diff options
Diffstat (limited to 'tests')
126 files changed, 50178 insertions, 0 deletions
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt new file mode 100644 index 000000000..64dde411c --- /dev/null +++ b/tests/CMakeLists.txt @@ -0,0 +1,64 @@ +add_subdirectory(gtest) +include_directories(${gtest_SOURCE_DIR}/include ${gtest_SOURCE_DIR}) + +file(GLOB_RECURSE CORE_TESTS core_tests/*) +file(GLOB_RECURSE CRYPTO_TESTS crypto/*) +file(GLOB_RECURSE FUNC_TESTS functional_tests/*) +file(GLOB_RECURSE PERFORMANCE_TESTS performance_tests/*) +file(GLOB_RECURSE CORE_PROXY core_proxy/*) +file(GLOB_RECURSE UNIT_TESTS unit_tests/*) + +source_group(core_tests FILES ${CORE_TESTS}) +source_group(crypto_tests FILES ${CRYPTO_TESTS}) +source_group(functional_tests FILES ${FUNC_TESTS}) +source_group(performance_tests FILES ${PERFORMANCE_TESTS}) +source_group(core_proxy FILES ${CORE_PROXY}) +source_group(unit_tests FILES ${UNIT_TESTS}) + +# add_subdirectory(daemon_tests) + +add_executable(coretests ${CORE_TESTS}) +add_executable(crypto-tests ${CRYPTO_TESTS}) +add_executable(difficulty-tests difficulty/difficulty.cpp) +add_executable(hash-tests hash/main.cpp) +add_executable(hash-target-tests hash-target.cpp) +add_executable(functional_tests ${FUNC_TESTS}) +add_executable(performance_tests ${PERFORMANCE_TESTS}) +add_executable(core_proxy ${CORE_PROXY}) +add_executable(unit_tests ${UNIT_TESTS}) +add_executable(net_load_tests_clt net_load_tests/clt.cpp) +add_executable(net_load_tests_srv net_load_tests/srv.cpp) + +target_link_libraries(core_proxy cryptonote_core common crypto ${Boost_LIBRARIES}) +target_link_libraries(coretests cryptonote_core common crypto ${Boost_LIBRARIES}) +target_link_libraries(difficulty-tests cryptonote_core) +target_link_libraries(functional_tests cryptonote_core wallet common crypto ${Boost_LIBRARIES}) +target_link_libraries(hash-tests crypto) +target_link_libraries(hash-target-tests crypto cryptonote_core) +target_link_libraries(performance_tests cryptonote_core common crypto ${Boost_LIBRARIES}) +target_link_libraries(unit_tests cryptonote_core common crypto gtest_main ${Boost_LIBRARIES}) +target_link_libraries(net_load_tests_clt cryptonote_core common crypto gtest_main ${Boost_LIBRARIES}) +target_link_libraries(net_load_tests_srv cryptonote_core common crypto gtest_main ${Boost_LIBRARIES}) + +if(NOT WIN32) + target_link_libraries(coretests rt) + target_link_libraries(functional_tests rt) + target_link_libraries(performance_tests rt) + target_link_libraries(core_proxy rt) + target_link_libraries(unit_tests rt) +endif() +if(NOT MSVC) + set_property(TARGET gtest gtest_main unit_tests net_load_tests_clt net_load_tests_srv APPEND_STRING PROPERTY COMPILE_FLAGS " -Wno-undef -Wno-sign-compare") +endif() + +add_custom_target(tests DEPENDS coretests difficulty hash performance_tests core_proxy unit_tests) +set_property(TARGET coretests crypto-tests functional_tests difficulty-tests gtest gtest_main hash-tests hash-target-tests performance_tests core_proxy unit_tests tests net_load_tests_clt net_load_tests_srv PROPERTY FOLDER "tests") + +add_test(coretests coretests --generate_and_play_test_data) +add_test(crypto crypto-tests ${CMAKE_CURRENT_SOURCE_DIR}/crypto/tests.txt) +add_test(difficulty difficulty-tests ${CMAKE_CURRENT_SOURCE_DIR}/difficulty/data.txt) +foreach(hash IN ITEMS fast slow tree)# extra-blake extra-groestl extra-jh extra-skein) +add_test(hash-${hash} hash-tests ${hash} ${CMAKE_CURRENT_SOURCE_DIR}/hash/tests-${hash}.txt) +endforeach(hash) +add_test(hash-target hash-target-tests) +add_test(unit_tests unit_tests)
\ No newline at end of file diff --git a/tests/core_proxy/core_proxy.cpp b/tests/core_proxy/core_proxy.cpp new file mode 100644 index 000000000..caf4bf837 --- /dev/null +++ b/tests/core_proxy/core_proxy.cpp @@ -0,0 +1,249 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +// node.cpp : Defines the entry point for the console application. +// + + +#include "include_base_utils.h" +#include "version.h" + +using namespace epee; + +#include <iostream> +#include <sstream> +using namespace std; + +#include <boost/program_options.hpp> + +#include "common/command_line.h" +#include "console_handler.h" +#include "p2p/net_node.h" +//#include "cryptonote_core/cryptonote_core.h" +#include "cryptonote_protocol/cryptonote_protocol_handler.h" +#include "core_proxy.h" +#include "version.h" + +#if defined(WIN32) +#include <crtdbg.h> +#endif + +namespace po = boost::program_options; +using namespace cryptonote; +using namespace crypto; + + +BOOST_CLASS_VERSION(nodetool::node_server<cryptonote::t_cryptonote_protocol_handler<tests::proxy_core> >, 1); + +int main(int argc, char* argv[]) +{ + +#ifdef WIN32 + _CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF ); +#endif + + TRY_ENTRY(); + + + string_tools::set_module_name_and_folder(argv[0]); + + //set up logging options + log_space::get_set_log_detalisation_level(true, LOG_LEVEL_2); + //log_space::log_singletone::add_logger(LOGGER_CONSOLE, NULL, NULL); + log_space::log_singletone::add_logger(LOGGER_FILE, + log_space::log_singletone::get_default_log_file().c_str(), + log_space::log_singletone::get_default_log_folder().c_str()); + + + po::options_description desc("Allowed options"); + // tools::get_default_data_dir() can't be called during static initialization + command_line::add_arg(desc, command_line::arg_data_dir, tools::get_default_data_dir()); + nodetool::node_server<cryptonote::t_cryptonote_protocol_handler<tests::proxy_core> >::init_options(desc); + + po::variables_map vm; + bool r = command_line::handle_error_helper(desc, [&]() + { + po::store(po::parse_command_line(argc, argv, desc), vm); + po::notify(vm); + return true; + }); + if (!r) + return 1; + + LOG_PRINT("Module folder: " << argv[0], LOG_LEVEL_0); + LOG_PRINT("Node starting ...", LOG_LEVEL_0); + + + //create objects and link them + tests::proxy_core pr_core; + cryptonote::t_cryptonote_protocol_handler<tests::proxy_core> cprotocol(pr_core, NULL); + nodetool::node_server<cryptonote::t_cryptonote_protocol_handler<tests::proxy_core> > p2psrv(cprotocol); + cprotocol.set_p2p_endpoint(&p2psrv); + //pr_core.set_cryptonote_protocol(&cprotocol); + //daemon_cmmands_handler dch(p2psrv); + + //initialize objects + + LOG_PRINT_L0("Initializing p2p server..."); + bool res = p2psrv.init(vm); + CHECK_AND_ASSERT_MES(res, 1, "Failed to initialize p2p server."); + LOG_PRINT_L0("P2p server initialized OK"); + + LOG_PRINT_L0("Initializing cryptonote protocol..."); + res = cprotocol.init(vm); + CHECK_AND_ASSERT_MES(res, 1, "Failed to initialize cryptonote protocol."); + LOG_PRINT_L0("Cryptonote protocol initialized OK"); + + //initialize core here + LOG_PRINT_L0("Initializing proxy core..."); + res = pr_core.init(vm); + CHECK_AND_ASSERT_MES(res, 1, "Failed to initialize core"); + LOG_PRINT_L0("Core initialized OK"); + + LOG_PRINT_L0("Starting p2p net loop..."); + p2psrv.run(); + LOG_PRINT_L0("p2p net loop stopped"); + + //deinitialize components + LOG_PRINT_L0("Deinitializing core..."); + pr_core.deinit(); + LOG_PRINT_L0("Deinitializing cryptonote_protocol..."); + cprotocol.deinit(); + LOG_PRINT_L0("Deinitializing p2p..."); + p2psrv.deinit(); + + + //pr_core.set_cryptonote_protocol(NULL); + cprotocol.set_p2p_endpoint(NULL); + + + LOG_PRINT("Node stopped.", LOG_LEVEL_0); + return 0; + + CATCH_ENTRY_L0("main", 1); +} + +/* +string tx2str(const cryptonote::transaction& tx, const cryptonote::hash256& tx_hash, const cryptonote::hash256& tx_prefix_hash, const cryptonote::blobdata& blob) { + stringstream ss; + + ss << "{" << endl; + ss << "\tversion:" << tx.version << endl; + ss << "\tunlock_time:" << tx.unlock_time << endl; + ss << "\t" + + return ss.str(); +}*/ + +bool tests::proxy_core::handle_incoming_tx(const cryptonote::blobdata& tx_blob, cryptonote::tx_verification_context& tvc, bool keeped_by_block) { + if (!keeped_by_block) + return true; + + crypto::hash tx_hash = null_hash; + crypto::hash tx_prefix_hash = null_hash; + transaction tx; + + if (!parse_and_validate_tx_from_blob(tx_blob, tx, tx_hash, tx_prefix_hash)) { + cerr << "WRONG TRANSACTION BLOB, Failed to parse, rejected" << endl; + return false; + } + + cout << "TX " << endl << endl; + cout << tx_hash << endl; + cout << tx_prefix_hash << endl; + cout << tx_blob.size() << endl; + //cout << string_tools::buff_to_hex_nodelimer(tx_blob) << endl << endl; + cout << obj_to_json_str(tx) << endl; + cout << endl << "ENDTX" << endl; + + return true; +} + +bool tests::proxy_core::handle_incoming_block(const cryptonote::blobdata& block_blob, cryptonote::block_verification_context& bvc, bool update_miner_blocktemplate) { + block b = AUTO_VAL_INIT(b); + + if(!parse_and_validate_block_from_blob(block_blob, b)) { + cerr << "Failed to parse and validate new block" << endl; + return false; + } + + crypto::hash h; + crypto::hash lh; + cout << "BLOCK" << endl << endl; + cout << (h = get_block_hash(b)) << endl; + cout << (lh = get_block_longhash(b, 0)) << endl; + cout << get_transaction_hash(b.miner_tx) << endl; + cout << ::get_object_blobsize(b.miner_tx) << endl; + //cout << string_tools::buff_to_hex_nodelimer(block_blob) << endl; + cout << obj_to_json_str(b) << endl; + + cout << endl << "ENDBLOCK" << endl << endl; + + if (!add_block(h, lh, b, block_blob)) + return false; + + return true; +} + +bool tests::proxy_core::get_short_chain_history(std::list<crypto::hash>& ids) { + build_short_history(ids, m_lastblk); + return true; +} + +bool tests::proxy_core::get_blockchain_top(uint64_t& height, crypto::hash& top_id) { + height = 0; + top_id = get_block_hash(m_genesis); + return true; +} + +bool tests::proxy_core::init(const boost::program_options::variables_map& /*vm*/) { + generate_genesis_block(m_genesis); + crypto::hash h = get_block_hash(m_genesis); + add_block(h, get_block_longhash(m_genesis, 0), m_genesis, block_to_blob(m_genesis)); + return true; +} + +bool tests::proxy_core::have_block(const crypto::hash& id) { + if (m_hash2blkidx.end() == m_hash2blkidx.find(id)) + return false; + return true; +} + +void tests::proxy_core::build_short_history(std::list<crypto::hash> &m_history, const crypto::hash &m_start) { + m_history.push_front(get_block_hash(m_genesis)); + /*std::unordered_map<crypto::hash, tests::block_index>::const_iterator cit = m_hash2blkidx.find(m_lastblk); + + do { + m_history.push_front(cit->first); + + size_t n = 1 << m_history.size(); + while (m_hash2blkidx.end() != cit && cryptonote::null_hash != cit->second.blk.prev_id && n > 0) { + n--; + cit = m_hash2blkidx.find(cit->second.blk.prev_id); + } + } while (m_hash2blkidx.end() != cit && get_block_hash(cit->second.blk) != cit->first);*/ +} + +bool tests::proxy_core::add_block(const crypto::hash &_id, const crypto::hash &_longhash, const cryptonote::block &_blk, const cryptonote::blobdata &_blob) { + size_t height = 0; + + if (cryptonote::null_hash != _blk.prev_id) { + std::unordered_map<crypto::hash, tests::block_index>::const_iterator cit = m_hash2blkidx.find(_blk.prev_id); + if (m_hash2blkidx.end() == cit) { + cerr << "ERROR: can't find previous block with id \"" << _blk.prev_id << "\"" << endl; + return false; + } + + height = cit->second.height + 1; + } + + m_known_block_list.push_back(_id); + + block_index bi(height, _id, _longhash, _blk, _blob, txes); + m_hash2blkidx.insert(std::make_pair(_id, bi)); + txes.clear(); + m_lastblk = _id; + + return true; +} diff --git a/tests/core_proxy/core_proxy.h b/tests/core_proxy/core_proxy.h new file mode 100644 index 000000000..d5be53f1d --- /dev/null +++ b/tests/core_proxy/core_proxy.h @@ -0,0 +1,58 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#pragma once + +#include <boost/program_options/variables_map.hpp> + +#include "cryptonote_core/cryptonote_basic_impl.h" +#include "cryptonote_core/verification_context.h" +#include <unordered_map> + +namespace tests +{ + struct block_index { + size_t height; + crypto::hash id; + crypto::hash longhash; + cryptonote::block blk; + cryptonote::blobdata blob; + std::list<cryptonote::transaction> txes; + + block_index() : height(0), id(cryptonote::null_hash), longhash(cryptonote::null_hash) { } + block_index(size_t _height, const crypto::hash &_id, const crypto::hash &_longhash, const cryptonote::block &_blk, const cryptonote::blobdata &_blob, const std::list<cryptonote::transaction> &_txes) + : height(_height), id(_id), longhash(_longhash), blk(_blk), blob(_blob), txes(_txes) { } + }; + + class proxy_core + { + cryptonote::block m_genesis; + std::list<crypto::hash> m_known_block_list; + std::unordered_map<crypto::hash, block_index> m_hash2blkidx; + + crypto::hash m_lastblk; + std::list<cryptonote::transaction> txes; + + bool add_block(const crypto::hash &_id, const crypto::hash &_longhash, const cryptonote::block &_blk, const cryptonote::blobdata &_blob); + void build_short_history(std::list<crypto::hash> &m_history, const crypto::hash &m_start); + + + public: + void on_synchronized(){} + uint64_t get_current_blockchain_height(){return 1;} + bool init(const boost::program_options::variables_map& vm); + bool deinit(){return true;} + bool get_short_chain_history(std::list<crypto::hash>& ids); + bool get_stat_info(cryptonote::core_stat_info& st_inf){return true;} + bool have_block(const crypto::hash& id); + bool get_blockchain_top(uint64_t& height, crypto::hash& top_id); + bool handle_incoming_tx(const cryptonote::blobdata& tx_blob, cryptonote::tx_verification_context& tvc, bool keeped_by_block); + bool handle_incoming_block(const cryptonote::blobdata& block_blob, cryptonote::block_verification_context& bvc, bool update_miner_blocktemplate = true); + void pause_mine(){} + void resume_mine(){} + bool on_idle(){return true;} + bool find_blockchain_supplement(const std::list<crypto::hash>& qblock_ids, cryptonote::NOTIFY_RESPONSE_CHAIN_ENTRY::request& resp){return true;} + bool handle_get_objects(cryptonote::NOTIFY_REQUEST_GET_OBJECTS::request& arg, cryptonote::NOTIFY_RESPONSE_GET_OBJECTS::request& rsp, cryptonote::cryptonote_connection_context& context){return true;} + }; +} diff --git a/tests/core_tests/block_reward.cpp b/tests/core_tests/block_reward.cpp new file mode 100644 index 000000000..14d181d75 --- /dev/null +++ b/tests/core_tests/block_reward.cpp @@ -0,0 +1,250 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include "chaingen.h" +#include "chaingen_tests_list.h" + +#include "block_reward.h" + +using namespace epee; +using namespace cryptonote; + +namespace +{ + bool construct_miner_tx_by_size(transaction& miner_tx, uint64_t height, uint64_t already_generated_coins, + const account_public_address& miner_address, std::vector<size_t>& block_sizes, size_t target_tx_size, + size_t target_block_size, uint64_t fee = 0) + { + if (!construct_miner_tx(height, already_generated_coins, miner_address, miner_tx, fee, block_sizes, target_block_size)) + return false; + + size_t current_size = get_object_blobsize(miner_tx); + size_t try_count = 0; + while (target_tx_size != current_size) + { + ++try_count; + if (10 < try_count) + return false; + + if (target_tx_size < current_size) + { + size_t diff = current_size - target_tx_size; + if (diff <= miner_tx.extra.size()) + miner_tx.extra.resize(miner_tx.extra.size() - diff); + else + return false; + } + else + { + size_t diff = target_tx_size - current_size; + miner_tx.extra.resize(miner_tx.extra.size() + diff); + } + + current_size = get_object_blobsize(miner_tx); + } + + return true; + } + + bool construct_max_size_block(test_generator& generator, block& blk, const block& blk_prev, const account_base& miner_account, + size_t median_block_count = CRYPTONOTE_REWARD_BLOCKS_WINDOW) + { + std::vector<size_t> block_sizes; + generator.get_last_n_block_sizes(block_sizes, get_block_hash(blk_prev), median_block_count); + + size_t median = misc_utils::median(block_sizes); + median = std::max(median, static_cast<size_t>(CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE)); + + transaction miner_tx; + bool r = construct_miner_tx_by_size(miner_tx, get_block_height(blk_prev) + 1, generator.get_already_generated_coins(blk_prev), + miner_account.get_keys().m_account_address, block_sizes, 2 * median, 2 * median); + if (!r) + return false; + + return generator.construct_block_manually(blk, blk_prev, miner_account, test_generator::bf_miner_tx, 0, 0, 0, + crypto::hash(), 0, miner_tx); + } + + bool rewind_blocks(std::vector<test_event_entry>& events, test_generator& generator, block& blk, const block& blk_prev, + const account_base& miner_account, size_t block_count) + { + blk = blk_prev; + for (size_t i = 0; i < block_count; ++i) + { + block blk_i; + if (!construct_max_size_block(generator, blk_i, blk, miner_account)) + return false; + + events.push_back(blk_i); + blk = blk_i; + } + + return true; + } + + uint64_t get_tx_out_amount(const transaction& tx) + { + uint64_t amount = 0; + BOOST_FOREACH(auto& o, tx.vout) + amount += o.amount; + return amount; + } +} + +gen_block_reward::gen_block_reward() + : m_invalid_block_index(0) +{ + REGISTER_CALLBACK_METHOD(gen_block_reward, mark_invalid_block); + REGISTER_CALLBACK_METHOD(gen_block_reward, mark_checked_block); + REGISTER_CALLBACK_METHOD(gen_block_reward, check_block_rewards); +} + +bool gen_block_reward::generate(std::vector<test_event_entry>& events) const +{ + uint64_t ts_start = 1338224400; + + GENERATE_ACCOUNT(miner_account); + MAKE_GENESIS_BLOCK(events, blk_0, miner_account, ts_start); + DO_CALLBACK(events, "mark_checked_block"); + MAKE_ACCOUNT(events, bob_account); + + // Test: miner transactions without outputs (block reward == 0) + block blk_0r; + if (!rewind_blocks(events, generator, blk_0r, blk_0, miner_account, CRYPTONOTE_REWARD_BLOCKS_WINDOW)) + return false; + + // Test: block reward is calculated using median of the latest CRYPTONOTE_REWARD_BLOCKS_WINDOW blocks + DO_CALLBACK(events, "mark_invalid_block"); + block blk_1_bad_1; + if (!construct_max_size_block(generator, blk_1_bad_1, blk_0r, miner_account, CRYPTONOTE_REWARD_BLOCKS_WINDOW + 1)) + return false; + events.push_back(blk_1_bad_1); + + DO_CALLBACK(events, "mark_invalid_block"); + block blk_1_bad_2; + if (!construct_max_size_block(generator, blk_1_bad_2, blk_0r, miner_account, CRYPTONOTE_REWARD_BLOCKS_WINDOW - 1)) + return false; + events.push_back(blk_1_bad_2); + + block blk_1; + if (!construct_max_size_block(generator, blk_1, blk_0r, miner_account)) + return false; + events.push_back(blk_1); + + ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// + + MAKE_NEXT_BLOCK(events, blk_2, blk_1, miner_account); + DO_CALLBACK(events, "mark_checked_block"); + MAKE_NEXT_BLOCK(events, blk_3, blk_2, miner_account); + DO_CALLBACK(events, "mark_checked_block"); + MAKE_NEXT_BLOCK(events, blk_4, blk_3, miner_account); + DO_CALLBACK(events, "mark_checked_block"); + MAKE_NEXT_BLOCK(events, blk_5, blk_4, miner_account); + DO_CALLBACK(events, "mark_checked_block"); + + block blk_5r; + if (!rewind_blocks(events, generator, blk_5r, blk_5, miner_account, CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW)) + return false; + + // Test: fee increases block reward + transaction tx_0(construct_tx_with_fee(events, blk_5, miner_account, bob_account, MK_COINS(1), 3 * TESTS_DEFAULT_FEE)); + MAKE_NEXT_BLOCK_TX1(events, blk_6, blk_5r, miner_account, tx_0); + DO_CALLBACK(events, "mark_checked_block"); + + // Test: fee from all block transactions increase block reward + std::list<transaction> txs_0; + txs_0.push_back(construct_tx_with_fee(events, blk_5, miner_account, bob_account, MK_COINS(1), 5 * TESTS_DEFAULT_FEE)); + txs_0.push_back(construct_tx_with_fee(events, blk_5, miner_account, bob_account, MK_COINS(1), 7 * TESTS_DEFAULT_FEE)); + MAKE_NEXT_BLOCK_TX_LIST(events, blk_7, blk_6, miner_account, txs_0); + DO_CALLBACK(events, "mark_checked_block"); + + // Test: block reward == transactions fee + { + transaction tx_1 = construct_tx_with_fee(events, blk_5, miner_account, bob_account, MK_COINS(1), 11 * TESTS_DEFAULT_FEE); + transaction tx_2 = construct_tx_with_fee(events, blk_5, miner_account, bob_account, MK_COINS(1), 13 * TESTS_DEFAULT_FEE); + size_t txs_1_size = get_object_blobsize(tx_1) + get_object_blobsize(tx_2); + uint64_t txs_fee = get_tx_fee(tx_1) + get_tx_fee(tx_2); + + std::vector<size_t> block_sizes; + generator.get_last_n_block_sizes(block_sizes, get_block_hash(blk_7), CRYPTONOTE_REWARD_BLOCKS_WINDOW); + size_t median = misc_utils::median(block_sizes); + + transaction miner_tx; + bool r = construct_miner_tx_by_size(miner_tx, get_block_height(blk_7) + 1, generator.get_already_generated_coins(blk_7), + miner_account.get_keys().m_account_address, block_sizes, 2 * median - txs_1_size, 2 * median, txs_fee); + if (!r) + return false; + + std::vector<crypto::hash> txs_1_hashes; + txs_1_hashes.push_back(get_transaction_hash(tx_1)); + txs_1_hashes.push_back(get_transaction_hash(tx_2)); + + block blk_8; + generator.construct_block_manually(blk_8, blk_7, miner_account, test_generator::bf_miner_tx | test_generator::bf_tx_hashes, + 0, 0, 0, crypto::hash(), 0, miner_tx, txs_1_hashes, txs_1_size); + + events.push_back(blk_8); + DO_CALLBACK(events, "mark_checked_block"); + } + + DO_CALLBACK(events, "check_block_rewards"); + + return true; +} + +bool gen_block_reward::check_block_verification_context(const cryptonote::block_verification_context& bvc, size_t event_idx, const cryptonote::block& /*blk*/) +{ + if (m_invalid_block_index == event_idx) + { + m_invalid_block_index = 0; + return bvc.m_verifivation_failed; + } + else + { + return !bvc.m_verifivation_failed; + } +} + +bool gen_block_reward::mark_invalid_block(cryptonote::core& /*c*/, size_t ev_index, const std::vector<test_event_entry>& /*events*/) +{ + m_invalid_block_index = ev_index + 1; + return true; +} + +bool gen_block_reward::mark_checked_block(cryptonote::core& /*c*/, size_t ev_index, const std::vector<test_event_entry>& /*events*/) +{ + m_checked_blocks_indices.push_back(ev_index - 1); + return true; +} + +bool gen_block_reward::check_block_rewards(cryptonote::core& /*c*/, size_t /*ev_index*/, const std::vector<test_event_entry>& events) +{ + DEFINE_TESTS_ERROR_CONTEXT("gen_block_reward_without_txs::check_block_rewards"); + + std::array<uint64_t, 7> blk_rewards; + blk_rewards[0] = MONEY_SUPPLY >> 18; + uint64_t cumulative_reward = blk_rewards[0]; + for (size_t i = 1; i < blk_rewards.size(); ++i) + { + blk_rewards[i] = (MONEY_SUPPLY - cumulative_reward) >> 18; + cumulative_reward += blk_rewards[i]; + } + + for (size_t i = 0; i < 5; ++i) + { + block blk_i = boost::get<block>(events[m_checked_blocks_indices[i]]); + CHECK_EQ(blk_rewards[i], get_tx_out_amount(blk_i.miner_tx)); + } + + block blk_n1 = boost::get<block>(events[m_checked_blocks_indices[5]]); + CHECK_EQ(blk_rewards[5] + 3 * TESTS_DEFAULT_FEE, get_tx_out_amount(blk_n1.miner_tx)); + + block blk_n2 = boost::get<block>(events[m_checked_blocks_indices[6]]); + CHECK_EQ(blk_rewards[6] + (5 + 7) * TESTS_DEFAULT_FEE, get_tx_out_amount(blk_n2.miner_tx)); + + block blk_n3 = boost::get<block>(events[m_checked_blocks_indices[7]]); + CHECK_EQ((11 + 13) * TESTS_DEFAULT_FEE, get_tx_out_amount(blk_n3.miner_tx)); + + return true; +} diff --git a/tests/core_tests/block_reward.h b/tests/core_tests/block_reward.h new file mode 100644 index 000000000..506d7466c --- /dev/null +++ b/tests/core_tests/block_reward.h @@ -0,0 +1,23 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#pragma once +#include "chaingen.h" + +struct gen_block_reward : public test_chain_unit_base +{ + gen_block_reward(); + + bool generate(std::vector<test_event_entry>& events) const; + + bool check_block_verification_context(const cryptonote::block_verification_context& bvc, size_t event_idx, const cryptonote::block& blk); + + bool mark_invalid_block(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events); + bool mark_checked_block(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events); + bool check_block_rewards(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events); + +private: + size_t m_invalid_block_index; + std::vector<size_t> m_checked_blocks_indices; +}; diff --git a/tests/core_tests/block_validation.cpp b/tests/core_tests/block_validation.cpp new file mode 100644 index 000000000..36e769c65 --- /dev/null +++ b/tests/core_tests/block_validation.cpp @@ -0,0 +1,613 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include "chaingen.h" +#include "chaingen_tests_list.h" + +using namespace epee; +using namespace cryptonote; + +namespace +{ + bool lift_up_difficulty(std::vector<test_event_entry>& events, std::vector<uint64_t>& timestamps, + std::vector<difficulty_type>& cummulative_difficulties, test_generator& generator, + size_t new_block_count, const block blk_last, const account_base& miner_account) + { + difficulty_type commulative_diffic = cummulative_difficulties.empty() ? 0 : cummulative_difficulties.back(); + block blk_prev = blk_last; + for (size_t i = 0; i < new_block_count; ++i) + { + block blk_next; + difficulty_type diffic = next_difficulty(timestamps, cummulative_difficulties); + if (!generator.construct_block_manually(blk_next, blk_prev, miner_account, + test_generator::bf_timestamp | test_generator::bf_diffic, 0, 0, blk_prev.timestamp, crypto::hash(), diffic)) + return false; + + commulative_diffic += diffic; + if (timestamps.size() == DIFFICULTY_WINDOW) + { + timestamps.erase(timestamps.begin()); + cummulative_difficulties.erase(cummulative_difficulties.begin()); + } + timestamps.push_back(blk_next.timestamp); + cummulative_difficulties.push_back(commulative_diffic); + + events.push_back(blk_next); + blk_prev = blk_next; + } + + return true; + } +} + +#define BLOCK_VALIDATION_INIT_GENERATE() \ + GENERATE_ACCOUNT(miner_account); \ + MAKE_GENESIS_BLOCK(events, blk_0, miner_account, 1338224400); + +//---------------------------------------------------------------------------------------------------------------------- +// Tests + +bool gen_block_big_major_version::generate(std::vector<test_event_entry>& events) const +{ + BLOCK_VALIDATION_INIT_GENERATE(); + + block blk_1; + generator.construct_block_manually(blk_1, blk_0, miner_account, test_generator::bf_major_ver, CURRENT_BLOCK_MAJOR_VERSION + 1); + events.push_back(blk_1); + + DO_CALLBACK(events, "check_block_purged"); + + return true; +} + +bool gen_block_big_minor_version::generate(std::vector<test_event_entry>& events) const +{ + BLOCK_VALIDATION_INIT_GENERATE(); + + block blk_1; + generator.construct_block_manually(blk_1, blk_0, miner_account, test_generator::bf_minor_ver, 0, CURRENT_BLOCK_MINOR_VERSION + 1); + events.push_back(blk_1); + + DO_CALLBACK(events, "check_block_accepted"); + + return true; +} + +bool gen_block_ts_not_checked::generate(std::vector<test_event_entry>& events) const +{ + BLOCK_VALIDATION_INIT_GENERATE(); + REWIND_BLOCKS_N(events, blk_0r, blk_0, miner_account, BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW - 2); + + block blk_1; + generator.construct_block_manually(blk_1, blk_0r, miner_account, test_generator::bf_timestamp, 0, 0, blk_0.timestamp - 60 * 60); + events.push_back(blk_1); + + DO_CALLBACK(events, "check_block_accepted"); + + return true; +} + +bool gen_block_ts_in_past::generate(std::vector<test_event_entry>& events) const +{ + BLOCK_VALIDATION_INIT_GENERATE(); + REWIND_BLOCKS_N(events, blk_0r, blk_0, miner_account, BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW - 1); + + uint64_t ts_below_median = boost::get<block>(events[BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW / 2 - 1]).timestamp; + block blk_1; + generator.construct_block_manually(blk_1, blk_0r, miner_account, test_generator::bf_timestamp, 0, 0, ts_below_median); + events.push_back(blk_1); + + DO_CALLBACK(events, "check_block_purged"); + + return true; +} + +bool gen_block_ts_in_future::generate(std::vector<test_event_entry>& events) const +{ + BLOCK_VALIDATION_INIT_GENERATE(); + + block blk_1; + generator.construct_block_manually(blk_1, blk_0, miner_account, test_generator::bf_timestamp, 0, 0, time(NULL) + 60*60 + CRYPTONOTE_BLOCK_FUTURE_TIME_LIMIT); + events.push_back(blk_1); + + DO_CALLBACK(events, "check_block_purged"); + + return true; +} + +bool gen_block_invalid_prev_id::generate(std::vector<test_event_entry>& events) const +{ + BLOCK_VALIDATION_INIT_GENERATE(); + + block blk_1; + crypto::hash prev_id = get_block_hash(blk_0); + reinterpret_cast<char &>(prev_id) ^= 1; + generator.construct_block_manually(blk_1, blk_0, miner_account, test_generator::bf_prev_id, 0, 0, 0, prev_id); + events.push_back(blk_1); + + DO_CALLBACK(events, "check_block_purged"); + + return true; +} + +bool gen_block_invalid_prev_id::check_block_verification_context(const cryptonote::block_verification_context& bvc, size_t event_idx, const cryptonote::block& /*blk*/) +{ + if (1 == event_idx) + return bvc.m_marked_as_orphaned && !bvc.m_added_to_main_chain && !bvc.m_verifivation_failed; + else + return !bvc.m_marked_as_orphaned && bvc.m_added_to_main_chain && !bvc.m_verifivation_failed; +} + +bool gen_block_invalid_nonce::generate(std::vector<test_event_entry>& events) const +{ + BLOCK_VALIDATION_INIT_GENERATE(); + + std::vector<uint64_t> timestamps; + std::vector<difficulty_type> commulative_difficulties; + if (!lift_up_difficulty(events, timestamps, commulative_difficulties, generator, 2, blk_0, miner_account)) + return false; + + // Create invalid nonce + difficulty_type diffic = next_difficulty(timestamps, commulative_difficulties); + assert(1 < diffic); + const block& blk_last = boost::get<block>(events.back()); + uint64_t timestamp = blk_last.timestamp; + block blk_3; + do + { + ++timestamp; + blk_3.miner_tx.set_null(); + if (!generator.construct_block_manually(blk_3, blk_last, miner_account, + test_generator::bf_diffic | test_generator::bf_timestamp, 0, 0, timestamp, crypto::hash(), diffic)) + return false; + } + while (0 == blk_3.nonce); + --blk_3.nonce; + events.push_back(blk_3); + + return true; +} + +bool gen_block_no_miner_tx::generate(std::vector<test_event_entry>& events) const +{ + BLOCK_VALIDATION_INIT_GENERATE(); + + transaction miner_tx; + miner_tx.set_null(); + + block blk_1; + generator.construct_block_manually(blk_1, blk_0, miner_account, test_generator::bf_miner_tx, 0, 0, 0, crypto::hash(), 0, miner_tx); + events.push_back(blk_1); + + DO_CALLBACK(events, "check_block_purged"); + + return true; +} + +bool gen_block_unlock_time_is_low::generate(std::vector<test_event_entry>& events) const +{ + BLOCK_VALIDATION_INIT_GENERATE(); + + MAKE_MINER_TX_MANUALLY(miner_tx, blk_0); + --miner_tx.unlock_time; + + block blk_1; + generator.construct_block_manually(blk_1, blk_0, miner_account, test_generator::bf_miner_tx, 0, 0, 0, crypto::hash(), 0, miner_tx); + events.push_back(blk_1); + + DO_CALLBACK(events, "check_block_purged"); + + return true; +} + +bool gen_block_unlock_time_is_high::generate(std::vector<test_event_entry>& events) const +{ + BLOCK_VALIDATION_INIT_GENERATE(); + + MAKE_MINER_TX_MANUALLY(miner_tx, blk_0); + ++miner_tx.unlock_time; + + block blk_1; + generator.construct_block_manually(blk_1, blk_0, miner_account, test_generator::bf_miner_tx, 0, 0, 0, crypto::hash(), 0, miner_tx); + events.push_back(blk_1); + + DO_CALLBACK(events, "check_block_purged"); + + return true; +} + +bool gen_block_unlock_time_is_timestamp_in_past::generate(std::vector<test_event_entry>& events) const +{ + BLOCK_VALIDATION_INIT_GENERATE(); + + MAKE_MINER_TX_MANUALLY(miner_tx, blk_0); + miner_tx.unlock_time = blk_0.timestamp - 10 * 60; + + block blk_1; + generator.construct_block_manually(blk_1, blk_0, miner_account, test_generator::bf_miner_tx, 0, 0, 0, crypto::hash(), 0, miner_tx); + events.push_back(blk_1); + + DO_CALLBACK(events, "check_block_purged"); + + return true; +} + +bool gen_block_unlock_time_is_timestamp_in_future::generate(std::vector<test_event_entry>& events) const +{ + BLOCK_VALIDATION_INIT_GENERATE(); + + MAKE_MINER_TX_MANUALLY(miner_tx, blk_0); + miner_tx.unlock_time = blk_0.timestamp + 3 * CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW * DIFFICULTY_BLOCKS_ESTIMATE_TIMESPAN; + + block blk_1; + generator.construct_block_manually(blk_1, blk_0, miner_account, test_generator::bf_miner_tx, 0, 0, 0, crypto::hash(), 0, miner_tx); + events.push_back(blk_1); + + DO_CALLBACK(events, "check_block_purged"); + + return true; +} + +bool gen_block_height_is_low::generate(std::vector<test_event_entry>& events) const +{ + BLOCK_VALIDATION_INIT_GENERATE(); + + MAKE_MINER_TX_MANUALLY(miner_tx, blk_0); + boost::get<txin_gen>(miner_tx.vin[0]).height--; + + block blk_1; + generator.construct_block_manually(blk_1, blk_0, miner_account, test_generator::bf_miner_tx, 0, 0, 0, crypto::hash(), 0, miner_tx); + events.push_back(blk_1); + + DO_CALLBACK(events, "check_block_purged"); + + return true; +} + +bool gen_block_height_is_high::generate(std::vector<test_event_entry>& events) const +{ + BLOCK_VALIDATION_INIT_GENERATE(); + + MAKE_MINER_TX_MANUALLY(miner_tx, blk_0); + boost::get<txin_gen>(miner_tx.vin[0]).height++; + + block blk_1; + generator.construct_block_manually(blk_1, blk_0, miner_account, test_generator::bf_miner_tx, 0, 0, 0, crypto::hash(), 0, miner_tx); + events.push_back(blk_1); + + DO_CALLBACK(events, "check_block_purged"); + + return true; +} + +bool gen_block_miner_tx_has_2_tx_gen_in::generate(std::vector<test_event_entry>& events) const +{ + BLOCK_VALIDATION_INIT_GENERATE(); + + MAKE_MINER_TX_MANUALLY(miner_tx, blk_0); + + txin_gen in; + in.height = get_block_height(blk_0) + 1; + miner_tx.vin.push_back(in); + + block blk_1; + generator.construct_block_manually(blk_1, blk_0, miner_account, test_generator::bf_miner_tx, 0, 0, 0, crypto::hash(), 0, miner_tx); + events.push_back(blk_1); + + DO_CALLBACK(events, "check_block_purged"); + + return true; +} + +bool gen_block_miner_tx_has_2_in::generate(std::vector<test_event_entry>& events) const +{ + BLOCK_VALIDATION_INIT_GENERATE(); + REWIND_BLOCKS(events, blk_0r, blk_0, miner_account); + + GENERATE_ACCOUNT(alice); + + tx_source_entry se; + se.amount = blk_0.miner_tx.vout[0].amount; + se.outputs.push_back(std::make_pair(0, boost::get<txout_to_key>(blk_0.miner_tx.vout[0].target).key)); + se.real_output = 0; + se.real_out_tx_key = get_tx_pub_key_from_extra(blk_0.miner_tx); + se.real_output_in_tx_index = 0; + std::vector<tx_source_entry> sources; + sources.push_back(se); + + tx_destination_entry de; + de.addr = miner_account.get_keys().m_account_address; + de.amount = se.amount; + std::vector<tx_destination_entry> destinations; + destinations.push_back(de); + + transaction tmp_tx; + if (!construct_tx(miner_account.get_keys(), sources, destinations, tmp_tx, 0)) + return false; + + MAKE_MINER_TX_MANUALLY(miner_tx, blk_0); + miner_tx.vin.push_back(tmp_tx.vin[0]); + + block blk_1; + generator.construct_block_manually(blk_1, blk_0r, miner_account, test_generator::bf_miner_tx, 0, 0, 0, crypto::hash(), 0, miner_tx); + events.push_back(blk_1); + + DO_CALLBACK(events, "check_block_purged"); + + return true; +} + +bool gen_block_miner_tx_with_txin_to_key::generate(std::vector<test_event_entry>& events) const +{ + BLOCK_VALIDATION_INIT_GENERATE(); + + // This block has only one output + block blk_1; + generator.construct_block_manually(blk_1, blk_0, miner_account, test_generator::bf_none); + events.push_back(blk_1); + + REWIND_BLOCKS(events, blk_1r, blk_1, miner_account); + + tx_source_entry se; + se.amount = blk_1.miner_tx.vout[0].amount; + se.outputs.push_back(std::make_pair(0, boost::get<txout_to_key>(blk_1.miner_tx.vout[0].target).key)); + se.real_output = 0; + se.real_out_tx_key = get_tx_pub_key_from_extra(blk_1.miner_tx); + se.real_output_in_tx_index = 0; + std::vector<tx_source_entry> sources; + sources.push_back(se); + + tx_destination_entry de; + de.addr = miner_account.get_keys().m_account_address; + de.amount = se.amount; + std::vector<tx_destination_entry> destinations; + destinations.push_back(de); + + transaction tmp_tx; + if (!construct_tx(miner_account.get_keys(), sources, destinations, tmp_tx, 0)) + return false; + + MAKE_MINER_TX_MANUALLY(miner_tx, blk_1); + miner_tx.vin[0] = tmp_tx.vin[0]; + + block blk_2; + generator.construct_block_manually(blk_2, blk_1r, miner_account, test_generator::bf_miner_tx, 0, 0, 0, crypto::hash(), 0, miner_tx); + events.push_back(blk_2); + + DO_CALLBACK(events, "check_block_purged"); + + return true; +} + +bool gen_block_miner_tx_out_is_small::generate(std::vector<test_event_entry>& events) const +{ + BLOCK_VALIDATION_INIT_GENERATE(); + + MAKE_MINER_TX_MANUALLY(miner_tx, blk_0); + miner_tx.vout[0].amount /= 2; + + block blk_1; + generator.construct_block_manually(blk_1, blk_0, miner_account, test_generator::bf_miner_tx, 0, 0, 0, crypto::hash(), 0, miner_tx); + events.push_back(blk_1); + + DO_CALLBACK(events, "check_block_purged"); + + return true; +} + +bool gen_block_miner_tx_out_is_big::generate(std::vector<test_event_entry>& events) const +{ + BLOCK_VALIDATION_INIT_GENERATE(); + + MAKE_MINER_TX_MANUALLY(miner_tx, blk_0); + miner_tx.vout[0].amount *= 2; + + block blk_1; + generator.construct_block_manually(blk_1, blk_0, miner_account, test_generator::bf_miner_tx, 0, 0, 0, crypto::hash(), 0, miner_tx); + events.push_back(blk_1); + + DO_CALLBACK(events, "check_block_purged"); + + return true; +} + +bool gen_block_miner_tx_has_no_out::generate(std::vector<test_event_entry>& events) const +{ + BLOCK_VALIDATION_INIT_GENERATE(); + + MAKE_MINER_TX_MANUALLY(miner_tx, blk_0); + miner_tx.vout.clear(); + + block blk_1; + generator.construct_block_manually(blk_1, blk_0, miner_account, test_generator::bf_miner_tx, 0, 0, 0, crypto::hash(), 0, miner_tx); + events.push_back(blk_1); + + DO_CALLBACK(events, "check_block_purged"); + + return true; +} + +bool gen_block_miner_tx_has_out_to_alice::generate(std::vector<test_event_entry>& events) const +{ + BLOCK_VALIDATION_INIT_GENERATE(); + + GENERATE_ACCOUNT(alice); + + keypair txkey; + MAKE_MINER_TX_AND_KEY_MANUALLY(miner_tx, blk_0, &txkey); + + crypto::key_derivation derivation; + crypto::public_key out_eph_public_key; + crypto::generate_key_derivation(alice.get_keys().m_account_address.m_view_public_key, txkey.sec, derivation); + crypto::derive_public_key(derivation, 1, alice.get_keys().m_account_address.m_spend_public_key, out_eph_public_key); + + tx_out out_to_alice; + out_to_alice.amount = miner_tx.vout[0].amount / 2; + miner_tx.vout[0].amount -= out_to_alice.amount; + out_to_alice.target = txout_to_key(out_eph_public_key); + miner_tx.vout.push_back(out_to_alice); + + block blk_1; + generator.construct_block_manually(blk_1, blk_0, miner_account, test_generator::bf_miner_tx, 0, 0, 0, crypto::hash(), 0, miner_tx); + events.push_back(blk_1); + + DO_CALLBACK(events, "check_block_accepted"); + + return true; +} + +bool gen_block_has_invalid_tx::generate(std::vector<test_event_entry>& events) const +{ + BLOCK_VALIDATION_INIT_GENERATE(); + + std::vector<crypto::hash> tx_hashes; + tx_hashes.push_back(crypto::hash()); + + block blk_1; + generator.construct_block_manually_tx(blk_1, blk_0, miner_account, tx_hashes, 0); + events.push_back(blk_1); + + DO_CALLBACK(events, "check_block_purged"); + + return true; +} + +bool gen_block_is_too_big::generate(std::vector<test_event_entry>& events) const +{ + BLOCK_VALIDATION_INIT_GENERATE(); + + // Creating a huge miner_tx, it will have a lot of outs + MAKE_MINER_TX_MANUALLY(miner_tx, blk_0); + static const size_t tx_out_count = CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE / 2; + uint64_t amount = get_outs_money_amount(miner_tx); + uint64_t portion = amount / tx_out_count; + uint64_t remainder = amount % tx_out_count; + txout_target_v target = miner_tx.vout[0].target; + miner_tx.vout.clear(); + for (size_t i = 0; i < tx_out_count; ++i) + { + tx_out o; + o.amount = portion; + o.target = target; + miner_tx.vout.push_back(o); + } + if (0 < remainder) + { + tx_out o; + o.amount = remainder; + o.target = target; + miner_tx.vout.push_back(o); + } + + // Block reward will be incorrect, as it must be reduced if cumulative block size is very big, + // but in this test it doesn't matter + block blk_1; + if (!generator.construct_block_manually(blk_1, blk_0, miner_account, test_generator::bf_miner_tx, 0, 0, 0, crypto::hash(), 0, miner_tx)) + return false; + + events.push_back(blk_1); + + DO_CALLBACK(events, "check_block_purged"); + + return true; +} + +gen_block_invalid_binary_format::gen_block_invalid_binary_format() + : m_corrupt_blocks_begin_idx(0) +{ + REGISTER_CALLBACK("check_all_blocks_purged", gen_block_invalid_binary_format::check_all_blocks_purged); + REGISTER_CALLBACK("corrupt_blocks_boundary", gen_block_invalid_binary_format::corrupt_blocks_boundary); +} + +bool gen_block_invalid_binary_format::generate(std::vector<test_event_entry>& events) const +{ + BLOCK_VALIDATION_INIT_GENERATE(); + + std::vector<uint64_t> timestamps; + std::vector<difficulty_type> cummulative_difficulties; + difficulty_type cummulative_diff = 1; + + // Unlock blk_0 outputs + block blk_last = blk_0; + assert(CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW < DIFFICULTY_WINDOW); + for (size_t i = 0; i < CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW; ++i) + { + MAKE_NEXT_BLOCK(events, blk_curr, blk_last, miner_account); + timestamps.push_back(blk_curr.timestamp); + cummulative_difficulties.push_back(++cummulative_diff); + blk_last = blk_curr; + } + + // Lifting up takes a while + difficulty_type diffic; + do + { + blk_last = boost::get<block>(events.back()); + diffic = next_difficulty(timestamps, cummulative_difficulties); + if (!lift_up_difficulty(events, timestamps, cummulative_difficulties, generator, 1, blk_last, miner_account)) + return false; + std::cout << "Block #" << events.size() << ", difficulty: " << diffic << std::endl; + } + while (diffic < 1500); + + blk_last = boost::get<block>(events.back()); + MAKE_TX(events, tx_0, miner_account, miner_account, MK_COINS(120), boost::get<block>(events[1])); + DO_CALLBACK(events, "corrupt_blocks_boundary"); + + block blk_test; + std::vector<crypto::hash> tx_hashes; + tx_hashes.push_back(get_transaction_hash(tx_0)); + size_t txs_size = get_object_blobsize(tx_0); + diffic = next_difficulty(timestamps, cummulative_difficulties); + if (!generator.construct_block_manually(blk_test, blk_last, miner_account, + test_generator::bf_diffic | test_generator::bf_timestamp | test_generator::bf_tx_hashes, 0, 0, blk_last.timestamp, + crypto::hash(), diffic, transaction(), tx_hashes, txs_size)) + return false; + + blobdata blob = t_serializable_object_to_blob(blk_test); + for (size_t i = 0; i < blob.size(); ++i) + { + for (size_t bit_idx = 0; bit_idx < sizeof(blobdata::value_type) * 8; ++bit_idx) + { + serialized_block sr_block(blob); + blobdata::value_type& ch = sr_block.data[i]; + ch ^= 1 << bit_idx; + + events.push_back(sr_block); + } + } + + DO_CALLBACK(events, "check_all_blocks_purged"); + + return true; +} + +bool gen_block_invalid_binary_format::check_block_verification_context(const cryptonote::block_verification_context& bvc, + size_t event_idx, const cryptonote::block& blk) +{ + if (0 == m_corrupt_blocks_begin_idx || event_idx < m_corrupt_blocks_begin_idx) + { + return bvc.m_added_to_main_chain; + } + else + { + return !bvc.m_added_to_main_chain && (bvc.m_already_exists || bvc.m_marked_as_orphaned || bvc.m_verifivation_failed); + } +} + +bool gen_block_invalid_binary_format::corrupt_blocks_boundary(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events) +{ + m_corrupt_blocks_begin_idx = ev_index + 1; + return true; +} + +bool gen_block_invalid_binary_format::check_all_blocks_purged(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events) +{ + DEFINE_TESTS_ERROR_CONTEXT("gen_block_invalid_binary_format::check_all_blocks_purged"); + + CHECK_EQ(1, c.get_pool_transactions_count()); + CHECK_EQ(m_corrupt_blocks_begin_idx - 2, c.get_current_blockchain_height()); + + return true; +} diff --git a/tests/core_tests/block_validation.h b/tests/core_tests/block_validation.h new file mode 100644 index 000000000..fe5b859a7 --- /dev/null +++ b/tests/core_tests/block_validation.h @@ -0,0 +1,182 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#pragma once +#include "chaingen.h" + +template<size_t invalid_block_idx = 0> +class gen_block_verification_base : public test_chain_unit_base +{ +public: + gen_block_verification_base() + { + REGISTER_CALLBACK("check_block_purged", gen_block_verification_base<invalid_block_idx>::check_block_purged); + } + + bool check_block_verification_context(const cryptonote::block_verification_context& bvc, size_t event_idx, const cryptonote::block& /*blk*/) + { + if (invalid_block_idx == event_idx) + return bvc.m_verifivation_failed; + else + return !bvc.m_verifivation_failed; + } + + bool check_block_purged(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events) + { + DEFINE_TESTS_ERROR_CONTEXT("gen_block_verification_base::check_block_purged"); + + CHECK_TEST_CONDITION(invalid_block_idx < ev_index); + CHECK_EQ(0, c.get_pool_transactions_count()); + CHECK_EQ(invalid_block_idx, c.get_current_blockchain_height()); + + return true; + } +}; + +template<size_t expected_blockchain_height> +struct gen_block_accepted_base : public test_chain_unit_base +{ + gen_block_accepted_base() + { + REGISTER_CALLBACK("check_block_accepted", gen_block_accepted_base::check_block_accepted); + } + + bool check_block_accepted(cryptonote::core& c, size_t /*ev_index*/, const std::vector<test_event_entry>& /*events*/) + { + DEFINE_TESTS_ERROR_CONTEXT("gen_block_accepted_base::check_block_accepted"); + + CHECK_EQ(0, c.get_pool_transactions_count()); + CHECK_EQ(expected_blockchain_height, c.get_current_blockchain_height()); + + return true; + } +}; + +struct gen_block_big_major_version : public gen_block_verification_base<1> +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_block_big_minor_version : public gen_block_accepted_base<2> +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_block_ts_not_checked : public gen_block_accepted_base<BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW> +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_block_ts_in_past : public gen_block_verification_base<BLOCKCHAIN_TIMESTAMP_CHECK_WINDOW> +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_block_ts_in_future : public gen_block_verification_base<1> +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_block_invalid_prev_id : public gen_block_verification_base<1> +{ + bool generate(std::vector<test_event_entry>& events) const; + bool check_block_verification_context(const cryptonote::block_verification_context& bvc, size_t event_idx, const cryptonote::block& /*blk*/); +}; + +struct gen_block_invalid_nonce : public gen_block_verification_base<3> +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_block_no_miner_tx : public gen_block_verification_base<1> +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_block_unlock_time_is_low : public gen_block_verification_base<1> +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_block_unlock_time_is_high : public gen_block_verification_base<1> +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_block_unlock_time_is_timestamp_in_past : public gen_block_verification_base<1> +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_block_unlock_time_is_timestamp_in_future : public gen_block_verification_base<1> +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_block_height_is_low : public gen_block_verification_base<1> +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_block_height_is_high : public gen_block_verification_base<1> +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_block_miner_tx_has_2_tx_gen_in : public gen_block_verification_base<1> +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_block_miner_tx_has_2_in : public gen_block_verification_base<CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW + 1> +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_block_miner_tx_with_txin_to_key : public gen_block_verification_base<CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW + 2> +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_block_miner_tx_out_is_small : public gen_block_verification_base<1> +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_block_miner_tx_out_is_big : public gen_block_verification_base<1> +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_block_miner_tx_has_no_out : public gen_block_verification_base<1> +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_block_miner_tx_has_out_to_alice : public gen_block_accepted_base<2> +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_block_has_invalid_tx : public gen_block_verification_base<1> +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_block_is_too_big : public gen_block_verification_base<1> +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_block_invalid_binary_format : public test_chain_unit_base +{ + gen_block_invalid_binary_format(); + bool generate(std::vector<test_event_entry>& events) const; + bool check_block_verification_context(const cryptonote::block_verification_context& bvc, size_t event_idx, const cryptonote::block& /*blk*/); + bool check_all_blocks_purged(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events); + bool corrupt_blocks_boundary(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events); + +private: + size_t m_corrupt_blocks_begin_idx; +}; diff --git a/tests/core_tests/chain_split_1.cpp b/tests/core_tests/chain_split_1.cpp new file mode 100644 index 000000000..bd598852e --- /dev/null +++ b/tests/core_tests/chain_split_1.cpp @@ -0,0 +1,293 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include "chaingen.h" +#include "chaingen_tests_list.h" + +using namespace std; + +using namespace epee; +using namespace cryptonote; + + +gen_simple_chain_split_1::gen_simple_chain_split_1() +{ + REGISTER_CALLBACK("check_split_not_switched", gen_simple_chain_split_1::check_split_not_switched); + REGISTER_CALLBACK("check_split_not_switched2", gen_simple_chain_split_1::check_split_not_switched2); + REGISTER_CALLBACK("check_split_switched", gen_simple_chain_split_1::check_split_switched); + REGISTER_CALLBACK("check_split_not_switched_back", gen_simple_chain_split_1::check_split_not_switched_back); + REGISTER_CALLBACK("check_split_switched_back_1", gen_simple_chain_split_1::check_split_switched_back_1); + REGISTER_CALLBACK("check_split_switched_back_2", gen_simple_chain_split_1::check_split_switched_back_2); + REGISTER_CALLBACK("check_mempool_1", gen_simple_chain_split_1::check_mempool_1); + REGISTER_CALLBACK("check_mempool_2", gen_simple_chain_split_1::check_mempool_2); + //REGISTER_CALLBACK("check_orphaned_chain_1", gen_simple_chain_split_1::check_orphaned_chain_1); + //REGISTER_CALLBACK("check_orphaned_switched_to_alternative", gen_simple_chain_split_1::check_orphaned_switched_to_alternative); + //REGISTER_CALLBACK("check_orphaned_chain_2", gen_simple_chain_split_1::check_orphaned_chain_2); + //REGISTER_CALLBACK("check_orphaned_switched_to_main", gen_simple_chain_split_1::check_orphaned_switched_to_main); + //REGISTER_CALLBACK("check_orphaned_chain_38", gen_simple_chain_split_1::check_orphaned_chain_38); + //REGISTER_CALLBACK("check_orphaned_chain_39", gen_simple_chain_split_1::check_orphaned_chain_39); + //REGISTER_CALLBACK("check_orphaned_chain_40", gen_simple_chain_split_1::check_orphaned_chain_40); + //REGISTER_CALLBACK("check_orphaned_chain_41", gen_simple_chain_split_1::check_orphaned_chain_41); +} +//----------------------------------------------------------------------------------------------------- +bool gen_simple_chain_split_1::generate(std::vector<test_event_entry> &events) const +{ + uint64_t ts_start = 1338224400; + /* + 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 <-- main blockchain height + (0 )-(1 )-(2 )-(3 )-(4 )-(5 ) -(6 ) -(7 ) -(8 )|-(17) -(18) -(19) -(20) -(21)|-(22)|-(23)|-(24)| + \ -(9 ) -(10)|-(11)|-(12)|-(13) -(14) -(15) -(16) + -(25) -(26)| + -(27)| #check switching to alternative + ---------------------------------------------------------------------------------- + -(28) -(29) -(30) -(31)| + -(32)| #check switching orphans to main + ---------------------------------------------------------------------------------- + -(33) -(34) -(35) -(36) -(37) -(38)| + -(39)| #<--this part becomes alternative chain connected to main + -(40)| #still marked as orphaned + -(41)| + #check orphaned with block in the middle of the orphaned chain + */ + + GENERATE_ACCOUNT(first_miner_account); + // events index + MAKE_GENESIS_BLOCK(events, blk_0, first_miner_account, ts_start); // 0 + MAKE_NEXT_BLOCK(events, blk_1, blk_0, first_miner_account); // 1 + MAKE_NEXT_BLOCK(events, blk_2, blk_1, first_miner_account); // 2 + MAKE_NEXT_BLOCK(events, blk_3, blk_2, first_miner_account); // 3 + MAKE_NEXT_BLOCK(events, blk_4, blk_3, first_miner_account); // 4 + MAKE_NEXT_BLOCK(events, blk_5, blk_4, first_miner_account); // 5 + MAKE_NEXT_BLOCK(events, blk_6, blk_5, first_miner_account); // 6 + MAKE_NEXT_BLOCK(events, blk_7, blk_6, first_miner_account); // 7 + MAKE_NEXT_BLOCK(events, blk_8, blk_7, first_miner_account); // 8 + //split + MAKE_NEXT_BLOCK(events, blk_9, blk_5, first_miner_account); // 9 + MAKE_NEXT_BLOCK(events, blk_10, blk_9, first_miner_account); // 10 + DO_CALLBACK(events, "check_split_not_switched"); // 11 + MAKE_NEXT_BLOCK(events, blk_11, blk_10, first_miner_account); // 12 + DO_CALLBACK(events, "check_split_not_switched2"); // 13 + MAKE_NEXT_BLOCK(events, blk_12, blk_11, first_miner_account); // 14 + DO_CALLBACK(events, "check_split_switched"); // 15 + MAKE_NEXT_BLOCK(events, blk_13, blk_12, first_miner_account); // 16 + MAKE_NEXT_BLOCK(events, blk_14, blk_13, first_miner_account); // 17 + MAKE_NEXT_BLOCK(events, blk_15, blk_14, first_miner_account); // 18 + MAKE_NEXT_BLOCK(events, blk_16, blk_15, first_miner_account); // 19 + //split again and check back switching + MAKE_NEXT_BLOCK(events, blk_17, blk_8, first_miner_account); // 20 + MAKE_NEXT_BLOCK(events, blk_18, blk_17, first_miner_account); // 21 + MAKE_NEXT_BLOCK(events, blk_19, blk_18, first_miner_account); // 22 + MAKE_NEXT_BLOCK(events, blk_20, blk_19, first_miner_account); // 23 + MAKE_NEXT_BLOCK(events, blk_21, blk_20, first_miner_account); // 24 + DO_CALLBACK(events, "check_split_not_switched_back"); // 25 + MAKE_NEXT_BLOCK(events, blk_22, blk_21, first_miner_account); // 26 + DO_CALLBACK(events, "check_split_switched_back_1"); // 27 + MAKE_NEXT_BLOCK(events, blk_23, blk_22, first_miner_account); // 28 + DO_CALLBACK(events, "check_split_switched_back_2"); // 29 + + REWIND_BLOCKS(events, blk_23r, blk_23, first_miner_account); // 30...N1 + GENERATE_ACCOUNT(alice); + MAKE_TX(events, tx_0, first_miner_account, alice, MK_COINS(10), blk_23); // N1+1 + MAKE_TX(events, tx_1, first_miner_account, alice, MK_COINS(20), blk_23); // N1+2 + MAKE_TX(events, tx_2, first_miner_account, alice, MK_COINS(30), blk_23); // N1+3 + DO_CALLBACK(events, "check_mempool_1"); // N1+4 + MAKE_NEXT_BLOCK_TX1(events, blk_24, blk_23r, first_miner_account, tx_0); // N1+5 + DO_CALLBACK(events, "check_mempool_2"); // N1+6 + /* + //check orphaned blocks + MAKE_NEXT_BLOCK_NO_ADD(events, blk_orph_27, blk_16, get_test_target(), first_miner_account); + MAKE_NEXT_BLOCK(events, blk_25, blk_orph_27, get_test_target(), first_miner_account); // 36 + MAKE_NEXT_BLOCK(events, blk_26, blk_25, get_test_target(), first_miner_account); // 37 + DO_CALLBACK(events, "check_orphaned_chain_1"); // 38 + ADD_BLOCK(events, blk_orph_27); // 39 + DO_CALLBACK(events, "check_orphaned_switched_to_alternative"); // 40 + + //check orphaned check to main chain + MAKE_NEXT_BLOCK_NO_ADD(events, blk_orph_32, blk_16, get_test_target(), first_miner_account); + MAKE_NEXT_BLOCK(events, blk_28, blk_orph_32, get_test_target(), first_miner_account); // 41 + MAKE_NEXT_BLOCK(events, blk_29, blk_28, get_test_target(), first_miner_account); // 42 + MAKE_NEXT_BLOCK(events, blk_30, blk_29, get_test_target(), first_miner_account); // 43 + MAKE_NEXT_BLOCK(events, blk_31, blk_30, get_test_target(), first_miner_account); // 44 + DO_CALLBACK(events, "check_orphaned_chain_2"); // 45 + ADD_BLOCK(events, blk_orph_32); // 46 + DO_CALLBACK(events, "check_orphaned_switched_to_main"); // 47 + + //check orphaned check to main chain + MAKE_NEXT_BLOCK_NO_ADD(events, blk_orph_39, blk_16, get_test_target(), first_miner_account); + MAKE_NEXT_BLOCK(events, blk_33, blk_orph_39, get_test_target(), first_miner_account); // 48 + MAKE_NEXT_BLOCK(events, blk_34, blk_33, get_test_target(), first_miner_account); // 49 + MAKE_NEXT_BLOCK_NO_ADD(events, blk_orph_41, blk_34, get_test_target(), first_miner_account); + MAKE_NEXT_BLOCK(events, blk_35, blk_orph_41, get_test_target(), first_miner_account); // 50 + MAKE_NEXT_BLOCK(events, blk_36, blk_35, get_test_target(), first_miner_account); // 51 + MAKE_NEXT_BLOCK_NO_ADD(events, blk_orph_40, blk_36, get_test_target(), first_miner_account); + MAKE_NEXT_BLOCK(events, blk_37, blk_orph_40, get_test_target(), first_miner_account); // 52 + MAKE_NEXT_BLOCK(events, blk_38, blk_37, get_test_target(), first_miner_account); // 53 + DO_CALLBACK(events, "check_orphaned_chain_38"); // 54 + ADD_BLOCK(events, blk_orph_39); // 55 + DO_CALLBACK(events, "check_orphaned_chain_39"); // 56 + ADD_BLOCK(events, blk_orph_40); // 57 + DO_CALLBACK(events, "check_orphaned_chain_40"); // 58 + ADD_BLOCK(events, blk_orph_41); // 59 + DO_CALLBACK(events, "check_orphaned_chain_41"); // 60 + */ + return true; +} +//----------------------------------------------------------------------------------------------------- +bool gen_simple_chain_split_1::check_mempool_2(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events) +{ + DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_mempool_2"); + CHECK_TEST_CONDITION(c.get_pool_transactions_count() == 2); + return true; +} +//----------------------------------------------------------------------------------------------------- +bool gen_simple_chain_split_1::check_mempool_1(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events) +{ + DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_mempool_1"); + CHECK_TEST_CONDITION(c.get_pool_transactions_count() == 3); + return true; +} +//----------------------------------------------------------------------------------------------------- +bool gen_simple_chain_split_1::check_split_not_switched(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events) +{ + DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_split_not_switched"); + //check height + CHECK_TEST_CONDITION(c.get_current_blockchain_height() == 9); + CHECK_TEST_CONDITION(c.get_blockchain_total_transactions() == 9); + CHECK_TEST_CONDITION(c.get_tail_id() == get_block_hash(boost::get<cryptonote::block>(events[8]))); + CHECK_TEST_CONDITION(c.get_alternative_blocks_count() == 2); + return true; +} +//----------------------------------------------------------------------------------------------------- +bool gen_simple_chain_split_1::check_split_not_switched2(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events) +{ + DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_split_not_switched2"); + //check height + CHECK_TEST_CONDITION(c.get_current_blockchain_height() == 9); + CHECK_TEST_CONDITION(c.get_blockchain_total_transactions() == 9); + CHECK_TEST_CONDITION(c.get_tail_id() == get_block_hash(boost::get<cryptonote::block>(events[8]))); + CHECK_TEST_CONDITION(c.get_alternative_blocks_count() == 3); + return true; +} +//----------------------------------------------------------------------------------------------------- +bool gen_simple_chain_split_1::check_split_switched(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events) +{ + DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_split_switched"); + + //check height + CHECK_TEST_CONDITION(c.get_current_blockchain_height() == 10); + CHECK_TEST_CONDITION(c.get_blockchain_total_transactions() == 10); + CHECK_TEST_CONDITION(c.get_tail_id() == get_block_hash(boost::get<cryptonote::block>(events[14]))); + CHECK_TEST_CONDITION(c.get_alternative_blocks_count() == 3); + return true; +} +//----------------------------------------------------------------------------------------------------- +bool gen_simple_chain_split_1::check_split_not_switched_back(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events) +{ + DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_split_not_switched_back"); + //check height + CHECK_TEST_CONDITION(c.get_current_blockchain_height() == 14); + CHECK_TEST_CONDITION(c.get_blockchain_total_transactions() == 14); + CHECK_TEST_CONDITION(c.get_tail_id() == get_block_hash(boost::get<cryptonote::block>(events[19]))); + CHECK_TEST_CONDITION(c.get_alternative_blocks_count() == 8); + + return true; +} +//----------------------------------------------------------------------------------------------------- +bool gen_simple_chain_split_1::check_split_switched_back_1(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events) +{ + DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_split_switched_back_1"); + + //check height + CHECK_TEST_CONDITION(c.get_current_blockchain_height()== 15); + CHECK_TEST_CONDITION(c.get_blockchain_total_transactions() == 15); + CHECK_TEST_CONDITION(c.get_tail_id() == get_block_hash(boost::get<cryptonote::block>(events[26]))); + CHECK_TEST_CONDITION(c.get_alternative_blocks_count() == 8); + + return true; +}//----------------------------------------------------------------------------------------------------- +bool gen_simple_chain_split_1::check_split_switched_back_2(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events) +{ + DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_split_switched_back_2"); + + //check height + CHECK_TEST_CONDITION(c.get_current_blockchain_height() == 16); + CHECK_TEST_CONDITION(c.get_blockchain_total_transactions() == 16); + CHECK_TEST_CONDITION(c.get_tail_id() == get_block_hash(boost::get<cryptonote::block>(events[28]))); + CHECK_TEST_CONDITION(c.get_alternative_blocks_count() == 8); + return true; +} +//----------------------------------------------------------------------------------------------------- +/* +bool gen_simple_chain_split_1::check_orphaned_chain_1(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events) +{ + DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_orphaned_chain_1"); + CHECK_TEST_CONDITION(c.get_orphaned_by_prev_blocks_count() == 2); + return true; +} +//----------------------------------------------------------------------------------------------------- +bool gen_simple_chain_split_1::check_orphaned_switched_to_alternative(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events) +{ + DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_orphaned_switched_to_alternative"); + CHECK_TEST_CONDITION(c.get_orphaned_by_prev_blocks_count() == 0); + CHECK_TEST_CONDITION(c.get_current_blockchain_height()== 17); + CHECK_TEST_CONDITION(c.get_alternative_blocks_count() == 11); + return true; +} +//----------------------------------------------------------------------------------------------------- +bool gen_simple_chain_split_1::check_orphaned_chain_2(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events) +{ + DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_orphaned_chain_2"); + CHECK_TEST_CONDITION(c.get_orphaned_by_prev_blocks_count() == 4); + return true; +} +//----------------------------------------------------------------------------------------------------- +bool gen_simple_chain_split_1::check_orphaned_switched_to_main(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events) +{ + DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_orphaned_switched_to_main"); + CHECK_TEST_CONDITION(c.get_orphaned_by_prev_blocks_count() == 0); + CHECK_TEST_CONDITION(c.get_current_blockchain_height()== 19); + CHECK_TEST_CONDITION(c.get_alternative_blocks_count() == 14); + return true; +} +//----------------------------------------------------------------------------------------------------- +bool gen_simple_chain_split_1::check_orphaned_chain_38(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events) +{ + DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_orphaned_chain_38"); + CHECK_TEST_CONDITION(c.get_orphaned_by_prev_blocks_count() == 6); + CHECK_TEST_CONDITION(c.get_alternative_blocks_count() == 14); + CHECK_TEST_CONDITION(c.get_current_blockchain_height()== 19); + return true; +} +//----------------------------------------------------------------------------------------------------- +bool gen_simple_chain_split_1::check_orphaned_chain_39(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events) +{ + DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_orphaned_chain_39"); + CHECK_TEST_CONDITION(c.get_orphaned_by_prev_blocks_count() == 4); + CHECK_TEST_CONDITION(c.get_alternative_blocks_count() == 17); + CHECK_TEST_CONDITION(c.get_current_blockchain_height()== 19); + return true; +} +//----------------------------------------------------------------------------------------------------- +bool gen_simple_chain_split_1::check_orphaned_chain_40(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events) +{ + DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_orphaned_chain_40"); + CHECK_TEST_CONDITION(c.get_orphaned_by_prev_blocks_count() == 5); + CHECK_TEST_CONDITION(c.get_alternative_blocks_count() == 17); + CHECK_TEST_CONDITION(c.get_current_blockchain_height()== 19); + return true; +} +//----------------------------------------------------------------------------------------------------- +bool gen_simple_chain_split_1::check_orphaned_chain_41(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events) +{ + DEFINE_TESTS_ERROR_CONTEXT("gen_simple_chain_split_1::check_orphaned_chain_41"); + CHECK_TEST_CONDITION(c.get_orphaned_by_prev_blocks_count() == 0); + CHECK_TEST_CONDITION(c.get_alternative_blocks_count() == 19); + CHECK_TEST_CONDITION(c.get_current_blockchain_height()== 23); + + return true; +}*/ +//----------------------------------------------------------------------------------------------------- + + + diff --git a/tests/core_tests/chain_split_1.h b/tests/core_tests/chain_split_1.h new file mode 100644 index 000000000..df7efea82 --- /dev/null +++ b/tests/core_tests/chain_split_1.h @@ -0,0 +1,33 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#pragma once +#include "chaingen.h" + +/************************************************************************/ +/* */ +/************************************************************************/ +class gen_simple_chain_split_1 : public test_chain_unit_base +{ +public: + gen_simple_chain_split_1(); + bool generate(std::vector<test_event_entry> &events) const; + bool check_split_not_switched(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events); + bool check_split_not_switched2(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events); + bool check_split_switched(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events); + bool check_split_not_switched_back(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events); + bool check_split_switched_back_1(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events); + bool check_split_switched_back_2(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events); + bool check_mempool_1(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events); + bool check_mempool_2(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events); + /*bool check_orphaned_chain_1(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events); + bool check_orphaned_switched_to_alternative(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events); + bool check_orphaned_chain_2(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events); + bool check_orphaned_switched_to_main(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events); + bool check_orphaned_chain_38(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events); + bool check_orphaned_chain_39(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events); + bool check_orphaned_chain_40(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events); + bool check_orphaned_chain_41(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events); */ +private: +}; diff --git a/tests/core_tests/chain_switch_1.cpp b/tests/core_tests/chain_switch_1.cpp new file mode 100644 index 000000000..8e9a2c1db --- /dev/null +++ b/tests/core_tests/chain_switch_1.cpp @@ -0,0 +1,184 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include "chaingen.h" +#include "chaingen_tests_list.h" + +using namespace epee; +using namespace cryptonote; + + +gen_chain_switch_1::gen_chain_switch_1() +{ + REGISTER_CALLBACK("check_split_not_switched", gen_chain_switch_1::check_split_not_switched); + REGISTER_CALLBACK("check_split_switched", gen_chain_switch_1::check_split_switched); +} + + +//----------------------------------------------------------------------------------------------------- +bool gen_chain_switch_1::generate(std::vector<test_event_entry>& events) const +{ + uint64_t ts_start = 1338224400; + /* + (0 )-(1 )-(2 ) -(3 )-(4 ) <- main chain, until 7 isn't connected + \ |-(5 )-(6 )-(7 )| <- alt chain, until 7 isn't connected + + transactions ([n] - tx amount, (m) - block): + (1) : miner -[ 5]-> account_1 ( +5 in main chain, +5 in alt chain) + (3) : miner -[ 7]-> account_2 ( +7 in main chain, +0 in alt chain), tx will be in tx pool after switch + (4), (6): miner -[11]-> account_3 (+11 in main chain, +11 in alt chain) + (5) : miner -[13]-> account_4 ( +0 in main chain, +13 in alt chain), tx will be in tx pool before switch + + transactions orders ([n] - tx amount, (m) - block): + miner -[1], [2]-> account_1: in main chain (3), (3), in alt chain (5), (6) + miner -[1], [2]-> account_2: in main chain (3), (4), in alt chain (5), (5) + miner -[1], [2]-> account_3: in main chain (3), (4), in alt chain (6), (5) + miner -[1], [2]-> account_4: in main chain (4), (3), in alt chain (5), (6) + */ + + GENERATE_ACCOUNT(miner_account); + + // events + MAKE_GENESIS_BLOCK(events, blk_0, miner_account, ts_start); // 0 + MAKE_ACCOUNT(events, recipient_account_1); // 1 + MAKE_ACCOUNT(events, recipient_account_2); // 2 + MAKE_ACCOUNT(events, recipient_account_3); // 3 + MAKE_ACCOUNT(events, recipient_account_4); // 4 + REWIND_BLOCKS(events, blk_0r, blk_0, miner_account) // <N blocks> + MAKE_TX(events, tx_00, miner_account, recipient_account_1, MK_COINS(5), blk_0); // 5 + N + MAKE_NEXT_BLOCK_TX1(events, blk_1, blk_0r, miner_account, tx_00); // 6 + N + MAKE_NEXT_BLOCK(events, blk_2, blk_1, miner_account); // 7 + N + REWIND_BLOCKS(events, blk_2r, blk_2, miner_account) // <N blocks> + + // Transactions to test account balances after switch + MAKE_TX_LIST_START(events, txs_blk_3, miner_account, recipient_account_2, MK_COINS(7), blk_2); // 8 + 2N + MAKE_TX_LIST_START(events, txs_blk_4, miner_account, recipient_account_3, MK_COINS(11), blk_2); // 9 + 2N + MAKE_TX_LIST_START(events, txs_blk_5, miner_account, recipient_account_4, MK_COINS(13), blk_2); // 10 + 2N + std::list<transaction> txs_blk_6; + txs_blk_6.push_back(txs_blk_4.front()); + + // Transactions, that has different order in alt block chains + MAKE_TX_LIST(events, txs_blk_3, miner_account, recipient_account_1, MK_COINS(1), blk_2); // 11 + 2N + txs_blk_5.push_back(txs_blk_3.back()); + MAKE_TX_LIST(events, txs_blk_3, miner_account, recipient_account_1, MK_COINS(2), blk_2); // 12 + 2N + txs_blk_6.push_back(txs_blk_3.back()); + + MAKE_TX_LIST(events, txs_blk_3, miner_account, recipient_account_2, MK_COINS(1), blk_2); // 13 + 2N + txs_blk_5.push_back(txs_blk_3.back()); + MAKE_TX_LIST(events, txs_blk_4, miner_account, recipient_account_2, MK_COINS(2), blk_2); // 14 + 2N + txs_blk_5.push_back(txs_blk_4.back()); + + MAKE_TX_LIST(events, txs_blk_3, miner_account, recipient_account_3, MK_COINS(1), blk_2); // 15 + 2N + txs_blk_6.push_back(txs_blk_3.back()); + MAKE_TX_LIST(events, txs_blk_4, miner_account, recipient_account_3, MK_COINS(2), blk_2); // 16 + 2N + txs_blk_5.push_back(txs_blk_4.back()); + + MAKE_TX_LIST(events, txs_blk_4, miner_account, recipient_account_4, MK_COINS(1), blk_2); // 17 + 2N + txs_blk_5.push_back(txs_blk_4.back()); + MAKE_TX_LIST(events, txs_blk_3, miner_account, recipient_account_4, MK_COINS(2), blk_2); // 18 + 2N + txs_blk_6.push_back(txs_blk_3.back()); + + MAKE_NEXT_BLOCK_TX_LIST(events, blk_3, blk_2r, miner_account, txs_blk_3); // 19 + 2N + MAKE_NEXT_BLOCK_TX_LIST(events, blk_4, blk_3, miner_account, txs_blk_4); // 20 + 2N + //split + MAKE_NEXT_BLOCK_TX_LIST(events, blk_5, blk_2r, miner_account, txs_blk_5); // 22 + 2N + MAKE_NEXT_BLOCK_TX_LIST(events, blk_6, blk_5, miner_account, txs_blk_6); // 23 + 2N + DO_CALLBACK(events, "check_split_not_switched"); // 21 + 2N + MAKE_NEXT_BLOCK(events, blk_7, blk_6, miner_account); // 24 + 2N + DO_CALLBACK(events, "check_split_switched"); // 25 + 2N + + return true; +} + + +//----------------------------------------------------------------------------------------------------- +bool gen_chain_switch_1::check_split_not_switched(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events) +{ + DEFINE_TESTS_ERROR_CONTEXT("gen_chain_switch_1::check_split_not_switched"); + + m_recipient_account_1 = boost::get<account_base>(events[1]); + m_recipient_account_2 = boost::get<account_base>(events[2]); + m_recipient_account_3 = boost::get<account_base>(events[3]); + m_recipient_account_4 = boost::get<account_base>(events[4]); + + std::list<block> blocks; + bool r = c.get_blocks(0, 10000, blocks); + CHECK_TEST_CONDITION(r); + CHECK_EQ(5 + 2 * CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW, blocks.size()); + CHECK_TEST_CONDITION(blocks.back() == boost::get<block>(events[20 + 2 * CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW])); // blk_4 + + CHECK_EQ(2, c.get_alternative_blocks_count()); + + std::vector<cryptonote::block> chain; + map_hash2tx_t mtx; + r = find_block_chain(events, chain, mtx, get_block_hash(blocks.back())); + CHECK_TEST_CONDITION(r); + CHECK_EQ(MK_COINS(8), get_balance(m_recipient_account_1, chain, mtx)); + CHECK_EQ(MK_COINS(10), get_balance(m_recipient_account_2, chain, mtx)); + CHECK_EQ(MK_COINS(14), get_balance(m_recipient_account_3, chain, mtx)); + CHECK_EQ(MK_COINS(3), get_balance(m_recipient_account_4, chain, mtx)); + + std::list<transaction> tx_pool; + r = c.get_pool_transactions(tx_pool); + CHECK_TEST_CONDITION(r); + CHECK_EQ(1, tx_pool.size()); + + std::vector<size_t> tx_outs; + uint64_t transfered; + lookup_acc_outs(m_recipient_account_4.get_keys(), tx_pool.front(), get_tx_pub_key_from_extra(tx_pool.front()), tx_outs, transfered); + CHECK_EQ(MK_COINS(13), transfered); + + m_chain_1.swap(blocks); + m_tx_pool.swap(tx_pool); + + return true; +} + +//----------------------------------------------------------------------------------------------------- +bool gen_chain_switch_1::check_split_switched(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events) +{ + DEFINE_TESTS_ERROR_CONTEXT("gen_chain_switch_1::check_split_switched"); + + std::list<block> blocks; + bool r = c.get_blocks(0, 10000, blocks); + CHECK_TEST_CONDITION(r); + CHECK_EQ(6 + 2 * CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW, blocks.size()); + auto it = blocks.end(); + --it; --it; --it; + CHECK_TEST_CONDITION(std::equal(blocks.begin(), it, m_chain_1.begin())); + CHECK_TEST_CONDITION(blocks.back() == boost::get<block>(events[24 + 2 * CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW])); // blk_7 + + std::list<block> alt_blocks; + r = c.get_alternative_blocks(alt_blocks); + CHECK_TEST_CONDITION(r); + CHECK_EQ(2, c.get_alternative_blocks_count()); + + // Some blocks that were in main chain are in alt chain now + BOOST_FOREACH(block b, alt_blocks) + { + CHECK_TEST_CONDITION(m_chain_1.end() != std::find(m_chain_1.begin(), m_chain_1.end(), b)); + } + + std::vector<cryptonote::block> chain; + map_hash2tx_t mtx; + r = find_block_chain(events, chain, mtx, get_block_hash(blocks.back())); + CHECK_TEST_CONDITION(r); + CHECK_EQ(MK_COINS(8), get_balance(m_recipient_account_1, chain, mtx)); + CHECK_EQ(MK_COINS(3), get_balance(m_recipient_account_2, chain, mtx)); + CHECK_EQ(MK_COINS(14), get_balance(m_recipient_account_3, chain, mtx)); + CHECK_EQ(MK_COINS(16), get_balance(m_recipient_account_4, chain, mtx)); + + std::list<transaction> tx_pool; + r = c.get_pool_transactions(tx_pool); + CHECK_TEST_CONDITION(r); + CHECK_EQ(1, tx_pool.size()); + CHECK_TEST_CONDITION(!(tx_pool.front() == m_tx_pool.front())); + + std::vector<size_t> tx_outs; + uint64_t transfered; + lookup_acc_outs(m_recipient_account_2.get_keys(), tx_pool.front(), tx_outs, transfered); + CHECK_EQ(MK_COINS(7), transfered); + + return true; +} diff --git a/tests/core_tests/chain_switch_1.h b/tests/core_tests/chain_switch_1.h new file mode 100644 index 000000000..05e84e6cf --- /dev/null +++ b/tests/core_tests/chain_switch_1.h @@ -0,0 +1,30 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#pragma once +#include "chaingen.h" + +/************************************************************************/ +/* */ +/************************************************************************/ +class gen_chain_switch_1 : public test_chain_unit_base +{ +public: + gen_chain_switch_1(); + + bool generate(std::vector<test_event_entry>& events) const; + + bool check_split_not_switched(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events); + bool check_split_switched(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events); + +private: + std::list<cryptonote::block> m_chain_1; + + cryptonote::account_base m_recipient_account_1; + cryptonote::account_base m_recipient_account_2; + cryptonote::account_base m_recipient_account_3; + cryptonote::account_base m_recipient_account_4; + + std::list<cryptonote::transaction> m_tx_pool; +}; diff --git a/tests/core_tests/chaingen.cpp b/tests/core_tests/chaingen.cpp new file mode 100644 index 000000000..c876e3a75 --- /dev/null +++ b/tests/core_tests/chaingen.cpp @@ -0,0 +1,637 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include <vector> +#include <iostream> +#include <sstream> + +#include "include_base_utils.h" + +#include "console_handler.h" + +#include "p2p/net_node.h" +#include "cryptonote_core/cryptonote_basic.h" +#include "cryptonote_core/cryptonote_basic_impl.h" +#include "cryptonote_core/cryptonote_format_utils.h" +#include "cryptonote_core/miner.h" + +#include "chaingen.h" + +using namespace std; + +using namespace epee; +using namespace cryptonote; + + +void test_generator::get_block_chain(std::vector<block_info>& blockchain, const crypto::hash& head, size_t n) const +{ + crypto::hash curr = head; + while (null_hash != curr && blockchain.size() < n) + { + auto it = m_blocks_info.find(curr); + if (m_blocks_info.end() == it) + { + throw std::runtime_error("block hash wasn't found"); + } + + blockchain.push_back(it->second); + curr = it->second.prev_id; + } + + std::reverse(blockchain.begin(), blockchain.end()); +} + +void test_generator::get_last_n_block_sizes(std::vector<size_t>& block_sizes, const crypto::hash& head, size_t n) const +{ + std::vector<block_info> blockchain; + get_block_chain(blockchain, head, n); + BOOST_FOREACH(auto& bi, blockchain) + { + block_sizes.push_back(bi.block_size); + } +} + +uint64_t test_generator::get_already_generated_coins(const crypto::hash& blk_id) const +{ + auto it = m_blocks_info.find(blk_id); + if (it == m_blocks_info.end()) + throw std::runtime_error("block hash wasn't found"); + + return it->second.already_generated_coins; +} + +uint64_t test_generator::get_already_generated_coins(const cryptonote::block& blk) const +{ + crypto::hash blk_hash; + get_block_hash(blk, blk_hash); + return get_already_generated_coins(blk_hash); +} + +void test_generator::add_block(const cryptonote::block& blk, size_t tsx_size, std::vector<size_t>& block_sizes, uint64_t already_generated_coins) +{ + const size_t block_size = tsx_size + get_object_blobsize(blk.miner_tx); + bool block_too_big; + uint64_t block_reward = get_block_reward(block_sizes, block_size, block_too_big, already_generated_coins); + m_blocks_info[get_block_hash(blk)] = block_info(blk.prev_id, already_generated_coins + block_reward, block_size); +} + +bool test_generator::construct_block(cryptonote::block& blk, uint64_t height, const crypto::hash& prev_id, + const cryptonote::account_base& miner_acc, uint64_t timestamp, uint64_t already_generated_coins, + std::vector<size_t>& block_sizes, const std::list<cryptonote::transaction>& tx_list) +{ + blk.major_version = CURRENT_BLOCK_MAJOR_VERSION; + blk.minor_version = CURRENT_BLOCK_MINOR_VERSION; + blk.timestamp = timestamp; + blk.prev_id = prev_id; + + blk.tx_hashes.reserve(tx_list.size()); + BOOST_FOREACH(const transaction &tx, tx_list) + { + crypto::hash tx_hash; + get_transaction_hash(tx, tx_hash); + blk.tx_hashes.push_back(tx_hash); + } + + uint64_t total_fee = 0; + size_t txs_size = 0; + BOOST_FOREACH(auto& tx, tx_list) + { + uint64_t fee = 0; + bool r = get_tx_fee(tx, fee); + CHECK_AND_ASSERT_MES(r, false, "wrong transaction passed to construct_block"); + total_fee += fee; + txs_size += get_object_blobsize(tx); + } + + blk.miner_tx = AUTO_VAL_INIT(blk.miner_tx); + size_t target_block_size = txs_size + get_object_blobsize(blk.miner_tx); + while (true) + { + if (!construct_miner_tx(height, already_generated_coins, miner_acc.get_keys().m_account_address, blk.miner_tx, total_fee, block_sizes, target_block_size, 10)) + return false; + + size_t actual_block_size = txs_size + get_object_blobsize(blk.miner_tx); + if (target_block_size < actual_block_size) + { + target_block_size = actual_block_size; + } + else if (actual_block_size < target_block_size) + { + size_t delta = target_block_size - actual_block_size; + blk.miner_tx.extra.resize(blk.miner_tx.extra.size() + delta, 0); + actual_block_size = txs_size + get_object_blobsize(blk.miner_tx); + if (actual_block_size == target_block_size) + { + break; + } + else + { + CHECK_AND_ASSERT_MES(target_block_size < actual_block_size, false, "Unexpected block size"); + delta = actual_block_size - target_block_size; + blk.miner_tx.extra.resize(blk.miner_tx.extra.size() - delta); + actual_block_size = txs_size + get_object_blobsize(blk.miner_tx); + if (actual_block_size == target_block_size) + { + break; + } + else + { + CHECK_AND_ASSERT_MES(actual_block_size < target_block_size, false, "Unexpected block size"); + blk.miner_tx.extra.resize(blk.miner_tx.extra.size() + delta, 0); + target_block_size = txs_size + get_object_blobsize(blk.miner_tx); + } + } + } + else + { + break; + } + } + + //blk.tree_root_hash = get_tx_tree_hash(blk); + + // Nonce search... + blk.nonce = 0; + while (!miner::find_nonce_for_given_block(blk, get_test_difficulty(), height)) + blk.timestamp++; + + add_block(blk, txs_size, block_sizes, already_generated_coins); + + return true; +} + +bool test_generator::construct_block(cryptonote::block& blk, const cryptonote::account_base& miner_acc, uint64_t timestamp) +{ + std::vector<size_t> block_sizes; + std::list<cryptonote::transaction> tx_list; + return construct_block(blk, 0, null_hash, miner_acc, timestamp, 0, block_sizes, tx_list); +} + +bool test_generator::construct_block(cryptonote::block& blk, const cryptonote::block& blk_prev, + const cryptonote::account_base& miner_acc, + const std::list<cryptonote::transaction>& tx_list/* = std::list<cryptonote::transaction>()*/) +{ + uint64_t height = boost::get<txin_gen>(blk_prev.miner_tx.vin.front()).height + 1; + crypto::hash prev_id = get_block_hash(blk_prev); + // Keep difficulty unchanged + uint64_t timestamp = blk_prev.timestamp + DIFFICULTY_BLOCKS_ESTIMATE_TIMESPAN; + uint64_t already_generated_coins = get_already_generated_coins(prev_id); + std::vector<size_t> block_sizes; + get_last_n_block_sizes(block_sizes, prev_id, CRYPTONOTE_REWARD_BLOCKS_WINDOW); + + return construct_block(blk, height, prev_id, miner_acc, timestamp, already_generated_coins, block_sizes, tx_list); +} + +bool test_generator::construct_block_manually(block& blk, const block& prev_block, const account_base& miner_acc, + int actual_params/* = bf_none*/, uint8_t major_ver/* = 0*/, + uint8_t minor_ver/* = 0*/, uint64_t timestamp/* = 0*/, + const crypto::hash& prev_id/* = crypto::hash()*/, const difficulty_type& diffic/* = 1*/, + const transaction& miner_tx/* = transaction()*/, + const std::vector<crypto::hash>& tx_hashes/* = std::vector<crypto::hash>()*/, + size_t txs_sizes/* = 0*/) +{ + blk.major_version = actual_params & bf_major_ver ? major_ver : CURRENT_BLOCK_MAJOR_VERSION; + blk.minor_version = actual_params & bf_minor_ver ? minor_ver : CURRENT_BLOCK_MINOR_VERSION; + blk.timestamp = actual_params & bf_timestamp ? timestamp : prev_block.timestamp + DIFFICULTY_BLOCKS_ESTIMATE_TIMESPAN; // Keep difficulty unchanged + blk.prev_id = actual_params & bf_prev_id ? prev_id : get_block_hash(prev_block); + blk.tx_hashes = actual_params & bf_tx_hashes ? tx_hashes : std::vector<crypto::hash>(); + + size_t height = get_block_height(prev_block) + 1; + uint64_t already_generated_coins = get_already_generated_coins(prev_block); + std::vector<size_t> block_sizes; + get_last_n_block_sizes(block_sizes, get_block_hash(prev_block), CRYPTONOTE_REWARD_BLOCKS_WINDOW); + if (actual_params & bf_miner_tx) + { + blk.miner_tx = miner_tx; + } + else + { + size_t current_block_size = txs_sizes + get_object_blobsize(blk.miner_tx); + // TODO: This will work, until size of constructed block is less then CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE + if (!construct_miner_tx(height, already_generated_coins, miner_acc.get_keys().m_account_address, blk.miner_tx, 0, block_sizes, current_block_size, 1)) + return false; + } + + //blk.tree_root_hash = get_tx_tree_hash(blk); + + difficulty_type a_diffic = actual_params & bf_diffic ? diffic : get_test_difficulty(); + fill_nonce(blk, a_diffic, height); + + add_block(blk, txs_sizes, block_sizes, already_generated_coins); + + return true; +} + +bool test_generator::construct_block_manually_tx(cryptonote::block& blk, const cryptonote::block& prev_block, + const cryptonote::account_base& miner_acc, + const std::vector<crypto::hash>& tx_hashes, size_t txs_size) +{ + return construct_block_manually(blk, prev_block, miner_acc, bf_tx_hashes, 0, 0, 0, crypto::hash(), 0, transaction(), tx_hashes, txs_size); +} + + +struct output_index { + const cryptonote::txout_target_v out; + uint64_t amount; + size_t blk_height; // block height + size_t tx_no; // index of transaction in block + size_t out_no; // index of out in transaction + size_t idx; + bool spent; + const cryptonote::block *p_blk; + const cryptonote::transaction *p_tx; + + output_index(const cryptonote::txout_target_v &_out, uint64_t _a, size_t _h, size_t tno, size_t ono, const cryptonote::block *_pb, const cryptonote::transaction *_pt) + : out(_out), amount(_a), blk_height(_h), tx_no(tno), out_no(ono), idx(0), spent(false), p_blk(_pb), p_tx(_pt) { } + + output_index(const output_index &other) + : out(other.out), amount(other.amount), blk_height(other.blk_height), tx_no(other.tx_no), out_no(other.out_no), idx(other.idx), spent(other.spent), p_blk(other.p_blk), p_tx(other.p_tx) { } + + const std::string toString() const { + std::stringstream ss; + + ss << "output_index{blk_height=" << blk_height + << " tx_no=" << tx_no + << " out_no=" << out_no + << " amount=" << amount + << " idx=" << idx + << " spent=" << spent + << "}"; + + return ss.str(); + } + + output_index& operator=(const output_index& other) + { + new(this) output_index(other); + return *this; + } +}; + +typedef std::map<uint64_t, std::vector<size_t> > map_output_t; +typedef std::map<uint64_t, std::vector<output_index> > map_output_idx_t; +typedef pair<uint64_t, size_t> outloc_t; + +namespace +{ + uint64_t get_inputs_amount(const vector<tx_source_entry> &s) + { + uint64_t r = 0; + BOOST_FOREACH(const tx_source_entry &e, s) + { + r += e.amount; + } + + return r; + } +} + +bool init_output_indices(map_output_idx_t& outs, std::map<uint64_t, std::vector<size_t> >& outs_mine, const std::vector<cryptonote::block>& blockchain, const map_hash2tx_t& mtx, const cryptonote::account_base& from) { + + BOOST_FOREACH (const block& blk, blockchain) { + vector<const transaction*> vtx; + vtx.push_back(&blk.miner_tx); + + BOOST_FOREACH(const crypto::hash &h, blk.tx_hashes) { + const map_hash2tx_t::const_iterator cit = mtx.find(h); + if (mtx.end() == cit) + throw std::runtime_error("block contains an unknown tx hash"); + + vtx.push_back(cit->second); + } + + //vtx.insert(vtx.end(), blk.); + // TODO: add all other txes + for (size_t i = 0; i < vtx.size(); i++) { + const transaction &tx = *vtx[i]; + + for (size_t j = 0; j < tx.vout.size(); ++j) { + const tx_out &out = tx.vout[j]; + + output_index oi(out.target, out.amount, boost::get<txin_gen>(*blk.miner_tx.vin.begin()).height, i, j, &blk, vtx[i]); + + if (2 == out.target.which()) { // out_to_key + outs[out.amount].push_back(oi); + size_t tx_global_idx = outs[out.amount].size() - 1; + outs[out.amount][tx_global_idx].idx = tx_global_idx; + // Is out to me? + if (is_out_to_acc(from.get_keys(), boost::get<txout_to_key>(out.target), get_tx_pub_key_from_extra(tx), j)) { + outs_mine[out.amount].push_back(tx_global_idx); + } + } + } + } + } + + return true; +} + +bool init_spent_output_indices(map_output_idx_t& outs, map_output_t& outs_mine, const std::vector<cryptonote::block>& blockchain, const map_hash2tx_t& mtx, const cryptonote::account_base& from) { + + BOOST_FOREACH (const map_output_t::value_type &o, outs_mine) { + for (size_t i = 0; i < o.second.size(); ++i) { + output_index &oi = outs[o.first][o.second[i]]; + + // construct key image for this output + crypto::key_image img; + keypair in_ephemeral; + generate_key_image_helper(from.get_keys(), get_tx_pub_key_from_extra(*oi.p_tx), oi.out_no, in_ephemeral, img); + + // lookup for this key image in the events vector + BOOST_FOREACH(auto& tx_pair, mtx) { + const transaction& tx = *tx_pair.second; + BOOST_FOREACH(const txin_v &in, tx.vin) { + if (typeid(txin_to_key) == in.type()) { + const txin_to_key &itk = boost::get<txin_to_key>(in); + if (itk.k_image == img) { + oi.spent = true; + } + } + } + } + } + } + + return true; +} + +bool fill_output_entries(std::vector<output_index>& out_indices, size_t sender_out, size_t nmix, size_t& real_entry_idx, std::vector<tx_source_entry::output_entry>& output_entries) +{ + if (out_indices.size() <= nmix) + return false; + + bool sender_out_found = false; + size_t rest = nmix; + for (size_t i = 0; i < out_indices.size() && (0 < rest || !sender_out_found); ++i) + { + const output_index& oi = out_indices[i]; + if (oi.spent) + continue; + + bool append = false; + if (i == sender_out) + { + append = true; + sender_out_found = true; + real_entry_idx = output_entries.size(); + } + else if (0 < rest) + { + --rest; + append = true; + } + + if (append) + { + const txout_to_key& otk = boost::get<txout_to_key>(oi.out); + output_entries.push_back(tx_source_entry::output_entry(oi.idx, otk.key)); + } + } + + return 0 == rest && sender_out_found; +} + +bool fill_tx_sources(std::vector<tx_source_entry>& sources, const std::vector<test_event_entry>& events, + const block& blk_head, const cryptonote::account_base& from, uint64_t amount, size_t nmix) +{ + map_output_idx_t outs; + map_output_t outs_mine; + + std::vector<cryptonote::block> blockchain; + map_hash2tx_t mtx; + if (!find_block_chain(events, blockchain, mtx, get_block_hash(blk_head))) + return false; + + if (!init_output_indices(outs, outs_mine, blockchain, mtx, from)) + return false; + + if (!init_spent_output_indices(outs, outs_mine, blockchain, mtx, from)) + return false; + + // Iterate in reverse is more efficiency + uint64_t sources_amount = 0; + bool sources_found = false; + BOOST_REVERSE_FOREACH(const map_output_t::value_type o, outs_mine) + { + for (size_t i = 0; i < o.second.size() && !sources_found; ++i) + { + size_t sender_out = o.second[i]; + const output_index& oi = outs[o.first][sender_out]; + if (oi.spent) + continue; + + cryptonote::tx_source_entry ts; + ts.amount = oi.amount; + ts.real_output_in_tx_index = oi.out_no; + ts.real_out_tx_key = get_tx_pub_key_from_extra(*oi.p_tx); // incoming tx public key + if (!fill_output_entries(outs[o.first], sender_out, nmix, ts.real_output, ts.outputs)) + continue; + + sources.push_back(ts); + + sources_amount += ts.amount; + sources_found = amount <= sources_amount; + } + + if (sources_found) + break; + } + + return sources_found; +} + +bool fill_tx_destination(tx_destination_entry &de, const cryptonote::account_base &to, uint64_t amount) { + de.addr = to.get_keys().m_account_address; + de.amount = amount; + return true; +} + +void fill_tx_sources_and_destinations(const std::vector<test_event_entry>& events, const block& blk_head, + const cryptonote::account_base& from, const cryptonote::account_base& to, + uint64_t amount, uint64_t fee, size_t nmix, std::vector<tx_source_entry>& sources, + std::vector<tx_destination_entry>& destinations) +{ + sources.clear(); + destinations.clear(); + + if (!fill_tx_sources(sources, events, blk_head, from, amount + fee, nmix)) + throw std::runtime_error("couldn't fill transaction sources"); + + tx_destination_entry de; + if (!fill_tx_destination(de, to, amount)) + throw std::runtime_error("couldn't fill transaction destination"); + destinations.push_back(de); + + tx_destination_entry de_change; + uint64_t cache_back = get_inputs_amount(sources) - (amount + fee); + if (0 < cache_back) + { + if (!fill_tx_destination(de_change, from, cache_back)) + throw std::runtime_error("couldn't fill transaction cache back destination"); + destinations.push_back(de_change); + } +} + +void fill_nonce(cryptonote::block& blk, const difficulty_type& diffic, uint64_t height) +{ + blk.nonce = 0; + while (!miner::find_nonce_for_given_block(blk, diffic, height)) + blk.timestamp++; +} + +bool construct_miner_tx_manually(size_t height, uint64_t already_generated_coins, + const account_public_address& miner_address, transaction& tx, uint64_t fee, + keypair* p_txkey/* = 0*/) +{ + keypair txkey; + txkey = keypair::generate(); + add_tx_pub_key_to_extra(tx, txkey.pub); + + if (0 != p_txkey) + *p_txkey = txkey; + + txin_gen in; + in.height = height; + tx.vin.push_back(in); + + // This will work, until size of constructed block is less then CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE + std::vector<size_t> block_sizes; + bool block_too_big = false; + uint64_t block_reward = get_block_reward(block_sizes, 0, block_too_big, already_generated_coins) + fee; + if (block_too_big) + { + LOG_PRINT_L0("Block is too big"); + return false; + } + + crypto::key_derivation derivation; + crypto::public_key out_eph_public_key; + crypto::generate_key_derivation(miner_address.m_view_public_key, txkey.sec, derivation); + crypto::derive_public_key(derivation, 0, miner_address.m_spend_public_key, out_eph_public_key); + + tx_out out; + out.amount = block_reward; + out.target = txout_to_key(out_eph_public_key); + tx.vout.push_back(out); + + tx.version = CURRENT_TRANSACTION_VERSION; + tx.unlock_time = height + CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW; + + return true; +} + +bool construct_tx_to_key(const std::vector<test_event_entry>& events, cryptonote::transaction& tx, const block& blk_head, + const cryptonote::account_base& from, const cryptonote::account_base& to, uint64_t amount, + uint64_t fee, size_t nmix) +{ + vector<tx_source_entry> sources; + vector<tx_destination_entry> destinations; + fill_tx_sources_and_destinations(events, blk_head, from, to, amount, fee, nmix, sources, destinations); + + return construct_tx(from.get_keys(), sources, destinations, tx, 0); +} + +transaction construct_tx_with_fee(std::vector<test_event_entry>& events, const block& blk_head, + const account_base& acc_from, const account_base& acc_to, uint64_t amount, uint64_t fee) +{ + transaction tx; + construct_tx_to_key(events, tx, blk_head, acc_from, acc_to, amount, fee, 0); + events.push_back(tx); + return tx; +} + +uint64_t get_balance(const cryptonote::account_base& addr, const std::vector<cryptonote::block>& blockchain, const map_hash2tx_t& mtx) { + uint64_t res = 0; + std::map<uint64_t, std::vector<output_index> > outs; + std::map<uint64_t, std::vector<size_t> > outs_mine; + + map_hash2tx_t confirmed_txs; + get_confirmed_txs(blockchain, mtx, confirmed_txs); + + if (!init_output_indices(outs, outs_mine, blockchain, confirmed_txs, addr)) + return false; + + if (!init_spent_output_indices(outs, outs_mine, blockchain, confirmed_txs, addr)) + return false; + + BOOST_FOREACH (const map_output_t::value_type &o, outs_mine) { + for (size_t i = 0; i < o.second.size(); ++i) { + if (outs[o.first][o.second[i]].spent) + continue; + + res += outs[o.first][o.second[i]].amount; + } + } + + return res; +} + +void get_confirmed_txs(const std::vector<cryptonote::block>& blockchain, const map_hash2tx_t& mtx, map_hash2tx_t& confirmed_txs) +{ + std::unordered_set<crypto::hash> confirmed_hashes; + BOOST_FOREACH(const block& blk, blockchain) + { + BOOST_FOREACH(const crypto::hash& tx_hash, blk.tx_hashes) + { + confirmed_hashes.insert(tx_hash); + } + } + + BOOST_FOREACH(const auto& tx_pair, mtx) + { + if (0 != confirmed_hashes.count(tx_pair.first)) + { + confirmed_txs.insert(tx_pair); + } + } +} + +bool find_block_chain(const std::vector<test_event_entry>& events, std::vector<cryptonote::block>& blockchain, map_hash2tx_t& mtx, const crypto::hash& head) { + std::unordered_map<crypto::hash, const block*> block_index; + BOOST_FOREACH(const test_event_entry& ev, events) + { + if (typeid(block) == ev.type()) + { + const block* blk = &boost::get<block>(ev); + block_index[get_block_hash(*blk)] = blk; + } + else if (typeid(transaction) == ev.type()) + { + const transaction& tx = boost::get<transaction>(ev); + mtx[get_transaction_hash(tx)] = &tx; + } + } + + bool b_success = false; + crypto::hash id = head; + for (auto it = block_index.find(id); block_index.end() != it; it = block_index.find(id)) + { + blockchain.push_back(*it->second); + id = it->second->prev_id; + if (null_hash == id) + { + b_success = true; + break; + } + } + reverse(blockchain.begin(), blockchain.end()); + + return b_success; +} + + +void test_chain_unit_base::register_callback(const std::string& cb_name, verify_callback cb) +{ + m_callbacks[cb_name] = cb; +} +bool test_chain_unit_base::verify(const std::string& cb_name, cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events) +{ + auto cb_it = m_callbacks.find(cb_name); + if(cb_it == m_callbacks.end()) + { + LOG_ERROR("Failed to find callback " << cb_name); + return false; + } + return cb_it->second(c, ev_index, events); +} diff --git a/tests/core_tests/chaingen.h b/tests/core_tests/chaingen.h new file mode 100644 index 000000000..3d47edeef --- /dev/null +++ b/tests/core_tests/chaingen.h @@ -0,0 +1,646 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#pragma once + +#include <vector> +#include <iostream> +#include <stdint.h> + +#include <boost/archive/binary_oarchive.hpp> +#include <boost/archive/binary_iarchive.hpp> +#include <boost/program_options.hpp> +#include <boost/serialization/vector.hpp> +#include <boost/serialization/variant.hpp> + +#include "include_base_utils.h" +#include "common/boost_serialization_helper.h" +#include "common/command_line.h" + +#include "cryptonote_core/account_boost_serialization.h" +#include "cryptonote_core/cryptonote_basic.h" +#include "cryptonote_core/cryptonote_basic_impl.h" +#include "cryptonote_core/cryptonote_format_utils.h" +#include "cryptonote_core/cryptonote_core.h" +#include "cryptonote_core/cryptonote_boost_serialization.h" +#include "misc_language.h" + + +namespace concolor +{ + inline std::basic_ostream<char, std::char_traits<char> >& bright_white(std::basic_ostream<char, std::char_traits<char> >& ostr) + { + epee::log_space::set_console_color(epee::log_space::console_color_white, true); + return ostr; + } + + inline std::basic_ostream<char, std::char_traits<char> >& red(std::basic_ostream<char, std::char_traits<char> >& ostr) + { + epee::log_space::set_console_color(epee::log_space::console_color_red, true); + return ostr; + } + + inline std::basic_ostream<char, std::char_traits<char> >& green(std::basic_ostream<char, std::char_traits<char> >& ostr) + { + epee::log_space::set_console_color(epee::log_space::console_color_green, true); + return ostr; + } + + inline std::basic_ostream<char, std::char_traits<char> >& magenta(std::basic_ostream<char, std::char_traits<char> >& ostr) + { + epee::log_space::set_console_color(epee::log_space::console_color_magenta, true); + return ostr; + } + + inline std::basic_ostream<char, std::char_traits<char> >& yellow(std::basic_ostream<char, std::char_traits<char> >& ostr) + { + epee::log_space::set_console_color(epee::log_space::console_color_yellow, true); + return ostr; + } + + inline std::basic_ostream<char, std::char_traits<char> >& normal(std::basic_ostream<char, std::char_traits<char> >& ostr) + { + epee::log_space::reset_console_color(); + return ostr; + } +} + + +struct callback_entry +{ + std::string callback_name; + BEGIN_SERIALIZE_OBJECT() + FIELD(callback_name) + END_SERIALIZE() + +private: + friend class boost::serialization::access; + + template<class Archive> + void serialize(Archive & ar, const unsigned int /*version*/) + { + ar & callback_name; + } +}; + +template<typename T> +struct serialized_object +{ + serialized_object() { } + + serialized_object(const cryptonote::blobdata& a_data) + : data(a_data) + { + } + + cryptonote::blobdata data; + BEGIN_SERIALIZE_OBJECT() + FIELD(data) + END_SERIALIZE() + +private: + friend class boost::serialization::access; + + template<class Archive> + void serialize(Archive & ar, const unsigned int /*version*/) + { + ar & data; + } +}; + +typedef serialized_object<cryptonote::block> serialized_block; +typedef serialized_object<cryptonote::transaction> serialized_transaction; + +struct event_visitor_settings +{ + int valid_mask; + bool txs_keeped_by_block; + + enum settings + { + set_txs_keeped_by_block = 1 << 0 + }; + + event_visitor_settings(int a_valid_mask = 0, bool a_txs_keeped_by_block = false) + : valid_mask(a_valid_mask) + , txs_keeped_by_block(a_txs_keeped_by_block) + { + } + +private: + friend class boost::serialization::access; + + template<class Archive> + void serialize(Archive & ar, const unsigned int /*version*/) + { + ar & valid_mask; + ar & txs_keeped_by_block; + } +}; + +VARIANT_TAG(binary_archive, callback_entry, 0xcb); +VARIANT_TAG(binary_archive, cryptonote::account_base, 0xcc); +VARIANT_TAG(binary_archive, serialized_block, 0xcd); +VARIANT_TAG(binary_archive, serialized_transaction, 0xce); +VARIANT_TAG(binary_archive, event_visitor_settings, 0xcf); + +typedef boost::variant<cryptonote::block, cryptonote::transaction, cryptonote::account_base, callback_entry, serialized_block, serialized_transaction, event_visitor_settings> test_event_entry; +typedef std::unordered_map<crypto::hash, const cryptonote::transaction*> map_hash2tx_t; + +class test_chain_unit_base +{ +public: + typedef boost::function<bool (cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events)> verify_callback; + typedef std::map<std::string, verify_callback> callbacks_map; + + void register_callback(const std::string& cb_name, verify_callback cb); + bool verify(const std::string& cb_name, cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events); +private: + callbacks_map m_callbacks; +}; + + +class test_generator +{ +public: + struct block_info + { + block_info() + : prev_id() + , already_generated_coins(0) + , block_size(0) + { + } + + block_info(crypto::hash a_prev_id, uint64_t an_already_generated_coins, size_t a_block_size) + : prev_id(a_prev_id) + , already_generated_coins(an_already_generated_coins) + , block_size(a_block_size) + { + } + + crypto::hash prev_id; + uint64_t already_generated_coins; + size_t block_size; + }; + + enum block_fields + { + bf_none = 0, + bf_major_ver = 1 << 0, + bf_minor_ver = 1 << 1, + bf_timestamp = 1 << 2, + bf_prev_id = 1 << 3, + bf_miner_tx = 1 << 4, + bf_tx_hashes = 1 << 5, + bf_diffic = 1 << 6 + }; + + void get_block_chain(std::vector<block_info>& blockchain, const crypto::hash& head, size_t n) const; + void get_last_n_block_sizes(std::vector<size_t>& block_sizes, const crypto::hash& head, size_t n) const; + uint64_t get_already_generated_coins(const crypto::hash& blk_id) const; + uint64_t get_already_generated_coins(const cryptonote::block& blk) const; + + void add_block(const cryptonote::block& blk, size_t tsx_size, std::vector<size_t>& block_sizes, uint64_t already_generated_coins); + bool construct_block(cryptonote::block& blk, uint64_t height, const crypto::hash& prev_id, + const cryptonote::account_base& miner_acc, uint64_t timestamp, uint64_t already_generated_coins, + std::vector<size_t>& block_sizes, const std::list<cryptonote::transaction>& tx_list); + bool construct_block(cryptonote::block& blk, const cryptonote::account_base& miner_acc, uint64_t timestamp); + bool construct_block(cryptonote::block& blk, const cryptonote::block& blk_prev, const cryptonote::account_base& miner_acc, + const std::list<cryptonote::transaction>& tx_list = std::list<cryptonote::transaction>()); + + bool construct_block_manually(cryptonote::block& blk, const cryptonote::block& prev_block, + const cryptonote::account_base& miner_acc, int actual_params = bf_none, uint8_t major_ver = 0, + uint8_t minor_ver = 0, uint64_t timestamp = 0, const crypto::hash& prev_id = crypto::hash(), + const cryptonote::difficulty_type& diffic = 1, const cryptonote::transaction& miner_tx = cryptonote::transaction(), + const std::vector<crypto::hash>& tx_hashes = std::vector<crypto::hash>(), size_t txs_sizes = 0); + bool construct_block_manually_tx(cryptonote::block& blk, const cryptonote::block& prev_block, + const cryptonote::account_base& miner_acc, const std::vector<crypto::hash>& tx_hashes, size_t txs_size); + +private: + std::unordered_map<crypto::hash, block_info> m_blocks_info; +}; + +inline cryptonote::difficulty_type get_test_difficulty() {return 1;} +void fill_nonce(cryptonote::block& blk, const cryptonote::difficulty_type& diffic, uint64_t height); + +bool construct_miner_tx_manually(size_t height, uint64_t already_generated_coins, + const cryptonote::account_public_address& miner_address, cryptonote::transaction& tx, + uint64_t fee, cryptonote::keypair* p_txkey = 0); +bool construct_tx_to_key(const std::vector<test_event_entry>& events, cryptonote::transaction& tx, + const cryptonote::block& blk_head, const cryptonote::account_base& from, const cryptonote::account_base& to, + uint64_t amount, uint64_t fee, size_t nmix); +cryptonote::transaction construct_tx_with_fee(std::vector<test_event_entry>& events, const cryptonote::block& blk_head, + const cryptonote::account_base& acc_from, const cryptonote::account_base& acc_to, + uint64_t amount, uint64_t fee); + +void get_confirmed_txs(const std::vector<cryptonote::block>& blockchain, const map_hash2tx_t& mtx, map_hash2tx_t& confirmed_txs); +bool find_block_chain(const std::vector<test_event_entry>& events, std::vector<cryptonote::block>& blockchain, map_hash2tx_t& mtx, const crypto::hash& head); +void fill_tx_sources_and_destinations(const std::vector<test_event_entry>& events, const cryptonote::block& blk_head, + const cryptonote::account_base& from, const cryptonote::account_base& to, + uint64_t amount, uint64_t fee, size_t nmix, + std::vector<cryptonote::tx_source_entry>& sources, + std::vector<cryptonote::tx_destination_entry>& destinations); +uint64_t get_balance(const cryptonote::account_base& addr, const std::vector<cryptonote::block>& blockchain, const map_hash2tx_t& mtx); + +//-------------------------------------------------------------------------- +template<class t_test_class> +auto do_check_tx_verification_context(const cryptonote::tx_verification_context& tvc, bool tx_added, size_t event_index, const cryptonote::transaction& tx, t_test_class& validator, int) + -> decltype(validator.check_tx_verification_context(tvc, tx_added, event_index, tx)) +{ + return validator.check_tx_verification_context(tvc, tx_added, event_index, tx); +} +//-------------------------------------------------------------------------- +template<class t_test_class> +bool do_check_tx_verification_context(const cryptonote::tx_verification_context& tvc, bool tx_added, size_t /*event_index*/, const cryptonote::transaction& /*tx*/, t_test_class&, long) +{ + // Default block verification context check + if (tvc.m_verifivation_failed) + throw std::runtime_error("Transaction verification failed"); + return true; +} +//-------------------------------------------------------------------------- +template<class t_test_class> +bool check_tx_verification_context(const cryptonote::tx_verification_context& tvc, bool tx_added, size_t event_index, const cryptonote::transaction& tx, t_test_class& validator) +{ + // SFINAE in action + return do_check_tx_verification_context(tvc, tx_added, event_index, tx, validator, 0); +} +//-------------------------------------------------------------------------- +template<class t_test_class> +auto do_check_block_verification_context(const cryptonote::block_verification_context& bvc, size_t event_index, const cryptonote::block& blk, t_test_class& validator, int) + -> decltype(validator.check_block_verification_context(bvc, event_index, blk)) +{ + return validator.check_block_verification_context(bvc, event_index, blk); +} +//-------------------------------------------------------------------------- +template<class t_test_class> +bool do_check_block_verification_context(const cryptonote::block_verification_context& bvc, size_t /*event_index*/, const cryptonote::block& /*blk*/, t_test_class&, long) +{ + // Default block verification context check + if (bvc.m_verifivation_failed) + throw std::runtime_error("Block verification failed"); + return true; +} +//-------------------------------------------------------------------------- +template<class t_test_class> +bool check_block_verification_context(const cryptonote::block_verification_context& bvc, size_t event_index, const cryptonote::block& blk, t_test_class& validator) +{ + // SFINAE in action + return do_check_block_verification_context(bvc, event_index, blk, validator, 0); +} + +/************************************************************************/ +/* */ +/************************************************************************/ +template<class t_test_class> +struct push_core_event_visitor: public boost::static_visitor<bool> +{ +private: + cryptonote::core& m_c; + const std::vector<test_event_entry>& m_events; + t_test_class& m_validator; + size_t m_ev_index; + + bool m_txs_keeped_by_block; + +public: + push_core_event_visitor(cryptonote::core& c, const std::vector<test_event_entry>& events, t_test_class& validator) + : m_c(c) + , m_events(events) + , m_validator(validator) + , m_ev_index(0) + , m_txs_keeped_by_block(false) + { + } + + void event_index(size_t ev_index) + { + m_ev_index = ev_index; + } + + bool operator()(const event_visitor_settings& settings) + { + log_event("event_visitor_settings"); + + if (settings.valid_mask & event_visitor_settings::set_txs_keeped_by_block) + { + m_txs_keeped_by_block = settings.txs_keeped_by_block; + } + + return true; + } + + bool operator()(const cryptonote::transaction& tx) const + { + log_event("cryptonote::transaction"); + + cryptonote::tx_verification_context tvc = AUTO_VAL_INIT(tvc); + size_t pool_size = m_c.get_pool_transactions_count(); + m_c.handle_incoming_tx(t_serializable_object_to_blob(tx), tvc, m_txs_keeped_by_block); + bool tx_added = pool_size + 1 == m_c.get_pool_transactions_count(); + bool r = check_tx_verification_context(tvc, tx_added, m_ev_index, tx, m_validator); + CHECK_AND_NO_ASSERT_MES(r, false, "tx verification context check failed"); + return true; + } + + bool operator()(const cryptonote::block& b) const + { + log_event("cryptonote::block"); + + cryptonote::block_verification_context bvc = AUTO_VAL_INIT(bvc); + m_c.handle_incoming_block(t_serializable_object_to_blob(b), bvc); + bool r = check_block_verification_context(bvc, m_ev_index, b, m_validator); + CHECK_AND_NO_ASSERT_MES(r, false, "block verification context check failed"); + return r; + } + + bool operator()(const callback_entry& cb) const + { + log_event(std::string("callback_entry ") + cb.callback_name); + return m_validator.verify(cb.callback_name, m_c, m_ev_index, m_events); + } + + bool operator()(const cryptonote::account_base& ab) const + { + log_event("cryptonote::account_base"); + return true; + } + + bool operator()(const serialized_block& sr_block) const + { + log_event("serialized_block"); + + cryptonote::block_verification_context bvc = AUTO_VAL_INIT(bvc); + m_c.handle_incoming_block(sr_block.data, bvc); + + cryptonote::block blk; + std::stringstream ss; + ss << sr_block.data; + binary_archive<false> ba(ss); + ::serialization::serialize(ba, blk); + if (!ss.good()) + { + blk = cryptonote::block(); + } + bool r = check_block_verification_context(bvc, m_ev_index, blk, m_validator); + CHECK_AND_NO_ASSERT_MES(r, false, "block verification context check failed"); + return true; + } + + bool operator()(const serialized_transaction& sr_tx) const + { + log_event("serialized_transaction"); + + cryptonote::tx_verification_context tvc = AUTO_VAL_INIT(tvc); + size_t pool_size = m_c.get_pool_transactions_count(); + m_c.handle_incoming_tx(sr_tx.data, tvc, m_txs_keeped_by_block); + bool tx_added = pool_size + 1 == m_c.get_pool_transactions_count(); + + cryptonote::transaction tx; + std::stringstream ss; + ss << sr_tx.data; + binary_archive<false> ba(ss); + ::serialization::serialize(ba, tx); + if (!ss.good()) + { + tx = cryptonote::transaction(); + } + + bool r = check_tx_verification_context(tvc, tx_added, m_ev_index, tx, m_validator); + CHECK_AND_NO_ASSERT_MES(r, false, "transaction verification context check failed"); + return true; + } + +private: + void log_event(const std::string& event_type) const + { + std::cout << concolor::yellow << "=== EVENT # " << m_ev_index << ": " << event_type << concolor::normal << std::endl; + } +}; +//-------------------------------------------------------------------------- +template<class t_test_class> +inline bool replay_events_through_core(cryptonote::core& cr, const std::vector<test_event_entry>& events, t_test_class& validator) +{ + TRY_ENTRY(); + + //init core here + + CHECK_AND_ASSERT_MES(typeid(cryptonote::block) == events[0].type(), false, "First event must be genesis block creation"); + cr.set_genesis_block(boost::get<cryptonote::block>(events[0])); + + bool r = true; + push_core_event_visitor<t_test_class> visitor(cr, events, validator); + for(size_t i = 1; i < events.size() && r; ++i) + { + visitor.event_index(i); + r = boost::apply_visitor(visitor, events[i]); + } + + return r; + + CATCH_ENTRY_L0("replay_events_through_core", false); +} +//-------------------------------------------------------------------------- +template<class t_test_class> +inline bool do_replay_events(std::vector<test_event_entry>& events) +{ + boost::program_options::options_description desc("Allowed options"); + cryptonote::core::init_options(desc); + command_line::add_arg(desc, command_line::arg_data_dir); + boost::program_options::variables_map vm; + bool r = command_line::handle_error_helper(desc, [&]() + { + boost::program_options::store(boost::program_options::basic_parsed_options<char>(&desc), vm); + boost::program_options::notify(vm); + return true; + }); + if (!r) + return false; + + cryptonote::cryptonote_protocol_stub pr; //TODO: stub only for this kind of test, make real validation of relayed objects + cryptonote::core c(&pr); + if (!c.init(vm)) + { + std::cout << concolor::magenta << "Failed to init core" << concolor::normal << std::endl; + return false; + } + t_test_class validator; + return replay_events_through_core<t_test_class>(c, events, validator); +} +//-------------------------------------------------------------------------- +template<class t_test_class> +inline bool do_replay_file(const std::string& filename) +{ + std::vector<test_event_entry> events; + if (!tools::unserialize_obj_from_file(events, filename)) + { + std::cout << concolor::magenta << "Failed to deserialize data from file: " << filename << concolor::normal << std::endl; + return false; + } + return do_replay_events<t_test_class>(events); +} +//-------------------------------------------------------------------------- +#define GENERATE_ACCOUNT(account) \ + cryptonote::account_base account; \ + account.generate(); + +#define MAKE_ACCOUNT(VEC_EVENTS, account) \ + cryptonote::account_base account; \ + account.generate(); \ + VEC_EVENTS.push_back(account); + +#define DO_CALLBACK(VEC_EVENTS, CB_NAME) \ +{ \ + callback_entry CALLBACK_ENTRY; \ + CALLBACK_ENTRY.callback_name = CB_NAME; \ + VEC_EVENTS.push_back(CALLBACK_ENTRY); \ +} + +#define REGISTER_CALLBACK(CB_NAME, CLBACK) \ + register_callback(CB_NAME, boost::bind(&CLBACK, this, _1, _2, _3)); + +#define REGISTER_CALLBACK_METHOD(CLASS, METHOD) \ + register_callback(#METHOD, boost::bind(&CLASS::METHOD, this, _1, _2, _3)); + +#define MAKE_GENESIS_BLOCK(VEC_EVENTS, BLK_NAME, MINER_ACC, TS) \ + test_generator generator; \ + cryptonote::block BLK_NAME; \ + generator.construct_block(BLK_NAME, MINER_ACC, TS); \ + VEC_EVENTS.push_back(BLK_NAME); + +#define MAKE_NEXT_BLOCK(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC) \ + cryptonote::block BLK_NAME; \ + generator.construct_block(BLK_NAME, PREV_BLOCK, MINER_ACC); \ + VEC_EVENTS.push_back(BLK_NAME); + +#define MAKE_NEXT_BLOCK_TX1(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC, TX1) \ + cryptonote::block BLK_NAME; \ + { \ + std::list<cryptonote::transaction> tx_list; \ + tx_list.push_back(TX1); \ + generator.construct_block(BLK_NAME, PREV_BLOCK, MINER_ACC, tx_list); \ + } \ + VEC_EVENTS.push_back(BLK_NAME); + +#define MAKE_NEXT_BLOCK_TX_LIST(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC, TXLIST) \ + cryptonote::block BLK_NAME; \ + generator.construct_block(BLK_NAME, PREV_BLOCK, MINER_ACC, TXLIST); \ + VEC_EVENTS.push_back(BLK_NAME); + +#define REWIND_BLOCKS_N(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC, COUNT) \ + cryptonote::block BLK_NAME; \ + { \ + cryptonote::block blk_last = PREV_BLOCK; \ + for (size_t i = 0; i < COUNT; ++i) \ + { \ + MAKE_NEXT_BLOCK(VEC_EVENTS, blk, blk_last, MINER_ACC); \ + blk_last = blk; \ + } \ + BLK_NAME = blk_last; \ + } + +#define REWIND_BLOCKS(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC) REWIND_BLOCKS_N(VEC_EVENTS, BLK_NAME, PREV_BLOCK, MINER_ACC, CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW) + +#define MAKE_TX_MIX(VEC_EVENTS, TX_NAME, FROM, TO, AMOUNT, NMIX, HEAD) \ + cryptonote::transaction TX_NAME; \ + construct_tx_to_key(VEC_EVENTS, TX_NAME, HEAD, FROM, TO, AMOUNT, TESTS_DEFAULT_FEE, NMIX); \ + VEC_EVENTS.push_back(TX_NAME); + +#define MAKE_TX(VEC_EVENTS, TX_NAME, FROM, TO, AMOUNT, HEAD) MAKE_TX_MIX(VEC_EVENTS, TX_NAME, FROM, TO, AMOUNT, 0, HEAD) + +#define MAKE_TX_MIX_LIST(VEC_EVENTS, SET_NAME, FROM, TO, AMOUNT, NMIX, HEAD) \ + { \ + cryptonote::transaction t; \ + construct_tx_to_key(VEC_EVENTS, t, HEAD, FROM, TO, AMOUNT, TESTS_DEFAULT_FEE, NMIX); \ + SET_NAME.push_back(t); \ + VEC_EVENTS.push_back(t); \ + } + +#define MAKE_TX_LIST(VEC_EVENTS, SET_NAME, FROM, TO, AMOUNT, HEAD) MAKE_TX_MIX_LIST(VEC_EVENTS, SET_NAME, FROM, TO, AMOUNT, 0, HEAD) + +#define MAKE_TX_LIST_START(VEC_EVENTS, SET_NAME, FROM, TO, AMOUNT, HEAD) \ + std::list<cryptonote::transaction> SET_NAME; \ + MAKE_TX_LIST(VEC_EVENTS, SET_NAME, FROM, TO, AMOUNT, HEAD); + +#define MAKE_MINER_TX_AND_KEY_MANUALLY(TX, BLK, KEY) \ + transaction TX; \ + if (!construct_miner_tx_manually(get_block_height(BLK) + 1, generator.get_already_generated_coins(BLK), \ + miner_account.get_keys().m_account_address, TX, 0, KEY)) \ + return false; + +#define MAKE_MINER_TX_MANUALLY(TX, BLK) MAKE_MINER_TX_AND_KEY_MANUALLY(TX, BLK, 0) + +#define SET_EVENT_VISITOR_SETT(VEC_EVENTS, SETT, VAL) VEC_EVENTS.push_back(event_visitor_settings(SETT, VAL)); + +#define GENERATE(filename, genclass) \ + { \ + std::vector<test_event_entry> events; \ + genclass g; \ + g.generate(events); \ + if (!tools::serialize_obj_to_file(events, filename)) \ + { \ + std::cout << concolor::magenta << "Failed to serialize data to file: " << filename << concolor::normal << std::endl; \ + throw std::runtime_error("Failed to serialize data to file"); \ + } \ + } + + +#define PLAY(filename, genclass) \ + if(!do_replay_file<genclass>(filename)) \ + { \ + std::cout << concolor::magenta << "Failed to pass test : " << #genclass << concolor::normal << std::endl; \ + return 1; \ + } + +#define GENERATE_AND_PLAY(genclass) \ + { \ + std::vector<test_event_entry> events; \ + ++tests_count; \ + bool generated = false; \ + try \ + { \ + genclass g; \ + generated = g.generate(events);; \ + } \ + catch (const std::exception& ex) \ + { \ + LOG_PRINT(#genclass << " generation failed: what=" << ex.what(), 0); \ + } \ + catch (...) \ + { \ + LOG_PRINT(#genclass << " generation failed: generic exception", 0); \ + } \ + if (generated && do_replay_events< genclass >(events)) \ + { \ + std::cout << concolor::green << "#TEST# Succeeded " << #genclass << concolor::normal << '\n'; \ + } \ + else \ + { \ + std::cout << concolor::magenta << "#TEST# Failed " << #genclass << concolor::normal << '\n'; \ + failed_tests.push_back(#genclass); \ + } \ + std::cout << std::endl; \ + } + +#define CALL_TEST(test_name, function) \ + { \ + if(!function()) \ + { \ + std::cout << concolor::magenta << "#TEST# Failed " << test_name << concolor::normal << std::endl; \ + return 1; \ + } \ + else \ + { \ + std::cout << concolor::green << "#TEST# Succeeded " << test_name << concolor::normal << std::endl; \ + } \ + } + +#define QUOTEME(x) #x +#define DEFINE_TESTS_ERROR_CONTEXT(text) const char* perr_context = text; +#define CHECK_TEST_CONDITION(cond) CHECK_AND_ASSERT_MES(cond, false, "[" << perr_context << "] failed: \"" << QUOTEME(cond) << "\"") +#define CHECK_EQ(v1, v2) CHECK_AND_ASSERT_MES(v1 == v2, false, "[" << perr_context << "] failed: \"" << QUOTEME(v1) << " == " << QUOTEME(v2) << "\", " << v1 << " != " << v2) +#define CHECK_NOT_EQ(v1, v2) CHECK_AND_ASSERT_MES(!(v1 == v2), false, "[" << perr_context << "] failed: \"" << QUOTEME(v1) << " != " << QUOTEME(v2) << "\", " << v1 << " == " << v2) +#define MK_COINS(amount) (UINT64_C(amount) * COIN) +#define TESTS_DEFAULT_FEE ((uint64_t)1000000) // pow(10, 6) diff --git a/tests/core_tests/chaingen001.cpp b/tests/core_tests/chaingen001.cpp new file mode 100644 index 000000000..f79420e69 --- /dev/null +++ b/tests/core_tests/chaingen001.cpp @@ -0,0 +1,135 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include <vector> +#include <iostream> + +#include "include_base_utils.h" + +#include "console_handler.h" + +#include "cryptonote_core/cryptonote_basic.h" +#include "cryptonote_core/cryptonote_format_utils.h" + +#include "chaingen.h" +#include "chaingen_tests_list.h" + +using namespace std; + +using namespace epee; +using namespace cryptonote; + +//////// +// class one_block; + +one_block::one_block() +{ + REGISTER_CALLBACK("verify_1", one_block::verify_1); +} + +bool one_block::generate(std::vector<test_event_entry> &events) +{ + uint64_t ts_start = 1338224400; + + MAKE_GENESIS_BLOCK(events, blk_0, alice, ts_start); + MAKE_ACCOUNT(events, alice); + DO_CALLBACK(events, "verify_1"); + + return true; +} + +bool one_block::verify_1(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events) +{ + DEFINE_TESTS_ERROR_CONTEXT("one_block::verify_1"); + + alice = boost::get<cryptonote::account_base>(events[1]); + + // check balances + //std::vector<const cryptonote::block*> chain; + //map_hash2tx_t mtx; + //CHECK_TEST_CONDITION(find_block_chain(events, chain, mtx, get_block_hash(boost::get<cryptonote::block>(events[1])))); + //CHECK_TEST_CONDITION(get_block_reward(0) == get_balance(alice, events, chain, mtx)); + + // check height + std::list<cryptonote::block> blocks; + std::list<crypto::public_key> outs; + bool r = c.get_blocks(0, 100, blocks); + //c.get_outs(100, outs); + CHECK_TEST_CONDITION(r); + CHECK_TEST_CONDITION(blocks.size() == 1); + //CHECK_TEST_CONDITION(outs.size() == blocks.size()); + CHECK_TEST_CONDITION(c.get_blockchain_total_transactions() == 1); + CHECK_TEST_CONDITION(blocks.back() == boost::get<cryptonote::block>(events[0])); + + return true; +} + + +//////// +// class gen_simple_chain_001; + +gen_simple_chain_001::gen_simple_chain_001() +{ + REGISTER_CALLBACK("verify_callback_1", gen_simple_chain_001::verify_callback_1); + REGISTER_CALLBACK("verify_callback_2", gen_simple_chain_001::verify_callback_2); +} + +bool gen_simple_chain_001::generate(std::vector<test_event_entry> &events) +{ + uint64_t ts_start = 1338224400; + + GENERATE_ACCOUNT(miner); + GENERATE_ACCOUNT(alice); + + MAKE_GENESIS_BLOCK(events, blk_0, miner, ts_start); + MAKE_NEXT_BLOCK(events, blk_1, blk_0, miner); + MAKE_NEXT_BLOCK(events, blk_1_side, blk_0, miner); + MAKE_NEXT_BLOCK(events, blk_2, blk_1, miner); + //MAKE_TX(events, tx_0, first_miner_account, alice, 151, blk_2); + + std::vector<cryptonote::block> chain; + map_hash2tx_t mtx; + /*bool r = */find_block_chain(events, chain, mtx, get_block_hash(boost::get<cryptonote::block>(events[3]))); + std::cout << "BALANCE = " << get_balance(miner, chain, mtx) << std::endl; + + REWIND_BLOCKS(events, blk_2r, blk_2, miner); + MAKE_TX_LIST_START(events, txlist_0, miner, alice, MK_COINS(1), blk_2); + MAKE_TX_LIST(events, txlist_0, miner, alice, MK_COINS(2), blk_2); + MAKE_TX_LIST(events, txlist_0, miner, alice, MK_COINS(4), blk_2); + MAKE_NEXT_BLOCK_TX_LIST(events, blk_3, blk_2r, miner, txlist_0); + REWIND_BLOCKS(events, blk_3r, blk_3, miner); + MAKE_TX(events, tx_1, miner, alice, MK_COINS(50), blk_3); + MAKE_NEXT_BLOCK_TX1(events, blk_4, blk_3r, miner, tx_1); + REWIND_BLOCKS(events, blk_4r, blk_4, miner); + MAKE_TX(events, tx_2, miner, alice, MK_COINS(50), blk_4); + MAKE_NEXT_BLOCK_TX1(events, blk_5, blk_4r, miner, tx_2); + REWIND_BLOCKS(events, blk_5r, blk_5, miner); + MAKE_TX(events, tx_3, miner, alice, MK_COINS(50), blk_5); + MAKE_NEXT_BLOCK_TX1(events, blk_6, blk_5r, miner, tx_3); + + DO_CALLBACK(events, "verify_callback_1"); + //e.t.c. + //MAKE_BLOCK_TX1(events, blk_3, 3, get_block_hash(blk_0), get_test_target(), first_miner_account, ts_start + 10, tx_0); + //MAKE_BLOCK_TX1(events, blk_3, 3, get_block_hash(blk_0), get_test_target(), first_miner_account, ts_start + 10, tx_0); + //DO_CALLBACK(events, "verify_callback_2"); + +/* std::vector<const cryptonote::block*> chain; + map_hash2tx_t mtx; + if (!find_block_chain(events, chain, mtx, get_block_hash(blk_6))) + throw; + cout << "miner = " << get_balance(first_miner_account, events, chain, mtx) << endl; + cout << "alice = " << get_balance(alice, events, chain, mtx) << endl;*/ + + return true; +} + +bool gen_simple_chain_001::verify_callback_1(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events) +{ + return true; +} + +bool gen_simple_chain_001::verify_callback_2(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events) +{ + return true; +} diff --git a/tests/core_tests/chaingen_main.cpp b/tests/core_tests/chaingen_main.cpp new file mode 100644 index 000000000..c575f9272 --- /dev/null +++ b/tests/core_tests/chaingen_main.cpp @@ -0,0 +1,171 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include "chaingen.h" +#include "chaingen_tests_list.h" +#include "common/command_line.h" +#include "transaction_tests.h" + +namespace po = boost::program_options; + +namespace +{ + const command_line::arg_descriptor<std::string> arg_test_data_path = {"test_data_path", "", ""}; + const command_line::arg_descriptor<bool> arg_generate_test_data = {"generate_test_data", ""}; + const command_line::arg_descriptor<bool> arg_play_test_data = {"play_test_data", ""}; + const command_line::arg_descriptor<bool> arg_generate_and_play_test_data = {"generate_and_play_test_data", ""}; + const command_line::arg_descriptor<bool> arg_test_transactions = {"test_transactions", ""}; +} + +int main(int argc, char* argv[]) +{ + TRY_ENTRY(); + string_tools::set_module_name_and_folder(argv[0]); + + //set up logging options + log_space::get_set_log_detalisation_level(true, LOG_LEVEL_3); + log_space::log_singletone::add_logger(LOGGER_CONSOLE, NULL, NULL, LOG_LEVEL_2); + + log_space::log_singletone::add_logger(LOGGER_FILE, + log_space::log_singletone::get_default_log_file().c_str(), + log_space::log_singletone::get_default_log_folder().c_str()); + + po::options_description desc_options("Allowed options"); + command_line::add_arg(desc_options, command_line::arg_help); + command_line::add_arg(desc_options, arg_test_data_path); + command_line::add_arg(desc_options, arg_generate_test_data); + command_line::add_arg(desc_options, arg_play_test_data); + command_line::add_arg(desc_options, arg_generate_and_play_test_data); + command_line::add_arg(desc_options, arg_test_transactions); + + po::variables_map vm; + bool r = command_line::handle_error_helper(desc_options, [&]() + { + po::store(po::parse_command_line(argc, argv, desc_options), vm); + po::notify(vm); + return true; + }); + if (!r) + return 1; + + if (command_line::get_arg(vm, command_line::arg_help)) + { + std::cout << desc_options << std::endl; + return 0; + } + + size_t tests_count = 0; + std::vector<std::string> failed_tests; + std::string tests_folder = command_line::get_arg(vm, arg_test_data_path); + if (command_line::get_arg(vm, arg_generate_test_data)) + { + GENERATE("chain001.dat", gen_simple_chain_001); + } + else if (command_line::get_arg(vm, arg_play_test_data)) + { + PLAY("chain001.dat", gen_simple_chain_001); + } + else if (command_line::get_arg(vm, arg_generate_and_play_test_data)) + { + GENERATE_AND_PLAY(gen_simple_chain_001); + GENERATE_AND_PLAY(gen_simple_chain_split_1); + GENERATE_AND_PLAY(one_block); + GENERATE_AND_PLAY(gen_chain_switch_1); + GENERATE_AND_PLAY(gen_ring_signature_1); + GENERATE_AND_PLAY(gen_ring_signature_2); + //GENERATE_AND_PLAY(gen_ring_signature_big); // Takes up to XXX hours (if CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW == 10) + + // Block verification tests + GENERATE_AND_PLAY(gen_block_big_major_version); + GENERATE_AND_PLAY(gen_block_big_minor_version); + GENERATE_AND_PLAY(gen_block_ts_not_checked); + GENERATE_AND_PLAY(gen_block_ts_in_past); + GENERATE_AND_PLAY(gen_block_ts_in_future); + GENERATE_AND_PLAY(gen_block_invalid_prev_id); + GENERATE_AND_PLAY(gen_block_invalid_nonce); + GENERATE_AND_PLAY(gen_block_no_miner_tx); + GENERATE_AND_PLAY(gen_block_unlock_time_is_low); + GENERATE_AND_PLAY(gen_block_unlock_time_is_high); + GENERATE_AND_PLAY(gen_block_unlock_time_is_timestamp_in_past); + GENERATE_AND_PLAY(gen_block_unlock_time_is_timestamp_in_future); + GENERATE_AND_PLAY(gen_block_height_is_low); + GENERATE_AND_PLAY(gen_block_height_is_high); + GENERATE_AND_PLAY(gen_block_miner_tx_has_2_tx_gen_in); + GENERATE_AND_PLAY(gen_block_miner_tx_has_2_in); + GENERATE_AND_PLAY(gen_block_miner_tx_with_txin_to_key); + GENERATE_AND_PLAY(gen_block_miner_tx_out_is_small); + GENERATE_AND_PLAY(gen_block_miner_tx_out_is_big); + GENERATE_AND_PLAY(gen_block_miner_tx_has_no_out); + GENERATE_AND_PLAY(gen_block_miner_tx_has_out_to_alice); + GENERATE_AND_PLAY(gen_block_has_invalid_tx); + GENERATE_AND_PLAY(gen_block_is_too_big); + GENERATE_AND_PLAY(gen_block_invalid_binary_format); // Takes up to 3 hours, if CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW == 500, up to 30 minutes, if CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW == 10 + + // Transaction verification tests + GENERATE_AND_PLAY(gen_tx_big_version); + GENERATE_AND_PLAY(gen_tx_unlock_time); + GENERATE_AND_PLAY(gen_tx_input_is_not_txin_to_key); + GENERATE_AND_PLAY(gen_tx_no_inputs_no_outputs); + GENERATE_AND_PLAY(gen_tx_no_inputs_has_outputs); + GENERATE_AND_PLAY(gen_tx_has_inputs_no_outputs); + GENERATE_AND_PLAY(gen_tx_invalid_input_amount); + GENERATE_AND_PLAY(gen_tx_input_wo_key_offsets); + GENERATE_AND_PLAY(gen_tx_sender_key_offest_not_exist); + GENERATE_AND_PLAY(gen_tx_key_offest_points_to_foreign_key); + GENERATE_AND_PLAY(gen_tx_mixed_key_offest_not_exist); + GENERATE_AND_PLAY(gen_tx_key_image_not_derive_from_tx_key); + GENERATE_AND_PLAY(gen_tx_key_image_is_invalid); + GENERATE_AND_PLAY(gen_tx_check_input_unlock_time); + GENERATE_AND_PLAY(gen_tx_txout_to_key_has_invalid_key); + GENERATE_AND_PLAY(gen_tx_output_with_zero_amount); + GENERATE_AND_PLAY(gen_tx_output_is_not_txout_to_key); + GENERATE_AND_PLAY(gen_tx_signatures_are_invalid); + + // Double spend + GENERATE_AND_PLAY(gen_double_spend_in_tx<false>); + GENERATE_AND_PLAY(gen_double_spend_in_tx<true>); + GENERATE_AND_PLAY(gen_double_spend_in_the_same_block<false>); + GENERATE_AND_PLAY(gen_double_spend_in_the_same_block<true>); + GENERATE_AND_PLAY(gen_double_spend_in_different_blocks<false>); + GENERATE_AND_PLAY(gen_double_spend_in_different_blocks<true>); + GENERATE_AND_PLAY(gen_double_spend_in_different_chains); + GENERATE_AND_PLAY(gen_double_spend_in_alt_chain_in_the_same_block<false>); + GENERATE_AND_PLAY(gen_double_spend_in_alt_chain_in_the_same_block<true>); + GENERATE_AND_PLAY(gen_double_spend_in_alt_chain_in_different_blocks<false>); + GENERATE_AND_PLAY(gen_double_spend_in_alt_chain_in_different_blocks<true>); + + GENERATE_AND_PLAY(gen_uint_overflow_1); + GENERATE_AND_PLAY(gen_uint_overflow_2); + + GENERATE_AND_PLAY(gen_block_reward); + + std::cout << (failed_tests.empty() ? concolor::green : concolor::magenta); + std::cout << "\nREPORT:\n"; + std::cout << " Test run: " << tests_count << '\n'; + std::cout << " Failures: " << failed_tests.size() << '\n'; + if (!failed_tests.empty()) + { + std::cout << "FAILED TESTS:\n"; + BOOST_FOREACH(auto test_name, failed_tests) + { + std::cout << " " << test_name << '\n'; + } + } + std::cout << concolor::normal << std::endl; + } + else if (command_line::get_arg(vm, arg_test_transactions)) + { + CALL_TEST("TRANSACTIONS TESTS", test_transactions); + } + else + { + std::cout << concolor::magenta << "Wrong arguments" << concolor::normal << std::endl; + std::cout << desc_options << std::endl; + return 2; + } + + return failed_tests.empty() ? 0 : 1; + + CATCH_ENTRY_L0("main", 1); +} diff --git a/tests/core_tests/chaingen_tests_list.h b/tests/core_tests/chaingen_tests_list.h new file mode 100644 index 000000000..d56f78121 --- /dev/null +++ b/tests/core_tests/chaingen_tests_list.h @@ -0,0 +1,35 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#pragma once + +#include "chaingen.h" +#include "block_reward.h" +#include "block_validation.h" +#include "chain_split_1.h" +#include "chain_switch_1.h" +#include "double_spend.h" +#include "integer_overflow.h" +#include "ring_signature_1.h" +#include "tx_validation.h" +/************************************************************************/ +/* */ +/************************************************************************/ +class gen_simple_chain_001: public test_chain_unit_base +{ +public: + gen_simple_chain_001(); + bool generate(std::vector<test_event_entry> &events); + bool verify_callback_1(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events); + bool verify_callback_2(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events); +}; + +class one_block: public test_chain_unit_base +{ + cryptonote::account_base alice; +public: + one_block(); + bool generate(std::vector<test_event_entry> &events); + bool verify_1(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry> &events); +}; diff --git a/tests/core_tests/double_spend.cpp b/tests/core_tests/double_spend.cpp new file mode 100644 index 000000000..9a007ce26 --- /dev/null +++ b/tests/core_tests/double_spend.cpp @@ -0,0 +1,70 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include "chaingen.h" +#include "chaingen_tests_list.h" + +using namespace epee; +using namespace cryptonote; + + +//====================================================================================================================== + +gen_double_spend_in_different_chains::gen_double_spend_in_different_chains() +{ + REGISTER_CALLBACK_METHOD(gen_double_spend_in_different_chains, check_double_spend); +} + +bool gen_double_spend_in_different_chains::generate(std::vector<test_event_entry>& events) const +{ + INIT_DOUBLE_SPEND_TEST(); + + SET_EVENT_VISITOR_SETT(events, event_visitor_settings::set_txs_keeped_by_block, true); + MAKE_TX(events, tx_1, bob_account, alice_account, send_amount / 2 - TESTS_DEFAULT_FEE, blk_1); + events.pop_back(); + MAKE_TX(events, tx_2, bob_account, alice_account, send_amount - TESTS_DEFAULT_FEE, blk_1); + events.pop_back(); + + // Main chain + events.push_back(tx_1); + MAKE_NEXT_BLOCK_TX1(events, blk_2, blk_1r, miner_account, tx_1); + + // Alternative chain + events.push_back(tx_2); + MAKE_NEXT_BLOCK_TX1(events, blk_3, blk_1r, miner_account, tx_2); + // Switch to alternative chain + MAKE_NEXT_BLOCK(events, blk_4, blk_3, miner_account); + CHECK_AND_NO_ASSERT_MES(expected_blockchain_height == get_block_height(blk_4) + 1, false, "expected_blockchain_height has invalid value"); + + DO_CALLBACK(events, "check_double_spend"); + + return true; +} + +bool gen_double_spend_in_different_chains::check_double_spend(cryptonote::core& c, size_t /*ev_index*/, const std::vector<test_event_entry>& events) +{ + DEFINE_TESTS_ERROR_CONTEXT("gen_double_spend_in_different_chains::check_double_spend"); + + std::list<block> block_list; + bool r = c.get_blocks(0, 100 + 2 * CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW, block_list); + CHECK_TEST_CONDITION(r); + + std::vector<block> blocks(block_list.begin(), block_list.end()); + CHECK_EQ(expected_blockchain_height, blocks.size()); + + CHECK_EQ(1, c.get_pool_transactions_count()); + CHECK_EQ(1, c.get_alternative_blocks_count()); + + cryptonote::account_base bob_account = boost::get<cryptonote::account_base>(events[1]); + cryptonote::account_base alice_account = boost::get<cryptonote::account_base>(events[2]); + + std::vector<cryptonote::block> chain; + map_hash2tx_t mtx; + r = find_block_chain(events, chain, mtx, get_block_hash(blocks.back())); + CHECK_TEST_CONDITION(r); + CHECK_EQ(0, get_balance(bob_account, blocks, mtx)); + CHECK_EQ(send_amount - TESTS_DEFAULT_FEE, get_balance(alice_account, blocks, mtx)); + + return true; +} diff --git a/tests/core_tests/double_spend.h b/tests/core_tests/double_spend.h new file mode 100644 index 000000000..e43cc2ed3 --- /dev/null +++ b/tests/core_tests/double_spend.h @@ -0,0 +1,125 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#pragma once +#include "chaingen.h" + +const size_t invalid_index_value = std::numeric_limits<size_t>::max(); + + +template<class concrete_test> +class gen_double_spend_base : public test_chain_unit_base +{ +public: + static const uint64_t send_amount = MK_COINS(17); + + gen_double_spend_base(); + + bool check_tx_verification_context(const cryptonote::tx_verification_context& tvc, bool tx_added, size_t event_idx, const cryptonote::transaction& tx); + bool check_block_verification_context(const cryptonote::block_verification_context& bvc, size_t event_idx, const cryptonote::block& block); + + bool mark_last_valid_block(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events); + bool mark_invalid_tx(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events); + bool mark_invalid_block(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events); + bool check_double_spend(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events); + +private: + cryptonote::block m_last_valid_block; + size_t m_invalid_tx_index; + size_t m_invalid_block_index; +}; + + +template<bool txs_keeped_by_block> +struct gen_double_spend_in_tx : public gen_double_spend_base< gen_double_spend_in_tx<txs_keeped_by_block> > +{ + static const uint64_t send_amount = MK_COINS(17); + static const bool has_invalid_tx = true; + static const size_t expected_pool_txs_count = 0; + static const uint64_t expected_bob_balance = send_amount; + static const uint64_t expected_alice_balance = 0; + + bool generate(std::vector<test_event_entry>& events) const; +}; + + +template<bool txs_keeped_by_block> +struct gen_double_spend_in_the_same_block : public gen_double_spend_base< gen_double_spend_in_the_same_block<txs_keeped_by_block> > +{ + static const uint64_t send_amount = MK_COINS(17); + static const bool has_invalid_tx = !txs_keeped_by_block; + static const size_t expected_pool_txs_count = has_invalid_tx ? 1 : 2; + static const uint64_t expected_bob_balance = send_amount; + static const uint64_t expected_alice_balance = 0; + + bool generate(std::vector<test_event_entry>& events) const; +}; + + +template<bool txs_keeped_by_block> +struct gen_double_spend_in_different_blocks : public gen_double_spend_base< gen_double_spend_in_different_blocks<txs_keeped_by_block> > +{ + static const uint64_t send_amount = MK_COINS(17); + static const bool has_invalid_tx = !txs_keeped_by_block; + static const size_t expected_pool_txs_count = has_invalid_tx ? 0 : 1; + static const uint64_t expected_bob_balance = 0; + static const uint64_t expected_alice_balance = send_amount - TESTS_DEFAULT_FEE; + + bool generate(std::vector<test_event_entry>& events) const; +}; + + +template<bool txs_keeped_by_block> +struct gen_double_spend_in_alt_chain_in_the_same_block : public gen_double_spend_base< gen_double_spend_in_alt_chain_in_the_same_block<txs_keeped_by_block> > +{ + static const uint64_t send_amount = MK_COINS(17); + static const bool has_invalid_tx = !txs_keeped_by_block; + static const size_t expected_pool_txs_count = has_invalid_tx ? 1 : 2; + static const uint64_t expected_bob_balance = send_amount; + static const uint64_t expected_alice_balance = 0; + + bool generate(std::vector<test_event_entry>& events) const; +}; + + +template<bool txs_keeped_by_block> +struct gen_double_spend_in_alt_chain_in_different_blocks : public gen_double_spend_base< gen_double_spend_in_alt_chain_in_different_blocks<txs_keeped_by_block> > +{ + static const uint64_t send_amount = MK_COINS(17); + static const bool has_invalid_tx = !txs_keeped_by_block; + static const size_t expected_pool_txs_count = has_invalid_tx ? 1 : 2; + static const uint64_t expected_bob_balance = send_amount; + static const uint64_t expected_alice_balance = 0; + + bool generate(std::vector<test_event_entry>& events) const; +}; + + +class gen_double_spend_in_different_chains : public test_chain_unit_base +{ +public: + static const uint64_t send_amount = MK_COINS(17); + static const size_t expected_blockchain_height = 4 + 2 * CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW; + + gen_double_spend_in_different_chains(); + + bool generate(std::vector<test_event_entry>& events) const; + + bool check_double_spend(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events); +}; + + +#define INIT_DOUBLE_SPEND_TEST() \ + uint64_t ts_start = 1338224400; \ + GENERATE_ACCOUNT(miner_account); \ + MAKE_GENESIS_BLOCK(events, blk_0, miner_account, ts_start); \ + MAKE_ACCOUNT(events, bob_account); \ + MAKE_ACCOUNT(events, alice_account); \ + REWIND_BLOCKS(events, blk_0r, blk_0, miner_account); \ + MAKE_TX(events, tx_0, miner_account, bob_account, send_amount, blk_0); \ + MAKE_NEXT_BLOCK_TX1(events, blk_1, blk_0r, miner_account, tx_0); \ + REWIND_BLOCKS(events, blk_1r, blk_1, miner_account); + + +#include "double_spend.inl" diff --git a/tests/core_tests/double_spend.inl b/tests/core_tests/double_spend.inl new file mode 100644 index 000000000..38873a8b4 --- /dev/null +++ b/tests/core_tests/double_spend.inl @@ -0,0 +1,254 @@ +#pragma once + +//====================================================================================================================== + +template<class concrete_test> +gen_double_spend_base<concrete_test>::gen_double_spend_base() + : m_invalid_tx_index(invalid_index_value) + , m_invalid_block_index(invalid_index_value) +{ + REGISTER_CALLBACK_METHOD(gen_double_spend_base<concrete_test>, mark_last_valid_block); + REGISTER_CALLBACK_METHOD(gen_double_spend_base<concrete_test>, mark_invalid_tx); + REGISTER_CALLBACK_METHOD(gen_double_spend_base<concrete_test>, mark_invalid_block); + REGISTER_CALLBACK_METHOD(gen_double_spend_base<concrete_test>, check_double_spend); +} + +template<class concrete_test> +bool gen_double_spend_base<concrete_test>::check_tx_verification_context(const cryptonote::tx_verification_context& tvc, bool tx_added, size_t event_idx, const cryptonote::transaction& /*tx*/) +{ + if (m_invalid_tx_index == event_idx) + return tvc.m_verifivation_failed; + else + return !tvc.m_verifivation_failed && tx_added; +} + +template<class concrete_test> +bool gen_double_spend_base<concrete_test>::check_block_verification_context(const cryptonote::block_verification_context& bvc, size_t event_idx, const cryptonote::block& /*block*/) +{ + if (m_invalid_block_index == event_idx) + return bvc.m_verifivation_failed; + else + return !bvc.m_verifivation_failed; +} + +template<class concrete_test> +bool gen_double_spend_base<concrete_test>::mark_last_valid_block(cryptonote::core& c, size_t /*ev_index*/, const std::vector<test_event_entry>& /*events*/) +{ + std::list<cryptonote::block> block_list; + bool r = c.get_blocks(c.get_current_blockchain_height() - 1, 1, block_list); + CHECK_AND_ASSERT_MES(r, false, "core::get_blocks failed"); + m_last_valid_block = block_list.back(); + return true; +} + +template<class concrete_test> +bool gen_double_spend_base<concrete_test>::mark_invalid_tx(cryptonote::core& /*c*/, size_t ev_index, const std::vector<test_event_entry>& /*events*/) +{ + m_invalid_tx_index = ev_index + 1; + return true; +} + +template<class concrete_test> +bool gen_double_spend_base<concrete_test>::mark_invalid_block(cryptonote::core& /*c*/, size_t ev_index, const std::vector<test_event_entry>& /*events*/) +{ + m_invalid_block_index = ev_index + 1; + return true; +} + +template<class concrete_test> +bool gen_double_spend_base<concrete_test>::check_double_spend(cryptonote::core& c, size_t /*ev_index*/, const std::vector<test_event_entry>& events) +{ + DEFINE_TESTS_ERROR_CONTEXT("gen_double_spend_base::check_double_spend"); + + if (concrete_test::has_invalid_tx) + { + CHECK_NOT_EQ(invalid_index_value, m_invalid_tx_index); + } + CHECK_NOT_EQ(invalid_index_value, m_invalid_block_index); + + std::list<cryptonote::block> block_list; + bool r = c.get_blocks(0, 100 + 2 * CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW, block_list); + CHECK_TEST_CONDITION(r); + CHECK_TEST_CONDITION(m_last_valid_block == block_list.back()); + + CHECK_EQ(concrete_test::expected_pool_txs_count, c.get_pool_transactions_count()); + + cryptonote::account_base bob_account = boost::get<cryptonote::account_base>(events[1]); + cryptonote::account_base alice_account = boost::get<cryptonote::account_base>(events[2]); + + std::vector<cryptonote::block> chain; + map_hash2tx_t mtx; + std::vector<cryptonote::block> blocks(block_list.begin(), block_list.end()); + r = find_block_chain(events, chain, mtx, get_block_hash(blocks.back())); + CHECK_TEST_CONDITION(r); + CHECK_EQ(concrete_test::expected_bob_balance, get_balance(bob_account, blocks, mtx)); + CHECK_EQ(concrete_test::expected_alice_balance, get_balance(alice_account, blocks, mtx)); + + return true; +} + +//====================================================================================================================== + +template<bool txs_keeped_by_block> +bool gen_double_spend_in_tx<txs_keeped_by_block>::generate(std::vector<test_event_entry>& events) const +{ + INIT_DOUBLE_SPEND_TEST(); + DO_CALLBACK(events, "mark_last_valid_block"); + + std::vector<cryptonote::tx_source_entry> sources; + cryptonote::tx_source_entry se; + se.amount = tx_0.vout[0].amount; + se.outputs.push_back(std::make_pair(0, boost::get<cryptonote::txout_to_key>(tx_0.vout[0].target).key)); + se.real_output = 0; + se.real_out_tx_key = get_tx_pub_key_from_extra(tx_0); + se.real_output_in_tx_index = 0; + sources.push_back(se); + // Double spend! + sources.push_back(se); + + cryptonote::tx_destination_entry de; + de.addr = alice_account.get_keys().m_account_address; + de.amount = 2 * se.amount - TESTS_DEFAULT_FEE; + std::vector<cryptonote::tx_destination_entry> destinations; + destinations.push_back(de); + + cryptonote::transaction tx_1; + if (!construct_tx(bob_account.get_keys(), sources, destinations, tx_1, 0)) + return false; + + SET_EVENT_VISITOR_SETT(events, event_visitor_settings::set_txs_keeped_by_block, txs_keeped_by_block); + DO_CALLBACK(events, "mark_invalid_tx"); + events.push_back(tx_1); + DO_CALLBACK(events, "mark_invalid_block"); + MAKE_NEXT_BLOCK_TX1(events, blk_2, blk_1r, miner_account, tx_1); + DO_CALLBACK(events, "check_double_spend"); + + return true; +} + +template<bool txs_keeped_by_block> +bool gen_double_spend_in_the_same_block<txs_keeped_by_block>::generate(std::vector<test_event_entry>& events) const +{ + INIT_DOUBLE_SPEND_TEST(); + + DO_CALLBACK(events, "mark_last_valid_block"); + SET_EVENT_VISITOR_SETT(events, event_visitor_settings::set_txs_keeped_by_block, txs_keeped_by_block); + + MAKE_TX_LIST_START(events, txs_1, bob_account, alice_account, send_amount - TESTS_DEFAULT_FEE, blk_1); + cryptonote::transaction tx_1 = txs_1.front(); + auto tx_1_idx = events.size() - 1; + // Remove tx_1, it is being inserted back a little later + events.pop_back(); + + if (has_invalid_tx) + { + DO_CALLBACK(events, "mark_invalid_tx"); + } + MAKE_TX_LIST(events, txs_1, bob_account, alice_account, send_amount - TESTS_DEFAULT_FEE, blk_1); + events.insert(events.begin() + tx_1_idx, tx_1); + DO_CALLBACK(events, "mark_invalid_block"); + MAKE_NEXT_BLOCK_TX_LIST(events, blk_2, blk_1r, miner_account, txs_1); + DO_CALLBACK(events, "check_double_spend"); + + return true; +} + +template<bool txs_keeped_by_block> +bool gen_double_spend_in_different_blocks<txs_keeped_by_block>::generate(std::vector<test_event_entry>& events) const +{ + INIT_DOUBLE_SPEND_TEST(); + + DO_CALLBACK(events, "mark_last_valid_block"); + SET_EVENT_VISITOR_SETT(events, event_visitor_settings::set_txs_keeped_by_block, txs_keeped_by_block); + + // Create two identical transactions, but don't push it to events list + MAKE_TX(events, tx_blk_2, bob_account, alice_account, send_amount - TESTS_DEFAULT_FEE, blk_1); + events.pop_back(); + MAKE_TX(events, tx_blk_3, bob_account, alice_account, send_amount - TESTS_DEFAULT_FEE, blk_1); + events.pop_back(); + + events.push_back(tx_blk_2); + MAKE_NEXT_BLOCK_TX1(events, blk_2, blk_1r, miner_account, tx_blk_2); + DO_CALLBACK(events, "mark_last_valid_block"); + + if (has_invalid_tx) + { + DO_CALLBACK(events, "mark_invalid_tx"); + } + events.push_back(tx_blk_3); + DO_CALLBACK(events, "mark_invalid_block"); + MAKE_NEXT_BLOCK_TX1(events, blk_3, blk_2, miner_account, tx_blk_3); + + DO_CALLBACK(events, "check_double_spend"); + + return true; +} + +template<bool txs_keeped_by_block> +bool gen_double_spend_in_alt_chain_in_the_same_block<txs_keeped_by_block>::generate(std::vector<test_event_entry>& events) const +{ + INIT_DOUBLE_SPEND_TEST(); + + SET_EVENT_VISITOR_SETT(events, event_visitor_settings::set_txs_keeped_by_block, txs_keeped_by_block); + + // Main chain + MAKE_NEXT_BLOCK(events, blk_2, blk_1r, miner_account); + DO_CALLBACK(events, "mark_last_valid_block"); + + // Alt chain + MAKE_TX_LIST_START(events, txs_1, bob_account, alice_account, send_amount - TESTS_DEFAULT_FEE, blk_1); + cryptonote::transaction tx_1 = txs_1.front(); + auto tx_1_idx = events.size() - 1; + // Remove tx_1, it is being inserted back a little later + events.pop_back(); + + if (has_invalid_tx) + { + DO_CALLBACK(events, "mark_invalid_tx"); + } + MAKE_TX_LIST(events, txs_1, bob_account, alice_account, send_amount - TESTS_DEFAULT_FEE, blk_1); + events.insert(events.begin() + tx_1_idx, tx_1); + MAKE_NEXT_BLOCK_TX_LIST(events, blk_3, blk_1r, miner_account, txs_1); + + // Try to switch to alternative chain + DO_CALLBACK(events, "mark_invalid_block"); + MAKE_NEXT_BLOCK(events, blk_4, blk_3, miner_account); + + DO_CALLBACK(events, "check_double_spend"); + + return true; +} + +template<bool txs_keeped_by_block> +bool gen_double_spend_in_alt_chain_in_different_blocks<txs_keeped_by_block>::generate(std::vector<test_event_entry>& events) const +{ + INIT_DOUBLE_SPEND_TEST(); + + SET_EVENT_VISITOR_SETT(events, event_visitor_settings::set_txs_keeped_by_block, txs_keeped_by_block); + + // Main chain + MAKE_NEXT_BLOCK(events, blk_2, blk_1r, miner_account); + DO_CALLBACK(events, "mark_last_valid_block"); + + // Alternative chain + MAKE_TX(events, tx_1, bob_account, alice_account, send_amount - TESTS_DEFAULT_FEE, blk_1); + events.pop_back(); + MAKE_TX(events, tx_2, bob_account, alice_account, send_amount - TESTS_DEFAULT_FEE, blk_1); + events.pop_back(); + + events.push_back(tx_1); + MAKE_NEXT_BLOCK_TX1(events, blk_3, blk_1r, miner_account, tx_1); + + // Try to switch to alternative chain + if (has_invalid_tx) + { + DO_CALLBACK(events, "mark_invalid_tx"); + } + events.push_back(tx_2); + DO_CALLBACK(events, "mark_invalid_block"); + MAKE_NEXT_BLOCK_TX1(events, blk_4, blk_3, miner_account, tx_2); + + DO_CALLBACK(events, "check_double_spend"); + + return true; +} diff --git a/tests/core_tests/integer_overflow.cpp b/tests/core_tests/integer_overflow.cpp new file mode 100644 index 000000000..82bfb2150 --- /dev/null +++ b/tests/core_tests/integer_overflow.cpp @@ -0,0 +1,184 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include "chaingen.h" +#include "chaingen_tests_list.h" + +#include "integer_overflow.h" + +using namespace epee; +using namespace cryptonote; + +namespace +{ + void split_miner_tx_outs(transaction& miner_tx, uint64_t amount_1) + { + uint64_t total_amount = get_outs_money_amount(miner_tx); + uint64_t amount_2 = total_amount - amount_1; + txout_target_v target = miner_tx.vout[0].target; + + miner_tx.vout.clear(); + + tx_out out1; + out1.amount = amount_1; + out1.target = target; + miner_tx.vout.push_back(out1); + + tx_out out2; + out2.amount = amount_2; + out2.target = target; + miner_tx.vout.push_back(out2); + } + + void append_tx_source_entry(std::vector<cryptonote::tx_source_entry>& sources, const transaction& tx, size_t out_idx) + { + cryptonote::tx_source_entry se; + se.amount = tx.vout[out_idx].amount; + se.outputs.push_back(std::make_pair(0, boost::get<cryptonote::txout_to_key>(tx.vout[out_idx].target).key)); + se.real_output = 0; + se.real_out_tx_key = get_tx_pub_key_from_extra(tx); + se.real_output_in_tx_index = out_idx; + + sources.push_back(se); + } +} + +//====================================================================================================================== + +gen_uint_overflow_base::gen_uint_overflow_base() + : m_last_valid_block_event_idx(static_cast<size_t>(-1)) +{ + REGISTER_CALLBACK_METHOD(gen_uint_overflow_1, mark_last_valid_block); +} + +bool gen_uint_overflow_base::check_tx_verification_context(const cryptonote::tx_verification_context& tvc, bool tx_added, size_t event_idx, const cryptonote::transaction& /*tx*/) +{ + return m_last_valid_block_event_idx < event_idx ? !tx_added && tvc.m_verifivation_failed : tx_added && !tvc.m_verifivation_failed; +} + +bool gen_uint_overflow_base::check_block_verification_context(const cryptonote::block_verification_context& bvc, size_t event_idx, const cryptonote::block& /*block*/) +{ + return m_last_valid_block_event_idx < event_idx ? bvc.m_verifivation_failed | bvc.m_marked_as_orphaned : !bvc.m_verifivation_failed; +} + +bool gen_uint_overflow_base::mark_last_valid_block(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events) +{ + m_last_valid_block_event_idx = ev_index - 1; + return true; +} + +//====================================================================================================================== + +bool gen_uint_overflow_1::generate(std::vector<test_event_entry>& events) const +{ + uint64_t ts_start = 1338224400; + + GENERATE_ACCOUNT(miner_account); + MAKE_GENESIS_BLOCK(events, blk_0, miner_account, ts_start); + DO_CALLBACK(events, "mark_last_valid_block"); + MAKE_ACCOUNT(events, bob_account); + MAKE_ACCOUNT(events, alice_account); + + // Problem 1. Miner tx output overflow + MAKE_MINER_TX_MANUALLY(miner_tx_0, blk_0); + split_miner_tx_outs(miner_tx_0, MONEY_SUPPLY); + block blk_1; + if (!generator.construct_block_manually(blk_1, blk_0, miner_account, test_generator::bf_miner_tx, 0, 0, 0, crypto::hash(), 0, miner_tx_0)) + return false; + events.push_back(blk_1); + + // Problem 1. Miner tx outputs overflow + MAKE_MINER_TX_MANUALLY(miner_tx_1, blk_1); + split_miner_tx_outs(miner_tx_1, MONEY_SUPPLY); + block blk_2; + if (!generator.construct_block_manually(blk_2, blk_1, miner_account, test_generator::bf_miner_tx, 0, 0, 0, crypto::hash(), 0, miner_tx_1)) + return false; + events.push_back(blk_2); + + REWIND_BLOCKS(events, blk_2r, blk_2, miner_account); + MAKE_TX_LIST_START(events, txs_0, miner_account, bob_account, MONEY_SUPPLY, blk_2); + MAKE_TX_LIST(events, txs_0, miner_account, bob_account, MONEY_SUPPLY, blk_2); + MAKE_NEXT_BLOCK_TX_LIST(events, blk_3, blk_2r, miner_account, txs_0); + REWIND_BLOCKS(events, blk_3r, blk_3, miner_account); + + // Problem 2. total_fee overflow, block_reward overflow + std::list<cryptonote::transaction> txs_1; + // Create txs with huge fee + txs_1.push_back(construct_tx_with_fee(events, blk_3, bob_account, alice_account, MK_COINS(1), MONEY_SUPPLY - MK_COINS(1))); + txs_1.push_back(construct_tx_with_fee(events, blk_3, bob_account, alice_account, MK_COINS(1), MONEY_SUPPLY - MK_COINS(1))); + MAKE_NEXT_BLOCK_TX_LIST(events, blk_4, blk_3r, miner_account, txs_1); + + return true; +} + +//====================================================================================================================== + +bool gen_uint_overflow_2::generate(std::vector<test_event_entry>& events) const +{ + uint64_t ts_start = 1338224400; + + GENERATE_ACCOUNT(miner_account); + MAKE_GENESIS_BLOCK(events, blk_0, miner_account, ts_start); + MAKE_ACCOUNT(events, bob_account); + MAKE_ACCOUNT(events, alice_account); + REWIND_BLOCKS(events, blk_0r, blk_0, miner_account); + DO_CALLBACK(events, "mark_last_valid_block"); + + // Problem 1. Regular tx outputs overflow + std::vector<cryptonote::tx_source_entry> sources; + for (size_t i = 0; i < blk_0.miner_tx.vout.size(); ++i) + { + if (TESTS_DEFAULT_FEE < blk_0.miner_tx.vout[i].amount) + { + append_tx_source_entry(sources, blk_0.miner_tx, i); + break; + } + } + if (sources.empty()) + { + return false; + } + + std::vector<cryptonote::tx_destination_entry> destinations; + const account_public_address& bob_addr = bob_account.get_keys().m_account_address; + destinations.push_back(tx_destination_entry(MONEY_SUPPLY, bob_addr)); + destinations.push_back(tx_destination_entry(MONEY_SUPPLY - 1, bob_addr)); + // sources.front().amount = destinations[0].amount + destinations[2].amount + destinations[3].amount + TESTS_DEFAULT_FEE + destinations.push_back(tx_destination_entry(sources.front().amount - MONEY_SUPPLY - MONEY_SUPPLY + 1 - TESTS_DEFAULT_FEE, bob_addr)); + + cryptonote::transaction tx_1; + if (!construct_tx(miner_account.get_keys(), sources, destinations, tx_1, 0)) + return false; + events.push_back(tx_1); + + MAKE_NEXT_BLOCK_TX1(events, blk_1, blk_0r, miner_account, tx_1); + REWIND_BLOCKS(events, blk_1r, blk_1, miner_account); + + // Problem 2. Regular tx inputs overflow + sources.clear(); + for (size_t i = 0; i < tx_1.vout.size(); ++i) + { + auto& tx_1_out = tx_1.vout[i]; + if (tx_1_out.amount < MONEY_SUPPLY - 1) + continue; + + append_tx_source_entry(sources, tx_1, i); + } + + destinations.clear(); + cryptonote::tx_destination_entry de; + de.addr = alice_account.get_keys().m_account_address; + de.amount = MONEY_SUPPLY - TESTS_DEFAULT_FEE; + destinations.push_back(de); + destinations.push_back(de); + + cryptonote::transaction tx_2; + if (!construct_tx(bob_account.get_keys(), sources, destinations, tx_2, 0)) + return false; + events.push_back(tx_2); + + MAKE_NEXT_BLOCK_TX1(events, blk_2, blk_1r, miner_account, tx_2); + + return true; +} diff --git a/tests/core_tests/integer_overflow.h b/tests/core_tests/integer_overflow.h new file mode 100644 index 000000000..0e00ada32 --- /dev/null +++ b/tests/core_tests/integer_overflow.h @@ -0,0 +1,29 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#pragma once +#include "chaingen.h" + +struct gen_uint_overflow_base : public test_chain_unit_base +{ + gen_uint_overflow_base(); + + bool check_tx_verification_context(const cryptonote::tx_verification_context& tvc, bool tx_added, size_t event_idx, const cryptonote::transaction& tx); + bool check_block_verification_context(const cryptonote::block_verification_context& bvc, size_t event_idx, const cryptonote::block& block); + + bool mark_last_valid_block(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events); + +private: + size_t m_last_valid_block_event_idx; +}; + +struct gen_uint_overflow_1 : public gen_uint_overflow_base +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_uint_overflow_2 : public gen_uint_overflow_base +{ + bool generate(std::vector<test_event_entry>& events) const; +}; diff --git a/tests/core_tests/ring_signature_1.cpp b/tests/core_tests/ring_signature_1.cpp new file mode 100644 index 000000000..bfdaf38f0 --- /dev/null +++ b/tests/core_tests/ring_signature_1.cpp @@ -0,0 +1,318 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include "chaingen.h" +#include "chaingen_tests_list.h" + +using namespace epee; +using namespace cryptonote; + + +//////// +// class gen_ring_signature_1; + +gen_ring_signature_1::gen_ring_signature_1() +{ + REGISTER_CALLBACK("check_balances_1", gen_ring_signature_1::check_balances_1); + REGISTER_CALLBACK("check_balances_2", gen_ring_signature_1::check_balances_2); +} + +namespace +{ + // To be sure that miner tx outputs don't match any bob_account and some_accounts inputs + const uint64_t rnd_11 = 475921; + const uint64_t rnd_20 = 360934; + const uint64_t rnd_29 = 799665; +} + +bool gen_ring_signature_1::generate(std::vector<test_event_entry>& events) const +{ + uint64_t ts_start = 1338224400; + + GENERATE_ACCOUNT(miner_account); + + // events + MAKE_GENESIS_BLOCK(events, blk_0, miner_account, ts_start); // 0 + MAKE_ACCOUNT(events, some_account_1); // 1 + MAKE_ACCOUNT(events, some_account_2); // 2 + MAKE_ACCOUNT(events, bob_account); // 3 + MAKE_ACCOUNT(events, alice_account); // 4 + MAKE_NEXT_BLOCK(events, blk_1, blk_0, miner_account); // 5 + MAKE_NEXT_BLOCK(events, blk_2, blk_1, miner_account); // 6 + MAKE_NEXT_BLOCK(events, blk_3, blk_2, miner_account); // 7 + MAKE_NEXT_BLOCK(events, blk_4, blk_3, miner_account); // 8 + REWIND_BLOCKS(events, blk_5, blk_4, miner_account); // <N blocks> + REWIND_BLOCKS(events, blk_5r, blk_5, miner_account); // <N blocks> + MAKE_TX_LIST_START(events, txs_blk_6, miner_account, bob_account, MK_COINS(1), blk_5); // 9 + 2N + MAKE_TX_LIST(events, txs_blk_6, miner_account, bob_account, MK_COINS(11) + rnd_11, blk_5); // 10 + 2N + MAKE_TX_LIST(events, txs_blk_6, miner_account, bob_account, MK_COINS(11) + rnd_11, blk_5); // 11 + 2N + MAKE_TX_LIST(events, txs_blk_6, miner_account, bob_account, MK_COINS(20) + rnd_20, blk_5); // 12 + 2N + MAKE_TX_LIST(events, txs_blk_6, miner_account, bob_account, MK_COINS(29) + rnd_29, blk_5); // 13 + 2N + MAKE_TX_LIST(events, txs_blk_6, miner_account, bob_account, MK_COINS(29) + rnd_29, blk_5); // 14 + 2N + MAKE_TX_LIST(events, txs_blk_6, miner_account, bob_account, MK_COINS(29) + rnd_29, blk_5); // 15 + 2N + MAKE_TX_LIST(events, txs_blk_6, miner_account, some_account_1, MK_COINS(11) + rnd_11, blk_5); // 16 + 2N + MAKE_TX_LIST(events, txs_blk_6, miner_account, some_account_1, MK_COINS(11) + rnd_11, blk_5); // 17 + 2N + MAKE_TX_LIST(events, txs_blk_6, miner_account, some_account_1, MK_COINS(11) + rnd_11, blk_5); // 18 + 2N + MAKE_TX_LIST(events, txs_blk_6, miner_account, some_account_1, MK_COINS(11) + rnd_11, blk_5); // 19 + 2N + MAKE_TX_LIST(events, txs_blk_6, miner_account, some_account_1, MK_COINS(20) + rnd_20, blk_5); // 20 + 2N + MAKE_TX_LIST(events, txs_blk_6, miner_account, some_account_2, MK_COINS(20) + rnd_20, blk_5); // 21 + 2N + MAKE_NEXT_BLOCK_TX_LIST(events, blk_6, blk_5r, miner_account, txs_blk_6); // 22 + 2N + DO_CALLBACK(events, "check_balances_1"); // 23 + 2N + REWIND_BLOCKS(events, blk_6r, blk_6, miner_account); // <N blocks> + // 129 = 11 + 11 + 20 + 29 + 29 + 29 + MAKE_TX_MIX(events, tx_0, bob_account, alice_account, MK_COINS(129) + 2 * rnd_11 + rnd_20 + 3 * rnd_29 - TESTS_DEFAULT_FEE, 2, blk_6); // 24 + 3N + MAKE_NEXT_BLOCK_TX1(events, blk_7, blk_6r, miner_account, tx_0); // 25 + 3N + DO_CALLBACK(events, "check_balances_2"); // 26 + 3N + + return true; +} + +bool gen_ring_signature_1::check_balances_1(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events) +{ + DEFINE_TESTS_ERROR_CONTEXT("gen_ring_signature_1::check_balances_1"); + + m_bob_account = boost::get<account_base>(events[3]); + m_alice_account = boost::get<account_base>(events[4]); + + std::list<block> blocks; + bool r = c.get_blocks(0, 100 + 2 * CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW, blocks); + CHECK_TEST_CONDITION(r); + + std::vector<cryptonote::block> chain; + map_hash2tx_t mtx; + r = find_block_chain(events, chain, mtx, get_block_hash(blocks.back())); + CHECK_TEST_CONDITION(r); + CHECK_EQ(MK_COINS(130) + 2 * rnd_11 + rnd_20 + 3 * rnd_29, get_balance(m_bob_account, chain, mtx)); + CHECK_EQ(0, get_balance(m_alice_account, chain, mtx)); + + return true; +} + +bool gen_ring_signature_1::check_balances_2(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events) +{ + DEFINE_TESTS_ERROR_CONTEXT("gen_ring_signature_1::check_balances_2"); + + std::list<block> blocks; + bool r = c.get_blocks(0, 100 + 2 * CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW, blocks); + CHECK_TEST_CONDITION(r); + + std::vector<cryptonote::block> chain; + map_hash2tx_t mtx; + r = find_block_chain(events, chain, mtx, get_block_hash(blocks.back())); + CHECK_TEST_CONDITION(r); + CHECK_EQ(MK_COINS(1), get_balance(m_bob_account, chain, mtx)); + CHECK_EQ(MK_COINS(129) + 2 * rnd_11 + rnd_20 + 3 * rnd_29 - TESTS_DEFAULT_FEE, get_balance(m_alice_account, chain, mtx)); + + return true; +} + + +//////// +// class gen_ring_signature_2; + +gen_ring_signature_2::gen_ring_signature_2() +{ + REGISTER_CALLBACK("check_balances_1", gen_ring_signature_2::check_balances_1); + REGISTER_CALLBACK("check_balances_2", gen_ring_signature_2::check_balances_2); +} + +/** + * Bob has 4 inputs by 61 coins. He sends 4 * 61 coins to Alice, using ring signature with nmix = 3. Each Bob's input + * is used as mix for 3 others. + */ +bool gen_ring_signature_2::generate(std::vector<test_event_entry>& events) const +{ + uint64_t ts_start = 1338224400; + + GENERATE_ACCOUNT(miner_account); + + // events + MAKE_GENESIS_BLOCK(events, blk_0, miner_account, ts_start); // 0 + MAKE_ACCOUNT(events, bob_account); // 1 + MAKE_ACCOUNT(events, alice_account); // 2 + MAKE_NEXT_BLOCK(events, blk_1, blk_0, miner_account); // 3 + MAKE_NEXT_BLOCK(events, blk_2, blk_1, miner_account); // 4 + MAKE_NEXT_BLOCK(events, blk_3, blk_2, miner_account); // 5 + REWIND_BLOCKS(events, blk_3r, blk_3, miner_account); // <N blocks> + MAKE_TX_LIST_START(events, txs_blk_4, miner_account, bob_account, MK_COINS(61), blk_3); // 6 + N + MAKE_TX_LIST(events, txs_blk_4, miner_account, bob_account, MK_COINS(61), blk_3); // 7 + N + MAKE_TX_LIST(events, txs_blk_4, miner_account, bob_account, MK_COINS(61), blk_3); // 8 + N + MAKE_TX_LIST(events, txs_blk_4, miner_account, bob_account, MK_COINS(61), blk_3); // 9 + N + MAKE_NEXT_BLOCK_TX_LIST(events, blk_4, blk_3r, miner_account, txs_blk_4); // 10 + N + DO_CALLBACK(events, "check_balances_1"); // 11 + N + REWIND_BLOCKS(events, blk_4r, blk_4, miner_account); // <N blocks> + MAKE_TX_MIX(events, tx_0, bob_account, alice_account, MK_COINS(244) - TESTS_DEFAULT_FEE, 3, blk_4); // 12 + 2N + MAKE_NEXT_BLOCK_TX1(events, blk_5, blk_4r, miner_account, tx_0); // 13 + 2N + DO_CALLBACK(events, "check_balances_2"); // 14 + 2N + + return true; +} + +bool gen_ring_signature_2::check_balances_1(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events) +{ + DEFINE_TESTS_ERROR_CONTEXT("gen_ring_signature_2::check_balances_1"); + + m_bob_account = boost::get<account_base>(events[1]); + m_alice_account = boost::get<account_base>(events[2]); + + std::list<block> blocks; + bool r = c.get_blocks(0, 100 + 2 * CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW, blocks); + CHECK_TEST_CONDITION(r); + + std::vector<cryptonote::block> chain; + map_hash2tx_t mtx; + r = find_block_chain(events, chain, mtx, get_block_hash(blocks.back())); + CHECK_TEST_CONDITION(r); + CHECK_EQ(MK_COINS(244), get_balance(m_bob_account, chain, mtx)); + CHECK_EQ(0, get_balance(m_alice_account, chain, mtx)); + + return true; +} + +bool gen_ring_signature_2::check_balances_2(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events) +{ + DEFINE_TESTS_ERROR_CONTEXT("gen_ring_signature_2::check_balances_2"); + + std::list<block> blocks; + bool r = c.get_blocks(0, 100 + 2 * CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW, blocks); + CHECK_TEST_CONDITION(r); + + std::vector<cryptonote::block> chain; + map_hash2tx_t mtx; + r = find_block_chain(events, chain, mtx, get_block_hash(blocks.back())); + CHECK_TEST_CONDITION(r); + CHECK_EQ(0, get_balance(m_bob_account, chain, mtx)); + CHECK_EQ(MK_COINS(244) - TESTS_DEFAULT_FEE, get_balance(m_alice_account, chain, mtx)); + + return true; +} + + +//////// +// class gen_ring_signature_big; + +gen_ring_signature_big::gen_ring_signature_big() + : m_test_size(100) + , m_tx_amount(MK_COINS(29)) +{ + REGISTER_CALLBACK("check_balances_1", gen_ring_signature_big::check_balances_1); + REGISTER_CALLBACK("check_balances_2", gen_ring_signature_big::check_balances_2); +} + +/** + * Check ring signature with m_test_size-1 sources. + * - Create 100 accounts. + * - Create 100 blocks, each block contains transaction from the miner to account[i]. + * - Create transaction with ring signature from account[99] to Alice with nmix = 99. + * - Check balances. + */ +bool gen_ring_signature_big::generate(std::vector<test_event_entry>& events) const +{ + std::vector<account_base> accounts(m_test_size); + std::vector<block> blocks; + blocks.reserve(m_test_size + CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW); + + uint64_t ts_start = 1338224400; + GENERATE_ACCOUNT(miner_account); + + MAKE_GENESIS_BLOCK(events, blk_0, miner_account, ts_start); + + for (size_t i = 0; i < m_test_size; ++i) + { + MAKE_ACCOUNT(events, an_account); + accounts[i] = an_account; + } + MAKE_ACCOUNT(events, alice_account); + + size_t blk_0r_idx = events.size(); + REWIND_BLOCKS(events, blk_0r, blk_0, miner_account); + blocks.push_back(blk_0); + for (size_t i = blk_0r_idx; i < events.size(); ++i) + { + blocks.push_back(boost::get<block>(events[i])); + } + + for (size_t i = 0; i < m_test_size; ++i) + { + block blk_with_unlocked_out = blocks[blocks.size() - 1 - CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW]; + MAKE_TX_LIST_START(events, txs_blk_i, miner_account, accounts[i], m_tx_amount, blk_with_unlocked_out); + for (size_t j = 0; j <= i; ++j) + { + MAKE_TX_LIST(events, txs_blk_i, miner_account, accounts[i], TESTS_DEFAULT_FEE, blk_with_unlocked_out); + } + MAKE_NEXT_BLOCK_TX_LIST(events, blk_i, blocks.back(), miner_account, txs_blk_i); + blocks.push_back(blk_i); + + std::vector<cryptonote::block> chain; + map_hash2tx_t mtx; + bool r = find_block_chain(events, chain, mtx, get_block_hash(blk_i)); + CHECK_AND_NO_ASSERT_MES(r, false, "failed to call find_block_chain"); + std::cout << i << ": " << get_balance(accounts[i], chain, mtx) << std::endl; + } + + DO_CALLBACK(events, "check_balances_1"); + MAKE_TX_MIX(events, tx_0, accounts[0], alice_account, m_tx_amount, m_test_size - 1, blocks.back()); + MAKE_NEXT_BLOCK_TX1(events, blk_1, blocks.back(), miner_account, tx_0); + DO_CALLBACK(events, "check_balances_2"); + + return true; +} + +bool gen_ring_signature_big::check_balances_1(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events) +{ + DEFINE_TESTS_ERROR_CONTEXT("gen_ring_signature_big::check_balances_1"); + + m_bob_account = boost::get<account_base>(events[1]); + m_alice_account = boost::get<account_base>(events[1 + m_test_size]); + + std::list<block> blocks; + bool r = c.get_blocks(0, 2 * m_test_size + CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW, blocks); + CHECK_TEST_CONDITION(r); + + std::vector<cryptonote::block> chain; + map_hash2tx_t mtx; + r = find_block_chain(events, chain, mtx, get_block_hash(blocks.back())); + CHECK_TEST_CONDITION(r); + CHECK_EQ(m_tx_amount + TESTS_DEFAULT_FEE, get_balance(m_bob_account, chain, mtx)); + CHECK_EQ(0, get_balance(m_alice_account, chain, mtx)); + + for (size_t i = 2; i < 1 + m_test_size; ++i) + { + const account_base& an_account = boost::get<account_base>(events[i]); + uint64_t balance = m_tx_amount + TESTS_DEFAULT_FEE * i; + CHECK_EQ(balance, get_balance(an_account, chain, mtx)); + } + + return true; +} + +bool gen_ring_signature_big::check_balances_2(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events) +{ + DEFINE_TESTS_ERROR_CONTEXT("gen_ring_signature_big::check_balances_2"); + + std::list<block> blocks; + bool r = c.get_blocks(0, 2 * m_test_size + CRYPTONOTE_MINED_MONEY_UNLOCK_WINDOW, blocks); + CHECK_TEST_CONDITION(r); + + std::vector<cryptonote::block> chain; + map_hash2tx_t mtx; + r = find_block_chain(events, chain, mtx, get_block_hash(blocks.back())); + CHECK_TEST_CONDITION(r); + CHECK_EQ(0, get_balance(m_bob_account, chain, mtx)); + CHECK_EQ(m_tx_amount, get_balance(m_alice_account, chain, mtx)); + + for (size_t i = 2; i < 1 + m_test_size; ++i) + { + const account_base& an_account = boost::get<account_base>(events[i]); + uint64_t balance = m_tx_amount + TESTS_DEFAULT_FEE * i; + CHECK_EQ(balance, get_balance(an_account, chain, mtx)); + } + + std::vector<size_t> tx_outs; + uint64_t transfered; + lookup_acc_outs(m_alice_account.get_keys(), boost::get<transaction>(events[events.size() - 3]), get_tx_pub_key_from_extra(boost::get<transaction>(events[events.size() - 3])), tx_outs, transfered); + CHECK_EQ(m_tx_amount, transfered); + + return true; +} diff --git a/tests/core_tests/ring_signature_1.h b/tests/core_tests/ring_signature_1.h new file mode 100644 index 000000000..1d74f6802 --- /dev/null +++ b/tests/core_tests/ring_signature_1.h @@ -0,0 +1,65 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#pragma once +#include "chaingen.h" + +/************************************************************************/ +/* */ +/************************************************************************/ +class gen_ring_signature_1 : public test_chain_unit_base +{ +public: + gen_ring_signature_1(); + + bool generate(std::vector<test_event_entry>& events) const; + + bool check_balances_1(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events); + bool check_balances_2(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events); + +private: + cryptonote::account_base m_bob_account; + cryptonote::account_base m_alice_account; +}; + + +/************************************************************************/ +/* */ +/************************************************************************/ +class gen_ring_signature_2 : public test_chain_unit_base +{ +public: + gen_ring_signature_2(); + + bool generate(std::vector<test_event_entry>& events) const; + + bool check_balances_1(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events); + bool check_balances_2(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events); + +private: + cryptonote::account_base m_bob_account; + cryptonote::account_base m_alice_account; +}; + + +/************************************************************************/ +/* */ +/************************************************************************/ +class gen_ring_signature_big : public test_chain_unit_base +{ +public: + gen_ring_signature_big(); + + bool generate(std::vector<test_event_entry>& events) const; + + bool check_balances_1(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events); + bool check_balances_2(cryptonote::core& c, size_t ev_index, const std::vector<test_event_entry>& events); + +private: + size_t m_test_size; + uint64_t m_tx_amount; + + cryptonote::account_base m_bob_account; + cryptonote::account_base m_alice_account; +}; diff --git a/tests/core_tests/transaction_tests.cpp b/tests/core_tests/transaction_tests.cpp new file mode 100644 index 000000000..4da9446cd --- /dev/null +++ b/tests/core_tests/transaction_tests.cpp @@ -0,0 +1,146 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + + +#include "include_base_utils.h" +#include "cryptonote_core/cryptonote_basic_impl.h" +#include "cryptonote_core/account.h" +#include "cryptonote_core/cryptonote_format_utils.h" + +using namespace cryptonote; + + + +bool test_transaction_generation_and_ring_signature() +{ + + account_base miner_acc1; + miner_acc1.generate(); + account_base miner_acc2; + miner_acc2.generate(); + account_base miner_acc3; + miner_acc3.generate(); + account_base miner_acc4; + miner_acc4.generate(); + account_base miner_acc5; + miner_acc5.generate(); + account_base miner_acc6; + miner_acc6.generate(); + + std::string add_str = miner_acc3.get_public_address_str(); + + + account_base rv_acc; + rv_acc.generate(); + account_base rv_acc2; + rv_acc2.generate(); + std::vector<size_t> b; + transaction tx_mine_1; + construct_miner_tx(0, 0, miner_acc1.get_keys().m_account_address, tx_mine_1, 0, b, 10); + transaction tx_mine_2; + construct_miner_tx(0, 0, miner_acc2.get_keys().m_account_address, tx_mine_2, 0, b, 0); + transaction tx_mine_3; + construct_miner_tx(0, 0, miner_acc3.get_keys().m_account_address, tx_mine_3, 0, b, 0); + transaction tx_mine_4; + construct_miner_tx(0, 0, miner_acc4.get_keys().m_account_address, tx_mine_4, 0, b, 0); + transaction tx_mine_5; + construct_miner_tx(0, 0, miner_acc5.get_keys().m_account_address, tx_mine_5, 0, b, 0); + transaction tx_mine_6; + construct_miner_tx(0, 0, miner_acc6.get_keys().m_account_address, tx_mine_6, 0, b, 0); + + //fill inputs entry + typedef tx_source_entry::output_entry tx_output_entry; + std::vector<tx_source_entry> sources; + sources.resize(sources.size()+1); + tx_source_entry& src = sources.back(); + src.amount = 70368744177663; + { + tx_output_entry oe; + oe.first = 0; + oe.second = boost::get<txout_to_key>(tx_mine_1.vout[0].target).key; + src.outputs.push_back(oe); + + oe.first = 1; + oe.second = boost::get<txout_to_key>(tx_mine_2.vout[0].target).key; + src.outputs.push_back(oe); + + oe.first = 2; + oe.second = boost::get<txout_to_key>(tx_mine_3.vout[0].target).key; + src.outputs.push_back(oe); + + oe.first = 3; + oe.second = boost::get<txout_to_key>(tx_mine_4.vout[0].target).key; + src.outputs.push_back(oe); + + oe.first = 4; + oe.second = boost::get<txout_to_key>(tx_mine_5.vout[0].target).key; + src.outputs.push_back(oe); + + oe.first = 5; + oe.second = boost::get<txout_to_key>(tx_mine_6.vout[0].target).key; + src.outputs.push_back(oe); + + crypto::public_key tx_pub_key = null_pkey; + cryptonote::parse_and_validate_tx_extra(tx_mine_2, tx_pub_key); + src.real_out_tx_key = tx_pub_key; + src.real_output = 1; + src.real_output_in_tx_index = 0; + } + //fill outputs entry + tx_destination_entry td; + td.addr = rv_acc.get_keys().m_account_address; + td.amount = 69368744177663; + std::vector<tx_destination_entry> destinations; + destinations.push_back(td); + + transaction tx_rc1; + bool r = construct_tx(miner_acc2.get_keys(), sources, destinations, tx_rc1, 0); + CHECK_AND_ASSERT_MES(r, false, "failed to construct transaction"); + + crypto::hash pref_hash = get_transaction_prefix_hash(tx_rc1); + std::vector<const crypto::public_key *> output_keys; + output_keys.push_back(&boost::get<txout_to_key>(tx_mine_1.vout[0].target).key); + output_keys.push_back(&boost::get<txout_to_key>(tx_mine_2.vout[0].target).key); + output_keys.push_back(&boost::get<txout_to_key>(tx_mine_3.vout[0].target).key); + output_keys.push_back(&boost::get<txout_to_key>(tx_mine_4.vout[0].target).key); + output_keys.push_back(&boost::get<txout_to_key>(tx_mine_5.vout[0].target).key); + output_keys.push_back(&boost::get<txout_to_key>(tx_mine_6.vout[0].target).key); + r = crypto::check_ring_signature(pref_hash, boost::get<txin_to_key>(tx_rc1.vin[0]).k_image, output_keys, &tx_rc1.signatures[0][0]); + CHECK_AND_ASSERT_MES(r, false, "failed to check ring signature"); + + std::vector<size_t> outs; + uint64_t money = 0; + + r = lookup_acc_outs(rv_acc.get_keys(), tx_rc1, get_tx_pub_key_from_extra(tx_rc1), outs, money); + CHECK_AND_ASSERT_MES(r, false, "failed to lookup_acc_outs"); + CHECK_AND_ASSERT_MES(td.amount == money, false, "wrong money amount in new transaction"); + money = 0; + r = lookup_acc_outs(rv_acc2.get_keys(), tx_rc1, get_tx_pub_key_from_extra(tx_rc1), outs, money); + CHECK_AND_ASSERT_MES(r, false, "failed to lookup_acc_outs"); + CHECK_AND_ASSERT_MES(0 == money, false, "wrong money amount in new transaction"); + return true; +} + +bool test_block_creation() +{ + uint64_t vszs[] = {80,476,476,475,475,474,475,474,474,475,472,476,476,475,475,474,475,474,474,475,472,476,476,475,475,474,475,474,474,475,9391,476,476,475,475,474,475,8819,8301,475,472,4302,5316,14347,16620,19583,19403,19728,19442,19852,19015,19000,19016,19795,19749,18087,19787,19704,19750,19267,19006,19050,19445,19407,19522,19546,19788,19369,19486,19329,19370,18853,19600,19110,19320,19746,19474,19474,19743,19494,19755,19715,19769,19620,19368,19839,19532,23424,28287,30707}; + std::vector<uint64_t> szs(&vszs[0], &vszs[90]); + account_public_address adr; + bool r = get_account_address_from_str(adr, "0099be99c70ef10fd534c43c88e9d13d1c8853213df7e362afbec0e4ee6fec4948d0c190b58f4b356cd7feaf8d9d0a76e7c7e5a9a0a497a6b1faf7a765882dd08ac2"); + CHECK_AND_ASSERT_MES(r, false, "failed to import"); + block b; + r = construct_miner_tx(90, 3553616528562147, adr, b.miner_tx, 10000000, szs, 33094, 11); + return r; +} + +bool test_transactions() +{ + if(!test_transaction_generation_and_ring_signature()) + return false; + if(!test_block_creation()) + return false; + + + return true; +} diff --git a/tests/core_tests/transaction_tests.h b/tests/core_tests/transaction_tests.h new file mode 100644 index 000000000..460192802 --- /dev/null +++ b/tests/core_tests/transaction_tests.h @@ -0,0 +1,10 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#pragma once + + + +bool test_transactions(); +bool test_block_creation(); diff --git a/tests/core_tests/tx_validation.cpp b/tests/core_tests/tx_validation.cpp new file mode 100644 index 000000000..93cb68c95 --- /dev/null +++ b/tests/core_tests/tx_validation.cpp @@ -0,0 +1,746 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include "chaingen.h" +#include "chaingen_tests_list.h" + +using namespace epee; +using namespace crypto; +using namespace cryptonote; + +namespace +{ + struct tx_builder + { + void step1_init(size_t version = CURRENT_TRANSACTION_VERSION, uint64_t unlock_time = 0) + { + m_tx.vin.clear(); + m_tx.vout.clear(); + m_tx.signatures.clear(); + + m_tx.version = version; + m_tx.unlock_time = unlock_time; + + m_tx_key = keypair::generate(); + add_tx_pub_key_to_extra(m_tx, m_tx_key.pub); + } + + void step2_fill_inputs(const account_keys& sender_account_keys, const std::vector<tx_source_entry>& sources) + { + BOOST_FOREACH(const tx_source_entry& src_entr, sources) + { + m_in_contexts.push_back(keypair()); + keypair& in_ephemeral = m_in_contexts.back(); + crypto::key_image img; + generate_key_image_helper(sender_account_keys, src_entr.real_out_tx_key, src_entr.real_output_in_tx_index, in_ephemeral, img); + + // put key image into tx input + txin_to_key input_to_key; + input_to_key.amount = src_entr.amount; + input_to_key.k_image = img; + + // fill outputs array and use relative offsets + BOOST_FOREACH(const tx_source_entry::output_entry& out_entry, src_entr.outputs) + input_to_key.key_offsets.push_back(out_entry.first); + + input_to_key.key_offsets = absolute_output_offsets_to_relative(input_to_key.key_offsets); + m_tx.vin.push_back(input_to_key); + } + } + + void step3_fill_outputs(const std::vector<tx_destination_entry>& destinations) + { + size_t output_index = 0; + BOOST_FOREACH(const tx_destination_entry& dst_entr, destinations) + { + crypto::key_derivation derivation; + crypto::public_key out_eph_public_key; + crypto::generate_key_derivation(dst_entr.addr.m_view_public_key, m_tx_key.sec, derivation); + crypto::derive_public_key(derivation, output_index, dst_entr.addr.m_spend_public_key, out_eph_public_key); + + tx_out out; + out.amount = dst_entr.amount; + txout_to_key tk; + tk.key = out_eph_public_key; + out.target = tk; + m_tx.vout.push_back(out); + output_index++; + } + } + + void step4_calc_hash() + { + get_transaction_prefix_hash(m_tx, m_tx_prefix_hash); + } + + void step5_sign(const std::vector<tx_source_entry>& sources) + { + m_tx.signatures.clear(); + + size_t i = 0; + BOOST_FOREACH(const tx_source_entry& src_entr, sources) + { + std::vector<const crypto::public_key*> keys_ptrs; + BOOST_FOREACH(const tx_source_entry::output_entry& o, src_entr.outputs) + { + keys_ptrs.push_back(&o.second); + } + + m_tx.signatures.push_back(std::vector<crypto::signature>()); + std::vector<crypto::signature>& sigs = m_tx.signatures.back(); + sigs.resize(src_entr.outputs.size()); + generate_ring_signature(m_tx_prefix_hash, boost::get<txin_to_key>(m_tx.vin[i]).k_image, keys_ptrs, m_in_contexts[i].sec, src_entr.real_output, sigs.data()); + i++; + } + } + + transaction m_tx; + keypair m_tx_key; + std::vector<keypair> m_in_contexts; + crypto::hash m_tx_prefix_hash; + }; + + transaction make_simple_tx_with_unlock_time(const std::vector<test_event_entry>& events, + const cryptonote::block& blk_head, const cryptonote::account_base& from, const cryptonote::account_base& to, + uint64_t amount, uint64_t unlock_time) + { + std::vector<tx_source_entry> sources; + std::vector<tx_destination_entry> destinations; + fill_tx_sources_and_destinations(events, blk_head, from, to, amount, TESTS_DEFAULT_FEE, 0, sources, destinations); + + tx_builder builder; + builder.step1_init(CURRENT_TRANSACTION_VERSION, unlock_time); + builder.step2_fill_inputs(from.get_keys(), sources); + builder.step3_fill_outputs(destinations); + builder.step4_calc_hash(); + builder.step5_sign(sources); + return builder.m_tx; + }; + + crypto::public_key generate_invalid_pub_key() + { + for (int i = 0; i <= 0xFF; ++i) + { + crypto::public_key key; + memset(&key, i, sizeof(crypto::public_key)); + if (!crypto::check_key(key)) + { + return key; + } + } + + throw std::runtime_error("invalid public key wasn't found"); + return crypto::public_key(); + } +} + +//---------------------------------------------------------------------------------------------------------------------- +// Tests + +bool gen_tx_big_version::generate(std::vector<test_event_entry>& events) const +{ + uint64_t ts_start = 1338224400; + + GENERATE_ACCOUNT(miner_account); + MAKE_GENESIS_BLOCK(events, blk_0, miner_account, ts_start); + REWIND_BLOCKS(events, blk_0r, blk_0, miner_account); + + std::vector<tx_source_entry> sources; + std::vector<tx_destination_entry> destinations; + fill_tx_sources_and_destinations(events, blk_0, miner_account, miner_account, MK_COINS(1), TESTS_DEFAULT_FEE, 0, sources, destinations); + + tx_builder builder; + builder.step1_init(CURRENT_TRANSACTION_VERSION + 1, 0); + builder.step2_fill_inputs(miner_account.get_keys(), sources); + builder.step3_fill_outputs(destinations); + builder.step4_calc_hash(); + builder.step5_sign(sources); + + DO_CALLBACK(events, "mark_invalid_tx"); + events.push_back(builder.m_tx); + + return true; +} + +bool gen_tx_unlock_time::generate(std::vector<test_event_entry>& events) const +{ + uint64_t ts_start = 1338224400; + + GENERATE_ACCOUNT(miner_account); + MAKE_GENESIS_BLOCK(events, blk_0, miner_account, ts_start); + REWIND_BLOCKS_N(events, blk_1, blk_0, miner_account, 10); + REWIND_BLOCKS(events, blk_1r, blk_1, miner_account); + + auto make_tx_with_unlock_time = [&](uint64_t unlock_time) -> transaction + { + return make_simple_tx_with_unlock_time(events, blk_1, miner_account, miner_account, MK_COINS(1), unlock_time); + }; + + std::list<transaction> txs_0; + + txs_0.push_back(make_tx_with_unlock_time(0)); + events.push_back(txs_0.back()); + + txs_0.push_back(make_tx_with_unlock_time(get_block_height(blk_1r) - 1)); + events.push_back(txs_0.back()); + + txs_0.push_back(make_tx_with_unlock_time(get_block_height(blk_1r))); + events.push_back(txs_0.back()); + + txs_0.push_back(make_tx_with_unlock_time(get_block_height(blk_1r) + 1)); + events.push_back(txs_0.back()); + + txs_0.push_back(make_tx_with_unlock_time(get_block_height(blk_1r) + 2)); + events.push_back(txs_0.back()); + + txs_0.push_back(make_tx_with_unlock_time(ts_start - 1)); + events.push_back(txs_0.back()); + + txs_0.push_back(make_tx_with_unlock_time(time(0) + 60 * 60)); + events.push_back(txs_0.back()); + + MAKE_NEXT_BLOCK_TX_LIST(events, blk_2, blk_1r, miner_account, txs_0); + + return true; +} + +bool gen_tx_input_is_not_txin_to_key::generate(std::vector<test_event_entry>& events) const +{ + uint64_t ts_start = 1338224400; + + GENERATE_ACCOUNT(miner_account); + MAKE_GENESIS_BLOCK(events, blk_0, miner_account, ts_start); + REWIND_BLOCKS(events, blk_0r, blk_0, miner_account); + + MAKE_NEXT_BLOCK(events, blk_tmp, blk_0r, miner_account); + events.pop_back(); + + DO_CALLBACK(events, "mark_invalid_tx"); + events.push_back(blk_tmp.miner_tx); + + auto make_tx_with_input = [&](const txin_v& tx_input) -> transaction + { + std::vector<tx_source_entry> sources; + std::vector<tx_destination_entry> destinations; + fill_tx_sources_and_destinations(events, blk_0, miner_account, miner_account, MK_COINS(1), TESTS_DEFAULT_FEE, 0, sources, destinations); + + tx_builder builder; + builder.step1_init(); + builder.m_tx.vin.push_back(tx_input); + builder.step3_fill_outputs(destinations); + return builder.m_tx; + }; + + DO_CALLBACK(events, "mark_invalid_tx"); + events.push_back(make_tx_with_input(txin_to_script())); + + DO_CALLBACK(events, "mark_invalid_tx"); + events.push_back(make_tx_with_input(txin_to_scripthash())); + + return true; +} + +bool gen_tx_no_inputs_no_outputs::generate(std::vector<test_event_entry>& events) const +{ + uint64_t ts_start = 1338224400; + + GENERATE_ACCOUNT(miner_account); + MAKE_GENESIS_BLOCK(events, blk_0, miner_account, ts_start); + + tx_builder builder; + builder.step1_init(); + + DO_CALLBACK(events, "mark_invalid_tx"); + events.push_back(builder.m_tx); + + return true; +} + +bool gen_tx_no_inputs_has_outputs::generate(std::vector<test_event_entry>& events) const +{ + uint64_t ts_start = 1338224400; + + GENERATE_ACCOUNT(miner_account); + MAKE_GENESIS_BLOCK(events, blk_0, miner_account, ts_start); + + std::vector<tx_source_entry> sources; + std::vector<tx_destination_entry> destinations; + fill_tx_sources_and_destinations(events, blk_0, miner_account, miner_account, MK_COINS(1), TESTS_DEFAULT_FEE, 0, sources, destinations); + + tx_builder builder; + builder.step1_init(); + builder.step3_fill_outputs(destinations); + + DO_CALLBACK(events, "mark_invalid_tx"); + events.push_back(builder.m_tx); + + return true; +} + +bool gen_tx_has_inputs_no_outputs::generate(std::vector<test_event_entry>& events) const +{ + uint64_t ts_start = 1338224400; + + GENERATE_ACCOUNT(miner_account); + MAKE_GENESIS_BLOCK(events, blk_0, miner_account, ts_start); + REWIND_BLOCKS(events, blk_0r, blk_0, miner_account); + + std::vector<tx_source_entry> sources; + std::vector<tx_destination_entry> destinations; + fill_tx_sources_and_destinations(events, blk_0, miner_account, miner_account, MK_COINS(1), TESTS_DEFAULT_FEE, 0, sources, destinations); + destinations.clear(); + + tx_builder builder; + builder.step1_init(); + builder.step2_fill_inputs(miner_account.get_keys(), sources); + builder.step3_fill_outputs(destinations); + builder.step4_calc_hash(); + builder.step5_sign(sources); + + events.push_back(builder.m_tx); + MAKE_NEXT_BLOCK_TX1(events, blk_1, blk_0r, miner_account, builder.m_tx); + + return true; +} + +bool gen_tx_invalid_input_amount::generate(std::vector<test_event_entry>& events) const +{ + uint64_t ts_start = 1338224400; + + GENERATE_ACCOUNT(miner_account); + MAKE_GENESIS_BLOCK(events, blk_0, miner_account, ts_start); + REWIND_BLOCKS(events, blk_0r, blk_0, miner_account); + + std::vector<tx_source_entry> sources; + std::vector<tx_destination_entry> destinations; + fill_tx_sources_and_destinations(events, blk_0, miner_account, miner_account, MK_COINS(1), TESTS_DEFAULT_FEE, 0, sources, destinations); + sources.front().amount++; + + tx_builder builder; + builder.step1_init(); + builder.step2_fill_inputs(miner_account.get_keys(), sources); + builder.step3_fill_outputs(destinations); + builder.step4_calc_hash(); + builder.step5_sign(sources); + + DO_CALLBACK(events, "mark_invalid_tx"); + events.push_back(builder.m_tx); + + return true; +} + +bool gen_tx_input_wo_key_offsets::generate(std::vector<test_event_entry>& events) const +{ + uint64_t ts_start = 1338224400; + + GENERATE_ACCOUNT(miner_account); + MAKE_GENESIS_BLOCK(events, blk_0, miner_account, ts_start); + REWIND_BLOCKS(events, blk_0r, blk_0, miner_account); + + std::vector<tx_source_entry> sources; + std::vector<tx_destination_entry> destinations; + fill_tx_sources_and_destinations(events, blk_0, miner_account, miner_account, MK_COINS(1), TESTS_DEFAULT_FEE, 0, sources, destinations); + + tx_builder builder; + builder.step1_init(); + builder.step2_fill_inputs(miner_account.get_keys(), sources); + builder.step3_fill_outputs(destinations); + txin_to_key& in_to_key = boost::get<txin_to_key>(builder.m_tx.vin.front()); + uint64_t key_offset = in_to_key.key_offsets.front(); + in_to_key.key_offsets.pop_back(); + CHECK_AND_ASSERT_MES(in_to_key.key_offsets.empty(), false, "txin contained more than one key_offset"); + builder.step4_calc_hash(); + in_to_key.key_offsets.push_back(key_offset); + builder.step5_sign(sources); + in_to_key.key_offsets.pop_back(); + + DO_CALLBACK(events, "mark_invalid_tx"); + events.push_back(builder.m_tx); + + return true; +} + +bool gen_tx_key_offest_points_to_foreign_key::generate(std::vector<test_event_entry>& events) const +{ + uint64_t ts_start = 1338224400; + + GENERATE_ACCOUNT(miner_account); + MAKE_GENESIS_BLOCK(events, blk_0, miner_account, ts_start); + MAKE_NEXT_BLOCK(events, blk_1, blk_0, miner_account); + REWIND_BLOCKS(events, blk_1r, blk_1, miner_account); + MAKE_ACCOUNT(events, alice_account); + MAKE_ACCOUNT(events, bob_account); + MAKE_TX_LIST_START(events, txs_0, miner_account, bob_account, MK_COINS(60) + 1, blk_1); + MAKE_TX_LIST(events, txs_0, miner_account, alice_account, MK_COINS(60) + 1, blk_1); + MAKE_NEXT_BLOCK_TX_LIST(events, blk_2, blk_1r, miner_account, txs_0); + + std::vector<tx_source_entry> sources_bob; + std::vector<tx_destination_entry> destinations_bob; + fill_tx_sources_and_destinations(events, blk_2, bob_account, miner_account, MK_COINS(60) + 1 - TESTS_DEFAULT_FEE, TESTS_DEFAULT_FEE, 0, sources_bob, destinations_bob); + + std::vector<tx_source_entry> sources_alice; + std::vector<tx_destination_entry> destinations_alice; + fill_tx_sources_and_destinations(events, blk_2, alice_account, miner_account, MK_COINS(60) + 1 - TESTS_DEFAULT_FEE, TESTS_DEFAULT_FEE, 0, sources_alice, destinations_alice); + + tx_builder builder; + builder.step1_init(); + builder.step2_fill_inputs(bob_account.get_keys(), sources_bob); + txin_to_key& in_to_key = boost::get<txin_to_key>(builder.m_tx.vin.front()); + in_to_key.key_offsets.front() = sources_alice.front().outputs.front().first; + builder.step3_fill_outputs(destinations_bob); + builder.step4_calc_hash(); + builder.step5_sign(sources_bob); + + DO_CALLBACK(events, "mark_invalid_tx"); + events.push_back(builder.m_tx); + + return true; +} + +bool gen_tx_sender_key_offest_not_exist::generate(std::vector<test_event_entry>& events) const +{ + uint64_t ts_start = 1338224400; + + GENERATE_ACCOUNT(miner_account); + MAKE_GENESIS_BLOCK(events, blk_0, miner_account, ts_start); + REWIND_BLOCKS(events, blk_0r, blk_0, miner_account); + + std::vector<tx_source_entry> sources; + std::vector<tx_destination_entry> destinations; + fill_tx_sources_and_destinations(events, blk_0, miner_account, miner_account, MK_COINS(1), TESTS_DEFAULT_FEE, 0, sources, destinations); + + tx_builder builder; + builder.step1_init(); + builder.step2_fill_inputs(miner_account.get_keys(), sources); + txin_to_key& in_to_key = boost::get<txin_to_key>(builder.m_tx.vin.front()); + in_to_key.key_offsets.front() = std::numeric_limits<uint64_t>::max(); + builder.step3_fill_outputs(destinations); + builder.step4_calc_hash(); + builder.step5_sign(sources); + + DO_CALLBACK(events, "mark_invalid_tx"); + events.push_back(builder.m_tx); + + return true; +} + +bool gen_tx_mixed_key_offest_not_exist::generate(std::vector<test_event_entry>& events) const +{ + uint64_t ts_start = 1338224400; + + GENERATE_ACCOUNT(miner_account); + MAKE_GENESIS_BLOCK(events, blk_0, miner_account, ts_start); + MAKE_NEXT_BLOCK(events, blk_1, blk_0, miner_account); + REWIND_BLOCKS(events, blk_1r, blk_1, miner_account); + MAKE_ACCOUNT(events, alice_account); + MAKE_ACCOUNT(events, bob_account); + MAKE_TX_LIST_START(events, txs_0, miner_account, bob_account, MK_COINS(1) + TESTS_DEFAULT_FEE, blk_1); + MAKE_TX_LIST(events, txs_0, miner_account, alice_account, MK_COINS(1) + TESTS_DEFAULT_FEE, blk_1); + MAKE_NEXT_BLOCK_TX_LIST(events, blk_2, blk_1r, miner_account, txs_0); + + std::vector<tx_source_entry> sources; + std::vector<tx_destination_entry> destinations; + fill_tx_sources_and_destinations(events, blk_2, bob_account, miner_account, MK_COINS(1), TESTS_DEFAULT_FEE, 1, sources, destinations); + + sources.front().outputs[(sources.front().real_output + 1) % 2].first = std::numeric_limits<uint64_t>::max(); + + tx_builder builder; + builder.step1_init(); + builder.step2_fill_inputs(bob_account.get_keys(), sources); + builder.step3_fill_outputs(destinations); + builder.step4_calc_hash(); + builder.step5_sign(sources); + + DO_CALLBACK(events, "mark_invalid_tx"); + events.push_back(builder.m_tx); + + return true; +} + +bool gen_tx_key_image_not_derive_from_tx_key::generate(std::vector<test_event_entry>& events) const +{ + uint64_t ts_start = 1338224400; + + GENERATE_ACCOUNT(miner_account); + MAKE_GENESIS_BLOCK(events, blk_0, miner_account, ts_start); + REWIND_BLOCKS(events, blk_0r, blk_0, miner_account); + + std::vector<tx_source_entry> sources; + std::vector<tx_destination_entry> destinations; + fill_tx_sources_and_destinations(events, blk_0, miner_account, miner_account, MK_COINS(1), TESTS_DEFAULT_FEE, 0, sources, destinations); + + tx_builder builder; + builder.step1_init(); + builder.step2_fill_inputs(miner_account.get_keys(), sources); + + txin_to_key& in_to_key = boost::get<txin_to_key>(builder.m_tx.vin.front()); + keypair kp = keypair::generate(); + key_image another_ki; + crypto::generate_key_image(kp.pub, kp.sec, another_ki); + in_to_key.k_image = another_ki; + + builder.step3_fill_outputs(destinations); + builder.step4_calc_hash(); + + // Tx with invalid key image can't be subscribed, so create empty signature + builder.m_tx.signatures.resize(1); + builder.m_tx.signatures[0].resize(1); + builder.m_tx.signatures[0][0] = boost::value_initialized<crypto::signature>(); + + DO_CALLBACK(events, "mark_invalid_tx"); + events.push_back(builder.m_tx); + + return true; +} + +bool gen_tx_key_image_is_invalid::generate(std::vector<test_event_entry>& events) const +{ + uint64_t ts_start = 1338224400; + + GENERATE_ACCOUNT(miner_account); + MAKE_GENESIS_BLOCK(events, blk_0, miner_account, ts_start); + REWIND_BLOCKS(events, blk_0r, blk_0, miner_account); + + std::vector<tx_source_entry> sources; + std::vector<tx_destination_entry> destinations; + fill_tx_sources_and_destinations(events, blk_0, miner_account, miner_account, MK_COINS(1), TESTS_DEFAULT_FEE, 0, sources, destinations); + + tx_builder builder; + builder.step1_init(); + builder.step2_fill_inputs(miner_account.get_keys(), sources); + + txin_to_key& in_to_key = boost::get<txin_to_key>(builder.m_tx.vin.front()); + crypto::public_key pub = generate_invalid_pub_key(); + memcpy(&in_to_key.k_image, &pub, sizeof(crypto::ec_point)); + + builder.step3_fill_outputs(destinations); + builder.step4_calc_hash(); + + // Tx with invalid key image can't be subscribed, so create empty signature + builder.m_tx.signatures.resize(1); + builder.m_tx.signatures[0].resize(1); + builder.m_tx.signatures[0][0] = boost::value_initialized<crypto::signature>(); + + DO_CALLBACK(events, "mark_invalid_tx"); + events.push_back(builder.m_tx); + + return true; +} + +bool gen_tx_check_input_unlock_time::generate(std::vector<test_event_entry>& events) const +{ + static const size_t tests_count = 6; + + uint64_t ts_start = 1338224400; + + GENERATE_ACCOUNT(miner_account); + MAKE_GENESIS_BLOCK(events, blk_0, miner_account, ts_start); + REWIND_BLOCKS_N(events, blk_1, blk_0, miner_account, tests_count - 1); + REWIND_BLOCKS(events, blk_1r, blk_1, miner_account); + + std::array<account_base, tests_count> accounts; + for (size_t i = 0; i < tests_count; ++i) + { + MAKE_ACCOUNT(events, acc); + accounts[i] = acc; + } + + std::list<transaction> txs_0; + auto make_tx_to_acc = [&](size_t acc_idx, uint64_t unlock_time) + { + txs_0.push_back(make_simple_tx_with_unlock_time(events, blk_1, miner_account, accounts[acc_idx], + MK_COINS(1) + TESTS_DEFAULT_FEE, unlock_time)); + events.push_back(txs_0.back()); + }; + + uint64_t blk_3_height = get_block_height(blk_1r) + 2; + make_tx_to_acc(0, 0); + make_tx_to_acc(1, blk_3_height - 1); + make_tx_to_acc(2, blk_3_height); + make_tx_to_acc(3, blk_3_height + 1); + make_tx_to_acc(4, time(0) - 1); + make_tx_to_acc(5, time(0) + 60 * 60); + MAKE_NEXT_BLOCK_TX_LIST(events, blk_2, blk_1r, miner_account, txs_0); + + std::list<transaction> txs_1; + auto make_tx_from_acc = [&](size_t acc_idx, bool invalid) + { + transaction tx = make_simple_tx_with_unlock_time(events, blk_2, accounts[acc_idx], miner_account, MK_COINS(1), 0); + if (invalid) + { + DO_CALLBACK(events, "mark_invalid_tx"); + } + else + { + txs_1.push_back(tx); + } + events.push_back(tx); + }; + + make_tx_from_acc(0, false); + make_tx_from_acc(1, false); + make_tx_from_acc(2, false); + make_tx_from_acc(3, true); + make_tx_from_acc(4, false); + make_tx_from_acc(5, true); + MAKE_NEXT_BLOCK_TX_LIST(events, blk_3, blk_2, miner_account, txs_1); + + return true; +} + +bool gen_tx_txout_to_key_has_invalid_key::generate(std::vector<test_event_entry>& events) const +{ + uint64_t ts_start = 1338224400; + + GENERATE_ACCOUNT(miner_account); + MAKE_GENESIS_BLOCK(events, blk_0, miner_account, ts_start); + REWIND_BLOCKS(events, blk_0r, blk_0, miner_account); + + std::vector<tx_source_entry> sources; + std::vector<tx_destination_entry> destinations; + fill_tx_sources_and_destinations(events, blk_0, miner_account, miner_account, MK_COINS(1), TESTS_DEFAULT_FEE, 0, sources, destinations); + + tx_builder builder; + builder.step1_init(); + builder.step2_fill_inputs(miner_account.get_keys(), sources); + builder.step3_fill_outputs(destinations); + + txout_to_key& out_to_key = boost::get<txout_to_key>(builder.m_tx.vout.front().target); + out_to_key.key = generate_invalid_pub_key(); + + builder.step4_calc_hash(); + builder.step5_sign(sources); + + DO_CALLBACK(events, "mark_invalid_tx"); + events.push_back(builder.m_tx); + + return true; +} + +bool gen_tx_output_with_zero_amount::generate(std::vector<test_event_entry>& events) const +{ + uint64_t ts_start = 1338224400; + + GENERATE_ACCOUNT(miner_account); + MAKE_GENESIS_BLOCK(events, blk_0, miner_account, ts_start); + REWIND_BLOCKS(events, blk_0r, blk_0, miner_account); + + std::vector<tx_source_entry> sources; + std::vector<tx_destination_entry> destinations; + fill_tx_sources_and_destinations(events, blk_0, miner_account, miner_account, MK_COINS(1), TESTS_DEFAULT_FEE, 0, sources, destinations); + + tx_builder builder; + builder.step1_init(); + builder.step2_fill_inputs(miner_account.get_keys(), sources); + builder.step3_fill_outputs(destinations); + + builder.m_tx.vout.front().amount = 0; + + builder.step4_calc_hash(); + builder.step5_sign(sources); + + DO_CALLBACK(events, "mark_invalid_tx"); + events.push_back(builder.m_tx); + + return true; +} + +bool gen_tx_output_is_not_txout_to_key::generate(std::vector<test_event_entry>& events) const +{ + uint64_t ts_start = 1338224400; + + GENERATE_ACCOUNT(miner_account); + MAKE_GENESIS_BLOCK(events, blk_0, miner_account, ts_start); + REWIND_BLOCKS(events, blk_0r, blk_0, miner_account); + + std::vector<tx_source_entry> sources; + std::vector<tx_destination_entry> destinations; + fill_tx_sources_and_destinations(events, blk_0, miner_account, miner_account, MK_COINS(1), TESTS_DEFAULT_FEE, 0, sources, destinations); + + tx_builder builder; + builder.step1_init(); + builder.step2_fill_inputs(miner_account.get_keys(), sources); + + builder.m_tx.vout.push_back(tx_out()); + builder.m_tx.vout.back().amount = 1; + builder.m_tx.vout.back().target = txout_to_script(); + + builder.step4_calc_hash(); + builder.step5_sign(sources); + + DO_CALLBACK(events, "mark_invalid_tx"); + events.push_back(builder.m_tx); + + builder.step1_init(); + builder.step2_fill_inputs(miner_account.get_keys(), sources); + + builder.m_tx.vout.push_back(tx_out()); + builder.m_tx.vout.back().amount = 1; + builder.m_tx.vout.back().target = txout_to_scripthash(); + + builder.step4_calc_hash(); + builder.step5_sign(sources); + + DO_CALLBACK(events, "mark_invalid_tx"); + events.push_back(builder.m_tx); + + return true; +} + +bool gen_tx_signatures_are_invalid::generate(std::vector<test_event_entry>& events) const +{ + uint64_t ts_start = 1338224400; + + GENERATE_ACCOUNT(miner_account); + MAKE_GENESIS_BLOCK(events, blk_0, miner_account, ts_start); + MAKE_NEXT_BLOCK(events, blk_1, blk_0, miner_account); + REWIND_BLOCKS(events, blk_1r, blk_1, miner_account); + MAKE_ACCOUNT(events, alice_account); + MAKE_ACCOUNT(events, bob_account); + MAKE_TX_LIST_START(events, txs_0, miner_account, bob_account, MK_COINS(1) + TESTS_DEFAULT_FEE, blk_1); + MAKE_TX_LIST(events, txs_0, miner_account, alice_account, MK_COINS(1) + TESTS_DEFAULT_FEE, blk_1); + MAKE_NEXT_BLOCK_TX_LIST(events, blk_2, blk_1r, miner_account, txs_0); + + MAKE_TX(events, tx_0, miner_account, miner_account, MK_COINS(60), blk_2); + events.pop_back(); + + MAKE_TX_MIX(events, tx_1, bob_account, miner_account, MK_COINS(1), 1, blk_2); + events.pop_back(); + + // Tx with nmix = 0 without signatures + DO_CALLBACK(events, "mark_invalid_tx"); + blobdata sr_tx = t_serializable_object_to_blob(static_cast<transaction_prefix>(tx_0)); + events.push_back(serialized_transaction(sr_tx)); + + // Tx with nmix = 0 have a few inputs, and not enough signatures + DO_CALLBACK(events, "mark_invalid_tx"); + sr_tx = t_serializable_object_to_blob(tx_0); + sr_tx.resize(sr_tx.size() - sizeof(crypto::signature)); + events.push_back(serialized_transaction(sr_tx)); + + // Tx with nmix = 0 have a few inputs, and too many signatures + DO_CALLBACK(events, "mark_invalid_tx"); + sr_tx = t_serializable_object_to_blob(tx_0); + sr_tx.insert(sr_tx.end(), sr_tx.end() - sizeof(crypto::signature), sr_tx.end()); + events.push_back(serialized_transaction(sr_tx)); + + // Tx with nmix = 1 without signatures + DO_CALLBACK(events, "mark_invalid_tx"); + sr_tx = t_serializable_object_to_blob(static_cast<transaction_prefix>(tx_1)); + events.push_back(serialized_transaction(sr_tx)); + + // Tx with nmix = 1 have not enough signatures + DO_CALLBACK(events, "mark_invalid_tx"); + sr_tx = t_serializable_object_to_blob(tx_1); + sr_tx.resize(sr_tx.size() - sizeof(crypto::signature)); + events.push_back(serialized_transaction(sr_tx)); + + // Tx with nmix = 1 have too many signatures + DO_CALLBACK(events, "mark_invalid_tx"); + sr_tx = t_serializable_object_to_blob(tx_1); + sr_tx.insert(sr_tx.end(), sr_tx.end() - sizeof(crypto::signature), sr_tx.end()); + events.push_back(serialized_transaction(sr_tx)); + + return true; +} diff --git a/tests/core_tests/tx_validation.h b/tests/core_tests/tx_validation.h new file mode 100644 index 000000000..e1939c049 --- /dev/null +++ b/tests/core_tests/tx_validation.h @@ -0,0 +1,139 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#pragma once +#include "chaingen.h" + +struct get_tx_validation_base : public test_chain_unit_base +{ + get_tx_validation_base() + : m_invalid_tx_index(0) + , m_invalid_block_index(0) + { + REGISTER_CALLBACK_METHOD(get_tx_validation_base, mark_invalid_tx); + REGISTER_CALLBACK_METHOD(get_tx_validation_base, mark_invalid_block); + } + + bool check_tx_verification_context(const cryptonote::tx_verification_context& tvc, bool tx_added, size_t event_idx, const cryptonote::transaction& /*tx*/) + { + if (m_invalid_tx_index == event_idx) + return tvc.m_verifivation_failed; + else + return !tvc.m_verifivation_failed && tx_added; + } + + bool check_block_verification_context(const cryptonote::block_verification_context& bvc, size_t event_idx, const cryptonote::block& /*block*/) + { + if (m_invalid_block_index == event_idx) + return bvc.m_verifivation_failed; + else + return !bvc.m_verifivation_failed; + } + + bool mark_invalid_block(cryptonote::core& /*c*/, size_t ev_index, const std::vector<test_event_entry>& /*events*/) + { + m_invalid_block_index = ev_index + 1; + return true; + } + + bool mark_invalid_tx(cryptonote::core& /*c*/, size_t ev_index, const std::vector<test_event_entry>& /*events*/) + { + m_invalid_tx_index = ev_index + 1; + return true; + } + +private: + size_t m_invalid_tx_index; + size_t m_invalid_block_index; +}; + +struct gen_tx_big_version : public get_tx_validation_base +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_tx_unlock_time : public get_tx_validation_base +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_tx_input_is_not_txin_to_key : public get_tx_validation_base +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_tx_no_inputs_no_outputs : public get_tx_validation_base +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_tx_no_inputs_has_outputs : public get_tx_validation_base +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_tx_has_inputs_no_outputs : public get_tx_validation_base +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_tx_invalid_input_amount : public get_tx_validation_base +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_tx_input_wo_key_offsets : public get_tx_validation_base +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_tx_key_offest_points_to_foreign_key : public get_tx_validation_base +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_tx_sender_key_offest_not_exist : public get_tx_validation_base +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_tx_mixed_key_offest_not_exist : public get_tx_validation_base +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_tx_key_image_not_derive_from_tx_key : public get_tx_validation_base +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_tx_key_image_is_invalid : public get_tx_validation_base +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_tx_check_input_unlock_time : public get_tx_validation_base +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_tx_txout_to_key_has_invalid_key : public get_tx_validation_base +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_tx_output_with_zero_amount : public get_tx_validation_base +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_tx_output_is_not_txout_to_key : public get_tx_validation_base +{ + bool generate(std::vector<test_event_entry>& events) const; +}; + +struct gen_tx_signatures_are_invalid : public get_tx_validation_base +{ + bool generate(std::vector<test_event_entry>& events) const; +}; diff --git a/tests/crypto/crypto-ops-data.c b/tests/crypto/crypto-ops-data.c new file mode 100644 index 000000000..5622acd03 --- /dev/null +++ b/tests/crypto/crypto-ops-data.c @@ -0,0 +1,5 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include "crypto/crypto-ops-data.c" diff --git a/tests/crypto/crypto-ops.c b/tests/crypto/crypto-ops.c new file mode 100644 index 000000000..b21e2e03a --- /dev/null +++ b/tests/crypto/crypto-ops.c @@ -0,0 +1,5 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include "crypto/crypto-ops.c" diff --git a/tests/crypto/crypto-tests.h b/tests/crypto/crypto-tests.h new file mode 100644 index 000000000..80f658228 --- /dev/null +++ b/tests/crypto/crypto-tests.h @@ -0,0 +1,23 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#pragma once + +#if defined(__cplusplus) +#include "crypto/crypto.h" + +extern "C" { +#endif + +void setup_random(void); + +#if defined(__cplusplus) +} + +bool check_scalar(const crypto::ec_scalar &scalar); +void random_scalar(crypto::ec_scalar &res); +void hash_to_scalar(const void *data, std::size_t length, crypto::ec_scalar &res); +void hash_to_point(const crypto::hash &h, crypto::ec_point &res); +void hash_to_ec(const crypto::public_key &key, crypto::ec_point &res); +#endif diff --git a/tests/crypto/crypto.cpp b/tests/crypto/crypto.cpp new file mode 100644 index 000000000..cbc5879ca --- /dev/null +++ b/tests/crypto/crypto.cpp @@ -0,0 +1,31 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include "crypto/crypto.cpp" + +#include "crypto-tests.h" + +bool check_scalar(const crypto::ec_scalar &scalar) { + return crypto::sc_check(crypto::operator &(scalar)) == 0; +} + +void random_scalar(crypto::ec_scalar &res) { + crypto::random_scalar(res); +} + +void hash_to_scalar(const void *data, std::size_t length, crypto::ec_scalar &res) { + crypto::hash_to_scalar(data, length, res); +} + +void hash_to_point(const crypto::hash &h, crypto::ec_point &res) { + crypto::ge_p2 point; + crypto::ge_fromfe_frombytes_vartime(&point, reinterpret_cast<const unsigned char *>(&h)); + crypto::ge_tobytes(crypto::operator &(res), &point); +} + +void hash_to_ec(const crypto::public_key &key, crypto::ec_point &res) { + crypto::ge_p3 tmp; + crypto::hash_to_ec(key, tmp); + crypto::ge_p3_tobytes(crypto::operator &(res), &tmp); +} diff --git a/tests/crypto/hash.c b/tests/crypto/hash.c new file mode 100644 index 000000000..6981f2be9 --- /dev/null +++ b/tests/crypto/hash.c @@ -0,0 +1,6 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include "crypto/hash.c" +#include "crypto/keccak.c" diff --git a/tests/crypto/main.cpp b/tests/crypto/main.cpp new file mode 100644 index 000000000..5cb5c9ceb --- /dev/null +++ b/tests/crypto/main.cpp @@ -0,0 +1,247 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include <cstddef> +#include <cstring> +#include <fstream> +#include <string> +#include <vector> + +#include "warnings.h" +#include "crypto/crypto.h" +#include "crypto/hash.h" +#include "crypto-tests.h" +#include "../io.h" + +using namespace std; +using namespace crypto; +typedef crypto::hash chash; + +bool operator !=(const ec_scalar &a, const ec_scalar &b) { + return 0 != memcmp(&a, &b, sizeof(ec_scalar)); +} + +bool operator !=(const ec_point &a, const ec_point &b) { + return 0 != memcmp(&a, &b, sizeof(ec_point)); +} + +bool operator !=(const secret_key &a, const secret_key &b) { + return 0 != memcmp(&a, &b, sizeof(secret_key)); +} + +bool operator !=(const key_derivation &a, const key_derivation &b) { + return 0 != memcmp(&a, &b, sizeof(key_derivation)); +} + +DISABLE_GCC_WARNING(maybe-uninitialized) + +int main(int argc, char *argv[]) { + fstream input; + string cmd; + size_t test = 0; + bool error = false; + setup_random(); + if (argc != 2) { + cerr << "invalid arguments" << endl; + return 1; + } + input.open(argv[1], ios_base::in); + for (;;) { + ++test; + input.exceptions(ios_base::badbit); + if (!(input >> cmd)) { + break; + } + input.exceptions(ios_base::badbit | ios_base::failbit | ios_base::eofbit); + if (cmd == "check_scalar") { + ec_scalar scalar; + bool expected, actual; + get(input, scalar, expected); + actual = check_scalar(scalar); + if (expected != actual) { + goto error; + } + } else if (cmd == "random_scalar") { + ec_scalar expected, actual; + get(input, expected); + random_scalar(actual); + if (expected != actual) { + goto error; + } + } else if (cmd == "hash_to_scalar") { + vector<char> data; + ec_scalar expected, actual; + get(input, data, expected); + hash_to_scalar(data.data(), data.size(), actual); + if (expected != actual) { + goto error; + } + } else if (cmd == "generate_keys") { + public_key expected1, actual1; + secret_key expected2, actual2; + get(input, expected1, expected2); + generate_keys(actual1, actual2); + if (expected1 != actual1 || expected2 != actual2) { + goto error; + } + } else if (cmd == "check_key") { + public_key key; + bool expected, actual; + get(input, key, expected); + actual = check_key(key); + if (expected != actual) { + goto error; + } + } else if (cmd == "secret_key_to_public_key") { + secret_key sec; + bool expected1, actual1; + public_key expected2, actual2; + get(input, sec, expected1); + if (expected1) { + get(input, expected2); + } + actual1 = secret_key_to_public_key(sec, actual2); + if (expected1 != actual1 || (expected1 && expected2 != actual2)) { + goto error; + } + } else if (cmd == "generate_key_derivation") { + public_key key1; + secret_key key2; + bool expected1, actual1; + key_derivation expected2, actual2; + get(input, key1, key2, expected1); + if (expected1) { + get(input, expected2); + } + actual1 = generate_key_derivation(key1, key2, actual2); + if (expected1 != actual1 || (expected1 && expected2 != actual2)) { + goto error; + } + } else if (cmd == "derive_public_key") { + key_derivation derivation; + size_t output_index; + public_key base; + bool expected1, actual1; + public_key expected2, actual2; + get(input, derivation, output_index, base, expected1); + if (expected1) { + get(input, expected2); + } + actual1 = derive_public_key(derivation, output_index, base, actual2); + if (expected1 != actual1 || (expected1 && expected2 != actual2)) { + goto error; + } + } else if (cmd == "derive_secret_key") { + key_derivation derivation; + size_t output_index; + secret_key base; + secret_key expected, actual; + get(input, derivation, output_index, base, expected); + derive_secret_key(derivation, output_index, base, actual); + if (expected != actual) { + goto error; + } + } else if (cmd == "generate_signature") { + chash prefix_hash; + public_key pub; + secret_key sec; + signature expected, actual; + get(input, prefix_hash, pub, sec, expected); + generate_signature(prefix_hash, pub, sec, actual); + if (expected != actual) { + goto error; + } + } else if (cmd == "check_signature") { + chash prefix_hash; + public_key pub; + signature sig; + bool expected, actual; + get(input, prefix_hash, pub, sig, expected); + actual = check_signature(prefix_hash, pub, sig); + if (expected != actual) { + goto error; + } + } else if (cmd == "hash_to_point") { + chash h; + ec_point expected, actual; + get(input, h, expected); + hash_to_point(h, actual); + if (expected != actual) { + goto error; + } + } else if (cmd == "hash_to_ec") { + public_key key; + ec_point expected, actual; + get(input, key, expected); + hash_to_ec(key, actual); + if (expected != actual) { + goto error; + } + } else if (cmd == "generate_key_image") { + public_key pub; + secret_key sec; + key_image expected, actual; + get(input, pub, sec, expected); + generate_key_image(pub, sec, actual); + if (expected != actual) { + goto error; + } + } else if (cmd == "generate_ring_signature") { + chash prefix_hash; + key_image image; + vector<public_key> vpubs; + vector<const public_key *> pubs; + size_t pubs_count; + secret_key sec; + size_t sec_index; + vector<signature> expected, actual; + size_t i; + get(input, prefix_hash, image, pubs_count); + vpubs.resize(pubs_count); + pubs.resize(pubs_count); + for (i = 0; i < pubs_count; i++) { + get(input, vpubs[i]); + pubs[i] = &vpubs[i]; + } + get(input, sec, sec_index); + expected.resize(pubs_count); + getvar(input, pubs_count * sizeof(signature), expected.data()); + actual.resize(pubs_count); + generate_ring_signature(prefix_hash, image, pubs.data(), pubs_count, sec, sec_index, actual.data()); + if (expected != actual) { + goto error; + } + } else if (cmd == "check_ring_signature") { + chash prefix_hash; + key_image image; + vector<public_key> vpubs; + vector<const public_key *> pubs; + size_t pubs_count; + vector<signature> sigs; + bool expected, actual; + size_t i; + get(input, prefix_hash, image, pubs_count); + vpubs.resize(pubs_count); + pubs.resize(pubs_count); + for (i = 0; i < pubs_count; i++) { + get(input, vpubs[i]); + pubs[i] = &vpubs[i]; + } + sigs.resize(pubs_count); + getvar(input, pubs_count * sizeof(signature), sigs.data()); + get(input, expected); + actual = check_ring_signature(prefix_hash, image, pubs.data(), pubs_count, sigs.data()); + if (expected != actual) { + goto error; + } + } else { + throw ios_base::failure("Unknown function: " + cmd); + } + continue; +error: + cerr << "Wrong result on test " << test << endl; + error = true; + } + return error ? 1 : 0; +} diff --git a/tests/crypto/random.c b/tests/crypto/random.c new file mode 100644 index 000000000..05d7cf5ff --- /dev/null +++ b/tests/crypto/random.c @@ -0,0 +1,11 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include "crypto/random.c" + +#include "crypto-tests.h" + +void setup_random(void) { + memset(&state, 42, sizeof(union hash_state)); +} diff --git a/tests/crypto/tests.txt b/tests/crypto/tests.txt new file mode 100644 index 000000000..a02e71ee9 --- /dev/null +++ b/tests/crypto/tests.txt @@ -0,0 +1,5480 @@ +check_scalar ac10e070c8574ef374bdd1c5dbe9bacfd927f9ae0705cf08018ff865f6092d0f true +check_scalar fa939388e8cb0ffc5c776cc517edc2a9457c11a89820a7bee91654ce2e2fb300 true +check_scalar 6d728f89e567522dffe81cf641c2e483e2cee7051c1b3cd9cd38cba09d2dc900 true +check_scalar 18fd66f7a0874de792f12a1b2add7d294100ea454537ae5794d0abc91dbf098a false +check_scalar fdb4cee00230c448aeaa4790dd12e855eca6223d81dab6bfe3fe99ce5e702325 false +check_scalar f3ab5c4a64f9afbd48c75ad25700996a69504d31c75a6aa8beb24d178cfc32ba false +check_scalar 167e88e9298926ecd66d32a890148a9adcfb80a7ecc69396edc5f5ee8848ce91 false +check_scalar a9172ced17605ab2ba82caec382f1176fe6a1e0b92a9c95679978b3999d22605 true +check_scalar 44f65ce00e64cf29e07bf3843e8e43e83b8b26d3dfcd83160d9a3fedda3fc908 true +check_scalar 69951c807647f4dea33f8a40b0ddef999a9e8efd1b1b176f45fb92aae6287000 true +check_scalar dcb6f94312b4b815101af10775d189301d063816b0aa9b9ac028c0eb9b17dd0e true +check_scalar a1a9574a90bed7f58bfd4c3295e181e152a4a39f9ad56520947e94fea40dfe2e false +check_scalar 757ebb27b14433f3ed696cd291825eba555af0863862216a98cf3080432bda01 true +check_scalar a7401d68c7956d41a05d8c6c1a3cc692cc269ad8a5837f93ac2c7654abaebf0e true +check_scalar 7c84ef4d9627529723f5e171a88bba91118192e6e19929204a6d23f5a541850b true +check_scalar ebe4b2f9eadd52271e1115aa3b89b7bb3f68d58bf74d75486b77e6ae8216f609 true +check_scalar 6221caf5dfd623587ca7aac45f5312faf1c2847d7bfbc5c46f88fd933970c866 false +check_scalar b38334b41f0b829bf3a2ea73b58c16afb56ccba5144668e78257ed4aa9a33a5e false +check_scalar 92e5df37f5412d9e9910cd28d27138ba46bdd4dee5dab1125f200f0a4e66f01c false +check_scalar 2d1717fe2965133009bdcf0c13b02ca85df4dc23d969d7b16fdab94341c2b90e true +check_scalar 82d771565024cf4b5c9add6d10a4114a2fbdbf7626f03749c8bddcf6c6feee03 true +check_scalar 2db0f3d9bf47666bb40ae25ef7508296af2ef665a5333efff92c9daee5ecd986 false +check_scalar 47883a3f0b0e624512887f3dae6f401b2f02eb8950eb8e741f07347108fbea14 false +check_scalar dae25f27f2756b8270f78015b1beafbd03a8d67a4dd940ee9550cecae9f3560f true +check_scalar bab79d355572361259484ca77308943b7c71f5831be5dde11b3c7a26ac6e9a01 true +check_scalar f0bf30a9862d51fd8d1ca3a4e5a0e4330a5beab751af075b2e46f3e2d0297101 true +check_scalar a94270659333c985ab1461e9820f219416ad76f551a34f4c983ca967aa6b618c false +check_scalar 98e582e9d0e485e6b756e44b1cb187e9f2d4e16c02d2713a41dcee6d7fac0205 true +check_scalar 62b57869238e72f05992e01f07c7a26c71ef9e3078ee7390cd4fc6406d3b37e3 false +check_scalar c751566f5420232cd626d2bd8073debedf219a0a28a7390200a2df9df8981647 false +check_scalar cfafede7d76def164bf15047a388365d712a600f1369bf692cb2dcb249f66508 true +check_scalar c0eb03c2c46a77b0cf67bea7d547b9b4d02116f70702790398bdabbfa775100a true +check_scalar 58c5afbb7b334e921bb46eeee1dfebadfbbc3a77c420b0b325b9470eff94cc0e true +check_scalar b31b178b4dc8f7a7c24f6eb0987e32b8a9446ce8207186259074cc3d925c530d true +check_scalar 467b2c5f63120744b5aee7ec255d170aba83babdec9e76c2690300540eb17483 false +check_scalar 9bc3be487bea81da020af0353660878e7deca693ac81278fac343b8b1809bd9c false +check_scalar 162cdb42f9d9147118537cc4d5eadb8f589f6de3929188f6c41428bdab2c650e true +check_scalar 6eeb88f685d1b5c99f8c27dcadf95f5bea9082e2735a4f8aafc3c3a35f749002 true +check_scalar e03bb5c9bedc41d324ca6d988e50b7e7c6cd6d2b1e471b752a00a10a19c9a604 true +check_scalar 4fa064dcef2f14fc453c30865583468ad35af81c460a643b11285c15f2babb04 true +check_scalar bf067a7b53dab7fcd6a1f5a2c8b9b54c262e9be5ea5892dba5e4ad25585be702 true +check_scalar 14d8d255c2156bb12133d5ee792061a21d3fbda2f14310753f3a90c2ad4ccbc8 false +check_scalar 81e78a37b7e2dfed35ad8228a6c4a6f0aa34cc1de43da23895c5c86790804e01 true +check_scalar 62366805970fb07b877bf1705d9c10517c6667ab7586d9afa82c30236a72f50f true +check_scalar bb3b0e27b7c57052e5ac20bc6390229f57c6dbc8213dbc4ee1cbb9e174e389f9 false +check_scalar 5c4039f162531ce9129667ed424446ef375a18da246a72c0dab00321fa04e929 false +check_scalar 8d41a450d98a6f354266e36510921649e5229412976f8f318a3090d390a46807 true +check_scalar 2fbce4441723379b8b6ef417803eb9220c8fee42f72da7e36e2c64b51628a10c true +check_scalar 5bbf0e5b58e3df89a5f4c607e3033fff8b9643fc900813f4ea50b889260bb004 true +check_scalar e5acfcb2ecb7175f90aa24db107cea1be7a45bc471c4c65b9f46535768545de5 false +check_scalar fae6e8d7226e6dc25faafdd8b5c63b68587980f6e76ea59b8595f18f64a96bd5 false +check_scalar 6736f7939157ccee066a40056c13d96230ca5ffd014b0ebb0a454e3d8ea6830f true +check_scalar b2b490d52f6e4d9ef14fc1ab3e1e97160693ba5d1220e4d63956eca316693504 true +check_scalar dca490cb4e21589e045150e8c0876871f08e6b3886c6393c6348bfb432799079 false +check_scalar ca2663d84aa7d7581ac4f0a270a685019178f5288013d163028d321e92b04901 true +check_scalar 7dd277472249a53620d6b21c1ab0424024581b5ae3e6ecb9a46af8511b55a408 true +check_scalar 30f07adb405de73987d81fcba3d523d420d130fe753afbf3dd19d5f08e8a1356 false +check_scalar cc31de9889440c695df43a9c621a7156bc064b161be2fdef35dd8ae0e1017fe2 false +check_scalar 962ac1be6677cf0d298dd1244501e6a164a915df61b83c2837f80a84541e2e03 true +check_scalar e0a1e1c48f5dfb7c0faddd9186214ec2f81fb0bc3aca423ccf0e538cf43a2bd5 false +check_scalar 8ed93780cbd46092acce856a8c691edbb8419deec5acfb26fcf82419b4a964b9 false +check_scalar f62cf00cac227d2b96e7f96268f0d606ad5924b0efb64e623e25584f993c93a8 false +check_scalar e49eacd6858efad9f3bedba8b9edff5ff3d5bd622926d5e96e6e8c8752a43d25 false +check_scalar ed424965b9a79c2f6611d7d4bcbe5bae4dbf2c8130141c714acc95c492061411 false +check_scalar 7ea2bb2a4dab662c3adf71eb959314208ff9dbf50b3cb1a7940e4a4d6d797e0e true +check_scalar 96fc939742b8ed518bb7aa4bb6c9bbe3fddded6b9441d9ea27712c377e0bdff1 false +check_scalar c5122ad5575b54ebce3f1d1d97c3bb0cfeb9e5ea3bb223ab63189ced40579cf4 false +check_scalar c9147f1b42890b089ae2dfdc27f69b4a29c67b8bc0264259fcf71c39e31b893c false +check_scalar 9292516356f70e84852c3a563970bff369dfc39325c64432610baa0f31f2320e true +check_scalar 85f8b6251f177701b319c5db4bc372a5cf05cb07d86b2b2d5c938b0faf6d670f true +check_scalar de88df59b4e8e3fe2beab575b4c6ffccbd24cf294f890fa61cbc231b0c976f0d true +check_scalar 2922bd9b50e09fe75a3745c62afd5bd1813dcffcf4503668e71d8f5d37c0090d true +check_scalar f090b3ed9355221e4fb40397c367fb31a2c7ce308ba96b9c4fc9610c14cbe305 true +check_scalar 1c545854bd134a995f2138d6d088032c33a9a23a30748615652e6675d56e670f true +check_scalar 588050d78a3079a12bc88d6bcaf34a95bc6928c9233f14056277bf36bb355d26 false +check_scalar 3956481800462e5c34aa2178dde33d5096c23185d61a5839c212d11e61adc901 true +check_scalar d0d61e471d5d503a6efcd549694b61851a58b0c8f8fb400227e2a48c1cbe4a0d true +check_scalar 1eed64f825d3f1bba4a226425dbef91f102ec01bcf4a0ac0a00baef8de20c405 true +check_scalar 86764f74c855d580581ff17416a2c394de55bb3cb6e676756e86f3893ee61a09 true +check_scalar a1cc5ecb2a528ab8fe3efac17a2859c2ef1b81b51d18643bb3ee3fcc8794eb80 false +check_scalar 740464b60e54da6a3541057742d327330ae5ac190e2b86708f5af7a1ff89fd0a true +check_scalar ada63ca80e15912177b738c7c7618917827893b57ad20688a0a9c93c6c7c4e0a true +check_scalar a55a6f1f2cab41704b251d3c64f3123f1635e3ee24fcce7e88cdaaf148636500 true +check_scalar 515bfea540021ffb6d8f2324952a1ffa02f40adb860cff143ff0d797bd63fb09 true +check_scalar 2784fbff1cad8d63b47359691caf8c7972219d7f9a64ee25fdbfe970981b2e87 false +check_scalar 596071a52ac2e1b55001170c7ae5ee8a66a52e4b14db270a66c4828eccfca8a5 false +check_scalar afee887ccf82dd3406988f4afafd0d779e43d1f0f1b5107b1c3aed15d4ab57ed false +check_scalar fb38ec6e693ee2aed1364c29dc7a60a2a7cb10601582a0ca4f4a0ca2c0499e08 true +check_scalar 7f890e7539b8b3e6510a3f523a764f582f9e2c791400678eee85bd5842978c06 true +check_scalar 26efbf6e436e974860ee3b6c197afa55c29b115e68b488ba46c1e865fe37f894 false +check_scalar 6f6d9f15f262dde42c60af6880e8c6b6f07cab7cad785c19866f9a5c37419240 false +check_scalar f90673b823b480de9e560948307e1ada8ff1f4380e74e89ee45aa7fecae1d308 true +check_scalar 269abc577fd32b1625895a1117dbc367822f9849441d4dbf7f56ca633fbf50b8 false +check_scalar 26fcbe1690ff0bc306a9ec3cef75bee1a5e39710d5c02d46334fb7d89e75dc0c true +check_scalar 48c827ac48cda0f2ccd29a37884a14fa9cebe2ddf76bcc4fdf827245835d1daa false +check_scalar 9c82c6403ec29e60ad812c1762610e00c05891c6eb0fbf2393b886f298397e1a false +check_scalar 260fb700bf36504bfc5bea76c115929746f4aa709ba831fddb64b59af9bfd704 true +check_scalar aaff292106a5dd831c507603f72fb7e0b9aa5ad990575a7a3dbe83744668c552 false +check_scalar aca3f81877ac78519ce2944063fd7c50530d0ba7de2fa20ebdb1107872b6f302 true +check_scalar 1086efacf20320ba25eedd1cf8d3b28348b0bf3e2191b7585e16dc9e4f7f5803 true +check_scalar 66905a80d3d06c38faa5212c7455e5f48cdd5f15d816025b6466c085ef6f2d51 false +check_scalar a9fb08088371cc78c2b514608cee6b43c534e657d4e1f7d0cfd9fd4173aca769 false +check_scalar 590e0a35ac44640ecf0f1f89eba200c6d98245b87360496ef408297af0011673 false +check_scalar 9a83a1ab418d8d9e92e0ecde0cb1246e4b25f407c5421a3997cda43ede83930b true +check_scalar bd3b91b68594291e859ace170fedcc64adfff013ed9f066bc625326e452ebc54 false +check_scalar ef68e423644b94c8549a9a8ca49e396d642ef0fc28448b77b2bdee1487787a0f true +check_scalar 6a6fe13345ffd78567560c8dfb511f20edfc15067212aaee69bddb77d5b4860e true +check_scalar a1fb1f4e3e88997e4e4017a8346d37671cad86cd5d795d2550b1b9c805dfdb0f true +check_scalar 99e61e19a4c6c94354a5b7a6e206663f677223a6d3fc78659d9eaec21ef38402 true +check_scalar d4bf37268f05041950d82420a78753d168b8b808628b48d6ce7b0ed330701d02 true +check_scalar fee112a3e2de6313bc8809aba4466720c552d3615538b0523163fb01cbd1258a false +check_scalar b9692112ef467088d7f32a873719c7f2179be1445aef71eab73f218e6d6336b9 false +check_scalar 9aa00cad08702566bc88d11a2e8a99b188efd0d5fb164a1b4f3fc7378b962800 true +check_scalar b4301f1630b288b9d6a8afed5c72c10c3c3ce8c935a7aed218e8ff3f70b4a539 false +check_scalar f7f4d3bd2a84cf95d8793bd5e792510d5e95b8ce833775572e901795b5e1bd01 true +check_scalar 3b7d10a8b1a2695dc00c7f12fc12c0876b27509b1ffa452c8b80643f3cd26315 false +check_scalar be2fa0a79bfa9fad3d7e9be1e5961c4849a38a1f4243a0c55d65d019a4fc5c0b true +check_scalar a03687639bb3d2e8506fcf8d062fbc342b499dfc26d36baea80edc87674d6b0f true +check_scalar c995ca23c04d581d52f7e550a4531b837f185ef58362b13f237964c0663f0139 false +check_scalar 32865bf3762338c5e13fba1ffcc08629498a31af695813f221ebfba72ff7714b false +check_scalar a8f37b565fe66aa2e851a74904e98c3059f92a037979da3bd4a52a10f719bf09 true +check_scalar f7474c236309d9888f0d8a53ab5a22bb4d600f3687a4e1d2815b89f866523202 true +check_scalar 090d4f638d250e4588d1a25888c0b9ac6c207e4a98a9ef5a69ad0b6b1ed7ce1f false +check_scalar 6b6daf404e2b6f4e2e0398baf8627fed108d0a0bc38a364e1b5d55bfd63f6d21 false +check_scalar 7e83a7bbf587be0694738f36bf52b24577a3489d72f7426ec0886a37ece4f10d true +check_scalar 5f7abc23dcf726378db619bc2ce1e86ae209daa6d1909117ce7270829c4d3da3 false +check_scalar f9ffc537ad782ce9f00f80be30e8b822c901bf62b2433c365a2f856e65f88706 true +check_scalar 9d3374f71e9ad3dbad360d8a80bc8b5c0d814eb09cade0c62bc094b858849004 true +check_scalar f97097fe5d46b78e030a5207f1db92df9c8efcb0051b6e3b65cb1a58dfab660d true +check_scalar ead8314b9663a10344eaad550137ffb0906500057efd4a28b69def67bed8a10f true +check_scalar 38ca4c5eefa2a159c05eac5e05466db588c8fbbac7df6717e1c2fc1cd15e0956 false +check_scalar 9b43159b9077fb2a049aa067e1d5c1a0d16da8515934b7588f4670483050ad0e true +check_scalar a43c8bb23b53fcd288d71d301e9cdd225bdf88e5d58ef3b485d8318c19fb9b9d false +check_scalar 2278fffc9472031130714cd01599f4a476fe5b94cd092fdc5568917fb7a479f9 false +check_scalar b78718c39d1c90448ef8787350c8baaec08de36ecde9ac234eb570397761a703 true +check_scalar 48a8506dd388eb99eab0d587bf4a7bd34e68f001eb88999a76f1878c32b8e478 false +check_scalar 659eb800501cccb504ae9bdcf5779ba8b2d24e4f63824c84124c453a34dd3540 false +check_scalar 1ce40f32aee47060a0dadf34ce04f81c48af3218051770fb86976785f981b05e false +check_scalar e7360d88d6dbbf3c352b80811110235a213aa5a3ea182d36c8c670ba9610a00f true +check_scalar 82934fcaed4804020e1ce4ff798c30312aff862b1371f7f74d71b4316b413806 true +check_scalar 5bb1383ae3547b8caeba767eaa73a8fc08ac5972f982c736568424f8665770ac false +check_scalar 533b7c9bde705efe0c08a8a0605ea2d4c3ec21919aeca99b40e10e29ca7dc255 false +check_scalar 93c1411f47251750b1b95c481d0ce55b401722273932914e2d1e78924e08fb06 true +check_scalar 5b90a4fd7d50881168802f7a8da19437305e38203b6bb6ac68b114b59dfbfa0e true +check_scalar e98125b5ad8262054c811f92d0596863ef876cb86c7f6b5783aee2e8cd6a5300 true +check_scalar 3b47eac89bc19bc46dde8fb091bb1128ddfb070cbac09b65d37416d62b1d9d3a false +check_scalar 4710f6af3f144eaa2a8f1f2af329bebe752d3594c73008bad237e5e0be0cf07f false +check_scalar a6a654a6e2d2ecd7b1daea341897658b01ab34f7e84d9fc1b3ebf8214b39a840 false +check_scalar 006ba25fa6dc45938b6ab7bf6fe7096bb0eee2fc17688995a3a01567739503d2 false +check_scalar ec2a2a700045b57c85c73770fbca5896aba8941ae39035a29641891ddb309a08 true +check_scalar a6ea18e936f99d7f284553e83545cf324784e5a263f47cdcd78cfc4da10cf80b true +check_scalar 86853a4044faaa87e2a949d9623d523eae1022467816a713488ef18de5db590a true +check_scalar 0f79400a90af899e64dc6c718cb2df4f8426cc77e1745e64af2dfc4743f4ef08 true +check_scalar 4b9727146720b7b9fc2bb00b7b65b18909b53558fc5c4777e2efcb336ce9f103 true +check_scalar 4a71e9840fb19d79255f06456bceda85029950a9d7aebd80f19da16672ea2e4f false +check_scalar a76d81141e740c48642aeecb93f87edbe74c94d7795c35938979913f62355350 false +check_scalar fe82ea864b773ba785ae30742142fc95a6311f1caeacba19ed019a11b3ddee06 true +check_scalar c43a927dd10a6fc47bd3888aa9d9613ba258ad838832b923251a2863691c0600 true +check_scalar 55d66194e087988015066ddc0237d061163797305034f8b54524e935f832ed08 true +check_scalar 650c717392bdf31373dbeda48d99fd10b76080f0319b6039f48eedc8de8daa01 true +check_scalar ef8a542e46802078598d8f41489c0d618cc19ac897719f3b298ea22cca35030c true +check_scalar 6f8be2599f25b3645571a0d3edda8d354218f1bac4e22fed861fb472ff615a04 true +check_scalar 78b99806f01c239ea3e717e15a509ffc2f3c7481b5eceb365f7eb8e2ab13d907 true +check_scalar 2bae1ebc0fb83cade154f1daaed5d1f03581f350e733f2f0d56a73fa3c97cf2c false +check_scalar 4c9f5a53e544ae46926b1504af11a7500f57487e62836c3f37b445c2b701dc0e true +check_scalar 162003195972b318297a38632d9859bc86f1677154f94996970a320e0d23aa05 true +check_scalar 9563b33d7a9a751d3c8ae2b4536bc2ed7cf5231051191653d7c08d502357ed0b true +check_scalar 2ffc2e41884b11129e1cc83aa95cd0b44dacb040a9ff1809a353597af8af0736 false +check_scalar ebfb376fb3a20871f35a54ecc2bf0003a2f2d00838196f0860e229c1db21e90c true +check_scalar 3da00eff81fd6771a23481fa8719fbe674c0dffa8db583e5fc0da7c9a0713006 true +check_scalar 2d492ad9915f6274a6b62cdc245204527a1216b4ef0e7e1e1d3aa6d81f0c3905 true +check_scalar 1a6d227bc48af4cff57ab11dc7ba3b7da21a9998b05dbeea4c05ca8bcffe2277 false +check_scalar 8db67435b9e243dfbb58f252061ca3a005d197b941fa1f9cbbd29fbeafd507d4 false +check_scalar b2f744640c89049ebbbf94bd3013d3103ccf0e750a810543b39601116dc3300d true +check_scalar 8177e87433900f41dbdc22db054c79995f6f610647bcee7527f51091f5198274 false +check_scalar 2c7cbaa6142473cecdb1c10bf9fc2430984a4b6cd34afc607668c6d88bf24f06 true +check_scalar a0a2ccb60bcbd0eda5dd11540e3517462bd841d58d4aed185beb5cfbda9e5f34 false +check_scalar 767219f2581c07b1bbccd62fe4af10b4e202538fe918cedefbba3297bc89b604 true +check_scalar ed8828a708c013d80fe558be718b1e738063c4eca7528c06067b73d9dd2adccc false +check_scalar 4e81f8c4a0166a40db4063b31a5a4e511648b0f094d8930d956f74a7bec44f03 true +check_scalar 09d5a71ca33bbc186f06b5ece548f25b0d008ad71c04e55d3d4c5fe0ef960b19 false +check_scalar 51aa0d12359bc5819055618be5955824d81bd6e5ef52d51ee7e75aa9ca09edc4 false +check_scalar 94927b83b0f167631a5c8eae13a9290c027f795dbd0c3d0f2d1a270b65db05e4 false +check_scalar e30c00666b11f332690267f3a2b8caa93a9a6e3961522a4ef886f3768f4c4166 false +check_scalar 6ec7e22c9921501879a85c89c2833e04526538c6cbdecd8a040fe6c57c881c06 true +check_scalar 54a4299c9d8572857247843d38842926fc88064905d8041974a1d9d407313a0f true +check_scalar d4604b16400e77f37e8f6f5cc4ced1ef0da8f2a832bf6a0f51321d221111ce83 false +check_scalar a545d4cb99de9fc8f976356996351009628be30201dd42a11f7b379a5099c40b true +check_scalar 7db6f2c324cda1f3c9b39d659e5b5e39ad8e4b65e31e3afc10e91f890d6c0b9f false +check_scalar afee4fe9a50c0d0aba669ca7f866ac4eb16e83afd843f142caf1132b9c5bcd11 false +check_scalar 03cf1b6414acc2990bf4df95a9afa40aefcbc55946f8f40298cec7b45e942b09 true +check_scalar 82c67f0cc06d1f5d878e710dc3734dc9b698fbd43b9cfaa50bc0734240631eee false +check_scalar ef10fc4f79bdfade5af636fd41a7e5c48e966b5562693fd7a95568f52d472d06 true +check_scalar 0ce4ab8a2f342f7ff2fd10b1b734d5333c7f8240075b2ae8522313d192d8a01d false +check_scalar 745a1228beb514bac4521c342b345f301fb28e7bfebb85d3c22497d4474fe904 true +check_scalar 684cfecbb321a4236354e94fd8bc74c22a28f1a3ee7e21193b0cf264204fce51 false +check_scalar 14a31b0cf4630e8e74730979d661c1902ab2f47823244ff7809be751b273b00c true +check_scalar 6c0c31a9e40faf4ead079582dae043bee80f27fbb8b76ffa5c960083d578ac0f true +check_scalar ef49cd4030926ad3dbc08425fedfed7de48a1ca119259abec5600be5b60deb0f true +check_scalar b432db4174848e42b9a680c74d66e746a48cb397b4008815064178cf7acec91c false +check_scalar 8c041643a91de5b9a652c3edb1b2512656daf33521197f7ab01056aa04d33708 true +check_scalar d683e2784298e070cd686eddc848e1ce3205c42822650cf9bc2301fb9a330564 false +check_scalar 48ad5703dbf88a809d1bde1d295c4e51e3cf24215a3136c251c165505f80e84e false +check_scalar 19d22f694db4b90b5500af61b7d6a26d5568b4a3048ddef5709698ed6df8820b true +check_scalar f8d5164c397f22c6b8cf3ae26ebfa4a9fe893afc2d7aec1f7c4f1e46c9eca306 true +check_scalar 64a5a328e130e416cf1b3fb3accd3bd032f66df404f5364e0ec9d18d652196c2 false +check_scalar 300931fb2c3670af36168883af39e10e1593945114e11c4eee9547d253f4f504 true +check_scalar 0bbe9316029ea6d59883574d39d1fcd3af3344d73033e2b615f0883361a11602 true +check_scalar 75609b2f7a8c04053ba7c1dbfc1b7c2a8f00720817d1abd2dc1db11645bbaaa1 false +check_scalar fa98e50dd3e3fa8308ffe861194920ec6b4f431eb34c67d7332a92830a7cb20d true +check_scalar 50b48576275008950b552a94e32d25c0835cb6dd44e146519848c9a7ee003707 true +check_scalar 032487e8b30ddec54b5cf90cbc38dde71104169e48228c2336916f1575c1c005 true +check_scalar 574fe8ee31b42bcb9224c34c34ddca2908db4b5f4f630ce76244d1257f81e504 true +check_scalar a4bba7f4765850dd77a67e56cf89e3c8967ba8f3c72ba14c7ea014202f81780b true +check_scalar 90eca818a69f6b8c52bddee273f37eaa96c58f2322fa5f09de36d606edc2ef04 true +check_scalar ac689dc28cb94239b78e6dd66249feec0519686e0a3f974ef8d4760d320de842 false +check_scalar a578412ffcd608f1fc4d77b954b5650d5016a24747e08664373a6c1c8d61c71a false +check_scalar d5b2f9a4b3ae8dcfc1a2ade16b320d7d00180ad72e9ba500cfeceb4e45335c00 true +check_scalar ba26b0105b5d74df01e27ac128303cf4f139b2d164772ce56a31b5787b5d2207 true +check_scalar fb9e9e404f5901ffc02ba848ed33c98a88365ff161b4d484f67f8d4d2bc9fe85 false +check_scalar e326865f9ee2b68fdff8c36d39672f897669d9efb52bd4b4d037f4e219f72887 false +check_scalar 8d911a2a666472a69614bbdd887169936e4e4384992cffac6f5c8ad3f81da708 true +check_scalar a9c04591640432f35dcdcdbe5027080c31613253f01a8e4fb1c2ed04f3e8c2a1 false +check_scalar e5e18376596aa363f1de26fb318eadaee85792bb7e51af164ba80da6e358ac03 true +check_scalar 2632ef6ab45b46f2a48b5691c3e82e54e50ba74f23751aa602ec77a39596a10d true +check_scalar f110202b14458789eb17321f757032e3515012143e8dd156a401d0b48ebb6287 false +check_scalar 82d4274f7518f0cf92637657c69407a5fccb685ce9de8fa617a6f6f6b86c290d true +check_scalar e1d9512e60b4dab6b55f14f56c320ad8eda6b8e378c5f873ce5d89c622c76c0c true +check_scalar adf9a384148ff31f52f4e2365c5234b93edd574df1b5b664650859a764130f07 true +check_scalar f5c8043c4b5a3a1ded6d02af7e048d298872e8fedbdfdb544b881215313956f9 false +check_scalar cd7d1bd7c2bf26b7060d2407dbd88a5ba4add8044436bcbf6e00e690eae29699 false +check_scalar af5b7ede9808e45e80f427d27e660443851ee2063d53c23dacb487b6b375807f false +check_scalar 3a854a6125fbae08eeaf8f29177b83cec19f8f23f82e1c0213acfda03a19a057 false +check_scalar 307e8bc876b71a1ad7da7e3f8687d3173a6605184b912d80b34cec7abd09fd05 true +check_scalar 5936e762cfe201af05d2e7082a10e5f58cb71cee179406eb026b05437211f5a0 false +check_scalar c02d9bb9b3ce61da67d7eb839ad6135b28485be17b6749a5d07a3a442e33890a true +check_scalar 766459f999aa16992ec9639aed4e1ecdd7b78c6ab7cc63400f2f2dbad02796e7 false +check_scalar 39be058fddfed6dee0840cd03f7c407c3a30b0a0e87cc8ada9772b4150fd9a07 true +check_scalar 18c994dad23375e3860e21ce5d430ef2b876820bd0fe9e84a3b3a5ba45c790c5 false +check_scalar 0583e64db042f0e22e7abd759ef1b51ab5155314caf362de34781e8da9b4a20b true +check_scalar 8d71c7122df856668387356a704a0bcd1865493b65ab254b24c9bd06c5414386 false +check_scalar ca94f5f35fe069a057e9a9431e7ea3b99c7efd9700c0f838d3b99ab82648d343 false +check_scalar 850d3c5acb9103049e0ce06fcd64a543a38bf20fb31ce3a47e275d1e043c5506 true +check_scalar 06580accc5c48aa72ce261547614b8629c10e2ee8d62971f8453b2007f91a60f true +check_scalar bef7fb38fcb2d6a5c22f1db03c4c26a0f61eaaa1e7f846b2bb46ff06aa9ca407 true +check_scalar fc7956e14919bb2f531c6cba13e0bf3568db3927b24a2f9131e0c42aac0cbbb1 false +check_scalar bf2ed7b0fdd8cc1222db5ae9e699de5d54abee91a3f8bd988d248ab041738aa3 false +check_scalar 126213a8e3de2ab1fc862ad8bb27d3b13de5ba55657bf6e04efcf4015dd70895 false +check_scalar d1729b969a9395788931713933c587ef3748c96976a488f6a1e2f1e1ed6973d0 false +check_scalar 2448345de229bb4c2695f9653653301c4562ff4a60c568a3f483474b6800875c false +check_scalar e72284802f2737c293838a6357251398101ec60ba6e8458304bbd25de570010b true +check_scalar 87c0898c4c283f24b7164fa8aaab9fc3b06ad5237b389d9735d58c54dd989186 false +check_scalar 4cceb19c61263feaffeedc984280a6f5ecc1eeebeed05a407359661d61bdf8a6 false +check_scalar 2e286296d5300eb4ae7200036acbd47a319d3f9a8eb66a986a36683b85b26002 true +check_scalar 1b7140ff3a09a82554d4219425c2213abd16d9f342e30e2f7c05f2a5188432a4 false +check_scalar c0cdfe0ac8dd014bc1fb4c5d3f22d74f30623054f3008c0d1e34af4f2eafdec4 false +check_scalar 0000000000000000000000000000000000000000000000000000000000000000 true +check_scalar 0100000000000000000000000000000000000000000000000000000000000000 true +check_scalar 0200000000000000000000000000000000000000000000000000000000000000 true +check_scalar 0300000000000000000000000000000000000000000000000000000000000000 true +check_scalar 0400000000000000000000000000000000000000000000000000000000000000 true +check_scalar 0500000000000000000000000000000000000000000000000000000000000000 true +check_scalar 0600000000000000000000000000000000000000000000000000000000000000 true +check_scalar 0700000000000000000000000000000000000000000000000000000000000000 true +check_scalar 0800000000000000000000000000000000000000000000000000000000000000 true +check_scalar 0900000000000000000000000000000000000000000000000000000000000000 true +check_scalar 0a00000000000000000000000000000000000000000000000000000000000000 true +check_scalar 0b00000000000000000000000000000000000000000000000000000000000000 true +check_scalar 0c00000000000000000000000000000000000000000000000000000000000000 true +check_scalar 0d00000000000000000000000000000000000000000000000000000000000000 true +check_scalar 0e00000000000000000000000000000000000000000000000000000000000000 true +check_scalar 0f00000000000000000000000000000000000000000000000000000000000000 true +check_scalar 1000000000000000000000000000000000000000000000000000000000000000 true +check_scalar 1100000000000000000000000000000000000000000000000000000000000000 true +check_scalar 1200000000000000000000000000000000000000000000000000000000000000 true +check_scalar 1300000000000000000000000000000000000000000000000000000000000000 true +check_scalar d9d3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 true +check_scalar dad3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 true +check_scalar dbd3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 true +check_scalar dcd3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 true +check_scalar ddd3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 true +check_scalar ded3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 true +check_scalar dfd3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 true +check_scalar e0d3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 true +check_scalar e1d3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 true +check_scalar e2d3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 true +check_scalar e3d3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 true +check_scalar e4d3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 true +check_scalar e5d3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 true +check_scalar e6d3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 true +check_scalar e7d3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 true +check_scalar e8d3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 true +check_scalar e9d3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 true +check_scalar ead3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 true +check_scalar ebd3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 true +check_scalar ecd3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 true +check_scalar edd3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 false +check_scalar eed3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 false +check_scalar efd3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 false +check_scalar f0d3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 false +check_scalar f1d3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 false +check_scalar f2d3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 false +check_scalar f3d3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 false +check_scalar f4d3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 false +check_scalar f5d3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 false +check_scalar f6d3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 false +check_scalar f7d3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 false +check_scalar f8d3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 false +check_scalar f9d3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 false +check_scalar fad3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 false +check_scalar fbd3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 false +check_scalar fcd3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 false +check_scalar fdd3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 false +check_scalar fed3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 false +check_scalar ffd3f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 false +check_scalar 00d4f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 false +check_scalar 01d4f55c1a631258d69cf7a2def9de1400000000000000000000000000000010 false +check_scalar ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_scalar edffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_scalar eeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_scalar efffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_scalar f0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_scalar f1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_scalar f2ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_scalar f3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_scalar f4ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_scalar f5ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_scalar f6ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_scalar f7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_scalar f8ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_scalar f9ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_scalar faffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_scalar fbffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_scalar fcffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_scalar fdffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_scalar feffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_scalar ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +random_scalar 53e7f81c3aa8722a7797c451118d6b8727152a9db79e48022b34efc9ed44550e +random_scalar b19e8604fa44d940045a39f30dcba467eabb989c6588b7750a85d9d57d195a06 +random_scalar 85597fc8d0327049037d764772a3947caea5dbe8f7d6a02932888459f55b5c0d +random_scalar 36fd20f901420c661fbc3993fd90577aa7441bd870640f8bc72f72e512a11606 +random_scalar d41d51943fe73f66ce3a67ec25ee45fb332c9b2def9e9c2f89f4db9273f5470b +random_scalar 6f5047eea7f75022b96c32e380249734a612f8b4fba59db93076b15d81e3b002 +random_scalar fe2530f8564a8f679518aee57961a77c62b277ee95ab088835af24250c094906 +random_scalar b5f7954c7ab1ece1223b343f3f19b30000b8e798a3189809cf8aaf0364dbc80a +random_scalar 7a72a2adc6fd9f63758f6c9f79241d1d40d58bd2dc634557847b683ccc955003 +random_scalar f673d2a60e3a7f567c1302ef95456874cbddf40b9387638871b643183c498f02 +random_scalar 12b175038d6a9b1945e5710353366cc3b17de7b97a0e5ce388e4a22a47b42503 +random_scalar 183fc26ff30c1c3c167158e1f14b7609a39731f361e049ef08144f82b8149107 +random_scalar d797c95f9c47a4cccbacaa73d7a66f4be631e1e6244cf9fb00fa62254f38350b +random_scalar ce9558ee115567099068c94c8b58ff3a43011b3190a107824d782f5acead810f +random_scalar 834898dfcbc3146d92e2d0fdff371d88a46fdcb000f65231f68308cb4e92ea09 +random_scalar f52ec5c489cc936c90c005f78299bd840d5e4974c30e9775c898660ecb0f2909 +random_scalar c07ba88b2164a8ddc59116d860f24c43f8787decb9c39c5b7b5c2a4ecf92fb05 +random_scalar e6d16381607d61ec7d310419662f736aa840e46f254d26d7b49704d3e3c0640f +random_scalar 84fbcf68b71581b359aa239c2860e477be526fb5b752adb915c2eb57f7911c0a +random_scalar 1fbee4cb33a7f500b7fb68878d1106af22a7563a240c75b9b9884fc91ac60e01 +random_scalar d0203f3960b2dede483ac33cb9c4595369a146ad4480222f594e145fef7e590a +random_scalar cf0526b232fe4fabf3712a9a3da1a463971ebbdde3a183b4138d699d69006709 +random_scalar c2c4fa4db53d6345d478df65635f892150c366a7013a4b3bb2e39db513ce7700 +random_scalar 91473568dbb80ae41251fcf69f35cd9dbcd2cc849ee4f3d707e8e02dc5f00702 +random_scalar a130f8a3c42bf8e8439ad010896ef1b557ff9ff8a658c5056648aef59a31ea05 +random_scalar 50e7402b731478f02bb1ff1351f6117477da20464fc59a923df3b582e3674a0b +random_scalar 496cc9e98868e0cd74c07ddde4ad364912ad3a913f19bf748d42c03628e85d09 +random_scalar 1c2c48347e7f6e1b0598592913e31bcf57d4db81682bd42e957adb87bd599a03 +random_scalar b5ae0d9dc69140f9194f9fd9a910d885a576f9f1af31f039a03186042dbdcb00 +random_scalar 2bd954b752e9eae8010e2068bc8dbc0ab5206a5389f7cdf87595c2a15f63e403 +random_scalar eb3c08152437f64e68b11ae1d7958ebd9a7000000a446e3cf2eb7c0bb7c03207 +random_scalar 351fa38b5652e6f84389f92dfedb6f306502a1410042d7052b9921c0b7bd6b09 +random_scalar 4d13ba0257403c948fbdcc8c9b20323eb58c9c579db7eb5a3294bcf3f7432307 +random_scalar 5f4b72a843bfeb72a94161e3cfed21ee78e20cf2a6ac7d4b471a88951240df0a +random_scalar a1636db16b71e8a9b2b8736f0d45e56dbf2e1dfc27a46421e8bea862ebebe100 +random_scalar c8e6312eab290a4d8b0485812e1f9535a5e47932e185c32033a9e7e4599aa308 +random_scalar e3645a06c88e048c83500f8a002057d6cb4bee84ad7d2d2b19f31f74bb5acc0b +random_scalar aeff085bd972a0ddfaec586a753a68e57fcf8e22f1156387574695591a51f507 +random_scalar 061f87e59c8f7a4ff1ab14e0d6a4bc1c4406c2342ac1710bbea891dbd59fab05 +random_scalar 260e790703252ace6db5149b17ae7409ad14bc5a55c4065b3fcb6dfc7ffd510a +random_scalar 242911a8a34638010fe81cba7b402cf23312fc9831b7b2af53c719d7b27b8209 +random_scalar d54aa4b1d086dd8c005c1179ee50f51558fe24bb1a986eca75d9ae3a2a45df08 +random_scalar d1963ea06b83bd807173cb3c25ce12ef2d3b2181aea83a82b20d710231e84305 +random_scalar dc64142813b42a54a53872ccc26cd4614e8946763ae55868c36808fa74b6630d +random_scalar 5e3f7c7a61011fa6d628138cc20293cce857b16cc18dfffc2a7d2a27e6435c05 +random_scalar 15ca79a2b2cc2d9b158a4d86c774221c82a5fa0231a34c20529f5dfdb29bf80b +random_scalar 16356566cdc1c2bd74b772bfe0be24c2b70e41161e932b7b0d1193f7e094020c +random_scalar a38d90739c9a3a7f87e1dca293684d663764df26e234e7240384c060001ca60f +random_scalar 5dd3443d574f0a8a71dad9913640858e8ea5fec7b4d220a8fb0ca0ba91665d00 +random_scalar 5817dea9510990a19914e1cdf675ce057a78ed2e437250b3e786788c2033e906 +random_scalar d4c8d3ab20d5a39f50319f7f98529e39b77cce813d77fbe9dab3d1aec8b54f0b +random_scalar 8cfcf0e0de3fb497e1983aa2af6423cf57c32742fbfb9ff0d85f8a4193c46b08 +random_scalar 3f90e807165ebbcd25949d9bb57c1d0fd3a885b1f0f519426d22c879618f4a00 +random_scalar 041bbc0997401ea529ae52b946db2be0ce21052b1fce1254bb05bd41169d190f +random_scalar 01dc1a19be80418ebcd23c671ad9b2656eb56df46c918b74857159a0e33d0901 +random_scalar 65707704f384762c8266afdef1189d87f7725ac84747ddb1c34f7a154bd2ed0a +random_scalar cbc2abe6011cbfc0192594bbce8914c60e02fb19bd402ff5a8c4b0ae74427201 +random_scalar 02843acfe10fb0776cf2a47baa3b21d84c947847876af7c7e77f78f5b4eb2c01 +random_scalar 0fbe5a2e031b7f64efe56548d9117c7899cb998a337028fb5cd5daf65fc91809 +random_scalar 724aae3318e10d21c4393c25626c3950283b7d0d97c31288a43fd21f63045809 +random_scalar 4f630225ba3863ed1d6773b032e3ff0a1f48ccf120b4f08bdaeca8191ca6960c +random_scalar 456aba919a70f3cee5c97a923fdabce81aa4ad6e5ce346523e7dbcf51523430a +random_scalar 60943fa051b1b26d76342d7ea190eb04ef3dbb1acd7b091eee834d0fc6c78308 +random_scalar b098cd4403466873e32904236731473298c5f172b69345367dbe42c7f4bdce08 +random_scalar 8b49112d62c2a299122052812c76381a13c1eadafa4a4c645f438c9d7d83a003 +random_scalar e27de729ca8ae4fce2d1bced1461db520f80568b573137cbeb864d14f86ac30e +random_scalar 509410d3dea8f1d2caafa3c8f9d4f355fb8d792d917eb441b377dff7cf619c0b +random_scalar 55cc39624c61327c48c548eba012aea76ac5d22afedb74306686ea936654bd02 +random_scalar e2afca33f6111806abfa1af0fced797885848cbf71061d9b8a4851227b7ab00a +random_scalar 186c9684dd9d44644a0daad304399ed2d3039341740a810474d127788ba8460d +random_scalar 8e00fea0dee1928e76876cbafb20128126af12f7dff3a2a11ebf19627d71e609 +random_scalar 13b7588c2aae2c44c7d99146ef68d7e9a354c00bf765e9a18cdf19489041de08 +random_scalar 9c72d99148c9de2af7f384687fc5c020f0c0e90cb5ae04f1c5a7a20b53dc7401 +random_scalar aee5d59e6ec2a057d25f102e0e925e9a6efa10ebca4094f884d5b4df96581b01 +random_scalar 4ab61e2c277f8f0125138c9635227d17ab7afbe0190438cefe27fa7b0ac92f08 +random_scalar cfcb36274564229211b395da894d62d788d472f5397ad23d5ca685206bbd6405 +random_scalar 5d21c8700e5a8b12fa6d146f0186ea10af4c3586d5f1eac21d0a1b134611cd03 +random_scalar 7dee1c2e6ec4a6382d31c0a4a3430717a25bb8b8804a79962d3385fcc74feb04 +random_scalar 60265c97c5f855557d19d995d9c1e09bd930467f2c35ca2d8ced83bdc84ff10e +random_scalar b304094bd96788e4a3ce031f099282dcaf8476a8fd0f2ceed06fd28e5b606908 +random_scalar 1ffcd82a15372db2140902190e26fc213700c293a65ff622e8706d4ce5275105 +random_scalar bbae0d113135006580c704b8e83f6eb6f55e57c24a048a60913526ad21f00d03 +random_scalar a362273c0e4abb0fa5d67ba557d30aa3cf27a180856da576be1019d79f013b0c +random_scalar 73ea84eacf95e0819e178dd0aced9bc7f844b1ffeff27a01b5f2ba988dbb7d01 +random_scalar f05bfa17b6e13ef18a3874dfd8b1e1c244674c1f372ea04cb0292c173008b103 +random_scalar 54b648f07ad446e009e573ea48d8acf1b9a75c2b4d0364c495e23f087aaabe0b +random_scalar 202e08aab92b49465f96fe10ac191e93b8ab49cd96579aa8774d8271b8867b07 +random_scalar 584f6405526557aacb37b1bacd94fbe595e19421c48c9eb57ff90c20d5ad390c +random_scalar b3621e07b73c9ee32ffe407e636620614d7e4f68707499f11bc6369ef6b07b00 +random_scalar a394fff87a726d82256cfc4058b9ec84117e03f7d7e25ef212317460ad5f930f +random_scalar c32fd38cd0a59083bdca06027a3208221553727f3e2e2daae1d5572646514708 +random_scalar cf9ba6583c2eca4fad19d1667a390a2ef572fe9ecef30bda28c21074111c0a08 +random_scalar 69ada07f80910c972e0a3fdc12145f68aafcb686b369d06b101266d8c4ad9b05 +random_scalar e1afdd0fe6ed47a25760c9d76bbf446e688d44ce2d482edb1f1bbb1d8b723a02 +random_scalar 360ce0cc2955ee6c1372587b3f33f7142fc175b13abaa1504f08061ff5577d0f +random_scalar 6917b030d9ffa1eb043b0e8e35d0514d3b3039eebbfee1e8bb66ff121377b20b +random_scalar 5adea893762a29521673d6e72ab665797248ce5a6e89c252c3fb152caeaa7c06 +random_scalar a11ed0df4410df6daff30489a7d4900a241e68cffcc0f4fccdd2008c6d6b970b +random_scalar 119ef792c0fafa57ecfe2277c8ef3a0582c7ab31bf312f1219db1b7a9711d10c +random_scalar 76e4913a56714022236190dc7044c323eae06529767f89e21fd869e846b7cc08 +random_scalar 5030adecd3febfb5346af386e7a6acf0aef1d6a8608c3e1b651314bdd8359d0d +random_scalar cc9ae2356c0ef441ea587aa6b57feea532ff1a51a60fe9cba851b7d1baae7100 +random_scalar 22dd1dca7fb0ef41a0bbf02a36a217200f83043d07b68b6bf100a7ae2054c402 +random_scalar 02d4580d62243bccb0df8a7b136d281bc53f444ed8edb0e7e45b50b645c34102 +random_scalar 6c7febbcd9b42e419e2675567c36825b56f2a839f368b2594e49b36569b74107 +random_scalar 5d04ea12cdf0f747c865a2e806b8c1ceb2b229f40eadbb1a87b6c5f405cfb60e +random_scalar c7697bfb02951d6016c9455cc1fb242b1a8ce69b5fa7e04abe5cb52bcc63be03 +random_scalar 1d3d9eef9439050c1d62905fb93a5235e328aec178084cbe61d7b1390d515202 +random_scalar 89205b48cf29a3ce4124314ffc5537912e815bc1cb87b481918e78af0aeb1506 +random_scalar a33a8909eed10ed148a80fc976e6d478de912d461f9341bd8e930426903ef905 +random_scalar 51780f62883f8d4e8d6f8202860f11e29499b3ea888a3783730d27f90ff6d407 +random_scalar af6f16fa7c015f94a571343c08c0239460df338a666d87f4cc59f83b588a340b +random_scalar c60d1e70c511e42a33ff49fa61d3c0df3d0ce76e32cc602dcd86d5e55e131005 +random_scalar e2969637e86fcf1c02bfba9bb0b15b8dc934e7619152fc32cd3161f7336bc305 +random_scalar e4302426c4be390c61ef4e27ce8c3f0afb30efc9629dc0b0ceeac0c744664409 +random_scalar a9710d635b6d92d96edb2793185eae270b289861403d181b906877ccb7e9750c +random_scalar f76a101a4624553374f93ed40fd4732908ed4512737c111b8ede59227e208309 +random_scalar c443d188f44ecb75bdef8f36700d6c239dab1c85588fb0652c38cbb377c9fc0b +random_scalar 246653b379591d0bd8e22792993b88fe13b8b819e104fde650d9fa254d44b10b +random_scalar c245161d0f9a2805b8629ae7615b81aa39b6f7206b2ed1b3fce44d6fd978dc0f +random_scalar a2b7ee14b35ec69172cb0163c4151eb025a4f44b5b18d192af3c596ed024a506 +random_scalar 09fbf4f5da8af3044ac6baf30abcd395b60759abda6399cf39f7d9b569f6dc08 +random_scalar 45562292a1402222434d581167abfd7bf66eea7b586380d01ef92fad63f42c08 +random_scalar d145d2aadd4cafed6a5c7e6bee92622d04216197730d8d2065a4e0318077710c +random_scalar 8d703fc50a478dd91c71d7a078508ba813edbb9e66131756f4602b4c9951230d +random_scalar e87a7cfd9d0df825002c695ee25d7ea5ace17331da48d27c702ebd9e6ab0f309 +random_scalar eb8eab1398026436a704dbe19d1652247ed49f671b504ad944fbefaacc09dc0d +random_scalar 59f80f56cf9295d683ef7d232ae4aab6655335e2238e833010f06d0dc9345e0a +random_scalar fcefa6366cd53a1d9438fd90d84e4ce9d77a329d7e7f2ee31d66c0bb8c0b7200 +random_scalar 50f83302a432115978b2543b1555df44fdeb62dc496c03cbe7b38339d1f22b0c +random_scalar 875e33664db7d37e4fc6e9a7fa215b1958a71267d277c0e5f5cabe87c58a7401 +random_scalar 2b3d75b23f42d2d2993a5791204aec41c9a4fce1503458323baa6c44c1adab0a +random_scalar 1fbcff1080374e3270c44a9df75bad337eb10d0f9c05327db19a73e7dc6c8600 +random_scalar 980d99dad41f8350915a626e215fd5093d789f4475c2184ee2483ea88b7c1b03 +random_scalar 974b60039fd58ad185e76be82e94df52396ff343650cab6297d332bc44354407 +random_scalar 47f13e7457e6d3b7f338d235237847a5e7191754388d4252572ab3ce7cfd0b05 +random_scalar 4bfb443aba7ac38dca404bec886d02d9ca94fce92d2b13ef86909e88281b8100 +random_scalar ef856e327aa92cb4aa04299d48d49fa7e45656bff2534f24a119b38ed5cf9b09 +random_scalar aed90763fbe1d83a158990135232ba43d4056f84a3b5381b459612730c05f80d +random_scalar d39f9a3830a0787c15bb81c75eb1e225705fdc3d32a89c8dbe58b1eec438510d +random_scalar 073573648aeed18276b6ca04b5eada88c6ae933feaae882aa19319847ae3bd0c +random_scalar 86d0fc7743705f3018a15f9ccb2b4d25964104a85f7db1a8be3b459e463b160d +random_scalar f70d8fa395ddc366880306e1bd3f3a45bd81125a1e2acaba3ffef5535fa4660f +random_scalar 0a4a310e48f4ee1f968118c1fa9e04d9810a19f7344f2eb5e2f3a54a74046a01 +random_scalar a1be2ab7ea07bb1df1abdb8587db537947f439090fc8644cedfefc72e51ff306 +random_scalar 72375f5af0aa22b7480688b9b276fd3f482b8d5e561baec6bc1e16345470e504 +random_scalar 8ecd53e6f28d0b7bc4afb0fd82af084d570b28416419a635269e2b95e45c2d0d +random_scalar 4517b82e59d1585c5d66f2badbd1e8b225de8794c2a830b7612c2a089b9ba70f +random_scalar 1ccc5122efe52d0cbc37b57d6454bfefc429227c3109bae79e063e7d14f1500f +random_scalar edb27f193200a2b2d55e39a7b7b947a28dd4c196d5ed4cf7e239c9765bb2a002 +random_scalar 0f630ccc55e0b8cd228f0bb959b665bb77230e2583585d86012411fe0fa17409 +random_scalar 915b03284eb43b1927da93ad429cf2e2d6304f54bf144cea37c51596286f3502 +random_scalar 819f95699799ea6a55c8623e3969db63c8d0a32a1509e53752a4db36b980240c +random_scalar 245c532550f12c33a417d9ce620305d7c07584bc823a43b553ebeb700579a207 +random_scalar 790ddae8df2b81ee6128ecc131652309ee91361e3738c8a2f5245d5793995901 +random_scalar dba8117b8ebe25b86cad7436cf42b85f7802df93b101aaa61b2f300bcab90a01 +random_scalar 46dc861117e982b434e954f3896b57a18b31cc0b808b0bc5735725740e1d9306 +random_scalar aedfff16b3e5cf89c77d2a49a87bc205c4fc145723d03d3b748ad02fce51f505 +random_scalar 5c6a324798e056bb443cd1785d3dac3b83d553e6a05ed2bf48ffbbbfb49a4f0b +random_scalar d7794ea28786abb0cd05cfc344a912470abe35476f331063bac28f3aa98c9802 +random_scalar 543da265ebe7357ea618e783fef22a429128cc7771ce7fc129adfdbca12d360e +random_scalar 29b5e43025c3aa6901179717a2fa0ccfc50871d7d956e8a36022b3aeaad9ce03 +random_scalar befddc81aaca2843d598e2182cf7f91f512a6f8fb0424fbb012898bae52b6406 +random_scalar 0d9a3b8e4b8cf72a92508a7a4684bc47cf5be55610de660a1889e533debcfa01 +random_scalar 9791f6e80732b1caa0d0b58ad5e1525d36bf902f57a79fe80ea235271bd65409 +random_scalar e28f7d2d70ddb4d47d63661b2b632749c19f779335b6668a82884ba09c0cf006 +random_scalar f176052f4b52d50c923b78ef8c48bec7912f50011124b8c221428fbb1ee1780b +random_scalar f5f650106db441aa5fcacbebc823b01be9124e6ec84b11517b055a46e7c72f04 +random_scalar 16bd2af776481bc0938ffa810a1d04f62e4ba7d3ecf120de3a31469ce327a705 +random_scalar 8e50c4409e1146a7bd437eda7acce2bafea6d43cfbca018a2955a7a259aaaf0b +random_scalar d7f8862aecdabde52173b225bb0be1205b4719df1b7ef9173e8c1d8c6e9e0b05 +random_scalar fdafc76c9f7c8281277064cf754d06b6f555bd8dba0c6d92fbcea914958c6604 +random_scalar c5471b14c230baab32f83c3ea887b766f6eb23929bb2f3bef5c519061661db07 +random_scalar 27bed1183e9a8ad3e5c9b973e5b8c3ef54a5056684a6529743f5a62b54640e0f +random_scalar 5961cbdcac12c8b78034e18d076487f47d18fcb1cf41ff2ef4c1420d7888f101 +random_scalar 8f05f3f5b67cfabfa77559bf87e01d84e788162a6f1402d11cb5c8629ba27d08 +random_scalar 4f4b44c5e1e451708ea8e752b873fb40fd4c3aa4c24d6f1ae7168b055b25dd0f +random_scalar 1539fd568b2ec07503ba37dc38fe3611cdc6ebe0cf4af7cab8eca5a82112960c +random_scalar c67a1b6ff1b96102e92e7f414a76323c7e310a99feaf6c5bc7b827b711e41c05 +random_scalar 0c79d16ece73a6ee269e5725ed75313e8f6eb908090ac1e4d84601ea60f87007 +random_scalar 107877d5b17fc2e1b0165e61beecaf470b1e431dc0a817afdfd4a0ca1f61450d +random_scalar 360dbf5a622e5a8ecd3c0f9c97152e2ff59556bb17f1d0aedb4123ef4df1e906 +random_scalar a9677fa7eab1be0fbe40d315768a29c99479e3df0f50d81dd1c8a059c83af30c +random_scalar 130d7b30e81134f63ee56ffa33c24fb08e0b4bd547d2f0a161e83f78e8c22a0f +random_scalar 9c4cd5a33283a1001eb0f30a514a9e9736239281e4963558c2ea23b651267c06 +random_scalar 02f664e21c0478b51c84e3c2eed8fe485a1e750f115d18966a972e5de97ed700 +random_scalar 2f04e383afb8b93faac5680c21551ab94a529e85365eaa3a2b5b35fedd3bf903 +random_scalar 82dc19a0b923003d17c07e7541107dfeed98fd179c9caeb55a7731c9e3e53b04 +random_scalar 05ac3237591930a76a2fa67af180b0831258cbafb671f6283ef4ecc83ed3dc07 +random_scalar 0181e017770f075add64629936eca1f81f067762ee7a09a93852e2df91618f05 +random_scalar 4ca38c24060c7deb483f05fb5ccdc6ce5ae4b0e68f9a3c71acb0afa1a05dfd03 +random_scalar cf5e003d0f661948fc33b40c24f959314a115da2065f260a4fd6c0952746600c +random_scalar 495f83f263a2f14748e11e788b00b3aa7d8f095966fda40fdc8b45a07f32a506 +random_scalar df358ad6f286cbf10441a331e740c697a10729d7deb91d38293371b010118002 +random_scalar 262ac9388ecc8459971beea5212dc0cfa0450cca53008886c0d460d43c93fe04 +random_scalar 40e987f2213fb1e8dfa36e5209dacd8478155a463388fb05c3bb2e050cabb302 +random_scalar ecd53e90727eed6e7d661cadcafdd0726d2d81b611565069d09df9ef76debb05 +random_scalar d09aa7364d6c78d9d00db71bf7bca796bcceca239ace6bc7519e5b10a4a16107 +random_scalar ca11e12dc7ca088d294001a77465436095b0fe3a83ab97ddd9f0d645198bc702 +random_scalar bda47658303724418db4176a7dfe6db46f2114a14f166dd7630079d7531ab50c +random_scalar 1720fb3bfbf92c82d352215288fc48793d2ac50b96881a6ef8a6efbb221df10e +random_scalar 418276ee2044143e52d0be9a9df3c42eaf56af78f65179014a792edbbfcb4000 +random_scalar 4cbdc8564016ad41f2f70702162b6f185463b9c2f72e99f60194d04bfd31cf0a +random_scalar 66d3b4122090d0fbbe612ac54a04d99a054fc02df651d9b0651fe53101dd8a0f +random_scalar 48ca7152d9b52a19420b49a4fa804405456e0c53912bc6ed8ddb1f883e88c70f +random_scalar 5e070dfc15fe900925141eb30b52b6864d5d301a3e5665d5795bd0d2af176d06 +random_scalar 246feed9747a9b29488e8b958da8c15d0c97c0c292cb4361b5c1d88a1a1f6b0c +random_scalar e20d788ae8d75d9e08891b6fe4cd893fbe6d33840680c24bed69c4cc1e815808 +random_scalar 39154da67b82521c514ca17fb4a46a288fa2016e24017706d00380eeabbb9906 +random_scalar 8cd0adc36d8ad3c7f99b53b2199c251466a8c0edcafe4762d43aad83f883c602 +random_scalar 6c0c917eadd787e7b3ed826b38d28afe7e5ab782c4e2f4689ad5ce2b0100eb05 +random_scalar 513c8eebd9b646ec42cfa14d5e7d1e0b91a7c78741534291704ad79419775e0f +random_scalar b23dae629a9946f0f1855b08ed8df2ae5c9116e531f8a7dc773697e61cec550d +random_scalar 028e63ead18c1801748097f33e7d23339d3d68fb7a1d53c54257ded8a925140d +random_scalar 57c20a585c3023d0291ce1a0aac2634bc0ad341b43f7439a2b6387ec44afae08 +random_scalar e76a6fe667882a23c798789f2d0435f7422026f87db8d28279e31e622a1ff707 +random_scalar 4dc2c6feebb1cc417f4bf29482d2b70128cb0b366543e9074a95bc3031ffd901 +random_scalar 35d75f01dc1455e886e58776897ac3460017a165571bbf3e8abf2c2e401a6b0f +random_scalar 977336852b0f8b94ee80f021786fcb154f038fb62aac149c8ffc6200c5163709 +random_scalar b7f367b678a94d2a811d4c6e6b06b57055fabb36c0fc22599436df65a7a46109 +random_scalar 924b3ad7b7a58bd9cf675c4ed19b5b5b890cef5ca8e9f7f2d60b607317360d0f +random_scalar d2ebb58ad144eb508f832955739fc468a70505b3187329329f69c3ffae21f50c +random_scalar 3442f00a098497bca9fae5dc9fed4fff561b53007edf69904d8627c7b41e0900 +random_scalar a1cde4619213edbedc3528476a3e84e390fd3e7833e86e59512c65f59381be06 +random_scalar 02f97c5d607b03b7822392a0dbc96c160bcdc1d1e8f5c0333c5f0d5d430f4504 +random_scalar 7093044afac1ad315b6fe8ba49eb9311df49f56e4db3308d5ccb4892d1e5d503 +random_scalar fd646f9b2100009c441b524b82726a233d00fedfaea9fe73b0930695e916e60d +random_scalar a00eb2c9b6e7384c7da45898f7407585fcbc6c56430766745207b6ac4b7ff304 +random_scalar c956f7dc4e533e82ff48428092aa89251e269f86f12868f956f4e432027bff0a +random_scalar c3d4519bb3c62de749ac4cf9b71983c904648899dd7db3d468b4f3a7427f3f04 +random_scalar 8548fe94f37c98d58c164d6425ac1e6c58469516bcff9dc60cf84fe840622e04 +random_scalar 069a4cbb2284d71d91a32f0170a05dc34899c5878ec5b1a730676bc7b781a106 +random_scalar 9f64acab1c5c4697537b187894c702a5348ba9adc1b04c507291eb4eafebf502 +random_scalar 372d5200682f645734a4be4e28f26eb2783b29cdb91f4ba9ee5909de5ab58b07 +random_scalar f57ca646fc6d8226d9918fe0063c2aed0f57dba8f5e5ee474240125ccf5ecd00 +random_scalar 8f891f844943edf758d57f59fd750e6adfc6607541fcbec665bcb7a3b64c6306 +random_scalar 5bfca5b7c97784c86e125ae74c723501e07127639210a794e9eeece03b409a06 +random_scalar 85e5eaff8c53ff2dd88f888fa01b554d34245290ed25065ea540c8a0752c6709 +random_scalar 4230dc9af32f677d00d9e828b05d3094e5b0d1b166e8df0571ac7fc2ddc51d0f +random_scalar d79944b5965fb3cfd700bbf60fa3ee4f7ddd693816547f3dd3adb8e6e0a46c0f +random_scalar 26167d57ca1a456b82c5da2a3b06cd7c51bb9f2ddf2372b052c26b7a00f60605 +random_scalar 861e6f68c150e23c0a30bc59a7110875a38793a805de187c8d56a128d114ba05 +random_scalar 964cc4aaf44d5000ed33b884b13b4d7250bd5dda232ebafd7e6e12b54d78aa0c +random_scalar 0c4abd57b7145fc01e6765ac717e1237a6b158c81fcdb08ddc4512330bc97703 +random_scalar 872b9cef495ab4a776cc335159675521540b389a43c309a125d7ae91c77a3701 +random_scalar e351851f75d2ea767c6f5fb3f44c8b7ae8e585be9bcc67d5c799729979ef7c02 +random_scalar 63b9d7914096ce2c9904a5cffdee37076c28f3c94844507df5da2839f148f705 +random_scalar a72feedd729bf1453b90034eb33e0258866ebfacc340a211caddce72186b2b0b +random_scalar 1d4ce86a8c64eb50fe72c43306d0297e88fa2939d5c9d40afa7451403f640f07 +random_scalar 1eafb7bcaa48417b45e0f16fb4187f6aa7520d79e2a0000907f0d04769725302 +random_scalar ebfa52176c8b0af780d37817cac2a4d30e974b80180e6d827744ed83cdea080d +random_scalar c69d6ef54744f3294795e8c0a38bc7e2405f924cb69fe744dced6d8b0d404002 +random_scalar 6347961f950c3af015bb4cf727ab80ea438f16943ccbd70cb27ec7cdb32a370c +random_scalar 38730eb626ac9a5e813c6df53dbbb1eeda44bc10b23f5f762331efac05e65d09 +random_scalar 8ad8d1d414ab01be4c3df1b98120ccc14b8729f0f81b015f2a3242b021a8a007 +random_scalar 8eee6d7779ad3d7494dbcf31febb49a70a4544e19647313370db30ab99b28307 +hash_to_scalar 59d28aeade98016722948bf596af0b7deb5dd641f1aa2a906bd4e1 7d0b25809fc4032a81dd5b0f721a2b21f7f68157c834374f580876f5d91f7409 +hash_to_scalar 60d9a4b96951481ab458 b0955682b297dbcae4a5c1b6f21addb211d6180632b538472045b5d592c38109 +hash_to_scalar 7d535b4896ddc350a5fdff 7bb1a59783be93ada537801f31ef52b0d2ea135a084c47cbad9a7c6b0d2c990f +hash_to_scalar 14b5ff33 709162ee2552c852ba62d406efd369d65851777152c9df4b61a2c4e19190c408 +hash_to_scalar 383b76f631652889a182f308b18ddc4e405ba9a9cba5c01b 36ddbd71a4c19db5ea7022571a52f5a9abe33fc00aafd24b562fb75b7fc0360b +hash_to_scalar 3a170545e462830baf c381ea27500b61d29e9ad27add0168053cc1a5b7fc58b6960f67c147324acb03 +hash_to_scalar 190757c55bc7 357f141395a76e2fd5003045b75f3216294eab0524eda1ed16cbe558145a2403 +hash_to_scalar e1dec4027ccb5bf7d273163b316a86 b365e89545402d3e7d649987127980ec8339af2e3067ff942e305a9ac0b7390d +hash_to_scalar 0b6a0ae839214674e9b275aa1986c6352ec7ec6c4ae583ab5a62b947a9dee972 24f9167e1a3eaab18119c225577f0ecc7a488a309e54e2721cbaea62c3db3a06 +hash_to_scalar 232849cfbb61443dcb681b727cdf7a2b84116dfb74a3c1f935 8af86aa2f8739b7d384e8431bd1ec5a75a1e7d1dc67f2f7100aeffbaa516200e +hash_to_scalar 0bd05745dceb00b2c18080e6cb66d9099e9610d620c188a9 79b024435100e891c167abd8f96d3f5efc6919e5861f7298b7736f2927276809 +hash_to_scalar ef2e5ce130838935ed202cd61453ecb860adbb903f0eb950df 594cd0a2b135b1c29544b095b8a43e5b3cea1806fdcb9b59cc53829cc62f2000 +hash_to_scalar 48c7811fe63d09ceb4e6ad0acd51487496b7108d279078bb 43ff71f4c9544c09e583d3fa4d21297463d029415e236ae758d06f4238b5ef04 +hash_to_scalar 854b5522f6a7a50af76e305c65bc65d2ad7603a00e244aabab4b0e419576c7b1 20a8a23806bfa8ac1e3d7a227bc4c3554a18f5e593e5f8b807767c3f818ebe06 +hash_to_scalar 3aca21fdffbb7305feed286925 995f4205c63106243983d2be160a2e17f2ac9b78c8e6a705a4c52d6adf2ada0b +hash_to_scalar 5cf74e22b8b6d30b90be7e2296f1e89cb76bd7ea3001663256 42138bd241761d92b67db8ef225347b98e10b74f6fb0123da7b44f8d51c37309 +hash_to_scalar 5eace33d8b54417a5bee734727d0dfadb4c44b7bbe71 16e3cb1efab4c1871946790ac6dc5f54f8880aa66cab176a42fb1d5da89ef30c +hash_to_scalar 1b78000e7cc0de64a8db20dc8b10 359cb964fe23ac02a1693f86bc0561738ea569f502f6312879f96d1fb1a22a01 +hash_to_scalar 5fad29a0af0ac0bec3450ce863394a7b9458 92a8c81d5d08c480f39430e366f5d9bbc7f8210bbac90f78ee2ae8b5588a9701 +hash_to_scalar 353e9340e9 e5b47f1d528661666dee909b8159ca5c3ea6dd6064ed22651f5398e0dba24e00 +hash_to_scalar 9de61bb6f3d5075b59fa9ae86a8df85b7e60efbe1969046e4f863f302d44 0d8ec9d8b735139232ff5cb99a5f528cd829362912c43c7b029049ab72b1c80b +hash_to_scalar 8028d7a78fc98370a58876bf4eae360a99c87df0162959d6 34231faea4f4a7b3f64d36be7a5261a047d063ee8b9b04bd58a03f8a3ecbeb06 +hash_to_scalar b2226a11ee05a48e89f210b9d3 83f43546f7189d4d7bad92b0d2648c8aa59d70f5a2610ecbad2a029b9ce7e308 +hash_to_scalar 232ef1768d8493f64ec43ac0e80b986060d47f5780d52ff3b9ee cade3388d2686f20d6d06a41e20c5cdb67f7ca43c4d74dbc5c3c1f25e8f7a902 +hash_to_scalar 1dfd925486af17a4592fe31b84d9e1 beab6d2da76d26fd4937ffa102298a0d69ebeebf46255b3e9387131873994403 +hash_to_scalar 07bc8e67666d 90581961337ab4b806082f6d3a1d297b2ee0fee11effb28a14b77207190b7808 +hash_to_scalar 2d219d894b5c0b55b5d078398ce0ceed3837 7c923555938a33b877edf8ecb9b1eb6a1f90d6bdd54ddc3a978ea1b297563604 +hash_to_scalar d96e5fe31cf5fe6cd09183cf7e7df5da577800aee9 ea51b9f3b17073f8db2ed169f8ac25474dbda5da733be3c4c8ddb74a26eae509 +hash_to_scalar b254e7824ff4370acb9ab1d8694351671e600767894b 1831a736fbba5833bfcc73720ecc7f6b5d3ce62dcbf420e55fc94f00037aa70d +hash_to_scalar 357c6b0ef93cf0097c372da0fbe831732ef9 1d6a6295c81f8ba4888028930ae09e2557b43abcf1c9f7103fe1a7594f346006 +hash_to_scalar b7202cb7468825d7d4258168636ed1ec 30a42478c3a42463a5bab1a0c1d4c0d3c51bf1f456b849a3d826e93788f9510c +hash_to_scalar 5c2023e9ee12a2a12bbf545e8e4038a177fd07bcb2e768ec4259d306d3 b2c18f7b74bcfd547362c45483beda13efeccf38602c16103eff8aee1bff3303 +hash_to_scalar 18d9e94418064ca5f13386224d7e01 db6c9680294cc20cd83783927563fe2c19e1e30462d02628bb187c6d43aa0600 +hash_to_scalar f4b63131b4d5cd7749f1b1e68e9533d522822c60 a9be8f15d3daeea4df114d957a15a3f7380fae58508a19156af613a692598507 +hash_to_scalar c54e0f7e67b561 1ade1203c88d0959a4e0494b48f31a32d1c7a1065b83d0d86a4232da6738a504 +hash_to_scalar 2554f6116a35f493070b17654a817eeb55e35cd16bf60de0da33abe2 53df47b8cbb269cd78ff4a9552549118e8fa22011c84030c39cad8ac73aecb06 +hash_to_scalar 0c904b4d59a3da ad232a646445a83d9b1c7c5b36363b1037b209890269629bd3d7c66d9d9a600f +hash_to_scalar 334a 1ab04562c0e3238e41e3e0de165de27b1c35e7a16d7720cf8421d5969cb0d503 +hash_to_scalar 1bd3aab0e9098d 77f45ccf9905cf5aa4d701f4a333bfe681520339288c871c61aab5d08472c606 +hash_to_scalar f62cbf2feb184a 4274412946a00971c1d225daa1c657676d1a453575164043ecf1675276bda605 +hash_to_scalar 8de6d27a8d670b4e0c01f58f552a58d611250f663786eb 43792a134016bb75c6e15165564fd3aef676dc5a716eec6476494498cc97b00f +hash_to_scalar b593ed9a740bbc1ecfe84b59007f87d6e665f5577bd61ffc78b6ce 67a5ba0d8036c19f2f62a19739c86a0945ddf34699f617385771d54d3979c80a +hash_to_scalar 0c6dc0e23711d7a602c4c7aec292588c634a11a40eee3aecbf f703568d1af5f8621bb54debeeceba58f971173c4889d9ea9ab34cf849307606 +hash_to_scalar d27bed385fd5ad43e0b68e13ce5aa83476347723c37e9d4d8c65 c849758dbb70eb051fc38304f35293c08b0d127cccc705f1b6b6e777ba65bc0a +hash_to_scalar ef7658d663e1cf95ee2a8be65c09f1b69e3f788bd81121bc2a1616 9e9b4600ca904414e72a682bbd37598c58db6b058bf59786ad9b30941568c406 +hash_to_scalar c163fbabb36fbc32b7e24cf5ffe4708e0ae9 05cddc663bd5d8193bfc9727e0da5daaf3077c68b423031e15c3d2bf8b677708 +hash_to_scalar 30 76508f84081e3fd53ad1aa29f1878ba0e8fcb96542a07186fe3aeda6bb8a110d +hash_to_scalar a29a8ef14327373356612a d1d73866b223af5f438ab1124b6eaef73fc7956bc137181f46ffaab5b467c10d +hash_to_scalar c47118180f0229dc185344343bc9e3da51 fcc968961386b6f882c9eb51af6ae23c62b5cd8e75b5d840c0cf9814037b4a09 +hash_to_scalar 55fa235eb20659e9bcd5812cf2b78167 34cec87f2ca28e65c2dbcfe9e9e16c852b0c3aaf9b439c05cc4a38a089095005 +hash_to_scalar ca1e303fcf3eb492ec ebaab9d272835327348847e95e4f7b0bc3a15927886847317a0a0f8db7859c0c +hash_to_scalar ff416888c2c8558a58d851dcf264be1dfb1ae457d0866934ba5ec625085bb030 8364b9ee560636a247dd57f5bfb868b5a35ef3446ea3afad8e105411f9b97c0c +hash_to_scalar f7115e63ee9d6ffdf1c26dacd8eb812013a5ed3db9b77e8af0 df5f1e2aee0001ea8acbf13b93124e14dcbe3da07e25996d5d3f949f927db803 +hash_to_scalar 0c9998e1 ee8ec14e54b6ed263d460173e6f0fb77be135b39eeb60f3234f1a81de956bb01 +hash_to_scalar 53472086cfada41b94cf6527d73b9b78ed8cc2b1ce 61855885dbd658eb2ae21bb805f33e28bd0a9ed4ecbf7259b5d2534965822505 +hash_to_scalar 259bdd4f7243ac81af3d38ce85eaf44e5c625f8f2550482cce4d 0d5c96bca1bddda05680c334d6d9a21152ad737cfa6298dd4b25eb82a8a31b05 +hash_to_scalar 1efb9ca4a4cc93855f3a7bd05273eb9c 461604804edbc7992d12fcab79cc6d9daf2c03f92802ecb265317202ddc92f0a +hash_to_scalar 7108691aec4e4f93404b90a090 f1d4e4e795afb6fc23c2f3c1e7b23e75c5f19f322c64c772395bdcf64ba09504 +hash_to_scalar 565be5f229431457ced75ccad8658090b8edf78a24562d1db4ef2b85 fa38706d92f0f2bdece41511c6e045aa95c0671702669d3b932b11c43b904604 +hash_to_scalar c7e95dad3d9bcf 14fa25063cd5e96033dfe7a32ba043da12c0712e6ce90bcf39aa0eeac24f4702 +hash_to_scalar c0c97edd83a8434e616077150863c3c69555c0501a0dfaf6b9c151c81414 f6ad267b0716dc92078263f581841c28665c4e203608afed703f99bae02c1600 +hash_to_scalar 92ba274b4317 fa0d73f933a67d702616a7e971e5af7691dbce2d2cf75e4d7fa7d62172a8cf06 +hash_to_scalar 3a7cecafe1edcb4367 89b3d092c7ff5c08dc9f51c31effdad4b2cf456a292ef5f94b556fc6b8db8805 +hash_to_scalar 50db589492127215ea94e9874337c9cfb41b9ffb88f3 3e149a3cd272414001f6e65a3eecd712bf4172c670b495b770bf697811783305 +hash_to_scalar 7b584c05770804795c0d79f7b8da48b1e1002c0fe1 dd78767788e8a5c4f1b4033c72e627ad961ae58d3515a69420c44dfa76a1dd0a +hash_to_scalar 7225eed4946a3f6c8ea5ac19ba16378d972e f5f24267d4cd317081eb6f99ce070341272e822879ecade4647dc951687de40d +hash_to_scalar x 4a078e76cd41a3d3b534b83dc6f2ea2de500b653ca82273b7bfad8045d85a400 +hash_to_scalar db9907f24b3bd51cf00c16dbe891f977fda8355e89d84cc93e27387bf5d0f6 73c5bc311b3e0c909695ab4bdc8c890368e1d2661a959421ea6bc25b36fff80c +hash_to_scalar e169e0d3f0929e3bfe48 a21066739e97040b07171668fac7e2fc67a3cb48912bfa281a8795f1a3edb307 +hash_to_scalar 45d6ec9c7816eb98245f6b3fd3b9ab964f15dab879dfa141528c23 4b37059e4ee7ebf7d3f74857d5a9f53cd0f30d39e42e3ea286c4e8728039410e +hash_to_scalar 2b4fdbdc717ca646d5a60f3693ba 20b1230cbe3d9dea3d6abf74cb628aa57e56876f03a4195cde0df6860f8bf40f +hash_to_scalar 15b4f3f5690d c069e453af981acaef67950c981a02d884593cbc99df2fe4b43c8e1c52959a07 +hash_to_scalar 96c0df 836d3f7e21190d609b8643cc96ebbaf81d48cd8190465e42d588de817e3a7e0b +hash_to_scalar a186e340580cc91ffa068f7cd430 27144f0857f8a016035e4190c052b1316ca176eb5c2e85820a65ebbe806daf0c +hash_to_scalar f5e78d9406ed27bb12890bd813abc82f4f 9afdbf19ebc041bc0231b0568b0bcc1a836b928be14742e1cdf615df2aff0107 +hash_to_scalar 4d2454359907302b4e40241a0f8347 0ad36e4098942bd724f0c0941267622f3d274106c8c02a34329cf15c20dd5603 +hash_to_scalar aeb8bb7c2c584d3d7f682296a238b538 cb4b44f7806090f507e928ac575c66fbfb87750da2c025b4ec68aedcc8ac3d00 +hash_to_scalar x 4a078e76cd41a3d3b534b83dc6f2ea2de500b653ca82273b7bfad8045d85a400 +hash_to_scalar 100fb9eb981f0c2f4bba26c83dc44c43e59ae04d1d7d 573bd92409cc04fec79e4d7f894d8300f955c9405aab5965394ff8ff3442750b +hash_to_scalar a83ae1487dbd2951bfd935b774c0fc142dc20012261e4899054027c9 0f01eec9f6adfe6992f10108501d15aa9748373dd844e572912dbe2f50056805 +hash_to_scalar f27e74638002f1d760b8cf98 489a7c1a264260ec5eee7826bae93bab2dbcf3205495c58d083bb4bffcdbdb05 +hash_to_scalar 775066e50e5932dc 42f0cfe1866ebbbd2fca91c6f4282e51231c7a1bb87a40877259c4e0a6dac20b +hash_to_scalar ebffa1366f60830cf937a4 c10ce7d18d6d8044abe60e4cdc6ff4a741cfb0c42f64f5beea92f93e0977d506 +hash_to_scalar a5a5db7965a568a3f40486db7e75ceaae1c2 04c4db9817c16017a0098d09c2e30771e177d72c008614d44dfc4690db85e708 +hash_to_scalar b2f951c2ef4eb6b861c11987f274290374ee76047caeef37122a a069a11cba2b439db896cfd2eee3f105e8f041ca0738a0c2c8ebc7a8b66ba30d +hash_to_scalar dfcc51417d649ae882f4808735a9c7c37740bcf2e13522040c25789c0aff 896eb37d75c364f604e83ea61a95f05b18acf107eff1921fb1e642d3e2a6970b +hash_to_scalar ceb73372a26d746e05af c570ea35daf569a461b967c2efa4da13fa5edb946ccf5566596d660b83ce2208 +hash_to_scalar c4e9946c0aa2cd30ef6a3240c4 a7ede14f04d0be893e89112a6d8c10a413d67b4204dc55acb80518cf8014d60f +hash_to_scalar 5d72b2 c19fc129dd596bde9bb754939432373e815b53282c4713d070b62da12da65600 +hash_to_scalar d87437bda57d 70a13729a8c1b392ef88c8a993e70de5f0e296c81e385f26b2fc9f945bd98003 +hash_to_scalar 661a3e0638e7bcfa422e7c9a7397 aa639794ac5338a17b01d238bb3d1324b7cc74d22d079bce5168c12bb04fce08 +hash_to_scalar e0d812121ead98c24de333cad29b9262 43b6986c5d110f0962d63229a9b094823888d552ab79a54ef37a123d983cf102 +hash_to_scalar 8e1601f8b5ca5d7bc628eb1194632a56 ae021df344beae6f378a362a345307f0f5dad97490651e09e8f58d44c8047300 +hash_to_scalar 665ec2573f172d978faee2a38caf047658c09a9e132d531b9b8facd1bdc5 15f6cd046611f0728b851cad6b9d25ec806cdd3532b18c1813dc5c223ff3c90d +hash_to_scalar 0816e8cedc2c2ed8c4e73a0c75f1c4e44f f26c9f8c1b7b1427b4d86d3b0a3d466279785808311aae09a0ebbcd1ec137e01 +hash_to_scalar f5e03baaa35f4ba8f8a3eba410a4ec4aed4a3bc04f 0e5800bd88f749467b701ce4686633729aab3ec5e579a0c828f4d98f2c9cd200 +hash_to_scalar da935a9fd2 c3fc1f02037e304100e400a4cabace7323c4ef310b2440aa245de2ffefd13105 +hash_to_scalar 7451f59656b0957ef45c fd334a1f172e18a74951df43b982da3d19f9a8976b213f0b91c4b6185a58650a +hash_to_scalar b017e544ae570afff65ff021c99a975c251c 74c7ccef39ef8d37ece8fd5243f6f0607c19b770689ce26a88cfcbd212570a08 +hash_to_scalar ac47b35782a7f64db920b36df228b6 295f8eb09b9358a6fcb867cbd5e33dcfc41ebb74c2dbeefc54beda5d13122800 +hash_to_scalar 80af 9beb9f8f9d5d9444e3edcf2291912112a691f99bdd8e0d8569790ba12e3b0407 +hash_to_scalar 380eb97f71e767e54dd449f64c2c3da7b42f538a5e5345cdb860e4c20ec4876c ff427ee8d2c82415a8da920e6e76ea1de4ae4414181543eeaf06f381ea1c1805 +hash_to_scalar cbb068a11c73c6b41de059df9e5f4c5a0f03d986 f065d97fc9c76206d663c6836ea06c165ecd1886e068af80f36ab8298c56860a +hash_to_scalar 779b186094d2 5cf25b8ca4484a705cb96c2f9858b683e740836847238d1f170ac4065fdb8203 +hash_to_scalar 9b3f73f3a0115149352fe28dc8257fe9ca718f429df1 5c59767888728b36e55df62deae6869c98458a09efd0c955ab8904a6e634f409 +hash_to_scalar 152a 6b502eb3f8f827421e6a42255fb2a5cc2d63141b5978ba0857c101fde8525a00 +hash_to_scalar ed7e73548a53a9b2fd9dbb654b5266c13ca5058a557b5b1225 ece34f5870f7a67e7965d8be7fd80c006ed7151ef42bbca1b69acf7a139c0a01 +hash_to_scalar 5cc8d09df6d47c5283b37276f9c9395e7f726feeb6183978 3bfff6a7a8d469def6630ef588be7337aaf36686b2e73727f1458fc92b0d6c0c +hash_to_scalar a8 e6f0a9b10c1d094f963f56cb5227e539c4e8496a44cbda7c25bb261e46ed8202 +hash_to_scalar 0aeb eecad9335482b43600ef5f9b5db3d4bb46cadc354b2f21952c6711486c91ec0f +hash_to_scalar 6b39c85520edd76b98bd7321794bd6ec67991cbd881f 7da35796d7cb0b903e1036c659bfb08dd593f87ec41206bdcf0d882a4b346d0e +hash_to_scalar 2b6d3db208b00750c01dfe16ff62a27efe60f489703922 d86df18758aa31c662227c15ebf1853489bcf6c204938bc17f655833366a830c +hash_to_scalar b05c8a5914d7e162 9541937576470e144ca3c17ee32a33135fb93172414ea9d13cc8e349455a8b0e +hash_to_scalar d9622b304b65727d00199d4be8c831 2de3e6006a784167ea3c33d58276340f0e30d9d2d3f01fd85c7f2a5c58846f0a +hash_to_scalar bf6b755c110d5b 4419f814c031ace7f64390b287762c0584a87d75bf9bef8960b971d048a5cc0f +hash_to_scalar 1300bac6c13a286268776bfdf29ebbcffe8e9c23d82579d4 63cb5a78d23cf810b5db39e1b9d48d7f1f3cef09d75258eec0620da463bf380c +hash_to_scalar 5bd2b43642d73f52c4bb1ae2eb8098a83a10966efd41aeb806 5ad6470ed0809bccab0a23fbf84680d1a9e8dda4cf002c5a862d7c85c7c7e50c +hash_to_scalar d8f45daaec7d2b206d1986f4a6aae33a0586e14bf8535a821c71 3bedfd95b29748a4100884499499dfa2695acb6d8a47a2c0953cd7cae157c302 +hash_to_scalar c3d9a1b8a7cb0a87edd3 0eef8631cda551dd21303f5a11d1c96b95490d456a86c5e4637933b546734f09 +hash_to_scalar x 4a078e76cd41a3d3b534b83dc6f2ea2de500b653ca82273b7bfad8045d85a400 +hash_to_scalar 34f22eea2cb6d61c34441a123b00 0b754b7586d97a1a88c811bc226eb9b449a86cb30b63b60184064ea75ae1c802 +hash_to_scalar ef94ce0429a249bb35558eb7d938 68d8870d843a53805e12cedc33f36fc87f842140bf3a03a6844d3720b11ca60d +hash_to_scalar e82de0d397 057343ec548dc6d73a0e432325cc731b14cfa89c74d4e021fd942b4db09d7d0e +hash_to_scalar 0f7d 84bed632adb4581c474dadd7d140e55b7127d5e13ae739bedc06c9cebc5ec009 +hash_to_scalar x 4a078e76cd41a3d3b534b83dc6f2ea2de500b653ca82273b7bfad8045d85a400 +hash_to_scalar f6a3ee600e9ed4de45b4f6c26cf41e24bd23e4af c49b184a8132a18e91ad8b220ef96946d94872ce96a5eb337a6f783d59ff9809 +hash_to_scalar af6e3b59d9110d86eb68e17dcb896a40edf9095dcb6018 083fb34ab5bf1ac1346bd7dcba952113cee7d453725b469b49c87f045472600f +hash_to_scalar 8c773bbe4ed39790645b5b1610362afe6a345221acc8ca4cec 42b4ad7a7b808940449ab70562f881260bfbd1ecd1fb3b37704e8a3d50dcdf0c +hash_to_scalar 9b0b2b 96ea25ca64efb98b69e3f8f169e37c1d75910952fa3235a5e9dffe08d7772804 +hash_to_scalar 725bca 428633c15cda9855daea0e592568a792bbda7665b6b8e4f5d13adcd0d8965005 +hash_to_scalar 1b 08e751d9d7b92af99948db9b6d14e515bc12236c2d3e589d2a7adf5ca69cc906 +hash_to_scalar 17bb25a331548082a7a17ced5791ceada62b90fd4742c5 361977420abdef31c10abb4af20fd2dac631adbea4c63ae738799d264650ef09 +hash_to_scalar 1bec40aef4f9a903ef1a92f66eee56851a25b46557c553cdd15f 0b7df89e8a79be601c642e9d825ff6354dab55225ca53b5d8859399099605c08 +hash_to_scalar ab803bdbfd413fcb178dd13be1c86d7f854cd4c35d0ff1 24c8e355e2240b126d2e0083df6937ac59042ba9c0ea53ccef49304a2e350905 +hash_to_scalar 160ba843ef0f7e51 3892d64338498d5ab0f4753d4be70616a169f9f0c4039606fbbf507969b4b102 +hash_to_scalar 35de90dd5717adbf5143884947c12a9aaf79d4a93668947514 6e9e42fa89172bb8d6291e4f99b1730ff8858cfa3c2f4b5bdfc1e54c4e3a1e05 +hash_to_scalar 078948476863961dca5823db0cf1678152 0b6b05d724384379afccd70c684ec7548c3902559e05d88e4bffaea0bcac1306 +hash_to_scalar a0b85d805da9a0b16616 3ba856fe17f975c5bb6305cc97def0f6de845fe14fdc4fa39dbea97d5a839200 +hash_to_scalar 9b007e9d02b504b40df12c89f19eb3265256a96adb5d4918dc399a 80fc823c8b61de2f2bfa9df0f7b9f500aa7ec2d2f9e598cd40bb2ed55716e406 +hash_to_scalar 5ff142 e8e0be7910f384fb05593458d3a0a50cd3720485451a3b88fb766d6eac1b0a00 +hash_to_scalar 693a93fb3166bdcd83a0700e4352 649b6bc56ebb4839dd21332d26078c0d11a0eba65f03c3d0cf72491a0cb77e0d +hash_to_scalar b38ac1f0c87e1392f779626f33f60c2e77 6421d6db09ca6977159c66ad759300673add3f8283d71191d2be8d0e79f1c008 +hash_to_scalar be91 109a614c8fb4e62bb79fd47ea1727c4a0168f986cb81824fade9432d0c62c40e +hash_to_scalar 17d5115b1d4b1c43ebecb63401b34fd3c297b3db7ca643652d 7ffb834a8b227f59dd55b2fb016b0ded3a0790783d739dc96323f345f360af01 +hash_to_scalar e6bac81e3e4c847072a680ad7c1979c2a6c2e8fb128ba07f2c 7a4ffaa201b57450d40534137de8d6c87e1d4c1f3391944de9b923e998ddc309 +hash_to_scalar 6f 4ae3bf858d2ff2319e508f65417f04f638c47e1bb887f095340cf5990e7faa03 +hash_to_scalar b44166b9fb6db4159f62d9a7be28382db0a19388 660e7d09e1bb69c1fcc4f1f2490477f64492cbb6f05a1903615f31bec0bbab0f +hash_to_scalar 85da49ae04daa5c0b9831589949d81c0f17bcaf2442127de86f8a2e746 98fbdf1a67dd0cf6dc1c91a74768fb359fe769103c3ca863b95c891166c1cd0a +hash_to_scalar b85fbd72a3979f 4a169f233c6addab01e9b453a0d850b3339a09ac09664bd70ab5d79809672c01 +hash_to_scalar 36d5b1d708adcb70575333f420461948ba3b507fe164 ff27646bb052a292a3974559573541394e2a7510bd55a146eccb8ca05c07dd0f +hash_to_scalar a27f52eb72b60d3b6ec81ae07a7a328f745619996d045b732ef1 974531b356b20641929e9844f53235c7b28b9722684d6559f7b9fc8a054f9405 +hash_to_scalar 96718971be 5e45bf2da3f5b2b8e4eede4169383c64a3b9c9b0df5923d7aa46838269bc930f +hash_to_scalar c0f7cfa5e8bbd2978d94ed92d4eff4fb954df38d 6e55ba284a3ddcd385aec69383dee4063cd8756b49af1dcd9fe26bc3bd056509 +hash_to_scalar bd437d980037653f5fc415d315660cf7e2cf9c89b2a18355 3957ab6326f2537208f79f6b5ebaf62ea237829e63978b77ee32f061da56c208 +hash_to_scalar 4ea94802dc4c93f1bc53b2e497fc618c3da4f6cc62a4ba7fc4670c7efb5bac 09484d1749c22cc58421109d80b7ffa1cf90124647e00182c4afe4249d0d7201 +hash_to_scalar 82b0849db242 f4c79e1046d081d66e3baa457d0e086947b830cfa2e0fe8941ed078d634b8b05 +hash_to_scalar 5950f8db130538903b0776548418c66b8e095e6fea82 f72d09be4c76d934b81aad5f6635e1af20781d807d8e450deb895edfd50da10a +hash_to_scalar 6cc1024c7a83ee38f5d1641744163588be640a9e2ce2468a76c682 e78596ca4f06036bd51939e877bfa21c8905a41f3f3c9e2d7766a5543a9dc30d +hash_to_scalar fa773a9336c95e b5a698e364aafc7333992ec3aa89cb17ed9f9c99061eab037785dee5be3dba0e +hash_to_scalar 86631b2628f0eca1a720b52d23 0d441df30234fad12ee7e2aa1debed64135b768d87820e5d1aa8106b55ff580a +hash_to_scalar 59 9a2c5f9025f1f0333863704310875ae81a574171bed5b047cfc0f50e347f630e +hash_to_scalar c7f433540c23b5f64a42a35d27180c0e92c37f10e0a34ed94147e88f8d707c22 1ed70274e0fe09a11cb9f2560f6b702c157dd7d3be105359e749e3e6f1d8d30d +hash_to_scalar 8b888f09148925 70e549663999f2e41ef888bf02f6e5678abd283cce8c6edc3c3f716ffa1abe0a +hash_to_scalar 04cad5265e2886e4f2857ff484cf15f37e0da57a37f9b245f6 baea80671a6750fbce4ae7e4b0e47fd40fc2023fb4369b81f9cb43f16939e90e +hash_to_scalar 7f1a66f1f459c59b182211cda8b35c3afef6522915b68a6ac71e4fdee38f 9db92a0b07e6982f43845b8e9b7870f1ddfd5e3c82fc37627fed9ebee4f93e0e +hash_to_scalar 6a3b39aba44aa65c99 23ca5981817a5c50f84072fd41e103da99e76dc498a87daded12a7311159b30a +hash_to_scalar 2d2322f0bb1fa9ec89c24f54e576a75b8747d641dc13d7082351961f bee17516c0844cca19a099615096d5e55e6b5e60f63a1d48d36df3451878650f +hash_to_scalar ab8277f0c90947fff12eb084fd01395c01d8939e3f337c26f24c6203 2ea5f553b96900350ea88bc05c5f2e5967a8db938a2340c5132289a92932f90a +hash_to_scalar c921a1 85b72ad57886613e35468c5230238d0034883f25e7cc691f6bf599501489f102 +hash_to_scalar 7b813af5137c2612f81a6296 1aa2d4a7996acfc988b271d6168eb8497367a818b13a705e41c480061339c501 +hash_to_scalar 495590e02eed7b18edc8301f691a4edd47f1ed f3583733cf0e2d5da90c3cb96d7447636ba20d13367b61318aa1da103672eb01 +hash_to_scalar c423ef60849a8ac85b45d2626d6d9c0e1613ece981a27f57e638ac b4f6f97dd892d9124ff7d7e22f97a1ab1790ba2f5ae73638e20d6a1079b86f08 +hash_to_scalar f3595b 19ac121f0458478e817db36c7c405b93a93a9bd0a6cec2e38a2165b8988dab04 +hash_to_scalar d4b819e735c3d86b c173e374fdfa3a2ee4cc9235c9f1a3288ee1f43d6b8fb21dc9031fa5f59e2405 +hash_to_scalar 67b70bead5a15b5de58743d15319facfb56596c25d2ecd1cbd591b6f56d6fff8 fd1fb9efd2d642ef2fffe98d72012cfc8896b229d4fca3c1130123414a9d6800 +hash_to_scalar x 4a078e76cd41a3d3b534b83dc6f2ea2de500b653ca82273b7bfad8045d85a400 +hash_to_scalar 32bfca 9e55322532b249691cb11800cdad7af669d91542ba3a22e3b36bca3b3f125300 +hash_to_scalar x 4a078e76cd41a3d3b534b83dc6f2ea2de500b653ca82273b7bfad8045d85a400 +hash_to_scalar 64dfdcbfbecec7d20ef84e278df1b48c4d6b9f74fd ac2a2b5e9be42d4671b03688863b2fa4ad2c4a0edf1aea3b655a9628fb93b409 +hash_to_scalar 8ff1dd65b1691e91a904c1b01da6a7b6a97838f0 c61d80faf26ff15f9a3d49a5f4b3f36f35a6dc246e00d9ccb97ac15629b81b0a +hash_to_scalar 8f3561c1 e6f25b4bbf45727c430ac7283edb9e782afeaef24557104120d598fb14952c09 +hash_to_scalar 28ab0fee046d30114632d1a8301e3f9980979cdbb341f208 9d005df0be511481510e2489807ba5c0ea92af255583f2cfee6cff1a182c5300 +hash_to_scalar d99411adeaa051c9fc5c1225e59c b33a824170a84d97183353c0e1bc4ecacdbd2619c5495bd903b4be0c91b5c405 +hash_to_scalar b652da d3d4ec6770a6023fa910c28ef9b063d933a089ea5be57488a7a24b415be4f206 +hash_to_scalar 7edd274a8c47 4e615ec7cdd783db19b63db625b4bd8730f07b2d24fbe580dd3f43b3a3498502 +hash_to_scalar d1d428aa3a8f014a4b2573a0af9240e18e3fe657e9a749 22f8040569f976ed4533e451a5f8a00a82a336b182df2f3360e0b0ef1312100b +hash_to_scalar 04c96cba68446468a13ba1d85477ffe3fbd6f3c88aafebe0f1d4e733 7687b1e2f4c2bee2e7ecc348ab1cc63c4853f73c6078c0e543b7e2627436d304 +hash_to_scalar 94844f43438215fd44db27e015736f35816a0b655193de3befc17e0c807792 c80d6f088df3f3625dddfc4c031a504e5a85227235e610a272aa7b310be1fa0c +hash_to_scalar 3207c281f89913ec03d5b3b0b08810 fa21358d2eb31fcc164cb4cf42ebbeeb79976472f36c3ce2ed9684b1b3677f06 +hash_to_scalar 75ef2c4e59a9206bb25e6e55be a2a06c06039c4afb6f7cefe48d6c4710b8ea17d12552b6dcf5d10e8c9efa0a0b +hash_to_scalar 23168dcb92f68c065df88f3801beb87a 002b05e0bc49ac56f3e120fafa3ce9b7620679ddc5e5e7c7ec48cf8dc21c0907 +hash_to_scalar 42721680880ef743a9e5258cf74c85232dfbdeb6283bf31d a8e2fad23f131b868b82cfca32ea1a1ab8b3516035b102abd94b599eed374e07 +hash_to_scalar 7a2a9d06b6ca081a9dcac3f9440c68 98cd08928220afb6d2d5c2f703fa98f6a9c55e77f3fb6fd84dcdccbd4afbfe02 +hash_to_scalar 7b0cf6 568c7d70cfe869dce2295a4208845eca5bf22de5bec3134ca5475c935e4f330b +hash_to_scalar 0ea36e41326c1fae7e2cf716b4def1fbbe 05309447b79be498ab58ac32d900d045acd01ec4391a153883f6c06106fbe90b +hash_to_scalar fa16119c2f0e557393e3256cb71eed9b5498758d353d891170020117b6ae88 3e12a5c84834dd0bc2d74ace209aa26181171e46470907155e1a502942685a02 +hash_to_scalar cac9bae2c66d6eda4093810836ef77852bd79c8064aa2ea29408ea85ac 5c7ea9eb94ce6815900d389cca5b4eafbfc7ebd423b7b22cf15ffcab703f4c0e +hash_to_scalar 815539bcbbbb3a582b3773e8 4386a056d2a6d0daca73fda839c96d31ae2b26af8f9987f8297696e0fb5a6b00 +hash_to_scalar 6e 68e36669be9590e654e62ee06f34a42791040ec42ef0aa69e59f09872f105c03 +hash_to_scalar 7d22ec3d1f3cea2be70b7bbfa09543aa 6b89c0c7932271dcdad120e3d032a486629440c8dd28d7f72734fc7e11dab20c +hash_to_scalar 4957c50e61573a7fc595041ffe8e1ee043a1d439263a5e115453fbf3 797089272c0a29dc46cb0c3abdf7e8d709c6271127343d47dd17a8eec358cb08 +hash_to_scalar c478f328ec84f1beb5b22bc5fd037e76422169ce8a 79fccd7bae05990d2e7df119f79938549389a3ee2e0c346567a43e037ffb0d04 +hash_to_scalar 2bc6eca318d96652cadb2d211e98334704d01b77 70024e07c87aa1d6e92056188518ae19255962c35af46f27602fcd15ea39160a +hash_to_scalar f8612a2e8a4fff879f1cbb0d310fe65b49107964 12b2335e58eb20a8dc8ff1a5bb868d79edfd704bde1ae6d26a5fc601cae21209 +hash_to_scalar 39cee47a9ac8c924e9bd302746 7c3ced52bd56302892bc2ffb2df2a19d8d05acf7dde7a3690f333cf672e3e604 +hash_to_scalar x 4a078e76cd41a3d3b534b83dc6f2ea2de500b653ca82273b7bfad8045d85a400 +hash_to_scalar x 4a078e76cd41a3d3b534b83dc6f2ea2de500b653ca82273b7bfad8045d85a400 +hash_to_scalar 21c2325f10d3c3337fdd3c4f8f6fe1 9903500efba40172c75be826b20e2b1cf5111150bcd904fb4e1a557111205208 +hash_to_scalar 5d9fea 497b515b746be9a6d4ee44d5cd39e326bbd5b14528c9a4383d124ed20442ca0d +hash_to_scalar a08629f1fca98eca85f5a6 a66de38c9fbd42182b57c49d90cacdf5d8fa2cc762dd8d644fdf64f70d4d780c +hash_to_scalar bdfbb55fb1fc6f226c4bfa3466 c5404c2b0d39db6fae4e3c3a8cb4e9085b4873834c094c1d65d75d89140f6309 +hash_to_scalar 929c1f648ee357a132597daa08a6b36c03d413a8956a1f11ba5d 423e7dc43c18eb85f7e00652cb1ecaca5f41a454714e79f6c541ecb9a911d702 +hash_to_scalar 8fac9ad6c126f9421fd35e f5904cee95bb5e130f5ac77debe1676963b44ff0886a5e148717fb1d3a74e20c +hash_to_scalar 458fcea5f4bf97a4cbb4f4396d9e97dde0 cd9e96acc5184e429a9703d855d1dd3089cca3f62e80f1ed6e25574c080c4e07 +hash_to_scalar d1dce32c02fcf1cabd244066b00e47992b9a6c31f4cec4 15a800bcc57fe15b4af6e0ff9641511b92b4ed33478fd69dce61f7aa003eba01 +hash_to_scalar a09aacfe861e94995a85998bb6f6c9d652112d8a77a1545e 01f9835e4c61025dad60b7f15eb0a9fe4ee0fe54beeeed82a092a522b01c9d09 +hash_to_scalar 6ef2b70a5c57959b57a040b2a3528c56eafb1494ffe365f218131911 0139a03b8763a4e01bb2886ce2ff095a6fde54719f59ee25a590687c85d4e60f +hash_to_scalar 63e5f6a8b8588315e5a93daa883bebeecd67e9ec88c755 04182129ec028b8ee4a1382c43479a45d27ffaa5ab90fa456dcb8b1540be3c09 +hash_to_scalar 1f44b7c7f1d0fbaad31dc2d984 8b08c5a5209d106b8991cb5f1ee3c9a66367b669e7b1090a16309a7ed472790b +hash_to_scalar c3d88100ebc8f3ea2381e25d610d36fcc95d6fd542f54a5d03c6b3b52b b08038e00fc5e53a5f93f7691cea898c43064470c770bb202ed0fd9e72c0730c +hash_to_scalar 8e21aa83f5128a6cd1a550161843727178d3b1ea0adb16d36d439b 654923db734fc492cd2c28523dfc36860ab0c6f3dae018f762a886298f4aa205 +hash_to_scalar fc7089fc0f72c700a3bee0819d83f87320e1c00967b75433cf1f6f fcd9337e5f5c6ac475d9a77836161b85d52be791ab80051b391ca62c1a625c09 +hash_to_scalar ed76fd127c013952de4221994e10cd7141ba880893ec0b160900 c1550e485843757565e1140010f2d4584ab475d4382c43b022b5d23ab9588b09 +hash_to_scalar 23 a324bd0d2a8032141f682a88c5deb31892d86818ac98932f7ce2907c5976fb0e +hash_to_scalar ff2d9f9e7cc8e3514bf9ec20e5 06ecc498146a9f3b93a674dcf8ba4ef7de33c9e940379891ddd8c1d825848305 +hash_to_scalar 599945d722a743e1 0ad489bd8d81acecb2e655a252a02940672f93f145fb4dbb75740154f3863c0b +hash_to_scalar adad4c02a9a66205ce d7a985ab9f4b8b7a72d3b4c2f5de10bae0032fa4f6cf7e8ba28d58a53bebe207 +hash_to_scalar d50d3594f4eaf29b93a3e2c212 c8534126bff1ebf61c9287c798d1f9b8b867a670375ff3f11b712564e83ff008 +hash_to_scalar 0dd235b0323abbcb9996ae149c2e1abda8bfa185ebb2a64f53851887772021 9b9f71b76ee7c39ea2641f0452b65f53538f47cabdc7fc4ae51b8f4b8c904105 +hash_to_scalar 997402 a9d7d12d7fb12ba82f66d6b7e9aea507268e1f2bdfa26657c0e5dd1f6cc28c0d +hash_to_scalar 53dc8152b03725b6f96f258376af0fc6e73f16daeaa2d19696f539c234 3a5e74a06be26f674f337df96db52248b7205675dab1cc4595ded2e244cdeb00 +hash_to_scalar 2b4485a77085d16d1634afb46b68bed59d6590199c0f 9d883b5140b45b8cb19b1e58ba197aefb82b19282bba839a3f449c4aa4d8bb03 +hash_to_scalar cd39 5d209f5ec13eccee9dd01c5276c6c3028eae3520b8f10f01cfdef216ae1b870b +hash_to_scalar 13bfcabdc8b673b87493f669c79184bcd33f42 ac00b11e079c70c9893562f707e647566a301eb175d93ebba9183747b29c7802 +hash_to_scalar b68c5d50e28f93807d4e77a675f2bdcb3e81f75963d531dfed1101cb 1a84edbaa00d14f2e6f243d0fdf328d0f2dcc6fd392e3da243b731a07133ff07 +hash_to_scalar 5c5623df5a43f56dba69f2fcfc5c704db2a121e1f4ecbaabda 7a6bb3c84258eeebf96fdc3b5be8cc81e471b721a22de3b9091be248a7ba8204 +hash_to_scalar 9d8386f72297cf41427657bd19327fcacefa2b 99aaac34b72fe19924765d084eaeeb14ca543b9857eda55e85a67bdf6edb400d +hash_to_scalar 935f8cfe29912dd29070026db5ca0af64e4e34 20fa6943ad7d79e8154b8eb7cd7911b33b0e4aea56e6d3ad05c8ea79bc763008 +hash_to_scalar f4d62168478835caa51f5f 6d69674b71c9ae54138178d439e3524dcb17864b5dea0272691a88beccd2530e +hash_to_scalar f5a4ee908a77ee51b8c3466899c575df40a814e56bbe4fed22 e00a483dc31ec7098b48850d0e88bd15693e27ce422809f49e6f9c5463eb7106 +hash_to_scalar 246ac597c8386b252b8037a8e7f11f4acd02c3f8bb7351 c7c2ad02ccd91b2434abe439942ce4dcc5dfd44ccf8f7ae99994229c876ee403 +hash_to_scalar 8122f1ab97f113cbcd034caf 8eb6dfbd5c7d62cf10502f2ef4e90dcf49e89e374f9486ec139fca588d1cdb02 +hash_to_scalar 3b64403dc86b0f37 6f89f29aef14824c944d44870dbc17372f6a5e9f194e4e9b2f0982f35493c107 +hash_to_scalar 0e8da976e3aaf59ebdc09e9582292abd7d9dcdf90c83d102314626aa2cf2d9 79707beedaaa1d231d0d61eec3c935454b542746ef8b5776c877ea6b482d3703 +hash_to_scalar a217d6214ac5a6ea6b35a46ec07dd772cf0dd741bc58892a44e1be 4a3a57496112178056c6d749e86d06917384433edc8a7cecf6587ad0e9fc0703 +hash_to_scalar 25a7298b03157dff98428fd7201b ffc577f71d6e7d18727d43abe19fbaabbd1ee3b953b2b4c1be014db173f34704 +hash_to_scalar fe46a74c7e7c 384a6c160527e298885f914c16331c3007a6859d95ddc3d699cc7aea15459007 +hash_to_scalar fb0eef56ce078311e4dd0afa08b57d4f497eab4beb35c8c74fc667959249d3 790b735b5bdbee8fa44b6f07513f6e81eeb2f3d62f6fdd237a628d079efb250a +hash_to_scalar 5398f0b78de8fbab02402732677840c21a0cfde4d0bdd1aad8976ee713 804ef61908aa15bf5e8aeb97c019df5794993a4f2e2ada967b22ebc32f17470b +hash_to_scalar 07758dc6ae54e8cc704d288046 80ea68b156b6c9931b63f63afe79c97642c4e9c1cd2dde723cea3a266b8fc40b +hash_to_scalar 18877a7e05b84ec7c1fdc744dad76700b95c808d0a82123d92963a3471 94f2b511f50779bab1c105d15a2a0af058d6a45d879107930a6aa5b0c8d1fa0b +hash_to_scalar 2f37fac2f6bd42 054b5a4762a7482c4923cd5efcaffbe3d4feec20fec4fb830c917626e9806005 +hash_to_scalar ea753ba82b4573d428d526de89daccdfa7a33079aa9c9ac3 d9bf5688fed9c3f4a9de4c001f1de130002f117bd8543350d57b8ef380b76b06 +hash_to_scalar 2a5d772c76aae0040915ffd7 8227a0904298e726cedb75746b0a3b41662002b4ed8fa05c2110e4a15bfd310c +hash_to_scalar 585900d92342cb8448c944f97d1642 acfa0d43b9c6a91810b0fa1bd42f0d9e077f7f5a62f9d9aaff8418e1130ea508 +hash_to_scalar 2ace 427f5090283713a2a8448285f2a22cc8cf5374845766b6370425e2319e40f50d +generate_keys 5b1bff17a9c26feff8ba3fabc9e14d9c729bc182a4e5e6c0ea390510d0b69f4d 548b044902b6da1edf7abbba8de293cc2c8b3db901864027d35d1587f003e50f +generate_keys 50bedfc7485d87610cbb55f052585bee67e9955e3eb4cf48216a3c370f0a67f8 3b290c6a5465047525d4b639763d778ee55b1e9683c5fbcf809c8867d579d809 +generate_keys 1660aadd3abd4b8c4ed1c618969b15d68de63df06fd5c2a570b12daa644c245c bc3d92fed4453a9a359b64236b8de6c3f31ce1369c2e745c46fd0441bb28a708 +generate_keys bbb0a1b8f6f66ed9e2cd0c1a84bb7b6823480ea2dc4830d155681e69b62ed762 30ee49af7ce72b883aba42adc06bd4d04a77c92849b27755a878be4137ad8304 +generate_keys 4de96ef7e6052e3362fa1b95da33ccff4b49f182a9b1894d03d6ca7c74f70296 0c827ac906c29c3bd85791d530ecb6e22eb1437536a9cf4d67494daed44af402 +generate_keys 3b0bb4bff19c10709f40ab280296f46a12bbcfad5c76c85be2d1edb6647276e5 3c36eba7519901a99750a50d0f57be30b8b7b40106a410f92bb1e977a89cac0c +generate_keys a4bf1f9e58c1b739616ac76505740991196f7a8fbe6b3707100498a958b6570a f934d64699453da097dd21ddfa04eb5862dd25115e1cf4e590f49fa017902a03 +generate_keys 8ac96afdc404c837c3668e412096d667453e598ae8d1c061e7a85853168e5fa9 bbed60a47a517ee49a0763e8daf2aff02461690faec1d0575b7d5d8b9c57bf0d +generate_keys fea2995a1a360eba2569ea99c59d4e516e4835b96d9a4e50d3e3c2953b8bc68d 4e9c7f7a92c7a90f84a3a2a27b8d0a8fd5139d35e76bde9748ebb7279c3b6b02 +generate_keys b475418a659dbf6eac90d553f70b90ef4792d5a9008f6fd3d6fe9206b51e5f74 02d6a8fc49eb02ccc2bc5e8945b9cfdbf613ea925474cd6bc09c502cc203a808 +generate_keys 94d245388554d0649bcc946cec9d75712004a0b2afa9a9bc7cabb2a2bbf0a307 2e03b177cfad669246e48dcafb04c68cb0909c4e172b1c31247ff557406b6609 +generate_keys ef30ef6d032fbe80675ab89c4ff82f16efe346957ef618cc7a6d57a3682727ad 90cc1294e09a386629d14b85392cde3e40c11d3ab9ff3b7962977825d0d22c0b +generate_keys 79aa700d1080e221df74db8284a39a253585b806bf308b8b0b2ae9d8d16797e5 d16fffaac46f8ecb6c1889f5ede0dd4f2fe6d97cf276de2e9d8b7985cc0de208 +generate_keys 1f8bc117bba6d6203629ad1bb7c7a685f5380b158e3ce62f12a566f45b5723b9 117bee308c1a471adff1f208b36b647a156095d94af3afa0e5526377fd169806 +generate_keys cf7d56347ea427d761ab587fb4eec7aec14c0f2b8e7ddbf3c08481a7a7fd5c86 a7d3618ecd9f0fc023abdf658efe47aacb91025831fe324d5d67c5d073b8b506 +generate_keys 4cc97e74f5775eb20e25fc62b5a6f89b2f0c8c4e25a781b4d803edcbf38f163e 6c1af6a11d377c5d4a52d679cad6b099a7b9dbd73ad996feb2383c09e1f5ce0c +generate_keys c76662b6c0cbfe654431494db620282c549b1118ab609c101f6d3477a4fdf021 af13fb9fcf24ba1e4af5f389e660c38749906f7520e0a31369d4e6208b67d00a +generate_keys 7bd25381eb1de9be0cddb5201d9412c5180b0591954507821439e9b8a54448f9 5dbab52b0f2fd0da15a5873b86ed5798c25fb89b458da66f5050751a7bf12d03 +generate_keys d031a3b2fc50d238bc6784506a2067076bd98b4705db0065022c4d8553acf5d7 d163039b46085c2685b818ece1b0242151f8da82ce0c84f52b79ebf66486bd0f +generate_keys 17b080a8ebd878f101861cf23d20537a6dc3d88b8e831ba3b05b719993eb4f30 ff804532c84e4a0422c8ae62201d65d1c1d39748ab235ae90d1f2a200b807909 +generate_keys af5862785966c79585df522ca6c4e0f4f4249d46e19daca1a9f5dea6c6d9618e c46e7d74486182e5bc9adc051f3312f289603ec63f6c94f435e5a1ab3277cc06 +generate_keys c235c61d248da5b1d8d8e39885063f56b6bbefda3218f4225d709c9df0ef7ada d7d6ded3cd6151753d8a6685dbebf9feb804187895df8abaae42b30f66a9f503 +generate_keys 8fd66befdc1e9e9d46a2d2b68ec2c58f8ca77295079f277e3446fccf748e6bf0 8f7201d0cb6b8c7f035089e6b69ca23f118f46cd4a4869b9d79a63114be28707 +generate_keys d88dbb2c218b73935d980be99468b6c4f8fdb65bfe3d9db2e3327b3bbe9a6751 c193575c0c7eb2da96e4309f259d24a722a7cdc040c6e139ab4c03cd23c4130c +generate_keys a33ae9b0052c4377ec5162a3860acfa271d1d89eaebc7ee5b2d78c9bdaf65b98 241ad9128abba5c0535baaa0f8ee0aa9d53badf4cfba3a209a2e2a6f71314108 +generate_keys 9206e2f4021e1dab6986a7f8cbd3c8c5f713c155dcda7c722a5ed1ee160b3fd2 de576852c9f130a3865d9795a4f5f5615a43fbd49c09d5e9ed485c95e6a6800f +generate_keys fb210efcaabb5f7a5f65d78c459b9d5c1cb0cbe972c15e29194fe5b8af4d9229 fe2bcc33b7faaca55c5f2c5d18212e7ad8d29782b7088202046c011269d1a20a +generate_keys 58ee355886041dbe8cbbb7738014abd69d1f75b6cdaf32bb2a56126a02be61be 05c9b44c3a12373f9683266a7fe8950d7909a29f0497de77bb5b94ee92d78a02 +generate_keys 8dc35a32b21d5a841532e275d10ea73d56d3f37b6aea701ccd6a5bc1ea5bb5bc 0afbdd7bf6cf3b6eed97a7b231f517c29c4731433a7744502ce16d23d01ac603 +generate_keys 904d35fdb4060a7fc9848f90bf268541b76e4cf5417dcfb9413af248d194d6ac a111f0ff77042009a7a376b159eb068f7a2f1c4bcea12d23df78e5067ee87d08 +generate_keys 1d82d6b307e5475fae2ad9b83032158eb4cd4333e301c93e973bfe0ade007345 3684110de307ee5167b1daa06f57496f9ecbf6957f59adda0569d7580f90c507 +generate_keys 585b8ac5c39f152e81c125f5a4eb05c5aefb2406bf435c771ca13ae337604808 bdaa87631bce2d4f1b17f489387accafb946655c0f885f06ad9c91c89fc9b000 +generate_keys cf80081246896ed7b5e2a2028457d0fb49db747bd06d797a7ff751b542094ca6 1ba926a3eb6b5a9921ea3428bb5267c1bc7e9c85203244e86d2c8d364a02d207 +generate_keys 294258f27ca6632b11e2d3df89ff50a323aec9e4ca110e407022e17468562819 67669913687c7462e3df45e9818921f69c6155994e8e8963e91d1c92817e8101 +generate_keys f79c754e9b2449064fceddc59c464a65bafa1032f8e426eb8d6aff03385328d1 3edfcebdc2e427686da5228f7f05e14a1ef242535af45c66d38f1be17c852906 +generate_keys e31ddb15d87d8a959d4956b25f8dfc45f1d54fb567db2603a13e36f1ce450f1e 1553e2b92de9efac7588423a60156d451bfdf4591856a49dc5a037c141e14b0e +generate_keys 5e42b38d735259a11dbc738456a63359806dad3120b38dde9a5233f37909f680 40504b7117797a1fdc632d7d9cc148bf0db55210a155c0f7ee44b60ba3844104 +generate_keys ce6b8ed77b3c51d78004532c74d6eb051dcbfd73975140218018e674686f23fe f3ced0e2971c60b44a5e84c5810ddf1310f81ba5ff8a12b24d0cd264dae71607 +generate_keys 00498e98c66511a6079ae1102c35b0e722c88fcca77b4ea5b665ce318ca86f96 ffd5f03495784f5b8a79a6e1f77d21894a2a37406a09ae84c32a9b6266d58e0a +generate_keys d1efddb196a689f10dd9819e4a8166b62839b438e4e1dd46c805dcf8b570a31f c3c9323d3e446d220c7059fd98fa0c9ab9b026212835a970378c143c938a3108 +generate_keys 30eda42e7fd79d90e653fa605172eba8f3677a6c6dead0acb93b6e1b04c4c2de 6fe06ec6c1accc7e1565f472c5a7ef867a3b1d23f559d0810ac124616aa1830b +generate_keys b3ab042bca24c4a39759190898c25c50482cb73abcfb29667a7fd9efcde04e6b cb9eed98bf42c8cbf1cdc198262c71cd061d997603f2adeb775507be60c6af0b +generate_keys 2dd2227e2c0389d859b2d9750fb11a8c9091317256c2cdd225ee92ab07f896f6 d6598b1a68f7336b82c8aa371ab7e00c4051177223bbf9983ce33f918e16a704 +generate_keys e19ecf5adb04349a5044c197304d00024a76137cca9cc5ec4b517d0ffab6cc07 798f93cc0628d50ea67efede34650bb8b1596cd5e1b5a1c6f89b8e9389310203 +generate_keys 45434718ef414575caaf5c1f9c6e5e6646ca908eba755c309f7894b939e883d2 0f809e03709ed6f0e9daced253b315d91ff7f9550981b3fa6450a05bb92fa40c +generate_keys ed0ca85d956ea041613206545696d3864080268226dad32fdd41cd222c42c045 6b9518aab7daa6cff16778f448d4e2b36c478a4fd9381b4e6c33370c2f3af40a +generate_keys 69a3628d2fca516ccd9dd28340a950d462691c8873325ab062c26257907bed95 a6e7dd03681bdd1695aa2022c7d378cbe78300a6fc58e5fa8e0ac61bd3af8a0e +generate_keys 3db683cde4d0c0ae2efce188268f5c1ca87a3ad21546ac71cb9e975401426986 c95e5da7115f792fd4fab589e45855f31de19d341b2917d31db8f86ace60c10b +generate_keys 831eaf30631ac76f73107d6d828f8369b4aeca7aa7ed469388c6685f1d8af419 bc1f1efa933caab6c5d608fa202284da37e53815429ef84982671da669785606 +generate_keys 632c0aa6df19aa1f404e39f1ff49538120be12bb9f22cd35ecce9a2982a8a593 bae04146f2ce06f20686664d800a9c6dadfeb6fc8cf377af01dedd137150060f +generate_keys 26b2e8dc65f82ba76741b47d7a37ecfc89e40a4f47e32b4dfd5ae6eb73039180 fceda7c8835b0b559ddf17d41a12e3a14f2f52add7cb73feb0b2cdb40c7a4a0f +generate_keys 9664a312a2fc2ec3e9f99e5ab5941000d08de91db78ecaacb136b0546bb8b3d2 236b68574f16ef4dbfc3702e16498049443d7bb821ee47d146a45e46beac8a0c +generate_keys d8e60e86158b4ad40545ffbc1d5c4e5304e32e60719568ee9a6438a04c301e24 83c0ccc0495659b4ee28532f204eedaa1ffdcbd0bb20e4df7b336ed641c4410a +generate_keys 093613f65e539c735398e2d623099e2a2b4efb0378fa5151760dffc6aa9fee1e 9798015bb8fe277c836b17b7770da6620c3c0bf40fe837f30f69d233b6e7eb0d +generate_keys ff3e3883b3f1c120419816ea29b21c5579c3430b0d1cbef86ebf27cf5fe73c4f 4c62326d13d3a1667fd9d14ed592d03044097a60f940d9942d43e0afc080f102 +generate_keys b4152f960aef5d4c332b75385f9fbfa22abbac2d52f2ada962187fb522cc9916 7dd6cecbf9a3ae112a4c8857cd922d9e986f4125d415a75b8bd657ef6a6ce90f +generate_keys b2f9cb612b6cc8f2dcf6402a0d101a85e490d976e26afa77168e030bd2ecb32e f1c97787f585ec27df9292df3e3d0d1d915a564dd80640feb437490c58c43303 +generate_keys a64b351b5d6feb45817ddd31696ead6acc0bcfe4b38439761121232f79ac5089 0aa3a82fdebd778527502e1c644dd2c344c2c8c493c62059cd1c33c213a0a705 +generate_keys 3bf47d762cc2c6432a047ef071d7dd45577aa7e5de22540f13f92a06857dc7d8 12a0d11516b36c5edf46d0d095cc3ffdaf3d792b34ee4ea07d1e76424a70f508 +generate_keys 1612a1c727a36e5e6e04c941905783f29ed79555633f063ac110821bfaa318d6 dffee88cd40a8ea4cec5f8be7b8161cac9d9c3891f4cecc290e001b0adae4808 +generate_keys 725820f73a8305fad708facb32ddc98f4c98a104d366b1c314e4850daa3a4b41 c3503c975c72817e604429bbd976f2be9f4527ecf0ffeeb89f17cabd5f405304 +generate_keys b5adf16d1e703bd6ad3f08184cbafbe03fba3926076f6d6b843f4d9efdc934e0 8337f17836182f718a14369415556e5c7efdf2b7a8a0e6f181db9f68a1370a08 +generate_keys 278c8ca7605fe252699e0ca5897b8b87b68da1e86602505c1688f86c57a684db 7d36240639e26a7738e54281d33e3f9f359b8b9ac79f7133e23c9cb28737490c +generate_keys 77212eb4ec3bb2239f409fc4e33b1626da4d1183c7a4c88784a6ddb7a4f32495 7b8c06a2a9f9119eb22c02c0299d27db2d75c58fa6f104c922be6e24f59eed05 +generate_keys fd470afac9eb2ef7ee1802746b4cb46a5c247dca54a14a12fc32af81d2d6bc1f 5a706c562f3971e2b51edd836dd81947c6f263c8620e0c4a14182316d3d39b0a +generate_keys 58a4ba97f03eb8d05855c7df06c863baa5bf0203538c70ce868154d8be8b6e03 702046003079df66b8316d46722b2e3732966c99d6443141237113f52f006205 +generate_keys e7a8abaf96e61cc7be03011376d3f204169c0b6e7f8a087856c11eb503f485d4 18967c04a7183a2174850e1389a74d005cd4730235e68803b2cadfd3fdae2d04 +generate_keys 8c19e0356b3a78b18a492643c1cffccec3c92117219103cb634db028e8141788 c72699bb88889d06f6b74e27ec66d5e004b8892d5f17afbd7540b056a7439702 +generate_keys 73fd4b38e1fa460396fdd206580ffd682b732fe0c5b76d4e7124457073b0c9c2 83ac6807cecb9858d19a33b7154110b1e5ab9c53739dbb86ec61ea60db526e01 +generate_keys 05a72d54166657932d78442c263ba7089bc081d15deb4720ea01ee10d89eb68c 7e0887b87721af58854753387b4868812dfad99f81936a7f18da8a30c844c50b +generate_keys 53c083bf0d9695f0e7f0c639a394cc15571c80148646fcf87748365fc702a809 e84473be8e06e04b88062bb2728a5f1cf2a6a61d199af677eb771979ec503a0f +generate_keys 475974688153f2e244c9ba25549fa5dabd4bb3a457a011d95ce1ac8a93643079 d026ae72a7b4eae888d1b00464b6a4f524f58b68f3e28d1b87fa852aa76b6807 +generate_keys d0446bbafd1d81e47441a0d0f662d35d8e8e8c7a46d340298880ae79f6b8d83e baf8cfd4040391d3c52cbabaa5f0236838fe235df2745b02235bb82a90da380e +generate_keys 229d8c9229ba7aaadcd575cc825ac2bd0301fff46cc05bd01110535ce43a15d1 217b89eb99e66c31eea36de52cd05fbdbbd612935f666838bf2949a757998807 +generate_keys 280b1c899bb52cb8a597cede3730a1383dc0a48c63fc133dde87d89dd513cb07 3335c7acab6860d5f1ca823a9dcaecd92270622f5f8f5270a75f379df1200e03 +generate_keys 88e6db236fc9f01c11b6c3f26d4cdf2763704756442ae8501214416d8e1a7082 01e7bb013452a447324b1e8bac74108b82750ab5b612a6f8c162005a67be1d02 +generate_keys fdadcb4433fa04a2b6900bfcca8bf4bfd39ab6df876d788e309028b116b17a33 cb1e5891dacc9428113c786971305f30c7761f6aaf6f325f2bac6ebf18c89802 +generate_keys 6430989596c8225d82fc4b21cee6518def534620961a4176cdf989b0b9cdba17 4da2ae7366a6069e46042cbafc63283d5d672c4c994ec038c0686f2599fb3b08 +generate_keys 80cc6c6ef5b49f607787e32a47ee2ac8a41f9e0fbacd1c4be329861aa1e54f90 a943c700fa1b28bdb407ecdf5b30ed3d086dd977c7fd1ae9e2cfbb398605d200 +generate_keys 1a8c936e9fe8d6088763bc602401db3e41bd5e41d1c1639d9b73c7ab5da9256b 150710ed8fdab598e150f6db8503a5caec8490ad369ee5e23f3ea664ce8aa703 +generate_keys 17bc58ecf7ee52da6bbae74ad453d5f7f87de51ce540733f2cdb1ac0973ff244 2902db0cba12872ef8421311bf7dc9e22aff133d582fa67ec0d8f6a61b148700 +generate_keys ad5111aa930a4a1b9d41fddb573f302884ceeecc57d8b8a52c288130c856e13c 2de137448d0613c2da977be5561977b1ca2bf04db559bd06dce8e49946657504 +generate_keys 14168064cfd8d2e746e7bedb3d184b9e1bc6d4544512fde8f0231492c30b2067 7b0622d19cf94e1f7bc5b551d561464e425f1634279f64d701cab25261714901 +generate_keys 6b507f25c8b74ea00962b5d2fc3d0f60d5b8a9acc07b7168ed7abc8e243aa17c b2a05c536f87e96ec5461a74d5397bc61e176330e3550b190ee3f2119fe20d07 +generate_keys 7ead086dd0aa68bb70af16667e0687a51da9691c569e716e8ecc8292a5c60ae4 fa181562cafc0f62f14b014bf650263a0e758245077592c5048d6bae9ce7b904 +generate_keys ae7faf51af45cae65d9500800ffa4e23c42fa6591a373850ad7824812afabb20 21b7257d3a2cc7cc42f8b9e1ccfe30b1552fdf2179f3af298481c322cde5c40b +generate_keys 291d9d0ee240b44b92e7e0a06d592585bdc5eb2a8e830286e3db67ba7cef1d2b 23d8064d7fc3bb0a5f79e669adc88a12b85c479ac544e415cf92dad46bc8520d +generate_keys 314fb5acb1aa0443744588951de4ff42b46e9c84ac3fc2f8f7950849972d8ef2 5b8535c4e2c163643414446408a02cc121418ae291eaf94be302db00fb908a09 +generate_keys 09270e301d35ffe97a31c8ba8d05db2f7cc4ce39757f2169d68f7771345974b5 fdb02e5ee98ed6960e6ce10181076ea8303cb314611384f4248dd4e01257ea00 +generate_keys 26b91657d0625dbdf78201f61913e2fa6fae9d3dceb19d0861faf616dfba1466 4e929bf2e36a19a583beb53029ab0e51bdd6a9489e4ad272024033323feff80c +generate_keys 3a989ed61cfa729599a34361621d69ffa0cd5d69470f8b49787b1dfb7d26d302 0ddb22893d5500c4220c130b6824c2605fe41e250fb7d1a9bc446ea80020ed0f +generate_keys 6585ef6b4f6992bc611d1eb1e506f09f977ae10d402244f60c315a2d0cdd03db 66a87aa4006e807d4eb26134bd13719e0438b5fdd7d9ae81f22ac0d7ddbaa402 +generate_keys 3a869f822f6e2bf8398addb052e6ff449426d18c72f1efc1162ea53406cec119 2be030a5fa7b68696e4619d84716544bfdef9c202d7f11dbab4f67b7d0dbbb07 +generate_keys 7d000a90146cf13716e32bc6223a433074ac823d54219c62787f1644ca7ce01a 09920478e8185daad53f89b26f889c47cc953a6cf179767a865236550e51f109 +generate_keys 534483c22be59d10891a6aaac4aa60cbc368f20e5865a617d201c1219fca65c0 3a89c221c3e8bb29a1bac504b0f1304eb945d0ca651e203f86944d01590b500d +generate_keys 2dd8415ac4c83c6de33d03abb01fca432c2b179501081e5840a6508a43701030 3efef35f253f8e93463c6dde4076ddbed0b155e8d509dd2258f0579d9a3d5508 +generate_keys 890beb49d277495977b0b4b0928f2b41d5c8a5424a48fd7df2db1bae665a392f 3cf1a35f01377bd70a190b3673e3248d2b1543863ef0e0d9fa0e3b4ee99eac0d +generate_keys 59ec4b30bf26d68c96617759bc6ffc3bdd3fb5bb1afd8796dd2a5b15efd2f9b1 2a3be73ba5a3ac03c066ba7f5927c73f604633e53b3f3a6bffea5f33de5b200f +generate_keys 4712cf846db2dc79aa8eead0ebbd8852869503f9f2bf4cf94a769febaf387df3 2ba8d586d863153b613b7511e73b262f33d6d39e2a359871d8e4d57a7a85dd05 +generate_keys 20d59ce77abd46b04b2adbf65c4932b88e357e95e47251df0e3711be03d885fb c55b91ebcd79c92ec29b31b9962d23e5d8cbdaae51416824eac092702eadb20e +generate_keys c2daaa84bfe48f2df408288535822058f73680c3284e4c6a05680c2f6c2ce450 916aeacc03422c207402e485c9820299cdef0065b3a573d1621ace920639a50a +generate_keys 648cbd6469186de180d808421697025ac45540b06058f30318a324f228545cb9 1291cce65423b162db3c9fd66da9c5c0ebc5423058d76f8958bea45ce726850b +generate_keys a26572b9975e2b8fb0c02743c0b2b8c32f4f16c0546ebd4be2f74d88742ce996 6955b7d248f12a838afbd106ea6e43127478a41e584ea6090ea581af2a28a206 +generate_keys dbc87b3bbd00cbef20ba1fdd51a928f4f24211a89af3730d1dbd9c90a9efedf4 93d3a24f5f38172b70f46cfaaf7eb115b88474b55c4f122cd3eb06abfcaf7701 +generate_keys c2e40aa89e135078c8c4b0db948d03a751fa28eb45a1a37f22031d0147b98bdc 8b68edede1fd6aae455f40f97d4b4155ae2b32e01a530803d9515bd514ab5508 +generate_keys 7fdf4a2497e2bcd1adc644b5fc1acd7eb0fe53f8f5c519b2444a2826e8463cc4 696b161cea1a0234e1fa4d50763a8eb6361043a0a2954bd325d9c71f1336ad0c +generate_keys 0c0de80107edfabc84bac72cbca0d1038fcb0a32dc25bb5017eb52c072021c6f bc2f2e26acc1f460cca178cc38fff83c90ea3451392ad788503b3cd82eb6a003 +generate_keys 04d641fdfe440f3e01a3596e4200c857d24e2918d3764080c5a2f7c44e38ade5 68fa96ac8e5b428e170b45fb0ac3151bdcd3a1a7022abd8e3c4584adfca4d200 +generate_keys 807688153b50640b7abaa3d9d1825818dced5bad08874c645f9c55d1defc8a8c ac3a5e34247bfc11ab12de6bee20e4be8b86be1e83c907591eba04c9ab562e0b +generate_keys d344358bbd78c559951fbc39973be66c7a6d40791a4d95cb3460c0451d32fe1b 055e32944b5b68efdaefb007031f1f6f635e104b0061ad06713e72e553f01f09 +generate_keys a97a6c4ca9ae0608a47a5a802c3ff3bd2fda7684fb466418053ce151b3d2f965 3be573497ca3f7ff6a9e74b2b071ca47a92875ea2e8684bef53ffee469e13e0c +generate_keys 1644a5a274893dfa8cb5b002ae81a0184bf8dbce27153e2a5b61c039d11fe4b8 ec5e13b096f906a39ae8191139521451220c55135b4e7137c541021bfb8d4f0d +generate_keys cda191117ee28798a4595101f36677f3012fb8a8d77c15dfcde5c5370e65f74a c5707d3b7c46ee96aea13572ce0098c147ed76561f8eaa785db3c751a38e5702 +generate_keys 8badb0f3c682bab82a98030e501858e99c4cd8882e9ba57b4ca4d6dd632f072b 8b72648cf1c935b59cbea1f88ccf9d2db4f51e9d3dd171ca584cdf5417f7ad0f +generate_keys f14528cc98f49f22f72215dc049201098cfb3fe8a10ec54f48e1e23abf5a406f 0a41beea9c5c52248ea46a167082e2a237a25a23dc839d98b0617f30a0cb7c04 +generate_keys bd5e2bf398062052a7b8fc499f5a80474ea70a8de306db3ce043db1032c7ee07 a146746c51e8299e8aff371967fcd33e6ac3b96cb5fb8ae02d42530cbec97d0f +generate_keys 7a9a52124939ac956aea137e859b63c2a66a94ae3ed3b9fb5eba69eb48b3e816 b2000748fbea1f6df428bb671ff12c9a2d6697b31c56ce27b680a6aa86da750b +generate_keys 69b79c451023546b4c20f49ec3d50cbdf98cab6423f4c106d2415a10fd0dd013 ed8d702fd96184aa4b5c3b6a2d683b50ece8c866564cc861ec37b1321565c806 +generate_keys 36faa952a937b438050d542521e4e4e1d6734504ba12f433930af83ff3acdf07 e90291292669866a5394a0a34cc64cd3d561b8355937b98e5021b2d96693fe0f +generate_keys eb7d36454b781100f69fe70297ef7ab1d8fc349b376ea545d0a430db1f5d839a 63e52602fa15ea6931454e621e757ec3395e13fd57d860cbafb34b90f9ba7201 +generate_keys c1a3027bb6ac32c304ad9a70290f681e63e80cb1578d15e619cfea843e5eb34e c6f8299781d6524d17499e5fa04b09c435576e9be69e47fae036c2c4b84dc703 +generate_keys 4b3ef10e56e4f5d55ee12458b3b67066027599cb48e63dea8abd27c550fc86c1 8de4f875aa66f27d5e53887e0053ea7558b918e16964a12d9c682799283b190a +generate_keys 21025c4b6e55fe86855db0046c50e651028d89a6b8f8347e13a42c5967818bc9 9fc82cb609e23e2308228c2b86d3ff277463e3a2009947ee3ddbf94e56ed2808 +generate_keys f7056db091ee3826916468d2f576eebbe465989a830abd1ff16493073522cfd1 ac107058df4686cf9edc7f76133505f0ca66365f71033cef509b5f7821c18f0d +generate_keys 995d3fd1eee8e212ee7c04c37a17a2b2e95c2853eab81c37dbcf5e74d789f0e1 b8fdf3463d0913f2446b1ec0b11ae8c7b91cc8495d73c286ec683151b1508305 +generate_keys 14b59433a23359931f2814013b1fff0006a969af807b036e53a946b7cc92f3de 04d6678e56290bd21092c10c5523a8c9b81b2b9352b8f4091b3867e3c4b3ff03 +generate_keys c938fcf664e7b6e93b22d8a3dad5ae412d4eaa6d019c3d713f1182ba8b3493a8 57fdb61f87b284029e6729976185fec161a29b42f5fc1c34bb0e39080de8f20b +generate_keys 4a206c012e437d2f4c13afd6aa1d360c4686d14016db0b0f0db4f8cfad4fad32 4b16f64756d5ea6820347e633d87b23ea39988d3e7cdf8236eab2afc969f7706 +generate_keys 36e9c71c91c9cf0d6afc0a1c20971f4838f5ea15448301a63654ce17d76fb094 2246bbe1f2ea6695c5e7016a581755993233d9e517638b0be739e60e84f49f09 +generate_keys 552e069a6c480746e90b3736cc77cd9d58bcabda73de2dcbc33d8586c08f4499 c9ec5681253da937faf512c9dae1c4f5d778903562afec6b2b6582fa4380d80c +generate_keys ea1117459d4d102ca8b2df1eba6d0033be916eb884e6966c150936d2b610fb28 4548a565e8971fc09572ea0001d0321ac5437884a91be5865b95dc9d3c5d4d08 +generate_keys ed83434a71e5967fc36526b046ce6fc38293f2a9cc85317e719b77843bc0fef4 14aafe8443a6d0416e3ab4ce89e6474cec8a9f6020ee80550f7c413ad144de00 +generate_keys 20be914a2473423da71c8ccdc265b529411fea9d85f4a3e3ef899ae0f929f227 441ad4c295361c7cbde452b8ffb1cee4122dcd97e68df0c1be2b38a5f324ff08 +generate_keys f6f529f85665c82c3d2dbce1282de6f7fd1a89a4f264e80584ed0ace499e3e26 8e82db8d8445dac40f2014e3975e75c0ac53d1235a77a0661d7c4e1cad79e70e +generate_keys ee3257492f5d109237123ed10f08f667854a1ed3de0b315bf48b635a96b9744a 04854edafd7ca4426ea961c9f32c616b2c61ab92ac694e816db38a4168c68a03 +generate_keys eefd4f221f76de3564732d9ff6ebf5ae9279e6242b6cce545d918bb56d564bc1 48c23c8277ca7a29ee0acf4fea00511dbf04243394f4d81f109c9b2c8c67050d +generate_keys fddc7e7f9ab851a026cbe382f51fd9aada78cf56691a7dd5401cce8c9a70450a 23fdef9a57c0624ab27d321783489905d15df666f8b64d75e0ba8f5baa3eaa04 +generate_keys e7b5cd9ac0af057ce8e2490942898c4502944b9beef616ec536ae19718c1f11a c952168c46a2619a533cac11c8218c303c8d0452cdb9bf4e159d4e9dc3f7b501 +generate_keys 4931c45856bead621f2116219db91309a55e662eebec0f34ed2a5db999b0f7a9 dff0ef8ae5eedd0356a3a8b31e75e68bccbb6ac87adb58194a967f05909e430b +generate_keys 4e50722ea5c4215126fb364deff4a2190503a08c9ca065a57724931e1ca60e2d 2c177c44e58b323202616c6fea98d8d5d87b31f374ff1dbc3c9a3eb002dbb10e +generate_keys 18152285674f8ede11892e0908430efed268e444fbb358a9b836b22ca82bd852 5fdb23624f8f746c56d887a8760e37815c8f92f09d303dcceff79956c2816b0c +generate_keys 69909d1c78df30ad0f318e734ca3121ff7dd54bdf70cf3ab2f900813d55317b5 748ae40ee3fd197973cc95b499e3f916ea557a811f62368349bfb43686a4ed05 +generate_keys 34e7f46a1c2fcb589525275098d1fe93b007bf9d81ff4c8eea2d17080d69b748 d7d490f2c1634d95baebf639be908c110831e29b4614a5d1e3479fca3d4b0a03 +generate_keys f3ad6130ab195d85ef12cf8aecd4c06a942a33887fa9b986cb9ec2d7adf0017b d866ca716f6bbd40a0a82dda2a4168e8c7d00291b70e135b4af801d676994708 +generate_keys 959dbc0e9828fe3ccfef2118f5b3d941e8eb0232190bcd4bd9700b19d5af6517 bd793a83bd13ad03d413e346079ac9e12ba4f1a00b1b1ca90d58844424e58e01 +generate_keys d294bb7f4bf95350a55562a34b6b1128dad2fc140c6cff0b68e6a172579051b9 0981e7b85633c526f93e7e7ee3c086d9f1d12ba0fac23f304e043d2975af2c09 +generate_keys 8a583f2bfe7d394f16a2010777aaf59df96117a79ddbfca87e0fb8c66eeda76d 2bbb038b6e986cb7d4c168da9ca96fc3569ab626fce670cf8a9ea204b251110f +generate_keys 5178f2b1d1e948d2ceb01494e6df580598eb3a2042d953e3220b82ec99619bda a91b76c31d69524466196390663730abd2265d4d3a73ed6052fe9ff799d5eb07 +generate_keys 2c32615363ac581fb6979d7cc4f8c26ec366258c1dcfa7510e5553687f6dada3 594ec5b03f573c5b2893e878c539c30bf0933b241e47897841f9d5ba4e015603 +generate_keys d5af6e427f29b00d8c995cc26889e9f6970d2345b8498b4b7202c97488fa33ca 10903196ed1e2e0fcf8719f1e73aca2e140e11d08c24d0925f87b7cfd9d22d00 +generate_keys 743f96e1be451423745ae71bd6d9105741fd456132ce2998835affab90439cf0 cfafa7247879fbaabc0da3866cba788928f3f2e51176f77184fb462ab9ac0504 +generate_keys 9eb9452708c448f661a050757c083a5726f89828daa95a59c92f07e1123d6658 3a52fd4b79b95b0f045022b49d0f941eaaa2ab6792e5fa6c44a4f4bf13310a00 +generate_keys ee2999e4347a3c9a5f08a6345f8c9623cf4bfeec6cf648d1dd47df5a8639b4ab 28c61b0c43e67df4233701598026230b1c9948b3c0ffb9d4a1686a49c51bf507 +generate_keys c49fa30f4b663f0bb096ad1a6b86d4a7817c7e2545818a738f5df440b1b31e93 8044d7c2036266903b9d3f3dc2787862feda94d53795b6b6029de9a5d769150e +generate_keys 55635b25520a88fadd6887d89d756a35660fcd7ba10e8a57b324308b8a68b7ab 6b0bfcabb5c8bce361fd34ad428c18d0986f7b5a6317633b2975c2fb48644607 +generate_keys f64c4595e9b90873efbb8a6bf2833ffbd06177953c7ee91ed826415cb42b49a5 4daf418c6d1232ffeab4e4f2e2e9940d29f867fd0d237a37f8d576eac4feff0b +generate_keys cb09dd31dbda881e86249c6b23481380d7261435893e774009f35f854c8582b7 1af00fef5c54a30331f980ffaa5d1081ef17bfa00cae3da03fee66b6d7784108 +generate_keys 2fc3faf2348bc0be89b0b4ca5ef1b8d9508ea00f74ef11d9fbf0a4346e543565 9e5aea34d3014e8515660e43f30ff62380fa61c57c098b032629a648019ccf0e +generate_keys ca0da87c8f8f9042646bbcd90515bca8ff4bf8e7ff8e7551e627f341674b9b7f d08dff2882bfba1e6efcdca9714dc2bc46e7eb74d314d2910b0e36b0e1e0fe0c +generate_keys e2a484c6e868a92b10660d9bc10fe0183a9b2969a96bea2ef41f7630c8c2504c ad6d2cddf36c5d18606b143c7d31fc30cf84244b2d2ae7733b2a136f1e6d5104 +generate_keys e64120db95f30c49cad33ca62a90b5c6d44e1e45d8d0c8b248682a3bb630e39b e559fc0fde0dd5d8292f52193e30ef421d990ec636b1232c0a347fcd8acfbe09 +generate_keys 239d0fbdde4339cdd8ddd4690cf190b6c3e3364c09b06c4517f354b0f38d03ba 99846e2ef2eb4bba7cd7b9a089c2eebe150bf0bee5c65b2133ed4a40031b4402 +generate_keys d02f998271d8546e77c848b47da7830ce9370ae38724008c6fb2fee35db0e23e 5e2e2883d0c6f0f2f58d7cbe761bc0db98b3afc42e33aaa1cf428e2020532f00 +generate_keys 91cba576e408beb078729fe927a5175a52364db21879b06faed82eb1771ecc8c b964a7f5a8c62e9582aba6795837636481edbb35cde26ab4c609c75f8ef2530d +generate_keys 07e97bac3444bc9ecedcf91323ab5246828e60bacc86e982c3048f7c992fb0e9 51a8f73daec11ac6c7db362965b74f84d009b581744f54bb317f3c76df496f0f +generate_keys 93e74a33b8a682473f6c8e115f4ad9f211c60ac9a0b393f1f82db970b16334b0 46e6955821a6eef75dcf16c527f6251abad801f42a12966bb55f802dbe45f40d +generate_keys d6172b356b65d072086cecec8a49bf65f847006b7fc4b9e704e4784893f21df2 cf01d30e3fd0094e70fb12c5e4176bd7338d5e95995105c7fcfa9293e923f900 +generate_keys 4067f06ec739d01268eddb3446f30a7661084080882583fb7f8bd7055314e216 8fa3699c7d2ed3cc563123b120c17d4085842a9dec2c92f5df37593cc096890d +generate_keys cb8a7d80530db110e62ddf14b28036ece54bd0f8fd159f1f5c78488d141c1426 e6cf08de874d7feae11091c2bbd09d22652ec18222bf253d0aece533c84f5904 +generate_keys 9d41d5a930b74663132acca08662919040c4279537f830d603a3fce00caf379c abb013d1a540ec0c9aae8cf71cacbbf171914f9a521812b6aee68e2c646f7f05 +generate_keys b7a01ced9294248dae433a60d31371675b69c728b524cbe21e1f5174dc8c0827 d1180c69e745d82c2fb355b896b16c89471a3654373a3191a404c09b56d27d01 +generate_keys 00893171807a440bf3d88c000ac334ab6aadcfbd15b96bdb714755d839babc65 1833b15521d048fdf0dcbb3189a5d71939415b60568c989e6d29d6ca74110b02 +generate_keys df4baaafb91e33b5a1b711894b2ab57ab1a9f7a43dae1bdff07e6b422a2ead77 d02efbb7de745dde153a2013c84c50031a353bb433fb58504aff1df12d589a01 +generate_keys 237b4cff929d0605a478e6e77eb0d0bcd3e629b1ad0baf970242aa470d0b8622 18f969585c571069734b260a844a0db3fd2040f9ff035bc8517d99dce0c0850d +generate_keys 1c1d37627db49c8ad06688e4022b6190131cc364541b106e73b5a092b2e48b21 1c99372c91fbc0878bae676ba67aa91a3d6d01f65b8d7e580f08191131b50007 +generate_keys 58f89fbf8ac0167c150ef07975907a75246cf7849916b44f188b77ce45224672 00441321e8597a75ca29aec7d167494819a5cb664752b20b078103aa2c5ddf04 +generate_keys 461d68a7ed05cb355c0eeb0caa6b08eb704442e9867f4a43f52478882822bcb2 07f82a58fd05e51233619e61eee4fd22605dad2d4d11321f897dc8d4a47ad205 +generate_keys a84c805abf8e8d409babf557fa5736a85e6fcdba7e4b0c096e229900d6601ca2 c4b53824e7b766b8c8cee6306378b5f197299519fd90a83dd33a44f08c9e6f0f +generate_keys d8c016db39ac6dad0cee4df023a17b33c9dcc3b3711ed03b2b800bf24d9ed69c 3d54f8b4aa7ca169a79d17bcbe2717747437759493dac98629bbe5959ea2d10d +generate_keys c145737eaafbfa8b4b6b355efcfc6cf4d8ffc1b517a20ca1612c8d66d19cd2c8 2d59259149fd406e250e6d874f1d58a6dcf216775e655043d6e867410ea7a406 +generate_keys 3038c320501792bcc625a27f425560b992883707e87166a238ed9d264b860b42 11bc4415a2df6755d9bea880fc5e6216a8f149cc21721fec82445f5acab8f90c +generate_keys 9b70a23c83df0ea2e795364b1c191e6b78a8542289f70cafc9d90c9a6bf5a870 9c2949bdedbf8173256b4376cfca362d6da9fc7fb643b1eb878fd6a13e618a01 +generate_keys d14b2c7ca8f14ade1359200078b9baf172e05f3a4efa6daf57efda40f96528bf a0b1abf1fb731cc939068e7dbf270527f87b96e75ea2277eba520104df699207 +generate_keys 3b94c8ca9a2104c2f6cb4daef2a5e98d26050860dd44c979aa75636f82784570 649c12de60a88a128797aad418e5ca1ba7bdc3f52bf8ed1a46901123fd7d9501 +generate_keys aa355cb61b468dbfbcd553e429083b88f4cc310ddafc8298dec2e05b3521a776 2e2899ddf55b53d6d169827444eec801aa15a8834287946f6e8fc8b81ccb940d +generate_keys e3c5306515831b0a33376814ae211875a9adda6bfa7e5b28271ae86bd45e03a0 c623c8d4cd58e0e8b19851eb8bb31496572390d06f6ad61919e3c03026450707 +generate_keys a041190dc37b9804ad425950972c349b65bda86d0fd0d0d5caa67e084e89c401 6b687313e709231973dbb9e44d963161f5680700de26f40a9283d3e9643e8a06 +generate_keys 213864143a9ec2b7ed0ef6869904fd49cfc4a9ed2bfeb6a45a3e939d73b43322 e62f4d052c86f8df37e86b9db3bbe8c7a1858bf3802fa2a414e3d56edda8d407 +generate_keys a3caf76927a272f0b763341e290eed2ca8db2fe6fc77c7e768bada164ae9a4b9 815829f66c3759e8bb5d860ac991fece60e7b96edbd9994e45be5b8d7e3a4902 +generate_keys d4aec2d112199b5f5db16dc8797d05264d9c3a48d47513886f70eaee7e7feffe 32fc3f2e90cd0f913e7f4e31f0ca3fd4571f1c4e1ea8fc77165a457ae8c97308 +generate_keys 4926826efbc05bcc68ab322b48170edc07583e00ab79ab03466cda4f6ec02046 779a54ccb0ef31dd476653e7e5437da031739587d9fdf9fcb2af7dd48024da0d +generate_keys d89973be10e8aecc06a286798116b01263025d0e9ad4f573b3a5507529a19657 144cc1a5e4f387c494d3540804b49b91b860abf2ecf57c8fb830aecd5299ad09 +generate_keys 62464f9d548025262b40d9df10215266fe3b1d0490afcc1926d3063ff843b10e 66518a2868c7f627f70ef134b019ab615b06df44068297754baebaf59afa6800 +generate_keys 858df7b352e95f1b0db5ccd024569558aec1eb6f5f12d4e3cc973195016f65ad 4746a90bfd6344b6882a02d7e49689a9b3a0d90208f71d77be9aa1fe5cb6cf02 +generate_keys bef7333c565fdc9f13e8548d4f4e9cb85966f7de206c7814596c69110d6cfc3c cf26f1e423565bb985a41ebce25310d1f7f3e4ed84cd09865614e3f51a7ee105 +generate_keys 34129d06a9d1aa0ec30509303ef9e6d5030dfcd06ec430c98ecb8c995ca38d7f 7e61c1aba8854e40b2ecba4f2094f3945191d86678bf7578f26d3b8329e4a70c +generate_keys 9861410e7c4412b11587f24b72b70b3a1c70895c3d334ad3589751ed7151c60a 204e866babe65d4be720429f8a3160dffa0147f1956d4ea51e9fc128fa88c309 +generate_keys 9457ad32f3c8d1751059a7f0bf8e3991eb90878278d0b2588270f73ca90fd40a 7ba56e436e23fd2cd8698b2b8f30285a65edf671cef1d681afcf068e0c02ff0e +generate_keys db27fdf381eff45085dfef00289f74c1593e48ae8a4b4bb3e4249d62717800cc ba5dcf2e7acf0e0ab4eb98799aa250a56678a0de3a2c43102b0b3915bf39d300 +generate_keys c803ad8fa94d52c7e1b80d1b70265d1749a7d01f092c9205a206cd6b22c16a0c 9f72fdf649d8e11ac24cead862c8fc4ccd4c7cac81372cc6a8d31d6d6bbdb000 +generate_keys fd9382f23aa8eb9a45443abeab9166c5cc5c82551e48c7de1896a24800481385 2ac53b477112edbd83c29e9ca44be41ff1961032b69764a49e544db1a9d52e03 +generate_keys bb6812e294abdaefb4a7c495f431ed70ce54f4be17a03bd23c3f96c7feeb8166 1f2b9064de1cea114e432b3f7d3006c0d8f152e6da806fe60bf07a3d1425320e +generate_keys 58f44247c5211adcc9aa1e39f30e824f86277fb3a7a3dd4579eb69a7604a8b2b 9c9bc189f58dd2c310bbfec3db09100e66e789ee1c9c1a135138eb84f8b1b004 +generate_keys aa3972dd13304c0667eaabad9226f1600801c86d6dd4bc866ec7b6bb02355d84 2001b668402bb0018b5ee68cc1409bac6ac81e11edf327593199b2721085520a +generate_keys fa8893419d85032ee942567007b6399b3ce84b66084d87ce7cf1928416a54ad3 c10d20ff85d6c1e488a55269524743efd8ef208b0c8a66dbbed68f00d9fa0304 +generate_keys 834d06a425eabb71f7a07a19b27cc1288a439d2b2ae80c331ab8901f73d699f9 07e8ac54911af50cc8d79159e7314d5e5a60198b624bbff3ed0a9ab81dc7340f +generate_keys 42fea3047a014b71b1db1cf90de03d0550edc5087ecd0f321173e6d3c0b9789b 275d6bf22051dfdd90adf4e5978822b21bf45f2bfaeb707df7f8b29590cd7a01 +generate_keys d7c3d2b4b000a5896db5b80f791b677ca7e013b774a091847f3d25b3604a595c cddc7efe7ba386a25b4c730ce271eaaf03807901a3eeb475bfb84811901da100 +generate_keys c21fc8887dd3800f66fa0662c8511f11d912b2ef377cd1e6a400a5dcf325c14e 2266944d63b2f17811df85cc86d5c7fae4d14741f603ebd51f2d11361c173707 +generate_keys 94ca1f7b82bb63d908aa16a4e53db8ef8285525d5e274770a3dd4ce4c03b4765 2333c008c69d5a4af2f1774ef3108a499139787c83cf00d300ba127d84f08c03 +generate_keys f9eb32f61c53a7b39563fd7a858cfbb297f3b0308a5fa239356d774cd9e82bc5 4faa9fa31886b73ece9835693d9f9c375aa7e85575e2a5a07e6666dce711d908 +generate_keys 14e52bea2fa51dc37701b79a35f22c23131b1a774f7a6e767ac8195cff4530d6 38a9d141eb34200d07b5214764ed3a60fae1227f4ee875dc219ad54f8942bc00 +generate_keys 65d8f19befde7d697573c0c5eff6aabb1ce7cb004914cfdf8590c309a35620be 73410fcaa0cad528e1a94ef0d99d8d40236600f17017d2d76ec5a96935616d0f +generate_keys b49e34f9e87fa71c56bd73b06bc09665bd134d72d232721a2c46028083933cd7 329a2159965a402dd1f6dc511888c7600852cdfddc4b6695c12a90eb1c4fa90d +generate_keys 97887034d804a94667381ccdcc77047fd0cb29aa03436c60474dc041ba3a36b2 8561307bf2316a7625c3f637474fb6db49334cad2ed5883eacbb276e74499604 +generate_keys 3660d40bb4c51aea6a99caa7d3c05a7f66c450f7916ea663871da92ea87de22a d10464a7703fbc848d0c000458688d3894ca34ebdf16442bab1fc7d728f78901 +generate_keys d23bc0b3f73c519a474db364fc6df409c95b8e84ae0f4af837c4a8b0459cafea aeccbff36ba75c638173d8ea6d0940960d247e7009655258ef1090fde0a58b09 +generate_keys a1558f7ea407d2607e08d2aab0ddb2a534c98f8427afe162a81de0f3a043a9c1 d6144c3da2c10417a8a4a6e0cb366401cc724164f0f4c0213a00cdad385b1201 +generate_keys 34cea74b7afb81070047c0c8105109d9029a9327f8bbbe5f0d47a297640a333e 8616285505cd2412e34d11cb4f5402ae941fc45f373328b80a1a513079d67709 +generate_keys 775db4dd4119cc34ccb138db6e31898e807a97ad5a326bdb19d8d0ca0d2351aa 6bdf77d16905c391fd6701ce2e9cbc7652cf06d12dd0cd4e53470d761f7cdd0e +generate_keys dccffd2450b593691498e7e3e6c9b91cd5c911fbb34c3f1ce47b8538f4b01fbf 5fa65fecd565a8254a79f282db46a8540cd08d1352deef9df1c8f02c3bf64607 +generate_keys cb9929280a93e5d75d9d762a8dace4bdd792092f9e308bc427f69948ad9db80e bd51d5fd98643be89ef5ade769abea280b54772053ceb130835c6c4e4fdb0506 +generate_keys 602d92e7bb6516f5bed53ddb7ff4c2a21458547d3caba2a661b2efee48c12ff5 1c89008502d9d12718c18a5e06d3f02b3592a07ee6a23b8b9ba4ce43c4b8340c +generate_keys f3682299996e71075e0e3765c6467fbfa49e15f5bdc5cd763814498210c6b692 1244fa03249becec2660893f47e4042d4ba5c82a1863697b7e92c1f308cf8300 +generate_keys 07666586b7bb1d64b722becaf5e04030fb4d810101d9d6576a607b813a394bb9 2e7d57cc5c5096fa26b19d7dff2724ce35c06b4567d9e90fec65b7ce9c9dcb02 +generate_keys 24f76b93880f2f9bfb8fb5fe02d1a8b556256a588b2961b89b46dcb234fa56d5 b2f7e888bb515cc70d121e4db3ae11899beedfb83441f942fe2277d478eada08 +generate_keys e66744afaede774de5cdaddf7da49597634047f14082a8e7ba31e6d1d598e5ec 3eb23129065cbf015a74157bdbf5e621b1b055d68e3d89be772a2c65080bf803 +generate_keys df4d49cd4229e758188152568192c8d125e9c4c3450dbc3c4942d7df9608a80d bd1353aa7f23e52b050218a54a81f1acb99fa9ca1a4bd129d453e00f93ee1c03 +generate_keys 980002d21a7b5e816b685b95bf4d0b1c0b6875e232c07ebf1ad5d9e50291e33b 400b6149223b950c0f9671a0f6e15f03b87f61a39469cb5e64d45b16be23670b +generate_keys 9deddbd4f93aec6dadd565140cc33b47b430c56af25d37d7e2268f3cdb5789d0 7ea6884b41b391c3b2d550276ed187a60564f660536c2935013ce84253f33c09 +generate_keys eeacde3b65c20923e76f498ec3d2f2d120de67917faeed1e12c160c9eabd4f29 a417f386c7cc9a5dbfabaa27ed475540aa2b5b90daeb2b1ec59a4394a96ac10c +generate_keys 9bef0d0ec65e02ab9e53031337a8c5c21cd1f47cf4bc36a21a55d4f13a70fd36 0d51f52d62745359c55467a78ac330802f4f99aff36d0c01d4682c7f1f21a605 +generate_keys b24d55f4f7fc55901ffdd602d62c9e3cbfb0b7929c86f143e5079c218aa384a1 c1e289f4f5adb5a28f8f551ee65b1e7f1627b82400354ed9d0a866d7485c4306 +generate_keys 6461a2eb23b011d6ae906337a9239c50d4bf5cc1fe84ce931db775b4822d0171 b0930d2bd1916646deb4c7bb65c525a29f265f019aa5a5806ec2be5f2c486b04 +generate_keys 59e814a9cfbfa6784809c00a0528ecc69601b2d3bb345dcf115d6857b9f16ba1 d06b14237267ffa9e2f55507a5f2289f4eb3fe89f398673bdfbf051003567e0e +generate_keys 846917dc56e941bc2fd8944c777aa4d81a584d9f8a16976d15177b5715921146 a0dcd8d70e6d6c0e1c6c2da146319effa1e00123f57c54189d98c13f4d8caf0f +generate_keys 03a6ac9ebc217587438a3d8f9e349f82c3ff5456e01b12943f3f801abc42a643 30d121ba4d0b499eeb559cecbca3c7dc459f591e102e16fe7ba14260c72cd301 +generate_keys 41c4520da5f22d7643ba42dd985678cecc6d488af1fb01ccfe628b63f64cdcd5 ad9b947f62cf725da1573202d1044f575f1d0a7c74a0b9ec2498e64caa942d0f +generate_keys 03544579ac7936a4cdb72d85ed84c74935d00bef1dac605ffab84965e1b15e43 1468a286066bec0763c36d956b250e683467ed947f4e29e13f44a8e226a3de0c +generate_keys 17c3cb24792e29407dbca3d97860a50107353a83daa5877db933e2acf8f44cac a1211c88f231dfee6d5e135e02bf96b35918fc06f997a4acc3e645fc443e4100 +generate_keys 16f7c5f8694f44efc66ca707eb44e1810914028b6443d49bb63c255ef1929456 e73a072feeebdbef77489fabab3cacb64381a1af51df1fc48a45075fb2054806 +generate_keys ca6800e3cafd9596d1beded9ac8632843c25c0c144a197ee2d83de9504980c2d 994a1b04fb5accf36cbb3afefffaac60e4af977b4142c6ad92763baa5259110e +generate_keys 88c6d5eda326cc429ace335e2dd2f8ccea7fb92b442fd3d3b9c8a43cf673b681 5b335c0a81252d2928af843c3d8f2755fe291860a88aa5ebf2d41a10e374f60a +generate_keys 50abd9aa3dd60b11cc138dd5b495b05168c1b456fc0db5703654d55a9560e650 e3a4edd54cac10a104c89be41ff498266c4ec5ca8a120e88b4c90e21af8db402 +generate_keys 999bcc50c873d67b80fbe108c34628e73e92a3f95c622b68b11efefcd2d05b5f 7498fb247a265cf0169e460654b695f27cb7f40fbf4e3f5fdd422b7943969302 +generate_keys c30b4b74672dfe1f6d8e8805b49577b7d31777774a419445e698cf14fd087392 cf5d27968f521f45b77b9c374e6ead4552a7c4a1aa2a957fde794ee27f01970d +generate_keys cc5b519994590d413d2c62175e15aec85c290e51ae7b5f87ac173ed9c0977706 1bb0b61e5d3b4a5194084505827ab4aad305e242e0763757f14fe63198d7bf0e +generate_keys 584cf994fdc23ee3f352f9317de13349d0401ed86a3184ef87b3b20ba9276c1c 2ef083e2e5223a8842f61e0e508da37749ed796047553c0968da27dc31b0a70a +generate_keys 50ad0cdc695f832b543eaa2a21b7a23d5987e0cd4829a0af58083877fc930e7c aff1407286adfc773864652bb2218c8081f6ef6e6fabfafaeba17f5bf98c5503 +generate_keys 36f23af9ea19f3d36371ddea14f439e5950cf1d429ed2be1cdbd1581852c9e34 e3ec8aa5320c82b51e1d254f1e08dc826fbe72a1afd32a8395548967f10daf03 +generate_keys af4bdddb4652c034a63afe38bfd9787346dfc617f47588b586955f8d00046380 c5d8ef2b11e4c55952ff5d9ffc95726baaa2be3b1d5034dcd0453f7adedaaa0d +generate_keys 93dcbd4eb0494f34222d2ae4263a5a64c1217ffb37705efbb673a3c73c61bc30 d098457de9bcdc0381d7c51770127b6fbed2081917aedec762498626df461c06 +generate_keys 1395c23089ebb52f18c1824523ccb05cee69d68684fc28b2a2f2d2179276ed27 5aaadf56381f650a5b8b3f9f793c9cbea913b52a1cc075d308dffc45ac8ccb0c +generate_keys 5e54333317feb3750a389f6f29f4ff13f61982595042f281fcb0d60300816b0f 676281ff816421ace7e8db6329a4b291fe296e347716a85707ed319b66d12501 +generate_keys 97562c45c747675d240103a8999bceb8426420035d881af55fa3278cdab5d7c4 4d4fd7e57286aa2d3cb66df5de8c1a61ef69179d0cb3f6b4dddc93ad8e460100 +generate_keys 6db001d7224d662d41435ea04c756e31428bf3472226b4f0f55228c13ee66773 9e39e281dc59750f252e51b68dadfaaad7c29b601e0a8c2579bbd66f88368f04 +check_key c2cb3cf3840aa9893e00ec77093d3d44dba7da840b51c48462072d58d8efd183 false +check_key bd85a61bae0c101d826cbed54b1290f941d26e70607a07fc6f0ad611eb8f70a6 true +check_key 328f81cad4eba24ab2bad7c0e56b1e2e7346e625bcb06ae649aef3ffa0b8bef3 false +check_key 6016a5463b9e5a58c3410d3f892b76278883473c3f0b69459172d3de49e85abe true +check_key 4c71282b2add07cdc6898a2622553f1ca4eb851e5cb121181628be5f3814c5b1 false +check_key 69393c25c3b50e177f81f20f852dd604e768eb30052e23108b3cfa1a73f2736e true +check_key 3d5a89b676cb84c2be3428d20a660dc6a37cae13912e127888a5132e8bac2163 true +check_key 78cd665deb28cebc6208f307734c56fccdf5fa7e2933fadfcdd2b6246e9ae95c false +check_key e03b2414e260580f86ee294cd4c636a5b153e617f704e81dad248fbf715b2ee4 true +check_key 28c3503ce82d7cdc8e0d96c4553bcf0352bbcfc73925495dbe541e7e1df105fc false +check_key 06855c3c3e0d03fec354059bda319b39916bdc10b6581e3f41b335ee7b014fd5 false +check_key 556381485df0d7d5a268ab5ecfb2984b060acc63471183fcf538bf273b0c0cb5 true +check_key c7f76d82ac64b1e7fdc32761ff00d6f0f7ada4cf223aa5a11187e3a02e1d5319 true +check_key cfa85d8bdb6f633fcf031adee3a299ac42eeb6bd707744049f652f6322f5aa47 true +check_key 91e9b63ced2b08979fee713365464cc3417c4f238f9bdd3396efbb3c58e195ee true +check_key 7b56e76fe94bd30b3b2f2c4ba5fe4c504821753a8965eb1cbcf8896e2d6aba19 true +check_key 7338df494bc416cf5edcc02069e067f39cb269ce67bd9faba956021ce3b3de3a false +check_key f9a1f27b1618342a558379f4815fa5039a8fe9d98a09f45c1af857ba99231dc1 false +check_key b2a1f37718180d4448a7fcb5f788048b1a7132dde1cfd25f0b9b01776a21c687 true +check_key 0d3a0f9443a8b24510ad1e76a8117cca03bce416edfe35e3c2a2c2712454f8dc false +check_key d8d3d806a76f120c4027dc9c9d741ad32e06861b9cfbc4ce39289c04e251bb3c false +check_key 1e9e3ba7bc536cd113606842835d1f05b4b9e65875742f3a35bfb2d63164b5d5 true +check_key 5c52d0087997a2cdf1d01ed0560d94b4bfd328cb741cb9a8d46ff50374b35a57 true +check_key bb669d4d7ffc4b91a14defedcdbd96b330108b01adc63aa685e2165284c0033b false +check_key d2709ae751a0a6fd796c98456fa95a7b64b75a3434f1caa3496eeaf5c14109b4 true +check_key e0c238cba781684e655b10a7d4af04ab7ff2e7022182d7ed2279d6adf36b3e7a false +check_key 34ebb4bf871572cee5c6935716fab8c8ec28feef4f039763d8f039b84a50bf4c false +check_key 4730d4f38ec3f3b83e32e6335d2506df4ee39858848842c5a0184417fcc639e4 true +check_key d42cf7fdf5e17e0a8a7f88505a2b7a3d297113bd93d3c20fa87e11509ec905a2 true +check_key b757c95059cefabb0080d3a8ebca82e46efecfd29881be3121857f9d915e388c false +check_key bbe777aaf04d02b96c0632f4b1c6f35f1c7bcbc5f22af192f92c077709a2b50b false +check_key 73518522aabd28566f858c33fccb34b7a4de0e283f6f783f625604ee647afad9 true +check_key f230622c4a8f6e516590466bd10f86b64fbef61695f6a054d37604e0b024d5af false +check_key bc6b9a8379fd6c369f7c3bd9ddce58db6b78f27a41d798bb865c3920824d0943 false +check_key 45a4f87c25898cd6be105fa1602b85c4d862782adaac8b85c996c4a2bcd8af47 true +check_key eb4ad3561d21c4311affbd7cc2c7ff5fd509f72f88ba67dc097a75c31fdbd990 false +check_key 2f34f4630c09a23b7ecc19f02b4190a26df69e07e13de8069ae5ff80d23762fc true +check_key 2ea4e4fb5085eb5c8adee0d5ab7d35c67d74d343bd816cd13924536cffc2527c true +check_key 5d35467ee6705a0d35818aa9ae94e4603c3e5500bfc4cf4c4f77a7160a597aa6 true +check_key 8ff42bc76796e20c99b6e879369bd4b46a256db1366416291de9166e39d5a093 true +check_key 0262ba718850df6c621e8a24cd9e4831c047e38818a89e15c7a06a489a4558e1 false +check_key 58b29b2ba238b534b08fb46f05f430e61cb77dc251b0bb50afec1b6061fd9247 false +check_key 153170e3dc2b0e1b368fc0d0e31053e872f094cdace9a2846367f0d9245a109b false +check_key 40419d309d07522d493bb047ca9b5fb6c401aae226eefae6fd395f5bb9114200 true +check_key 713068818d256ef69c78cd6082492013fbd48de3c9e7e076415dd0a692994504 true +check_key a7218ee08e50781b0c87312d5e0031467e863c10081668e3792d96cbcee4e474 true +check_key 356ce516b00e674ef1729c75b0a68090e7265cef675bbf32bf809495b67e9342 false +check_key 52a5c053293675e3efd2c585047002ea6d77931cbf38f541b9070d319dc0d237 false +check_key 77c0080bf157e069b18c4c604cc9505c5ec6f0f9930e087592d70507ca1b5534 false +check_key e733bc41f880a4cfb1ca6f397916504130807289cacfca10b15f5b8d058ed1bf false +check_key c4f1d3c884908a574ecea8be10e02277de35ef84a1d10f105f2be996f285161f true +check_key aed677f7f69e146aa0863606ac580fc0bbdc22a88c4b4386abaa4bdfff66bcc9 false +check_key 6ad0edf59769599af8caa986f502afc67aecbebb8107aaf5e7d3ae51d5cf8dd8 false +check_key 64a0a70e99be1f775c222ee9cd6f1bee6f632cb9417899af398ff9aff70661c6 true +check_key c63afaa03bb5c4ed7bc77aac175dbfb73f904440b2e3056a65850ac1bd261332 false +check_key a4e89cd2471c26951513b1cfbdcf053a86575e095af52495276aa56ede8ce344 false +check_key 2ce935d97f7c3ddb973de685d20f58ee39938fe557216328045ec2b83f3132be true +check_key 3e3d38b1fca93c1559ac030d586616354c668aa76245a09e3fa6de55ac730973 true +check_key 8b81b9681f76a4254007fd07ed1ded25fc675973ccb23afd06074805194733a4 false +check_key 26d1c15dfc371489439e29bcef2afcf7ed01fac24960fdc2e7c20847a8067588 true +check_key 85c1199b5a4591fc4cc36d23660648c1b9cfbb0e9c47199fa3eea33299a3dcec false +check_key 60830ba5449c1f04ac54675dfc7cac7510106c4b7549852551f8fe65971123e2 false +check_key 3e43c28c024597b3b836e4bc16905047cbf6e841b80e0b8cd6a325049070c2a5 false +check_key 474792c16a0032343a6f28f4cb564747c3b1ea0b6a6b9a42f7c71d7cc3dd3b44 true +check_key c8ec5e67cb5786673085191881950a3ca20dde88f46851b01dd91c695cfbad16 true +check_key 861c4b24b24a87b8559e0bb665f84dcc506c147a909f335ae4573b92299f042f false +check_key 2c9e0fe3e4983d79f86c8c36928528f1bc90d94352ce427032cdef6906d84d0b true +check_key 9293742822c2dff63fdc1bf6645c864fd527cea2ddba6d4f3048d202fc340c9a true +check_key 3956422ad380ef19cb9fe360ef09cc7aaec7163eea4114392a7a0b2e2671914e true +check_key 5ae8e72cadda85e525922fec11bd53a261cf26ee230fe85a1187f831b1b2c258 false +check_key 973feca43a0baf450c30ace5dc19015e19400f0898316e28d9f3c631da31f99a true +check_key dd946c91a2077f45c5c16939e53859d9beabaf065e7b1b993d5e5cd385f8716e true +check_key b3928f2d67e47f6bd6da81f72e64908d8ff391af5689f0202c4c6fec7666ffe8 true +check_key 313382e82083697d7f9d256c3b3800b099b56c3ef33cacdccbd40a65622e25fc false +check_key 7d65380c12144802d39ed9306eed79fe165854273700437c0b4b50559800c058 true +check_key 4db5c20a49422fd27739c9ca80e2271a8a125dfcead22cb8f035d0e1b7b163be true +check_key dd76a9f565ef0e44d1531349ec4c5f7c3c387c2f5823e693b4952f4b0b70808c true +check_key 66430bf628eae23918c3ed17b42138db1f98c24819e55fc4a07452d0c85603eb true +check_key 9f0b677830c3f089c27daf724bb10be848537f8285de83ab0292d35afb617f77 false +check_key cbf98287391fb00b1e68ad64e9fb10198025864c099b8b9334d840457e673874 true +check_key a42552e9446e49a83aed9e3370506671216b2d1471392293b8fc2b81c81a73ee false +check_key fb3de55ac81a923d506a514602d65d004ec9d13e8b47e82d73af06da73006673 false +check_key e17abb78e58a4b72ff4ad7387b290f2811be880b394b8bcaae7748ac09930169 false +check_key 9ffbda7ace69753761cdb5eb01f75433efa5cdb6a4f1b664874182c6a95adcba true +check_key 507123c979179ea0a3f7f67fb485f71c8636ec4ec70aa47b92f3c707e7541a54 false +check_key f1d0b156571994ef578c61cb6545d34f834eb30e4357539a5633c862d4dffa91 false +check_key 3de62311ec14f9ee95828c190b2dc3f03059d6119e8dfccb7323efc640e07c75 false +check_key 5e50bb48bc9f6dd11d52c1f0d10d8ae5674d7a4af89cbbce178dafc8a562e5fe false +check_key 20b2c16497be101995391ceefb979814b0ea76f1ed5b6987985bcdcd17b36a81 false +check_key d63bff73b914ce791c840e99bfae0d47afdb99c2375e33c8f149d0df03d97873 false +check_key 3f24b3d94b5ddd244e4c4e67a6d9f533f0396ca30454aa0ca799f21328b81d47 true +check_key 6a44c016f09225a6d2e830290719d33eb29b53b553eea7737ed3a6e297b2e7d2 true +check_key ff0f34df0c76c207b8340be2009db72f730c69c2bbfeea2013105eaccf1d1f8e true +check_key 4baf559869fe4e915e219c3c8d9a2330fc91e542a5a2a7311d4d59fee996f807 true +check_key 1632207dfef26e97d13b0d0035ea9468fc5a8a89b0990fce77bb143c9d7f3b67 true +check_key fcb3dee3993d1a47630f29410903dd03706bd5e81c5802e6f1b9095cbdb404d3 true +check_key fb527092b9809e3d27d7588c7ef89915a769b99c1e03e7f72bbead9ed837daae false +check_key 902b118d27d40ab9cbd55edd375801ce302cdb59e09c8659a3ea1401918d8bba false +check_key 4d6fbf25ca51e263a700f1abf84f758dde3d11b632e908b3093d64fe2e70ea0a true +check_key f4c3211ec70affc1c9a94a6589460ee8360dad5f8c679152f16994038532e3fc true +check_key c2b3d73ac14956d7fdf12fa92235af1bb09e1566a6a6ffd0025682c750abdd69 false +check_key b7e68c12207d2e2104fb2ca224829b6fccc1c0e2154e8a931e3c837a945f4430 false +check_key 56ca0ca227708f1099bda1463db9559541c8c11ffad7b3d95c717471f25a01bf true +check_key 3eef3a46833e4d851671182a682e344e36bea7211a001f3b8af1093a9c83f1b2 true +check_key bd1f4a4f26cab7c1cbc0e17049b90854d6d28d2d55181e1b5f7a8045fcdfa06e true +check_key 8537b01c87e7c184d9555e8d93363dcd9b60a8acc94cd3e41eb7525fd3e1d35a false +check_key 68ace49179d549bad391d98ab2cc8afee65f98ce14955c3c1b16e850fabec231 true +check_key f9922f8a660e7c3e4f3735a817d18b72f59166a0be2d99795f953cf233a27e24 true +check_key 036b6be3da26e80508d5a5a6a5999a1fe0db1ac4e9ade8f1ea2eaf2ea9b1a70e true +check_key 5e595e886ce16b5ea31f53bcb619f16c8437276618c595739fece6339731feb0 false +check_key 4ee2cebae3476ed2eeb7efef9d20958538b3642f938403302682a04115c0f8ed false +check_key 519eedbd0da8676063ce7d5a605b3fc27afeecded857afa24b894ad248c87b5d false +check_key ce2b627c0accf4a3105796680c37792b30c6337d2d4fea11678282455ff82ff7 false +check_key aa26ed99071a8416215e8e7ded784aa7c2b303aab67e66f7539905d7e922eb4d false +check_key 435ae49c9ca26758aa103bdcca8d51393b1906fe27a61c5245361e554f335ec2 true +check_key 42568af395bd30024f6ccc95205c0e11a6ad1a7ee100f0ec46fcdf0af88e91fb false +check_key 0b4a78d1fde56181445f04ca4780f0725daa9c375b496fab6c037d6b2c2275db true +check_key 2f82d2a3c8ce801e1ad334f9e074a4fbf76ffac4080a7331dc1359c2b4f674a4 false +check_key 24297d8832d733ed052dd102d4c40e813f702006f325644ccf0cb2c31f77953f false +check_key 5231a53f6bea7c75b273bde4a9f673044ed87796f20e0909978f29d98fc8d4f0 true +check_key 94b5affcf78be5cf62765c32a0794bc06b4900e8a47ddba0e166ec20cec05935 true +check_key c14b4d846ea52ffbbb36aa62f059453af3cfae306280dada185d2d385ef8f317 true +check_key cceb34fddf01a6182deb79c6000a998742d4800d23d1d8472e3f43cd61f94508 true +check_key 1faffa33407fba1634d4136cf9447896776c16293b033c6794f06774b514744c true +check_key faaac98f644a2b77fb09ba0ebf5fcddf3ff55f6604c0e9e77f0278063e25113a true +check_key 09e8525b00bea395978279ca979247a76f38f86dce4465eb76c140a7f904c109 true +check_key 2d797fc725e7fb6d3b412694e7386040effe4823cdf01f6ec7edea4bc0e77e20 false +check_key bbb74dabee651a65f46bca472df6a8a749cc4ba5ca35078df5f6d27a772f922a false +check_key 77513ca00f3866607c3eff5c2c011beffa775c0022c5a4e7de1120a27e6687fd true +check_key 10064c14ace2a998fc2843eeeb62884fe3f7ab331ca70613d6a978f44d9868eb false +check_key 026ae84beb5e54c62629a7b63702e85044e38cadfc9a1fcabee6099ba185005c false +check_key aef91536292b7ba34a3e787fb019523c2fa7a0d56fca069cc82ccb6b02a45b14 false +check_key 147bb1a82c623c722540feaad82b7adf4b85c6ec0cbcef3ca52906f3e85617ac true +check_key fc9fb281a0847d58dc9340ef35ef02f7d20671142f12bdd1bfb324ab61d03911 false +check_key b739801b9455ac617ca4a7190e2806669f638d4b2f9288171afb55e1542c8d71 false +check_key 494cc1e2ee997eb1eb051f83c4c89968116714ddf74e460d4fa1c6e7c72e3eb3 true +check_key ed2fbdf2b727ed9284db90ec900a942224787a880bc41d95c4bc4cf136260fd7 true +check_key 02843d3e6fc6835ad03983670a592361a26948eb3e31648d572416a944d4909e true +check_key c14fea556a7e1b6b6c3d4e2e38a4e7e95d834220ff0140d3f7f561a34e460801 true +check_key 5f8f82a35452d0b0d09ffb40a1154641916c31e161ad1a6ab8cfddc2004efdf6 false +check_key 7b93d72429fab07b49956007eba335bb8c5629fbf9e7a601eaa030f196934a56 true +check_key 6a63ed96d2e46c2874beaf82344065d94b1e5c04406997f94caf4ccd97cfbab9 false +check_key c915f409e1e0f776d1f440aa6969cfec97559ef864b07d8c0d7c1163871b4603 true +check_key d06bc33630fc94303c2c369481308f805f5ce53c40141160aa4a1f072967617e false +check_key 1aafb14ca15043c2589bcd32c7c5f29479216a1980e127e9536729faf1c40266 true +check_key 58c115624a20f4b0c152ccd048c54a28a938556863ab8521b154d3165d3649cd false +check_key 9001ba086e8aa8a67e128f36d700cc641071556306db7ec9b8ac12a6256b27b7 false +check_key 898c468541634fb0def11f82c781341fce0def7b15695af4e642e397218c730c true +check_key 47ea6539e65b7b611b0e1ae9ee170adf7c31581ca9f78796d8ebbcc5cd74b712 false +check_key 0c60952a64eeac446652f5d3c136fd36966cf66310c15ee6ab2ecbf981461257 false +check_key 682264c4686dc7736b6e46bdc8ab231239bc5dac3f5cb9681a1e97a527945e8e true +check_key 276006845ca0ea4238b231434e20ad8b8b2a36876effbe1d1e3ffb1f14973397 true +check_key eecd3a49e55e32446f86c045dce123ef6fe2e5c57db1d850644b3c56ec689fce true +check_key a4dced63589118db3d5aebf6b5670e71250f07485ca4bb6dddf9cce3e4c227a1 false +check_key b8ade608ba43d55db7ab481da88b74a9be513fca651c03e04d30cc79f50e0276 false +check_key 0d91de88d007a03fe782f904808b036ff63dec6b73ce080c55231afd4ed261c3 true +check_key 87c59becb52dd16501edadbb0e06b0406d69541c4d46115351e79951a8dd9c28 true +check_key 9aee723be2265171fe10a86d1d3e9cf5a4e46178e859db83f86d1c6db104a247 false +check_key 509d34ae5bf56db011845b8cdf0cc7729ed602fce765e9564cb433b4d4421a43 false +check_key 06e766d9a6640558767c2aab29f73199130bfdc07fd858a73e6ae8e7b7ba23ba false +check_key 801c4fe5ab3e7cf13f7aa2ca3bc57cc8eba587d21f8bc4cd40b1e98db7aec8d9 false +check_key d85ad63aeb7d2faa22e5c9b87cd27f45b01e6d0fdc4c3ddf105584ac0a021465 false +check_key a7ca13051eb2baeb5befa5e236e482e0bb71803ad06a6eae3ae48742393329d2 true +check_key 5a9ba3ec20f116173d933bf5cf35c320ed3751432f3ab453e4a6c51c1d243257 false +check_key a4091add8a6710c03285a422d6e67863a48b818f61c62e989b1e9b2ace240a87 false +check_key bdee0c6442e6808f25bb18e21b19032cf93a55a5f5c6426fba2227a41c748684 true +check_key d4aeb6cdad9667ec3b65c7fbc5bfd1b82bba1939c6bb448a86e40aec42be5f25 false +check_key 73525b30a77f1212f7e339ec11f48c453e476f3669e6e70bebabc2fe9e37c160 true +check_key 45501f2dc4d0a3131f9e0fe37a51c14869ab610abd8bf0158111617924953629 false +check_key 07d0e4c592aa3676adf81cca31a95d50c8c269d995a78cde27b2a9a7a93083a6 false +check_key a1797d6178c18add443d22fdbf45ca5e49ead2f78b70bdf1500f570ee90adca5 true +check_key 0961e82e6e7855d7b7bf96777e14ae729f91c5bbd20f805bd7daac5ccbec4bab false +check_key 57f5ba0ad36e997a4fb585cd2fc81b9cc5418db702c4d1e366639bb432d37c73 true +check_key 82b005be61580856841e042ee8be74ae4ca66bb6733478e81ca1e56213de5c05 false +check_key d7733dcae1874c93e9a2bd46385f720801f913744d60479930dad7d56c767cdc false +check_key b8b8b698609ac3f1bd8f4965151b43b362e6c5e3d1c1feae312c1d43976d59ab true +check_key 4bba7815a9a1b86a5b80b17ac0b514e2faa7a24024f269b330e5b7032ae8c04e true +check_key 0f70da8f8266b58acda259935ef1a947c923f8698622c5503520ff31162e877b false +check_key 233eaa3db80f314c6c895d1328a658a9175158fa2483ed216670c288a04b27bc false +check_key a889f124fabfd7a1e2d176f485be0cbd8b3eeaafeee4f40e99e2a56befb665be true +check_key 2b7b8abc198b11cf7efa21bc63ec436f790fe1f9b8c044440f183ab291af61d6 true +check_key 2491804714f7938cf501fb2adf07597b4899b919cabbaab49518b8f8767fdc6a true +check_key 52744a54fcb00dc930a5d7c2bc866cbfc1e75dd38b38021fd792bb0ca9f43164 true +check_key e42cbf70b81ba318419104dffbb0cdc3b7e7d4698e422206b753a4e2e6fc69bb false +check_key 2faff73e4fed62965f3dbf2e6446b5fea0364666cc8c9450b6ed63bbb6f5f0e7 true +check_key 8b963928d75be661c3c18ddd4f4d1f37ebc095ce1edc13fe8b23784c8f416dfd false +check_key b1162f952808434e4d2562ffda98bd311613d655d8cf85dc86e0a6c59f7158bc true +check_key 5a69adcd9e4f5b0020467e968d85877cb3aa04fa86088d4499b57ca65a665836 true +check_key 61ab47da432c829d0bc9d4fdb59520b135428eec665ad509678188b81c7adf49 false +check_key 154bb547f22f65a87c0c3f56294f5791d04a3c14c8125d256aeed8ec54c4a06e true +check_key 0a78197861c30fd3547b5f2eabd96d3ac22ac0632f03b7afd9d5d2bfc2db352f true +check_key 8bdeadcca1f1f8a4a67b01ed2f10ef31aba7b034e8d1df3a69fe9aebf32454e0 false +check_key f4b17dfca559be7d5cea500ac01e834624fed9befae3af746b39073d5f63190d true +check_key 622c52821e16ddc63b58f3ec2b959fe8c6ea6b1a596d9a58fd81178963f41c01 true +check_key 07bedd5d55c937ef5e23a56c6e58f31adb91224d985285d7fef39ede3a9efb17 false +check_key 5179bf3b7458648e57dc20f003c6bbfd55e8cd7c0a6e90df6ef8e8183b46f99d true +check_key 683c80c3f304f10fdd53a84813b5c25b1627ebd14eb29b258b41cd14396ef41f true +check_key c266244ed597c438170875fe7874f81258a830105ca1108131e6b8fea95eb8ba true +check_key 0c1cdc693df29c2d1e66b2ce3747e34a30287d5eb6c302495634ec856593fe8e true +check_key 28950f508f6a0d4c20ab5e4d55b80565a6a539092e72b7eb0ed9fa5017ecef88 false +check_key 8328a2a5fcfc4433b1c283539a8943e6eb8cc16c59f29dedc3af2c77cfd56f25 true +check_key 5d0f82319676d4d3636ff5dc2a38ea5ec8aeaac4835fdcab983ab35d76b7967b false +check_key cafcc75e94a014115f25c23aaae86e67352f928f468d4312b92240ff0f3a4481 false +check_key 3e5fdd8072574218f389d018e959669e8ca4ef20b114ea7dce7bfb32339f9f42 true +check_key 591763e3390a78ccb529ceea3d3a97165878b179ad2edaa166fd3c78ec69d391 true +check_key 7a0a196935bf79dc2b1c3050e8f2bf0665f7773fc07511b828ec1c4b1451d317 false +check_key 9cf0c034162131fbaa94a608f58546d0acbcc2e67b62a0b2be2ce75fc8c25b9a false +check_key e3840846e3d32644d45654b96def09a5d6968caca9048c13fcaab7ae8851c316 false +check_key a4e330253739af588d70fbda23543f6df7d76d894a486d169e5fedf7ed32d2e2 false +check_key cfb41db7091223865f7ecbdda92b9a6fb08887827831451de5bcb3165395d95d true +check_key 3d10bd023cef8ae30229fdbfa7446a3c218423d00f330857ff6adde080749015 false +check_key 4403b53b8d4112bb1727bb8b5fd63d1f79f107705ffe17867704e70a61875328 false +check_key 121ef0813a9f76b7a9c045058557c5072de6a102f06a9b103ead6af079420c29 true +check_key 386204cf473caf3854351dda55844a41162eb9ce4740e1e31cfef037b41bc56e false +check_key eb5872300dc658161df469364283e4658f37f6a1349976f8973bd6b5d1d57a39 true +check_key b8f32188f0fc62eeb38a561ff7b7f3c94440e6d366a05ef7636958bc97834d02 false +check_key a817f129a8292df79eef8531736fdebb2e985304653e7ef286574d0703b40fb4 false +check_key 2c06595bc103447b9c20a71cd358c704cb43b0b34c23fb768e6730ac9494f39e true +check_key dd84bc4c366ced4f65c50c26beb8a9bc26c88b7d4a77effbb0f7af1b28e25734 false +check_key 76b4d33810eed637f90d49a530ac5415df97cafdac6f17eda1ba7eb9a14e5886 true +check_key 926ce5161c4c92d90ec4efc58e5f449a2c385766c42d2e60af16b7362097aef5 false +check_key 20c661f1e95e94a745eb9ec7a4fa719eff2f64052968e448d4734f90952aefee false +check_key 671b50abbd119c756010416e15fcdcc9a8e92eed0f67cbca240c3a9154db55c0 false +check_key df7aeee8458433e5c68253b8ef006a1c74ce3aef8951056f1fa918a8eb855213 false +check_key 70c81a38b92849cf547e3d5a6570d78e5228d4eaf9c8fdd15959edc9eb750daf false +check_key 55a512100b72d4ae0cfc16c75566fcaa3a7bb9116840db1559c71fd0e961cc36 false +check_key dbfbec4d0d2433a794ad40dc0aea965b6582875805c9a7351b47377403296acd true +check_key 0a7fe09eb9342214f98b38964f72ae3c787c19e5d7e256af9216f108f88b00a3 true +check_key a82e54681475f53ced9730ee9e3a607e341014d9403f5a42f3dbdbe8fc52e842 true +check_key 4d1f90059f7895a3f89abf16162e8d69b399c417f515ccb43b83144bbe8105f6 true +check_key 94e5c5b8486b1f2ff4e98ddf3b9295787eb252ba9b408ca4d7724595861da834 false +check_key d16e3e8dfa6d33d1d2db21c651006ccddbf4ce2e556594de5a22ae433e774ae6 false +check_key a1b203ec5e36098a3af08d6077068fec57eab3a754cbb5f8192983f37191c2df false +check_key 5378bb3ec8b4e49849bd7477356ed86f40757dd1ea3cee1e5183c7e7be4c3406 false +check_key 541a4162edeb57130295441dc1cb604072d7323b6c7dffa02ea5e4fed1d2ee9e true +check_key d8e86e189edcc4b5c262c26004691edd7bd909090997f886b00ed4b6af64d547 false +check_key 18a8731d1983d1df2ce2703b4c85e7357b6356634ac1412e6c2ac33ad35f8364 false +check_key b21212eac1eb11e811022514c5041233c4a07083a5b20acd7d632a938dc627de true +check_key 50efcfac1a55e9829d89334513d6d921abeb237594174015d154512054e4f9d1 true +check_key 9c44e8bcba31ddb4e67808422e42062540742ebd73439da0ba7837bf26649ec4 true +check_key b068a4f90d5bd78fd350daa129de35e5297b0ad6be9c85c7a6f129e3760a1482 false +check_key e9df93932f0096fcf2055564457c6dc685051673a4a6cd87779924be5c4abead true +check_key eddab2fc52dac8ed12914d1eb5b0da9978662c4d35b388d64ddf8f065606acaf true +check_key 54d3e6b3f2143d9083b4c98e4c22d98f99d274228050b2dc11695bf86631e89f true +check_key 6da1d5ef1827de8bbf886623561b058032e196d17f983cbc52199b31b2acc75b true +check_key e2a2df18e2235ebd743c9714e334f415d4ca4baf7ad1b335fb45021353d5117f true +check_key f34cb7d6e861c8bfe6e15ac19de68e74ccc9b345a7b751a10a5c7f85a99dfeb6 false +check_key f36e2f5967eb56244f9e4981a831f4d19c805e31983662641fe384e68176604a true +check_key c7e2dc9e8aa6f9c23d379e0f5e3057a69b931b886bbb74ded9f660c06d457463 true +check_key b97324364941e06f2ab4f5153a368f9b07c524a89e246720099042ad9e8c1c5b false +check_key eff75c70d425f5bba0eef426e116a4697e54feefac870660d9cf24c685078d75 false +check_key 161f3cd1a5873788755437e399136bcbf51ff5534700b3a8064f822995a15d24 false +check_key 63d6d3d2c21e88b06c9ff856809572024d86c85d85d6d62a52105c0672d92e66 false +check_key 1dc19b610b293de602f43dca6c204ce304702e6dc15d2a9337da55961bd26834 false +check_key 28a16d02405f509e1cfef5236c0c5f73c3bcadcd23c8eff377253941f82769db true +check_key 682d9cc3b65d149b8c2e54d6e20101e12b7cf96be90c9458e7a69699ec0c8ed7 false +check_key 0000000000000000000000000000000000000000000000000000000000000000 true +check_key 0000000000000000000000000000000000000000000000000000000000000080 true +check_key 0100000000000000000000000000000000000000000000000000000000000000 true +check_key 0100000000000000000000000000000000000000000000000000000000000080 false +check_key 0200000000000000000000000000000000000000000000000000000000000000 false +check_key 0200000000000000000000000000000000000000000000000000000000000080 false +check_key 0300000000000000000000000000000000000000000000000000000000000000 true +check_key 0300000000000000000000000000000000000000000000000000000000000080 true +check_key 0400000000000000000000000000000000000000000000000000000000000000 true +check_key 0400000000000000000000000000000000000000000000000000000000000080 true +check_key 0500000000000000000000000000000000000000000000000000000000000000 true +check_key 0500000000000000000000000000000000000000000000000000000000000080 true +check_key 0600000000000000000000000000000000000000000000000000000000000000 true +check_key 0600000000000000000000000000000000000000000000000000000000000080 true +check_key 0700000000000000000000000000000000000000000000000000000000000000 false +check_key 0700000000000000000000000000000000000000000000000000000000000080 false +check_key 0800000000000000000000000000000000000000000000000000000000000000 false +check_key 0800000000000000000000000000000000000000000000000000000000000080 false +check_key 0900000000000000000000000000000000000000000000000000000000000000 true +check_key 0900000000000000000000000000000000000000000000000000000000000080 true +check_key 0a00000000000000000000000000000000000000000000000000000000000000 true +check_key 0a00000000000000000000000000000000000000000000000000000000000080 true +check_key 0b00000000000000000000000000000000000000000000000000000000000000 false +check_key 0b00000000000000000000000000000000000000000000000000000000000080 false +check_key 0c00000000000000000000000000000000000000000000000000000000000000 false +check_key 0c00000000000000000000000000000000000000000000000000000000000080 false +check_key 0d00000000000000000000000000000000000000000000000000000000000000 false +check_key 0d00000000000000000000000000000000000000000000000000000000000080 false +check_key 0e00000000000000000000000000000000000000000000000000000000000000 true +check_key 0e00000000000000000000000000000000000000000000000000000000000080 true +check_key 0f00000000000000000000000000000000000000000000000000000000000000 true +check_key 0f00000000000000000000000000000000000000000000000000000000000080 true +check_key 1000000000000000000000000000000000000000000000000000000000000000 true +check_key 1000000000000000000000000000000000000000000000000000000000000080 true +check_key 1100000000000000000000000000000000000000000000000000000000000000 false +check_key 1100000000000000000000000000000000000000000000000000000000000080 false +check_key 1200000000000000000000000000000000000000000000000000000000000000 true +check_key 1200000000000000000000000000000000000000000000000000000000000080 true +check_key 1300000000000000000000000000000000000000000000000000000000000000 true +check_key 1300000000000000000000000000000000000000000000000000000000000080 true +check_key daffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f true +check_key daffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff true +check_key dbffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f true +check_key dbffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff true +check_key dcffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false +check_key dcffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_key ddffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f true +check_key ddffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff true +check_key deffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f true +check_key deffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff true +check_key dfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f true +check_key dfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff true +check_key e0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false +check_key e0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_key e1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false +check_key e1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_key e2ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false +check_key e2ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_key e3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f true +check_key e3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff true +check_key e4ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f true +check_key e4ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff true +check_key e5ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false +check_key e5ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_key e6ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false +check_key e6ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_key e7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f true +check_key e7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff true +check_key e8ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f true +check_key e8ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff true +check_key e9ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f true +check_key e9ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff true +check_key eaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f true +check_key eaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff true +check_key ebffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false +check_key ebffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_key ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f true +check_key ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_key edffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false +check_key edffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_key eeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false +check_key eeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_key efffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false +check_key efffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_key f0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false +check_key f0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_key f1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false +check_key f1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_key f2ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false +check_key f2ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_key f3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false +check_key f3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_key f4ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false +check_key f4ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_key f5ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false +check_key f5ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_key f6ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false +check_key f6ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_key f7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false +check_key f7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_key f8ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false +check_key f8ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_key f9ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false +check_key f9ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_key faffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false +check_key faffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_key fbffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false +check_key fbffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_key fcffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false +check_key fcffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_key fdffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false +check_key fdffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_key feffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false +check_key feffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +check_key ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f false +check_key ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff false +secret_key_to_public_key b2f420097cd63cdbdf834d090b1e604f08acf0af5a3827d0887863aaa4cc4406 true d764c19d6c14280315d81eb8f2fc777582941047918f52f8dcef8225e9c92c52 +secret_key_to_public_key f264699c939208870fecebc013b773b793dd18ea39dbe1cb712a19a692fdb000 true bcb483f075d37658b854d4b9968fafae976e5532ca99879479c85ef5da1deead +secret_key_to_public_key bd65eb76171bb9b9542a6e06b9503c09fd4a9290fe51828ed766e5aeb742dc02 true 1dec6cc63ff1984ee46a70a46687877a87fcc1e790562da73b33b1a8fd8cad37 +secret_key_to_public_key 37621ebd8de6ca022419fd083066285da76ada9bae6d2b7c1a3847d78a726b0b true 25255c26721758456545bcaea3a99407cd3df7c8208eeb49bd80450627138fab +secret_key_to_public_key a44f5cc6e6583394ec1970bc16e9e3b70c09ffb2ebdd515c8f5e6a8c02b5ce04 true 1be4c7b195156a06ebf6a81acff06c3cbfcc4f869a8f0994e0d98d45f586b02a +secret_key_to_public_key 46ca522f94c1ce7a3755a158234f87872792ca03cfbb0aebc6897bf376d4a009 true 577a7b3e1b89089936fa89729855e25ad646057309c21da272b38dd3db5da9bf +secret_key_to_public_key 93f6713bdcfb18984dccef06dd84690ffc054b6eb6f4c75ebdfe9bb0ec1f810e true f888cdc2cc39194e638587116ad14554a42b52ed13fbdc3410ad888408b6b7d1 +secret_key_to_public_key e49fa0345748fecd9b1f7a60b3cf2e6d61b47a15a033a390cb0586b7185a7f03 true 345c0c9279ac9686ed7b73648bc3e92e34d513e0d87d390d74250830976757d1 +secret_key_to_public_key 195917df120eac02087610a7fcae94d61538e9dbbe6773ea45cc7cf3808bbb03 true 043f8109c1c406aebfe8581b9d0bb41159a957a91b4d6b08ca18bd7a804bcdaa +secret_key_to_public_key 0f588b029cf8d9b6efccb2fcda1ce33c16c552c11e5286807a74f6f7c7eb1603 true cc690e16d540108096d73bfc458ed3695a60043fc048877920efc03860014314 +secret_key_to_public_key 2ab2964c462dfb7abdda7229c91c1b1d217d015b9b429b76e93b7af854ef2200 true 294352ec050ad768e14d2e13f6c588b8499171080106724edfda9b5e3d0b9e21 +secret_key_to_public_key 11f4389bb16bcfb02de71b385345eb7593121097cac0a14387090f1a7dbe100f true a6422d15a124f5e8c0bf9d8269d36df75de108003b5cc984be6863774c0b0021 +secret_key_to_public_key 27a92a4c8ad3de40e5e51c89c20dff6086fff954f574494154ff4f18faf82a0a true 0dad7138095b22905f7074c4750fcdcd7ab4fc210ccc41812af50c9b26888afc +secret_key_to_public_key 27926691b86d9bf9bfb575f1325e418b46de258495185a3bc681efb9ee671904 true 1869ced31a176913f66d77fcb776f1ae51d404004d0efcb18676ef6d9f18764e +secret_key_to_public_key d5f7e654389be8829aeb51c4ed8a02474d1f72d0ed62484e9eeb403f0a9ae007 true 6d145f7b2454f6d38677cb1650d980a933dea237cb820bd330edcf9111265379 +secret_key_to_public_key be82dba0af095ecbd0cda2a1eb29a99ee8db1f30280164bfbb9c2375a884a308 true 59f5445dfe7ac2a13f93088caedccaf78b69a3460b70547fa249f2fb7f3dc5e3 +secret_key_to_public_key 2edf31fc16999e3701df8dc2f7e0f2e1d759467fe932528ea96a865c8f277b0d true 95dfd870794ccd1bd002e8c49a705dc3785c9653300acf33f83d0d3364495838 +secret_key_to_public_key 9d1e136fcdbd254050868cc5c39f6f9d5002aeb88812e87965bdbbb96a8b4a0d true 652f4ecadd25a6ec39e3aa054e29594d1f1ccbeba68f7a9b077ee67abc96ab71 +secret_key_to_public_key b698b802cc11440e334b24fadfcadc41b326d4d778fac4ce480c54035b1a930b true fca3990fd75d63ce510fc4b504ec2cf7b8782cd628262cd9579d655f49e3cb85 +secret_key_to_public_key eeaf6cd6f9b98dd405fc6f1a3f4b51e25e7ec5196a481b769cc64272f6e5b605 true 90b3e7d42c45b93fd9220860bdae2fe32d066428997992a2fb33c3db95c80a9f +secret_key_to_public_key bc5de49a0e962b790c5621a992ef2c6d2f8b00e00a9d5234a28a1283e842680e true b68568c9d54eafaf22d7d1e0537995df496a104241eaf1c144818bca45bb322a +secret_key_to_public_key 0722633bcd8149d698f93ad5e59f9c82094b3f31a320858a77ac0a840c4b790c true 89f882ced622694a341139ec1e3c4a2b7ee221a1aa6bd715c18970a366850fbb +secret_key_to_public_key e0a183b0f6b8d740e6c2a1e1e45c7012a6d53492a8a2fb5afea9b5efcff8da0f true 207778ebb5195db0e11a9202d148ee82f8e7643f40ff3d7f7fdf1ab54d099e77 +secret_key_to_public_key 4fb4ac57a3dadb7aa7bfb355d47d854dca9f74ba95bad6516690b37a1bc82109 true 37b03b835a480c16679af03baed33ee5f790529229a8dbbb0040078c12c77f20 +secret_key_to_public_key 3c8815429e077ee07bdf149200f8835c72824cad357c0d09b3f8bdfa9a46100b true c6291ab7cb860f6152062c140d17e9ceee43cb4f4fe2352535b920f57abfac8c +secret_key_to_public_key cf3306dc1efd9d8e4b52a5ed5a7ab1b0e1aaaae9e8bdf59a551bbcbb1955170f true 18f1cca329baa78cc9b44ad7b61962b3e9fd3c761122d77459ad9dd85a75357b +secret_key_to_public_key 1da414fa06f1b64e09d6ac6c11b8e1f960c191b13a1f8f28e966c40ff69f5209 true c349163acbb4ad652e9b0df4d8229739c7f63045e966c87b4cc3c518dc90b77e +secret_key_to_public_key 2ba33b9a522747b1237f16c4a92c807dc77a122f61a4ffb005ea58d46380060c true 9e4dcf4289ea582140f1b7a0b5b4aaad46f43779bd260df2ce0e506a543e59f8 +secret_key_to_public_key 4fda0444e0945782e9794bfdf215ce23aab77ace5b99c5c742a10ebaa07a180c true 61557982344d8735510537e6a411d96509f5f758221c71c6e9d222b36df8d3df +secret_key_to_public_key cb4ca686b0fd850d6bafcab2c631e0bc79b524c9ac469acbeb43739b2288d80f true 386beadac2a2cbb40504b37f3f35d5615f388f144ebb57724c65dde4daab9b6b +secret_key_to_public_key 3b025cbf409bf9337cfcf14bcaf71d8f71378c77b0fd6162c556e21b8e65a20c true 6a471d4213ca2bcd20347ff4c6acba430a39ec7c3be30356b831b3cff89b298d +secret_key_to_public_key 037fe269ec594e39a2ac4e361573297e0589bbd7d7be1da7b04a16b1b7a16005 true f4ef4c492762b74044d51d0bb54f59da5ce3fa6143dca51e37526323f3220004 +secret_key_to_public_key 5866ae6c15bef968705e44f50d987b6998cd23cf245d7aaf02c4ce0c6e5a7a0f true dddf08a2133ed26332b3162ceac3c74eb1eb7100a800214a784dd894fa7cb414 +secret_key_to_public_key 6203a78793453c3d53270fa5a187abbbc3f3287eed33268d28b1073e09952f08 true c47f6aaba4df82653f322c29d5b277a13b9c8789a761d18e6e77602d4662a930 +secret_key_to_public_key a9995e9b642abba8c655375d924f9ac47aadd119938b95c385e0b246ddf6fd09 true e869bf8b797d38005919e301fc17a4f1fd7ac518f8d77704daf61e46c7e75727 +secret_key_to_public_key ca29c53899ffdf30ae0f1913ecabebe7b33da8eecc31a5e45d897b8a84c5d209 true 2e8ebb025544dd8995244a658525824c4294a8d7a4bc714ad54b343aaf3cd584 +secret_key_to_public_key 3c51fe647838a619bfe973ad2927d82acca4a9981227fdbee61ffbd33c69f508 true 097afa02192abab56844e0bb830799f24aedea0aff1881c1edc1e9395315ddfd +secret_key_to_public_key 3792f1dfef3381b371ca3643eb0f8ff880154de306e08819b2153e63ddd3320d true 50418ae0901017200ebb04200cf2b18252c809ef247f8e953036df958139581e +secret_key_to_public_key 6f2d3b10347dabc55bac370bf0593706fca766f6d51f80f566d3441bc473cf09 true 947cd634fa472a07ee20112b40786bb91c9b638908a30e0aea24e3d8b6698dd6 +secret_key_to_public_key dd599e55bd2640a00c5ad81c86e0b4ef2962ddee3753ea0d7ae110503b937506 true 341b670266ab0799f2257d66a69845347a3917f8f43cd7b8cef6f84aa325d3fc +secret_key_to_public_key 2f5f7bd26f152194d61c4b8fbabb8b9693c2e1f079fc37cfe3350c6a8fe83702 true 8f624bf82e905e70e0bf60658949c22cff752b7d403c763485266087170c65b6 +secret_key_to_public_key a107081764ca02802104890ada2d68c7cf934fb4e758ba0257fcfa4a02d5ea00 true d979eaa7d125f55ed311b5a234daa0d3108a21193d8c07fa62a9c2260e2a785b +secret_key_to_public_key 76e98dbb3e855888a48c53c82be5e0a4b151b763c74aa872592ac32930768607 true bdd2ab0d3d4aec5dd987362bfde6baae4f7b7dc0567c0369cce9777e7f12409c +secret_key_to_public_key adfa37572dd43a3242e39aad11a0942cde7505e0e74a46fc13fe527be675460e true 4f39448bbd7c0d277fb1c5c82a6f2cb94f36ba947c831f4e4d51a2574bf09f2c +secret_key_to_public_key 5b8a5621c883c1ce57c296b4299686c5ccae00d8cc0d5a6ae132552f4e818b08 true 23a208f572ae7960edd73a559957618e992d350b5374e0171acf7a9bad9d6ba2 +secret_key_to_public_key 7aaed2119c50605858b8bf02c54c574cb2c67e6c0a62662eed59ee0cdb22b204 true 651a28dd0d3738d392d831544827cf9de1db1169c59ef28daa7d6b19935df60d +secret_key_to_public_key cbaf383951a3ca8001f9a192ef7dfff6e7439d9942f96bc9548ba62a528c540e true 2be0a01cc919891938b8d1d7d3ee2c4e4cd6881e5b8f20af0115cc92c7444684 +secret_key_to_public_key 9fa062df5c10727f8a39337ade34ba910873ca52905985551bf63d688a808f03 true 719ac139ca68562833aa6387afb389925ef351d612c508beaff5653935d9f780 +secret_key_to_public_key 52ceb1925e652691459653d067cc9d72cbd6486f268fa75988e19b8a13935e0e true 9c7adba6cd3b2e497ce7b65429f30dc3f97d66993061d989873cb640706bf1f2 +secret_key_to_public_key 3dc8da07da465d99dd380b89e481692ceff68437db4d889ee67f1f6703b7fd05 true 799fa42738b17ebccab3f7bc04da56a39e10d71a90b7d0bcc8027b9796e6e541 +secret_key_to_public_key 6155fa2436181959c79410d89a57c2fab505bea7859e01410dd149c21bbd430c true 78eba7538aa56398455234e6b811c43ecac3c0f7917b5eaf933bfa9fc4b6e87b +secret_key_to_public_key 1eb6eb56fced029dd8e951f8fffc531bcf4ab4420d2e78aed1c1da15374d9b02 true 48535b20b348ea6b798b76ca47950e15d6887f31b15f5581c2978de1ca764d89 +secret_key_to_public_key 7a3b85ec6023f35bd388243df72bf1e6353ff4b71f2c1eeec08f82d1cf69b401 true 908b9edf169f360c386b972c308244c512c1da08f8eb1ddbea72f5b3b55481f7 +secret_key_to_public_key 6f9e9d729eb3c877e8dcdc23ae51360761cbfe5beaec33cc1e7997b766e9c10c true 618a89402eb6093f568964754c2d7eaa68e2ec4ab2105374594183a2bf9a2439 +secret_key_to_public_key c76858dfb3801442c23c317db6bef6f1e7eff0395b33e9a3efa5f44d1ae45401 true 80709d904b2b144344208252e86d43a2aaf8d9144bbcd3873dd0b33ab543985f +secret_key_to_public_key 39606b633f898435cf5fa8a2f5dd366fa05ed7929033e39cb6a2e2b1288fa601 true 40d8887d017025fd61d4d08171e8d9fed26acb1eae2af8034118dd7bd6700289 +secret_key_to_public_key fcfb7974d04d0bb5608fd1065e6a79998b08762b57ac3ca0902c677fb5ffb109 true b6d28ec9a9af1e0d045c47784e4fd90168a594bc3a750172a96c6361732f973b +secret_key_to_public_key cc3a1156e1dd31828d3b77f147e0042731390c4b0abcef014f1ee65f1703400d true 07f1b172c818bfa8c725f25b229d51a090efa030b1cc8aa3b4235461eba1b738 +secret_key_to_public_key b84a9fa170970e9b6ecb5cf4988da1c91567ce9b4b9e06999357a08c24d7a401 true f8167a5474447697a86c20dc7ec02d6c48421046849fbad54299b18588f1df67 +secret_key_to_public_key de4f4293b695fd3a38f642a8334b28099af7712fe82e183ec03926e6743efc04 true c974cbf17ed5865f0c64debe333674cf9e501beecf8b08357d9a8968b2de223e +secret_key_to_public_key 1e7f85ec701500c134ced910e81dbe4521eba6e5f07b857de967db0a601fd60c true 1bd0edf0e62946b095dff2cc58b69dda9ae3108b189b0951af886f39bfc92b5f +secret_key_to_public_key 7285497a62dd41d6e4afc45ad199efd5c9a5790a886d64e390d2dcac3104d200 true a4a6d0994c1202901e05e7c9ae3abf2e99f7a187179d48e277980a296d103922 +secret_key_to_public_key 3dc55d284470e6e49720ad259616e41709072969d22ed2a11ec4119284364c0e true dae85ccb69073f582002f297aaf3c7be15829775ba622883694ccdd057227370 +secret_key_to_public_key c71f78269e6800fd203c4804d1581bbb991bf224e4d68eefb0e53f9a1ad7620d true fdde14df7916d4894ce8fee923df4206fcf087ec0024cfe13926f3332d5b4275 +secret_key_to_public_key c1c24b673546baf3da43553a47569c485df0a02bf9dc6c5fe7b7052c17ff5308 true 79f540c37d570a251da7d0c55d17ef8a37d6b85f7bf323418160103b8358e081 +secret_key_to_public_key bf55ff2d8d3599eb65868993c61725309f9d960a886208b1189ed12c14a34c07 true e2ae3d37a6e465e0f1b69a9e59019baa4278f17d8f6cee20c8a2fcd5498d1d15 +secret_key_to_public_key 4cf3a55d559872a476fb39358b6cde2d08a285459206bd081f855aa3f4a2f800 true c24ecd652f06e08049589ec0b15ecef54d1b302d106731148661c12f3a5f36e1 +secret_key_to_public_key 007bb56720459b452430bdd16d759554d95ee07bb4676f4a1d6cdef681479102 true d0eb62a888e3bdaab88a6bf91b6fe3b30e9dba22ced5730a2b276784ed834854 +secret_key_to_public_key 0c61b1def62b2bd879b525b659681755886b049705167cae4921b6dfe4d70402 true 07004140069627768c39aed8f6b4cde0e4cc7ab4887adf9e9090d5d0df2b5590 +secret_key_to_public_key c9405ec79fb96bb701671fb779d340e0ad3ca78f0fd9f6643743871cc8459f0c true d2fce02f16ae2833fb02cc4f796c551105a4b57657f285afb8405906d60fbe65 +secret_key_to_public_key 4d1fd593f50b781435eb8249e1523705777975b13f090bf433c21c38f4782809 true 1e3e5fe501190b58aef26e1a477b36fe5f87d29b9e69f0f417d6096afcd4563f +secret_key_to_public_key 866653644b547e4dbc19b9d5342a3b41a8cb976c95b490936997175997851a0c true 91c2835db174595d2eccea74842927dc3bc4ba7cf66304ba03d48237e48576b2 +secret_key_to_public_key 2647b1fa16b0419df836ba277e8198b3e2f6e3818a9cf768e01059f79f2c890a true 6d056e613c4475635a69f5958b3d843bb7fc638910ebf4c16d483c70adaefe7c +secret_key_to_public_key cdfe621d83225d1b254626b2b1b224907eb4bc21cc2acbb2916177032395190e true 588a2716732cc37a4cb3c5f8c6777a2079cef604d069d4a57d3fca7bac9b708e +secret_key_to_public_key 4ed50ea62bc5a90e2575b031c32ea614a219ab6c2c2dfbd95fb326889a3e7c0d true 07b93aceec92bb45930a3060198cc90d9cb5451f00fd982f346b99fecfc5adda +secret_key_to_public_key 7344c22993eb9a771efca51398237da23c476beed0d837f7400d36ee17e81605 true 901d4ab8d8a1e70e30ec28f0f28b18dc4a9a50efed0e28154b2bbfb82c0f5ef3 +secret_key_to_public_key 9a4e4cb6d3fcabcb613f295711fd8c73c90bfff8695b93d625e64f53f170dd00 true de12bf71f6e9479334d16777a41f147916e5ced54a91837b2570824a374141e1 +secret_key_to_public_key 4b64cc5e6a07128957c97b6b4c01f5b0ee494717ee2a27615cf733ca34c62902 true 3f7cf22073e14ee6d7bf3d3c83ae0f910b879a9c5b6b2af72ad272f1f841d169 +secret_key_to_public_key 91874171bf65dd2b76f71c13692e627948d04d026e9c6668c58b20cdd362d506 true 342c6c9bb3ce60bece85acc039db8794a6cc042e74463296623539f2b5df9538 +secret_key_to_public_key edfc2870124469844030b664f24a339f4f3059e961149e32f6e29efbffb88609 true e808c1604024fb7fd1e350e6c3468fb5a4c83084642f2c7f4c6c3aa7b3487df4 +secret_key_to_public_key 452c370cf713b0d64277e281b8923945ee322f7853a686d3e1f4b1f098a7b702 true d22b29e587aea0daf21dc69a564e333d5594b9790a1a89360da4d735ac7aa21e +secret_key_to_public_key 9ecd4eb53982d6a151b2400aece937a836d06e53988ca4b1214820c1e3d7fc0c true f241a5900d1aba4d14e8300e4b3347d8f99599088bba48047848af497e25dd86 +secret_key_to_public_key 074249e89b49e8196f0ba924b6b8f4d071516de0a269214e2ffa50000dd3a107 true ecb996e01efcf5ab4cd86b7527c10276c1d38db35f2079df92ba18c036f034cd +secret_key_to_public_key 74582339fde12a64517182aa1aec3ece178d4184b772579a091827bc07e9d500 true 68d88ce8598b530d24446cb580eda1fced73be4b1f2964a014939bdf501f8e5b +secret_key_to_public_key 322d39d4d784c789539314d591860708b1baa910ff69e05766452aebd99d4f02 true c2ebec9d170d67ce63f34181a3128c225cb2f8ab17777e99080d3012107bcc53 +secret_key_to_public_key ca84895ae0031f26f309b1dfdf4717c7647f18574d373e449c6449b8adcedd02 true d4a3d334c0f365b829feca3c8954fc7083b9330df3dac626fa0e21f03304d3b8 +secret_key_to_public_key 0c1fd5ab6402b3c55fc798996e7e928d2ba7c222ec934c81242d29f334087605 true 8025bdbd8274b3457e8a08e35164a4ce1779551327132e9c467482d5718d79ed +secret_key_to_public_key c401793b1b3fc346f788715e476a0cba84fccbf11cfbcf4c6283768f5c439b06 true 9e8df72a610449badca15389557ceb8dc31a125c119327c4b2de3b418aa5733d +secret_key_to_public_key 799e75765ece01594ed9cad8b7d13a791d43977419ddb563e03e80a3bd144b0b true b4d3ad412acea06b25f555f7433563def04487345889e1ae43e1843a3319311d +secret_key_to_public_key c2cc58d2b132f76a9a676856efc24e73eb2a61adaf3a8953bc36cd8a44c5270f true 2137b18b4475e6ceb533b40acf742470099e14451b1cd0f2f0c4f51042e192a2 +secret_key_to_public_key 26c84712786174f6849fa7e1dd58ea9dc7963af51db49c027cd7d87065ea580d true 0ad9275d533f7df759c12ac66165214237761b36461254239dacef4dfc872932 +secret_key_to_public_key af93a657d68815bfc57b9458e1aadf3afee4376d25ec17a940aa716eac5a890a true 579816b4cb7073d9c7c6348bee01ee66e6d80a687e4da6f4a809f3e15eba36a7 +secret_key_to_public_key ab43f8f87a962acfd211636090043e54b80bc0a61bd67fa8effb751ad267a90d true 201cf0e2579afe28d6fcebaa063bfeec2a75e0aeb1f5ce9cdde5d7189c5e182e +secret_key_to_public_key b34d3169f95482c09f439073c1d7c5c154ac2b6dc5e08cffbd3bfc9c5148510a true 6eaa11b27400e1101aa68e1ddfa9636d3540efd66d64d1672303f3f772ecbe22 +secret_key_to_public_key 8faed5d59efcf5dff3d8dc4ba58984c30a493af537aca4ee4f36f62054300501 true 41fd82778a65647ad672ff19db6bb05299d2123a78726c5b1ea700224ae55d49 +secret_key_to_public_key 0a416457d19cc62198dd930097239cd0c8c0b5670e9b44f23a1abf3b041afd09 true c1880a46eaf132a8d78a9736c43416de27c55a9705ef17ac1a7473a8096546fb +secret_key_to_public_key fb67f700a84c7d0217edf69fa9de183b7df35d9bd32442783bf3b18a39a03800 true 21509ebb9f4eac0a745ba211388cc1c4226a60152378fb39f72c2dea00eca3b4 +secret_key_to_public_key dbd9b13e109ee0562537ff23104de367b0e08d03f58a5b8e05ee9caf14a97803 true 575d05712fdd23eea56837ad0b4654dbc2242376ae96d689df43cc7e1780e052 +secret_key_to_public_key ac07aeda31189c9b323496292d2aebaa278dac44339b0ad73fd034a1d5247a01 true 1dd2ff14057ffd72365145f15d77ad20d33fdbbaaa82bf7882ae3e052d8a3685 +secret_key_to_public_key 934132b0bc6f246390ea70574f0dddc27414120ae1c63895254221364d7c0a08 true 3683bbadb5fc2780a5ee715fe998508550f1e386f6c50a1091033cd0433c6272 +secret_key_to_public_key 4145e504949bda4b6164e16105a234f0f9720ae57d288fb31a50a6a7befa6904 true 05db7394fc7997d42f2478d2423289f079d10e5e621ee036356fc8b268c45129 +secret_key_to_public_key a1be9defcf54fd0d92b9bb7daea72de2cea8565492986eb7510d06d4ba548a02 true 7f9b33515fc25b92870b7f50631dc801d45dbe6c3f0c0e0b5faa20c1f2f9e825 +secret_key_to_public_key 3f82cfebca18c1c1bbd0ec94f8235b53cd5d9a0b789dca7040bb09e183f7ab0c true 21417f61f8c6f5464946fe1b21bd7a4cf72e9d92f61110cbc9d839343e9a730f +secret_key_to_public_key d2c9134ba2a9d1ae6d0f5f19c5aacc8bf677e6c51f75038c9e18513a94a5940b true 3d5c1b2fed400eecfe785fff0efe537854080723f585104dcccbe8dfc41cabb3 +secret_key_to_public_key 8d76f2d2c43de1fcae4f03438e52ebc3b1d7c41c9aeede0753014698fa45ce05 true 2400d5121a1a2f5c60edc4f2964638383bf6c8e801c553f1f99c25d376fb74cf +secret_key_to_public_key b06e1f79e031d3ee2485d846b4bf5f595acc4f6033e825c788728b9060fad508 true ad66861f450045ae3b5f490305b187878b4369ee746d4051295b0b5a1f68b8fa +secret_key_to_public_key 0689bc164f335582fbd0973502279ed4680445ffa8fe37de7d236f40cbd6d402 true b12dcc33d314b81e819541cb916e7f4c4362de6c6e85600402f7bbbcca3ff982 +secret_key_to_public_key a3ae97881eff3eec0cb6c4409c8b469f5f1fb493350c276d2d77176909c27001 true 0a6b065acacbbc2d24601b446680cb87f69614d010bc4bf53b58978039f705dc +secret_key_to_public_key 06e47f6afafff149d56378fce2bbe5d70b0786a60745a58c474c5b7e4a1cc908 true 5354e7243f8207874d30f3102e44f71c7f95e9869296249e2c79542b5bc77a8a +secret_key_to_public_key 9299db32b2261d0a43fe0a0b7d5ecceeef6a89943f393247337494b1150b5505 true 12b038897482126d970ae036f93438beb0212cc3c5bdced9fe3ea39d3108c2c3 +secret_key_to_public_key 1b6aeb724f6c1fffcc06d98c9e5cbf654c19993d32e2f8ef6894065a083dda0d true d28a1822ce6fbb4b8a38a25ee8a74947c82042cf945246578114d82b7ad32727 +secret_key_to_public_key 8e25431a9e7a087506d8675b970e7a8acc515a83336c84cb24f08dae82debb0c true ce37affad39740bb003b53526428500af727b5a11895c2486a533a77d6930bc7 +secret_key_to_public_key 0f936925bb69d52fe130363b0bd114423fc006e1651c6b73676582d2a4918001 true 88371c103bf5f34ded1b13a26ab9d51f493e414355a6c9489864e07780422bb5 +secret_key_to_public_key 93c9f7e4e56530b4b2e18b3ee07de4ad59d898dbd5cea8f59bd7e56d3c19c702 true 5210b829e470ca5db5b2a84db829e4055fb2e4a2a0013bd74d35bb946204e18c +secret_key_to_public_key 97686d65822840994ab17b2afe4ccc6a3a1fc7a79cfefc9404cb89291917780a true df9809f8cba1f9d4ddf3772f8cb92f62ddcbee097e12e175cf918fc41d56a517 +secret_key_to_public_key 6e223c932f04e6b65b48b67f596f1afd49a2f4b256be1ab2553170beb7330f08 true 7b5c03f81ee4f2214342248712b15b8f907afcb9898a60974f657cddabffd2ee +secret_key_to_public_key 83f10ca80dffeae5132de3378cf42a96f386d0e82b468257271cd88d02a17e00 true c6fdcd51d4f7729cfae36220f1156d7fe2f63d43fbb9d79ed09a841d8c53527f +secret_key_to_public_key 542abb7659b96b3570fd72edd48f4d178108f8c7686a32643a9386d35b32e208 true 6862e87a27099c942b0a337a423d2af04921447e3bc5413f97cce632dd35f83f +secret_key_to_public_key 84b588341eec7f7d0e1eda2e85f2dc3cff5cad35b3b9571e3d3e0aa4bc285707 true 59a7f5502e95a7666a05f5536e5876f684ae6e0744ce141d397d7b36be6eea9e +secret_key_to_public_key fd09ddfe4e3415d1eb149a9dfbece16c014608c502ca9b84a3d7c78b163ab108 true 0a34cc2ab2169b681d580bfe943a38b28b07e742564d3cc4bd60eca3759432d5 +secret_key_to_public_key a5d3ebf9b164e45fd7df294d77ab02993396bb77d42a9d08eba5f4b628816104 true 2f9a9f7dcc1c7e3827af521e14095f943a5a2aa620a6a87bfc385700cadc2dcb +secret_key_to_public_key d1f17f7f27d4b9e0529b2b2638d51174e1f3ec13ae8f28e23129927b80e13600 true d5dff18b82442a0a2e5db2f65e382d65986046c9adb07dbdb379d6a9e98bbf93 +secret_key_to_public_key ed82976db02dfc4ec022c0bfe74c9618dc197029f05f5508f08aaa5611459f08 true 8e55c67050ffe8e09a0c166a57c5b1bc56c050c9ff1a8cc09b5db4dc6ece2175 +secret_key_to_public_key 52f7b06ea8a3ba05ce3516696264e1baa29e1ac13feb6f9155a2b1b98890c608 true ff0a4f0bc77de777b6dc883bd96daac4820c41b63bca19b7e950a09151e9621f +secret_key_to_public_key 32af052682df55d5f951d60b38ed3afabf122b4fcc783a347f704917834d3200 true 803e452fcc4c87299c48d11105e0911a7d114075077c6ce112c4d6d9306e4e39 +secret_key_to_public_key 1a3288ba23a58800a4219d31f2a3c6e8677060f7c8b6ca4992efbc7b82c10f09 true 1697ff2b9282ac9e1b303b9358d7c40723ca54487ba3c77dd804d70386745645 +secret_key_to_public_key dfe5402b1d4ab2c391d99b23dbd3e85ccd1ec5de3e04a32b8273f744a06a680d true 8c7565a9b71be9c96643977c35ac55ac3c0f0861d4d4018f46acd57436ec8b06 +secret_key_to_public_key 72bc0660d979fb1ef673e244390b34042b44397b945230164aa988e76ff2d502 true 7818b3c57fad3d031d9e918dd185fbb887fbd3265fe1cb66c52e80d2091266a9 +secret_key_to_public_key 84cfd9d51da2161917e5cd49a18077cbdc575efdb3ff023c480bb90f5f575002 true ae61d692b70ad5bc550117a58534375742f30b07a2d489e342b7f6050977d25d +secret_key_to_public_key ded9cc0ad7b950a5e0d5e35ca46e14106333bbabc4df6c7bbbeae6aa0f44df05 true 6f42d27a2af904130b1dbf001e45d9e30a69579c12d95938b6b198cd62084f64 +secret_key_to_public_key fd949e7b210093e7a26dadae748764f09a70ce8fe86ea69536f4228dc27d8900 true abc86696ad7cb6b823470b7c064295904942a2b0886a5e8d2637a17f8799893e +secret_key_to_public_key 9aa6628e55b3824e4e303044a75961e68f34a4e5635b9085dabfd9914973da0d true 7539869c55c324b2a23f5334b572e7f6ef0cf49b5abc9904d5137a8e2f7f437a +secret_key_to_public_key de2dbdc32bcfa95f006ffea37895d87046afb97f5d4a6da622de4629a986640e true 480e84c739c85116eb0822b0db7b89e3d73d054acfe7adac52627b4dfb83abed +secret_key_to_public_key 8aa63182df8647871a62b68d0b833e84eefde2c7a41a05271980e7cf6971c000 true c04b56cc422ff852e4e1f49cdd08d525545e21060f7327fba070463fb1799239 +secret_key_to_public_key b3daf94027cb411ec2323460017cac334678d0614de6ae9a30bd46534844e90d true baa6c7f686ad80da23b25f8427b0d52515bdf313aefd5323321fff9195b2ab64 +secret_key_to_public_key 8e69634fa898f370205f6dc194ad53e456bca7b06b6b5d7f5f3752b820e3680a true 49a2a2ecc714a74a05bd6b9ae35b045a9382034fb1d8c864b65a413d15072e1e +secret_key_to_public_key 87f377cb08ca1bb3c5903277d4ee9e0995d22e409605e89c61ec54b43aa37307 true 44eef5466d1f714bcbea974649b361b0e2886526300a3e3612236fa6d351229a +secret_key_to_public_key 46316cc94c997224e9a5328f86a7509143835ce9fb33aafd8a7ba71e41efff07 true 3c973729349902dbd1223cead94aa436b2458c3186af81465c6c63e04f11ff57 +secret_key_to_public_key b23de1c9c24c4a60121c1d24982a48756fb269ab30b6f2e458013e45f03b2708 true 50937bbb5919c3f6bceb314b3c589c5c5ddc55eb3b5961739bf31538df235eaf +secret_key_to_public_key 86f9c8cc4836df5ccd832bb4c353a94a58ecff09b8b95808d094f548cd5ffa02 true 21585782190c98acb4cfe796e27d9c056fcedd7ac12e014be1bc3a0945b046f3 +secret_key_to_public_key 863256f588f9a7f6b2c3d3051591f243fe57884192fbab125eadd7e5a7c6eb0d true 506c9beb01e0e72676742bd43e24b2902dfe6b60e4da928e3e30e67e85aa9d95 +secret_key_to_public_key 764efb3280499be08b9590ac9374f10f495dafbc3ce7ac0febdf6185581b4a08 true 19b71b55fa3103ff114449c901ec0d2834a7fae9b228d326e0f40ed2a738175f +secret_key_to_public_key fcc034d6b41e63aee6ed9abb1e00fb9ae706e79e78fc5dd0773e3dd377960d04 true b59ecd89fdbca3b8c0b4ef548f43c22ed9772ba392bc97ccc624a211f23fe9fd +secret_key_to_public_key f27aaf3599aa4f9753b87033db7040887eca98c1026cd662582a962cd3965408 true 697a80c7c5d792cd4305aa828df9b688bd168846d56eff307f869f6b9424cf01 +secret_key_to_public_key 7a28f456b430529353516192ec5661d5e656f14fb979de33957e370d74264907 true b086fa4f3a8fdd8bde2241057f38722ce9a888fa28026de0a1c4c0eb1296820d +secret_key_to_public_key feedf620db2fca8140738ea8ba4f2b254ad56fcdc33010e081197c2ebfbbea0d true f62ca4d9c70b9a25f858b23f8cfe6b3791b260d688b440059b185a389e0ef2c0 +secret_key_to_public_key 460556eb86a0481c9e83e5286b94b61f2c9e621754357865ca136f1d27b3c608 true 518fb65b73c18bb689fa14fbdd41237bd7af8b957b56d23021f2a27dc40e003a +secret_key_to_public_key a86f284a7a34708edfcdbb22861e88b5015d9da1373f8fd9114606cc2ab54b02 true bbc83cadae2e7cb3d65bb9e362bd48170089767ea6411fca5eaf060b0b6d21b6 +secret_key_to_public_key 2f05f12905d45c77ea1e08cc328ce34b39f8e0b9ce4ab13f9de54a9fdd9f330b true 146a455c22dcf09ccbe1ae3bc37d6e5d3d55c70dcedc208f758c517f56753f7c +secret_key_to_public_key dbc15f443928fcdda03a9c07e2e2fb0029f98813c9fd3fe2cf195f1acca1bb02 true 7cf78642d0a1312062e77f024af90f53e5abab7df62ca13eba34252036800533 +secret_key_to_public_key 64dc5cb7b9e39deb8c824ad54d24482561505ccb325893fbe60ad22b1ba7b10a true f9f30b050d9d9f4390880bc78a79322636f6ed44f9c30d87f5e3513b3817abb1 +secret_key_to_public_key 64453c209a89e4d80a77840af962fc73790a989829c83a5484cfaee02420db0c true 0b11a02b1df5c58a698dc23f04d53977c123429f566295634869c6d6096ccdd2 +secret_key_to_public_key 68fb303206e9eec077c990395b299f1b0dade8fa3e9ff6d1eb937ef86ba50603 true ac57f952e44e5b7d9781dca682d55c43fe8de572d82938314492e0cda7a341b6 +secret_key_to_public_key 9b514daeff43501e3f553be877f0e76b250834946244ef49606eb47f6c03870a true a8977a7620b870d45508b81ff6c453dbac4993270e8822e3764dd3f692d86f5c +secret_key_to_public_key fdd20f614fce7fde039a50b536786b3f447dc1707781bcfab622f2424534410f true 9c8e81023f8b900e73f6c5472ef759986204d6d3e40813daec8cc0c399475ebe +secret_key_to_public_key b4d337555b17786e09c8ad41c6ca124f433c4796365d80a2486c6e01120dc904 true 8383f426735b0a5d7fcac1ef9cfbd9041b4a2a3b0ad731b9bd14ce5b6bab0808 +secret_key_to_public_key acf02623bcf88a4e895ced284070f3c555e1a1afa5b5713b4f881afa59d9a409 true ff6ad4c2ccda7f77e385495b79be40febe97c771bdc7756b60a1c82e50da37f4 +secret_key_to_public_key 7d2101ec6bcc73fd1c65f022b5c4050c52e8646b1a4f86da016d3502699d6a0d true b1a7ca93391ba2ffccf5f16b36ae809e3e56be932c67a51149d82518040c9c78 +secret_key_to_public_key 7df91ac46d126ce525509f44c02eb3304d0d77ddd66bb0b78202800c0772210b true dd2ce2b2766d404fb465237acab636a8578439216eb2b9d56006e359de4f4e4e +secret_key_to_public_key 48f8c6a8242725da175ae66b591cc0037a213a889fae3ba66aaf2da338a6880d true 8f14328b9e2b3f905c681623b16c69b92240f766e27a807316ace7d21908fc3b +secret_key_to_public_key 4da375c72f88ba9701d9b2349335ed9453bb4dbf77acd7c160ab3ff8c849f102 true d8618969867baf8bd64a417dcd261d4be418cac21de13440392acbdbca175761 +secret_key_to_public_key cffed15bf0a40b69a8cd704ed9b41b3773495d3f00ce3ba68d093c93dbccce05 true 28f3b4924683c465edb931a64f9ccf8536a366259fc60f664dc661aa88f5e054 +secret_key_to_public_key d0ea4a975c53d46e4caa9198b732e74fa8ee102ea8be16e01b813bd014e18b0b true 16ee559a5e12807d1a0c46f8e513fc1d4731b16e18b2c1022b7d8974cbc4c658 +secret_key_to_public_key 0f7ddd62a3f96e8a5e52c638dc39534c9ca78358612007f1d9c40ecfb8005809 true 109b1d7ee0dc6f7f61cb0b508f5e73dcfa3926edd08b10216618cf126588cfb9 +secret_key_to_public_key 4dd63b0f4d82b5283bb03b33733e37dcb55e7a7321288e7e8844124e025a4e0e true 8867f6b499b43a44464d6c95b66c9624be1ceeff444471263fd4389d5eab9fc4 +secret_key_to_public_key f104a327ebf5deacc3e2a023f07e6429def4480cd6285339cce820dfd9a2fc0a true 621649fce9d9f427ae3345b9f360424d03ed14f4c9c28680407f448bb6ff23c2 +secret_key_to_public_key 367849894c7bae08f0090138ce810b075866ed8f96920f71ba1ff5acd3af8f00 true 89170ebddd1350b4c6aeea6c9455f8ef9b6970e2864c441b10ede3ac689d00df +secret_key_to_public_key 2ea9c282369d9c28c2918729b4aca978a7131c2a0b4259c73773d03f5f4c7d06 true 28869e2a3572573db9fa13bcda98930a7dab55646fa6dfe84778eead4931987c +secret_key_to_public_key 169788a97ed304d38a30dbe631e85a6f21f5e90254cbdc7db5bc63ab12af880c true 36368a6440bd326e33ef3d914326f1bc7a5509a8b1693cb5265359211c04dc05 +secret_key_to_public_key 08a33f4a192410b102e64b78899ba3fe9a0c9ad981eee265d62ab4d5377ad70e true 75a9bee4ae3d7a17ed4127a660dca6d31ca489761c262aab87c47e27e067be69 +secret_key_to_public_key 43229be5c6983a4076d6e6ef912bda15fada630d279694f8b4b9d592d5190f00 true c10a92aa21fc4984a58f43cb35da410979148e75758f13c5264896f5d12d8c0a +secret_key_to_public_key bb8158e9760e4cf8f3630ade604886249696c085d229fedce8915d761e2e5401 true a2cf8ed75496fa2a50d314d938c232da3ab6fc5cc3c2bcb04230159cd980fcba +secret_key_to_public_key ab3c39a398f3cdfa2e2a13547e92fd387dff6030126e57dc8496d3a25913b707 true bf671dd6ec91e544e5b46f672f7545a99baec1bc9d150b55e47a4f1977b30e69 +secret_key_to_public_key 49df500ebb5d858ac14e23a422053051b19ffe0371d66bb2e5c4b9c0c7d42d02 true c099ebac12186a871e6f599246d827d0499ca4868e008e67870e2c3b56d01a18 +secret_key_to_public_key d1c8ca3bc41a8b432984f49627aa257e8df559aaaabd474b4e767a613253a501 true 81c6b6472b4e298e2af39618a05a1ddecd2d3938073e06529001e0f74946d8f7 +secret_key_to_public_key 04b773ced4fa98f6253952600273b96766f884bc82a5f991dea49e70fe26c202 true 5bbaef0b74f66333571743a0288b116eff6df2257f0f5bb3d408814fbed4bd4f +secret_key_to_public_key d7ebaf0d36d26f62f3ad78139256c9aa27329924e015b83aaa41b35bba225f02 true 34fa1431f9f7229a8a46c78488b79df6202fc4d593f534fc126bb8c35252933d +secret_key_to_public_key 4fa729a6a3f12632ad25237f191eafb2b1a15bea2de83b279742573ac291bb09 true fca4701fa464b8fafdceb506a2d72e6a43cd232f80ec20cbd026b76165de5108 +secret_key_to_public_key 2bc83ce05bb1a6915b9508cb84e9a047bdfb43db50c3982a9639843b55a0a90c true 19036b6e41d21dc7cae8630fdef99dee991b241a26b6c33c9efd39400a4c662d +secret_key_to_public_key f1c2cc93f82ba3e4ad6a821817f63f73955238aaa696037941a608f09e7f2709 true f4a8ea405909086e9b425a14212e72900c347706a03f8ee152698166ce78fa52 +secret_key_to_public_key 8032405927484e41b84d5c2acdf3de0e93f99e2a209f4ef9f606255f833ac00e true e2cd10918f8923445a5a8bc61546e25218b4d35d5fa4499e4679215651a7aab0 +secret_key_to_public_key 59baadef268daa3fc41de9f8662bb76e195560bd0f229562ec68c282663f2e02 true 9da2a60837df5f96089f2d403e94154c5c2065f33ec535f7cfbec6c8af33e9bf +secret_key_to_public_key 5811b4ab425c6972dc427e1143f2dd50c6a668e759a7e19661ed5eb45bc01200 true 637816039f0fa94ac170b11b749fabb499adc141c60ea37f0d593094a0f4b6e0 +secret_key_to_public_key 3c7221eac98f72bb95e71a241b24da2d6ea02fa8833b1b74e5d93473b596a50d true 807f8c72b5ff00928d291527ae8d71b50c1565cfb7693cafebf2c44187d47616 +secret_key_to_public_key b88bdb32960e84aa94bb24fbb4bbaa8cec27d7eba290033c764403fad1f95e0f true 35a0793815d844877a1c2d9b53f7a6c55bc1ef06e2662d3886aa33fd400d41fb +secret_key_to_public_key a11563679c8d42068d37e47cc8ba2f6e67e3fe756e545789ecd0c98cc2c2d005 true 7e7e282122841948d59b2ccf8666b19763626d6789e7149a154ee45d1760f1d1 +secret_key_to_public_key 4c57caf9822a1bf0b05d3b18c7152de377192a49fd44e64c7949bde3930f0102 true d20173fc52cf972ed6d02a1655c42de439d660a846b7f3715b0e94651704bb63 +secret_key_to_public_key f2cf7b842310564ee8732429ee12df5fa70ef2710e9441f1e99c8bd7c0e1da04 true 38a2e0a3259f8630af1609137ec959e919d1eb3b1309008816b39eec8a95e0fb +secret_key_to_public_key 95145a3c0aba5d3b988699fa63c3cc29f77c3e1860e3c0e96610786562870b0f true a9b9a92e1310e32b0b286a541bea184a7e3f797b2c4341ff7c6e9a66e939f05d +secret_key_to_public_key faa3f9d2d90c48e07a1fde58525c14a3ea162961edcf5be85527ce33226adb01 true 273ddcd1637c6e9296e7c175005e0563ad3f32d254919783c66d39813607850e +secret_key_to_public_key f71932c2fa6ef76aef734513ad456e5f04f0eff8f82d492aae9fa41b3512bd0c true 611ecdc9520f6dd1ab66d4e6f831efaeaf416728e86ecb797e21414f4c215b8b +secret_key_to_public_key 0fc2a65c5a4e80625cb6334371999521706c57b243125d3dfdd1d406b1b4d30c true 9b313eb804aa4dcb7e154db4176236497664eb50ebe9a1e8c303d04573d675ab +secret_key_to_public_key eb3d8fcace4e04c4f6973dfa35a6752e043715b806fc6838736a70c978891f08 true 25e594911f6aa22bb354f3cfa8614bd662a2077563e4ecd032d50b33bf057c6b +secret_key_to_public_key c56ae64be3fef4afa4331d599e1459cb6cf68bace9b89e9072c0ae8626c8c20f true 6415b35fc253681760f0ddd0f927b58146d3b62bf305cfb7e139772d311c7149 +secret_key_to_public_key e3721df64e31a0d3c67d9fb0b7ffd1317dc1866091eaf146a87390200bd77007 true 42043b9054a2b4b15502b6a9f1a2bbde1811887419b0384cd20b950ac77c299f +secret_key_to_public_key a2d0aa0c2cb57b6c025cc7584a16b2c347837b8c2fc1f551177356fe6d2a7302 true 830bb4ecbad92540fa597a9da8950b5a36e2ef5499e95a064035540a7fbb1973 +secret_key_to_public_key 14072e468db5900b3f45cc4acc786175fd313bc5a55c53f7e705abf53b07cd07 true a17f8174931e2bb380501bf4b006a769016f2125c24083e47ba9e5dd1f1be329 +secret_key_to_public_key 65fc9b6476e73d9c11d9000faa4931207b4f1cbda367d61ac8b89b1b20887b02 true e64abf86cc51d47bc5a8d55f5e81605c1385f4ac7361400783a06c2c22b31d1a +secret_key_to_public_key a12c4bdd6a058bdb3dcac92253490da0325c3eda8b04208514eae31caafb1c0d true 64efb20fdb3cd0a99216d63c6d121341545694d0d309a2bdee3a5002fed3bd1d +secret_key_to_public_key 76ed1982d459a999bcd45b919deb0ef0d920e31b0cbdd2b316b0ab26e4758107 true a20af7692cf3fd380b4977de64f813db51c50611db5c48a2c37356ef09c4ab58 +secret_key_to_public_key 594714394d8fe803e4848f63e156aa757666864a9f218a408fbc0cf217ea790b true 32e37cea3b303c74610b1d07257720fbf3a722335e98e253a30600d786fe5e62 +secret_key_to_public_key e974126baa62def5082bde5bb4f2a120f0722afc4605440b5c30554a2381bd04 true f00ef041fdf7a035991108d0f6819ff286e7a5e9e59ed0a57466baa906670ab6 +secret_key_to_public_key edd5ff83fe8270e9fc692a3aab1fa30366ee0e6f5cd649f69c02df98f44b3d0c true 087e63040f5f5629f8b27d9eaab6f9d37f5a187f68aaa619143929cfeeb2d083 +secret_key_to_public_key 9f96635eef23ae4e34bfdb33387d1b41d10f4444e3513dfb708a48fa4c8d190e true cee75acc0273b315b128f192bc570e0076b39e666118f0c62d970ba79a00dd45 +secret_key_to_public_key 2dd9ad1eb307d4567b1ed8ae402a60005c2d4e3b71771a4b49984b4ab914440f true a239416d2dfcfd053f126010eb196eeaa2f060d081142c6ceef0255b34f7241e +secret_key_to_public_key f76e7b32b109a23b05af6d8f9aba5a331e700548c17931fb02723bec5884ba07 true 3924d55639bbca61c9a027bd762cfc8028cf0c5b1628f238060537167a0a7590 +secret_key_to_public_key ba51db948cd8af724ee5710866cb4712fac2ef0db533d4e592ad86422b202f09 true 93e8cbdd2834516ea95e8ed1ad7f3ff622b605534d75f99717ae20668cc0ddd9 +secret_key_to_public_key f4f1e356647c06dc51004482a4f05a21db5f4eb08cef1d06064f1cfa8ba79a0e true ff2029772b590740b01ba853796539d80765e09b30226a0380d15eece20baad1 +secret_key_to_public_key 85e62db63d4bc27d52556cdf391f17ffd254f3b4641eb7ff0339cc3d2661ef0c true 6c1258fdd74789017207365c322c25edfb53e12f3df92679abc10ca7cedc6651 +secret_key_to_public_key 7993d18816779566d48cf374b10c32e90592c9cc7decf94174a4b185e81ed800 true c3f81b994ee1c3e3ee2d70c0a005957a628a58b3104f328d308d36bf1262a271 +secret_key_to_public_key 247aab6aa964ea812edebf1e05039e6ecb02aab9620acad3ad77405d82bda000 true d3b47c7307712293cce75dacebb4597576960e46b9684a56e4e483023065366e +secret_key_to_public_key c5f7e9395fa9608a5c99fdea1b951af8cccbd5e84ee4c72a283fb32211d6960a true e14710b088694fa319a7962a3c32195bfe49276a10ec1666e89bc6d3d75d886f +secret_key_to_public_key b4a34d49493f10a566c25a65cabafe2fadaee6453675b61ac485acab25aaac06 true 9312572e8a1816899aabf7a5fbe5bd6f665f8b5eb6cf5cac9fbe02ca125a2d96 +secret_key_to_public_key 1fea45c71b2c74b441ea70a47f184c08b4b3c991e41cf8f88b2e7d0f5e1f6b05 true 98a3b35c2e1a6a0a872dca1d4e7f4ba815a59ab4c6281ce297798fb2ef72faa7 +secret_key_to_public_key 467f124425799b4d6978e10f60dfe3f10b96c40f9f0b35d90f4e045b9c191806 true 72b7cc8617465e8b163e6e85425e6ca52f9f442ac964144bbda8e39adb010809 +secret_key_to_public_key 7402c11c5617937a8abce31824c84577dcb6f9fba1d7a343f4e904db60210d07 true f282686a561407a86e5df062e897b09a914d55d9bd0420cefd5bf9fba20f1021 +secret_key_to_public_key dba8242bc8c181f6c3cc6a90ea0b20e68b462e290628231fb5d219f27366b30f true 71d5a1fa646bbb766758fb23375a1ba07ff5a9fda4b8623f8be629126356b0cd +secret_key_to_public_key ca2c391c3de76c1bfb8d8984f4670b05a7f28f919ef7cb4d3b4ea5665e0e7c05 true c06f8cb67225ca4cbe806c16bc35466a4f207f811e4da6f4dbc8f514abc7ad56 +secret_key_to_public_key d0be9f1db718643dd01f2176f7afa20778485ca20133366204b86a4e9bd79407 true 0b00f4191d17acc18d2007e874579508d5ea9c099ca1246d407b412b1718b94d +secret_key_to_public_key 87c99fda44c64c8e3d7144c7fc6dd9c9e0d6917acb34675bbd90871b90756907 true c6ae21a9e82f9d321d928a75c204e769324fd8f7f26e916d277c9ce71541905b +secret_key_to_public_key 40481a6122f12472aa137cf00679a0fc50e98a6761fca93e866d5a86a0021e00 true 45605f7080db727aed1f3923153a704e854ee7dace4606a3bbbca5849fec0ce5 +secret_key_to_public_key 396d2d1998357f7ce3588716ccbdb92d54d58e539a7241f33be5661da298d100 true e028828300b8f21ca9d8e18bb1276762e2d15d906d5cc09364707ade620e3531 +secret_key_to_public_key fe7ad04bc9b2a7e507254010be75fbf4455858013a27e52db3d568c5a7961f03 true d0e60508a6ca5b885217519f41aa6a607ba8650ba3fd7c7fb147ae3b24a30d3c +secret_key_to_public_key 2c39e099bbaee2b663ae7a3a0cb5040d3028d9fa88489d040d0dd4d0f8de300e true 5417aa4b25836c2f14c7d09047e3010f53c53323915da4499f388cc82a35d2f7 +secret_key_to_public_key ef4eb69cf6cdf46c0cea03b0ac7f065bddcd4964e40e5624a23e80b24c02830f true 3a06e6d7f13d2a71ed1426c92479a1b9e238b2facfb6bed34862a11833c223f7 +secret_key_to_public_key 757544e38b6d86c536825ab3b22fa6bf885b3b28de2488dbdc52b6aa40ef6b00 true cab011bf65ad481f94298047a76a6fd159833bef96a67ccf8d49e434b58bbafd +secret_key_to_public_key 9c370dae8950b451e8d1222697f4a4ab356d6c8719d4802ad236c2f90f86df03 true 01d78550aff0fb705adb1e67f6623544c2561c6dd7e8f735a2364b11d719bc21 +secret_key_to_public_key 8fcac3714a6077a14c266d816abaaf395f2a7dbc1e3c0c58575e031e4c880b01 true 55bb2063d3f802c4e0a53a87c3f47ccc16785323a7fd4922b880238d60b74213 +secret_key_to_public_key 423a61d383376d3d33d33cdf4a6a1ba3d46ee4c6bd5b601f0e5afc196c7b010c true ec0f01bac65cd6b8a0ab917780cff7e50d368d952ecc1bf82ac18558bf05f213 +secret_key_to_public_key cb6cc49e912bf0c80775187c51d9f180dbb6a05005063ecc4edc9638d828930b true 22c4e93a9da133176dd24225016b2d2ac0e24f95ac0f12cf782fdf18222f999b +secret_key_to_public_key 3b96410003269285dae39c8e1643458cdd23cc42d8ab9c622aba4a0f99f65c0d true 2b22dbce12d59f003e77117ef1b82579d77cb27c381215a842f6aa8f0496396f +secret_key_to_public_key 8b7d4f79a8534bfb7ffee17f4fc38a6870a7067491ccbd45706d608d71a2a70d true 3b044186a160e34e276f9eb02643a6d9c58adf19eff9df25f4c61fc4e5302eea +secret_key_to_public_key 53e6b1925f5c96b4a3efdabec9fb8fa4834175e867ddc7dc2fb35c8447ff4f0f true 90e7171387313e233ecd2f118cf9317a9c105e7e74517d9ae0e795065749869f +secret_key_to_public_key 115ce8fb2403b9d8c35696946442d0bae6066424f0d920ffa5bc8bd1af768403 true e4a01035cdd87f3fd3ad5d29c0bcaeced90a5166edbd8586e6a475fa514aed6e +secret_key_to_public_key a7bd256fc760e21c875b39d2d38ba899f1e94ec19ca58e5b15ef1ac2f550a400 true d357ca42f2fac97f7b69bc948ee97371fdffc392bb923f457dc643dc2c62da82 +secret_key_to_public_key 914bed590b7f2af07cbf17af9ba5c014b3c3145c1ca87c84474b039677f7050c true c52c5710e74850dc1c2da85d7b6ae7d4f31cd06e9ad94ddead8582d26616cbb7 +secret_key_to_public_key 8caa63151687804df1eff8621afa18eace7766ea872c8cf303df937999d9cf07 true 411da62f1b6874aae66e2a27d719b1ee6b1a3fd960c8ac8ade8b47308c04a637 +secret_key_to_public_key 1f4038d0e33b2db60ea95d33dbca3dab4bf3659ce9726b8e1bc084385d6aff0e true 572010f08d80e1e6f41867592d821aa527fc0dd7bb570492274b974e88386956 +secret_key_to_public_key 2bffebf44de4964d893409733d2f4aca3fe8d980527dd37d92177d96d178c80f true 7d5ef50044d010f6e69197737a121a7a10fee23e9f00916a0133311e0c4eb963 +secret_key_to_public_key f6983878c7912d212960788c38a4e61416a5cb688ba4a19980be85ef4f80c60b true ce1594e0be1f8be49358d90f0e56db4567920f58afa2a60650c2caf003df194f +secret_key_to_public_key 8ace96097bc9f146edd86b8304afefdd6d716ae46da8fb604b0ad52dc59f3206 true 1b25c0849ba23097d3d5bf2fbd9be4113d6b788e52b96f65754f93c0e2e8dfea +secret_key_to_public_key 8ba5cee5dcd26f5f6d7f189412b651eb3bda1310c333b2dff1e02f75c8bd5903 true a31a6474c7e178693865d4a84b77a91a288c717f69157de5028a2f52365f51ce +secret_key_to_public_key 3d291339170a30a401c6d1c659d4e8ef8a0eeee7f613d3dbbed7b9392932e60e true 08613b8de0dab0a12005df47e432560429e2d5f65138033f345f2784f164149e +secret_key_to_public_key 8a00b5c24fba049f64309ebc257229ad3194888c122848c9b01861178113d001 true 615ea0fe8a98e5c0a778cb501f659b793b6760812b9e62cb87cc311897a346b6 +secret_key_to_public_key c0c08f54f4d9a0298dff1c5d867722ea7167e1b912b5b6226d8993d821d70a0e true d303b8f1fc10cb92ff44def06ed3619cd09c9c8ce756daa2362a98e5efd1ae5c +secret_key_to_public_key 9d3628dad2e215f8faa1865fcf08bb0ab178ca8591d75922005628100d1dd60c true 628093bd32d0a647f96543bec62385bcb2cb1ad4c6eaf5a447d2120b447d389f +secret_key_to_public_key 51aae24b3458ea5b2e2b71916bc9de8037986aa60565861a490d9fc6d66d6008 true ab902b6322933baa1a0d5efa57a1c0a03e796adaa36e85d7a78ac77542250079 +secret_key_to_public_key b7f405198cae391174aa17a6daa52b3312e33834374cb4c06f0c67e74fe3200e true b8e59b472f4212eaffba43cec6fba463c472d5c1432d07c53434d08c906f0f52 +secret_key_to_public_key 928a641e2eaa8f80cd6552c1c59f9f6a945ce6061fe8275e7f85c3a16bd7e009 true 0507c11572491dd6d030c26789af4c3e89a9528bd881a2cdba613d9329a242e2 +secret_key_to_public_key 23e0f5fce20fbc38554a2669ed645f4af80a0f23b73a7a8ca440d36c03ce320f true 4be660105bf4266b8b8069881c5dbfbf9a465f6fc23f5b692eab9cf2b898e9b1 +secret_key_to_public_key c24919ac8ed9575f5a2743e38cfc83ed8c40d7c3a643fb4f59bf3408475efe06 true 0db887341f3e332b7e110d0f8dfe7049733bafe9c997b7e7692a96a3f4078265 +secret_key_to_public_key dcb063c8cf3645cb17ed6153f61522055b515e196529227fea832dfb253ca806 true 90040b979a0f6a4c8acf3cb7567690060972710aa977dec6820b109bc52bd162 +secret_key_to_public_key 1150164713c2ed27789b80aa5cbda56c2f802a765fdfc5491717de8b3ea9ec08 true 6d15123df88f7c993b9d4629a0c3756caa0a2406c8af9e8598240e9b637e7f8b +secret_key_to_public_key de305195cc244a900827591284f169ada413a48dd7ac3c1f50a4ab8abc498a01 true 81d7ea7e634161861bd86c6d3fc0fad71e36e39d4427b3b890cb48a378736eda +secret_key_to_public_key 48c37c166332e070b6103f1a4a375d7c3a2d1c147a5072102484a749d511760f true 0a31acc1709a8399834467e1f8a59e8760e6a6bf746248aba57f2da9bf475afe +secret_key_to_public_key e525a2c1cade3d2c650bcdef786b5816be80bcb5d2c05573e2250719334be500 true 3867cd0395dfb75c1187b565dcbc5147d08b5d7ceafbc67db5d5785ed7a1d9e8 +secret_key_to_public_key 678b66376f600b267b13b3b2350258ef820b092e00601031ea5ac8240e480742 false +secret_key_to_public_key e6423bbe509a3db6745fdd0ced5fb8455310cfb55fb1c092f543233e1ece5041 false +secret_key_to_public_key 6c3964fefd6e7190c99374183f198b3f5a47de39d07208fe6d219f446b3ec9ab false +secret_key_to_public_key fd03c0965f272dc8caf3280119e7bc273007558e0872c9b180b9c43138d5736c false +secret_key_to_public_key dfc62f4d217228ac29e347607aeace863a0b213a2adbf2463c9bfce3a31e9f31 false +secret_key_to_public_key b563c773ef4bfac54137112c7ba59ea231432ca3293fc6933db916492556b856 false +secret_key_to_public_key 72235e34a108d26648839e2c0ca08e67338982cdb8e68ed5833fda867ee7671c false +secret_key_to_public_key 6843e479782757e584b961fe89c2b90bffb2fecccdcb267b6f000f2affa87395 false +secret_key_to_public_key 4d81512bc17983aa3c0983178b282c107acd0c901b4552878fc57c601b1793f5 false +secret_key_to_public_key 36afa6e6c38c13566e2da99d487717d7a59bc4730528466a7aa9b43613e0f398 false +secret_key_to_public_key 8096c46a247723a7659bb4624dada245a45df6901f3036343550daa715ff6ee9 false +secret_key_to_public_key b2b4f1f0444e70205cf7fdb606313081a6872f62c508cd5fe8172d70505637f3 false +secret_key_to_public_key 840f838d72a64b150f0a4a13ce2646953fad40b3d7e5486fc1f1ed8d131d5e3a false +secret_key_to_public_key e56d31f28223e1f6bf30f290335a6e0de854db7acf4318d531cf1f8a1f1b57da false +secret_key_to_public_key 13762aeeab7dd4abd403b38b5d4976232f45ae408306fa1ac0a1cf8057f8941c false +secret_key_to_public_key 90a42665bcdb35853933a4e90dd5318b47414d24691fcefab08c22ce2f8be5f3 false +generate_key_derivation fdfd97d2ea9f1c25df773ff2c973d885653a3ee643157eb0ae2b6dd98f0b6984 eb2bd1cf0c5e074f9dbf38ebbc99c316f54e21803048c687a3bb359f7a713b02 true 4e0bd2c41325a1b89a9f7413d4d05e0a5a4936f241dccc3c7d0c539ffe00ef67 +generate_key_derivation 1ebf8c3c296bb91708b09d9a8e0639ccfd72556976419c7dc7e6dfd7599218b9 e49f363fd5c8fc1f8645983647ca33d7ec9db2d255d94cd538a3cc83153c5f04 true 72903ec8f9919dfcec6efb5535490527b573b3d77f9890386d373c02bf368934 +generate_key_derivation 3e3047a633b1f84250ae11b5c8e8825a3df4729f6cbe4713b887db62f268187d 6df324e24178d91c640b75ab1c6905f8e6bb275bc2c2a5d9b9ecf446765a5a05 true 9dcac9c9e87dd96a4115d84d587218d8bf165a0527153b1c306e562fe39a46ab +generate_key_derivation ba7b73dfa3185875538871e425a4ec8d5f16cac09db14cefd5510568a66eff3e c9b52fd93365c57220178996d97cc979c752d56a8199568dd2c882486f7f1d0a true f5bb6522dea0c40229928766fb7019ac4be3022469c8d825ae965b8af3d3c517 +generate_key_derivation 45f6f692d8dc545deff096b048e94ee25acd7bf67fb49f7d83107f9969b9bc67 4451358855fb52b2199db97b33b6d7d47ac2b4067ecdf5ed20bb32162543270a true bcdc1f0c4b6cc6bc1847728630c3060dd1982d51bb06873f53a4a13998510cc1 +generate_key_derivation 71329cf72de45f5b98fdd233707501f87aa4130db40b3570527801d5d24e2be5 b8bc1ee2987bb7451e90c6e7885ce5f6d2f4ae12e5e724ab8432769af66a2307 true 7498d5bf0b69e08653f6d420a17f866dd2bd490ab43074f46065cb501fe7e2d8 +generate_key_derivation 748c56d5104fb888c4143dd3ae13e578100cd87f4af1be562ee8401d2eec81ad 659f545d8661711e337ce3c4e47770c9f55c25b0c087a3a794403febd3f1600d true 796b938b108654542a27155a760853101aa896eba019c659e0bf357db225603f +generate_key_derivation 1a2c6c3f4c305b93e6c09604f108d46c988e16bb78a58bbc95da5e148e9ca856 668b766d1a3b09fc41a7f27ca50a1ffce1f6456b9d3613527f0cb86e1eed6705 true 6e9e6dba0861417979f668755c66e09cba4b06d07eca5bcadf6e8dd2f704eef4 +generate_key_derivation 6ac060a711ce299a7ee47a74f7b3ab9d53ed8bb19fe3bf5f786745babf22e3c1 00b5bbef9ad292f0289126a0ece082c9c535324c5ee0fd1534f7801777337f05 true f59b6f915e270452eccdf7172f1cf0fe702beca9067673ea3ef7a4920066a1cc +generate_key_derivation aa1a5a28ec965d1f4838c2781628cafa9867dda2153990c7fc4d19dbf1cae3b2 76c1838f52d761c3738500f240b14e48ada3c1e92081d5f60e53d642fffc610b true e4ced0d7c6d10f0dd4f55a4d7b69ad17b692179b0038013dc8ac287fd4360cf2 +generate_key_derivation 1ad93701cb458404ebe32645876bc3c3ca4c318bd5634d9cf2a1412fc8df92af 69ecdac81dd2c712c4383c7a602d0ce40b66f7afa5371b7b1430e6672679a00a true 9ba0f9c3ebd17af8a9c5ff29fc5fdf01555d77a61e0056d7f283a8b28ae84218 +generate_key_derivation e2dcbaddd4f369b223d056e0e254614e274079b0d28636aa7c7660fd6a1c3b17 435e792c42e18d17624cd2a6740ba41c983c5ea506146b65762990e4aa089201 true 230641ed77b79c239f9e9858d8076b30173822fc7469ada85f85d5516aedd3fa +generate_key_derivation d9a8ca485970b266e0a805acf4a193b07f61f638b6673aec409b2b1f1040856a 6f2ec363ddf334f3b25df564e142945f0c7c10f64dded0ab95251aeebd41c200 true 4ac220b3572ccd752b0b84100f8ae74a2caba2c89b39bb5d12c2033d91a57b8e +generate_key_derivation a4ff4c9aa679a6ddc2a4abf73bb550e675dbfe0e5f7e07767e896fd1a6dbaba2 39cc6daeeda5ab5d753781fa47e61c6de8722c6e0dffa30e7c0ad6e2cb9d400b true 6d45efb1033b1893d8161f93d63532856b3977521c3406482e81d0adf80ad9d4 +generate_key_derivation 8c92d3d3aebfc3098ba8244ee1c2b52904c0696b9a96f45c8cc2535ece49105e 82f9079fb392bafc9a022457cf87fdf83dddfd2a929a0c0b6d48eaf5495d9f0e true c87ab7381e44274bc81bcb3ea2fa6242c4b553a0d0752d6992eed9c578df82d7 +generate_key_derivation 7da04fbf634b4352247db2afd076a201224e4ec79d077277545832f1d054b6a2 790f9bec58808434608ddb6355145f62bd451132d0cca4586b637357a5fc5b0e true a741fcc9a0deb759a8594fc4749efb9ef66157d022295548424595910be1c662 +generate_key_derivation da66f4462b31ce7f0588fe0678316203d3429b09a2817ebd92125110762d6ab4 a4c6785203727ce3ac41562eba5eb3edaacfcc62b44f59dbb6aabaf986bf380c true 0366fcd0f09720cbe7a91c98f13937b04073cdf853c1e01b567a38ac4f8a62c3 +generate_key_derivation 6b26435ecd94a9faff6732b8082ab62e5dfabe6008146abc78045ca969e23a7e db6afa285c75c3b75c73f85fc090d257a25acf323cdda26cbfa14b47278a0000 true f4969ec2d7465ce64c4ca0a039d0602633a11dedd6718005e818bdcbe99d29fa +generate_key_derivation f8f8bf0be25d43bbf3aab042d2048ef3250c06d752727da7aecee9e8238b540d 16e17065360900ac865b1475684c9fc9c5f0a380098699ba0f8755c76f6b2802 true 880fc7553b4d5995524b711377be68e949858efdf1704b96baf4e6f1eea528c9 +generate_key_derivation 22234161eb1f9c69a1c47d8a87cb8cf27577b07960133121a0640ce994b1a95a 21baa9900c4aaccbd066b3e504b95d82e2434ae52ecf0bf47b34900cf0d0b70d true 3e04e07ab2fcd92996d016dbc2db353947b5430237f154f24833d6cd2a3108a9 +generate_key_derivation 8490227963bc68d06ecf4f345fa727ee9e0ed5b18efefb5b7c0af492e5511f66 c586ac13a7ae233f9b559961945410b534976652d85e1c47ff9ca0e4e88c010b true 6befc177a0d2540923f15236394520c375d9b5b85998d52fbdb6b37e4280417f +generate_key_derivation 26f345dd6b27504b9e01db305e4af30d6a299b546560eb4985c9e1d157e1bf8d 0be5e93d84aeba52944d1ff616f4135c4147a023dc5d0264668920e2f1733c01 true bb9eecfffc7665c1fbd2bb0941771e35cfda958a62f09c86cbc2821dde7ae314 +generate_key_derivation 6cfb5442101ecc2888d0cf31cddd1ab276171c2890d7158e322f40fe6bea7e5e 5fa40bacaa8c4ccf47e1ff59bda08564a363c885aac353174244f264b021030d true de7fb8907d45f0d8627fb2974f5b0cf68c8eed0bc6b56e78987a6a5ba351f442 +generate_key_derivation aa7fade573ce7e909337e45ea3110b268e33ee9d4ccf6b078a502ef0c4cfbf9f 649b96cef8cb8c1197bc92565ff1354a48a0425a5d81e317789179eda7831905 true b45700a9b9efe6e0c4669673cfa236396b1a852b166068676c8744819a302007 +generate_key_derivation a8c2a4c51d4993a3858dcbf112c7b1431480c249642084ee17f181a39ee29749 f619ecb9cf799baaf5ebdbcbda091a13b332cdc946d1c15f9b5763dc9a42b108 true 90c0a18274c18b09256a6bcf8a43e1ed841dbf0565847579198cb51693b56bfe +generate_key_derivation a811abd83ca23f0ff1d2e6ad8e2d5d2fa11ac9315e00f6aeefad506a99ec4cdf 20b171414d7f8b17589bdbc55e67cab373685a9643bd55ac55eac89b4bc5860d true 24c13041741f2470a5338fcd64ee6fd3e8318787b1e4932122bcfb010c11ddd4 +generate_key_derivation f89274b244362601fea90f6d0d8a0a465958b26f1cbe139679f2dec02ad92f9d 54e490c9640a1ad4877fecaa9c26f6e47bf0f04e11d730e52a9bab6de456ed0c true ff9ceb299022d6b6f7c4e56fba266eb4b2aba89c335e0d4814fec24c611c2827 +generate_key_derivation 750dae80cb964153b99b52bb7793e6af81845bd045d991c30eb09c009f655063 60fa169db75edc068d77618ebbb74d6be47dce502766a841c2dd04c3794f9c00 true 022c01d36265a8a497f82a92d4fdbb5555f0d32c71c448d00589189166900b9b +generate_key_derivation a43452a819753a0632517e3f629c4211f09e388c9e046feff14cf79717c99aa8 fa934ce9f0b0c9cc1fecd2843eb08cf194e9825a387fb5190189ea2421054d02 true a2c15491fb96a7f1ac1e2c61a472b272b0ec9b45a9cc4d78a95f6f062fb311ec +generate_key_derivation cddac822a3a36005853dde55a89843740e7658b574a30541d15d0facebc4a537 4e401c7280d6b32b40bc2443afea1f3c0a02769d0d8ea15fd39704abc2337b0e true f2187790bb4c968bb41a334d32cdf8c103ca66126d6f47c159d21b0212a6e228 +generate_key_derivation a3321615c7bc12213866572da080043cc4a554496268065bed5827e3f85bf3d2 f95febd72a282b281f43bcea73463ae7e8068e6387d69da0b5263e62c8c15605 true 512e82ce3019d7cc2d99aeb1babf3ae43b3fbd52ce6c4b352108de52bb98960a +generate_key_derivation 8ada4509a9808934591eceb62dbbba175c8d8e2924e2b3ae94e8457a19ae538f 65eca3d55238354c2f62fa8daaf278a378f5d112d104cdbcb136a488e4be150c true a037cb60b79175eeb635dca11ddedd95dc91521048b7744ca3bde7bf6d78ca09 +generate_key_derivation 0616c33663ce9e314f3268e4a8ff35affff7d9b8e7ee1f76bcc862cfed4350fb e1c5eac3a56530a1685898711e6d9bfde0be7e3ad44f176920d4203925142201 true a2d1d1e041f558dbf696b88f36f136a2c7e7972a7c7daa2e750e74f873e93fb3 +generate_key_derivation 9b1ab844b7d32527fe8aef9dd20d97eba02cc549a62dcfe80876c410ed340083 98b024f76fc96e00adcbbed881926b794ba2cc4946b18401f2d2ec3fa45a0803 true 3825158996b527fa8e14a45a50d21cabf30485c0bf06d506a5da905e4f80705a +generate_key_derivation 2f405f131baf5a08c417284c408005e9839220f9c326f18e9b64b32103fbb8e4 47d8ec6d27670448534793f5cb78ace8e690c314e84837140c8cf1686835ba08 true 472afd2048722329d16c100e3bf9925b1c790429dc491082a9e4460480353aea +generate_key_derivation a45e1641b1a76171be0fa452a78e1b9e618a0e6b7d1bcde8b6c531ea63454719 92af3cdfddafef66bfb51db1665de81f92484f88bf5a458089eca54ea274430b true 772e9a4c6a29d93ed924c0cd7deadaeea6d2a754bcb7d6e086ce7a74a7f2c8b7 +generate_key_derivation 0c8db095fd707405e56ebbb885f46941bc5c84bad673332e8c37e98ae29364ad 026b7430194c093d69e72c15420567e9f6027c66a82f3f113740c327d202f706 true c9dafc49f44482ac55965b54bb0eacaf16b5c038cf2896479d2b8d2fee823fc7 +generate_key_derivation f7887c057d00c316f897a498bc892ce53538cbe547496737b4324bd79d34865a 0a5fab23d43bd800f35cd90ec71d4ec5660ba35239a66da63f5b6f018069940e true 95d91043376db7e75b44043370bc86485056487afe230756c5174d7848aff672 +generate_key_derivation 6c3a8e178f54af42109598de496ab7540d6c55f1ee2ddcdfbca9d8c0185ae29a 1ba95d48b9d3d16c27d752a73733cfda7a8f6be875c847302b54f736efdf0209 true e90bc70d1f66b0b3e92712a55894cf08657d71301ee409824dc5fa712e1c4318 +generate_key_derivation b21c71f382f011ccefb48b9fa320f5759afbcbcb4207084404ba57f43a2f2c33 ca34d124feb2c976f39d0de5ab1e7963f79194fb1466bdc383357f2190f6bc0b true 252c32982991b3f0bad42c2f09ce144548ab5ec0fc4c916a2d99f0cdcd532922 +generate_key_derivation 34a4f30a190faa6ade48d887079487ad3d448429f23150494a53d71d4af3123f 801a5847c1552a36ef6d7a7156530bdff9c8baaead1e7db2ff73c299a6a7d203 true f5564a1479053114c19b7fba72d742c50c830f2692726c0876bf981498deb876 +generate_key_derivation ab257f04585c82ea7684c37fc06e36b394d4cbf14c30fb3ba55fdb9bc5464141 9db723ee4f23ffd9a0bb352159a0777e40ac79c3c52312c484fccb074e626a07 true 8edd905f2c606760bfd2b0702a955607aa9017c25b3ba0726c1e47f50632058d +generate_key_derivation 36a9315683a4a105c2f081af221f13fdd41b8cf59a797a116d4de5bb4a094516 c393edb2f07878eb4de82d8949c33c57e47dc917fd762d791da623497dd79206 true 2bdccedce017f5f533ba0387592957e8d947b07c2489db360dc04b00416cc996 +generate_key_derivation 12bf806455b9f6452dc0b8afce72e368b8aaf1ce214328113923be45f5afb012 2520a2d366fc10f1476fa4f675a26aa0fb94259460e56a08c7b078154b027c0f true e7927c5e408e8c6b19609f2608e11e654e72dcea0c5aca209f6cf22e5edd1b7d +generate_key_derivation 7f4eee85a22fb8c55ef874cabe8940d802b978ac2cbb7773d73e1c47a022cf52 e307c96a39e36c7721d26d31011495f9dbba888bced9ed7e36485bac791e9a02 true bc9dc7b2c9ff5eb25b4f4aa05077512ada06b596113fd0e7dcced14c00705ea4 +generate_key_derivation fe7770c4b076e95ddb8026affcfab39d31c7c4a2266e0e25e343bc4badc907d0 ef03503e6f5cbd43ce11961e87f362646e19f075c7a13ad96456cccb70a1b60b true c746115c194f63a5a8ce16fc880ad0a5b2533bbc1d3ed3f68362530df945bcb8 +generate_key_derivation 0a915cd2a40f9e6290f9046a262675d142cca54c4a1244d5ed1114366ad5e468 9c0e506a6a7d209d8ca21c3a4bb8cddd2516e0b9c3a8f4a1b57edb89f74ee400 true 47a8cd310364e6926a86af2d7d2d2795ed47f03f47c8d41f9f0de2feb963e92f +generate_key_derivation 5910cdd6cc2e71a659fc2a22e61da3f38939ebb45b51538206e423e1a0d9bd12 6b7e4f32dd25bd6dd326cdbd32db986393e99ac8dce0e1decbe99ab90ebe980c true eeeaa2d2c0579981ee407946ce81595ddeb80a8c0cc27a39fa8aeae840a1c6fa +generate_key_derivation 852b8d6c9197e7e04ea5f9b91357d618aac363dcb7aea38a185b3d3a28e8644b fd74e330b90a768ea12d38403ccf2ec5197aabd3f55d95b4df460d0663decd0d true 9c91682da7cdf2a855eeb8742c06f11e532685480add696a51493b42d51ccd29 +generate_key_derivation 73c9eef2fc10f7474fd9ce337531889561819c321dd75fb2574771bf04e648f7 52f21e00b124e5d53675053a3af95ff18c090cc41a541fea44378d86dced3f0b true 8335051a7243bccb1dea7d74c09a0af40b8e66cc90e476630fd3c89c9db69c5a +generate_key_derivation a4e0f579354f0b75bbd1ea95c9dc99b3d2a0157250fbd17809b94fdaedaa4617 bcd5478668fd30202b9593b0f881356c8bc39831ad1ba9eca2344cd5bc02a101 true 5123af7938326cd5822e39a7460cec2c5fdd3c31cee9679752f472964ca5743a +generate_key_derivation f19b32b42c9da73416397dd5b80680bea468bb3e7870da38d4c6795e24fc7883 ffcc54d74deb8797f20f6906020276b47c87cc9d3a98df5217cd5e1b256d230d true 59119c65a4e46dd3578a2e8bfa6fe4eccc870a872490b3251b46f6dae31cd2e9 +generate_key_derivation dc5a06f53bd7a77d8b2599df1c7e51f3da88059636ad22286fffe89bebc03541 10f58e3c4bbf9bc8874c954f5596190b8a694bedae657152bd6fcc27fe0a8501 true 9c81f5f8a488a322bcb00bcecd633529f11ce6d0b7909d7643cb194aa61fe164 +generate_key_derivation 5f65e7511cd6ad12d03d00fcd811656eaa29c8708b4e6e9fdbb63f9645cebe86 416f741eb87b2200aba1d66d79f8cbadf8a38718b32caa9093fae82c027f7d01 true 42f6c71ad9584c7f7e9136ee7cc82bd300078af9575ce2886ce6b6ebbb258464 +generate_key_derivation 9b0ce2be4670a8db3324f2c5466bcfc180cff8dc0045008615ab092f95063df2 9b907c12a39667f7727332a47252a743af46100ec084b4cf9ec88ad85e5bf20e true eed80c1ae964485919b8cf1871b381d0d504c2188391157e38849ef2da8f3a53 +generate_key_derivation 708d1ddda1d0a9b9c502936166fed8af30f1b45a494c31be970e39812afc3971 e6bf163388a0539fa7c42a2a5fd53805b3b495098369ab1844710aece51a7a0e true 0d2ef24dc598012136d17e84a9d68bb6e1ca76b330f5d42ee6c465d282f667b7 +generate_key_derivation fd4cf3f716f422f584d5e56831c0079ac084148f5bf2331251f8172aacb0ce96 8927a4059eb15b04d66d65580c1db170944f8a0008fbeb92120fdb519f8fad03 true 8b8eb3d5d22b9a11489132cb0f42d197288cfa94e3902144e02b14875299d90c +generate_key_derivation f3e3a159e4f497ebfb759bef986ece0a8d6a637c187279ade3bc7a11c238af7b a41cb5172d12cfa431622da5b544b78b6c69123140732a81cf23c78b4cecdf08 true d3fddd98e640439289b660bbbf49238380eb48da6bbe88af169e4c17acd33eae +generate_key_derivation 5938674edbd2053efa56c21454e0321508a4eb2bc62f6214cea895410b93ffad eac876b67c0d5a5def4aad7155304714891711bcca5ae8b2ebd70a015f0fc803 true 2c4b7d5bc0a86b0ddcadfb8388c9a0f94ed9ca41fd338ea13b3fcc0580540648 +generate_key_derivation 5f641c3a8dcccab676d8ea340a6103b318dc85f1837409e4eba1f0d1dfb811d3 135fc553a1b8883aba9af28aba3df54f69c3e114859fe2d6e33a6ef31919e10c true c25ecd96fb79e6f3a372dfaec98e4ccbfd99458414ceb459e515adf03e03fc69 +generate_key_derivation 84ff4e8aa5e8be96094f15ba3a6be110425443480f536bf44ebd52e0ae7dab75 aeef2295a4434b0cfd023923f7bf3da2e4e9aa12ae478a732fbbf6151d0da808 true aefb8aee82c500599830e13e149ff5e966f9209296c9a89f7c785f55f6b05d8b +generate_key_derivation 0146ad3ddcb9eef1aa89f3f91d7b464dc71551caf7e2214fc0a2aeeca5cef11c 87407fb88ae4f457fd0227a062efd8f8004a58e9c5ee5c279da93dd611f5d702 true 7a71c1472d3afe0b006c1a12155dac0b393bd41fb470f5a5c353f4500e66498a +generate_key_derivation 147ebe565789054e8a0aa8f3bccda5fe8ac8661d17aef7952460ad4fac26ef98 cd638a720cc8669817477dde50bc80d16e825df892d084f290a76cb94ae07a0d true 4d0d281ff1035a65a6c19fa4c6d81fcd6b8fd7c775d00db3bbaf3ac24956ba5f +generate_key_derivation acc52e9975d0864de7d28b361379171176319fbf28b7487e72882e40b0dae949 60e62ea762de8c46137b32618e880e53b6ec04c621c375ef396afb151e43550c true 66ee4983e5c47256caa9121134fb3ae0593b3fabfa68d7256c125cf8ef2d4e56 +generate_key_derivation 4a97a46deae025494f2216f2ff4fce4670821a5ab66ef49e4b8822a8a75c44e4 ddd3482edb3915d39e10f236b39dd8194d3d66ec7dc52a2ba04e550ddd6bbb0d true f39185333dde90828615042a69d77e8e61cd9cd5a3acf0bc7d1dcc9ef5833ef3 +generate_key_derivation 20a2438ab8ea131c8b110a6fe681800e0723b22b06fcbca197f345e443480f4a af2da9f0e721bbc91c635c0eef80f403141fa23d3cfed0ead5352f5b627ff60d true 8c8d5923db144fbfef2d26c528b273990d1c920649d022b35fecdf9eaedba91c +generate_key_derivation 75580928d7acf0c0f86553a4667ec69534eb9c364f95883173744339aca754d1 914b6ea86f6ab55445a249e47eb8522de011dbb426ff29419cc660b83c62400e true 39ed249bd48a18efcb6462d3689ca754ec0de8c110bc8b2df5ee858e90d8ce50 +generate_key_derivation 4c67cccd1394ce79e1d7f3e9c0f55306af7d9de48af6b1681d839b1ff1b590fb 44918b89edabc9dcfd02b998e9dbe94436e84884779bb93661ab57547cef6f0e true 7523559a8deddd4580e883e85f13d5d642d8c2fd54924909e2096e3dccde144b +generate_key_derivation 7a644e669fcef92c94d6795042aff00392322f196fe2163a1d4d6c751de8cc76 67134a122b1e3c25dd505514af1b71ad890a1798539a92a695187874e484500d true 1d73285dda47d33f2db7f328f9238805ecad0c63f0be8acbbc26e136e72c14e0 +generate_key_derivation 2b5bcc620b46d2d51665e0da7f8026ac29974d5be3cac72c09158286cb530bd4 b981d49ea48333ab3d550a7b90a813ee874220f2cb9d7d94b6203ed7d7a63a0f true 2028f79c035d7233c5bc61d83fa7d0e1e4a90399ebd36ec661af4494a9cc48e1 +generate_key_derivation dc31a0cc6961b91109ee9593676375ee73de7e5e4fa521f52bfb989ba93f8fd0 d1044c47522777ad784505081a002debe0aee148af6837d6e32a7f7891d08a07 true 2a681c0015bcc5ed86595523b6e7966aff122dc4860375a7941c13d0d050dead +generate_key_derivation 293496b41e537e6571add67ceaefa1bb032a54b9a8b2409cec58ef2dd9edec72 7627cd1b18be73b683d4572a4e29e9a17186370c4809ed88663f9266b7a8c205 true c9fb2f0b405aecf1758eee99fa177e0f9ab607d33a08ec8887b62826bc120c9b +generate_key_derivation 59e1b824812ae60c0b694c407d9be76a13e89ec04f6998b1a0648237b515f482 4ec937896ee552ef6519aa16cbefc4afe1739e5bdc554b818dfebe3499997f02 true 4794451d81406621515440e38eaacc867928df843f9f37c227aa4e0ae02a66e3 +generate_key_derivation 3d11931a26f01b3eb15b45f101543dd43c53996722f9445312d1a6a75554ae8e d62b274639791c577f710412ad863c5b13d3bb0894f688d78d77c22af56e2f0a true 113b7ddcc30a10fb1a252b41cb257880e7d2304ec095cd1f61146247ab92a6a0 +generate_key_derivation 4b09139e413a5c30b0e721bbfa7dadaff40ad9aa6211410109628adff7e5c160 8150b1a9dde06d27074ecc31f782259d85cbfa996eff37d5ca381f23a8e4c806 true 4bb39d6711896d2a998059ca3667223c65dc083b90eaebe48a187985ab677d65 +generate_key_derivation db7939f32282ebc406a9ad59c6b6f6ecfc1e5c590a5c186082ed8454fc1f3488 60f413322b35732c5b954d220f21c1f594b8e3beab7fc15e59ff1af392c77f0c true abc011cce8e779928027dafbd5d1ab96e327c3012fe3b8451f05036e8c1ef8b7 +generate_key_derivation 741c51f98e83f67aa86131b5ab6b4965f85e49c571aa28bffff1a38437e1396b cf4f7a72588e035edf747ec0e790bfd5c07abcde02ec019251dcdd5ea6d85e09 true 9ca6f2b3abf8e3de83f5191b26df6283121f4facc2bfaed6059cef2ce35be28d +generate_key_derivation b339ccff744baa79c40a2539649078c22799b1e4efcd1afd8109ca7235544cb2 0851c7b079fb619f53ee05b2753874396ab91f5a4cb35920f8e88c1c7d5fcc0d true d89c062b7ab16cfc2d07fe8a3fdb1ac5ce039363789c3ef8fe5c101329c54209 +generate_key_derivation 817e49ab8e69af5f035ec7480ab8c239883b67569140b45c72099f5da0731c97 b75b2c50eb95fc923d7c5aaca448f042b1f33abe832afb026636f2860d2e7007 true 7168cb4e7e15e57767ae96eea638358ed8e3ef8c279846959938cbd477a01bf5 +generate_key_derivation c7b49c1237bc88ce9bc8b0a4ffaf8232b3ca7451d45fa363e03ebf777548c367 96181501062030c3aef406c4312f1be9c3243b99027d9f684e919bea2b7c490a true e5934a94f64f85f228bf833c7ad6207ec5ba1251f4d79a54d5335e2d24a6ee3e +generate_key_derivation 79070084b4d0653634af34fe7e312ac634f4515dd65d207bc093b666ea793e99 e554615d2141203bb7c9d72ab8d410a4e1b6d1927bf9e62f4674cae42d0d1e03 true f1d1f77ab995a8a614b84215cdf2c25340226e9cdcb170969df01a4d11c2a9ae +generate_key_derivation 21e42de2f5bde7a67c582b9f89086be5b782bcb6cced9397130b791e693a0971 356c5c1448573053d1cc39a07366fe787d662f296e1f4ff113687c5fe5d23505 true 5e6096b4294e58d70302a295cdada43b9edfbd6d51b7a789ebc5b89d0228ebe4 +generate_key_derivation 463c8b621516f4e3d7d94e60ef78db9bc2efe9238e3a8f150735894a201514f7 1dd4c04104bd381c2f2c49d173e5fb568262f0365216e60aeea822309098fc00 true 78c09bff91d823573938782862147f153ee7df743d41d951aa62c770b6383293 +generate_key_derivation 19842f7878f24a5a8e1d819c93e89ab7ac0faebc6ab486db35f94178a1dddd22 e2722840d7256e153fa0b6abb911e70fd9f082f8b4bd7f1cccd7bf3ee76b4f0a true cd0ed548398cafb31120f92037ae80f97d23c8fd5f1a25f52f06924ff610fc66 +generate_key_derivation 0a1f966f7919e3b1c0f1890f74d24e99862e740f92328532d44fce0d18ca049e 302e1943ad0bf80db1b6b6e652b0c2b8d0134bbdd50256fe9bbc51c7cb0e6807 true 0658e12673939509bbf61539ee5ffaa62f3aa76c63a4dcc2c932a5028b564dd6 +generate_key_derivation 92496cad48ebaab841caba1dcbe561bcd087eb571d212fff841903b9242c82f2 2ab9c80a23629a35ae828f8d43636a9d9a65a31075fffe38fadd751956ccc902 true 6402656b61ac3c4c27984cd445b3dea5e75db94b205b1fe3aed4169de987161f +generate_key_derivation fd22acc9ee1c7f2ae3c2caeaaa508066ff51f23196f8c76aa09c24fc204759c5 ca71cf5c6ed58f1c5ae9adb623ce1ac0f97bc798d1bfb2dd063722fab2d8a202 true 3b03a1336552e29520b99473de19c61f4176cd68efca483b2e9d1fb2fb2ac82d +generate_key_derivation a3e3c73396b046d6192759029572e3e1f6d33396169c51cf86fe66080d2a0e6e a8b90ce70af1429ed2fe287503e3886b170f74260c270f6a2733b29f1e596f00 true 94f1006f0ff79749b812bf2a5c33a3e0b3907692954c4ea47ed28fc5f008c553 +generate_key_derivation 39561e759bf1c64ad8e1fac43f264f6dc9bb1e143181e8330d49f6295e476f3a 08dec6499678282f124b816d21b4d986297d52c22ee6ee337dd460f81e117f07 true 068505e9dcd8ef254c377165df60c8febf2effa8e3ae75a9e2c8b8952fea31e1 +generate_key_derivation f26605bcef0e46d5b0bab15d5fe44c47f3a02cdd6bf495002d920ede36543506 301ec6822bd2f8925170e976a8af98d257b4f3fea250179efa89ee0331e54f03 true af0ac433feb04763151600e2a3efcfe6034228cf58dd0f104e5628d0c5e53249 +generate_key_derivation a20039d9647f579a491baa601611cd4432216edb0bbf95691467f80ee5cc5e4e 4bd13ffcf3ef23fc12cec3701cb72fa6b518ad6dabe3c540b2df64b08248cb04 true 14e3f525b8037c8df6680e1b8b132d0dd478b37942bec02fff11d5e154165f63 +generate_key_derivation d96cf9ed75b957dacc3e56a24d5ff44778741208ae82e11b5cfadeb590b41bbb 40072d06e06c8543381ac4fcb7eb5f77501dc986df5856975cfd440483d58c08 true abe3225d08230d7d59a1376438f68f132bb629e4efe616fbd440359f2dd7f14f +generate_key_derivation 872e09c8bc04c48b387b2a23584fa7a5445da182ea80dc46b5cb0913bd44537a c82372a5193e32153273c2ec123a8f3ac5cef03bcda5417487cb71e12d5ddf04 true 3e665c1daea5d75875897ecb8f9ac76c89c571fcc811f1c24634a7308e798e85 +generate_key_derivation f8ee7bcf82f59f811b9923f13b5dc9dd5ffc9e17a66f8a1125e42048bfca44b3 325e362a0ad8722899a3deec6b3e5519f390f7672d785629a242bf34f12dca03 true ea6e3e79ac18d6f79829d34cfca828defa0a402b194d0f5b0f3858bc5604db36 +generate_key_derivation 09e03b997b81540d6a089a522762fee10f72e9f4d1d8147ae576eb8d692c349e 0a0d758f114d293f8073e9f8fe1217e7de85d8f99a55d5dfa1b3673563dec90d true ee5bf01d015f644dddec7a1dcc3c1ee52b747ccb18a2d56b7e9779ec2480d3d8 +generate_key_derivation 5fba43902e7a04b4f60f406281b737bf5efc2994f91e665828b33353112730a7 bb900361e38494a579ceadb88ef7d2228eab01d6a98040a2189943487cf32b0b true 226b986869c4129e57cfe1480b934a03b371e991e6b29d943be920f15d11c8c1 +generate_key_derivation 87e2231e0b18470234e91e5a6862a7ebd6353087c7532dabf1269ae92a0a1424 153f12b87cc0c31b316772ff6f3830baa6fb966423f79b1a37d0408af2fc4709 true dfbe23031923ec374b722b0fba924d3947715f8600e020d548382c40f23cc089 +generate_key_derivation 087b3a40a5b9e5bcbda3f745512c5900c182b3a42b13f8dc35617fa67ba5e0e1 fca770d3c923cd1e646d5e5c653a55b0d09be4a02a8e009e82ae7ddf1856b00c true 52a4d62397385a2a0602b3f346956a7163bc3158b4e699ac2c9187dff009dccf +generate_key_derivation 201e480f2ce2bb70b2f6b52e907fbed9c1fe164eb671e9619f14c83a49bbb758 ed457758267e636562c2795a198ac5970d72a9f728221171392bc31a38e4450c true 61bbeaf513ded614937260af628e6812f8369e5c79fe45c37fbe9c0b1daa5bca +generate_key_derivation 0c4a2c8353ae53c85fabebf44dc4037bf0efe46fb9cb996bf60be05a9446db31 058170e8d716dd7aeaffb6df3159b174d47b7c5048b6dcfc8323d80a622ad70e true 4f879e4e5bc242b3962fda86ad601bc03566e1fb520f4901b594747596e1aece +generate_key_derivation 3f2992da19fde99b9b7c4b36232e74d5451ac6263b6ad1ad18f96b2fe1d81b7b 17973e5ecefd263b1dc1db5321f26ced09bf8ab4afc0d7210c0f10be08fabb04 true 30f6e13833fda56bcf49271de3339f36c8158be04807f6533c57f101fc7987da +generate_key_derivation a09c897f41839f6911d1d00e65e7b779f06bcacd05cc76943d74d1d81db27eb7 e8c7a4941ff1b92414dbb568355b66fbb9dcf7be1e1562667b3b178d96949000 true 642ba8e2145e697f19c247a7b749074aec494709d982f430aa7a09d45ba0cf7e +generate_key_derivation 96d309c60e6423398cf3ea8c43ab540a9add0543b8a0a1d772fb9fc535519f0c 3284dcf0c63e1cb41eef07e02c9c3b4971aa68ebad674d296641287acd111f07 true b4bf0f07f2d62a3508d3b2f99e22734fbdb41c7a697a25f6c7c5cc3859c8261b +generate_key_derivation 7183558376f8d7dccefdcf1e36315eca62e1a85cebab5f488ae553662b0f0a6e c6d00ff3ad67d1d69910cf31ee0b36a371ebbfee9a9efdeae19a70eae2e5bf0b true 9e8d6df672972e7e39888a928f36249ded603db0eaf3eec75c93fd3d5e2cef80 +generate_key_derivation 7141a8613dc8d57f22ce475f6a1d5eaf0aca1d89ffdd33adf8d9f48f5328b633 795cdf90e92d41d7adeef6eff00a925361ade31ff175d5d97861dc4dd3544606 true 8be3e71e3304cdce6d053ecc876c633fd9e8421e2c0e1f3c1aed8a925125e807 +generate_key_derivation 12d7507c028efb4dcbee1d31a106332bd87a30fa0b212b9dd9750256cf56234d 495477e0f0c8b3cfa00b94424969d3ab418f63cbdfb3d70c2d5173bf4fb16901 true dad4a21c87625536eddb5dd13c6bb3c43e8ccc6888e6fdcba907c44da20bb477 +generate_key_derivation dd723f4f962fe0274a464c93021b2f9bc8b9b9259dd4758ecef3728993e604e0 7b7fe27fa28b59bae2bf69c7395cbb2c5cf53276c0df65afdd45f84a58e58e0c true abf4d5b1ba4af01affb36ea0f605e48caffe77125017b44ec9c2634051eac3aa +generate_key_derivation 7e11dc32351cbdb8bc003c46a925c5afe31a0dcfa4c0873dd3ec0ac252dc433c 6ab7ca501c3d33e9a4753b8ef967ae876c9801228be316a80db321c0ae244203 true 8efac8e158db3ebab109f325ced480c5bace98af821e61dfd288d32c8c657d47 +generate_key_derivation 9d562150b0ff2b954d47daf8cd4e29ac367483590672c91e390f3e51eadbcb0c 50d789c692b131238b8cf31719a2f77eb078532d2114a4f4cbc9d9a099d63002 true f4e85b5daaa0723c5b733db67ad2656839726037e6e4e499e711c05025b76fe5 +generate_key_derivation 8d2ddb5d0b92b3f47f13ce10955730fa79d7142a5823979da9fa89ad7bace912 1b9543fe99871f77f71649c875981eb130e472cb461a293da5886356d48b570e true ed05b601dfef700f86160da57a93caddc163c6d350d1bfebc4a026f4d2d535f8 +generate_key_derivation 154c8c030085760b1f47886154e6091b0bbd5f91e74d36bb52e140cd20c9b5ac dbd0c891490a03d039dc531952d9167221fbc9cb97149e520c18f55ac6c4a50f true 152bc0d30e7358fdfc4635f5936503c64a2a23cba784bd9dd9ce5675235d1e73 +generate_key_derivation ddfb02e1e41a775d0f9389ecbe2bf2eb53bd872da6875717a9961aed15707220 8c097d1cf7da940b89f95b1c3f670098c1d6d2a8e6a81b84e9219c11301c770b true 357ba443b5831e10b13c2e24f945961ace12fe3de3f40e338d09adbe7d159c22 +generate_key_derivation ff17b253a3344dca8f6e2edae6f9ab0db884aee8a0291b5b4636d43b35efb4a3 3417cdc1d464dd6a35fc357cdbddf32d9e50ed1f270570c5cc4e125cda76c404 true 7b96192c82f756465865833ef3428d119022d865ac494b4f74acaaf59cc9b5d7 +generate_key_derivation 7fd9fcb71a176a1a84d56db2c354c37042962c0e189e48703861b38f2fb0047e 735ff07c1a8db4042ec917c41ae07c6866d859292434ec66704df974c6ba760c true e282059d1e697b185edf390f76d313dbebeba9f54e96b8d536f7eea87feb7b87 +generate_key_derivation 3cb7fcac195eedabd8525161d2a0f56b756d7685804abd2207436ac4ddfed7a5 d7d4ec50bbb7eb44e87977b83aafa7e23a5fe73b671d425212c2dc5cae9f610c true b9b91badb418603e5bdc26364d97b3c61728a176e3e138615a803d994155c429 +generate_key_derivation bb4665369f2893fa1de15be8ef22058445a4aa757214717eb38955cf17f48786 e819a0380fa932cd313a561e9de1613d17ef14d4a195118ecff1ca43e65a0607 true c45bd6b7929f667f2171435ecd684f129f1fcbb6b6c0eaf1960c62df5b93d0bf +generate_key_derivation e0e61efbb0643ea5e7028d518fe5b7948b0538f2c3f22dc35e77e2dbc0177487 fa86092d752fdc0220fb368f5c5e1ba4b3b611673c82f3935d48f34302eea807 true 788c8e484e3f9210c665e2294067453978bfb3252d9fd6c8008a126227064c93 +generate_key_derivation 5f1a88158aaba9e5213b4632f67177a04062009427a0eaa36c7f30b5e7cf2743 7e58e6dd5dbd3c1f9b29cfa9acd53032cc735f3c3ce94191f1f0568efb522301 true c6b95617513338bb9417d50afe5ea62cd1a5ac9f854bd9715b24b91fe2205614 +generate_key_derivation 86e6a41c2bfe0e5e383cec6aaf5feab2a213fd8e7b4d6370c1cfa56f57268c86 0d6103f20a2ecd605bf790f807f7813f01e5c445f47751d56d087d0ae8928a0b true 8fd37993111c7116b508ce2a59e65c03af1e5b8511f69a81c30f7fe89c924c58 +generate_key_derivation b34e1ef01a966d3ab3c5b540b0b2a97138d17b9ef4c8c1789e9967b7415aa210 6523b5f401983952cfc15c8d75b1928d83e4a4259910f0124ea31fb4474dcf05 true 8534f395e33797d7e03391606eee09721cef8ff86b442f0650150c6b2ec6701b +generate_key_derivation 1f912dbb09702e377319cc1c26825d4fc94619fe4b1be3e89b93f3ebf190ef4c 608e6c1a60f2004bfcbaeeaa03a95023d8f8100c5a5f2c298518a9c39610c400 true f8c98695e4dbfe8369d7e9ac2f12cb99d622a75580defdff56f14c6f1c06bd94 +generate_key_derivation 174fdf17dfecdf00f084f20c75e10d73e3ec48cedcff0eb3f756cfc94db13cb0 84672f91f48a88c3e1ce54ba65cb7835da2c550fb3da8cccf9b22535d88df906 true f8ce0d2e1254d5cfbac12d654ff8dde6341bfa5a20af703542f1170db25a2324 +generate_key_derivation 399d6dbfe20b8718296088bca62597b3c6d82d6434681fd83c38e50f9b338561 a5ae42ba99e745e43d99bc15364c0c19ff4198daaa90d962f9acfc84847f400a true 8f8b6b23bae47f57c0859b04a77592380d7e4fed865f292f943643b2d5e06b98 +generate_key_derivation 8c958d01597772007798182f5dc9ff2db55f898cf8422ae80f6f6b3523f94557 11d3fe5fe4a5e54003094d384ae82084218705810503e6e1c034e47f8e432d0d true c0463588d70094cd794e865b825e7bdee71e6d3e98247edde8397874632b0c40 +generate_key_derivation e9fc283b8640dfb954d811764de45e89b4185a9497d3e50d954dc945750ae419 691e0eb4c18019bca114e48d3d1c4b4161709e32d97bea1084c4cccb8350dd0e true e3f4dfa94bf8759e6598cb187d233170483b3837447d25e90391f0aec7aabcc3 +generate_key_derivation 3f2fa3b2170afdc33ee134ea3be864a8eed6c7ecb3eb423e22f3f2d242dead23 8532df1da57bcc4bb8c3416d579c43742d7cc3d5373d53ab0339680fe29c7401 true 9f0a3c73752f2aedc29216608a36c726729b7fe16b4d9f057dcd7e3678dd4c31 +generate_key_derivation 55f58edaae72bfd21872be79d02bcc6741b02c5c0dcfd27c46e7abd1825936c8 cf3723f9af5cc783908a88b418ba584f522dae0209c5fcb5a6096748a464990f true c1747a335f777c1456f16c3fa6878df61385e9e7fc3963276921148477ac1701 +generate_key_derivation ebe48c8d51dfb3c04117254eda60720a4f25f99b478e60de7c4e2d43cac94d63 e47472232f59f22fb886f69dadf836e9da1d3cb1c8b17d40e9ceda9ef5f1e606 true db1335d2fc515dabb97b42f9ba13e2f8a17af5611880281fcc2dc49a12510b3b +generate_key_derivation f32259b20e7b8ed49bfd6ac269f5676c59abd66d8fd028e4fa70e28514c8a647 ddf8f187cc4f0b8e660a71a6ca42236b40fa19eca86823d936f3feea0e317c01 true 7c72eb90bab5012aa430f9417ab07c39b54f22937c18984a1ec37c2438ab3c71 +generate_key_derivation 63ea16d0001c52b52d5563871f64e996b30f32f3b82a5a6ce3125d9cf35e753a 2b4c4078210c1d6d89b793086ca41dce38ea05c9507cf253923647beb4df550b true fb3d47872580f68d0afe49522bc6d32aaa60a303c9c6824ebca6b1be394862bd +generate_key_derivation 087a68e7f6113aae9e84f25c647a59784ba640fac0726d389515619487df3c59 b801263bc5d926d698f74fdb4f15e28d9410a8db534d0a955a7eab5772418d03 true e2197e056469df75224ecf96d11c13b341699611c70d98b7320fdf6276c38962 +generate_key_derivation cb012610b779ed1fb8d780eacdc09b467f9eaaa0ae92038ae60894c16c5ec960 89e6544ebbb9a70be57b95667e68470ff994ec2c8e2e2928d7af63a4357dda0f true 70d729468b526dc76f17f26c2a4057fd6cef19e6b640e3b3c594d40faa4af2eb +generate_key_derivation acd925cabdbded0b9b6a20f1b53fd31e1c6bd145628ee3e328e6293af17e301a cd9409e9711af1b871ccfeaeaae3d20a6d92a8a9c40bc74f9ea2f062490aa701 true 2fb96433af6ff31ec782df7c4bcf173b95af2751e22f367f419c13cec7800fd6 +generate_key_derivation e093ba8d9fdf47c50418d672af5ef5ae7e148d11a19c51817e3bd4c89e144522 0b70cc413d30d54e092b3c6ed8bf00d77d289fdb856f890789bb003b1191f405 true ae5f8136e596eb261350f7126fc36443c83de2d016227483c51e5c108bfd7b67 +generate_key_derivation eb5e54a0eeef60bb67731a48857aff07cc781257c2788ef70b3f3a910dd5c47f 2e597f845e657ba9b9ff1ab860f3b97298c9d77872bab8392286793cb0e33206 true 3d1b2abc7ba8b39713157f1372a7887fcfb66307355ff62d123cd73a09944bf2 +generate_key_derivation 47686ffb1c36dcd42da2b01888dc42d9f85d6b90ef93d4526810c52a026c19ca 9eda811a84340b5e40369f1cc455d5bc03a7034b05515d49b12d5364e986a90a true 86f48ed6531fe856017df86b157c6350258abdac0e25ca98c63e9afc32df46c3 +generate_key_derivation d6b4ce355cffc5ce81e024762649c7b3e97fca2192a55c09a2f467050d7d7e56 e700a50fa2183df897b0e9a194d906dc5c79edf5be2caddac8a48e6c9617a60f true 58420ab79e5f232e1e5004f3affdc05440e4d37348d272ce1e3b73b35c575956 +generate_key_derivation 77b6c0f30918ac69a6062d0dac41169e5063ceed54711515f363d2ab6edc224f ce78fc8432ac8ab669cb4d501d9f5485eb34bc913a2977a13e0b1e2a672b1704 true 2320d5414157eadd65cfee6d8ee909334c167afd3478eaf9563a90b8c1fae483 +generate_key_derivation 9b7415fd6c879882ca31f16a6e44b95c54f74ade1fa909c055122e49166fd48f 4876bc82b19b8b13891bf9ab167deec289eb626aff4fa358eabd1e52a3a29f0e true 050b134cb54b812d6897bc00ff846dc10d94a61694ffa0d6e6bc34468a88567a +generate_key_derivation ea9337d0ddf480abdc4fc56a0cb223702729cb230ae7b9de50243ad25ce90e8d 43d7e2fa319091f97e668307777427b6d965053ec317e904e2143154f772bd01 true 142f44d13bcf5a43e99177209dafc01729e1ea5da14006c0e43bb9aed3a63e52 +generate_key_derivation 2b154e18e1b18f7deba5547c174b9baa110fdbcaa0eaa218634a5ed3fe337dc2 0426db05e375a7373bd421d447dbbea6ac90e6268a20001e82a7dd2fd24e2d0f true 43afe621bb1fd2d529480fe05748e54d661d7d39fb12355e5b0a2b514c93c4ff +generate_key_derivation 93ce17119661b3a2a51af328ce2e14fe097ec1ca62c55f270760e97baa8e51dc 07a3ce59caa14d72eda5fa22f616323fac33fe83c554f2eed3a234317756470c true 05eeb11c47b5fa760421e0d55a4b8922f6010b7e221ea262e910a7a19e42fa32 +generate_key_derivation 180fe62cbb71c0580d1a9f3328e535fa006a5432ea2739a2131cc10c4ee8e9cc 1e7001a0d69f99c562726681814ae6ec6f81625dc25a5bc2c19e04e089422107 true f541c0e9affaac4fb0a6caf5e73f37290ab16151ea5c34fea615179ebd7642ed +generate_key_derivation 9996adf4d62e290ce8561879592f9a8116a2f50c864ba6a0e979efa36945f141 2670c890b0cfe01f6f9450a9ddd8fe340d3544f299959cec5ca2c6a711b5a80a true 54d57aa291a40db81417397fe8324ce18bbd03a3c7ac9a56d264a1115d0e1a2a +generate_key_derivation 6144c603f05173de0c2a1e2c8daaa191f15c3ddb35eed27c56ed4cf7b129ddd7 2c44d707f90f31018f34acb732c615fa8a0bd4a478a35feff99cdc3ddc884e04 true 00b80f78c6f667ecdc7d28927eb2e3bc5ed6f3ff3c9fb1444e2850739eb9fadb +generate_key_derivation 185718c43a61792146cac5b4c3d7f417fb19093b37b3b0edbc909be7b9a40843 8f1b1bcc645b74a4ee6d501fe1a13a9588e7ed0ab0131fa1a3b46e5465d9e602 true a19c971d3a1ce78b63c1803f3ea4e3c778844ff18f68d75a725d8864ce751f5d +generate_key_derivation 25d538315bcb81aff9574189ea65f418aeb0392f5cbbc84cd8a33c7ade31ef0a 056e98e3f01148196e19a179e6e9c41fbd0f3e4490e89e03cfc1999487b0ba0e true 9c8dcd697b95ca2f05479e49125fe375a39fa6e3f434f6fdc2419dad6afd9ac8 +generate_key_derivation c3aee5f3b005d6063044741f199e196a534a64d4d97a63e8b96e92866a4e8a98 03b521f58e52d62e27881594fb7525d4eaabce364debcb84dba14f9874d0cd01 true 20b3d54f2bb9000d1d2609fc43372a654b395913b025716873e5907be6cd0399 +generate_key_derivation 542db0beacad949824163be006932262f5832bca1af91d50571c29a6a44d20ed 704849a31a899c495fce065034292809749e7f4f82f005954a51449ff06dfe04 true 1ca1e9f53b9677f8c8d48d47156d046158f5fe5dfe457800ccba54ac3767b048 +generate_key_derivation df31470b1854322efa9519c29fa1cbec5625c1e43082c15c8446ff0a3f8976ce cd6845dc76983f9a47df66dd21cccd8c896ad604027391f392889f04fc15e706 true 80c75d4e9bd8daab67f3d0c88e8434a28a8b74393f73f11ede8f3c1c3d12451e +generate_key_derivation c7486545c7be1dcd33cc3d592cd7bedfd431beba0e3a95cb6fbb41146e818a0f e0a3ba659da0fa2ca537e50b45a2bc1554e577380d2deab073f986268e69ab05 true b811aef9503b01cc39917df6cc84e9a37db2df8bf69102592267a014df50ab48 +generate_key_derivation 84ee638eb05b063528b419654b778472d337a6a51903637a40006283a7cad8a5 b637f80538f5a3c8d6e6c91a1e8efb6b887956448f86bd44f2b8b329e2689e0c true 639c00667f1bcb3d5c4e580d6eea9bf4aec981c058498f86c4e9a68d10a9a20b +generate_key_derivation d1e5ef67ea76834e3a2b6f7935a2e9103146d9d1257f52d380dd33808e5cea32 870ae321d5ee78d7eb3c5eee2ed1042c7b59e85436f1ae6d7c61d36882d65005 true a086d9a7aaa7f85c7b96a4965d800bfc7b4f75dcf9913245baecb510a2935d7f +generate_key_derivation 7f214c9639aa7c5c6c3057cb628a17759b091041708ae0da16548a1692a8f4a8 133c92cb71d6bddd622c425a78b3a8b2a353c6e93c850c5a1f70c972d813090e true b1a6236b946ef855faae2bc4d0e5ea3ea826520893075488354a6715d3afe24c +generate_key_derivation 34197f8872fe7f089e5f5ad6c0729892b3d4054c2f3b4adc04e1adbc7c56361c 86258d6dbd8f9ec6606632a466b66adf97704a8bc9c56cec214f8efe6b859302 true 37683a82629ec8c835ff692e6b7234f5a814f184b06654b013b2af8d15cff8dd +generate_key_derivation 35457185b4f3473011019edbd4e63bdc9fe14678b3e3c1f03d5290e5ed9b10dd debb2de2bdefd9ca90f67c48680030cd7af9e32ba47cd577b111f2fbfe244a0d true 4eb611de14cfb89611d3885e334ca8fb8222ffb7528da8efa2da30e712d10744 +generate_key_derivation 2ae15aa893c3b501c22a6afd3badf58dd1e7a31b66ca3a6ee34bf3d61883d03c 48ad0e92efc0d65cff72179f000181232238c1a0448722fa2501537fba60130c true db70f40236819d326360ad8eabdeabb04f2dc6dcd455d84635084dc736aa954e +generate_key_derivation da73d0544b49048a192508296dc8ccadfc70e6273ea45932370d4de8b40822e0 d19406ea6f6f977cdd9271165e68c4946fb08c04082e5ee43bec37420a84cb02 true 95e6b3bf259e2de3503ae4c2794647be78ca539b0802d609b6a4329f8627f767 +generate_key_derivation 948f9df499611da74dbc0704954f9c952b9c018ceba842c58ea5f592fbd6b98c ff1c76de3c3f6fe6fbff3a6381f7370ed37c68e8371297f5d562a5c419216c02 true dda7a1ba3aa3251bc525e8da6c2295c96d5d2997da2151c8eae66cb10c7cb54c +generate_key_derivation d3f12e4ce0f37b09e03dce44cdc1ac10da250a03525152b1f057f93692b599fe ed4879cd755c4c41819bee0dcaf0275991297cbc32132b76f1e85017b6d72b04 true a911de8480e87a242217bca463d36a82d8dee1e8eb57469fb4fe84512feac949 +generate_key_derivation 5d95db8223122fb575b44f805f80d351b91db3a6a8fa9fd9d279405db25097ca 5e269d8d75556002e8081bca3d68141970d82c2783c44c9ebe1b39c4f30cc80b true c15d133f1381d8e6c13201c490b49a3be2fb86a1ac71b0308c9becb54b565a69 +generate_key_derivation 0d114180e2182749898bb90531be9f9d1d8b3bd3a8709c1a79794df201d424ab 5552affe726725474ff27327ddf5b2184d26e00a24c904c50eceb4843faa8a06 true e1d62b2cb49f1f5b310867e52b7b468beef202f065cc528359d83a9e4dd1afb6 +generate_key_derivation 9a2d7bf1cf8fb090192d2f3febec384dd03e02b2bed3ef15f5746fb95802b3e9 49584a49a787dd5465bfbe4b41081df52f680fb7c0023f8fd5f03d91a9492e0c true 7bb444359da3aeb948352b0ea007f66d2d05322e75ff3f040542dfcf8c188ed0 +generate_key_derivation b8d3a1b342e6900e89f25aacc332b0af98b526a3e2c4b0d375bf0ef3fd74ccc7 6b0e3a46215af54589ad1e4bce6b7b0e539766ec513613fe902e061f8cabab0a true 65dfb7913075f6b6da5abba375a2080fdccfc96efa22c1a9b43057e249e8a844 +generate_key_derivation 9e07f2e173f8b2e0ce1b57cfb21e0b807204a42c66f87fd0d213c9da413d2e91 3d72f5725f2345f6309d0d931c70afa5455be0c859e103f356c6873f7d01fa09 true 8caf666de54abedfc83c79475b74511f99fdb2fcfeb56245f2ecb3e8ab239b26 +generate_key_derivation 92ce19a8eadaa345742eddacd842340909c74a78f2a2fd6386c7ed1431835812 0266550ee1ac38c1fc5181c5691f103f396317a09d5319bd4044c2f5e5211e0c true 323d3426febe76d01f534ea0e387293829dbe55c1739aa12cccdf0cd04c24487 +generate_key_derivation a411a92eec81b6cab0e5744917e5b94360b68ef27efa725174f43b20d959eef2 adfc7fc202c83c508da4775e496f023a13fac497a8a0dca2d07e53841014c400 true 01e5f9dbf5060cd81ec7c631b6dbaab8b032c7d2de8cb1cd04ff24c296d50fc2 +generate_key_derivation 28bcb7c96baa29ffb82cf4861fff281c2f36a65e9eb9f62ca027a7c16ef92285 9b5f13d29c3900d6056b69711cdb724d4b56962d54e90ff7648bdcc4fa80800f true cae7918b648964131528a1fe019b0b9ec27ac46d66da5aa5216331c52525cbb4 +generate_key_derivation ad2ae014ac635ba0a7da58c96bbb1c4c66089c2022f04f92fd60cf0415f7b646 cbd840617889b86818aba5dfff86a41080048e4558a2c09d6ca08af657a00e07 true 564f5b26c3f9d9177a0a5bbd4f256be7f2d32877ef740b4e4d589707d160824b +generate_key_derivation ddd9d29ae4c14052fd4bad2d06a02a291b8a0d8b3ee5c39630bd31a8164a6598 352b816fa5e4d77aafdb586fc809247d5c14114c540e81304bf974a146a2c102 true 0508c71b08466a3777e576e02cdcc8c7ea58bf2b3dec88e277cbf5e0fef15df6 +generate_key_derivation 964f6bbc3191a86c5f75fb7c3182b67704bd2b97e9dfb56b45d0ca094efbf51c 0d4799df8fd8a10867004129547658ad73f4b3673628820545ea2b6cfd16a601 true 8c84dded36f97062c578287e89e6c4850af8e72049f0c935cd71d9b9cc655795 +generate_key_derivation 515eeac477dc474b3ff6a559b5c4ab16c72f25426b0e89eb384fcd71f1cfe128 8e4c005cc0676f5e04c97e6f52d4b7aa890a22d3b409fcadb4bb29204e7bf008 true 45ccc95d83a0fdb3e93ce97d7dfcbf4ae96b05b442b2721a4c038b4387366a1b +generate_key_derivation e0b41b740fb2aeb3afd5bf98b3a3dbc5a6a0201d700f4e601aaaa63a892b1d88 904c5e1aef51cd32764d8b45d08a5d02cff0ee573d92a82ecb04033bce7d6c08 true 4eca81f8c53367b1bbe0d760143bc70db37f896bf38510a88dae1a2cff8f9c83 +generate_key_derivation 8201848f597b55a3933b9225e69665b432a72cd86cabd4f4457aed6c728aac1f 70d45a84c8c4e1f08780cf19d6aa2698a2749db2f31e1ee8aac07d7d0fd47a02 true d6db8ff738e9c39d9d0947591f37a9b4f6a3c9b2042dca0c82ca41d6bd2bb227 +generate_key_derivation e7d3719c67d13d3eb0a1b54b5645d9822818edbad7b64e3d85b0dd3586d10f26 a4b0108c7a689e5749fed2c1c79d0c12a1ac949fc8ebb833d3a8dfb57a093a0e true 87de721053b862f5d777963dc633567fd89a0f26b388f7a8e1f7c0cb3e497f44 +generate_key_derivation 290e6328aa6c81d7ba4091bc16cae6f429ea935c705a7a86f4c8837964e9fc3d 2457dfa33a72fde5d0a5a3613e884276b3551d72983cf1624268f47984b3c606 true 3d22e41c5d8660d4d7198daa8d43878c4a735ebe532fa05b7138002ef9315cd9 +generate_key_derivation be4594a64e46fd93a719adeb05d98770216a3ceec9ea0cb7c164ee71c1cbaf1d 5ace38613daedb1a50723923e578e135093c19fff4c22e4bdb2efcf98fec0e02 true 20759eef1043375b9cf290e7a2d70cf5562fd23090915fd9591f358a0b7e3905 +generate_key_derivation f54fb96409c1ad12bedcee2b7eca42510e1e85a2bdeda3ed14e9cd79281e20bc c8144aa48497041ef3eac0573f015ddc8cd8f98f01941d30a95d3fca4745a20a true bc2226069391d88fc04a9ace76506b8f5659514c6d41360fc123db1fd90d9aca +generate_key_derivation e16d5cded23b7a491390ea779c2086f281c706ae29246e1008422e9b61ee2a3f d6a4ce97c5b53612b664e8a68a8a0e094b8fdb3715bb10d8984360fbcecd1f03 true 70ef8c5a282e75de8fea786884a85bd3d0ced2808a5375ef2b2441afd10dcc42 +generate_key_derivation de2ae8bcd67145b6e83a7e0c27042448dac786b7e79b814303f3d117aeede2f1 bc864e37ddad07462deaf21c4f7f6b36708f42dd18dc2e48f62561c1fb919f0f true aab980148177edc24727c38227af4652f3530523bd06f533c1cd31c4455969e3 +generate_key_derivation 4ded0d6ec4a8961b9c45fc9825b7253243a034723b3361f93f6b4ca1aee56648 3643b253314ac6d99c6bd93d6cbebc03e49d0476b0088c029c7d74d8b2c62d0d true f5b8ef486066030e2ea1d6e7951ce7b0c5423f2d01262bae71d8fe5c05d86d8c +generate_key_derivation cc47084ed85e66824968ff76d75c4a47c3e3901c7167bde209ebabddf64851a9 25d83f6d6a23b5e79b0ef83ddb9c5b08f288e6a810bebaf73345265a06a3e003 true e72fef3cbd38f260c12e3286d869d666b5ec36b57f0ecfc5c50a3346c74f8c2c +generate_key_derivation 58ab70b59699cb4e89ff5601a1faf9f64331b85da4c2ffd0392d51e6b0a149fe 9671fe9271fa180e495710538ac8eb4a0ee44675a258e0f1899f9f62a54b5002 true 46198febca1764f417234d0027f2c43677222ee9322bdf06738f35f2c078320b +generate_key_derivation c49251ffb86c5a1fd8b47aba25eb3938d1b9b05d974695a52641cbaa8eeb481a f645d8a10919e8e4e6c33363e466fcbde7063fb1a5e5a45394ade110ad671c0d true 90efafb57a971f08dde80f8b9e5b7272a0b9833bb3595ba25c01ae8bb648c2e9 +generate_key_derivation ab4a33b9f8ce707e891e51c2a6e0c8e8fa69d7c68976037c864eb731d6371200 19df9e0d02b51a63363401345a7ac36b87b938ed6b1abe854d4a585a195c7a0e true ba5a146897723215a21439fc76f7775afbe06d4723d33ae7b528a6d90cbde71d +generate_key_derivation d87d8f7292988a9c614b8fb460feb1c1d24dc72b05d11ea4c676035e3c7f27f6 445239f1c25c28dbb2d9dc3638297b76c2846fb42c11f9dcb0e0bec65ddd5104 true 4684289fe1a76278e11d8a1f4dbba2a5760b25c4ceff30be4d04250e5dff7790 +generate_key_derivation 44e805c0501657c2a2feb81350ca9f43abd5e3f828b0c116cfa493b5619305c6 33d2dfae2f6f57f9a5885173c5a872f9d209da0f7b1bab0db1857152b6a67403 true eb941213666ba22abc037e29b00f60e5d6cb81bdac218e6548ea6a400cb3e535 +generate_key_derivation 11471bcc713d9c254f8e3b5209187659a4573dae104c427fdd22b695334b7e08 93ae1109beaad6fd94d82213b1f925c68f52ad8d4888566d53934d9273454c0a true 77da9fd62ca95109c20731ecf57cc5136ef95164fb1ef8f9e7a808a70af8a856 +generate_key_derivation 959b39874f1d2204ef83590d09b4a5361d1907b67344e5a9450fae7477db8128 c7d85b3d8cd5ffa2120c78ab8090c3035a36526889e51501c42b84a09486330f true 3dec72ca95f365bae69bbbb7d4b5ce8a798d1903c086d131164b97f8f1dc914b +generate_key_derivation 9d86100050478f09ba80e940c83f9c08ddfcc8a31119c25b8bb55c1bb88173b9 d6814ad14ead0a89d20ad95828af3703697b497642ed012c085820facc086106 true dbf7999f487a671e146d3b6b269593280369723e8bcd7c93a6eef3614a7a1adb +generate_key_derivation 80cae8aca9c913ab5875c0827affcd697a252092c4aa5690e83adb8a436cdace 8e0f8b77020b7484391894e9a99608c773880f11a42b50e8c5e53a28c26b1f06 true f9d8dcac380f656f1b81e28fe75a275f46e29375aecca5a37c0f026af661b367 +generate_key_derivation 4beb98ad8d6bf2cdd8abb352805b9a574438c467e1081cba85c84e2dd3efa684 9372bcea7da23650d6c97e15f604d6ecfb011e9e961f698bd17cd1dd499fff0a true f6c942e7c3855489361a20bb142cbd4ad628fda9a5ddc00c83872dc6488084c1 +generate_key_derivation bf74d9104280db155496449866d7d862f616c1d9d5ae23fb3ea79e48c90803eb 325e9043ab607a69fbffa52c3e582525921cb014e93cf5a1ac943eb8d1c2a201 true bd3eae028998bd76b6a8bfc13a8b7a5f71c835d151ea778bb2070e1b94648ee8 +generate_key_derivation 1885fc9e1370c5ee51c3632de2a5d85a3137a0faadfb4727bc3ff383c3c87d6d f54d954011bdada13aedeb4d26b3facb6317b5d63de73c2a42fd2cbfad1f370b true ec1b2241de73c8ef06848e9590f5f1d2e24202a1ab810d14cfd73297e4020616 +generate_key_derivation 5bed4f770729aa10d34abc3fcff2ba7c8ac6d28608d612419f6965e55f60dea7 6312fea7213901a26638ec252369e7ff6c12c436275a8fab1ff3a1cce819930d true 86e6db8d26379fe1fbdd33b268f16de899ed88d78f6ceaaa50764db786fd92ac +generate_key_derivation 92652836d7c3071217d59bdad15b9368c7669df201c78872468200c4b1eab894 d23e24d9fc5a284f5f805b647dca2f1023621bd769fe4e9060d54f90cf4a010c true e526bba299234c0bc171d765c4cfe87811112c41fbfb39ab46f54169db17fba5 +generate_key_derivation 02f781af51d0e8d2b22d5c9de62259d0de1f98d6b33583b1909c66e15a919e00 a63dc04492bded2e9e29ea697cd13ca37647cead8ddac7c85e81eec61f792603 true 1cdd7ef10b7f798e340cd620c1ee6a1f99d9fa027cf56151a4597e306d4ba227 +generate_key_derivation 9ffdeacf19f1dc5ac82f1c5e8806f3c4e26b38d97ac625aa32fdac1ee7a10599 28062d528094b2528eb419784a891c9f2e64f6df34363a6a5068acbb57ab770a true 9ad1e1f36ab8d0520b2f5a360f035fffc37241bd4a48c40d8b9727fcc6209d3c +generate_key_derivation 5db7b0233538e94ffe34cc0ecf2e0a918df43b1048d0810a14eebce25200b4fb 44210e68f85af28d1030dea7e86330ea3872402624887164d98884203b0a2f04 true 380b4aea3af285d5d426f49d261c0f9a1c7e7df3c50ed128fdc0ce1603864bbe +generate_key_derivation 23d3070f7a506d3370304547ea769d42bf4b2f654f3d1780b168f8fcf66bfe00 321d809efff71f65ab53191fc54cd0ed8a734aa7db4c8fbd3810b9c5b6c29203 true e785173368e101424037e678f07237a240fd9ee390a4bcd3d6e697eed38c011f +generate_key_derivation b8e946f1371dad0205c996650e01d42dbf51910a279e4f07e19046c90b156418 e9005c2a1d2b9db7ddc9143585cc64ddb9e2cd0ae98c2db104e6155599b1e700 true 7fc14077c07e03922b6e3d276d8bc8574185e2f875d2191ad3dafe7fad4132ab +generate_key_derivation a516ca754064c7d8325f03d89c8b3251774e19e9ef74add8e5bfdb21bea7733a cbd10e40fd63db674e4fa28f346ee0c2d5e6be57fa4e485ac4a60e9b13238801 true efb7c477e7f7e4546b46af222d45382670ba046d08200637ad3c18775ccd4b54 +generate_key_derivation d00683209259d21752ff9454597f0fa38fd51382992f164568cc973b48279bf2 084aed5cc65554158fa201f02257658a391a8fe9622cbd6cc3c3e7a91c059b07 true 0c763718f0e36e5b3b299d78e884d5207e366cc752aec06cacc82489d81e8ec2 +generate_key_derivation 65fbfc3a8831be0ab7726b6a887c15800abaa6dcd65fb7d94b5db2765cea144b ba8d3324f9ca6f59a0545ccb910e38f78afa5487ecc884705b479634eedbd305 true 673c479af3f6c9864ab0078c3b2edd2b8d93baee7736ff60d8c8f934171ae780 +generate_key_derivation 6db9cd43ae98124cfd3032bf13a50543b48bccba26536d40ba542b2c30b64255 23864c040342eef830c3d11efeaa5a9aba2823404041274532eeb3e0b097660e true 67dfd476bdacb52f012fdc6e2335964c46fac627f2d72227abfee956477f4a97 +generate_key_derivation b0dda11f82bc859caed64c2f2335a38d30ec38961d1d791acd22331971db75f8 64b0e5ca508d8816864c6eeda4d0c8711be4e94a8d706f01524e7db50a249207 true 3053624e85a8fc4620aaf54eaa0def8deba579b8efbf8acd9ec58bea58482190 +generate_key_derivation 9330ca1b1e001463aa493d44c62c20276d4a09c3fa2faf5e36e6601f45c7503c 1ed639ac4930a84c457400f1254048fe5ce424eaa9f683b9085b4016fae31d06 true dd102e054ef6fff23517a8383fa9bca040f387970ed699e960bbc7a9e9272328 +generate_key_derivation 4864fbafb75b5713dd7092a1d0cc2d542b8c40ff67189e5c6f36f1712668bf91 c39cf6850360357f052bb0d0d3d75b8ed5682734e88494cad12fd4911dab3a0a true 36b91270963167656b52a9f1a0a4ed1e58f2cd15132f4fc999e1ecd2491577a7 +generate_key_derivation f90f3f84adfd258cc1ce4be2198b7a53cfbd4a02fbc45ff016c40d38721d47de 10c9fbae5714a15c05338037922b42adf6a499dcc7775013720146845c819d0e true b4d667cd5f47e3f82dfeee56fc6b5162cc4001c65f97fdfe24044aca129a2641 +generate_key_derivation af450decb956164fe2258779b24e99ba0d4e470d77d9695de23905a099e91919 8f07a0cbf420d7ec13a231b33f457e387f93cce1b6bbc4b2736d4821d19f730e true 36dc9056462050b3b2956ccb90ee3793b0926b2c3429194d752f339075d164e3 +generate_key_derivation 20da3f6d275481e4957ef18d250de47936f1da3c3fe9300753576b28b42ff002 37c46bf5859947298471baceae2ea90d20ac7d2a120bd09a5f3fb5d75b084105 true 7b5f467a47efaf56bd8957b7e5fd6044afc569dff81f06e11b09a29e81dc0123 +generate_key_derivation 58bf9a62851ba0a911fd68c04894b72a9d948e64936c234b7a32c0c8185cf188 3deb07290538437079b640e515617efab1ce0b151f28633f08bf39b60a0ab507 true 7f7814c3f32e448fa6555ea3cf4a3afc6317e7703aac771d8d5324f097bd840d +generate_key_derivation a235a7bce0259001ab6e4c5442451f5548a9afbc3d3e7c928886d3ac21d84e88 f5aea401a7f87a3a51be62b426802dc40778ab37114109355395f02e5ddfa307 true 7a28974970c83b5b556062e004c8cc61768c7068febee3ac282bf8bd6e78172d +generate_key_derivation 848a7aec69a962e960f673526734a9733f86c6fc7c9279e5fe23284ba51cd188 97c23a5217c55a8f6b1794eb29d11fb4606f13933cb2f881f54a8205ab382501 true fed701b04e1f20919495d9a14a552191e9c948ad9ffc96d77b9980d0e3e2ef4a +generate_key_derivation 19fc1de6bebe4928cb265dd6538b925df0af15226c45bb9292feacb038e39d1b 5c3026460ebdaa6b5ba08eb3bec8055004784dd4541a2d60af1e27ab45cdd806 true d93724fab05f93b8091f89c398378b125713e4b89a9703ef70a910a37996d8b6 +generate_key_derivation 39a29bafc90c62bc578a7368c1ef1acd1211ade2a4bed0356fe361096681f1d5 6bd0ffb9a15614ea1824f82ddb7adb756939dd136fcb0758e6a778563bcd180a true 51e5480acd8c41604f6259951b990dc081575d2131dea7732fb17be7e45b10a9 +generate_key_derivation da15912f625334fedde2dd3957961be9960e76b674f6cf92850e3c60dc855c6b da4bba43d60c8b8136d753715d22f91dfba236515a175170e5249d7b8741b207 true 44ec2cc32d609bce83f774bc7d0f6e2c2505fa6414a4be871b24ac431a0f108b +generate_key_derivation df96554a11dedcc64329c5c6cb41cce768b4dfbf444d3e391f1ffee68752bfed 4f62736f3d12a3dc394928b9a32e8efd684b06c199b9d8a0d4df0b5b2f2b4f08 true a81b32a47ece6b831f1da3866dbadc39885ced942379ae2f5698e83b1ce6dcea +generate_key_derivation ab63ea54fb16fc95de5b72ea31855c036ba0450e6d45bd132a327d6dc579c858 08f8fb540f48aaa461e6eb894be512792e57fbd2d376014b8fa041ed652b290b true a36ba7b4d31349ad278a6df8f77adb76748b59f4929348e67dd92adb9fa174dc +generate_key_derivation 65de593f98b0d4de1ace0f6dc60bf5c7ca9fc6cbd855dffd6a4c07ed744fc885 b9c50fc840737dedee1bdb2ece68a26e20825b6d7d2e7812ae36cdc55fd3b40b true 3a015113cf3861f87f2babaf68c8c6b52faab4228e48510581e03ba48d7d60be +generate_key_derivation 4ddd1e6c27bf2286f17027cf4e895b649f079b9e37bb6607bcc36e0b66e73f94 fc1ec44c59b4419b5a2b1d6245968194a7ffc5dc6246a2c884bd01cc8ffd1c03 true a874a44d8a004bd529b17e4ea187635ce3ebcba2ecca8fc6ebaf7c14dc01b0e8 +generate_key_derivation dd3b8e371442997da92160b3910d449879a6a6ba4e85fbe04ccb5d38974f2830 9323c670c1d9e664f6ec6c97d7256986519a35e4c6ef466386d289f5c4b1e009 true e70336cea9890ab4dbec340228676614db0068e3460de15e4f9751311399ebeb +generate_key_derivation b1bf02730b4a284ab035db0edefbfae7fb3078e18e0d4dcc0b3fc2e048f28846 d7828460a33152706c362c9ffc03c0e7e1434c2be57f5c1184c28533e029d607 true 11f897972ca16061cfe130f7e8916fc92a7868df0548547348ecb5026441bafe +generate_key_derivation 05c5409e577d738a4f70f9312f219f88af88e539ac1a05ce396e5fccc0e462b7 94865eee3000280f21cd33854f0e63835db402fbfd71aaaf04d07cf2cabce302 true 24079265e51e849fde16897022325df1fecb631d7de94ebd7b77c42df75d743c +generate_key_derivation 2d42e2b1123cf3ed629425a3cbcdd7050f245eb7c341214ddf7501d4c1e31a74 c7fa852d75ec0fde0f14a9db22264b11d3a909decc5160d83671a55dfbd8f40f true 128c49a8f10b5bd171cf19f998fcc2d5d2049109071336298da6a50b2b02e284 +generate_key_derivation 7462e55eb710954127d4a5de8200576bae4dfd41cc2ce970862d7469d3011afc 550692203cc3b513f51412f0a3fcd7de9a32472579ad4bf73bf66981a082c603 true 7906160dfbba58f2c49a266efa9ef3d2ca25f10f9c640d75d4a6fe822b234c36 +generate_key_derivation af3dc217379f8b78c068adc0463518f359871ee398c434496ae6033151fb3364 462b73deb17e0be1489283e31d93e31da2913fe6705ed58e22ca8c536c90e40a true 8474f0b701d503e4ff6031a5409c7ef207d91670874f7882a335166fb784cef9 +generate_key_derivation 05c95b9903be9edc1bfbad6db5b938ab3b9afda582364161d69b524adfc5024f 1eb999911a0c9d641bc58f1912bc44b4712330229fe0e8f0eda3b51557e56c0c true 2639e0823678e0316ebb5fe9518f76a801cc39afb151a4788996cc8b6af0fd33 +generate_key_derivation c298b5c585caa416cfb282b2ecfecfd258e1ed37986f236244c3557cbdd35c1d fabeb65b17b58c9d927ee8a6e0b72f7b076847149cf0d4334fdc21768e1fe10e true 6eb4b0e82f53967d3a9d2797721f63264694c0bdd19c6ba563b01f9a3a2d4bbb +generate_key_derivation 6ddfed84cd5b0b85c3fdb9930c03232478db319317d05ecfd845e1a3a6fc3dcd d66e046b0310bdc02c2574cadd96538b5841388c7080f060f7fb3bbcb4d71b08 true bb9cad4cb00eb8a720a5e848fd388f14d86b1757e846130d91804cd25f5cfb77 +generate_key_derivation 8d33c8b71d4019207971b5c8f6879150b81ca4b7f05abcaf4016eed8879e6194 e927b464b5c89df9adeb13030722a39037d3148f2aec0a59550835ac79f36408 true ec49f59bce8797e49714da10e2f6bcd7a101f6d9f09ddbd5f185c75c322e0ceb +generate_key_derivation 4e8e0dc95ff68ed4f4b5f01033576b98a7e895f72f0796891f39d93f95ee95e8 f5d6deb10f951457687c5a19e847feb8f3070c5b531d689fcb288498f55d6f01 true 9cfbe1bb504e83bd3b4ecff260eee1342dcd502376bc4f179a96ada1fb64c4cf +generate_key_derivation e04d324d1f9b5f42784cd1ab00804d6823e852c525d364be4f0a7c21dcec4410 ec86c37dda8168b2c94546be337b9ca0ac748cb601d245892fbe9ae2acfa6308 true 330fa8bb80e9ff13eafe1f20acf88ad620a559cfba63832a913c6caa406248ef +generate_key_derivation a1cd6724a2a1708b7d7d059b9cc1106376d5faafed4aa508fd47370a00a96734 7e66cd777ba0282857bd9c84c3be941dd27b5d916964277d6c48c512c9c54e0c true 781c873b8edebfeaa7688c546dde8661cff7160ae1d853e2ad836e55e44f9a23 +generate_key_derivation b4644ba31de9ece106c49ba89df833609d393212fc81236783b71bf2f2f0afcf ee5019c66e6f4563670477a3a97c4340e0b38cb97c9d0a2de88b227069c3d90a true bf114ea982ee7298514756001000b9030228ef1cef0a74abcf44f9eb207e6aee +generate_key_derivation e698625842c0bfe127b159154ddb48fea86872728fc349b39169628901fd4f48 8d73e0270e07ac172b1a670ba84722dcdd1a5492a29d150ac5576ea203096e00 true aea8bf159063c0a4caad541da541e0017f68af4005158b3ac611d0428b1ba4fd +generate_key_derivation 8edfabada2b24ef4d8d915826c9ff0245910e4b835b59c2cf8ed8fc991b2e1e8 a01fa9849a0f9505ac8c80c2bb4d23fcb303c401d68d231ae7bc7fc0a8dcf80c true 6d96c26cca0e76958c6298203d4349b43c68c8800304e43b16b034c62fde5495 +generate_key_derivation 640fe516e88b222d96a3047948b2ca18d6053a1180e4ea734066e0f7bce0e12f 6ddd76bbd25fed180e8e5db11d62d6fd8465834987f60e8be214069c68e67104 true 121e1c9c02ebc7483ddd3e06d29fa743ddbe9e330831282329f5c839058f81d7 +generate_key_derivation f0bb1ccfecae94a2e6c291c9146c4a0912c34c315a7d0bceb84a7c1c4af8b8f6 18292d8d46c54402743e37a183e388e45bda31be9a538ff059ae81fbf4e4c401 true 2019550584eb704d2f5b31f77c51f7dfb4d0e9ab3e8f9852b80875dcd45334b8 +generate_key_derivation 933b80a35a3eeb15ff21779a8e2d7a39f6f2b1e8e98a2f84272098e13faf2b73 5e4d6b854ee7cc047eb832c7c99b19ded6e34759bdbd6a28a31372223ebb7701 true 34454915ed48478616a55d178787f54803dad1b3d424f4906d56f4a051fdbb05 +generate_key_derivation 4727e4bd6944e7ae519ea37fbccb39eaeb96bdfaae7303502f0d480871064e21 3bd2d4669fdb55589de8568f4e4956cff4daa023f0a00ba147681576af23e101 true c1374d239c503cd61add3d5bc0cbc64c2adf0a53db44e3b6cd4324660188d4fd +generate_key_derivation 364dc335d6567c94ee6d9eed575a2b0593a326cab2aa6efa3a2535f7fe0c70e5 c2f806649b0b72c9ee080f6cd8b289d596e600a6d0dcc8f79e1cd6f3f9eb950f true 626d90417d136b4277e501ec1588c748f878478e99e94b916af7b3ca687cc382 +generate_key_derivation 0bb49f278931b465c4284240ba2a5f8d3cc57ae127dfd2f8cf4ee9d6e409c212 9324a9592cd6683f94dcc88fc8432ded8c6573b56d3cc58be6b356f653b09901 true 947ddf3d4a5145c30ffb0b7598934a4da32b2156ace571662ed6b9b163f92510 +generate_key_derivation 93cb71a05f655ea2b1aec29e4119a3edf83f97f64530d6633e1452c1874279f9 5cef184b7fd31bd5d308435b242db44bc2eb5da9efe0d2e69f64eaa3d8049404 true 5a3b0d1f6221180b9b7b51370ba28aaa1ad91af9807e945668778c2a531f5930 +generate_key_derivation ecfea168cb65e3cd982408e706d555d6a59562ec168427529586e67bba9e497b 7dc5bc5481aa604c53dc351fb8ff1d0c382d84bb8ca4e6c3cabf98e7a3b9c100 true a27e2b525c8c559597476f2b25307de26cb85fe3d4f2136a2097047c477ba351 +generate_key_derivation f76f0fd1f0ad52353aa3b27b14535179d11f487eb2b07102d92bad55507ab4bf 06701f75a96a995a1cd2af027fd08062f518b5275636a6bff3f071a6b10f1903 true 31e0c160aa2560f0509be7b49aa0a9e864bfd5106f17b0f22ac215b3a5d71cbc +generate_key_derivation 9b30fdeff384d21fb54108421445ba57199e0c92851e63584501739d4c72f7fb d4ef8f7b77babf0901f53ceae3a4d11e0912ad0c420ad313004f5ea66c225b0a true 80468e876055c106f17e4287a8bbad2cef7ef9b731a95e3115452a113a9dede0 +generate_key_derivation 56e467150e7b5dd32a4f18d00834139b5143a63ea80a6e566aa43edf1ecbb77b b3d98c43e19ab7e6d05b76d133f2d55cd1a81345710c8a700c1521207e32fe01 true d62213831b52f8be91ff89a0b0f42dc2aaaf0a39c6cd3af9e7f5bd2cc0dc7336 +generate_key_derivation 234677d88547eb4725915cb45d43508b5f0842d1c48f0f0eedd656f6efbb91a2 bc73448dd4c6b724a1195552ab8e55d5d5ee3f407475a7739d09b222ef55cc06 true 45b39ceba4858981dfeffe5d43f41179ca1fc983c0d18ced683e4f8cab010226 +generate_key_derivation 02080a4425dcf5e4fa760aed1d88c19fb4dd685b382069c6c73dded912fa4bbe d5881b4badb977a0e9f00fc8c128dc7a6d3e1af6dd9a2a9e5cd2a3ec7c7ba809 true c28d30a4fc0e82497275e1d2fe0009b8e7d5aad0623e88373df477c583a570d9 +generate_key_derivation 7c8299960dc6d8a8dc26904e969e6b91ac5c56b30d05633d9d5bb82c96b7414a c1e407b78f36989d53ba69d10f9ae4a03686083a91892933bad8023b09f7cb05 true 266a122b5aa480f08aefbdf80418dedfb50c6fc69d54c0b18ce548a131126b12 +generate_key_derivation fc47857f7307f3856461b0d8496aa6979c252f5b28a0b0fb351fbab9bacea656 18646b3bdeff7cf47a53b52eef452b92ed54c99a14fd4c05dcd0ee7ba1ae2e02 true 2153ad86a762fe076d94786168e7355ef41c8a166c01ae20fa2e5616f75473c9 +generate_key_derivation 1b4fd6368ce245947d8ae45e1bcec52d1130d6d77a4c16303bd882c6195e4900 08541ffe563c134ebb1eb8b9c56d624b44a36d6e01eb502dd2fd1b0f689c6200 true 79f309e40571f0cae5b40c0c2ed2daf77528f7a407cf42e0d3f82656712e9d3b +generate_key_derivation 819262169617a2c7c37bdc10b6dbb3d1ce9ae6a14a2cbdd39c726646190d8990 8ff77533bed82d7e887665e47ccc9f42b2a4f8e0fbaf96fb2b611d213630ea03 true 614e3c6809548ad900d82622a6223c439947fc2c02a08ed30c7c2a05c8ceee97 +generate_key_derivation c5bd09f316254e3eac968b6c368937dc57b48fd6e27a116acbb8471bed50478c 7a4c2a13b6d14e44f83039c64d407b1fe9c376453781da0f0acc2233ec9e3c07 true 86ee085d476bdddee37bef26ea1ddf07c2fe29658d9038e83a2b507ef8e04384 +generate_key_derivation 6f4b0d5cfceaea59ae0da758565b674f42086f5f22e68479a7247d04828fd64e ded3dcf2d1d69eaac988fbc9ebec0f4ebc182f8d14b7fdd1e076692a6fe98e07 true bb6082656f4641885f4e448c64c594190e8a21b670cd1d152132e2bc1a491d06 +generate_key_derivation d875a37d7ffe687d74dcbcfb1d7b48812c49505e322a43568605b2219a8047b2 869be2bc50c3f12a5c83f0d581e6d5585391daed3c651e81f69868d55e6d280d false +generate_key_derivation e667e7a144d40b9280026dadefe7bda1fa6f897a03650b2ad842ec2c3e30c782 4603512009eadb28bc4ab49ee9693179b81d0fc10af3d11ea7a1b3e8aceb6b0f false +generate_key_derivation 570d215a4095e43440c21373afa30ca5c9b420bbc1530ef029bc6225944df7cd 8a2bdda64e82f5e2844dcfa8152a9afcf8a7839d845de8b0bed61d5475d8fd09 false +generate_key_derivation ffc0ab99873d7e9e0f650f9c7b4ac9d5c371d584dda752658cc903b6cc0c6271 697bd39b460702f72b0a56adff6ecb92c6e3eafaf3f6421433f688aea9958c0e false +generate_key_derivation 7d5c23fd3adc8ae0c2b015c8399f356d8efda2aede07c5b6175592a101da7828 750749e8f32e0ed80082690cb0b277efddd3f8bc1192327aaf54d527df01fa0e false +generate_key_derivation f6b57fa88847f5548dcb4f476a1d3ae6c1c353ff659ff60aa7ed99924e5dc38f 961dd461b5a2f7990c70327a3cd6ba99d179dc9d9691b14624b225282f0dee04 false +generate_key_derivation 3231c1c0a8f4c0de14322b39bf5433983d5181f7f5128e2fbe91a0465a617605 8d966f300402e58d4323c6bcc2738fb93bf06fe09f0b5f7e28f1452ad14c7d00 false +generate_key_derivation b131dbdb697fa110dcc4e0d6ceafd8d43edd106c4e6ea0b40f294417feb04f9d e67826af1b54427919896ec7a951439b15138f94757c1323c8484be3bd677502 false +generate_key_derivation 6b3e67802e7d10801ddd43995d1172b0948ccc71f6ec9ff75ed0cd0ae712990a 679365dd3c22a9148b76516a26d66989dfe66781e51605a9fce9c81ebae53301 false +generate_key_derivation 3ab76e30ff1d80af476266e4651c51891bd4eb5b0766ee396010f46dcc05af9f cc16040dad3baf707625a8520a500d26f852cb7d4b3794b4731aa9e1de273106 false +generate_key_derivation eb95833aa5f33188590153fd3c1831c731ee1906273c47b5aa8cf9121765df7a dc02d4fd7e11de09baa02b76e8ae186871f3af6c3ef42db57298556486adcf09 false +generate_key_derivation ec43072fe96a368d4de7bb6f93337b0a4370933a6a570644e88285920405bd06 7bb51c5a37c9ce199a83053af4f1295f25e0437db05058dafb088be11b60fb0b false +generate_key_derivation 10116c4ce44f04075e9bb4730a26ee54497f3d68405a73b28644804f39feaa8c 4edfcc845815fc9c4eef2ec7eb2b0b6f78036ad61ce4970aca18ef0b28f58107 false +generate_key_derivation fe8d72d42b2434e9be098169f54bb9406a099b0798909f35dc1f6c365fc46a5e 096b438d8ee6bbe5d186596935cd3b813fa31d87398412b73c26f91577a96109 false +generate_key_derivation 2dbb7fa128ca83963f7536207ada644b3507f2e86682683e6203f1ac19962ea5 54d858ab58aace17366113f34c261b9cce0138ccc6cb99a7f503956905189600 false +generate_key_derivation d145e1187736b3e2ab6548fc0d4c4c7273519d2bceae6eb6a6f96dda63d01b5b 1f87b168e5a1eb395be75c86936be49cf77262db475f2339698599d752182506 false +derive_public_key ca780b065e48091d910de90bcab2411db3d1a845e6d95cfd556af4138504c737 217407 6d9dd2068b9d6d643b407e360dfc5eb7a1f628fe2de8112a9e5731e8b3680c39 true d48008aff5f27d8fcdc2a3bf814ed3505530f598075f3bf7e868fea696b109f6 +derive_public_key 13bb0039172efee53059c7a973dc5f6f3c0a07611ebb0f5609cd833d5d25846c 1 5ca5429e836cd4172b7427ca8dc639f39c299f1b8e0d00f9d3f9a5bb2e49251a true 52e0a76a5785d12737dba717fd6c90e0e7d7a1a6c758543758abe578793c7a52 +derive_public_key fc9f87293569070b7e2e1be48e6ffcdfef370a728d4c01159b5b7b9783e0fa0f 1499890121 2c887eb3a891f60d9382b9a368f7d8bbd91fc8742dfe1054d1999e9f928e399b true 678c62af985543c426e90db94de447219ac24d8f3f44652003fe2b70bef54092 +derive_public_key b7884ba954056a2c33f2da970e4b14de9a9fee254d569e34c68c43a1835234c1 771 fd90bc87b73dfcc94ddd5e1b5090ee6537b4ccbe1fade2b542d9073f980a1db4 true dc9700bfa55175403c5c2db22d2685252504e4379e4fc169fe52e1bb8b65e869 +derive_public_key 75c4b56550636fa58f837511c8054106633b577654e80f766cc608aaefb67dd4 7040 6b7a50dc0993b9d7c96fd028153cf9e8abb150e461b25c15ba2c437e52aefcbe true ff8bc368609807c9d3da866ac660d8f051b6f93b2709fb5dc303e5eeca4300bd +derive_public_key ce07639dd9afda564b2e6322c32660e53b699ee67d54ebc223d49eb424f8d2ab 20 b4e4ca4f5c43f50487dbc6920e9928ae5d03963f436c7079e0d9d2eb0b9485f6 true 7aa03cda46c000b1ef3ab295cbebc9fa810ff61a1d6ea047e66269fefda6dd94 +derive_public_key 56130c334a615eefa750de8070fe8ae4848246e617f129b2edde5cbca75e114c 140014 f0597c388631978adb9200e09b18d25b35aea05a0e46c0e0d14bc5989e6a7826 true 8529f9337f53eb1d0d799fdbaa5e0b9eebdcbad0d31032f96ec04a66a897e9cb +derive_public_key 2e69c26042f76810429401abe64caa3ec47b1e74471d03db0ba6063bbe9c7806 346 23453f1c2bd5554b278efc54fa16caa3093af0769da74a8237b3af169c409133 true dc68ca9bfc041bdaff90eeaac63a78cdfd4bc6818c71dc52303f5ae13969035f +derive_public_key df1ca0206f51107cf684897e0f89cbd22d5159b1c6057fc6c5b0e6262da994dc 251484 7f42a74eb18ee343fd15a7612df7b01ff4b7864902d2e91595699dcd6c891630 true cfe705af5da71ea2cac4f2a2eabecc7e9a16abe9f877f37310f5eab469e735f4 +derive_public_key c6db1162829d011ac154927533dd26886753294ab76429d6e9283a75e9231447 1602 1c642afe4d459e113cb35fb3fad3698fabf578a0d10bb2a9b7a85a5905734684 true 99f1d50e2b991e5397dbb17fdb9556b2622ad0b293af0b117ae8f4b862e662f8 +derive_public_key 71ccdc0dfcc4cd544a0089ff9ce397093cadab17e0ec1315d96bafd34bcfee20 1932534752 db8982d284ec22cf9980eafa25f880bc76160e6339cb9794b0fd014b5bacac0b true 3130b8c7908c8749139bfa019bec4356d60338d615751828f6db4b96098be4df +derive_public_key 300f87ead806f6472c212a3b0fe6d95c0a89205a569b7e7e6be8d649c7a80d7b 406 e5d2e3ebfd532538c8c1d88f70119b6b44bad9741feceb171737ed57166868df true 39aeb0b7504d6560d769ae199f1ffac0abd04f7adf2105dd28fef38b92a03170 +derive_public_key 274d400d5d50b0eff28ec06f5095559cae82b1c36cbe8849e220ce862fc2094f 54487 3c7c321503339d2bb3142b62205d6086e3162ec39c25f328e9ce201a75b8396c true 41e405c17248b9e48fa58905594082b51afc7fbeec316e61707f3c95ef3bee50 +derive_public_key 00ea2076ad0031aa619b50970adf702949c12d74a3e41878fc3174b0def230e2 1016638478 98faee6eab619884703c0f0ed86f0d93ea87d07fe2f56bc45988dc7c94917bb2 true a42e7c20a70332f501029e8b3ca45caa58c1e1d34b15c0f3160340ab15a28fb0 +derive_public_key 0e0cf6c9523fb274aaaac216b9b95e803493d93a150b22d6fdbfcb63b5d31b83 54398555 3adb76d95c63ad3c405bfe67098ed4029cf111339a7c30deb1436af1bfc46edc true 238bacaff6e7ea62c6b796317d7a57c20cc685c8b52fca0656d2009db607b1f8 +derive_public_key 58fb9e9e9bbdc6df94357e944c64b557d602e0401d05d00580133ff99117ed63 4157739 7c239382508b2231d5cd922897871931c8ed3e142fe4819c28820cb071784a7c true 55d4163908bb65480a54ca644b50de19c3f2c3ba7f5c7cc6dea26bced5cda1a0 +derive_public_key 0987ff7e53106fed5a4f5ea28d8dcd2c211472750af73e92f25669026ab8cf50 442057 addaff8158fc9c54fb33b0ce826fc8a87ffef4e0e8b960eb99351a84711c1e73 true f5be756a300373e9d93f6fcc3c84642a973227a8974882ee5ef9b8905395aa35 +derive_public_key ffa48972240ad7f6e7cce6c6dab0ec4f4cf9e39dfa27e66572a5da69a8736b90 1056 bd7ed7741ae53419834a74c3f6c7661d9e8b0d4dd0b8801c193e534a8406cc7d true 4fa5c1b686b92c8b0fdb653f57620b13ef942d526542bea75c0453135fc66dcb +derive_public_key f93dc0dfcf4fa1e7367e015ba94c24dcccd9155d1f01175061dd66ce5abc58ce 1021 234805f8b98f92920c74492ebc38ed6a265769dfbbe31317222f9e1c7d08f41c true 6dcb9733f0f9a9cc5a670474c7f20f6622259da3099a660202dd62ded03f5da9 +derive_public_key 29001d6c043e5b2d0992d581f908942d6436c190d93dcdbf0c0db20ad6cdc474 6 0c43b24fa4d84dc7c79ea7cd7b7f75db23381ab66303e56449bf5f2690a19a33 true 74dd85877adf235d6e1c088f31bab25ce777a32ff898dbdade14a9d85d4a5026 +derive_public_key 20afff49df7d55553b04ce10337e32840650e0e1ffdf5be0a53e16957cd10020 22652 4ce07413853b484918d76a9434eb5e8f59b3a81f0dd551b76ddc735fd7d4f989 true 88469df03b5bbbd38b2cac6e49b1aadd77ce6acc6564ba68f16c2478e37a99f4 +derive_public_key 1257d0faed8ddff95f1b8d04c5a7163bbd1a949a02d9d158d220f3a4ad8d9e07 46545440 986f5e3edded361227392b5420c1a2e2c6761e5d04eb566b0118c9f2838826b3 true 4cce48fd43821b6fdebc5d6812702687316788f71ae26afa5d170ccf2df7e22a +derive_public_key 85674e2778ce2133e39f47260ca79bfe98b589696fd2fc3985b02080d4d9f96a 6316 1306063fcd9a20671c980262e370f264fb71300e5ed24a0238a20b421bda0bbc true 8e5da2caaae842ab5ff8faa1d89be9422da5bae9d36f52d789b7d1cab724fdad +derive_public_key ef21df9b78a0e5ed581300a8b4ac76ae86635ba95f13223e38a914d4fe14a406 29297949 2784cc6be0686ffa767a1ab36c16097801cc01e560ad58023b88400eba2fb2be true bead80b5cba96370ccbb8bbade823ca98d4a17c7578146d26404c8dc4f820b25 +derive_public_key 73520c22bdc0131d5028ae20d57c532666f3c1b77751632fe5a33a4bd6a23722 201 22306733306e6cf0a29dd6fe9459769c16f3f2abff4d7e6f7b4c8ed6bcd665fd true 0e661ae518ae2ccd1841276d9858001677ef3bb866f644e1c945f66ed25524c0 +derive_public_key 381876482fddddc1729b1830ea4f25ad10c8b8846c4f2d4ea5fa48f6781d910e 1990771 d9d2c918e11245e6594bcfbf306aa8b2266b911210ccb9e6ab56f2c2fa340fe8 true e148965897db011177068e2330df718557d3b862447c380c5f7fc0f9c833eab7 +derive_public_key 78ef6f45398b8347a13329d0034f5df4fe3e679d4c3223cbb262bc6732f74f14 7 e2efef778e2fed1447b5ce0376046cd0cd327f5b1390679b08fc066a7ff0b2b3 true ba93790ccaaa57be240aa0ebbf559cc79a1e7e7d00d479964b92834f1596f8a6 +derive_public_key d8feacb8c500b2773fb10cb048232e2a00ff12e442ef9ec547e6e088a645fa4d 1052389641 138526b7f109532b0def2e54df0c80686e5d238b7494671e83596d71f73d938c true 582ad8692a11d837aa43ebd7f9ae5127fcb019fcdbab7bdc732e4e7d8ddcae49 +derive_public_key 7a524ea0d7bf04725a4934e0d6d0bbccf9b6b01e4f91d8833bde3fd5c796d42c 42277414 a5634d184ea8669ae25ce6fc3621b174dd4d17e9802fd0ce09cfd977a958d280 true b115ba912014ad3502ed3c2dcf3f4a8397606ab04c03893ceb90b14f8332b704 +derive_public_key 68879781237d3d9b76ecd5999a0e56c915a0c8824fcd7c77c291b52da0525edd 24819266 d7c600997d00a82e8147c4f76480a70fa748429687049ddbb5053273f0cff440 true d3221cddbab5c2b6c374dc41c1d8ba2cc1e76a6c08f576cae620be53cd3e9a25 +derive_public_key 703b0202901b32b0e61d1990cba1751b94225a9cd8afc8515dd777586a7870b8 6821214 9728562c894fb976531ffd14d29840e8c0a690ac777ebd4e7f9147b234cdfb74 true 11cac76d3b9e24f2b72bdc0c0bdcbf2835cd609f2856df4e9134a08bbde21ddd +derive_public_key 55125e1933919cc8c93b49fa87207be1c061c762818df88a7c97ba2a1f72548a 47983 5b94bd31f25378faef090d2510f013ed5d9af3ca7b1addd9e2c12b7d46210ff6 true d69dea003e83d0d5e38a0558d45ad5e29f86484e448f108435fd294e5884ec2f +derive_public_key b6bfa20833941c6142778e5919c44bbb3215589cddebea80212ae918b15426f5 1175295965 15c0b7e5e8f2fc32806f7db3084a94f08db203376d86bc4ccd0f0e51650e5b5f true edbeedbfd8b7e329d5a5a68bedcfc7eea5f6f6ce36314a22929ad9ca7d939781 +derive_public_key 8ba2cb240366f88e431af2fe7469b1fefe76167fce1c05a3c0da4c166372faf7 14234750 a49f796f281f7f03ab0dd9754e6a238342d083bd19aa4336c38271485dd66e1f true ee19f2ff7de9f267c00e37bf67effb991871aa8241d3d1df8644273016cebf82 +derive_public_key d0b2345a3a169d4b1e3d1db00c2fafc885e50ff8fb49f87903cc77a8ea2a48c9 0 17d5b0e45a00d6f31ae7b500e8ad454405a4cbd79efa43abe45f141f930c56a1 true d3074c4b6d085d7eb70bc358e09ff4b0180109829d9e66ad475d570142c16e6a +derive_public_key c4d825b6686d6430670b10eb73b03aed597b4c9eee0a3ab37612f8dabd0a00df 0 878517f4e229934df2d57fcebf3ec0fa1ec65d51ab7bc06e84c296db0b258445 true a1ad1974a20f9d91d9fa640326ed18a64252c8e461f8482bef7fd4bf739f84f0 +derive_public_key 04aa5dd7f8db8496be5f28464e1d1f80bdb4d57beb7d5f3822f97260851bb109 147021058 947753f6661d3af16860d23a2f9ab2ca3004355eb0f7550e243915b0ea823604 true de8360c13c77826cf715a532c768a3a21bfc4bd64d33f587ea362fc6eb23d8cc +derive_public_key 5c6c59da31e15a5fc4baf592b7be90753574e4a7e4bbfe552a5d0b02d35f1253 6618 bc056c702cd44c98395781f30e4a7022d88d4bbac64ece6d2c489ef240269d1a true 4484206ba54871ecb2383230e617d320d1e370e67febcaf1b051e6b1b49319aa +derive_public_key 5941dc7bb22b801778c0f3f61a789496a5667f9c9badf51ad3dca274ac23e8a4 36 ad9e2779938791f4086fd11fa55e2098232e9b37a51d666fcd2f09f084434519 true 69091d61dbd487ffcd89040a0a0967112db0fe6d890da39e069e9393a9335fd0 +derive_public_key f33144f370de65456d99b299867e5bdef8aeb564b9d3204bc7bbb9da2a6f5246 1106912 a95c77778d0747ef59f8ed5f542a71e36d0b3aa2166a56140fd5a614471cbaac true ba587084cc3581073ad183f2d2c8b4bac5ee83bc199f8c4928559f216d320581 +derive_public_key 158d40f4aa3fee5a590026b004e911531b0530f41d109b063981592508a797ce 2 dbebd8aa099629c14287575581ded1c1be25ecb094a7de2d148bb452e0db8467 true 022526ba1e17ada82b48525a6c9104dee11d5c43c51f2a4f05e74ad132c6c4f4 +derive_public_key be787871c196d98862e4b805703f67430691ffc8247ac76a6e67c106be126c2a 31 86f096733985cb8722619ded7f4e49bb568f586a1b9e93b969580c52a77f9176 true 8dea2d7021e50c7026b35c7987014700e51abcc937c76f4b4fae7e2e76d92494 +derive_public_key 5a90360156387fe6ef4e3f62c7cfaee7201189be003049153787f9cf21a90bf1 3848647 82efde4f0360589667e9d7122e4e46e5ee51ec49470861132d57b2b9c6165a0a true 34300ca7ea0fe917c87d76c4fe5f3e2c8c084279c0d4b97b3b46677fece21c39 +derive_public_key 5855c02443fed5ea18d83eee852e7114eedcf08fd97110f657adc107c2788f73 14317 a33a103c0c933a37d529bd300cd18b7cd07431a0394a6fb61f44762eaf208ffa true 477d00bb58f3de750e034b621712a731db9e4747b159e0f7832daa53fd21b18c +derive_public_key fa386e7052fc7f47b284dcace115a5e2b382f79466a6d7c1deec3f05faab4885 703934379 b3dabdc2697d7c86ebe6238d0f0e9247f0e026b5eaadc74f6cd579ba45770deb true 844d1fa66eb8737827360900bb5c7549645727c1e62058f0fcb3b951b848ed2e +derive_public_key 417e3b78e5d1a7cd0e37d4b56c6a0401711e4c14fcdd64547168e0b0d6836dc6 412748 6e23e0bba7ecbc7a93048a059b9d55572527cc591ae7f09028268bc9f9e6e513 true 648af44c969df069af61f4f4c3d1a71f5015af63be4837a23fcf0849241bde9c +derive_public_key 2166cc2e7e5894048a5bce5edbc27a2f2dbe90c9102e3bf78c30380b2a58267c 252299 ae19f00b23b5d06d8059a0f0a44e02104d63143daf25d4fbe7cf9ba3f8a28ce3 true 415b8f2ef1c246e0fc23c9dede25584a96243d623ce2c2df654de4f546de5e86 +derive_public_key e1033a934389c6e841fc4b8a3ea6915933a2db3055d5cce32fdbab8bcfbf2ab9 6 e9e3895c54cc4d5c2794e213f4f37cded018a3b47a4b040a7270961c391ae173 true 5ab8bf2f4cbd77edb573a04a0a4275d85128baebca119ed5a1e1daff5524a27f +derive_public_key e805bd151b0fe9bb3b961a939368312b9017f3fb7698c98749be0567666324f1 68908 0d191cc34a521e4c830dd723cd0cccff2a3d0c0ba8045c6aecaf9e38a0a1b482 true ba52f320d446c1d32337f5170bae7c98a53ad359d5cd733c4e106ee9b79e6d3a +derive_public_key 85eacdb3cf8d427c374057dc8db39fdc0c7e0181872cf428e78c17981086d596 3362696 abd7b557683aba67e184d389d59499106ac93edf31755a9ade49e7463ef4bb69 true ec5143e08dd26bfe706684f4825a93ca98d0de39c17ac9cd922a80ba908e7682 +derive_public_key 26abb1d45a4c34018dae4a07f6973c64e69ed949e7f3fa79b024a094e8261ac7 2043 7bb947f388a9f79f94bbddadd26f96c24b8e1a75dad4a60df08553c98f4de639 true 02dddde629befc3ef4ca2526bb7965a42f316517a251d92a04c02bb10ef70ff2 +derive_public_key 2cca79d9692a4e7773a1c781c410aa5a6510077a1c208a8fc28fd82d6a7a219c 150070274 7e06434e828afc9b47c0f9000fff10ea6fe32296f5b9d41d0d0d7cb92928fc70 true c4b597bd4b3387a351faa89b8719af8b6409e251281030627f545cdf6cd3130b +derive_public_key a1a931287dd6a065dc6e3248895842ecde5463b96974985988e0475dd94892c1 89998870 797b1a55954af6aad350f67e3b1dd4aea1ab3cb382c241130be35c6c0649c687 true 906b3c37bb60ad7f4a215dbbc49c4470a354fafdc252102da8d0ce90a47074c7 +derive_public_key d594ed51e15e6c039b8ddb1e2f079df966b7027a3ae7b536e6eb357c5981d79b 2617438 dba37d2ba339a2202de7c05d830028a27261614921c0c31beb8890f4e41c1f9d true 131cdaeda058df54fb36a1c3b3a7840a53e2e5f6320d5d3ce7f407151577a120 +derive_public_key 5d8f968488bebeb0e8569615ddec32847dcc71a534fdff2b3198ff4682617c0a 4642 ceeedcdd1d7bf7ffe9e26e00293857f32d63734b87d1f946811125168869b934 true b0f70950ee0c62930ad3a4cf4830d4ad653a20b91af7f909fa5d89849a9ff3e4 +derive_public_key 060f6a212ae39c06f20d44ec281dd39ebc3a7f998e1b17d696ae4e9452b64b9a 5 576a8cf8a1a02e8baae96bfbca8d455c9d646afab5951a1296500881751baefb true 5a526c87c5a4d822a3b442c1c100bcd53c7afb33e212d5f4ef153645253131bf +derive_public_key 0453ee211d2c2703f6dbbba07dcceb483170c0497467f9b31115880594145fd5 1659973 f6784f0693bbdde5b11be4c2b283ae036be61bc0629678df2a3ba04941bddc61 true 3e72a13de776bb7c5c00fa2ba4928efbdd8697665eabcce93703c5a663ef9785 +derive_public_key a89e0e2c038e1e9c733460615b4b3c6a83be23680e6ff3c31dd69838d2ef6776 1 94afdf35735ba8d93d3b5be4d112d69cc1e9549798e56a9e7cb21ad52aa5efa2 true e353dee00000e00dd934998612e609a4887871e2dc5a21738704bd75d090236f +derive_public_key 0c49675808b1ff0518d62846ec827a6764614874b899c4ed4f50c179584e3d56 40511 35213a207ee3f6e2be584b585cad52dbbb08568889c159d1bc8304cab36cb637 true 49a07061b9bc4e0389464cf19305d42a4dfcc5288e280da901ddaaa2fd7b4e60 +derive_public_key 29c20059323334172203e2367c55f742361938b9b607d7a154e5d0ec6fdada75 4394 df2c7bd994c48879809c2b6f9c147d5950c724a0da2ef719dcfe06575676f4a3 true 4408275eb595388d86e60fb2a35a565fb2b39ec7a7f779eb400fe4e112f2648c +derive_public_key 0d55cc89a646fcd5f98cdfecdf0a459f7eb762916a7d4a1e2e8ade415feaaef9 6 afa70586988f7050cfdb46459faeaeecef1768d92e19201b6e32ee2716ce505c true f1346fc84af97132c4e8e45ad2e3fb79793e12963354c308ce147528a6d2f8f9 +derive_public_key c7da638e7246a6585f3f571a0753c34767632e3ec94c88f66c896f29705c7372 56110641 6be3409f5dbc4944760d556d53ff323f4584e5ad6f17cce89610a0562872ba31 true f578a8b90208322c63108c59fa11569396cc8d11ced36ffadaa47fcbbf252c63 +derive_public_key 45ca13c98298ab0450bb06c77bb058ac156abb766882e89cc26bf89a59d40305 6245 94bad0d166603cdbbd94d5aeae1e7b87b36b46860c33cb5025685503436cdee7 true bf70b1e94754f7bfcb10d021d33b95b7a8f836acf7e0cc4247588856b2a8d4c7 +derive_public_key bbc7f092e459e4248e92eaee63a84e148a6cb09fdbf00bb6f7fb9c3c2eca918d 489372248 f47e081ab935aff4319fed0c5ac7c3564551b492c19198ccf2e60caf09ef9b92 true 43c0a211c23b121ea8942ac42301f5e0790225f6d72e2cd316599d2f55fca22b +derive_public_key 268d56910afd7d8c6ca9425619b10efee6f96197bac39cd14e4f6cf2289c9c57 852819064 1e24f8530f357b922ee919d8689a54ead8610c78ff50ced6e082b3149ceffedd true d275c9c444fab580c39205700ad80f57ed95d1b945b4714a0bc9ab2034dfaff4 +derive_public_key a7de608aea11d8a801452155c031479e7389c0bfe821ecf289d1c7b2ee1e7db4 3 ef7e370ae4afd1c4392a4800093a76d482b447fb448139a1402e2f4cc78615cf true 3be92a2090b62f620bccd66dd216b86fe621715d0e42b3507a5a61707f38eb7d +derive_public_key a79d6223c77da11dc8fc95f9b81d6f3b562715feee24b71a680ede8c4fec10d4 1 51746ef4ccb8f0fad32bcc284b383b92f3e0757d8dc2eab15b1e55a0f023dd08 true f01a5d165bcf0c8d334279575354d7adb26f5262c9100a57b3cc0bc2ea508a9c +derive_public_key ae3eb0f9896fefb748acdbe5be988ae75a50023d63c96158f481a8287900bebc 18855 67a0e3fac4118de3c10856b922f1eac3f4c7e0344b98bfe645d723d623c6ec5b true b161fdda5f0c168ea916a14cc51b866bc658e490ab4b4697b8a0eff1f649ddf1 +derive_public_key 06c3097b063d56e42a718c0eb21c94dfe8f48adf958bae78154b0226aae89d10 60377 23f0e6dc1f310bf50bf5271e6eef32b7264af908021e03f72cfae40b11d54bbb true 6804225ee06df4ec92259f121575b329d7c49dc7da80b9c56fb8c3c8f3b5ed96 +derive_public_key a315c34d0280a70b570dba2475123f1117e45f860624e3334817c39485b9a4c4 239568 aa92b8d86774dd4f156265b8fc5cf3af977220613acae296ef08b73b4bbedf0d true a92d3ad79427cd6d8574b99ad74e35ce5e7b9f6263db94543244f8acdbb15f39 +derive_public_key 04ccc1145f359307e2d2c323afb4d4f1b557a1287375d4dee313fba57740132e 1910 dbba13d5bb026d1ce2059b0d172172fc505f60f4e48d26057069f2ac145901b5 true e7db3bdee7c55899fdd5d664c133fec809fe9aa58937a1d395d150e9214c2ede +derive_public_key 752b0d1ed22e4a5461d255293a4de7ba9f03d784b37663d1871318a5270842cb 1527 aeedc4e054f7dc2cae077a5d983bc0e10bb4597b732b9ed45ef14ba3b30f1de1 true 249d5bc5cd52000241b2f52fe502068b6b1cde0e188ab52b1bcb993f79b60c37 +derive_public_key ba99e3a1f7c5155617dbe674f3033ea7ca948850c0c614577ce0dc4e8c33d033 3107408 9e72656a301e7237906be8794142aee04696b363f808a89faaa7df45b0b5a152 true ced6ab10c3b75bf7fafd466677a60e99b83403b23e4412b9820df8d8c7d6bc95 +derive_public_key 5a6dea81bb0ef25702b9be93d19f6a6b7f0522cb17063224bca62fc523b48d24 376 eccde9c7a2210fd2c89c0ed1f6b7ec235e4f2651beec3db56a2ecb178c03a7c6 true b6284fd56965f74f6fdb7b788caf26d15f37cf1f8bad30a1640f4a278717b966 +derive_public_key 000409690469fc8c815d7f3a1d42534245cfbc4fc48719cc97fdae78cc1b1f4b 954855 6ece34614f1cf23d2c00fb67cda93058de81b6f9d538a68ad890d734d4722639 true a68e98a388afae4d6de2ce3367c93dfb93ebc258c2806b87c68a4ed8578a7bd4 +derive_public_key 5e5baf7d42cfe451b5eb977d8ba38769721ece1137e827cf262d9fa38aded222 230250245 5e5787b81ec1db4d1dd9e7c0cdc1cec9b8f7eec9aa3ddc0189e346dd3d9d2d28 true 89303195a5ac337dac81d6e4d07f4af0d87664acf856135113a72d3615f98bb1 +derive_public_key e0ed10403f3b5ecd8c37b20f3147423442cabb494d9c9088af0bc7d6e3ea98bd 183408 33b89a625e2066af01d4e3c641f34cdf280fc0303c7ddacddec71f6264b006c0 true 8f062c50718cd4496b2990d0985e373d00fb3354ebde2a1ce0ad187eaa09d54f +derive_public_key aabbf6de17268f52f911d6dc47011ee33b5dd4204746479b62b0d572540b55f8 19911 6f029fbe5d327f959c96e5ceeea1b07bf8c09098761b6ef7306e0669ef5f9d36 true ac2288dfc6455aee6694b6a0aa4684ed2e287c42e83ad85c6624dc33f7030651 +derive_public_key 8c7081026bb3b4d0d23dbf3d9d1797ceb742aa9aa42d88e6f2bf2377d9162949 150843 c15e0bd1e8e03121567abaaafc11e477aede4dfd01bc44e0a00d54c25ea06ccb true b9e2b5d59b2d62afa588f937da195fe22d035265a0db53dc46d3ce709cfffcc0 +derive_public_key e839a9c004fb7af2f437b07ba95d311f77c17b63e390d15c893f4cecc727a79f 28119281 62bdf96be18a5cc6171f04bdb8c77b28f3e1635c2fbcd317ee3672fbd396886f true 6adb6710c12bb4d986493aa2a76db9e945b45166ff18863c4b53829ad3bd5850 +derive_public_key 95b5062794b55138d3f3812801313fadf493ccd19967e7aa8c06ac3dc5d239f8 31 ae054a153d38af269392f79e3c9e15f95afd28b8d0ff743c9e5f3032e929f87f true 6097d66900a0a5247136519bd8cb751a6c7d91887bef7e723ead3efa7bd640a0 +derive_public_key 71ae7902a197c2c517a781c3abeaa1a2883b1567911f0360668f07cb28ec8a7f 316 4e6c4ea8793e4ce9177e3cee7fcd77e1705ed408db26276aa7f808d7caf58fc1 true ee5ad1843eb2020dce26135da5e112702bfd56c38fe39e5a93aee2112e77e85a +derive_public_key 171c87bf78a3f6ef344b0b12a11ed7323311e682828c84ad0b528215cc6cb18f 444331 43ec6964315183b814dbf84f0e8a2711d2e1029918a673c7c0d7e6f3627567f2 true cba2c85b954bd7774d19beeb99fecbf91bd396cf769e04d7bfdc9c3a9871f174 +derive_public_key dd89c3f4449ce02cb5351c13a2d92cbb6fe8c9ba14e4d8500dd14c434b42168a 135579 16d015afd01eaea9b0d93ce4e206e2c05c78af3570de5968d87d65e63f33858c true fbf3721ef6f6a2df71c2928a485615d8db23af32cbacc701a16f0cca74932329 +derive_public_key 3e3396dee36ff46a8389116337f0f19eea06f4ce2a0898f3882da563d08be6a3 4083 d97effae33f72f1b0cc749c5cebaf13438905e028bf2ba6536b2f35c2516642b true 70e5bfc593a6cef84b43c40d2fb608d0affecceacf2243a7af3c168da01288b2 +derive_public_key e9ee36d5aebb3f9335d71c38cbd8fd10833e86fde8b17209459e265dbd3d9b78 639 c3668443f2ee9a4c51fe68d41751f51d8107ff5ff2b25989279e832fcfbc7af7 true d85dabed65cd765640c57b5f1440185ee5c9574d2e022d2bfddbf8b55e02c64b +derive_public_key c5b92a2a425074ca86176848e4550fcd996df8441794662abe4cfb5b616d2525 11975295 85df767b22b76af2523d2af9292e305b82e61923a604b277d5958321108c0809 true b645f9f1f8114cad654f6afa870fe7ef7f55b659b6b4689d1b628bd2d9ea5437 +derive_public_key 04cda9b16c433ae5655c7e94c0c5a4c94b4fe6c0007b150e81463574be29f3ed 56508704 d2c89c0ef56cf18bf5a6bc02cdff8d2aaeabaddf7ebcffe80133be18e96d323f true 69c018c66255ec7f803b3efb2ee68d04c89fb4911003fbc9dd3a6c62152b8777 +derive_public_key 9a36a7d56f16ab19075e4b8610dd08e17ea78362cd0b0d66e09a73475d4aaf82 8716 f52cfaad8d2e6916e78e27e873706eb2eecd5f23c0f573e82c05cf2302c86385 true a155392f300540055a31425af6df789283ef708d0e2531fe729a313ae4eef0cb +derive_public_key 74e1f76ea4933cff4eff0ced72a9b860f865a119f3058538c941adf16fcbb370 648 a5cd1453e683032b34ef56f51cb5e52d79c9c8a8d7e32cb61689f7b8bae2fd69 true a999772c1d0403f9d4ce6eb5c99212a1e93118784e6da3365bcc34db7eee344a +derive_public_key 97e243ad0cd2bddc4f1f1429770621aa9e34e880f574144ded8c38d2daf60ad8 95988 85a960434485bf0eadbbe36217de33ab1b6304dc1a44848f7b4758680526ed2d true 9864ac7d020fb1b897e76f63b9edf56310441651ef3bb9847acdc1d279f77afe +derive_public_key cd806c53ff3fb4cd2ad8472d1179f450d12014ad9aee13d793d5dc9d4042fe79 3086 8015139bda184cb0add1ef08b3ee99154acaee51a0bb4d9a28cdd31d368c4359 true 864fea7b1e9b882fa7421a30ed2bde10222477a367384271794d2b5e952eb1d3 +derive_public_key fd48101a6e2d93ee15d32b9719b9f38aba008241f3e68fef0ddb950c07138b88 100 ab4013ef8d9f70243b4da4cc74266710f3985501d2cfa1b987a96c77630ea929 true 753307aac92c2490c462ef982577780d5751f81da2e8f3535ff8d7dfadaf5d95 +derive_public_key a57fc42e62d897e0e45171a85d087a7a9486e15bcb04fab66428f23dd89440a7 2332467 7d652f09715e51179eebf78ed50971fb2b7abc45ff606b02bb72bd83abd2b982 true 77c996b56db17dfee31bd13503a97e7a4af50159c64add77ba4c99c6a4423297 +derive_public_key 4e2b9b3697709738a3d2a1f068e805eacc516a4997693ce3a27de74e93192660 104404 f3884e42f48e9ba7152fcce58ef1be2b5b04b8652943bfa00138b9f6f61a61ed true 71ff1c52a52a0f7dccf09bac6d4a8c3b5ad338e2a9dcebbf2a443a8267059bb1 +derive_public_key 9c49e0d2755a3ca36097633a221613ff396a9c22586a4c8c8bc3bec42b8e3d55 0 023b79fa050d0be360384bc50291b9f1ae99052b835f785ae87136ee7337f363 true 233c2049b915aed129918ffd1e0277899d771038c019c822fa940ed6e4a9c4fc +derive_public_key 1d256ea284c0170f024a58c8ae5f644b7455ad0be6130b617ed835b80649b9b0 0 c39fd74d65fed12c44ab3d588b93c74d75c7d604de28d5ac41382db38f245962 true bdb293e3715dc4529f1d225958404ed8c4b5fa263052e4a444f2ea3bfbc22849 +derive_public_key 22b922e51a4d3117ed4f17705ea579fe1ca1fe5241a2479ca5831f95c19b9f80 10507 5e55b3e43cf5711cd9b0f6247e1950c7de82c94335faa6ff61fdfc5b22f1142b true ff43d5d40e16642459035a55c11f0cae33f884d6e4ef9be3d559d867593c2af9 +derive_public_key f791fe032385fda4031bef914dc769c15375fe0cb2ef26f24e861e0700cd5027 7570 e08c6473c49d3834eba536d493624b77dfccd29d7e533bfd9e6c939e842c8691 true 0abc65ae43125b1a8881aabca88085990367a499dbe5bc92139c7d9985482bfa +derive_public_key 6fd67211155138ec11f68b5e44e1ecafdfe9693f37f7ef0b7db42b75f560d41e 1411028 3860642e585ccc7dd062e50a685bf31a7e94c4dd26dc10347c25181163bfcdb7 true 11647baa39ec081c4097eaf4c364b7f76b6555d22c6e449c71839f97bd30ebd0 +derive_public_key 54b7c02b40aa8f73cba6a4951049bf1a3182595b2eab4ae5e5c7026f97dbd607 318 5176bb6a7489eb2b7664bfe5b7d17c0b170345e2d50e95b4709faed0b0f92fbc true 65790b8cbd3ff6153f70f3a70e1ce7657d39d84e95468e0cb7cf0334b11f706a +derive_public_key 1c09e1829cde5d41591625d6d212b2761c47199bd7f2493738093ad1098d10ea 56 133d23a7696007a185ff0ea131276b18a92b5cff76f3963e399c63f275d4f3d4 true 8b3080c1d5b6cefef08687402d1371a7d6a840dcb925140e9322af73369e9263 +derive_public_key cc3404a6e9b77ad2a2582e6a6ca71ee17aca4d7c14d033c300f27aff529c30c8 0 f92dae61ab4a4a644d3d9cb55e7747b6fb565f5cc5c26e16ee576ca2d1f911ee true ca71ccc7115039d954100a5f63dfcfd4bbebb7712a88b367d158da430a9b2d3b +derive_public_key d449990ae0e408c165bf7638ecb1feea3e1a29cbaa6c6111d5b9561b1671e497 21474957 af5d7051df2df0eb98ba0132f6c0728a87bfd3f374ac6e94c8e05b557ca855ee true 0237c91660fa77be473b721040396be538e7b04c390ccafbbb02bf7becb50099 +derive_public_key b3b92a032578ea04204809f056d5594c44f752ff9b9ab0e6cd2ca253b9eb77fe 246 71bce5b13ccc71bf8ceb29b07f086cc05b539e161b5546363881cbbb3337a91e true 89067f191e81bc5fc6e2a2c0d44899dc8f7a94c4813a94aa82693367f2f4961a +derive_public_key 9ba54cb9d5340afa5289bbbc603f0ddb7cf7ba8d17d308fdd17a9b0e81bf0f0d 15 17e5c78544ac1013e9b9ba20386401d912c46c5d51d19098c1d28e392aec6422 true cc5dd7645d111411efd3d3d18330b5c0a4c46a5c1821ce07312e45b850f6cfb6 +derive_public_key 449f643578e4ed0d05d3fe0c022fad0438c2fb685ebf39b3518dc28257e57306 2 0fbc9e622060326e6412c0665ff6111398112f02bcd896b7980225c82e2e01bf true 455389e085d19b53f9d814eb4d8918babf8cc9f6ea3e7dc28f017d4854a0b979 +derive_public_key f609b13d0de28bb492b5779d45a5909e9370d029fe97d6851323b82c5c147354 171639 b932cae35594780d217942a7f417cea71b64907747bc73a2ab240fb865450a4a true 45e062db72303a3d00bb11ab18a4141347f7ca4291bb467cd97666fc8cf10f16 +derive_public_key 59e5a1ed44d87e9a5d598f6ad6cbe005a840ae0577cebe7bb719ac81aa227507 87 ddd9f66d0a12b60fe4cc5ba405165ae8bd1cb4fe3b9415a7847bdda73f3d5cd8 true 0d13c1efe4b37b90ccca7c960fc0577fafa653beecc5624bf696d189d0f2e8e9 +derive_public_key de99fd539e9ea675352cf47eb26468c25720ab8e4017caa4258d2cd9332af181 0 cf42cd543741b41d6a983d08bf44b971885cd5a0593c74ab008c4aa28ce9959a true aeee94196ef1a0ecda5e7ce5909dfa3c62d27d0c862dd547f5b5df18a0ecfc76 +derive_public_key 145589b8e1ded2ad39c22a8e0cea067ad9476b267021b1613bcf4eb354ae0e43 0 80796da64d350c2c8551f21be369674ca5aea6893fd30426755a9aca5098bbcb true 0b4ea19d5030c1df5314cd7d78f73e7cf489b5fc36450fbd2a07aedea7292a17 +derive_public_key 004e01d0793bc3dc46d5d61df5ef11e2c1dd33365c4975d14bcc1ddc1a100da5 1780653 cc0a5ce0d6445040a284e9c15cd06eb41615dd3a1588b32e0aff0728fee85d8b true 6d05d0ad8412cd8b22bd52caf43082161c285d4a7c7c3938108fd50b7e983ae0 +derive_public_key fda38561aa8a3758481704dcfd2f85319b24a503db318b1ed1d3a3b668dc4dcd 4875680 8452487cabed963b2323aa031c8835bf511140aff06973a6aea48332cdf93d20 true 22aefc0daabab2711cabcc5dfcb068484d2ab06587907d8c41622bdcf39dce07 +derive_public_key 5520038617820618fcff4fefc59a09162b8736025d7a5d337a094105381a366d 0 6dc44f79046e1fb1cbdc68bf936f4ec6bdb5b1f47458d987e6ecd13d7939af42 true 26e1cfea8d1156242a4a60fd9bf0b1f5879dde9076fac4e8a18662be63f834b2 +derive_public_key b32abaf342de43b086dbc120e1af6b5b30629f6503a2bf0f7b783685d0e14cc2 36643 2f5a4d5bedd21c1aff8475e3c014e8a79077e720679c1321297b15a9bf865282 true f843408e7570c92d472d49cf464d798f199a6968d1a584df72f4b818209bccac +derive_public_key e298205c1d71bd93b80cb7e7fba0a102f3ac7753a977b2126333b5ed1a0f996c 56 a37fdc5b235410c62b84a6aad7a77f63abbe828e825f0c71caebc26dfb61f381 true 29cc6dd4859b4d52fe5614e8862672eb06ebd76f2a2358b0fa886ec2c36ba5a4 +derive_public_key b2a172ca805edeb619a7386ac3ea35dc214244b2420869aec2e612d67e0de04c 66619561 fda013485cccd83225ab71cf9c65c47f5fea887b89df49b5296a18f851122759 true c8ddd31fa10d8e8bd7d0e0ca44294d26967732874f65bf1d5bde0c8846ac1d5f +derive_public_key 314ee320b1f32d7d4541ed83dcfcadf4825466fd76057b63fd79e09c82a7e315 131415 cb5aaae9d7858d9f15de9b1d5dc30dc80bc534ce52b2f6f90f4aaf2cc1ad2811 true 087faccc36c84f8938f63df75e2e63f152e3ee596a310d9de27f6c7cc415c0b8 +derive_public_key 439f2f2a1eabcd956d9ac7050503b5350f6f0bc87569a59f9295889569b405cc 11642 236469c4f5a0a04debd6b1427c15cdb01d7cbf2effa095892c2e96da09f23e1b true 254e85040f399bd9153789100e09a9b98c8f8a7f8d44cd6457ae302543481e40 +derive_public_key ef7b81687a10259949f596884a1ebf8c64fc2182c769caa38a947040e9ea5e34 33 d667b6cb8fa18bb38bffebf5cc2e18825faa4a8857a81bcc492e0533a62b3276 true 0b46b243b83f15cb3c3c9f26518d54f7bc5da0eddf1ff6b3afdd7b8aef48fb7c +derive_public_key 88dd8f6cd8d5b3c4e58795a27bda469481c380d792498a672ca33b9d6eb7cb0e 0 e28702e1afe36dc2975333a64cd852d17227c7ba243a1c9fe82006b708ed2ea8 true 71090fe7354134f4aa9fd2bab0858e0016c70e04147736a4c7caaef2baa0ba99 +derive_public_key 0651b18767d86b222cd71967968c76c31f4e32069f7bc5c1ed13d9803381882e 98549898 f2c4149fa307a403e02849a364d5fb593f2b13b4547f70afcc99c1eff388069f true bada4306bfa81c2a18429b679b66422ef54865d333da53917f4b317f677f2bfe +derive_public_key d26425fc850967a191b8e3160400b9996bb8cea9f31be47543d99562b2e9ba6c 10 69c8c0263848713c852c19e2bb8a294853fc68cabba7cf0dfad01733567ac7a9 true 12452957ba5a7e6d5d8d9f71546ccc820c8824ce8d41e8fd42471d9a088bde47 +derive_public_key 71e28cec80da5e8c0909dd185e889cc613521386c58a61065ef1e35309eca8fe 52115 808c702a427ad987c522fab98adfde05e064228be410f4b353a36c8321b25575 true 9e8eef1c1d7976d72fb7bc0d6b810025c986c97bfc04309ddc4041e27b0a62d2 +derive_public_key 23a4c790b855c63b6f1f3339db74163107f54ed9e7602292dfdd11a1ef75749e 837306311 d1a4cba7c6a911dbcc2773da7393cae6938714042051972150abe2d2fc14ff8e true d1f428d86dcdcd72e0ec612f8e3593e63c19f58abf04ce6a10d2987e22de78a1 +derive_public_key 19ffd2e07afed044b788c3102cda770162ae961b23e77326d656d42036d45f93 5531699 9cd6f5a239fca422bb1a75e8ff1cd7da8d7478af730a93633c8987657730845c true ccc1564c85c181f1307aa053d63349a5b9a71a19e71681fee7e6d49445a4c633 +derive_public_key 8ca6e66f4b3e0988159b8527fa384a040f648f82edadedd483d0a836a66da9a1 12236889 3ed2c4a5de690392dbaa4ef4a1629efe4ace8486ab3b7549026bb4f7cf453a91 true 6a6cb4c303f15984f0961288d66c929f888ce740509cd34a3be498e212f383d9 +derive_public_key cd712e6fd5185cbc71289a295fed4b08e2edc3394debe3a8a99cf07a16ba8643 60854307 5f4b8c6af037fa13aa9f57a3bbba69ba038d159f49b91323aa0a1e7ed870c4fa true ed9f670033e5f834f2158e054e55e16f2e58f122060ff316439a036044de3a6f +derive_public_key e9a85c2c5b92a94d06245a84614f5fc9cfd0718eadf71c4af68bfe27a62cca8d 237290 e41ef77e59e823d24fc559f07c1d0d0df4b828738837db887ca1ad201be84ab2 true 59e615ff7943c184c7182039624ceb22aa569c25e692eb760cd1029c21c2a22b +derive_public_key ce03527b7a13dd8daea45387849e473cf5d7f6a764b8cd4722e27d830bedd1d6 41 fa99cb0876ad8ebdfa34b41b0de902b0982f5e06c58e3314bf2d2f19ec972a97 true b48b53b87678aeb44a09eabc975684caad38a3e523b41315d055cdd9eef7de0a +derive_public_key a20c7d880dc87ee67794e1a161f755413364ccf1495daa7f05e5421f273bc09e 2598 351861ef0447f48ac606c2e7fbacec885afbaadab10f9d895488b37de79b2eab true f2dd3749109b5b2832b4445095a8a03480f30692ff77ba6b0924128c64d5fd86 +derive_public_key 209cf02bd764de91e4a9c89a90229077d594484604dc27f6cc933cca339ab4b0 0 334891a2131b7e5d9f7f68c666311eca4257a0d19f6bbfbe0ca44020f1616257 true 8d61cc876b39b15dce3b82d0106b3e265c8e54b3ce914518ae42ece0138c0d50 +derive_public_key c48e85e0169929a38d9c47be76a9d55409b86596d3baacac6c4a045bb1fce5df 13341 72a0a75567928fb8862775999d0e50146ef5709f6200d04a2e3d7eff35138c91 true a8f4ada09f19a9faf56173858876a86667149101f04365cda54d43a0b9020582 +derive_public_key 6592249440f78830c112f3d1c4d088fab6940a979888e4c7e97d7b8bbfd98d17 48256903 c90fa1afe5a1053ed3aeedc970a357aaf9a7fd3bdc2ae9f9d722932bf4f04f71 true 412d2b2e80f63f05ef651a2373486cd029919fb5ba10a30ff25164b1e354ca75 +derive_public_key 1c273c7f24f69ace3e947ec668f0ba224ee8e3c24d129c821eb77ce32c18cefe 9838 ae4fa664eb4f95172cf69b30951d62e91c1b723979ed1a0dbeb8075b6f0aade4 true 7cfc41eb2fec739039f7b575f689b676059aef2601d0986605215d68adf275cd +derive_public_key 7d6484100529e7363eb6efd736f5aa2c873d77b856416a803cecab85e3b1cb18 35316 e6e686af066b30726f8b72dccb7cf6165d25830891bde55d987da7c3a0a86bcf true 1f3ddec54dd50402edc75d2805fbc60fa9747f0e36c684dc6e0e58bb43e53e5a +derive_public_key 9898bcf6c9edf8127e996e8ff0c88491a4168aab8a4aba87d9ebdf0041811dff 1229 9042c09538815c593a3ab5d91c6b687c9aa13df80d13067c667c9dbfc79d84f3 true af52f6ee6ddbe3d4d648a15418ad7ddcf5d97e400be3d9b2af1ede64b783efa1 +derive_public_key 58e985948b74e103de94b53fe6779415541174b916c99aa458919d5a06428108 14453 8b79b89c345e0b0d8b81716ca60cb2aabbbf22d229783a12e7f8b84be308702e true c5f0074c81ea5316ab97f5cbcd22b263ed52cfce4a91d649ddcd1079805d1f3b +derive_public_key 831045f9212b3c2063848e6aa88fd3170d28417c37524dc0852b340c9fbc1ee7 59014407 051d36f852cc914aaa3c9e25b2cd70875072e2d59f5ad0a8995e0db83d46f887 true 6d842644652d5f1d93705e276175bb0ff3e005c7e35986a6a1a50098fd6ce290 +derive_public_key f5c240950c628fff406ff0f2e4e144a321d9bf45d737e1e21932be48bfc42e38 2407972 7aba5bcde6b897a3d06bec50044ceac1fd7ec08f03d4711551e907dd909f6e95 true ed06cda0d44d3e1198a464905cfb28fb9ac467d4e0dddeacf8684a6ccedd286b +derive_public_key f127d5591595c4f9bfc03f405e65326fd8113d0a5279e751e7cc318691ed382c 81388 6d17b902657db0aeb8c6d4d25d645f4848a016408d5fe44aedd2355f9edbed64 true e5bf34a21151ccb08173b03135657c50f7a9a36786580d77019c4d1f8775ea8d +derive_public_key edd756484f7eb9da332fcd571e1b5a859f5eaf7d2c0c15ab399bbb79a7be6fec 142 5f71d35d48e80fbc4b9a912435bc20c90804edee809d1ecd3f333912bd707abd true 67b79c19fd3ac2e45cf1a108eb0e1a50e8e6e9e883c46f5c95d169d1e7e52da9 +derive_public_key aa2c00f3f49c19bd5e3d25a8d673a6e900dc09cde42db10302b6d7e8375a06ff 31648040 fabeff55cb911d56c30bc7175cb572982dcbdd6fb04e7ead65772e180bb230ad true 9bc974667acfddffbdfbfd6ebf7a3be18d5c1f32f512a59828574a0fcd0f0c91 +derive_public_key 79a13da77806a371e823cacde49088d1c101420c67d9029f0ddcd1fe5b6b2196 2031357050 569e4162b23267fae083d1420b762655af617e946703d1b836ed82d6d3e25d41 true 94f779401e9634f5835eeb2660271e2b1bc5293c5d7d0b0d34f25ae4442bd36a +derive_public_key 7382c213090e6d88572c2ab1f3a39dea6ffa4980b84dcdd25fe1b56045914808 333 5ce485cbd8819f74a5bcb33d3ac26ce5b7bc6d62fef90b096f69d8f06be97239 true 678441ea4b679da72b3be5b8c2ec4f21c50c2515a5a8f5c582cb3417dd3bf793 +derive_public_key 7ee993e1fedae5b9c202fe0c647d8913754528a333baabbd17dd69231de95e7d 667027 ea0871c048b2f6bfd8eeaa8d7c83027b55020db9ae325f145d57877f04a69696 true 487094404d2eb89ac9fec1fd455a105ecf693bcb841b92fb1d8d110831d7539f +derive_public_key cd803c10a86b76f4efbbe7e145e18dd1ed2a3e4c882dda468519be736680485f 11 676b8499ab870486ea8c1b4e8c75d3610fd3463d19821f093884b5d951634d55 true b20df0905080d05926e146c9ee07bb6715d5858dd827c727ce3c9fee8ad89db4 +derive_public_key 7820dc1a3970a9e8dab5f4d3a309153706fdb274d9975fab74bd12864a7f309e 2286 faaa405485d6c63cf4506842413a5e2fb107410805ae0b319b428eed259925d0 true ea657b8c2187eb5b5df9b67a120526de288c27980789100e1a135934f9c696ed +derive_public_key af6f5d4655b3cac2cb3b578f7747132e40a72e9ec8ace68f5a584f02c3a5e4ea 20376 1692a869a10a0720531357a4ceed66e8430028852764425e01e4f79303c90d56 true 4bfaaa2a2f161aeba55cf0eb236c3cafc344f27ba0e71e731d1780a983757fa0 +derive_public_key 6762678f1d50d9ecbacc071de8e9f28a8a9d6c86587303d3b574aa42a761b976 12330472 529b02b494af576a51c2f09170747e44d9d0b40235cb6810e237b24f3f5c557b true b52a13af4a239e65f7f629585fb7b1013f40a4a239d0712491a8119f7efa7f79 +derive_public_key 8632314ab9fd2fe5bb633fa6fadbce8c859e2745564c0311beef191a158d5ceb 54681 d8f51ba64efff85158e51a13c4799e8d091a8d35489d3f798a88a74dc0d3f722 true 2a1c86b418070b3530225722cffad8ae6da2adb9524c737620579e7ae59c4f82 +derive_public_key 531e8bfaa80d6ef31758004481de33be8f2fce1fc94a83d403f640e432b5a126 29112 e6383f14ecfc071bfe1cf3fc5d41d3e6d9cd7d7eac1f22821cbbdd0f3f67a2d2 true 73d3fd45e8ef932dd8a51e13240f34f38f3b1c814f454836c65c7598817cb0fa +derive_public_key db04ad478c001b524f54b96cff2c4806cb6ad6898f141e44ae30cac4180edbbc 148580473 96bcd5e669b08c6a2729fa12c68d95648a03e69e92d4193b8a5e4535f9a4e25c true b7b8b10d71e148e13a9beccc6957f5c42b0b7c91da15301f8aa5cd94b2e878d8 +derive_public_key 80ebc8343f829b31a69181a5478e031b108f72d33cfe1828f6942f3ec70c78b1 8033311 0b5f244d174007cdbd44a2078b480fdda371bbe400521baf6d58da70eb1ed9e6 true 87c73b71032f4a87bdfaa9200dc0f0737c5b4a2fbc9ef4505bdff21a2d377abe +derive_public_key 4d871f166f1d5ffcb924270e2aec1ecd82a206748f8f79699b2e4d9e1e9e0945 0 764aa88857bf830997773e6bfe0c825fd583e3aa10755e66edc10516763cbc4e true 5481e16cb098a3bf79982b11ee6b156df9c6bd3d92acb1d4da34ceb9a1bf38da +derive_public_key e3c52aa6d1d053f88cc0cfe38587502ad6a9e96ebe2aa08893eaf5e62b907da7 42820707 d2e8ec3a841e24d16cc955ec235462dd1202bd864dfe2725e599e8ec902f95c7 true dcac2efaebcdd43217af771e6fa82f42d1b5a7f9f690512094d75d334b3efaea +derive_public_key ca99ca0f805f931577b9835b742790bd0ebec396b9ee0c63981c63056e49a23a 22 2951750c965e82be4e6ffe34a465945ab7f18ea4903e4af73f5d8aac4398ed20 true 3226b114e98da7374e191e3f74fd603c4067382e27601bd71c93e65a64fcf9ab +derive_public_key 030b566e72cdd5f24ca218613745316f3416bff7c2ef4ba3805956c3ed1dbe06 520479684 5f4ac0f7c9f4f358b3ffb81fe9609dc1aac0cccae4d9cdac739109f5e226e525 true 91d79c9e4c97e03f3210fcd826d6c7948e384f425add64a40bd2250eb60b9fac +derive_public_key 84d79fad6c1f4b80dc93820e8a3bd74f805e3f16f7043d9ddb2ff748723b6ecd 11853078 38bf1c18956e54094223d18c64e97ab750d5c360c37d01e557e6e7e352239e2c true 3ca57b4c265df2686615b852b27cfe8ac2b3a9b93340b8f576bf21c40bc1c180 +derive_public_key 8e267ce9fbe7a460d02dc001ac5f55a6d51ce0544eb902edbc9573a747a18185 78373 591a00b2872dbacc5a5bf47135c7b3b0b0d17538a255e1ca1fba7995c21fda88 true 6038ef7d477307760bdcb6cdea71606ebffba16e663a9555686640c49c63fc7d +derive_public_key fad4d6c35ce29c33425ec23b68d2610bd816098e8785d41949a90c71d8a26399 131 0813ac103674f0ad2ddb9e1605c05ada32c88a83bfd78b7f29caedcbf92201a9 true 72a958f33f10442736934e4e92e224a1314c7687fc49127cec05aeb1cca0a657 +derive_public_key 32cc027ea8a372062b08e6305b13a8d58e6e70c98aa8380b103246e9b7adf468 0 3b94e49fc7bd35d7bb6598910fa5ff73e3d887bb5398aa97b6a6822069276fda true 8a4c88b3017eaaf4a7964039255c422da1ec9e7d2e405c865256250937ed8f9b +derive_public_key 08d7f748088790871d4c91214ef8c55934686fa97bbdfa90e99910dc48f70df3 1597002 283e8623d25a7d814043205026114a6e6d3579160ce30bf559469b3e96dbebdb true 2a9432161ac99d7374a9b9c483ff8faee24126866566f1602d9f52c79b5014e1 +derive_public_key 9450ce1a031345a1204c2b317541d5efc34c773e9d50dabd1b5046e503b54953 14934329 cb407bc6e0c2539cc7389a5643979e68ec99a9f474456eed2020ee660bc2540d true f4788d8c169f883068395477ae60411005c443bffc83a9f93f1fafb7a767dd00 +derive_public_key ff6679a4d31c031b570f46a45bdf0d54365429cb3323283298db791b85de9c87 6871118 4d334441c0aa7dccd451e31b6b5fbfc80470ac78f6e2b7744bba2c046c1e5f61 true edb36f5f5489175aa6b18fc10b132f06e807cd938dd0511e853d7d815eaa1026 +derive_public_key 8e3fbf5921b49d9785435cfcfeff0415ea0a2ac3174a5f5c43d20b184f3dd832 10604123 195be883a401585e6ca9664cb88b57783a84fb1a13ea91c435b895b3ec66e333 true 532af4220d48789b922dd0dff0ab8b0f7961a7b2c16b38d24415671c3ffc666d +derive_public_key e0ba6739668e9eac27b2e54fe9ac30d43c9951f386a2b39b0ea7f94507a05d29 8 8e5cbe3b524e68ef032120b77f5cad5b6eb034974dff20ae8c85607b07ca4d13 true 968a25ebb4384786b144ae2f8596c725ef430e133e75a86be0ae27cebb3a4fb0 +derive_public_key e844bc576cc9d5bb682555f4d6c0fef3ef567cb07226d180a84362874743de86 10132131 86ce85264c0f5a25bf009cb6fac12a056cf79f8181beb3f7cae14d9a7a6fdbb8 true 1fb15a880245d545e327d8b769d7f8fe64cf16149d44fb5161e80d05be0ee297 +derive_public_key 01b9cfb30cdbc0837ab496566c430021c576f1b3749581839f9747d1838d8852 45629 4e187788ed516ba4be752d417aa68eeef4e780427353472ec4b92aa94e58a00c true 4658eb0861274cab745e443ed6f8a2c5bf3a56c8f4c940ddc77a16e15a8a5795 +derive_public_key 82525a696f00f3f13c58b559ce0dbb9c5d206ea372042567fb438d32bf2d1164 397722 c9d627ba67966aa898555e775c0c241d70fdaa47f754bc26e0129e5db22b068a true 356e9df6c768c2ac58175f098a73a9e7337c411c3beb4e017908db631885bd76 +derive_public_key 1d2719d3937231ddde223b6b67027913b88b1f9a90627dba7b0c9ed40ab12c6a 78 0cb53d566fa3983b149e069dbcd83b2c3cc662fb8f7617da1aa9be17054c876d true f4785814d2f7bf24b422df1110fb7066b2f07eedc9cfbf57b127a686d5d36119 +derive_public_key dcb29d76d16fa8328176750342deb838b559321d86f40c9229b140150facf54d 120720609 94b38bfbf82ef7e147a9d88947f27e4f19020a235b7b875d68c0c935155382e1 true ddda01c28df37452a4022c99d93ebefdcc9b1145725aa7aa32b232c6269ec1db +derive_public_key 8661238d595129c03b14314b52b3631bbc14a298dd3aca91950ffddaaa208819 983772601 3882a74c7fdf083763353bb01489f0f71eb50bba1004c02fe0d8281c4ffca4ad true 3fc5d830aa14dc23e59bf10a6a513058fc90ae73253517eaf9b8daec12110f18 +derive_public_key 647a11adcc810fed4dbffb6f89bf071634b9726de4caa0c3977a38b1d52f4911 226 13447dffe39a4c1183b0f35bfe1776c4ba0b8957183e07873bbf52bd271add11 true a50ed5818a06bd64add434b07ef7027f15c287ababca9d3fecd7cf552b9f40f7 +derive_public_key 8139404e563768658539c862aca5f77dbf96ee4ab2c332536a6ddfbabd99d7ab 30245789 30d976859b95c4ee1f95179ed778056799d99ca05bbbd659db02838ff6792bc5 true fbaedeb85bd35a5a5aa10f1e3431dc3573ade061be4a19d1ab362a9ae2359ca9 +derive_public_key 2cf34a99d10371fb2f6d438c0fe7d81038a534c928ef5e2bc0a2f528639f66a4 144003004 456693f45951857756baaa3984cfb397d343a5b3230ed004216ab37ab969dfad true a009837a61a072374d3102726a8368f56fe079341055a8490d478ea788d1f32e +derive_public_key a2f18d423ca3eb9ff74fb79f85e721c1e416c893331632a450f4d1e7f21097a5 1 1ce2e087abf7a54a573dc0bece97effc47958ed04d3ca02b58ffa7bf1ca17be6 true 74dc31dbe8e98cd287000576e654188e0984089f0d12c3cadfdec48779f548aa +derive_public_key e877fb7d771fc931026081a0d180ac60d2d3c59e2012118cc5b5ed7d5bfc350b 0 6261f1e03e9b7dbe4d4c0161a4d13bf0f3e33451eb3e87bd4b0fc2d80cb1d3f7 true 6e1e495ee26fdd6d187c9e4286ca323e9d9efffc20673eb94be26b5ffacb8629 +derive_public_key fbdb7725a36c548d25a1f49315aeb51539671bb7e582c8970d78554dd66f820d 3374736 36d25e15e42c90ab19cffc03ba473027681398d0e359eedb112d29a62dbaf1d6 true 30d0eb89efaabafa9bef9e4ec1ba067592bb857262ba14ba7f07746c517e8f9f +derive_public_key 55e99da42788f95d2415bf51039517dd129cfb4a1b66d676977341ce5a92280d 454769 4281d8f29e4ea7b8ef9a45823b9ebf96ca96f2233aec8b204f8acb247bc53d05 true 8d56c47422981d5b9c2bdf4ad2a77614cf2ea71faa7925b2c7510e8013f02a57 +derive_public_key 3ee9da962e552c47eb74daaa8f4cdef1a5559b1776b4f36e39cbd228a32503a3 22 3ae53c8a8d38f2d054772ae7182cd135a27cc2dd9d9e28e5b9ed37283219e30a true 377cedc7f44ec0aaccec70943b41ea8abc9b22ffb19324985d30302081b3f257 +derive_public_key 2cfe68257b5f2b40d93d8ad0785f2efc9f591d4127f5bc953c5b7b5bf7278438 14597989 93b69760f2345ddec069280766829b59f57b65aeac8d2938c7e262f8c52d3d47 true 91c377f78097bb737e419b0ad5780445a369e6c730337e8d46c3bb687f4bf37b +derive_public_key 4a14f7a9260e0cf92ecdf41ffe50192e71a591dd688204cc4f4900d26f6b114d 0 d6551ad2a403591dc431dfe17e37975f3dcc9a5bfb5d5cf54a9022feaff26763 true 64a51b25f017222a318888b56b9ee5fd35821b4075b4708eb28cbcdc46740dff +derive_public_key 92cd30dde99989f600cf2c9079ec751ddf4a0bbc0815b551289ee61775108011 89676626 68a9f49f06a8e6c1c4b680be6f8288b9c8382c75273306b49f9f9406696674ab true 9601c1b28fb77d2acb392e25a610bc1865f51dcd1fdea1349e59cf83068684b9 +derive_public_key 5059da06fa249d43a4d33ae43c2e0b67bbdffe169056d39cc103b52b5bea4a15 25 53019ddc329dcb20343110619bbd12c82a2cfa013c65dc19a7398ae82b39a71c true 3a1faedc0f83d049096365f5a5f7b6de6945d9f3e840882420bb0ba73080ee90 +derive_public_key ec0c6b2ea5f868c2bce9cfe46a012277bf36753ef2fe09dadeb168553ab0af36 988 11b9018bbc72293417be273101885e9d47974eb67eee3a0288a0dadddf2d6d6e true daccb03228f661724ceba36270f71bc30a73477b2dd505e69524ca78dcaf0c7b +derive_public_key 5bbf97b882db9bd6aedbb7aee356e938c5166cedbf66a5180bba443e1b70c9cd 5 01b09709207727cb2b65be8a321ad0a18371a23dfad4ab5ba74357965b53ed9c true 4828152a366a9877ea75f1bdb200a4f43699abe9c7ecbea6e8320487a6943db6 +derive_public_key a82c08c39ad6f014ff56adf6b82749695d229b17f75c45e6ad09244bc3a459db 786475024 cf7160b48d27e57f62bf636e175c71555bb4b85020369764b22a8c0919e6a073 true dbbf9c220c1a6b18dcc9448250d0ee2153bb9d6ab77c2be6226fd93202ae4d07 +derive_public_key 67f02bca7aa60316a28f73bf63d36cbfd8f66d33f6c50963367e21d7a445ab4a 100708119 d8c4b8185703168daa1943b0dd45ede095ee7adf386c768fa1b9cb906c0bc3a1 true 3c0b0e3ca9d70bd979fe5e181cd203cd0a00824aec4c4eb18dc71a7abc9084e2 +derive_public_key a39fdf86ab7589ee7fd63ffd328b1a7b719689b1e61153c4364faba90810ef5e 3596068390 7335dfef7a29c0886b5d76ed9fd1435b5889c5bd4f1ab3dd5b0df738debbc21c true 25ae1e59f069db4f602bb84f68f279aef3ea1e4a0005dc523a5613aa9389d352 +derive_public_key 9a73449cd2042481b7742b6c931f2fcbe18035c193e70a15a5c45185e5491193 63137 85f5033d259b4c57516d9031ae0f2c2ffab876e86d24022d6ff364bd671fcce0 true cb0db2c7b2ffdc9d6fca7ac3a2d1a8d24ea2910bf67afabc55c759d7627629c6 +derive_public_key af471df72341ef1dc2c7ed130e031a03f37282178149228dc1752c78cd22f647 21768777 042e23c3a90b24523d7d5206cbec2fc36d1a144cb691cbc518ab62b1d66b8ea8 true cf7aaf77281face35a89b3ccb64af72dfa362e2afb5a82c8367442b9950d08e2 +derive_public_key abcfd7bd2bb095d628d7938d6cfd94cfda91823391dc899a2ea78dbd391695dd 1335518 5def799fe25b1d2eea1b4ac2f7dfa745dcf18457ce025c00d37dad1c00c9b5d0 true f0f1e6a503b2ee8b9024f45ae5a1d8b395543156914a9d125c5e447bcb561c46 +derive_public_key d1bb45498f1c60f68d154d85a966924316a5b0fc01db3d6ed92c0ac6fc71b9b0 480 5a828e93304e955e0841b0deb1b1750cf4e8416f946a68ca7092e068557acba9 true cc2f27775e4d161daa99379d4385b97e52ccfcef71ffe5bffaaedc0d148a1fce +derive_public_key de313b5398fac29ca8e20f8a6e761690b7787a0f98393a27e930a6946c2e9501 68029 ea319be5d13d876cf7e31a0ec026ee0fcad8914a2e33f4fc98576fc7e3aed813 true 2d7653dc39b19753e891d6513d386f2b9effa5e34d09b23e2ab6de54994a9f38 +derive_public_key aa90cef4ae169dc9d4ab4bca6da653c1f9e928f1923e9115e916bb54d9196353 9 464229bb8daea5c5cdc7dfe32442cac674608c2c23f5ea6e7a30ffe109501553 true e3aa39223b0f6fff6033b3924be8b1e8caf4671aac4f9ddc6d2f1238fd2b42ac +derive_public_key 648c3fdaafbc31921aade7d54dd1d9f759736e0ed097fda5d2d7dc2a3341c7ea 1394430271 7aaa48dafda459163b1a10d4d1b0adad00e0964103ea8eb083f1778270127454 true 4d32498a04e09af3e1aa81a2b4344eaaaa11a20930f0887c12be9b143d620d5c +derive_public_key 5cb191f9d79adc04497d3ba15f15b1711c0209835433e4a4738b5befa3fe27a1 224 e3b5e170591b71994c5e490ce937b1097aeb717ef8b5890ef9485e489c1afbf8 true 6a74e02976e9b1741cf8f5c873f3c62af53c80ee1046d8a2e5fe112818340e47 +derive_public_key a27db39ff857bf25405a08e2cb6f259f076367d6a7e0e360d1d203413e1e814b 71331244 b5aa6647d2d389f9f9380e65204b9e810cedca8e804c9661229086cdbbe408b9 true c3d86dc601e910a4d321d7e9cea7bdf39af39956dcf92ca5b577d726dcf6db4a +derive_public_key 42119cb67625451284ee8908e2ee9bb92be61f9e2674727731379667680d3533 253807004 e6a37a8de7142328468ef98d6fab4ee6f0fdc33af81be767e0c5812d7afaef5e true bd4631549ad67f5b84b1a0ea917011818d6cf47597a9cb244017316e55d3fdf5 +derive_public_key c3bf51aa80ea9e9e0e608b60625271dd74ad0a8ad76ea7a09797b32026cce103 2340032 d03bfee303d52ed5ece5f0af67c5d98e68efb74ecb95909b8cace6e1e18df523 true b4a6535afff6fd3900b87000d25b60b6785177ed03e4723c6d7148835a137b94 +derive_public_key b65ab35ce4f351a21768e9cdf28e14a55d199a2c73bf2503cb4d1c9c20c328ed 32818 e0c3a0eb573bb2145223c1aa7ba21fc8cf384f0985854d46a9d5e741972ae52d true 0a610496ef8153f2c21e7e9d78567c080e58b62a31db15b67ab7d79d34ffba65 +derive_public_key 6320b06083f514d22b94f265a96f56e6f7b3b1ec11f167354d78de24bd8f4c9f 32755 b13064df0b3caab0f5b5ea1998de41808b9a6b449b244f02afc119e496e0dc76 true a808678b311001d6b1957ece1b82c4e63c80579f3e8b9ca937755cd0b4300ce0 +derive_public_key f58f5e1c69015227dab42020e512d2fb60d4fd4cc01ceb6fe8362cd62916b557 1862502919 54a155059d5ceedbd72bc52a083cdb5833ecb69e13be9bfa6d732ce70648758d true fb435ee142bc9b09eb2d6c1489e6e13e90470aecea1a5d2a22714f40f9bc1685 +derive_public_key bd7310ab07db11bce48a662102c0670988e2e599966491a490fd3ee841e01217 1244965 d8768d8fc25af1760f6e3e4982e273a8b54419414a81b1685e4cf1478063c774 true cac4934fb5ae518a35eb1bd77e22181e7b197e9d9f21f17a62a37810e0108ccb +derive_public_key 49ce2a4856dfada3b6096ca70cd61ecb47bed96bb6d60c8257da6d17a51df937 11661 19763bca6fbaae28c2ed7b4cb0e5a77f14ed0d98a0ff39e4cbf7744f9671772e true ec2ed8a4ad30360b5458bf1fefe576e3c7cc635da64f6e2c4435a18c0a9f60bc +derive_public_key c89f12c3c94a5e8eef83302e21bd5c924edb58eea9a8e5320bd45776a3e27d8f 93 855ab5bcc461dcc72f3bc7a9aa5c855c71da6b6981a28a92791eed3f45c982a9 true ce148b2f4299932faba82998cc182452ac99ef74dd5afc339cf94cd8c2cbfc35 +derive_public_key 9707f332d2cc1d85b8ab034b6286827bca7bed2845b45e3c581b309b2d0e14c2 340926 848b72bf0cf301213efaa9c62fda4cffaaabc6e3028b76e542aff6a158d7ea93 true 6ab6386a23b3809b07a5db452a1d1a29f6e86fc5f7df625f717a6d7316d015cf +derive_public_key d131c0f33d95d61558bc299e6f94bded4143e9142821952c6fd2c00aaf989422 110451995 928b8cf5fb52c1e9c89d4be46fb363616dc11312d9077f5e72125bb3564d1f7c true 797d8a2d288e0d180585a6646bc03f85c23e397b4174a2c3d613f5117621f7cc +derive_public_key b257b45cd0253c0ccba8a35dc723e6547eecf12e324b4aa8286948c42ff9f5df 246755777 521ed9e79484e778607f92145cfa9253f4074d8b6523412d659dadc71bb5ce7f true 2b5d2948e51ce0c63fdffc6f3642997fefc6abcbd56e47b6fb86a7cb0d360e2b +derive_public_key f330dd2d54f7f4e3445ea31c8d1e58063b78d97403312e07047a72b02b5addd1 667321726 6dd2c154318582381756f9f0fbe88cc8a51ccf03b7c9072747f115c53e236765 true 5920de9acb7be9a505ad3272a71b83bcc456c4310d3b5ff0643fd47a1fd12e6e +derive_public_key 1545347c3048aa01598269619342d8b6a88f6857d4e05bed1f1893091c991a6b 8033 7f1c7329606a499294dbab9173343e462922909b5ed05556cf3d96ea6ca05ba8 true 0eb1e224edc7abb4cb2e42f738c303c0ad62c81c2201d0462adb8e5e8da0c43d +derive_public_key b72d3b89a5eded10027d83d8fa1d3f6509bedc25eea8bf17ac4461fba5197dfe 67 a1609c3770026304ffce23c33498bf99b3eec23d808553cfded91c2e10875026 true 30261692ebafb79ede7f07ffb4d96edc8ec2d68b5286ce3cac8733d1359333b5 +derive_public_key 280658fab8f618d2d99dc7a45d5156b0a950001952da11bbe87c963c2c3cc386 221803865 2a048fe213505732777eef9a7e9e397bfb2a69dd958b04923978bfd1c87b18a8 true d8f31f374cbf0b4db7ea91092c506ae8b8dbd3e00b6e0f53c5915a467ecac5ec +derive_public_key 72c73e25dc4bad887134f370f63fd4d934defa98816c4903f87d8424c91239b7 1138 920b522c359c04f994d862356a8d6aa27d6ebdc8fd7f79c4df90ae1fec7fb3f2 true 3c2d6cebf1853947d70ab00b1621bb44c720f21630275472695577de18b4edec +derive_public_key ad6d26484e50a2b5f45787abc9db2b4dbe71f8af23378d284f80cd793546d010 6942771 a99338aa67688dc3618c9f609d3251053bfcbc437d29cbfc7f5135fe68eab045 true 45f11dd04ef635f06ff981172afb4748566f14a1a0c15e54b19640d28f86b2cd +derive_public_key 728397a29b27d36d6453d4638339c6391c454c04b47131d2bf34c64aaec7e302 20316756 ce1c36240d6a390119d3e3acb2ad4e48223d920839b457a454169113d2f0cc0c true 0cdad261a343d1ad64dcb4704d3c12a98171217c3a97e838d458ee8b17bb0014 +derive_public_key 3bf76565c93486c86542a2ba6928d42b850213f3566331bfd788d99c67a25f41 3676623797 3552ba9ddec150128eca080dc54c45e671be029aa198266df89b97cf75d421ae true e395811604fab9ea6bf45dcb5ebbbfb8e2ff772aae6d270da43b366127e2dcef +derive_public_key 1c80edbc419ef57b43c1c90bc8c2e4bc1a5b7ef713f14b564087332b7405553f 1643647787 83c09f66d0ea8364f6bb76a4add5f8ac07313fbd28d69bc94a27a44fc17a60d7 true fb6fb73dcbe273b33f0cd73c3b09c313136010d460388f254cfbe06cc19cb573 +derive_public_key e792b50532b104709b217016c8b8fa189589587467aad408a597b75a333bf0e9 10378011 65f005c5ab232c1bf6c2e1d5d9d0df6b0b8b36ac33f3c5daa9149851d79a5f83 true be1ac65ca6f1b055d8c0def192b7cadd23e5655bfe53f03a85d787ceaad72020 +derive_public_key 51d3e22ab048faacb2b2bf7c6891da24acbe2b152d407079978f2d2cbdf21a6b 28750 497b2c202a489e5ae177beb6b55c1df0c51ae3ac05a69da8d9d5bcf7c207837f true 06be7c5b8cf2b112ad942aed5cc7bd83f85106de54aa5f98809844b9dcc023cd +derive_public_key 7b8ac9405c3ffa27a691fc4a366c876ded387dbc21b28b5b912fbaafff4c2458 312 c3a7ac6d8f313e3f1439773a36de0dec68a5560bef985f1157f75ed507ad6256 true f7fd4ad94079a99842b8f88c8bad8dc3187483efe0a846072af1143fab05c9f2 +derive_public_key c968fc26b5c59b86f8313ba37fc04e596c6b83ec6f35797ec14b3d9469a84927 0 bb9afa0187af780be1c2ba45bcecde0a3a83cce984f063d0318c9bfb3134f88d true 184defb705e269011004c1ebee17dbab6431cf7ac145da4a9b73b29d8501a3c5 +derive_public_key 4282a29aec72807776dbe767bc45f9e5aa95c4ce9b4fa351312d43c5d9f2acfd 26123 fc22881a10931db208c380dbc9c6d83b4d3dab64751bce61058636f1a088e4d2 true 45625f61ed7ae060c5892e6ca8676d433ef92bbe9e207ab73927f4fca967fd5e +derive_public_key dc20d196f4c42a9a3fefc031645d0f7eb1ab96e49d42d86ce87016713a6f718e 2596757 b979606a7ff5f51a2291968ecea570378b7f7a49a89a5262a8673724cf702c5d true 52458bca627e4d7a40f964c3a0837b38e6267bd39346b42346d50e055cd12c84 +derive_public_key 5d89a9f6fba4536092cf47a700139fa522352e3e817451f5e318e7971d73d6ee 30680400 521a006d2d8be6f37da4f3c47a7d5887f526202d12b85cfb0c9e6e0ebc2513bf true 1a512176ba2c7407356fe7760f3f2eaa1a12fd965ed3849c44a1ef99aa21b092 +derive_public_key 5094a88919fe5ac7275bb6e23f76b69ee52900377abb9195a68e23511fe9ec22 1219 e5277eb93ab55ea5ef45665556ba0333380dc852162938ff2d2f5580fe1b5711 true e09fd0f95b0b59be0d02054d5fba3af95e23e810598baff4eec23056152a4c6f +derive_public_key 39f51f462e50850ada90abd66080a58423b941d941dc31dda85217d5f6f07bcb 219128 a8458f7baff1d42d0c83346ef8f53ce8ba5c169ed067ca33897ea185e012798f true 08454deebb8bb33e7a66f7697d4c09a99e23917d28f719092f2565cf12f82411 +derive_public_key 6e331657fc3a5a463942dfda38a53d163c436ae863fc49669b4ff481da0a923b 226101 4976ba68c2aacbd0a7973701ad4430bfa25bca7c71f62ab94493302deefffa93 true 37d0d659972211f8f4b53abdc73d39ecf1b73e70490e51671bbb66e3cf9242b5 +derive_public_key a388a7d24c11c7d705fb99fd1278d7d9574fd1e3f03cd836fcd5d7e021f3d4dd 7478 73d3d8b2fd9d27b385d30ccdd60dfd00dfdee364364ae450be7d4cb8c4027c81 true 1ada67d46d1ab7213a606f82406edeb601ab30f2768303b5b57f7e86d5f7c1ca +derive_public_key d968e0b0e15e18fbac4d616375f3f0ca35fb9550722fc5db3f94a1a2549825ef 1 160c9ff6f4f4ce8f8d8b5c800061595c30f32bc5628b4876b24956c51f269773 true d5938e1aec57346584d53987fe9e4a8956e82f4960e235f4e183230add6cf493 +derive_public_key d4aa1ce9a1325b411041efb62a750dbc1967dd10ee5cdaae6032368bca6ef5f1 49401 437a0be18b5450163a92335827d11e43025c2a273d922a8e834df4b32d52d390 true d07213119d96e5e9376f864554f5d3152554e40593d1cfe7a5c36d9dda7b2c9b +derive_public_key 1e3629151343c8a26f8a597509320f625160709791130b74312a4c7e6f6d9830 3934 a7aab792d9cf7a556e9a466c41694b32736849776bce6d9db270164a87eb91e3 true c4d90a1b3cd6075c0382404647492541f3c0e7ae76876319726a01f6f108ed64 +derive_public_key 6d4d0d70b8908544a8e8b385c69039a4b2f25e75e6537289982de074bbcfd470 61821 726b80b87fee360e2eace6462540114cd26c6b6904ee30d4f220b716ef6ad6b2 true 2e8104c27adea2cb16e511aaf58bc59caca7c7213cff7d7045461b15b8714c65 +derive_public_key 4f5cd559eaf84cea4bef298857fe0787cc9b3f85c00633d11e990c1d2e3ee9e8 0 6c132aeb35e42199c42aee7ce6e167e28614a5c54cc1c69d3204031011ec8cc8 true 66602e28c31ad171bcb4150477fb6b26d95a712e9d2caea89d4be4124c0150c8 +derive_public_key 3d2563fe6bcea094dc4427f216e46abe727bee7e1a4b35f5e0ecc017af86f9bb 139812302 cdcd6b638f05f00c6447dc5b21d0cee0db966d7c2b3170d14da1f4d42e44e61d true b8e441e17804a55c566e08289e8b95ef05f50fbfcbe95cf5594f60c30a030725 +derive_public_key 7efae02f7a716afdbd7551369b139f71c33b296570c2995bfe0ce2e9b259896a 1816145 192430b9c53091f04d75591bd323c269103377e6641b241e1f18bcf589bd0f03 true 2fde6eeb5e0217862710557b06b7a0095c7af227e882f05212157dc79c97fe2d +derive_public_key e9e2e385f657bba82515853a4ada63c4d52dd6f422f93367e17e231604a9bcca 588 caaf3a67e26e312599125e644d2e358a4d01d4b006798b3bce932849f77f529a true 83498bc8a1aed0fc90a3d53d972d4ae827402ca44f41e4a284d7a0ed10682dc3 +derive_public_key 0386ba428e97760d296b66133cf1f4ea9792ac0dce2d700c74a3c453b9b2bbd9 5103 dcdae408c04177e623a1c26125303b2a866a78c50b3bf845dbff06bed361c4ef true 4550e9683132dab89a660dcbe675a973826ef5c20ce42e34f94779a1b949afa5 +derive_public_key c2a1a8c7f6cd30f44b3ca496aed34f83b6e9e0932450dd39dbece75caaa1b96d 697 8e283d2130c26eaeb8cacd27e063ab321fe23e74d300cc5e1b022b4a3f7ce486 true 9c9555b0a66deb90752e12e0ebf1c8490b1c4615540b96ac13a935c42e1be45b +derive_public_key bf6535eb6eec027f278f054a33e69e745914beb74fddcc1309661c58cef2e69f 4382928 3cee18de99a2e9f313b99301b1e18a33fe661e1e586fc78c74fb9b49a078613e true f708a481ef2b3ab02c03dc26973da5c689c60651d666cc5e46689735216c4252 +derive_public_key bc53dbaeb700d2328930d6503c7b8bdeb7c96ddeca7b3c8c703f9806e75d753f 4 6cad5fbb7096936c74fd02d8ffd16b01e7e5864ccb52d65c625b40b640d4198b true acb0b5c3e705780010abc00e2e26c6d9922eebe6ef5f85a708ecb2931e2e7a93 +derive_public_key 6e2d45729e1f1d182d163f496ca17e9d277762c70e6dae32cf845950b4484b22 1385 fc94d754fe91618999105cfa4f1cf9fbc3987fba9ade75ca5b90be49cd75633f true 82cc36164b99949f481771d1a3a62f9dc2125c3c99b8165ac6209a4742f39914 +derive_public_key bff381b785781c1e0e6d1bbcaf565766d86b16ed7024eb896e030deefda30eea 2593 b9bb0cf5f40b4d59bbeaa2de60e608cbe1bfa2163e6b00ec798c8b92fea504a3 true e7893b259e93cb576bab12f9cda06cb2184eaf6e9331a2ead11929a50949d59d +derive_public_key 3dd04c2d005bf5e1d197791a5521c7f1bd8e6d2a2c7e76c8df0a1858f8d2efea 52 7339e2722369f7d2e2a566b6bf04e1a38beb4c182ca8aeccd30e8454c82fe905 true fba0b996f04a131e858b3a8782becd3a97f8cba585eb35d17a30f0d4ba398a65 +derive_public_key 57c8e9c8387e49a4b725f3f40648ae5ddd0f2d6e18b14c8398a69ea89067f93d 19 43f47ea6533a6b3b0bdd56c87452d3daf4b9a7d6b6a9d34481d84ea5e0a98e3f true 02178b53602aa2926b62c8b8eb5023241a652b3863947421e25d98e00fbc199b +derive_public_key 245ef7e45e094f9719ba26563e23e2f35aec9a560ecc2b9182e813ad46e98f53 77 a7511490e65ce3b86b0f5aef439d03ae623e8afa605fa078dee26a33c9848cbe true d908a3e97c7a1b847a3407935f7b7bafd64eeae61e2dfce4047a97cf3a401c9b +derive_public_key b46659d97393504bedc000fc89c4153ef2781ba7c4501dc82dd115bea8de5c52 56196253 1c6f06fbdbe01c691f7e3e7b4e55781b1ae18c87f12a6841a12d4b071526f864 true 9976eb2b1738d4eab428bebf062123cc0ef2505e5c5600a5a1163c28aca7ac4c +derive_public_key 7a6b9fd14dbfaa2474cb5d3dd9fbff2cc337888302719ddb1bd119802d665acf 1436546 c9a9212e87f9db626676c6556d49b40a77024b4fb7870f38823d6a2c8601bb52 true edab9c94499e465561f913acd97dda910d40455e7dba804214d7287e87468a03 +derive_public_key c6bbaaf2ed0e5ecdbdf8b7306b1d38c51e415d1a9c479646b9b4a21263035a8c 865121 5729f42dff02c42faf2f043fc04c23146e4999d7eb58fa39c808a01cb41a1d7f true 47a932ced8ec378d19cc22fe66b9fb4a43d98c759699ac657c499ae043a0014f +derive_public_key 2bc5c122b4cc36fb0cbbb75e183ff05cfa976336e3e46fa6240857a1ae71143d 13777 6cbe97d3a95c07b0fd96db6be4cd282d0e373e2ba8dd4ed1133b34cfe99b30d7 true 6169acc67528c76d5fec80c922947aa2d57e973cd437b7728054d44a86b0f727 +derive_public_key 05c3c035bd9c18f0d80312ceb2306fc94f4791e7c3d3cbe25ec3b37c248513b3 1950578 e81e1c81081f5964da43976897c6a1fe04c1b0621d7f6ca9c83f6ec05c61e143 true fa2050e4e21a89b1a0dab07db770ee047bf983a299c3d04ed59ccc2e054f8650 +derive_public_key 07bdccca5ff66091eb6145810c55f250ab3c1da6eea7ec9382a091064a455b17 2 d2354bdd4808c2926553afec4e5868c3c8801af7bba7f800111d16058325781e true e008fd24e30db897ca789bd6f0589b24f317e562a48587b6470324d07fadb76e +derive_public_key f04cf2572dc9158a24d4f886a8cac32ca250fb629ca72de66289d660ee553e0f 2029 6d6478eecdb79b63a07212ed5d301af915d59e1ed02be13dabee1d3f875f7aae true 0379618e82dd4d046b7fa4cc49aec3ac320d578e7e553497968252d03be2f60c +derive_public_key 439365ffecbbdf9667982be93d4f23a88054c16639e99630371540652cadd201 11020 7bff6f094f3771d59b11a60106fb8703cf8f94dea7ae4b2ef054d9e9ba92e0e9 true 8a3dca46a848ca6d6a7b1a654ca6c9f0d6ebb3915a1066ecd4fa20f47b5d7344 +derive_public_key 779db2750d14399a21e0b5e3b64916033752b8d49f84fefc8ea8be62f1cfe453 650928 fab61df7b4b4bcd55fb5b68c5b1611c2042c34c13a80cb569be368b29c4158bd true ebf83434bc3216ed6771a9364c4e95625cc02f56af454a40a17911974fa39dec +derive_public_key 08a13acd109cc08e6a825cc6d50b5d9c56c41540f677a2323dad18931e93cc10 10 a6482d5a66612a7d977d0f472e51e6ec30333b21d6bacfdbfa63be9d23d0baea false +derive_public_key 9254ef2641a0098c98118803afdb2f4c85925f3c325cfdfc6916ee45e47ecede 56 4211b3cb9672abbd3dc1a6b86b298bee9d9fd68ef2b5f03f21891d0d3be31465 false +derive_public_key 54d5afb8b78aa1a5172c44d9e2ce9bd46e48fc3671944be0cadd0b5d3153b31f 1 a4c8d5817609c90efe6d21893103a5fbf186061292931e0b385edce7d3e5ba55 false +derive_public_key e05389e5fc902255ae0aa7b8269759b94a62bc3ca46d6e292abe0e828019dfa3 13654084 5b3a284d616e2c20041e022fa0ca4d444fd12a2b954cd65725cb0e92ee263c0d false +derive_public_key 13aec37cab06e7962ea7dd36bf7466fe18c41b2c40d27aa7d5bf53dd2addf215 69038 eefedd9223698aad67c0c02e90022110d5a36c4c10a195068da378a44faa6d82 false +derive_public_key 47f6f2bc7b7ce46e628145cdf55597811934d6184bd5c249baded9f4d3ebea4e 0 15b2fa44daa4840f32144ea2024c08125ee1b84535e0a3a41904648653773468 false +derive_public_key bec042688e08986a1a0a4cd40c6d648324a873214f2ed7419d1baa0e54239350 150564 d3625ff787c8c54dddc250ea9164e4d20ace3c08b9bd3fa0b9d1e2b710951ecc false +derive_public_key 11e84fed7e1eb3495e9c464b4ac16fd0010dbf24ab65120e57d2d51dbfbcf2db 24 a88c9199ebcc36b9d1dc97038a036e6d61661810e2f06854a6714fe4ead96c05 false +derive_public_key 0f689aa3581a739a2b2e3951164e1a43666fc5928c1be9eb6da10c2f6e0f6af4 3664 23608c6e58190556c9eedcfc13e337cf94b9e64d938e56c10b44b8f36ea4a2d7 false +derive_public_key 3dae704edd8e0e0723ff3595507782fd0f273279be9fd67b52eafa1795f726c9 455 4f658d1c1b755c5d9afe3455dc79270ef227250a763eb98f37f148507681b820 false +derive_public_key 0036759c3e20209b4bb37a913df0184b3ea26b72e7f06ae1ef5c6bdbc348b916 2544406857 ee86666cdcacab3df5feb14db3c686a02246daec624473ea60058e6813ee2c3f false +derive_public_key 0fb9110558d1bf0d87284c9bcfd6043bd95022ca52674f06d55e5ea672642bfc 9 431127b1e53e1fcfb299b9a9659fc38be894938306653ff3b218f1c98cf6cb13 false +derive_public_key 5ea95a51ab11b80c7d09d0c8f8952b70c67e81d0fd421bbed43ab77c1b7b300a 51498574 63222fb36788295ab2f9c686e83f835d6609078f8a6ef33b3bcccefcca99853a false +derive_public_key 2c312ef971def53361274c37a90bfde86f959d877a636ea641a9c976ee80c7e3 121 b611ebd2bcfefc81cb772e35e3dd0204575cb0da644f68d4f9828a2683861e6c false +derive_public_key 6fa161dd958022caf185faf873dd9adbc5578352cda505e84fff7cc99a8762a7 333934910 c2b56e207862958751d49643f23079009092c32bf82179a1295e3b85a385c1c3 false +derive_public_key d85725562544e1984048391413a6112eb221bd217db3baaa9843bee331000e8e 21880446 f3148c3041e634d829e5df463ba3b1d64df282d620d63485e1f10024e003b939 false +derive_secret_key 0fc47054f355ced4d67de73bfa12e4c78ff19089548fffa7d07a674741860f97 66 5619c62aa4ad787274b1071598b6ecacf4f9dacca2fd11b0c80741b744400500 55297d64b0c0556d5583ce0e30c2024ccce90c93d16bdeb4e40fce7afff87803 +derive_secret_key fea25a8d0184526c85c16c032c7678c7a1e3ace773b31566d159dc8a3cb81ae1 755 265685f284fe213678cad94e337196428237ac55edb5871c1f0209769ba9a803 e83934c766427920055d77755b7205156e1bffc37f68135182f0974fe008470c +derive_secret_key df2c15b6f3ee51445f9097f5488158a8021dd15be1e6dbe676087bda1f2d9760 62075 04a4ca22d78a0e746c9e58e785da9635664cfdccf4b1e87537b359f656dff403 6bad669f91c2df065ee93b446b2db9d3582960ff804096ef76be64febda5450e +derive_secret_key 04fcd66c3c3551d8c9cfe47a2dda3bee9af6690790415f15f3c85fcbeae5eb1a 42055609 de68a85fdadf027981b4acf455a2b112d33f70937f6b4df24234144a5e189704 0fa11e23bc5fcf7fda3ceb2e07ba62adae3c696ab3d315ec51358f9a4267ee01 +derive_secret_key 73579e1e4fd06d78616b1a4f939275a701f0c0b1f7e73d5bcda522c070e50b43 2053410 599f97fd820e35f32d3ffd2507ba2b3617d2de7f7142cceb4a80967bbca9f109 61c8c0bba43f62a70f658bfe7e5af09869ee4b132c4d86b010977bfed6bbf907 +derive_secret_key ed118911b278428ed1a26f8c5ec923a8dfce29a7c0c3bfb353be9f158a5c277a 1896804 d9640af78bbc5dc1f1d3c1bf2e85cb8b67808e40fe49042a92e61fddb1fe720c b7d6fc96e28b99449be056109f0df445422115bd682fdce88a1d0331d44f7208 +derive_secret_key c13b8ba1710c77e7aedbe59c6f2d2160e65056488549d471eca67f1d44918ffe 43 e8058ef0f3bb3bf3a6f15acc04c947de745017c8ed1b5b5280e5dde62d24960d c707dbbb0e4cd0c4863faab771842682eef327d979d497e3f0e7fab9cc2dbb0d +derive_secret_key e4a94a7c8fc7546d2300a00b3079a6f92d27892ecac7dba505953bf2844cfb2d 24046 020e3c34c1a1b208e51ff7248b8c3aec2dec969be1aa1cebf685125c7b7e8d0a 06428933d5d9e51112d00130b799f60b486e3b76cb55ab45de6f380fcb250f09 +derive_secret_key 9d62651ca1bc7946844ec22996b6bbf64893d0ed68463e7936d5e4776cee554f 30361 423d553e1b154208941a35beade2ccff69f06646752b3eb1b83d0b9539827b0f 54bdbb0115432a2d5aca4760823712678fe80d1fe9c926ce15391939434e500c +derive_secret_key 1ca55257ffdb20e93cddecfbf30f43141f70572ce66860b580f4024f40a31cbe 9387777 abd00394451d70415e1c9f71705d169b71406ce8e7fc8aa29a776073693f4208 6ff182e0a4e9ff2dd471c7086f7f9d17cbf139e6f0b72e68746f1969cd4ac90c +derive_secret_key 4f37834b9c2aff4d8eab709cf1ccb8bc874a469da0475bca4505d5ea066dcbc8 50 d38e8123f0d08ba2eaf508c0904b28101d2f46e55740b1ccb0a1aefaa080a102 a4640319c41d047829c9231d603d3f18ee4ece19e950dd7d3d1a4dbc47e6810c +derive_secret_key 5e2cf56e73c5b2b011056660bc8a3ff4c62bac0d6643e87270faf22410504659 25261806 b3b270d07dad67fce47fe15b574bdf6d8caf2695d7536f0ae594a66d55c1790a 6c5d21e56125436886c959fa73b95fd9176639f26643480e531d274273de8007 +derive_secret_key 9c5958c354f35798d19c120cbba1d6128034f2a4d064e7ada247a652445fb916 10731622 b11fe0134adabb72ceb21aef7a1408694905112074eb1d3b3d32fbfc52e99c05 2ab7fff5c38cbc6a74bad41d55d1a67fb44b9313552e07db8f27924fdf615804 +derive_secret_key bb707742202a4eb7178e83dc96b904cd4886348dc69608de24f5baa44826012a 21 613458301d8e5244af8b09f7119f5f81b0d576260b0db8885c78b1a7f2afc201 34754f176801dc4462bd6d782f6c92feea6b1e885e384f61a800eac8b462970b +derive_secret_key 75b29302bd5526e9c3bb053ba3ecd21ef3e149d2d4abf0aeb825e072281343b8 188 9f1ef66ea1944d8329fef9123f65a6322fbbe9523d2e81be7822924ff598380a f4941c7b365447ace6ae804837d4c4373607a7b06903b9209bb126117a79560c +derive_secret_key 64c689c90f928a450d704a41471d56b0d19e96b9fbd318d709ed574ab4964653 491063975 0169a0d809edf69930f063460a56ed74b244c7f7af90bac2149167091ffd1e09 055083b8f78f7a51fbdfb4ceff27b60ff473f50f777ba6a64da63b9df26b960b +derive_secret_key cf487971d4e2bf0436b0dc49e0ac7920ec1e0861165ffe25a8f28fbe35519486 11690663 67bdd3badbd933d5255e658e1cdf5bc1e71a361e1e8048faee6ab2b4c8cd4b0d 90ac0b0a7d9629de252cd1799f9f8f1e59c739698121c24773fe6bce80a17f02 +derive_secret_key ae8c74af310a89480d17486479f1d369e0a56be44b32dee53ba77c451a02acdb 1993 05c0762a267036e29e7e5016ef7589b11abc14b5cce5abe521cecd0b50947308 8a749ef2337c46cf30a57eea0bdf68b6c70c25849c88edc5ed34f2d19d472404 +derive_secret_key 663f212146502b787d877a4c9787acc7f66d38014eb5397f8654289f3b95e40d 27 6b3bf5d4fd4c03129fb771b838e2ada7c9eaed65760d01dcb1c3619d55bd8a04 b36e7a64463fdfa2e3e56b5b225aa3c6651a5b2d0cc31acfb8f902f189524e00 +derive_secret_key f7c762f903e87885bfbbed90f84f8f64c708bafabf79f33f2adc33e62c5885ba 0 1f57e640825942acd833e7f5362da1eca91fa4f5b1acdaed1b62e968e98f500a 35eaf7d9e022fea5972381cd40501647f7048961f4f2d351227da0edfc4a670a +derive_secret_key 7b0a2aacd1781a76a7e057cdd947f0938f91d10a481ea4a0259f7a5d31bec654 893448691 0510223554f92a91cc67c6ae6d7d659c75d3cb3c48c9d55deaeb79d9af85ba0b 68d93428af739ad6d963c0fd8c6854d24eefd16b13952f50ab0457e511e19608 +derive_secret_key 4e70ab479377c3c8700ba453553105ace212b7ae8292be8e247095733a390b8e 87813051 58395bdb7e4b58d4d1707e7856b6535a796dba08d181d22014d9f0b607c99d0d 9456e1647ac37fce2c3ac73d2bcea41fed2dfefa3dd7fcf20922ce0af86a650a +derive_secret_key 466fbf1157905fbfa326bc0d9df5ec735516a62a19054fd807955ef892590bed 29 13debff897ef9476c388ef64b2ce3757cabc98d41f12221913c9f2a373e0210a d2404954049035091f3744875cdc0adc92e67b1befaddc02a3482565b7cc680b +derive_secret_key f822a8288071e8fbd5964ce4755c9e3314d01a934986e2ddf77952614db14458 3728162 e03b1cefd8b140bdd44fb2afb6dff23d9c684d3f15c4b489a92dd9551b8aa502 fb553ab907e14c88007d4b32fa8075c32e896bcb55bd3c624aa4949d09a27102 +derive_secret_key d4734ca92a189dae8dc61836bfa6be8d838e624ce1242155b4200c2b5130bd74 204972 6eae086f3a0fd49102861d260ab2dbd2a7f6e0d18695c12638c4da52842e8401 064c83ebfac71ec945fb6a6b478c1f151faa49d39d750c29cfc72be27a69a808 +derive_secret_key 3faede36e9f844af42c2119ef3d325f1c6dc1359a6a5f2969af1124e9ee05e9f 458 73f8953246e7e4df3b44f0667ca4d131c73654cd4b98a0d71eb2667236769a00 6a263a15f24176f8c56b090d895bb7b5a4c7ecc5e197184cabc04ac1d452520f +derive_secret_key cc1d64027ab703d6d5a8afe5e68ac23e801fdc94309f7bb88d8c533b288943f3 0 cd7889bb3f741345fcc1f09bb08c7ce920d19ce746339d5c963d50026b7a490b 5a8327cb1e6985315576e07fd746b829dc686e6e298569d46b880d8186283f04 +derive_secret_key f7a1d063f494ad003ad1e18b0c14ed428d29fbb929d0889e093c781b1bbf4828 4 385dc517c446cad30604c993b13d871149469cfdf998ce8a428265a127c47702 5d05e45db98a31417a6536e792b75f41ab855b87da3bb37bce36f1d2626bf104 +derive_secret_key 87b95ade027f2a7285677c1779da47fd49414a678a6bd61b4e4321acf4f2b217 13014 2a49a5699c511609c54edaa97fdcaadd64549bcb5d6e711c7a709322b7f62503 360666f1ba8f25d62892384af7a559f9a7bdee2a16f159ea725eb56e2e023705 +derive_secret_key 1dc7c96bbdff1574be5c40de5880546655a12637d162b7327b7f7ed40fdbb16d 1 d3bd3b2cac1efa21c9af02300ae018c1c1045ec1ad55aa392a9261e9ba63d10a cc8e1bd2a5095c6e8dfeb8badf48174223546917b0bd3b75ee83d716a2122503 +derive_secret_key 3494ae5b57abab789992fdd790771ba0bfc2eb54b88828376e582d5015a047bc 1343810 5e931d0ef581e985be1a8cd9f4f6778bcc454c63e09168fd038c4ba4413b0203 4caa7b4493a08f444d2f1e82c45c64633b7b5ef6b4a2c1b3c82156be93cfc30d +derive_secret_key 8d1b33d704b585a1c1721e3c633ee9981881e58fcfd1835ae338aec76b98b82e 70 bf1fc4f944689a14819b97e621ffe73ed46c6e03376a024334823734979db004 e4fc9c1a09259011458efa598d51d0189e91c2e5ca115b30b0695d1af5fde70c +derive_secret_key f72bd8fe05efa8377196977f3381ef20539528c3f308257648b2c583cef47855 187441355 3b86d5c1f1fbf381e63b1ee9bf8b41c9091c8cdb4ee4cb9b518d90102ef6c906 ea72b1f3e853d0ed281d1b119dc0fa155e71b28242d54e237314c44234e5ba0d +derive_secret_key 0c0b90d03dd5e422500d7540475143ae0f03ece418e2fb8efc21ed4a4f5bc184 783 28fa627399989a992464148ed83be2d79ad88569b845e024bae587e39ea3870a d550da0a1169274d86c771485a8872c1c5638538d4cfe2eb4bd9afc8c8324508 +derive_secret_key 2116610f3ebb0b730cd32308e3981c46d29d81800fa0bba216499adf6565bfea 2363 0c7e6a0cb45c3abea314d573a671b3a052c2275b2c990a66808be1273d2cde08 760b29c95cb3a351e1bfd76e5aa08cb29e66eb0eacae5d9df90447bf9d9eed05 +derive_secret_key c410321be072c6700f180f2672c38b8269edb188ad29a87579196652e242c564 744 3f73df9876a9a6139986954e48d1c5e9a8d76fc6385a96a67a8e15bd76529907 ed3ee5477faf56f75ebce759740ae043d267e49b46f7b962055c71664293770f +derive_secret_key 2a97d5181dcc3fdbd8145319e1bff891b3c4434ee81708af6a4e6dccd2aec701 21296 76b083462227d175143c84df722c199b123b3a57bad37cca02fee5f1defc6803 35620f73278cb728fd09eb98fb903a84666dfa6046b0029a5e0704d0bc194e0f +derive_secret_key 040d9c07357308f7f8def27ddb0bda18255dfff5a05333faae9c6b5b1a93b627 2681 e1e5a31aa3c3e108bf29ecf861d341fde8c19c106104e0faf84af795a9085700 8cf0d71ac651ee5b33cbea23a61aa899f5d5f94b8b0ea4e8bdc7e90fb0b10e0b +derive_secret_key 4fb81d88a888c1121dceddddc9cb6d48086953e2284b3c91f3ce18e25a0b3a72 26592686 bed6a3dbd324da12f2ebcc3c569f3a2b4d5586a9f943cd9c03a19853abba6309 f228f9735751a4c27517a95a3e2b2a73e4315b49d37453e1dcdb174612b60505 +derive_secret_key ad35f1fed55bb8770c290ddeaf15d584464702290a978135b29f7ebaa5bf25b1 806472 5dfef53fe2ca9de2ad87865c5c4322792712deb2b9b2de2f3b8fbd7c86fec008 5cfc77a531824a404191e155438acda4db45cf206d13a76e1300c49eb42cf007 +derive_secret_key db5eebda4e2d34297d2cb5c38f7f0bd759f06fbefbd01448fd9d5fbf900a8084 36 be6fa90e5969c0de8c0939ec69444d6f240e391339b427d920b4268fc44c3606 bb8fffe300074f4d89e13280731ed1edac2cc7adc35370bca7b0c18ceabf6407 +derive_secret_key 13140753ff934a699a8397308c8b207f06886c2730ee64f5e3407f96b621b530 1895 b3904221257affeaa23f163c81b5dc1b58602df586ff5f9f43e4142c7e146d01 e43ff3dbdb4927f3b2a50b538da8cfb916283c903fdd39be1430f04d238d3707 +derive_secret_key 695f20d615e5798600b73802d584521ac0189afb406c3f60b20bb743f4ea1b9e 31552 fd9ea801f0dfc910f67912ac915963eef5dc31aaf68d1fe5043784fc6a440508 5b9419f475463ed257ba1d2de0394a8e79ab62e46415a3b4904226ff39478301 +derive_secret_key 18b48028cb1a064ac4271196b298f3cab677a6b13602a5c6748a139e00cdd40a 2255 ff34d6e62f026d5d715e08a4418aee7fbaa1b8e3c08d7d740e81dfc4c404250a 142979916654e40bff815703f3450687a062bc128cd3f582a264d7615a944600 +derive_secret_key 438ccb519550946116dc4ba68d670f46eb65d84086e478a35f350db5735c4b07 374 55faba03fc8be604db066cbb0a5179821339521d1a84bf35651fa329ea36f507 8243ee979c696935a7774aa5402a614f4c1b756560c77c7dd1b4680fbebe0106 +derive_secret_key 98a4710dc316fbb8a76ab2308efe453f8e43be1e7df840004e7467118c9988b4 500 e8663dc916a65fccf71467fb21ff78952226740c833e06e32af0215ca1caaa0e 5fa6cb4ef788555938b88411a21514349b6a12c2fad188c19462b3476d23440e +derive_secret_key 9f2d2522fb0add4962177f96567a8e7685f03d2e266b5c2f33488291078ccf67 222 4de40a704b36b1f659c86cff07f8bca5ef0a9a0f428a3f9054ba3d766dc1e401 91c79a73f947cd5f48f669a68c9a4a7a7e4e0bb25533a67e86591b0793d36405 +derive_secret_key 3f1f7184a40f32f364eb7fe3acfa3dbf2678480566873cdd58cd0a973f3adfa2 17971 337ea5c7ae4ff14851eb0736874370940689911c5c91d46a62535789cfa7bb00 0fe3c65f1afda2fe445f64bdba259dba0de489ea0a4897a423dcd9d6d922610a +derive_secret_key a841f02184b21a2457831722044304ed5f2d85855bb4b9ef880409ad29cbcf57 34192731 e9c21788d0e839e409f9a21f609b5c02c382fda77f185b56af017b7bd5309d06 1500eb623318550625e04a5ebe896dbd4ca88fa1d1677869f18027cbe1a8bd00 +derive_secret_key aacf674706d70c05e0105a99a5a6978db2808cc97ac67212dd5399de5eb50671 3 986fea1092254d08ab56e83951e0e608ad9511ace7ff8e1aa9da1ac6e5f47c0d c99f711bbfa0b7303f9fb4ebb28ccb8a7e17c07e766ec994ba71461ebd549e02 +derive_secret_key 2724c233bbddf2b2289cd5d5a8f4d788ee5b836c7668327b4f5e71a490b23db4 3 867670c91684adb4c71a067d3e60bea19863530f18c7421c03c08717d0e7f702 68b3cad47026d214d07825a0cfc4a2a7a15fc773d58d962a5d10089cdce2280b +derive_secret_key 035a428055ada1abdd7e28d4d38d64abac169a37d7835dd260fada61c7e3d51e 1599700 8c28fb3157e21c046d60521dfb7c1839e48b7499b64ab80b3ca439a9c7eaf300 c26d68bc26aa732bc2e126fccbe927bd7f92b96fd49d0f2de02bc1e4e6b55e08 +derive_secret_key 0aaf8b67ed99040fa384a0dd544b327cd7fe9f3ecb7853a22ead9a54a9be6830 14797185 0ce65680b9a280751ffe5a85bba1c64856b939c66439faf908d71a7500322b05 eefaa4e3f44c6ba3d7bf81557fa81349573c067155c99c92e49f3938df1c240e +derive_secret_key dace393f1080e97eeb44a4a93a489cdf7bd652f009faa4a2e47dbf78d5502ab2 978686464 f6f95534d934fa3a8626ca8f2b339274477d167ff7a4a0f25c88846559ede10e 43f77007f354e76bb9a9d2e13ced7cd1ff1e42d32ec5f37471d63f010aefdc07 +derive_secret_key 2b30fa5e506b86bdc7e41125ef1fbd84352d76ef3e58015cc773bf7332de1991 0 cca53c64e9c5591c9cc5afc6513855c879d533c2c0d536af8e6c24b1b1f0dc0f 79da0ccd588161ce2abd93fd4cb17ba4e49ebc21aa48b536d8ea93e52b053204 +derive_secret_key b301c9b23ab883089c465e5e4ad096461e485850d90e87a5b1c75f089a464a2d 74209 c6b6c3e21818a12d7276995f223de8aefa16afb2c1f53833ae61f954a3daad06 1213aeca73f8ea63bd9a2e45cef0a85ddc4fa379f61572178d23b57dabf69d03 +derive_secret_key 4916fe07b030505cbe741973edc23e2ff2a2466ceccaee8a668818ea9c88c969 7112712 db13650830e6bfc0b6e6b6288eb660e2a1f0fdc7b7e6056e3daa63f185f1ac0b 586419b0d1e1d24757d63fd44e6d1d71e1cb0307df0f7d905a7af7a16642a80a +derive_secret_key 5d65b50504fdbf74a499b5bfcafe8360e38c46ae0c234cd04585847cee899362 49539803 86426073f3e87fb2385d179c772e4a82d650bccded32ac1c4258a6ad5063df0b 08d348b02d786e3adc05afd813afb3e71aef2845b88e0c8d22ec0dcce4acd902 +derive_secret_key 9f6f9aadbe4b7364190b3ea764f785c8ca2ec33fd7480c74872299af22998aae 2433898 9aa11a7dfce88ccf578ccad1d5d9c25bfaa1e9c1222271e8f7d9ddd7013c540b 38e6ce353f8fec8f12819f29b93d7a4ac5f5e99527dd608c74cfd13ed7f56b07 +derive_secret_key 4c303ff19317002fa202fe579ebcf790d6042092f748876f7a365239e1e52a80 0 a6efcd692853fc43ead8c82c17a4f9598652dba23568274ccffaea6e737bff00 02d7bcc95eafd1b14a9f57503b19944edd70c9b43fee6a1f71da3054a616630a +derive_secret_key 6aa64af464e21cb77b0bb644ccd6b66c9c6519790a8a6339f1a3fc05ca1d3770 3 07ea6b523a83ee0d3766155f0f565a4668c5cc65c8722bc60fe7742255e73b02 2e9d8e19b753736f5dfa71b643a6688f1b636f0a8bdad3efb6ca2df52c5eae06 +derive_secret_key 56ee4d4350072ebf3637430daf901e0e99d0347c8f39c776d7b404249a857fbf 1034283032 e68de07a27393d2bc19c60f95c9ccbaecfdefd0d0c44d506126096a92705010f 503af66e8a440d6e7b4a1aefcb84ce00417d708f5893cb5aaa775021ddc7a40f +derive_secret_key 7b3559c73ae51b256aa76c23ebec239bfb8ccd03a31610a7618eaddab1ef3ca5 0 4b5fa5df913a8979c249bc538d84dd875557e4611b5d76388fd0451c88e5ab05 87cf71f8ac9c08b6926c76a8c71cc36c456b6fbcda02f0fad9d95b0865303a0d +derive_secret_key 9f71e579044ab493ff0301c80411dff04337024318bf19af8f30c55fa826efad 44607553 8abda1a925d0035dd16398c87c9e5c7027e13b787fc2d5f8dc248363256e5008 1ed7b1e498ab6b201a8c25ac680d667939b60448e79340fd6ab269b6f82d360e +derive_secret_key d391054b248a0f524e3676729d0a4c255efaa5800e9179818c66259472b2c602 25240 19f255cb3af8db1de9227dc0f12109390a676535b282b1a4b07b0d8bfb61db05 518d9dccb7601f6d662fd7a7ad1a62e8ea0e8a0aefc8b8a3b7fe86c1b0ed7102 +derive_secret_key 509a4d7821e347f14981b6dc30b992746eb32f81ef0a12b2893211bb0d0a6f1a 382699 dea7f9f6613438c884acab71396e3a36cf4a0518ed0c7492b9c5357a64f6eb04 b9d737beab4b9dfb206001775390f4429d55da38ddbaf60630c044c466f1cc07 +derive_secret_key 9a11459b5b20f8e19a65f1b3a405080601aa4e8f38f15be7bd04d49d008b7779 605905 5ce92e3ab14df668336d216a76a24e3376bc0301b6454577169a7654ba56b106 3259dfa4d27a00aba238806299c60dbd0fc46974cab51e2534f10a684856a50b +derive_secret_key a118293834f4dd23564a6cfd8e03652f25513e3755f530db48df18f7b2b598c8 38088925 2c35d46223c6325bc232edc79d3d0bde56c7f9fe6a6934006f409ea1bf8db608 c8d4cbd65907d5bc1104dab2a61250dec12509fa218c0bc2e363026111efa200 +derive_secret_key 14addabde641bc75e5702c3e533c9defc46e0814158309922ed3d254b54bafd0 372637353 769938138b788670c038c39a789cf4ae01de05041de8dac6b8f6e20f145c5704 c061f89689689f8f709d8629cb1ac2aa5df0a5eaa2b3c137c3a7a06a47bd650c +derive_secret_key f0e04f48a64c141ec983c1b92a69ee8b181763ca5bd92ca06ed1973ca7fe0099 123877 99d452b9ed46aef84037e91d04c639145a0ef513464401a98757b82ea4fe1704 20818ff54ce09a01c60a85617f2d6c27f14117f79a7656e763de77e038b94006 +derive_secret_key c37fbbbc5e45bee29d31841d7e838d285f0ee86e686bf054fa035da90a8de0f3 11095 329897dbf40b0adfc2d6d7c30c3e62f6eda0dad311f18c01482cbdfb3e8ba30a da6ba063ecf81c574ce54509022b3f012f31090d37da1e1b553e79f54d276207 +derive_secret_key ba73e8d07ea30be78bbe3fefcc40f37b746fca7006ba99b3472d5dc9c6951819 0 19b19392bc32130f1e7def49454f2a5e8aca64e6e18e21d149f29af16db1ab02 5ee13322db943d084c2237b94295d19c8813ba097450f77da2cc00703711d30e +derive_secret_key 4a35a89b3dd409ce0cb7fc53b2484953cfe04fb40d0a1f9c9129ecff5f364373 46246322 fba0b8fcd3ddfd5a62eaa9dce1e3b74594db686e0f420be3070b829bb631a409 4c4414daa95c6935b785010c0dc0d0b76eeb18ca636359e73e4c251f1254e206 +derive_secret_key caff5e44e4b6285e39e860c4afed0786c7781f7ab32cdf9e0beeef70dc3dac80 11434230 8057fac8d5b9c66bc9cf390e783941ef02c0a3464aebf2d677fc4a61ddad4402 e11d28560f66b467f3b436cf0ab0886bdbd827a03b41752d66603cb4aa376a0c +derive_secret_key fbd5dea27f019304995af878363cd6f1dbf864a4f530c4af3b826264ccaac3d7 70132260 37d2ffc72417a62d5b521f22969d723ec7bfe5e0ad147fce8d9c87c3906fb30b 7a962c434dad167a553fd9cea06d826969c9cc9960be5c865469a11e8df1ef00 +derive_secret_key 1dbad3792e84d3904646ba39181a6604f442e6c3f54cddaeca5db85a8428e2a9 67765551 fb93fecaa4291e2055490ae5f47a2626c7296284d4730dd5da12ca3dfc290301 103541312be4057652dfa16f8dbda65b5fd7a21fbbf4939befc79db668c1ef09 +derive_secret_key 8875ad1eb19f1ae7e2c1896d95d56bd82ad2afadef88d5bdb7e6401febe31268 9583 c79c19a73a96d910cb01bfa364f9d60da0fbec268adaf895b3628aa5766db507 9453c9ee74e71934edb221a94ba05d9fc9c1d449f2530bf3ceb161b14739290d +derive_secret_key 5ecae1dc27f7cbfb963314c0232db121154705018e9f77eed5428105b6218234 25069 b8c7bb2560045fea6d75b2eb0ebdab910f03a2f974b12458ccbf8bb3c41ea10f c20f0286f937219d26a02eb58091506d99a706e9521ee4afc23e3dcdd61a4204 +derive_secret_key 75883f73434b7435543b3a4dfbbc550c63e64c0c4c9a834c6082dc89cb19aaf3 681 9031381b273f9280b8e69865d766855b2a6345e9d7c0e18992882b301caff80c 01e9aab52568faf879955151b022d11f35442e7dbcfcd4f173cdbd5bedeb5300 +derive_secret_key 7270a51592cf98d252f73c10b6c624a49ef819afe9c7b2cfddc2aa87202f7054 205129 2ac73de61fb3f0cf2e4cf1168fbdb182e866b1384e21823b02d13dc7e4848503 96c742b9309b91aeeeb03c093659dcf1fdbeb538b6247f0f741631ec75a6850c +derive_secret_key 9891198266f968256a6583ed30c8101f63ef3a6b8d1447b82daf6d1e72b08250 6573 1036b648cd81d1f997756ea166a3d10044332bbf6b0d3e43ae1aa2913e3cdf06 5db242d019a350015128cacbd73d8d58f0385363afae21b4a3b8d9d72d76340e +derive_secret_key 57f8c6b2ec27cfbc705812def2d1bb1f8375ef6b5622b71777ca8399d929a432 12 a09cfd081dbfd7f6f6e36f86476b785d8c40eb4f120ed49cf5b486aedbb52507 3bcc80b99ffd9117b97f72fa9aab8015cdbb2f45ba4cf7c443e0b61e0b3c500e +derive_secret_key 504249986363fc1267095df37f7d9112d87bef56a9c5362a4fce5825e0302777 41052246 0e0290f1c7f937840e53eab3c68d8eb03949f0d98b566e1268c52bf1a7f90b07 e102d9b539344d784abb2a8047c6ca6fef9134325a5d8a812b6bd869aa397900 +derive_secret_key c68c10078d886d8f74dacc24611f8519ab077409efe20a2aeb09e99c5080173d 13547 d2ed75a871d9afc215cf5c538938b6de0694f764b7606b1e8b565832d697f106 be39a03fb1a2490f4ad5e236f0b77c667f5bc12e94185aa47ff6b05a5ac2d302 +derive_secret_key d21c4455334f6e74c9fd398292387195482d2c01393a9f74682209c00e573c45 27416980 df62d785e9069b4620f8749375979616411aea7fcf36957b661cf85103dba309 423569dea958d83d6a3f85a0a785a40c9c0291d1a36f8dbb41d5e894689c5a0d +derive_secret_key 21959238c6fc2d5ce951aaa308847010bd8cc66210f20ce244e25a8b5ebca5af 226463581 d30e52e5e7c5d9e1a7b12da0f01e4f44e3a080a62150e4a030d4ea653859fb0d 1321cef82fae3c7b6df0a46aee34412697916d3baaa4ec49ba7208c7aa67a907 +derive_secret_key 4310cc6d0db9213655faa72f98fcef718e0faba76ef36cf0dcebde1004284a09 421444140 821c71d929ce0d2c6d7d8475f972bef6753e39db49c5f4b497a52b42f7929b0a 03b61063331303698a7b1bcfffe18bb8c94f9f9c90a2f1649db55712ef721f0a +derive_secret_key aab75b0fec457f28c46a4df5024e48157531bc8105d6a29eafe3e241d4968932 235684 7c3d53c69b95c735b7cfb918ca4963cbb50eaed8d9640550b4a653548f67650e a158fc4e6fefa4d28745b014985cd1f09a52dec6d36e6e7c3aada6f60d85cd03 +derive_secret_key 302f2de2394d17be18ef90f5a9dc363ad48f72c216aebd73d6420e7344b3491a 1308 95f4193b873a844cb2c2f1f3278bc2faef256afa43584f86e94d20cd24361109 6c5a08f32bebe891517b3fb2fda33caed68f3c201591acc95d940e82c7349a06 +derive_secret_key d6fdbab05daf3bce40e48fc237dc829c094f37f6d9d156ea48a282913be5df3a 255696 446e1a00c085d65cef24416904207ccdb170b47c160320a6fd0af6a5cb1bef0d 8f6ea1663373d112c4946c3dc4f9589ca7f8753d7720198213f1bd98b76c2906 +derive_secret_key 1ae1d19560fac6a318a2612e406763e7ce4249526b5e19bfe0abbdb1d89bd201 51972 205c18e14cc4eab6762177ec71e665aa8c5945a5bb8913f92eb6479e56c8bc03 5240166c2e14073d39737619d8ee949cc0eb72302da002aa94a390ae8d70b203 +derive_secret_key ebf4af354e6380f6e218b32fefed598411866162f22f5fe72fbad8b38f3ee674 13257786 d428802dc6fe698a31cfcc35befc0a434e7b032ed6e9c4c00fd29b769703e605 29af2c65aec91c88b09bf0245e0531d99b58faf9c8f5937c0517a7becb18670c +derive_secret_key e1c56a524b698234695976298e90ca414d633db51cb75c6d10054a22244c8b7e 4791 b63714d9d96b3ff9c468921b7d7a1e4f7853a386a4196ac2a57a74f904b46406 4b22d0dce1d109c7b54687bee941ba20077f41529f08d5bb7c56617bf3504205 +derive_secret_key e472599451ad37cec21e0f4e8ee00c58648c872e8ec828b6a653d5ecb408fd14 1 94a797866b99d0b74c5b5fe6e865984007770fde86f6cccc7212b525dbaea80d a7d65d1a1ae9bc9f0d73aa05f224d8951261f7d83e3ae9a952a0e05e2d13100c +derive_secret_key 3888620a82b463587ada366b50e30aa27ea4c5f50a581672bbcaabc34ac314c8 3218185 8b6078e315d9c023a8d230119244bdab4f31f7715748cf2f00959e50a7fe1b00 d34b832b6df66ea39ebcbb1004de4a0470bb8bad3fb57d3856f6053d3a897e0a +derive_secret_key 08931015d7e8144eff587aa93a9cdbfef5ff73cacb8dd25bae609bd8b0a8b842 14481 85c4544e75852b4e2a0579a57aa08f7a24250f7ed75b571008a3eb4290c0660f 2e8cadc27335706997955602a5773131a07f74200ea3a1a7b908fd03c160810f +derive_secret_key 52cb514ddda46a63610185d906c9a3bee730f12dd76b2ddc5ea7298b260299ea 18 d7fe59df24040d47b9a11680a7e4499319ee9cad6e089c8b1031280d0f302207 e13c7ec3abb6b24b9d423ff25a116f39cf1342e5c2a7d4639d4d2a43a8e84d04 +derive_secret_key 9e68f3f173c4eb86c216c023f5e404643d78e695026ccb48a1709ef7f8b356e4 756 75be6ef2f301dcdf188e45167d0c6470abe408a1651e7e8d4a07b7dfa1eace07 6d306ad9c43913ddf1e64f61f75e582573609654fcd7f7ffbecaa59fab332b0a +derive_secret_key 9d9f16c31e49463b712bd15ad4a53adc5e261fe3b0b21c229455c5d11044c781 11036962 5eaf9f0fba3d39afa3e6dbd3bc7e9b7f3ea017e93f36f60def67a27c9261d202 1bb9d4ed4997ef939210bf125b57f0132ac3822cacc51af7408fd2b6c8322905 +derive_secret_key 6438a0ebf2930fa290a4dd656375ddf7339f4540d4a44f312e1a634d7abe5ded 3007 eb7ef26449e74205863c88ead838d8c9a3f80fd0d782cacb4e5e87070309f900 f7e40167a1f2fda0e78b48aa494f2d460cca0044d2dbd5134f62ceab40e34204 +derive_secret_key 1c565a8f73d66a4c5134bfbb761dc5656d85b92005909e56bb3bc2dfbd2ed7af 1057212 91d30cbb3d9123d5ce68558d0359d99ff039aba7a29f4148f9595334f0b00f05 6749bb7c3fa2b8e571d9b5ab7a0ac4609a49bd5b9b08bd8233796025a4f40a09 +derive_secret_key ae6245000cd9700859cee95ff800f11350cd2090e86359c168ee78819d98aec3 33993145 7869f6d056981b095085211afa4c8ae7e6053d2fd2d90c75eaa5574cbc3bab0f bf6f687f821c39bfdcf6941e015f548dd831ea725b675cd77e25e6879c7d730f +derive_secret_key 64b9d15226d032bb8b9b887d60496597ae4d5433299a8a9f0ed702120eb3902d 1 d00c7913e685edf9c50c0b90ee64b22fd1da1da746faf6b4e5daecd6c1767b0d 8df41126c700c2a840e9dc01404f6a5379417614dea5634ca5b3bc86e76bf40f +derive_secret_key 1983fb00ec3cc628472ec8d91b99bed137e4a98f33390cf9d460185e682d988d 5188 b416236242e5ae69e2920d14d6a1baabfb80c0d53b95d33f7f24747ea3fe3902 225501aff1117ffdfa49aa5ce966ffcaf1918f912dd25f8bb6d164266135b500 +derive_secret_key 95e5d133b41551fe5615f5b690baa6935d3374d040ae57c2e4e5896239e125b0 23 25640598faa20c9e1bb201ba776ae252b3227d9b8efc682d84ad028e79055f0f 61a80d245ae3e4fbea21402d9876ad97116ec49cfba4b97fe442fd7fdf882e05 +derive_secret_key e5360736d6233700439ac27fcda902b6b3071886c9fe195ab55acdbf528dc50f 6150 613d73dbc6298d59c970ff2c2542020fee62b336ff5e6bd6aff713b16f0deb04 b366f64450a1f8c82aea16e94617576b61cae423361789573972a324d529c405 +derive_secret_key 83725aaebfd246f1ba04030e5f50af5a979946df6f6b873a9494cb80ec7a23b8 31922 12334c8f649db9229efa02913750d4b7565d500b4325872816e0a0a72e2d7c08 76a84d0de31ec91b2882cd0dcdfc35f751e3440d9c77a47d4f80350a3071bf08 +derive_secret_key ea9ec7488b7a8db8c76cb21b246739136225546b437ae454a5b66a907c0ea86b 15877373 e2ad6b8513e3fe69541b3ab208e71d79309de63fee29f970b53e4b6799212309 d8f5f77aea03fd1d5091024c6c4a182153114397229dfda23f58022a1c22dd0d +derive_secret_key a0d1fdbf4a1c774fbd95e5df13b83564efa45dfa7ad5cdbbdbfd28c2737fc345 99 a7d60ca5b812e995998c51847b416e16462e48297925957a795b6d4388cd090e aee51964eafd09f13bb668bac5b99a23964d13673ad0427de1491e1e9fb57c0c +derive_secret_key 5c4d9311da5d627ce2f3564641907dc45fb967255ee57405df0ecb3065823f89 2 6eb3a15978ef3a6477a19dc72fad772d5304400fdc4ef09f0951c41d40e57108 ef1abfca8cad1557c55fc74b52895b72a928abcd5ee7416aab63a6bb6c569f0a +derive_secret_key e99227148be2ebfda334232633148f2d1f222ee7c990c2d5e0dffe2281e352db 858 f2a4776abb56939ac587d8357cb7ffffaa07d96c1eb623a7e08ebba298879a03 cd5ab0e1cd863ebe1caabc4082baa741d79f8c28a8933f86eb622c8936ed1700 +derive_secret_key e6d85728dcbe8e18ca5f98fc57851ce38f95d6c52a0a3ee17b52ce5505262394 100 ccfdbb4c86d57f9aea1c52284d17cc286c196f0f93cb08931dedb4a10fc4ce0a 5d0aa23e053c249a0569b543cd192f4af11e925fd7eea84f36ec8ea9465cbf0e +derive_secret_key 9eec934e5b4d74db6b0694465d972a9effe8ea9a199c1c9be13be76b80a3f092 1 82c0e19ccb8ffa2c998a1a37ce929f13af0200ba21582d3b7eef3759887ef10d 82228a6ff30a9007c88802d74f7ed26458e64a19fc30f730b9aef2addbe79304 +derive_secret_key 0f43c1efaf302a47a664dc8453f88375acf082b26b3e52145b05b3794b738cf1 191 063a3a6064ce5160fe3ad65fc740886a251a6085ac7ae30ca850dd178e380e0c 53bdfcc7e0bec08def70ffc41c9f5dd363c834785b4091d6212793c5339d8605 +derive_secret_key 5c342d02342f62998e7e8646bb15ed193a0a129086ee56d675aa45780a86f00e 174 d3c98ad7c9768fae843a1e56b06bced14bd47fde6ab6e63fd20b7763c2a4b80e 3c8483ff4aa7fb9be8b2c06cd1ace6512bea9284c27ee89a772b8896ba0dbb07 +derive_secret_key 2ee448befb8073111b822cec330f8e4ceba4f9932ca1334105c0d39fc3ca2e7c 257 fe40b1cd43c754d421c15ee688be94130498323c03f8a6fc1f4028a026d40f05 c4d147e9471f1cd7c7ecf3c898a2bd673817e5aacc0a43326f41d29d354f0e00 +derive_secret_key 8154637273ee4d724444d5bed75ae0d5d6510e6cd4d6049ed52ea72942ea09cb 654751 fcecd8a37cc86bbbb8f5e59995de110cf2bf63f8ce83bf82197b0d23a0aa7a04 538f6c8d7995e7a30ef4f3c3e8177c82ec8715d74215c3e75ef5a631add0290a +derive_secret_key 3614a3a00b0126671d4131f460f81be0ffe9560220400a82fa3771eb89478e1c 377 ab854c3cdf3a8bc97df696bb62a382aa8e94fb12666273f0a0e85e3987c31a0a a10ccc6625e3db60bdad66c7bd3707a308b849b19dc2066610927d005f8db50d +derive_secret_key 20841a2d83df80666d52b2bfd7c8b91528cdd7a3013639b673c7a6c5eba0b20f 29567 6158bbba9b8227654bca316bf2bc18d13b5f27cc2779927b08ad3ffa3cdc1808 942d2840393580979a26e7d787b354ed5810d5f07615e984dc01468fdcbcdd0c +derive_secret_key 29cb7dcb017030f2b5deaab21b2e276bf12599014d2989c174140705643f0fc9 234647 75d34b8640e6a9eb478d0c3a57cd6cfcd9ad5c1d13c19d99c0d9d20f41139200 11c9ba77326466ea88f5533c57e3678d42141c2300ce35db2aedeb56862b3c04 +derive_secret_key 87081ac4eb79c97439d23e7afe327b955d67d9ed9bd101cd2cc15b1e99fc91a3 15232 54ce5f3b6c498e78e610efa7f684985c2073ad83d8c0f76c924873df81bd4002 a3959707f8b8bb9a8b831c3b8cec045624e9eea0891211a66f2108c194561006 +derive_secret_key 0307cc704d6cecdfe652f7a4f23132278d6cc10c27a553b2c325d3d66527eb99 9202 7aca51abce812ff9737258264f7ef2c1a2eabdc78524df1b79a28dd4d1c1f505 83567397a8451df4cd2a5cd53b038f7b188682e0a8763af87366e308773d7d03 +derive_secret_key 4fb4c853a6bcb2cb66abbcf961d4df4aa0c07fef9d7d8e648c12733793b850c4 11 b2f70782f7bac1daf71a2caf35708943776919de0cbc5c7ea8ec755b27344506 817fe81b169820a11c13937db36c1def72d6b395e01a3d97197b99e9c8e1f303 +derive_secret_key 2a7f1a0dbfa0b3b794a678d586a66c25e14b6f95e5b8d3068c7792add1961d46 109 ce57c2da6e12f032105b4113cb9ccbd5c1484868e74dafd7ad0b021195986e0b 2b3f2f5ec228c7800668f8a1e23b3ece41dfa471a0298ee03fb5784c6d718b0d +derive_secret_key 1164c712d5db8ad0fe44ff3ce402fb6b18e3e3942db125392e323714a0a8365c 106 ff3faa4967abd1bb54f83510c7de724f6fbb6f23b7efe72b2b32ff70003a1509 1c54368cf55c62f8b5180aecdcccc9aab86937a9290ac5a795513b4c29f2970d +derive_secret_key 3587d416bd1f37aa7e75d8ef7a078f5f3f5ca089eae7aab01ef013ddbb8f5e46 2840 a8c3c079034779aaf359bfaa6246428233046ab713bccae08a2a7500823a3c05 dcd3ccc5632ecde722d6084a353812cbd2a7c3ff534ff54a2196cc94db5fac0f +derive_secret_key 9e3170f6b808a5a959cfef85fba66fd752c5b1d6e8e6ae11c5027650bd7d9cdc 13 4cbdda6ad1883bc280016d7dd0bc04c3d6aa565c2e71dbaa6061fe56297db10d bc3f879a4d9bcd47a5106b8660df66f8ca83fc490f935192a1802c9aabf43e0e +derive_secret_key b5ba1cd4f1b6ff5fe0412f35fefc6e765135e3c0f722370024e2d9a6bc0759a5 11498 61966fd16192d59b1abf27cf4f39f4fc2a24f2bb093b591bd39e7da4eecd7f06 c1d4b6da11ffe929a7f51cfa46497fc1b1533dcd60740bed37e8f60fe68a870b +derive_secret_key ef3085c8ff7e9ddbd062fe94f09fe2e44cbb64467f2efb595364a79a023e7b2c 1628 179cab1ceae5934ab56bdd8480a3a57d553cf199aa9bd18774f202f8e1f5d50c 5bbbbb8f8d396b25bdd55e2823ff2d5cc6c28d6c89b40909f0eb1375b7693605 +derive_secret_key 14ea888e65a172d87d0ca1ea3a28497f36643cadf7ef6f826a229010b592039c 27744371 2ae8330bb871ebc17a0ff80abfd04c4a4e036e36e72055beaa754dde50787004 7d0c659c4d9e2ee1f3e066950e9e0946c1493994681da65a82aa3a1dd0236105 +derive_secret_key fdac08f951bff89aee7d2cd631d6134e431583834b8008b8f41ecedbf9b48bd8 859 7bd5e8960a174ae6a2870e0ca6f29c482e12a0553f16d78f520b6f6574861c0a 39ac610a94da03355d32798f853dd298cb6a1023b114aa7f486b6a026f2a7603 +derive_secret_key 6ec75b621f87637eccdc37f977c7582495a3e350bf702cc8e1b8dc70466a000b 2010 00422014e6169e553dc2aa9ce61a84edd658aca18482f7fc53e339604899c409 868a841f8f5cd6d0362aceefb3d437aeed6f854c85608c87025e08c1e4b34404 +derive_secret_key d5c37da6e8afec6d26063cf4426350f7b085eb7c3effac51fcf85f2e49c2186c 58001999 ac67abd7f4ed50e6e73926936f3b9f5942132be6f027d93a4e91c54a2b232b03 176da8abef858a8c6688f9ff9e7ec48e21b874628d2d993a70efccca839d1a0d +derive_secret_key fb14cddb5ba7ef56a53bb0177fe857e85056a8783fe4099c32285c071290a24d 606 160250ddcf0796f02eb3f43a42b9d5686d5d2fac2b5b7fc7c55536432d9d1d00 4d19cfc6bf62c74601d49aec9745b9850d12cafcb4c031758ca8cba342e89507 +derive_secret_key 4756c9b63c4779537dae5eecfe1c0a5b4b70c638048ff9f0c897f6e2641fe6f4 31039275 f1c94d89524dd7cf67fe3ebe809c8787e3c4ade0da6a6e08616685b2c335790a f2455efaee4a97e28caba0012c62e826e309ae85f9de51c174407cfa483e7200 +derive_secret_key f0928a8e68c23ff264ef029bd6dbd2734a45a0555d011059ac30ddb55b7e32f5 29 5675b446ae1e09a276a9ab542ae970af092f08480ff0a1abac243a8fec29bc03 2140a4f4eb433c3814295fcdcea544bbf84d639d10f5e27c1ba1d4de9e56b205 +derive_secret_key 6bb1d17879ceaf9217058081abe574cfe8da00ded1b755ee4cb16f232c9f6b74 2594 3b6f7cd68f5ecb7054f8e4549ed93a0fe42300915a43fc0ed762e5ca84aab705 20d3c954abb4e384233160976a473a96f65fac555c9bfee39067781aab443805 +derive_secret_key 8da44d1c1415e0b22a8cecf9d9d8a648e1a6827d299294bdca939881f397baa2 148312995 76d59f901950fa438b7e502a946d9c933ab65204df3b6ee3b159a9b3f727da0f d6967b1851c0de164803a83a8cfdd55cea1c83d18a776c00bf38ef972b238700 +derive_secret_key 14a2403a907afc490e1d4e0846119010428b9b3c9035395ba351d9e0e954a825 67194 2ae97465c5f9f14d6b4f52444b140f45d078b051ef935717564e8aebe46b3f0c 325e6eee33bbcbc1a75ea2ba28e26c82ccb14d377af737801680b17de479420c +derive_secret_key d38b0fc241636d5f198c0a9addbc9c63b7f45dd1fec17ecaa8ead0d204c3a39f 2827 989d6e0c7ef414f4b11faa416c0e5e20c7afae519daaf9dece5882316608660a 81d4f43c4fd8402ceeeac09e1b927652cdf810488650db9932da04cfad698909 +derive_secret_key 71b2737f006a9b4ed600326a12750394901d968352b8e233bbfc25fd20599222 382081 38a39a9ad935285beef3e145db85e1517b1fcd34a9e1ae80866886199b6d1d05 8ebb1f017ec00a3281b27a28c2afc401caccdadadebfc056664627c809c9a106 +derive_secret_key 332febf041d1db3b422298a56e50ed8fec636b42460e07e3f0d3e492f286066c 1112591730 9797ab098015dde707b468a38ba01c82f3245ac7c5acc24caeb6fc04dbc63004 98e181e10c7a94cd1d1cb815fdd80f8603819e610befe89210888595a94c9606 +derive_secret_key 45c738734841a73609f6c18770fa99a766376fc75a720996eb901d205be589af 1641286675 cac9abfac3a4c26dea454deab89e609d2f99adfb1c55e1bb668ebea611fce90e a22bb27e6d39354b5dce33b8bf8af717c2ce11ecb8c233be4abc0e738c0dbe0b +derive_secret_key 1f7443d6453cb01d65710e5c29fb408f8f16e342170ebf3c564471a7211aad32 1249448 8a7d9dc5d8f4b5bb070bacde5bf1bd74fd6f4fd5d11f6086d99ad0064ed8dd03 2a5cf911cb12c840bd8c7f7d5be053995877914b8473fc10bdf72ff41ab1c202 +derive_secret_key c0c8626f416ff32f4a11e8cf98282bc5f0623d25ac100885eb8c3e49ad0fed43 29361056 039257d76b72e96e18063d5f13b7f72ff9a5971f27102237a2f66a5c5844810b 8440745187799413e77c0830db746c8e2b77c76add6775e94687381bfb737401 +derive_secret_key 7905cb46bee84365799f97a6b274c5ac1ef679cf829d54d53871db2379cc24df 5614 7466b387d218b0f4eef29b3d32a4522add103a99d889e43d144a0a7531c96204 161c983afc6b7af137b7c6448ef28145ec21d8475a826c466be0fc9ebad7a002 +derive_secret_key 198730c73e485c3194cc2ef1bb51437fb75a031b899d980ce72467ab7e75855c 124047 9e69a9892f50717b8a11bf3f674ee29aef664520f04ad6894d3da1470faf9704 6296da9faca3737b0a2116e141c7cc2c6c25b71fd3498c9bdabd399e4adc5001 +derive_secret_key 794cebdd017cd0f5662d5461b492d1b6bfd24a84cacb823c7f1ee7b2ea62787c 60731075 c9154c56761a16eff14fc9ee404f1e356827b5e6e1e839a23c7f4bd759608b01 cc4d2a3e411c9bbf2b883fc631ef0a0155aedabebb250f1b60d070b4774dd50f +derive_secret_key 1986509c9af8469928bf4c0998be207faa728a58f558f4e58472ae311ccb746f 17556461 b23e146d6ab19b152f28013b86c473e76e8c3f9da7253a442bfc63a106ddd70b bfe77a0e41dc7a476bb776b782befa30b0897e22a11bf8f421ca7adae6cb8407 +derive_secret_key ab05abdd70b412ca2655a6e66afb090dbb0f88fcb29a5222e299dbe87a727e48 29015599 c3aa8d7a23c05058231a4ac5a9bf91129775ed75a7f9315171c7a99a48ac6201 3085643d28854bc39ac11853931b6d7d63708891b7648f7b70e4a9539cbeec0c +derive_secret_key 16326c0760a1a8fbd2feb5ce8218b011871e75c45f6eaa2e21ccc6d4ca378ec6 722601 331e71e4334aeaf99d4ce38371b1ba167121969fb60bf189782e4fb4e87f3908 11ecdc63032b1ac4a013219205437e487fc9a770137389597eac140305174d0e +derive_secret_key 15d3d876b90b230ee360e7ae3c1aed3e142cb5b55e5f5a7cbbbbbcf070c616a7 22720 cb453fc5b59c2701174ff8e720ad14f347c53777871c2b1999474ad74038ef04 d862c17b9f4e175b58fe53bf0ad57cbafdaf71926558238610a806851bec6306 +derive_secret_key 8428e52ce38b48f0a2ad2b34b6c0b2c6b36aaaf18873741c83e985f9e06a446e 478 e5d24c080792b73ee47eacee4bb734b0331275a8bc35170eebf463790d3e410e 156383809b178badb4dc94ad3ad0d95ada61af178f1fc6d6e74738622ea03502 +derive_secret_key c505505a0dfe7abaf8adfaf94214b117cc621488e5a0db972bbbc32ef3fa7dcb 0 c06a635f95d7576210535489cec2cc509c5b90439234ce3c1c5289b2a6a97502 c193e198664c6cec0bcfc6333dd19632e22a77b681ee0c3a548ed4d43dcaa506 +derive_secret_key cd6f0d46e8b0019397d5b406171edd1f249578909c04748bb9895ace6fe68755 978776904 c17194748fe08cf92b8f4ab42ae3490a4007f5462db7dde7420f36e5db346307 f45e7366711db4537b56ab6f5a07dbec964f1526a89504d22e47a1571252a10f +derive_secret_key 5979492130d554de66a4e377116be6813d1beb6f5e534ceb86908ffdc2660929 30 29590db2f45523959dd85eb1de5b8d63e3972a6270fa8a024515a6cf4110980a b28c959962c2ac45665e50d02805527417a99573ca2fcf71e9fa5328c4640d06 +derive_secret_key 838c825cdef495d93898af2a41bac50afca56848a1e8a5574713776bc90b78cf 190 d8bfeadb37cf0be64fb8117eb394dddad1e0dfb3e0d149e657e3230cf2367f06 757b0815911e25bc80cdbe6733f4d7258eba954da799c21a517fa8db9f77dc09 +derive_secret_key 48f967652e827ab54320bada68369a465c3a35190b73f8fddd2c2f6bacaf03dd 8653569 f687bd794da5a46fe97897e46eff49dcb5395e059664c0ff87ccdc71da7b2f0d 7a4be6c3ae43ba81f22c8b4fabd3979f7aec8691473b314c35ad267ac8196307 +derive_secret_key 3607cf27f98f1757b8e76a7a478d7d58516acb0b2c53968902daca7b1462609c 1386669 300db752fd55037c29a0c33de0c20676cf0f28ae56e25f06d811a39bbf5aa303 25fcaa0f5c89278d2fe0364d43ea52e0f4e3f15bd3d55e893c7e11e8b464f80c +derive_secret_key 359098f43d98b96afabc8f0e5f5e597d610b8b0856a5b5d11de86756f37483c9 15600 b46ac186ba172626a377cdb1eb318762da42e2e31abf6308a3a2bf1c0d37c40b cab9a9bb3149e1e06932fc26e5cb6f6d3b5dc15ce6ae70e2266363d692ee3d01 +derive_secret_key cc7ce6a58a04852c3cca56c960f1566a0e2dc5a62f1e208d3df9aca90e2c97c8 163468 2de948d907c87d5b9282f5a296be60ea1588e492b8ee5168c4524d285533f208 c89613b6a9603756b8055322710a4fd8b5f96d5da349a9dab25364e37cfbde08 +derive_secret_key 29ed24119a7aaeb63fedfe913147a14bd1c35f5571d622efef733af4f3b6af33 456593136 29ac9e43e1b48cb0d035d68721c2720f449f056f7f1950c0fb52b262a7619a0b 6eeed90d9d97fe62dea411cb67cb893439ae99b9ce77c88c11f381211611d707 +derive_secret_key 0be916e8a0a05bcbf1bece510cc42224e8a2d430935c3d1b766c271c31df7767 525502927 f9a0c412851afec8181964c0ab95e617ca3bb64b6384a8515c9ce3428ea26800 38ed0c0313a4c7b9f838ef605bbf91aaedd172c1554e97b1f6847ddfb4f43700 +derive_secret_key 0fb08f2e7f679f898ec1b4e6eeb4ed7c3aab345eb302b41fcfc274be62de45e8 16261445 740b0a697abac819f141a01fd37738f46f9ac6e2cc1e21a8997196f0fbdd5e0c 2659a7f16df29af0c3f4e74656e73c842d64fde3ff5b62fa40e035bf3456990a +derive_secret_key 42ad2da26ec698b38e799bb4cb2fc5f5b266d3377194471931a57691d3d53bda 4 69e12374056d28048a06ba68a73519afd6c6381c69fdec9468e6b1979f4c9507 b9b0b9488793f8f711f0f4207f5fb27036fb69cb88fc0bcf3ee490219c4d2704 +derive_secret_key 02509ef1509cd972e77cc910775930f4437541419ce86a40b422a8ae2389ec17 59340 1f120a335179f002557a38fdcc19bd622b6d73c038abaf93213cb90d5351970a fa0ca67d406fc850451b72041bb1c05fcbf2e22042c7489afba0ae8d56539709 +derive_secret_key 6768644488df1f1d1a54d51fd200e2fdac0d0a354d55990aaa09f0ccf6a3682c 2942756 fb85fa4e50aa1d10dcee27828e31c35e4a0348d8350ef13a6e350d853508e105 d7796ec4d0d28832b1786c2cbdff0fd3d2047d3e795c3d7bdc9b16eb70b7f209 +derive_secret_key 02d56f16d2a72fae1a57feab8ac4d918be932a4e4cedb284fc1fc8a3172ba8f1 922547965 dfe3d3af3298621c10874dc95ebaa591e1fe3a81f768e6b70e940d51d96d290b 763e168424f661bd0777c3d1d130e67ef9285b44d6cd2bb103e9233fae06bb02 +derive_secret_key 19360614fc8b298c78a6d8b46e714733775df2931fbc9bd6fd997904e68f2aa0 3731785 001063053a4a3208bfd7a2bbaccaac4dd1c3b779fa9ac94acf51927ba0e5830f f0d3c80b5627128a20c50c22c566c8a559c26631225511d34b522f00570de209 +derive_secret_key 306e7cd81b00431d1ad6b77f612bb525e4047a189fba6304b179d60fdbf3c1bb 183554664 3fd791aa9fc235a0d5f2717abc2f6f833649dbe0f0be2fb06e6205c618e8af03 1b101544a40afee59ee6a77b39f36c9640665cc749fe7276175672e11f73fa07 +derive_secret_key 0cdc862d27d2eefc8e5158a45a319e2c086998a255be5cc0b55b6b7eb2d42318 160 abf12a0a075584db0a646fdccbded1d8ca2dd85f74c007a28a2a0bdc02153704 246b33fdd28da78bffee260811806966ceba033781125385e30e2ed5ed763809 +derive_secret_key db78e939e7116b70ad82a308fb7de3c1c1be4acc5eb5e0af5058fa15750d51e9 5215950 3bdd7724c8974729415fd8234349b7b8f96467e897786e9334dd83f6ac5e490e abd57d43e55c0ffc465a247d8aacdaba0de87d8f6224aaddc62663762a0ce608 +derive_secret_key 24b0a862c37e05d166032ab1e0125c2792e999c041be8fc669529877f5e5b12a 204430773 f7b0db4cd783e9adfc1811434a02205631baa82db23ae1c22f836e022c04d901 03be8c2186f5efe9a19e7ad84d40f9e86d834c00839924b7911814ffb3da6f09 +derive_secret_key 8f29aab6d864f4048defe9351306c08b896f69b11bd7261778d8668f57e1e095 1674077 a78cb46c5d5621e513e50ef4d53bec236277d67c8bf2360f6ba9a5a7664d3d08 2ce7b86c547c5191916547b859c6209e4a60e0f620f8c63ae6c72c5fdfa1f80f +derive_secret_key 761db74b5f78bc312396cb3ca842727fba5b8790ebec9f2ac437261a45d0be19 148 8f6ec651ddbf6b9e533d8cbed9ff338da0d3519064c90a0e2f9f357712ea4c04 e04ee261aa91715d93efd764000b0201079765207234c6674fcb014e0d074108 +derive_secret_key dfd456b0defa69a1cfbf89f30489ed8439971f84480c67a00902c17e90ce6da3 241 56c4adcca2ca16e74ed882f60a997af56c1ae971dfff46c090a2939697187100 bc163368f37882b3369fc38cb8b5c54d92eaf8afec384f6fb739a5249d121500 +derive_secret_key daaf8ae4e34ba1350811f127801a9dadb7878fd8c673e3eaf40f124b47fa0da9 3107523 7300ccdd1ed991b9a8d1ef0d07b0fddef256359fac8c72aab2691e0dbeff8d02 aec9c1eea25d506a3bcd01d7983e157d1992c92d698846a343958a6d4808b70a +derive_secret_key a1a99a34560ce85c7a1ec80699f4515af79bb08bc22a10766b1d38b9131ea871 469112332 0042327b9cc50098b178659fe5b74f8fba26a27687f2403998e3b2331b64ab0c a84bc17b2f10a1bf4e95718bd082cbe95ed953f1fec83191a1a46c824986180e +derive_secret_key 67bd79e8e2551e69e4a647f8ae7f6eb8651dc183bc56a9dffa5a297e6147f380 248698130 626a8a276ea0447cacffbfd8c956b0a057847f3bbd77cca7135564ef35999107 d5ae5d27d15cea4fbeb283d7e8579f9ecda5927b9169470db17ac0275eb9f901 +derive_secret_key 8c5725820299b8fafb6c9ee96782ec3336ed47b224f9d92871fe293d740052b2 34152884 0dfe7c0c67beaf17d2a40f548645c42e325653d2027195806c552f627649da0c dd05c0087efbd0726f28ff7748e3fc809a3b50b71a40d0f0cd5ed29800cef705 +derive_secret_key f1c27278404a28811bd8249891b403eeffc97e4715955a40aaaa068b1a943007 495619 66fa71a7149f4aaf838ac5ce9fa91e07939128d8bb1db1df5d4a7204c565a504 b60bae360ff2dc7225bf97ef72a2a07b93870d17700429826e17f1134b06de06 +derive_secret_key bc9a8f57ef00dc02c43b462e67afa17271afbd25677a0eeb542f2aa2a58b7fed 872 7f2a890dcf31a3507b87d009a6957aba6aafdcbdcad5d64519e33b92ba405100 f6faf81091949df2a1924a0556de9c1fc688af86a6f26bc1aac8b7497423ca06 +derive_secret_key f9d7e1fe2e3f8399ccf14b788c3e262cf5e4a93346a999458698a55f536f4de9 220 e6d9c448bc86514a47f9f7f5b6854813fd2cfc9b039abdf08657051f8429b50b 93edc72e8a7dc6e202dbf2411c4f6a61ce05304583a26afe0914b3cb2289c100 +derive_secret_key a1ae2ecb955130240b79914289429f33d9d29c559d9b5f5852041aa7ec383daa 316730087 99cc976a3cb982ffdf34fb47ded388350205c4870dcb3669df6c14e34eb3e105 65c3177eff91261d0fb2cd35711b761648eed74054db09b2f8dc5a2ef0ab3503 +derive_secret_key 129c6960e4e6a0fb4e025f6133cf43abafa4df588940ce85863e85aabfc2e3af 6212708 7a2e2a9e9b185302432785b9bcbabbe5bf3cd436076f39fe3910033da885f808 abeed0110cf9e6acb0cfc467ec0d30e08193429c649442497e3a62745214ee02 +derive_secret_key a2395b3f9d230e98411e0d38e331f797a7678fafabd4544af9584d757cd36fd0 14455628 265f3859eb5f58578274ada9381daa379735644ce8b7190f11d3676d409f0205 4cc32b89db3dfdb8311edf044204402c5f9d35c8dc029c7c02547f1fdc982803 +derive_secret_key 5616a6a49767eee9c4b9030dbf21f41b016c2755d5518357986a62df789df0ee 53609 6e498951f795944f8f5a91538ff3da93dea91bf7274cdd9092e38fcc0914bf03 7a62c09a0b8f38d2654feb9c6a7ab03216550edec16abd91bfbbea5aecf6ab0a +derive_secret_key 7d2575f5477f589efcf9d53ee4ba9a13beb8391726cdd7e40f8ae02499b3c78a 10 d85e9f89ace5bf04cded4e70b346e1543d714599ce0b94b79fb2b4bb75a2a60c a9bfdff03e9b971262ee36a02b00ab6e708d93656568219f0e5a8c3a9eb86e03 +derive_secret_key 4da4e4ee43819abdd267c3f8e310b667113e7a3d132fdf6b4bb70ff371904808 66359210 938650bae4fdb4db4c5eb69c1c04a334352a86fe1a19197292faa73c505ebc00 04dfb1bf514e34d7012b499701f1c0c9eaed559afb8a9944a25c6f9d2b5eb902 +derive_secret_key c0e2516b9f857f3c190189faabcbff2c5dbc9fa87ca24ce34f5c5100dc852980 350182271 3c41348d2ec119967d26a6719bce2af8e70226c22856a84085c97776414ca40c f2dab7c03dfd959bceb2dc2ede2790433da4d622c52f441dc820ecdb59873503 +derive_secret_key 9a97f37c8dc4793ea942f6f5a311a77d480325b6743d5874ba1603999f16c3b2 1 777c0cedde7fd4fb95b8542d15e643801820aa87bf694a26b683909dad76000b 50e9d74519caa24387e3da8acc3d989fd77d714c30f4000fbd921939135f9c09 +derive_secret_key f2fcb37acc736806c52467c80204dbb82763d8ee3d930f5a1d3cb589f600fec3 396853 4f612ce9b8da13d45dcfed589f22b3864dbb758d5e7054628a787cf39a18a101 a27007b9409e24a1dd7b5e45e43eacabfb1ab5b59cf9bb3c5cb5abb94e92cc09 +derive_secret_key 4398db3e682d2257f81b86929119cf503ac3e211818ed6d24209563509eada84 1609603441 7c629cc844f0a5a954f5f1ff5d69fcc1c3b5849c6946634e889ce2e1b0ff220f 2c8319f1edb04242c4be2bbe59f5186e4ea5396f3a4e33e8226c17cc5edc750b +derive_secret_key 0b5116e8c70c7abe3934cd094f069bc6a9f4a8ac7887a7aae73bdfa81db40f9a 13 4586329fb2cb8a6863473bee7cc74c20bd11b5825041d2f832b81b8c9b00f904 acf033027a4b25b646ab93499a13e35c62533ff13df132419da8b80f26fe2203 +derive_secret_key 25d41bbcbed3d91afe1fa5e56b99dc035ab331da753b278f4a11dbd645ab86ca 1209 d194c2b90472b36d53ae61ce5b2347ed70124fc2cc5a8476f1bf6fa9e7161005 c50756735d44fdcf3006d26e50c4647c4fe5271afb147511b6fd18297e2b2d00 +derive_secret_key db7b5233f0d913f25292cb5957709b2b20cf2c4fb08ac7facce1879ca2a54865 1326463158 844c9e691a7ba328a95d2f4d11603d03e7cb589985ce3a83c76624e259076306 b2841211b99e42a5a662eb793f2ece6f360f2dca234ddc0aa97936452cbf9200 +derive_secret_key 1b9031b9872e48d85763f4b64be4dfd27c60077d1bc0fdaccb1d16830c306bd1 5170464 434e6f35320faaa9a2db608d5a14f8307ccd2e66e4325fad7de38fbe15d6d006 5e16867998db638eaf2528b958a0ff710471595f64f22a4c91e9c93604c3d70d +derive_secret_key 39bf63190641c50cdc41230703057c042bd97a3b4095c08e436ce9588363c668 216571446 fb04ae0c803ed5fdd9c8b4e083da8b9f8f396f8c840a93f8aa67bc7e66cbef02 e76d929d82542c2f7359a44ec861989acc6030482eaa6fddb47c5037cbc4f40b +derive_secret_key 32d317ebd2e3aa2dcb987d27e8356e1f49bcad6335f8e0929f4bf930e095cc28 368430761 cd17d4ce004aa76035f58a5dcd9ef422febba18e3e4c8e43ab9fb69f2bc64602 4a88954252739e6bbca1d527f8d60fbb0b576f977219f11c199d5759b821c809 +derive_secret_key 042522b87fe1b5ca3fe0dff43cd3c7c2dc3b126c68e8d15dfa3d5de59931e523 137110771 e7a668f42e404dbe6c798e85faf73b9084863ea39039dbd5a34dffafb9bbb50a 1049e80fc8c4ce42fee8bc65c64681846394312bf6f77dbe0136917bcde05702 +derive_secret_key 790ad0038a4d7e22d08f74816125cdf77fcceadf18e3af06708f9c3f6ec4d792 2 d3d0c3db4a57b32d2208ca4345e43d70a4b80826568f81c20153884028cda00d e400e6705c08c7383df6efa2c91aa011f4cb0af45966c92bed6d81829e38a005 +derive_secret_key 53fc7f59b34550ef4db0c3da379779e154c9914664cce9acab7238bba01efaf8 10521695 a80ad147f893ab56e1c60aca60151feedbb6f61dc56733b9b124d2d59aa3660a 9bee1ccffa4fb8c45eed3b932edda6184c4a1beacb0cf59dc4a44161620a4602 +derive_secret_key 5cfa3c6e2efd58bc1b3046ee8f3fbe3a53a53e6249e95543f0887a2671b91b68 9466861 44d23a83d89b5ad01ea241cc392c727b4604d353bfdcf6148163578cdf88f90b 7b12d4bcdd81974150128dee355f7ae01aa15242410b593ef1051c68220f3d08 +derive_secret_key 0ec78ba7de8138641c00442f509f7069fe2713e90e79e2daee520487a67b2c4a 34 dcc4c66feecf8b0381c43ba609290de28632c61a9d5d1d2b6fe296d423cce20d f230f89c2fe6f5925bebc1c226968c8dac2ee91f65aa9286c2a44d2efea5ea02 +derive_secret_key 108c56cfc260d1d9058bbed6003a76693f02e38bdbb20082435096fe92dd7240 172173 672d109450fe1384a752bb92d36d69e0aabef375a3f16536214833fa1c249e0d 7f8dc2dda3b587a7682e1fa8a5a67e1148f26d36ddca870d34a6d89aec9ed90e +derive_secret_key adaa9002d39c25eefd4721428d96aca99849686bfb44a6e7a54d1e448dd1ca8d 1375394 6d534ce833ac1b7671a342a3319cfee50e995c331005515438d32f0c29e5c40d c2edcd8fb7fd1545ba9d94dc205e356294bdb0bd87d363ed019747efa0d7e80d +derive_secret_key ce2f9e3ed8a5b24510669003b32fcb5bebe8fdb1ba17ebb08aaa4c7cbcbe4fa9 51425 683f18ac08e276c42bf7eb4b2e7b57535b37535c8bde5161fe9bf2dc1dc7fd08 ffcff61e36762c6249c641f695c85ac6b7c3315d93b42d4f32c70788b2029a02 +derive_secret_key c1a7ad060e86bc6d2f6470b0b39effb345a7309d738dabb45a18d56065e3663e 8476688 c0f9bd1efe3a96a2a6c447cf26d20d8c86cc8f692c4bed1045bb651e4fb60602 d0c920a2df75b6e0b0f4f91a873df3ba6adc86317911ab4ffeaa79929bf0f304 +derive_secret_key 45d3031dcf8942fd77ce550e0a560794bf08387ece09d441a83ce40e1b73d96a 1053 1f5afc0a5e4f3ba5f35567d6bc48d3613a08f7ecb9234c908055c0100ca10d00 22b17d37b529fb6247fc501010f72799379da29704c9214f22c9ac9ee2cc7703 +derive_secret_key 9361b5df0b09cdc5c9e0925c841c760ead7ce9884daf29f1e7c0c2d0de7c49f6 6483 18d23c328720c797905055f9e773d332fa41aa973316b0825058afe717bbfb04 40cbe32ec5527aabb0231b4945b34641ee5eaed54d9be1256232b1fba0a91a01 +derive_secret_key 947812508f072877b41b17a7a32eb38423815627e0244b499d6a08e3b7a3a439 997 c715efd181e95ef1ed5b41b2dd4d5dd201342b83d443f4692198b6fcb5d92b08 b3b88c31304e161bd0899c6dc2a8390782c8e75ed336cf029d375527bfe01f05 +derive_secret_key 2fe73495b78de676735d0ee13b8e80292caa43e60c05cf29d608797037c72206 143599409 842752a32e576c057efc3913410ba4adbd108748cd8415240064020dc8c8df0b b66fb5ca76693ff5bedaf750f3ff1cfb33cb0d6770a7c28cafdb3caf1ddc4b06 +derive_secret_key f539784167b49c4b6d169b2678979cdc1ad6dc01509841810d4c72e1d601ad4d 1322896 68d3e7c4a8d7957532cce042d76af86ea5276cf27f340f1dcd346872fd2fcf0f 1f6b7daff864fd5496eb522d77b76e8d1863ee438d0f1c48efdc1b6ab389e800 +derive_secret_key cdc501f495fe11d3596b265a926f067048fcdb409fbf7470381543062e954d6f 12907569 deb872909e2d3b30a62685d8211422aaf3651d0f280c5ae83c7094861114ff0b 88334360ed2dd127c4b90bcdd60a489a69b1d9ee1eb213d2fdc6b8f6a3d33704 +derive_secret_key 4f3687468d9d7f33bb0786a2185c9dfab790b65cb76dd45525599e9ab9ca36f6 57645 dd02b663e47ab73e826920278b8207769a9688749d8422552b1e660d81aca80e 54e552ab7e72c01efa74f0ee2bf5661f2dce1cd5dc163528e240c6c3b3c0ae00 +derive_secret_key 72cbee826e17d5f9f05632a44c806c1482293d60bde2bff6b5ca15afa76ff400 19 1a558d41cfb8bf22116652eb7cbaac3f5918dfa7191ff80bb8bf6dd5f8226303 4f32b5d18f9193c011e1f439862a84b72f2ffc49fb659a0f9230061f488b2a0f +derive_secret_key 4d85acfc3024345fa9243f20318052faaea6aa03d3c84e86cab26452bc357b75 302385092 b791136227554c2410049d0d1cc9698736d3e31908bf5fc83724452f56666706 be398b1db0e0e80a90b89998dd182776927aa944b8b844e16e4bd2037e218302 +derive_secret_key 35c496baf9648a894b2c08195afd11ee6d918383969db2e79eda9ceeec3f81c0 0 d44a6c9f9b3ec3eb171de07d7d96302c31204525827cdcf8991907c07f914f0a ce8fa37e0e83be985f7e9eda81b64ad757eec99f60ad16437f01a94f7f5ab101 +derive_secret_key 2d11eae53ea46731b2d64fc0e4070ce7d39aee6f7572c0209f456a145617fcee 2447 712885f7247b2bfa3e3aa1b55f7affe2329de764dfcdbc718512a1615c649f0a 5329878dd486cf4d9e2840f9587c96377c5e50340d47978685cb3c6f0ab36709 +derive_secret_key 295e45c6a73b11d0c84d0d10c6487b9ed4d019c4b8598c1ac87c4730e4cf2ba3 3225165650 7e68c961ff05055e52d0d543d6aaad94950f2100a9055e624a773906e1edf900 68b8aa47cb6e272d84a42c6fa2f318bc8471bdb3cedf639469f2f6f00576bf09 +derive_secret_key 0453fd7f287bf213d405ed037120393292b2d0726d803e2ca012b6a94a155cfd 43216 c4e1bba6eb7dafbbb8cd41f49f4946c1cef41308c50f3c77bd00e647c3ae2406 abc367f194c54164ddc2a12fc8d34bd73443b7f24f022bd2a5594068fbc87909 +derive_secret_key 2b2cbdee950161158702ca50d3d1a0e753fea37dd7e74adeaf9c5cf4cbde673e 114682 b5a575e1787ccf66daa488f1dc7f9a53b8ec376d374db416f8448ebb4659b60b 38987a4bee751123a1dfbc54606c27a384d559ed6e30b128daa407096fa50903 +derive_secret_key b70a149dcfa5aad6a7089b5cbe51a11b35fcda947b979a332bbce433e507b095 27274731 f1562590651815284f9baec75abd39b91bb1f87ebdb6ebf127e9e5c7ade0ec0e 84112d8ee760fbd6bac9be1a82441c739658b7007af74850afed4f9b142a2a04 +derive_secret_key e6500bf66cdaf7afad5ad17c9a4e79bf2383d4647a04311cb1fab16d3d551580 32 e62b0cc611daa1e20780fc1c636fcec116b009043c73621ae3961cc00bef4800 dd99fc9cafede18fcd1e98a07b73be31441599009f59caa8b674866545083102 +derive_secret_key 8efbfa753edcbd6634d7ef2b97a66947f3a58a42c2e38ad2c40005976f9aaf11 0 40db4d8b72cbe787ab59cd40d1473161f7b9603cf3dc8b85d1c8b933bfac0c00 8a354e02b8db7ad246b9618316239442478a39ad37997e70d1f4e3ae950bbb08 +derive_secret_key 242cb771fee0adc85cec44c16651775b21dd0cc5d3c4af61e0be1d3e4aa383fe 2626433 a46b9e4bcd0c94215120df5974124e925df219c65c8914cb0f1efd3ba5e7730e c26c7863e8e22b8dbf5e5af1f73548396510b60c767cda2ad5b00ddb6f067006 +derive_secret_key bf61015e95f1ef7e1aba568aa3eb76a5a4b2061abe8b280d8ec981d2a2e697ce 9885 3053e2ab84a8f7c491e48e948d3c314bf764fd7896ab5d318712eef8878a7004 edb3f4856e3b10a5f047bba3dc89191013f64a67255e331ffeabd219733ef804 +derive_secret_key 3b971a3e31e516d02bd24e200dead3e613d46e65c8cf59f73158c78a00ae6f49 240648825 91ef145d34a92ad0db2f3e9ee61a8d7d8ac6be62e0bb1e4c36b2942aecad6e05 4e1591b24316c62a4b92c6c3dd1b7b885a5558d1a0fdbdeefbe3953a4e4fa804 +derive_secret_key ac9f43475ed82432341a8150f9968674b811c9822c9efcd20f6644583e61e0fc 829584256 5b0f900e84e4a0928a4236b3ebcbbb062a738e5b329f27546bdafff5239cfb09 43c8dd239b11273963aa8374726667e2cff9949948b76118a7c9316acc45c301 +derive_secret_key 06f7d826d92d21ff3c191910e027b6d42ac42599b9ae37ea3234c916d0f15083 514924 2884379812c36a5fbdba8ceda6a6b99496a2452802612a89555c4417e5840d0d 20ac096ade244fbfed78256c7b6032c2a99a53f452a51f2446af01f62a26f50e +derive_secret_key faefa880bb90a16ea01d94501a4d83d631ced74223e48d16a13a80d369793e56 793 86ce4b13e407fb50b436fc00aeb8305b088db5378fabdcb87ebf59b092a98202 2ae725cb53c0ea23e03b13062c0c1c902ff651efc7c1ba9c3200111401af6e0b +derive_secret_key 02dc614ef9e68ee3e87946564b285dd2efc00b866e9c4a505ff5fd37147fdeae 27756216 a096029c4da8466831b3178a2f36f71572c446d4b3bc062764f33f1c1ef7af04 4581d0d5bfe2fb40916dd20b0fa2b33c41b32effbed5a0e9d61a373607759005 +derive_secret_key b39d86558059adcfe1312744511aa9dfc18f7f10602ed81e930ab601f1a19396 123 8b71d85bf31309b9095fd9f9a3975e8962dceabdac884a621c9a40fd9e4f870d c666646b13cc2d53f4f0756ee0c8a5e4f02a968d119fc42edeb114b1cf80ba08 +derive_secret_key 51436f3b12bd21b867189ebb38f80c6a8c6c0955cd158f07d50d175b5f24c6b4 4810061 1f9ec33268c37a16b571185058a2db7b9d536d3adb0a7df2c80157520fc3ca09 49b91a7041743fff226c9734078a5b0ab13acea8af3851556ca9365457b8b90a +derive_secret_key 380e959c727ab23c2a50da763af21be456e0d2fe1f8ce5450e1da68ae8a3fd99 19241631 f602686cb9e6fa92cf16c05784c5cdb961e43c25112902810803ecad8276680d 705b72116dfa48fd2f84dd075dfcbf39499b84a96549e85edf8b24f74e773801 +derive_secret_key caf74ec8c3808776a6943148006b750a1caba928a8f19ca9c34da4bcedb8542f 81 c72466bd671ce2000d22a2b8c487a6cf72dbb0c6761e4ecd59b1f73c4a42bd08 1015c6d041a74aad2c9b317da5beb6c5d214870a5c4b683e6dc35962857f8408 +derive_secret_key 1c0eb4a9d6a4c10422fd13a3b3e46aba54705dfb4faedc38ffe44202839677a7 32 a696969134d41920573fd79a04b42f7025adcaeb0aa8472a3568a145d9730d05 b4e318f9e55560ba72ee7cbe1f8116a328d2489c74d65caaf485971cc611db05 +derive_secret_key a13a21e7e9f624e34a2d9fe67efb3216fd4904f4c776ef0b22606c2d5f6a3e26 660 0327175c70a04c21ee47ce76d2f54240bd3814d23fb49ee97aa18720c4988302 9522a58186285c74fe7c09e986738251eabbedea55754fefc58486bfac0f080d +derive_secret_key f1386b408ec9906eb3d57d41e2b8af02933e612a9f8b2dbac05fa762326311ff 6217528 28e98d761c6203aedeec914c14117e3a8561a57721ab9452bce29767a3d3e302 a66b62b5ac53cca7a3e629a6df86ebe0c2eea323d2ec562287ed64003cac990a +derive_secret_key f694c0bdb2c74cd1de3222769d857953a05e0e297390d4fe36d26cdb88cc1667 1569243 5b6b9ea1306effef0b281d7aec05540d17d6aa8cbee29ad67af138d89bed2402 2090c72b401b57a92febe4412ce78b46594ce2e13a9121ccd2253483b3f6570c +derive_secret_key eda19757117657b0d1c0d4697bd18eedae54956a030fd331b3c59f1febd11873 2269906208 1f072dc0141813d105cdb563f75ac25e7caa8f18a5a71203cdc55a0f97c79e0f a8369543b200abb4f122ca918d99f249c842fce1930778dc152b5abb048f1c0f +derive_secret_key 959395f6eae1c294dbe24a9d618c5e1c8a954bd88ac6a36ca8a2386fb778e815 3 5c9d5e490a6e99a74726b7dd96894f88d93d6ce0ab9e4000b27ba5d9eb601b01 2c7026d6aabff03f1ab192e8e79039f5f8f8bc6daf6dd24bf43a7b33aac3440b +derive_secret_key d62c88378ce8373605f1273dad8b95e363a211b32f1d5c6660c34d8377f24a12 580255 89f953fc6398eddbbc22f522f1fdb23ac20aae790e02080bd4d1af272a369e04 407f96a8501af17de0e517fe09406f260fdf5faffd6c271c77f3eac66f22ed0f +derive_secret_key a7e960a5042a609550a5ebb4e92dac5ab1da84a4a1d31e8247303cde527d195e 0 cf77f6fb16a9ef56d22fbc1fbf5a2c18cea9f073fdaeb1ae76b4094d344fcc03 df50075177ed0f7f1d2f28c522d698cd1b4985a5f73c5ba120eff85b92869a0f +derive_secret_key d6408e25e22ba9a10632e0703184d757744a6caf03801e69cef6b67d81c6e293 1679856 96c4c1c29ce5d6ee8de7504c089c16607c2626421bc827f65cfb27a3d3ee1b0c a61063d5d44fcdbc9979e6add07a61bf99eda51d804d6068d783a1e4accab80c +derive_secret_key 2dc8c25a0ba0b4f573839f27fa306a16f20e9518fb97ac54f5e03a79b235a672 883 b64ad695c5ee220384ba374870c6f3ea0636d5f3b0a60147d3217349ffdde403 fdd71b4b64fded8a493d0e2a4f4dcfe3f74d38c69ada30070e84330f72ed430a +derive_secret_key c3c14b68e9a3b22ace5505922c450f285fdf04635b59e30634e365315e3ee45c 2329125 b6ec185fc75d125184941609324ea00410265a598ab6e4cf38fa0557aa48ec0c 87605eca5d45183bdc2ed0c564123913067c3554a8e62e592b2e97f693827b05 +derive_secret_key c4f05c1e05bb1310f213aa3a13c386cf94ccb458dac0f91b43adc39e9947835b 0 210aed1193e1d3bf6707871644b43fcd30611cd7f4be154af3bcdbae43f25703 6803c014157464d6bac12597d1e4a43665703ebd8ddaca376aa8e4fd66143f0e +derive_secret_key 43f4a4a4b1fd5b47ebabc343047e1a7204bd42d7ffb7d09237a2877c6a7be9aa 5 38b0260a451dada9f2e07d0b47866e60f04fda84b3469fb1abd6e1510ac2190a fa1531fa5faf8276134c17e760a20ca5d14b13175285072ac62db2157b0c520f +derive_secret_key a0c9feb7fec6d4b600f7983cfd50af76e7174035d71f871d00930e69b5d1941a 384 e122c15427a6c9f25b044df9b15e2cbe2f7536cabaf1eb2a7035be88e41b0e08 fad1664bd6b759733e699b60b0f8e10a2eed515f7cbeb05389e9971e8a8e7a08 +derive_secret_key a3a28008cba1ecaf190b901be609926056b2a0f6f079b60a4e8113c28067afa0 171 316588d086f5e99a2c915ee2f843f86ad5b74ae8ac90e17b9ddbd5b8be1e7f01 fb42598b07222a3e9176777975909e10c4d3a8eed11c93cc31be48eb66c0050c +derive_secret_key cca2a716b60e7f96d02186045954a24c38686714f7661435855a06b519968592 9469 9cfc768ae1ea813869e0cb977759c0cf66d0e745425f045e728f7f7755e7d700 67cdc93c4a34931adbca31fac541dbbb83e102633981fe5a15514bc8cb161b09 +derive_secret_key d76fed84dce0fc00392419d6453cbe540a5750ab795c74b32309fbe000de1635 226766161 18a6d5f73431fe61a7f7ab563ecb400f1f2e645f8af21dc67a7b35bf4af9580b 3f6ce0f5216804ebc2db173040494c69d3ab0e18513d5f3cba4875bb11617501 +derive_secret_key 2a300cc0c66bc939134a64d0c7647667ad2bda2c9617215a082ac6312aa3ef49 517850 bd18c8e907248bc5cf0a342af0acca3c22a8595aaf37280c61f0e4d772a9c102 4c07dab384e9f7a69789974fcc1296a64c1093c770413d9cc1b0e73a0e55aa0d +derive_secret_key cb99d2c0c11ae7c9274de77f8883bcc78d5ef2ed7d77cc024982ceac07cfa2e5 900712766 3dfd746c1318742d7f374508d2131e5da8117f79d7aa32dbc14788933781620f 3103a53e415e8044c484c8e38a756601d18c092b0e60cf20f833aad242feee0e +derive_secret_key a2eb32b0e18438b8fccebd078c7a8c419d76edd7a163aadd80d9cc1097da4845 683919645 8fc1e8972e4a8e4d429d2116c2993c3a9f0405e195d9db1ad6ee5c130d661b06 8287a1a390b3c726746829c8e6cecc47d76203b50eb8d4ac58cc43954558550a +generate_signature f63c961bb5086f07773645716d9013a5169590fd7033a3bc9be571c7442c4c98 b8970905fbeaa1d0fd89659bab506c2f503e60670b7afd1cb56a4dfe8383f38f 7bb35441e077be8bb8d77d849c926bf1dd0e696c1c83017e648c20513d2d6907 41adfba66b31972636e89f946a639c84e8408569492a5119d7a235fbd7a96804ebc6b4827d10f0a69b0b43ddd25bdc185d20e41c9291180a3a54332fd1bf290f +generate_signature 2ade1389a860c9249a42e45d32a9fdc29286c8dc0c8ea1216ba786c74517eefc aa2521256174ef6566618a6468c7b8a71ce2dca398be2290148b813710d12f7e 344a6ad0374b6ae8278e3f226d58e8bb2796e89141eb0ac37cff8552b158260e 97ac22e2085532253e277effd07dba071ed8fd3eb2cdec34c81b9ebd6404a900ff03b52d5d51a286fae6a2a43811412dd7681c19999722602842843b62e49b08 +generate_signature 5e91901e800a1959b4ec07a2eeaa3a9b28893029a26e8ef5d13adde490e5df91 486dfb4904d81b1bdaf865dc07ff71145d1bf8a9e0c160b9c817315f6cb30398 6a05fa0a97e172c9a8f5d2e24851ce87bb649a46c34b33330ae71d0d24a4e70a 4dbdd3aa67d152372c830abead3de5c0b42b31856cd8f19f54c7c581dce6b602881b701d291f7098b8f4a33e444c39b66ae50b57182aac8bf92b97164ecbfc0f +generate_signature 03e29bd7435541f8b12830d68fa31a8976a7a2750e4942f36cf834506f3f1b17 3a9768ff7593e63e615433567e9f2d7167a934a9afe7fbe587f0502942ed4ff6 b1b9f0cdb59910598538708eea87ad5114ee9eaae0bc5c62907688d6adc60004 e368cec71ccf503e67340520a2fbbf76d5a064e525565e2ae3a86dedb233e70e53ec3a40f5e0dc0f7ac026f731faa001f0038852306f1e173baf16af19f04b02 +generate_signature 5eeeeea12358c1ca323e2bb7f7c4f4d4f64082739f196e5505a116760af245bd 238cb505dcad22cca64e100b9b0a3133b44dec7a6a0abe198f6563a1df53a3cd ba2c8fa6cba86ddc91f810519281abeb43554e43ade7bdb3c238bec0bdd12e01 7f9598f10dcb8bcd2bea225a86bcb0791976d6f45824ad6c06a41c856985ca0ab486fe24061873e699e7371f007a1a7d165583ca18f032586ff6984a310ba608 +generate_signature f3f9ac0a5f5323f4af5441d5700f9d520e6cf41ea441ba045716b591e743cad8 73c0232f4a68d26578542b4d1e02287b995aef419200f78b3294f1c1dbf979e8 9758db88417ec357419b8e7ef2a75d2c65bdb800d27f6203aa54b5609955780f 58368b40d61dd72e811d3925bda152a9332a1cab3587d1dfd437b5ac057010035bc178a5643b423fecaf3fab32785976436a89129d6b4a42a131f959e4a9d903 +generate_signature 0c85328313e78623d436a1e3cf04ebadfd0178d4b230004469ff8e995fde6d11 c1429c3c7676607688349d6727135bb442466932035cda069ab2463b97387d59 1e58bd527b1ba1014ad772c523700434791a4d4c005f2ffb81fddfccd03bd304 c9de33459bdfc20e2d0d2238ea692f8cec8b9cad491d997405fa60fefabe0f055d5ddbfa39e704b1d2592a48d74ab7b19cdcc5de0f13a72eea636e22a27b5c0e +generate_signature 9d2ea8622e9d46d17a568571332f14d6be90a40df1aebeec20f8418a5f94ab55 f8b705820107149e4845f2a3f3bd045a55944aebf35d1104632450bba4141db3 d699d458752018ca3ca82433e6fac7547030990c923e4192978ef179ad4aeb06 45fd031c990492f3f31f8712885b2758fd0612fcaa59c6a6a178f854eec381086930790b63842590a04a60ea47aff6f94fc772da7256136e0f2edac424756c0a +generate_signature de9240454aec3ea2ae6e13ca9457e43003991b9d0f75a4b25117e1ae66617ea2 ef02c34f64ca98543ae5b871197e413a7ccbc008f2366a2552f2cb5f852d8ef0 05cfc28bb9cbe0c4d02d8692f40fcc864665b118064f1bd31a347baeed24240e ebcdb986cb11bb19861348c764e26e085bafb36c0aa9c4f16c077fa6bc926d0cd98102f4fc0223a482c8f66430e2ec4595c739ec291a3031d86d2094ee1c5a0d +generate_signature 806c083034f5bfc469e68a490f512a3c6cc3d21d043dc3f9d4941f5a9fac609a 65aa36a44250dc1e5985676f193b23119f7d5f9e0291e6643fa55ac70b1ebdb4 5f5cbfd6c2d5e22b703db1c64163cc0bb674a1bad00cdc77ee51001af5f8af04 46388f8a24890347dfb85d0877a78fb53049ca7c615525df66730387d9cc180378a2eea2ba71b470f18310abd0b6b5e9fa895b0da5ea9216ff48ed12f025da03 +generate_signature 413c368f9b4327907fb6bcccbbdc0540acab58dcf1a860c98a4340448ca4ef4b e37df5cfb5f8ff60b822d3550bdc498a7557e1c11d82a035782931854b996b27 4dfcc2bbad477e1cfc6076408fc85ff9f3381dbc2ca5f6b61b4423a29f372d06 d151fa8538046dd8c858dcaf45a9b1cc6fbce607b97f6e52ffe30845e31f220b7166a115a492342539a34ed08a1c04a77bb57d96f1f65b567e90767ccbb5d20a +generate_signature 3932123f3c95fdb21bc6fc74042f39eec45e588d707fbb7036983f3597382bb4 8b0138170662561e8b4e32f0821d21d187c62e7939903ee747aed3b1bb277d2c 649ae266093e93d0968f31ccf4d0b9307abf1e50b7d2b811f74c9b83f58ab00a c9651ee70677d92edd2589102f539274933030d00f6f05a2c0cb73235a08bb06f9077c2f6c8278db213db8417da6985f8aae08e6f93b44710d86a0244797a304 +generate_signature d17ab44dd70f88e19f0e8ba88a413fc18b2a1ce0ed712d6d110a191c9a284236 38bba4ea01a82f0c16f36f4f3387d6015f2c703cf211f6b73936db53645ef2a4 9d7af7de69861c61d3c8c6f2022e360a6cc8a647a4f3cfbeae6c14f46265da03 ac9b40c5e13fcc7d81378558d9c9e5e15e197741404e4c2a263807715d7fb100c4e4c71b75cb41329e3cabe6b18191a3de9d30f64cbd2977d83889b58721e50f +generate_signature 7dd81bb4dcd4d74f4c034a4b6a51a49662ad34a2687401ca00e8a628a298ef44 5edda4da92d8227684c8e30c940a9d4f9ac51c9f1e1c9216e826e6de3212f47b cd386423bdae74357991ad01bae929b6ba9d65803d00f06fc9f0ee34a764bb0c 339060668eb3ce21c16bf2942c4142a93923a30435fe7ce8e39359409c129b05afb68a73471070e9e975dae045cf16b7d923a9d99dad56ced01e5c5c3b47a908 +generate_signature 2e8abcd827b3c90a24a65d29e229b5bf59ded9b13ca77f51a98fccb37cf9775c 10df138936f814628662c2cbdb25dd7820c310d7974bc74314131f8423880dba 0d8d845fd386f1f47c4e92d6861026d697215a396f3eb7eb76cd478dd6c1220a 942d0ed063b91ffc7898a212438f326091d2288aaa44d7e2606b68282aaa73009e1f864171601bfbaee92c178a4697b8783ef34dc445a7cf5958040a892d1005 +generate_signature 83e42343a638dba6fb5d78e1b9c11e236425b432c77deac3ad098b93ad73f14e 3e855c996c5341e02e85737a2b03e98491037d91721cecaa17a83c2c4d5741f8 87be0823f5741f09e2f0c1a3337afddcf1533dd10e0b28efa8b1147c9ef3a703 cead7ef79b1f6b72b59cc12f5074e9cb36fc63bbbade09a4ec78aa894903af0f735a3b552c8df2edaaec3fed47e7a9b739c766036bf43a1b4f14b4660f4e990a +generate_signature 206fef6045a5e44f87bc7acd4bdcd271e1c55cc8e42f5943f1f0b1b3dc0fcc54 9d32cb01bec30e0d7dc921f1ce44b5a829fd84c37e4304e4f910cb9df501af4b 8adec55623bd61bbf39d72e3f891419b5264af1bfaca43278dd86a944ec04c0d 5e2d5355efe9aa2e04ef836cd92fcfeb269930f3dd194533a4d29768bae62e03183b74c64ca5bdb76f2763473ee10ce9e7227d630e4e2ac6617f1cdc7ec60f0d +generate_signature 0f1d0617a849e1266d6741e17e8fd8a4af392577ba27783ed203377cce7514af bee8f6fdc7360d9acd4a4076ddb2f572d9e9306940b39e5bdae031db28f201e4 95f785c3db1b8ba26e660e9ae8a60af20a00289d984a83c852482c505d1a940a 08d017ab97322008141dc15db28abaa92bbb0fbaaae0f31e3b700eb7fd136c096fb004b703177cd007e5c9d6e963c8b64247791ad0889c7a8b8c748858490b02 +generate_signature fc47da4563a05a5334fc291b1730ccad835e9469f417987ed3d95aa041ca2aaf 0c1ad3f7c9e60987a84a3525a4dfbec5ad69f276ecb32e3c0880ce69befa4810 50b84ef4f4178228d07435d3105b0fe52ac7d2bfd38da43875579fe65a7efb0a 876f0589f7d1272022999b3545fb8dc1cfcf62c9a2b04aa196fb8099afd30f0270dc58c1735cb0b1cbc29e53b10e9dd9975be9ca7b656e95e0483c97dbce230d +generate_signature 02cb1e9244aa1f6736d8aa1d5428b30658756bd318bc938d5fd704d97e4a5d9f d52a28a31f59208e4e41f6473e6bd9229ab6a809b228fae3d8f0a6bc3a34eba0 c6fa9ba77466112e1d268891c5cee9f88d091a93c06cd4ba23bd034cb3d0840c bc7b429861d39a6383b830df49564da9856a1a5b7df9a6895fef0d8df75cec050083d7505d2e19f89dc91cc598d16e64e494c544f1ad7453dfc835b70247fe04 +generate_signature 62eb41777076bd1a90450e80e77cb1aca6a5f08e2320128b704b663402759d01 8e83ce60900fabed38fb560505d26420775f10ad6729b209992816101c1c4cae 14fcd95cd127e1218c11fa267c46f8c2d5c1c736e53f8bd2bf084693d1114404 d689be63dbd3b31093605400348e1d6a7325e7530ce650c7adbbfd11f5885106f9372cecb3305de28621124e25fad69942a304c16338df0467b3707869f20d07 +generate_signature b862759c98652ca2b1522a556729103de96cfe831b3ce615547ba70c5f622c0f b7827c8b2edc9b4014cf4421f1c9792c012ac3264b15204596652d5854bc7673 1e62f5b7eb5d2bf88032c98edc74a9c138969cfee15f4cb69990feabc0f8840c 21f9b422fb0575bc0416549d3695b106f2fae834196764800df0ef6e1e5e34074abbc54b65582daa19859f5c029d51ec361d55cf7f3d2f336f63bdde26fabb0b +generate_signature cd35a8dc333ac5f33f3e12831a0a2f9ee03c7f421dffd7900b7661e76b056f4a 31ea2dbe369fc7a4514f3f826cd259eb8baa6bfbf22fbc2ef520d98be6e821dd ae4ef972bdf190ee205caaee156166e180e054993709bed5ac96bfd80e8b7401 c743c58c7f4c27a3a240d9d9d2107fdb176db92f9e95e627fc6fa47f170cf70e011865a8720913fc77efa1f0a74415c8e187ba42a093cd0ccc5ffa0b20410307 +generate_signature 5dee08dd0f483aa67e0b2539c362eca5c4529961935d56f661ba641e5efa7e30 be75e0ce86b68a72f7487fec4857a7a6a188176ebcb9192123ff98c49bd2b4b1 b13ba6bfe9c23671e7bbc4a6380c1ab6c61b09db58220d28781d8ecb1b37e609 943f654c9747d760055a4a7f98186a374eea7257e638e567f0497b4777e0d3097c8fc6cb49d29672dca8a9536afcc5921f716b9d0755b62f169ac7b243c5cb03 +generate_signature e88cf519e819375fc59bc8de8ba403278999311c7490290f2f5438306bdaf339 ce99f73115a02e03f42a1b583dc3cfd5fd1747c1400d1b6df73e1a3ddf616932 0a33216348544ad80a652433253b6921c0599d3a80e4b2d4a0477cb121e08104 3f0929d82c19d7d9ec2a495960315124877bcb5398ce6c27e4088e1c495fb70bdf696deac9edf202eaa4ebbead7a6f12517794cc33e4b9dca2c8236b1fc3b40e +generate_signature 82a2377ac1c6a103cc0b955ea1ed3fcc41bbfbf6416b31984f28aaacaf4e2a94 535ce02ef72e89bd86e0fbd9f8f0197a99b11f81128f5179044e4e6d0f5f1a93 dcf1736d7a4306330ffd64315b2122c5b55bdf115dd52680d5ce798893b62a02 a9a71249372e01b2a126cde62b97e956044cbb60c4995f440eb7ae4d1f81da0f655ab67f279fa8f7390d377b79dbeb575577e685b89c5446700ef3394ab22d0d +generate_signature b207af5749179b6f2b30f48f2e0c19d90b6655cdeeb3fc37f656321f50ab1508 b2b43995a5ad7f51c6c71d29e1991f431444b5e73019b3d36fca05bc566bcf41 b1e043b1b9f4c280f798aa59c2f62e46c4abbc65ceb17349f4d11b867937ad0d 4818ceb75362196ae48d16da6069b7d603330b010dc7b471b898635c4638e30d2e4d5c22cb98cf66b94e5c924531d22388ed40b69ba64ddc1d8664df56da900e +generate_signature 63e53137888836ef30cd6a93d34a0fa749fcd9459bafcf143da29956a6f35060 4762dfaa39af96a85ae746326693ca87d82a008b96c84792ed1c570abaaa81b5 723eaeaf84c9dae7476aabdc5fd409a0faa7c61ba8b424ff78d299b9480d5a02 b051fc13c69406d5da0141e0087398273bc45fd732bdb90e38acec452b237c051fa4cecdc3677362f64071366e5b244e991c20e406cd2536e60990b5a6e71a04 +generate_signature 4cd5f4b8cbbe735336d469aa8f2f7c7e5195d60f897b9a81b599b2e045850705 4a6dea121c196f56360e8c17273f1b94827efe1f24cbcdb9d3ed61b9a207b73a a8e62911309f4d4fe0bb6284fc4e3cf4fc5b08e3812e27328f68c2a6c278440e f771ebbe054fffaa12d29573f25c624d88b343dbea5ad4992753b730254a2403199bf703fc4e3629a5c14c675893bda4584c509ebc62c8e2e453609f3333d506 +generate_signature 7687ef751d6533aca6c911d70bbc4a8c5252fbd3112969a9a40b9e1dd041756d d17a5002e137731bdad6600b5ea02b520efcd1005008c6f1244deb839ea041cc c848b5aec4dd76bd8e33c37ac65e884699fdd7b5c7a905801f2f46c56f783005 ba7099ba5a21f70406981a9b0b5ced6895ce4ea43d8da9fa8d4b26fb5af4430d5d36d7ef9a3cc36f0627978b546531cb6e28c9468dc25850650fea9fec092f02 +generate_signature 7f75ac1c1d1832d78136ae9459b070982eb03e91fb4b686f17e60be644127d2f bf2d56a4e6d6f7eb153f31bd9f39d23a9e8d06ab8f906c716dde473fb2d16554 c901408e3a9a52cd7b95db0a8a5550aad0af38190c082f5d8228e5587367f500 e5bf769d9ec203f32035249c10da7236da8908fef78aeb6afd7bf1229b4d9206e2fc3729692af87293d3653637847975357844d4627a88d3fb30da8c5c1fb502 +generate_signature 1772e5a77a57fd69d6ce9a68c81bd9c4f81579741103a177bf584819a656e1b2 2ed6932a62fa064c9c2e39c7ab0ddbb6786dc849286af8e35655a58cc9be79da b9446a654072103d6e331cea1425472e0782b532ba9e235d61ced65ad6ff3705 cab455a551ca5771af30c75c9972aae9fde4a90fb7b24e5a8b78ab4bd30be60a129838221fd7ed56e614c710538b27dc39c1004ca8e271af0c2c1ac9bc5bdb0b +generate_signature 8bd02d71480ae9f17e999ca813b837402c999bedc4374d416e6aa9e233818f7f e0380564647a85532bf68ecb662fd8299921c8c51982b6310b4a6806bc056dca 9df00a62dfe8ffe27a34b7bc6a24a10d7f147d620f3ed78953930fb845598a09 1f014065e83ae2a42edee5a7c4183fc5102efab8f3d2a3ca65cd1c3e7776ee08232ed12cca6b5309890659261b9dce4c009f4c3c9b77d8dab30597a294701002 +generate_signature fda1233d780d70dbc9580c2b80ef1806a8ea2df30c317f7891462d96fa4d66af 5f769cca4be9aeb809e9803160b179b1a7bb7cab0e2b0f6311c9e29a8db20de8 076d27b6f85be7acbfbdb38d1b22e1d75c139072f7ae9d33bfb7590b474abf08 4600dfed5e02f3115f2450c0a19ce5c755bfbd57b11bef8756f6d7d04be3760419b973b1580625524dc3ffb8559e7e3051642da3ab69a051e886b1feb2a89a0a +generate_signature 80a147a42fa1e4f83d3915888f5c22ad71f92c0b2e1dbef9657330912baac097 add3133bbd5b10f3b34304864277b2a335b3625afe0d188ea6f60ba7302cacf3 911a315f1f7c21c97b7dd0385da95b6bb06de39796a538d909d51bfc07439700 19d51a6825df10eaef009e53e9efe3265c6016947345e148b25579dc45c8fc006bafac3f33c5b210860da6e2193be3f32f91cb26a2576695b2d6003cd0edbc05 +generate_signature 870ef0ebf5756b28ffbdd4cb65c2abfe6bbc366408ba42940376e91c750473fa 7c91e023da55901252f69ef58bf56329bb7ab688f444df00c1dfa80916a1851d 1752295c9937a10004ca9884b676bf4cd5608e4fb882f733ba1d91093257320a 1ac31cf0bb8870192c82d9bfef1caf1e8eff59f805696dfe7ac54fd062d9a903c1688320e27eab378c69cd017c965c9b73ad97bdb655c50e383128d26d68e703 +generate_signature 711f84e938e19a461e28c770573ba9220b84b233ef6494e1600b432333bed7e8 2fa1edf5af46532c7d290322f145d44487bdc39de5b60d365f9d2937de5bc4d8 86b9d8c1124989a8d5704873ee831f1620e580799fd46e507e55c9dbb2bde40c 55d08531dd7495946b4fc89b28ec041eaf54e703b2f38faea6c662b58f3f48024af646ea9c781e925e9b032709d40713debcf917db7ce66ae98c7ef59e772a0f +generate_signature 182159820cf794a0a367e94e6181cd2bce0aa7e8628c89f2aca4315136d58bd9 6252042e2d1f1694b73799d9f4bb777e7019ca1655c73dd79715e42f473f6c29 f34fe47fd0f4e59854e9b1740c91336978ef9b72bd07b2cbc601319adb261a05 947ea276f779aa2a0a56026b5ac48968cbf7eb42e5f369b35b0d6139a23e5204a75a70f9ab869c7b4a20e2c916c92c9ff2e2ed6bc9e359d05b0c3161b82bdb08 +generate_signature ac1490c8b703addaf061bda16c13c0ddd4ab06da053317ebba240be4e794b7d6 14d9ac957f7b65d0a8e55488d62a60325caa227bd28aec1d6a4f7fdb83a2b6d5 1d9d9a3c2200e2a127b68b06b432714b585dfca9fc8bc46c44e1a7fe7462fe07 551a5d005e3ef55273c16701435d8e3847c7c1c20df3978900308d37da64a50677f004c9d90cc1f457f9f50176f6af997b102d65af194b57a1a7f683ceea3c0c +generate_signature 6712b724736993684f7380ac03ead9b3df8c8d0f131d4ea99ade9d153671a3ab 69f90161bfbeae0720a5e0463f15814ff8267d8b742c2eb612f387f08cf32c30 74d48447a77283726f32f5e726074f1e3173d05a55b9e14796d2ea5436f0ce0d fc0854c64a24d2ab5441da978409d1812e3570ffcdfc7b635d208a797941380b21577620eab0effc14b78eaec5f8da471bba02dac2695d5576a338f72f8dfc05 +generate_signature 2796b04ccbd3ecb7ca3182d12bce035edcc049e6eb7226977e914c22b406939c e02e549729c483263547dfb5e4280d5e4ebe90a7140c79c0eae07ddcd91f2266 a81f6fdda8b3c5efda411f6ae5830c151c1e09ddee44fcae52128e2b4fba540b 5f520bcb0072fad6191264f77d70de5720cc8fff1a0c3b7c2f45512874f58f06df0bd649ef3fb22da23e018e2b120c170e1aa03f107b88434fcd15c3d7827407 +generate_signature 6b07f68fe4e8de6a194532606d0f64bb2561abd14d66cf4dac2526f8a5f40763 e21eb4c04c5abd7c4b12e434560c636a9c0fb4df380a207a93321e1865a7aece c194dbf0de2af2b96b1af7fa24b4b29f1291088413c9f26ed98954856c411d0e 3db5294a7b4c3497c7aa2e994244d155c3c8fa6784482095367b4c0000e5810b22867ae36011124356da26203873bc00a32dae2d9933f81692aae5961740d001 +generate_signature 17bf7d4f22e2e16297c3105c5ea01f9d7210b77a02d2ddc8d9263b536c1c51e4 94fc695c28959e0d68fe1dfaea0bde1a2b11be6eede96a4ab65b68ef0a98c082 bc021c4b80b42671b43227544c185fbbd90d29b5d2f110d5030aca995d0e2905 fd3ee4bced7fefbbdd768317c50b2d0b697cf4f5481ccf21e3b9677c0eff660b92488d51f2b2c6de91fa0a409df8933a420af9c649d241d6f26991a5699b1207 +generate_signature 0833ccd1e71d03cf19ab214685f348fa88e711bdbc6e7106047b64a151fb6c57 f6064b733fbce4e1200382adaf77d93c542a673573fa492cd4260fe28b14ee16 01f9a1785bfd24fa38af0a5d0c8324f8946b9d0583222c53772e69367597490c 555e6c2c3179553ef41683cf98050e78d580eec4feb0483e6724a79bf091550bc18e69035297d9b622b0b079d66c33472a3eab7f29fff3084fd3a377e95aa708 +generate_signature 2185872fb1e5cfada7668e6914ffc05f1c5fde38a7319e79010a8c1fc1c2bf28 23bc7fc2dcc89856410f5f2a006f4030d7880226ec512f8ce22926c569b557e1 e8ff76b5f7d00a8b8e6e2fa40b7385dd86692bb197cbf1220f3b59f00e149604 0773eb40a6b4cd588a746cf7b1d98ef2b012e89204d7d67dee14cfcfb0b7f00a9e5fad263f40b4dd80f5bed4f238125f9cd8895bf0ee804465cd9d6b8bd7ba09 +generate_signature 690194220a436c23dd6863d2b7ab4ac41cfe4ec6a6bc6843f1efd4388f37ee46 950f222148c84dbf4d586e7f7a2b53fdc43e45e034d0363883f50059302e5074 46d06e7cd27acea2c4094cbc3ead11d40b800fdde1a0fc1f687048e2b7ac8602 7c1844d1b9f5b79dcab032ce04f41c98bba449bbeefc16518433d0c9abc9ba0c3bb4c52991292a33e41d547de839451356988a36be1b47edfd5c9341171cc005 +generate_signature f2f674fe63b53dbeddd1966c2b3a3fc7d647f63190bd0a183908f782ee65b60b b75b075e9ce254f9efe7baf09897c5f58263397a0cedd458ed8c123a552e08c8 5f2ef89fa9956057bbd7654f09ce75f82188214ad1c75d8a1edb1f954689310b 7b01e326c3253e9c417ee74763584a12e1f6810f567c33fb4ccdd9c5af22b60b60be5d7c62d53afdd3525abd04aadebd8655a345f7ed65382a2e3ffa628ed909 +generate_signature 98e1472b88f2580a68a4b10b0634bfdd859590805b67e9b2cf8b76be25c57942 1edb8eededb14db7343fc79bba30422af90e92c739492ba1abca24a33808668f a8e7bac4b9bedd6cf89f709fc97a5d9c7180cf8cfe36fea26f3931192366d200 0222e379d7f51d6c4fea45f8d4191c586e983bc5f428e6665a62f93cf160ef00460115207f0c3650c942bb7d66846df8f2b520e644fd47098cc182a1e557e200 +generate_signature 1ad499a52576270197f365c0268892d44b73e9130f70c5fced7746498ef531c8 2394d9a89125d99e13502169301dedda64cb38509465e972b6f20c7f098d851b fe04a7d2a3e4e8c2a870c774483ef0b122b8c01813914e59042fbb76a59a3a07 770f748be4ff75c8bd2ede1677d97e69dfa451942e1cb023c912034322d6d507a53a3c3c794b3fbdbc60a727f4498220e1fb88d4124c81b63561c0ca6c22db0c +generate_signature 43038508a053508376f5d0595bd8cba556610e673b8291a322a2b9c72dd4b214 4934f2132f6ca4a2aaebe35ee547f935fcb28588e8061d7da267ae0954bcc987 041a55efcb7dd92f6fd6c2c2ae8c93af8d6248a27cf51c3d3770a0712783ff02 bcd9b147bcd926b86b86457a5a621b159a0ca9fadf3417a02fbec9c3f22471022de2c6ce6f3a2c06a2214dc053503a0b533ddadf3431932cccec0953b426c50f +generate_signature 4f9141ce176f61503a42ad71e3713b8a52dc56505809c8d6d98baabafc4e9910 516aba422fc25e0533ff24157c263ec3a284e1dcea2a8a04972b00c29df0dea0 23a237bff637b3008b429465d3223cf820ca4db0d75084831ab81808d4878006 d35b73ff85fe969f151102483096463d246972b33ce5869471fda9a25b456b06d3fc4c2d17f4d10acc4f09d0d53d0ae1acb3aa614c394b12c06c716d6b4bce0d +generate_signature 13dd60b4ae30f8146fdc6a54eb8018493742413dfd267f18bf0d21b380dcba18 8b85dd2808f4a567bbe3bc67bd11209c98fdd6d177678afe6cbc6fff19fa2d76 396068b93693fcc4afac343f8955a705d3fdcec131495c1b131e0ee9fc7ff80c a421b80de01776d82ea32a82de2fc03d5447f54bd2e26f3236b0a363d08be10def72f057b4452b4cfb365d32ae394f2f3b6bc3ef158ba8a19890077e7393b205 +generate_signature 72b57bd7a1dc353f62cad2299a225484014343a40ce052f66ef2bdd581f3d5c5 57427bb8fc70228d84e191047948c9bcd9582c8f1b3118f56064eda938857a33 daf6de1663b64ca4fb7660058f16926e1fa33175f298249183c6c8d862712d08 fedf7c31efbdc6ec1203e73fb32df97dbc9847a5ee8fce0d5b72d240f038d00ee7500d00c3fd230eb6a35c77fc1212c4ee95cada8f900f6f1f27254f82cec70d +generate_signature 0e5824738082572ccd6c9ac2b97e37412b432a6bb4a1101234bf77d2a2a1109b 9ddbc2b910f572818af16baf273026b8cac3e6b7f2fa540a9bec2b38d2020dcd 3f4b0832a84cebc9377eadef2fc78a62f6f32576258c8d2424d7dc7669213d08 9094cf5be4120f21fc861d49fca07ccc76039c1c3487bfc55680a228a597000aab5e7612ad2ad5bf626f4476514bcdd510b4faa5f501ea84d1964adce4cf8a01 +generate_signature 459f98423e876494700752609232d068596b762ef006c299750cb3ff573b0104 c2fc73baa1d5897f75668116cab853bf359f156e24b19a745966512f6835bae8 9ae7c3212e6695e0f5668d062b2291b27bc45affa1f77b9bd65951914a842d05 3fe60cfa8e3910025e9ab62a44b4966f37b2b23994155f36380522c5d15e92008d18a15846d2ba682f6cd903bd0408544e6f5235436399c7aefa18b70b599206 +generate_signature 6d176d259af7ee75ad769376ea2a5ab9accd9a9f4d878192759f5dadec194f35 2317f20756c1462f4d69d36275fc14958419769167eb526fe6a4f3007036d474 1bb97762a71f9aa32b2f7733f1fe1e0bfe8e654ee6f8361f83a61a22f32d5101 a762be3847061986f5255fc0c704f9adda6de7257609010d0a75729ea5df3508def8eefd24d4f87b7914f792769034d5f0c21863b969aee91a116f4190d5710f +generate_signature 88989b9365a33a6a6870f4978d8a68c2b310f7f6f6bcc3c7342fee9a2985400b 09ff1ab9622a87b66f39804ce7b84c1620456e83bd2ac9fce8cf3c8564170543 f3cf70e5732cf0b4fbf81f78e95bddd0166aa597c2a932ca16d9e90a2742c80c b21fd534079cf7886f5d4ce8da689c1d1a7b65a69bd4c35b4b2757590b01570798cf76438e3042093cd0407a7e8408c43c123500663570a7ef462564e92d3e02 +generate_signature 72f08a3499045d8e2a14b4872a89a7b53756fd3dc0e538ece7093168c6f88b06 26ebd8fc7bf1a0c6c1c8f55f701d66411ce6d2d2a70f87c2a5ca42e0f8c8b359 75c532399d4cd4475ab2714f0da1f6b1f131ce4f18144b69c99259c58b5ac203 b845886d1518eddeb80b5a3c9e5feecb75a39f6281eac2080df8a7daca625605c54bf951eb03ad383ebf5b14eaf7497aea70946859ec2fc5b259c610fbff080e +generate_signature 9dcccae9215809a2a124f8a3bf62b5bbdd0ebe6d7710586c5355c7a7283b0e43 cfe96abf54cf0ab6895ee0a7c9fb90ec9ccd654fd526c36d2370398cfb7e8f6c 911e17b1af1be9f9446dda5d6d03de66c64d0a785b60a03ab7b26e2068c77101 ae0dcd705b5780a4bcd9de74ac43597bf21cfba8af806e309515b59fc7723a0634e1025fda1daea9e6e128f99accc3b2ad45e5ab19c9949f7752ec9352435205 +generate_signature 841ac5bce833dbb72069a88c959cc59561e7f05baaf63bb7fdc98a4d6e1dbeaa f3e8bb769efab6217972ced819551c79f29bc32a131a2ba05ab26c33d62c6ebd 858dde600179ebea9ab1806ab8e41ed2abb320ba593faea28eafbb5a7f989206 8425e70e5e6c1ab947c4a485aaee02a348eea7bb29ce0562e59d3866c57115009bbed9542da4b6900bf99c289ee951600ed658dabbaa13a498d8d66546f9310c +generate_signature c570dde787ce9fcc3d48c5ada9054346455ab9a11a1d65b0eb223547bd39d7d6 426ccc3e1c17db41bb5c975d08279f1451c00976216271c9bf221910ad1eb8c6 4979107437a699a931e67dc36312a1c0b5b5edd3a60c1b3dee3c12596e500107 c1b3396f25461e454361132520393f44d95c6dd73960b63dba2ade304eb9a80df26fcb5debf7e6ffdf1105a9e32b0958e6f5e3ba5fd1ffc439a07469e76a260f +generate_signature 62e8187f216da0c992208f3f7afde4e5ee42e0c09ed9897b010430170bb87350 91eb9815ec0a5d2d2b98bde3a097db217a922089e11c4b15d9e4109b6c534b56 4d2234323011d6837889e21b7482c69925eb483ba5b367ca48f5360cd92ce708 63aa181566c4f76e7b4111c53cf681993a0769527e31378ee5542d2b367532038098ff87c797476d9fa189b87e62c0477a23f40b08cf492b8e07de5131334505 +generate_signature 49d7e10bd4a42988f7b202cce474c577619f9bea53a7914de4d295b8529aec80 2daf7743268523b94442ce3f0be3910f40771a4f18a22b52f3132b6b5ab2b3cd 5e6e1c05e2e836a936e17a1765b30165f3851ab56ca1e38ac459c8b7a81a2004 c4be0fcc508b840ab2a16b08817731d3c525844ef4ac6696455e983fc5bbd40492322dd10070df82a5ed703046a49762753d353a5a1dea0553ab93d354a6b40e +generate_signature 51c27e54ec56e597dedeb33c6f2fe379383a8df301688f95e37fb695ce64b1e0 01487d5868e86da7cbfbf00ae1bdf8faf8d51a40c5be011a1ef11a2734616a38 e844859d1b9a5328533fb41383c1ed108a110e6413c044cfec538975bddc8405 9a3e8b8a7b675ac6d819e4306ddb84f4255839a8290c7e422502d49429deb9083b86ea785e1869a838615fe1b2db2760300ddeaa7ea9c0d16bb1c63256caa60c +generate_signature a26bbb54e14b7f7587fdf8b0c308bb80e3bd626c20a6980cc08b9f25317aa00a f248b297c284ef1114629819876d311bc01926a75899ab339891b4270ffaadf0 7c7af96309f390370a9a5031b9bd524936233f5f806b9c45f3821b91da8b8706 6c729754f7623395fdcd8c9191be74389c2dc1da74d635d865e259fba95e6e0f75280fd8baae9ed059684d9027c014b4afbbd3b63a4ddf2c23c5890c5aabe70d +generate_signature 18937794c31d063933d48dde3fe7b5c6709f931e139fdd3cbae74e68abfc5cfa 4abf6a6c47126af111ab9761d8136bbbefef57cc6eb6ae4693803ac915351fc6 4acac844a196b1754f42f9af15c6aa9893bd00b5f466fb691ef396149171ca00 891700e4091deba80791d3185c753fa6d73582b63c9a387aa394496fd218610c35bdd31b077158a17fc0ca4d8ae17c13a65ad2dd9c7ba2a0719f19be3e5a3208 +generate_signature 0b32c806869d8b25e120317582013a95c995f9347814e4e37f6b948b4ba1e2f2 47397e6dbce5916e87dff2a55c63e49d1bdc826d4ead31401d47cc0a37d99352 c852e5ba498eb8b9686557309591b1e9b0533a07c97bc6a8186c036bee2f420f 178f1d4db9021615d689f5d236c0166a52d92b7cde2e06eefb722f171b315b0a168eccf7cae21e3255598aab5745d2c96d2a14e5b69ca3cb5171a376ca94c500 +generate_signature bb5e240d1bc7e986e6e929dea3095830fa11b51fefae6cb1bdc8e060775905e3 7ae97231c99afe3dcd855aa587f1acf5f62ea0c61cba1e0c14b0fe4fd26a7b1c 25cb0101d7914aa49cd52abc533a7cdc00f174ba107cdd6788a1f64ff0ae390c 4338d69b5a05ac3f1ab190d86bfafb8bb5afbd4dad0f01eda6647b7d00937f050443aafd80335e53d593fcd0efb35c247e35e5e22dfa9c8c5098da1e4a5e6b0b +generate_signature 30d230c4ebda0c60892e470dc95ec1152b00c8176c6a93ca73b3057cc7c1a494 20200fa0969e8ecccde73758c864cd4079a9efc8476776755390b9a56800be07 4cce1e28f0c62eb772138560e232b27c44ec7ecb7081bfbe07de7d7281c3da04 7cd4b400f8e8e586fd136a9ec2d0a38de45ad2b4df62c0c75d110ccdfd6d330e1d9c2d6707abf2a95a960b5b18f61f950e12e06ac96591e21a82ff2ab4a5470c +generate_signature f1dabb3ce43a519e5899d465abc054635e9fb30f3d49dbacf2dbb54725041d61 2be7da84b3e47473568338ddf79a8c87b22f29ef4295ae6c6ca463df3102278e 8831f066a87841b2beaed0f20b93da8cc730e303bd135ca540511c6f697f7f04 b0ebe3b9ae5b0f38e9aee0f38ddc73380a09e3464d065628679c1d8ae31d650e52cbc634317ad21c20831e41a66ddb9354d6d4678ad245d584a670ee2c921f0e +generate_signature 5d60c456bf82803cb3830fa2de437c377f5f0ce42b762a0d2a5847b95d6d4400 38aa6f868aba852ee5f2c2444212088ca48268451ad0bdf5b42d020db2eab246 208ca6972527da0e4333b6d756e5c3f336d70f1af86ee8088b050e73dd51810c 0f4cf7ac3ebd37d543bd4280959e4bdcd10237ca5655001462e7e1af7077c80be081a8480114caf1ad748c757e1fd87b45a4e76ca84bb8f910dbf6c7d4a7e303 +generate_signature 58bf45b4eb8cdd324173894cbb55511bc69ab649e1dc79311bbfa58c6c0f9275 a429e66f32ec3d35fa825eb5b6357f4daaffcac3a11c47ceb80ef1114a06a217 c3330d61f993dd6652cba521461f4280d83330119a6ae92681b708ab32418904 16004cfe01f44d8d5ba6f286de0fbdf1bee75008bfa19c0b6cefdd50d9f5f201f01d80ac93210791e99927dc64c400ebecc3dcff83bea30c66a5b3149ffd260d +generate_signature 2229a90c79f0e3dc230cc3919066d3e4b385ec53b0559f7ca8b611ee2f29e12d 83d93b52f0df0fcfb3d6e2b13ad01ef38c494090c18014296eed91a5d988b2ac 3e286618640c874daa6e36dfb01b5e2d1f5d77b8d9ca6f5ae5b7ebe659b46709 52f15398b14700c6a20fa88aa69e73970bd5a7e6dffe41edac06a0cd5cef620fb02a8aef130066026f91f07be9db30ea16585d40870ea2bba0294da3b045f409 +generate_signature 9e47f640aaee7ab2e09c8fc12a32a531768258c5135eb8e521965d8708eff2e8 a8411a8de998e4b6be239be96460ec6d4f4a8b616b94f77347838212ce4b8613 cc4598110b1aff2282997a410e7cbd837e12a98461a6c6ffc307b77a323f0b06 a1849d95dd1a93ef3c1657c0795af350e02868456018a681674c9607317f3f0bb6c546151451815b555712a6a5b4ac0f919c130a97bd2ffd5c98d0e26bb61904 +generate_signature 1fbd47cacc32270ecfe0bda8b1b1bd9ae4e03a794016a2696eab9cb0ce2c40dc 41d8ee40da7c75784b464f1b2fe89409f898fc57f395b46ed0038e98c184aba2 ce061c022ad0ad3125b6cc34b0d27291874d29575b10e1d44528ded224b1500d 4dbb38e46e6cbb8af09d4adbd3705675e0914a1ada643809ff5b8612606dde0514787ab50dcfbd27f5e27786831508a8ae5217dca41de53b87208a092c258302 +generate_signature 0756833a04e57930ad436ed6e50995529036c5b55db3f9ef070a000ea7b3b668 ef541d76406b4b71299d45937ffac3a4d284b61faa8644775e346ec6f6eda51f efe31b98bdb433b3535e792aafb0373d66952196bf564dee8c02ca0dabeee40b 8ea8ddc00b50317b34ab166c50065378112220576f75977528b4875466df23089f467ef93f5dd171797c4c726dee90f36255b8413a068d581b9bad542e1d2b08 +generate_signature c5d9d4483c4b9b23e21c259fa19136f0c69cf2cee896945510e95141ffbb195d 39e841d4ac6335babb18e8d9e47e1c75111639709335a1310db0ce2edf686871 6a2b88bfe8a66655b29e20294d715cccec610efa3503cafcbcb5323d8e618400 0a7b4105826aa2d590d4ecaf30e81cbbd4ec3ad5e39136f3b914c826cfa21702e31071c8ec5e57cf02c769088f1ff0cf26784354a17bc5090261365e7c1a0a07 +generate_signature 8bc9f9c21660ee20ffa666e7be110d8accd2d1be0550aa5bb3b4ae905418b060 14b57372138f3995b35fbb964ed0481969684f0338470a637e183b9780191372 85465783ede0e697db9aedcaba7f2aad3f4fda534db37b9654a3325dd4361302 24e9a54b859358b6491c6938623adb62cdbde74e413083cfcaa54d0dea46aa0b5a7c2b5058fba87928f76c6e754956d3c871a2c0f6f0c31116a6cb8021d22206 +generate_signature 7ed3d902f3ee03f81674c4452bb1cf33c0601fd27e25d5aed0b618b55aaf7167 458fa36ccf56bcf966910083e625c7efd4114daee53c45f288ec2cddeb444aae 3a0e8fec3301b4906383419798381d28a2a26e9249a58097734dfde9b9be370d 0939222f3b92ab882cd3baef26407f95a4f97884ea09dc9ab76658ffb4d16208256bdc8fe3ff36ad6d6ca0ec2d3f384d28aa993b2f2b007003c24880ecb8050c +generate_signature d95b625b3397e7726956f869e61df3634ee46b08a914a6a0b10b9e427a9179da f2cc630788dd65572d325ce0895de974fa3d56e07717ce2776ea51a32a542644 921c6a6d736c246dc6bef590f359f7093b32d56b05cd8639c7e94541caa2a504 5280282f8d8bb3e1a5588de1c9b9203bce905ed4efd52694a59864068ec897099a0e1e3dfa614450ce5953f7059777602381b5f9b673d380f4b3b8c63fcae80c +generate_signature d17c7a1189954c38343e20e2b8e8a290e294753072895948d184cf0d1c3193c1 2cfe22dd27f8b7041cddd1b8111a29a1c56b35989aabe9edafab342a484f372c 9317e035d8bc4a451e52ff94e5594885823ad2cdc7eedf66c5231a4f81bddd0b 54922b34b23a86c30f75ba43485179b3ceeb50794df52e5bcf6030fd5557b505781b9669848792282ec6642c93566f4afc9a6673a47c825bcc62a785b9b9cc06 +generate_signature 9387ebacbf7d29655f65513d886d006af10a8c75a11cbcfef8f530a72fbfc972 006e6a957483b2f082fae65ffd18fd525bdff0d774dc20ca0b48b9cd8f592b2d 811da01862356cb02275a0c7878185670732b10c7de15ce1b2dc9ace1dbd8e09 ec0e4197e71038dbe2ab542cc23436af93d6a10a0f78652f00aa3a9be3ef560cbbcd8d1edc513788b57264880e6d8b07f626655ea0f34aa4149a3ca3f1ce2d02 +generate_signature 307a4932ef8f15539d70e8721dfa1a4142ba4ed7b2a734f8fb37ffd31f72accc e48b91027d713f4e5ec7d0fe315589b36d6bc6ec338e218f31eeea8862209922 0fc991a39d51dbfb559047a95078e8cee3210760eb9c0ca860e5fa48e267be01 7a95d2186d09b5fc3812e03edaad6f94a274ac48e98734a9e5886f343ac4990efeb465e6ef476371d2219147de64c656a3abf3e5c1aa3cf7af752f61625d0709 +generate_signature 4366484aed2052c6c28d935b2300b5a4e5172bd79d96a37393df3584c0020b2c 39ed6f8df7c2d04ca843e2e76bac2c6a4de490f9c8d1c4ff16b70df13588a4f0 de879609d955fb6ddb4b0609fabb4e49fbc7ec017952681f911552eac8ed2d0a f9964381f05d3f1cb4410307d353b4594ab4b5a067b3a83ec025513191ff48098831fc7fda4abb112932fb58325c2d03b9aff51d5232cde9562c2b49cdec7801 +generate_signature aeac4a1e1552df635de365394f86621ee2f21f7561a71a63c07fffd53fdbdc0f a6a9623f5791d0194199f52ea1e4c77be18a94541e9fc8d86b591ac8f1c0c3a1 c4ffa6e43fad2e9e558118f7b5a1cd2196453f91e1aa3691013209c7f7bfd40b 36ab079f39687356743588b86a89ae7895ad7f9096d0f3e087defa925a16bb0afd1c2e9d9b57571049f4e36840e03424629c256de047cded04355797fc6d3301 +generate_signature ed905056a502fe94edd1c28b3f65491330b58a1e2563dbb8d8369651a2b30cb1 fe89f71bf6d52874eb89f234baff8c878ccd22c5c614ad18eac64f1d49ee00db 9826bb63674eb73980eab3d333d90b1ecdd18a227a34e729ac4aa4c679570708 d93edc001d061a215ffeebc9323af12ebc5dfcd0b8ebfc102255974a5d142703fe494c5ff9495d6b2a0f194898295e50ffcf737fb73111c081d278ce08478d09 +generate_signature 327024bcbf89837e82f4af135ab5bbbae710d4fdbfd771423dba6d089d62ecbf 089a1ffc8c9ee8b28e3181694127146615db3ca57d4f808e375b0844d68e4ba7 9c7c12aa4310db31790ed6c9041b711f0c742fe3c903e3093e2589de9279130c 54ea465f4a54dc5233e39ea5e7af2539faeaaecd522dba9270d0c1f1b4cb54025938666791141451fa3e69690b3275cf792e6dd38329768b308d5c59f6bffd0f +generate_signature 5fca639815dc14114fa452346ca15db70f4f3c13a1bd1dd2e5cc6633bd884a97 0acae623f287aa3b9758a36ebef615ce9aaa16f619d3cf56b7ceb515e2ea5c27 11569cbb68a9b17a1ac43c5b6b87a9c94e269ac507541b87accb5681fda30a04 03ab406ff16709a103b4f9afb962881c9433710bac9b5ebd9b1b456127ad86073e4849debc4460ef38991f48769e98904b4f11f9b87cd380ba5406c14214250b +generate_signature 0f217303b1076cd895641ff1751d2d469def5e140e0d61dc1a4239c3decdb382 d0cdd348b338fd12dd2602b2d5a872e820e1d9cd6f0b2df9c5c4a04e49559a62 fad9edd7ad17647a02d8f2077b9ff3c0fc755e5eb071165bf902654e7ff1050c c03672ba03f28a92adf35c74412b704b6b4a4674110b2984bd8d869fcf14450b6dc3f7efafafefb1177b80831e9f4621638b4721c199a2db6d14cf04344e1900 +generate_signature 254a879d64f8532e5f281149b52a68bcd96c2148f33e3bf7cabb4dfc3450043d db123979ed900409c0090c74705fc059ff72c4e1ed05656b117327e7d3f68d4a e39e1a551efa30ce0b2461796147ebd86394c8c0abcd8fa8118fbd7cb5f7920f ce3f68b5a6d7b779fce51f68003b90bb4fbb6b1e204c269f425ba62a00686a0bbb2200e3e711592e8239ebba26e17d2a2a0adf21220a84209bc24cedeaa9b80e +generate_signature e65ec30c477ec561fd8dfcdd1a3b89c099ee7c415de5e780618433c3209b9824 e45c9e7b6341e47a07e794556c9cf91869cb97291fecabe4867e036060c81ed5 860e36d4b74b80737704a4db0ac58e4181d807b6a0ccb4064dee200de67ae603 44a375d193dedacba4b04a25987c3120cff9cec824481d9a79954766166a6905a147c163a6eeb674278dd3768f55a57b29be2f784baa82c71706876442270104 +generate_signature e701f76a8a06647e5e10c677a9fc17ac37c628580bccc5500f34381536b88b9f 1bfe84084ebb54bfe97e3701eb27cd77e585f510270dff9b22aec8a688d0512c c7d74b95fddc2dcfbfa0ef72aa1078f62b786f5c0d0650782a2913b5a22ca609 47ba4aa05b4ef3642cc45cb89ebf9aa98adae0e223feb56f2bd7d889c1a6f30850fd39e724d3d96ede7218f35f862ad276bf021ea61fd716711f7df0fb597305 +generate_signature f220bdb877fbf2bad58a7e98cdaffc0047f8d4512cf884e45c484d5b2a19275c c37d89b27a7449d9015b93669810f35faf07908d5fbf4d93ebceed9c1021770d e4692ca12eccebdd039f9d234a083b49a184b7d241025e4b27d022fb9f46c802 d93a98d75a69da5ed543c128ca0a6f0336ed5ab2e928b97efe4631a1232caa024822d96c71feba3483d289845ead4b1f4ffa8123cdc9ee8e1568208003f7e707 +generate_signature 2de9420d201089ef5c3c1fdc2ecb69446de59b44b84813d4f2c60c4762cba262 ea272022926e4b6059728e63ea0530c064280312e22e82419a5463b34b5d223a eef8d695f5b62c90c77bfd4a4e257de3defea7eb93cd546db2f0c448deb08d0f e49801c901643f91af6c0f0e5b77b3f4b8b706a9e5e7cf6259accc6d86b2bb0efb08c8bd57d99cc5277b6913d92782a35be89c6753e4a9425cc99c9c65ce6b0c +generate_signature d22270489687f1aefc08d45cb567859a5a7f0fc6bb4346ff56be386f3c64ba68 b231b42bafbff5286ccf0828fa423487e3edfafdb3cf84b4333b92f7c5f8e005 3d6b4f25367114c0fd1922209e6d6ddb062c959f0643d6b5f5a54aa7a8dd850a 475b0d6305af0ef4e0cc3f45e71b2d0792b4aafc6c0c007d03b48e8abcf36308a3ca8844b111cab85f49fe0812fc10522a1db62cb0f126c955508ec88ab5ed00 +generate_signature 0f80ee01c68b1c0fa0f72a6890a523e2f941a934d5aea5a37756fc9308e3d149 40485d2af8f529aad1cdce430971bf593c40ea5f650c65d24ef2f3a1d6e09844 ba73077ab95f6b2185b68884e757c95ff288af975d70f54e6ddf75446b59ef0b 261d88446b54f13867b0ff5424fd5a74aed5ca239b9d53ab6c68a1c1c772f30a5cc3ab0c02e6a05c226f33d6c8f5653fba3499ac27818ef70ec2ff339b1ece0d +generate_signature fb9279828f9075e43491950ee0a6b55f2740a03e2803e20e9baf42a71845db16 a60c8215f4c3144d397db32359b1638a94bd48efb4921488be9bb2dbac2d3621 24d0feecf4a09080ce8cfd390619e0f0c9185278b712b9a22f23fe6d1b028105 6bf9a38e81fddeb3049ba90e263afd4ad6566d78f161614eb5f37efcd713570fba72e52514fdf7519c63b912cd6ac9c613de097b25df9b0dbf59c081a0cb0a0e +generate_signature 1853a3886d3421c884701015146416e2372be5dff4804a87c367d69a14ce1674 a469f283112cb9e1247cb12358e1d1f0c2c1efeeb0311b4921a4ec3c2fa6149b ec7f0053fb49ae322026d8dc884d02e4784fef17469b85415f4bb269f833410c 3102d52f2bad13c1296c3c1271c2a40a3f327534d5a94ff6340b8e1eec35b40bb54724c6b92ae4d43ccb2a7f91711653563e3f4cd29431f8d575fb246551970c +generate_signature 87a4d1813017c757f2fc7adbb6346bc711619edaa8531378e25686bdde9b54fc 8e1cf8a065ebb111aeaee0458198b02e9df18e357e60604aeaa62f0e7e81fb47 d75a74c80860cb58614643bde56d7d0793c57750af954f4fe949e08d73e14402 0acf181298846ec59a8452c54882763ffc6adc5cce0c165af559b77d4523e5049fd9fc62c6cae47e24a1a400e745df419b4435e5ffdfc3c8732e8011b2950201 +generate_signature 36332e7b2431dd072a158803b24744d01b69f096aee41407d70ccebda99984db f37969dd37feb2205fa2d7c87d62bba58a675b9ee08caabd2496886059a5aee4 fce10979cba19bc179dadec71cdbf640bb3fcdd3afd07dc0e61124d293ae7209 f65e8762a0dd238f771c37cf41e896cb86ceec9c80636bdbbd9099854e468a06cf9a078f78dbf835b67a224a97b61ec8bfd248a5505e90b1dc0d3550bc50f602 +generate_signature 2c7db34f2f249ab08724d1a679fe855bfab2ed68228668c7e712b4760a839f63 ac948ab799b000d6125355c96a4c7c2f7918831e2cdb86c66f75a84ab3b588d8 711ee793591c685bde7f3b136751e5a39d55f0cdcdac03631ece1622a5982904 088816bb72067d7a3cd24e654713dbad7c48cce15d484f27833ed29133bcf10f5ed1af0894411ce92b38c443475e7be2a3f3e409faa563419e9b4c8d369fcc00 +generate_signature 9f92e54ff6d3c2033a5ce9135c8f079a93f0a7ff4c94467d856fc63c0e96fbc4 c6407e167719e2dc8e9e9d719b1ba7be2797eed2e43dd27b02e8b7affc6ba801 9a3b191d1806472ff03203d5602b9cb73d3f0262cdf56ad70d20119941f83e00 7ef02f0590bd3e4bd2d67e32a4782c19a77a48319580743480012c21a285c90c4562c7d24a4c71b6c73fa10a5331f9037fca5a35915998f7ea693d873756610e +generate_signature a70f0611b8337641f0d45cdffc56bfaec855fabfeb6fcd3da1292206b4a03309 0baef43d5b9d89ad7572c413b531381745af1dcfd1ae90d4b20f0f78080f2ccb 9e5527c3b3da09edcebf39183c5d912e28f47befb833177726833e281748c909 fb2867fdf85a7fc9461cee077da26e3829ff31e792ca6a7a64e45eaeaf68ff03844d3493d76c14a791b8896a2536c9cbc16f3339118029543829138cf4800205 +generate_signature 878f172b5f34e0b18a55df0ca544d7dab961eed79e07fc4689a0a3be8b3ecc72 03971f351d3e118213c1762bb564a2b56e3df37d3217665f16f5193fb82f8a5d 213d506a9731bcdf5bf8c3968d89e7385ee573aba69d1572c3604cdc29e9a200 65c7143d6bc0ba476efac208e4769adb5e8f8a8aa8c89c02c00f66fc6c67dc0afe8ab0d4ab745c3158d9ab400fd5fe9da1b1b2992f0042007efc5730a3ae1c0b +generate_signature d5c32a4a81da9af917c63f72b91c14e0a8fa93413572b702cbb3e9594481deb1 b558e0724567f7b4b08318ffe6b0dd0b53cc4a876ad1530692f286b068d19f9f d5a64d1b5c47ae79629ecb770ccdf0bffb1148869360958202ddffb2b5a6340d 0671b73ca86650771e95ce5db94afd94f749a315ea513d0760fda3e436cf380ad654fb229db4be617f59e3b26d2ee2b037244a703f33415037062a95986cb700 +generate_signature b3f0024e9682ccfeb0d69b0c6d2f0911526899190e7f0fb4eb1e600da16aa63f 019ce545f3b46419d987730c551e1787ccfa158bb42a8f203631fc211e492c6c f03757ea2d5b66ba968b93e5109593e8ec7f4c6809f15c6f6d881b1f76435909 32b47e92fea38ada7278ef7ab83ec74757eb453ffa1a39add472c1a609baf707fec8964a51f6d6830afb3013d0df44f0ea70f2167f3d5de47d1641a0bd39d006 +generate_signature 0b18efa336170b3a6683dc486d1f36b6c4cbe86eb310388f71cdf70e143d0aec 987eb3e73980b221b2524179565720f451786f8de2b3407c8b5716ef683c15b4 d3db1e882a144f312d1dc307d8bdd2eaab5816804329bc36430803d23744530c fd39527b88ad639bd08f80467ac9ff846125ede2f7a422ac1d844891a7dffe0df8c3d50ddf503802d75698c4e35730f0e0c30fe0068f1d5cc9a05485419bd909 +generate_signature 69ae4cedd012737619b29be8065ede9f93b324b50252024d928ef04c543a79b3 35a734465352db4e813f76b446da1c00dc703317f1ce52c8a35a0cd571074568 ebc39ce202ec647da79c7af3ce6ddf307fc44de800a68a255c2e7dc7ff997204 ee0fb3670e6144f3d957268e011948e5d4588076d0f76d304da9825d1557200d3a69763c391e7fb53031582b5ab2b237cbc566b4b23ae067d702de4f147ebf00 +generate_signature 065fbb38e8325511ceb9aa041f32aac98a5dc8cfb06a85c98853b25cdfc47057 281b3c8844fa282b064d56acc83e92c8e6568c3a628645f63e40a07aee80aeb5 bca17611de2f9642df95a938f64894a4079ad06f842cfaa9bac087fbaca3e70c 64a81d6fbdd3736760ec9e52d6b5718b615b5ca2ce97a963597fe32ba1704c0a7a92e1f2a1ed943343f4de48f6b2cebac61652d973e74b559723831929487402 +generate_signature c13ed90a542fd070e07610a0fee13cd42f8753f3448591ef9c9f57ad721fe9d7 02cb435d82524b0d03853e29c7ec0920556b85fa12886b063cf64345dba55483 e90a0b4646cdded432d27a6204c67a76b8a3db2dfe0bb2ac6957d68e6aa72304 6e347979ae11e64140741cb9579ce9f664db155f0033169d08193c517c75b501855404a91130ea0e4dd4f718d15326b3fc390c20da9ed6c530c09eced6a7d20a +generate_signature 7badd2f8d2dd8198990738617145e90c87880b95d5c875be0cd7be0dc25e7839 240b3d620b61537d7fcbde252e9de6da442bdce4e24cf4bcb9d13b50206129d4 9d9c7c91e5d71920ff7db53015814d4360eb7e398cd6ce8233c2a1dcc54ae40a be1f20b3442f54fbd16a05f46800ea387acbd8d518642e95d75d55d585c8c30416356a60be645881df162bdfc0a0cf1ea454ed5492c467e0fd53c12b4db35d0a +generate_signature c537ab8551726c4d7ade51835585bf7850fbbc1d57f9245fe1b29618e2aa5c30 1ef9913d379ce22e9f97757c68fc5414e73a27e69a55ca223cb5eba854888d90 c3f5baf38db5121dfb177a0cac1d6bc423ee0c8f7c1323d9b691b07489006b07 0c558d33ac98a07ae757a3147040c39854db2f51bad3f3ad756ad210e53536032d3b78fcc3039c43248bf40d9db900d551f10fc434d10e83cd4b8cd04f296f0e +generate_signature 696aed47faaac314742d0e6386548c68617dee798a83105d3746747fd06d0cbf 279e1bd9754759a921c232f37d744d7b57531a302245dbb54f95259aaf923c12 28bec44d3dde67ee976fa0761ff650fb0d9ac60e74725e4c5ba3d7a0575eb90d 6000828f187aaa4b1571d40586e84b178e8fef605fe679ef34fb14a76d5d880b0b66c93ac8a30e2c39f32ae4099e69488a4f50a74cc6caddb179c0a5da822b0e +generate_signature 0215e850ee377ac137b6f9ac06809bd6cfc31918bd0a372155f28d45c65eac25 45621dd9f0fd09053bb23b178886d7f258045154ce90a9576d708f0d92ac656e 0da2f7254d9796a93c9ebb3fafe40d398726941e469c6f8deffc9c32c2b5d00f 9eaf7b47487448c11058ce0e56c9f3972652b72f92fc36659fa5a3650fc05e055f72acdb571d7894974d41f66ed1e319c44ed5cb8aa7e7bb74e4e7dd7f987602 +generate_signature 877a11a34fea5898e4643861721def338135c5cf6dfe1a6fc6777e77fc68d245 9e47630b2a88e9f86555a6a8462a435c0ac2c45bbb85115add2c4ba3dd578031 a3322e75481f1ae1eb9828f57a2b4cc1c786167aeb54547c36c936600747ac0c 05488f5a23ad7cc70be490d82bb9d476b0c841b02f9188630f765de655326b00982c27bb60142a6372b532af009c116bae1fe0105639597adfa7e1410934ef0b +generate_signature 191a17e4ab9fe35c2b1ff3190967be43353c62dba427e461cc6a2dca6b12228c c7312755cd3546fc800b0af704752069cbd24d4d132f4af435c149d1024da97c faeadb6cc780147a42bd6d1968169e088a0b5b5025171ec01fe7ce17155b7d00 cdeffb195302958760ed2d2bef9cdddc7f9c9651a9dc7f63972c75420d2c9f0b0088fbb2553481eec49d7e17ac9a94368735daf207c1e0483df31a188beabb02 +generate_signature 37bcb62ac859e2e85caa766836436533bb47f58b8748f921d3b1bbb81f9b51e4 bc46c4cd6ca4c15d76864b66439d46e8f8ccd846e899f18ad782d6a3608e0c49 28fff080636d9950ecd5dc362736734a75a72851823c7e01e7489b28c462ce06 eec9ee4812d750381e3e152c5f0c4669ba2ce39e3d6c731b3ca52e09379cca01ef63232170a386d21dea336147926f974d6493440638bc6cd6b2ac1b0f880b05 +generate_signature 42a48c4a50b87313860ea656a1df5698aec2a2f8d03e69ab24c7f9c7f7f66056 e4e4c0e5cd007712ed5120892e21b0615217230b1370f9a531192e09f5463f1f 0f98ce51f4aae0b3c5c549fac5d94fe0587e38f298354f36e6a259843322740a 0458b2f6d0e2b1bdbdbaa3b4653d0c97fdb3a821929a072905854ed994274d070305e686f66173b8d4f2f6a915de163cfcba68fff4f8d78eb4324ded1e09880f +generate_signature 2280cec561410c47170e37a38805c146ac1a8b73c1691537fdd9d10a9c430579 21ffbe4f3e0ef3bd589689c0f2c35bb702f121d83d8d1ca62554220c1da72e56 a2cb2795994ed3ff548fe707d64f59369cc6e893ee2ce9830ffa526b2f41f402 a4584714c13588b1eac0dcf9c8d73295783595b5c1c10a0255ef1e6d5dc31a07c562b89314ff7507d6fa41ac07f7e5ef5e5a7e263a655f2fe7800a950f1b700e +generate_signature 7df35cef6dfe5607c06a64a38510e5c42093c703a88d5d76dfa97b14a0f6add8 9211c6183c199f81e344d3650c92b83c96bbbacd6ae654d8644b76a21611ae07 16b3d5bc1949ecae9e4db756c129c71889214a5af2ff78aa8a479a0c5d0ff90c d7d54ada1500341157c35bed3eff082960df1fd03ca9af942753111ea2d7c3012360268ade0609c08a666b06bc7fbae65b0b9c9df232f73bc173e62590de6a09 +generate_signature 4991a192c5c493c47372771fde392802036834e9fa14ebf5c4696e40420a4c39 61c0eedb78215458d3c724551d7220f92b8f70aa656514de7fb209b26728a083 ff600a4ce0fabd6602b51e9636ff9b8b9e102f1da91f00376aa2e50411deaf08 538e575f413148ce714f379f1387616893157e9db2b07dd778dc3b1b19d8580d0f422c504192e9a001143239ffa6d279805082abdcef22a1fad40d9a66456f0f +generate_signature e9d7fa57a984dd1d9c7a93125fe69f4d408c821d7c17d199ca494d16405c0daf c536bcc2db715ae003881137da965ff0e30dbbee0f4e29d5a439547b8cd48175 1148d655f1e23fec319f04dcf5c5ddf131fc182b50e39334ec0f312e25429700 7f1a8d29ebd0c1f06abb2545a32a1caa4b99a447970938a8091dbf719a986508f2806d08397fec9c73f56268c205c28f413ffee92e6d40ebaa2030c4c4cf5005 +generate_signature 9c619840f7234b099d0995b905a15ddce999775aa1720f0bc9477bbf0c5525ab 4d8720590ddcf790a1baac573dda9ddf0efc21223335b15a23189fa67f515ea7 dee02eb9d27969ffdbe6f7c22642936e5965f3124fdbb0c51b1c44856c075a04 275fe14ee523a70ef474980cf253f07d7ed9a176a18121462d03354c219b2f09ce78ba68576e2178a77e9b910f136d3ab6f89659d6b3111fb4bceed0efc5dd0c +generate_signature 4e5d10eaeddd0acead90bb49b03e73b84e966bb05d63055031cacc8ea5e49aa3 e2c8684aab1e9860370e94d295bac00283208ebdd29910d54c9a28477daf6551 4487e8f01f0ebfd7b1870e7a1cdcd86470fe644de11161309114f120683b3509 dee91e24591faebfc4358de07267eb3260a2f39c7c82d941ddafe7e64373a202e2be0abbafe8ae48f797832ffbcd2231daf81ef1c2420ae49701067b9862940f +generate_signature 8db465446cb5848044acf5826a3c8baea057859846b551238a0536dae39ef712 f3a88b4793016d12031ffa76a5da01dfb771e9255e8de871769717199b83ccdb 3ddbbf3cf5f282afd370de5d33dbd8464b805bf4d7c74be2410eefcb5072da01 4c5f5674f6f8b597fa00bc83d44138c6249b9ae1bf6c147cba3785b9b1a576097e00e4a12811e3ff669e970cf0badf06a2b8567a4137aee88b98ee4bc998860f +generate_signature 24979bf7adb7f8b840a3524c3d3bbcb73490e50e71400632d824f420427df802 78057cddcf685984606870f37a2f0d76e4ba59d169722729695edf4934528856 fb691338b3fe0cd1a272b7ff7e363727c66689c1c7cfca7c007a5543b3abd401 cbbc150182612960da3c274d32af2f3e8bfd7e5c22fa19a2c1429e66089e43097254cb39ade82fc5842228cfeda6c89fcf46513a35c0d8e60fae55491850b103 +generate_signature 8866f2c3e0566f73f173a7e0f9e33cf8b1795fde4cb09deeb1efb17dd82ece33 28c508eeeda24bbaa55dbb312f534292bb1d8ca09cc34ceba36a3db1ae5aca9a bed8a7e6bc28ff86ed87c5f54d91f8fd381a2fa9057b6d38b095245dca1b3708 d223739d8c5d9ab33d0fb7994683407c8860a6f09ff1dcab0880a29a4f952402040f91abcd345e0412da0ad7db731bd64eb5231c84a099daf595c382797a1e0a +generate_signature 421c152f337614c5a007b4eeba8d4299f7fab313c1e4fa935048288d4b2531d3 862b1dfbfbe3934696a9ad41adf2022714feb99e5a1936ba2dd4cc08edd7166d fcc52b66e50a4761eabbbdba3fa82f2e391db31ed1be585ba5a936c31dc36400 7ac59d4a3823da486906fedb7b89a97ee188542b4ee6139335b5e4261b1a8304ed3e5c57523a6c27c3915699e0411c83e98b55e41892776b7243058812007c01 +generate_signature cd4eaba1978fc73de4114aca7dc6708308e72a8a861c96c2eaa13dd06f2e82cc 88855b172e2e512fc6ae2bb6e1252670210b17fe4c021f97ce7245ef5e0766b7 fb333a06054d22771b8422f547838f14f4b868e6c0ffc7abaf52643b36e25a0d 96f77fbad2246d441e11d77a74f68e371a5e8f4487fc2403c8ce9642d32d0d0d16a1ad913b564f2ec35789d10dab51546cad04482fc14cd144d49b38da4a480e +generate_signature 38d2cc1cc489bb0af029d12f1ed624bec71d68c0713f1fd7f5d367efe71d72d3 3b3df37e4fbb3a730b5f9c5a1f7adc45dd2fb2c05d1e141d939536b6f55065d6 f10b5d6fc5830989df088c2a1a9bdf95c37781bc8990b95beeaff246b858770b 0e74576563e2797f03483aa7264b93cb5fc9fa20c9b8fb7c8e84dbb2eec77900a29802ec12c00ce4bf681b7443807cb763289a379ff76b0840282f27ff4bb708 +generate_signature 017a5495b9f777b45cd256eb87cd298ae9d346caef147cbbb916d95a6b61c677 e8d23a7fa523a7d1d59d23f5929cdf9872ad01eb77347b076121b2a8d24289a7 d77e90cfc8bdced4c2957514ad1dd3ee2b4e841f843dc2cd711df92d31225801 ec2e112f2a9509e04290278361b2182c636b5779d038baaa4c28786bb518a60373555493b606fef1a19147ed825c46bdec673740bef177ae2eeaefe6afa58e06 +generate_signature 5cdee6559376c9ce870c83b06a6492b019ec54bd0058c2051813cf600bdf25d9 a2def558fd26b3e1b9f1d13b131a324ebffe1412ac2d043f7395f060e35f4780 29e13e332419405883c0103dbabdd28035a4be98f8216230d4a31072ffdbad0f 61fdf6abc507b614d99dc516a00b568b1fdeb9b1c11e38494e6d4dfb17ebf70a2e2ef100ea9b82856fe3cb3c440eda34c2a55e31d646568bac6a8aa15eb07903 +generate_signature e5f7e794c78196616415dad78d3d07439809df7c7443e44b82e54c6faa5bacc8 6fb3a5c5d7b694b63f29ebaafa2cb101d455d95d1b30c51d2027714c6048d81b ce2794dac0a5fab2074829050ff0f631ed916adb97c110d1d9c01f11fc572005 89c614040b6f140e0e5a245ca46e1037cd52d2bde37966cb6157d6a9a6acab06b051f746f8a75b6a5f4baab29264f4483ca81ca49153a02956640c20518f540f +generate_signature 5283cc05c1a813496774fe331d90989baca3a8932ed5d6ca1633a96e9881deb0 c776290262741f162cc11cd2c6ac606330a0c53fa543cadf061d844ef306920b 7012ea2ec897d4db791c283cb2f878103fb6e29c831549f2c11fb306a3f33301 9b468682a0c83686e4e73beb7538d7a0df6a50f651e6e579eae18b707ad65000e99962217bfb21b0351e08b09eb13056bc172c9ee8887658fb06d738b06bb10d +generate_signature c7769cf2307480649f60e6b97930ec24d3ad128375546675b9da306de670ab0c 3cedc8256aa3d7844139e180826e005f8619adfa8a493da9e824181e4cc007ec 4514bdaf0b277950569d81b5195c63f14fdaadf1156dbb3ee16f3aebe2cccb09 3a862ba6ed9f70b1e1dcaa0b2cca4688c36f6724afe2ae3389e8ed8b94d6ce0acada69f4f6684699906456c157eab26d4970c9bdf06d9083ea3016d955a7de02 +generate_signature 0020398fa58108e0b0e5356b87113093b1e657fc5aaa229a2cbed766a1343b13 dbda7c364135fe9237e54e87c742a1174d17d3e70a08051780ebe274e399a4cb 12160063e4e47b248ec37339a3e62e920b41da6ed6b9ef1dfcc1f48a17c0490c 15189616f9824f7156e65f6fba5a919152017d62a8764234094bc10fc0e3890354e04208aabfb98c06aae907ff53c72733665f5b94d036b3b98a57f272da9a04 +generate_signature b1e43d4e2cadb0e60c8791fe13909d0226ddc2fbc5bd25f73466910ed0ab3f2e a1926c9a221e847a653ec6136e4e23768ee329db20a7a5986b51c0b35eb73d15 5b0d93ac7c30cb138102c03ca6b27291e5adf76d82bc88862bcb3af8df86d308 bf17905747bb2f99f89708413dbb1caeecd29cd73f0f46d24b79c13fa09a9c0a2e4638481623cbec52f1986318c640017f22045bd00c2b2d27c66963bc34ac00 +generate_signature c5e0e0a1d97e19628730750589a954c02102545c18f7bb05ef3e9eb8cbe36523 e4a4af78733fe9a3b297bf135e8b57181d8c0e39ecf9a5a7ce1898db57b18b17 7d29486ba52c61fc5ba24e42ae6f1861f161a0063f102ae3e86c480b52d5a40a f95c29cbd0ca78b63e09a77cc7b9801b775e347bcbb4f1e93b3d2f9d39b3fa004f2be67ee13077527fbb8fc0f4c2a8c9ff8db421917b7ce13f7d5ca43c4feb09 +generate_signature 81bb454381f1614e7e5764e88664dc47f825d18ed5710899d1e5968169d7bf58 1bce52512bbb39ddb4dbe9a10cd12314ce08fb7ca6b20d8a0855b334b5416a17 8fcbfbb6f711655ccec1b456597b0ce4a5c81adfe9523721503d36f5d5be5708 e14bfdebd4d7ea7bafc2467872e8a6a39c65f473598d1baf468dc14d6f56330940153f68e296f8579248c1c91371f466cedc69e48a69b324e038252a082d6103 +generate_signature 8c9949bde07909984cec9d462c7e1de28f0d47d143790a686bee51d4983556dd fb6fb90c091135388023524466045bfca011113099973ceaf2d6dc4fa0aafbbe 8dd9d958ef607e46a14f742e8581c903661935e2257f24e852ced3f7edc5ca0e 2bfdc1a161b5277c7b18ead751e5e3db524857247642ff0c4927218395c8fa0b60cfe294e004eaf429a3cc1e6990cc90722bedbcbb47c72ade76d6811e68f20a +generate_signature ab5556f1489abbd7a0c8c877a18313617887be7ba186a8e0a2d50e9d94a578c8 e7f84cf6411ca6bba208b07ab26e48a09b779a1e7bc907ed587a1d7ebc39e273 601f584a65a16dd59e6a1b86310a66a11192cd5ee68a4943ec38bbbb1bb9370f 937c72108a1f2c680b5a1bf88696ba4d36d94c3f929e645c177ed9370b6eee03e4fd662ccced32ee38f1e6a9ccdabd282e7f6146aac75a09c09b31f4a69acc04 +generate_signature 47fb94c340262e3cab3ffb03e06695bfbdc2439807cf26620c8cfe4395391309 a5f429dd825be9eb1b76f7300754a454844d07d1627312b14c70a4ea4e4566ab 7747b7704dbf86b1d338f3d49649e43009e7525edb11e684294fdf1d6fbfb708 1ca22676df041fab4c2471184ac3e10903c26c03340517b54fb2014d45aa970e4d38f193f768d15d38b1516c56f713ab80617660ab14218c41f252d950e9740c +generate_signature 6ba24acafdbcf7ca8125c560f585d33fc166ae363adc8f0422c2242f6a2adad0 b27456386a01d84300fe0695bcb594296fedc0b2ea31e1a176cfa49eafa0e5a5 237401f9b747baaabeb8d8df6f526f00a6331288118c5aceb343908fea8ff708 7afd863804c60d1bde37837a7435eed6e888268aa6fb4bd8e2672c9278f3b208e883ed4f080a35e9bd21bc808b7148ca63c00038cb3140160aa32e2cbb530407 +generate_signature c8dc5ec96cda8c740358be0754fdb8644a33bbdb9352ba63ba8c8ebb19f7a240 d9041763f43939ba1b6015c369bf8596a53584891e45b20f4031ecbeff20b36d 849e6afd48fbab23161a1dfb7d3b60151dbc4b288596726ac07b2fa4fab68109 0335fe7518873c6261f5e903fdaaad29663089cb9576f9adc3581d2c9ddbae099c75901b24c6c6c9f9d4540a815040ceaa9d237545a59b6fc84154cd8c0d260b +generate_signature b6d466f81e80d56104e09dcbc4bcb94e4f095ad48c635aa14f74c106ae57b9d0 005a126a81f80baa89c897c921f562aa44afb0a7f317e2cc2988197f980fad94 08042ce99fa8ff0a4c082fc1ba66bb11f8c94ba9ae38b4f37aa050a3345b2808 ce904f0bf1eaffeb0198072bd43130dd5995d52ffa4244b2ac5a1319bf19c70db5d3690936907bd2a20a1f3d9685ccffc70885bc448e1fb9f42b70bc5721e80e +generate_signature 8c442d20262492d6075a482a853037319738a944e8ced7a26c236008348cd06a 1543c07acd90bdcc1ed42560b2129f52db09965732e1ad75da5df80f851e0a30 5abba5c682b23a2e44b9b426abcea8faecc8da15f0d124fa428cd21ab523490a 646db7f9198a8a96a69e9313ab1301f6b8e2ba82e6a4cf5b6686119bbcc8060c859a09d1e9b6ff8151cb43d00c5ff1f82a96d4e86a80d05fc38fac566131c406 +generate_signature 6f7951c7ca70cbe7abe0d6befe5a5a10559b7d05a56fba3280266361a919b07b 2a08f949c037c51b3bc036e3779b6dac628a9fa2561087d15c029de399596209 77f07519b561abd91c4bf4a10be08deb641537d7503102d30b8403bae936910b 9a1b29e8e4cb584a1cadf576bde1d39d45c9c4af99f3ed48ca0381fd05712a0a5a27fcfddfd1fed67b42b4fae7dff51fccc79868a7b52714713dfe50dc4e4e06 +generate_signature 22b1dcde0d75d009c1f37df37ed0a79e162049ac2ee48681e312244d540b046a e340d157c047d55d82817a49b51f3c1d39a82d38876a05050dc5296c12a2b6df 8fbe0766b15d4fa7542756b1cc33a62bfe2da4f7f00ca30dfcccd7d63d6a350e c4071a80eddb13d17341e19223ab4b731301d0ee69b58e98ae613bca450e3c09c5b0dbc233ddfa2cca333109cf74f909662d58a5db790c7029568fb58357350c +generate_signature e1552258578c4238b55b9c096f1da86bc399ebe8c55df9dd6d0468ce939a7695 98557f788cbd01ac0b77f5e4bd2c0aa65c58cc61b49f5842a53f898461d22ce6 7d052de95e7e055d117709ca3ffbd6294edb2b0698b549f623327a7856d18b0d 86ff6dfac2b9372d5530633568234ee713760ab511cc7c31615acf536e2c710eac1c79c1737e978f6e2335be68ddb328cf5136a9e2fd5b7e9c261470b109850d +generate_signature 9ef760bfb089f081576ef619c98fa69e80bff76db56853759a98359944af31f7 1e2022577b355dee237be685fc8704c73ec09fb448ce3ac9224c7cb26ed7cac3 e9d5ed5d17eb81635b3f44bbde735d506a1b1002fc963369db98c2da1fb9990f 4d691872669063c2a108efe35bc269e58db0a3fa80d0d791fb323d97e1519203004116a760873df160d6c6fb4a16bf0a7f22dc594d5917f9bf59532bd5573804 +generate_signature d48118e8850b94a1d6536e8ad26424db5ff6a8856837b5f2b759991cecc0ea79 76acc258e905aa60091cd19a0453c086bc63fbe6a9b9f9713c5a59e4a1f65735 e7eb8679919eec79d95612ea8d4f42d3dba03c92997a8db4ea7ee670bbda580a 66b105887f3460afc15e5bfabcab4fb30ffad9dcfe1de27021cfc4749fb8a70fea6f6ca92c9b2399ec8fb3f5d5843b9a7d13b69e2bcbff2303c7d31da93d2505 +generate_signature 95b23e89020f166b62f1a0ee717a478c07b3c96d697a3a5e1eda873c407511a8 8d7c53fca9f208f436d9b1a921daa731f79e537a6aa1f54b809aa4ad9b33b860 b702f52f1dfe951d4cbafe535089128cfdf8e3c62e95238614d230bc783fed09 4711ce87b656e3ba158dd2c7b54f4c90c3cf42e2f8d8db5317428c7a32552b0780d2f879e10b26baf38416335ced8a2c137fe802cfae343576a11c80fea0e207 +generate_signature 73017e127a3cd7c8a9f97f80ccfe6804c5bb683b22b6242a307aa84f2b2e5663 f17f920f113d54ccf8790951b2963d35165c852ed0cf7c6f5da3c1af2874f7b4 7dd05f2bed1ebd7b1bba8060fcad9368c9c114e49ff553273cdca2adbe5b7c02 b4e3f18ffb19b5ea02521aef8eecf414c5f6d399db8b8c567f749f766816b101831e6908c5ecc535682a1cff9855acf5fb082b28c866e719494c1181c8da0b02 +generate_signature 5df7c3d6ef2ed1b6140e0c52d836594ae75adfe243cddc0cc11e253674ea1d3c 5d45e0470b6d249abde6354c3db9e980c56705786c11bef17f94a31cf7d05d95 60e30994ebb7c53ad955faef54e0abf7d7aff8932af097db250fb56099712b06 dcd01dbbc6e6c768ff4eb9092012091fefe7f2dd65212ade4be19cecc7e31e0ca74b09b01ed1e267fce42128201cc71467e261fe69f5932b19c8f1ab7f14280d +generate_signature 5e1dbdf1b13c9e0be80b4f4e10a2bf29144fa2e66553e81fb50f2f7b55633f1e 4cb10093b5c9cda140ec668a576def490cf7453635bb4921cb9ef8c8e909ee52 067e27cc60b9d9da528aaa8a48ee6cb30418189c8f6bb0d5710dc1074dfbd605 41115aaf71624ee2144d7d0f0d0ddface6cae12d620fb3aaea3b6a58abd86e0a9c1bec91e4421c3b4a889bca090a118405b67693f7122f7894371d5b7a18f200 +generate_signature a08e5b2e08d5f1c70edac02d97b7174e348c6d4bbc201485245e8578efdb2f5b 4a10b74ec6c5ba4cca27a473ff6022c3618b2e3c24625708add88767da62e3f6 50262cbb867b9feef014c6d0f301838bb92b66a8f2109e67d036129096168900 2047cecb87c08ecd61efe138d887422fff6eab7aba3fd3dc5ffa34fc116c8a0aac15f8423b3f79b636539ff45550abf2b8ab49f56593fc47352ef57427c0fd01 +generate_signature 07edba63a2c0fdb2e02bb8b8e6b531d2a542b0674e24f5ed1f3ef2583d2d9eb6 8c1059bbe4a373948ede638667da04f8caf05aaafecbad08de797a804f2e65e3 abdbf74be8cba1d22bf91057a94b1f12a063acd976e4410152a07de48b290b00 e33c1c1f387cd06a311d3f8829fc0700a71008e98c9a692401267d604b00a20173191f1c8ad6aad05432cd76ac66c891cd1e6855c77d2b2420afa027a159310a +generate_signature 5dfe35eb9c70c55e285e3e9121651110e8daf329a1d3110bb342341f0b13e285 898082df3ceb5d2e96fd5400b22bc169e04d3ad581a63de9ea638eed30a1f63d 1e83a05b9ccc0daeb952e2d6b5cfdd414fca43664ed0ecdd30c5eadf7a8ad20c 793d027fbccb1243cd72667351e943e576775bce2ad9d158455983bdeb866108647b3e72499a2829b262d2f840399e4016ef6911cb36e17c598b741b55961402 +generate_signature bcface283643b5f6fa0140dafff732ff07f4345abf3770523489ab4ff2731c58 85dc41f9264298c7ad08099dd2b20682dfa4c9798e69695f9626f644ef7c7980 b23d6a04cf867f63aa2e6a26784d5c7a00afe68a37af3069248177b77b50c506 4395dbd98754e623f364ed63da090581c325a259116e7b9b40266456814e450c727e087486a7135f24d85f1d47f30959aca0a254faf472088ba6a579346e0c05 +generate_signature 79444422974fda912b29426d4fb4e8900953d14b8a04b2b48a3370fbf6e0d34d 55c8b685946d2e1720c290ff6c2bab2643e35f6edaf04476dbed56472ccfa242 eabb6c32344af64e15d351011ece8fb6cb2309ecaff2d43d819f59389bf57607 b736b2d0323f3517365e93050888145c9b62e2fbb1bc62d4216a363f2caf660257c419e6bbff0bdf4cec461717e414cd0dc66acf9c7d5a0940b9c09064591106 +generate_signature d2c081f5d9a76df2448bf6aaa021331d6e0fc87e31b6fee0bcdcfd499d2dd94e df1afbf7c09126a407fc34b118985ccf41c4e82427e6dcbfb0d3897cd3705d8a 56db60488923ad7e0575b143e71ce05d93e6d273a5bd445cf74ac9d8336c230d 6a720099dbe026e42a9ddff8334cae0b471c24f78a589fb6aed16c04da89250df3d023610cbd8368a4c7310e6508c9e3085935e77c17dd237e26c5d024502b0d +generate_signature 8153ce2a925a6437aa445072075b5cae447affcc86b452290e5aadd91e446e9d a504a848e87137e24df67b8330d7dce41efb6a3ffe99ca69d7a2775bb4ff66a3 58a649099831b7343c6800ced12204ed25408aa9b1525d2f8aef6b8a40cfa908 443f43e6ba71a442e3475b75e5b8057d2263224e5cfb04325512b78a5d6c5d02fb7555a350eacf05389a03e4402f24279a86f677908f2db58477fc3284ec3c0f +generate_signature f85e575bcd9427a761197581a05d22e3784e602cc471d88ddef5ed4e6ef26ac1 e4582873da79806344aeabdac709ce261fbeeee546d0068c3d17a64527aa1cbc 1090799dccb3d243647defbe3ae894d316d68d4539a134d8aa86f3a4116be203 ae3f5bd2451f1d0427fa3ddfd43e29952830737637eca92bc11b702e725fe204cd80aafc0a304ccc4465965304ee385032a32fdb0cb8031667f4494e25b09004 +generate_signature ac157e1a76bd72924e77dbf97e15469a4da1be6d154a8974aca1d77da7592e93 f4005a9e2341967cae9307f262d87c064163d0997d9f039a2488fb044d449604 7f8c5592166b6445aa14fa0b765d3908f8ac9af1c6de0f01544ea95c487e9c04 12cd81c5b4a26a419ebeaa4c9359921076a6f4f4ba58fb8672c3274c2eb77d0acc9b43dd9e20143b7e7b0ac7174ebe0749b0c961fa427ba34fca7daedd094b04 +generate_signature f135a8ea135688e2cf612a1517c305ba88b556d3d0f5c3cbda706bd485993c1a 5ad2fec0008abc302e993a7e03a99358e7113ad6cce435c81d440463e39fef88 5a0e0b8724a44adf7eeb27ed8cdbd6a11d9f1a00d0729f6325910ca6783dd500 18185dc79fe4c41b9ce8e5a81f8d8459c641b4bc2333c1d26da4e3d07badc4088fd440494360ae965555e6a4b802e9b455a3a618ac3bf9d787b1fde0e3606907 +generate_signature 2f37a11507b767b81357f9d03bce2d6f92cbd79af252ec737a2126e1f1a59fa0 2030a8eea7a816364dd23b81655dbd00e10edc8f40b5139cc49506db9fe12c44 907f88dde3d47b78945ba4180c53fab25024bc009aa678b34c6958c3af14a00d 813f32c4700ae51d736026ee5932ecf36ba0603c8e076fe76b51cf39c339b00cd15fc123ef72733f9a29733f303cf7192970aa192d80441f16a063cebe25ed06 +generate_signature 40f923c6bbde2b5aa8ae568a53594738edcc102ae77d2eb2ba13250bb3701aff 3d0d965e35f87612a3d53ac8b62ae4e7d4aa2f1cd3a6fe3a258ebe91457a810f f88b02b56a6d583e5ee52898fd7124270a1de3aae61ddb45e3fd4d272ca49e01 347b25ee0d085e03306e6ff10264e23311d2e5916edd915d809af46f0b4ac802e7594b45618ffd115bc9b08c28c060559bf619feef33842192a3683c04122e07 +generate_signature 3c4a9e9af77301f53f078bb5780d71d3b14e55457fb26308647706d88e7e8ec9 41a6ad8332efccc56dbcfb936c84a1e608467d9f58aad447e7cedc9c091b8f33 6ae28d2f4d72100a1638132f6c363d2d65c73f2f6e9e6ef883775ce3eee94401 8284789ac7c0c1632e78fb9fd3eb8cab8443374d6c7a99a51f59458face66609a409e5e03dc375f14760086de96d1f183ba6cfdcff5aba35519854d4b62f1a0a +generate_signature 6e361cb98046db1c58738f54bfa5e24003ad2843625089084112d3e956781da1 a40a310dbf5128eb712aa9ee5d339f8c0e78c90e8e44977ec83a6138b6191627 ce3e7483fae52df03b7c08d8f30fa43fa505f0a7948889282f5e46b0882db500 f67f9c536d25e02d55a34455ec80be6995391acc2f12f83b0e88bfb41fcb4c0236490ee6618f747414be9b17488a78594a0f2a3d7b4112798adef6be68492f08 +generate_signature ba7df37a2d75e962d42d31a91525075ac836100ed1a78ae4e978afa432a1235a b4ccbeb6c17e719c79942b74b81a3cfb5ccd63e0c06b12fa88f9e90cd9e8a1e0 a35bbaaf8d8fcf421d4307e3a52f63d382b8ff35c7f6e5f7a6eb0a7adfd02f04 039d5886e1ec0ec7d0eed7365fe0fd8cf61d24e62bd8e86cdae81130b1a4be0812ed100f2a208298a0ae742f5bf7dc52c52f54cc083a7955c5f73855d840b107 +generate_signature 81599211da2f1378330d2bf7f86e0686947fa402578cee048c6fd648a909f2b6 865b484252a23a1697c736ddf81d44674d9b51fcbaaf5bddf88061402ac65189 8509f1f20c25d821fe6057863277222b54399eba3712721c82c174d81650080f f1efa9cb98ad24b4360127092c67db3e2202d0fd4ee28c7ed2a996d674e3a4073e2b8c52b0f84e7a300e1184cd96e9299367d623c0397410b356daf6db9e3b01 +generate_signature 9655414428a87d11c0bbed9af0bb32010c4847cfdf75ebf4a8c73c1d5500f44f 53bc48c7306182d958147ed4510dc3c1e5b3ccfc16938f1a7d757ce7ca2fdeac dc1506e5b95e1d6e6e06ecceb4b8cfaa00daf3d6fa26fb672374ffeceb0cb505 55e0d362cb4370b5b6ea862a28322fe9ea8c4e5bc18bc078cfca149ba923480b476bdb7053951597784e0efec4e7f088a4e805b1ad8b1b258c10e9bc2ad8910d +generate_signature 3e1ad25eb7a1dc33c84bfb09d73d946aee497638ea639157e1eed1739bd0a84e b507cad326ce68772dd3cb43c31bdd70cd71d722bb551d209d53449c232f5055 c06773a6b15d1409ccf3bb4182509cd418fee29a93d966c511809b19eaae4d06 1b387007ff1d75ef49f4756996b38487f3d21dd5d639f5c62bb9ef1ab1e9d70bd7de58dc2d198910d3196f5554725c44befc6f43c5e89bbde88ddfb579fb2d0d +generate_signature 36bd8cd274466d762f8bd459e5f32dbd7662fed9bcb44b76276e793701c7f5dc df9013de104e242aec33250ee64a3019fb7ad37bc06a421c60ac21626c9ddd6f 6342d56599a678fca61f584facc41e316f0bf152165767f50e3346b7ec74a208 dc68d3cfac0ff48e0e056e37a27c8ef096135f17b115a5a2e94359e60b32740cfdab3e035e9ee0d922203917b312bb9ef0a8e2bbfeb9d34c3c89ee75a81cbb03 +generate_signature 829f725bd1ec12e3c244c4b0006499fbff693b33d0797c043334ec591a8d64d7 fc559b71cc887e98088cc873b9d7c69d104276e257cb28197644f49e8854e69f 36228dd0b09d05703d7f8b5235b94958439b8a95b43c8e09b577a0fe6b26a901 3dd769e6d79ed52a62a137d1af70867756fd3e140f0ae674c7441b7976fe48001cf568f0c922066b4daffd4d58e2da2897fe8df0096f3366943a36a3a28cd502 +generate_signature b2fbde52043e979fae4cbfaa1fc218bb87b87b21410c498be62c5b288f0a59d9 fa437eb7611028c6141280c056fdcdd20912575cb57d652f78034f7afaa5e0a1 df1288522dc2cbca4473941856c0f24952f69b5c9efbe6df24396ae25ea91105 35e46c633de3a5281fd4df5a84e4b55bbdb893a87518726cd3950927d056f80f3c094c3391b5cb66a253a9405038f4dc7c6d1a2dc7a104b859512ee15a30310b +generate_signature d21de662f0d58c9f746f0984fc3691a3d0bb0776e539a2282207b8ebd8e5ca85 679397579f31b061479734bc5fb2218c577503f35827c815f22bf53761c272d9 b04aca24dcc7f0c6d04c3c676a6efe8062fd5618d16155ba2a0e4d0485332c0c e38a5bb9e2ebe003172cabf2a3f6a67a2c4c1b536390f989b26f9f0a3147690f55942d4db5748ecdba45d9bad81c5c325f143575ebd3df478d0ea7ea0bc86d0d +generate_signature 44c6eecba5511adb489dfb05815e764f933553baf1acfb6e9cebe010337b24c0 a08e4416e02f056c71ea72e2eb1f8a89f669fbc225a7254e4c8d0f8d39ebd1d3 40f60e9ef735a23ffe2ac767726ae743f2844fd7e8981a96cef85096359c230b 332c0730801c2d15308856ea23883a28938284fc68f1be702370714468f03701305c5470d6b4e0f663e95362062f9d96f39099f9227f29dc3552d92829359200 +generate_signature c36bf112fe3f11d4a33a28c8f7e96e18c0a561eda487ccc7e441439405c5b339 5d764a790fb3442a21aef48510e95dac552d0f34c2b03289ab11faf21623c451 ec45f5dcff2cae290875866dcb122645d1b88cece607be63783c3e088cba410e 6018c6815387e952d1f8c42222e166f7b360d16ba78a35a27ce3bd4233ad7c012ca0cc118dd6323794252a31015a131058851a7572b5fbdabf1164aff2940504 +generate_signature e642c5bd2b451b20aab856686bab22f6987a7b5330c2491ad9d43059cb5b17a7 e5c73f7ca70afc4019ba044c177ab7ba3b57070effd788ec950e23f766617ae2 1430d7db432dbcf48c88f489017aadb6bc4a4dd30dd68245e281359e7bc6610c 71a256a377534509f1716542678d8635c0c4446fd7138c4a2d153780434d210d3d583d49e518456623198dea829e2f5803e14293a3b70c5eac349fb6f8d05409 +generate_signature 0b427120304ff23f1906c33972a5ddfabc833455e1c00b4ad522dde15f401237 45df3d7b2ff3ea6a638a360019b6998dff96ba9c11ec454fa763b75ed9e21891 07290dd0ccfcf302d33d38e5b943f338a40e63fce395f47984e7edfb617e3509 1c076bcdcdae3426a4f91bf88437b01a7ee474bd7ba086dc1f0f8c0c9a032c04bc9e326bd4471f744ef043d50aac23a526e1499e4f5b21bd1dcdba3d77c4b50e +generate_signature 5ada550217e164eb59ea6506858ae1ab537c9cc15d362f94570255e558911490 891681f48e13a2f0f2a7e189995a87f9af3f3b4aad553deae50f38455eae34ae 9f12a804897eef85dc4f89885958acdab399cea0cbb6c7bd2e2b40185bf53201 4e5464d9c965b145bbfa4ee2143105bb98f79c457953368916978d64e4d7d20bd741f24ea3e6eeacf4060272911f8116c500a4da816da186df61cbc073e8050d +generate_signature dc200cfb46b99ed1789b022df4462e679fffde969ef75181470fe77d2f659224 a8987ff64be78dc7120fa7c7caf8dad90e4b8dc44597769eefc67df636c26062 4f5a3321915e3c9922eb7704a158f64d27d32192687412d28748d2ed4636900b 621b4a89aa668bb9bc4ad9bf786bec99efb8572d27771708aac1580f18fdac054d31ce1e13c56a9cc393a269a5307fb20a389c14d7f4ee495767ee841ed7ba0c +generate_signature 7462d6b416e428b5c0ee3f90ca39575495955b720ad0e7e4c2955c1ccaae1888 36260bf759635f1628c16ab8a85e22d20d9554f6811bf2d7d2b0e724088c8567 2f37c7a26aabe14e904c61e256d5e2857adb8e94c3d28a57950bd68b5677f302 c45607b9f23ac3cbae4566df28dc0fd8e46ee8a524daba56c785cdedf446ed01754f26a9bb72b8b42421b463cbbcc8c6087b5390496ff1afd7dae9d78be1da04 +generate_signature 51e9571c4b6814a631509d7b43dda8a19fbd9c5536c3355c3b9ec28fc7d4aea8 cf237efdc47a5fbb1063f9851704177751b2bb6dd40f35a35bc49acd95e11370 a37484d7875c479c3df673457b1d82b1d8fc80df5274aae7d1aeb39fe2aa310f 08d9be6a729a27d13eedba8ff518720bde6f1867eaa23ecc2389259ddee62d08d24a6ad2e1f969161b56b1bbe9768288cd1a960f1553e72449f8508a7da7de07 +generate_signature 512f462d431403b24c18924eaeddf9d911d5c614d2a5e274c21933a136cd8e10 20f1bb98259c891bfcb5e11793ad38c2ca863d739f7a2c53bf5f74c9472b8fd6 8f92a6e203eb6d8ea988a11177aa370bf142928fb93c466bf18ab55b50492e08 73bf95a5d2587b1569df3621d582da84a5522fedb5a5794f3757847c83cf280e85f87c22a184fe5b66c4cc8f7cf9f19a1488e11e2e6698c38d8fac7e0e19cc03 +generate_signature c67ceead9a67e5bb1211538a0c96cb3605da36f1fe2a8664de0f134781a85889 25adad7475f476c9c02b9fcd3c7865d261e5da7261031256dea250c71f305bf0 8a451763e81d056b3622ff5db2432b5ac52a4565735d1f399d7fe44f409b6109 c5be7bf89c1848aeafba6946ae1019dede83ff740554e4ceb69b7859fb47b6053b5653e3bd00421fe086aa291c210f3aec1ac29a0c11724d0320b0f13dd1a008 +generate_signature 8744e27a87056f551083b1240834edfdf4576a4b8c4db7e93c03bec8f714b842 ee8c02e0eb978f310eeca705aa7a4bfe38cc10a9a92e8458f5656dbcb22a604f ebba71caa77c769b5c0920033be75dcd8e1af9a19c97c4cfad52bd52efb3cd02 2e7581480b18c06d344166ee5a79ecb5fa3039a5c9957e8068ff09a5aa0fcf0cada3be3cf01ad9113924caca3b88d610e7738b5962e0e0fa21ae62ebf124120f +generate_signature 01b5d99e68a458de21c085b50147ba1f67b0930144fa77ee5d4e1d37e91da1aa a928416ec7f0a87dbded403c87fcb073528cd4f90651ab9e3bbdd14ca61b6e46 370f367e7ea29b50ead04f5195c6b0486923c4e7109c8fb79b1059059378b302 210044bed17a014c53a89aa9635481e3ed1c2b20f219504f13ad6909fd79f00f5b098bf0e49fdd36aae37b620d12c2682fb110521ab0331392107d495859f40d +generate_signature fe682bde8ff2a30f81d616c05b9b356e32b3b6f11fc4f58c133d7b9082f3fe84 dd191591dd57a04d33124ce1af1ada602b3f5304b15d4a90aa0732d72742f501 c2b494b0c63900df29f46d4ff2e56a644aee5cad4105aa0123bd9809d675df04 44d5c029aabc08a8ec7360fced674523b6ffa5f4361badcc5dd5b7ccd57af5000a82acea519b8ad6b6db219f930d65945667d4c87677ac59361be12c92f46a06 +generate_signature 96a71cd74467e3b95e4dd8874535ab8fe7710ec4956aff40dae1e7849bcd4c24 c55e53a61395c80d8adddafc2bb1224f1e64ca8014fd13d809c86d7b5e299e0a 84356cbf4af292e87e3b7fc328cfe45d5bab67b784405de76533fa4fe049d702 b4eb1a5c7d454613235c5a1fa22e412a8a06b8d1da1404cb80b59f84f036c001094e748720c5fea4326be5ca34caf8267557a6c224b7b3f6b0e9ee19aee02d00 +generate_signature 7332333e4bedbc6291e64c3acb32779b6bb94493e83e676da1ea8e7ac593cf7b fc9dd303f58dbb87fd82695b463e1197a265279031cf9ae5a6a7e6dafe2f0fb4 9fabb96d4292617086a3a9c0dc084bb6118f73eeb602a6fb3082a37fe6d7a40f 29829cd4e965decffdfc0d866cfcc76f021cd5816280c5f9ed14b4c43f46b80e81f5f10762f002686bfa98ba238d562e493b8c65a9addb4512398afc8f8d6c0a +generate_signature b15d619a2e307fc4e1848688c3388deb8f2e0eea38328cae0886adeb42474204 5d2eedf3536c0d1857d75190f3da8f9e214dd170790722c0ec90b5876f46fa1b f107b7b3f7e17ed25504d36574d01318cea43a84b0c275d097ba0cb83e872601 da0bbb4309f077b22353ed0fe47203dccff8a301c1857833c41d72d7955a0906bfcc99e30f45503fcd2e032723c159b34d10d0d4a90755da7210710599ee0502 +generate_signature bfd9fa1f474799d11ab3ef3abae59c17b300b8cb899b2fcbfacec678cc77bdb2 362bbd5e5c95c7e1adb900a3c6c5a67b5f050e58ceb6917bfd037abc61457f23 4bb72c886f3d978943afdd5c1e53882caa6b323e0c0836a1485156c569c2b604 25b34f04046a44efea3c442f6853b0bc39d2a2970a5530b3f6345eedd27fc60f3d5674de169ddc6334d0a1e4b4f2304abc434d4b4b62e9cb07a437849a2b0502 +generate_signature 3b8254fb834017e439bf4c9db7a54b8d72cfdfe734e64e3db94bc42761e52a64 3f1a3561b18915b34bf1b451fa01ce6b9e2124719b4f3843da1caa106f5e724b a9439b2e768ea849b35fe3e8f31fafd2460343374600031aadc7a047d8f4650d 8151bef3f67b91e1b8db1d6d8872e0ab27e70817861787e99286ab9ab28c6e06491904015409f151431d34c17e501e264cccbcca23e18eacc3b93144fc18ef06 +generate_signature eee51b7ed448e86eb34c493bb7cde32b654a2c3b94734b54e313b44705736194 9cf9b0c581562977e791eaab88f9574ac7e7b173077b3e67283fa00ae448d19c 7e0763abac9d638732d9cd91c7662b13b14067fb458dd8c13329ba76d9685a01 9eb25ef0b5a92471dc77ef399c705af676dee3b61418aeee3df2c57c35a5680aa662d877334846532df869225b174590ed234055d0139425e1dd94871c9cde01 +generate_signature 4d0fe60a2d913071d88b67d806b451e5217b66279c8a366ea50df32dc7f019f0 30be371fcd62d0aa789bec1511074649e012bafde098d1997867cfd1a1c00020 14ae35724fef1e5136b485fd319f2ddfa31858c2f6e8718016ac61c7bc09a00c 34c16aa2d76361ae999faf61bac6dcb21d8f67912cbe56cc92535012da0a2f04396d161191380d670a0b5366a5a83f95111e916de574614a44fbedd1591dac0d +generate_signature 52558464c45be054502fd7a95873356906175f45d96a123a679c61293ea82c59 f2df74450892e64b630c1bd242ad6d6eeb74eaaa37817359f0ca6ceedadac351 fe2330bb3f97ebcb29060bad76f122164f4f376f1dfece45ec8e1b74a9d73304 92963c1f4e21a692cff1fffd36356da35282861844610d0a58e19ce85438c8016f2064d303a8abd19f7de365869ec1d26d5cb02cfa5c864b69f0ddc902ed920e +generate_signature 110cb3d607cf3cdeaedf72bb5e757beaaf33735c4e0a6c9d36e15c3bc44f46a9 299e119e03f8698bb3f91c0383fc2fa3566893b430c4181ae75da3b6db52a14c 5f8e1334f8edd3031ae48b6167b69ee954b2dc825d96c1a66115f3e0dd19bc0d c7bbb514cb6333cd47d4e4c99ec6aaab793a3e8ecfc5754c48aae09631c5040889f6a1551d2eada3c3f3b9e735c5183e9b0d4198ed10dd6b31706d521631a40d +generate_signature b9c72e905e48aa099d4618aa4be67625490d93c298ae9a3ad50bd3051825ba5e a2d1ca5b1280a41694c3378e2346b3f9ec16d27905a7d9f1ade0aead412fdc5c 2fd3f1486114d6f267cce879108ab62839c678eb46a846383c25904f47719605 29d47564c241ac9f6e80e65caea00e4bfe36a2e082fd09930a21eadc6f74b401fffc06d15df962209468aefd1a36435c0ecce62ca2dea41e16e5c24b5fd1d70e +generate_signature a61d5acf702d80aad1e60667f5186d692d03c291015af38ff48b3f627dfb6c93 794e3180afac94b50792ae3b11ab01c8ef4e02973b3c2efa5b3110d2cc5bc5fd 89a145b6365dbcd67ad36878174eab5d3278b2da8a0724fc6b9fff3dadfdf103 f17b84326f52bbc547b1ccb32c1280c0a6325797ebf34d0828ab717fa72127012c17f67ed4aeb4644511b20879b7dd7362d5ea5997010e77dc93c8bf25fd4f08 +generate_signature d0666d9f44a461d56c2c6c35bd098282042d7ab5b4138f80b22b98b940df2543 c97f167d5fdccb9158ab96824c60752f6a1034e163b96da179cc42a8d6f8cea9 443d72bd61cb9ce36ac11839333cab61bc85506b91dec9ae8d0071fe9805ea0c d5e4edee9dd069933451ded4de5cab375d61a17407c73266ef59541997f4b10249025c47e5df85d637d7cd9c8942aa7bc226b48e762be242a318662543119c0a +generate_signature dd4e6582d6f65498b6e6dbf35f5dcdfab52f90a8eb7ef7391111bcbe7066929e 1200b5eac5cf70e9c52da437ab1d7da3ad5f951f65baee0ba8aa02ffe69a3675 b72904a3d7180d9c2c16e090c52051ebbebe0ba8376e2defd850bdd698fb6f09 317e3873b1711eb2d1b6683b891c3f9fd1d9b640d798b399eaff7de9ae138600e1c535aa0fdbb737c45b2635ac1857b29a3d7e0768237ccf8630f7bdd7e39809 +generate_signature 6a1c4227f59b75fd001623aef3687fafa8eff103526023aa6676e8f08fe3c15b 1613c592fccc2e0031487aed9aefc3eb0b86ffefea0f014173bdb28acf4e8bb3 bb93bcb48a4efa8ae0b0fc9393653f2696c77603e9fc3bc1956473f04f64e402 9afe337be855a0aad8e2f2219fe5f38efff0779665bf106d8d3d75307df8700f21add70316824ebee74d2cc197d3a8bac772adb9df31e8b5ca72cd4981b3d503 +generate_signature 2677f450f708876541bbae6ec7030aa87d2f7599bb4f669c190b8df2b62daf66 7a85581bd21fdad5609a84478a9e61a084ab78021c7bb0fdcd6c9efad8cfcbb9 26971f12134601802ef62ff5dacb99e5e0e08ea2455861e63af3cfcbb8cc050b 758896ff7ab6393727c45a53748c1c0db57eb132bbf97624130f5edb37a88001b83beeea0a4fc27abaa153d0584f00d8168c615e15181d8a4ebd4a96513c3703 +generate_signature 15bbccb57984f152d62b0c82f12d732b75068118fc3062805c157c33b9f35741 cae0a132e7e32e55906039a7f510d940cbf4dc16543beb1004b636866635a5d5 6d16a1ed565e148f653ae3c20a978dea4f2bdf009dfc8d9e66a201c9d184e906 92adb060e60bc4b3904366dafff0e3bc700e29683605059fff7ea92b615a270b409e65981d579c3327fdee258683c2055e688aa45ba9fe62cbdbed6520f8c305 +generate_signature dba1e5cb897f3a931ca00c61296c26aa6edaaaa95d844e8cb29a8818e5d3cf40 8011fbc326c27242f794f1c93e7e616ae847badaae42e30ce345ee2054752490 9b02000c18cbce2c5bd97d9e572ef1124b710bc4bf820b5e740c6f52185fdc04 68e45f5355fe0521e0f10297ad4e59592be05f13976d12dbda5e1bc7efc4290a77f4fa3a1b4fc46fb8c547ea6c1208b8d2e63b837f2dad11df5faedd6c38de0c +generate_signature e9257b43c57e17027c955dc21454cdb41cc59ad29307468ecc595466470519ea 5c841fc7705e9f0691444e3833e84b946f0978500e66dd187b6b4011e2bc5722 ad7c20800b766bfc8d97bd71fdd21b3390f9b5dea4a763ec94209e832add0c0e a83bbb8d76c32675b4d7b7a24dfcc21619964cbb84b7f4ebe92cc79676b55d06089ad673ded1660a4c61cce4fecb9dcd862291bed7955f0b046f42536453e402 +generate_signature 49a91500dd7fd49dedfc127ad940124684ceb5d0d298fd708906728551ce059b d19aa3856ff99afd3a621c339cd5688ad3d108e313cc6a12e76b857a56c8b254 8120cda41048d6102dd2ad998972b345886573e7caa4955df7c3b6632f96a50f 38f2df81caedab8a5665a076b9c7eb1d7e05477f10ee293dee4f54f668de2b0bea8a4975a22ea588d8fb3e0731d54cc76728230533e9456648b853536fce8601 +generate_signature ee3d3c574231cab4d8b8de5b127423e88ce63d30ffba94e44b7cb52d933c4551 c7c4c1ebb9ac8a9ab8c71bd032c95bf4d76ed79fe8ac53265f8d2e0ff0913e5e 685985d5d94c9702bc73c58eecd4f2c69aed4b5ec1136af0636ee81d94c2530f 9366cd5036e5ddca159204be01b19b236122ad17c3aa0c3f102921b388b91e053691cb727a06e90b126a4fa082fed31efc75835d6e5134999260099c97e90c01 +generate_signature 1473d8159b8f7ea02a7227be5ddd874e9c6e3c114708f7c46de729a81f0379bb 7d995c9eed1ff652f954617817f772dfeaad1ebb968c3b4260c22bcc6aa2e764 302201443d6fcdfd98585792085a7b7e804ea4a79bca8fd6b1d24d9ec30eb10a 165e8c1f5c0c47e2e1ddaad96c9dbea0b94313bd6c947bf2b49efe8020ce190d3ed64e455eed6fad4ef0fd748a93226bc5cab3033f1bb05e087a0d1e98f66b07 +generate_signature e0b62a10aa27778f06ce587a439179f6be9a444588be2fc6c61fec24e4cbfae9 b31d7350dc561bdd04634b1c65d4d07721b21be061f4ea6779a1a9f0268830fe 033f706a513a3102241553f06fcdbaa4f1899f9776f51584495e0eea1195c906 e4b3f64a7fb38b66679f5dfec62eddd9a46ade8a6cdb9f771d9eb89aa563350e11d925f130ac20f0c42432cab63fedad810de8e3a72d6dc0557e01717aaf2101 +generate_signature ce6fe431c9d841f2f7494d0c214ed3f4d470b1de679e30d0980137dc8cca5369 7c4883ca0408e5279b4333cd5970366e7d2cae46e88bfa9efd5b9554b8677438 bf876c480666daf828d4b5aed26b853372ea58355c370ece915600f127dc2a04 b8e22ec11439598354682b80d81c6654e937702fc2ca6de42376601aa6954a0928cf8497b5d945bb4d25a9ba6ad88c3e39b770a53d92dd665970c8b771f3220f +generate_signature ea984e9cc588ddcbd884642c0c1eb40dd85cb049f22688a80f42b0835b3d2721 4e200ad1863ddbec552c937ea0f28577d93959185269c21b5b0a2faf11738582 144de89fdc0a762c28f54d7cfe1d9c7c1dce3d1b520bc8e6b1df39405708b505 a81c8574819b8bae35bc0f513affa3c1492467c4b22e268bcb7db200083a9d086f3144aeb3f995667730eb266229263300707f937e2ee850d642c38bdf59cd0b +generate_signature 298dbd2126d0276c1d95e2e5220bd529b25c16ca670094a667fd3397c7b7b22b afb3b9bb1769caea17f4102c3e59eecabdc9108195d33f0129307af251f8f330 f17b90b7c4bd2169f7f1f5816f8f72a2bbfc03c4617b957db3ffc04b6e42a303 4bba71c3d06121ea7e003ebed49852a0fa77673fe01c228f40960fdd74126805a329f480a96a671b6699bc0b3f0c51d31442518db3a533493219b8ab2da1590e +generate_signature 9c5c87cc348b763b29665e7e9fc83c2ee425c57bc610856179879b5fc644dcc6 67894b54c0628bb6c56ee847b712253782a9b02a506dab960a5b8eb9e613215f 082fff76e7d834c3034b37eba3aaa231b1b190ea3514791beaadd4b3daaf5508 328f5737f98b455d82bfdb8655e7387d8a4370a54b8f91ed71342863318fc401b5ca3584db8fd104db823bad2b033414361c61eaa331675da17c6fc9e1512909 +generate_signature ab263c0d9626de5860ea22e2f999676b455641c23e9edd517f420c01e84cd2ce 1ecb565cdd6da4bb6f6cfa57e75940630360f663cf56cc716f1b949419f9b6e9 d22ef716713fc60b11e619292c44ec432fe7bd4cf582544fcf2ebce23d566009 226e143d5e2d033474ede0e4114f4da01baead5e9bbae6a9f342305ddbd8e601cd927d3c3ee7b2e460d2baee59211761370f6f33deeceebaf8c1fada626efe05 +generate_signature 2acd9cb6a9418f90b507b15bd258878fab69afebd0cdc57ade4719ab89be32d3 814c8efa712bed141ffa2e72b2317dcba9e917330523946c2a97e8af3f992fe3 199e9c09c85ff00f9431ef41d7d9a56aa05cb9d09f548d2fad7a783eb2faa400 1ef47316b07f7cad4076e70863c08071a5be323e858f0a7baefc5113b24455089410a2c18fdffa9c5e3ace8d4332200a156d601ec0c724c7fdd55eb667bd7008 +generate_signature b8aeb16bf5d31ae4fe7e321da12d8defa7923946e197390f0a1696526099cb03 eefaf0226cbb5685e2770e2b72a0de26f30c9ef5673053fd64e762d9efea370f 4e524c57a12abdf684c05bd99eab65efb947ff2a50b1f27ceef7f4cd268afe05 dff7951487b8b37103d5922520ace922aa582362a590117d07d9414a92619d0f33fd2b1a2460cac288375e9376d746f6fbea5b068e736220052af14320163801 +generate_signature 4fbbf6dcbbf50f92d5f60b467c9bcd4921b756691660b2ac73b256e6b614acc5 0453e634c6c63a0dd1a999307b2c9da357b54fc1e89eedd1240f6501475d35b6 ee840259b97e841cdd17946b4b4acbcb90c7bc05996fea802825c62f18c00902 9fa0357df98c0199ff33613b08ab56c50d361aee1373aa9994f1410e0df30a0c45620b9194b8ec490168c1fafa9e00803679ec292b80d2c9a87b256fd5b45f07 +generate_signature 7038946351d9332520e91640e4ea8aad9642e66a9661c1e62a519a3e03d24f57 9bbd178c6a6bc802cc56f0565ba7ef52eec02c1f0098a3fb1a958aa1885e4d63 f68267ea33101df63bb15fcff1bc528b032d770fe69a0b6f0341c614e7ee5d01 07ba12b7840ff1b735594118f7f0668a475cebee5c4c810cc30875d2d4d70d08ab4e0aea65460b2674585fc4190a6e888cda887ca5846355cf21903f636cc507 +generate_signature e8e5ae2e4f4f51cff909a6a73d0a24be6e049cdf32af893b6156a9f3bd7a0613 54e78d50e27c98418a28d0972af5ff4f7e6a5f2e212d792871f4395a4e0842fd 873ea1693f04187e4b39eeb4395d38e2b12494f3a426dc3ef1bb58a2c0a55608 ee8b2afdb47c4272ab2d8156da188012f36a2afdc93500a9d038aa9627981b063b9cf755c397d64a03b02e7bf29637de8610c25dc2846c99768d5c9f3497ad09 +generate_signature abdb0a9f87e46a82240bcc77f5aa5f8c0981398731f7bc392b1e7f2d569c491e e8551e4b00aa9a74084250f33285a955efc56a310bd287d97ce3f213eb51f97d d28b26262099d372ce35d41e3a289d793b425a62205f0f22fe348510120fbe00 dd41dc6165ad1104e020dbabf94731bc7d630e0131cc7d2a72fbc8ea2ce68b0144f207cf47715c7a64cd01db4f346166a38548bcadd315f11deac6ca7f913e08 +generate_signature b6e7c69d55fd322626930ec53729cc2975b911706721a48e41ca406146cb63c4 58a63d82e3245e9771435211f2b415c5739c99370d08011e0baa1b502302b16f e1e4f2327b82c6fd7fbd35905d91056df0c8df6702eb282487ac55b3801adc06 8409e7f33570971ed3913f916a8c61984eb39b68dbc3b370cd5a744cdd183600fe53c8934c5163892e7a6ba80f31e735f4ff8129e96b396cb6ddb6929eb8140f +generate_signature 98d1fa8e6b508971d25a7147eedd2347f076b72729a35f9b1a81203ff85c810d d1e1c86421a34483152b3cc8bb124d140fdd638210ee1bf0df30c80b54e61343 5acdd92d2c8eb54a0ea6d466f5c2718d703a5108ffd352b6f8ff70f2baa9010b 4167df54c0ccae4237e42a60566db15bc83f7469f5ef2c858c67f9b82b9070046e2e6096d66b57e36566d675191c0ee371c752b2d8032997356f5b1b17b66209 +generate_signature 91dcff5d1d7ec3854de213306e4e744ca4c04176d4b20830d1a2012e6cb026ce 15b09f757df19ae41ef4e9050d0be8e76c151b20a7f4f792748f83aa14b7e0bc a9e865fee7d1469c369dd683d7808d5ec65cd0f035dd5e09c1eb034a7396c305 3674d44d7f649e67b3172deeb645b1f55ecbb38cca3fa0bebe01e774a26bbe07d64678779607e6a789f97b01aa9d8c58a1ccedc5d585bd5936c6a0a34f44be00 +generate_signature 9291ce37db25aa4c373266a7aa25d585206492949c8ca4671eb7e470c6a85778 9d35b6133fee1dca194f7a64e8c1dd4a03a76e3805cfbcf80c9c42f9a45e91a0 6716b59ebdead7684c13ead0a4aef3fea77cda742bed36b3dee1d66a475d0309 3352a3119309b753ad845bea25d891e3b5f3aef5d1797dcc795f07b6326c8b03f9e5be6d20cc886f7c65cf4645a224258b590f645b08070644693a780a6a0a0e +generate_signature d2dfb2e50813260e6bda0a4150ad893b32f99b2dec47ca8402f0ab8ae30603cd 7b8bd1f571d5083a8316fd99efd6a3a3dc54d87d78425ce1f46185a2cdb18a95 5d76e12ac8050665387e1c8af4e18308d9f227b0decf22355fefab31ce1df804 d31a05360afeff90e060eea669d0cff745f1d778c87fdcdad515d3b32cd1c00b7b32723ea45461db6d8414901f2c65ce8ef1d834845913a9de2d8788d170b606 +generate_signature 7ba6dedecefb1d24c087c994a2ce612e568fe90b47eabd04a9f44a9196cc7d06 ee5a5d892f36ba3ec29b259ef936c1a14085caf56e5419ce2c85dc356750231b 648229308a95c52f19b3011f816050496d77dc42afff59adfbfa851ff4da470f b6f60be2927902228d168c4b8d94037764adec3117f2f79b712ab31f0403b6022a4bb0ee90061d3da34be0281e743e0b9505095dd01fabc97230229846085104 +generate_signature e53c575148d6502987c90b32ebc374a2ee76fdb167b4bcc2fd963aa3293a50d3 db099a6c2dab7de4916d3b2e21c2bf1f89f24280c29a4802ee27899089353573 9a34773656675cdf07d64bde08eb98585b9719cb9d52d919d54d70047639b508 461d3f532687ffc861956a8d6241e5655b668e2c8f9e56aff004b26d8d654800975a6382b6d8dfa457f75fc179ef8894baa2978a92683c3b41686188988d5404 +generate_signature aa909b74b14671e3c56b0aa0a39e956897151694e42d90f502f5426606a4bd3d a2481756e3204a51d40c8088e69851185a29c962f97c800a88102b812606ca0a 47d0d3279058134729f860e7e0dec0943115dfe22f052ef7756b5bc263aa030c 24316e8c132996a46fc1c0b3e2caca9e2c77e73e9edfc3ea5855a0d6828f87072efdc277478ead9a7c188cdfc2cec79390f975cf96afc38e82f059f3fdec9608 +generate_signature 09719be164df8ab8ffd5d4b6820d1520992afbf6fa717cec48964f3af489af51 3798b31c7c0f929e70268010839042b76df746c4f46b0e219521eb73e89a0d4c 516de341e7a3e73b96f2a8e3c0427bb73eb04fdc967f6e0d2b87135c0ad72907 71fe0a2b2adaa3e1e5cf44d19ffd1a9a1c1198570d7d650a01443190efe84d0ad6a9fe4a91c4ec8303de7eaaa35827ab513a1899c1a5ede9d4f8cd030225b303 +generate_signature 95bc343c1fbc1ac7fc31c617f0944c8a5caa4b91977bad385ddb7b72133b9918 3b510a05791831d9d86d268a3c56f48b40bb3b2854236f4a1457aa573f1e3616 83ed82fb8ea18afb5ad9664ad412d2a9ad5d36119aa08eae5ae48d3b6e979c06 f75d061edec30fdbe29df7c7b922746bec64358f9a06ec1b0771e4763def7b073f60a399eb149f6c97989060a5fe72d6b99e8518e55acef43edd2e092ccb7f0f +generate_signature aaa59d9c7b9745cc62775f1a565de3e704ea082feeaabf91897c163e9c453057 f1d8a8a9d1ca40c3c1985276b8dbad02f9b05b308633f8d53ddd23fde382046c 38b8d2d9729218db5231f4e46c2641bc43983320d493eba916c9d99aaac88208 8dc9436c1922cb261e5a022d06e4c29c6f75eed7fd33e3f52394cea623bdd402f66fece7c5589962c1c57edf86958397ed7f75fcb36207088ba5e8133c95f007 +generate_signature f4433ab65909fad4afe06cdab382d2fe7b1f2d12a47ddf3c4c634bc9cddbd52f 320c05d188d2ecaecc06c15352dedd207739ebde86133f7152b3b83074764778 d34800b40f3d39319a844b8a85c65bc8e7aee303a7b8e423d2efc1c4c48a6704 f7778febd060ff54eb5018bac99f24330a68c6aa8e0245515d777979c1edf10cf757e148982923c8ec721931aa31b6802685ccdcff9d04989386e5f388ba060a +generate_signature 121cda7dd82e45d586ec16c5ea52fb38026dc84d3acf8b53d9b14c752bbac650 5af2a1a8a88c0e0b53e555a7077a737c2cea050b7dbc0ba3d8ca2ad037c908e7 007af32d54c623c7eeda1e02984238b6799b08db17e3a4231daff62ab3d1640b 5a17bcff814143b151c30fb7faaef0e0dd8280fc05708ff002e2b6d91602ba046f4239de8623e83bbff48ad728f0f81f67386c425979c4c9f72ec1b86888730b +generate_signature 4adacb5f6d707bc06145c6c445ef70db86145b78af456ee5d687530713f153dc 2d96e3dd0c90587368b586dfc7954d5d6ecf04523d0797a0fedfba91f65649b1 1f8093909e4e249adbd396d9296980bf6b65164dc6ea679d955b98502622de03 c8b24021d492912631f3d934bb7ad355cce16d81deb4e49599c8a39e41f72a09898602c9b29e7c20c7fff5b57691cb822bb7a7476f9c791881a3a570bcc51309 +generate_signature 86034412d429483e52eaa4f8e3426f920886f5a7302f9733b60c3368f8feda5d f47f3d62360154548b01b27b8e20bb653569dd2e0d8f3e2e4926563b19d2905e 383927c522c2201332dac111a750e15bfdda86b1d47483a11624290569a4f808 a996312afaf7f1c1f329a676b3c5279725946332d0e9d0d508105a57294419049b89e8fa741732e6310a678478d96548551185843ba71822154e9145b47c7e08 +generate_signature 891ce05ba0c25b7d2409dd83487ffb0328f515d0dd77bf1c2503e33370f8cb99 0103c4ef2f18527e1630510bc27ff5966b018199c0b82a4a0d62815c74f1d0b7 fb1bf90759993320f4e16f3237c2d63dfddf6594f21c74e20267d61a8bf7520c 1096ecdbb36e14d420244ed5b97207865387d4156c98d1a97882608bbc7aa907afc6518205690d1cecea28d8796f5e610f9e06a79ee3d04bbd97eb0d3706f509 +generate_signature 268378aaf9b6403f036e24e356e90d67c3b82edb01180fb7d135e895283237b0 32b9fbd425dc1a9e2d6c693699594bc310737d3954b8dcd5f3bec5a056a4e63d fa028fb4484c90b355655014f1f20eaa711d1d61ed8e200b718b46d475603506 9e6bdda01719f742eb5b58c41d6ed1eb83b88e8081225fdb21ab61c53bfdd10efc9075f7d8596453bc7ea0ea304cac95ca04ddf4509bc9e66d1b28d680b2b208 +generate_signature 4c1124a23917f12efbf34c9c90b1a079667aa900b78b8a77297f55e50c3d6e21 ea3392bb6cb736c3053fe90bc64917412190b673f2d1db93338414fafbd15414 54cff91e78a84670f568167ee279e72cb0a32ecf75544b5e4d49ea5a77a92003 f47c858497a8ffaaac900c58fcba9459733bc13df2d1f105d56611ddd7d56a030f3c3ff48416dd500daa03d95e3bb6a96b7d9b44086fb1db12edd29058490d01 +generate_signature 112cd2bc459cc678065ba583a09c83d962e385cb546523901ec4d5b47425d0e3 0693ef1cfdc58c35a00dee5477fa4d8c73422294c88b8f9d826dbc414dec2306 a3d6655a3bcdb2baf44248a541141a67018c9080001457e165ec29d2c3248600 56441c40867c340d3846c6a0f3d1d33225389d4ed31f3b3bc7c6d3e5f6a83700d604336909499e393749af785fcba11800742cd5fbfb2277cc87d32022a99c09 +generate_signature 2de379049e28fe930809c36f1062769665d4133d4d668a718b84f9183332a2a4 29aa902ba683847b1b59f09ee480e1814454bc72c48fb3884540d369f1a9f2b9 de444332bd0fcd47f6c1a5b7fc7ae1bb544a2298672288f04effaa04aa7d940c 50a2049a64533aad969971a943246b4252700f8b4866c098cbe0b6169449c00c15bf4cdfe7256e9d1a06ed80b9e5cef867f2faadd59876cf96e5211acf8bbf05 +generate_signature 0d2ff1cf8e58881dbe688be73ce844772c6696636469eb8ca9086a3ee2ce07a3 a743a9ed747abc154394fa822224212c3f7cb9fdfcb40a24a142740d1644de9b 08281ab64eca078a437c7f10208d0f5692ae85f6603fcd1d9e8ec2bcf9f64d00 989e4c821a4179a4a57143659ecbfedb147ecd720182b7570fb6b1b47f770f02dc1ef1468bc59a40f6a21c472c1e0a1f94f8b6731b7044845870e705bbacd20c +generate_signature 7104100649edb970e649881d4059faee3e51e221a3ae07fc33d944eb6c192322 c10ad6f4972dc849e2bac69e549929822102071d43f404abe8049a529b9c930b 0e060a4fef0a46f9c3d8702b38f82270e76124aac1f6a8e1ec402aa9e7812b02 fca2c2db423b200286542664e4b7bf55e323800f26c987bf28d6278168e11204564c7e8732009691fb4ab19de5a90e44ba3ca053c8b683a3682eaba29a2f940b +generate_signature 995be2688f3f7354dc17d7fbd48e010611de9d84247e1e738be9faae777d20f9 89d352fce80cc5dba45a618468866cbb9414f5fdf608ed5dde3fb446fd665c20 791941512b24ea359aafcf96ae0d9a7f7c24d34e2177eb1822dcf12776580506 41472fd0cc207313f5bd0212c1de4d971510d1e7e7a2850f47e67dab4992730960e043b67d87cf031c3b09f0608650f14e553272de34ad331919521194ee510b +generate_signature 77262429448c69ae1fc4c99b652c282af2082b046a227b57dcd724f56ba0a696 9b605f01f72e9fa6faffa84481b9e609f7b1e20b8a33b46b16cceb7f5c0cf411 b912862268d63a977c75fbfe9aa7008190758367379862024232c0cd2504000c c3f93f091f6fa336cb9a09c29ab0d96ffc4d326c5d12c9d8026cd3512854fa0bcd13a8c0d97424510ab0249ae4894d44942857be68ca037693ab614570c4b908 +generate_signature 382537401e042257c1a0c6062ea8ed101da3193a6cac540d675354f12f7cab82 1c209e65076e9d4dbfb5762f3d1f59896da89efddec6d696a4498303f67d667f fdc2f3443bb4f28cda3ee7cda5255d36a89a983b91361700b63b87db477d1108 e9d7fbaf32f4bc541b776ccd19052bd26e01155bd86de53b03ac985ca2722c03ed47e10dd152a83ca0b2690230ca48b733c2f3ab66e548c30fbd5961998dcf09 +generate_signature 55b89623ad6f7b1d2ed599d2a04d8236f2d3fb8b337ba9704439193ac7956889 eceb2e5ac867b1603e9c61890aafe7871b3583d38c0a9f4084573497bed466a8 cb1a0a38f92fcf57064b0b1e666693cd1abe9a2b42cd4c7c667c933e3ae1340f 22773ff165a1aa41527743ca240d1a956139654d4798be7e068491e31624350529f5b2ee0766db4eb429e7e14822bd4d485f2f9c762c6d352912d7bef564fa04 +generate_signature 22c3ac4d3466742eef52c67e784050c30b5d5ba7b9235e4fed8190ec18cc50ff 628a568ca8cc07afb1ce46b3f78af000a37dc9bca3fb8f73d7d5e697b267fd3a 0e180e4841d5de78630e900c364dec44daf2f74e72066cc609eb917995a8cb01 a3cbdf00fb6a2180d3409a44086a54dd57c5969c2342bf7cf96c9d759317e10a487bcb17e5dfedad7dd978b19cce4f3f4891e3c8cea103597dcccf3311d6550b +generate_signature 8bcdbe48e967d9e68775be61493e60f6c5488427caa85c0c42b3ca3aff756b75 5de2c451223d0cc7293ca1826c02215c6b519bf3ee0e5b91483990c6250d808e e8b26635c9a1fa4b7f9165b745abbd45cba7258b6420187ee6e4325a89b0e802 9296e3925e31746ac7cbb076c5c51dbae362f60f470de8d70a10d1e8fc01fb016c083693a8d0004073b85b2e1fb9bb20d26691d42a2245354d63a065394b7a06 +generate_signature 37b33cb52f44b8c43a0d619ba8270eeb2ee657c0e70734a05c2de878f77ab540 7f5ce9f0aff75716477a94c13dbcf878a8a2513920dc40fd2a29814555ce1629 f8afe1e242f39bf2b08c35d6d18aca0900a1e5ae729efe56892919484b5e8c03 31f977b07bd089f253b8bccc5062b8bd5e8aee1c0f844e9a1d8dadfa1026ff01b3a9cdabd534f522c10658688a070e286d2a852ca513ad47d9fa7ab9062b9d0b +generate_signature 069bfa548d79462cd27ad3720842430f2c4947532513a36f0e012097b77e6a7b e6ebb1f4eae6ec2d813b9213050ac47c0054723d754685452f112551e9e6619a 6cb63dc9d194448e748210d8bae8bbee8e0cb494bcec2b51ae06c9f1478b740f f6fc3efb52ba1961692bc9abba13b7e0de9a3f1cfa521a56834596b3032f0c0fd84a999ffc423dc42512f170256c8cdf5c7899336cbd58ebb186ca89ef0cba07 +generate_signature 3fbde8fc46fb4f1001ac7fd712760e0d8ada351c2d2c28b6da74bbf9e2795c80 79ae18c7007b1a790ddf2e6080615398ca77b4d06c1b2f7e536cd6b8ddd5a21f 70f8219f8b4d2567a4771051f2988b84f137a4f84cb26f081843908c7d959809 c2f662bdf5f076e5dd6b1eacb974743caf2dcd09cec07a78bb44590533eb8102b348187f2bbf65b5cf058544ce670f679c797b028a3cc367d150df5e71cf980e +generate_signature 7b752d6c0cc3750012b98ff0a4fb325eab31e8bbc0dcd995d9932215386e4582 9519b641893b754f8224bec54da6b5c06730c3f4c7d4704f2999a21b46a30032 0e931c71c9a3789e25f79e722cd6858d0fff3f5198597b056247b9cacbffa20b 378ddc8ca56332d6e831304ae6757727ca8e8c61eec5c5e55833c74f8d89f500bc318c852dfe94947e69236505ad92536001c34f10f86d634a5a9ec02584f005 +generate_signature e64074ccd0cfb5b56a89cb07faa1386061fc4853b0b2211d87a7af02bc3fc0fb 7072faef529d5daf4fb8663574a4ed86a7fa17e5cf10f09190e280500a216738 d6d77164dd8a1f6859e8a814d2a17367b8a8fcb5e6bdf345d74ad6d70658520a 13047ed243beb6543cc82002457c04f54e07b4300815aba2c7e9028e2ec1620911ee285a16267af44fd78a375369d72f598d3e2184b541361e2cc1eb205b170f +check_signature 57fd3427123988a99aae02ce20312b61a88a39692f3462769947467c6e4c3961 a5e61831eb296ad2b18e4b4b00ec0ff160e30b2834f8d1eda4f28d9656a2ec75 cd89c4cbb1697ebc641e77fdcd843ff9b2feaf37cfeee078045ef1bb8f0efe0bb5fd0131fbc314121d9c19e046aea55140165441941906a757e574b8b775c008 true +check_signature 92c1259cddde43602eeac1ab825dc12ffc915c9cfe57abcca04c8405df338359 9fa6c7fd338517c7d45b3693fbc91d4a28cd8cc226c4217f3e2694ae89a6f3dc b027582f0d05bacb3ebe4e5f12a8a9d65e987cc1e99b759dca3fee84289efa5124ad37550b985ed4f2db0ab6f44d2ebbc195a7123fd39441d3a57e0f70ecf608 false +check_signature f8628174b471912e7b51aceecd9373d22824065cee93ff899968819213d338c3 8a7d608934a96ae5f1f141f8aa45a2f0ba5819ad668b22d6a12ad6e366bbc467 d7e827fbc168a81b401be58c919b7bcf2d7934fe10da6082970a1eb9d98ca609c660855ae5617aeed466c5fd832daa405ee83aef69f0c2661bfa7edf91ca6201 true +check_signature ec9deeaca9ce8f248337213e1411276b9c41e8d4369fc60981b0385653c0f170 df7f028022cb1b960f2bd740d13c9e44d25c344e57f8978459ffa3c384cd541c 2c2c8e7c83b662b58e561871f4de4287576946f4e26545ba40e78354c6d0b36f69ea44892f39a46cf3fd5c2813cbc1c525dac199ada6fd5ca8e1e04cff947700 false +check_signature 114e8fffb137c2ce87dd59eff7f4b8e6cc167fdd28c3ea77d345d2c8c00989a1 d257f46216be34be5589e0b12094e643d1b31bc3c50e006d044d1ea885b5007d 9579b6e8dc108633ac8b67004699921aef479b6e7ee9590073fbe1404ee4b3d533dec29fd35540f13ac531c3ae49abb62cbc11d36b0cc3353db77a294d8d3d92 false +check_signature ce03e1fa5476167c3ebce1a400ca1d2d375176b5cb9ed180913efa1a688ddc97 a05a3a6776f85c5d04c42fa2c6a731831c3d3a4e3a12f967f9ba0b1ecd1aee98 4992de4fec265113710ec3a211e86784581f96241f0305d069a1e4629b504d03b3a1561fd9e73597db89ba00beeb60d2107c1f835176949bd354e8a173d46705 true +check_signature 7db838c96a3e1fb14156986aef37b70f932ee79d3cbc8233cdd76997eaa0c0c2 306593abefdbe99beec4752ebb135131a93e8361fc35f60a1c56fc4501c6782f 5bd47b285d25ede033bc5c2049edf3feb06fe29091e2c90ba25128c6c1a050713f28db1b9106013d22d5e0ba05bbaca43c4d30b6f0bbad8768e6cb89b205c20c false +check_signature 2d96536cad13a409d5a46a6bde1f5cf1d9255e741d5a17309248dd910e02d1c3 c2257e5386cdef44b989ce395532b8e03dde166ba26c18759e1c440738242fe4 2f5e7a5c690c0d3bb2974e47eaa159d0bb2205a636b8cd09736add9fe8d75bee4249b30f8e1b99c1dea45999842f5709d2ee1d8e450807319723625074c69605 false +check_signature 87625d63fcb5653575416de00c82ab4d893d6d5b64bb79eec564f61fe6cbe4de 8d4c678d19b93fe24e90e1e78ba439e3ab8c3d6fc8c2eb89bd343b92040de1b3 02f424dc88a9fa42b262707cb874d1e480f74a366bca7ae96bade60cd0c9e5515e993b892609b1d8dd2835177568911df548717b0396f9ecafa6d977dded2303 false +check_signature 83824c2a42fd2d1f9f74106ce128ea3402261eb67a2cbcc74603b8fc52c694ed f5834a5bffe7f8fd69ae6626e2d95902f470b309968c65834cefae251c408425 0e652aa0db24b0346fb2923b9c16d94f7038687a66e491c2dba3aa62a5ce27a3f15127deb15af6f02190486e65f4e48946a2dcaa85c54ba0273ddd84815e630f false +check_signature bce37b33f7ee148282c3ccc12565da4f7c53af9646df616b17d95631ef209d14 13f4ba800ef35daefed6b8e54e865113b1d523a8719a5d22f596fc12203298a1 40cd174bf8b7a7564ed09b8f5c15d1b2134e5b8a36ba907dcffa5d76eb201c842eb63d40eefa4fb71a7e6f7fdadb96229daf56a121e64484e12e2455a12760bb false +check_signature 1d7a83ae9338726c1b6776f5fafdd78a79df32b1f8bd2702727d9c17f8771caa 42f746e23416bb1ca24b486424c3462291d9d6fa7436da6e66e59bae0ab43162 9417c063b682475fdc01a623b1a88043f176b1df0965b28b54de2712193a740e66f56b22815a05bcecbbaccd5494d29f7bbce32456201a8a21f0cca1892187cb false +check_signature b921adf724750c6305c33cf98dc866dab70ac24ac2c6aba47b9cfb621aa0b691 53fd594636a7e10be480b78eb51a8188ea610be58fcf98b16202d2481dee3662 f624b6b8bda7df029d85e5c9a4a2a206fa84354ac703eeedc44a1f5c9d33e306bca16faef19fb8af6f7ff8aba005092ffa1781592ea0c193f5edbe1ed2bcb11c false +check_signature 06f6ea8e3a4cc5e6da4a5c300b8056eab7d9a260bdd8d445146a906a46377003 d4f328c185fa9ef3398acc0e62a47b738f9f799e6649dccc0ade5f6b0b5388bb c26cc73e7891b1d1c4c7e8166c835198317fa6c024e245693ccb8a9a456c9b04edf11f00b64eb317d1617be12d1d49606f25195017666db6242a58e98f839789 false +check_signature 9409e7a481efcc779b8ee25b012ecb057cba3967296ff2e540c4c0f4dda0e82e 2c7814a245fc1a24ea25ce395415bfb715a9c84832d49f2e560d108afac578dd 567acbabea38bfffae0a7c2b745c574197471e12b239aa410fa77f497a372ea941711917c6018502e340860930494c112cd107d0f6bf48dea68c18ed6b8bbce7 false +check_signature ef83026149b0a2f22f2e086c8d4b8b237b25b82acef3f90214fc0b2dd8434516 6ea89899209ea552694676dd68debaedae8188a6bf0ec95ef64ff8ccfbe79a68 a00ac22a9ef1cd65832759ec6d5f868c38ec719ea6831090e8d93799929eaf72fd476f9257eebde6bc449d942cf20ed71d14bdc1852521942f2ddc4690a21bd7 false +check_signature 1b246206e60db2d7d2f54356a2973ff6dfc8921229923f57ecd2096f087952d8 d7b213889dec8fbef903f80df2b7e96881eb8faf8267fe0df3041359230aef90 b81181559d0ec72984bb9fba9e1ef5eb3c3904add1d57197d19a04f0b3d5d5578f4ad39becb2d1d12dfbb0a9294df4e0ff5eadcc29a7a9d6d52920c7cd5ac70c false +check_signature 6d18e81cf4dcd5dfea5b12c2287ef3317089aa5a5eeb813d4156ea08958db8a3 6e3649ed3894b5423adecdab1d1782be4640a92ed310aa2199c5861cb3405e96 e99b6acc2c6169e1635adcfa55777c2c8b3023af17fb4fbcb2ed44435ac6da10afa8743f402cea715f4b59323ca6a3d74df2dfd955194f8c1574e4234ac66700 false +check_signature 9a42386a99a81416028a9fa66cc49d8aa66af6982bf709e8d5c46d60f5eb57f7 55290789bf61a9d623dc8453275660fa69f753a8dd25836dfa1a55a836c08659 f67d12a33595183573e2708e02df73e301d988cb75bad371d59ea92a4304ea8ea879a5bdfec3a68b9ce0d53bfd72808567ab897ff8758b18401ed3cd688459aa false +check_signature b49f3b74d8da9917c016e5ac06f8437b671463b8a81b2671243df2b2b8052fb2 aa248b65faf63026d2bd3e159c7273a69af4d1e2ed917d4cedd0f24eb0d61991 ef92065a1f1e51568ae40238a4be93f811fc06885193c60d85b76dd3fe68b6d63eead361ad0090e2e270d5d2f199c6b95d19f9942c21cfc20fdf313e43f39b03 false +check_signature fafbfe9233c1be9051ca8e2ac1b331b8341842d91de0f802817a5c30c234f391 416f5246a8a8a3402e137a8befc05d6f02db534e67461397023fbe0e29b77aa2 542e9b73109b1febc0c9cfa6384e43cdc0f0c170c746849ffccc626232355860c717f1c4d11ee6fe90a75b0294fae2dfe025462ba44704f193ef54092e9d5808 false +check_signature 61154b91c6610d2d001a1e6f6f2652faecfdfffec237dfa844ac799b393de4f5 14c3d2ad74ba443296102139cf94b421a72ff62f2b8727e303e53d6a22ac7faa 9e4bfd899e87b3b88b7d39f4546605ae892675315b0ed83176edf9947924ab069750696702856e7ecc1561cefa65d149540223b15578b378926f6196d8572f0d false +check_signature 40e0758cd9c9f8f8f7d0fbf351084863973a3622c92dab501ffdee610278f86a f79812b95048683d47eb5435bdd97c5a39532c6693dc8b965af76d7f3ab88e92 a9ba1cb8bf2898e21c12bfd23788994fe20d45ef6f775c197ab157d7c2721100f2123c19395f13ff79941e4fc9ac33b2f70077a79c552b4ebc97a4321ae66e09 true +check_signature 3b49a4ba1b62db697c7826a66b3a24f5c00054ba8c212ddf6094654059ce973e aaa6eebac75c052fdf2abbe18e4718c3b388ff919bf4a514ab61bcac661b4409 5d156005ee2588edcf470dc653a0635dbf3afc393eb2d89a75054a93b271ee02e46d532ac2d65d7f661113093a68d2ce6516a5abf08231104d0fdcbe6649e80f true +check_signature 088144dfd67a5cd013db2318eadf14a2ec30f7b11f75e687c3e76aac5b0ea584 21e031f6f3d406f53e14e57741c9861ca785cc9bc6fe041aa8c2f0282e8db52f 44c354bb8980cb86ff17758d9a834cd1f1c6b82b9de7a2d074f0ab8dd3507d221bbd53afe01180305555444a085d0b73b4353a26fa980d594ae33fa4600c120f false +check_signature b1930f6d59fe22b002a0a822e0ca2f3168f792e02f8be89e5d565de7a2eca4d4 43e773d2046d30e002cc231c85057f834d508bae0ac5eae3ec581da291736efe e5c0205493e59f6a644ecd4ff30b2892b266a26f17ba9a00f604fc62f1c40d0313ce08d0c303a8696bc638ee0bf6835562cfdff9086bd221c236f7441357470b false +check_signature 916ceda80ef84b8538e06c5fec7f04810a960d878f31c390705c6bba01814a93 86fef19663f5fca7d6c425944140a2941c2f2c131cbe881868bebd1e733bc432 68fb16d0429f61bbd63ff328b4defbc7ff03b5d3d3b83618da159fe02a808f0a22c86ea632e4b7b32a662e70bb7bbd8fb381fe10950c340d82ae5c0931b07a06 true +check_signature 9f2ca44de5b87bb7d90cf57dedf6c5e6a232372b28e9542be6cd6943e69984ca 9078fa24f1b212816e0c9f483db8004d2a6f6d267b441292218392c5d033b01a 6bd88d6d4b2a2e16e823241fea53e2d50625506b89b1067b9aa038f8d55f480ff018813c937ad2a7a09162b7538e179785b9c40ed6f4367b30cf7d76d076960e false +check_signature c16ea334df0501f4fa8e6d31fc733cd9728128759d77a94ce662f343fd2b4b45 30c16767c8353a7e7dd0a3ca1449a0cd3756135970333f0c96e7e6b151e00f54 548167935d72bbd001a9d8ffb805d3ef661453e4d39fece6b131acbfa3c1bb0df10c0232da00ddbeb9181b55d174f3d38c423d17227e9b6265f23e33389a05b2 false +check_signature 7a94605c0d43ec0f35eac8963231dc1c08b972045007d3d6c3905e142b3e2829 5fd4c73fd1f146f41e16276ea18919b7babecb5928a06acee7e24c006cc2417f 1d6c46b9de850979c7a7bfb5304072c3c778027801a5dccf19d78bbd5741ff02b743f1d88f7bc3e9b32a054f6e5c3334d456a69b5a943bb9e52f046748e1d0b5 false +check_signature 9343ac2dd894b368e76537fb7fa61672b6f2d00d7393cd4ab725218f59dbebeb b1e869915645764bd9a15ad6674cf11be4371903cb6a63c412c1379384938045 c0d2b432ab43a41c03d923227f7e5fa6367cad41bb34c3408d42bfe2a6018407c3bb22aff17b69dc4cbb95fc0743bd774ca7a889f72b911418c38e8a9d9bef0e true +check_signature 70cbcab50667a8840352d1a38e9871a517d142da5174e84423e55e0dbc7ab634 076daae7755177728b0e21499d3520b86777e53113547091ccda04528a4e8cc9 9943b01dd217dcf746ceb09647807001de56542936169240d12700451e309e0ff1193f04ce3848b92bbca3d306f9ca9c84a0bd4dd7342aa68bb94712a87c2b0a true +check_signature c620fdeda0c01518fbf903bfdab96296b6d68a6e54f77349de9dd0a89b8f2dab f45f889e87b9cdd172424336880a16fc99e8a72e5a68b19d503416d276aedeac 973aa8034a1995ffa58819a4856dc851f4625bfe1b583c1e06fb6295f1d36001ee5d974a06316274e3af8db48b79ad03adc6f822ffb695436fa7ac274c2c268d false +check_signature 883f1ae53940841369bc477089d27c369b2771200c36afc80a1e862be23218c5 1e5ddaa318b8f3bb6e1d3211f3fdf3844deb3433e7a58ca81c4c494dfde87745 42be7f838c60b965abfc3ba5b5fa849d5a73fbc9d907d440431265a07ac00d74c89b3d4dc3a5d1330f87a894df74a0bb084200ebe8fb78a5443938d7e3b0b70b false +check_signature 086b76c066b5d34b4062a2058591a193680f8269a68b2f75611d9420002c0659 e331c38217bec0115ad936c96efb5228d0e26c8e2104b4695f6e566f81e5fec7 e073048df4f0eecff9a5c9219c1eb64557ca16bc0e45038d08b94e7fbc185a1263842d2665209ec99fd948799d45e1ad569637a88a0bc0eed31829393ee73713 false +check_signature 32738c9f04e480f9a8f3d1a37c1733558cfa23c833247030b74f1a9126d6cbfa 933b2ea675a4fc4cea830daad6b25053f2e766fb12bf4d16a22146405b0cf7c8 3d47f7d43de5cda1b762ba108687885cc4c19510bc924aa6180a3d33d570e2edc430d9afda75fd07bd1a3325698a36b3cac3bf85b61ac5c3667b5c9e5ee8a708 false +check_signature afda9dd111f115f0358a17fbdadd526398ae14d845e3670db7537bd06e1b4f04 7c67e16e80f007bc9723135cc3d0283920943a1faee59f84c19e10f82c799426 3df1783d5419fd49279a99128959a7490cada9403aab910a51d5e9deb4ede202f04881770a6deb7e01ef223d9358ff0b4cd519f0b7ed2549643945c95af06cec false +check_signature d247d2c85ed257022ec9b0c152d4c2c40e80f2637667ee93245b417fc3f65332 ea47eb53b525f087b830ba9a6f053f223f97cd914d711d1d8987592997db5dd9 ea792a023be8c1884ef85aa47212cd92cd2aec696b910e039095a845a7941f0b1f19c23ec412fb6b003578beb4a18560619bdfed401762fa4473a6fa61658503 true +check_signature f4d765776aeae815d6f079033c69b1b7e65376471b8e530825295f6f1cbd4a32 110e566bbad531298eb9da49615a5ec08acaa5779f7ee71c39f04cc2ecedc7b7 65b3c6794184a3d826d3ac155a9d87d648a5de48b7a31246007dc226b04d210e03c02d590af27d03975a796119ec87e9b9a9cb7128df16eff175816fed2ce030 false +check_signature 08f24fe3b0dab6cddf18ea6c763c5c667d57733f32081b7cce88933c6dbd90ac d2fcd90cb246e55a86ef47a0bcc49ff902c0e45a2909cdb33065b4ba21e33014 2b76f7b81cc72fb56bf780002d48fb4a1a7005fe5b5ac26d2fd82a444b59fe05b2d25d914550e6b9dbd0e4a5b57f54ffc22405907318f6f5f2f84a0f00b0ab0b false +check_signature 6826599e0ad3e2c795cbea6dd30114f909b7c6b417a609439f4e1c4805ca8720 4e8f90cf5671b17d97b479c5ee29cd6f2f0fadbb22f8316b0d0064401bb7857e c6e6d48948fc3c87847ce50b3a7686dcd73b76b12e854d38ea08bb87e2c7750d2372837517b621559e0a687398f67e0943f53a1c35e3b085e27bbdb178369102 false +check_signature 40b6eae8a27a184186427fbfeed196c6db18a096343d1c9bcc11484b8f461e6d c55021f810e1de1627dc5cdd7163a464cba3d585af7b9d47da7a1fecc151a605 40803be66914719aa8a39845d6d07d8df5c8fc437882ed9d5ac377e6d1ad97043163b642df0e0436e3ff547ef00f98235d60a93b667a3068c2b3af3b98428e03 false +check_signature 56a9b87d7262a77a1da9d9c5ed82062aecc2811998058ae13f071e25cc228be4 858ce9107c427e7071b1dcf85cf2229f6ab0b91232d9e261628bf912c4c7f7d2 1243c0509ab2992c4aed96e6d566fad176bb2214c072510c2ee3e4e019f811b5b66384fba19f599d62b5a5e7c72ea49f4a179d693c4193f677e13ea901592d8f false +check_signature 281a31e5a31c962cbe6d6d5a910f1235c52af09e6448fc80a835187aa57e2671 cbcf7456ec1c2595711dc0d0bcfdd94959485c232e6d6ec7925d648a0275ac7e 9856c1e6beda57d148745ed56ca15e0791666a440b0558756b0c7a92dd0d7c032613c49ecc4ad9c0046d75558140b79c5a1829085612ff352edabd44624ffd00 true +check_signature 74bead005976d8eec2d56256dc4b3165b238864aaaf1ca72fab57ae423d2a503 8a083a5dca2868f66d4bfceeb9f68c69bbaafd511239a145a7e2be22e0a6b586 7bbf3f55491463e3171d07ee48b25ccf41ba5d52da5edeb5bc523746ead49d51705c734842f56050c61af47d8f7f7cc2eb1e4df0304968b819c7aaa1efad1ed7 false +check_signature 3e2ff76a26b0a579ff026bb251579e3d584710ab0203186ae4ff1062387633a9 36346e83b0a875eee90d74950db9a86300afbb60424167a43bdb68550f0fe42d ce0f314c9b5d62d1fd8b695ef7e721037c10b7256de02fc140fbcb0509a1596edcdd83bd4cb1fa8361508f3da83e14e3c82bb5e149b831de3314c4e4eedc1c0d false +check_signature 1ffd81dec35e40928ebde4b2142a823350d603247be751e64802ebcc2041c7d5 57134229a89e7bf2d080bda2fb5ed6615a40c78bd7d3aac0ae3a9f1b58446518 b5661d6b8b417d1340fb57fc264258745dcf3b21e592d16716cc85502dc1c360c591c4e6a48eeb51eb11727b4f7fecb4facd113d4da844b4fea3de7602dbd60f false +check_signature cf4ee342c3da26abff8c76ff01b4e429ae83c6bf32afdab122e651f8ec3c7989 b7d6c18f7eaf34345597608af769bc49aad7e67ded62584a17b8ddda9029468d 1b40a6415c9f069fa8ad8ce0a2dd790a2e4fe4986be657e6ca3b3f1451dd1c0dc1a671042979c0100e751af063287310ffbe725e69f208b10716efa0c285790e true +check_signature 4afea1bc4b6e1d40ab5f391d2faceec9c62578d4947389dfb38fb4c8d32f7709 0d5c80f00872a774812269660551b34b9a902ad8ec0c1a4a5cdcf439d8f19e9d 4c4addd045170d9b2c56e8b91af8b83dc1d9438829d66247292e2d27cfbb9103c3dc72755ed0c55bc332eb5c6204dfc1b6b7908405108113fa5bd7ef1cbfe90f false +check_signature c23af8d9cd0e8629b726eb64c6b204c7b7346630f43eb73f2197eccf7d9ef999 8ddfabb7d342d66afb185df46728ad6fa10a90b06560e4200aa73322be129900 1549701f964c5a52dda3231ea573141188608ed3f8b6ac0a8191dd3ea278e20e63db6dedeccc7a9f1fb3c23265ff9b0982a0458dde7306ac30fb7ed09ef3ba06 false +check_signature 5e95efd029ec296baca1eab533f39aefccb2ea052bfc93bbcaf3e14218f984f9 a6144c6a5ea2687764724f774f4f92e9ddf77e39c90f9276e8b72524cd516fca a7307bb846e2d499a7cdb9e87626ddbfd9f23299a4a3de5eb5e018e5ce8d0e950943b5c46b3a0e222a2789183d213b95e6d5eec0781f791d305e8b8d52ef2e8c false +check_signature c1ab449ffbc78e51e40e44cc63622552c7b0f11e4a3b77c06e10769e012751c9 1c9f0a92744c32396d2eb0f63a5654910083a1adc1bc923c0d9a5242966702a2 b8653e2e1ecd8ccf08c6c900160516e8e477dd8829a837bdd235899f9d64ee0fc717394747b96df54015e8e6fc3b59cab28c5df93d892a8ec6e2b4cec5754605 true +check_signature 2cc3692f9efffaa6788f2b528d92ef42e975a6f38cc98a074d59aaa18a9198d4 e645637bb3b54b018a91c37c54b376237a2b082266d63013d9cd16bca7cbc6eb 38b6243e5b7a82cea8d8000931cc29a5822c567324aeb10942d0336ca1a4ba7637a1077434c7ede24c382f3e8329d49a985fc402efca3ffaf92ced9defb90c00 false +check_signature 43dd81e71e8c60dccd75f0ffeab0283d77d1ab410a638620511863ff62323922 b27e57d32cb84f7e0964e7d8ce96eda465260678e646d58ca533e6c06dd8865a db9e6c7883507239a712389f0658bf5bbbc4445e6c8b2628d2fd4d2fc70fa9af1f1f100c2e21a4807282d54bcfab802cf95c7b6b7c63449f27715938df637d0f false +check_signature 2f867226a4fe1f33e7d5214b5f218b261d1de56177e5a31c367a64cf517abbf8 50f3d002d7ce36b58133ec2a37bdc10fb76ad56c70a6d61341962145bb2c4cc9 83ba8733a67dc0e84aafe1b7238995e3aa4a2cbabe01f40c77721fed32895d0886a04ea2f56ad012d287639b64b68d76ccf68928c75790b60106cc6850e7b4be false +check_signature e8c43cc4c5986754b8aeb9794efafad928133f2da2beaf1741a9418553f0d537 fdce6b784bca0ead88124c7980ce4582df5cf070d7b03e69d2feb55a3a1c5aaa cbe7bf4c1c37fff696ae2bb9fb7bc03cc35df02507ec67bbba81fe5fd662460ac9af3f78762dbdb70e9388c8b85fa12b85d70c21670ffc0c10c67bd353971307 false +check_signature 11d57ebd8e2dc2f14c11132df95c4507853fd92ad79273def8e53002e0908499 d3296891ee567b8c1a088c1771b2666d34301bb2234a0b3b3ed5cc7f64a6fe35 e2405f1028ca98ff520ac48d65dee1d3ad13b89694414a4dbeedb71510df2106e8bf26b791cf2256239f0701a209eb26a55754202790252f87beb87fd8b8fde7 false +check_signature 58c2e8e070001ce13608156804d4c168c9dcb6f38e29e16e44d39944483856cf 93382fa0283401709b50a2ac2521fa060886772b0f5ae94221c4cdc32f553aec 803b39d6d157f692d691d5d9aa824600c349266eef9fac584065230d9490d4024260073ea408a305be55eeed5cd5012b3d1371607d61c512f52677dfb50dfa07 false +check_signature 10e0dbd68b496dca34bb19016b7e0b09d594ca9892ddd38f8e1758c4cea809cb 7ce2c12cb01981e969f1f327d4a20cb9c9856b093d803474c188724ac5dadc78 188462c2b3d9c4f9e81be0eb0cc81d7498d0d35c003dffde88f91b087365bf068a8654dda6ecb1ca18977dd1704c7eb0a86b1e98424f368bc17b5d31dff3890b true +check_signature 775cd0daa8318155efe697bb847aef3b3a80aa5e9786326f471fd57d0047106d b0434ee73f06b41cd38dc4c014be4c3c2d5fda9f81b52a58b6ff05db9dd3da08 87999be925f2eab3bfa6669c18f8a8df3d904d85df5b863f8207acae0c4bc207805b876cbfe7d1fc26a8ad62d86fb1ec228b88919e224c494746c5725a1a7201 true +check_signature 0dc42c91ac6352b00b933c541174cb1886a9de7ff68b227c52955c61856ae7c3 aafa9833db9de79d5d86d2cadd345e43fd4ba54ecbea7847110db0e3b40ce807 6c017af0d049afcb8888e74c624a17e6b3b487fde4783479b3c8c9445a70b00aa7da4b2e4899b04d7f8a55572631ff535836f11780e3ba1b296975a0edd34f07 false +check_signature 83d5250dcdca4ffb2912654004f3c58ec8eadde7e418ca500ac379dd81233338 5f97075339d3f98e488ded3eae74cbaf6518a17c310d0d2f2542cc44831a727c 09b2d497bbd1c56bf2ae47548b99ca29e0d546c26a6ff3a75ec3a5b304899f26ba10c245c8e5e58dcc56c4b8e3f1acb55eb1963fb7643bfc5898c5f163a3d002 false +check_signature b8e692984d3d5407cde2ca717651150c45cb150f0cd96cd7abd9911eb09f4e34 ebc25d1d03b62bb0030a234fecdb11b2636e82bc587732d3ecb63010f6e9676d 11f2335b9db1357c250fcbec7ac60b719f0e0243852ad8d395c3c5a777783709a5ce535b54d7395bbba4c998204693e47d67675e601f4288b8cc2d58c7d82706 true +check_signature 4693124d4b8cf9918d8d59cda481625e7270c3862702379206ddd09b09f5c8b8 857fc99c43e85dbca69a6c6d1fe38fc7bcc26611e7541a4a8b343c17b0a64c3a 470aff28ff7ee773fde10b136838d746974f0909ceeb31025c6d9a50d7a8430fdce44afadbe596682291e2c4ecc46b67727f1848a8bf8ae839c0991f56b9131d false +check_signature 98b4e15b0bbcbeaa3c72f4b64c70f609093a70269bf51acda6048d068e7ae29f d094f07c2f34299737978d6aa4b237588b50bb711c071232efac65fee1be0461 efdded2fc25f12b6254114030b840ac0271b8fc516dc5d58b421ee7e0df7b1056b36fc255ca7941a90a156829f5666457dd3412c369bf08a1c5c13917a1efb05 true +check_signature eeb95ad412d1d251ca9dc88455d4212d3fbb8cd05cfb0662596fce1541d8ede7 58b217f19d482caa2adf6063953083a27788e011d692275683e1ee447781357d 8db860206e838d77031fcce79738e997aa3d8dc9f9650ca19d39961de639f447d80fc3d7a29a1767890be1ce218700f0c6b0f08515b6db6e0da17aede484310c false +check_signature 58c76eea169fa0120d1c3986070084cbfd352ed4056d723fff061bcfaa3c9e42 9caf478bc7b5d47706c0eeda67ff713fac8fa77b651b0635c1c36330e7e883e6 ca5a6be6d3f52acf8ce6be78eb60f337f7b35d16949b2dd66ed67a32f02b95717e36f034b76c93e9485714215ff1196209c2870a901377da9538e7a60eba6900 false +check_signature 294c96ff5234da8129f124e32354f33aff3c8509ee14ca57ab9a76e67542ba4f f57a59019f6c4fe32e9315db10cb62f55b1cbca743863b4f37e12ba8c81ba139 626843a1118cfc830b16c9c864d6efbde55210b29a11194877fcdf66b8439f08ccfb65df5da5e1ecf4fd3b6137f13ae7e27764c1ac08f07a3666357519083c01 false +check_signature 663f580b14170b54c410cdf171daa0eab7956af24fc475f9a22541492116ce4d b25c0cc0be565d3a359ecdcb0ceecd27f7a0aa820132754f8bf18ed49c830a15 da2d3ec4fd921d27695ff43d68e6fdec1009553f372cea5f76af0b68716a2309e15f5d58087e8c11fc8cd3f4fdac9f509b502519dc778785050985768147000e false +check_signature 5276f367e077c50435ba5c3caf320464245a9c5b8e7fac645d4c73c386a56b85 e675290a402fd21e68d03e4298bada5673f062e3876147f42360d174929b292b 76dbd4648038daefa122d7a223c11ee94f526870cfce1ecce27797e6b69de807aca55903bc848f21f5e3f25ff86f6fd6b92aa25832b7e92e1b841f9130c52f85 false +check_signature f561d4d2cd927dc56c1176488ed4015df4f7900faeb9751c5f4aa06492874aae 5f1d19e16aee76f3f335f371f9b03aed7e9a7a1fba24c1a698e507d4fac6da5c cfc5c35072758b0dd017021d66f610fcda69bf3a8211c9baabdc5c9d7c4d160d055ee4d953ddee9e2ee20ebf722920aece4d2365664ee19b5a214166ef9e050f true +check_signature 112010cd2d26efc84e1703ea0d0b20151048838fd1f48523f5fc62f634c49453 d22372e1cf8ebd4d3e41449d1bf08f278e651df4fec30e69ab4e1eccc2d66bdf 72791ee1b9624d0684cd3cf6fc061c7fccbbb81b5681e21ef05319b16acb9007c0092e0f1b372a724c12fd8b1dc3fa9b7ef11c5feb29aedde85da2036305e40f false +check_signature e597851a19740e20e7411b03ebe7e603ca26e464d9e1be24ae94327246a44867 24970881935ef1d4ba35b98802a4ed2e0b68e7d41df751d13c95a60fe61ee70c 93fa2bb7a0abc374c6e4d72b225cdf1a2bd53e338465f6b39b17c23dc9c14704f721a30ee1946df2c8b5b905ee0f09d2fd7c054e50aa6dba3e28e4a7be2507e2 false +check_signature ee96ec311b1db35cd73e65179951a4af2b688309812db1621126f099494e35cf aec23a395c827c345b19bfb38e5fce179cfd8569564e19970f1c834a199299eb b490f66d83d5ed11a9f55a2386b015a6825485a94f36a7390490e342fbab8406399f49143ae48f908b4c6d859aca035d00ecd889be7f1eb737f46c0873921203 true +check_signature 83077be87ac523ed2da94c2ffcfc1ca5027f2d1f43859802d40df2f96ee95fe2 8e6d4ee77b075cd599d8ceaeb055469cddd26f15652a91ae2a61794e8353eb96 1da09787bcad5415a1ffce2d215b35db86d50053f66fe23c05cdf6336f12030c9650a3e170ee8dd233aa1d7128a871033daaac9b74c8c566d27434520ae64f00 true +check_signature 1b7f6552df011a198cd47cbcb508b1375ca9f5dc95c6fff462071ed095351035 68d056552ec6d05622545275b032cf37e0944998eca2613e2c189f834774a5dc 50ce34393cfb325b4c5ea8c34948b7f757df9e4034e04e2e06259348d528ee5145a3a074d3016a15f47d830141d0d34106f16573afb7646bb419f0cd1cecd509 false +check_signature 9c39b23fe721113aa3837ae1b545a82600698e8ccc68498ed4afb29d25f859e9 694c58fdb1934aecb985a23cea2e6a5cc2ba84c0b2a685bbf2e924095b1658c9 53c34bd0adee4383756a1133ee62f8700fe4f88b075585a0fec1e053aabfc0014e814f0b42271883eaf33c0a3171d76e8ff45ba8157d45c7ec7137dbc1c2450c true +check_signature 5289c8ba8c4ab9629282c8ee0152fa90e83d562a57444a312e7a1a5c6ed3b8a2 be8aa61f54163dcd0d7a941506a65573a92061eb793d62394a6c6d091d66fc55 6310c55e19f83c498d39377dd23e6583d8fbc8d16d84d70f1261d8dd577a0a0fdf225bfd8437ce8b67c3b907314762d0f07c766ae5233fc06bdbfd0705428133 false +check_signature aac6bb27f647224afa05dc1cfaa8e604ab93999ef927fdb0201d8c80851d4b44 c584b5535f7144ab5774a8650dbc6cd38325cfdb1a00286973a79846dd3b92e7 ece1d5775cf0d31ee07e5b9a57fd3ab0c2bbe7faeb0f6110f3f50d67f3c71c8118c8e0e4da79c2eb231a7e18710c70d9c1c0b147054c60c70c7f28fbe6a59d07 false +check_signature 79c6c499813307cc56dffa76ea55d9edf2aca6c8d1bc1db08b816756962a1bf5 8cb322916efe196c940a9c365a0465c5b1ba3de989f6a950ef7f02d6c03b3900 a1a989c1d68fcdce744e0b18c0c87396f5c3f2292edf8d1097bd926a93cd1506a588bb73856e1b7890b5fe95e01b86b8c0335f49e8888a170162a3a891b19303 true +check_signature 7a7622a439ab4745e4c30ae2efbde8545138e43cd749d784b6163ac01d0c479a 62d1fc422a1025dd024321d5291594ac5377642da284b0aae86063f36bb36d80 c3ede96ef8202295a19e2aa53f90a315080350790006df9be6255ac2049446f7a1e057392a2f8edcf7f6258507888a39026a052ed9ab220d573b211c403a0900 false +check_signature c91b287e7c77d0fd2823769aa432f9e416476df2a3691b061567ba2d65258ffc 06d381d1d128143b278df358b30d4fc173f426558bd65eba65fe887a7d125581 5aaed95719080e387bc5d41abcb8d9ab6514f50b646e4f95f97e854534ba240ec3623fbfe287c0feec53915f77a513595165a2a885b3cc087b693553d6ad295c false +check_signature 91815e269a16a6c412e8a604ee1dba93f00b13416eef384621a1934c7b8a2973 a80776a89afd4ff9c6f6c93231b1f283d7184a3f736d69b5849184f11dfa4c6e 3672113ab56b852ec9d184cbadb5b5ef0a5ea0b64409361fbcb4557530b2d50b2e1a946474095f10ab078fef28c9e60b94c81a892ce8e8d1ad3a329f5eaec700 true +check_signature d69bd93ad43d38593998fd89dc7032d5d49b1cc181203f90d033bb7c23413e20 a3d675846b63e50375413973b874ec289adc9243efd97d7f3b1b7710cf7ba4ec 0f6a621ec81182672471a2d5a0551e4b599853306fbea1225f4e6c15d57e92e88acc68135cd17d136ac52482504011368f2e47eecd690a151c394011a4ad2b05 false +check_signature 68ee7b58658cd8a128167f98d27321a512efae8cb98f4a84d59bef61112bd1a1 35e783d8f464c8ae1aedfc3477c45a4cebf8a29804a01dcc263fb3427813a413 e28a9c91a169d38197302c1fcc1306e2ae15a228d4f13ab3922c5c27f8b141121020c077a792ba15704343f84748906c03c3f8f329096986a23dac5452ba9f23 false +check_signature 8cff2675af738ef5ed35dd58dd88bae1ed59213e9015191b6ca75b894413684a 76d57a0bbe75bdd37ed5d8436121aba5e653241901e42ad1831fe5a1290f1c35 7d55045a98626eaa8b9c9a4e38e8b3da0e03cb546296362511b6e172d3e458080faf98918dfb86342d96c20d3d51892a0f9839db064c4c38bfc46a481a5ce5d9 false +check_signature 33ea920d499ab8c2ec0cc23d59bd655fb68692600de1ca21a9cc3707f84bfa83 da3b411d2a358eb416ff3e5130dbb4a528d41e8c25afc34630120dd13512d5a5 89cd78f4991de3c805cf3ea8624b818fa559c643fb80af1199cf001974994c00b5d45e09c6aa25aeee7c559f375b1a101c5fed724a020a3926e1c3f925b89f02 true +check_signature f9e80ec779af0221c6a7c306993c558bf24e20eb7adb51043f872ec46986039d a3f1b017a4bb3a048b73d7927009deee71b889c2d1df39adbf01ffb5c4757b01 ee7d05d8ff30c3b0e6870b3902e6f9fb54b0c8cf7d405e5743a15958e1aae90e1c34768be63184021ede0f3b70e3073ce5e2ae1c4a02c743a0690a40e468927d false +check_signature 1471ad938be9b0048d65b03228515df19dc52486273e14bd72f47e57a4a4a2bf bf47d31ab587702ae4cf7a581ca5a009c5b930881eac1458acbd807972ab0e13 20b400422dcd802a0925e8b0fedb0aedcccdaa9e692ad7c71388098b2e2e10b3600975333d1f5efbe1de00470ae0b1a5c94187f9c99a54b1cb36eedb33d23d89 false +check_signature 8853e0d1fb7ce1cf269483b890f81b864fb70edffb8a7d923a34e59810a7cd7a fc99cf0b70a5fabb0ceb0f4bbd2ca458c12c64931c9c75a78398ca16753c3d30 438ac939d615284d5fa73da7b8055ac381fc6bb10ebe2a72d02557a0f6f0db0249b660678839e2854a8a4a7945093555106f53958faf41609ed6e96e65c8348f false +check_signature 89c15dda393624f879903e457d51e67845d1078678c2e9c27ee72a3f95923f16 da42a95c8e2e0833a531e9a98fa1502407eb4002cb6aeb1ffbcb57627d3ff263 8a4a7cb92eb20fc22060e7183d2ca536af5e628cbf44a99f6fdaca438e42f007226bab5d40037b4c77081d8d40a9150cc97491ec7ddd5c61c803d15569be0b02 true +check_signature e9f6baa7573f5571d026ce41bd31f1d19de7916031ddc80f3fc69443bf323808 4527c1f245df325ffeb629036af474d328903c8a8b2cb3c5ae32f25d310f74c9 fec4e7810c39d711a10c3ba205429c5dd0b29e69bbdc414b61c0b66773c8590d19e01f0b8898575fcd55a136b847f32c3664a485c517ce07b1510f19a8ee1f0e false +check_signature 4681c0ef3610694a7c22120918b88e2090d3325c570a41adf68cb7f53835c6a6 8865406cedf341c8738fe4e43d99bd51a1828468d3900baf08016f5a54a62be9 734e2a51b26c5116bddd62bceaec85828fe2609514d4fc1b3b80d2fe24a3a409b9d7a3d69210227eed51a7b52e4395987e06311a3e5d2d0502e006f4339fa604 false +check_signature b68b7c4090be0fb3a135c2b861fde3ddb6a95bbb023ca5a09731638553f10da3 a39519e99c22eeb12a394bf31d21e0666351f75eb5c0a6ce327a66f974412173 e524bd25f3f1897d6fccd5cf398151c7525b9265cd5882efae8aa585c10eba008e21812c2fa9c8781626b0bcf06520b2837dd1c659f3fe14225fcf26e2513005 true +check_signature f73cbe759f22b6ef78f1928c09778c85d1d8d122a56764155d320640fe3f9496 04d1ed9b76bdb9127631761e977c322515595123527f368e42430f84d1fed660 42339acc914a5289cd4b8d06784d4df8845590e29de0a50af15216448e1e350aefc25e89ad4e38bee92c8a11b3be31798fd870382a46f5f2ae73ca1708d4950e true +check_signature b6844a8f8f7ffd61ebffcebc22ac74cac0101572fd41f20443fde142a52253e4 14d36e1c54eb6fcb72f6c991e3869491289d14136e706d19c4b4d285345a7333 c4062ed36264842043b2eb474e78850bff463ac37e064b720a769db6edb59d05cb151605268003abe0ff8836a4fac1021749186fc07cfc859ae36d39597a84b7 false +check_signature f9eb03bd39feb77c7d71cd838f1abe46838d0ff33a2713f051726db8e7b7921d 2203438db1ef94e97be21d6f98bf36fefe2e6d7b890220dd93935de6b37e0821 775f10d3d318839f6d85d5940ccd19a4b1c6673b6263c8477e7c488c8e9a6d0cc658a3322223b3de79293af90e9cad416b84fda35ba0d0fe80498e22b753a4af false +check_signature 8e62031457f2cfb2ec9340634a8d7e89d6169499b4253f974df2fafe06110842 ce0a6a5f6efedbf2a1d55d0fac6a3b7e6c085e35dc563bdf14697f7814c6ee4e a66cefef4bd9afad98d4aa9d660fb441a8724813d1fdee18188b988fd28b6b0397df91f13878231d69ae47d489515a275d40f32b5e8f68ce7c113be866ec2bc4 false +check_signature b5d396d7e13718beaa21f6421765b4705628105b0dfcee6509329b0ef6500d32 8c863cfac6ca0f65f3d55a0b212536c2825a5fd8f0389079d160d1745245f340 62eb711b9be737e02e61427f56c9dcc03b833274ed8de283593260249e390997c08da5ed7389bdff372237afc0e762e43a62d0a8c56a75a33ea55e67b3e74309 false +check_signature aa67d9296eca5e2ee7252f5c63a0dbe253c149027d7740ab7a733bb6f75ba903 572a4265fe89d80ffa65c884ac394e05ce4bc00e52412a4e70d9f6dd1202b38e 064c67a5d85238c7b8c3b587cf8e8b6e4131f928927aa8b5e0af534bd2edd0bb0f6734098e91bad3bbfaaa6239e53b396e37da5fa31c89c10bb0d0837a596b0a false +check_signature c694bf63f3d6704dd46804618a38646b92e62754b6f1854ae5d2f33dc7234d0f 2cc93a9e8958e39c3b0fd9929ee25bbf2234dd9208918644153a97c85f2b444a 5c62537e1db42a8266c642e124ac81876f1c9bad93db3754927ba44d869f4b06d86a73727fc2bae8aae3536807b495a8a1626a2a8e76965734d2e218749b9200 false +check_signature 39838d46879f1b38d8e818a85b43a3d13bfdf0c46b4d1fdb57c173f3e7ed9e96 52049c468fd115e86487deb205f45ae9c575c1c7d00e983c4c88b0e79c64019c 930bce099993010259c022c83c13a9d937b195400a72c87815476566bb1e43049ec3e55c6c97221950e4a88c0d2f68e969c0b4c005ec74458132e2c37626bd18 false +check_signature 3e7e7ba58c80795fb87eef7d6396c95d4e160a20ff15785ade288b2b0dcb3c35 78ff6121c71e779af5f29ee2217fe3749582777574606f1a94deb8e9111dcf1a 20e6fa4d3ab61188e213220a397e7235b3a7f8f31176a4229d27f93f3d923bf31ffd0df871d4d26a7c26b2f1f2f7e894818ec032e25b4cc2c9c4303d4144160c false +check_signature ecd6e5f611ccb506b036c22c170db42bb6908da13742b0b30cdd2d4d49a5ab67 1965a1c7f90b9ead3db44ff5bfc7c6217a138e55ea4e39eced32e1db299e8b81 25c2ab224239e3b264fa295803e7475202a1cc886bb012e67f64e335c144510d39906aaeb9bad97d13db47fc7895d94283db892342ae57cbbc77b469ac1df336 false +check_signature a45217a4521ac67382da57ca5dd8986647e6df1e053957525c82796aa90d6626 657bce22fc58099ab9bd7ffcae4b1f541762d71d91cb4f13e844bc24ac98e9a7 a590eeb65cea9510fbcb470baaf99e3449c221120607f615a24f063295d3be048c1216a6f08dcfb6d7ccb2255f9deb2593f064dd2ea2caef8bcd925d3aa8f7a2 false +check_signature c141f54775f806b5957b103a43a36de99c535adc687fb0acaad44cecc53cfc89 ee095d3f1096666e66a8e4a5b7b27ef5f60d6b963d6899f8694432d07d2ed193 5254acb327dcb3cf50eaad4619157acb26e28da13e653ca52a084fe5e513c8afcc599130cd8c9d9d274fcf29069866d41323394088b2703e6b84e92c38d952de false +check_signature 4a5b9c68c971b371583cdee9c579ea3a0ad50033b05053f8bbd26d249c8181da b9e4d9f479df12b2b2f04ef2e3496561909d4f16e24a43f1622d103b0e429283 421413e755e888e15704f2b0b56b2d16fec2d60e8459a3a88c3567eaba55eb0e26773a4e97a379013e899205c207c40469614efaa6f6b76bfcf6b50ac8937792 false +check_signature 2c07d4024b0db36d82be67a1da0629c7329c1bb80ba6e305b6f40d3bdb023a73 037a5e7eb75523ad4f27908a9e6c89739f16ff9b7fde02e8ac76da454f83ce7c ec586b279240aca17f80dc32289a7e829f4056bc78555e9d5ad2c430845642e327f67c3c2a74b0c18afb5d3796735dcf41810bfe9b1b875706d8309036a27a78 false +check_signature ed83078fe330839132feea5eb771a0935e3cef9189fdd115dbf4e5242ab55f99 d398707e1d304fc13b89a8ced334852dbe3271e5ffcb8ee68984d866af053e20 a6d60915069ae635e3944fbbe5e9b8067eb514a7b1479f7f8726b6ca597c7c082bd02a3b716e3af6495838c3a3dfa7a99ae3b6d65f077d3e751f3a98c96b4be4 false +check_signature fbcb2bfd6843d73dc5fd0f61bdc629296f13434efe1a2e8143b251a8a6e99631 57bb10b73b283074cc8d9b7e048ce576a84381cf762f2f7bd808b16431c2dc9a 9ce59a18c8262e0e30db0cb0663c4b31bcb9569aa556d17b7168126d96649102ca591e17542b85660825c716aae116b084a609e7efee5f615417a09330e9d142 false +check_signature 2bd972333015b6f4302a8f88bfddcf269c70484edba2007f0e9aa895701229fd 525785835e001a33f08da0c35e6a402223feb575d4e6192be0325d10eb4d0c0b e871d67360cd49382580064311734e4cbeaae6ad6de545e84f0f136c04743f002cbb5c46cfb0b0990a50160d8538b87df729c66bcfea30af5a667cc2c8458b71 false +check_signature dc9dbb2b2e4ee2bc16da69399fbdaf02817c087a5e78bfc969cc86085ba77d00 27d93829ccf678a18a03e5e7974f8e6b266181e943ad30fbbc28e89246dbc705 7f931e9ecc49b950f3580ddef57a3036e9f13ab426f091d2e36a3ac1a0973501f5824206ba88c401fc92abda460e7c18c6dc1a1849fd63865321cd7794ed650e false +check_signature bf42110e3c49a6a4bef339b6b764c6d8d56107ad6d227ce357fc31d12498816a 3c5292c30e221823b0961c9939385071851a205c2a67f03f4ad856645bdcc504 97ea98bfb64c1cedcc5fe00fc088049f43a1daec5e9ebaf96e9c2f335179de04121262814f138133097ef5ae461d4b0b78cd168a7807e03c1befcc7031c5b805 true +check_signature 2963486419e8dd4041689a563d60456eba48e707e071d10e1b461be735ac15a1 1186bd7259e6940b8bc4608b7a58abdf0f205275d7eacd8b4819b2a6ef22ffdd 56d0b1d8cbc0ee64dfd59a37163154eba2a13c4b2a1bd63a02e37ad1ced19c062185130265bc1a215d42efee3e065dfecb7a764de518f152cb693d1173f7b888 false +check_signature 00b33a4f8f5486362712da0b914b2165d04c652de575c040a615360c6b8d02b5 270ac06119dfb4415016e53ca8b83b98254c832d2928ff3a71206959136cc709 0547b3f4011fd9695b4cf3557d9ea0b69f488c84ee0baa080a5a9a4dcfa989004451577f7f23b22b7281eaac7789d1cd174609fb092c3386274454e6f94e5a04 false +check_signature 5ca112f1e71036e5ef0e2e0d2704365914c4198862a5b28a4c0aee2963ca35e1 b1098a6043edff1c248fa4a5ad78c79a267dae854baf2b74fafa6f4fea831f89 a6ee1bfaf75e3ff0f901150ce78e3838929a91116858a1dd236be6d126c7b15b753c55c4d6f4da1e0ac3bf11a770b494356155b0446a35ed6171dc7320c5880a false +check_signature 62a84185d3f5f015bcd36a56097902048ddc74811bf33466d6638068e5805dca 8ded0de0e2f763d60b3581bb6960971f0819d45200dd970eb005f60f59c48ac0 f11e4ee4e540b27f0b2a589d443f93b9e36c699ea61163ffcff048d3a3c0530d0b3a2c65aed5cbe5b06be077033a559b746f7a87dcb6ed71018a9bf73abe989b false +check_signature d83a7ac6702dac9c2937f32102738a28d92e9fcd705b8b1ccf7e8e0a2d8786ed 8ae05fa6dfcc7819d12dfc690675d27b84b661138d2a85c502ca88be2990d381 a1d80995e33a95465870d4cc3069c8386f737f19f09606b64789d61cb83e3a0d6ea68a020f3d5c40f340b612e45cfa94dfc6e45f41b574cd712305c8e7dbd40f false +check_signature 3c0dd6f388d92f7d3f7b1c162e3aeef45cb56c57ce4056e425702ea0a5317567 96f209da0c24f59adb4d5670bbb967fc93821674a1336ef9078edf7eda643ddf d5ba6351c675907129e3e17f4363d7ddf486578fa08f45b3b0bfa724b4afcb096a194dba7a0f4e60956691f870a87b9d8e8719aa50ccf4172dc296e9db925401 true +check_signature b9b96a0f85d5d22748d65bf69c33c6db5c29d6be7acd1e664e9d5dff338e7e96 276805510f4a90ff77e0dbc0e75c6fecbf3b68bc34b406aa171152f234bf8279 4fa18baf88fe6f79aee576af1393ea3ed559d3c7824bf15b4057fa41a071b209672daf2af2b20237967ea57ba59f72dd33c3558b526ac9bdfe5b0b9e021d1392 false +check_signature 9fd40d6e9b68b57192bcf4e1439d50705171614feb79f7ea629d7640ddaf4a89 60df412680e83d4f96243314699f4dffa6f4ea6da18506dbb5d8b4ca0957870c c8f3e8124de59335144b2a6b96e9c6c9a18006894a99cb50eea3e5a407e5023cdaa0e20c315221e051c7c8351c423ab83cf8f4bf78f20e32a52a8c18f5d09604 false +check_signature c6eb4b2625113bf8756f4038abd758aac244cf6d95e55a0fa73faefcd372bbf9 f4e7b2745e72ca8324f1a4a234c33252ead9d6c2e94f008b3b9baf85afa6cb0f a7f348cea08b366bf3e840987589d7ec10a672f9345ce137e80674af3d570f04d513f3440195c3641a83db0a54a01345552abfb52d2241ad8cf94fbbb255c107 true +check_signature fe79b0358042df0517efd6ab205a76040aece8175d3c83b8529fb9d118c18d42 dd01c920cff48826825a42f57571b5dc32b8dfa1efdfbdac575ab282f9fdcfab 6e6b4290134ed882531f8f7f42d54fe724574df5d0b9b1a0e00f69f84131e40901ff9ad2f7bc7087b02fd189c2e6ffe008c832909384148ebd461d9c9797c20e false +check_signature b47b84ce92513774e976fbda647c42dbca87fae9daad6ac0cb97d9262f16aaa9 cff341c78ae9d220b9da4b0d6b254c16be4ab137a09535f30f1bda2520d3f405 185aaa6be7c1edaeb4668c4115aa5fb222aec3fcc8bcd422bc27c72e226b3e0b6e5f388c07f672ef5356d2845546d5f5e4540bcab3776c78b0d736313a8a006c false +check_signature 7af6085843ed724d872e71f468c0eefb0bf80a13c0bbfca9cfd2ac9a09aedb78 e13c987b86f36cb6d81d7f40f01c251ba2e91ac95f9bad99563510b18785f248 59b9e73da44e1def33713d555c886ab093817913b5ecf3188b0e684504a4650f4d378abd8a29ed19b1d9c79cf6ea8329ef000764c97a5c023e2dcd3c8ca7b306 true +check_signature 46e702b3e2a1b0227ee5f94a2a803a047b0f33c764d601c0cef625a849b0e0da 2d0adb3b12acc804d3751af10da125b4f60c6bbcbfdabbabb0a1a2c3424f00e4 0d2b5ff890a89ecd6e7b26838a72adbdfc98820684f1a3b85e3a45964f16d303c42f8357b3bbea8567494ed74a96b4fcaf12787eb5c3b75781166902cb8a695c false +check_signature 579b07ec03b7bf919fcde7165bb3d2d6533cca311ede7182d0244889c381de2e 9ab9013bca2f4b58aae445fed95dca9cdbe0be178444cc1648884ae7ab611938 aec8b842880aa7a8bd980cf1315e8fc3464aa3af66fc17c1fee31f6403f5d406ff3c44c08b48170b73de8d18a1370a5f9691cda265c07df2c16ab7b166dc4501 true +check_signature 81827e41b96a670a8c517307893fec64ec23a4126c6631761faeda38109b038e adb3a9b2612a340466283f8f1ab99aa6c59be8beb9ec466801403220cf76fe1f 002b14ba33ecd0d4370ac7b38e3cbffa46b3982b52f272257a30159c332e170ac219f4dd8483bf8480677b873e672c03af79338b1352536e462cb395a4dc4a0d false +check_signature 92542ec480fd737b84c673448399c9dacd02a8458d2b1f41a01a744ea93ac1c9 4bdd395610edecccd1d572a2f8c33670260e4bbc3581b866142143308a282c79 30b0720164074b10ffe05fc24221bf3e50c5ae1be2032f2792e2a4dc692960ef3f60756cdc81585e711093e5ec60721a363f5e206ab51fecfb9ea754b3098382 false +check_signature 41eadfbad65bf007bf1988697e4e9680ed1a9b2e0886b409f6f75bc52fc14533 69a89e1e5b285fc2371b0f28e5dcb73a4e820f30815fa2665afdba90665716d8 adb064f99c9037084180796fd65a6f53671b342ca94a968970e6e96bf7f9ad48ed487e2b7db4f2dc92e25ef9188889ba6c8cb4ac574c1821116251f426bcac0d false +check_signature d0fab8a303a5cc053efaf9c72d2da6e89905f2a9110641f8f133b64a7bc31cdf 3fc058f2a5f1b41d7eaf97e7aa31ea7a59e72608cbc5283bf24b78d61a6e43b7 236a93c6a46334cdef7728f1cf1ec18dbe7787e10d457afb27d17a9dd611030809441abf1f8295e5ad9649cbbb65d6252a7e805d8a0d489768040f00f468a50f true +check_signature 6999dbac641e837c702d0cc0932d8208319baedca7c1c7df3cac69ae9d34871b f047bd0600dbe2e72f0bcc1394dc4cc8a3736493878928043318acd4ece1c963 32e136cb4e1aaa6728972a5b4300c7d2eb5f7699c781d8ebfe2f01fb0cacf30165ec7d29fc898b7048257dd5ae6604a3464222f04dc4a2a563088a37bfe86b03 false +check_signature a78623e59321b7c3d79cd251773188e3c8979fae39e53060a4259eb8ce4d92c9 f6bb5ff7ed06d96c34f792f80fde79d31da9c946253209dcc1f54ea9ea8c9096 389068f00d433f216a68b83dc62dc70200b46153121ba360dd0a2e4533106c0fe51e015ee43146ff40db7ab45d7bb4e842e8828d9aed9240c206c50e8af11205 true +check_signature f16bdc6fc2b40a367bba4e1658d276b8dfdb5abdd515f15f21e204e17fed3e82 c9a76fd884d2673a13b1ee080759ea59376a5168447370a90f7a19409f25d994 29c57be8898ed3f20c8565a7879525d97f024abb78ed6dd78a54be970d5c830a5e7b496d527d133fb48e67e8d2e16a12f7302b0d7a663222e2e5546975eb8c94 false +check_signature ad9738312df13165a6f225d20e5cf2bb84f1b27339eecb414e60c20f3180492a 6e02a2c218c752ce33e96f806f00768df077c89b1ae939818ad2533b90a3a14c 9a4177c069270cb6dc5b9c0648efeb2cc1b0703642310ddfcf17769a2df0440d74a1b97d1df2401c5a19479003da7d02694ea422479924005562414661bdff00 false +check_signature 78bb8e2d868e9c873064132bf40a237cc863d686c0549ba0031014a92baac117 a47251eb39610103f5e594c2ed7cd52ed680325670c1c86c6c0da6f808cfc88c f1a87fa0b3a9c9bd1640d6555ee1c15bf32048352e1429057f7eb38361024d0d8f5dcc175f367961a287c9685609404c5a016602acdf8db76042a7f8211bb902 true +check_signature 9914cac3887a748abe4ec36c2df93001afe143a9af45644920a40ab3551832dd 0ed9e7f0db8ce8b36bb47726f1bbbd84edcfd2eaf954bca770cde3ed93ac3aa4 f8c36b3a9b37b3cf74a602595cc533e1e6250b66d136098942d7b3d2afeeab0fb86d0549736ffbb7ae0d85111b8cd56748d167790f51430dcf2dee5fbb814d04 false +check_signature 7fef9df7e1740c9632f94cebd7100a8434be39738cd62ffad45d8d8ee4d6ee85 a32ec09383511e0af09d7efab8205c39237a8f6d9b04112b819a2e478d04629e 213047fe9a320dfa1a27ab1782a5e4f04f641319d7e1489a50d167bd016d21c78845258de1d94f1cfd0f5306b92c005751c53616e3791d8e6e5941b463fb1800 false +check_signature e6cf2b7ac1b3aa9973870669a9058f7412e5e198fc1df6faeb873d035c35cb06 884c446be8cb8d77c0ef70746b430c3cda3affc570b0edd2fd4dbe3cdb7fbb29 387da8c2c9ea47a0ee0a912cc7c0810fbdc1ddd21344f772c724355098471d67b24ca0e12435214a906141c97a07f81da687c0586c9eb551579c3488fac88123 false +check_signature 4289ad0c2b2e8d913476ea0ebc04e6daf784fa6e7d6a2bf5d49ed4ab29719115 7ae7de4f85ba90d52c7eb8e9f4e123e0425a4fc4777dfd2840c9f623c76edae9 e3aa4abb74d754d4a5e41d12cb48a0b6242d45634f1773e46d224f8ed5bf9f0ccfad67f9faa00425f3cc2a2d39bd56a37a7f093a42991729458776944dd8e304 false +check_signature 51ba03884a418674898fd590bc4db6e0f626e48fda522610b4c6bedf68c4107b fc5aaced954553bee646e754798c418a4e78282194082851dea71a00f4ce9690 aae68f442609e79ebc6e949f21d324c204b507fbb43648b3cfa8dd016123bd0f92e36b06e3c0c3e08c5b43c0474b4e88eb7e8d9377daa2a118ffb15342bed40a true +check_signature de086255d48fc091cc16fabf6bc2c947db8a4c6d96c025c6f50f0f9a5309a8b0 13c6d495b1a6e5259c5e23a34a8d5260e2fb5d0663d23fa21a63bd3fa7ee3eba 1435b65c1262d0e465d2086fb200b468fc99de557ab6b751e6165417befda20449804d9dbc4ee823f8044bfec9f3666c5847d3f34b5bb69d19477e5576b8a00b false +check_signature dd4785940682581386fcc09a03d94cd09bc5ce031244c364e73bc0502052c356 b09b92c1ce10a2c044c3beb5ea471bbb01394298ca2364e70978acece6fac5ee 34fbd83cb47f8794a0eca6ed986ccc026e4fb85f487d9281cfe10f4b9713888a1fe15b0198e5862648df35d3aec0ef12d958dc333ded4c80f10187a3645cc009 false +check_signature 1824f53a7d32bf8b1470c8024b042525f067de60833974c7e5e159a7555af00d 7c528887e98668763d283833de11d49d7dd39e1dbea10649161fdb7c82ad87cd 442e08a8aa7db2862decc23da399b6f02f92590b1235ab8c741f706a392fcd0acfdab62c865e6a7b1f511ccc93c8cfce05650031cc99b5ebeda427c4e84e8f0e true +check_signature 56040e2b6d0d8e00bfac2931a60f6de87c651c88c930b4b4805a4e7352abae6b 2969c1f26daf14774ad8a2846df0805fbc22a005c0bc535df9d98cfb5096c97e 0105d4c962bbef88bb8a65e199808e0e1bba2942d2724d9b9afaca68df973801008a1d921fa5118d108d900f5a013ed224b0031130fc5c4dd813b6ed1593deac false +check_signature 36cace8013115df307c956838964560caf4b081a8ae6f578f9edc5ddbd731c0a b2669528949f346612c37f2eb9e31dd6afef65ec3fc1d528668cee4f1bf54107 fc0e61bf27040f12a7a1354cb0f0972cdfbea298ddf19635d99415edbee1e90379df1b6482b8f3ba9397b00ec074c783e1a6f8dfcad1be2c9fc7172a56170506 true +check_signature 4a34a2ed10f87606e03025fe74187523eed7ab9f1e91e725590653501946e298 c77462674fa807bb22883e554c4f5771907d4f5d42d74aac8fb9ee336a1db136 5097d337780c540f315fe8d6086116519ea85ba8fb4b99e4a9e42a4cae22780dfecf16a51449e6227742a226b78094a45af2066910b47b19f783da7f1ed7c500 false +check_signature e9d12566ca2a43237d74765a653ec04012c69582635706f4676d6f1e59fee9e4 38f85e5ae12e87826b1203a41d547c5ae3225c768bfa368ed9555f20c8c68d40 d04f3f9029d87559cc683986a628a46681cdb44f37d95c3589ae883e0a49d50f21bf8bd2be96895dad33129f91ff1d5425cfea7eeb5edca218089d2e27c5c6b8 false +check_signature e675b337b5fbe05ec83fe04ce8db7d01c01a470ed5351db1dfa843aa05ec5717 4ef0cdd62734a9207fa1c5a7585dd2576c7be28c88b1037e7e44858dbb50632a 396e0224d505b309ea77028cdf8914b0080893f8c1a79473552d69a261e00e02dfd53008a2b6423256f47fbff420f48f0bb55023d57774d75110f1d869b2e970 false +check_signature da7326debb77296e413d530042565af1a932cd736185d1285299a98510d593b0 a048577c42c5d0f22b88747645f2fa84c8ed63be30daaafb450bdcccfb487463 9f07118413b84d09fe5b18381f2954be564bac4ccfa8a55a76fcba7203ee2509571f8295f7159b2349b15e9270319f8a3583fcf01c2e2d93257897e42fc3be05 false +check_signature c73e637c79bf76cfad8e5fd2882bf6d1e94b442b71c3e7ecc5964419d8105aa8 395081f51fb3d34a35c2c9d9fbc7a033e9abdec3000e8d083f0747b6514edbe9 29ef3323a8fc514623e6b7acebf7954ba43afe058bc8eb8f29342a0156e6bd03b5daf875ef3c528f283be00dc752fceeacd03b282b04d23b7e2dfd8e8183fe48 false +check_signature 63d5217306dcc827b0562c9f03ba33c95f8722e411ae0ee8ef3bdb4d61383d77 a9d3cf6e96f66886508a1222c74e6ac5972e50e151e6ef9c8da86e888d756094 7087682ab21b6a350ecbb50394d336aee71457bee7aba1e7d69319fba5fbdd021c20802ca5085739598b1970f59cca55e73680878241e675de1bf2ab9149a41c false +check_signature 8002778d4c3d43dbbebd1783026fb606dea0554ef4ed541d40c29fa876eb932d c16c9d540430c8d3b2a2ff1c01650657908dcd20bb5b5b508c6a415d08c38376 9985378ab87976de89f3bdfe0e075f15ede02919ac412a1b5c6f46a62a809f02bcd55f26d26c4f0e882c14856d440b79ae78f2d2182762d26a4b4cb5c0696803 true +check_signature b6c88a0a27ee19dc3b845b78d4a1819d5adf6bccb8e2168ff500e4f7b786ebbd f920370ec3837942716e8811cf9346f0ae5bf354eb2c7bc8cd90c5a43707a8eb 2125f7d000f02f1328ac414a29c9ec9911bb6b4a1851a38929e4bc6b1459109f4e4f24b48d8c1776909bf7d0598786fe6e1b50fc46028a2949515be8f1e1780c false +check_signature 8dde417c2aca4b8b573dcd82ac2c14bca1125bfd87f9dd2d182f261edde81035 76b2e55036404fb5f62af0e4fed54bdf8c0247596ce0ab8451f8e67dab634b82 020aacb373ebbf56e2be81568c6979f8aa3653067578f636466c8411f7da9d01051fa84f3d8e5eace15d2d876f53c1a5d4b5345c35e66a0e8df63d2df3e74504 true +check_signature 400a113de0c780d48ea589053a0cbd723bef14301189edb3537ebc44a29253c3 b32f48235aa3a4ac68ccaceff40be811cdf899c22d414b54bb92cf9a9449d42c 8ef6326e14ce5e00b21a92072d5bb4af81ec39ed718288978b2e6e36300ec50fdb96db2fcfdabf14e90b53ddfc0221fcec5c803f09d507930771d342d45a1333 false +check_signature c8004459d6f717f2f2b8cd9a2ca143fe2a853d920a175c8c876c5174e594364e 4b0c02414e688e0e516012fe02f296c228b76e4ce213b778f6672554db582686 a6b37a0ee56bdbbc9998ede740c4b4a112b63487328818f795a1c1bd373885077d7ebfcf774762e1c4abd85555956e5221b26f8335d5070ee259aa73205314b0 false +check_signature 961b3544a613953d9d00e6f4c1a325733db5a73ba530a406f286272da1bb4c2a 99fe405e4013e555afb11c67b2cf86e6368d59041a1a5d98d5a0d5d0425d6957 071e7faf64c856eac9afef439896eedd63259d5e165f479cd087e7e74226a09c4abb981a2936483031bc5a919c5a6bbc199ad4a35c57f25dd38200d1633b4d57 false +check_signature 066609a9872c4aa76856c5701c8ca810ad57c0d842fce39f5490222eb8f960be 69fae9a1247ac7d3357f09484ba58aeb09dfe6009d2c4bbe963b6da7fbcc75ef 8ec040a6f8816e5a3b99768de710a10c34fe149367a765cb3d781ad803d83800e55e89233f71cecbdf06f40abb75bead1f4b8f8cb904993627f9890a2582700d true +check_signature c366fe2758bcc40bd72b0b96cb365c19957f4c76a15ae65b7a2658c75cbbdee4 85f659a78131979131e76ee62597ddee2e77aa19e3cdb0970d11b47c4478345c ef0774f8da5f3f2aee579a598ceab814e66cee7f81e30ee64557b657688a8a01bc6ce72c69afe82932a63a557cc5a19f346fff1c7c2eba50494929e643b7da2a false +check_signature ef3d20fec4f5690fb824c816bcf1400d5aa75e06195eb314d6e09ce85fd03341 ce3ba26b2588c745a92df46db32e3bfdd8da09ce1bf123c92129ea5aa8f825fa 1662bb9e233d286aa038efbe4d332a12b60b33a75780b9888e4217e82ad75218b014d405b0e1705ce479bb57aeda9610d03593daad1f21192631836087d9a40f false +check_signature baa2d86da340bc7a3dd7a71418cf32cd6057f5ae5129cb62255a78ecccaeca33 8fa4fd810b88570b8e15331a9029688b1a2235b01e5d9bee91e08b73b9abfc35 08d9d3552badbbed89aaea26e008bf1d9d53c84020ac1394bc6f81aee510d906a776e674763d79f89cb5d4d8c29d381dce1ddea2a82dc95f4b7d7452a1386a0b false +check_signature 6b2229cb3f1745cd613c6a5b39829770df0dc6bd5cdd64f4f3cdeaf04093a6a5 c958fbe8dc3b12cefe2953de6a7fe9658509cf06d4a7c59c120f63d70b438319 81f5fa25aa5867df88ba6d67b04767484a0807f272444a83db4488271e7de907795c4ea473c3a71bb495bf4104bc6a33a4a7a13d59c144de42e9d4e9a10d440b false +check_signature 73962970b6254757d2a698100777e940156128455d15c6ac9b5e86ad1e25f5d9 9ef844797cfab48b058fa056d85c7d6070759dccbab72790ecda95ed590adfba c93e809a159f05bb4ae9cd2dfe6a2a504b1683e29f24b8395b2f28b3d4ba588c1882384a9b2eeacde86129692f90cdbc33f113d40e77b224db13ab42aab17575 false +check_signature dd312e4ea445eca2d5a4c45ecee65041e4e22af71ea8839ae1abf5f8e826873c 0759cdf6b2093c29f05edbe748fc484c86b337dc35eb4c2f05c3b6d5fc02c20e 95e9280deb11c3eba7bd9d12e58a46ca82453a6e2bd825a2d051be651e18d4cf101c7787290b58914ea4453404c81a3cf9e39c122d751aa0d4b42beadb6d7e14 false +check_signature f6dfaafe3101e353c6ae2a07e3c5453679ac47f4c7d9c425b24ad3560e8556c8 c95e08462d1bf35bedee7622c042330f6d114d1c31e139fb4d13456e3d573915 8c5e7c07ba79aa1aa1123c6d4a9bd5b2bfafc3fcea5011bee01df7b04c16340e30540928e78c09e7a06aa8740f952c60269e22106582e30d37284fa95f0ab907 false +check_signature dfdc085cdc54d39990e25f35c336d717cc35d52087424ae09edffed02ccbf963 fd0962c58aa6a20c6af5b92bbc9062767ba43bbc1cab1d2de12961f49ac10171 aab5718f35c9267f51b8c616868acbcfb45ba0d502c5aa6889564befb149db020079428d42f75a652d4f68b1b1ff0fb9ccce9e3e89be942713ed886cb1eb7c04 true +check_signature f214e9b5b3dc31a242b2dd438c71123cd3cd67b0802abd3765bcbc31695cbffe bb6449612241d9a7b85f502056fd2f0613ad1fe1d863b721e4d1f2c9adb4304c 9c84d657823c50a9e04241a570d364efcd15771b3202a0730724bc99bd598b02c15cc408e05d4a14f3ff9f66e03ff68ab7d72c40897a32c3183b1b7bc8911402 true +check_signature dc14c0bc3e0c4d38a7462e09897e78c4a04b119cc165f3cab323b1e44a38be42 3960cee7c101f5833532252a24372f9c20b8e764ffec4c7cc75a7cf02110403e 781e8349ab367e7b5af882fa37d0c95ab2c1ee5c066b9bfa1fefeedbd63787c38952d7ad715514fe6a5ab76db5e24311ca8b75d93fa806b9e86f5c8481fc600c false +check_signature 455eafb5a909a45404d1c9dddae48795592d0937fdf53cf48cbda7621fabeaa5 3f9bf3e4e1545225153010ae6caae1f165776fc8e46cac9ce37d5c39656cac6a 8814e1c17dd7d74fc6a0742b0b4fce898d69852acf5f30ef52ff228bf89fec0cc4aa142ae6725c6371db04c7c3a54342dc18bd2455f2c0cfd570c280efdabe7b false +check_signature 11b6a1a3349f9211a428abe20d0cc9b159ebc0aef215ab977bc80e5b8b26ce03 0237ce6382e83da4a2e81451c53b3dd9de32c0f9bc624d29ba16f41e8cf47638 ad43985ae2e6a6649757e779bc4a740a2bdbb5f79463ee6114a6b0e6fb066b04039cb50d1e10849ec77e698caac8545c7d36d9ab8690f075ed302ba2e5b66532 false +check_signature f86909eeeb4cc145aacf68048c804510139fd8dfca8a7d1a0600b049965b2130 f05788b62e8f13ee0b634c5529f424f56a1b40efb0075919267f542de2ccec25 d9a80b9fd8a6c8d7b935d15f259d72d30d69257e0a49beeff5fdc228043331094e6e93c23b19e96b6eae49f2aa275a23a895585fd3b79793407cb253b59c7d0e true +check_signature 62ce58411cefb9a510f605afa36280cd02e47a6cb855a1573198319858cefd48 39c8f4ca71f17b65c0ac7f6a78dd79335b64a1d7564b6cf49c12813e3cd60773 24e0e68f14327e46363d1a9f1ed3d7b858a2dcb0542fc3931b7d52bdd0439f09d5bcaa03a30fdf0b43911e1cdc5b6bc5892c991af4252a3c7c63588959b90649 false +check_signature ad2a540c905e9e81aabb92e7aab4f8066bde0fc8389f586f37caeece6fb34162 917f46fd55f285f4769a220d6b92f8cb1023c2bdfa5a1d4b4f6e1c2d8c99fb75 f3d4ee42c6f48781a478d65be3cc236073120a373fc53c7462dd029938fff70fd19beaa775c2883a218e3c6c4c3d81fad6d20b4422b7b805de9ae10fdb862c09 true +check_signature 5aa5d16f66c341b27be95ac01a64d7eff70cf1fe22ab3ca86fbfd4b9cdec8032 63abcdd26494e0ebd86c965f6aed0101032cdea2373a4586719ec3afb60f725f 2d1bfce52196fe280a55d1f5b69ca137abdd34545c8abf9bc3709eb68341a206b33c83bb4ef419ec1ff04e7d3357c053ef7d2ced5b81744c724d7ea66ffe97f5 false +check_signature 3d18b5d958507781426a19acf14d1b718d795ac2b3cd9bc782fa8b85b6c533c1 429c646dc090656d803f0bd25e036d829b89f90bf0ab2b6e7b4c239cf604c152 fdbcc0c7900ea7419884d1690f0ab44c5f106d4ef6756e751b250cd20b4fe30706fe1368230c74668e66db1866e18136d3f9b401ca3dbf114dc0ae786c9aed0d true +check_signature 142257a143335f83b3eaefc4da31fcba0daa9b0ef8065c15ff8457ed95c03e7d d7d8ad230bffa21c28d42e5d666395242060b5e8cc48204ff89b6ad32f0f14a8 67e6b042c0bcb8c5612b3b283167dd2ce58a65411b758b5e79eeeb45702d3dc62255f448305e7356117f3adf3382ee429b37f19f40992a46cee12a614a5d16ce false +check_signature 72e94202f8886c664b79ae8c4c9fb943c5ebf289711c094846d177dd621c3e89 04a5e418f99760b40a19bf76aee25f480abc94975ddedb4d470fa2025b3d4111 75c156eda240e03cc14af66ba107e078d6b16b235a2636be768f0baad82279bbe7ce57d8d29357e311ec39fa29a323ce551cc17d18db75959a8709da1c0c170f false +check_signature a3242a6310ff98096083719d0f087ca8ffcaab0b6db412c52186d0b04ea11688 de774d3c0a02d802d8fd4778769ebda508b096e9e8a59ba5dd19d68a706e66df 73fc786ae0a545da76343d0efedce350edc353634503f26e5dcc006ce4ba8b00144e1468f873f7d26691e682fb40bdda2a68704916cafb7c2fc33e7f1df511f0 false +check_signature 287a5d4d9179b877f2dbc0c9386f22392e1c3b04623e39083db7f9a1152df7b5 249ee0ecbe1cdcf3d1cd337c531bf7b1795b036453733bef11492743b382dd00 09adac33a8f571fee6ac056b5d70498ffeff42077837de5a4927c277dd5db05efdbdc624ba093b9fe3be3777d10bf480c2c6952bafbd95b455117d7fa7fec384 false +check_signature 275b430e53d9901ffcff2871fd4b74595075021e236f5e93a3cf45470090b101 cb1bcde08998440c794874157bc43414a3ed2c24419fdbcc80d43f960c571fd0 2ff8a1bc1ec89687554027a8996535cda9b9dff53d200534564d1161ecb14e51ef6f61a2c570dde307b37aae21e87f7991af9d45052fdb6c906ce111d3b88b0e false +check_signature 27b0dc208dd1e8bd48b085a69c5d9c243b0a2945cfe46cc9d8ba8bc427a51db8 035223ecbb37a217c81ffdeb58fc9a2a989da9d0492524dea30c3393040f1012 73df9cf590dc4fefd698bb7b4bea95e544c5bae51fbf3ffa148a0bee3cbc2f0a7d7e4d733dc59afad63cbc402077801049f4fa90d7dfc16820b880bd12f5db08 true +check_signature c6897cd4532c52c2f1a96ec26a6dcd7ec7a2c2854c30c518eac725ba1903ab1c d96220ba9f60387ee39ecffaf6d58c6a2c694da5538430c329200fb1f7f6ff02 d70314c618c04d0c2c14cc9f2464cd49a624cca663fd73e4f6782141b67fca05e32afe860af10f239660603bf6ca7442005ea08894a26ba7dfc5efb9121e2702 false +check_signature 75a7a78d093fc3fbec0a5276e1dce164eb625a77e7c891db5faf6a1d8b80eaf0 e0faeb46a65e256c7359a6cd460056cfc243683db3d11cc960586bf2dd1c3076 acde6873a4283409eedfaa818afcde1956901f1858539e946452a948284be40bc5c0c970bb410dc7293ca41fcdb2190a534d08bec6b1c293ba6cf9e2db38e501 false +check_signature ab35d4f6c3871993292497bbf3a79af1f826cbf4b63068b3a194510ed829335e c51a2a8b1a3ba60c84d4e00383d93f1fc9025fe2f2668edfaa69f30c7c0125ad 80082f9b5bc91434e89ba78c1fcaf81acbeb16e749675f5493e154da0fc2ab079b5ef2713c88c8687b318a9fc17890f0675edb82105f5f5836953c6de75b7a09 true +check_signature fb06a1854e64c9740a112f59c0e2e2a5342fd9d0181643477a919142908c54b1 1e1b9db92d586f378ae5cead1c76ce3f098ab2bd14886f9ac51ae849737fd0d9 b57928882eb70e372e4dee35406cd283d1f536a4514d4cbc0ae5aa246715810f8976f0cc8d74dc17f50584db9b744810de340f5b19299f5fe82b30b656fbaa03 true +check_signature abd4f193f9c2a8f4d54e79e60a79f20859db957a2077494459a264078f106ada 69dd6f6edc0bcedc1ec4a92349acd86fa2e30faca7a86e5bce94a1c5b7bb791f f9f4c10728b2e3ab3bdceb8cfe90f10bb0020fcbfcaca9245cb0f3e032af92cbafe953861ce040d5eb8d419bed6873a29c14cd997dc9200aff01f4cd4be95c04 false +check_signature 3c80f5daefa2c87ed3574e38ea8b64dc4e53c3b22976bcf29caed356f22a7729 1f79c7cc0001311ce4c9cd2ee69712a88eb7b43367c2f12511334f003f71869c f6033cde3895476670a11f6c5f0083a163e4c68e9528e9d6d117de84d5935f3a1caf355c2d9336caf63cad75627c8d209eeab3a9e7f2ffd23ca946b5d3aaf305 false +check_signature e6637b6e76973ec0fa2b3ef9f1f86042ba0b0d91fd3743bf0f9ce38767dd401b 9c809bd6bdb167eaced1d79e8121df10fe5e25c864a27957faeee57b2ac38eee 7e35ad9facfcab913a07f3562a912237f0a9b6b874a4ec0b9f7c659de45c050dab5d78aaf8926dfd69ad45f0b60308c249b50e6250c102846a82cb5b0dfc6e01 false +check_signature a24f176d58b4a8db3cc4639726eb99a7627a0c1a2fb8d8f348e3eee086ef362c 3591dd7c73dc9e3a7f7eb12945c362a2b33c9552bee4cdf57f76b82841adf2be 87db653745a3c1343ebbf93a04a683217bd920cbd1d593ba46ecda49b68d720fe8e9d91cf3155ce5baac92099a94f19d658edc84697faa7402ef16e0ed59820a true +check_signature 973a0d5a5e9a9e9203223a3842c87af2a0fe2b49d733b3e4305f8bf04b1becb9 b3c1eb655fbba40cb7d76b23f6bc7854a2e8eb75ced22c8e8bd8d0b1135887e9 a53aced45832ce5d2474812ac6b3679a17e636766175655b0c26d46cb61cda05021cf04fc5989804c69e2f8911b97392d7ae51e322a6667721a6e8da5d91c00e true +check_signature a1576ad6adb41882e555c326602b2553ab7602c59b14e2db54a6c5114b8e8557 8252337f80000ab41b19b82f383f70d237030f800a4348f258daed62f35ad2d9 98f6559f75a9d71aa9209671ef8051fda28bb26c3cef4578c1b8e6649a51a70b3a77b5091f1897d8ae00a4e140f88767aa5d58bc3bf0bd61afe32709b666c2bd false +check_signature 249ffdaa75440bfc5f0f5c4c47dda52cbd384f37b2e0560cc9880c1c6a3e1049 4156757cda03103488b0bddd37cc4bb91064157b590c4e4715db9f9c63068e0b c8c75cf862e685f5e3dc698ead789ef791f2bfcfa1638a610115f2f634d457ae0684f8185ebe7c885ec14c8906f15c4717949cd69a0b4745913c0efc3af93f01 false +check_signature 85d0f5423d4c378ddfe1313a6bfb859b0b2ad5eb8a551bde184a15b47453a5da 504f7c74a57ccf0e1b068af49883bcbe6657991de61beafc778d317cb4d7bc74 118aa6e49b1d87515aedb0ffb0c712e9ea5539413b56f7b528849e62fcda1204694b87e5c9b740f88e82476272c00b49db09c9e621644a6eb3c5a44779be0005 false +check_signature 37776c30d074cedf16531e7b21d52682b5b871cc2122a4f3409c97a9e1a28a84 1e18c5770ed58733b4e821040882c4def2695d5e205ce460ad67dbdd4b0565d5 76a232684595e4eabf5e6161cc04943f0fcfc9ed0dfd616d28f81eabe2b9a84dae2660ac6771c86f9409113568be287100bd6801f04d079bd0b21c4916283eea false +check_signature 5c0ab75d16eeb4db165d9608901ae08a9ff6a009b57c782b98f44bc705a435ba 8e05ec8a1df90974abc6245e6d2bef715ceb4f8dbcc7de495013f8693f574de5 b89b0e2ebf57f96dc70e60ded7d876c0616fb30595d02320acf3f78ff1f532fe4b62e6d6e087938d50389573bb13e5ccf57acc2cced6e22ec391b1dcf19ebb02 false +check_signature 1f48cfe066bd58b15568a41d01081416ce846659c20c98f1feed23d7e89de013 4ad514874f9664d1f2bc797eedb589e393e9679c7ccf05e6cb3053df220de503 51a10d5e9b230c2486a51b838bfe2731732d3129bf11142bebc94c415f0b35087029c49ad53ce8fb866154f9a87d362256051367417905dc52409e0fccff5b42 false +check_signature e98fed9856b3367a1427d927ba553942f8dfa78c27cae550d60f34f9d9c797f6 e067842c7de0ecce72e5614911dbab4cc6f22fd60b9c46d88d04cf6da21526bc 79c181c96170508bfd4cbc146a300f9728dc875cb1f6f14167e47c493f8c1d08093eeef45a1f55558ef395c162a486e92cee2f03d3453617dd076113310dcdb0 false +check_signature 23617f4d106215d445cd414d6e3d659770559752e7fb33e4b4a1c7fb66f6d7ec e21a6dfbccf6ea06111f83721421f136ca4374fd0f8f6641dff5a5c7747634dd 3b529f83d992389da2578b3932eb6d31d5b30df4fdc5c943f126a0d2d11e7008317da1e667056aee21b55f95160fc50b93b496c440409518e3677291c3277e8f false +check_signature 4e63b42481cb1b5530cb2c6fc3d085e998b4294da532d6858ac76922a6abfd38 15521bc7f662d459fcd2e6e12236befa0a65ce36a04a8b729ab593538ac8f82b 01b2b15e0e30334bba7bbba8227bfe08c6810700830e30b35018525f094932391d8b5d28519bf26a2304ea71833799801e6c4bb7f0aa9727045d999ed170f400 false +check_signature 3adb7fdc1c1988c5ac334aaff227c87260cd37fbeaab4e6e9abd2461d23d5553 5d22b0f9c9ad2e9abf423ae1026bed06387f5f21dd9b52e4d59b627f37cba458 611f3b8967f107cdbae82b58d077eef1bb178cb08ee4f7567ce83a4790bfb40a22d947232222a34515dc02e078ac64139def013646c6b4ca633c3735a09ef80a false +check_signature bb86845fc42363fc45be68389c5b5183e798564bb27a8016723e9258d0b20ecf d4ea920169adf19f4c47a15b22f926f697cd38eab8e067603c42ba0fed226f1b d18b5e2875c399518bb0c848c6805b33354a4c1d64880f3dd9f07c823a10d8e7796b38b2f306f2a615e493ead006ee43e0ae78f4e084d79b42b909a245429a05 false +check_signature 083df6b7a5374b4a4328a26049d73d1906ac9ab975c43475236cd6421668630b 618da2329fbd8db4fac0e593d3bf4bba361c5f22f3d246d421c96ff38c508fb7 7b13c63d8f423dc82e4d75a7822c8b41a0f398614da8f6965ee71cc239c9974e0ac47a30d9ec910c878d0772fa0650ad555a738c6c1dcb5d7b2eebb1cdfd1705 false +check_signature bb569084e6269afdf7570ef95680fb386b4b97bd26757651a2a989c684fa72f4 f56af32b4c53e4fda4a1baaa7abc1a8b36592a7db3f5c48acb5081e0d4596a29 11508f73a76068b806361d27e50a68da34d7c352a0566ff3022e9696d4076d05442aa9ef4cce1c9dc54832d7de74e1fba88b26104cab4d5850e111da98e0bc05 false +check_signature 99e44c0891daa895338a47a0b8fe1be14600fb924d90b5a11d1b6a4e189e0226 090e12af5046eb76f742726b9dd28dce651351e81cbddbe856ffb8ccdc653869 add0db98d04f3dfbc74051a6f870327b693bb6a73263df2fb7ae45cdec070e0ad2b1a881d572edfb41287868d366bd8a938fd8374979e0298fb707ac2bdd1109 false +check_signature b4a3b72e9a697dcd178fdb7e9cbe7dad1afb0f6769e8bfb9120611c84bf23aca 613a2be21f964bec1d9cd9dfa298757671291808e5838a7c194cee4b5e5a7465 e497a9d0236fc9482f6e4da472b08537c178c2318bffdcb6f0eff2022d0d4b0be6803322bfdd91d923c8e40288e70e92a31c9fdd73b1d8fb665ab15615943706 false +check_signature 849566caf8a7be9959890f8521c984b76eb1b5756c1fb0fdee1e34f709e67e95 d01be676cbb3ef03157f7b8af19830a67d87ddfa2174b93810548a68dbdd23a6 70feceba3f56446b6c70d989fe44e78662a16212fddf5f674daa3cf809824e6172294d3fe25ffcac8f1e5e07b92cca477d6b5d9ff5b64af42cd318cb8b8d5504 false +check_signature 826aaf2996a45e6d70a0d90591302e06ac152c27809ce75cf28e1e7d43179a7f bf1b5b66e90e77981362bd8080951b68d668f110bde5eaef1cd475a15f101d79 672822cbcf05773f1f0833a96fc7a8906976c94f21fd9a5da3db2a90bfe85c02e2a6a5de5a7bfb794907c019361475c4296464c7e7150c9f1b65a07f1246920d true +check_signature 87f33ca5b3729506adee9e45e75c6f50d352fc7c152067bc6d52fe881ac91b0c 5d4c77152b65bef82f61aea7f41edf1a178b7836df3e7c5c4bfe740c4d55c469 25abd6e6b52fa1c6d4eb1927c2bd7cba0f739a3aea91a4b494780e420dd4121a9235a6f939056e9e857c02447c3a3939d0589cc966f15b27b90b428b86a2fe09 false +check_signature d41b537a0dae20b2bf62d58a7c5d6f2de64ed8f61d40dc4ea2b10fce41711c4d 44009b3074bcf9531c0ce6251b05fac5fc8dd42aadfead9efea23d142d484f8f b944b8181f3c194d7be0c97527e457d5d64e59270ad5cafb4480e26581c69604705ab4223fa54d9877a85c4b2772fe9176e283c5476e1a096939e84cdf601d04 false +check_signature 74173a74e838ceba4384d6fb1c799a8da0c9d3a36f0e55e2d1586ef6bc7f50e8 99a5de8c8fea4507448c29c0fb7796322c1016705b6b9ce30064b244dce37863 4b1e0a1263d10717cff5f60292491fd8e1f4286379966d1281b1ff1faf7b75063ab5851da21a8962e5b63f32e1ceb2d6bf6e4eb9b43984f085653c55f7f0290b true +check_signature c5eb266cef9fd6b1489a99663cce2a4174c23ead23170cb458129983b64d8ebc 5f5b3c5ba2f1d7221efc4c935a1ba47c9c1914e9b519544c9948eeb25432c249 ed196c43a62f87b5f4a11344286ddfad932f9201db234183852b43ceb33af95a9613203a67635da058067bcea1f4448df09992dd583f5e6a556644a86837b706 false +check_signature d293d4fce4deb52cd5a2e5c03c840a124f388b0a637596857977131553188e43 ecc2fcd003ff3c403278f9e79f33f229a0e1a761a1c115c7e5e7390eaf1037c4 4e746d12eb4542fc9ce5b165f7e52d2ad08f2d3197c258f8b200389d0704930150a1ed1c6e7b967134a6a0dc765030dad9d58b6f314213d0bae70c332f45a7c5 false +check_signature 2247b7806d80d380ad20dc6fa543c5fefd31aaead98b81644c4ae2700eab2627 e85fa500394947dbda1a73d1e0891c0196b4de2277ecf056e4274270f5ffa0fa a4e214769727848edcd201458c3587a988b56c95afc3ce6d727796aa7eb68400f4e1ec062e1174b52dabf31f9b3e73881da877a733c008f2d125c37ed112afe6 false +check_signature 548c9e7f81792480262b60386793ffda30b0b3282cd9775416faa8d94095e0f0 8d695a23bbf5f3a17461808a6e4fb8ccc03c5ba72b5b11cc23b029a10a30cd66 b7209d6f6d0d9ffb282c1e98d4c1cf171f10d4536634326854843ab7b4569fc47b968c99ebf6a1cad9423935a5ac23eaddfba794e8584a3b59fa457398ec8706 false +check_signature e57d66f06302f62d79887e3886c5779115b89ffdaa678ac564636ba0f0ac8cfd b4eb4d81371bf8122287cc943a2caa49d6392531abe4c59889cd094b49db7d07 5278baa2574ef3985bc1fd802249f36c0b76f9bc89d434940db848e5003af9041f9198110fb457b98183a7e0084b88feb7a9e730b9d11c257d6007ca3726760f false +check_signature 591982842fb3b66ab2cf92f1ea048d76914b1d1b8dc925e634c2431fccd32012 98d2c139f0b4bc0c36e068d11d541290cc65a96857acd0b88dba9a12dcabe6b3 111717ea846395d8b2ce5422699f01dd27551c5c67de977ffa97cc50b8e9400b632c2705379b33e4e0d5f1e2287824b8c0af7d49c9d6240b04fa14fc63cb6f0a true +check_signature 9838ec858557d67d8ad6e2f7008fa819a2782f14c7af1126ef2c570958f1aa95 f73048fe44a11328a0ff24e11756c5f6eadf0af3419a2a5dcc97905d5149649e 1816b8f2fd86b71a14b79e9572afbcc75c6dd9f0628fbcfc17d73905cbd7e308c6a366ce1b3e6caf0e80b7dd5f5939bb073cd5fa8ca5ee2222fb818ef32208e8 false +check_signature 8d369aaa228a84497ac054bca5f47271a4585e4094a65175cc6c1328c4838e99 5905677ac6cd0c73f49288647e63a5abaf623e8cc52df57ccd90d6b608c376ba 9f4c983aa411401ea411e594426a564cc0905c059c7f787de80d2c85f757cdc9869546eae2189d89039eeb5ba81fcfc6bfcc221d380dd61e16788b87bebf8aa6 false +check_signature 935f59ae90b09a27dd8a84cd7d968b838cc9186f53e7af7516a8ac1d4a5abb67 f40a4200e2c84c58ebb28854211d2f7bb8e94364a931476644626cd2b09ae916 0d431a27e4920d3e6feae99366c896869c945634c34798ea64f352bb147dc30039d37aea80b2068f871e2ab6d5fef88268aaee1f9c9b6b344524c96118f06705 true +check_signature e97de8bfbc46a4dd66cf221313697e991d2233b737fbbea140c9f9e65b814e4d 56183e587c64a1797a048328c5d02b4c6446254d6851f4479e143e41635cd2b8 5130eec4fa5383949473ca462f4bada147e8c07083fbf4504dd80dedbbe7720fb0bdb70abfcf1cea2c72b160eae3c4b81b9d64b64f5bd4e3a3598f3b977a578a false +check_signature 0db667b3f847dc51f50e00df15051a92ee42ecb01a5c6729d8a7dce2766e482f 66c50afe35e67128afe73adc21e1e17d535c11272a282e0eb51938b72b0e0fc4 6bb89c9c853159fd0b10291c9e44926b6290375460b002b374a65109e387a30dfa0d9a93a681a3d26596cefb52099826e321ab63a78f616f97724d46642b8901 false +check_signature 262c96602e33f162e7918ede45f3ec5267ac6eab7c02af74c6b6378d0b3991f4 c972d66add2986e51ebb66976e26db6c32298d602f77c4e6fd55006e04ca384d 0f8dc5846d73eff2809cc4eb86fde0a0d2237309d2aae8d8816a1b6ca1e3c7e31acc2ac23c236d047d102cd60c3737c67ccca5e3d58e5cac982ce7d51abdcef8 false +check_signature 2792b65813705a407f3ba8d1d34d9a7eca8edb266ca27e3fe99b2ffaab6fe504 3f8a7079202c335eb0ef7e3880209a140f63460571f1af86a1dc57949a01d474 3786d706d819f88c2926bf0e29b36ac239338c8b44a32d0095ea9f1640560d0f0bb6de706f71057a15645d752b9fc7c48e25010db9eaa5d383a8d5ced6987c04 false +check_signature 70e6d385bcd64e89ce4eedb9c877baf4bddac34d0ddb9c09ab6ae35c9faa6a1d 623bcf696bdef2b6f1e34609794de0e36f62bf97530ccd8ee9948c9e16024957 6bd9f707b8ca583e6831f878cc708672c413a23de7276fa8d69286649a807c14be68fc623f81fcf0b75db6e1254c672fc62e02addaf27e2f74ac03dca0ac2902 false +check_signature b09a144eba1faac9c36715008f6f79e9894bab1b43a9f8a73a92c34472bd8a86 5f8d3403e2e62e09e1b8540079193019a9883cf2ef0f4ddcc8ab1bf067bef74b 8e480b962ba468117bdb70d03712549854c7c24475b351de86b999b97a333ebb00e6a0c1a7c081e9181ac58f9b2a72fb289c762c519df22d95c845032590eb0f false +check_signature d95f6291795426353efc33dad779d7a5cf05f7b9e3e28567e20115a10d695b09 3e6405cf103708e2e62366513dc282e713a71f9022b7e177b462f542536ca6d6 129ac8c4e65711337e6dffd60960f130f02204301985f116b718383dde900a201ea52112f8da9dc6903501d5d91917f592e7a5247dead513dfd1c891c9f12e02 false +check_signature f81916e4f815de7c1b1261e963d89bceca9cfbfabeb0d9c01d7c32cc351194e6 f7a5ca33dee5760a88a4565a6b30b34726948156c06e3d2d7be8a508603947c9 460b247f45262c98379b189714bbde759b051f0c5e5740e71f47103a0ebe3937a1b809b4bb70c00335a6d3d45fe304f96e55843079328d9130312c3213e6dd0d false +check_signature 31fcea77ad3a6d1a629c9f89eb06e9d4c6349091cb01b077a2c3332bc13f4b33 20f4f1c680756df0ea1a568fc0b28b29ce97bb118143f1683a4eb1059e46fe43 edd459cdb7a02f4d55e45d168fd2fd1a17a1c9ab4d66cec0ff7bc407bd0443d96360d94020bc01744ec3e14f8ce5534acb3f84662bf8201ab8e5c4d6bc3e7c64 false +check_signature 2051c80e920d57ae3059308279076dda7b43854b0f75cf20bb3460e227ef5a91 81f0ec7e209c43ca30aab742a2a4a702a7b836c693f6613b7bf895c6536f6379 1c6f1102de216086b69d5704ad9bc5de5c9787604c3141f4ee100667f5f06fa1f49439b2d092fd8d597cf0e092ca284052123771307c3392ff7acddfa48ecb09 false +check_signature fa7dbf3794624aacb97c9dbe5aaa55c0f4b3583e47843f2cbdddb43174f55d68 3e3cb6432d8aa8c21477d122d9bdc3c52d82dfaee7ef428bc4e798349de063fa f57ecef8a86cb17b3ad905e1dfec658d965559cfbc8a9b08cf0d290cda77c70c73d5e90b4a3e2ebc6fed090ebbdff05b8ce212bc0dd0df6f421e45729c52aa06 false +check_signature 08d48d56ac8b9a6115e1f42585e37195088e3a341ed850d566c720177470c6f1 c5ce8f67f90128797c99b03fc9804b1f81efb1c051d43e386f6649f647f5bc64 b849a8d21512126a161da26386dc3dd604a4d4b93357f5354414c14244ed8c0e0146e6579cda6dfc8e73efb3202e7a3601605128daf79df07977c1e0d0bd9d00 true +check_signature f65407ae3fd72d8fde9e69912dea997dc4c48e7b5a6357b35ae20eb631e0ee56 ff5ff2707c52dd6c89e3f58cdbbbfd53269c48e44339bc44306c96410751c3bb 38caf0d41ca7c10c4a3cb0e3fc49d984d3d6befc00b8952d03c4ced4ea2946b62ecf8add10d047b928c1650c62f47aa6844f57fcfe3e62f562601bbb072f1501 false +check_signature 03f04d6ac5203108bd72651be74e21aac97813e6c39f8cfce8737c0c394a196f bbd5b352d2974a86801326414dcee771475494d7388b492ade3d59ee5e05a7b2 17e7877a91d7d2a669393fcdcd5538f184a3804aaecc9c2eb1dea56fc4fdc2075f6e00147873ee16470f8686e4c4d1036819ed31dd5e96937d81fb83c4c21208 true +check_signature 165eb53ea0bc5b296e42ecfce0a8c9324a8c5dca8c352487bce83b77bc8b1b2f 863c274ccb81a5832382af2fcc6fb34a9520a9291b2ee2173cd9747cb58ff248 bb062279761d7af8e3f6aff32f0c6291fbacae481063fafb317e9b9f96f8a96549fde245ae5f64b35a92b9ec69ccd51cd069f0a208e2e01792dcc907b5df090d false +check_signature bc85a04d3c62c373b186a427a7b9880b41e9c68e188893fdfce5ae9ce6781375 7326d62d3e8dc69bd07c6d107aa1a7b8bdbb320bec644e5beed7e3adaa47cb96 a33b6fddf84b726a74c580b0f851acf421c4d5f49738b3de436f6dcae196820437ae4edab40a13a5f363e5f09bc007dc58f482a701df0ed95682926019f0ad0e true +check_signature 25f475d625437c965145487c1ad906ab771d89c7024951d1f73af64e3eb2e6fd 0cb748db38bc45b30569c413719ef7d7414b5e13b8d85443b976a8238af329e2 38f98344dbe8c2c18eab095ee879ca5955b7db573b966f9cfe51e5fdc33b0502f31af3008c27c9eeddf5086b102b7f1954eede2c8886ef0133d0b9bbe7054e06 true +check_signature 808b1c02c4dec1f5c4324344dd1e58e82b1a30f54163abaf7bf8e52c2c1f18f8 b2c496b525db2ff7ea47ea16db42ee5ec4765064b566041a3d617df51adb001d b2795776c82f053cdc8237052406c80cfa5a993dc0e13f1ebafc8245de95b5088ba2e45fa349dc42dec97e51b5eef020ed1010a0e2cd81ebf63f6ac050fe6d0d true +check_signature 33f64539439107c988f457034d3485d383ec69ee5f5e0e34cb9247f4e11025ce 5136a7230e4a6a40d757f279fa535dfdcc29d7b723b142741177be2c4fab511a 943f8dac5f3c5b91238e74961e1f80f00aa3bf5555748c6cf92cb79904f0ca45a6d16e5fe94b2515f68b7aefa71b6fa349e67182a915726f0ecfcdfe74d72b5f false +check_signature a4f46bf4701cc45a104b8561458304dfa11df1f1f22686a5e3d24b83ddbcf8a0 dae9d8cb54b6b0c7f395a4730106a4c9b21ab15d8ba45d956349f96ac88a2609 c3f61facbc88e4bee9fbf520124e7b3fe7b2a617e90a98b513abc13c0f98c0df6d6628d63af45651f43802b8eda426e2f9dd0ab86944ab567c58351b3aee62a0 false +check_signature 9c9a490b0a6520508038c71b77ebf9e44fefad691c27efe0184859342b21a57c eb0430d1473c1747239cf6f7282233770f1fb5d3c4da4f61d09db353975af501 b521c551621e159020536b7f40f2f9d5a2b5b7194889b9942ccaa57eb16d9605138111d36647ba482a5359ac1c011ff8d7002a363d5a7f20b7a0acf66079cd8b false +check_signature c91078fb8eeaf4570458a278fc5bf3c1db35c0465b9b61171fbe1f92fcf4e338 8ef35d70e6d171e47e471a04a06c3584609c47b8d3065e52fa77e66deecd4ae7 515cfc0c557dc8cedcd809196f38d1b9d261d5f40ca1e9dc752b0b005ecb720a6f8a7abbf248041a3e4e6bc09abfff6f93d2c85a523397569fbae47786707704 true +check_signature 599f807ca40bcef83c3f444a6c5ec35df3a6e54b37aacf6fe1a12332ee5cc0ed 473876b80539da86492706fcffd1c1a10660039aaddbd06862d4484dafa4a529 fcb31cf7f5d3a1e0ac3338d71004e3676037c622ed5c2813c013fbac6104a42b94130cbc127a59106583366687b1a90b83222eeeaa03fcb4923d93181457fb07 false +check_signature 8e2aa99babf04276d2ca1fbd64b3940af209b36aaf477bccdeab0ec3890b3a3c e1260f75182ad271ca7d330e4ac65b854145dca2ab6ba864e5c03622ea6985eb 736b582b3facc1c52a382730fc0d577322b64f0afbc9f1608d6f7b93e011d9020708c55cf86870f37a1c67c8149d0d4f107b0409611cb4af2c1d6eecff535600 true +check_signature fd869a5991d685b91f660dd535208353a818a1f0de82af32c9831142f1f8410c 56d6df00bd6aac54f9db936621625e7a71e737ef2504dd47ed17b2c6d0efb27b 7020d2da17688127d237903f6117c3d229ddb117c4e96ba0db78df7d50552909a2d689af2a98d5ce88cfcec74d46fb77e09d5efcc13c0efe162fbe854359050e false +check_signature c47b86f60803ae49411aca2225ee186c32f008af819f4a9b14d9909b5c892d1b b56b0fe592d099e12ab82868ebaa6798e9ee72bb0bc5e6def98885e9a1539af7 62f3769066a457c51068cc7dfb1dcaaa1cf25950d290d4139ee528c7248e8d025a9713f1307faa1699f2bca187e0a1d08490e4e99b247e64d34eecba51a1320d false +check_signature d0b0027bb57ae83bf4829a17d4467de0aeba4795794c532e4366df7e9ff113d6 610d38e5de582a52e45200c8838853598fcffe1a467ae2e98ce0646f78063bc3 b728ae60ade18c596508359369b1e8d7ef667a7a94d4f99f5102ed827c666d044451420cbb14ae326515963fd38d2654392b719213dff9fa00996878b5b73007 true +check_signature 71723bf9389c5935bf1640b7a5e6c17ccdfa392f422581ff8b88888ab698ac04 ba7187d32ea113e1e66c0a1d71dd1f8b41cdfb6fd88c2c6842ff0a653051e43a ac6af6745e6375abc6faa306f6b6e5594d7d8b0cafe13295dc64eafd9def7fa55495dc27900f3c22c17f5da9c974815ecda63451dfa5640ad096463096a91002 false +check_signature 07d798f3a7600c9d8836f2c9d912da6dae3f6ffa34019942289d817a1535c3c2 894e2ae63a95cd94bf03d1996ebf2d41fe1e010b4c5143468978b52c3219b3cd 89a522a511e75792b758051c713411e4fcabe9cbba44e88bbd8db940195e4e31070ccc2376067cc3b6b4063e2a4b0866884b7df23050b2fbd90bb4b68a35d80a false +check_signature 367f50cb7401833b2d2d4e61a705824a5efa4dbee7192c039780e28ab5f8ba00 e3f3373038a22a641d8c7aac290365b651501f11b5b82a73379baeb8a373ba6d 5e15063433eac3d5bdc461b5701439c10ea14da6e505c10c94ca7c4e281ef70f412d440e6e7612ff9fce760d44df17a7fc287fdf11cbed4a2d6374d9a95b0101 true +check_signature 426a7375df13d1512b44a87b3ba2c5ee3f999189bc79519b392456f3747f3902 28abe0c857966341f2de1a9852f63a94c11d61332da14960fb9037a1bd6e4a8c e9d878fbeb4792e421ceef4e31fabcfced9c625bde5f368431aee876769155056b04968704d202d51c775c2860ad3761a9c39e78c93b9143882799eae47d1505 false +check_signature d85a8edf2234196d6d6b23eb4df9be9b0cedf581840c491cb1d11be359440696 f5a23771598df225c0ff5d5f5d7593007734080f800dd27b35207cf4c1fd04de f8a4ca9ed8b7415e7be9c731f0d41a6f5cddf750879a5ad9bdbdc8f4fa3e330dfe41f883cd00da8ca2325f55840a3fea67d744f168c3ccc7b91efa9a761dbe0c false +check_signature cbefe589735724e743d7f8585c6889bdcafe5a6813e4b1f37c3cf0c68e567fd8 449f5adadeb587f2895a22eb486740903e48bfb751cb0caca3e850c65ec3aa6e de2d3b236a0b67d45db08e54e5e8bcbaccfec848b2261ddd5fca735f132ad97cebe3bc80679db5befac534de85c33714aeea96a85c1013a2e55d5833ba89b262 false +check_signature 850dd159ca4318b813a9984f1b5bc8cb0c3d940b5d45e7bd055a5210f434b941 fa45a67d67f2a892f934f8c802bc78875e7f7428f0395b16256112bc6a4aaacf 43768b5e0bb6ff2d3daeb25f6f6ed1bf63dec0867a6d2048fe2f0f5de1647d74886570d34fe813d660a31c500abe448ef31afe61600a6d082a4f7f2bab4ce944 false +check_signature 809e57902c168bf36f5cce16f5f724b77b6f93595e02709661bce292a4c8c5b2 723871c2914cb5f7805b038809b31280cdaa0984f2765d12c033657aa96831e1 fe11e6a9abad6b1c2838b75676eb70939a5a00f245803ac7605080f77b729403cbce1d3b0b7e63cca0ebad0ab03b83ab203ae61dd1920d5690a6c0017c9f7700 true +check_signature 3ea8625c64f6c8fe805386c5875d83bec85a3bd2b4a8174a6c6af2e9207fdd6a ff1f5d99ac6ba3283afdcee8a224bd43309871e1d8567ace6bc337633fcd4440 7481e0456d3bf36abeb77733d4d56e1c5aa5d17eebe721c7098f83fb2507c90e4046d54e509f357ba06fcf241afa1630a22ee05040f85db25f983d9a95cc2f07 false +check_signature 6a27d33e604d91993b215c9d7f45855e74472b0d7355791149d41261683e9b6e f6e0c428e51b0f2e79f53304de9815ff4eb206d327fd06aa67fc0d932d7ae0d5 a1f6efdb4759ae01bf099b689580c374aa7bc79d873ae436b64d995f649f1104e619ce29f01f1136c272a3207b0997a2252304a9c8fdf32b5b7cf35b628a3a0a true +check_signature c9240a21322dbab65666dae0f128b06eeba51924bcd98a15d15862228289fcad 32760dba8228d05e5f8b694d5645536c1c4e992d48485831ab492dcee77a27b0 0ceef5122967c192ff875453f6598f8d64483f5202dce2a2f9a4eb516fa1cc05abdaf3b2ed6f6fa4f589dcf951514721a12db7a4c92c0d4e3e9ce4c96f5c81db false +check_signature 4367f6a9db47d546f37d182f77f7208789fb911571997adfa74201a213aaa92b c74138a99e5429adb7cf11a06035d8a97ace835d1e5d56307615c492912ad70d 9be5f33a0ef9b2f3421c7a4e42ccf32a058b06f03a8337f968f1e0770810aa0bc5efa0e7eeecae0f8bb593f6a7251320bec6e4833da578ffa318b907a0548492 false +check_signature fd0bc7052fb5cfeebfe0b086077681c3af90ddaee4d705cf860c3450d9cac1dd 32e6c1e068d7bd9fa336cfd7b16d86a1dda4ad93f90e51710983a58d74139c98 57c0514588da3a11ad5a8d79ff537940eacadd0f10580a3c7ad23bcbe358e5f4853a52d2adf35a8cc43c24ec8f6aeb158ce7af495509cb4a9f6cf5e7add9f90d false +check_signature b34a9ec6c6070ad2e91cfe3d02aa5c3bb6764b75d14dd087a5f093833b7991a2 68aa1e14fea6d8bcb0099ef3373e4f8a9745ce5c0bce5eea34b7a14a38e6228a 2b70aa61c68995a2bd2f70d066482952bdf90d3cd0818eae1a2f99be07ba170dd31719486e8989ef49059cfbc43965bf48fa5f8ef78719b0849a5d8761968202 false +check_signature 4765970012908be2682edc180787b22fd9c45a837974a7d765d5ec2ab70c2b5c 43ea87ddeb61e4bb2d12ae8e9d213aec52cb80600db1821160c81836d6c2693b 9f2d54369e74219663dabeb52f017bc9f2faceb081a3781ba4e44c0e578a480edbb18726843b460479222c5e69b31f41ff8c5308b2459d57f10cf0c470afce03 true +check_signature 9e452b85deb1e0125247b86832c2aa01782e3a532f428227ccf9e41549bcdbb5 fcf9ebfb6b6667384564440e8989b76a10e86e359f3daeab9de85f32b7be9e7f 91e13a8cd9b3b96b2ce1fd209f4836b8e090809ab8a01b3c8f8e6f73255b5e05ba0d0213ba6ba09058160ecc89c5d91fb2f4336f14951d336bbb85eec79aca61 false +check_signature b047505a4b7c2ea1b1a00ae9c4001f6793f0c1ebd37f52de9fcce1cc3ab12b95 b0d16ab72120f1852272f648bc9bf5fa54693c0a9b596250af2f892dac52bc29 256bc1870a3e4871eea77dfba0db2b8f7a86aa97da077119066d19bd74375c0162fafa8f086f263edb1a69396bb44b27901fde9f51965578e69410e3b2c8472f false +check_signature 6c6b74c59a8123b5d00089a215ffe39bd9152a11819efb5f31d177d9c1b91e3e a2a95477cb90b8eb44b78b4a11fb0fd6ef37a82de784a771b03c75dbac43b387 c35f4fe6290ba3ba0dcebd00cce588fa69fadee7791126cc3edcb41a4b6f12053847adfb28ff7ba59f82cfce7a572256bce8a2064c75da059bd18195266ce6d0 false +check_signature afb49c2a6bbe214eff37ef910f25522e57caad2f5e72de48bd7c22a8ae757f0c af2cc5aaac84dd9e1831b17c51f10824d5395373f6138d7ec0f9a5d135f9fb4a dac03c9ea200c43c9f9b8e0d312ce5aeb5d9bd8abb1e4af681fae0a88b30931bf6fdf04c9a70b71c6a4187d715ab43b72bf013409aa0fa0ded5d58b0771fad0e false +check_signature 6056f884d2bac4929775d78ee792d9cf0b082ce8a90696f7225e63e213e65265 2870ee66d3a35dc0b80a3500a9bdb0fc6e6b9fc3bdafbb3a90ad5c4043327440 80cde10ed0078887a1b78bb5b153704fba3adec546c0182207d20f24584f3fd6a701398ae8b35d752d378f00e3aaa99f42e94a51ea0ef7daf83b44136056f00f false +check_signature 1f81a250872d10df1ce50d9e920aa1d9c6449386457c1393070255f2f392ecdb f75948c7b82f6f59b3b4e00faa53edbcb6f632b7a3475194c5eb089a7bb64f84 46820505dc172b4fe370c967c68bf90292c6195a22f7559294f33f0dcff15d0278235579097defcc3c32c7e3d6dbc45c8c797526c9859676c3e2c6789b5f7e0c false +check_signature fc097ac71e0a75b17d392284d6995fc1219e90f304e3c7bbd52572f5000d6d93 18bf263340fda3c2fb97ed3cc1cd8b8e44c965e24df4b1e6616198d30a0517d4 2d2327e66af3d2be7620f4fa7bb14797c5feabe180167fae68973016fb18e00992d6ad5ca9d0a2ac6cad8ac849c053735504c657e0be12be5c7cf5793a7b0b03 true +check_signature b23af6cfcf81ed8177a49a7e1485f03cea6d1b169170ddfd93456977fc7a5949 25fbb263b62901c4f93bba6acb0942e11cf656134c647440ce5a4396c11d36e6 c7a86e75de8de7d22bd26b8a4df21c5b1f62ae8077160a7b94c5be7b9093930c6e7dfde4aa9113311bd8e1fd8302ad095b578f841a95746217ddc1d0dfde5ac5 false +check_signature 3a91026ffc848f779d56121ede0447ac3ba6882123f1b598b3765b19145d1a8b 1e626a07b0eae9a020e762f441796e33a090017593ddbccd34beb1f198c88434 e7d3a11da75da69e0f5c38793c3c729433b8c6ad0c7f346b6cab454e920b7a007853fce160f422d3d87bbd11a538c9927b76334d6cfe3db55e5148e56606cca2 false +check_signature 4a6dea191f1a9d3ed0ea32680bfd394642bebaaf3c7c132ff1b35a1e58ac0ce8 248043f800e90d117a82e8a8aa37fc9f5de7d295e4f659fdc2d029b38d8bb3d2 3db4bef72d367f829fbb971c172c3b70368e802989e34ecf8e990148318cc00b5f6254f29cf6901e4e010f4587a6e0c4e9f48d172db31f6f1d0f0d2353d17cea false +check_signature cb641e240fb7ee2ba731baa41316f2cdeecd1ee10290ef33b22de03a5f28a91b 1ae6aa13bbd63ef99e435e94f6886ce7db34814726bef2a261c6dc31b7bd612a d23535b3145b73f005b3fd9856513400862144693aab09fed893d2205c992d0be818106e0edf655a7da614d1138ebe9ecf1bf28e75a3a579f51347f0cea37859 false +check_signature 4b0de81a59ae305ce0f7d297dd4df14032e88fbaf3629c1b243b25415b2f0a50 24a583ba75d8095219ed073fcfea8ad75d37f30c8735a10f284c49e53108fc34 d7f77b977dd9919cf00a220c12008267bec7c77fb4606a1e19b6b1470e6ecd9aff41785091da4d9052f6d92fea313ff0eefeb9c40ec4cfb3847233bd1df9f502 false +check_signature 72bfaebad3fd4ae4685dca80990fa5302a12eeb952f00ac90044cafddbf3667d 3f9369c2cd4ff820b120be672e5547ee257e7fc854e701f6189ec7102b926374 aa87ad51e780d1e378589406cf397d42cbb9b4c6ff5276aff24e36561890ae81c91783f78ccffeaef2701d9785d82f58076ee4b3be8fd65e8dafcacc86a28a07 false +check_signature f4171b718967da7d08a0d1b5d93d7f37c5b6594a26b7a0044321ab19df0c3df3 516648681eee10892498c4fee18edde7f2dbaf74daa2c74c6d9c9c3e9b71fb5f 40175122a7a227f6016328e595fc70591ca5ee71017ca907d5238513ece94909ae5a3606009668f426712ba86755e7a787c50d73df6a807194e17ff6725d0b08 true +check_signature ade5ddd17c520b3b0a04682152393d6b2ae9c2b5ae4e50de9dfd262a638904a3 1559329af03555b34784a988d461df601a02632c51223f22e64c7f023d12a91c 82f0d64b0781da72f39061e5a8d1e88f74343873404b6fa086c9497e3585350a8609ec79a3e9c186856cca63fef92129e31ca2fb37dd1e7c5686f4c58083a303 false +check_signature 0461e5982eacd439aba9735d20c62b7247d5b4c2b86050cdab7bbe4b534f4308 44eb6e57c319f5a56062c9716e9ff3a3f2ceed3f75bd355b117df75577a7c3f0 0c1c7b90e6cf176a32ef32ea4c1b868b02f4c5149297646250b637d6f3550e035c0f35265e36cf18503f93623bc1b0c35490a33c3e1184745791d6cea595180a true +check_signature a093876e55a8980f89a3b8e5911aa386bf9377bbd7a8a8084a03009073cde0bb 9cf09163055bb4e6b90460bda638f9b7dce64c31b5308701944b277cf98e7539 1d09975c9c9e478d5d920e544a605386574460f1de5fa4cda226efe0ed371ba086bbd9b7b2d76b8e0e76830ecafb787f81be4e179c2a60c7c04955fcfc4f1b82 false +check_signature 5646548d108b090d8602ec9b8eb9817964b6034a8d950f41f44bb99201aaead1 c69bc064dc758f9d23a3d6babccd2bc83dacae71041d370d3b43e2bfb11d2f66 bd52cee9b6735d6800d4faa2422feecf4af221ddf0b1ed5fb2f5210c3f03010b3a9993476fca2305a4bce0ce5fe66aa99e08cdaf7d6d2a0cd76c270d7cdcd907 false +check_signature 3b2d71cc4737f057be2ac75d60c9e618ccc57c834cea1335b80f56cdeb5d1fc9 d6eba224004e75c51ac6a31ab59118345f2410a1720422effb4d0d35766aedea d060a193f81f4fd70f4e171df463cbbd2fe739b90bbb73fba0ab01603929250d1564ad568136364b3f592c3ca8d8098fdc296155559dcfa10f323845b588770e true +check_signature cdd47290b848918463943d8382a7d44e9bd0fec69c5b78d9430f82c1a9f245b6 6fed40c669a76beffd9910793b661dfac5f4ff1852aae0193770ae62ab04929b 8e8917a79c518ce536d1b744c7f43fdb78a62d102da12e4f599c5f9f22defedc186327f60a0ba4c9317e29932b6f5bf1fbfe5cff4c1e76cb345d5067eb5f7ce2 false +check_signature 70405691c4cecc2926aea53aa1fbc370a46a4965f91ca66f7349aea4cea8070c 417c3b2b9c93f909b7bb16210ad2bd0cffe8600f87bcfd244163ada118bc8cd4 66c6711e1450877073c16a47b5060e76970091c4bd9c190807ffdb810e6afc0952b2db6a229efd69394f7c82912b379a09fa40ad867b6eabc848245317f8ca32 false +check_signature 27a1367a782a0655230028e88b0680234e135a235cbb1503a7d89a7138ea2d30 db592a54f2c9e5936274cac3294f11900e188531a56252083fa1685ceeba06ed 30d337fa46ef71e7c8e5b940707da0623911e275f5f1a8d058551a66deb94179303787d71b0ed40e36ccb2d8c05878c5bf435dfa885e7f20528d91b916926090 false +check_signature 7e0e7c5665d262d211a158da6eb852ee9621b0d5f0bfeed3b7e57eec37a8d14a 7f6678a789e72b8dcde9c2119564039fd75ce97b5e4e794e68c926c89394475f 63114a4f498b1e0605078f407a1270ea74dd3a31d6cd2ac4de854c88919b3508394fa83053dba2f4082a98e01791f4ceaa57e4c898b1f0c61f0cbaad9b313df4 false +check_signature 70cdd25054d77f6588ae413ccf4de5cae6e6b80bdc94e093df65eedb01f7724c 7d1127d9e37d6b3c8f38c43a0aaa245a9822e8e5c6b75f0e576628f06a66403b 9b1688ebecf161dd0e15f04f08e2116841c5578ade7bd994147fb70344bf0a0e3d6117942c9c1eba709ec55d57da321b68a3c704b1eb0c173aef512f51ab3f05 false +check_signature 99ecd33b20f17581763bd84588ebbad59992a69bf441dce1f3b434c68799d782 5293784a98ac037126d4060117b93f6130f91bf2fcd6a493e2369d3f98ac7bbc 64c857ff77599b516958cd3c02815620056c531b52895353329191bdd4ed634a6ee3ae634cd9d12560c3a83ec56f2c70aa95fb4cc9e02d2decf3fe02338d9f8a false +check_signature 57a7ba51dcc9929b01af66ab4d3fbb039036f547e1c82dac2ab8d2694df986d8 6d39b983b89af2b9cdf9c7605fef84b34565bdadce91e16ceb849a9cc34135dc 201d5c290773e8214c2fd290a5b160313b00545c1a7cfdeb4bdb1f366efce0053d28ea621d65221d7df07c732a02f2051c9a489f878f74cc5853072f818b8404 false +check_signature 2e6df0305579ef8c7aba10d6bf62d51c6b73329f5bb572aad6adfdc76ae0ed03 30793574c6e05800a0ffed391d6d102a227fb5ee7d5c05a509d51a2e42460438 ff4998a65e67becd55ca888fda3ea58c438f9939cdd386ccb53eb22c78fa88bef7b49b697901f8e4fa96dcf71ca4406912761dcebec9814018f08b2b73097d01 false +check_signature a3bfadffb340d7097faa0d602fa2d4271f082c2e47276507108c0059ad2bffb7 ad388335fd782ead4b2ad4e0eb56646d683a5a567dd1d384d75029cca15b3afe e11792c8817b7ef5f63896d15e077908f4291b86efcde08a877f6a1be876dd0479b83c3a6f01cc8ca08be7a5d6b20d954eb79bc7c596e5e5b0aadebfee827e01 false +check_signature bbe4698a8db8193c22a2d8723e20b9bf7111995a48dd7010a1e287cca77a3270 43145028613289deb10857f2e03ebd70bf9853e40e59234c491e049f7fef9291 fe739c4cd0c583e8ca2f638ef720b2b5623870d366ac8589c001cdd535c6cc08bc27a5995ab3d2a49ef0d3234a3768fe6ce4f8c54cfce638fa1adb11d343f90e false +check_signature d59f70c447f5e7bb183d800c3eff535721cfff0a3ffa327594d573b8e2b47def 7cf807de0db62a6e73f1ce6934b1bc55f40f9232cc58dc98d96461e84b55686e a68982c46410f69a8a8eaf79ba545ca3bd0bb8222de9bc7375ded46ce9be950365ba148356f2bd0290632b0690e9c8af4a3f351620e26239b9c8124d5e7ce502 true +check_signature 7487d873f23f6a3302b1f2aa537fdc57868df6acf713f469ed3e6a2e79b443b3 09c12b4d8dd1b938ad6473d069544d196612677e134409ef4d22726906536970 4c1eba3c0efad0b904d5b454a9c590563ab7581a569908af23dea1569fca880137cbb4e5b60a002af900cb2489f3c31844b90b91ab29e2957b584fd2ba7bcc08 false +check_signature d95e3dad0ee69201eedf4438c539e70a7e4fe22f93405b03af757ea4610dfbf6 67453c0c767cf842e48e0feadcff39aa5903177576afc03f2a169dc2bdf2147e db0fae5169039107fbbbfa04c1af0344f5e20f428cbf26e293c3648032034808cffafe8023d7895fde373aab63d085f1dfc444c261e503ef6ff8d89a5669e00f true +check_signature a66f08e2f79f9dae8412c12983b473dd6932a12159404c6a12bd6e87111ca369 1596be99811ea82807280f19fe45fcbb44233d86a1645b207a596b4d9850a047 242242946ec87506a7287efd70db1c8176bf5211d975bb48c0b67ecf588dd1064aa6cb7927d21f2914a6538aa65b8818ea426b979e9a6a038ccfa1651f05470b false +check_signature 1829276530f67d1bef72d3f40a8050307918b805284ccfc2c41f33bba37cf8d1 480702b1a59f5ba280fcd947ff0ae71400b47be80c4457ffb9871eaee914f6fa 55f6a6ea9b4615d995a4a06c186f29dedf8de0292984fcc5b75bb76e541c1407147982cfd057ea759493df9c38a9a0df9a0a14a03482821105f0d82369e5970c false +check_signature 11b82e7398469cabf6d6192a45232d2db602df65af8b4db3fd98a7b663c08628 21f4d729dc1ac5f2ab8d51d2a8c58c5cd395295bfa46a0df40ebcdc3bad556f9 b0326b27e31e604c22dcef65722453ddd0d5a09a063b25d9d769a11400df360c23bdeab50ce3540348c5a364b07d9856861633919378819c19e4766193105906 false +check_signature cd3635603beb581acff8bbf4dceef1605f1948739688b5db5a88919e7abaf01a 00f86f022d5ed991d9302783cb03f73e6ac908ea02e40cd6f18821fb4749495e f93b89bdf313d32bdd6ea6c7ea904f10916d584d0a6944ef55a8f3bfc430a404d435c4fafc65b3a5925923b12e8f745b403a818b4087c17e9c031cf3752e330a true +check_signature b0bedd910fde04f14d764eff12b61d83c458ae4612d5e68484bb85d742252028 f894ce528f2a8ea0aac7de422578195da9632f127ad04910b398b2b55ef3b02b f9fce0a4315ebc6e16fbd8c580206c25d5c7da80411f1d3584fa4497224e67028f89250da83c9518b518ee2552df8af627b4d00b5da21c0e2f737f580cb30308 true +check_signature e2d21de3fca7458721bc5659ac39177dc06cbbe7dd2f363c9149927fdb6b234c 9de78d5c7d3c5ae0d7e49c5f1c3d6c9bfaaaea82e4c3f1ede84b6b679a59ae72 6fee1d640568d0a8841f6dbcbf44facb3cef95c13565c31c46f150dfad73930eb000ed29eeec297b53b5d9ca445a0c735070ff706f2341dbbbbcebcef67e2d0f false +check_signature 0081ce3e98a86a393b0a5479fc965bfc3bd3d5bfc9d1f3a8967fd5e3515c68b0 f787aadbb51e924c5efc434ee71d7a294f9b5ec57be238a813ed60c475830153 b0c2c30149f79641c67b419219e310af0c274d034c5af28de46d4bd64180a309070f16938d5dc87b04143d492ed69bad4e265e073bdf321be7fb345f7f32090e false +check_signature 46a4e147069ce1d19c343bee22908eb5c4f493a37475acda3f26b31ec870de13 780d47c0dd019d6456734a9746504fbd53f2952a8425f88e47e0af47cddaf858 5f8d629478c6abd6a4b455024035c32ba3a83e5465247c51725acb92c24120028dc64fb3ae1427bc4e3473097b31bca78de17bae99f0e8aeb382d56a70a30da1 false +check_signature 0f46c33aee7a6016774e889be3074574c3c76200ec2dfe875ed3c77b3dbffcaa b8a654bdcaed016b9bf03ba7a667dd6bddaaddd2307590d8e5d95e1732ed9acb 1f35febff82c0310d28d119ce938c54f2fb848029d58d0268c3e531cb952440a757af6ed9ecc153a641775a052c77df958991efa7049ce25972bc2b274bf3b0f true +check_signature 6dc0c591ff0fa7b8bf6895d1869889a765260175546d753ad8db8d9ef0a1416a 70e14d7c8f244b26d574c7dd9ed3b30a752c2f7f81c5e4a87d8823b5391bc138 b03cd5be6e5899abe944e606d1c3fee7ec38286e65eb1f676427cef1f239a20d2989cbc7ff474967c16166a8c9490fda1a64032fccee2441670bb74f53e1a30e true +check_signature 2fa904d20dabacc79bac42763cc0277bf1241cab17cfb51e64a87fd757fa2391 7de903a2a71be2bfad06acfaf70c0d92011d0b58453fec29a34959b78976f1aa 6ab16e0658f73c495a3473c107329b81144fe93148bb419444bc7c0a6fb16e9d87984fbfc256591ff7007ecfb34933eb1d53750a23ea58d0f2acba63a2be6206 false +check_signature 6625012adb1e2c3430c116c494af5eaa45c88c4fd53b483cbcbe2866cd8b7f93 7558f467116039f7eb82b58f854941e1002546616325dcc5b403b14334c762c8 535737ab91bbc7cbe7980335f5f90cf577a8335b7dd9307a82e6d865a9fcf107501e33a134f511bacd111684f919baf3a00391f009f912e9d4c63401ff5b4510 false +check_signature 3f84a0d17cd68117b394389f515afb4fa178d60bf67653ae967c454c145304bf abfa2ae3048b5cb3351d5693fd815b0578a4856becbf5a95183dd278ced4908a 8c598eae838da4153167927b4e82dfdbe68ea9a1b536d35b47c259a13f811e195cbb4fad882da50738e97d1c7dce7e0648ca751abd8f61949b3604498520f805 false +check_signature fbd5dc2bb70c3e66475b30b8b1083f771b588be0526cb80f62bb066d8e62eeed 9cde8a890bf861774178b4e2f19e86b9d1f73d37b47f92060416d170d89a9e36 c4922504cc61b9f8e4ba8f6b1169c8d4613c5f22269ed2819de270cafdfa2704ca3e404349e1a83ea58a8d9612aa46be25bb486c667bfb50236b9c36cf91f30d false +check_signature ec25995b1c4ced84bba99e0fb49ebcecb08a003e2fbaf573e012733b049e00e8 987ef0ad9dd79051a10d84265d723dff1b84727c2e6190e523aac84f8b32cc74 24eb02d61cd15bb9073d9f3222bb6f0b5882e9126163d3f4fc42ff0372538503f586c7358127d7906660084a6c82b8ac75ad78b9fe110e1a12b64f71bcb2a301 true +check_signature 00ab3fe2c10745005ff367718651ae77d121d986d84fa44f8a701d25e7fd4855 ca7f36fa68c42ed0726149ad03cfacf8f39a7ee4886b0fbe898cd3012dbc4a7b a970e5ab34e6d10885f6f5cbb0cc18016cdfa4affbc2f9c0f68ca1b3f42cbc0bf328ba238a41b7607bf817c6a0b109e121c3ede258cb734bf523c49a888b0e0f false +check_signature e3b5ef651e536268bc3f5ad473403747937bc5bd07301c72979ebd01e87b452a e533d8f7823d890ab11003d8394df99642528b86dbb3ffdb62a9d3c62c06f7b3 7b2da3b9ef8b66277ef1e04c7647f125efba511c349956105d91c3222e8d3b0d4e271672e9f4bd97ff482715ac613b330450057d8246507b9d91badb5f19cc06 true +check_signature 7e8f1e1063feb0ec2a111a3f39e92d059705c2d98f0771eff5f8eb1f57521cbd b384e8cdfd794266ad52c2ae53f6021b636cfc1082e115437ac7655a0d8c40de b568da5a7629a38a00fa0890db7b7259724acd45ddf024a2125c48bb2abe4b03b22853583a5471a713d5d213681cb135f8137d59810d286561e2b45ae6cb2b0f true +check_signature d837fce281d75a8cc8a1ecfb1153beaef3e13c2c11c7f489a2c6d50469a7935f 95cc605ff63c4bee5a11395316f93ff393e557c79c474b4d1353716a63872880 2860f6b8a3a8fb24b99ec5ced6e25559e71656ddeb1c99ac13ebe3ad68604b0f23a1e361eb9b197c4376f2a0b3a8168a8fda17dbc144995e97549fa958c6ec06 false +check_signature 5f4f109a83a720cf7bde34542e0a290c32755cfd2b1da09cf7e1bb102ba8fc4d 2c7a810c61324ba6beaaad26a1c7f1931bb70381522db1e518f18c3a0bda434f 78ffda6ecc9efee049bfb602eed0fa85776d10ff689235cb3e3daadfb7ac9e0081fde45e0a54fb0e84ada828d3d1d2027f95623ed34a1d96bc956d635e7de00f true +check_signature efa066c7096d9e48dcb5c637983e0d1f19b7b3ed4fe3b3bcfab75f8aa18c88a3 4b040e45df4f86466ec972a1c56511fbf042139211150e490f9c5d549366967a 924be40bc32867e19d76411916af818a27e365ba74ca5de54d543eb82ae1880cf164eec4d4cd1199189e71713c49a01ad9cae2ab589ea4986bb61ad084e1350b true +check_signature 49ed62bffe9ae0a9563734ee6276f494d90b020966d17a5a2fd8b3d67ab1460c 027f34fc2f00f14473eb65fa374373c5b6b16af4abe0ac75242ff83146e7561d 79905d0f14aff95eddfb5a4025b3ffd7265a80febf26e8ed0e07045732746953828a52f492ef846544c8725048d1dd1616652d7e292492db7bf3855a3981540f false +check_signature bd9f4b011a38f06a1e42c2b8d32cf1b27f9432dbf9ab9acce304bcd2fd0ee535 fc385bcbfa89a4d01a2b50f0062561e1c10f3dad9fd5a5ebc648313b9ccbcbef 2943e5333e35ff3357597b1cb8f74b0c895cee1e9dadc7db2a992a769942dedbd5c2017607c8ec330cc5f05d9681f15eab48c8eb6c7a62add8280258ebf77702 false +check_signature 7d747782c73000b7a9f1be24bbd7346682f5675a9e481765e8df325ba3a8dfcd 69b1253ac313efb11306c741e9dd5b6cd261f859424f66d36caeb882710a0469 8a98636b11734303ac8e3797b422fb70a33489d8bf82629d0e309cc97a007cd1e59ccded13be8570ed4f77e779c59e37b8ed8852092b3a157bfe0886085d3f8b false +check_signature 0b0794ce3c3e9703f7595f13db306cbe1edbfe4eb6618ccedc00266ad1219eef 4a4ebc66ff40ba0249eda997f8040ca381b4ea90a3d61c4c3fb708c754449193 3cffc2ee8b62a81aed4e9e6e33236108133aa4a7a0f819277e917e44a7dae508480a28c914bc14795f81a9fca09540e925eb3cf92d99f022680f5b7ba4b9d306 false +check_signature beb774e1d379889945d8a1270458f726751d73c425221de43fa15c4c443532ea b8531c82da0658d698c44062a372a75e4fe791445df17240912ccfc9dcaa1820 4a050cb411118b91acd5cbce3d9853c02570e7864b8d8d41111db16ebb9bb7069d384b5410758fe13cf4a50b37991f2a51bedd87b7070d4bd47d8051f9bd8e08 false +check_signature 8baf11bbb8ab85675f46c9acf8cd77549464820f37206e4bcc2d6cacd75c865b 3620148b9873c15ed280d95e06af19258ed1daaac838da0b265dc842860c1eec e139c2b24a97870cf61d963e9d6d970bd0f33b40509332641ac2cd9375ba37092b7b84bf5e15e839a7cb309c7bb988299b5e4eedd61569bf45394f406eda2468 false +check_signature dede1dedc2b1c4588b19a9e43dcf49ad0b0005c44be01bd3ac8356af6024060e c693cf60d621195835623248acb9e467e39ef3866fd91dc053b7f7b07435fccf ec359fa9ce1c540b9d0daf88a3d72ac70e848a96eb55894b7a9f25d29d096b0cc0c5c4cfe8d75bc9be1e1d1f2f4bbd3e8440f59c8328a0cc156d5ab75e4a1c0b false +check_signature 7ae5328e7177e12fa0520bd53afa66158bad21bc90734079cdda08324b2b9d2a 5dff07ce5d3c22263e14f2ee23995aaab6cfab16586cc31b87b20159d90c9e3e f4a2ade50b9c449d8b007fe4b71fb14ac76f50b6f464e507e8f12d45398bd19dc552ed32ed9518dbd95149c92fcc6798470ba0c4c58321f38e725aa434c34601 false +check_signature 2b6dffc25f4d4e55fc7499c1f5e6fb4a998456a3734bf05bef320913c9c4d5fd fd73522dc36a2f1805e5fa2b7a3c9b34d1bfee416a9a6df09ed25002aa281aa9 ba6d1d95563e409d18b1cb8e11407957c939684f630a942b26ec05e2673aa90629d71200f67d6f3cca45eb524ea44320452051acdb2a64eee841fa1e0d247f08 false +check_signature 94bc969b03986d4fe94994101d55db4fbc82bac4849aeec4c9568bebe2e70de6 62e4355ef9c3a74b41a73201066ecd2617c53d3f8e6aca90dd2e29e7efb1dbeb b9e242d4c4061c8cd0dac913c82355d38019252a27a5b4dd730c867d8b754c01d91bf09782e78b33a019e16871b13f20884a5cac14058eb250a95489fde1ea4e false +check_signature 8c535cbb1da67dcd487a164f8c4750e34c779145359c027c6e3e0133a0093be4 2fe1330f2679a6c08ecc054c923b87e979b2cb7173d4b917b3564a3490d9d9a2 8336e1a63de604408a9df8587d78300363d3870f72c707156ed37460e79cb33a8e71ed08b3ab92cffd4eeb882cca0928625263421f8e22e27df743c2cdbe1d0a false +check_signature 1f5c5cdfb6c1726adbfc9a58728d9fbfcf2bdecf83cca405632e7eb5d0875ec5 f4b9f4cd90d7df838d5bda83e5136c96c10aa6e0119fbe82319cd1ad08328223 2362d621e89acbc4ce3f70a3fe7d4443b67a387e4fa54cdaa62e0a01564397025f9e6b7699f5b793ba017babca4a3b7bd671f2404fdad6d827b658bc96a16468 false +check_signature bebf03a4b6aca0b7d9be06e9f5e4027ac5ef36c8d4567555e04b8e1e1e4fd0e1 3e5402691953e5c5ce668e0e4aa6ea7b4e601f3e4d94be3444ee408d5bee6353 44fee21dc6b1673cb274161f1b6b0da8cfa46a771628f9bb0f7a6ed9031ea1732f8bdd2745b447ddc581b78c9872f68171185adc2405aaaa92e226573755660b false +check_signature 264c127ea46509e1334e9aec150f1ab79a2ddaa343c4a99b13d130375e365061 0ce5bd82b6237a1e81ef9c6c9572e95f807e8be0cfd6506b84a82ec8ecb55a7a d3a27eb4457d60e770f8b083a354ace5792458403c48abdca134878ff6258e079e41abb4f553d3b35db472526cce2b28913d2de62ea263726c2757be34b34c02 false +check_signature 712a77f1a93bc1cb39c7663c42dcb201dd40528c5018513742b8665db83ec908 b7b9bcd5ccc8350f5dc85d294b6e0a913257955191a29371e2191dc2ae52ecc4 ec16e87d39799484af52c28c3e27b38dbe6293d587d1400ccf128217b24c830a0006aa720c9636841a6f55294347d1050eab6f8e86aa7bc9e55061afa1829b0d true +check_signature a94a54c13b523c36a6ffb32c66c1c5fd3f8c7bb172f1231064afe0f3f2782c23 4c99fa7f80c84d323ba0191cfd11e327a818acf5d9bc72f085d69388b11a9cb5 bb9f8af07a031cc64ed9e9bf1369aead1ac9392dc85355227e18ec9304b53c97da57a2b95207a31b7d8c22bf73cae5eccdb082265fca02212f6d5e12c0f04606 false +check_signature 3db5a830746d521880050306bf153d7351cb85ca3d7164ff722e8bfad2c9778b f929ef7885fb0bb4307f6fd67a5ffa3baf11352b53b41f6ea8a817dcdbe54c3b 665a4fa15f16a750431edecdc7b780d7775d7b8685b95efef243893a8a0115434dbe87d31c3bcf3eb2f5845564434c2dadc455732738c5e16163a3ed5ebc590b false +check_signature d7b73640ecbcd34fe320c0767162d73574fc297f232e2afe68dabd76b8ef1e11 45755fce2b2ea1389c8e5650cc82811bad07fe3f5423205e9b575cef7c5bb7ea 66361ea647069c3045775b548d0bdc3a3726e16fd382547c92cca2d06fc759012c45a8f374b5e53737885f4935ce48081ccaf446e03375905d3114a75ea35d09 true +check_signature f082ff955d7565f8403e47c4bcd3b567bcaf3a54a8900c15974a64d1439a9d59 c7036de49877728001af254e32421a064df87ea032f98d7000eeadf026713f79 94474ca173e66053282a86dd2ddd9911fbc55b796dceea5c41722dcd472bec170dff940e0263578f462d05be6956299112400204cba70cb9c92d664f2b6e0106 false +check_signature da05c46b92fddcb555c54ef6e9842c02568125e7d01dfab246c52e4e2decb51e d8324f167354ce23a6beffe100646d8b96f699aa967313b4d54e11951f15a8f4 519237a94a1dea76171d963036611322520b70214f29afed89dd328c2ddcae02621c60bc9d6c55bb1b641ddb8ae1702a6071879794b2bcd23febcab5b7a39514 false +check_signature 98541b80d80680a7c0d9d3ea50bdc343216fbb085060ab2d8702be52d3b5fbc4 b09a3eefc7c31cd8f3f1d65e698604f3a7a5e486077610600fe352fcb5b692ce cf90c10f5057c481c85b87399eaab80794f6536f7b2cd92bbf0a10f76af47304a38b9db0fc7cba7953d92ee576330184a727d959742358947b847637e18ae292 false +check_signature e64095ffc25f57220fc65ab2bf4d8fb34806588791d27badbd709e7527e26b7f 030d4d2503d711cc2f9b9bc796b59b256758ea5d671576bb5197efa116e602f5 410d42be91d434df4ed7983983871cdb982313be1bf2ff4a026ffae7bff45b0baa31381193b0e596a18538584adfffff9cfc65c65b174c51fa04cf6f44088807 false +check_signature 9881c71280f07bb1f4e9164ef27255416830908b889c3915c738de637353e702 cef59d346979fe2a7ac062c8ad3cb648a52ef28ec2a9cc618b554923e21a13e4 e230769fff94d8bb091015d65cf0985d0983b87c3d565c02e869ccd95bf3e60c7bb728c38c933757f19bb40d7eeaa39775211dc515319bef6e3a79d1c54e6209 true +check_signature a8460322ba08f11bbcce2c6cc1a3aafd481cd25537d45cd3975c955e510db910 42fdd00c64bf3522e0892c606b0987f8340ad81f94d204b7606229dd2acc396f 69ab592ff7a216dfacdfcfc19c680c8145c652e05e11c57f06dd88573204cd09927405249898a838bfadad96c0106166aee22dd8300e934e3796389407c9a307 false +check_signature 93fe22d8b54969bc5e2166f0316becf3526232116758409bdd1abb0ee47a6e8a 1d09ec2b3e772071cc40748cbe417a6c6d0dba06ee7cea90e02eeed8003c0ef9 663ed175edd66ef639d2d01e7b3ac90f25e0cd5399e061f06c44ff47d961760415550b3aaca77601d310a2591493f26a433ea7103914a2c24a3274371ba0e10c false +check_signature 2f2bd022969f84705319cef2744b2de342ab8092ea2598d1cb4c91a5191f2aea 5af26bc27543ecfb3a0b42f13f4e75efe675dd280ae7e41fd8cb18cfa51bcfbe d29965abcae815a8c345454939d7ae7c1dce5c5cbe0aadf8cb30fc75d2f75c77aa1fea92f71b7dd7a9310bf16e3a06a5acc96228960efc3bef2dfebed2e1fb03 false +check_signature 0f3e5055ad62241af230337045ca32d7d216b4ff0c41164459eaaa4e1dc56f08 11310ffc0aec7c4a69be5b8289e655aeb6882ce3ade0e2c5a28425ae38c90c10 efa287c8131b69223fcff0c48ca395081d07b044bbe5a13464a875ca35fffa0f3ff0b2a7ca31f5c69689e00e4df2d7c89adfd783433c70e6ba6256028f716b01 false +check_signature 8b3771c51a40a1eecbb7b0ef7dfcd7fa5196dc6cfd65cfe3d18143c856f83efa 621e200cc4bcff2e775b7f8bc63ad84e4b5ae90379fc503695666e4b249a6715 9cf6e7cbedc54e39fe83bea33884755ce600ca1fdfad7b14cd166f91beb7b90e728b10bfbc1f162b020fd2c6de6db10e84a859c554bd509702e8b7d10969ad02 true +check_signature dd569a2a2ebcf8c2ee6019c7af0da3e53397d6261985096b45c6f22443956a84 1a4746b0c9deaacead07dab91c6842d0e4ddc2888ff4bbf85b1461bb0bb2fe5c 08fedb3afe87c14903b58daeac9bdaaf3b9f120f70e1e4a1192a349c0a33890459574606922269d8548a39cc3bdd8894b80991b3296288f4d8bb44f36a73390a true +check_signature 912d78f3e41dd0496f12f471f4f3e99615401af1bd129977dc24f3756e73ec80 4284d206087e9bf07315afff46619899be7fb77bd2ac646e785e6e3778db5edc b8f5931e8a3cf128ba43b42d86308d34596c761e4110993e0974a0d75c8f4b855f03388010752663999701052054defefca178acb465d094e71f8c33147e700a false +check_signature fe7120cc232dda6e5463f3d5234b811450c2cda86ec9b205238061c406f0e6b3 c238fafbc0afc63ff116e3874289a67297aa0ee02f009eac2d9d1386e004b704 74596398c6fea849143a43443453d098c841ff29c4981ae9e4d802a610a4340e296818dadfe4354d48d4d546b65cd3ac6e91955cbebacc2d9a28bfcbb35bd173 false +check_signature bb60590c074a2a1f29b5aa9e3bc9b08204a3fb77a9dbfde7f101ca6b205f3749 409850adb44b3915b8774b7f4598623eb768f28b6d7d18afe6b40fba81aafcb0 c5f532bddbb24d9499de8088573e40996ff6f46fd43f66255130dcf3a9449070f3db609b7329006c59e1e493442a5b4e2c95e23f20abdab6f118714ecb9edb58 false +check_signature 5887cb32298c712695e0ed018d28e1503c623b1aa118515f87755dad624b43f8 5b832ce25eae63f254c8a37cb9400efe74446221ea011703f4a4e56cb00fa26e 518abdd8d20a61e29563dbc2efb5f5bfe6d426c14cc4175e6a90573571957407710e0d509f50966efd223db0e698ba4cbc8942bf6470c50d574808497ca9440a false +check_signature 0c09a5724fcca8d0f7b1a3fbf97a1ea77f7c3f6eff91a0ba0017bee9092011f2 11863062ca14a2d79b196a992f9a64fca7f440540a94709199e4a86d5e3e4d80 377ce42f63a0276e14816a276aeca2c84c780c2d80a580d4b500431e2980570105be7eb031206c2c394fdac70159e1b1457799694a94025955135e296626cf8c false +check_signature 59f14dfcc0e130b80183e0473a7851a8e8fe024ea77336a0f297accdc2c3794a a8f3872366accc29a6349cd7eb1abcadddad20f1f200ac97759b6b7372a89602 d12621652e3eb001484ce05339e1288c30aba053926c2b1a1b61b92e244fff02f0879149c776b5ec760d47a689a89b38d8908521bd3bc13e6010eb6fc18f1b05 false +check_signature c07bf8b7870651b3b9a0f824c89f54ed25d3cfce69b6792afafc87c5e4ffd732 778c965cca10b717561672bfc060967b2fe384af287d6238dbe861a79edc44dc 26c016f4cc610ce493358f638005e40d037b0a19132e32fc94cba2519402c405901c7b4fcbe7cd3eb6316cd5719bc601777f4c557c986652527499e47076d908 true +check_signature b1ec71fd60a6692a0f1baa311c2ac4ae6c139d3ed9c64b973a68d2da6c86fb8f c2719858b5464e8a504ee41e04d7eee6acffa76cbb90a8ef0bed7e4d5f35a20a d0762e61eb5f5be223727c9f09921f6ae9565f5f1a7c27cbadb155b12c62be148baab1f92711d4ed27bc50833e5412b482bab273f5c8f58235a2cbb362389f02 false +check_signature 433a8e21cb8f8b57762af362c918c130631196f9c4183b3a91ce33e9d499959d 2897cc662ee8c9e417d76d48d89f4d8d215501e66a16b0ebc87943ca78e8677b 08b2dba84365e85da84725b3ddd8d5c300d4f8a5a34616a78020a1d72c5d0f007b582199ebb8df38490124bc25f28bf241194339f667012115843bf48b135688 false +check_signature 2756f06a788bedba6006dfd04379ebc3bd0d582d9f3f09a8b51d0351689a6ae8 ad0af87cdbb4d718ebba9b4222e3198570e6c62347ad2d93b07c8f1145118996 b9bf218bf38bb4244d2d28a3dfcb337db1c62e9ef8064a9bef764fbf78600c0463b24cff39140df080d55cae39fec3bd44bc211e555dd1c55f75bd6bf7b5bd0a false +check_signature f079705ddc4e09271f0e7323bf14e536923f12cacc68a5676cad5684525b476a cdb54738adb6fe9148099e9442e6d8d13d8ac3012686305f6ad95329c8e8e0ac cc440eb7fc3ebaf02bbe0b3436a0ee67590f6411ce61e1ae9e7cc7d3a405d30123c3270ad0918a33c6a57b0c7e55f0234d1ebe6640c8fc1fb819f96232a84f09 true +check_signature 3e20a050ce64fee38ed8979c2b0f690d235ce690f103813b40a3bc1f29ceedc1 f3167ea992005396e9931985381fbefc67e3d66b0ef73b699293a35f821ec02d 59f538549df866a496fd555f9e59f8202ef993643a00dddac6f6bd5a1b88c25fdeee5d699cb45ec3f93b3038fae325c9c6a575110145c43645edf9d80670c51d false +check_signature 6a00678f3f2a650bda1796bca464567925f91bde38d1e1887a5ca7f29dbba8f2 0d7449f33f5fd47918247327550330ca692b102ec0e628550812e247088da82b f2af140135471023c98b2dcbdf9daa1b84663263c13733789f3d1355b9111c0bef4064090628de91b9e95c3029c533a25c11a91f5fa83a8e218f38b43d56d660 false +check_signature 639363f39eb2b6883ebc926217b973259215931d911bd33e86c0ac53aafb22be 10f549f06297140b5681bf73eb44c42394ff75bc2e3b49173c18e79a92726af6 be4f92482d575cb5d9ab67fa10754c70345f70827a779b80a7dd5dbcc41f620c53d624e2b9705b569a6229be96e420c4d070d06d56c01b1766bddbaa2165fa07 true +check_signature 96aed7dd2793632d0ad9a54272a35fee3c4cb67d1ebedcacee878d08dbe223ec 94539f512a6b0a40a9c174056472c6475a4ca8f27b91432c39172c4aa524167e 85b21922acb2fddfdb71da041de52998ff8ee3e1361655f6a67005368c6e9606596f64c5798cc06c3d5c4c1351161de34a0d87cf16c2bf8f5f32d39f1acdd88b false +check_signature 6a037fbc19a5147fa911dc59a15662726d1ffe7a7e146540402709660f66fec3 6688a35ce1255d48a52d8a0cb2100a9317fcc0f60487c91195982c1f4e655413 620098cdad1b7a4dff4836965288214340b5d65ec34b19d66e04f2e9ce9c2da72ff2e9108561e15345924ee91f5bc2e208ed6c8d36a001d71ead424256bb2e56 false +check_signature 4a5ed9977a6320a55f4be9a4a60c4472815d278d8df1202721d506b9be3dc2af 5499803d6648f943a79d41b356ad77b61165572c1e4f549d443928c44317fdd1 34256ba0c61511c499d183bf60b2a642165cdc79c6e442348b2b629dbd4b5f0bb2adb2302be2e6d7d16e3253d0df388e9e33a4cbeec779d1b3f73a3d8d4a690a true +check_signature e19770d985d938aa858d896128930c6ee52deef4d5f5be45c49d6fd9e2c11ac6 fb98c7bb2a3e8d4a1e13bd122ef24dc01bdd45ff4a3ad855344c1b33343d751e ca272544b301911be7adc9f6bd9ed629b9be4fdbbeef086c05c13c98b588860dc61a171451dafe56ce8d38a853eb4f0ec93eebcd7f77463c8c2531391ad81a03 false +check_signature 3ed2ed5b3b45a4d0a59969c9187b06fbfe8316ed487feac4a72f855f079fc1c5 7046789264e8d4d928cfad5205e694fe5ad0ee20df1e55b3af06d065b39a7065 1567aacfaf81d7e4c0f4ae3ff8a7ecbbc89ee1ff9e365cd1bcda3ebc09f8d39cba251ea4cbaa9065fae3b55171db7e209e3f3ad2acaf305e93bb7769c117310f false +check_signature e43572c933af5343ffb324b49a87c8ea0a94268a646004e6d9885df10983f1a0 37f9d94703817d873a0d50b19ece6bc74e0f4863896be36a5b557391703b4daf ce0356e38f8f0b446dc026e59c5771d729c3d9a5bb6cea1a4649a94c34aba601d8b91922a0f59612ada34b90500e56a850dc6282abcc8b150f4e4830c44d5f00 false +check_signature bc1a581b1164d003423d8618bd1bfaf042a25f1f18253b485832f1e469aba442 ebc4601a73117c82e756501d07e0d0be6d92e9c746b060a47af10537ffdfae91 59aeda87c1c8a9454670a8cf459f8ed69842e131d8e6ca8520c69bfe2d14b30fd69da24b5fc8dd7db7829766fe9bd6a82d0e358c50f4011c867dc08b687df56f false +check_signature 7e7ba15ddbda300b12a46aa785cc339ef67002dfb34fe52e6019d60ac459c571 9cb14f8c7a5d5dc16c7de7e133d295806a65171d9ca5a5c3b4b5542b32a2773e 7b2417ae7caf5aaf2d49c9ed017c27e9c61d634205f652e652501f3adecf7f02e9b173b19120a5920b89f34be3ef2e7231965ef5234d0117ab2e5b9ea11cf200 false +check_signature a20acea3cbe398ead45b7b7ceea687726db18c3e6c8da9b87ec76f2a3c83e3bc 20a1ed7a1bb52f457e1cc42b7eecff1c7eeca3a17e5b44ce4967143d4a9931d1 7865137321585245c4197719c055db4969fa6662a5aa567ec85f62417b60ec01545eeb1195c6d8dca4a26b1936d3573a70100c6ce18a80f44ebd9e1fc3fd3fa1 false +check_signature 7406b11847d065ee1dba08124065227ddb17b147da2dc5d4aac1ecd2e5666d95 bd54b94d54a404ca3189d40eeaaf0be4718d7a0d62445c1817ca95f3cded7171 b97082fcc9e30fcdff2a0be2886cd01d436756be1fc7c059138a0bb97d91ff0f042c608e25047519178701d4e0d3506a638125c118eae8bc589a88111419d80f true +check_signature be3d39d27f0f15af686172316b393f791ecab3aab5b60ab71a42b8ac8b33c492 d7e99fe323c46f3748222f705eff1e9a460d858c731a755b759f541d87820723 4f54620e2d2894682d4055e1c58f096574215fec1d51be889c95fa0290d1f585d045a2e42f05ad80c6074637a2f263744f21c495239a2061b6c3795bfd51541c false +check_signature 28308c178019b1b14ee667db75f8c58aa93b357610884e1d452de4b2a1e4b29f 9b6bbea8cc319424aabd8d0b4f61eeab0db02c81f462a6d04b3b39bd101de3f1 ba8dc0995177c85aecd104ba9f83334cb59635a153d8969a9115454a82f525b1cb816d28e0b71f76af4f92c1ae7e9601ad654dfafebd98a6f756d36b6d2b7305 false +check_signature 74faf838d4def6fd4311dfd5c5fd5edbdce6ff276bb753ac264919e4179f4d7b e3f145e15296d9b7ae4fd026d28ff6f529ef3fd152d1a207f079e0693789e198 bcbcdfddfec8ee641a3227a2fae14962404761d1ff40cd803108bc3fce6ec982982890615bb39f8bbb1dd085670daff7abb903cf1258e5fd62ef2be907009b0e false +check_signature 95d3f921684095f4cb05efaf18d3cd97101f589df8283a6b8dae4983cd5da19b 8b8e44026120c9b58fe7d38f45d12c6e5a30bd83e0250617c1bb71b6b20c7cde 853d2c9371d9dd117798e6358ab009496dcdabae8ee449835a3064ecc86b2c32598b0c41670b101ed8db7ccdfee5f3fbe0abb7a8537d5db7e425e8d53292cf0c false +check_signature 8ad45ceb3c0b908dd7022ab95df9f8da2611cec5e45cda45885b3e8afe4496c3 f5a49fc28445bed8eb1653e8e32bfd7fcc1d3d72c658d03e595b9580eb22314c 0fd5f0fed3c0f005c2b5f2b26ad6338e2c98877c63578bc2adf06e7933312f074c4edd41ddee4f8a3fa485906ae0c696d29506b7f781cea26ceef76149013e09 true +check_signature 4eeef937cd12e45f720c025981ec5445e4932cc8a8d6dc29e4244cae4b6a1054 1a59fe64b9b48c8d801a8d7daac8b43272019f1481d0e80069ebc873a822f8e0 ba3daacc80beff4da1779560cc70b6528dca714f6101ddadfdef16b2d70d9f05a397747fad2fac978b728a9fdf741ca3aa91255e15c2c39321776032171a000e false +check_signature 0523eb1843ea83dd419088cd0f9f7fbb7f84582117faad32894692c545a5d9cd e6c39c733e49cabc970fcb00cb98e172d5f40c8c55c7b22a70b640daadcfc30d f6c34668fd657b34c33635514cb9b0bd520866be8a31b89d83f316a18f47fcf3d9888f28b58b99eb6d5c22b8493241e285092f1cc8057d8b7ba21769852d99d7 false +check_signature 7a524ecbc6c385cd2fc75f0044f52e3db712419037a1b177cd3d58bdb4fbb537 4f0aac80f921741c1d25fcb07cf76a19bc2ecd62ac1f8dd4e7db68f16162e925 42a00ab4a85615cc5b6b0372d240423f29515d7eecc1a7ec7d67e6372445a194c626ee99f2b51b25c0986fec3b4caeafd27781578067c3fbd73dd005b9c86507 false +check_signature 1ced369bbaaf6801538573c0deffd89971fcce79563bcd03aa9c6a7dcfc745ff adf3e158773def49256ed68688a1e2ccc68e32f9870bcdd62577a1d56b27581c 433a1bc923e8632baef870c6d8941644abf53bfb9e08167daa1edf44df766d0a0daf428a33c2ddad7620f5ee313217c3acee8b452c9329801629eeab0f2bab07 true +check_signature bbb98eca82f8536cdfc26d14706ac5e45928603c6a7b2cdfac6d9b41147a30a2 d66ad4670027917fa181ec2e8f56ce7ce28180e3b0873098a984353b849c32b4 66f9b514efc585ef9fe6aa88dfc9f2b905f02d8077b227d3f868ab0ba5112c0e667b615d57024230da36e90752ed3309c96ef3a955fd00ccfb45b19bb3489c0f false +check_signature ac2016c0bfc27f9d43bc85af4530002c329a6e95bec30e9f782051331621e833 88240ae12a598117f6a1ddbbd3948a0207332def11b9d3746fbca973386f9ab3 c68c0bfc3b106fe4299d6122025b5cba60e56291e3f33726c65f7041068b018bea5f4ba0909c41b6f3a9124d8eea7bebd86415c545d7a4ae999fb4cf3dbf3303 false +check_signature d40f448fc22db6c2615edab6289f83cc460867630971663cc914ec053f996204 888206fb94f8265b309376dbaa319c43c0c15cc6724c31a28daec7e090d899b3 2d2f6846f5b57d73734114082c1563a713499398ed0bb73feca5cb751c6ee97c98d2899a742101e44c7e0b4d1a087b55c5fcc600075ea5dd4d069b534846da0b false +check_signature 0844348a6ef1432c66bc1cbe17e704f0731df64fc1b6b9a18c70d66a50aacf34 7cb82aaa315e6c2ccef05857b3ac1b247c51fc9ba5912168a43b014977e6308d 84deab32195503c9437d6d8a14c3c6a4f827be2da0b48c20c1d3c305c491bf0e55d3c32b3310b8f1b6532fd6070870188c269c0bee466f8703214b3a7c29a108 true +check_signature c1a85051f34d30fa95e69da6be3d7ad6b16a1827aebd4947e2c86200e7f3f676 7d351cef3ff3dc6e74bf50cb27bb024fc9e8597077646148e571fa94e5c0717a c1f70a06d2fa41a29addc7cf2caef8b5be767665e5b2aa430028ea89751b7825d3c0abaa6ba2dc20782110cce11e1c11ef69485473b2a970c1484997c6884f0d false +check_signature 0021bddd9143ad3c2c56153067d546a16bf66805232d90967eca6ccf5d674046 51b3e601b8b7c50630c62afb30957fb8bc9166e41f520bc3122cc17b6fbac027 61e60a37897756554f1a045a70224c56e46a6c93bbc3e7c55ca9dc9931362305671ef02a5f9da85c7a0eefbc375aed0d87b8ff6c368f8c32f6698d6da2fba00e false +check_signature 7d3ca1d2f3084fa214f6408213b3db5aa80cfb9ae29e15477954d14286c94ae5 240260111fa149e10c83c9a26245a55967bf3f73b3aceb646fed504340eac25f 8fa6134c0d5a08bdbb696a312f3a90ce8daf1f21a07a7c43adfaaacf6288870ce67b51d210909025182d1e835a5961c7450a20eac847471a60ce5b6a56092701 true +check_signature 510b9ca705c991e49ece419ceeb1352351f3afe603cf069d64c5d1352ef9e6f3 dca77388a384eee03da84c393f3d3efa56452e7d43a143a33073f288bf31b79e 13d9eee35d231bea513b65f375d8154ff24519613b2bbc3049dc1c4fd7d59e0a2950823f9c87c52c5d97f134bb13b6bf698c960af76cf1b3c1afd167cc86e400 true +check_signature 9134660972dc2b9f0654f583f68c9ca537b483d6a3f66bc14e7564caf9912e91 36779c04c987749895bf28dc54b648430e4f731ea05d355325355b164ae114fd a305964b6d3d74f2982eac189e9c098e3f9f24e2fef6f2d4a8192491312ac4813298c2f92ee9932414f56f1b312bb9a8e3095c3e9355c32ad8d30abfe48c550a false +check_signature 87f9cd64a66c0f7583a923a69f5a29296c53b6d6a120a521775372e3c43bf2e8 77418b2de805a507e5fd4a6b92930b62a87c93b4410981da3840096acde4bdd0 1dbe47acbd9c7b2d39cf97d0f55931b5645320f2af81530716c84f9e79f40406ada5ba1a7333ab2e944819aab3c4f583b327e8ed6edbf0c4d0c62013ff231a0f true +check_signature 7caf9dfd123d3b7f35815733b8ad9412cb857d3344de307be5292246d5a0a83e 70997ca3b57fc2b9dfe2e03728b1a36bf82012f16870aa9ce7e8941aa0321238 7acffaefa96b5a11e199ebe7563953f669f71f75b52ba90fd8f630823ed01b039c8c2e1e44bdfa3950b50408ae56ef140ee17846e9554d5521962d0e84ebc103 true +check_signature 61ecd41232521b96f8608d1f79cd2f3717261d545679e109ba3329a6065b76f9 2d0b4d92e33e3376a917ad3e0fcb6afcd72bf913eecbf8188b5c40eae7a6c434 c283a32062ad92361d1a1d9ae0b0af7ba4b4ef14d5f58e507041925a4bad2c02782dec4765c8f63cec36eb54876928ede86646a0ff642c548bccc9d437be7308 true +check_signature 4113eeadfcae3ed76e5bd0745a6f1cd21e41a6b67af4076ac091accc61b868c8 bc18187850dfe341bb1a1bb57c2c5e15bfd69cb9d86ccf45e0ebf00ee055c6a8 d8d8e751cb116f51b8409bbd98a1701f30ad93ed72b25d855f3cf4d807741005c18335322fc0dffc1210c7a1b2abfd848dd9ec5176d6be6ad8cfa0b1b8d2a60d true +check_signature 9f97ee8124f7c1f9d7af26bd2a4efe0d88def5181e4e7d3b611b8666a08b4812 b169761070e57b71f0730282741107d1378d63707b4f397e1e145f6114c9c94d 76b7f7bfe52464c2e8be682e023f15ecb48c143f7253e8e1f9574be5085d3571f0a2379da778765da56719c163906c4b69efcecafa89816e4237ceb202cd1e01 false +check_signature 719123201745249e69c9f8e13c5718baada1ddcac892c4556f09bcb960659a85 4ff9f5c18f8d78d37c08fab9189720b7f23f6f4c54f470abaf358ff5b29b8212 a0c895db6a8566d5d6cf8f1d8f05b3aae278640f0b2640f034755679e8b77b09214736213fbc21f3433535f7686051522f3b6f4462471d5f6d05924370d57089 false +check_signature 6787e5801dfc90f5e55c9902d44d41608a5a3c12216e138997015da84d95f18a b982af583f4d730dc8679e5b1e3029b0ba030c2b592b731429116f1a0c639d62 0e2dbef41b760610b4a92ac3971c08afad4751103c63691881233baf0df6ce06bcc26df38ff0391a4ae6efa13dd6e256dfc6c796d867ed103a7e77dcda328404 true +check_signature 53b8e357051a9d0316fc7abcf5e599a0ad08420621bb597bc74a5fb02699ca50 772b61f9f0bcea161629583547b5e834c056f03a32318abc54240c2c763f6ab9 4fe6ed63dbe9a1476f31a3ccc345cd3286074c733f20c31462db29dcde75fe0e0af23addd19271458a650fb5f23c78d2bf81406d26796a64d603866ff8ddad07 false +check_signature c5f216bbe95c0fecf308350aaed530fdcd1672c04dd13fc2e774a5600bbf8f46 f8d94a71fcec722075e44d5af946c4630f216cd511d7585ad4d6346d91704746 a566aee3df443d00e5eb3514a3a346066ee02e8e6ec2ff87ab3cc8a14d7a909ffd586c142c5640704ba5dd9736fc9a955404d2f52236dcb81f5b052e089e2b53 false +check_signature 1ff0c83fd5989e1290076b8ae5d70d286ec2579b64f9a8e844b5e371a3509ed0 07bd56206c84666d3657d06685efdc2ad10573276a7665d24accd6b5abb80ce0 92f98ac7070ab9a4612ad3d4cc40dd0790d14a11cf349c9f56099f3d2e307c0f025503352b31c19695d391c448c4c87f4909aed4edac8708f21820d1cd1d0004 true +check_signature 5b2319a6bf1bbe6db7a643386f1da892778b7b83316e9a7752c81f82e619e771 436f5e10e2691488c966fdfbe8202ebe9d06e4862b9ca5da439cdc4f3abbddf4 3caf46141b04b4fd45b552971671edbb97a852d70ab4035f450604260196d80290270ad8792589393b99134c4e110925dabae3717e1add06ebe57468a069c50c true +check_signature 2aecd39a0e063f55d37917446369a253b5b935df269685030b8c65f790a9b986 74c1560dde2eed037a911439a56c9d82f5120fea8edcaed129f481f7a5d6071f 405b7cf09c8032f43f5c61e9c56d67371ba9988d991941a6bbad81448f2b394714a24acc6f8d1e0e8da23943ce29186593897387b671c2efd1c3d92ba1dd6bfb false +check_signature b92e994f80cd4994d2b717ff3608e6203501fffc2d6b89f41aa211db0d9945c0 51039f70b3d8127664f0bd069a3c6fdd80c96aa72431cf949b4b51f9bee648b5 292c9c15102eaae0bc20652bd703501783b42e385e8850a2e874303844045f09cf7d4f220ef49d05e38e3fae7ef83f41e32d62ef9ccc92323efcc2acdf9d0d0e false +check_signature d3d78fea6a242411d53171569f7346cf6ed8ee6460728933b87f21a2686b69fe 173424db7b62b7ceee310204b52d06a7431947504ff3804d4b7179c849c0a0f1 745eae4cdf34159aa3b2dcd28cd4975f326507f1ab92a7dd2983062e0002c40e64192a95e1eee6a861dca29ab8beb81aa081b4bc78b6a9fab1d6421e813a0804 false +check_signature aca1e90f0c64c9a87c8cac4ac1d19adcbd8786a6dc6f97e62cf99b5548c67393 c2045a337a2754c6020973c8d6528a57b813c3f81d9e019b6dfb18276ad2aa16 2575e061c1b37824a135c08705ed0046a8fcdd6e0baba3716d880f8992fdcc02f9553b201fc6e076c4a52ad934607dc4cf4846bb6562e2fc6c26c6771869e005 false +check_signature 20f9393d2eb3300995dda94bd17e626dee5d635d76f8da7964ad197dffeaf716 ea194e8c4364a7afc315ff8360b1b018cb05b05282cd89062111351ed28d90f6 f68e4247738f54699909ffba9be221015622e2c46c2f07f8deebe6c5549ea903b40ac1a7169e391a5598fbc9c61d962346248fcc4dac29c61fa8554970000705 false +check_signature 516090c021cd1507b6cdb91063125c8979a64c0d38ddd523709b19f6c1addba4 ff1838058698f74f0538815f9fc9ae190a0e0dc713e07d8a34e7a6b3736bfe0c 692ce34dc3bdd89fcaf4a0ddef55ce70307689ca66583b212b8eecf4fa38f900cbeb93aac6c636827a675c696386013adf1782465603964d65b0a6c2d6b0cfa9 false +check_signature 0bceffb5158e6ecb3c638929848c8174ff0642e0a1c260092ead2bd4fbb6202c 3f65527b7eaedc30c477b28a60b588083a2a010e05b1e02d61a40fd330b3b01b 5207b79cd2c8c2f8c14205c3fe3f0477bc1e46d4deea9e85eaeb9e6fd7fbbad0651173e5b3994caaecc8973825861a3c49920ce52d56a17d58553cbc8d9cf504 false +check_signature fc30ebbf82486e11c6fcd115b160b486d28386509534445485b58673616a5008 ffe115b07cd40d38d5381d88ccbefb475fc23d58816d4fdc8d9c6b436173d3b1 6dadcfb4ec53b630997c1e4e7a752b890fc4ae465677e919fe071f22128877023300617e75b5f60f18bb5c763e052619e088d28e3d84db3f2057e2ecd016d4b9 false +check_signature 0573e326dadf1e97a6f05c8c9dd2e13da3b3c9eac88a753edee29607e616a998 10b4bafb59416a754fa9b37d397897ab743109e0c3aeea942cfc01765e9bae08 b517727234fa41f442aceec15dd16813f03c36330358c625e475d5e1be80ac753221f2e25058ea1b8a7d2dad37c841a50c31fb0c15411abc1b8589f08941b409 false +check_signature 4a904a3417de52da1accf8cbe1c25945002e5e021f04eb9d156cb601ec850769 0e59c53365fecc338b319b42daad217f9c2771a985583cb44661e444906a36a2 46a50712b1e072cf125fda7a0faafafd1b573f797aa6b3e1db5bd9dd04df1301dadee712295dc46d076d9fdfd075b6dde8238f7b7925930030bb25f60bed6c06 true +check_signature 018b085ef6c660c2480ae8a9d4704714e327bb1bd4f0f90adc14d8ac7a55d6d4 9414d86e0a1045775f37df5f479996ada444b4fd1b77dfc55e62cf98bfa1a4e2 599e19a9ca9fb1a2c43f357cdffe2ecbfc2feb8e1f69a976c5e3cf94b740880bfae6d3f7c28db4fb3755a93593d7edc651ec68cf469ead07aba5ccd3aa7d2c00 true +check_signature 67118ef2e08f19c4d33016f4bf010214204fb51e09f414d3f7427fae240ccc26 62fbf65f08c8276069cb69b3fcb996963b648d64eacad5f0c3e59418d70dfa92 f053602afc18f3b0d5b417d4bf884d2fddcc9286455a953c41d4782f4b94a7057834d19970f72908de0a35798dc73730c68e3a3884985ef263367bb7ed752a0f false +check_signature 2b12bc854f97bd14a10bf8294442bd7f2e39966568843256cabbe82d25255d73 79e240ed801ed5bd2e022fe5c06514918f598665957eb8db17082162ab0afd8d c04cecce0a4995dd98039572ed4ac7c22396b5eee30c913950a8f8e03857af0d8f53f05843f5b72da42804ba0f483ac6c17fdce8956a40b93f5742132d6c4307 false +check_signature 32975f69a151fa4108aabc2e6beec4e03049ff44520b00c6d2b8ca437784fab4 ba0a4708d39f7a578423c449205e9d18ee8600e081ac4e8878efa2c1c1c22fb5 0ad080ff494929cf045bceee69556bcbe598b29aa537f95a9fdca9ec4782540202c945168bc9924b2a28d6f6f3ea24d76a591a2e9ede14c094f5f73ff662da07 false +check_signature ca62d4c926106fd83cf7f8bec37572a03ad594f1eca09df75357655824b1bd88 0737301e9163d3f1ebbda5353b4ea028801928fc5330087c103297d22419951c 0c6797afb37f5082cbe799d737f4f6f493f845585d76b0cb695a4d3bc6015975ad721fa41fbeebf10aa7fba8bfc0ebe27ee87dd26d92cc76010270d0311d6103 false +check_signature 36ea668736eb1d402314a348d43abd0d1b5fe88c06bf573c61175cd4da5e9477 db66dbe8ae8397638c679f1b40ec10885f2dfea67ed49f98dfc85516dfe0318a 342e16740a75758e52625a6398387c4d62a1987aac33349fce028166af14cfb104312f6d673e1b3e133696b0c70d579953f43350a134d797329087dab472cb05 false +check_signature 4e5573a386a9a2b2cce17462b8547ec708d0e57b5042e8ad69f3938babf9775a d792c8cafc5b202a6d2d94e96393f2c849a9b1378f7a4f789c18053cb07baf61 65f0c0584ec7a56a5c1ecb526689d9e4611d7daaed40385ca34b3805c2b2630f8f570384955ed986052bd1f44eba70b7fb5e54ca7e87cd579ce300d03c7fe102 true +check_signature fc8d823e668091a5657de32029145f5238f0c19ffe3c9c1a2da400bb437d2668 421f735cd674cf2b79e8935545e737d31b3b86854057c712d0906f84f9dca7f9 c670cdbb6abd8a0414594a55e9b11660c86a4cf6f01ab44f626ba3dda777f303cbf1d16203c08d372f012c50bb36488e6582516267533a0e2fb7b05e67213104 true +check_signature a347ddec6f8efa7120e0e44c3d587d53316736fd7a02764cbb3b10d8ec59d8fb 041914c8d6e7751275cc0ff90214a14328857a3c1ee86300e2221e17b968e733 6a4c277c4eabd27b98af3d0c33f091cac09cbeb4d372aa26ec401b177721150daf5b9c7f3bf63cad201d58c193bc3e7418f92b7c9e8f744f9f9a7a2e21858305 true +check_signature 7ca4246b253d931ac30556d22716650a5fe6e911a740cc62628373d841a84ebd 2facc0c761c7991605a07a9753b25152aa5659c58a2bc959ec4c0a87cc1347ee d87aa13897fa8c8b6fd8aa54c268f3626c333992b8a05373945822fd73530a0919602fba5d2e9d05b20d0267193a4d8aeddf4201be6dcbeb37eb09cfe32cf422 false +check_signature ac72908dcd8b31ff87655ea7627a7a09aacf926145696808b836b4f951cdf609 ed8e0fb70437aa0956c0736aa3ad017c0d43664841f4dcdd6490584652c4843a 5c5875447560d3d1bae622a1cc8e9df1907870e2d285b08ddafef37791d506e2873d51215754feef9584e905efadb61b9e0c479c39c986734ded4f6bc38d3a02 false +check_signature 2efed00675c631f7850ec6f7fec0dc5c82a88fa75e1327022f15bcaa5a6463bb a317c0afba9eaa59ba93b482115e807eea49ee909afe586bc9bce179181a6c2f 3d30bb18de461419dd828834ca3ab3abf01d5b243a4655a7b4c470ef039554c976d9dd2d341430352fbadb86e5e70746b7dff54f68c0cc1eb5b7d71e7a09a003 false +check_signature aabd4de484cc10ebb30f9c782e2c87207ee1a30c9fa4f06cdf0e1b39f536a521 200d95a2acf2220faf0725372889151e167c719b5ddb9fc8a1fdc3143158a48f 89331de995f103db60c211cd848a140507aeddbdf944fdaa61af6ad3f187ce081942b62637b7fba813771718825b0c05d4dbbe62d1628acc11673472cdd1670e true +check_signature dae573c0db0823eaec2e8656a366a798ed350b0eefe40c97ca6b879216edcd3f 855ee989b6a7f6dfc53ee0ececbf2bed0a87300d0352e027dbcb47f26972bfe7 c7573a12cfb6bdd5320208addede304034f3655ff8bf26e7ce39443a63cf2705d64cb32bb343f2fe5eac1dcce1415345c76bd5dba2ecb758c0cdd018f0669608 true +check_signature 703047959ccf6ca44bfa4b085d9398e3bcf22c9a11114f95cc3df86959962dbf 17c2924499b9c95139e5f97fb1d737f206230970a7a7878f6749c28caebe0a3f 54e1b263746d4189712b4f133110ad8d689768a4b6f93ea46647f6cabde9400cf4d4548cba89421680bf06c661da72a1ed083320cc0ffe323c673326a270500d false +check_signature e31740960594c975665951a195802c12b57c1ad1e68e8976af7bd347e8db009b 8f32d6bc976a555df48b6fa6a9c74ebc2d61bce2b8491d050e01aa30ac1963c5 647d28b262a8ec87ccf939fa7501b7e73d4444368eccbdf93e44ad7bf3901702542e55a1e88066207d4d8096c480f52c9f55cdd9be1b935adeab766b933d6a0a true +check_signature 1831e21a81fe9b64a54111b73969e0cc5684bad6e580a2b1f5543516130e04bf 4a826148f8464bfcb413e61332f780b7a6621ea3a5ab6978ad98b12ea5cfd9f3 cda193dbfafea942df343cd69a8a76d2d67c111d08e949e2dd0440594e47998502700a37c7fae108e98231b1e35d062cf3a3ccefc1fcd79f92deaca251301f0b false +check_signature 7a998dcead73bb08cf3e35c1ea25d8d1fe10e262cfb0b43b6157bb58483ce69d deb2bda07576d9dd5108d5936f88fb255499255f426cd03fec321ca8d8414429 f8b93ef5eefecae8bec85d73f0a960ef0deecbb0dca8ff475617d6f1dbf461e8c289b37f0e3ef1681f42b8f9f308ec21e7d1a709e5bd20b78e7ec67ece407f0f false +check_signature 6c2b79e65dc56b65aac8b40979929ce2ff4e11621d025b3ff998085b07718d1a 81a02f8d1b5e60bd0ab4e9c0f896ce9c6e106a71af442cb275489324e3a1fbd2 a9f4212df4c00e5aa2df986cc9fe2cc4e343bb84c70eca47c8559bbfb64ba40e9153b9ed2f59fd4362f9035c74faa8a51a5a15e0b0306fb067c15b1e4dacde0c true +check_signature 0716174c9571df2b5e8abdc4abd33cf249b2ded6478817ed5046e220634b5184 0c5d9a2efc2a8df3f85f3682a898f42be320685231478ab845ac89787a2f1447 0d7cc516d562b8d6f26acd85df32627902d168df8bd68c8237f2e5b441ef5f5dfdeebcc4114ee20bb337a074b38d2c40048a78a76786899c3cd00d76ada0bfa9 false +check_signature d9258d864d47b7e62d61f43a51906ca941d75e5fc2ea081a088fd6b58038f0dc 5acd4452e318a800a944b1a66d36485b31f883d1738919a240d753b5b5389750 f4e8a12ada40082a620e5863a133f09001a28d3f6f1e7ec30da4fecaef5f5f0d2ac68de86900910707af93d02ff2db86790e52a406a935cc752707c682e7087d false +check_signature 5b7bfeb2a11ab36820a129256fb38b892d7c9f93fe58aa56e2acdee6d307661d 136c1cb18286240e4628298c587444dc1a7073b05cce4a30fe6f52f38639fb52 bc9beee778e6b8d8f66d679e2e758fc1b0460903697c442368643fb574874f0cf465fbbab78b435cc948c44da100d24d8a378ebd05073a4d18c2d700e154488b false +check_signature 5f0e6ccfc3d42b25a2f7bbd1c980a22d93ff30f27e67954ddd36fa4f8d93600a a0522339cd67e6ec69a2cdeaede7120eb89e71a41d5e801472a99afdf4cc7f38 629467b56889f5ba36b59926f2a8f17ed9e315024fae3b66a89c25ddc958b30036ea09d5767a14947d331a5ea8bba4ef43781ec836355fb9f805def31fbbe905 true +check_signature 46e14766f33b8f5a139b1f2ddd25cd2eaeca79155f812bd24893dd3235493126 29bde47470d93fef83de4c533d0d63dea99f154a11188770e2b1682369e648c4 aa623ec054a48a5197e43a91ae2ba385f7b9197c6832fec4993954e9de23f45597a0fae456eb35faea9f6c81e2c47b44703a7bc9aa811c5afaa40a2a112c7fe7 false +check_signature aa528e584c692a1a096cd2821214fc264a362b91b807cd4da4be4d84af7e8b15 d53070a1c27c041b64bca96632a6b95a0f1e51462dc96df8eef8b25517775ee2 48933914d67a412c909410f4a4079195c627ccd9b7fb4099ef16c92a6a378e02e22b4c8586a2fe6f5559d4c275e567c3ce30fec03a7533713955c286d1a07e92 false +check_signature 31aaf4f393534312bd0516ff5c36f86209f942ac3cd11c34ba5f9bb00312bb63 eaae0888eec9227bab58e095da3a2b9ad6e6233cd053991dcf27d02581e04810 900a64437b9915c090e9f75f40b692a1d5907d998dbcb5440dd701163fcb3c08d843d6eeb26ea8037be47265352eff37282d5c820be7c22584a2fcd5fbbf460e false +check_signature 6e34b4ffb422f79d6c338e79a33e5350b5419432db7890174dc273b4f6533663 b6bff833bd56a8ad69d3cc357facb36e7be5b86654b9e4bd04660d89f84a4382 0765c7dcf0dc5f7998952d05637def4ad9e360e108d5601553551e5c0968cd094b05ec64d3241ea7d2409136ea04681ab6971cc3234d43045a04a67142a57c08 false +check_signature d46eec1d07477c9153ae0dcbd02df66aa1af9ac5e5f8c01f4ee6693b2a23cb83 b21e8af422090a68a07c852243348e2dc84a887b7b32a21b576dffa2b8407a07 c36be2466d40e67064b5539975dd23795b218ff7fdc5bb462bac29a70e2110021b2ad0dbd890f025800bafed093d9b7236dd4b1cd3bfc460f02960ac0ff6c30f true +check_signature 442fd8d7919424e2c783e0e768eaab9db91c53b6a0209023e60e829116db45ff 30c7a55d59ad174442c159068b14c61ad030ad6131e79a38597c6df369f25c8d ee9b7f92bce29cdb151eda4f5007e1a22bf2208fc89d1dae21e0b4924ab6a4e263298d7c74d586721ddb8d391ee97b93ce658113f4b4dfef434905e0356eebff false +check_signature 8445c00b42d7c748593ad8c1e165856744e9eea8e4082089b9dca2c8547f7b41 b82c10a811d3bfcf7d6b3dbb3e9eb7df476a91415264625c347c5d5bb5fe5a4c dc6fe8512f5aa05d0f77d8b94946344571fc9778c835342a8fdd305c3db62a0de7ba6fc8cd98c96db954206d2c3199adfea14f08a14a9d6be5a8657c892cf706 false +check_signature cfb52876897295009069db931172e543ebdc192993d3d54f36912799e73417a5 f97dd70ddd52c5b05576c01850081afd17f65499c5ed9adc3a313b0435449ff2 6e14e5455c1e8d7c3552e6c852b21ac6306a1fa0046e7c644134f8733359e3009382194bbeac02cecbc0aca2050640f097f0924a67dc309adfea3364d40e7b14 false +check_signature 07b95304778c1e03548fbed71b8395c7f8127327251dd66766fda9bf49aeacaa d17e4953f7e9c9be86274eb248103c0a54ffdd139add40fc0638ba651d87dda8 11c2d697c41cdfd4f9aba6c40b88483e72b4f1d5e2b9588a6c4b5942f6a4c03407ceb6a66254e67d9daad7a5f81f6bf99406e9c6a32dcf8ba58df81e96316838 false +check_signature 6e24959c30258fdad3b7a9f514f2a1ecae92030c3088c6b8759f714e85ffe445 6bc04499b62bfb06d3c3961f874b47d26aca919701b4f0108db59fe743f30071 dca27a6dc58f7212ff838ddce80f5e00705badee055914509a323100644ae40e7cc3e47366866625ccc44bf30d476584d8720317c8691be8607f0a9a236efc01 true +check_signature f39797202e133eee0a50e41d386e70bd66cb6af52c45b57542f6fc08e04c9969 6e6840e9593a5fcc448c26a497c5ccafbc7be03fc15b16452a4b10415644bcb1 e7be1872a651e36a73e3a12870d257ec8b7bf88705262bc38533c3be08fde80c910f17a07447742c12b26030b6fd7323a38cf6ad4a87caae940db8a612a92fd0 false +check_signature 92da4215c2caa7cc731c729a8a1f1a8d04c042e337aaf8e4799dcc5b67ed5ed2 2ebe6084ed33bcca9419882b9b749b01382c4608e5f3de62077885025a9046e5 5926d40d0d571f29a2d4b7f523f8a3216248e1bedd0e9d2f5e3f4ca00b631400c6b1f97a3a0b2bf101d7331898ee81dd47cbeb5363acff9eda019a80179f97c0 false +check_signature edf10c36f121a1bbb0e789ed78832cce26192e9d9ea47837ce8e4148be3e1e52 ad8c129daa918d3b990bb0c1eb95825c954c2d4d6ded5972b0875a4f3f43ad56 c95dacbfe1b1f4334a7966493ce2321d3ce5e2ef42f2494b99a69f4c350cef03b23df838a6945e3589402087f92e14178e10ecc61eaeb8b3aab5fa6b8bf9cd03 false +check_signature c9519eda2a98a0e959929542fe7f55d14566d0cfb8f977482e991abce18618dc fbb76ff0b8e25f970f4750e59b6d1ff36d5cbf8b8c334f9466433efe3ddfb850 06059c70db398e68cf2ee192d753b695e90e744953ccc70e98119c78bc23c03a93250b0c03ba84375c724305013e2db842c84749e0934febd588db840e467b04 false +check_signature eee7aa48f2d06f6db4a6e44ef82421f82873695f82443f39b530361dd850631c 46c1086c8ae73be3b8534295da535b7dab5c57c62feccc28792a0a593ad8adf5 b7b892fd5bb31a91ae26d9776ded2622489d55a5e1e68bf561243100b22392d5ea4029ba2fb2f96b65fb91e6cb374a0111ba2c4756b54ae2b00ab5f060a0f304 false +check_signature a32e30e3f7062c621e97aeb10ebee9e7bfb04b8af45e48f2391eb824bf4ad13e 5f90b0273c643370ce8e514adb804dbbd3d44ebbd0fbeec5dae34fcd739c8b42 e7128f717605c3f7a8d07ee72523fac23fab613dc92904253272a15b01598aa3795faebed7bf73636ec5a17a0fd22bda2d2bee1f0533b7c4e25dc48f2bf0df00 false +check_signature bd86885a2b1475a3266824b92599c2d8a2ceff81d83237d8f197f98be026f6f8 afd8a92ec4a6a4102c3b6dd98603565b2272b516c842028812515af8ceb349dc 86dfbcb27f5fb1f8796347336f6f0a54198053c8b859ca14de965bb2c302858a9b7367f6cec1545d11ee1f586ddd07bfb3fabfda051a6665aa6391dd5f9d668d false +check_signature a330d23ebc423abf20b2e18addfcbe9035f6bcfc1bc82e3158f0ca462780ce7b 1309ac5c8d08759e2ff88da76e904f9f657920623b0565d4ffa04fefc45cde1a 0806e345e61e87ab50c0549a9e61d3a7a470cd9c094eed4333549743a4479104da757ef71425fb5b49374c3028e43ec48861012537a8a4483844402f443fd407 true +check_signature f4fed1f787da34c0bcc968dfde865027a097037ac67d9c5b721c00fb211db10a 7a8cd988b3a0c8510175acb5e67a77a96d0e162972e7ea39a27033c6836852f1 7e12e3f564c7989b8f2ac2c2b7ab96e3dcbc3e31289ce9290747cfa1160cb0024effcde71c36e1fa06545bc46bbc8f6ee6e9a97186e39e8ae7636341eb7dbc03 false +check_signature 68c816939b24d1ad3a1d68609926ad21ba67dba9ec76fd0755713198dd331ba0 3f81db6c4202c1f284eed2ec32d978c6e7bcdaa1d8b0d5374aa6751a70477c4d 5be4c748df7b31d8a0c19fe25074d5934c58623db55f2caa1311ca0f8963290f4dc22778ee17ca235e9a27bfc798e4b99e9aeaa528691b512c29a6e79be36f68 false +check_signature 9e6ed3018b30ada3e60e52ddc9fcc2e1fb1a4b3f86ba0ffc87fc4cff1c993b14 3cda562b4fcd94dd0dc96d9a9e6668cd340a36461d4fbc7c64e1a73d0c9a8f3d 167ce086e95ef702bdbcdd1735f56a77eeac9523adb88c125979f5e48f40750692e19a38cef61d45959ea748ccc92c9d6f633710b73d1fc0cb958c6066512c0b true +check_signature db5300ed1f9662cd239ed1d6893fdde02e65e501d84d2801c87c404ede70c1e1 4b09badc8bea8c631c220bf1bfbd62073724f74351cfef7fe840e2ca328fae4d c3495a5839b26f06056e08f74db2702fa188164cfebd4210624d73cdc8dc2d390637d21b0ac59ddc9e140c95cfa43d5b7f7268b5ba3b3bac0739115da2732cda false +check_signature 9f160db33d08b02a29822aa9542db4afaaa1fb74def8f6994571ba20a17b2e71 bcdb4cd4180c2a519da7f647feca1f251985fe9c207ff56b59a77f5b08baccf5 0f149bde885ce100a45345f09cf56e56916bc086de7ffe5edadbe6e2bcf35a094fa9618b889a84252b8b07328c7fdae99ee6f422e677146ae2812ed023145e07 false +check_signature 94a2ac7eab19478c5159a14384c484e0bbb4eecb775940f6ac978166ba71f92a 6b936516032476a1c75af4a689a48d12f0c5a225d95103f6c934db78b5b3547a 8f604d23984172d29cda49301a66a6e2ed937c5b9b70ca18b60d93200c4df10900082e78272a1ed6769907620d6dd83b31a73370eafc383aa4eee139343a5003 false +check_signature 0b5525c578131ca8912dca3654e6e6e825fc94dd8d8da4f96f893500a7c33f6e 57062d0cb37b6f560829c2ae9a5ca605775e5d22a9c9d452ffd4a3f8536e7cf5 620b58665e733e85d8c7f56a25515255aa4e9dde412cce8262572c3bd8d00c0a88c077ac3a769d5429946ea45d2077f6ecd2fe1348e9d56d608494a093beab04 true +check_signature be1296671116ab5a79a000310a853882f4b03b6e5842329bf3757c3449cea112 37c297f070c2c1f2cca8642b1cbc24abc744bcd4d67aa9c13c77e7403302a400 0cde2c401598f7237300ad31b9eae6bc944d05bfa3b360fbcaa74dd768ea0d0e21fcaa7c9c0a4261323b6d7dccb7808835678a3dc74d82ab8aea59cda5e0290c true +check_signature 8c5ec044ee5320fa9ea15c5e52aab4dddd224854e65366f083747fb0a1bbb727 9fcb4041d0e6aec5bbc3be01cadb5a247a30e349d34d97a8622bbf5d0d26d950 d9fa68d9540d180588505fe73ee55ab4b822b65c302f5395855aec50963b7601d25cd997d1a0d3a657cd5769427dd97b19258eb6abccd2b5faaebfa4be2974d9 false +check_signature 976a5ccd4043e9e88b64c0eda357a5ebe5e3e512b6044c4d99dbc3799419be7a 761bf2b2370f964ad55e7e7d35d35b7d32b3d82aee4fee5ce14b79117f016d64 c789b4330e619fb999f29b1babcbce37e697d803b7c2961f6e8e8c92eba5bc06db5f66ae47c4f5c543391583f70019b33d5cac7679a8effe935be40802e25c0d true +check_signature 481aff81b2b83105da725372d389517d8b99b2aa57799ede98b2047a5ec17c2c 0de8c958a2a50daaf409ef50096e86da4eaa0deab34943fdce415b66381b4a90 40d05b877c191183b8bee3ece402665d6b8f9dcc983bf937cd93f4a99319a60ad81fd050addec13258b3fda03f6ac151b70089fced22bbceb5e630fb8d052c16 false +check_signature bdc2e9b8ce1a4c5073de355c55ea3109984894c338779cec73530c9de1cc9c2c 77c94aa21599c24029e2f817b95f7c9960d3a0727acc4885d8582dd2b4c57fed 8e21f25d6dcd44439a19b7f5d6dfc1bc115874823ace28754068593b48e506ab93548be7addbb69651e8487e96824588f41828081a5bbf11de0207c8ca319f62 false +check_signature 51748cf6fec82ff14face14bc36ad290af669b1cd8858041741cc33d8e009880 341cb549665bec4f8b71eab5d39d775ac45780689cdd1db264a36b20cb5e0f57 8e4a5623b21276ded58278a79a7ba17479d64f97b1586bb46d87529c4947c60faf4b954fc2faa41e9c32e97b85bbfb17908fbbe4b493e092c7893221fb29590a false +check_signature 8dbb10e2c198631e7016437d8f25f39d587d0df0e77ea4bb4a19165739404bc0 7a5fafe3f6237a6ef914890d38aa9cd585ff0b0ae190ba02823f3781a1f61ebb 187428caa114709beb653c7fffb7e9eb559c3bd61da346bac1209f38d584fe06fd25f1f3f76a538bea5000b565086b8b12cb6586202380488d40d9bf9a387b94 false +check_signature 43b8caf0ad1874f45bb154da508f0372cdc2c3cdc8e756899504fec7b0b9d05d a59f700fcf2987cc9c7767bcb474e0c7e5fff28a683d3f1f85273f4d4a2f4dcf 3ab24c6d97593664449733c413b823a1ad8e6e0bc71be00ac234d50f5e11182cb69bd82487ff43a3fc6b126763cb88ae23d0669ab7136db39a25e8978b210d07 false +check_signature 32fbde8c3759bf5b650409a9c33d6b3d9b35508db301c30d5d2ae3425d47c10c e7ed702e8ebcd0fe71c4ab766b080aadb61f2d4059a7596ed0762d3c562a2a60 d95b992e7b21025d0ff1f1958d32036d799601ccebf13ee057f4eec935e9a9e65068829d2781ac0dc3901c67b4e222e00576dc660e578e70bf3f477ef8864b55 false +check_signature 962c3bffd53677300d440a3b6556ff7778cebb35d825d3143111536e80aac60b e8d591bf5450110e7d3483dcf8497dfb54edaad2654e610c1b81de6fe6cfca05 388ebece67ff9adb4a67b88023487d05c3057a8cca0251d6339f501cca3eaaa41bb07202d88060e75d98e7cecfc39106acf07b88eda01c262e4b04ddeaf7d203 false +check_signature 6be8926e24c67d0917a2d1f53f42db18427e53493195d95fce014b01fad6c0be 16bd8cbbae8da957e0f3dfcc9cf31363e3ec779371298321604005385cf9f8a5 f557c7fd783210ea79c5661d458107ce6513400a2bbbb28dd564fd73e1c4ac2e3eec023422e4c980869d9d9ce58c2783a5e07ae6f4c031f1a1da95a401fde9b0 false +check_signature 46179465725d8a6c073b98e3d2213d01a1fc20b0b02b55cdf624bb9629b29e98 db680a925c4594cfde8f0bd983531f051482643cbbe49ae99eeb1d60ba2a08e6 6feb9458c34581428bbb47eb282068c7687ecbc48671a8d5149b741ab484d30d1cb47a02e92059b12533eb06425cae313bbaa14e00251c0278e58b5bc3be73e9 false +check_signature 84b4358aaef2eea767b6e2eb6f82b983958f379285499811b03afa96f0ff9f25 a6d5db99a459a3559516aa599a8ffba446b789dc1f5f10bbd7155f1405d6359b e3e01fb3ab074f884cc02c06e5eaed23c73a909f1d42a929c0adea9c1017890a6a87ef25c605f66fecc8750af54e730128d7d13cf7e2a82a0510e0b661165009 true +check_signature 9b9f99eff0fb466635b9b5428dc60f2e8f7ae1a0412e63436275be26967a426a e0fcf004e5a857a7c010ca8f1731e5df45ad5ccc1019a081e8182b7be3c1bcf0 48e74c1ac2fb2fb6c09944a0b82d8ea3e1337223a923b009daea9b4b0f8f380ff14133983882adfcbf9fb2de0efa641057104bd7dda3ba7d293e5e04f48ffe00 true +check_signature 3e0c26f5d318b5937e7ce64cc529817fba17bd90461a475fd3c9c5cf4cdb274c 8e87d01a50450ad9eed52b9d42ab6cc05e02eeb35b5e1195d4744fc568f9cc3a 1806223ec5a5e77d20aaae12fa9c50bd6b23152401a7cb3eab731abbd540773c4852a4b7576e98abd157945291d0fffd6863625e0edbfa7d24cb91e278834b0a false +check_signature c0bb3e5d2683f7ed130ed0b612aeeb5db960b29de9674bfed5add3c9e3c6168e 89dc49a9f0c1e51ceba38780a58a1903ef8d06309492bbafc2061ff452ff5bb8 3d0715ae398ad1bc3f4b5b2fd793a1b5136750d75e71bb5ef7abd7a8f3077b02b6bcdd6e19935dc6bfa04c5ec6bc0accb521e06c2ac32a7094fdc82aac2cfdb3 false +check_signature dfbfd2afb2a611d5f1400f7a52dba224029ae1f345f1e07dc640fa15eafc7307 4e1018481ad0de395c1c926b2236d281c3aa95d0ef396b52b7c6c61a40e6b7d6 37fdec353729648a07e240f0fdcc468df65a578c0f337fcebdf732768c0c4a0326ae06c0f078a43c8e935566798e039c32c71727fe20bd334c5dd3bcc747df0b false +check_signature 60c06b35d7fdcfdb228ff6f3e533d01b150d0939e8a1e6a13bd010bc0e047cca 85151cb17caeaa89caaff94a03408992c93134ba32eac64d7cfd89cad69fffef 512685cdfd298654dcd9c59ea9137a9bb52bb12efeb8af9bed7bab4f71d0bb030a0ebb9459cd2685155c3401f16b2d4479928a850ae2182ea357d9c9df4fa70a true +check_signature 5eb662f8076f6c3e3621ac0699593b8578eb181ffd8377b75d36f22036bcb3f4 0b423590e576f83486ba0d9ef99207d66074aad48e9791117c4cddc1673f9935 5ab3ac6284b47e60e6daf4bbc688fb80698e94379ba679d06a0389e30c888801c7430f5512dcdeee389fd86c24b7daca0dcefc628453a3d9a16dc6d295a68f6e false +check_signature 556572807a931c2128604cdb8fdd414b18ac3de8d65a6948b629df4c365ec571 595497eb52426eb087b9838204d2a5c1d47281beec602c60637e84196b053a3f 738f54815583cf89b799def50d85d2590e896826d68847f279b924f4f0d7590e80da50d3c89b1450d72f9329f0d2532e74042f1f87b4de3d5d06cb5a67ad700f false +check_signature 10a0df91796872d980789ea4078fec5cec9b0990cceb5f566ad8d59cfbecdf1b fcd0d9d5253c23917dacfc0895d1d870469815ffad14026e7e75481738e984f3 dbfeae65c7ada95e36406fa01cd0cf2f767dbc6c062a108c4026320bb334c130aa0fcb8af5d62f2ec0c3abd84d4706fa47c6148e8da633b5a13845eac1b78700 false +check_signature ce7a35f52f35795d6c1eb4e01c624c85b688a78d984c72849b358d60eba2d78e 0ed098d38a407652e60f24d6ce00e854c90aef88aec3d4c82f31c380237ebe70 41210e132b8287da697b5458b92383a27993c7add3086c01629d839994c550074329e83041ba9022aa71f3c6f65cafd1e7c4bd1b9797f821960cc813a21b375e false +check_signature 5088ef6f2153a4f1ce2ad274493830358343f3bdb4a54dc3718618ac1d7560fc 5a58fcb1ab2fa2e325d2d24901362d781507be9bdf0458addcd5f74e7aafbc4d 99e912c9513adda45e04036df6fb508d567e671cf49be3d032ab29b5804de70e67be571b84b24d154b1f50932e17ad23cac31c8640856b2076dcac590f3be31b false +check_signature 305b0d01519959e5fea54aa83117f59f5755187b2faea1d76f0d204bfbc692c0 f362fe9bf8eaa6b77b5ea46a145ba717d69438693b74b2aa8c53eda3ad6678ea 3f9f88c4104308d977f3e21f6844c2bf0fa65f2090a13efa2933158a693bf3e1c87ff69be84c86d867e43a50cfc46950a31fc7b3c8bf0d00ebc1d6160a76fb05 false +check_signature 4fe54d12e6c3cabc249415a10f5c1ef45eb8adab7dcd0215a1701d5cf362c9cc 01f14de28e674609225ff506c8f9fdbd408608c6d9ab8beadcc845cf5e4c8d7d a0406d540249d27c490c7ce15cf66feab416990fa0b81c6a8bbbf70b1b6c2e0bc67007fb581de7107487e1791aa7bff3cc4a79e609211e06214f1d05c9de5dde false +check_signature 51b32bc45478be6947c788d1b18f5b5d65494e27013afad1d288d94aa635ae12 47260522256f50dc07d3b0760b2c87b85364870db96f260154c016c6180917fe e1be5449429bec127df7fe4fa2db206cdf53be08014060d71b797516f2956206cdcdcf05181b8a9cc35c711b3634c5ba67ded6ebe971a24699506ec05dc9ea03 false +check_signature cf2dff8741a3a1ec23f0ab90958b0794010fa47e50ead239144db571c44482f7 2fe77e0e569b9efaf81a6bff4918842a8eb36d9d9b5a40f569573f8ca329a400 9e3da432cf3db477783375f0c6c4ff2aa558776cff47476619fdbe70dd479f0d1d039c4b005894c17e7900312d2572ce4e27c0ec0412832b547ce4dfce20b60e false +check_signature 68fbfc416fc1c81c4cc1afd2539eafba45a7047db760e43a003d254be508fe09 be1bf7420eea5bffd900da473b57dd6617d525af622beb3d58720325e2b3a0ac 04dacf4f3c8e3fd5c82859082067335d48d9378b93d9f6795f9482b0e60a914674b7a2721b6725672e2f94e0ac890d4653501262fdce200cac6dccccd271ec8f false +check_signature 07a13f9525a17f0b47f9aded518bba42e48cf5d2a3bde0f359534fab65659adb 9defb568ea53dbb7e3fe62aafad8caa4331c693e97891f8f17c56b1819f3532e 39526f6194387844493f7b8901feb25a02d9249d7821a71b4e7d66c27ca6507f5b24c4f2047650cea2f02ce464311884fea1ec3561aab3541efb75694fdafc94 false +check_signature aeb7d2b974574de4c0f3db1fc93d755f780c35d0764464162b30cdf1c8e466f5 33bcff428df9f9e6410c9202014824ec2a2289a97820a4348fc5e090d90b95fa d4158c2d6c413e9f2f2388303cc6e429cf17492b0383a33a75aae57b34cd1384fb51db0cf5a1a3606a56b7f603b9b89d978f0a2a10d63d10e6bdf51c50f4210e false +check_signature 9df6cc78ecd112da01166c2013afaa84d906570c44d0f6d571ad325754bea2f2 1d4086a13ed53d1547fa57e2574ba76bf7a4f5e9c7e833c72d79be92f63c9b42 aad7ecd3449f92eb32f4a19a01ff3ce5b968f2db45df84f96cadaa5914b4e5d9c7cb463a945d9c8e96c14c33fa1ee9e33a1a3d86c7440baa8636291f74b3300a false +check_signature 4e1443b22049a5bcbc62e0c20f8013825251664913125b6b591433c98afaa8f4 361159386bc69419268ae8173bb60a030f45292e4f43cf41dc7d949702040df8 ef5daffd6d1f8a9fdc2739e74790b92415e16c874fa5c49bc4e8510e0507c903be8ba340bf4396a61a13aed657fa218bd9835763976c24630bfdc2bf24611003 true +check_signature 4222fa87347badef06c877959e3a9b74794ce60c94474ae3c98de3fa6ca3d0c9 496a95b0ecc15c99e8430136285097f5829f7afa5a27f181d3d814e192292d95 a3143a82287b8cce81d2564a2d765d9b58d4fc3705c53e357a324d0029e0740f00f55f2fcb520be48be1d20b361e34d522ecd12fc10d7731c9ccad01ae149505 true +check_signature 2db4497de15d3ecb0d990c7ca310049bec73f288ae865a4254bcafcee7d08141 c980ce874f3f84b5b31190caf40b24d151ece78460dbe603d96c7727b1fdc490 cea430f572c7705f0e4a7fcd98db4f61fbb8db9c7a3656a831d8f1f9d2f463031b79b5d62d1aa602480881c50233f73ada40d396a20e72856ec3e8b4d9643a02 false +check_signature e7fdf00027f266bac366ba538e1f900d635f04ff95ab6f6e09d2875db7db42e9 2521921940246cb7e1f1aff9fb3db9965024d50eb833e4cb1cb9e381dd59f124 9f153e05ada1a28fc72b1d8cc570205b23665f4ff0737cac255c76a91593000770ba6d3320b8b4043afe1b77c0a3c6dd3d1f6cf855b748ff7c3cd0fc2c1622a4 false +check_signature 7a33b1f68d4c8d5334353b0d7c79a0454726cf9143d7ed48361163e1fa04c365 f0e5af64bea9c21ac669753d231649a6c2779662f12d08457f550028e287532b 18b67955a36af7890b502b4889fb6be31e69bd16e016ded3fdda14718dbf2204897d92fdd9c6e482da23149f0bab3ea50d75850678bf5edac33243dd072b960d true +check_signature a07a4e21253bf880c867ee40182194cda88350ff901e6f9cd7c4c62953709baf 4da13f551cef1069e0b1ce0eb3474d5ddc1e64c17042b6c578f88faafd95f95a cc04207bc2640c7d468f95e859ebf584f086d6ae06029092e65bddda804d6707cb01e475ee52d27c97eba424ee4240f2c2a0ae9ccc985bdc2d684b69d03afd03 false +check_signature 1952b0075742c2dc4c164aa3f4d0550d5ee748c27fba60bf9aa802c2b6bf9715 0c7ddb0b41296205a662a48097bba6d2f5992abb19cb7046561f6b749d441b67 bccf4cfe81d2037959e3ee11de599281038a08162eec90838a8403f062f92a79682e0317a9515bac75a810d9ddd9b1fca3132e186bd29c18f671d4ce8dfcb906 false +check_signature b2d7eb5d044c81c42f36696cdf411381fc4804182ddc55db2987ad4cada61c8d 8f9b4111bb7f5203ce78b5ee27e907b627a11a36f80f8ee1dc7939416a8a1e04 a431b46d5ca9ca41a6dcbefbc427ad3624b85c5b6ab88403be3b9efbe0d18d0320b1bab53daafdd7272c8494c5953441ef31907f11837125898dfc20f88a36fe false +check_signature 9c59340fcb9c9b37ddc5f18fa178df3548135e30b9147aa5efdd6fe6c2286ad7 f5be78453a0d5eac05cce4513b4a39d74ebf759f00043cdb759b0b732a01bec3 9a3172770772dca9ceb22987313c4f0b2a1d7dc8566f0041da3fa9d114308207c07e2aea608e04b2482f07212789f58012efef435eb1e739279fd291f6c6360f false +check_signature eb88c413548eb8924682cd7dfe1b66567a03f9c98d9f2eb272be1f1033c460e8 4dad20bd1b6771162262e4207060819add925f4b92825fae965118c6daac99a9 f52c7b612286b08c467d836581f0f08568c58c1f4c138b48937dcf107c039800936e9f583733e299bc07e8b69ef3c106c7d47f6ccea7d885fdf5e53bc3c52b43 false +check_signature 748fa65229e740c49868d1ffd72b0ecf2a38f6ded11ca3f8a8e636a26dbe2714 e6e4904cf87968010c9a4e3d9831c63b4c51badd0459f73ead063a220563d807 4cb64a56bbe2dde9e869506d34e3b3c3388c1f68540e1246b4563c722e86f8033ae66523851adf5ee50024954c5066fe67dbcc4b1aaa05793a6df7b31717f133 false +check_signature 24564f9558da8a47b74bdfb9f75386688386946e7d0752d68763985d8d62aa2b f8f93b439a2af5e7a1b3b22a10ba6ecba60a4f43193a3b3e12857ac14e89d996 eecc29671ae1f3936694a327c11f7d7ee4002250c2a735c767f9384705e41a082d0bb83e3800860f393de2924cbbfc40cf3f519120dae353571dd2e93286f231 false +check_signature 70edba484996d578afe80523b0ec15a07020e98899a4391146defb55551521bd e83ae828307340c439987f95445ca96dabf23cfd267c6e0a896935e7fbb4c9d0 28389cad85a826432be1a63d5b2ad367ed2b73488a3cfb3836127203c7726b09b9cd9775aa531a9586e11a836cd69c159fa1d3da7cce06443a4ebf90244d1902 false +check_signature c9ea2f365fa8d308e69d53419bba82c87e6e613bdc71ab60045fdf1d57f66c30 50934654502763c3874a8e456119274bf9ef0f8c21d2e78d033665c1e9fc13b2 f2b5b716e1a9ee7e0ed3e516c92f7f40afc92506f91baa9121923fc4f58fca0fba45944656a75423bf959497c3bb472dadf0b8b8f3cdfd34cc0c1d8e34ed510b true +check_signature ff19bee8705cf1a66ba5416bfb52f7269f0d015bfa2d5e1e8c81ef99f4174f7c 649477b801a5385cd7653834fc597a29507c7f2fde65de4ebae7edaab90dfee9 a813090183b3399a84afeeb8fcfb70e969891c4d3c2d91e45c0b1f27a3f38b58eec2ad32fcd408f6a96888595581f1ff381683f28f0120cde61d9b83c6e08503 false +check_signature be9c889bd9dd7e67512840992e205dc901e27f6d893b90d97d2abec372acc007 0e3b78b6c99cc2f6809869e07b11c814596fc6a42c66fa4c96758e713c09abad f6687db16d0fc8dfdf2991c44a34664a6c74f36e45f206eec007210bad745cb513db1e972bcaf27f5fdfbf2839bb1a4d279170d5476f0f4c8e05053112dae80d false +check_signature ca18a6ded48c9812698387c962e2ecb0294ef0f090b34281df94f50887abb50d 5d18b7f9d97e78bf7fc78dbf2c821bd6ebe7e471f2d37ab07d3795356ed98642 ecd9ecfd38388783d1f854ce7b039dc0925f9c7b3a5b31fe8bf83b8ddaf77d0403b8b967c5a74310626c3b5550c3ba10eb8f2fa50e938521d1ac9529b0cdcf02 true +check_signature 15a17382540b276d8d14235327a182e773ce2cacbf2420be6aa262a0823e3042 2bded0b6457b0a07671df903f30075ce545a0b32f7db4eed4f1f1aef874e8f71 c4c14248296c776da41eef54c79edd51326bbcf2f47cdcefd9a37db726aaea02fb4f331dec17f27501f1d34f02d3371000e902be65d83a140d3d61708bf6430d false +check_signature 37f1f0aed2c87bc73bf3c55eef293f14ea962f3b391d935f9b1f3e658d840166 4fb53c5aea9b35fe3ad4f01da473d389e2cd2fa4267dcf0d6ae3a96eac9e172c 1484664a1d652702c11aa7d0bc48ea2533ecf838ed4b051c9d1a6e878beb2a74c1316fdfec070b0a04ac5fd6f9c4323b2bc85ad018c14f925c270b93e1ad6a05 false +check_signature d081b11cf96d27799c2dcecdcfd57c7ea7ba3ec0e352d9eddffd3a429dd04b6c fe1e720038ebf0547f4f95f3e4cadcf9658d649a454fa9613344b00a87572a89 c3bde60ac4b18b35b953b5b7206b575af8bff02a34a6105baa1ded668f77d00560fcbddf7e1f00a1f26ade482025e55b0701d3b396c75bc9bee4c8912cbf6dd8 false +check_signature 6ce3c149c50318b940e14929940bf8e5bbf36d98b26f5d5a4be18954fbd9b529 41bc04037fad5296689ea05d32254ca4e9ba9f0010957ba89ef3b02cc08efae5 d276c625ebd3869898316ddceebb2deb5e83a3faa6f3dd865a5a25ee053eae009846797393ccfa759592e2af9815628f00ffbb16e5a0dbf7e76c5a3865ad0230 false +check_signature 510a7a19ed0b4605df1cb88b6cc36ca2dc926c58ee66bc21c32b281034ace642 6fd01a51372f8f70e3673e7cd7474f95dde138c46940caf5ca935b3c317a9c72 514ff38b0fbb1451f9a38c263df7f8a84f70540a2b24e44122a8bd3a8df0c1247c5f6aaeede7077ab643311bc57e8b29f9863ae8b6f920cb2826f9810a8eb301 false +check_signature 6b67fc75a5d30b54b7794482ee5f49d3abf95b1bdb322555034eec5c05b9069e 123ca7b6326fc2c6495dbd1bcde7a93306fdadb8f5b63a47d95bbdfabc594457 01c07283eb51d4cccfb84e71bab0b679be7a90ccb203f330d5720a70951cdcd4a595118a7d20613e29caf50e04646f49744165e894d49e3ac3524857022249b9 false +check_signature 66fa55ea31cce9fce2bbd6b412a0b457fcabcb01ac48dd8e38c96b1a7efdf6fc 603aab3508bb38d93b96dae2aebcf4d76beb78246f1d97e6f5343baeb7d5c513 c864b8d606410de83742074de871e0c73542e29c8d5244a52df5b9c5c0887d44263e01cad48c39175e4f9fadc6a5c3ff20916a39389826c8c623a3ec30e45103 false +check_signature a4b9dcb9b2adaab9f3290b12d16187cbc9f63e7287980b4c10724bd1ac096073 ed803b78c34956686dd3492fd414be5cd41b4026c08aa92a2ebc120cc1741a37 1a6484f1a961ca0b495f234f072ba69d49e543c12c924298e0ec3965823356d2437d0efe79903e60f069bc45c7ef02e5f8cfd73d21ffec24986c00cdf624a001 false +check_signature 0d56f36ad04fdd9092fc3c7bbbf44b79a08b78f0b6f8b54f2e3a9a1d32e5d179 6cdd24b6b94138c4dc28de51cdb29934a3113dd3b730a69769999f404bc568c4 ccf2ca4757e64a1b4837be8d6f56c7be6b9faeee5844b09a070223cb9b47b5ff79d6c18792a7dca908a16c253aed1c0c31db5d321ce8b5da85b5f87913d45608 false +hash_to_point 83efb774657700e37291f4b8dd10c839d1c739fd135c07a2fd7382334dafdd6a 2789ecbaf36e4fcb41c6157228001538b40ca379464b718d830c58caae7ea4ca +hash_to_point 5c380f98794ab7a9be7c2d3259b92772125ce93527be6a76210631fdd8001498 31a1feb4986d42e2137ae061ea031838d24fa523234954cf8860bcd42421ae94 +hash_to_point 4775d39f91a466262f0ccf21f5a7ee446f79a05448861e212be063a1063298f0 897b3589f29ea40e576a91506d9aeca4c05a494922a80de57276f4b40c0a98bc +hash_to_point e11135e56c57a95cf2e668183e91cfed3122e0bb80e833522d4dda335b57c8ff d52757c2bfdd30bf4137d66c087b07486643938c32d6aae0b88d20aa3c07c594 +hash_to_point 3f287e7e6cf6ef2ed9a8c7361e4ec96535f0df208ddee9a57ffb94d4afb94a93 e462eea6e7d404b0f1219076e3433c742a1641dbcc9146362c27d152c6175410 +hash_to_point a41c7e0b404c67b7cda969b102e539aebb7c55695ba1e4580621615460b85373 bb6efb51b4d847c5d1e03bfa68a624add0cf9923c57d78fd3c440845eb010007 +hash_to_point d7a3cb05a3846008cda1755b6d2f0d3b4ba3e2d1fddd098670d86ac58b4a6da4 bdfdf6e21eaaa082618d408e8c2da5485e5de7568dfb7908ff8399b056a8f709 +hash_to_point 21980724cff0a0aa58c720bf66e22c12fe6ca76b8abced48b51695d0a9929716 019bd0eb3215d19c8d69b9b1903418a9e38ad8a80b59eaa59621025fb5ab33b7 +hash_to_point 6ff28dc7e074be14c46f11f2cf19bae2ce82ba6e1b7152fd80ea1cd89cb11460 83b7abe8cda7a3716ae7170dd5d0e8e994574ad632ce71a7321dec93fc7d9748 +hash_to_point cbebf8589e79e38dc4b9da4986a24480d471fbe820f213d7059db91e94f06b4c bb926a656bb1cbba8ffb2e43cc22597496b342994c229d9a1f0ab7400a18ca47 +hash_to_point 8e88a4647a88d583e712c5de7725aaf99b667c35d71f9a155ddceb4535ba64b3 571fbb41ceb1caea8f43bd713fa9251019d8b70924ffa97cf98e8c795949405c +hash_to_point 5b1a391b8326adca88ea15f376a11bc801cd1a2cdc745aa5080951de5a532d2a 4cb9ff3e7055d42f1cf739fc22a57725d05f8e92aaf4f105a6f4419c9ccc0f54 +hash_to_point d71db4857bad8d104c940b44b3c0f701b77ac33bceb3430d5e8bf3d1855c5d8b 6d8e36e84bed370912adca091f25296201110a4745b5fe977c23d6f8bfdb5550 +hash_to_point f89a603f47360ee2b0db273f63eb012eaa8469b27ce12211c7dd3f6cf57f76d4 d33161d963bfe7934be5d38b880af91e9cea24b2ed287fd31c336e8f651a68ed +hash_to_point 2edfa0ae2c931f13ce8b9bb6ce07446ad95a52735dad1f3e2335f1aeedd6fdbe c2747f491527febd78065eb0dc440358074c20af18199d3443ca3862bad4a403 +hash_to_point 646022adcfd8365bd5d3394c622d5936678e1a335e7113a8a4a98d045ec0acac c653e3c8359b3f60c2d8c50f9869ea5de459908321696e228b2aefbf397445a2 +hash_to_point a780eb50f4ae405d09b4ecdada4a7a2235398ee9b8c17855ea14b42e410b3843 c85dde24690f374183fd8913dcac1cc7e1098246ad03a6678a97a09f73d730b9 +hash_to_point d50c5b9e90b00ad2a3d12f865937331eb8f1040ed035387eee4d5fa3d3f619c2 c8555cf0309eced0554a4fd6ea1298f19d6e4028198f82a7ce1d79db9892522a +hash_to_point 121d04463675f6eb9dba7aead37ef893ab63f9e31f4d57fa87edd9fae86928c5 d5051691bd5497ef82fa7904042e1191a28b4a37c63926ff35d07e900b9b8b0f +hash_to_point 036291b42946c45b627a83701184f7d41647779cf5475d39e029443be33acacc ccc370b8bd978dc2d096eede50271c16922994b97959a9bd0171aaf5d4eb981f +hash_to_point fff86285af4a9e8f777fb16723fea046207e0c5949934836acb43a36360ec7eb 98fc4d1c6077c21c2993bcd7abb0af6b4daaa4c2fdea13eb4cd5ad5f7ce0de6f +hash_to_point 7ed5a8182b8c79f553a101ef17df87dd45870821d53fbb00dd4d5b2a52f0effc 0ea13276d187cffa25955e3c49cf72244bbe8c1d3b72a1f5f0502139970f106e +hash_to_point 4c60069c56d10bb3edc4dfe98d73f39456d846d4139fd3adaffd198e5009bdda 2097cd5377111642d9d7b96980a316e5227a4ed0f989232d09f1268048282a6e +hash_to_point 176b82d6d68b0b906da1e992f5010f23b25d36112d8987d52e514ceeb8010e3d 3c8abee0fefa206c3631bf8c3208593afda93fa8a1ef75355ae05b3fe41c2749 +hash_to_point 72aa89d776c6bc7bd09385ac7e8112868f85025fa966bb5df65bbbd5c63a13c6 dfb5f593f9e78041c63f784e6db5f902d98ecfa3bd3668f8baa56062cc9e9e35 +hash_to_point abfb4aef4ed3277ddbcb0bf13fc54faa8e161ce9b58c625d4523fc050e67e991 746f5b282beda0f831a7cb453bc5727cfc70d01227a109fb26a62d06f09ade3e +hash_to_point 433ea849299a1e5f0ba7a47f2446104f892101945d4179e9048192bbc8f59af6 f647b5caf04c090bf1ed6261154ce7a50449e17fa1d547fe6c21b03b7eab73c5 +hash_to_point 1f295bde4a00978cdd63961c782c91dbd91729816ca9df28519b504c04893b1a 2c91d1f7dcc2d5574b4456b4e719da361d79e9643a95c35281a734250000b127 +hash_to_point 1a850011820eff7fc9a5644781ea03724455da1aea500aa6c87effe72de1034a 7f64606531bf1f011843793a89145f3157d6e8cc5dffd6d289f1b77b0ff38145 +hash_to_point 54bd98c746d28b7c9d1de0333ee07a263c4d9a3a0147da3c7b28dcf3e6a38bc2 438251faaec2c50a535011fafc8342924bfbc3d86896e5acbe2939fd3503fd6f +hash_to_point 61834c9ecb168cbd15817685e16b154916ddb7f89748f2155b023ac1159772d9 7b0b740a8fe9bbd523a9a3adf2c440b7d7eb6ab9e766cd666a42269f2c4d76fd +hash_to_point c9f2b10159f2c3dccf5f41a86f5ae3dbba2c98f61094652438181268a365c09c 54a8b18c11f206e24785c3bd484ca31a5f057f60be274192b0e65e8b4d312d19 +hash_to_point 178230e18c2a454c51bd69eab228a181e75d43d8be60039e35cd606e57d1a853 afeee169414e67181f57f4ad3bcddc6f7554ae38020fe2e11174a6bdc20412a6 +hash_to_point efe510ccc5f224a5b50c084c90029ca12eeb0ef01ef4698f247e1df771e9236d 82e11c8ab897d4bf0baef243c3f95d16d32c45bc9f13f358644c21e19d4cc0e2 +hash_to_point 1219cf4695194ace13c565b28368f15bbb56902d56eb895f586fc0eef910a5f6 412cd09d574f68e498741ada157a85336a60fe75fedd0892d111ce3cb6b2be4a +hash_to_point eda06e78625070db7323c2f2cb76054053a5e6dcde892b0fcfd19041872dc1ae 3d207eda1e309c4b8b8d5c273a29c864579ea2652da1fd2609aa14b6aefa3b23 +hash_to_point 9094e97036b69eaf668add6e179a06ccecb17036711a9c3bbb29beaf6d643ecb c10aad0c1e8c3706b79b5f82e75fc2280e02fc19603c8d1159961175e3e11a4c +hash_to_point 37b1800578f3ee0114136ef7e429102f664222df3003b549001948512b1cab3a 9e8254a67bdf36a4a20a3e6224a2c743b1736f5bcc8b821978ef1139d4354d31 +hash_to_point 4360a5b660eb2d326d6f69be216e351e34c497e9e44778e6ce359fbc98088522 4c1ae50ca34f1844239a9107ae4cd86ede2280a1b860e7f2f2234c2f2e4874ca +hash_to_point a75e82836e65682bd9810c7434c536501569565af8e9372ae1dbd734640dcc60 9c8f1dfb32d9cbfb35cb6651df2a280b86a06d2cd92fa7fa566a165fad1ec172 +hash_to_point 3cf2974d1d1d00e0be22a2030c53f350883bb637f6a8139b92a86c249fd0a966 62c2454cff6f4401240d7c2aa2ff4e0665c6d0918013ce2625034474995bbc09 +hash_to_point 088aa079f44a79dc490ae200732e4728471b9dde7b85535468c26b123c1ee340 1ecdd643b7b998e2b504c41ac6baf7df94dfcbd42e513bc388c54a8a92e6b390 +hash_to_point 5543787f328e9ebe1addf2d4ca9ba0709a7134205c0850fbff8f9c04a4b31677 5c41f42b2867ba4c14d0d5c61fd90226e147ab018f008dd83e0d768ef28042e5 +hash_to_point 823d901ac4cdc6cf3e46f946c08341544d7c18ffb2aae6d652a1a10af8694c7f fb0ac69c45a7e509a819eb5c01f80c3c86c347bb504648541fdab820bbb94842 +hash_to_point e4bfca0ffc308fc7c344654307a32ab3008bcf5070523133093d4387341ce4d9 94b09b83f1355e9740c22c8600ef5a278e8f98655b1be0b4bf7fa6ce7f844cdd +hash_to_point 3859f8109804e596a4bf45126d1c4a3033f4112e349ef38f157eaad5e9248fcd af103b02bb065669ee9d42043abf5b31c51e5ca815f29403c56258865768fb8a +hash_to_point 9a49662aeb249adbd4c093da3e875c2a8423c7e0123acf61b3a5d488055778b9 7195d8d965fa146b447da717deb4944622a7735997306d0c21a148602c95e823 +hash_to_point 5c49b709e88a273f56d775740e750749f859855b422040b0036da433165f4100 af7c51a68116b577d39663d3e5aca308b36e9758c0dcb5c5f7117b0486786841 +hash_to_point 1bde7580ee21543d6b47486ee4d2a55c568a751c7628a495648a8a0cd7ff77a6 d4c218507dfd43080e2e5ed941b9d05456cee990463f13dcbe4257da0d0dedf2 +hash_to_point c990a7af0a97ef27ea65e3166b0222f73302a02c5960ecf207b4a682aee0372f 6013ab247260392e0e512362dd3e416a6ed1132d0450b0d90d2bc8f00d160c7f +hash_to_point ac27a17d1189389cf1f70af8e568dbfd53f577793b386206d504ae0abce05a39 c0210069c656eb8a32f363c5e67e26b472918a9e0124f03b74b73a16ade77e0a +hash_to_point 31ebe0d6dd1662bd7cb451c1376b8aa92aa412af570743eb629cca489bd3fb9a 57f1b34587f7866361d5d504643ec7adf86d56c2b8c60a77aa2d186923ff5528 +hash_to_point 449ad773bff18c02f894538ebe9e93a54843a1e93dcb0f02aa0343664aabc9e2 da8b976517d8f32ad964ae735126549e1f8bea2c492621fd6a90cf4759a5582b +hash_to_point 4aee7ea3d49d96e15c77d4d20f14ebf121f99fb6b7e8081891e88198645acd84 97d6b0b72039c3614f8d46e8d37f605e2cdcff3c7fdcfaff1e962c9d1686cdc1 +hash_to_point 93fab226937b99d05fe498d3a00ff3da70a890f0a63cc2bcdf2eb7fcaced40e9 4562123a0bab149c5fe22522c3683bc9a3a682a42f30cb1cb418f549e7e5bc44 +hash_to_point 91f2c9c030d5845adf49db17748c8bb19b80fa1fb13c84d82834dcbb2016fe92 2f75f4f0b27f69b01ef7026694a66370b3999bfd01166ace59c3f794cfb28b22 +hash_to_point 1051476dc715c13516a2d9201249f68b0e27d1af16a835d7be851a10279417b6 10f935ea2e704b8936634edbb7e89154dd53c3ba74e95dd14881e9d4f56854b9 +hash_to_point 729eaeb491d5beedb4766cb89fb4416dd41a551e153a08f83343168105cc5765 f1fb9a530108752fde94a03ea2099ae17f6dcc72b23a52910ce4d8cb0706bd98 +hash_to_point e399b1f1aeab37496984c0d55e7d7e55cdb51c6e22fa3ec5d1df75fce5783259 c03ac1332cf0b9d02dc7bee0be7470880cc596e144cf5266e8b77c15b87e4f64 +hash_to_point 9ed052bde729224bccf780bcc3d677b7239c3503a3f3254d1bfa6bed256862e6 058f3c520ad62411c20b25bf78eea2ce834d12a12e3b8a47191027d9387f0791 +hash_to_point 6b7295099bf669ea795f3eed2bb0ade6e0a05d232c6d67da6dd583eb3cb6fdec 6f13fe162009ecef3c5a47e26bf34b6d016b35364eac48c1fc3775611886ef89 +hash_to_point 85c1cc949214ac8e0a3e205e0e1f1a66784ace42907cc9723e3b34acb3ca6b83 6dab031acab92664e04bc9807ee88fbe2e96f70e9069a38300ecd253bb8e0399 +hash_to_point 8b0d8685fb92e664861a18b6fe4cc83764da7ea829a52c8b0f21f798bdb6bc0b d7b18aa946e28211fc749507b08283d963d2635c9ad7e88cf5a1f7ab215a0543 +hash_to_point b85775a9963d737099280e74b2cb7fa8b433d6e2f40d2a1724d19b959e7fb1d9 65923fbefe0ae80eb947aa34d68af59f1fc104ac500c67a05f0f5fbd416967d9 +hash_to_point 5727cf2cc96713d998aa9aa0e1e8f1ed69e34fb54b9752015ec2bcbbdb1d4603 c1fc2513dd29f7f3fcc0d3ac587ef9aa6881c7c7f9cafff07047ae27f58ee942 +hash_to_point 43fa08067a97a96cd7f1473038c44ffe1c5da34a924e2cfc9a536f183090dfb1 527ccc412739ccb5bc0c46c63f35621fc2c15b3fd7c83252a1dad040aaa9fdef +hash_to_point 65e3d22f19312c1e9529b2200d7d3e4a88ed33a179bc2e6c818d944897037fa2 f6764f19dd66267116479a31ca474bd88b15b02a95c64c7e34d21e2b962cd9c1 +hash_to_point 56df6bc2fe426e30b5a72bd37b9605aaf75d4c90648a4f9c199c7ac5aeffe15c c5e978be4dc1b45abef387292aa4808dc5465a263697d86fef3b1aa6e1b28272 +hash_to_point 48518169ffb4d192ffdc6147376a83d82385951a95004cea28c7f7bbb9225de7 22927c67e44a353c7cb9bc303e18ec66fc99b75ebc2f541a3dd03f37eaf900e1 +hash_to_point 6ab3663a5b8332595e90ed1c9ef96096c29a6fb8ae4f4cff0e9d30e0f4448fd7 20853b151c9b7b053bb8f9d0e6ed6c43c6ae51d1fce6bd88fd90b2b8167f4187 +hash_to_point d9f3064efa8a74775aa8be7407461529d50a8c4fdac2164b643feaad02c13ab4 ab24e90595793d13b15520f42dae212c3c8def7a1527a961b76f0ef45c9ce0cd +hash_to_point f2ada1d4893c33abec4c6f8679d9fd0df32dbeea8ab7648fb21be3b084582fbe 11fefff917b119f6d6931fbbc5e69273e7d515b76bb82c46313f305f36ce481f +hash_to_point bde15c2c63ad02277633de0c55f20c1ec84deee59c95b73684c9b1d1d98519c2 58731e4bf1e704cc39d4047ba9fe35939b9203aeabb6c57c95e088711e77693c +hash_to_point cf8bb235afcc34e80dccfe3a1854f831dd06e82c299cac2aa514a6492fd9f8f7 05f0dd09a1f971665ed768be44e4c0a72cf350e056cad3fbafcd6ec5472b91b7 +hash_to_point 8594429dd064e33953a6eea4331d63caf734332b7ff64e22683a5242384d6911 e993c8d05980fe22b43253815749a8cb011c86d245d3531ead5f187f5b214a61 +hash_to_point bf1d265f0126c423cfbc7bf7be108bc82107941672bd364ada4a8455d2febda7 161ea254a17c312969b2b7fa9cf73def665a18337e7aabdbd834566ad7ae382e +hash_to_point b80f1c16a91c608da41a7cd2dba36d57c6b73b66da82c7a02429f86d9df9c3f3 5f01a6297a3a2908078593bf1fd6c8a2e77e0a0fea420fa2fe3bd5c54934da9b +hash_to_point db690f6293b0bc437397a4b8d0697a6b7d03b861e955ead4f37284598302e597 8707ff11d73168789da7c9bada742ca8e77a6220aeb4fc63616d429dffa9acd6 +hash_to_point a2a2e220871df683096e88319a576c9397597d53dc4321879779c00604b0c9b5 cd8b64b33f13ce7b736f54077d849d68e14968e6feb8270f677fcb457edf8a16 +hash_to_point 4e1c7cc557763f694c04e55d65fdc546d01431114fdc397326b6a90975d3bf6d c742ec33ac654884a783506af48f9065f14e2fdff29abec684099c417eb49fd4 +hash_to_point 7a6e256a82f9dbdf19e921cf8bb144e8749790bdbb2228a7e701796224f5c262 6ebc96e385b115fbd901161f13d51a88609ce7f6ad414921fa6f51f5ac649b49 +hash_to_point ff73c806a9906b75ee122011611134b5ac3d2780689f9c4bff993dbdd91d7cf8 bc18e3f89062b2a05e787f219a92de3272a66e9c9b04eb228fe54257711d9974 +hash_to_point 396e4c811505a894766a79244f3e14da8df8e6d82c17cfab9542dfa4df1b28a6 fa04a1371aafe952ce774b17a8613526fda55a6e4f7e59025f1e02c975753924 +hash_to_point 152f25cd6fe5c48545ff47257c75924176631bff77f3fbf94f0f0479a853fa7c 77c45cae7c16a629d6e4a0683e8e0fc39ab709d01e65da67d8c27488e8641530 +hash_to_point 867996419e3d0dce0b15e20343357131b498750b1e4886d4a2b38d64fcd1f62d 8491b1d7d4d2883a33950f3a92ca8ebf123f94805fb47d76dfda6c628562c183 +hash_to_point 108f76b5804e74c915444d4aff33bd731f04168b7662689ec754ab461ab5ecd6 0e6dc60f9f556a3b819fc1a47e9e0e834621157469b12c508a7d18d2358d27ec +hash_to_point 49c832f6f1c29c4324f82d0bb2bf8f4ecc36bb2566605c2c8e6d4d760d57e5b3 b0d0f394019c1b16c76e3920440f234252c5e7cbcec05ea7db8d1a1455c70ab7 +hash_to_point 8a43aaee739ccd0e6f192f682ba8918cfbd616b01ab70800c8199645a0a14eb7 846983e88c7d58a3401637f5688f405b0464fdd36d7aa058e0a3372bd4223698 +hash_to_point 5e4f543b7eb8c6c49d69b23d10901f80e2315085abbfa0087241034bf960ccd4 2ceece65baae61d4618d6659e23bfe60189a2b762166b4847fb778d3bb289f6d +hash_to_point 110af662b71713f9098af1932e6514bbb43d5724c80b5cc963fcf1d4f11062ac 3465a0e4b4402ca45ad95b686f4e6def9d8a9baa38ce59a6bf3443ba349db8ee +hash_to_point 38ac2bde8a6b060da1d934caef64e38a0e8d4d8fd7763851aba81200f8d12691 10395bbbacd12f40a498a43ed954be7e3e238aa887b040518b4cab198f59ecfb +hash_to_point 7a98a3e34b1ffe10835bae80ec34ba77397315704a1dc23ff4064273d25d4d15 3520fa6ba42d911cd53e7976f7001b856bcaa264b0f41dde8885ca9e5f667810 +hash_to_point 4b4ffb69e9a3af51aff5687c477023177562d94fc369b222cc86214098384739 439c0752992421d0e8c6dc7173e44729f52a6d143c235ebd1d756b30dcae2437 +hash_to_point 9fc49562b22e1ab399026a1d46e1c1e872e2e07f53714cde0255feb2819148b5 5224d6bbea8e2c33dd148f764852c72cfee9665d6c6ec5ef77031ac5ee861f47 +hash_to_point 892abf488775b2fca3fe4b0c3697f58e3165866631a30e9bcc4a98bbc9f42f60 02770005fd9b53c08804b9d4f366a8c2ba0554e1677affd700a3d18a3c64a0c2 +hash_to_point e6dfcb8132d456553bf26d27d9e83226ffe34ea76ffbc6eadeaf6b132058bf0c 22a758d187ff8695e1beef47e494e6f3a2283b5218733d83ee28eb5ebb67b5ee +hash_to_point f9c73146089f8749a8658859bc960a23f993b0597eeab25958de16058bb51195 8df5180c750dc6d9fab8afb426c77e41a39e2444533fa46ecf76984b26c028fa +hash_to_point a72f10ac6ecf70a1b17a7ca9e61e0215350caf0801e0a053633955095085db68 aa1d2fa895784e734cbd92d356aa2a94f23eaf4e16e524994cf9960cdc1c3471 +hash_to_point 8106ca0e8fb3b6139f204328c01acbe54c8ff38447933bd48f85f864ece23042 85ac37e18ccf19ed91071684ea730019d6469f8bbe3bf74ebbabce6d01980d06 +hash_to_point 62827a00208d6e48a1e4e5017d1a42eadc58d382dd0d291ac0b910e5cbff2945 d62da672f788bc989c776f7ad30b6fdd92a46c6d263ae6f79d26cb698f52a340 +hash_to_point 321d44dd0f9e5d02241f556195ec29df2ede40b197f6d400674d2e75765c3978 d28c2353fb61f321aebdc326b828724be400d103131c09c4095dd711029d7749 +hash_to_point 941d53f3132fdc8c14ba4b080bc09443baf311d967ca5016f62fd458726fe1cf 9be9b4b884aac7d8faff49be25fc9f4fbd9d828c07cfab53f263fc3c1e3a5ee2 +hash_to_point daad94b6004eed3f9f1a58c82c6cfcf71f74bf4f2e60cec60494d25f1a76b4e4 6ebc76f7196233ef999acf54098210f848864b912eb224d9e3ed2e602dcf765c +hash_to_point 27398f739e8821d1d5c85b045b343274c62476036b358b11aaa87d49445c5dce 1a4afa8b6b1fc48b17c0a9229b6f02d2d41942c03f6e5b1c849f229f436f3fd1 +hash_to_point f6639cf7f41619a8cc58f9265acb86576d7960c0b751afeb48ec379da86cd4ef c85ea3ba8c1b9fc7c4cdde051e8501a2d224732bcd0c8974f477b36633426134 +hash_to_point 7b9931b576f16df50ce0fb29a70bfa94d6fd81ef85741fbcc0f3d67cd1c4eff3 f42c2e891107d4deab425ba3095f4be09651a22a0dc76452520fd09d42d5f08d +hash_to_point 6bb9088964c82ab8e892cd061ab3058632fa15d98596b8a9de0854a959bcd8e8 4ff4dbf37cc62703707361a14c1aeaec9e35fc976d25ec3928be7e046a80be14 +hash_to_point 993bd39a1ce9b8d03d504563fd582246823cf9d17111ba9b7e684d47085784f7 b036cfec9e9cc0295031feb50358511e70b3f7e71a6d069017f0e428285301bb +hash_to_point e3594a225b48f86bb65537dff478f30d07140c8f286708612fa9fa1474088e39 d28e263777013b7649cd048c067b18b63161b8543392d9a85cad551c871d55c2 +hash_to_point d6064b1a3586bc0db1e60b08833ec91fb4709f05207585aa6d028251e3b6bce0 c360c5ca99f0ba309d20f649470271f5d74c1a794442d7b0eadfecf43c8484ee +hash_to_point 5275eb7124a2df3d37070d9d0225aa18363343fce22d9380f8bcb5f0c33dd677 39e8f1a8ae42d82bfa30b0792acf406a94824073713e7ee1b8e9f471704912d1 +hash_to_point 3e0d0431afc723933ae08b8a0d0ae504ebc95194a6ab0c2e0547bfd7bb340c64 250122a48610abb634eb86cd5e6ea626fe7e7ca79a1f7bec55f4db1cc518325e +hash_to_point e3915bce8800d31b7c33721fb02f9844de2fbc93e3da92081e747ae83a8e3d22 7658f36d6be4ca2bc8621d1f68a4a4dc9e7ea2601ad8a9ca42ef0561616a067c +hash_to_point c202bcb53044b52574d42108d07e1bc99e3437991ea55be36bdf880848c77733 d078eca7da46a5e6883356a5ed26e08e1ba7957d6b51c518cfa80b3d194a1480 +hash_to_point 017324ccd42d217f2c7f6de721229ef8c533cdb0f4f1433f6501196a73ef242f 8bb3516b35199b7f4922797e9683e9d72df8fd589450c11ef83949b08b64a8cb +hash_to_point a7075bcbedccf4592cf1983538e4c910a39e08045b070fbdd821a4cb9e9020c2 8b876e4d43c31888bc2642ce61c3ca3fe8c8da55b678cfdcc2787cc9cdb0cc12 +hash_to_point 3bf8ca02243adf1a2e34c8060e416cfa29be6e411727a0140fb0036bc712f53d 196dfcf22e7fc6b6d7758411f806f12a555d980520a1d69ee0eb74057bcb7feb +hash_to_point 29a87f1d88dc9873e143a0678d447af66ceca1b5822337c9e85684de160ea63c 4aa8dab44e3d957450c871bca013bbf40c60dc0737056927e11eb57a3ea4d72b +hash_to_point da0bab557e851e921186032a19ce21bdf47c767558007ca6de31ec250c00d25c 7899ead57f00dc0a956d69ba2d8b556a1be8f35a5ea3b3fa7179bd3d3eacbd51 +hash_to_point 2ce966eefb280ca6a5d629f33d97dba0a9f41d4ce71ae91ea162bfd20ade44f4 f0bfc699e61e362216311b22a535b70454b725efce9952c5ce22e48a573fb570 +hash_to_point c2bc98dd2a7517442a9b66a8fc07c3b87e75159aa9a81ef302e7a3d7aaaf18e9 6c042a5678639712c06001d579512ac0037870391e501225e5b95f0208bf5515 +hash_to_point f3a1ec4a867e2fb5e16f5617b47a677a0f1ebcdf4c18e935f4c94adc80782d24 fe7994e96d8ed503d978e128d80964a8de669b268eb71f5a2e3aea3ec392b3b2 +hash_to_point 307be4aff1d0d0752e857a88e7d4cdacbe9f6a1efc9904e020ed42f37c497ef9 f6f21058b5f3982c0809ca41c3b2429a1d4c7fd7396263f3ac65b452b85b4b48 +hash_to_point 15471a73a0e2f90b776a373b43fad5fa0146c310398d7f2804c513cd25aa6270 35ad033391d7c25d24605634e3db7069bf18961046b96b5a83c7f6fd67b349f1 +hash_to_point 3b4b3eef3c38f75fefea04483c2a69eb569774c79ded92bf73b9a55cfef2c5f0 4d013d88cb99b0614cb33b50a9ae05d7a5740f25c6b34bf9a7d5806279be89aa +hash_to_point 133a76addbb66d62422660ae61d1bd785d6b017bd84cb4f8163e69ac801abbd5 92a8c338b452959081f0a6595344a696777fbf077c0baab6c7cee2eaa79b1e50 +hash_to_point 6fbb4348466d9090d2f32b6bd7c6b54bd399f341772c06199d1d6f425096fec8 d604e5f8615b80fbea9662cc7eee326b4fd90bd03fc8b02de5d5d86bdabb20aa +hash_to_point 0adcdb15fb9e1ed61b87a5427d52b5ee0b53c0305a4fba760bec9c23831ae5e5 e3bb0e46f9d22dbcff73845aec18ac2c1d3a38e853b0d363dd334b1d2b3cadc5 +hash_to_point e088dbce19dd6bb48e0d2a3d6686b78a3141afa2e3fa271c501e3c712b3d8398 bcd58daf1b3b004ec0df892f208eccb74b872de2ead94fb66ec40143653bffb0 +hash_to_point 55957f638b190fbbec4388b0230307802443ec0db552a6e12831539cc4a9d11c a8016ab604ec66214af3946b5bffae7b9260c311da6f13c8593b09756032eb60 +hash_to_point a6fdf6bedaee413277b0ff736300a8469e2b3405ae2b1f5568deb99f69c56f07 646f12a0f6c5938dbd9c9369bdfb62aed84eb84abd8eec69f44cd32bcaeaa6d9 +hash_to_point 34cef7d5288e38092b6f1096b829b40deea00ab66afa03003d914c64070b4906 bff806e8c68b0ef5a88ae5e64bc67fa7ee1e42d5777a61be8e79edb992a71f1b +hash_to_point 34d06d7bb1b312e9740bb0940ba407a0581eee86ef3d7b20a69e6785a31b6255 a6d899713ba1222f0d62be8dec91b525d5291a2b69fdee885291102e27c80e5d +hash_to_point 041fbca587b82988700a9f573537fff15be3fcbe572dc3da650ad7e8c903244d d005005f18cc37aa09601a3a2e44ad2024515539e48ad914ee5e4323fd94f551 +hash_to_point d55e5640c3b7f0a424821078d7cd36c0662a7502facb75b373c91080925afb63 be39ad5a7061b46343b622ad97793bff9aa97ba2e31341a0495a616e9fde6223 +hash_to_point b965f1724da830fc6a892226e420d8d5b924229abb357f242c1e8881b0ee13c0 373057e3c45c120b419169f52f992d76a0b1de1f2f2c918dddb4ed08439c3163 +hash_to_point c6690c38e0551c87e129b81b03448a8bbcb8cd936f3a94193ffc3dfaec006ad7 652e8bec2e485851f74fb7ccb1ad6fa1a71fb21dd45341acf3985c86c04b3f30 +hash_to_point 1b8f07862ec7f800e61a221410dfe9e93a3b41a179301ca607f11afb57d9fd81 135615ba236c265729c2aaa69dc766be83780f00f047d504148323515ce91ba0 +hash_to_point fa7380693c844801971aef325f5f6707997311d1555624697d96655e5a7c1a78 a6356b23d48a7eff106c58dafa03483b0876e9ae27b636b501f7804bbfcfdef1 +hash_to_point 549543ba9f2f5997330c48a434d71b06dc01be1d422bb63260465a80b5c66c1f 25a0d041877566b15cd9fa2eff1891f8f3830e641668a853983d298e60b78c2a +hash_to_point bd7b986a669c07089a1ede05cc8b7884fbed840d19158235aa1f72c3780c6eb1 27cc4ed181593db1fcd2475f3e4498e97125717bdf3078196992670dae027246 +hash_to_point 8df8549222c7057ad60b1005bf59fe3a3be4a7057d3a707eb876baca3839abb6 98cbb6c5f417c39a38b0f283f2070e55450f993f2a65734ff5a5b84088f53318 +hash_to_point 36c0da4710cc1af1b9c191d268e8ce3f9dd55830ab2526c4891a1d76e58e3c3e 614a12c387fa1737b4d133bd8b237d0b58026b229058673b52b910a6d8d89848 +hash_to_point 3eb748926c59e91f5784422bc278d8de63c338f9d9dade152c4db021411b1833 08c940452a51916d4b74d578b04f405caf9a890105f4f842d7cde97af4f245b9 +hash_to_point cdf1c39919a44008542d9a7250447ed719b7855ac5b1579d2ea6dcf998e467bd 96aa0c87f8139c2666093d61f615963c87d8ef00f09180abe5da1c52fbeaeb31 +hash_to_point 5ff576c6cd73f2b6b19e814b47207b55849b7e1b7c5c48aa31241f481d5626c9 3ec2dc3df285b9b9bfcae34ae31c2fd6e0846b0c9fd36ca1bbe33cb6c4a03b83 +hash_to_point 7c9a7610234acb926d743ee9aebf46d1ba5bbf2ffd440bf207e638bea8d50441 c1ea504ee08263f119f693f5b05af7fe4fcc39e72deab086a2510d9b6d75f91a +hash_to_point 3bbb07ba1198511a456b5f239cd89475588ce9170353009332ade363b3716189 b72e0bce5933c4fb1771be3b302e43659fcffee0d9b1583cc3f6c4b48e81e248 +hash_to_point bbb7f73379243df51ad005440a88d6fbb04cc2c41534d4fe6e95c91c3161290a cb39c1b2779021b3fa618610a0b51bcf29a6c1601f162e25bcb95feffeb5d5ed +hash_to_point 048791f4d98fac912126423256f685e7f27a762533bf853ba45a21d9f1fe8a0f d2982c159beb89cfa6cfd393370aa4aadd04e2ffde8524aceac8797cf86b38ca +hash_to_point e27f4f8adf3479f2d8a3d0c5f9ce155824a5c209845574c54571521e8ccb374b 98c792f4a68a0b781fd823bbd70db88a380a6c66b697e01228f9fd749d1e840a +hash_to_point e3a1fea613b6cb0aaa74d6319a15f933821eaca8142e9db64263d7032902eb18 3c1d92ed50a5c0dfefe9cfaabbe8c5c3a2a477af9c700540b2be322b1553e864 +hash_to_point 79fd41bcbe51dbe34dc63e86596a19bbcc3b9044521ae0ac479fcbd2760ae131 8f333855cae1aa56028643ed8d25d3275ea53ede285f450d76dc57d2bc7bdb99 +hash_to_point 45848cac731031637fb676f68ef3836ce434ddd1da962001cba3660be6003697 1fce38c08f2e62515ce33d6caf64afcea80ad0451dfdb539cd3ee128232e9647 +hash_to_point a4be3ff8b2b34e3792f72a61d14c2bc75943892ca00c247977d51c93de0f4acb 7ea3ab561d6c0e86e8d018192c4c5484f3f4a60284ad76325d832ab7ec51c7f5 +hash_to_point 53092d805d173972deb7fa4f0e9d1c0da34a52b9db17b73cd0d3141c891c6565 b4da3e082510726a6254d1deb74c597892a1a80125330cdb062ed55b29c5c9f7 +hash_to_point 1e6ddd29275cf7bf71d721e9c5d38fbe3bf7a7da2b8052a4e04da15659f1488f 418ae60b1feb1a573031c0bdf27fba8c8a7925df06aed487a88823f510841883 +hash_to_point 84d9ce991d50c6597f8dd4afc440fd32ec8e2f1291e639d4a29c377ae138c4a5 ef333f5a3d834b809b9888313e515a525bd0533183f81446263ab090edd5fb80 +hash_to_point 06380d1eb9b7671d483362a76ff7be319f89e4c16f3a5c98331a5a271a570149 ba5a73c2157f9fc185d819d8788efca4dfe59e15e6dc55ae64aece934e8143cf +hash_to_point 96745d82591658f8f4844699c4231fab7ff9335d2dbef1246979c962253eee48 5469053551a2702141e98aff4b31c80ff97cbd21357f422a5eae48342b7700b4 +hash_to_point a2c7a37412fb1173c0e75e5a4e913858a2f2772e5f21be54cbd5391cd81f6fa6 d77daca7615cad68cc0801138534ae8d03945ff9c55b893a2858a96e53cf9afb +hash_to_point dc2689312e034807bbde334556b5938c83c7a4f205e72f83f696f96514760c7b 6318e7b245a7b68609cf3c3c08c364efbddde1d2fbd7bd8bbacc74b6f439a0f5 +hash_to_point 8470ed5937b200c207627e7d637281c03c01d6c0814d94389f10108c6bb56d8d 596141be8631d387949d87fd18ec7a5d890790d695806cdfd84131f9a92d9bdd +hash_to_point b7e12874f0ce763d46e04ad67e3b5a5586b11317e6e592bd4c4f2d627a662788 8aabeb61a29ac826ecc31d8e265be581eb1e4c959f918256d328286f36c57047 +hash_to_point 2e8a949f9f612a449d9bcda59891c9bcc68bc234e7437879c37cfbeb09e0da6e b73a45aeb5d849e24682f32d4e207cf587c9a7692a83abb2e77954c52e1f89da +hash_to_point c1abfb0cd3d4f1227dd2834fadd86871df4af2140147adb97a6325ab0bf456c7 2468f3374862cd9ee0716c9d13efdbdd740ffe9a0e152f8ee575c6eb63f3414e +hash_to_point be3abd7488aa7450a8816fa186790d09c9ddfde25a329258a648e1481eee07cc 3689aa3bb2039bf3d670e3fd30477a3e7ebd14984a5c4e197a0ce0bc7b811303 +hash_to_point 71b38c953ac5ccb4afcd8add9368f782825fb2307247ce228013cbaf1b99e09d ada5fd051ecd9725290a6660a69b5efafb12a36cb1083ba8d2a8bb779218a0d6 +hash_to_point ea0830e7b4248f3cf32a0efc1dfa812a1f22a1d9e0afaece898e09f0afbbaad2 1284d0f19e53a55c4f15ada781d5954e1b796a3e6195e0e2ad64013d931edeee +hash_to_point 0af5ecc45142f6186c5c8d2328b9378bae03f6c70121cbb7771eb4c8655b88b2 1cc14ef67a57c31e972b2e226ca3bb5034ffac3b967e14d33f1eb9087a4f59dc +hash_to_point de64c98a76e2443dc8b15ba6e02c08c1b6ff271a3ad8dd5fed42bf9773fd97f8 fe6534979d827cd291cd014ec2ad34942f804c8c6da5c9e2ae732d39c1500644 +hash_to_point b9e6988b85b1938f413838d16409c5b78141aabd2faf879f28992b90c143e885 329639298b058b75a44b6fc6f8dda5ba97133e063312919c85d85d3a97d11db9 +hash_to_point aa502b234a587b9c2828c1c2b62b0d606b86d893c4215b517c0a4b8b08259fec f7da37a8204ca4bcf442cd76f352ac1fd9d38ee76c694463a36663e355de21b5 +hash_to_point b519548dcca9077641a6d8d6e412b6615701507348f7fdca5d0b5fed8ca95455 0b253907f8da2f319b26f93c3d04ea8eb3018add20a94caf8ac0c661c0a1721b +hash_to_point a1b7e9dc65e2483a000c3bf23e5de8bfb5b3b443e5a690e69ab1c14a818afee1 2209a8b1ea25c95116d31ac3b0c3cc50a609acdf5d77d2bd1936afd836fc483f +hash_to_point 99619ab4a831481823fed7975dbece0b49b04f853a18f2843e996fe619e12d55 634c24ac8171c84c6eca1cb2b743e549147c265fec20d9cdde7d19d9fc438493 +hash_to_point f5300e7a436d683a286af2478ea7353194b00531f4faedf43a4beb4a9c4df181 37c3710b48e2293245ebea181411caed089e5a7a1b9252e506b83f871fc26b43 +hash_to_point f11edca9cd499e7ed4e91600d3d7fd078090bf096b6cda57c9018e38d7203966 df19986c8552253fe928c32860133fccd334dc83e761e2381bdb21b369df12e2 +hash_to_point 1ff730b951a28d6ecb85db38e983725c977613a68beaf98afe0d84fa52f14a72 e422e09f2058ca888b5c6a7c212977d69ad3c18f02cd148dd66fee6f36c61f92 +hash_to_point 86c8bd4f52a0da933f98a161b46097874e00aead37927430d61c8c0bbc0ef72e 6dea133e90805d075f8d3d5fd1827a7c7ef538ff9d80928cd460baf66293becd +hash_to_point 08e73deb3f2cc96ed888d4742431aa3bd7e906c0f6edd9972f7f7b4ae9ffbbab 7a529abf5b3d32323878744938c0593fbe1479144e462b9d3dedc7400357e8ca +hash_to_point 6a06747d9d728c2a3eee04d29ad24b1363971bb994f8a3a5388e937bd5b38148 56ee061b682c724de54bdbde14717ac13ea084d1b0037835b225b8f45fe48ee9 +hash_to_point 7b1b0609398c9ba7a4623b27b004f7f3992e535302ceeb3333c4ab5dd93da980 236c3ee6c70fe0e53acdf4a0e34bb30c63626317d072727ae0f7803dd3fc7dfb +hash_to_point 0d19d4ec0eeae6a2e3171b792bba1994ad26050693a80a3a8dcf43f9048036c1 869685a185a333b9a7fb166ab5a0165a61869f12a0678f3ca65ea2c8e40ccd8f +hash_to_point e2e86d3e75a9e11fe3b252baf89f66f78adea5fd593744ce133fab6abced51d1 fed9fd54e936ebfda5d7a0e53f4db777d8f9ae0c828cb57d2adc7d2a2b97c91a +hash_to_point 5f661d341a09433b56c5123f50b9448a9c65e0fa570e5439040b382f3ffbf6d9 8b2c208dd74235bcdc3dfc02cdbb0fb98667796539b2c4755dd8bb4d3d5030b0 +hash_to_point ca2a2390fc4e9a2456626dee20ac8cc04d26de1f9015f3f6d8187ef4ff3ac19b 1652ce33cc4a918c7348d1de00a528d3c2a32bc083eb7ec1ba0080b905d82d1a +hash_to_point 99247578832dde6397ef482c7a885abc3d315b91d8eb16e267048dec89eb0467 91c3d8c3b890e034d5e991a9ff70e4484465fe100a304516e5f21ccc96dfa3e3 +hash_to_point b5224510122dce5dfabe68b16ab7b1d4f133d3dbac396235965387b8ae5ca824 d1104d34549bc58dc42846ae012f7bd0c7013b036545cfb0a430382f7f47a01d +hash_to_point 3f00cb7a81f7b8fa79f0253a0ec1a3faabc0590c9c39c2617054d1b0377d8c2e f7a7ea514b9a90d422e45b25b0305ece6a1e75ac88485daff5be1d208738614e +hash_to_point 025cfdd3faa9d85b6bc06831c9f7b850cd82a730dd046c33e4a89637c2ddd260 071b21d17ed44a415d602b48421768de258f5b4f74f0c9b051427b11c3f88f2e +hash_to_point 58f48898581d2b262e7faa06dbb20eef8e36907597f4ac911ce7e816c84013a8 3cddccff41876e1afa7297060608d328a14839c4d90338cd630b7775c2f2cf4d +hash_to_point 806e8f05f671649e267e3193ec23b5a86eb79c957c8a00d5d7a4ad7fee8a12d7 ea2aa3321c2f4778574d6506dcb3386d291346d1dcf0921b5795a553c11750b6 +hash_to_point 5ccadf3b1c30b449201c220d295d38627c3bf381b6abff7975b8e2c099399ca8 d0ee1bec1471be7cabadd9bf22f7e1e18ccf2494109806a9f7f8d47b5c1f25ff +hash_to_point 86c2f1377354c0e02ba935ddf224b0b5b4eddce64987447d4398ba16a5fc8186 9bffc8ed0801765bda467c60acfc9dc9c1a4c4cfe461db77dd7a3f15b02a7a7f +hash_to_point 38dac5e3a649197493a75562b962514d40c9cf47c2e3ddc4ae481dd07c1f5c91 dd30a465c4b9754007ede53c294ff1bed78b5f2c677e24fc20e5f999ec342158 +hash_to_point 2d13f9ecf6b50af547739cb4df4c0d4dbdce8fe2dd052b94c64fbdb437a2d6db 02a4ebe5375bf6997199d6d292cad962decc3dd346eac5fbd2d9325f24692f03 +hash_to_point 139b28cc42975a8e7c4545e8ad4a960c20192b4726cf224d0bb6546a93d8677a 2406244a43c2b2b404c2c6787172009047db4b0c4145e865e2fa6e4054a1804b +hash_to_point fb2786195dd95878e866a9716bb2c7bf21b4abdaff41f3e75503f9710725c0ff fbb8efc6b57f635668730d83a8662de2bf71c6d915a8cccf1b1e323a134353a4 +hash_to_point 1d5579f8cb694627d0c7319be388718df49d86454debe9084ed47ba837a7b757 95122521b22c1a534bfe5a5f37b7794809a6ef80a2ffda2b08c5f8e7798279a7 +hash_to_point 706fa20166c83927871fb15c39c303c041dea57b3c5940de8fea2c14a759a201 6a11fb86857f012b708d619c33c5ab4e3176b0d31c955c509b0f3ef841b452e4 +hash_to_point 4c3b65e0618a5cca7d50e9a8a2d24e2376e8adb09611dea1624d422e329639b9 828a1b4b8855c4d0dd384580c43506d90228793d8fb851df81ca55cea3039436 +hash_to_point f57859914da087f548f3f064bf575fe47e9d42178f8e66d896e6f5fe45c656a2 b67246c1567fd16d8ef05e13d06415d8e14a89534971f9309a8cbe18a22f357e +hash_to_point bb680ced036dfb330171ed72972f186dacf3374483fa4e2af6780ba66b2b5574 752546e67b9f37e5f5725cef82ce513857a540199e0b2724a74f7678e41ff634 +hash_to_point c0dc99aafcaae855aa99b17c0d68ca841c03527b76aa2a11c38a561bcda37d0a bda5405bc8ba8d2cd4ed7eb1b42d91249b22733ddab5e6797805363ec61f4246 +hash_to_point ad156f4a7d2e431f23674f91a71ef65b3bd9077176996c4e02970539a23d2aeb 64df1d12fc2202db4efb6439c906c941dd4137b4b19509f9d9486b85d869b001 +hash_to_point fd112c3c63410551032648c025ad89734fbb4ba21bad30f87b91e694ae4c6c4d e2752480ac533acd196e959e58ec36ebe8309853e7cca5a4614ee13ee3f45d06 +hash_to_point 43fbb7440940e6ac095a3a3ed97161ca707269fa0af6014ae191f8586c36478f 8cd31b9c9abc94f6340b5948934eecf41ef2e3846c61ada8cb7bae7f7c0e4981 +hash_to_point 45087bf19e14cc93394ae54caa40d1072f0ae86f90d0101b8a78d63a3be43e8c a0d20a8b9060c1391ec551e3462dc13609780414b1fad278c76b78a7fb431262 +hash_to_point d0474f4413d5f903e6b50fc40ca0af19f89ca31906198c6d7e93722b8016b65f 215bcfe9a30472a94dcd6ab6de708b4c6c768c24c3abe7d22d743f58990333f4 +hash_to_point d649b45f4d10d8c5e216d7fa1e2a6465bf6d729c669e5febe198e6f35ce8c460 1ea5d8b384496d7ce7d707dc8806b967c8d15028b5c35dd9f7089453aab9a121 +hash_to_point adb4c42dbc358b4d0ddadd79446376fd84eda50844a7a34413303d9c94229a3f f80d8b2ef8861ac5266d17d7f8971e5002d55d0d40abbd2279b3a5392bfb701e +hash_to_point 616eaa295ddc0c0755d22046b24198b84ce7a66e06e8778855e399d769e67f0d 2437fa51f8be9a966034c5b0d41fcd628b89ced37eaff2da23d80324f844182f +hash_to_point 63c0c30e3c8a8717d97be9aba79831e6c55e57b0a591d0a4080648e83c6ee538 c5d35a4f975538b004b938d7c25867439934e19e97f17b389187e54a0e6df979 +hash_to_point 855174b59d2dd577d5ece9e22f396c6f7aad0857661f3a925a8aad64288886b4 f055c3cd008d66bdb40bd47fdba474ef59613cbcfe1dd05cb1f3a79ced021ff1 +hash_to_point fc8d2ca37efc34b13aacb89a9376dfcf9621201e8f5ed9876c45b3cf1d6b5ecb cbfaa1628bb1f9c62cb0b197b48110b9793dea19ff863d5ce94e26069f755657 +hash_to_point a1f81ff59073858b6e21ea3339bec8b3d3bc33573ca85026d94e5f898ceecede e3cb0034795557bfd8612e86d87036ba0172ad9688f0afd862709cacd27903e4 +hash_to_point 61841e1c08df81ca6c8e195b2aeb187e27767ac298bb62855b15fc185e901081 bf8f6f0a9c8374da26985d2bb042f8356420aa5de66c82fd5e0f720a50a69c53 +hash_to_point e77667c5b33b1113d47cba4a2766f673c1d5f63a57298a3dca92af92195b354d 6a7827ed9078f343d11a88385f6dcde2180a33a883f957edc22b38f75403bb00 +hash_to_point b3896d6fd82ef85c4e79f96f45ed7b4d66814c37cd2c794da868570adc8ead83 e2327dd5220844fea1bc16ef8ba3519939fd39096eebe2656c80f7ff3b1e809c +hash_to_point 7e5ef26e3e50a8287a1c7ba24d41e88f5f40946881ab0af5e30652105ede7c6c ca4a0c61706d2e1664fe45cec1af5bca9bc7fe165f8562daff10a36345e050be +hash_to_point bc16d30b3e5c8982449cd2a11a46434ac06ad5db8b7e01ba7300d46ab4e00e90 df90c53a700adf1c32eac8e82fda53cf7578400e8e128644ca599ab8bb5c1abb +hash_to_point 8b826af84a6adc9902da4bb9653209d3c6293e7d44234f5485a5cb465120c4ae 1d08f00042cfc49eb84ed6bcdf2110f55bc5b27cd0898a54105be4c95170bc53 +hash_to_point e158aa2285103eada1f176e94023514b9cbf0952c70bb256ee6eb63a8e90b81d 060fa005c6693fe84185b14a1228e88bfcdedd90028af9911783696d028cfa3c +hash_to_point 1f6f0a153dd0e6ff9aa7910f29980efefc966fb90f502e524d0aeb0fc345a2b2 09e9f8b8306bd5a0f415e07f65c44c1fc0ce222be23f71e6fdb81be4ecbcc4fa +hash_to_point 8b8cfbb58b830f93c4a16ccec26745e264ef747f8d17fd5a3ef282e8f41e0fc3 1d9c9dc63affb7306452b059aa340c9e84a2a7ebf489a4e8c20af0bc17c6143f +hash_to_point dd583289c05112300dac0de5a5cfd6b1bc67dd12dfbb2ea8b7f6e86388520cac ed0a334b518437b2872bddcce1d48973643d692e8e31717ff82e98c9ec01990e +hash_to_point 15c9305554d18480903da544cfb4dec3b1c663dfeacf3b27d6c88eb78c1f5497 9d50f07c41f18917e8746460ab424fb4eba43b619f05db16c5508d33e7497128 +hash_to_point fbb60a34f061f710ab53e390c268bc308a4715dbdfb74a3914f49d2aca198eeb a79e2f8fdb87d5a5b10cfbacbff4cc3ac8bbe3a6aea52730026b2b5259949b7b +hash_to_point 86a21f24a14ab7796660b1a0c71e13e2c8d087f187080c5551a239861cfa021b fc09351012854b64e62c8708c8541337b034608129e9bd781b0b049c4d0d557a +hash_to_point fa9b331bc4fe993e8c7ccd1a6709fa807c3ca8aa893b42148c5403c9c40fefe4 d30144dad8b951a515343d8349de574227d77f2bf4b7bbe4ebef90459f61e797 +hash_to_point 32d4115ba7970c88d4adf490112d3c72eee4b6c444471de154f92c0ee65384f0 e8d91507b1efd1d067b1155a9634f84e425da791a8ef413d06d537ef334a3150 +hash_to_point 7732f81d4982cbeb7b56b83222cb94b2926ad0a74973889f67b48c6e51bf46df 6dbcc684ac4dc9eba9e72e36059d910e6db1112f6a1588d2e23e6e2ee99ca0bd +hash_to_point 9e2f4135ee6b8743871b042bd7ee90628aa12a2f2a8bc4711799928fea49992d c9b2e79ca5230fa300a3909dfd125ece4114fb06abe3b1d4fb1511af9a46d721 +hash_to_point 973ea6c5b6078104d99c7af23dae9c0e40e8e69c31ccc3d5de492a29c9cc5cde 8e774b86661934cbcc9cd371d09cbc7c547f2225bfce22fcbc38a5d4e289a2ae +hash_to_point c34cff2dc26df0c38127c1e4642133303783aaa57245389791d9026f528c7511 8a363a642084d922a00fc62ffa296ca4913ea0049bdea4cb6ef21e9f51509c42 +hash_to_point 4cbcd8d2affc8aaa418aa4d035fde7beb844bc8267fb89a26f9e461bc558d94a 328f8efa6bea3953680694176211e6baf12e39766e89467a2bb93b3406a2383a +hash_to_point 3dc96daae7372d4266ca1711edab9a356c09e4cf4c8a71cea1e2ed21e063373b 221a5c7fe06f16c42e98b6e3b232058b6cf8be0d44559e76f37108e2d18fa213 +hash_to_point 6e1e6e21304349c0e3a85217602144c9fdc1708aa2259f96c509caf2c3942e44 e40e06de8c20d357b1668a5f025311b44b19ea49e10eae83395f6e96ffd11c34 +hash_to_point 167b7994b46e5711d81a3c970a30a0359c1943a97d1b331c75e31d299c95b21f 77439d6ff0cf2015fd7b74399343539821e37fc806c7eca57fde70ca73525d09 +hash_to_point 477e02c1daad984d3d9a8306c1bbbcdd856ec89286f4ee0e32b6d23228101f81 f1f2cd60dc5cd98477228630edf9bcf375562c2eaab6ec33bba457c3537147a5 +hash_to_point 672e1a4d0f819e81726a532884599c1c9ed2be6076474ab2bfff20634abf1227 3ec6046b788e85c0621e0a13e4e4692f3f360b0067937ad9e87be25e37cea4fc +hash_to_point 60dd975a846cb92fb3a3bddb26369c68aaf50677dd07124500b6f9a18867b1e6 89601d6bd2b35767c70fc84980e70cdb20481f76dd9b52d271e9540b6cb077ff +hash_to_point 0670076c445385726b5b1bbbda9b5b5c65565c965043e7f82bc36ea56d14df3a b6a9ef8e8c029a33d807c8e0b8331d6c7f29f6f6cf8f1d6ceb51027ce933d6f7 +hash_to_point 539a5bfc8932145a2471054fc842ee0475289a5b1ee1a1fa1e6d8dbfbd52ceb9 6773624f44c41ec018ba8c7073c676a58c1340f305132c6bdee587b3d08af6cd +hash_to_point 15ba1965a910317beb48703601bf0d22c8fffff82cae0a3d159d8a94cf8b3a31 2795b0e862a94f69a2ce481a20443e0b62ca8445b1dfd1cf1a4415bb431b17a8 +hash_to_point b46bde188ab538f4a518ca26cd118cf290e893c9f32afa00e35ba278c9fe06ea 452a4417a90a9d324bf537393616172f8b3c3f6d78671573351b076cba6561de +hash_to_point 7090b8b98b30cedd6029069aabe1240450ee7a1f9a35167956cf45414b6d8551 158b2b01f96a17dd66fd0a28d7645a4c695f1b3814f64e1528c0397863468b97 +hash_to_point 3d323d052f1036e7fdb3e9bb215e4de81f23e332b68193872be0b7370c52f934 f09a808c093dda7822829c906d3f85f5358ceae54e49414e1be66de60f44ed31 +hash_to_point 2d2af493d7c8ec8fa0fed011a072aadf27af24e1e56faa0ad4aa23a1d89c4f61 757b32796259aba55f1d3a8b14d0df1c6f8ca8e8b9899d8563dacdb5e89b143a +hash_to_point cb487a9ea905f078b657b453b80394a651150d0880c84f7addb219749c8c0843 f0e21b7197ad61f8de0fa039a4fb4732e005d8c4216c15c45dba4d066101584b +hash_to_point c4fab29801f27798a1e7319f6479c8cda258272aa82c283d613a7aed2c0edd06 deb6df999f31939ed0f7a0b85752b11e18f35a9948ed6b73f5f746a8b86838cd +hash_to_point 13903b9465a009c0677711569a1620745cfd2cb7c3c3cc321cd33d8b61efd70c 99113ad3309a0bbe6063608710d3bd0290e80ad3ca424c813f4eb5f9087a1209 +hash_to_point 7a0ffc90c1392da2fbf861b1584c93e5b93b55d3cc44e269c565fc911b94dcc7 949e5381451f5ca92ee3a7b561f8c50d3f8b42b82101178e26b2205a6aa4246b +hash_to_point a5ec39f6fadf1542beb4294a70a87347103b22a11a3090f04fb5b565e84d66e6 9ef36238a773886f9a4d60d808b7682d4053fcd1a5b4d8e165706aa645db8534 +hash_to_point 559dacec6876590e144ea7c7718b4af4fc8468f87f638aecc5cef086d819fb88 dd64dcb70f5a704e5dbb37b6e87df893ae902f429a444c1721f6c7e747cb8d19 +hash_to_point 0000000000000000000000000000000000000000000000000000000000000000 ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f +hash_to_point 0100000000000000000000000000000000000000000000000000000000000000 5278d545cf9c859bb5ce01dc6c8b8d4e3a02271ca6d529c835e05a64981fcb8c +hash_to_point 0200000000000000000000000000000000000000000000000000000000000000 fb6e2b404ea0a97df827c8ad5d3a4676fe7176665cbd464c46de72e633caca13 +hash_to_point 0300000000000000000000000000000000000000000000000000000000000000 a6393daaa028abc4a561b34f5f36fb7e4d44f0dbdc8aef3626d469734fd8678c +hash_to_point 0400000000000000000000000000000000000000000000000000000000000000 8b2b2ca18c4ee6271f8853d35799f3706f5acc92985ecbc87bbfe210460c99d0 +hash_to_point 0500000000000000000000000000000000000000000000000000000000000000 99746a762349b0a9740303fc74ed4c1816d0daf3cafa5e537088d2c5dd85165f +hash_to_point 0600000000000000000000000000000000000000000000000000000000000000 d077430bb005b3743fa30458230520281887b13629bc33ca7826a3a6aff4d00c +hash_to_point 0700000000000000000000000000000000000000000000000000000000000000 491d61605fba98a01d57b3df80790d37dbc04f2fe14aacebaaa40e47f2072b71 +hash_to_point 0800000000000000000000000000000000000000000000000000000000000000 8c02c2efad64ca492ff06bd558c746d86786e0b973455b4207f2506a9430862e +hash_to_point 0900000000000000000000000000000000000000000000000000000000000000 18edd6f75b6359d0c8182ced6b8641a79768c6417ef5b4640e6d858d85f219b6 +hash_to_point 0a00000000000000000000000000000000000000000000000000000000000000 39f05f361fa5f99bc2847c2da1cc8fb799c1c5f89d88476928bd476b4627d8bd +hash_to_point 0b00000000000000000000000000000000000000000000000000000000000000 22b50cc82330901a8f47c518e48970e1194827a0f50cb4952dc809881b6e3149 +hash_to_point 0c00000000000000000000000000000000000000000000000000000000000000 4456bb03367ab4b8d86c37624bafe3530f5317eeb48cc0000f88539730ba37fc +hash_to_point 0d00000000000000000000000000000000000000000000000000000000000000 79f979071f10c503862a0699c09ce2ca18e444cacf79fbfe2ba08d868033c221 +hash_to_point 0e00000000000000000000000000000000000000000000000000000000000000 dd1e8f50bfd83f94aa0f6a52ab10654c1dccabbd729fb274f6e4a01b006f34af +hash_to_point 0f00000000000000000000000000000000000000000000000000000000000000 9a799c1ffea35d18a9d442a57a08080d4659ba69c9e867731a81a560e9714c89 +hash_to_point 1000000000000000000000000000000000000000000000000000000000000000 d0b4470440d3309047d4a9d7d7930f4ab9b47a27d43fb4fbc512594022fc55d5 +hash_to_point 1100000000000000000000000000000000000000000000000000000000000000 8fe1130d96c453a16d08b9c7f8fa8eaaf92e91013e22e9540067f043bc3a9755 +hash_to_point 1200000000000000000000000000000000000000000000000000000000000000 008a91a51834a1aa276c5091406f0514e4ca3a7cfc70b5d7b87d84e768685754 +hash_to_point 1300000000000000000000000000000000000000000000000000000000000000 dcb2d5b787a4d37cda41775e3f5beee0243f0471005e0a5b41029dfa4ac9c6d8 +hash_to_point daffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f dcb2d5b787a4d37cda41775e3f5beee0243f0471005e0a5b41029dfa4ac9c6d8 +hash_to_point dbffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f 008a91a51834a1aa276c5091406f0514e4ca3a7cfc70b5d7b87d84e768685754 +hash_to_point dcffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f 8fe1130d96c453a16d08b9c7f8fa8eaaf92e91013e22e9540067f043bc3a9755 +hash_to_point ddffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f d0b4470440d3309047d4a9d7d7930f4ab9b47a27d43fb4fbc512594022fc55d5 +hash_to_point deffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f 9a799c1ffea35d18a9d442a57a08080d4659ba69c9e867731a81a560e9714c89 +hash_to_point dfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f dd1e8f50bfd83f94aa0f6a52ab10654c1dccabbd729fb274f6e4a01b006f34af +hash_to_point e0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f 79f979071f10c503862a0699c09ce2ca18e444cacf79fbfe2ba08d868033c221 +hash_to_point e1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f 4456bb03367ab4b8d86c37624bafe3530f5317eeb48cc0000f88539730ba37fc +hash_to_point e2ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f 22b50cc82330901a8f47c518e48970e1194827a0f50cb4952dc809881b6e3149 +hash_to_point e3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f 39f05f361fa5f99bc2847c2da1cc8fb799c1c5f89d88476928bd476b4627d8bd +hash_to_point e4ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f 18edd6f75b6359d0c8182ced6b8641a79768c6417ef5b4640e6d858d85f219b6 +hash_to_point e5ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f 8c02c2efad64ca492ff06bd558c746d86786e0b973455b4207f2506a9430862e +hash_to_point e6ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f 491d61605fba98a01d57b3df80790d37dbc04f2fe14aacebaaa40e47f2072b71 +hash_to_point e7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f d077430bb005b3743fa30458230520281887b13629bc33ca7826a3a6aff4d00c +hash_to_point e8ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f 99746a762349b0a9740303fc74ed4c1816d0daf3cafa5e537088d2c5dd85165f +hash_to_point e9ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f 8b2b2ca18c4ee6271f8853d35799f3706f5acc92985ecbc87bbfe210460c99d0 +hash_to_point eaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f a6393daaa028abc4a561b34f5f36fb7e4d44f0dbdc8aef3626d469734fd8678c +hash_to_point ebffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f fb6e2b404ea0a97df827c8ad5d3a4676fe7176665cbd464c46de72e633caca13 +hash_to_point ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f 5278d545cf9c859bb5ce01dc6c8b8d4e3a02271ca6d529c835e05a64981fcb8c +hash_to_point edffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f +hash_to_point eeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f 5278d545cf9c859bb5ce01dc6c8b8d4e3a02271ca6d529c835e05a64981fcb8c +hash_to_point efffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f fb6e2b404ea0a97df827c8ad5d3a4676fe7176665cbd464c46de72e633caca13 +hash_to_point f0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f a6393daaa028abc4a561b34f5f36fb7e4d44f0dbdc8aef3626d469734fd8678c +hash_to_point f1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f 8b2b2ca18c4ee6271f8853d35799f3706f5acc92985ecbc87bbfe210460c99d0 +hash_to_point f2ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f 99746a762349b0a9740303fc74ed4c1816d0daf3cafa5e537088d2c5dd85165f +hash_to_point f3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f d077430bb005b3743fa30458230520281887b13629bc33ca7826a3a6aff4d00c +hash_to_point f4ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f 491d61605fba98a01d57b3df80790d37dbc04f2fe14aacebaaa40e47f2072b71 +hash_to_point f5ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f 8c02c2efad64ca492ff06bd558c746d86786e0b973455b4207f2506a9430862e +hash_to_point f6ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f 18edd6f75b6359d0c8182ced6b8641a79768c6417ef5b4640e6d858d85f219b6 +hash_to_point f7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f 39f05f361fa5f99bc2847c2da1cc8fb799c1c5f89d88476928bd476b4627d8bd +hash_to_point f8ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f 22b50cc82330901a8f47c518e48970e1194827a0f50cb4952dc809881b6e3149 +hash_to_point f9ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f 4456bb03367ab4b8d86c37624bafe3530f5317eeb48cc0000f88539730ba37fc +hash_to_point faffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f 79f979071f10c503862a0699c09ce2ca18e444cacf79fbfe2ba08d868033c221 +hash_to_point fbffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f dd1e8f50bfd83f94aa0f6a52ab10654c1dccabbd729fb274f6e4a01b006f34af +hash_to_point fcffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f 9a799c1ffea35d18a9d442a57a08080d4659ba69c9e867731a81a560e9714c89 +hash_to_point fdffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f d0b4470440d3309047d4a9d7d7930f4ab9b47a27d43fb4fbc512594022fc55d5 +hash_to_point feffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f 8fe1130d96c453a16d08b9c7f8fa8eaaf92e91013e22e9540067f043bc3a9755 +hash_to_point ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f 008a91a51834a1aa276c5091406f0514e4ca3a7cfc70b5d7b87d84e768685754 +hash_to_point c7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff dcb2d5b787a4d37cda41775e3f5beee0243f0471005e0a5b41029dfa4ac9c6d8 +hash_to_point c8ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 008a91a51834a1aa276c5091406f0514e4ca3a7cfc70b5d7b87d84e768685754 +hash_to_point c9ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 8fe1130d96c453a16d08b9c7f8fa8eaaf92e91013e22e9540067f043bc3a9755 +hash_to_point caffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff d0b4470440d3309047d4a9d7d7930f4ab9b47a27d43fb4fbc512594022fc55d5 +hash_to_point cbffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 9a799c1ffea35d18a9d442a57a08080d4659ba69c9e867731a81a560e9714c89 +hash_to_point ccffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff dd1e8f50bfd83f94aa0f6a52ab10654c1dccabbd729fb274f6e4a01b006f34af +hash_to_point cdffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 79f979071f10c503862a0699c09ce2ca18e444cacf79fbfe2ba08d868033c221 +hash_to_point ceffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 4456bb03367ab4b8d86c37624bafe3530f5317eeb48cc0000f88539730ba37fc +hash_to_point cfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 22b50cc82330901a8f47c518e48970e1194827a0f50cb4952dc809881b6e3149 +hash_to_point d0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 39f05f361fa5f99bc2847c2da1cc8fb799c1c5f89d88476928bd476b4627d8bd +hash_to_point d1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 18edd6f75b6359d0c8182ced6b8641a79768c6417ef5b4640e6d858d85f219b6 +hash_to_point d2ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 8c02c2efad64ca492ff06bd558c746d86786e0b973455b4207f2506a9430862e +hash_to_point d3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 491d61605fba98a01d57b3df80790d37dbc04f2fe14aacebaaa40e47f2072b71 +hash_to_point d4ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff d077430bb005b3743fa30458230520281887b13629bc33ca7826a3a6aff4d00c +hash_to_point d5ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 99746a762349b0a9740303fc74ed4c1816d0daf3cafa5e537088d2c5dd85165f +hash_to_point d6ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 8b2b2ca18c4ee6271f8853d35799f3706f5acc92985ecbc87bbfe210460c99d0 +hash_to_point d7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff a6393daaa028abc4a561b34f5f36fb7e4d44f0dbdc8aef3626d469734fd8678c +hash_to_point d8ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff fb6e2b404ea0a97df827c8ad5d3a4676fe7176665cbd464c46de72e633caca13 +hash_to_point d9ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 5278d545cf9c859bb5ce01dc6c8b8d4e3a02271ca6d529c835e05a64981fcb8c +hash_to_point daffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f +hash_to_point dbffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 5278d545cf9c859bb5ce01dc6c8b8d4e3a02271ca6d529c835e05a64981fcb8c +hash_to_point dcffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff fb6e2b404ea0a97df827c8ad5d3a4676fe7176665cbd464c46de72e633caca13 +hash_to_point ddffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff a6393daaa028abc4a561b34f5f36fb7e4d44f0dbdc8aef3626d469734fd8678c +hash_to_point deffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 8b2b2ca18c4ee6271f8853d35799f3706f5acc92985ecbc87bbfe210460c99d0 +hash_to_point dfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 99746a762349b0a9740303fc74ed4c1816d0daf3cafa5e537088d2c5dd85165f +hash_to_point e0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff d077430bb005b3743fa30458230520281887b13629bc33ca7826a3a6aff4d00c +hash_to_point e1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 491d61605fba98a01d57b3df80790d37dbc04f2fe14aacebaaa40e47f2072b71 +hash_to_point e2ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 8c02c2efad64ca492ff06bd558c746d86786e0b973455b4207f2506a9430862e +hash_to_point e3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 18edd6f75b6359d0c8182ced6b8641a79768c6417ef5b4640e6d858d85f219b6 +hash_to_point e4ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 39f05f361fa5f99bc2847c2da1cc8fb799c1c5f89d88476928bd476b4627d8bd +hash_to_point e5ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 22b50cc82330901a8f47c518e48970e1194827a0f50cb4952dc809881b6e3149 +hash_to_point e6ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 4456bb03367ab4b8d86c37624bafe3530f5317eeb48cc0000f88539730ba37fc +hash_to_point e7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 79f979071f10c503862a0699c09ce2ca18e444cacf79fbfe2ba08d868033c221 +hash_to_point e8ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff dd1e8f50bfd83f94aa0f6a52ab10654c1dccabbd729fb274f6e4a01b006f34af +hash_to_point e9ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 9a799c1ffea35d18a9d442a57a08080d4659ba69c9e867731a81a560e9714c89 +hash_to_point eaffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff d0b4470440d3309047d4a9d7d7930f4ab9b47a27d43fb4fbc512594022fc55d5 +hash_to_point ebffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 8fe1130d96c453a16d08b9c7f8fa8eaaf92e91013e22e9540067f043bc3a9755 +hash_to_point ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 008a91a51834a1aa276c5091406f0514e4ca3a7cfc70b5d7b87d84e768685754 +hash_to_point edffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff dcb2d5b787a4d37cda41775e3f5beee0243f0471005e0a5b41029dfa4ac9c6d8 +hash_to_point eeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1f2ea9c11e83391af474ac5facee583a29206e6956f734b7eabe9c265b95b24a +hash_to_point efffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff faa522ef97c7c2044967b1b0b69003edbde301c90877bdd36f1498c1f30c4e7d +hash_to_point f0ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 6601b5cdc95529b160fc004d56330aacd75e059c592d80460215a114c957ba4a +hash_to_point f1ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 82d075d53c7a9336474b6220de57afb1eb3b27021e7bb2f9f8cc985900055147 +hash_to_point f2ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff f91a9a45346a8d59e40dc35b8019f8755e5c1fdc4cdff9c3f5d6e5ce82320702 +hash_to_point f3ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 941c79acdcdf3a45de828d7bbf6336f145b6871c62ea8efdc24b5722618a4d14 +hash_to_point f4ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 492027ffbda871e4bae9310a151a777eebe1bfe53370e124b4d67a626c9f9ba4 +hash_to_point f5ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff e2ad9f841941fddb73c306bf8d0bf24a16bc5e050a1554ef196f6171c1816d9b +hash_to_point f6ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 9ad0109e536a62b16ff21ec9fe0a15ddea8e20721f9930e947c136a7abc88a2e +hash_to_point f7ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff c54c2161e8035726dd01b7f26f30baae14c6aeccb542172a27dfe0781e804796 +hash_to_point f8ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2e82e567af49683c15389c27e09e30a12d5ea77c192d26598c013e9a9ca9a761 +hash_to_point f9ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 8eae5b7527372f172cf6bab67ac862f3ee8839fbc5e0a74307974e6721facdd4 +hash_to_point faffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff b30379213f5a76b413ab531d00376657db55aa0bcf58ade126b51c0afe6a4014 +hash_to_point fbffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff d02d43024e777f5fb3630a54d9e8c91e24dbe79eac84b531cd7ce6153761911f +hash_to_point fcffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 47c79f49603529da72f126f09f03eeb0df67906a86ce1d6ef1c54ebaa425679b +hash_to_point fdffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 9b238c928fe8993e63543b87c83d6cf17bc0524dc149b080102671bbcd3cfb8f +hash_to_point feffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 123a5287f4de990b3dcf9c32456a57349fb40bcf0963912c604770a8fb9e9a41 +hash_to_point ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 80c90f3f23af8763b058cf5029e42f6a78a3e48dc0eeb38f31b3a6419e64fdbf +hash_to_ec da66e9ba613919dec28ef367a125bb310d6d83fb9052e71034164b6dc4f392d0 52b3f38753b4e13b74624862e253072cf12f745d43fcfafbe8c217701a6e5875 +hash_to_ec a7fbdeeccb597c2d5fdaf2ea2e10cbfcd26b5740903e7f6d46bcbf9a90384fc6 f055ba2d0d9828ce2e203d9896bfda494d7830e7e3a27fa27d5eaa825a79a19c +hash_to_ec ed6e6579368caba2cc4851672972e949c0ee586fee4d6d6a9476d4a908f64070 da3ceda9a2ef6316bf9272566e6dffd785ac71f57855c0202f422bbb86af4ec0 +hash_to_ec 9ae78e5620f1c4e6b29d03da006869465b3b16dae87ab0a51f4e1b74bc8aa48b 72d8720da66f797f55fbb7fa538af0b4a4f5930c8289c991472c37dc5ec16853 +hash_to_ec ab49eb4834d24db7f479753217b763f70604ecb79ed37e6c788528720f424e5b 45914ba926a1a22c8146459c7f050a51ef5f560f5b74bae436b93a379866e6b8 +hash_to_ec 5b79158ef2341180b8327b976efddbf364620b7e88d2e0707fa56f3b902c34b3 eac991dcbba39cb3bd166906ab48e2c3c3f4cd289a05e1c188486d348ede7c2e +hash_to_ec f21daa7896c81d3a7a2e9df721035d3c3902fe546c9d739d0c334ed894fb1d21 a6bedc5ffcc867d0c13a88a03360c8c83a9e4ddf339851bd3768c53a124378ec +hash_to_ec 3dae79aaca1abe6aecea7b0d38646c6b013d40053c7cdde2bed094497d925d2b 1a442546a35860a4ab697a36b158ded8e001bbfe20aef1c63e2840e87485c613 +hash_to_ec 3d219463a55c24ac6f55706a6e46ade3fcd1edc87bade7b967129372036aca63 b252922ab64e32968735b8ade861445aa8dc02b763bd249bff121d10829f7c52 +hash_to_ec bc5db69aced2b3197398eaf7cf60fd782379874b5ca27cb21bd23692c3c885cc ae072a43f78a0f29dc9822ae5e70865bbd151236a6d7fe4ae3e8f8961e19b0e5 +hash_to_ec 98a6ed760b225976f8ada0579540e35da643089656695b5d0b8c7265a37e2342 6a99dbfa8ead6228910498cc3ff3fb18cb8627c5735e4b8657da846c16d2dcad +hash_to_ec e9cdc9fd9425a4a2389a5d60f76a2d839f0afbf66330f079a88fe23d73eae930 8aa518d091928668f3ca40e71e14b2698f6cae097b8120d7f6ae9afba8fd3d60 +hash_to_ec a50c026c0af2f9f9884c2e9b8464724ac83bef546fec2c86b7de0880980d24fb b07433f8df39da2453a1e13fd413123a158feae602d822b724d42ef6c8e443bf +hash_to_ec bf180e20d160fa23ccfa6993febe22b920160efc5a9614245f1a3a360076e87a 9d6454ff69779ce978ea5fb3be88576dc8feaedf151e93b70065f92505f2e800 +hash_to_ec b2b64dfeb1d58c6afbf5a56d8c0c42012175ebb4b7df30f26a67b66be8c34614 0523b22e7f220c939b604a15780abc5816709b91b81d9ee1541d44bd2586bbd8 +hash_to_ec 463fc877f4279740020d10652c950f088ebdebeae34aa7a366c92c9c8773f63a daa5fa72e70c4d3af407b8f2f3364708029b2d4863bbdde54bd67bd08db0fcad +hash_to_ec 721842f3809982e7b96a806ae1f162d98ae6911d476307ad1e4f24522fd26f55 4397c300a8cfcb42e7cc310bc975dc975ec2d191eaa7e0462998eb2830c34126 +hash_to_ec 384da8d9b83972af8cbefc2da5efc744037c8ef40efa4b3bacc3238a6232963d 3c80f107e6868f73ef600ab9229a3f4bbe24f4adce52e6ab3a66d5d510e0670d +hash_to_ec e26f8adef5b6fe5bb01466bff0455ca23fda07e200133697b3b6430ca3332bde e262a58bcc1f8baf1980e00d5d40ba00803690174d14fb4c0f608429ce3df773 +hash_to_ec 6e275b4ea4f085a5d3151aa08cf16a8c60b078e70be7ce5dac75b5d7b0eebe7c cb21b5a7744b4fcdc92ead4be0b04bcb9145e7bb4b06eff3bb2f0fe429b85108 +hash_to_ec a0dde4561ad9daa796d9cd8a3c34fd41687cee76d128bf2e2252466e3ef3b068 79a2eb06bb7647f5d0aae5da7cf2e2b2d2ce890f25f2b1f81bfc5fef8c87a7d3 +hash_to_ec dbaf63830e037b4c329969d1d85e58cb6c4f56014fd08eb38219bd20031ae27c 079c93ae27cd98075a487fd3f7457ad2fb57cdf12ec8651fedd944d765d07549 +hash_to_ec 1e87ba8a9acf96948bc199ae55c83ab3277be152c6d0b1d68a07955768d81171 5c6339f834116791f9ea22fcc3970346aaeddacf13fbd0a7d4005fbd469492ca +hash_to_ec 5a544088e63ddf5b9f444ed75a75bc9315c4c50439522f06b4823ecaf5e8a08d e95ca0730d57c6469be3a0f3c94382f8490257e2e546de86c650bdbc6482eaee +hash_to_ec e4e06d92ebb036a5e4bb547dbaa43fd70db3929eef2702649455c86d7e59aa46 e26210ff8ee28e24ef2613df40aa8a874b5e3c1d07ae14acc59220615aa334dc +hash_to_ec 5793b8b32dcc0f204501647f2976493c4f8f1fa5132315226f99f29a5a6fdfce 656e390086906d99852c9696e831f62cb56fc8f85f9a5c936c327f23c7faf4fe +hash_to_ec 84f56fa4d7f12e0efd48b1f7c81c15d6e3843ebb419f4a27ec97028d4f9da19e 0cbd4f0cd288e1e071cce800877de6aef97b63fff867424a4f2b2bab25602608 +hash_to_ec 242683ddf0a9fc55f6585de3aa64ea17c9c544896ff7677cd82c98f833bdf2ca 38c36d52314549213df7c7201ab7749a4724cbea92812f583bb48cabc20816ad +hash_to_ec a93ee320dc030aa382168c2eb6d75fce6e5a63a81f15632d514c6de8a7cfa5ee bd0a2facaa95bc95215a94be21996e46f789ee8beb38e75a1173b75fc686c505 +hash_to_ec e36136601d84475d25c3f14efe030363d646658937a8a8a19a812d5e6deb5944 2fb93d78fae299c9f6b22346acfb829796ee7a47ec71db5456d8201bec6c35a3 +hash_to_ec ba4b67d3d387c66baa4a32ec8b1db7681087e85076e71bab10036388c3aeb011 cc01329ce56f963bf444a124751c45b2c779ccb6dea16ca05251baca246b5401 +hash_to_ec 3fbc91896a2585154d6f7094c5ab9c487e29a27951c226eec1235f618e44946b 7d983acbb901bf5497d0708392e5e742ec8c8036cbb0d03403e9929da8cc85a7 +hash_to_ec a2da289fed650e9901f69a5f33535eb47c6bd07798633cbf6c00ce3172df76ac dca8a4d30ec2d657fefd0dba9c1c5fd45a79f665048b3cf72ac2c3b7363da1ac +hash_to_ec 99025d2d493f768e273ed66cacd3a5b392761e6bd158ca09c8fba84631ea1534 7ef5af79ab155ab7e1770a47fcd7f194aca43d79ec6e303c7ce18c6a20279b04 +hash_to_ec 3cf1d01d0b70fb31f2a2f979c1bae812381430f474247d0b018167f2a2cd9a9f 7c53d799ec938a21bb305a6b5ca0a7a355fa9a68b01d289c4f22b36ce3738f95 +hash_to_ec 639c421b49636b2a1f8416c5d6e64425fe51e3b52584c265502379189895668e 0b47216ae5e6e03667143a6cf8894d9d73e3152c64fb455631d81a424410e871 +hash_to_ec 4ccf2c973348b7cc4b14f846f9bfcdcb959b7429accf6dede96248946841d990 7fd41f5b97ba42ed03947dd953f8e69770c92cc34b16236edad7ab3c78cbbb2e +hash_to_ec f76ae09fff537f8919fd1a43ff9b8922b6a77e9e30791c82cf2c4b8acb51363e 8e2c6bf86461ad2c230c496ee3896da33c11cc020fd4c70faa3645b329049234 +hash_to_ec 98932da7450f15db6c1eef78359904915c31c2aa7572366ec8855180edb81e3a 86180adddfac0b4d1fb41d58e98445dde1da605b380d392e9386bd445f1d821c +hash_to_ec ab26a1660988ec7aba91fc01f7aa9a157bbc12927f5b197062b922a5c0c7f8dd 2c44a43eda0d0aad055f18333e761f2f2ec11c585ec7339081c19266af918e4f +hash_to_ec 4465d0c1b4930cc718252efd87d11d04162d2a321b9b850c4a19a6acdfca24f4 b03806287d804188a4d679a0ecee66f399d7bdc3bd1494f9b2b0772bbb5a034f +hash_to_ec 0f2a7867864ed00e5c40082df0a0b031c89fa5f978d9beb2fde75153f51cfb75 5c471e1b118ef9d76c93aec70e0578f46e8db1d55affd447c1f64c0ad9a5caa5 +hash_to_ec 5c2808c07d8175f332cae050ce13bec4254870d76abff68faf34b0b8d3ad5000 eeff1d9a5aa428b7aecc575e63dde17294072eb246568493e1ed88ce5c95b779 +hash_to_ec 36300a21601fad00d00da45e27b36c11923b857f97e50303bd01f21998eaef95 b33b077871e6f5dad8ff6bc621c1b6dedcf700777d996c8c02d73f7297108b7e +hash_to_ec 9e1afb76d6c480816d2cedd7f2ab08a36c309efaa3764dcdb51bad6049683805 4cd96ba7b543b1a224b8670bf20b3733e3910711d32456d3e58e920215788adf +hash_to_ec 685f152704664495459b76c81567a4b571e8b307dd0e3c9b08ee95651a006047 80dd6b637580cb3be76025867f1525852b65a7a66066993fda3af7eb187dc1a5 +hash_to_ec 0b216444391a1163c14f7b27f9135e9747978c0e426dce1fa65c657f3e9146be 021259695a6854a4a03e8c74d09ab9630a401bfca06172a733fe122f01af90b4 +hash_to_ec cfcb35e98f71226c3558eaa9cf620db5ae207ece081ab13ddea4b1f122850a5a 46763d2742e2cdffe80bb3d056f4d3a1565aa83f19aab0a1f89e54ad81ae0814 +hash_to_ec 07e7292da8cdcdb58ee30c3fa16f1d609e9b3b1110dd6fa9b2cc18f4103a1c12 fe949ca251ac66f13a8925ae624a09cdbf6696d3c110442338d37700536e8ec7 +hash_to_ec 813bc7e3749e658190cf2a4e358bc07a6671f262e2c4eef9f44c66066a72e6a7 6b92fbda984bd0e6f4af7a5e04c2b66b6f0f9d197a9694362a8556e5b7439f8a +hash_to_ec 89c50a1e5497156e0fae20d99f5e33e330362b962c9ca00eaf084fe91aaec71d ef36cb75eb95fb761a8fa8c376e9c4447bcd61421250f7a711bd289e6ed78a9b +hash_to_ec d9bd9ff2dd807eb25de7c5de865dbc43cce2466389cedbc92b90aab0eb014f81 30104771ff961cd1861cd053689feab888c57b8a4a2e3989646ea7dea40f3c04 +hash_to_ec b8c837501b6ca3e118db9848717c847c062bf0ebeca5a7c211726c1426878af5 19a1e204b4a32ce9cccf5d96a541eb76a78789dceaf4fe69964e58ff96c29b63 +hash_to_ec 84376c5350a42c07ac9f96e8d5c35a8c7f62c639a1834b09e4331b5962ecace8 ba1e4437d5048bd1294eadc502092eafc470b99fde82649e84a52225e68e88f2 +hash_to_ec a3345e4a4cfc369bf0e7d11f49aed0d2a6ded00e3ff8c7605db9a919cf730640 0d318705c16e943c0fdcde134aaf6e4ccce9f3d9161d001861656fc7ea77a0b1 +hash_to_ec 3c994dfb9c71e4f401e65fd552dc9f49885f88b8b3588e24e1d2e9b8870ffab1 984157de5d7c2c4b43b2bffea171809165d7bb442baea88e83b27f839ebdb939 +hash_to_ec 153674c1c1b18a646f564af77c5bd7de452dc3f3e1e2326bfe9c57745b69ec5c e9a4a1e225ae472d1b3168c99f8ba1943ad2ed84ef29598f3f96314f22db9ef2 +hash_to_ec 2d46a705d4fe5d8b5a1f4e9ef46d9e06467450eb357b6d39faa000995314e871 b9d1aec540bf6a9c0e1b325ab87d4fbe66b1df48986dde3cb62e66e136eba107 +hash_to_ec 6764c3767f16ec8faecc62f9f76735f76b11d7556aeb61066aeaeaad4fc9042f 3a5c68fb94b023488fb5940e07d1005e7c18328e7a84f673ccd536c07560a57b +hash_to_ec c99c6ee5804d4b13a445bc03eaa07a6ef5bcb2fff0f71678dd3bd66b822f8be8 a9e1ce91deed4136e6e53e143d1c0af106abde9d77c066c78ebbf5d227f9dde0 +hash_to_ec 3009182e1efac085c7eba24a7d9ef28ace98ebafa72211e73a41c935c37e6768 e55431a4c89d38bd95f8092cdf6e44d164ad5855677aba17ec262abc8c217c86 +hash_to_ec e7153acd114a7636a207be0b67fa86fee56dd318f2808a81e35dd13d4251b2d0 ff2b98d257e4d4ff7379e8871441ca7d26e73f78f3f5afcf421d78c9799ba677 +hash_to_ec 6378586744b721c5003976e3e18351c49cd28154c821bc45338892e5efedd197 3d765fb7bb4e165a3fa6ea00b5b5e22250f3861f0db0099626d9a9020443dda2 +hash_to_ec 5be49aba389b7e3ad6def3ba3c7dbec0a11a3c36fc9d441130ef370b8a8d29c2 2d61faf38062dc98ae1aaafec05e90a925c9769df5b8b8f7090d9e91b2a11151 +hash_to_ec f7bc382178d38e1b9a1a995bd8347c1283d8a2e8d150379faa53fd125e903d2b 544c815da65c3c5994b0ac7d6455578d03a2bc7cf558b788bcdb3430e231635a +hash_to_ec c28b5c4b6662eebb3ec358600644849ebeb59d827ed589c161d900ca18715fa8 a2d64db3c0e0353c257aadf9abc12ac779654d364f348b9f8e429aa7571203db +hash_to_ec 3a4792e5df9b2416a785739b9cf4e0d68aef600fa756a399cc949dd1fff5033a 4b54591bd79c30640b700dfb7f20158f692f467b6af70bd8a4e739c14a66c86a +hash_to_ec 002e70f25e1ceaf35cc14b2c6975a4c777b284a695550541e6f5424b962c19f5 73987e9342e338eb57a7a9e03bd33144db37c1091e952a10bd243c5bb295c18a +hash_to_ec 7eb671319f212c9cae0975571b6af109124724ba182937a9066546c92bdeff0c 49b46da3be0df1d141d2a323d5af82202afa2947a95b9f3df47722337f0d5798 +hash_to_ec ca093712559c8edd5c51689e2ddcb8641c2960e5d9c8b03a44926bb798a0c8dc b9ef9cf0f8e4a3d123db565afafb1102338bfb75498444ac0a25c5ed70d615da +hash_to_ec cfea0a08a72777ff3aa7be0d8934587fa4127cd49a1a938232815dc3fd8b23ac b4de604b3d712f1ef578195fb0e53c865d41e2dfe425202c6cfe6f10e4404eb5 +hash_to_ec aa0122ae258d6db21a26a31c0c92d8a0e3fdb46594aed41d561e069687dedcd6 5247eaec346de1c6cddf0ab04c12cd1d85cdb6d3a2fba2a5f9a5fe461abef5eb +hash_to_ec b3941734f4d3ba34ccaf03c4c737ac5a1e036eb74309300ce44d73aca24fef08 535938985c936e3780c61fe29a4121d6cb89a05080b6c2147031ea0c2b5b9829 +hash_to_ec 8c2ee1041a2743b30dcbf413cc9232099b9268f82a5a21a09b63e7aff750882f 6ad0d4b3a65b522dfad0e9ac814b1fb939bc4910bd780943c72f57f362754cca +hash_to_ec 4b6829a2a2d46c8f0d0c23db0f735fcf976524bf39ccb623b919dd3b28ad5193 2e0097d7f92993bc45ba06baf4ca63d64899d86760adc4eb5eeefb4a78561050 +hash_to_ec 9c1407cb6bba11e7b4c1d274d772f074f410d6fe9a1ee7a22cddf379257877d9 692261c7d6a9a7031c67d033f6d82a68ef3c27bd51a5666e55972238769821cd +hash_to_ec 638c42e4997abf8a4a9bffd040e31bd695d590cde8afbd7efd16ffdbae63bf66 793024c8ce196a2419f761dde8734734af6bd9eb772b30cc78f2cb89598dce97 +hash_to_ec 1fb60d79600de151a1cf8a2334deb5828632cbd91cb5b3d45ae06e08187ae23d ff2542cde5bc2562e69471a31cfc3d0c26e2f6ccc1891a633b07a3968e42521c +hash_to_ec d2fdbbae4e38a1b734151c3df52540feb2d3ff74edfef2f740e49a5c363406ee 344c83ba6ff4e38b257077623d298d2f2b52002645021241bc9389f81b29ad12 +hash_to_ec 836c27a6ddfe1a24aba3d6022dff6dfe970f142d8b4ac6afb8efcba5a051942f b8af481d33726b3f875268282d621e4c63f891a09f920b8f2f49080f3a507387 +hash_to_ec 46281153ddcdf2e79d459693b6fe318c1969538dd59a750b790bfff6e9481abf 8eaf534919ab6573ba4e0fbde0e370ae01eae0763335177aa429f61c4295e9d4 +hash_to_ec d57b789e050bf3db462b79a997dac76aa048d4be05f133c66edee56afd3dbe66 0c5a294cb2cbb6d9d1c0a1d57d938278f674867f612ed89dcbe4533449f1a131 +hash_to_ec 548d524d03ac22da18ff4201ce8dbee83ad9af54ee4e26791d26ed2ab8f9bfc7 c6609d9e7d9fd982dec8a166ff4fb6f7d195b413aad2df85f73d555349134f3b +hash_to_ec cc920690422e307357f573b87a6e0e65f432c6ec12a604eb718b66ba18897a56 6f11c466d1c72fccd81e51d9bda03b6e8d6a395e1d931b2a84e392dc9a3efa18 +hash_to_ec c7fb8a51f5fcd8824fc0875d4eb57ab4917cb97090a6e2288f852f2bb449edd9 45543fea6eed461016e48598b521f18ff70178afea18032b188deea3e56052fc +hash_to_ec c681bb1b829e24b1c52cb890036b89f0029d261c6a15e5b2c684ee7dfe91e746 263006fe2c6b08f1ab29cdf442472c298e2faf225bbf5c32399d3745cd3904bd +hash_to_ec e06411c542312fdd305e17e46be14c63bab5836dc8751da06164b1ae22d4e20f 901871be7a7ff5aecade2acff869846f3c50de69307ac155f2aa3a74d5472ef2 +hash_to_ec 9c725a2acb80fa712f9781da510e5163b1b30f4e1c064c26b5185e537f0614ea 02420d49257846eb39fddd196d3171679f6be21d9adac667786b65a6e90f57b1 +hash_to_ec 22792772820feafa85c5cb3fa8f876105251bef08617d389619697f47dff54f2 a3ad444e7811693687f3925e7c315ae55d08d9f4b0a29876bc2a891ab941c1c3 +hash_to_ec 0587b790121395d0f4f39093d10b4817f58a1e80621a24eea22b3c127d6ac5a2 86c417c695c64c7becaad0d59ddbb2bca4cb2b409a21253d680aac1a08617095 +hash_to_ec fa0b5f28399bef0cd87bfe6b8a2b69e9c5506fb4bacd22deba8049615a5db526 ede0ea240036ff75d075258a053f3ce5d6f77925d358dbe33c06509fc9b12111 +hash_to_ec 62a3274fc0bed109d5057b865c2ba6b6a5a417cb90a3425674102fcd457ede2d ff7e46751bb4dcd1e800a8feab7cf6771f42dc0cfed7084c23b8a5d255a6f34e +hash_to_ec a6fcd4aecaaaf281563b9b7cd6fbc7b1829654f644f4165942669a2ef632b2bf 28f136be0eb957a5b36f8ec294399c9f73ad3a3c9bb953ad191758ced554a233 +hash_to_ec 01baa4c06d6676c9b286cda76ed949fd80a408b3309500ba84a5bb7e3dce58e2 a943d1afa2efce284740e7db21ea02db70b124808be2ff80cbf9b9cb96c7b73e +hash_to_ec dd9aff9c006ba514cef8fae665657bc9813fe2715467cf479643ea4c4e365d6d 68de2f7d49de4004286ce0989a06a686b15d0f463a02ffd448a18914e1ddf713 +hash_to_ec 3df3513d5e539161761ce7992ab9935f649bc934bed0da3c5e1095344b733bb9 e9c2dd747d7b2482474325943cd850102b8093164678362c7621993a790e2a8a +hash_to_ec 7680cfb244dc8ef37c671fff176be1a3dad00e5d283f93145d0cbee74cca2df4 a0fd8c3cca16a130eaa5864cbe8152b7adfbf09e8cf72244b2fc8364c3b20bf4 +hash_to_ec 8a547c38bd6b219ea0d612d4a155eba9c56034a1405dcf4b608de787f37e0fd8 76bf0dc40fd0a5508c5e091d8bb7eccfa28b331e72c6a0d4ac0e05a3d651850b +hash_to_ec dd93901621f58465e9791012afa76908f1e80ad80e52b809dc7fc32bb004f0a8 09a0b7ecfe8058b1e9ee01c9b523826867ca97a32efad29ac8ceebca67a4ea00 +hash_to_ec b643010220f1f4ee6c7565f6e1b3dc84c18274ede363ac36b6af3707e69a1542 233c9ff8de59e5f96c2f91892a71d9d93fa7316319f30d1615f10ac1e01f9285 +hash_to_ec c2637b2299dfc1fd7e953e39a582bafd19e6e7fff3642978eb092b900dbfea80 339587ba1c05e2cba44196a4be1fd218b772199e2c61c3c0ff21dcd54b570c43 +hash_to_ec 1f36d3a7e7c468eb000937de138809e381ad2e23414cbbaac49b7f33533ed486 7e5b0a96051c77237a027a79764c2763487af88121c7774645e97827fb744888 +hash_to_ec 8c142a55f60b2edbe03335b7f90aa2bd63e567048a65d61c70cb28779c5200af d3d6d5563b3d81c8c91cf9806bb13b2850fb7c162c610fd2f5b83c464add8182 +hash_to_ec 99e7b98293c9de1f81aff1376485a990014b8b176521b2a68cdbde6300190398 119cbc01a1d9b9fb4759031d3a70685aebea0f01bc5ee082ce824265fd21b3b4 +hash_to_ec 9753bd38be072b51490290be6207ca4545e3541bdf194e0850ae0a9f9e64b8ba 1ad3aa759863153606fa6570f0e1290baded4c8c1f2ba0f67c1911bfc8ccd7a0 +hash_to_ec 322703864ceee19b7f17cec2a822f310f0c4da3ff98b0be61a6fd30ac4db649c 89d9e7a5947e1cde874e4030de278070aae363063cd3592ce5411821474f0816 +hash_to_ec c1acd01e1e535fad273a8b757d981470f43dd7d95af732901fbba16b6e245761 57e80445248111150da5e63c706b4abbf3eef2cc508bd0347ff6b81e8c59f5bc +hash_to_ec 492473559f181bbe78f60215bc6d3a5168435ea2fc0a508372d6f5ca126e9767 df3965f137cf6f60c56ebd7c8f246281fd6dc92ce23a37e9f846f8452c884e01 +hash_to_ec afa9d6e0e2fb972ee806beb450c2c0165e58234b0676a4ec0ca19b6e710d7c35 669a57e69dd2845a5e50ed8e5d8423ac9ae792a43c7738554d6c5e765a7b088a +hash_to_ec 094de050bdadef3b7dbaeeca29381c667e63e71220970149d97b95db8f4db61b 0cf5d03530c5e97850d0964c6a394de9cde1e8e498f8c0e173c518242c07f99a +hash_to_ec 2ce583724bc699ad800b33176a1d983512fe3cb3afa65d99224b23dae223efb7 e1548fd563c75ae5b5366dbab4cb73c54e7d5e087c9e5453125ff8fbe6c83a5c +hash_to_ec 8064974b976ff5ef6adaade6196ab69cda6970cd74f7f5899181805f691ad970 98ae63c47331a4ac433cb2f17230c525982d89d21e2838515a36ec5744ec2d15 +hash_to_ec 384911047de609c6ae8438c745897357989363885cef2381a8a00a090cf04a58 4692ec3a0a03263620841c108538d584322fdd24d221a74bf1e1f407f83828af +hash_to_ec 0e1b1ced5ae997ef9c10b72cfc6d8c36d7433c01fc04f4083447f87243282528 6ee443ab0637702b7340bd4a908b9e2e63df0cc423c409fb320eb3f383118b80 +hash_to_ec 5a7aea70c85c040af6ff3384bcaa63ec45c015b55b44fffa37ab982a00dc57c5 2df2e20137cefd166c767646ecd2e386d28f405aebe43d739aa55beba04ed407 +hash_to_ec 3e878a3567487f20f7c98ea0488a40b87f1ba99e50bbfe9f00a423f927cbd898 697c7e60e4bf8c429ba7ac22b11a4b248d7465fc6abe597ec6d1e1c973330688 +hash_to_ec c0bb08350d8a4bb6bf8745f6440e9bd254653102a81c79d6528da2810da758e4 396a872ac9147a69b27223bf4ec4198345b26576b3690f233b832395f2598235 +hash_to_ec 6c3026a9284053a4ddb754818f9ae306ffa96eb7003bd03826eeccc9a0cf656e bef73da51d3ba9972a33d1afb7d263094b66ab6dbe3988161b08c17f8c69c2d5 +hash_to_ec f80b7d8f5a80d321af3a42130db199d9edcb8f5a82507d8bfca6d002d65458b6 aa59c167ea60ee024421bfbd00adbb3cbfc20e16bd3c9b172a6bef4d47ca7f57 +hash_to_ec bc0ffc24615aa02fafef447f17e7b776489cd2cc909f71e8344e01cad9f1610d 5c4195cc8dc3518143f06a9c228ae59ec9a6425a8fab89bfc638ad997cf35220 +hash_to_ec b15fad558737229f8816fcba8fbef805bd420c03e392d118c69bdf01890c4924 f5810477e37554728837f097e1b170d1d8c95351c7fff8abbbfc624e1a50c1b9 +hash_to_ec ec8c1f10d8e9da9cf0d57c4a1f2c402771bed7970109f3cf21ad32111f1f198f a697e0a3f09827b0cf3a4ffb6386388feda80d30ffffcbd54443dafcba162b28 +hash_to_ec a989647bf0d70fdb7533b8c303a2a07f5e42e26a45ffc4e48cff5ba88643a201 450fd73e636f94d0d232600dd39031386b0e2ecde4105124fc451341da9803db +hash_to_ec 7159971b03c365480d91d625a0fadc8e3a632c518acf0dbec87dd659da70e168 377bc43c038ac46cf6565aa0a6d6bf39968c0c1142755dba3141eeebf0acdf5d +hash_to_ec e39089a64fedac4b2c25e36312b33f79d02bf75a883f450f910915b8560a3b06 77efa7db1be020e77596f550de45626824a8268095d56a0991696b211cb329cc +hash_to_ec 2056b3c6347611bb0929dad00ec932a4d9bec0f06b2d57f17e01ffa1528a719e b6072c2be2ce928e8cbbb87e8eb7e06975c0f93b309dd3b6a29edaad2b56f99b +hash_to_ec 2c026793146e81b889fc741d62e06c341ce263560d57cd46d0376f5b29174489 8f1f64b67762aa784969e954c196a2c6610addc3604aa3291eb0b80304dfe9ef +hash_to_ec be6026d6704379c489fa7749832b58bdb1a9685a5ffb68c438537f2f76e0011f 0072569a4090a9ad383a205bb092196c9de871c22506e3bb63d6b9d1b2357c96 +hash_to_ec f4db802d5c6b7d7b53663b03d988b4cd0c7cad6c26612c5307754a93ebdc9710 f21bc9be4cb28761f6fe1d0a555ad5e9748375a2e9faea25a1df75cc8d273e18 +hash_to_ec c27d79a564c56b00956a55090481e85fbc837fd5fb5e8311ecb436e300c07e3a 1b1891e6abec74621501450cd68bb1eeaa5b2fffff4ec441a55d1235ff3a0842 +hash_to_ec a1e2f93c717cad32af386efa624198973df5a710963dd19d4c3ac40032a3a286 69c60571e3f9f63d2bfb359386ae3b8cd9e49a2e9127753002866e85c0443573 +hash_to_ec 76920d7b1763474bc94a16433c3c28241a9acdee3ff2b2cb0e6757ba415310aa c1b409169f102b696fc7fa1aa9c48631e58e08b5132b6aadf43407627bb1b499 +hash_to_ec 57ac654b29fa227c181fff2121491fcb283af6cbe932c8199c946862c0e90cb2 a204e8d327ea93b0b1bd74a78ffc370b20cea6455e209f2bc258114baa16d728 +hash_to_ec 88e66cfaef6432b759c50efce885097d1752252b479dac5ed822fa6c85d56427 6fb84790d3749a5c1088209ee3823848d9c19bf1524215c44031143dd8080d70 +hash_to_ec c1e55da929c4f8f793696fc77ff4e1c317c34852d98403bfd15dd388ee7df0df 2f41e76f15c5b480665bd84067e3b543b85ce6de02be9da7a550b5e1ead94d34 +hash_to_ec 29e9ace5aa3c5a572b13f4b62b738a764d90c8c293ccb062ad798acbab7c5ef4 bce791aba1edc2a66079628fd838799489ab16b0a475ce7fe62e24cc56fe131c +hash_to_ec f25b2340689dadacaa9a0ef08aee8447d80b982e8a1ea42cf0500a1b9d85b37d f7f53aa117e6772a9abc452b3931b0a99405ac45147e7c550ac9fcf7ffe377b5 +hash_to_ec 0cb6c47fc8478063b33f5aed615a05bcc84d782c497b6cc8e76ec1fa11edbfdb 7a0b58b03147e7c9be1d98de49ead2ce738d0071b0af8ca03cc92ceb26fc2246 +hash_to_ec 7bd7287d7c4b596fe46fe57a6982c959653487bea843a77dd47d40986200d576 343084618c58284c64a5ff076f891be64885dc2ac73fa1567f7b39fde6b91542 +hash_to_ec e4984bf330708152254fb18ecef12d546afd24898a3cf00fba866957b6ee1b82 c70e88b061656181fbd6ff12aca578fb66de5553c756ea4698a248b177185bc6 +hash_to_ec cefd6c3cb9754ea632d6aea140af017de5ea12e5184f868936b74d9aa349d603 4b476502a8a483aadd50667f262f95351901628dd3a2aac1a5a41c4ea03f1647 +hash_to_ec da5d0f33344ee7f3345204badf183491b9452b84bccc907602c7bad43e5cf43e 9561b9e61241625e028361494d4fa5cd78df4c7219fa64c8fede6d8421b8904a +hash_to_ec d6f0a4f8c770a1274a76fd7ae4e5faf7779249263e1aaecc6f815cf376f5c302 cd5c55820be10f0d38feb81363ede3716a9168601a0dd1ce3109aab81367d698 +hash_to_ec b6bf32491d12a41c275d8518fc534d9a0d17aade509e7e8b8409a95c86167307 4aae534abbd67a9a8f2974154606c0e9be8932e920c7a5e931b46a92859acf82 +hash_to_ec 0f930beaad041f9cefd867bc194027dd651fb3c9bda5944ececdba8a7136b6d3 521708f8149891b418d0920369569a9d578029c78f8e41c68a0bb68d3ad5df60 +hash_to_ec 49b1fe0f97be74b81e0b047027b3e9f726fa5e90a67dafa877309397291c06c5 0852e59dfae5ec32cce606c119376597bce5cd4d04879d329f74e3ec66414cd3 +hash_to_ec 4d57647d03f2cfbd4782fcc933e0683b52d35fc8d37283e6c7de522ddfa7e698 cbeb9ebfbbc49ec81fac3b7b063fecac1bb40ea686d3ffb08f82b291715cd87f +hash_to_ec 4ea3238c06fc9346c7421ff85bc0244b893860b94bc437378472814d09b2e99f a1fbae941adc344031bbdf53385dfdc012311490a4eb5e9a2749a21b27ce917a +hash_to_ec 0cd3609f5c78b318cb853d189b73b1ee2d00edd4e5fce2812027daa3fcb1fed1 0c7a7241b16e3c47d41f5abbf205797bd4b63fc425a7120cb2a4bf324e08ae74 +hash_to_ec d74ab71428e36943c9868f70d3243469babd27988a1666a06f499a5741a52e3e 65b7c259f3b4547c082b2a7669b2b363668c4d87ac14e80471317b03b34e5216 +hash_to_ec f6b151998365e7d69bcbce383dd2e8b5bf93b8b72f029ff942588208c1619591 6ce840ce5dfbca238665c1e6eddb8b045aa85c69b5976fc55ab57e66d3d0a791 +hash_to_ec 207751de234b2bd7ec20bdd8326210c23aa68f04875c94ad7e256a96520f25d6 fc8f79ab3af317c38bfb88f40fb84422995a0479cfa6b03fa6df7f4e5f2813fb +hash_to_ec 62291e2873f38c0a234b77d1964205f3f91905c261d3c06f81051a9b0cb787cb 076d1d767457518e6777cb3bd4df22c8a19eb617e4bbccd1b0bd37522d6597a5 +hash_to_ec 4b060df2d2854036751d00190ee821cb0066d256d4172539fdfa6fbd1cdfe1f9 59866e927c69e7de5df00dc46c0d2a1ddf799d901128ff040cebb8fd61b95da4 +hash_to_ec ac8daf73f9c609bb36bce4fdeec1e50be5f22de38c3904fabcf758f0fc180bc7 7d8dc4e956363b652468a5fecafd7c08d48a2297e93b8edcb38e595fdd5a1fde +hash_to_ec fef7b6563fd27f3aab1d659806b26b8f2ec38bc8feefad50288383c001d1c20f e6e42547f12df431439d45103d2c5a583248f44554a98a3a433cf8c38b11805d +hash_to_ec 40a3d6871c76ecc6bb7b28324478733e196cc11d062dd4c9265cf31be5cf5a97 8c55a3811c241a020b1be202a58d5defbc4c8945d73b132570b47dd7c019ccf0 +hash_to_ec 0cd71e7e562b2b47f4bc8640caf20e69d3a62f10231b4c7a372c9691cff9ac3c fb8e4e3de479b3bf1f4f13b4ed5507df1e80bd9250567b9d021b03339d6e7197 +hash_to_ec 40a4e62800a99b7a26e0b507ffb29592e5bdba25284dc473048f24b27d25b40a 90ae131d29ee4a71cd764ab26f1ca4e6d09a40db98f8692b345c3a0e130dc860 +hash_to_ec 1ddf35193cf52860bfe3e41060a7f44281241c6ae49cd541d24c1aca679b7501 3b4f50013895c522776ced456329c4e727de03575f6b99ae7d238a9f70862121 +hash_to_ec 014e0fa8ce9d5df262b9a1765725fde354a855de8aef3fc23684e05dd1ba8d34 3857f57776a3cb68721bcb7f1533a5f9fb416a1dc8824d719399b63a142d24de +hash_to_ec 09987979b0e98d1d5355df8a8698b8f54d3a037d12745c0a4317fe519c3df9cc 32a181e2b754aeced214c73ac459c97d99e63317be3eb923344c64a396173bca +hash_to_ec 51e9e8ec4413e92dbaaba067824c32b018487a8d16412ed310507b4741e18eed 0356b209156b4993fd5d5630308298429a1b0021c19bedecb7719ac607cfa644 +hash_to_ec 14d91313dfe46e353310e6a4a23ee15d7a4e1f431700a444be8520e6043d08d9 6f345f4018b5d178d9f61894d9f46ac09ff639483727b0d113943507cee88cfd +hash_to_ec 0d5af9ace87382acfffb9ab1a34b6e921881aa015d4f6d9c73171b2b0a97600d a8dbf36c85bebe6a7b3733e70cd3cd9ed0eb282ca470f344e5fcf9fe959f2e6e +hash_to_ec 996690caac7328b19d20ed28eb0003d675b1a9ff79055ab530e3bf170eb22a94 14340d7d935cffce74b8b2f325c9d92ce0238b51807ef2c1512935bb843194ce +hash_to_ec ad839c4b4c278c8ebe16ff137a558255a1f74646aa87c6cd99e994c7bb97ce8a d4f2da327ffded913b50577be0e583db2b237b5ca74da648e9b985c247073b76 +hash_to_ec 26fc2eeeee983e1300d72362fdff42edf08038e4eee277a6e2dbd1bd8c9d6560 3468b8269728c2c0bfc2e53b1575415124798bc0f59b60ea2f14967fc0ca19ce +hash_to_ec db33cecaf4ee6f0ceba338cc5fabfb7462cd952a9c9007357ff3f0ca8336f8bc 0bab38f58686d0ff770f770a297971510bc83e2ff2dfead34823d1c4d67f11af +hash_to_ec a0ee84b3c646526fb8787d26dcd9b7fe9dc713c8a6c1a4ea640465a9f36a64df 4d7a638f6759d3ec45339cd1300e1239cca5f0f658ca3cd29bc9bdb32f44faf0 +hash_to_ec 6a702e7899fcf3988e2b6b55654c22e54f43d3fa29de19177bdff5b2295fe27f 145d5748d6054fb586568e276f6925aef593a5b9c8249ad3dbef510af99b4307 +hash_to_ec 30ce0fd4f1fac8b62d613b8ee4a66deef6eb7094bd8466531050b837460f6971 f3aa850d593ba7cef01389f7e1916e57617f1d75cd42f64ce8f5f272384b148c +hash_to_ec 3aa31d4ad7046ad13d83eb11c9a6e90eb8483a374a77a9a7b2a7cc0978fefa76 2fe0827dc080d9c1e7ec475a78aa7ae3c86d1a35f4c3f25f4a1f7299cacf018a +hash_to_ec 8562a5a91e763b98014523ebb6e49120979098f89c31df1fde9eb3a49a15b20f ae223bf85e2009a9daf5fd8a14685e2e1e625fc88818b2fd437dd7e109a48f59 +hash_to_ec ccf9c313a47b8dbf7ce42c94b785818bc24134d95b6d22acc53c1ec2be29cf27 3e79fce6fe5aa14251b6560df4b76e811d7739eec097f27052c4403a283be71d +hash_to_ec d1e33cd6f8918618d5fb6d67ad8de939db8beaec4f115551eac64479b739b773 613fffcbe1bf48bb2d7bfd64fd97790a06025f8f2429edddb9ac145707847ecf +hash_to_ec 81eaeced34dd44e448d5dafa5715225e4956c90911c964a96ff7aa5b86b969bc 8f81177495d120a1357380164d677509b167f2958eb8b962b616c3951d426d8c +hash_to_ec 2bc001a29f8eab1c7377de69957ba365fb5bdaf9c2c220889709af920dfe27d3 9bcb3010038f366fa4c280eed6e914a23bfc402594d0b83d0e66730a465a565b +hash_to_ec 6feeb703c05e86c58d9fc5623f1af8657ecd1e75a14d18c4eedb642a8a393d16 6544628ba67ed0e14854961739c4d467fcf49d6361e39d32ea73dabeae51e6c3 +hash_to_ec e8ff145a7c26897f2c1639edd333a5412f87752f110079f581ccdc87fcce208c d4b5a6e06069c7e012e32119f8eda08ff04a8dfa784e1cf1bced455a4d41d905 +hash_to_ec 80488131dcb2018527908dbf8cdf4b823ef0806dc1d360f4da671004ef7ff74d 9984a79d9fd4f317768b442161116eef84e2ca49e938642b268fd64312d59a27 +hash_to_ec d8c4ca60446849a784d1462aa26a3b93073ff6841cb2da3ef52ab9785b00b1fd da5ec1562e7de2382d35728312f4eea3608d4dba775c1c108de510e1ce97d059 +hash_to_ec 68645728dfc6b9358dfb426493238ba38f24a2f46a3e89edb47d212549939cb7 d3253aa7235113dcc1b577d3bb80be34f528398815a653dbdbacbcbdfd5887a1 +hash_to_ec 4e8eb97ba2d1046e1b42e67530a61441e31c84e5e5e448d8e8dbe75d104eaccb de94f73e83222aa0e39b559d4fef70387b0815b9b2f6beff5da67262d8f0eb3e +hash_to_ec 104ff03122ffdf59b22b8c0fe3d8f2ef67d02328e4d5181916d3d2a92f9a0bb7 1517ccf69c0328327e1cf581f16944ff66bc91c37e1cd68a99525415e00b7c9f +hash_to_ec 80f23aae7356ae9a2f9f7504495a731214d26f870fb7df68fdc00b233494156f 7aef046b0a70f84e8d239aa95e192b5a3fffa0fae5090c91273e8996beca9e38 +hash_to_ec 2424b33235955a737ebddbf1c6c59cd8778af74da3bd3e658447666a2ab2f557 d19e2be8d482950fbdae429618da7a9daedb8c5944dea19cd1b6b274e792231b +hash_to_ec 0adc839d2b8f099e4341a4763b074c06318d6bcbd1ec558d20a9820c4a426463 cea5da12a84e5c20011726d9224a9930bec30f9571762dd7ca857b86bd37d056 +hash_to_ec 46c84d53951f1ba23c46a23d5d96bf019c559aa5d2d79e4535cfcdb36f38ce25 2a913a01a6f7dd78a43cdd5354d1160d9a5f0d824c489a892c80eba798a77567 +hash_to_ec 99bdaaf68555ccdc93d97c3a0fb4c126a1aa8b1202194a1a753401a6cae21055 1f645efe173577a092f2d847cc966e28ba3b36397fe84c96dfa4724ed4fcfdf9 +hash_to_ec c540ff78f1e063ad26ffa69febb8818c9f2a325072c566091ad816e40fe39af4 de7a762262c91ab4beccc0713233cb91163aec43e34de0dbcfad0c431e8a9722 +hash_to_ec de8b1ff8978cd5e02681521542b7b6c3c2f8f4602065059f83594809d04e3dda 290601e75207085bff3e016746e55a80310a76dea9ef566c24181079c76da11c +hash_to_ec d555994c8a022e52602d2a8bdd01fc1bfa6b9ab6734ff72a1bd5f937de4627f8 5f6794e874f48c4b362d0a24207374c2d274e28de86351afc6ddb95d8cc2fd62 +hash_to_ec 19db72f703fe6f1b73f21b6ba133ae6b111ae8cc496d3aa32e02411e34c0d8d7 42f159f43d2d62b8cf8a47d5f1340c5cf070e9860fc60de647c55d50fe9f5607 +hash_to_ec 23a87a258c2a5d1353aa2d5946f9e5749b92f85e3c58e1d177c3b6c3dcac809c e5685016f79d5e87d1fecb3e2a0fe64e4875f7accd2f6649d7f6b16317549cb1 +hash_to_ec 43e1738d7d1b5b565f5fc78e81480f7edf9a4dc18f104fc4be95135b98931b17 650f5b682e45f2d0c5d5e8bcfd9e0cda7d9071b55ecbfaf5e3b59941cd7479f2 +hash_to_ec a9d644de0804edf62dee613efa2547e510990a9b7a987ebe55ec74c23873a878 52ad329f88499a4f110e6a6cba1f820012d8db6ccb8f6495ab1e3eb5a24786e1 +hash_to_ec 11f2b5d89a0350d7c8727becf0f4dd19bd90f8c94ff207132ab13282dd9b94e6 b798a47bb98dc2a8f99deaf64d27638e33a0d504c5d2fbee477a2bc9b89e2838 +hash_to_ec 5e206e3190b3b715d125f1a11fff424fb33e36e534c99ddde2a3517068b7dcc4 2738e9571c96b2ddf93cb5f4a72b1ea78d3731d9555b830494513c0683c950ca +hash_to_ec efc3d65a43d4f10795c7265a76671348f80173e0f507c812f7ae76793b99c529 cf4434d18ce8167b51f117fe930860143c46e1739a8db1fba73b6b0de830d707 +hash_to_ec 81f00469788aad6631cf75b585ae06d43ec81c20479925a2009afac9687dff60 c335b5889b36ba4b4175bb0d986807e8eedb6f6b7329b70b922e2ab729c4202a +hash_to_ec 9ef5ff329b525ee8f5c3ac38e1dba7cb19985617341d356707c67ff273aed02d bef9f9e051ba0e24d1fdf72099cf43ecdd250d047fb329855b5372d5c422db9e +hash_to_ec 3fa1401bd63132cf8b385c0fa65f0715ba1fe6161e41d59f8033ae2b22f63fa1 8289a1cb3c2dae48879bb8913fafe2d196cc2fdab5f2a77607910efd33eae6df +hash_to_ec 6559836fd0081fa38a3f8d8408b564e5698b9797cf5e15f7f12a7d2c84511989 28d405a6687d2ecc90c1c66bf0454d58f3fa38835743075e1db58c658e15a104 +hash_to_ec 8e0882d45f0e4c2fb2839d3be86ff699d4b2242f5b25ac5a3c2f65297c7d2032 2771fdcf9135a62007adb5f0004d8222f0e42f819c81710aa4dc3ab2042bebf3 +hash_to_ec 1d91dc4dd9bd82646029d13aca1af96830c1d8a0400ddebeb14b00c93501c039 7792c62e897f32cbc9c4229f0d28f7882ceeae120329a1cd35f76a75ac704e93 +hash_to_ec 09527f9052acbbdd7676cbbd9534780865f04a27aaadad2b7d4f1dac68883cf0 b934220cde1327f2dc6af67bcb4124bf424d5084ef4da945e4daad1717cd0bb8 +hash_to_ec 2362e1abe73e64cdd2ca7f6c5ea9f467213747dd3f2b7c6e5df9cb21e03307d7 676b7122b96564358bbaaf77e3a5a4db1767e4f9a50f6ddd1c69df4566755af9 +hash_to_ec 26c2dd2356e9b6c68a415b25f91d18614dc8500c66f346d28489da543ee75a94 0f4fd7086acd68eb7c9fa2410e2ecf18e34654eb44e979bc03ce436e992d5feb +hash_to_ec 422dc0a09d6a45a8e0b563eeb6a5ee84b08abd3a8cb34ff93f77ba3b163f4042 631f1b412ff5a0fccbe53a02b4a3deaa93a0418ed9874df401eb698ef75d7441 +hash_to_ec ceecdf46f57ef3f36ff30a1a3579b609340282d1b26ab5ddef2f53514e91bab1 9bc6f981fe98d14a2fc5b01a8134b6d35e123ec9ab8a3f303e0a5abb28150e2e +hash_to_ec 024a9e6e0d73f28aa6207fb1e02ce86d444d2d46f8211e8aaab54f459db91a5a 5fb0c1d2c3b30f399102104ea1874099fa83110b3d9c1fcfffb2981c98bf8cdf +hash_to_ec 5b8e45e269c9ccac4c68e532a72b29346d218f4606f37a14064826a62050e3a8 c7be46a871b77fc05ce891d24bd6bd54d9775b7ef573c6bc2d92b67f3604c1d1 +hash_to_ec 9a6593a385c266389eef14237874b97bdcd1823c3199311667d4853c2d12aa81 9f55ee9d94102d2b9c5670f30586cf9823bf205b4d4fe088c323e87c4e10f26f +hash_to_ec 27377e2811598c3569b92990865d39b72c7a5533e1be30f77330863187c11875 abd82bc726f2710a8b87e4c1cf5a069f0ae800de614468d3ff35639983020197 +hash_to_ec 7cacfaa135fb7d568b8dce8ea9136498b1b28c6d1020af45d376288d78d411f0 229fccd49744c0692508af329224553d21561ee6062b2b8a21f080f73da5bd97 +hash_to_ec 52abd90a5542d6496b8dec9567b020f30058e29458d64f2d4f3ad6f3bfc1a5a0 874e82ced7cf77577b3374087fb08a2300b7f403de628310c26bdb3be869d309 +hash_to_ec 5c8eebe9d12309187afa8d0d5191de3fdb84e5a05485d7cd62e8804ce7fdc0bc 12b7537643488aa8b9dcc4bae040cd491f8b466163b7988157b0502fb6c9177f +hash_to_ec 6ca3dd5c7a21a6bf65d6eefbe20a66e9b1d6b64196344be0c075f47aea48e3aa 5e1d0705ee24675238293b73ab1d98359119d4b328275be2460cc6ee4d19cc88 +hash_to_ec d7e6cd0d39b4308c2a5ee547c4569c8bb3887e49cedece62d218d7c3c5277797 793dc4397112dfd9a8f4e061f457eb6d6fbb1d7a58c40bad5f16002c64914186 +hash_to_ec 9cb6de8ba967cca0f0f861c6e20546f8958446595c01c28dae7ba6cfa09d6b14 ba1a2f7502b58fee3499c20e35fa01bb932e7a7c4a925dc04fbf5d90f33cfb5e +hash_to_ec 8ef9c7366733a1edcd116238cdbd177d61222d5c3e05b30ef6b85014cbcb6b79 8fc89664722947164ac9b77086aed319897612068f56ecd57f47029f14671603 +hash_to_ec 7f317a34e4fb7de9f69cb107ffc0e57fd9f5c85b85ccb5319d05cebfc169924a 4b71c42339c73db7d710cd63f374d478a6c13bdc352cff40e967282268965ba7 +hash_to_ec 15beef8d9687b92918a903b01d594859db4e7128263c8db0cae9d423ff962c1e cd75e6323952f6ac88f138f391b69f38c46d70b7eda61f9e431725b6f1d514a5 +hash_to_ec 7a1c04c9af8fc6649833fe81e96f0199fcfe94959256cbe1490075fc5be0904e 0368270cd979439ae0a9552a5d6c9f959e4247fcf920d9e071464582e79c04b1 +hash_to_ec c854c583d338615f85f69061e0fa9c9d7c5bbbfe562e8774fef3be556fe8bb63 061620171d7320f64bee98414ff7200a1f481521d202fb281cab06be73b80402 +hash_to_ec 0fb8af5aba05ad2503edf1cfad5a451da088e7e974772057cd991a4e0601a3eb d3cbc20384a4420143fcce2cb763b0c15bec4f3267d1bdad3c34c1ee6b790f5e +hash_to_ec 9a251cf59e84a9da5630642f9671c732440caa8fcf4c92446a7e5f5ef99da46c 9b9679086a433f2077f40bcd4c7545fb5cc87e7dbb8bba468d53cb04a74361a0 +hash_to_ec 8c632e357cef00e0911eb566f8cc809136b3f5ac1e82d183e4d645cef89fa155 5e06b0f4f278fa1ccb5431866e0b35171cdb814e2e82b9189ce01d8d8a1b2408 +hash_to_ec 4aa4c31463475086a5d96b3ff550340567ab3b4a86fa3f01cfe9be18bc4dcb54 76a2916cfc093f27992e1f07b50f431d61d58e255507e208cd29ea4d3bc56623 +hash_to_ec 1d33d9aadb949346e3c78d065a0f5262374524f4cb97a7390c8cdaede7ca6578 9ad2f757f499359903031adea6126c577469c4e834a2959e3ac08ee74b13783c +hash_to_ec d9217b9a070df20c4d2f0db42ff0bb36bfba9f51b0b6df8fdfe150405dce4934 65a843c522b4b8ec081a696a0d2dd8dfdfea45db201de7a5889a1446c6dff8c7 +hash_to_ec b665b2ca8a285e44ba84e785533b56496a5319730dbb95bc14d3bdfece7544dc 8a804cd13457497b0a29eeca2cecfaa858766ec1d270a0e0c6785b43fd49b824 +hash_to_ec 43b5cbcc21b3404bca97fa9a661940fe64d40f3ca569310e50b1bb0173c4d5ee 6c12fffb540d536060bb8b96cf635c1b2cbaa4d875a8d2fb0bf79a690363df19 +hash_to_ec 11c58f20562c00dec5bb4456be07cd98186837e9af38d50d45f5e7b6f0f9000d cee76b567586f66dadd38c01213bfc1a17d38e96a495efb4c26063dc498ba209 +hash_to_ec b069a980b51d8e030262db0b30069e660f4a3f6f8075d1790c153ba12b879f8b 262391b00bdee71d1d827b2cfe50b46c29e265934dc91959bd369aca0cc6444e +hash_to_ec 75274bfd79bf33eb2f9ab046d34528af9a71811e7e3d55c20eb049c81ac692d8 cb93c850e36896fe6626e97c53652af6736ec3ba0641c7765d0cca2bad2352de +hash_to_ec 5cdb6a24d9736a00f197d9707949fedc5405f367744fe8c83b7cff650302b589 8b4ac03123fab9275dcf340345a1b11fba48ef106d410ba2e0e6f6457037a419 +hash_to_ec 07fdc85f809f95a07b59b084402bf91c512ebbe05c7657d6ba27a9e7e121e3e2 61182b3def063630e11de648a278032bcb75949f3a24ef5a133da87830ae5c4e +hash_to_ec a4188ca634cbb796f9927822e343d7b267e0a609c1a0ffa4dcf3726b9ffcc8a2 a911e4899fda28fd6337d708d34553ac5e810ee4938f6f7d9d6e521cab069edb +hash_to_ec 3c128ec5c955ea189a5789df2c892e94193a534a9d5801b8f75df870bc492a69 59eef5ee9df0f681df5b5c67ead1f06b059a8a843837b67f20cce15779608170 +hash_to_ec 51a4cc7ec4a14a98c0731e9de7f3ce0779123222d95455e940f2014a23729ec8 105863ccda076af7290d1bf9ec828651dc5811159839044d23f1c3e31a11c5e2 +hash_to_ec 1b901a31acbb7807c3309facdc7d04bc3b5a4aa714e6e346bd1c6ad4634e6534 01b3c0000b6c6b471c67c6ab3f9c7a500beaea5edb5c8f2b34df91b69ff67f21 +hash_to_ec d2f2c8d79cfa2e7cb2db80568ba62ca0576741acfbe5e2baa0d9b3c424a7c84d 7df9d9088022bd1ce6814d6f8051eef27a650ee38e789b184da2691efd27139d +hash_to_ec 04dcb7644fdfc12d8e34d6e57d7769db939b4a149ed2b81aa51a74ee90babe19 6cff0ab2dd3b32ba1bd1a78e3661722f3f10003a01ce83e430970557decedb2c +hash_to_ec 222798c6841eeaa07e7b7e29686942d7c7f9afc38d09360c8e1f52f2b7debd12 133e3a04ec82aa9b8dbbec18cadbafff446d1270bf7c6f3f97ddd3906dae2468 +hash_to_ec 4f7277c3ef247a0689b486ad965f969c433fc63e95d7310e789c4708418ccabc 7e0f2c984dd3cffb35458938c95fe92acf2e697aed060b0e3377c7a07e53c494 +hash_to_ec 359b4d6709413243ae2c5409ea02714a9f8961bbbb64a91e81daf01e18c981bf eab69af2cb7f113ad6a27035c0399853d10bd0b99291fad37794d100f7530431 +hash_to_ec 6cea3c6a9eb38f60329537170aa4db8dbb869af2040061e53b10c267daf6568c da9a97f4fa96bd05dade5e2704a6a633ba4dbe5080a1e831cda888e9d4f86615 +hash_to_ec 3dddecb954ef0209bcf61fd5b46b6c94f2384ef281c48a20ffee74f90788172d af9899c31f944617af54712f93d1a2b4944e48867f480d0d1aec61f3b713e32d +hash_to_ec 9605247462f50bdf7ff57fe966abbefe8b6efa0b65b5116252f0ec723717013f fc8f10904d42a74e09310ccf63db31a90f1dab88b278f15e3364a2356810f7e9 +hash_to_ec a005143c4d299933f866db41d0a0b8c67264f5d4ea840dd243cb10c3526bc077 928df1fe9404ffa9c1f4a1c8b2d43ab9b81c5615c8330d2dc2074ac66d4d5200 +hash_to_ec f45ce88065c34a163f8e77b6fb583502ed0eb1f490f63f76065a9d97e214e3a9 41bd6784270af4154f2f24f118617e2d7f5b7771a409f08b0f2b7bbcb5e3d666 +hash_to_ec 7b40ac30ed02b12ff592a5479c80cf5a7673abfdd4dd38810e40e63275bc2eed 6c6bf5961d83851c9728801093d9af04e5a693bc6cbad237b9ac4b0ed580a771 +hash_to_ec 9f985005794d3052a63361413a9820d2ce903198d6d5195b3f20a68f146c6d5c 88bcac53ba5b1c5b44730a24b4cc2cd782298fc70dc9d777b577a2b33b256449 +hash_to_ec 31b8e37d01fd5669de4ebf78889d749bc44ffe997186ace56f1fb3e60b8742d2 776366b44170efb130a5045597db5675c6c0b56f3def84863c6b6358aa8dcf40 +generate_key_image e46b60ebfe610b8ba761032018471e5719bb77ea1cd945475c4a4abe7224bfd0 981d477fb18897fa1f784c89721a9d600bf283f06b89cb018a077f41dcefef0f a637203ec41eab772532d30420eac80612fce8e44f1758bc7e2cb1bdda815887 +generate_key_image 8661153f5f856b46f83e9e225777656cd95584ab16396fa03749ec64e957283b 156d7f2e20899371404b87d612c3587ffe9fba294bafbbc99bb1695e3275230e 03ec63d7f1b722f551840b2725c76620fa457c805cbbf2ee941a6bf4cfb6d06c +generate_key_image 30216ae687676a89d84bf2a333feeceb101707193a9ee7bcbb47d54268e6cc83 1b425ba4b8ead10f7f7c0c923ec2e6847e77aa9c7e9a880e89980178cb02fa0c 4f675ce3a8dfd806b7c4287c19d741f51141d3fce3e3a3d1be8f3f449c22dd19 +generate_key_image 52dd3e80863f42fdf0599bcf742f179957f05c7754f1fb7cd2f81d4110f49fb8 e2cf53627279cbee2b4bdf130dcd21161db64728751d9ef5818b84727dc84208 65c173331469b38da1d11bae02b1c784699e1104f35ae4a9baf94876f279a694 +generate_key_image 147c2da0816929e8b575ea7a460d71946b7a40af3f8543c59779ddd09ce6e49d b4d6833a86ad47e247bc75410c42b0add4b1607b94b99aca1021cff4a9348100 8ed434593f60a913982ea6497ccc318910783b0e66f257597fff0e168df97b98 +generate_key_image 87abd513a1ae21df5cf9a366f0c27ce04bd77a7aeeab6416a293d62567aa82c3 3f0a75ef880a9ce26dc5337061ca80f740881fbd477fb241743294d748a5790c 3255ebbdbbfa43743d6d71b21482c27d096c91fab7acae1dfdef8e314f00ab3c +generate_key_image b0094bbc2a4904b502b2d1ff2e721e7b09fc95f1f5d04934171527ffaf9bb2a3 b4ce1cfcdf63b20d109de05929aba2362a18b015f9ed3d26e19f54dbd0580102 66536c55e63d78dc98546fed91748558af1c71ffbf35e799f90afb1479879a74 +generate_key_image 7d8e1de8ff2a245e57ef8bd583805a841f8892bf2bdf21a22ebea3ecd80a5e0f 8419bf13eb52a01b430f7e2e9bb52348f3692bd35079ac50afe041dcafbfc602 0057bf1e34dc258abb3952d6ac192732d1176f5a18806b1afafee45d4ff1c9cd +generate_key_image 5475ecdb7459c710d5f9731723ca8d67976ca938295089d497ffa8190582ab17 ca4af3d2d5a78bbcbc1fbee9ac0a09ded6941510f828356be4ed6091e41c370d 8e423f22d1ed3ae8c0edd6ae43ffca962bef451f9a2cb91681e09647f05d81de +generate_key_image 53de20a3ef17dd77b415138798aa6219ad6d939b90823115272d768968d383c8 064d5cc8a3f12ba90ac9eacc8df20a5bfcc3f369ccfe0eef19886461f1f70706 84b776471b8e66e99484a0bc4e3a9e34a011d709de78bb940d9e6722d6607d36 +generate_key_image 3f17986c52e84485b1bdeab93bed019fbc4549df3d3b7f33373e30406b672755 6cd3d64c132ab677e0bedbf22a2c5e6442a5db44a4adc93be15860ff3c5ae803 cd6b1de475ab38391f2aca40bc4b8b9865efa508c1d5425cf059a9cc0d53bccc +generate_key_image c12ff64e6109e9938c92f41bb0408ae714d07d949f58ee6cdd7c04c71cd8b0d7 96ad19d850c87f03752cfe7c3fa1e75141f235493c39b85f0bafe1a84144470c 05f403ba20d579704f60b6136870a361e5a4c98db88a967ee358edb72c95eb99 +generate_key_image 208811540cbece3c18c15ae0e257b8a3e2d967896c5f77a21118077737aa6132 624928ea7985fc1ad70d09c4e66b6952161b97f9dbf7122f97865a2d2220d301 19df8f4878d23b0dd4654e8dbf24feec39afe16dc9ec057d45440e1ead6a720a +generate_key_image ce9b99b074600f3154a8781b96a1c37431fa9b0f375b1c647a55f2c2af6fe91d 5f94f690005da88893276ea4059b01bdaf8d730027a622f6e0c2944857370000 e56d4ca61d19373209a1da106cec27143ce63e3fb17e0c8b62331204358ededc +generate_key_image 3827b75e0466dcd3b25bd9aea036f5ae3a57f5cf88638623da5cd8365e17a1f6 441dbc60354f5ad20982613fea34b92ac69a2c279192ada9be456e4b8687c404 d1179455bacfcea133f48cb7d0e92bc28603f918acd96047194e80da72b56640 +generate_key_image 19e40a25e4c46327adec42a70143e1a36e7aef8ae8f65eb958253089507a9502 b11b1411d842b29c5b5ee9916eb5125c5ec314978a4e30ef29a699c5fee7e20b 183a32a4bbc5d2111eefc19f2262d1d5f2c4b7045d9a8c6fc6d312388848ef89 +generate_key_image 6928f07db5f74b877c9daf195c682909e7fb37990bb98b7913a2787aad1a3dd5 0f0b9116d376480cdf31cb600c0f84f29143f01653e2e2055657431ab60eae0f 0bd7cdedb3464490a1d50e4bd1022786f5c6b50959a0894e0bfa2cfa8e73b8da +generate_key_image a075ff9d0398ebe7cfc9510e62305ff279b6815be9b4812c6c27ddcf02028a6c 09ccfd540adcb7cc0163a2cf4a55a5e82e4ab55d9f26612171f242f05ca9a00a 77f2b30c7ec64013206d83c61dc08322d07267950cbd7299f1d5b1124fbc0213 +generate_key_image e73fdf5e701354d5615028da5b2f0a7847afb4fe22e499fdb9a908d6f8ec69dd 26011f012153eb633ccde0719239ecd9f17c203ba853b66fcabf2c9dcf5e1e03 c4fb45b501f814c8a3b77d3241c0f407a5385ca451420ad896a9b91a6729ffce +generate_key_image 74ee190ae0572bc8c21bb826e95f5ddab29c51cf5b4f45246cef9b7a1374d105 c269bef6336e12acce13f85acb6d3c14f8f64b7f262e791e0eee32ebab6da70d ee2cb49823ee2bd686e8e9d1c89ddf1084af34d09c30428b23d2ecb5d0edc7b2 +generate_key_image e676ffe4c8f7d5cdbecd1d5adc10ba8044f1a9233b29389359b59c70a11ea3d6 86d1359ed2bd41fc6454a503d601998cd81ddf90a3dbd917dbf39eb536fa0a00 b51a243a850d3adb48cf526ee4e560096c0832142b2f9e79baabaa3b1ca8971f +generate_key_image d98816b6541587f57879cdfbf010ebaa3415610be81e55910a63e16994421eba 3832674e35ba51a9ba7322a08f186ccc6f7a9e9c1b48df74932f9627b8f43703 f2854c388f632bac0cec5db34a50c3e3e3f191a0b6482437554f7471318336e5 +generate_key_image 43be65596cbed853e51f407ef9ac18a928a5e0df265570ee76a5333d86fa9760 fb41ffa7e7a32694e6d5d2df75eb2eb3d2db24402fd0279ee07e5e607cb87b09 be3ab088f319520fe75894b6b3506eab099c9deacfe809d3e8b91e66bcddd572 +generate_key_image 20ebc98aa8ced4be7ae0ea5f49c4d5f7501e3a9dacf5e34dc4fb434f9e40e52a 03a151dc7238c91981df0187da9d7f51012fcc3f0d431f02bcf5e99b5a73b204 1ff12d06019ff37ac29c1aee5d84fed9363518f37a6b016ad09e66147e302776 +generate_key_image 1d9ee4f511889c9a38890bbb4278b4e1e04364bf7a8f6170d6143c0dc4341a02 984082f21c012e6f047e2b2b31cb812729e7bb1653c70e9851ec9236fd309b00 89a7a836251442536bc8b20f8dc63bc3e3e6b281dc858f9ac7a8c141eccbea1a +generate_key_image 829e3d99ae8c4a6610fb885808d81aa0792a5c88ac0fd2970c3c89b821eede45 736b88d78fa09a5badc5dec77de73de77bc5a4c5fe663538f595d6c743702d0f 263dd98c984f4c5ffd6f33bc6881293f4244a1efa4e1e6bd247ffc9adcc9f266 +generate_key_image 361f2937f806da92b8b12ffcf9c6b18719e1b1cbc77a6fe6f5bf73e8e3fee46b 22a151ca89aeabd7496091dbc8cc219f1b33c572ebe0ddb2885bc1888a22ba04 0278472a6bd9ebdfe1c6439796472a601334a8bf734f8a67a9f8fdfb7608255c +generate_key_image 607ed89cd124a71c95a53167e06c74cae423ee4806eec9dd7a75cede69d41b94 928d423bd736d7d3dc4cd7322f4037ae448736d457fab2c0520e4d190b9edf01 6f07c42c5e2014c53dc7f0812341b53dbc60a6605437236d4aa814e47cf29d06 +generate_key_image d9b23ffa3476ff864bbe124ad498c0d0f11116fa7bf0bd17799c319ee6058033 cad5c699792665d69416f69d6480e419ade54b994e4c91dd200ec15ebb8ba80b a669dbc4554982f7ee60f1544acb5202b5145b5fa304f5ce64cb79483f8d2933 +generate_key_image 64edc37df0be2592841a6917934857dbea8476fbd4c2fc5e5db08783d7d15e20 971ad6a5019de3d1bf7a9a14c563aa35bd5f9c3e12fe092326a839c4caa53602 14a09f7ab1e7f3ee37a1a53f1570e084fb6ac7196db5860395841223e7c6818d +generate_key_image 4e5eb19ea5e4d279889954356d1cff72ea716cc1c61efff27a629049d0a4c238 d778baf5adf5585079fd40e5f28486325dbdcfdd4f831a5face703a06cffac03 ac6df2df00d6a043ed593c922643fbdc1a335a99f31c035bbaac24542ff8b5ca +generate_key_image 815b24cefdfe660e18307a2cb092f05e5738c5ea231f49bd27c58c2a63210917 bfc75313d7ac80b4a677b488ddef363abef7f8055a752d6c8eb3ce55e269c508 e51cfa404a27acb4ac88e58b9e4ea0d301a8e28a24387bb3f4ce186e582e4ec3 +generate_key_image fab3904c39bdf79bbf760d22ed34c256204dec54f07f18692719485c19f914ec 0380e9bfc3418ce2ffdd16ee6973264fc8a1d75b93b2d5711cc97d22bf132c07 fd1866ebc3f8f447ecb3c556373e8f1a9c21ab10c1e0f546892a8b31c876550c +generate_key_image 22fca0461e157f3f9eb68f9c713dc13e693fe5dff1e4fc7694595e140c94f6ea 8712456a39a3aebb719ff8ce01a8800ff7e2f3aa55be0fbc397773c0efad7207 a9530b9e3fe6b840f8373127adfbd503bcdbe929f127cbcdc24353c8c62ef642 +generate_key_image ec9c6d0bda135bc6f3815a87b9aec6ceb90c11dd91cc4c0c6af9d5c33a096441 ae5128f6bdea9b6f10f515183bae2d5256a174f98bc310b9da8eb9fecfa84c01 d19f18ff358c75d5bf09ec63b279d7edccd16b7c09dbeb7e96b493b41026da58 +generate_key_image 382b72e8f5fd0542ede977307cf089878d3b54885915dc441829af94de4fdae0 56917f487974b22da20e6e1db9762ae3cd0a68037cec49c84030288751ba9401 9844de8a0e23fb95d432a809c12e0e65ad2e6de4aae93de7be230211767e9e7e +generate_key_image 22f9cdb34c7df3de4ec58e22a22374ae0e54b5d6fe16659f320229d45d134f7f 658d8408e0d615b54115c2d4b8a2954a1d4c5dd1663d1e580425c1fa9f823a0a d2c85c620301075651ad56f5c3fcc3ddf2ebf738f538edbe4bc479f1278c8771 +generate_key_image a9ddb7ef082930c01bc6233fbc9e6515405ed180a64d1c67c029362bb7b2aad5 cb03f744c8e49619e86c6d350e07d5444c95f84f06a962f48eca57ebdc31d609 e71a07d29a6ea91dc5dc9b48cdd0908bddaf44c70537281df5354fd4f4f1b3ea +generate_key_image e97e16ba01802b5a9a8c5f63f32690129c06cb844618698eb6dfdbc042949d56 c362293ad45b766caeeaf69b94fec3d7d9a9b000143b634eaf0e0a2f1ee79701 1131eb1ac0c6e424a37228ee1102e3f26adffc1b39c120dff28172755384c84f +generate_key_image a7b159fb06c3a4ee3a0506f2f6a7f1ecb4c44d205fbc3a068f15dbee6a588e17 4eea9f3453d7bfbf1fcda219a2f9d62437c47cccb50cbf8a13d47dc5c81d9d0a 220d65f9739fdda7ef84784ed087a7a3d6946f6e71d31ed34b86fb9cfc78b6ee +generate_key_image 4615ef74598eeb124b23e18538c97ecb5b901b20f4bd6a31b167111c0e4a7790 b7ffe6541bafad04e33f00beda714d361f245c4a49573d47fc8bfb0d3fd33206 e9fbb255b63a35124f01fd7b7c05f59721b0d4cdb051f1a5c205aaf90fe90e34 +generate_key_image 765ad846af0dfcf33f0b5b5602b3eb9148551af20ed2fa4461efbe48b7b2bd62 071f44123a457935c550b131706e9b4b99dab7e1b3da7d8d9d76f1b9e26e9a08 4c7d3a84476e401dc4e03b48e0c50dd233d90bd7147034a30c994796452177e8 +generate_key_image 8f5b147c004337486e3be173e502aeb4a4fdd28092a484e5d93a20331abff99a 97f392a150e4c101888acb89d7313b75cd634790b01427bd708b3065e26d420e c056c1f217fdbf28d1060f6b26e54c515f1a9264546a4d33edacc71f008c0bca +generate_key_image 6a153197857a9622147701e5f6f8cf9fab3207ca7596d9bae04133ed9ec4ba43 3efd0d7eb39db57a7a6d433eafab6ee415c17deb99cd98181a44faa32f7abb08 9e9ac6b4f41c0e906d284b4df9d059cc31eeb572e7c2b69cbddd5d7af90ab844 +generate_key_image 9796007087dd2be25c4a26e6cb79dea4f088d0ebaab167190ab0e47b95f60df4 778472556055289578e6d7de1cf6f453236db125d425d04fecd3dde90850900c 3ba75e34a40f951aaf6ca4e8c3ab36f4f1f550bb491c85c032774d61e33cb1a4 +generate_key_image 9241bb213817418ee2e957e9e93431c14394e410b53e63dfdb1973c25bee91ce 2f3771e76c57e7af88b36c75e0fec11b8dd6b14aa18a9e703c5e0d10cbbec902 a2de6a739490b2411014d930d8ad9745b9a98bc1d3cbb7f732ae8924b468f1c2 +generate_key_image 167ebe4d97c5b3a1b8765be5c354273e91a2d3b806ba1b5d0f2e7e3f7ca4f26a 5a5a06aa9a102f5be2dcd20a2bef58caa274fa1fbee6cd48a87ee0d402674c02 3f84499c83a86df4571da112a54e092fca1dd3f21a1db0d1fce59206c39a0df4 +generate_key_image e22ef8b2e47c768bc93fc3b321987de0801b36cf97dd72843a41332bf491e2b3 f0371b9ed1375ed5d8aa8116c2d8c8f7493b9ba53bc3f24f5f17b1353be3a807 eaf91d0a130955f178936257f2a1caace8120e31cf10b93dc3622717da754a00 +generate_key_image 887d25b2b437620cad569089f73f2ec3f002fc839c241c228318989ae49cb0ba 4cb63c1e78423aa86002117376cbc6fe6a1d70b248c730c01925a78ce93e7301 cb4dfeb2677abb5b5b794041be476055aa36de6fd01164f0e7cb33c964c2c4e8 +generate_key_image 29aa03c909c91ea3a506d09bdc769a1149556b85e36b6dcd04139c63c51e25e7 2cf5200d7291a524123d98ff5d64db61d41e12b8ed51a26f1c70656647786f0f 354dd8a01bbe125b0f5c684a3274158e47f25f7f5fb95b61abecd3fb06899cd9 +generate_key_image 43ca0a3a9cede1872f39c80127aac86cd2ee56634d0fa386f6facee3b4df9ca9 d5578abdf320431da1b17d6f893731b587349d8080a260a4d066debba0926d06 2f5eb902c148f19ca1c2323708b11d79da688bb752dfa6d98a9679801ab06b8d +generate_key_image f914a132334c7d4844f706066af75c6d59d6ce04ee04c86b72abc42312ad6db4 3aebe5563aade2de9a8573a9cee3c9600e6ee98a0745760e77849fd37d163b04 164aa088b6f224cad2c5a3a883769ecd274eeddccc88261cb9b35a6e7bb6fa4f +generate_key_image 170283adf2051ecf7510fceae6b661c92b58faa562f802ec765ce43e6cbb3062 a8aa1d85f1148d9ec7ce4fb7e189d170ebb41e4283a6f63269dac2aa80b4df0e 5d0d7677ed38d1db2603ebdb3dfd76e15f8c3fd07ee731257ea00f8974cb35b2 +generate_key_image b89c3d534b01dc1f2e54a0ae51fb93b20ae2cb3df9abe1d3b9ebb5f96c963fdc 9fbb1e56a676d4e83ff2e5fe873c775d9c53d64ae3fee9fd79ae6d61170c9c03 476b2b4f351e3612ef54b5dbd255ae2567fafafce770c6addd3e62c9ca015959 +generate_key_image 55aa2e22a836f0f45b6ca385b243fcbd0925a91a2a5128ef4109b05930704809 a98e4a0daca51f65ad8e3ed3a04e81886bbc81e8733df083af71c275fc3b5402 b0ccc6ffb1762e435c506082b5e7d35d2c3ee0fa33bf828f18508e0dd16210b1 +generate_key_image d1f9838d68d2f45feae44f49b508f51dbe1e7d395bd1160912d3353a86fa7c83 6c64d86af5079db72b44554a9317a2fef54f515ddd95cbb5cdaa76f8033d100e 336cda56fb3b020695744c8cc06d9a94095f9c6dbba89ece58aa87cbca20425d +generate_key_image f24fb1ef284cfc93fb04d0742000817fc89a5a66b0025f83104b7d4ed67d6c0e 49acb83d973e3205b152a6ce2f2713c25d47d169c02e7df7bb850f5e7caed709 2292473e6a69fb3b288731b5fc3830174df4f97a36603f9ecbe21146289eb9e8 +generate_key_image 133265f049079bcdc84bb806ee6a31417e1385263d756eb26ae783bb02ae1b4e 0e18a4f2fa828b826c3240f634c0212f220645e18540e85ebd099d78644d7a0d 351a88cdd1a8b61de4eefc12a57f697f36bfc33c0258b04ee2f7f1ee99dfad09 +generate_key_image 6d54a1d8a99b047f3fb7ce1d03d797a59ce220b490a8bb40e2394bfeb488686c a849f8f7626daaa4ab69dd0bc66148833c97de4fce12f4fa70ce8960bedb9d03 546cfd30602b71c84cf7edb0d344abb2ff04f3e55672c27eae0d4cd45476fb5c +generate_key_image bdf300c1dd84c0339a21fabf56be03a8140aa53582f21240757851e7fc743276 35624187d64314dc699c3c1d7e87e6112e02a6748bbed3511c1a3b1de3821502 49728e7911e15fbfdcd7f4cc818766a8fb167dee6846c714511321f712c17c79 +generate_key_image 8e2322b7ba5d8e6580fbb58bb84ab762afc0b2c0c1d3f50293edaa8014df7ced fe03e67c4a59847d11823d27a4abea0b15d040cb1974c4fbac59b3e60c7fa30a 839b695bf5e41a1d6b7909a39bcb93480cf5d3798e5f792a9baf43367ac4b2fa +generate_key_image 7b4cb69cacac426066060e137ed8c2a3a99bf33509e742bea6d3b22ae1a50f6d e02d75c8bc2bf43ae2b495d142677ead2ad7ade4b9477e1259761de922811401 9b29c1f56ee5e01aceb24ab628d26a0d508bd1c22cdf17839971ada5f659e6c3 +generate_key_image 348e73516d29202334618d5215a865032a95f9c7bbdc703cb9180eded8143801 8f3024484eb3c9177882546152101703c5ab5af4f74b72ddf4b46b64e4dd8207 a30788045c60c2130a41525dea62a4b2f6b44e53ffa44b77e6174624b7e1d6de +generate_key_image 537d3fdfaceb0494d68f2a15ab877a5bdf728f8f5771e3db03890d2498636ba2 07d3200d554beda9cc89139cac99585e6cd402b2045f65930a44d96231756807 8f4ec127e6f74a795e4f54b1b1d723fad043e5e196fb14afed705e712ab59ab0 +generate_key_image 83cceb44d3bf08000fbcd986262b08de4313f503b3a3f8f5e5438345f0ff0e42 2044b41a8868d86266ce0d3d33e499fd6720e114b32cf0ab6c5f3ddfa5ab6a0a 45f5d966cc92a3b764484197e0615e204495529f8b2ab24e54baf3bfce1a9b3a +generate_key_image fd78d538e54fc03e73365126416dcf7f9356c7649e23e455b785f5fc24108517 09ce3ff682b271b311bc59189bc06d912a7c9d22ff0f1ab7b89cda76ad76af0a 5577c44e684f3b91e61772f9f9155c2f43e038dac6f0e9e914ea5c114551a9f3 +generate_key_image 9006f8b8ec1db2d60aed44f2446829c4e1cd3e907f3499ab61d921bf3b2858cb a9631b621fb1674aa11629aa85ce1789c713a4b7e7be6121656fe4897531f10e ccda5755ca132e6ac715057e06cc4d42c173e1df3a0c3a2ab653d082c0f6a155 +generate_key_image 4ef082a2dcb88c0f23e43f245f14cba6790ca472e447bb86acda88b7615cbe9f 7afcd9ea2e2134aa55175fb74993961338bc32d39180622482665d469b87040a fb450a55114ce8ffed8a5a86465246851295ca9cd228f835ef82ae141699a9b9 +generate_key_image 4a0fd51aa66e0dde7ac35fd8278e951d8ad8ccf0f135e812a49d3eee8a308c22 d4932fac290a26801bede6f311aeb7538602b24ece20e86015a0593a3ed4ac0c 3459407fcfceeca7e46ce2e4ad82a72888af7736b10cdcc269c96c2be1896210 +generate_key_image 223a82ad43e062acb2a264677e839ddf8141eb62c8091dd5ce64d09b70fea2ac 93066eb249c3abdf8816b30f6fa6e495cc80f0750f4884c6f99df3029c21510c aecadd087d46bcbc6604bbe8b3b976441b73c24fc43ee3fc5bc13a7908063aa7 +generate_key_image 828e7d1ff61db46c3181f75d73037c3882b3922eb670a7a87bb71e94a2a3acbe 79ed1843f3e7515180707f479ac6696a1a83cd7a40fceceba4d0268ed990b009 a51584cb2b470499c1325fb2df71fa44b9218c2829de8812c19137549d28a5f2 +generate_key_image d19245dffafdd1c52733c96732a366905ecc28142ddc6a05ac514bf91e865c21 a7b4027a894e2fd5fb5ceb9ff196dc62d49b7cce0e6767079d2f3a1a56745600 e8ddd6fdec3570e7fbe1aebbae5d50792eaf9064867aa2bd583ec2c571ae9adb +generate_key_image 5230b58ba915342f567a3e70cdc6096d0e781b39eff9ab925c269145ad28e999 7a86ded747b54456a45bc0e9bf86ecb07133fded6634f9941e9a9cddd0a93b00 b00ea02c76777c527dd3db0e3df690faa1ddc35c4d6c765b714e1536ce06c6dc +generate_key_image 465828f3bb00cf36964f980d449264655e10243b5253cd2548fd6818d4deba2c 1daf4370391d3ea64ba25532f805d6942ac8e495459d54465f272b0260647f04 628f031eeecae2006f9ecf980eb1c09b767590858abba7e152a13717ad68ed32 +generate_key_image 51848404c7b3e6261ab998cc94acd648e712cce67821de9f3839259bef6cfdcb 731657361e2a40d02c48793d95d4af35bc438795120b3271ad64315d23e8c100 f1940fe03444879a1f1a6dea7076395d7f43fd8d87229cc9648c6e0a317e7d30 +generate_key_image a63436f2936ed616819a1e855a4c8d34274323f7909b36b75b6dca6fb51ecccf 74fe9a7e96475dd7390740bf6ddb26cb71f4030edf99a6eefabe39d441abc901 92c517de264a97d051ffe8a247260806233a0bf1f945cd6deeb0d81c8c140bbc +generate_key_image 4ecc650a03a733134116949fa9d487e156a035dc7848b43a6c0f4d61ab8be48b 7b78aad131877504601c7a2ed82e41e09fa09a194a339d2863303e54cd3b0f01 1558d6557989bb3c4921471f5512aa7dcd13cad8ea550c71e23b70cb9a340267 +generate_key_image 98429b0e69a797ffaecc0039e351afe021f6dba97deb1f710bae4de238fcb1cf 85a67257e28b6b94fc3cbf3b1575592b943a1b9143e7b62fef4a2e90dc3bb70f 1b066cea67a948095328d7867a5822833766d12fb182c8365982a72c53ec202e +generate_key_image 5bf0869d0b257af2e50fc84e1497d0ad1b202ae406db0667020c0e5c2b400035 18da5f45ad86692614091594478af98279c5fce755657f89ded581f8ab7f4705 813d004809e5281f5a8813007a0312616037f3e1f9d611754b2fbb411e13f32d +generate_key_image 4801dcdd7e0238b9744d80ab0113ad11c1cd5c768f377a531a79b29a11448c54 156207dfd3da2aeb17fb7f09d52a764795e08496b705fd684b115e73b4950702 0bb75b1a61c92100a9b0485fe9b903d78ab5d2ed901469407c87314f517d8921 +generate_key_image 45cbea1ca36b75c9333f0dfd609d9cb2f26e4e5bc029a855994dbfe92c909ece a40de8b45d2d20940db285d56b31857efaeeec30d4149a969167a00d80350a07 2caac467d2c7a4a962f004c4a610d2adbb56d7eccf0756654eb813e6abb4a127 +generate_key_image 8ecaebea6815717085c19ddce5076d0b46f6d6d914c74d1a954cdefed73134a3 b07e341bf336510674106f3fee85b39f2ad219b033bd84bbf4ecdc473d703f00 9953707b85b71dd78392cb4465a3ce973aa9af83144b3c852809b7a3b7ebf649 +generate_key_image 2bb02693a64f6aa49586099c8f256a46e4a0c1bb1380a67a7c903d1b9a5bf5c4 45bf124363ef4d342545ba44726d2d9036808271d974b27e85626a66bf4c8609 9e6333b50f9be1fee4da1bc99bc59624b215041e697ab0d84ad9d16a19af6900 +generate_key_image 9bdf49022b705cf095289824ab35bcbc1a897f2ea38de57c738cf1d65ae71d13 472cbed0c4ccf9f5cc9721837d66e92864b029b79bebd2355440acf034698a02 359baf4b77401a469b1a0792e16317ccdab732ee012849526f3ece710c80e244 +generate_key_image c1a7237709c5181990cbaea9246bf055efe0b5e963c7e48dcf6493ed87e82146 6202da160056fe70c260cc0d25c2dcc1c4e21e931d1d8cbd9b310115a8ecf006 e77f8f515c067c073f887c7040837e5c5980f27a934dd7778a8141e462598170 +generate_key_image 560d46ee14f47e9cb2e760101829d66fe8c305f94a96b3aaec983405af051747 f2ee73f6f440353d3860a11deed77aa0d17e509bd40897175f04d99f5b5df207 be20755c7153f3a96bdf9587964ee6e804b92a1d301ac8f5e076fd64109092f3 +generate_key_image e28f39555558d0ce047c225694a2421033658d40645817e68fb51ba054030a6e 9b54a4bff4330e02bf6ea7eecfd94cc8cc5f9de3d4aef5cd6f326f4d5cfd9601 490535b50b83e4b80c347ec9eea0e31e3ff0c8c4625442dec41219f92b3b455d +generate_key_image 7038ceb17286de150479260661878d628f65e3d728535c0bcf6e26e5c5f6efba 284c02a294394e50557e5f37cb129951d5603b619129ead90c7a09765817fc0d 05354578babe279016cfdc689c08785d655783d7e247e438ceeae7f9dca686bc +generate_key_image 7064083a2b2ff85a25f543ddbcef0fb59d17912af9ce24b39356f73bad35fe65 06b217cc103e8b43e3c0edb24d02aa6aba2c8828363223b7c94d162860c52b05 c6aef8babdb269e794f32b56f1b95556f3103328f6bd1f0781bd60d5bb087b83 +generate_key_image e47a6c2aa3e86108908ab531927ae2eca3a1882329de4cce6006a84e2d327bb5 79d16c8779ffd7f0d3bbf1f12da4c06fee37b97dde20a66a847be4ebba0ccd00 eec1a72ad91db6b181f9fb105dfb45ec315024000c9cf26665e72f7f4f28a85f +generate_key_image 406a88c8c9f1ca1e093b84334cb3dafef9932fa9d1de6892e6d979ffac8be4f4 fae64b836606d04bdb11e84c4c3322b85f2f18cf8a635bb4af85891d60a98402 e796be0f95dc6cf1a6be63c238d939ee234df9f8301110cd5139472e610b9d31 +generate_key_image c62cf8b283d431d554fe83ea80ab244a54536106432054c8243d45937bf088ec bbab6c0d77bdb21fbfb956f0fc23f5781c882e55ee0c3e6a9ec64d36457e9209 cf9846236af91f767b6c58d3e21fbb9fb8d5d3f9bf722a539bc4d403bc4dbd07 +generate_key_image a25b2958704e0189c1f94eff203d72410a5fd8afca88f0e59c20befb03516e29 18f5118a72364735ba4af221cb2199afef13e5073ce029735a2cb401f029d40f 19ff27e09b053a47885169911de4d8469b90b2503c79852534818fba793d414d +generate_key_image fbcb582cfd9360a20eb76f36fe47737c6fc69fb4001ff662583504178c2a6ffc 364292b825023fb0349aa55d28597ba29728e4b541897b1df7ba2757bd5f0108 98708465b7cda0948e8b17c34583e147ae732c4e09f30f84cdfa56b3bb6b4e2a +generate_key_image ac2d7a1d96c1bea7917198ab09e881536c5219060ec7db1bbc2ca03f41ef4367 62eff273b5a9cdcdfba382df55e10d4efe4636ae64080d1162bcac670abdf10f 73aa5b91125c805343e1fe3139e028ab0ebb56da0a4cfc867413d6ac1f56aa7d +generate_key_image 281cef491e4fb177eb1e356d89f300cd7b131dac66ea2a2b86d3915fa983249d 6b999e222f286e9d2f2e01cdddfab006f665e4fe9cd65bd80c9cd297fc71c40f 0b671bcedbd315826263e7fa4080b586f79662b309d565c7ba0b55b04490f3d2 +generate_key_image 656d9bfb6d987896de75645b0e28954761d1af0b5018d97220e56309f981e232 69ad261a37a7f517c250c5827d48c874d6f053b64aa6ee5ccd337689f725140b eab4d3abba1162470f9141248bd0260d2488875f8a81be17595beb1cc594705b +generate_key_image 13d52ab6504360f376d2bd30de05773766df411bf2e7cda2c1ca11bcc9bd98e6 66fc39f2dfcd57990f6ecf094ddf106b5a2eb74242aa9b4b507f039d11131909 82c3ef7429de98a30b4746df3ee6ff60af418a8c1e3ec5d6787d275f0bdc73d4 +generate_key_image fcc194622c47fdd444499895b33f1f6cf0717a5d99fa8d4becedab2beda9c693 68da6744db32b8d0b49aa47db445172662895bc3d94fe0fa15e756637826f50d 4ccdeb1d73228ac07227e953e8637ea6cb43b3eb78ab64e21ad4b2f4da386917 +generate_key_image 45a3bf603f2a0eaf3ba5f7da558e81d1488587a197bdc226c3bdd1744398e7c3 ae9fb4b230183293752b0aa0fd9148256d1291d6158560d045fdeaca4f8d900d 4325e2a508bc1b2be18b9e52234513fc62783d850d4cf12ff4d093143d485daa +generate_key_image 8bde8b9bd62a260238850e37130b08bc3dac6c62c8b2739b59c5be5ab066c4c4 45e2027be0c7466a09a8b179e5a273618693b8ffd63c86605f34f447d5112507 711d50e7dbc89fde4f833e46527fb55cd8175a41405450d485fedb0f739e5d8c +generate_key_image f40b0eb85b61c5d5cd8309e359abb73916cc7c8c560a25f8862e1fe6b583bc21 5659efec61b37164d5c06841ef1218d27df0bd2fe48e053e580aa1cca10e6708 4dee44d9b457854e3e4e5e56281e1ade0be6712c5621adadec9549f68ccb4f54 +generate_key_image 13c7b003a9699bd58f77a356da671adb912e18fb85dec6684c7002bbf771271e 30bcd616c7d77da550a8d6296efb32407d44ca7922904442431de07996ad7001 008ad45367105df4027df144c84441e8bc71713780c8ba6017f007744ac4a635 +generate_key_image 89d1ca2777590e72fa199dac37754e26b612be9176e44df19b9ff890f7419630 0213873665eca65f23a062bd5ac8dc543c796b26232c6064cbc64878d9934107 97e1cd2625d39b19016d0ac2127dab71761b11a53b4621f606121d032d02fb60 +generate_key_image af97caee8e794deb8e25829c14b80192cbcd1d4f1ed454df22ec32498cf09b12 41918092866b31724a92ceb5852e98ea0224bd71d8fd316272409e4d8aa32b03 96fb0655bd5dc75326e33a6296dc17f46f9fdb40384fe0a1250dd88257be1adf +generate_key_image ba95e05745c37c89d49cb4bda5032ca0fe84a402a60ba41f72670d840ae50df0 2e352df6a82c1b8298897253aa820a4f40a6609dbe91e1305c7cf4d178ad5305 c2ded38b83aceb5828fae63f8b83597060268fdd8a76d7f8e076db994c53aaa3 +generate_key_image a03b2659ad552bdf69219fed3c4d40ac24b6d3da696ae262cf8beff59b09a710 12344a729c39db90cc9e498575ab9d973230e8c3062242b6c1a88a21dc809802 211bd9c2427708e98e1f1ed3b80d39868ec072575033c764a975ba9820144a66 +generate_key_image 8286f78ab7deb1f29ebd18f27b0fe13cde07aca101a136ad71c6ad5d4208e354 92b6b76c89282aa7ec984d207a09873e1156290ba1512b9f4232ad461d902500 52b2e033c303d6ec81708ff052bc51ddaf300dffbfd87ded8b2628236c63b0e0 +generate_key_image d2902d243a0862514ccb05cbc68611fb58b9f865cff560f881ad4ae856117734 5aa4ee853d039764e59103f344476c68e5ead9d8d9b13d3af6bd028819d5610d 1e0786054f8d2683fe3629c093e5db31ed37d8f90dd99a16cb3604169c5ee620 +generate_key_image 7109a7863ddd12d747c4b461e9d1aa05b7ce181c33d87847db15857fbc1d7c60 0ba07a81e6ce83edb750f4c1a9862fbbc765a8ee0df40c8344329a026b9b380b def1ed772c9468d868bd9f484dade28ef057e94cfb6f37f1f180971e29ae3c5a +generate_key_image 52a384e9556f0ad1f1bbac1d962b718e5cd76bc2b8b72529f59f23599f290701 cd319abb39200d61057695a205ef45236e226113248dc89265bf8f2a62b5ab00 d4b0b849ffbaee19363a0a5b1b0db8880d4ab47f412044d1948b9eb36d9412be +generate_key_image 306f78d4b5053bb4e6144b91b2ccff9ee1da06d7613e939c0de2dad56049b94a 359bd157c069a0ae7fb749cfbac5b1702704454a3372790c617818e5c8477401 3a38cba4fde262d14c4ae43ed5869a2ccf7a265bedd00a438c6cfb4e2af766e6 +generate_key_image e12870fff5c6267a58fed2f877ba89e3d49051a8e6d6bde1a91ef2db6ef89d77 31b6ed2af6d6377b209c3ea41d87b763ae41bd7bdd1f862a06165d48decf520b e027a9c186b3b86b9cec9c5a87365930a676cad65f5756e243573177d4bd9c71 +generate_key_image 8a5153df78a0d37ef3d0e6be1b7f9d2bb2539addc1bcc3e321034d5179f50683 71e9f144a4c5f0ceda686f5216df72518904ddc08b158c9808ce55489288970b 56aa487b9038cdd5880c5b7db34903e786c4683b0aece21e43c35240ab1ac057 +generate_key_image 71c1b592d1a95937230f77007cdcee73845adcd3862158a2c892993d3a507293 eb2e6d5d3a4d925e0005a3cc68ab731741b5dce7bf19b4b09cbdfec33cdd0f08 c4f812e6dd22a45a48a5888d9e85ac703f5a76817d43370ecf2b589ce0b16b18 +generate_key_image 696079d4ce7ff5d375227d33501c3679319c28fafcccbe8ecd31421d07e74aa5 b4eb16459b3a3c655b5fc902f73538ba7f3ba7e9982f2ffbd5a6b04ee0023501 5e368fc805e373129159a5bce3690499630bf63bdce98fffaa11e1580b7d7965 +generate_key_image 8478ee3c815d2241bef37e7bd7dac72f27a5b03781e9dc1cedf28e4c256ca06d 325bfcd13d2d1766913a038ce00ac55bb683a0b3f85818bcdc1524499e9dbf0d c5e0b52cc64cc18c30eaa6d60fe9718af18934a7df492cac2a15cb2c0b7bdae8 +generate_key_image 43df13220ff9a365f4401357b5b4d7b9f7002be3022c96a2814be6372f7a4849 991ea08ad34057ea3464056baf19d3e4454b427936b9a8b9e6890e9913ac7006 583c43c34797f7f0e8eeedbf3ad051cb379760ab7ecdf0c049e9612335116480 +generate_key_image 7911c22c7245940fc5129ffb4a53b870bfa4b0d7f70dba5cc54f4afa8f840fa5 cdfd8b4e6ec94269ac8f4054b59f7ef81d2148b649040c5b16ddc05bbde62a01 a16d34d6472b32cceaef8920b624aa82387f70b45cda1b8850dd250a053a93f2 +generate_key_image 53c57de7e14b50a410f35b8af95e29a32e936f7c5e11e4f4d74d68155734b9a0 5d40e2a07fbc20fa3a16a8a9342643fb0d46be8da7ed09f6b5ca075e4b420101 7b54364713343fcec7c1739016240a2cb3ee44ed23918b595ec35f7b70467425 +generate_key_image 6bb380346cd532e6459a124363fc1ff0d55f6cb1b57ba5aedf876da96b60c58e 4268e0fe3cea30e08db9c5066c252d6951b92eab76818df50dec251eaea63802 bdcc73f196ed476a0f145e407891b0df6b3abe0472f3931224cc86b0eca973f9 +generate_key_image 7610215e0e674b36d6c897edd134d1bf1989c6941816c184f6cbd94ac4f4bcbe ce7ddba2856e32c9a65ca2f0e921f3bb42621f12c38f70efece5bd0d30922f0f 1853328317c72a930478b61808ced4dd62b2fc2cd3f250e0e0bc3f48cdf1be30 +generate_key_image 352109a60a3b5c604166498fa64192ee8ee27776e6ff0b5a8d29f231960ea486 83a036441da2a4c768b2f9508482dde7ac5294907703d2a48054cb04d0651f07 a9ac1396e6c9ef42c1e2f277cbe83473f3a43b705b0ce7b6a29973cedd0707a4 +generate_key_image 822fe13d96acce1a79312663ab08985ad4c48fda0a5a716a245ae7deb5ed0348 c31f8606474cb892fdc8d3a583c2503cb8c603097992e320b411e4f0b595770b 6329a318505b4a31f4613b5224373f36527e8dffea1a626828bca03eb261c2df +generate_key_image 7ac22eb1dfc5eda36d75bc6ef2896f08adb68405baca533a22f9c3ff6db70c1e 3dc1e001dde08afe5611fe74e1499e28a0c79e8f337adaf42904bcfa181d2f08 784f92a3276d6fdaee3af237c50c42351bfd2a2144b89a3c95e4653384811222 +generate_key_image 66b0b673acddaa3e96cd56b525a3096f0f3b1ff29f7eac11271dcf2e78835d3f 2bba552a31ae265e30b3f2da71aef98f81e97a2bff63e6f4f67656cc3373600e ed64819f38ab7dad67c13daf06e45c8d0654e67c0428f3a063264309583d82db +generate_key_image dda826fd0be104c8ee06b1057307f57149961c3695a87d6d6e1f600b6ad1efbc 3add7e705768e0f0b9633112513ff23a965e98187e32a0d6de2e3bb5d1e8b00b 8a243b790fffd54d0b1f32a275950ae6175230df76140b9c873b6e363ac2112c +generate_key_image f4ea16ed9336813e72ac29560c638cd81c25f1f61737a0c91ed98f7100ca87fc ac866f384cabe894534a252f6a0afc69e272dbc514f01782acf9812272f5e70f 5510e485683fe1870e8c3db5cdafb4992cf53e756678a91cad65f7836f586f70 +generate_key_image 8e31869da8ebd933521e13c513b803338f781417d5607882fb60860634cae5b7 0739eb0bc1fe6dffad3e631b3f4416191f4f095bf53e66cda9488a001f29f007 3c6e66d05956b6f074a3814abe175f27f292cae5bacc4d2aa461064e9373b396 +generate_key_image fb3188e8929a1e527653bccb1f6e0f811c549380f75ee2e677867d16b7ee2004 c3a7b6dbbfa1ba6f75277de1c3325fc4011311fedfcb3faa8fbad5bfdfc73e05 85f1f988708f3facf234f20175b107bbb10db9ae0f88b4981b3516c6a68b28ca +generate_key_image eadaa7b898c469017b138806454b4af9048818c4f53d66da12adc10c220ad07a 468d23e52d32d7060a984e80176f4cc8d679413bef8f39479078646f523d7902 240a9757db2e179774c7dc650f4601cf299f24d6e0ebfb8d8aacfe71663db7de +generate_key_image efeba8569584403746078ad797fb8f18f15e1936664ce4aff66a4771e2731ee1 ac6a186f357f558bb4e4618d295a59a9fbc3682612a6e9f6b01cbb13e020e204 a27e221f822d53c23d4608c79091111c2a83cd4cdff4727470edcac135e44b00 +generate_key_image ecf4595c999d70be350c4280f0d8cb1143b0d33952c2f84abf02cef6ac03e60a b673dafb8f7be378bbd1b58a3c785079687c0ec1721a5c9da89da0384724a201 c5dbb8828b5fc2675a190f685c9158199b85296429b94f7873db72590c8b4682 +generate_key_image b5878cd00c86e7a6ba6b5063cd041a7026981017b4eb3758438f464c459635f6 d4eac7a03c4564b3136f6f8bac69a1574c199f354c63a48d64383f5f0a082507 6ab17e34d0d501d7be3e396982a9dd1e1fe621e3fe0ad1c93e55bfd25ad36b55 +generate_key_image 586a2e25fe3002f7195fa584dfdea68025cd86e3cf236748f39a568568dc01df 44716080e724597214a76797900ddc255b5608dc4f1289e0c33616d804d76002 6c45fac6f0c581b4028635e2b6da7d70cb89e9480b282830b52e9d3eceee4a4f +generate_key_image de11e87ca7a21cb560f6d828735f1ba80ec32e14c88a286898da79e856cb92be 43a2704dcd8f04204697207b43842051e9b90a322c4e3ba9ef82deb3d2d56401 c0dcc1bfbcb6be8202e367e050beabd0b4fa9abbb86051a357d21b4d1c97aafc +generate_key_image 0723b558e20d327df224740aae76bc9fd31a8ba0a6f376b244d1a67e6a3c1087 8c1d5f8777946913d356cf6d3c7a0c4e790718d91da8880ac3df3a0bc1206402 3761117d575a26ee1d2a09867dce69617e8c6dc5e86508bff480f9f4548cfc28 +generate_key_image 34f865d8b0277ee7a740dbaf66d8fb6b796143de8b1eb0b0827dae3b6cca09f7 c63ec4bade22ccdefe70d16f7a85702cbad27e105c017d250ec643276b0f1506 cb9148d50b0f39c5f429a7dbe034f611f77236b9810fa688aad73aaf14daf48e +generate_key_image c5f25378dc08510e2afb13ab81d1a81b866e2270ef663535eba967205b75a9fb 18bc1129bfa613d697337a6afae1c45cdb16848367d905fdb9f1e02b742e3707 5d2846ca94c67ca64f7f1b995e8a81092715587699236c4e685778242d81d7f8 +generate_key_image 4353b87d19489257239b5a2ecb8d04ea68557125366c6e6f9ff1d5aa9377c58f e9973943124eae5bca1a141a48bfb1e0ead3996a4dc72c1ea1ee5be74c88760c 18bf17f9f258a0c6c81f12751637ab67cf96eade3ffc7d6680ba474cdcf3f1fb +generate_key_image 15524f4a97971b323046d2b901560a40a96fd662fc6c7eede85a674aad72efe3 4aa107ff7687076f43f526dab42e13fe08f60f69bf6fd3d049f31e3daef13802 86cd965b369893ae280bf3de0c98895490557186c82ed43bd5009c133d99ce5d +generate_key_image 3c0e40d7f4f9e119d11b3179fc72525a88b44c8a40ce5221c71ff7a0f4156ebd d4f79b8d3c68f5aaf73731431bd36b0640a77c7a5a8ec95cd00f83c08c438c00 4394e311dfc31439d0c418a3ca92806053c7b162610d8135d6b6de8910d74b0a +generate_key_image e0f0293c4993774b3a49480115675662f2d660f49b70f33f50087e6cb24273dc 9f9eefb1a275502d958c8c4b5261e8bce1df1b38127835f9d00614d7a6a0be0c d42c2b18d3271f678349b66a9763441c56468a0482690a7284931bebf590aab8 +generate_key_image ad527c2695502efa0adc3f1378aea64170565cbe92f0a4b552e27cc159d4076c b4105a78fc0739ca799bdb4aff07347479edfee42221f79d2913855321e2d20a b490bf8afb10813b3565ef470a104be8d4bc6bf8ef262f0ed2464f88ec3b9b9d +generate_key_image 446ba18c0e11cb8af3970205d8a8599a6db3cd6907e0e3d73c5aef5fc05a8831 551ed18b2e34ff087b66cf324386e3bac08861a4681702f1dc3754cc82e51a08 9a69f758f425c70af840c919eeb8055ce8ce74389346863f13f35d979d606f46 +generate_key_image c2185d5a5ac7dd25140faeb38f58400e8f61e54368db1cbd13ee7ec4bafdf025 509dbd34824499e689985d94bf7bddfbe25d4e12a34b0079d8f9ba956934b608 83670bf946e597e1d2b343f568947e77dbdaf741cf354c686d7c59647c41f333 +generate_key_image 306d37dc5370b77c040e99b7944c75681b642b3a08120f9f405499cc83539b6e a8a40ca4f74da67401224d0f4c6bd26c6b39a562a40e5a088dda809866a3700d dea2fc25f3ddc9cc97e51c968c1046834da35009c0e8c0e62e053aa6dac8a7ed +generate_key_image 23461840f101f50bd8ebfbe221d13a2b1a634ec683eb2b3325bc0048a2986ff7 5f1f1d7dba8d249b7bea0042f328b54d0aa947b7556175c21169697bebedf206 d2ca9b7e0e026f770d52183bf115dee5f55b71b35d2f431c48560c03a686b1df +generate_key_image 5aa93fc9ee08b974403ce423129905a589042da9aa50c43b8322c45381f44b57 cafd82eb322a4d6bddcb6160fd8abfda43524bc41c2276c4e4f6287d7773e20f 0d74f36a22a43d7961b728ccb7f88444f02f6cb38f3a141ec03edc7953cc2421 +generate_key_image 28e469961416e97e2ef5979c4b1fb46a2a8ec4497bb8b5da78d038fa2b4cc354 3542fb20bb7fda45ae51e3c49ba8376a0a2178e5878c439f9c6826ed3a0ebb06 b968737eb1486fe8e9e80adf20f80bcdbaebf86b771abff07d4d6c581838f93e +generate_key_image 4d51cc5c7da3b2d7d7f2edc0706938bf9211994b1df36f4411f988bbd21602fe 98b7a1305dc11963906afa62170daadef1fbdbeb2fc6c5e16a7548029c5f5e01 88b0157d9879d64f6ae1e90e7f78ddf2ffa52c7f87a856e258d745a1b40808ff +generate_key_image 2dbf996e011cb1442180f1da7234cbb4f0955007971886a4ae0136df43115a58 d76645cddbf25327b667b5aa9694a25093aaa6f9694064bdb750294143dc7f04 5f43f459980e84b7c9886e729f4f8a98dde4728bd43a6a7753cff9f9f27c2514 +generate_key_image 316246f9e17b014a4fe6cabdb645c2d7ede04e0a409604fac3cad7a98232b943 5546f9fcf8df86e785e19e5aa4ea069f7a522d641a0d77b16435303b1fcae10e b12377a62d7c10812a583c6cdf1876ca4217f6e2d75e30fcdf8b37e6ec6b34e7 +generate_key_image e979c608516a0a5ff29a23b2ab0ff41842d1e1d77fc037a5f94be86e1b69b3b4 ab3e3992ad052620858d98859081b899c08a6a1fba04bc8b08a3da531f1e280f c9b66d1602818b870acd8cd1a15d47a8a4171fce9af26475243e92dbe5c1b317 +generate_key_image 2224895bff0ca9d3f8ba098da4202051dc26666ce86f031f7c488889e45edbde 5658364e7f8a4b31e3d7b43b846b3bb72151a1858380bbc06b0582f2e75a3203 c9299beaa2407a208bd246d38fd3be15c2360400d7667baa87ff76e3c3065118 +generate_key_image a140d8257f73a8107e4ccf81e0ad5f200da42ac6992d564765f49acc1130039a 8a3dfef935048a3267eadcde2a8b7697947f5150b1f5c59a567575f8163ae70a c99f240bf88e272f647eefd4485a0a72fc2a26eaf4434a17e2f8ea7d14501341 +generate_key_image 09815d8a025c16e1d9abbcb7afd63a6e525d0080094e0fef369c3d8cfdffc323 180034c6637ac38cbc503133a16204f4fdb3989f2f8254ad908987fc6b9b1c09 19cabe0e4ce614b3858a2d298c313f69841e99aa21cbb5f863a6b998d4bb5954 +generate_key_image 7b43c63ac6a10c2f23c518a9b77ad4c729ddc441d6f0de1b169d05f1cf626dfa 2b5c7647ca177dbe38ccfff60f6b160bc80fe00dcd72caf2be1798ddb2c4e303 bfdc7eae3f535d625448cf6e7e23dce413c083f2647f0f69d003cec3c131eeb6 +generate_key_image c1cd0214db099d0c156aa0c6d9659eb6e1556d95016e04d18fc7de7c5e33d7af d9fa01b7dd0297557562d5d830a4333cd0aa1010658b32f50683aa96b10a5d09 6f9af925c8f9e695b917ef30f741205ee88bd3174629210340835e736e95ce01 +generate_key_image 0d764c8cd8b43935c27a83e0aadde0dfe8fba1ae62badc3cd5a2bb0f7d999ba0 8e6b3a98167f5304ad9e03a65a2fa6c3f8948f1e679c8bf9aa6bbe084792910b ae1298d6e21d534641774ff6fe18566d81be55208488a423b412d42ceb3afa12 +generate_key_image 5254d69eb2117dd0916a6ecb84379f3e592475b62d273273bf775392bb0d1a3a 4b7b5c60fae9de97fc5d220b370964198987715aa86fce47af63b7ea85781709 81b8d531991035015d301c7fff798deb759c7341adda2c32b76e37ab691ecaf7 +generate_key_image 3e6d3625839597075dc00c00cf6985792231693a5c51f57057255ccaff04ff94 1a735089d65d40f1dfda03b9ace8eaeb4996dc4b5a631c1e6b52d5ad3bbdb007 042546f3e1e2afe63f3529f5d4e5a0970482768d357cf9d53061e5b0e9d71a84 +generate_key_image aa3eebb0c9ef4924096aa1933bd947d05846361ea05d33c583042f175a1066b8 0e6f2bd80bbab4c69856e63b8408a22188b96cce735b18d687f4ca9789b3c80d 5a9ca0d14207c8d74a51f4c370f7534a5b9061a6e7914ab665820aa99f0b9ce8 +generate_key_image cb63c1c68432975d48b241d9ee5fe8ee7f13a6cd2154c4f009a6ffff8d0f1c6e 9196f2973297e6960665af54d684cc4681e578b5f7019323915ae48fcbfc8e03 91452a0a606e67407a2096ef64142a3ea9876a3f5f876735fb9db9c52792c1e5 +generate_key_image bb37bb0c99a96d981b2fc857be8a6ee15f15e8f9cede23be52d59b0f769c1db2 e1166bb70d9a916f62bb4a8b629b49b67eb0a5d4f5b353deb4d435b17306a809 94605dec588f57e7abe27b67b42221f22fb50e6bc3c52290a4df8c1b6bc846d5 +generate_key_image 8c3d4cc8f218e73856a3963dfb03de82b7744f5f889cf4f184246d8c4463bc5b 0502f903a93250e7733a304735e9a4f28144bbd2710844ab1632300e6a0feb0f 208d5e671b12fdce4bffb385cc438f5c5291f0ddcfbbf0be7336127c4401700c +generate_key_image 6bc638650c36303e2a3d91ce7a259bbbd0799b61a547a757c0c26257a0f4df0e 20f0b4613d8098e71947f75256251209bea0c3046082170b1b42304130096108 acb5c48f615d8abcd4f94fed98ef03cf206a9bb558068557bafeac7702ea34a4 +generate_key_image 766cf9be5f2dd19f7ba06c79586ce4261fbdbb7ad8f12ab30e34ed6b1e65a1a1 b16ed1cf7955a06bdcd602cc5edf5408648819d6741e9764a2364b3167c88b0d 3c3fcea8597d24875b5d6cc3a20c0e341e11eaf151cb1ba62ff5d11c0d0f0055 +generate_key_image c93a7e0f164ec27af5b52b26262effc92eac5b783b9496056c6b7a42cfad73e0 ec63fcf9b3828361bb7109e071e71cfc99079776261536bc1bd4763d607fd202 a84bb9edeb1bfea197b38e4f686c775de53dd14d64c5fcdd570a7769ef3f1bc9 +generate_key_image cae52bd47e230cf6871b6bfaae1434ee56c6eb85341d41a8514ad75ef6ee2d29 8261364ef8377117efce3e75ddf3f1e3263e1b00c30caef8d180182816d00705 3604e0646bd4ed71b84ec7fe2cdc55c60bc88ec84f770ecbf65c678981360837 +generate_key_image 2b2655a1463b3c7e76e3f30f920c0eadf59abdf82b547a4f258b664873fe8d70 f2262c1b7e7433598a770146f094010f88173bc5aea8f52e7ad9c757a760520b 47aa7333c86a36664a1318e10eed83ecc76ffc43a6d22d3b89a30f62032bc82f +generate_key_image 60bf3b89c31ab99e0b3fe6812f609f303308ed27e99125f6ce36904e9b050ccb ddeb8c808ab851cffffef29e5e3c053c475f9b581045e45406f793a6a08e100e f2c84f000143ffeefffce626204ca0b23193a3ae7e59ef9687471a3353217646 +generate_key_image 7326a74702586d2c3371a84d8a2cce5e24090e8d2644a8bc84aca59e463fc6a8 1c52595fc8f2bda42b033ea0f4914474c51830f1af30c288624ee90a678a2202 54d4dff1a4def219ab03ab0975dfb5221bcf6386cb96d9ecea4d25faccdbc837 +generate_key_image 56ae1e25e58c33498e75b78bb7c19635eaeb4c4fcabc65b55ce737ece3224bce 59d77951127d9b227b2796a855dc7b26b413adf5f40088185807a16f01680c0a 54a1839e6ddb68775ea2dff4bf21e2e7048987105e337240c5eb2f7661b9673d +generate_key_image 5239b601a807168f02a706ee080f3a4a820a82c4318a44190c8d77b5a4d02a99 9cd0333fc650a7a5b7397b33fe05137be8e7d8b3b41ffd9f043518848c72880b 51dbf8c55363ce8cccbac1f5483e44c3e16751463c25f822e6a08426cd5f2392 +generate_key_image de639358a60cbe3efc900127c0ebe8d4abc6f9ff062a2a2083ca7f78fec5f263 85f6f433fccf3b7f50191d6949cc66714059f69807ab4992469e1ae5a0da0c00 9c356b6d9372905f039c114d82ba24d3df02d0d4ac0e3e643be8bb72f84f7dfa +generate_key_image 3ba572e7852e44d48a862ccb61d190bb40e94c4c8c4aa289bae8f83aba5650cf 5c01351fd66a8ed6dc7fa3c1e81118f92117da5114cd64fb833af3d834f91501 a4ebb657b418399d704c736b5106c2e67f0f8e390ed4086ef5f36295dee41c88 +generate_key_image a5f5f7f1da5828c8af009b1fc0c86f7875ab8560b452248d3776b8744b559f1f 293f58590af5d4d25efbc1f0135a92bc28f70bb0a95f2d129113078c602a9303 bada50a9617fa5c6276a08e4bab46fad22fe0df0125b486769974602fd6ef8a2 +generate_key_image a8f909489661d54ce960b81ef7d2661de5eff77efd9ad50388fec2e9e658ece0 196ed883e9dd30985cacc37aa2bc0235281da73501f9cb0b96c890f661c1ff0f 07be020bca46918517eca8675e54c984cbf24e78031eac35900359fe9582aa34 +generate_key_image 359feec1ddd4b6c8c3dca5aa01f3f08623835329a60d3c9c3ba7c0668c3193fb 60cb86e9be9fe305c6df8d4ff8ac8f41a4e3541ce5e7630a040dc0506695610a ac9d17122fe97f53ab55e945ebe7a872edc9adbc385b738ba6739f4b78223e4f +generate_key_image a67f22bb2ddc3e649db20f5fb163ed1026c34daa0e0d249a861f9830add9dafb 4e543290a10059970b4dda59b2f349c959d218b97466306b5c284f7d915ebb0a bd97a7222befc90a71e16c6c3ce3fefedf541a2f595c914d413549547bc03b53 +generate_key_image fcfea9b25704ade7b54f4dcd61c8ed3e97fd45a13406141fff07f9d3fb8f3191 fef29570476c4fbf2e2f14475d52160a0bc3f248d7d63a22173962f7dd20e200 49cbb8617bcca4191e92bdc742fae784d5f6e7d893f396a1473df0de0089d60d +generate_key_image a024ea75eb7d0ed7e8cb493a62204bb180c46f20645d6a9345cf7f450ac18783 df5cfa9fcf4e404f92b2cbb4a05c2da92dd9252bc304e9c91ac9507020029f0f 849b486a9d1912159b6c016d608d0f65e198e38ab6a587a84b443b39bfefa3f8 +generate_key_image 75627c8c48635ee964792052bd770f218296c8f8bee18bc2ec85a40e4eee3237 c6fcf417e9ce136840081445b67247f16f3641c56ac22cf775bad9289f93fd09 05459f29571949060c4e687733fba5dd49d83551097056afe7c25c166558f9e8 +generate_key_image e39482545822090f2b0cbc09663f2632c6763ab9829fad7b3a90ab5091785ccc 99393809036be1937e4b213b263c7eca844e7ca61244f84a29d6149cfcb35f05 d4f022b5782104ea64349207e5e664b5e5b95fd8aae63947ff981508a7f44093 +generate_key_image 22b32a2761764f24ea8fb35ca3059b6db95334d0f1dc2280f86ba587dc1b95a7 4b3127b68703303d410a07932ca40832eddbdef55fe0048e8f06228d2c39bb0a bb2124b7319e21dedb1ad356349a262fc04ca09c37427747ad7860c1d93bd145 +generate_key_image 54d1d0401dc00fae59445aa4fb259e9f4eae94df037958df3426259fe1d60383 357d271cde1939dedbaefc2f27737956fc0b4c21db129549812e875184983d03 a3b282b6035a85bab88284bcad4a1ff6331f1d18502b25b66f5f4c5ad68124f5 +generate_key_image 67d3314c9635afe506026a747fe9fc0a7e9aa5dd4c8730eaf56a8e3b80627b05 d1268a8a161fea35a87b08cb681deca638582d9a38609691170e764266e9480b d9471e3f36459b90f39d516b5719255008c72389f786d3d6a7c073eb418f10cd +generate_key_image 9c566556b72758f2ca30b71cf70aa45dfb2b1abafaa8baafa848a9e8ccc68d7c 86586cb2fcba0027d4bfeaf3790c6d91db6792a29833227dff4eb7ef5585370e c956013cdb00432253f18dce32f6dde368e19b4a3e766979902ad32e1bbe167a +generate_key_image 430572349de807f60a5d858d1930691b1cef9f17edf3e4f8b2d54428e78e2455 e281e13503cbb076a75669b0344bea0b1ccb720fe7a125d0e849e8f01489980b f8f122f046f1b2b3e200db245601677124ac8646ca7d2d3a56cc89c21b520597 +generate_key_image db4c23c9d819f332ffd3294e8d27b214327f618a1954c26561954dfdf45e2e7a 81447d0a543b23285120c13e9ab040ad5ba0fe92f940466e041df6dd42e9060a f655772efa10b977cc3c0409eaccd118c892487ac383cf38995686df653e0558 +generate_key_image 22ab220cea15089f1e219421e1cb98b69b4eaae574bc9f1fc39c3a070d4226c4 188ef67fe9dd71519a70c5f38a603e3729c227457ad00fba2b68b83c3e293d0a 846065c013a5b75eea03a4e6f44abc3a6875513998ae645626b4f679467843b1 +generate_key_image 699bbf5159593021f3c362db95d30ebc69c0f58e0a06bb137c203d545a4e72c1 b4e018fcfa7304de363375512074948433786050ba8a43f805e625150df70007 2c21b891a3d6d03eeeacccd0fe0f0035d9c3f2de017b01d240811aa6e8c4a1d0 +generate_key_image 4375d3e3adcca9e9cb27b1022e7571f84bdbf3b8f96dfd24c96dc2d9aee52148 645a40e9bb05c2369c171d77d81ad806a5da261dd9b59ecdab488b32a4886e01 dcb5b9ee15cc8233b343843676ac7ac3f260570c34631ddcc624f601dadf7554 +generate_key_image 6a153e4a1a8feb42afacf87d9378e837dc9bab9e44a314332fe297fdd706aec6 c999a27b2818978098f26278c85bd26d0d8965a724b9935cef3a99443508e002 4298607d0a1299ba5c8173b4dd1c9bd5cd25b6c95da0f2f5725aa990d29559a4 +generate_key_image fb3fe6a0c979b651b0efd664adaee524d261d1acb851b9a79ccc82188aa4843c 72d861ff7f5702d97ab5d7fbe29070f9bd8edea211a5444668d0631512bda105 8632613903e5f85ebcb2269f4f97e07115066098f0c7adbd4e26f236e5839264 +generate_key_image b00e0f60e5a76ab753530a897061a33a7d9c47075a3c15051469f404c4686937 8656d0700119ccead033748bdad8252f5b1c87088fdfb81cc43e52dc0feb1f04 824d2c0f1c3e66aefffe6cdb56287e6a652ba5f83ec7c303ef652d0c261f34c5 +generate_key_image 6da92efe2273975e6723d5d554e3b18b7ebea6f3575f36a926558f6da38d6637 2f8ee0dfed02fc0658ced7e912f9d2143855d1c7a0f00918916edf4741400a01 ebc303220e9fa58608f004572fa3ef6cfa8f45b9419b547e1d08b550e7e0fa47 +generate_key_image 2aca886b58cf272aeb3a33872c3fc0b1d659f7f1a07c664dc1373bc31abcc77a fac5edb659a0ea9deba2844bef12a79c3848aeb10f117a18cbc9fc9e53db4108 01ae9486acd9eb86915e843e0e6abc3936f92b6101dacf9c727f011520939bd6 +generate_key_image 83b7f4485137fafebc646e89aa5b5af65d18baf84369e22fce1a8af45b371aa0 5a105703c66220108cfe5f0b7dc8fadfc216a5625a9f2bb1f585f915daa8960b cea0d0ac7c5da8b08ae64d77ca4571fd02ec2d474991aee96f65edb9482b827f +generate_key_image 52f15f7d6368d40ab10e36f52d992e73f084cf1f36d9394c532dd36aa3769cf1 c5c4d93fd7b9e1d1783025e4f08664379de41f0895fd7f9cf87f28d26c015b02 a2218b4a794ca58830607d6dac883436010c9a371749ef601a3f3284ab2c5d23 +generate_key_image 49797e8de9fa101b3e774742c491d993f938a82220a2554dcc89e98b1446689f b035449904cc2232cc78b64ac5b1c72c4f6bd80cc5b3a517b64dd96183fa3c01 6bcef05bfccb15ee2de79a525279aa95b25245011c6f8bd637e322bef0bcf2d1 +generate_key_image b6705cb4f059aff1d8fc57ee3e1dd546df474384e3a98488e027b0204257185f aedb24c811818333d3f640fe5f4e9083499ea2e940a8b36eee2f64bf784c9a0e 45eb00e999d008c0734ccc324450fabfdf1b0edd3d13dbd1f43d91e3d0eb8cab +generate_key_image 07a0e3c734f025508036f9671d4ba5f4e503581048ef4b0dc1d93b1002021640 39d839378af69fd457b49114596516813186c08cdd020eb3bf711389ed918b03 f9235057fd07cfbfdf99057c1638a9425ada579977c4f4d9e750af549acf5342 +generate_key_image 997e4e0fec89e2a7109f566b50b0073d6fb3cbb382548a357d54d53ad601ec73 ac9a8ab3e2a4f4fd5488b48aea2bb297b0f945e05216a01c57db389cadb0b50f 38a8c2dae1d798da7e5150070c6f47b455a61b04a5c31ddf97f185d3138080cd +generate_key_image 1e0172b208c06a9dc2a69950d7b5b27391c1ccbd4ee87eb3b629e1d5e81823a0 7da38f67cc3d6fbca3ba5223a981f5b1af417842f13e9591583fc7c872694604 34badf12f02b96914ee08491c4950447d69bb87b8208465ab5ff7b1fcfa3b386 +generate_key_image 61988c3ceda18028959fe411e61344b77efd873a994789269d64691dcede7aa5 24bf823e74fe4c4401f05aa7d9fe22cd04fa8e68de963660f4d274d12467a40a 4bb47d1a75d1e81346c7ff48607e3137fcf102228502ee32b2971a5b584b13dc +generate_key_image 96e7d25c0f22e08a227192a39635b8991ec832c49005d84e66e21bf7b0851696 6182c6fbb164dd38ed6f97728410bd606dd1f61881d88447f55cc95b9801b00f d7996735b471c833f56ae5ebda086d7f767faca6fe8bfc5037c87969334a31a3 +generate_key_image e0fbfb1ae0f02910c176c2eabd595ddbd24dca372d46a2447792efadc8e9e99b 2de901e4d2a8698471c7ed6ec1130c4e7d4c82a13a45baf9d26d112ab4d4f207 152f28b691e522d04bf4dacaa71e28b904e845dfa5f6387dcdcfb14a3d9bd933 +generate_key_image a980962f257cd512a942924165fb4f219b5ab045a30e3d8fbf12883849213355 c4e5e72cc126f4b532eec5fa64da4cd1e2bebc90f6c3808e514da89926a0a30b efae3802bdd08325c9a7a2b3bac291ba3fa7fe3948587768cc8acaaf3be8310f +generate_key_image d5635d26840075ffd8cebb8bf0cc003a8c2e60f9046966c5d8ae9dfe07d4aeb2 2ba9dc39da2b55ffceafdb6bc1b5810aefa2d419025996966474916ff5b21705 bc111f5e0de40f6a9df761e6af7cd38af270f4a832780ac6a22b4290bd621f31 +generate_key_image a2091a592b41154b3fc80906fd991cc35218f0cf8f794909cb3430c951154240 f741aace24fd62cda0bf5974de84bc1a20e88caef7053179eb906d49b8fdbf0a 315e8c2a60bf7fb9ac60fb24a5d6a74be135a53cdbc583a40e6734e5b8f76088 +generate_key_image 774be323e58e343b28897f18b63f0d7c3f0427912fdce41b964c896e12519d64 1642e209a2469b819739c6b97775063d7766eb5ff076112290e9ef8dd8c1670c 7a3b29c0d46fdd11b89c1cfe84281637a0a9bfdd2de46f21d86e3e445bacf156 +generate_key_image 05d48feae11125f6b3bcb47e236100ef882b9b53ae51a658a87cada9f583401b 5af555bc693768a5cb03619dd8f700caff1ca8f09fe478200d524186f5c2200e 31a43ccdbc484c571c6cb6d99d9e2297ec4987db9ef4cf70438ba271475c755c +generate_key_image adfaa2815d8b0311331bab9990840ebab38b4f12ef21844d2c6ec4c470cdedc7 2fb5853883c321e6c0e4b1f3f54f11725b8a68a2aed2332f2919a02b83508306 524a76d10e7289f662c8ea30c31abb9eaaaa1e55c6652778d02a9cb3d2a60b13 +generate_key_image 23d5a36582128db300d38ccf726046ea042a700b3da2f796eda2ff78a9fa156c c71d6fa00df2221b811cf1232fbb63933f3df80fc01dca4addce804b32a25b04 07a0379fad5c07a8ce6282add2688229d8f773bfe2e85152e90ff5a4cc0d8163 +generate_key_image fbdeaa136c00e69a8de5b60b26ce9f378243ef6e3e9cd9197a1bb7e486340b45 235d88c363a73dfbaae7b3b326af01594bc1f87492178a4accb4d8b64877fa0a 2c1bd81cdb8661705183070ecf5344ed8e1b4ac5b0c171832d7326a78644f092 +generate_key_image a8c4c3a00f310f2dca7cb6b9b433ee7411b76aa9b833ea94b1583fb119b74493 f4381c216f7a868457138bdc75603c3ea098f739ce459176b8868d523ab1240e ce1fdf74bafd291958a898135de0b5adcdc8fba5866a677626ce677acfd6c054 +generate_key_image dff32c36ef37da62f33ffdd370273762df6c25e96cd26bdf68e35e1dc8749bea 716d032f2e5ba32daf1c22cd67a857ae084fd756bf3c6d0f59d0aeb9d11d0b03 fd59fbbdf57fefbdbcf74b2f9e0e01f7b4a3e851b450955d96f9e7efc78c626e +generate_key_image 8d1234afe85bbb138ef110a6fcb85ff5313877b188a8ad42f310529b63bb696c 456b033052916b5e4b414e77d21df208aa4e4139469c17e79dba43339b693e03 b67746a1339c85e564dfd7df2e7f57a16d2bf17e3783cb758b8de06dc584ac89 +generate_key_image 7a537cd018a9d16d185b2101b283edc40111bbb07d772568bb2cc7afaac1ec09 6ee8af6dca10580d54707dca8bc3f58c13c612379208e3d701c6b3daded62306 88bd7443518d8394b94049b19f890faf4c6cbedb25fe3da3112e63ea16448a0d +generate_key_image 2850f3d3138017e47d0cdb826ec76dc680d04e1fc2aadc7f58bc93d0cbb97426 0eb68b1c60bac010523dacca24247ce97917852c624b98a744cfead27e511700 2e63a831d516e6fe9488878fe8901d6df513d5ca7d0fee6b3cc23ce2dbcfe533 +generate_key_image f531ef7188d2a39e99030c3f02d1bb47a899c0a54e230d445b555f0e50674acd 07131a71722a2306f54c97d2b864602abf04f059fbf070f0343b00fc8bb0260d 238e7f40d66f3bbb60bb5a02117055eb7463e637cfe370a59f4c76d24f127cae +generate_key_image 8a1ff39350100d37da402c734cefb13fb2d9baf03a0bfc3785ef6e93bcb19303 b1c372f27abd7da1296278760f7f74ae8c8db7ecb8f3891ea622db5c731b0d03 a03e79adce1cd2fa4cd913f6c0b03dd82dcc80fe988de92e794b72d021a287fc +generate_key_image 20f54ba653372d080357ff54bd1423b6772d1fa5e76864ae7c5c2e4e7fed6ac1 9c05b4ecf56c52dfa93690ea0eae3d3f9ed74cf2cef45ebeb57357fe0a295305 a7d5662893bd3f30e6e912202ba3939980286aca684c244fc86c724bfac421da +generate_key_image c7d19cfed17a1c7afbc46a385fc8a20f8d4a1bdffc39651d42470ed0d1f86b79 a43a285e632a144b423dc815f95e7f7e9106868bab7ae43932d1d932024ade02 97d49bc672e495ef03e56f631c1a12d65504fb19414b543410153a9419a6fda0 +generate_key_image 500e95c7d91fcc410e5293a430ee7f797ba41661569cc27a9540dafe5258957d c5717f2a1bbd1272291c4365ff3a88c6871deb13c1871aba39d7432e82590e0b 20a73cd45b03c46ca9d926e6f514a7205ff9db2790631cce903bbe6f1924b7bd +generate_key_image d89dcca2c675c24bba550c7b379f10b7870173201dbaad7157a9b48212a7d208 7a655d4d87da5e79e866cde2f1f7b2c9cd2bf9046e7edab90ac319703eb0200a 68e622c113a60164b5ab7c1893203cb32e51dde79d6b0852513aa0a3330353f1 +generate_key_image 58928673ec3b020af5b1c865110a3325278a28325220acefaa68110d3e015c12 0ab4857ae4eb69a13fd36e80017a9682b4849c530c7890c9116b56b5c6d2c30e c02854e9ae94ed1fbe785f5f04768b9e881540c8b8ebe24daf73d5bcab7efb9c +generate_key_image 775db12d98ee42a555b757fe45340fb8dc966d3004d1e2e0b0e621774bc547a3 dc1e41a534c4ab85b26005f9892f88ff1c1c38d2f8c8f06ad7f4e165efe31a0b 554173c8bbff2bb7ba0cbb1bf524a87290e1426311f255f03c5f88580ccc771e +generate_key_image 9960f2fe7fff005f94519b74896298cda8b5e3a329df56e3f69ca709b034074b 1350d3b3bffaa6eecb5b1ccc71c66e9993b17adc128b66ab75d1eaa4202b090e ce0095f1b407874a079d676b1963e2b9f6db7feedb6f5e65701f0bed413877fe +generate_key_image 0453318cf2f211d4a6c3cfb4ee7198115d57796079d49169b9f72ba86babcc06 b63f05a9db8cf6f783d79878637c867e2641b103ca6af39bd14f80376a50c001 5cf7182fd8527f25218483ec660d955ac9cc001de3278923f4672ec734374a33 +generate_key_image 4bd659bf2461becec62d3e8b05adbb3350bb8b66cd5b55df0c52caad6c8c65f3 ac896434b0f5421f5d8e8b6fb17358487e6e1667b53b9b422026aa43f0b2c209 66b44ad3e9849adc6d7625bea9d88a3b962673705192c7d060b448f2539f9d7d +generate_key_image a3fd925269c3c3fa1ad5cbf7595e44c32a4cca0b3e2039719623789aad9974c4 ffa75a55113ca24027d3a326487d7f0f40ef06920cc919f3fd95bb5933519f06 616dfc4e776d7273a1323eed0db8fb2eb80fd33671828e63b2e823c096ccb7fe +generate_key_image d8a4367c325edbf5a5e0a36f27ad6f1ef5847dd681bfe212f9be1a48e6763265 5d07bdd9299685febe02946db3ae1eab03efe455856f0f43ea7d8ca49d46910c 4e170b551b082c1b7907bded0027770cefd0fa7ead56f0255629281fd5c5ee10 +generate_key_image d981829c726b537d5b495e386eb335818911a084b728520ad160de6d3ccc6d67 904b7148a5905fa83e0332ef321d4ee202f416e86e5171539eff47999f906003 b072cdc80a3b7b55544f52ce916849dcce5e73613e330a5b7b8ace1e374cf8df +generate_key_image 6c461894e687797b8c62674a42048bf8455942ec804261ddea0def73198d9701 e17ed8c8130f5353f20917ce1b1ae91ef4581d6935ac1e963fea6cc9f08fee01 65fdcc550333facb82d9a33e316f717d7167b1181d63af96aaa4f624a1385da9 +generate_key_image fbd91ab7e63b04985f8623f05eff48f3ba16fbeb64b66881535fff045cb06a8e 164c2feb95397748b10e5e9e408c820f6c582e665ecd340849cca2b482333d08 3a8dd024d961cc384326561fb100357ff426f2dbf74eee430275f5996e60f93e +generate_key_image 692c1f562eebfa7902e1fd2f42435257df41e87564deb791b653d56b812fe968 b2b38eed63db26855a64403e807c9fca86dace87888830ad0de46e01220c4f02 aee831e157fc656b0c432683ef6e0dc50b940169e8b4242279a6361b16f395ac +generate_key_image 8ef9c401f5d1119d2603ba0b636a862f01e0659ecdffd52c5cfd9389f0e9bf56 0a12ac95001105870205ce36754b68dd4eac4e021f0a0deb082644add0c8f200 a2eb8e05dd6dbc0da12eb73dbe02b81eb8b0fe985c8fcae37ed5596203792fcf +generate_key_image 007e03d991c337fcd68b266676f2628788e8bd952e58078f7187e34ed9df94a2 5239beca1757ab72e0c18a4d5c70d63ce95be0569fd128c48b1833fe98683902 940bac041dd9b0e791e195a50e112354d369099039ceb69288b8b53865c1d0dc +generate_key_image feeac3846cc2fbdecab7f71704eaf9561ac695c3a7c0d6cef89c3184a9d67896 5cb0e570a5bceb709faac84653c68e540eddc3f3d93258019f89f20eb6da6c0a c3db08ff11c957c9e46386d42765db28f97daa5424201c678cb08881bc255d22 +generate_key_image 38e6c1b51dccd0d7a1ce3cb68e76c34914b95c2faf443a5ff3dbaa9b6dab44c6 aaac20a72f965c36ad3989bb93e823ced24215d0a7069bf428b03c79d8c4ee0f dff197f44bc47dbb19b58eeb95c2a88d55894c007099fc4cf10d6350e1c20e2b +generate_key_image 7be9c0cef2ddaecbc3024176ba2d15c18f83427648af51f2bb3f199f3a7fd7a8 b1981551eb60e41fbd0c044f3a53715a7c6c6d1c85ae066271ad13595dd81e04 7843fd4cf04059b3129d6f42ec08b7469fbc12acc86d3a03a7b40815aa59d327 +generate_key_image f871604950cb16ddce0b5b98f38db5da1e35322e0d47860471333c45d9e4d890 82cf04215795d5a08ecd064868bc5358b6faf6b609a1561c471b6f9e2fb33f0e f110592b6a6625aa1bb2ae7725c20bb059109ed4b72c37657ce813a3c6c581a4 +generate_key_image ce358f43065a43b5656a5c0ca818416393de19bbba5cbadf686e3ac72d5e7452 212cc9ca4e549ddc1ac6373d56c05bd480aa9cbd995bfafa25a2d9345f8b7806 8504b27d6eab3d38d63214b3ba4721a6d0b718b5caf3e48220cf594f69a63210 +generate_key_image 1e14408cf1c4d7f8916dfac1deb11158576c788272efa185dabc8a0765d8437b 9acdd332a020dc528c373c28a08a0eb46b49c09350b2111309dd16b75a6e290f 1ebeac0b3fda7d38e3cfda41cf69e0e0326e2e3c6460f29e2e0d579f7bed23f4 +generate_key_image e956182c29b447c870293496890bb95b982fe06de4e0ad98ce6d4ac4bcc5b270 fe4a91f276264096bcb5965e2537319d5b4bf94829e5bee646a0bdb0c8b1030d 0e47442e2411f8f93e69db860c202812169637948904a2ea53a6544b7e9d3e5d +generate_key_image c48915cbada882378f8482c7e8ff57505f04b2ec3d5785b660e4deefa2a3ad8a 4d3dc9bbc62c61b8a51c687aac2f1a37cfb5f13130d3ca1669e103584afe230f 05a6bad9f2ae11a2aef79e4adc9c35391d86fe41d0a6d4dfb5ebab480f09a548 +generate_key_image 696e28ebb13454825fd28d0aa1d82dc5e94fa7a00d04d2c13b575fb419fe5722 45ebaa0a477c9f2300c39a7f0e2989953d2ec66b1c55232c24ecb1fe72843402 2a422274da2a2194dafb4de318f86a88e532b8c949a0d2f69df53d180ecd42f6 +generate_key_image a9e191cc12aba250fcbad18e5dcd32dd44a1e96d3d7b65d829ef763128aeebd0 e02f200f8a1f26774b2f75c4f0b2e5d77d662d97586513b8ca0b1da3c23aec06 1456ba31ee58d9bf23b45b9cec1450025fea11de2c28aa805ca043072c302e38 +generate_key_image d1f63b7d407edbdce8b31b642308ade5d5ecf262825bf3c6be45a1efa6befc2c 3e32cf46325bb7541c04d7e4aad224f5914c0de390d6b041963bf5e6a3faa50f 06ee50d11ea3a92d70f63cafa5cf86007a63555b320000d7bd159e8089fb938c +generate_key_image b9adc45192d3096748f58c6aa4180c1084ee1c78a116c3480ec522b542021dfa 18bc52551e150155c6b8cc4f13b0424eaa87d4c1559d30475b0a8704cba10406 32b86a5be046d81ab74ab7f7ed1aa08e8869b86e87a56e363852b76cef396ee2 +generate_key_image d8e79793544bab0ad58fdfc3c1bed3759f34dd272a16d487172013ee7a0eb516 d033ad38553f7da7820e2d808f89e13ece56cabbf599e8f89346998bc2607609 0d65336c2af006c30b9b3726e6785765d35bfca27272c7f6b886ed39c9f138da +generate_key_image 1b70e47678324ca44632276550876be0e3507884e8ad9e268788d5e03f7119f1 0fc5090c2d4d32178cd217509da32aa88966e3ec90fc0e1ff5ee6ad42f038107 f06ecd7a0b5ae6a98c1d711dd7bee77f6262f84df6ad013a355b5cf823863ed0 +generate_key_image 7427c053014583ecd07e81e1c917906c381af54a7ecaba8498225518a156bae9 d9e07405029a8bd4ba75dbda93756228e18674e3138d2f7b2e7796ee7430ee01 1253d396a6e7a2bff50c1fdf54bb90157727fa20466fac74e9138355b17092e9 +generate_ring_signature f23065c28a04de5d38606f37b7cf29c680c06c2a9bc00b2bb3bac696f9df5c61 7046e48f17ddaaebb928ae39dbe62c23441f01ed40d23fbf5f07e5a352d06197 16 9cf7b3138ddeb90d60b31bbad6458bd58bcad71192d37e69444b28f9450ab37b fe25432b3e417e7123b3b55661f9d8e01b9238c801feec00d01b0a144439126d 1af5776b1bddd8ea5e775e035ae7a3fbfa2e08401f7bb01162ca7d2c9ce21aa6 8138759a1d698a79ba0ee523980c7899f5833ccd15f9c224a02c44accc46ed71 00cc8407088c92ac28aaeebfa3de0f699de189923fb7fc18daf1361a7356c203 6493d68aec79197563b65b4d202665da993a27318538b46678aba6df7475e6ef 2193c3b3e8c038d3ee84d30a3e6b8ccbdf29b25f9b576953907b28a3abe41689 3f4692db3e0e194005497b99f5097938659fb00906b308e4413ab07d20d21ca2 5adf105a86dd1d4579bfb3bbd362119122bbf9517c089273570189f368919f60 8e2b0684c678a5e9500332e375fe28f9ce127e1d847a56aa198f81d02afecc3d 75cd3c47a8d0616d4f7374f3b652e2b4dcbedc826b8b0f22c8f2b12d8449171b b26567ad1bc3e39a4d59795b347cf852c35944498d5ab3537ed76f63111bc196 a78edb131426ca91e0a25be0197578a4d4d2876d18313a940814d8c8e65f493e 943aa48aa6dec62a8f30eb16e796196e3a35569203e58067228c8b496a739d4e f9d1ef180af3b08d9ae7ee9dbb687591bdd3f8fd2b1912de622cce6a9e0d25ba dc6c4e0b458a8f3b47d5841dda4b34bd01c845031421c8fc34d90f2356564fd7 f7738841783117a5206b00b4054df1949312437643b353459e02552d2c69f10c 6 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 +generate_ring_signature 89226689e486049662075f55d46361d821c5ede1fc172581458207aeb3d7374b 4048d63774cf0e3d73059b76c1160f5b36fae2add758c0b5d0a76eccf459081b 2 68943d3665e40eaa5d8ce9a3279e70e9d00afa0cea15d6671e024efcdad2900c fb89cf7108eb3b68243e732e820d716e11a0baa0def8d2d837ab998a9bd642c0 f75b48b628a7f3fd1dce1055f7c0b81c36454e012dc7ead8d5528c11cd52990d 1 b75835eb2db9033ea11f871e0e161a1e30492a62f3eb7a82c8c121831dd38e05eb354cae51a82957662bb379e4f64fbdddf3cbde4ef12f78110a2c5ae9d9d60632da8d7b460b7bb875b5a60d61260db92d107b3406506bf8bbe5de83380370028bba901d4ce74b00dc1e2b6e95d6a5f8e9a0704d107992ee8d3cfb773318050d +generate_ring_signature b5d8229ce74db9826924b3c6e5caef7e7e5bf671ed19fc11be2989dd3c47931b cce45b0c2c85b4210b5b11644afc9395fcb69ba98603adddb5553445e9ec7b6c 144 0be075ebeaf99a172e8e39e394767c3a3f987767dd4980c63801034626594ae6 73fccd68f4dddcedf7206f4928e50477501c1efd04ac95c240bcdb1311abe7d7 82d86f2cee19fa0019fdd5680e9f5bc9a0a19fd20fe801693646eb80029cd721 5028c84c1470faabaa794544bdc8cd2c711465def027442c68cbb51d8b26a173 cd8f47f244cc2c434906ff8a3b05cb0cc6237dfca4df80f54f737ed73a8de6c9 b5820b71fcb114db2922d51ff6ce2243fee94e0b2b325539c7ca31701a291b9b f8935af82ec3e9e25665a07e742a0db3ab87cac8f9aa8765bf50edde6b039370 3ccbd63146f9d7b10b80d92ee369e723579b31d62d93c6792de1a4eb498cfb3f cd2d042ef2fe9c3cabe3092cae589b3ac93bc006c44191ec547645ccf67afdff e2d93bf17b1a2fea61e957bfc3e8a9f354ec7716fca36d9d3147608eb3af97c2 8a48888c11261fb5a99f7d446d679b545f9053b2daf6c82afafe43f8ddc2b6e0 1d5a580055cadbb839eee43d38dddb20d970ab5c1a9e2f05c553d299cf495774 f502b134474771d28c63829de5e2cbb68f561ac4424979ad81d9561c77c9a8e5 1d0c147249493a9cc4c6a08a5e1b787bcafe06363736cfa165b1a01347160495 5ac2b45e81b6098c0039a2af48d87b98e39923f3140768b797ca3d33929ac7ab 3859ceeb597d189dc18be59daa68d39bfc2361b820524631bc05e22b78ff775e 96dcad77dc296cfb3929634e642229bb0f748cc674266991ed53d64956d6677d 3035e9feb91d2bdc3917a8c58b76600141a4333dc94499e36b9a75509ec9278a 78b57f73d0d54237460f950433f02b23a8b73fd686db4872dbbaccfd93e4962d bbc589f174313a7862b5cdbe0bdce6ddac58d6167fdd906bf255e3e98ec79160 cf34f7674a32ea2273517d25472e5bcc686f3f461c734e4e93a302b4c9439d0b f880e06bdefa123e7b6a09ba0e0de33fde7cf7ec3b792abb07ad06107e192f73 988521245df44f9840aab96fd90af3c22455058e24eda4f2e33e1269dff4430b ebf20602e0afa497d66b8e34e5269ed831e970f912310e178c1414d25ca71c35 5efd0c9703fc2e020379534b469c526171091147c59d2552a871823c11821e6c 943dc0fc80c35556a653903f09cee980d4f66d9e7179dc26ace15aed32cfb9c0 274eec520fb3250395785dc104e5b914ff88a4d7f9da7e07da6c0830b2f3a1c2 560f145a25c13e0a1f6d9d79edd399d5afc6b09e3103c09f1d77b11a975e3b2c 3b13f3fe0e4428737929f2e13aa57f675e7e3688d8b7b0475d0a950a730d354f c0c4ddf2f2fbf1c0c8ec3873285ffd498b594cb5714c851c27e1397d386e12bb 81ae0f6596c54518ccad5d592123c5960e17b589686cadf3b530b185d93048f7 4ca1879a6b680cbc2024fb37a2a17853767e884cd8e2ad20c2499fbdb53d57bf 56d56a1d537d1f9bdc2505bec8cd238d765e1bed5c245c1054422520d7204ab3 b3c4e1763c0bdb20cd468a13560fd0ec0576d167a3d3d62523067e8e23a2ece4 90805b8b9ad99246003275c1dab6d1bc2dd6bb12454ac381c662048c5bc54738 dfea8fcc3267c854025ec6c917b696c1905e23282ccc042d81ab3e37782380c7 d86baafc5adb032b78d5a7e2047b619544d0d97236d79002d3a091897fa0c48d d1f6ee6693c03674a865ff5f24316e48f844784161afffa57f0bec4d098f01de 9ac006713f84fa6e3bcef13946203f85dfdddac7a471ccc417a65fb929c52d3b 9cbfc2677c60a2cf155dbdcb8065778c7428f6ce8524f483d67eb45e7e9ce463 ab7bd7860210e59ad3231d0309b591d1032b6af933d59506641e55b659efcda3 7d5e773ac67fb198cd86d94f52d8949d3a44bf213980e2e9355451e65d5d3888 3f34184c4cc8f2d7fff24871d02347f522a690866c695f2c7592cd37ce48f9bc 6674fa097442f932e1e25123d663672e2de17b2385b8c41a6a509c46f89e324a 234a35e2f0da5e2182c2450e90101cf1690235894fe8ff5cf7036e03d4423865 f2c8967a786fe891000838ae56ee84891df8dad799971bd87ad9e3aa0dc1d03a 0484249715649583e496f21fec59eb4c35553761ab82b3bf85ce18e67c184ade f6104748641de70509aaaf7330d390f45ed534ef38bb11ebf52ce8e6b1f9cc42 beb938142360b3b1f0933990a5c0e65180d77c2923b2aa2a3f6250c153c8dd13 518d918bf968bdcd664b6bf24e865348f7093ed723e0293ee86a2402b87e5df4 e86e665a415da43c81bb03d895151814ec4c045147a4bcfe37a014a846f26436 1a11a329f7530ab7b31198f03d8d29754ffe53af384fe5d4db3fe90ffa3360a1 cbf7a677e205f9ad968df137584d4c90438505a629dd6b5f3c4f822564b41c8f 903ea1173296e05bc70d6ecaab59f1a6ae55ba8b428d5ea9a3a5e4217ab5dd49 aba326ca541d77ebc99dda5c1ecc21a07010c2945ce9d5d18a2bc753fcc4156c cc007e712cac3f9d64f16ed07dadddf934b1b9373247e0e8d350e5a2551ee0b7 14200d798b42df0eccfa9f36ad0e18f1aef0021e9d3ae7912e71bf4efa947f29 658b34f8f8f575805b075dd65b5493b737b1d8b6ba122a55a25f7053f23da8da 146f311fe86024f1a81034d6c9bda14c3d4728fdbc030901a1ad577bef3ca5a0 9eb53c235a0298a92643833c1705b6bbbbf99e254a74e93a63b1443934ee7aa2 ca1831e48ac62ded5bba90fb71d61fcc7704151495bd72e05c62f780cf9b519c 4d1d68714278a5333173e703409b4303912cf3b44133102fe9eee8842306fe08 4ec22758002566d15055dc51f1386907f7104dd011c8337f1b36fb29e881bdd6 0c90d65ca0d89c7835d5cc8f185c6abefcc68c0fde058a516ddc19aae133f6af 548f850b0f17d7b21e8c1a0d77785253b05737045b944364c157b942d094e5b2 d0607ab0ba606a0765283abdc2db799ab04c5c63edde5554396e28a87c5bcdd8 51d421c5fb161cb1c883e2e81930d9f848c5eb587aa2092431afe368fef3e0ae 5ece9e7ca0757f3342408b957d8a0848fdee5938251626670255ebb0a75ae101 5579c81801b58b99d1238f2253651b143d8e3ec4cc69f0ef5fd5483d216e1319 7bcaa05b83bb272070bb8987bd618c24e45311b57085b5b6a33f3e1ab804c4bb 89d7c2d2338e0b5fe50d17efd1a567460b484d1dccf9d528efa6757d5233c85e cef2cf9153cb0ba4f39713613ba40ff9cad9cbb7e518fda13e721c329e6e38b0 8a831f7a9a03d40371d569427e1c00b4c6b59a804135c90849fb0abeeb203bbc a71b0481ffb4425af168570f2b0b415ed1fc1c181204e21a27fa5862d8a63c6b 99fedf8d43745d034e111b8cc7d99e54d18b53c40a428d2628365b2b720a67e7 d2575e2b349a45027aea08f5b423ae42950e39fd365891533196026f6cd2d496 e081393f25372bf4f1aee37b8bb04921fb8f6aa0fedc1143ad9fce6de55243e1 ac4168afb6887345c8491a395b777fc2ce312372c6655295faed65742ac69bfe 5472335979b474db10d62e368bd14c7fa3681e2aa3310ab5175d47b9b23d4861 3e70485ea10a5d0763c84c5dd9e09a25adf926965c59c0d7d1345a60d0ce6024 ea6173b067f377d97a79537f532b8d2343567e92cb9dc977e772cdc6129447e6 da151c45da028df365edf5ffb819db00f38ceb10fa687d629f958d653c7f7753 4d94eb70a30b0c63513a4f09907f972fa82a2f941be6bd9ca914641ebe8553bc 3907706663fca37513a9a30facd133017aa772f69731be6d4deb4f40047ccc48 32d52817b46b90f7cd04c2aad2ba6f8d44c8082ba397c60b0d982c5c7aa9a8f7 8abe3186bbb742c573ac355421962942ab2c75facc6c898ee4a19a03b2526ddc 9bcbd8770aeeeeda57a9a2dda3b526e5abd65acbfe8b68ab4fb346da066c476d 010c68c46034de748d583b050e2715d98ba852735272e8d11d6e527bf1a40cf9 3407b8a4d8c5b985a20d33d3896cde2cb823320fa4f7a8f2385dc320d83d5ddb 53a7e5fb8541fa6abcbe75a39cd9b0352119fcc84e724a515f3442d4a558c55d 73becebdf4b4ddea87969a7d672b4778586a5711226e7ea72b6d615bd6eaca29 96cc838b65be8f2cc82682aae4948d766751bdcdb162b399f73b2d1b28a47492 2a0780dc42a9aa0ff3cda976a46510ea79ade528d57c66131da66f29046669ba c0e71216cc5e4dbd872b783181fc19b8c838881b8c7feeb7b679bfa700c5f00f f7b1094d3f05868b1d8f82468e3e63d6ee98a2556190e8ebdeeddbe739662e70 7cd1ae917e9fe9b2250d118b320a611c42907668a2a916430086e79fdc31624a 6c02f8d8d410727f698344007fde07f7bb260eff705a031fcca93387c0538136 d0f96ccb71432fa05978ec91f83d522bc6237dbc29a28ef02c9019f7674df4fd 0754988d535e9b8e840d17088c97eb0484b9086fde51eb499f9079c8694b9092 b45a7849a1b66581d71acd062609a406e78566c94863ae128f4dd89db838b09b f2c392a9b334780a36990057be799cd2d96d9544b3388563fac448e2a8e61ba5 ba1ac60d28e8fe4266f7e99ba5dcfdf2c3f03688836b6e39295b4f08356e5e39 3cb51ec951027e73f76394226b502c12549883591c82f40998d70a24433c584b 6349964aa8486223d4b70c8b8fe69145525bd91ef6628e1c6cdd2ce0ba04c266 290f25e23204297c88d4e709a0ca24e3cbc54b657393ed8569e1d9f5110cc2ef 0ff7d6198640d9e511867fc6f6eb733728d4087cbf803cd6fda69743415dfa0a b11f6e8f2fb83fd784b1281372023354d58d84ff26c24f6fd7701537406c00be 0b5a3a445240b4151eaf074d6be3c50bc54fbb69db6f1eae09b6c146e81f87d2 a70b418a5ea1f707725dd25fdb646fc10411acf4ee3495c160e56057d469be7f ba5d677d820274a39f795af23e660a8fa619f6213d0c99051f93006a472105a1 da947bc68bb177db418974a50388357ba6c0c7f7d1c269c6c7e7ac12013aa388 b8fface27affd9eabd46e85658c00b2d1a187938e70aaa0401ce2645e1faadc9 01950f516b23727d50e930d6a7f982701200cc9b4f91e5fdc24fae0621df0648 d1525f7d9ef2244122bc256f431b58a53f348af292547b970214c78677d96748 928e5176379bd48f34ef5acbf25898ddde6fc2de80783d71d01dda12f38a85e5 c4e9fb2607e4e77d6be6651e8f3252ee3b0cb4612adbf38432d8cc40a25b6423 e8c78da2f6c26bec3eb9d0c8e54d7169a780b4eb3a67f60a7be45b3b347950c5 5f198b0d848e36526f7159ede1b985ef4ac6981ec31d337efe6fe896236b48b5 d49ad6a6b2bb67adb3503179d1c79163385eee4ee6169fc060058b8ddb9fd401 80bef6ec30689b27bfee132087ec9308d11746263f7dd4313c400cf98a45724a ccc998e5dc245cedcc864285e40a6453fd2e443a687e0695e1f36887168dc5a2 c6b95bf4bf9d0514ef8f69abba93cf993c4731598e9bef7ac7d1df9b5cd868b0 571028b516c0d6f51d1b7809fd5066494fde172fb962f2a95d9091cc231bb462 f039561da33396d6cf7f3d5234c3b624981a193128904f296a2d49539c5a5354 c254db3225ffbe528992738a1c2a2d659a2b69b7823d5dca1f074768b2d0fa1d 26e8fb8d19c19f48c8a4a6fc8c7ae07d81a20e338b26ebf71eb6fe9cbedf82e6 20c5dc8182e869ee3b7824eb8f3aa8bbe41cbe85fef2416a116a781cc761c459 627f6fa349be0f4fcc820ebab0c373d346081727c41b3e41f6908401c55ca8d9 dd81b44f36eacc86416c791de3b6bab04d52f8a001cb805f71a09572a8dee99a 621a8ccbf534ee9b37d39f83a6f02768bc0bbdd56a9ffad301c905f43f95df1f c0662a10f78456cc0b271e278563c6b269dbf1cf6ebe5cdda87c07b735aa2e64 49f3a3193e87521d12becc9ef14c623e844f1f1a6f55fd6c2704390268f45d90 6623968079cf82cc14b56fc0eb73faf93b4cb5a4f6e1c56f12e2978aca03f6f4 c9f349184647ab482890e8f118a92abb469f62c2756b599706898a7ba2709a8e ab17adae0cb94f56924e7aa5e4dbb18b640fecbeb23f3728694a071af7efdeb1 d3b700aecd64ee52833e70c957c2d6d3f3325321786e4ec6fcd95a4645e016a8 a6e161b23862fcf9f036fa3627f2887089f79bb4e9df6587a23cf40079e07a02 44354eb4d4a96bd9dee8a8e74f2596f5cf117eb2137057758b012ef761ebb94b c66e82e556e827481441c89dbb03bc57e7fbeed3b684ded48c276056bec9fac7 1376ca9c2e462f8d22aac18d284d5ea20b8614a86b30fbe073baeb41074cc51e e098ba48f7f5f85336e47ff10a3edca5eeda1bf9717de3f4262a80e77ab93674 2779e3d23b90fb744d69d5812b0c06bd17ef83d509fd6d5a86cdfd534dceaab8 d66a3585928fcb67eb352804e9905ac7bca6d6011fe5f7e3c15df19a6f9d55c0 9892556bf022ceda7b1f04aaf0328ec0220e468010a235b760069df477789167 d089b93676963402c9ca2305200908ef13f6e5e5539cbd865b44cf6b32499b02 106 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 +generate_ring_signature e8020add6aebab8ca5f8b49f2072f631745887fa205d8db1a3aa1b5a4e232d81 dd963b8d2145bd369feed2501aeac1de2fa16ecb1b7cb93564535a6dbccbb3c0 2 9f1c652d42539ae6c7a43a5118d5890a4e1b386b3a400ebd8f2dd5687626dd55 90a86ceb7951f7b5668205c22e8d2c9953d0e44773f7d0159618a8a0238a53b6 5e6dd5608134fa4c64007aecaa340a0f379d1a5c6d4adbf017a239eba303c808 0 54f64f10696886893b4f082a6eb9d359fad11a3e37ea1ddb98a107e8981d3d0e12172753fe43fc0ed4619c4377ac771769da9b4fbfc953e6edbff7cf5f718e0ca3de0c75ab5ffb3eb1cdaa427da5130428a7c070eb5e76b8004e36e1b00ca208419b1e6dcd67d33f5669bbe6806f5268c5f4bca38c2cd3f880b55158d1e0040a +generate_ring_signature 3e592f32788ec54e3f10560b1380761329df534096ec12251382a96f8cab7eba 0b72892038d4248c430d1ac93f4985a8bb9b43fdf457a83618b7045980b8e6a2 1 526c98024c9a4fa8c6ccad5101f4afc972fdeb228620d774669c13ec4d029cb7 0741f944319e0c4678f4a414a12c6956cf9d4b3ad04a40cd6030e47ab7e9700e 0 2aa7cf859727b38bc828220f8e498f6c9a2474da3462cf802afcd9e69b8db204574fd64224cc7f6b8baffc7e26fe091d2bdbd14bf7ef4bfa32302db080c21a0f +generate_ring_signature 701268c079222197470218f73587bdeb19c3620f25d1511042edabd0efcae448 c2b7340137942802b68be0a9cd0deb826a43f7645807c8f4179c64b11021c36a 1 515cc1cbddabcae11062f52ba676265114a44372719b9b5dcff7865cfbbf1568 20966d94502e95dffb45bf07173991a5c0ebca48c0941c8c6705f7370bb2340b 0 09f1d8a4a5fbdf99caf3b6a5a8c876ca82ddf45e0975171e72a60625eadda80c5bf666ef8d1764db408de5a6f5decb2a985cc87a0db4958243a36eff86021701 +generate_ring_signature 847a7cdd3eda4d087626d16b975bd8dea19bd914d35051759ccd76080649a606 a05d0004f793a217255613e5b533efd58bf1d00e9ffe7d1062aa6eaff00bf614 29 60fa9da64e6873d5585d7c6b445aa994181e460fcf9c4edf9c2562432034c418 319cab68723c9c65b13df37ec1080812e182838e83f12a49d72aa8b82f8a906d e0d78f852a658ba8e2812978927a42caaad783594e463b73d25bad7ebf602a5d e5d6e07c783c40cf86479b179ae2c3064df13826f6ef66d1b5bb458788f628ad 97d175ad6b1daeb14df659240d2e567b269604bcbe62615efc1acbb3ebdad4de 5915b9e450d09664efa12f6477a526084e9a1c16c814f366e4175cf03f0bdeaf b08b9168207c344ec1f1addf104b06f4d396fe0a703c6fa22676549e221a9819 e28dd982bb083b405c5888a05b7ff932026a2d163febf55f7f8425df7a2381e4 b6cc0bc087d836d4e29e5ead0bfe51998943e147c259a851e138e931d6ee2cea 6bc6641ed933fd309190317c1b43bf34a7fa205b2cfb041c9f8d51da1775c09b 2438d50597d45379e848462033a037b7281eb6b3acd259a5190d9279e79a3d15 eec728d14ce0721d82e552a13d446866f3e43c5fd45d8459f6517aca1f703e38 6fbf0ca4da28ff0d2457d63f48864662748274eb304d6c22e3bfc83296ae0deb 51aed9ec8aaf554276b3397a30f18f76eef129585a5ac056ad9db42d6b062ab0 6d3b31ca3c9fcfc03be971f1107ec82cc5f5be67a0cf280c899ab566ee3c3cf9 acbf10cf496ccbba0ce691cfcfb240d1392c583288e0dca2b562710f0acabf5c b227447474e2fdbd382e6dc62061f4313c040bd951dd46d380b1fc4b8dfdb341 93ae8143cbcd9604e8862ee5d5942e90114e5133fd55052cd2d9c266a858dc85 2d90f8a4ed2e98285e9ab6938ef20da123f365b84f3b269b3ed03dc885e2c86d f7a9bc8f7901886e7f5b6a62c0f09022281d213e043df961c9bc61554ef4c8b7 58cdbcbb72356615330903011bf7267c8f2d7d61abfa88789d43567e51c7cfeb 742e0b7bfc9382859b7531e43e11e99c1ec1089ee901d502f116742194f78534 bed2b49b3170073561c62fbbcc1397c1e82ec0a252299234709a02b5badbe17f 6c7802b9d92c53b2b8ec8f761a260e680f92b4577485b5f516fc594984381047 3f32e6f5e41eb10431e1113916f94976f4fcc9db76edfdcde37cbd20a22756e3 9031e2a54db5f2d4358cc9486e5b25626c40afc5c43b20e260b0bc301d85bc41 02dca47cae77e6ec54842ae1a80f341adda1e0f5f78d016a06d1bc5595b7574b 65399dff20e45ceeb08f30f42a1e4f45c7c086e2a5f5c30f0645acea610cf4d8 894d72f759785abdc31f519d816040dedbb4df5af332187e9265eb1d4051da06 6f6da025d6473c5c0f30402add3b401e177f144bae5f907af5febe3ce32aac0d 7 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 +generate_ring_signature 21b7918f07df71bb61eea02d6eaf44427254d6929fed711b69702a07f2581ee1 2170c653c773adf0ca992a320751335723a37f418473b51e05f39f4c56ca0158 198 a7310ff48dae857eff6a14d2feaa21e9d2002f36130b16460b6c39a4a7f9fcfa 638c6ab8292f8350eba3e282099ff5bf2157e249d6d8f4817c1710f650107663 15a1047de62574f925b50199dab771affb8f588651f52d19fd6412c40510ec84 fb40ef2ea3d9c88142c8014b364e0e0c7a3c588e5f45c8588e54450d51b426aa ca504e824c28187e327b5d7ae7199a246f73858407bcade0f3ec9b4d51678d6b acfc1fa1a602a4e8d7b40f5db21b12cd4fee3db4ad9dc873f6b2f835573ff911 a0c976e070ae6c6ac4950b098f25fd6152cce78b02f9c781500fc12714ca63a0 4bcd175516e2d4f9b189dc916c29ea08625a10439ea0a81ba3ff909ecf188edf 8c68075275c103c3581e9e0c3b70687278dc986cdf603376d8257e4d5d95808a a27f6a62d4aa751c9240553e0a3997eb518033004ffad5ef037ee51358bc6d2c 738354933226891098ecc542f68555f2d16326e5dbb8f8c2fc91db0d93db6c11 37b94158c61cbbd44dca406bf67c8d4c13e7d0c8c7e9d6794d5d29f576c477c7 dc71ccc63377eaa777e6f591ac890132d59e63dfd9fc26d1ac5d90e995fe2bd8 a9c3655c5e63cfaff27b9b7553d34b8dcb632d8d7eb60685904c589665e02996 35b199d68a146841cc6b62ef32f7fcd470c6ba3ac20bf4bde67ab988875ca553 7e00d706b974eb2cdec2dc4de1e71773dc7c7dea234749b3dcd9cb6ceb3d68f8 515e89a78026305838e4e059b0ee9573c61017b25e92bba60f61ecfd06118880 9fdbcc0a4a7b68abb0cc94571b407ebb3300c1a37cd1d629dcfcfa8ec982afce fe328fd284ef8f8ef08babe0357c39c1afc76657b3fb3e76948c546dadb5ae55 473046fbfc71a93af79fe516e88dd2cd2e4a129346fdafeb8458a887434020be 76025b240fd55cd3f0d7618cb987353c22ee6ff017f68aadf246af80d8f53a1a a3e4ef02949475560168d74e757d636ce95390013a9f7598e5751c785a0a3558 ca46eeb8fbe1b6f71eb46039987aa3a0333b2423000e28c8ef91bbf96574b5a3 756fc67e7addf14dd110af278b6025f47b721604970da8af89988004a74f30c8 430ee30d84f2bf7dd3d73f6cc7d25970b0da0e44b346203eaaba6b87c8d1bc49 f0bf365b8ef1c4af3c1489f969def37f165f60bf90c4b1e7d1e64caac02e0d00 90d8d60b866aff84be78562d69efb7c75ef8ad43a6dbf8180c7f3bfa55385f42 81fae7a46b3206690ba6592ec7ea31908b6b7426eafcdf4b72a7d867db80c290 47dd69f8405178eaaeeb253b81d9854ca3a5cf4dee853c9f09e5c018a888a990 3dbd9c96886f5ef5ea553af02f558c12699a62aef89f0959d36c11b9613edb5a b6e92ea527b2d00198bf9d08c2349346bb9d2e52f9a58f6f21886762a8bee77c 5137c2a7ef939c6dd71c516956c0bad82ecce452fbd92d80ad2f893d5db044bb 83b98b57a098b4606091163dd68af52900d995955054bfbf8dc5be2e285e67da a34e7a7bd0709f83d3e8edf3f4703e8e78f5a8328b8b537001ccd78a1fea0099 04bb7b526f22df2a7fdd7dd6d96a996dfc840d3c52e51407e6e02fb48653c17b f85f3534c07f3ede1fe71fa8ae9c41a7a6a8ca0114807f27c3a648e67d010c0d 30772180f96ce761ddb6bba60e078ad2697edb3b6368fd6b5532cb556a14a927 246288f7cfa451ceed0911a552bb87eec77673a9ea63868c95fa1a5cd2595d28 5ed823adf2b16c339daf9a63307143086bbd5d9bd48ad7884e12342177b93873 98d730c7b3ecf9a20d36270912edfb78e51f7d57783caa5f0fb73aca4a98faac c9b1c8b87c927d1ff20e8e11be50ac120ea712d56c79bbd2b0b4a7cdc380f0e6 e016f3e3bca138e242edf9b041cc9fe41ebbd76758fd4648b617c8566227d19d b4785c29d4cf5ec8136a91d82b37f00d32cd9f5c0cc4ed9f98d89e9e12321501 d7530c1336052f7fbad4f88f42f7b93a70d824ffedfc0c677b021ba884f54a2b 8a2b6f62da42c1c2345040a426a328224b6e1dde8046031bc38aa198fc946495 8ab5343f36337e7292f19f4f0cf0ed20f7129cb685d46960181ef8ddca615f6c eb77146a3a92895571947e4624b52f76349eea5415a1f0b64cafe44a1d86d427 144403c29b2301fd621b2192d294770c43271c4b1a65aa8bed9820928939f9e4 6fb15a7b933b936a2b00a1c574f114c8f1fb55109c0db8fbb1f6aa0cedd24411 5c098c6ddcc9775715a8712cc941dc760043b1be592cc1e794ae2df2674bd12e 3d3aef339088b60d7de300b385eb5740bd7c45dab071724717e85d10dfac35d0 1f965c8bf7cf38446d5cbbca496b9f4e1316598c9714ba751abd6279ba119fbf b50c8380cee5ab2db21d19d3790fb04dab6abc77ff660d9249ba511823270917 50f3f18353606ecf073b404fa9fd25dd89081fb2558fa739fac549332d81f426 b317387602d238b8f8e60dd59cc63418f3c911bf08e27e743802a6056d7dbe6b a67b3f52133c365193b3d0b07a770ac1a9ae2f968357f405ec0c5dc764d9e89d 51fb034fc77c16548c523577fb83026394dffcda641352e07f261046aedc29f4 cda39cdbcdee442b798ac1c3eca2c9fd9029387c5b9d6e4931ea007c69c1438b 5eabf6be3369f04af85cc3d9ea07eb7d36d5e8c917bb4ac82f65f783087fbef3 b93813588e0e1c30066efbaeaa1305afd7f3bd335fce47e11eba8613c2332277 2ab4bef429a6b5516c179036065c2f051e75cd0d39f5be376db50fbe7d7b524c 4ba8c45569fb7f9633d85db9c3e614fee637bc57f7d8366cdf43384b1c07d5ce 1c6be33f9df30233ee408d93647939aec0a74010acdcb1aadcc828378bc2ba7a 3a5440df19aa23f49469bb5a49f03e94dc8e1518f9acfc64d2992a424c3ecaae 9e251605352bc394ae6cbc7075e8d83fd2c7b8de90c327a3c3682e1b146fe87a 806ad4707c67355f8cef4711357215018aaa16178497d0b7870c27d8319772d8 f6ef4a8771330a3b101dcda998edd72efb655dc5a061dffa72f20fccce62a05f 458caee8a3eb73594db714221608f3ec2e8307b7bfe4ae6076a695ecb329c105 430bf3feb7d8c15d59db56c928803fcc586b1388a9f55864c9509af0263b1583 3c481cab8ee77c6c9182c23a0813c673b5a79f9e39ba968911926127b90fecde 354c79b857a63799189c3fd2ed192c9c5ad45649389191442c4d5d3d653430dc 06f2fd30509dcdbeb9f1b1dadf07a2c1a0f07f0c09ed89eed7aea5d177ec4293 185158f86c6ae379c94c02a972d6a2b7b509611c01fd464e42d1f4b6108312cf dc9c395819a1a1a4d441c34f826100fa164d746dec8e4ec67e2957cdb66bf496 3b2180d54f65060b21d0e3908eb9e61d51d401c3dc6ba7f9a6b6601ae9fc25da 1dfd4f86dab80474c115ced9f14e9654b8c0bfe960d4783ea749a04af99b329d 2836b7ec30ceff00da114f97fb42827adae4f851c960a82f3afc7649b15f9af0 e2f4901c3f23a57de9bb273e7c475a6e95cd151b0f124913ff8793a54e86b00d 3dd28896b87d391d35d51a898a534d20f08d7551e7b6e94bf1620e35016a8d56 29dc089a27b31456ac0015c122b2f01fd3c2df6a7198068ade70e56790b5bfe2 5f9f159b1955da1e199020a276d8775f5ddd405986545bfaa6d760be0b4f43d2 ddf00a1730b611dcf862d320af05aa81bb4f514d36c7debb5ba42e098a1afcc9 68e9c66c54501f39a8a15ae6ae4264acbab0b5d80de355e451d5290baae5c5a3 7b408eb753d2fcaff19e4660d42d3bdd8ef59e2064b85432b324090d59131996 6b0a02f9766c59032201c2c5b04453741921cd65d5150740d99155d2dca6e647 5c06dd72b563394a34e43ac353e54551486d2be717327ec3907e4eecf84f389d 416ac45ccdbcd8b039df9243151e7b150d9c8d5ceb663049bddf4fdc5b13d35c eea9d96242a44976de1526661b40a94932999919479b04d5c542b354f7fca5b5 2d3473d34a84358e2088f6aa6d9fc1035e3bc513ea613fd6604589f0befc56cf 33f7f9c42a7a1f400f64885a3b8f754f7a37cd240568ed89eb4b3bcfcf627adf b10bf05f99f3580191561caf04194fcdeb7b2354aba272159f16dde7688a458d a191c822cd757e136bf17d7b3255d2fabd55b92fa07c3fd2e7769290ccf759d1 6dccd76d0adc94bdc5a3ef4530edb326e205dacf527efb8f46c7be4e21ed9a0d 6f6c9c24f0a9dfc75ba05a829af930df9c90641e35647ac8d9dfe3bf162e345f 4bf557d5904b29c5ebfd6e8bd11eaa8c1ab125a5617c0e26d999afd1da4c69bf c5e1cb8996e6e9c445f5272b25f89ef9f89be61bdf71688f066a8156701b3c14 70e3172770643e04ec34ac004259f8d2219259abd222f89650f41861d47b1fe9 e6be521972ea378c4cf5c41d0776217078f891f04f630497c98e9e4cdcf0eee9 5bf7784a3925c89933199fea56841277e029bdb8e4dfe7ac78b8467d8f84c97f 70f5ad88720513a888301c9bd51a0d5dbe12de43df5d52293153547de0d4f8fc a62e3849fe1b727cf71319308e67d346bb3fc735e27152893b63ee238d0af39a 241c0ba2326a2cb22561110bfb366b7e6a6eadafea230a61dcfd4a9f6b4dcba6 568c41fd4e61caac83dd975631219405341201cc7afa1abc9853ae67a0a80713 b50eadeb0d534b9d1d089862655f4fb15c60763edc542dbe8b55bcded4e16027 f96b13a63ba656428ec73c7d5f6b22a5cbaaf54426b49252428af975333aa980 087e4e0d721080d22ae9b7163c846daa8f5b589a6691e8963c5da8025f9624a2 e24e5da5e60393b9553fc0a0b7a519fce15c3909ed4d79b1204a67dcde2e4569 8892499bdfe206daa5cd2355d77651010f3d4bd3dba9d9f031bff0754c270479 decfbffe3e059ea424c13a18e0825f19128bf74d3bb8bf0ea9f16c77e2ad2e83 cdd209bf4caeeb585551e50944ec07a319f3dffd5b09a012d18f5f96468b52d4 a85025abaeb2656c57b586cc1b592d49b01b6041f84b7c76d74de7ff226361f3 4698f35cd4064410373adcf01d1a5cc9975401fdd593451d29c8fa8685284791 776ad642d6cd0f9c3272ab6cc24064c5ce287d0c4c0c970bf796249515244965 815a7d461b39d605d0cf09624a01741b100d7d8fe7f5a43be593ac631e5f1ad6 3e06f180ec6b34f02d9fb05ad6b1e18f61c86b30ff481ddc5998f454d1e66557 053342a00d7f7e7d63094f10f2db6aeea8bc2a4604bcf0780b06f670780f5fc9 0e0b9d2d83b917845a3f5e73a04137a499d9e6fa8b867ab98bfa82b5fd76ddd7 8a7478a0b93dcc275f706f458a0f3f7022ac8812b1a0b3fb59a17ff33887a926 2aa41062284cb512431c3da7a24fd4dfca3b3b9d4746e9c281f0a6530c77bdb6 d2aa71095261507fdf7ff02a66ec2f810fb4cf25a1cc061f2fd9e6cd991d29d8 749d7d4fb454e0441786b0b83405adc7521b9133be1e9069e98b0b4a0a019742 9402fb817cb1bdf0ec3b3ea7f0e6de5af7ba40e5dc449a4604ffbddeca3d4bc6 7fb5ad8c1c39dc05b6b9f5683b0bfe3453a36ccffab3d7dfe8b0b24c9affd6eb 1d5beb87c516b2f164cf9b133359af4170f80919ec18b0c32130ac1b72384813 d7a29f1eb4fbf3d5e59c92fc82de7b21ae3dd5592fe5bf14ca947cb07f91f294 7c4414a285d08785d7ea218d851629f3ea64cde0db5f122a7d1234f2846679c1 da461281fb75f952c2d820e634628c9b7ad8bc85b2652066514dbd5081a8f001 24ed659f872fe2ab6ee3ad8e503aebee8871399ef6e8173a9a93f3c927c9a006 302b8bb71116213bb79816efe7111d60102a43e2553085ac726b3e9de9ebca63 ebf8a047c74fce459c1cfb3a267c973f22be621e82ddbdbf5c0fb8e94d8dedd0 82ff33c38beeae7ebc65ea166ca06e0838209719d9f68574bb0403e7a07951c9 856688e811d72ab66cf00280841d83d21d9a5982f971ca1b1406e5c205ccbeff 9314feb63caa7c71cc0c2e1957cd334732875c8da47356dae4982c32eabc902c ec90e690723155d6a5ba149f7070c142f367020035f3c9f7fe394f4c67ff5bcc 222caed12c17c95bacec54ca61a7eb3e37710521dd268815f025c082fa8249df 532fe8d1a928b1715dfc99a1e2fbc51fe9dc599badb35c31bbcbaeb53377253d d41e747309374c7b1d87c86affee4d0747b7a1d9fd1d127b54891d896008c6c1 89170b10570cdb10d9e191a8a73cd46f8b9698db908daf7fb1dc9c7ea34e2c92 4c7c8409f431e936708106858f52c7c54b59bbf7485f66533ca079bc93128903 e2e9f74f6d1ab74bcb1c276143e6bacc3656fa372ae0c55d86365d4bf87f387a 71370d72ac3428b928fb2eb392b7f9b08b1e332c5571b720b1062e60600d4566 3fd75f265802ca0b4e7dc1b45f2248cda782bcc3b60571b72ef62b3980fe4801 094c60456ae08e383c95c2dcf3bc2e3c067762548d57b89bb7bfff28ea5de068 af19c103bb8c17788e90adeeab90d5744cf8f7272b83c51dd1c5076e9da6568f c51e9883759ff945e2072a319879dd1940f8298b2752fdc99c3eab5162a9b9be bea441eae3c9b9554bbdd4f797920a478705209d2c837dfe6a43f76df9102375 68ca55b4f18a7ce36e32f68f31d6e55e0f6056eafe2066d1f4f10a1d36e4aa61 746d492d44cdee213b7b1ba63f380d3582cc84b187c115f13489cda5fa7e56ef 89407326a649e5a0904d2f02dd4e488f88a020c40a9f91671fd3f7c2212f00c8 a28169cb023c0f991bb0035546a78d954d0cee7235bd52bcf88a5df99b557f56 19c17f8474d5daf47659a9864cf1af09a594663270eca53da879650400469a92 10ffea22bad2190a153341c2b0d21cb3a4f907b8a7e926ab8d0c41382e4b8058 5e0f853d144bd9e6f460d06a4a3a39f150448b88835b4532c41b2587fd4c0af7 31754c5684b404654bca97ea38f2c00ad3e5f4ffdb97fbc8668ec58694724d82 b32e6d9773921282689cc369c0312f5a0451e66ea941e6448c98f8e981d48acf b147c1c3510eeb037c72cb71dc37425e963685f84f32a50cc01fd408d0bf4d20 57d2c9657c3e9a7296bb505297e55796b77f5d3db2f4fb1f09d23771ac62f398 b25cf9566236c3997d4d997f3d5670f676c13965d4a4a66fdf6900fc4883618f b7b93b8daffc9d5a4e47f4757a70e21a66df2f452bef667140299482f3173478 7098f7acbb510ee3f9c0499b2395d96f852d21376186f275f02cd7b2d87faff3 8c6ece212cade6da775e5f059b0efec5bb6136903d3e5ce07edb1ae45854b6bc 94887bf7a0fd4b7fd0d2da3bd78c13923ba3416a1e4e84c90aec94b860541a56 176b865ea64c0020c7e8371ffee45df70ee0f2bea422735c30201ee2aa31771b 45b58bb64bac42231f7f98469abbb0ef075568d99de4d3ebe2a480fb52cc6c95 10fdf36454f77b8909acf5478166555bcb2474be93a5cfe6d4c882c05e08d3de 4b0d03f74f8a5dadc9ac19dd2b0811f5b73b4dc60972dc052a656803510b8e86 c275c94455f1a680592271bbc61593c4dfbb38fbcad68743c1500cacfb542d03 bbde1fe13a989e8ae0ccb8260d4c1f3330a337dec7cd5c20dee2ad781610329f 50c2ae0be35cad3b9f25102f68b7e69310e1829d36ff52d23a7a000b31caef02 35bb8d2683e7e25d64547774b2c9e8553c295c367129a53cd2ed7447393358da f8e1f760cc5b69685e8d68d6d023fd5760790bed603f69b3148fb4d245d07e29 ea4174e4e5a6844c93f511af95d507c45c939ceaee14b0a033f2c93fe8f5a040 4f117a7382d9d5c50861b62a8ec5e5905ffa6633ec41b00bd61d0ffee78dd05a a88c98a8ef1d64f1395a7029525d0de4b131db3cda25b1a401c723c64cb5e357 617280cb8f8e0e0f42c62c53c732e87ca4fa192b578c1120e40905df9e8d8194 c409b94d1cab6ccadb8460b3d131cc18becb84159897e15edd646ec4dd4fdb9b 2e42617d8e1bea79f0f399443fbd5f15947ae5e52abe17726ddb03ed0d256d86 6a73186410df4cd8670032cbfb4b62b0b7f95ba4d2c3bad16d5a053f71515852 7205bdadd2305aea4b0082ec7bc8a2a8856edee2560e02741a775f7a0ed2e1b2 cc7ba0caffb42807788c1eb7944ab97f8fe62b73c41300131853c968347864f2 78d4acabd2f716af0d52789f27bf35ac8bfe3b95ebdf90437010ef89324fe1e2 98198945989839786c18edf339f538c065e83985d97dd7eabec1baddef389457 603d891e289f2b8ca96b43ad5c54d284beea789a4ae319517833723feb4ea9d5 8eec45e1c95eb6a99c6223b40f6b9e740709941c848df5ee5c4a1b23f100e68c 948afeeaf126f4fe582998b6cf014b9ce21b3a7e0cd439f40be5384f5c7ec905 2702a8ef3481001ff530a56006930329e095a1f73543b515159a0412d53303cd 1d0c05dcbc95d9a736871d7c12f9bf6b0455de0c6d19a17f90680a39e974b96c c92cbe487bb69a8bfd16a8fd9b4f2c272f564208f1f6a39694ef3a72b7f1c236 5d8db733373e9343d771cc78b6f7fa5b5fac0e5b7b55ef6115c7611fca121150 ff9701d74d4540e1b6494044cb26d0d1edc2c6df60c5f646753b256ef187fcf8 c414793da4b592458d92c8116978ae7a5d3bfaf0adf1a0799427907987098949 83184b7d1d49adaccd9662c4004306d458a42d88d16088ee50ec8d82c9d23256 35905e97de54db871c52e900b7b28c9524050c8508f547ca355122781dfb8dda a177e03fee74823cd5498a30bb30defbf7fcb04a77c7a03ea9a53f166196138a c589143a5a14b61399ac8303294231661f6871f01fb323b645415f9a6f854e54 223d256da69a41c4391235895d0afc14513ad9b8bbfa6c19475a07287bd591dc 6da1397c2980f41a9802a535ec35e3c605cc0af558a2c08a44435c086491c85d 2570acf82514e472c79a88e3baaf0f070386b8e68f783292237d920b3155de1c 59d4fd0553f2577e6817728152a7c6dc652fe69f78bdb2a95feaaeb37e8dda0d 65 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 +generate_ring_signature 25dd893cae76d6ac1932f11696af4d23ced5c7f8c9b26c443513e7460ec16ecd 5d9938750d6d01d3cae39ec888e440f33fec671feccd0a5bcb83a0bdfda37022 6 c29716ea74a2eee8270fcfaab52d6eb58c02084e6c0ee1efece22d8ff5ac9ea1 85179c988425643a848188ae78fbb0c39eb912d731fd789ba04016020e904dd7 5dbf0ab5804b5052e98871ef45eb1d79fc94177d6cfde3574f118c0418a84aca 3053056e01b44a45d9d4137e3fc8cf10b86865dfce0f9773fdbb459b0b305c41 e35ae435c1147ab31281c1a79c2d3a31678be7e87050d041c61aab1dca9b74e4 e451cf5197c665cf0ceb5a9d7b93d139051f56e11bc31ef258f56c9023b94d80 c53355e6c89359655240817ebebc88e2a7c039a53e718bd076dadbe8b166fa0b 4 1dbb453e5b453701c3338eef3ef68db6ee035086bfc8410913627dd0c7d3720a1df862e5c6f6a8f6d12b125f95c0012c088b040dcac9cb7407a105fcac15e003d7d642a147325243afaa4c2bcebfcf6fd1ca10e87a0462b5d6db60fc76025e01760602341861b338a0ef7cb7af886b34c7b9d4182663afdc031d38851ec783058045c1e0ab105ddac7f3ad790b91df1d409b53f098db27402cafa868f9f4a302071196df3342bb5fd7c0021b880d1990f688cb6ee09a118c20b06970dfc8920c0bc04c1a4555272699e5ce5555b5794a6ef0faaccee5f0108fb98231a754f4000995148ab1927c15b1f43a4d0a4cf8191a6bfce7611ba96ef87453bc025fd40edd0d0aad42d9e7391bd225e5d7b2b69f77650d2e33dcf188545feb85fe9bf90b48f34188ee9d40d85ecaa125e82a959d77e301758786267f2fd133f0d6b88d0188f16c7204fc6670552455198feb84383067b8fc201d66e494d8732c9572a40b5d9028b2638c0eb3104747b6ab09a65e174b1ef8c7f8d83e465dd2fc0c53be05 +generate_ring_signature 2f1a0d247c8827dba4d4ce33f142f157e2f1767529fc7c19c789f00cf6ffd688 3374f89c3f99dad856ba5ce07e7c38dfeec5b312427bb33c8e1b8c372c6f61e8 15 41a94a5d8abcebc4c87b58bd560596b715bd33edb75aa248955b5e4602960ffe d30add0397722f8cd6238bbc36ef02a1351b0bfd5a462151a57cb156e477a909 8ab0a8764b7ce7c3c10a7e6d201732c6ff4fa5ccc9e2c6e25256db8f88c19467 c12136781dc3aa8a1dfe8fa588c768f3f5b73acda82626cb380ebc0e42a3edce 571d28f9270ca75dabb42b076a8f7febfdecdc966b0c106c4541cb6820380f2c c9e639cb8b24ec739970c8f7d87bea123690fd4f1edd394cac1fe570109db396 84321e4fe650871a21b17061c6581701f5acddb389d49e4cfb8a65bf37fadf7c cbbc7e4105af837cc47494fc5b5e78735a33190f1dce55e2657d2d538ae6fe95 d8d75ba6364a1ef06d0dcda3ab45bb2c245d7abd7dca3574a5f48c3f5c10f3cd 74effe798cf28847c01bf6276a0c24f5be7e6c52a3968b7df9b8545a692bd9d8 72740510584e7b51328029f4bc32a40c715d892cb00f70fe60f7912cd7b7ccfb 518813c1abe65ebdf8bfa96b139e171b30da00b3619fc258770bb316410d8488 bfe01ebd9d90edab131dffccbdb58cacd599d5f0a3fab24690c7e932f2f06835 9d8fa00ff4874b2f6cd130a224a2d2df214f27977224132d1d84a5ea13a85493 d780603fca86efa77fe4d7a9d35617b56e6b1f1cbae974bc5ca9ab4b37f94388 783590cb03f14936ac520b8b90b9a59ee656aa1a35a60774c23c0b120e0ad40a 12 9158ccc2d472e28a8d2f1e6ed3b62b39a91524d2f6520accefcc6cec8aca100cdc94b436ed91c91834beb2a6ee4a53e9713ff9921a09779a4f45785101684509e487c496f8c1e22a514a9465c401dbc71489cace0b22da0adbd67e51547c7303535d60b04e6ba6ae10dba5f8aff7abfd7609862b0f0d2bb80cc0a5ee7f15340658f3c13fde8dcbdf4eeca60ffd70ef863b1b6d58a886a6e38619b211943bf00fd45592662ba19ccd03a07816c46e81ce065bdcb3e3fe812f6800d285f6fc5f00100afd0dfdf73ac374ce5e947b3554166fb4cb29b109e9ae9a11c7cf2588180273309c202317a6be74cf8a7fa81222889828df87e6e925f5a072e033225f410532e10dbc765cdf29629228ee600b1651dc2feae0689182015be8b9031c3e6902cbf363a740f5642f15b45af5bbfb6f0678ae2ef1bdf9e2dbdb9fa9346382fa03ccca7828983bcbcff1304b5f18614fe5ab4d4b2f19f54fcf3750692b64045c092e0b11e9a4eeea6e81fc1e1c5ccb1d092bcee755ec785d9620e4f9fd05432a0128d9faeb2620045995d1dd25d4c20ca3ee5a47a80a5b2478e8863f26a3f4d303b9473b92b277d99ee47366593632b30fa7e9540ba2fc4006b9156ff826d89609238e76ac26af11f00bd2ffe82fba9bd21449cc859e7bb526074459638a4d81013a879b56024fc37b68e86d9971aef4eb21d7d58c31e0ff1008005c01853e1104852255cd2ce65b29b1970e1d7c111cc6ad347931f75951c7751c5a89f43ed5040bf8d430488768766be16f689d306d4ebbb432c2bb69c99a067d34038d43520a9276cbfe1019c9e467cca3c690919d223bcd236ef486ff913cd0b1a4c9f0f60922f1977788912619cdc1dbd4a87a1023103a4db40b4c59c2fa3f28582457fb062d79407e3249dd62667d8168b16c9639acbde74d28e35b3e2ebb834776c4be00c3c78ddcf13afb883a6423595702700557b0fe2586bff9114e5fb5401eaecf0b3270c59b8ba28ce9f2974c052371041086564a4938bec60051695327069df502cf9f127d98fd41febb2277740b83b006602a412a80a8e3503d88b696911ff102bae8b249d3fcbd6eea881e70a30ffe99b9986404e62a0279bc64a0f8c078de0ce559db4a0d6ade50912ff586546fadc349c5bee6e1e656508601bde2cb84c80c79854968d21818c1eee82a6fffa31a4b76d294e7c0673200aeb87d3becce6f03a289ed0c99c378151119e7d66b9b4f268a73a39fad0f56f06c8be76d3333f5011ead9d8963a0d0bf96156bc09288e710c3d592981937a61eff462bed4cbdf802943de30091af3c556b6c74c0c64ec6aaf7b99c38fb3f4300ef3283ccff7a4106 +generate_ring_signature da547499dc76464e031e5ff7ee251b23e86a65e7ef4a702f49430dbc1a3224cb 33d203426218d7f5ba88cfe70ee0255b22f15cd23d1e7fe94e02fb4d7a835de4 1 86b01d9ccfb40a5020a4d522c02855924147e974f4909a1f15afed38ffdea8c5 55adae1b399bf6a36b775e369894601a26a5395e5092e93f1717e75dbf74f60c 0 c7beb3e7a8955c8e95061f6f4797d35dc859774c02a788b58f39cd67bed09d0712860b14824dacaeebaffe7fd9acedeceee60eb353d0a327deefa4598663010e +generate_ring_signature e7e69c7adb279f38f2e2f05051fd992a11149a8998d1369be08f3dc277fae761 85bbeb775e94cc97da84eb667dbc70a26e60a5276454ef41a97e0aabfb8c2e2f 56 18d09a4f9592883fcd32ff6593cec77b9f973837f03d16996ca2cc33651992c6 974af2b4ef03f64b3051a9a18ee09ebe5ee860ade199631490bbdf6d8de269af 0f9b58c9eb9bb3211deb53ef5b997c8aa68ebb9357ae4b827e6042248e07525d 582bcbfbd1c46085fc27008c081b8c3190d8295ba3ee29a28a811c8dc7ddf87b 46e691e35acd711297c564b251cb5b279d11936e67afe44f321a83e7b2362157 254a0add41690908429a4349aa13813cb4b18b08659017515816181971d80324 97f30a5f6836526a6cff058d570b292595e8b056f740b325334712e9c197b8e0 5848a77ebae6530b5cbb1d1f479109604dd9491182c4f4537f3d857b160f63fe fecb6d36c025378dd87880402a8ea775376954bad2bdd78ba5614c793c0f9c8c 172a5304befb1ceefbcc22bf34479c924f29afd264a3ac3b426cbef3df1e1903 7bdbe1fa6447623cc54d957d4870e2be682aabc434db57e31db09b1472774c85 394ef3d1104938454158def95ef99ce4614a373235912fad5dc6bea68e9d8b41 23e1141711a551670210262fa8a59271dce5a05939d906a5d3cd7ec5277c1da5 969dde51d1fac502a370b8bf4f40d13824fc919670d4671b402a294b6a89bb08 0509b587aa1566227473c0867249948630965f4f94a6b024dcc64faab4cd0e66 7e0462bb2cb462c7af329b6bcc6b9664a2643cd6e360cfd14bf7eb53544c999e 738ec5605320e83f6fd439853de054cf99d9b320916ca3c26c53b914e6aa490d c1613e126399c42bae1c4750d814dd533c406db959abdd275b3d9c3e72984c24 d588bbe6c2c2744068758a5d6e259d1cf02473af17a1368e62932688eb7764c1 26d840d38fa305151e8873b14a441f42c864d873ffd7aa2c7c278109a446bdb8 66ff84c63ae19639ccacc7b493892f8f26ceeb3dd6d8f063859449da9d5b13ff 828787793865161872024f6ba77dba847f0873be2562afd85a64bfa0f453adb7 1874b21b0a18b6b43318736c3b53d871bc491695f5d86c8811ad8b2aa8464648 8f1df6bc7f2a2ca7a7d00f475fa487409a0f4155d2bcb2db1e9b007cd9368b83 40b39d643696c1517209c946e7e797b4c1cee0b339464c9e8b13ae28d9434afe b3621ef2364d2a8a9f38aabb9b624b932300046569e9fb026d36c7e73a3e8fc4 3115f7a4b63d229c5182da0a3f624de6c7e2b50e13a7da14a322f0de69595418 7146996c40e7e9570671539d471235c7baef7387ba12f1fc06602fc973a3ffa8 ddae2cda3fa2d25bb4a412f4aedcdd206274bcdbae18a3d6b4c25d978f8f5dfa 124c68d03ba3fd815102f4ec1e16016e6335ed47d9637771c426c49dfd87b1b7 19a1d656e101999c3b1457e995d8a0977c18bed779deb21ef832e7795d4d9044 b69f73ce720530c3fa94f7f6f0b1c6c8e5466a89b97be80739187695970f6871 ffebe2f897378da204d5e8338caf629744fe910569166768481b76d0934e5e0d cfcdf78c7fe82f7fd14a6766d4cf608d6eb92af30bf11ce79348bb2422c1ae8e 7af0a5c4137717bee0db0faf10813515b700be3b04d639490226b047a32b660c 8e824733a807d4fdb63c7621b6838f70054b9a069c3e8b8e36c7b7a2fde41de4 b51e86c2ca33303c307c9d1080f5066ffd47b67dd1a1a368d4bfe5def1fdcad4 f271285616306d959f3ee158276b7c35364191836ceabae3d5f532d1c2f6cb0b 0634672a39f8f196a86e8afd3028b1ee852026e53b57ab5dbfb36024bb3801bb 84b77938a69db65b4f705507f9a052aea980fb5827062570470bf1674772cbf4 b3f1ae595027df180e6d1ec987e7d4faaa5832d72c759f6c4b33fbec5c197248 b3aa197ab9bc1411a0088271908462c745ad08ba0b6bc52b82300760d1edf3e2 764478333c006629e5be2ede6050b6a9e19f84bfcc9af0cb606bca2a7fd6ff57 42ede624cf6b0648b2219d84e2800f86295b45b2d62c400911936b00d23e8eec c6d188b2593f276c9d8af38786e8dc83fc3f4888357576e0ce1f817c6f4ed0e7 e54f8c15e52301951fae217b400db2f8a42aa824f182bd97e979d38cc6beac71 815eb621be2111a52233f936689d47fa18695b52431435cf969ea1521abfca97 c39db1d00d3dfb57a9e61d8921569686b0cbe20e69915cd65c9530c8bc7840c2 88841ef6d698114e8a73b56a437acaf9dff3fae7edbf85394ceea8d0a0abac7d a10006d29887038ae2678d8ccf83cc66f6e30cea14f3776dbf3b1064b572680f 867185b15807549d9248eec40382c0c2efdddd0b6c18a884ab811bf0ba074dcb e2408a5abedc5ca9c397b10df9eb1d4f327fd875932544769b9b6ba124131669 390f5c7be19c6f50c0645efd3d416b1c740d38d7f95fc6983f5297921026518c 5368d661c76b57e15f8e4cf676aa0c8179bad2cf815856a97ad48db1deca7db0 87494de9d4062f589bd263b6fc826dd85c6b81b66583d6abb6fb6cd5954dd296 a353830ac2b086e36537b57320da789652df3df9b6bbe6f963e9cd6941758aef a0d9ff166385807b7eb58ccbd283e08e6b2194e0dc82ef190b3dcb15bcb3160d 15 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 +generate_ring_signature 8d502bf01a32e567707adbea7c5b07946c8a91ed1231dabbb363bb6c475debe8 797d78be1bd8f1fa9f586e9710621bd3d480427b45588fdfe8b845b12414974e 1 bf227dd9be0cb17b4cafdeae98527a2bd5f22d56f4a4449af561a5c7e9979411 c1d63edbfe8e5ccc53d5c54f571718b81448166bc241c68f09aa1fc0f337d60e 0 3431aaf62aebf00ff389f3f2dec9f3e61edc48de2c8a9e70e78399deb7d4910ed463c56c0c03a6a8609a3f6c6819c45645da18bdfb0e1b54a930bb3e44d6660d +generate_ring_signature a360d6c579fda6e77d9d8f7c5670c5a3e56dd67f9bbeb9a2a51ef4fc846c9e4c efe52ab1e05aa48518f70282135dbffc35e61066c0ff77f69dca8f4f77cf26a7 2 5f4e6fe57d228860581b1597387794778018d9508ae293cacef275f3f380f949 7f855f04ad22ae8e65f0dd48b9140295e23165c1bdc44c2e9caac8f7a4d47690 742392bd543557e97a5c79270150105e0e05099b7db61d2f07f2a4ae1b0bf301 1 43a07da3b3c8ba581efac13b4a9f6f7b291c98e19c0173f60b50c57c7b88ba0e575c41be6b3d499ecf03ba6acac4b2ffbba6f8ef2f16c5be9cb8a3d0ebbd3b0f27fa9399fc0a8204d9615116a9eba8b93e2058e07165c03e51072f6ce5bdd3067aa8852c87bd4e4c0e868b37b9d3370b79c2563e99828e6792cfd8c40bf40b04 +generate_ring_signature f06ada276b4cb15bfe0baf1973b4159c4ae03306b3d1cb6624410d84ff75ed8c 33f1bb96ac7545b8d506cf2332fb5c1221d7833e8f1a58c7e72e7ea0c3a85f44 1 59ebef8302f5943bdd11879b6b4e3bcf098eb70a56e44871a3e6097b2a38f682 11e1c3f3d5d9187ead09f8679cb2172afc020766ce0de7ae29998b7af9895b01 0 0277772991037345e5a55766893e55b96deebc313f09ae546bd4ce693f71ff032ab8fb6f2e858f23fa66daff911dc8add3d672a5ae14930736c693079c5ab10a +generate_ring_signature 4bf0339d9f8d053c5508af5620f121860191aefa336297ae61c07ab16e830e95 4b74cb953354a6d552dd2093fe6547018f2ee804b950c00ae2cd959d9edffa02 249 b273d48608383a643e8f4fc7a3218d79135807e1f01bafdfd131a6ebb066f53f 13a87abbe6ebc9c0a6a758e2bee754d629c0f0e3c9a8c922f2d6b84ed1d09563 41368a4bca9b547d015b4c88063bc4c61bcda812a31c5fa1380cb9917d91bfe2 7adc855900644fe40f6fcad939d2ef3d2ad64c78c67081eafd47aa014fbcf569 327c96fa149e38b3e54f28f3462c9e66df4c74a6ba7957eb9fc52a91fdaf7dad 421af8feeb282c03a8fb30a7837837641c153fbd43a8331acc28b1c4a9e86bf0 61281e80c633170d98119dfb0fdb35405f8ad76b0f0d867185ff43116abe96f4 2e25524e65bfc6c97f57a92766d15c394e46386ec49d2749df2d45bf52daf1b8 47ee6c2a1c29f513e09d89f74fa7b86a39fc4468cb648f74e0fbc1e48d8f6d98 09e04617608530d57ace72efad388ae1ae3947c0466c5b430b9dbf351f392867 ddbf7d3d8bf539aee1727a3eda3737f18ab63ffdf80651c5597e10fe6676ec56 135947fdaa00c8fef0bee2b1a8e843746094317d6feaca3c12b15d10154979e3 203b1c508ae96f42485d43de27fdb3075f3be201748e51ff0facd328399ff2e0 c336b25aa242b63ae73f67e1bf193f50fa8f40e59110b69e76db94ed57886d6f 8b285837b4f1690849e2b7766d9f530218aebb3e2ff9110a7b149378dba033d3 563db591fe4810c041d6fee4423947f244f35e819f0638b691b2b9fc77cad430 03e7898c213d50755f382dc62e36599c1d3dd87b6c9e0159472ed2f9f334c0c0 22e97507ef3b946b063e25d97f5212b6494d2696f9971ff5d54475ca9dcc1afa 229b32794f12ebb14c367f5f92290fd8190e14a65aeff3fc78aab3f8637b2f5c d6a8b2d32e3fd2fb5d1c71bf9fc51c0095033217feda93d973e49308f5694ee1 babc6af36f56c37f9d1cfe50d88c6e7a1403d9ca9cda788a01669a8ab6f050ca f07adec8757f7740eb2403d1a4b1c29bc591f5f90aa3c8cfa17035b07f0e6937 040390e90391a7eddab4f52925efa58dfaf935ae202267ec0f2aa535266dedff 84a82b340c5ba88f1359f113fbf717a945ccf2baa3b1561f347a70a83eb3727a ed06ddbbcfe612935bb53add5ef26d3e763e820f62d549af2713be22c6c6ee48 422ce5b6fb4e39f0846ce3a429a03fd2dc53df54f806b5ecf1dde1f2b004b074 0de9902ce29035edeec28692133417787524ed249b1cc1e2a1c000c2f35d563c 51c3352d40a920458a2e73a32198bfc93a72732d434b1138050ab8574cbab540 777b6aeae382f6d39fc2e613dd90a4228c2e8d69b3c56a84f250996a3ccc401a 2a324732d151575134c39e80275ea6aefaeb038346fe08314bcc90cda45b75fe 99a2da7d0817ebd800f5c2dc62649fc202068cae2692760a4b5bc17950249a05 3b8676f56b6358890bd11968a18e40f0fa56155aad8f89967a9aa37d8297b177 c0c464a4bd5d573e1bdffb58dad5697660e675a9e9e63858449b89b267271a7d e649468d35445f60819fe76f8780023b5a1ea23f116398ffeb4b4620c68e344a 05e7d38bebe36c388c980a9df464f018f48681ba297ba940cd46853b52300819 56f4fe13aead9eb250187d3f55bad323522841e0b5fed2257cf419692be899a4 acbfda9c0407409f6363b3718432409a2c56ead586ea6f8625aece0d48fbb29b 0bfa3d79778d063ad3675a485bbb8f8baca3296368409d81aa25ed3da324199a 800a29bcac3c088906ddba33ed1cd9e8ad0335d5075ddcfd28ded381179fd5a0 7dffeda14c5e22bd9cb1269ac3326a6a617b1bc277a77f5066aa2676dd6b9d40 8b786c7df9fb0e695678e9cfc79771bc84badd695e7285ac75bff9d6a07c7b8a 11bab52ae903cf6d7eea8a8f14da338ab52829ae7abbd6826e0c96cb1d8ce098 6e0219a5b11dfdc9ac7e6a8ebce4bac2b775a98a12697f8ce2afa792dce8553e a45f1f5479673fcea8ac0680f92089b115fc939bbf97094a430ab849ffea4dd9 e5aaf69d15c087793936a53d679544d2634ff9db1b81cd2266629c5b5d6048e7 bcfd31af3666aea09e3255e835fd931019b944af779af8e22428b713d942694a d320bc2b9ee9a777749dcb6c40e59a9eff375737cdc0c9e63539e89264e922b5 00910267ec94f2cef9ab012f1884518fac66acc140e82bf9684319d438792eb8 b13f3a4fe4429f8c34ca50fd9649193a1d9d42939280df3d40baf029c08fea85 79ddc3b230713949fac670ca6ee8442ab77d3987ad1855a856b20ff8c184fbd0 b9cf848cf9d1aae5f0d066e281b3eb0d447851c688123e4823dbf3bc5ff84929 3ff30f29ca0f5d56e3114205f032febe2c7ce3dcb778ed20d0fde85e42d44a69 49f1c860b9653e21a699f11dc10a11cde10d311512294622594c7fdce67fb8b8 8b18920f526da2a285481fd308428fc2a125c257155fe8b9c439e100c1f4299e c3b822f191fac8d362d2262efde806e5bb0a468290708fd31d6fa83890363a8e 114fc1213163e40d2f246906455a7edbd3070157b2089bbf0f23ebcd4576e7bb f39aaa33d3a77cfc664fab4560c47c230af7809cbff25f6806c59918296e95c4 c5a3eb0d203d502d830ffa7ac764c029b2890cd5c7c48aeffb793dda0e35f206 ecefa373bd1cba2ad4b04d5f2921218abf99f0825cf482c3540f94432cf01c45 3d4313281bc933e2bedbd7cad99fd60f1748256df79c08936d2162bde71fbeea 0ae2cc5b6d3b36b676cf08f4a9b4d754339dfa0d0ea5ce5abf5470b4726d09b5 6990d8de84993016435ca8f23aa18a7e72dae4d8d7e232994f7fa5657d34fcad 3cffa4c6b3aec0efe4e7e977e5f8a7294ee5c99dd5c0ddaaa3fe23351c941d85 a2d0b812fd1c7d191eeb61567298981e36b340c134c78da944f8a2203352e8cd f455055f5002146f5bbded6001d7ce6cd58e7e274caee50cdefba3613388a0da 477131a096bacef938be8fb54088a9004b29aba49f4579c33ca52deac5a8e5ab 67080c465a248f515e86b58bdbe91ff272cd23b08b2a7efe4d69f47e0ac85fdf bec5ac0c0b01a028ea0b29369e79e1c81eff46e9e69031ac3cac91aaf4db462d 2ccacdc26da82afaeeefb377043620a661bac86ff30ac720a847275c3b22ef41 6b20b96ecbbaaff46371c8c5094ee3af5250e9171c3207804bd0ce83c486b5c7 77d1c2e2a5b9048ad9c2200cd77495505c851fe1d0e4872f46de66b7af209ef1 fcd862e7cc429f954f422dd13ae8bb48dc029bbcf9b914244b7ef0a20102a155 3ede83a52d68d2fe4f8d6e721aeb809bfdcc0b38882d41e41dc2087c2b197f26 e38fa088d56b933da20b16848fe1310e4243513dd3c729f4032f74d47891ac8b ff44c21ca0af4dbc2e0dc012ee8e122de372f0d530db0d68cecac9f2a7c33b73 3b9903664c6ef51dc655f45f82de37b954dd70a37af1a45eccff40c492f797a3 1f70a93f7b6b459fa011b5e7bf421d5108430c443b1849f09e23aadbafdf2b22 b957c51631fe2c2dae71100ece8911fa410088a255dfc3521c0b1299d1ec89b2 b4c2e3669df39ada556b367b6cc9ad80b49d3ee765b54f288f31eaedf947aae9 bec54b546520ce1edf6def1e99bdd92fe35fc090f3d7ec249ea4ad7ddd998d5d c0105b38734b5a317dbeeca88fd34ea91633d4eaa90171724a420512a1769f48 34d20eccf3554bc5cfeab0839a5da3af1026be554b8006c91e495014f47a98a2 89b6ae04aa15388f5286393aec911d4ae16fa9e1c6cf991a8edc93ca27511c02 dd8ed17a2d4ed78da78446870808e79b46bd9302b686b72600575324c9a18e72 9127b0709d801ac54b8d550285a6a4e30a77f84a532eaab6c337a1bef97dd1cb aa0c38fd5fad2f1302e5983a9a09ae83edc730a32610a7dd102475624720588f 1b614f9407aa350b5cc5c52ccbc788e943a3f3d6e6a75e332103c7cb52503e2b 7bb824ad656dd32ad9c9ca1deddc41a3589f3fb9673ecb1621da283659139d26 8bb69321746fb816425ac5848e3d941decc629180993180572a2d673766d217f 17a6eb6175bd025118254836943f75898ff81a9cf26cd18202665bfd15c98e16 efa75e34a18284a2434c5b59d0c28891b998b2120a274cabc2d6757225c1b746 4866748e5ce204fef81c801a58339108a51e6d3fea7e5e2c879b22b358aee2e5 eadb7e4fa4a23a04f7eaff1faf8cd72b98215fe213ea9404398c3d942551249f bf44973880920ae02da88d1293672bddb4c5ca8d2c7d128cb244e480618cbef8 466f9c575f9eecb3f26664d593dff14960f4c68b3545a704b99594cec3f63060 b57feeda8456b15539b5d24c1aab860b97cdb498b629f81d57ec233e4111007e 4915b38ba83896e3f34bd08451300e26d5ef5d8d8af7518ac0592d19845b4464 d0524fd7c02630ab477ab113cbd21b5347063c933529fa01813d43a0d7d80d5b 27e89f490f81f8b21f9a08539970ea149b3a18196d54edae47105e2c21262498 a159d840849c5682a7fcc45335e329c3f4f65a0370bd835c70b2ebdc08d2eb83 b6876311d19355a2bcb0990f7b3fb98639eb5306af6624767cbde5013246cf8e c9351e40f566cd7e30de47c39154f598902d0d2a4f78eee4b37cc5412b2a6aab 1e30ceae50d00e8a0e87c28e46713011b4d911da0642468a47b95b98c33f4cdf 0c0f7add9e8f5c60117f50951765739424cf52757f48455162770e2642b44c90 e72c4aad3a76f21c7f40a8f7726b4f25c887fa11de547e5174e57d146462e764 49ae88514ddd003ef502e13b4ac56270888953a5802a5859961459a4c702cb31 acba3157ed52715ab3c0ce192c822fc4d317e84e360103c3cee3115c70a601d8 b05947d43cd215f923d48dc386c3f992351c5034c9112763bc2f89d9b4c323bc 0995423fc0a5997c95e07d3c4e16bade98d1885670ff48e59929c59c6c91fdfb 722c55efaea965818c6588b5b72f63a5b5036964ce66c662b0d01e85417e03fc bf2a2562576c9108ff535b04e023ade892ffe832c81deb4ab1cf69df767ac1fb bd6bfeb30c62acdf53af007c5fffe06ac6479fdc1582dfea2e5100dcda23950b 0c597284b35c159e09adee3c5f2b4383ea00488302714851b99f0fc6a774b7f1 86af1fe8506d70599b9f8f277f4a9467bff5f11c7838feeade171b6d62c109da 3ba725fc3c37b7c284b280ecbd3030d15b99008537d072da46609f1118322170 0185bccbc5d27113551e4eaf0dac7a724fc0c5bd8e03ab58891a5af79d0c4540 a03be24b919fc712ccef8e92f8402b32a5ac2e6ed435f13a01ac0adbe4cfff04 13a37f625c969172b64012f9c07ea8f87606f9a44bca086f77b72126dbae08b4 c370773fc793e240c04a6c6b44ce8c6bc06bbbf85cad228c299a0fe0a30ce63a d1c0b2fdcc1f83f9ff3808ed8246a6bcec7818eb8aa2f985a1cffb4bc71240bc 8df94b166ba97d7b5d3cbc0efac70565d5fd8f1bb7676765433122d3241476eb baed16c73411d8331650189ebe4b53fe9bf2237abe48579f14fd362fa1eca68d 968e2c6632c17127cae014ebf9c72942da77624a3c7e850b821a3b35cf3fc089 042d32521b49938a514044f1d65e69d2e74e3382f9044dc58d33d762f6a3483c 5f6ca5b45a1bac1ce6f04d42b6eef09ccdad558e1b3d5737fdd4c1947d57580c b8f960e7d188503d9c23b47eaac1ebb6ecf00558059a2062d3ff4916dabeb00e ac773dc9ce7620b6372078649fdb96ab0036c6524d2c24af9cb2054372306681 dcc1a2b1cdd61951167bcf580126f4d91854144f410ed394af5a29732c430935 399c3cff7cadc89baed9290842c4d689768b41dbd3402aee4751e4e6dc83cd83 cba3fddbbbde39fb6f01534b8049452ffe7e1837d28e466c0929c7726b5bb3d2 a525c1b382c198a32c710f6d1bbba6ed75ed85bad57ade17efe1deef3cbebfbe b10695a3567eb36d140a8c81b364477e724812c5d5cdd77631f756a678965fd6 100f2e875351cfa296de66052c4a83ae00c2f40bb97eadd1e7ea0068e524c568 65373bf6d75c43fd82031c030df1cbb1f2e54fe11dd9152d06f67784437a8c6b 10900f24d787db19021c7f6ffd05ccd2c1485bc9ad50bea77b5f7e2dd4d168b5 9206d8d7772a8042bd9b3ccae4d1e897dee041227269589a85225df73d51d8e9 e2196925ba83980352a4583ecfc2609194bea93e43702e1efab71c76eb99a77e 5555834ada3f35ac16555078158b1e129d347b2815d0cee6e17bb1db04fab190 9e411227937e25b05de329d88b29a3281e1471c26ee51636edd7b2bdb54532b5 cd812857f0c9592e899749df1d1ca06a4ec898e2d459fd463b87644ca1a80952 c336f88981b39cd2835bb54ff9d40dbaace66bb32005c266e4697d072fcc59fe 2f96e2125d594ad89999559a2d49f196ae3a075651d34351aa729147fbae4c21 d7f34bf026e0f3eb8f989d50f7fe2ca31e3e84f322bab7d956379b6ca67eb8c5 4ee15b8fecc0cd747a0813b82a98727e6557d35636210fa25046ba2ec63f6778 5c024d33681e72ce084e049ac978cdf05f2f690f9eb9c3c0a2f667e9feae4114 eca951b655f40be30b5139801f0eb195e6c1236dc1de5eb982a64ddc5f3e0ee0 b1ec1fe38059d22a2361a3698b04b3633f8c5e90f94e1b2e67c7b0a83d0ba135 249dc9cd75683ea99a1a6d78b941d25f54240f025218ca113c1d10e83e1e0844 395735c24e6403b5f9b3bf6cfec617ac4afaaa68e3861320c6ddc0c3dbba3e3b b88c05ad20d89d50304c08620f6b7f4ef80c50a95cc2877fecd2b929658de37c f4d13f28d1c3d0b5424b8ac845becb99c0c63fdf0d50c36a72a2b49bd64c4486 5eb59459759a26c15ede5971790bcf73fca4ef0bca2b2d2c712ce5d7551c7bbf f1eb0ea50f8c27d0914231446e3fadb7f0f4076b236bd76d15a2178043f15b1f 042c13be06da921788250ae0fe2169ccfd7b8f58258f6a03f0eeeb9ee4b056cb 3e8805215ac6b972a2007adbec893c526522a43ef8817e16dd09637946cdfe01 82f05de9344173995217794bc4d6a239f157038e41858fb49d73eefcc4ce979f 779060ea9dcf24e80010259572f453b743c818fe22d78f73c178f4f8e15f8340 8578dabb1c0d7d98f5e8cdcf2aead724a8fef51d24850eac7acc4ec67de107eb c8959add000fef8da12a32535810a4629c9f3005990500c472ca0c115a0f57aa bdbef5249d2f3fff40c7bbbf5293987ef976bdb15d410a62dbbc80f5066cfab3 82cf3f9a8c5131e29b1b1cbc9f3d48594fe30a5a0faf9f7b4d3518ff44905567 cb5a1a999801bf308a00933438df9adc4ec64b82a91cc819f46fdfa4dc63cd10 a2b5ff7c5043db55d1ba34b94dfbbda40c407393b2b5cdade2a01296d6a2d6cc cd9f89e414c961caf06f311ec8dd62f3941f116b42ee2220f6cf8730af87f225 94f778566f9ef6a3eb371752f76cf66523306c2ded5612d187210140dbe8ffca 1fee562d0e19adb7274d1bef2616122f37fcab620c31b259095758c361749193 2753541527a5f28886b6079e94031216be897533dc3aea2ecfad2d3b34c14a0d 74f9cf2e7284f89e175f7da2ef898edfb392ff850bd0469cec5b2999ea27e413 0822f78b4c9670073a76bbb206aeaa9f56d2d4c37115cbfef360375fc2bc498a e3bbbc6efaace48edb5dcce9a82bdf8b1a01ffef4e0ba272695ed17f31ee0ba6 9c249607b3ec14755909b1a4b96576864490c7c6cf077222f40e604089c2ab78 845830b099308bb31cf8d202681d2f42a709ef7a7ff29f25fcb340b8f6f1af21 f18514f95167651c539492ddcc5a154da18999f6fb5ca844c6661f113f36505d 1095e5095d519c92794caecc036b98052f8f8ab7dbac113cc144734cf6e732c0 4fc7a8f505c45e9cea40249551027ea08f7dbfc56f2cfc7dba28a31f8ed09695 faf4bd877cac477edefae6746b50518756026be3f58c3e283325f8b3c68546c9 ec3ad5ebc4dacec3ed641ec9aff310f11f6528b186175affc0dc3ac494280e90 6762ea15a154777659755f3e952190a37166ece974ab87c0f0ae41fd7e919646 6218aa86f87c50c1d29d74530fc73096cc5770e41c34bed1094ddc66835326cd 6c6e8e95cecfdbca5a6a3f81efcbbec3f6822c94abd6824b0b2ff04d8e005a28 42529960daf5e9fcf69f0378c7fab63dc04a440b590129d09190b43adb33877e 34da8e22d7ac3501057278a7976adcdfceb2f0946f9295163c42b9969f349de8 3567172889fa533c80d6345fc3bc669824b16091528a9ac6363a49555b3b1839 83d3c5a2dc852c1de0fdfddfe67bdabd232e7e786aeabc536e469cdc5a96100a fba85c323676f6f3d712a7fe174a74291ac8a7093279ca4770e2fb8b53292245 9f745cf4495ccdc23902bec531bfe44ee6608599bf528860fe615b5e64cf22cc ec2408378662a405bda9cacafda3bc482bf0ca4a5c3ecda11822ed66dd23ccf4 e6e2a769bb7bc694d5334699e807b312b31dcb84f12c098e9ebe730aa0aba197 86d5f8f8b1ceb931231e7955ac295f22b7dd5cbd5474c6f17ae9c67bde08b7a6 872a5aa1c00ab676ff697bc965082db4b84c9c5912b13cd73e238205b968f6c9 98e88fb15b4e7149d36a4d96369605702421a82536601f0d92a8a22a00196a74 b90582eb1cbf5d567bedb375902a66f452aedcc9fa4e610361b1994ce9756c9c 46f7eac37dadeb7d586f1f2154fb93224ffef25dbdcf5a50fbe2058fe4af4fa6 1f7515f2e3b6b0adc19d28b1733b596f408b3e01efd7a1c32d8a730687c83303 d9095d067e48593259474e88b1bc9d7c1b8f7c9fd6dad38541738577faf674a2 13b7e9dad168b21952ab494ae468f7eb3622eef3c93754dc85ea5076395b8d6f c53c69379620465b2ca2c0b55e292b41771066169b131d8ede8d958de335a124 f0f67b6cba0a5e26f0fb871f3102afe16c95dcfb3984d36f77158c55c2116055 83d6462bb79bd75ed33ac87b5a7792c49f6a7c6ad2fd9462846a7dab0bd5ccd4 e105fda7964432c084b06d5a4ec3ae8bfab30b85fad2ac5e12bc91f570f06c1f 7281cf80a74a1ec7881cb6173e8c82a9878a07ff0642d24408eeda7de48bf6c0 8841e7f99d72d4523a6434bf2f7654354f5d262a9f25d06dc5387cfb53201fa0 7221681239e07f9604d5e68a46965faf97af8c651600abf993177a340f6e88d3 113159560276fff26c42d020fea67f3d02536350cbd7b4ea36f76c70c300624f 14152448ea110c2a7f6efe4bf7173821cc7436646378634944164141e862c083 3f85f4b21ba09576235a74bf59ee99fc7690159934ac709639927a12598de4db 0ffb0791b151164266c3f61fee62371ad4b847681e39f11545fd7e79c8049a87 deab05a92357a34e87684d48570d216eb3a600a40ce746851bd80e33ec1c68e1 704537fe1c46b6175756a847e8a6c8a4eac68c3834e18f1aea4159e867b4afe8 9432b7a32bf0e82599f4c89b837400ad18bd09a29678d52f9ef0fe672e5db9e7 72915931e01acf984fb517b671b1c2a48bde0650bcc8dde11ecdc957deb2ee0b f0abb70c156aa44e30f7ecbe678f9ee9c0036c8912b737f31356714014a28026 93af6cfb7d315152248a3f5832795c53ccfef807bf889c9e08d7159ba5c7bbae 5cdcfbd85daddd4f1342a440b80663d03545d138fa31afadf45f8f97d6215145 bc67d0bbc9c1e729334eb1f625be3f76271f67075e080ff2101f608cfa6c9243 647f856b3e4a7f5b9f0edbc3c2086a14d97c4cfd940804e93e7fa38d4657fb8b b04035320466e030fe02365fc9835b0a13c75e171dfc1fcbcd058af05fe9a193 f804d2682dca7dcdf909155f817115f585dceb66b4cbcc513460e48dfe2e0ccb ca00d1eae1ad641fd240af58d71dd5d1b360773df738f76475f9ddce0743c053 99de32f96953e27f7fc7d6ace8082625adad8f875af5ccf98271211f6ffbf168 cb72c37155f98e712331a709f85b2b4cc137c3065c93b9a8750612e0bbc55797 ac942c8126db13a0a40d133df902ded357717d0cb8791d9c2b1b62586ec0e7c7 09e99ca05570543f80cbcf9c6381e19e8d5f21c00d96c9d04620219b842cb88b 6c754834e8f10b4f7c63b15b62bcd51232d514d1cb6542d44b84a84ce6d35c14 9cb2a9c1e1b3d50718d06faed604122745d6a0c4b7218428d2a40da6694b0b20 37fa13a595721d0ffeda06edcf2a9192aca945e8f845f39c850361060779bf8a f6a1fb231730587cff8331eafaffe84c036062f58c23313d0366d227f936dc0f c4352ee007fa39a2d837e554c96e3ea9c5f30bc131ee4bfee4691af41093e8f8 7888f2ce93dd67b62dbd401a649f2bb53030cdaf63958062a3afc269c65aa1ae d4beedaaab33b1ca7a62d8e3922a9066cc57cda6f5f53a1821c4b93663acf2a0 86c01b16025f966d766445addbe03d51be961d39f02611b1be6d52ce2e65ae03 61f2347d273c611883aeb9d63b502cfbb03935e4dc57815f89b2d960ca5f852d 88de1640f8120b16fe3cccfc6cbafdc3b2cad4aad54cbbddce71dca7e5a93d56 234e16921e47d84dca0ecde65723ffac02962de45664eaeb48f886f502f127f9 a7cc083d50070f1f751506a25c920ced9af70758dcbc609018ea29d2bbd92378 2114d7509873f58a86c60bfc37cfdcfd9a9b3d6bcd9adb7ea2f872ebf105362a cd8022df16cfa6aaa2e4ba5a2a387ea45695489724e472b48af3002557a76ab6 8deef1f124f6471ba33742a17098f6bb74c0d78a02ef47d303d616e393eb4519 48b56089969f9016e90b1a0aa3bab624a76ffd2d5bf7f8938269b114591141b2 9f18576b44e23d3c53213b7b7e4ac62a106282fa4561b3909c2e8576dedf414e 6839dda8b939921fce2234d2de861429ef0e896e8bf53734c49a7d9f9987f2b2 b52f6b08edcdfe3b6c7913e9da807d82e25a549e36202b8a8950f0a14fbc58d3 558d9906fe2fe216003200d96b368d4277f950cba6ec1949be6e42f0bbf522fa f369d7d155899f1fb4351c2a580c78ba591f7389ade0a8be48104a149dba7f13 06ff79895fbdc3db1d298456ae015ed3b7d61ebe3c69df56878fa9d6bd4522de 6e90d3ac10d5efe134def9d541f0d840c09ad7cdbc80e7ae326c132abdc919f5 b51705d06714d270bc2acfce33937dd15cb0329952c899d6f4304c7476adacca eea364ab4655adc1d2af1dac26b24fd8a6554abd57925dd4bbed807d6c40dc3a f815a1d1b99c386ede5a04765bfddcd83bdcf4d3c43cbe2eb768e9064bca8bfe 542eec4353c7aee91d9415ba2fd07311a3936640f91f1b061f1a1fb62d0fdd0c 127 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 +generate_ring_signature 1013e6d2970665fae054a3bd9fe5e1ed9e80e081cdb6ca240c0f517f1b415cab 0af5247217901d271584c54159546c10a1d682cd243e66a945af30b5eb427cd2 2 8eb838cd7d2596dde1caac7f8c29e081333098096355a3888f6cef9ad54b4c43 ecb9686dedf61fc294b3c96c56ea43d6e57500ca683d8ce93e4212bce07e71a3 f36383ca3516a2e053540ebabe435e3b57cebf3890478f221c4aeb0b8bd4e30d 1 7d8cd6e679d88936bf287a6962f480c13b01a1d64907097a5796fc0294364900679be5616fa52df84d4b681b89693f12267445bda43c1a137b14b07115ffbe08ce0713fa2e177cfc9cd7871c6f5e45e824b4b3cbf55a4df5aec174e4aaa3ad0775f0023282c33e861124e2b796ef2d67eb3f1900514732f639d448c827ec8301 +generate_ring_signature 0b5ec78693ba8b68d4c52d569772840dda48ff5fb748ffa833e5392392c55dd4 be1f92e110606c4de9745e00fcc25187beeb7caef967abd9c355cc032245326c 2 3957312d5af6b690f318ccacc696d12ae70a51a5e59169a823de76c16418908f 4c4a89e48bcc7beb356d78e9d9455a67c53f4624c53254135d0f665562c388f3 6360f4e3a558da8015355552ef2b95fe491529953bb454449caf53a3169f6f0c 0 bb3f8230867bad4df30226744dd0edf927ab22776965da611846dd02007d480fcf9aec9c337cb31b7fa4cc0af7c875ebcdf2ab74571edbae5b17d02e4991900b7c9646b6ca7580ed361eb066e5d1042e626cef8440a71885342838bc7fb3e601394a865d0068bc334da16fe993744513b1341bd9f96d02791df43a59dce89109 +generate_ring_signature a8ae168867259e89dfddb607d8121f78d9bd1afe3b56bdf7f8d44f328c407626 29c15d05cf7408ed0252e1d25c47b8fa0c34878017937a285dc037fe48c3d9dd 4 38aafb4066b703586c33d7c055353712cea2a8fc42bb1af683af4d52194ae229 e258caa68a2c25529b6d845e6477ddd241646d89135d3e860f9138582b0e2156 fe25ca5baae2ae89f703b0d17d0e9ab8c314eb69ee1b5ad3ccc2f178f7a13a89 ff91b9cb17606444470257f1b2520fd7c7eee2e9f62fa284d96c423fbb32c32e ff3f205bd350797a39e072c715c24902a909dab05fa8b7e3338d2ef69a85fa00 0 7321e749d710b62d6e86d55228fbbdd0b83d46e4f76a8d78d8f0aec1fdbbbf0726308b06b760238bbeaaf24c39eb9e2af4c91834830ae752ecc2bada677b9d04965f63a9e8a14d1ebf50ccebafa4ed28d078949d0d03b57849c8f8237c9eca033f0b1f0b40fe3e800fb48cf2964037aec19704a5f63f490d5c191f84bdc81b0b177a9804c76dc1693a66271dded98480c352d87e5476a77641a0d82c3ce57704546d2fafed736708d7352a70581d7907d53fd0eb41da6f8f864325737fafa3062815e8bfd095d79737c66c7c1b710aeaebafee6415250a96e64be58f64aea104ddfc33418f15847ba685fafdfb002cfff772889490a9445ec715937f45dd910a +generate_ring_signature 6f7c9d02e53d619372700dcfbde7105963e017372fbe2918ff0331191453ff60 11bbdfd15b4d972900e7d088fe7971daa6acc8e8d97e2414e8f44fa0acce27f7 217 a9d2c0e8a6674d829f4d758c0dfdc0adaa073d9ffa6456c2d06cb7ed9c7a7359 ef1c7c48c75f1ba091bff82de93d8ff68f7bc31da2ce87c8569e7443d359c5f4 044e3b84c6acf627a821ab990f7085c93abd290e5930767d6a177982d6ca67e9 781b4c9fb9e32d73d2d1b963ce415c90cb1844416f7dd13280e1146ba1fc4e5e 05d8c1d8841d0e5eff67f665ef58e5aedd799e1b9949443cc414932ef536fd46 7cf07260320c63fdaca80f7b8ff9eb61bb4f9a9d3a27cbf0c93834cf93fc259d cbb0202ac483c7c3b838c1fd4ca2f1bb47e91b0fbe6bd10b1e45da586d6ef64c 25ddec4e59d2ee1da3a0736e7aaba1969c8c4baeb25b45f7414ecc3a39f94e98 0dcc6715cb35ec3f1d7808ff671b2433657e4384ad77c6e24f3fb40ce407ff9b 207324c43b3cb524a6cf244595d44d9a9fb6bc5dee499308b95ae8a226feaae9 32e51b3211ffb05469bfaf5366e9818fad3265923f4fb734acfdebee7c183342 f3745f3cc4453c17488dec37617c06e24c7d05bcfb9449c21e93c310aefa4a44 55cca614e77dcc4ba78cec6c46f38d3d0172ad2da45c4693733b845449b7211a d01bdb20dda9148e2ae0b71cce5ea5914848f79e3072f0b248ec7950fb0cb32d a7b51154c60f197d723af16e4e0f324a901b4b26393a71669d0e5a621b6a4c26 038d389b297f53b1d35e64b92e579422c93528a82caa3742747cf55212a7d9f8 9255e412cd98623b34f764d2a55c443d3675ddc1d67e70af7d3903cfa80ea18b 0dfe3c5dcedd604a467aa13cc1ae316c1f077eabb02803dc06de657126484f3b 5ed0e9819d6e2d0d113f1edd978e543056ef6e4bc431f95f2076d0d2fb475d2b 18ea161052684b291829d5246f410d2a10844b60733a978571e2aac29b8498f2 7e2e83d2284a89f30052c7d3607e88bf658f9fbb1bfedebc419fe3aafcc484ac d7d0b95c8140094761ed4460afb84bac314b952bae09bd0031961209a56791e6 76492fbe42a3e2e00f6b98c207bd06dc8a2b9211bd27154f2938fa0e81d54589 dd2d108646f82c50e2e1a84de94cb2bf50d660d604182dd87ddf620ed3751c7e 43b77c3b8b7b4f57657194ea5c26858d5d60849b5c2fde7b9e2db9b2593959af 68d833ef2995aa4b3ecd512361d4f99c912d20e152976be8471b18e5f82d7a5a 80ea13958354db6fb72d24ca091ccc979e37e8f5e866097a199f726a15ed0df7 568bbc6de62162897808b97c17cdcc6bc1986534dd5f3e48a8c39a0c2a5a345a d052a818e54496d2db412bf4ee41ed0152510bc19a0863a59def191336be7393 e9202d3178b1ba5cd5de88ae45610a543418e844e9b99b443292218dc1abf21c cdb6149924a134413884a183d5d5e4f88d37a7c7a85897f5d7349ffc66571910 64066a9b8f720038d5094cea5c59a4d87f09a121bbded687e2913561b7462d3f fb6d221ac1fcf65a9d188165549d595bff987464ff5e99ad035deb282d42dc93 a4ee1970e64f9e52e882efe800594e98f29e8aecf4ea3b662f95fab5b9e94447 ff21f495bd4634f38c0e1e162f3946cc0a593f7c738833cc83737a3cbbe2b808 5160ac5ea648b08a8219878f0fe2a2dead686c3ffa490bdaf76f5aa70ddc8474 7d432689aabb6ad473dffe72c3fd10f332fc667806187a1d0523272d69671da9 17e4a72c95f54d277c7ba2bad16f634ee82bf403c3b2af475acda08042017fc0 7c8d25f7cb1a3c7c76eb0f1a0afcff5e0acd6bc497c99c2aef04284e58cda7b6 a2f0a4e90c503240cfed6db5ebc3730fbe73dcd04e083c5c74e4e992b4bfcd19 61731b0a82a84272a3484abb794d41f8aa35f7ad7c15eda62119994fa82e1be8 9d0cb6dcb296c7a1d9f315d9f3cd1ee319a32cdb26f6ff29eb60864d1653435b c57d7d5187cf78f06a2b4192f4b2af9e6e3b5323f1923d520d675ad716b67e7b 66865357df4a203d0365078d80e8393f91157836e16592ce129aff41de009be4 6fa3380a808f73acf4636741ddf415cf2968b5c66822a3d9db9231b981319118 4705319d29971da7992ed65e5edf5a5d4ab65312ee5a555f92230dff85a8f6a8 84e4c913f2f98cdf68913c688ab2660ac1f77034c2007fa33bce2832450129b5 a2d9ef7d02cea31f517947a914a9731b731ed66c50eeb27c152ab8f3cdbe7f78 a4ebe351b09a08e8c9f508938034395f032d7992a67671a6feca145caa354cf5 584b6866fa954938d5a134b840a801dd0eac1a17c24e45e13f4566bde3e9a140 5abd93a726c61acdc9505a30eebd91df1453e1d7cff7d2ec334d986b08f71672 a6931ec1d2b21862f1cb935fb0d1b52791d8f916c2afb9937b51fa2317f493c5 8209bdfb0f4967a4855efb9c48b019d21ef2d17d2e768ec86de7bc57f36c916b 301e708d9fc079acf118ce1623a4d2eefd5ae3765883eb7ae06f0df59f0a9225 7da0a633b9c97d588d0c4f011db498f7fe262f15de189c77d0052e522e624f3d 69680b2e40a4ec561e8a753bf932feed7e401ab505e55305226121dc14084cd8 1cc70e12f5b2cc86a4c5fece7524a4bb842a4ea57944518d035f3f2f68b44b47 69a0efbd545b2662c8a6b04aeeb37fa58011570dd1133d95b47d544cafa3c81a 91ebc540692be156388b17ec9936efeaeabfa760bf334286cfce9ee9832a299f ffd00880cf9aff6051b7a16388171b8a2fcbe54862015476c77f7b3fc46d7086 c95389fa96f525e20aa521de82876391681fc1e62c92c80253f609775e0ad584 a72805faa42fac4965162a569cfa86887b8e6df3f9155d6a87d9f3c8c03c8cc9 e4f035aa88e869257fb5938c550db6d3400f4a1ad9338d412d04c2f60ba7c11b 9284397d95cdba29d6ea6df1609a48b96117cdbee19e841be496b79337d63281 012c09af03e3d3d7f48221672c5bf4e05dff3716d744647807627d9d7ed75e52 b9c9d1f834c86d1113d8536412829692e6794731e2cb85934f3add8ca5296295 70f4428a1f36c543107dee9931b378e738af47b4c960e2360521281ed01db82b 2245991898701a04d0702da058f30eac9f2eb869566bf5b0832f41449834994d debb66dadd879e7875cdd1fcc2e0c73a7164e295829ccd0af5ca6a44897e4ddd 3a094f9d7b3d011c97897ca7cb55c1e4aee5d2833ef5cb56a9d7c1aaf043e359 20072e748ddbda7f5a4f6a9f30c4e7a640997e5ecf97f15bf0cdb068c14d823c e5dffd9502a42b8638da63500706cde697dc42cf941636a3775d4ecf5f11563b 2decf150e5e635c47b67ff2c4c2f1c3cb74d15724c050b985a0d37e01e067646 8ab05fc816919f8017dfad54062e9f93d2f8cee3c011cc077e442df75c3ba0f1 5929f00cbc961bc693eb17131b6f89de73cd2137a6112d482346fdce4da3072f cd245415fca9190b3f5fa2b229f8ebca3aab2e084f01d0638afa99edd2c817f4 a71c52bd92541494e4a389f667ca59f34923911e17ef4ba923a04d238f89401d 8ae0b7bba43ec4b225e4829ffa00d0fa6f995f4ff93ce9237c645a7d7708b078 3a55518cedb46f2b1edeecdf56914a8f2de3605df30995fb2c331100dd73063d b249212b901d73152d5d6575a1ef5f27079ee8a6660c6dba3f0d70ab18079d5d 09cece2cec55abe14f6c5d3681e6a3da9e3bd75442369ace34915c8a725ec880 1710aa52ba925feafc4477ca73dec7dc11805e393642e5a444442989be1def0d b993ca971ea66dad353f6f5c338b6a2c8aecef15bd79ba03838a82c845172440 c9d8a3bcf7523dcc38d1a5ab4ca71c999310589e9712f54d8bdc13075d9602ef 12e8d6c4b4ccbab7ad98baecd77ccc8a1666474a1d9717e227750f22d6f46016 04a3246f91e86c0cea76b123bc08903dfdce13e5bc1710c656cca5d859148cf2 92494c362575eb4a19462b1b14067534a465d331ac233bd770adc155a0e9f805 6baf277853495cf5482fe08582d79a957f70e0a878e86bceaa9af967a3a1afdb 2b5fa12f48497ae1fb670b936287f03f1c473281dd42b594dbdcde4079ddfbaa fd9f84887a617768d79b3492844be5b8da294e3ea016c1e51bce26a36e72577d e7da58d7aaa13fea9936eb28114f9b7f0ef4997414b569aa895500c0afab20b0 5e0faad0e8d55ecad29d0ac6316e17bcc9eade3bda7aa3006d03a2e9fdef7e08 50c555404f87b93e52de103c405c9fb1cb3c19586a0b90422061c4dd513cb58b e6e9e2aed640f9c58d0e2645f8ff308af33d8c8e8124c0a61c8ecc9ca28dbda5 959d3c613b4151b28c1fb35569fd3d89d1e6d276af4030b77cfe5ee22ea7c11a 404dc708e03dfe8f28ba1ba88f2e5db8757a3a67edf5c430ef6f889711b1971b 12256a5cc36afdb2cde8d58f6b6c996cb4dbb3eabc9ef530f9b93466d53d99d6 1e423eb530434bf15bae5f8a7c2bdbaf7b1c10501a6609dd2446636d90a332ea ad60a07f8e4093ee17b949b1deb91f62e1ab72595402d45062978df4c3266819 1379f3a747a040ef4e5073b3ad4e33e8c31902c87dd3d61e6c08c94c979f78f0 33efe37673f13b2ad5a982ba809af30d7480efb4892f14364b1275f8cf4fbed9 d4271609be30b70ce95cf10b2c25bfae6eafe50af6dea2d8306a760db35eac85 c7d1569541855b69bf0546034f9b48afa641bbd532d38388e96cf1768b9af4e8 2aad5b98da163fb561c7595a5949383a6b9a0805f8b0e2a8844e045e11cfbc22 1358ce01434faf7c8e9b2dade15bd514c7e92c6dec4855c2d10683f45bc6095e c3e37be5881f20a1ab5ce33605713ace69020f4d9969b735dd84e6aed56c86ed 846c51c4b6eeaf711c7aab321c05262e21d1327d367bd5fe08c0e92be077c490 ece46633e4e417898ed86f20cec69668d6e04f5215f80fd8d9b7fd1f310c337d f104dab4913ff4d456ef784b0ee10a7bd79f6693e37c670bde2fff363f2a090c da677636d4db6c721915564b13e6b53d12ef075590f76dae676e4c53d67410dc 04a4fb6c35c38360ce5fdc268739e2ef6a2beed8ff7bc95460d62b5adf68f8dc 5e7559290137fd3d83706e5e7c1121883c359fedbbb94c8ca4b2680733d8b0c6 479b7e2475c7de034efd81859b61288b803c456684be12537de7aa99b5d127be 402fd78886359830d6839113804b636a85d473ead1920c9932cef4d9cea5c6f5 5cb4b5011651d2c69e636f81ca0d841807209d841a739bf2961d1480c4edfc55 d07f7d8beae6750468330d553fe1978cb404f4a1e2488c753a5d0749ae524636 7295ff8a66d12b4818b5f35d91f2b0ad70ccc7443130792f4e484a782db7f8e5 fee7468ba7194735b76a6416aa03e803afb3bc66077f65a4fc666a8670813a73 b1b2854a6dbc4cd826dfe66b8c34253af6c3860502bb629ebd8d4fe071fcd1a6 7df1fe7319b51ad76d1d6e9115456c2100b8fa74e46c3059ae65b32c756464ed a07ae5f7e8c60a6ee0b6bc0cd2b4cac1e60a964e98b4da967722bd3d03409a54 2c89e51f3e4a9ca6c0d283ebfc97ed96edbf16fb0f327548617e86b89e5f8dfc 8e6b6ae609a6940736bfc9a50a7b299b0274d9ccf03351d2a8f7694e398abb2e 2ea8b51ffa4de90f3cb2bb07ff59893aa13de7c32b7726ce1006dc88317161fc 904a28f7389923ee6374cb5d32e08197e899cfc066c96682cf3b0fbc3b72ca1b 729ed8fb818480801cb35ce3253ee767255cac0031cb70b47ce4388e1c28a3ac aff0ba9017e8179fff3df916b714c215b85d094907124b4ff5899450665b8da8 27f59c289add2c9470af149c956ff3b04f5c6388926b2984c24e5b6756c847c3 fec3cb7c1fd7fa60da89c019ead2d966e06fc052096442d3142226ff0fdb82fa 42d091f65225d2e064d979404ab5754f7ca4bad7c51406376fba94c4fd0b88d0 2bfb9b80fdadd222bb08bb790e6d188fc54419aa279c9b21c0951548674341bf 2916e5d0c9a9138cc0166320366ff1a1f7c1f491a64159f903e7a2025441ce63 405628a15b6d835366899c6daa9030494dd33216415a88e6d9645aed8c89b0e7 3b2656ab204b8472eaefa1dff67a0f1302d9aa9a1ad8f23b5481a685c6a856de c11e154bd9f80cc376fa95f3fc8fa3af606256855b354b639b4df67b8e8640dd 8bd2ebe7318b454747d500f3833246e8a3edda5913577d9871e7501f4c4c65db a720d5a5a7242952dfe68637045142b76dff814195f426dcc20d317213720e33 ecadd044840a168f7e83a8f2b3f67f5d49131f75fe3322cfacaaff9ef68a0e86 a23c3b773dc8374a0b50173d6dd2a5b29ce66b0d1d62dfef1560462e5a41cdfc d0a8fe4d361bff92a2c8d77aee367a097c301b1a0dd518cf136f8dbe5af9fdc8 f604bcb4374ee29b3c8e4041d27a08ef094ebbcb4ed19559f7515401dca0744a fbbddb30feff43c8798c2c6ddfe3e8b19ec2d3ce405e1f0ea1d6c148e9491dff 54b2dbdc5399e72856119bf552be5cb3974ddf1a7de015d7e5da1ee02b0dfaa2 4eca7debb202e342051c049226f8cb4767442f13e712d3a1742857e3188fe879 829dd2aae457f9465995c79a10cc1c03488a95de1b8dc12ee74ca66325a7be88 ad6d9c33f993edb38182239144b58430aced85e701780364ae9faa243fa7a217 e78c8e16cc112e8b526ae3496bc19f9fade6fa6778173a88dd0bc18f7262e2c5 31ea3fb778c29313a09ce9665a52949dd6ef52d9fd514ace880300a6f2dd1f2f 8615a6a3d70967d960dc0bc48e8ea0ebf59d8b39a5cd8a99266288f4e8316284 65f76789b071a4e9354db6f980cd2c35f1eaea62e32f34fa1a7e4b341606ab3e d5f40047e69e7b5f819b276bc2d277a11c9937813d5924e467b8c9bc81d215f9 355b0bf3c48b6f3b738c8562887e0ddf6f7fc04d1456d202e6ba02014a4c90c2 d137ab92a2881eced4293511a819679cbbc89008d21075ee21c6bb5b046215d6 86332fbeb6b2f50aa906a49247b09f207c425f17f0d2e7a8a2deb585bbf0eaed 58bcdce587e6eed7609d388a55b05e4240a61b568e9e5141591ce8629c238fe0 d6097f96caa48e380a7ad94df021698e525aa113791a2b8be91a7974d29de2f0 a9cae6409dab5099d26ec34a41f9d646663cdc941ef0862ecd384d27cf2e9a34 2751d3a661a51328185df4ed66658f02393f90c3350eda059a4c71b9d1ed9f67 a989804de21383e46dd2155ec0dbe2f5c127f7cd97a127ad4b7c76f017493f87 7c337941ed522a8f61149434e903942c595e0bf68a19eee809e500395ecffe04 d531d3a090f7b9feeaf254438852eee405bf412d41c053023716198d98f8d0f5 625cecc397c1b67441730cd1701986484c2b24b5c32ca61321ece2c4283c6a05 9f0fa0d4e8999b7adf27f9b31824a7c309b23d2be2ee83e851df8c2b660360f2 407b0bfe39971b9e0037dd79db93d164d079f8e00dcb8d4085dc8b41f91772a9 5455a1f8e7e7cc1374f610eaa089086fa7446610e74aa8bb4afda37715091f27 cbcb2b6fdca0f6e72f741e8ca88271c52d913d93784d69e70f16d6da7477ad98 db1e3d9df06599d6485e2ff371d4a600b43ccc249bbc6309c3f9a36de1f3af1b 406725971985265d7a2888e91b955ed40f4e3d1cedeacb710f8051c53cbaf49f 8b28e249da7f5c9280c01249572cba2e6eecc970a93bac53bcb4b9c8e6e640bf ae00617c7b499f288834e52a64504210be9fa398d113ef39525d6a85ce757c40 0677a6fd22fc12cf3dcdca106e05ee8fd18759b78598eedb7e176ac44d65e2d4 8e60bf4afee39109eea9edac28875c31f30e6e280d898a00f796d85de041eb6e cc7249762d8dc1bc2cbfe83e5a3a28842a48e6bf29c4e78c9f115cfc27bf8bf7 a6810203173aa88357dfed1f35beee6d73e38da78a7583b329810a06c46dac5d 431f2e1fe54a13aa3aad164e339cf6463b8190db5f5632d4c096b08e100246f0 e03c6d93874e0ec2c8ee0d238382040d455a55dc0923fd0b2afc1bd1f7d399a6 73b62b31b6ebcc9937dbbe4ac6907609a68d6eb4feb51f7e70afcc912d22623f afde6010128e5d4fd46a0c2afc6d12b4216b51e092dc050097ad9cee3b6148c2 cf660b8abca78a389af858c41ca235fa127cb86098964a5dda309ace3ff34c32 f74fbd3f2d3da14032200763a61edfb019f6a34492184702cb800ea889bf37d6 e74dfa1a4004ddfac92d41d388572a5f255982d40e207189e2c1892dc5af1130 6bf7dc128af4e7c039f52093b80cabbf0342f923cb372712fb012edc469607e8 ea3f3eed317815434b64a8c02647bb49933a341363351fb463198d6bfdfe1ab0 bf607ade73d9fbdf67d6f66f4757bd85f8084a1de1a5411217720e2875b94722 91d0180661702425c83970e04fdf5bb86511516c400f6618c9f66e60fa79b70f a4175d3185abd7a03ad7d139907322418577644a7394c77cda9092e937a1b401 31f2b49a2f3df0b3966ea20984843e4d40df5d3a115cc71923142d2cc9a5a339 12cbd557508932dad07402d9fe599cdf290d8e13404a7f0bbc30cb0e8f6fb051 e87e1757f7257a30b7fa51fda581127a5ae9df6f3a63c79ea0592b63dd431d51 624357831afe4f7f4acac70c457280b1e5e3d3ceb7d6642a7c5062f71bb73df5 beb1b43f58b59c7926aba3b5a873c614d008ae6220a12623680f2e7d571f2931 61ee7bc796acbfa157a882721938f4c6a38ea7c5780bca69f09d11bdbf4c6bcb 6be6cce2d2daa1c1dc937f44c7b290880f72e849a178f0fde7c451bbb16cc960 c6701e6389ea37f45b9faa73b44dc412c43e15f63827f73253251048d0d1aaf1 3bd90e4ae4ec59c20955a8786436fe323545d7d76dd86e977fae235710c2770d 86e7e8fae2623b5072bee6585705ad8c6a35467053011a29a2902bddf28f2e97 f975164d0117adc42dba23154292e0d9907eb1300524f9f146430763f27fe1a4 b1f1177dcdb89c3330fe6137eecd4e3f9f613456e32db51fa3f334882640166f 507565d88391e24f45e3219a723a2201a02c40c5cd88b3e16e7ab8d36d3f0442 682acb51bb734a6c5a8184f716a0b2bc890dd14d80a268d9ca697cbad6d2aef5 d6b05b529283e658771e12cb8db03e805a6f377515d2ee11ce71bee3f22b3f58 a3b057a1933ed0381d0cd89166e7b2cc8c3613f9cdd92cd109d86b4ffb842490 bd337f0b6ac1634f12c067493bcc741b21581dbcd5eecfd1386b4b50803a5beb d46971f3d8b4f9fbb71a71cc887646ffdf1ac95e40c8374881aed95f4e60d6e6 8a3249e79c08af225720d75c7736a07fa6cf863eea4eaaad647788c43b8f4ba6 f25ff9ae361b090d43b63274a411a1b5d4536307bf4c2aa857c3d515ef26335c c306224eb6323a16ab68eac94a38649236d1124f55b7bdec67c8961e411f1fc5 fbdf0163bdbb52808c79b0670c091b39c906583b379eab71153db54af0fa64db 01834dbe726bb20cfd6e8304bd14ca1f2ad2a92c6e0676640ba2306661d886d8 163b7b5864dea3f7fa0a7205004588c2f58326f0a93ec6f4ed42db249b46552c d4c93ebeb66d6eafebd24ff97dd405b61dabb318122177de4b20916eed1ddf99 68800a101d30377b7cc7ec21e5e5ba8f31098a1426f09c5713c59838faa86a1e 697c8ff36a824ab70fdedf3b4890e0e4d767f4894c7a4fe02753715e4e5504b6 169089c3de0a304c16958b81bc597b22424e08e4b44effcbfdc53cfb7ca32592 f7f4aac8edd8081a5d88e1bf2a1d8af7fc495f279183c1cc8ae9c2a2559acd6e 102abb0de31c22bd64ca47ae288a2ec0945640c9d8736361c8e7e5c70193bd6a 44ad04132ef42640626b75cdb2e4aef4bd6f8cbf52b5097db6ed3d89cf980c5c d97cb6a5a0a76ded4893fe31663fb9e463d6734281adbff52fb386a34c14f60e 109 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 +generate_ring_signature 7d40505d96cc9812cda2ecf10be26e35068ef21403fc13a3fe0374f1752bdc3b 58399ed2f6ab0ef8e44f8baabd4b7668e5d9e0ce163b55fde697dc1f57b65176 2 a0f1b1b883584dd18faeaee8affa2076a50d7783086353a9b7d4877f0c23bd55 9c840d84c4e8d918410d5efcfaad94d5be97b5a16738f9ba27c1301e30adc367 bc309edac23260a587d0ead081229e22a1a46029e24bfc99b8d264f0cb550e02 1 8b78c9925e52578dc859beceb2992ea8ae839ef081d08aac63d5d81cc2fe7c06551346edc43bac05062d05d52c8f8537d36b05243a5aab03147fda99ef25040d9eb5219ed48cc03d36c9290eb3847c3ff32a8d282d1c43ea826134f8be3218079bc6e7ff41cb03b61bfb391aab4c75b9bddbed1df874820bc64ea4665331aa09 +generate_ring_signature d2b1be9c36ccec50df11eb89ccada0a0d065fafc1a4b7296d85180598d0208fb 790464d130c590b15283bdb524cdc611c1dfe90ed958cfdd1c61f4a8c610e971 3 c760502af5bd01024b414aa8e6ec3291d24a119c069e5394023daa44cf502a35 304177d3c97d2ea31afd6600fab36a15763c2a7d6fd2b179aaf9adf4a6d93288 5c01ec55a849da5d9c141a1da2cadd189c7cc4302866056619bcf541c0ff4c0b 67567e52f4f0d0b41c1b633d3ff41eb5a3af5abbb4b71ea61b57dc39e433bd01 2 0d06a24ad4f89b490bf6c882391af0e88b6184c41240f81aee87adcdf8914b0783936088a8925db3fed6c41e7e257d37a82068691ae19448b28208816e5eac0d89ba84f7fa5e8fef12bf8b0c2b1b69ae072a00a056dfee71a1a80a3f7d536a05c1b2f435e4bb895d8e61f69eb665050291dd318cc5b40f0c7187797c0800d30f6f3a308ab2b5ecb91468e9fb0ac42f11c71b1af288b07e145d478b8b08c52700d082cd970ef5fb58bd7b4465c399a64434c8d0c47b1e7675b01f953d6ee9640c +generate_ring_signature 6a7157bd5b7abb0dbf254d14383ec158061c39beb909e371c736bc053821894e 319ca2b6bf52f500ee46fa4e19e07878690597cea71cfd1294d689377803b4bc 2 f579fbadb5fe3ef087c03567db8a70b8b40670bd8e77c9cc58a519e55fa91265 75e979d40c24323138df595858e567668aa8085c2adae4cd9a72ce08499f99f9 0e8eda5e20345e1e85b44af5a172c57f1b7ab0a80d4323bb560058b4bca9aa07 0 79c41dc101e9454b91bf39f319e679b534c6633a8fd7e92a9bcbae159a9a9207908de4dd620a6aac8f1839f3f7404aabd662eb14800a2dc0048d93eae2e8510c652f2a71c334f5d22988b882b4d1e98e44d51968c2dbc332cfb059f156bfe9096b857e437fefd8163185a032797cd1ccb50549b76d956c355dd910b9056c8e06 +generate_ring_signature 2ff3bc41c8184d849397465ce855f0331b2fb8089acd03896ecc40f13c26c6cb 3c0d534bad069aea7a7a99f476537d5fc7d744827fb3c5b1747bd5e628c0c060 1 6a2dd8917bb9f1afe10a52fdc06a7f1a8be194adfd27720f52dc6b68e41dac13 9a8ae3cce36c6a7ce062ca5008b7fbcec509d750a7af1755506ca42987e71f03 0 0ff2c80243d7614217c7aa10a79b02c034bb610d9a708c3b0b6ebe95fed30b0c8cd1abe749b9147c636fe55c141859977be4090ea812eac5b0b8406a9defbc0b +generate_ring_signature 4de455ffd336973df436d8cc5400f445edaadc720ff6edeff859b49238aa2fce 0d974c6f5c5852046fbb400ecb528e463a9ac8ddb7e4f87290675000e4c29634 6 e119b88581dfc38a94fe46a82590cd9b062d321097017947ab2a039d77723a41 7ed1ae0e3e982d596cc6b1c33913cab5e0cac7b70a22d957ce5b51fb86ce1535 d74735989a7d20983a2adc2f7913caebf4fc12e1d33946c96d893ed9fcc41b12 af83956b543c7ab0878eda74010bcce3c086b748e6ab788628c78eef075c90d6 357399bcc7afcb24242b9a1eb62432c35ae6cedaefd732cc858d7eae7cb92e79 dae830a72a324ab3113ae4913a820523184bbdabacfe07bcbd687ade7d8659aa b5558d1400cf33fa98203b0af326975ef9038e19f64b41299a32a0f135bc2804 3 45b8d2059cbe52e1f310218c416ce77abfcc3e9edeb2103cccc9a0a7bbb4fa01f4a10360b9270b733eefa8a29e7a8fa7566f89c13b6d107415a433f6c181bb012d295044d63b0ef0087c60f6f336cd916984ededa488a5b78addeb47db6bb609e7d6a95be81b4dd14d501be253e0eac658688ce3984d1378710d67155b41ec086a6f76b410250721ee7d0d86c8cd3ec6bbdf6ca1bfb0ea4b9a85b86e1758ed0b6cec5cfe7938dd7ba6c2f4130deeaf489fc2f8e5f49b17e09b305dbce5f0530f4fc82e0cd6e987dfb50aa7eceab74d5e3ec21c00d7d19e62e83ca1aa5d1b7705041406c68a375a5733aa0f3a00c7c2da766e7a16e657f15f7bcefdd57d5f3c0f8c1bf927976487ee7a1bc82c0a8f15aa0e9d95ee8b1d91711c4cdd3502eea2091367c7a531c80840bbce75ab44d4c54e2f06b65fade1c9967cb4482babee370c037c81f7a910c7dcf54a317dbd47e5c0baac251b89b3d243c332db4947de2f0cef43f64843428e3b80dd229ef5b8d632cdb4ea914011886442b8552fc3356201 +generate_ring_signature c5a69d4c24d9ccccb2b7f24569071ae98acf6e03b925e5a9cc09752d801c62bb 3eabbfe3695bc2dbd5901d017eb2e54b9caba0945720164f342fbe3e6ce66b78 26 f43a0cea4cdc1617fdf4dc9aabd74562d8a295c3f85ed4acfe4042119367ea4c f4b250e120df0108ef321a0ada6f8d56a290ddc4164803d62d92e06524f4487a 60c9eaf854e68882287d9f28241a6ee63496342162b018d85c7e547bd65ff258 d3bbab657cf5184747c0ea16043192f6b16743a2aec28a35fb3e03c78114d01c 8b00e6cde3c562f5d9318949c9eac03c685090b8a3d57ba4ae5704ff3b5d1f02 4e16fef6f635620955f7ca6ff8f3077e146acc5591573501874e0f7ec8a6d84d 1ab363c7267a5f871fa39b58b3f77f132c832a148255fa43d488e145b12f24e6 93d47d397bd986ae573e04cfd6502baa9f86572d8fbe2fcfc29d35a6c55b5453 a61daf279f18faf9f001831bc06539fabea3cf733b10abef58a1523414ba2496 063029c65fe66102a1c47575d374692a459a416b9fac9450b3c102494b85b5bf 095fc13758f256b4550452a379a65f8d1c23e670cb5904394d153e4f9ef6f0e9 8be1d43efa5494cd054ba8f7a2ab134fa778dde275d453564e2794af637c26e8 146719dffba2869567d19999455814cedc3384b8a104dfb6512dd434041e8f04 8c21f868f215881a4d8f8ecef15a45ea9c5577c96edc5f2db93aaa97627267d3 c6cd4788daba63903038377a7748208b58351ec9384c96fb1c85558063ca8128 3e5881dcdd2d29e42ce5229d59c8427d266e9c0bfc48bd849a22f9c563ff572b f2ac153edf0d83e0b04bf20f7fb6c70881a8079af523710983e8aa89373700f6 0bd89db8a50f485379de7737d43b3f7899c254190c41f8ed38c1b82eeada7554 50313db4b4816e421de0dbb01a534131546b64539e2ff471e63e8b745b825c5f bed722400190efb4c21cdb4d76679ac6ddd56ef850ea89f5ab43f89d4f2c02e1 c81d8bb33ba874db043e3d8bf303b5790192fea6459adb800a76d48614937fcb 01563d30080870956b47ac0514635364e1c5f8d45e62af0895c405e96be1516e 909d70e1e8813e0ac85788146a836b2cf2d3ade2d2c5b18c9b08cc41b688990a 2da5ed39c9928eaf2ba35e5195ba789f8a01e99bd9bcc55c81c5b1c7bf6caa48 4668235408de2079f6d3111e96e502117b10d42a5c0e7790e9eebb7105a792bc e6574c97ebfd1ffb756f4b27c71b787e0c332b830086081ba57cfa1a699ea613 66dfd1881a176aaaf91af0a512636d9c0049460df4ccce64a4f7527e2d0e0702 16 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 +generate_ring_signature 1a25025edeed2967079043c06388cd736a6305609ead156e76233de39443e6db cdd7e9ef74c4f826659baa13cc7027e9d3c0b4379472adae05f36e99ff600541 32 18cbd5ae5ba735e8ff1df944cca9ae3bc07187947d3a0377811c7e0769cc46b5 2eee82ab6674d77e15df8e3fef6d52f2159d96f510aef9f03a7080cc1df8a551 8c891c48ea8e5578faad92012e8519be5415a6397f92493cf368598927562aaf bbeacd239001a036995137abcd6f6df6af0d42517532c177cee3d774a14bd50d 6a7439d1ffd71e17552bf2d14763bad542aef8690dec9a35e7033d941df846cf 99d0c3c86698a62548085e50acff48c7142218ab6c51308429e5d516d27c1e2f b14165aeef86209407ffbfdb583485fd28f6edfc09bfb30000a69af629660478 a1b08ad9ac3f2fab9ae1c44b64c1f8c0d89c7ccfe524220a63c8fd4b80355937 c6f39774cabc63d8a858d76d2b67968c57754f6cf539a0516ebdc2681bfba6c8 e1420e8805e8267cf5cf14ea411f178feae61416ea6097c2936cf255d6da75af 68f36553bc4e176554dcdb4d40911c9d2fc1ad535ed5de68e61214740973721f 36995a5cc2d48acf783e851bc82a7d33b39e8d5fa98a28d053496431f62f4e8e 6e5a2e1e833e72907908da061752783d2bae0fc8ab5a5269693ad104fa23a541 e4c81b9504412585a70f804cda57e30835428f9e7b33db9e303cd8280e1eb133 b21e9d751bc67faa423ebbec6bdeaae824d66f1fd287229d15202ecebf972ada d85dfd2d4c2d681e4da972cb7ac70b9472b5a9cf847e51c7257beaf9a71b6c7d cc68be54b9a80b51446d0588e46f314f0ccc495c7d51e3d271737e76a465c33c 34305ec1efbf3dfad30fcd4e67ec2b03687d889bc2cdc77ab48e0b5ff9cb56b8 c1e4997cb9f2baa62de3da1f39b14b0f81dbd2b5b1458d4017e9c3d78a24d406 bec351ba97f26bcb0b2e4c2dc0c42db166d281a7907971bf5087eda6fd4c7092 a61009cd579acb5a183f65cb11309fbfc2c83f15a8e9a3733dbcce4bcc9b68d0 4652edce62b97c125f033318f97c9d0b6af10e054d424e0054da0892856f8a5d 089d6c08e5cda9afc0e25c942156cba8e1154aa6e108f7157b21beb0b1dd9c71 7e67864cce0de6e0b36e85a0ffa8839316dd5257f1d43a4bdacb63723937940e b7924cc3f1eb11c19f0f92c4328e485ff5c087f7cd65d56266882437cf36b3f9 b90b30b4dfe9bb2e74a319d3fefdfe16dd466c5f304cbc7002c0b406c75f6cf0 f0e309314c00e1052b94b8b61b8215385eb018d80f7d416c7ffd3e303c8355f1 532eb3f1f94d0c51c3c2084e1459abfb07ef8735edfd8f0549904a66bea4a6ed 00c8322013b025dabc91953fc9d2c7558e2d482f7d3befba5ade16bcaf12e2ab e073df0ab60437b296be99f91cb20f4e2739ed54d3f387f1bef16935a75c1712 9e3706f7488756a2813420361f139e2e8478d77a52a07e0e3e0f2f85c873eab3 021fe8333e571ffc9e67b99ba619a42450b5c1fffd3139127f63412b9464a57a 1bbbc450a6b3450d412637420a225f94f6a76e0de606ccff43a749e255e7a803 28 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 +generate_ring_signature 06849cd0519c6f1009ff2038da647ab6c1db4158bfee7644db31219a32de2265 5ab33b23374071466d658f4931aa7ce87e2800bee54a77b3228c07a8d1f9e4f8 50 f4dca6918c240e30306a9f94dba59fc51a8ce538d71996d1b1ec029c9b32acc1 3cecaf5af6facb8438a4feef5999cb9fdc28fd4e4ea8ecd67ee057c70679a00c aac24c3bf580a2047cb608e7414c28ba41923980929864f3a59c5ddabe1813b1 178bc14f54597a5d3216a28b763597cd9593deea8e59a5e4ffab0d3af17dad67 cb648c43bb1ea79463c31058908db6360ae89bafede111ff9119f619ad40be49 645417d726d5f09e7c40ba1b1b1e17de4b445cc6b443f106ef8cdf20709de226 42fe478f50153993cb0de879050356c81055b30b04c773d07215ce8a05e86b9b 853818c89f9822f8b5bbd1116cb8fb192b49db52881a63fe91be8828843bf49f 43996d323e85feda01a303ec77bcad68cfbd45fa93ec6f52994fe002f3f63320 e80f906975529b458402d90e871d4fe391325a3506880ce3590640c1721663e3 249d745a3bed28cf3ab726767b78266a4f0df17ee72e4c228dd4ad9363198416 127e4eb44765ebb96929285776f2f28b8b506fd2f802709b960ba5122386e4da 47925a49af8a140f389594c6b0f58c0cc7d1e9b2ddf8b4b19caddcc3c191e66e f2c5333dd0c1fa1b3bbeb8f76e0c3ad4d90ae352e5491733577f53653a512a47 41ba603e6990ab4a6b38194ee651f33b1bd811ce9b415f738a999791e9ecc08c f0436f4175cc6fd250f1df326cacd940d9554ad61ea96fc21f7338b5314c0f0e 165eee723e8a32ed375e2454dd569b0a94ded444d743180b81883e7faa4a4f13 a85e2a7516551b743a2485984fb579351503bbf3ffe4a74a04877f9dcbb53690 e94ccff70bc813f73e14eae7093ce6610bd111710c284aec75a04b0f4e931fcc 03671c6ea4b79883673021463f66222b4aec7c91f5bc03ad7efc562fb6fe2db5 26a39e79ccb667024f0b7c90c1dd724da2e3754d810cd5491eac2b3cde14a1be a250f4bf3ac3e0b8aec3983660251dc7d6540d59ef7d05ee4b2c7412c166c98f 914bdb7c9c9b0735dd1be3f60171458b8e312e53ddbbb23e541660bb31fd1a24 a67f611b7bf550f4b54065c0c77352d3c49a3dbb71dde20777788eafcea84513 a9d5fd6f07e027beea34762f024615ff38a74cde6b009cb1795346607e5c1ec8 7c894a201bb20226d380c8b58342ab7b946782bed4532f9f25c40f639f1b1312 c360d3b1274db4fba04b8c6db76de6d52fd4326f7aa8ec955be3c62aed7188db 2be5959d53e19c49a6960aab64e2488996addfffb2419e3c8cef3db1f3c33a35 ba81236a84fbd39181eea3b60b1a85d6947007cf42c93ac15ef7a2cef6a4d3fb 8de16d964a3df51e199b8df767470f4508ccfccd27b7f6d78b62cb9398bc55ea ef9b3fbcbc282afb025ca8db586de74a30264588f5f1060d243c7865e4c18c6f 4dc1a34353b429f5e1811290d12d6e69f3485e6af9b389843aa1b5a067ced872 c8295f4fcc4620e37171d648e229e07c0ad3cf81fbdd49e895c08ca2dbb1a73e 39ed7eb8e5da66c5b688e7447508a283c96bba5c55ed8ec000e42ed4872ff145 4f7f18ec1e2eeee07658a986008ba1086b3a1f030a0dffb339099f94d4c8f3d1 c05959888131b964bb63476d63904d04bf1e62538e8c227fa6d6a84b1b2c5755 9af1683e1561c8c82aed8dc257a5f301eeeb76d538cb62c80d85825c3b58840d 58b9d74270c39051b00080c63d5d306b6c7e8ce773b912ae34cb528723b31409 75c8f3e9399c3e6a233b1f511138af008476a4fef6749b0d039ad92edfa6cfa3 8f2d018ba38454006905612074115d7f52f021de849afb63834f621b0cf86813 edb4523261f4218904cd2316470a97269c10b7dd6278345fad3c78508947624c 89ec4715a6d64497ee9825ec916c66ea04f4f6005f2c09737d094667e0e2c134 60d872a3dd8bc3dcd1e620a448fb2ab021b5dbd0e42bc54fd1a22173b7af796d 7aa0e6c13aa26d3cf23d32b3aac2f4b9f07dd8975532d326fbdce20cd978b271 f20616d23430a3a6df1fec7eb6ed20ac2f5f4d17cc4af342a92928939bc220c4 30ee3a8103f3b6869b385f54aa458acb4fbb8225b8cb1ba1ce0b313b9ab32830 d2c9241543810e19e2d25fb2b82f1bba7a7da6d72093f8aa35ccb1a7eb9d1271 e716caf713eb8e1c3f8c0c02dfcd682faec217cd7fb0a872f9a6e498be2d8f1c 8040cbcc375bb11d6c4da2de3035a95273695f28b3f766a966966a217af215df 118137a60cac4033aadd331dd3c1d1511d4c6b3ae41b929c05a31252f43d097c f28183b869e0e416647dfbdef14a6e7b1276ae55c760120cfb92d5333cbb870a 39 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 +generate_ring_signature c3ed92bde9e8446efb5b9367d42ec2d1422a2cfa450a71141a7097a49688df52 f0dab29e41e047f2c8183acee8e0708501ef4ef0ddfa6e7f17a9024b6ccfe877 63 da39f87cd0110e4eeb4c3569349e603a31a6fb69dba927f28d18ccf5cd877d42 cd374e7929e2a64d6b9be6dbd9cd599d84d20f7612ac652f64372b73f1877408 fe80449785af9cf3ee7a75a83a43659c6f5ba4c18db3270b87fa75164c859f0b 1be6eb1f5707cc1869a2e6ebdaff53cf48ae08eae0a8b1e531b888542cf293d1 8ee5d44e7badf8d5c406edcdd8c530b16e4e0b3b9b9bb9355befaf2efc077aea 3d438a0fd481a0eed145afda32e3476b76ac92a006fb4fd7810ad329a29b858e 6b76c127a388232f2df579062c1bf1a28528be805489d4f2705d66123812b2c7 680039121a8a1928e28f3153cb1176401d5caeb5dba958c24fcfb0474cd4dea5 a19c49f7d41672de74e063361060426d2a8b882349b92bfc808ce1e61ef12f11 8303590b8103b58ae2c77bad446c90df388ab2ecf06baac717f0afc80695caf6 562b47c8f013f3b19c61ebacd5526acfeb1cb804935d358f7c91ae04c5837419 ef3a80c7141778f0a022a868bc60312f647d43431992d300194ef4ba3c35d438 79b1823612b9bf0aadaffb6084fd2227e72cd3d7e4e9c01ed1b49a6676ebaa48 0dc8aa6f08a8927375135075e0bb400446e6444e0e8417e6124520eddf59716c cf05ad9b936775c640987b5c24e97747a556d79438e8c971026419d7d570ed80 c2a77c27771f2b48d872ca607557e68b5209646fcd51d33bc2e7354ad20c64c6 bfb6f453161cf18160d66e15b35b0cec92e8ff6f280c7f8a3f7f6c8bd7c43ac6 f51fa0445e7aea779340cf8be0bbf08ebd182f58075bac9d6444c6ac43fc2f5f d007b1eda8d4fcf518760ac888c98c55e95d31a80f60dd2b4ac977b16ec218a6 621bad8defeb944bb8d45d8e639188f7126c575c99181c490020483bade02400 4be49d6eca74a476c53ea0b10339efd3f1c7b3b7ec94ed1231ed9d98d0c06535 e290e3eb2f3610c491129c37300cd2e06bf327604430c38e4ae74c2378521c01 404bac8f26b8258897596efeb6a2038769e5fdb5bd9f025879e62de6099b79c2 d831751f5e3f66c566623b38c3f42772de731327660ad06a3b074007ba95a0a1 1a82cd19f29451407682902139f2c23830fc162b921ae2ae5aa91829559610c2 15d0830fc658ae55e4dd3911034f674a1a401f09b7cc11c3cc6f4d2245dcaab9 f48765e2972e935d57885af53bca175a9f7900569120d1fcb7986c2f42b3a305 e3e2b896e6bc92b4079ddd3a3490f9c9fd0e759fd4fc2709e1d742a6196e49fc 02c733dd69cdf8e3890d006ea71c1555a8b6407fa2f3ac6d967f6e43db4df100 42d84b667f691ba1f585b49d1d5fa029da5520b0686d8798c592ea844137b3f6 5e6605e0f7abe6131b382e6a8759c4ca5fae77ec8291fa878935962ee02e7023 43db8314dbb6db17309b12392187087f92934bf63d7e052ff7df1dab66251e46 c1de18964d5b564728cda7674a983d85b9e61af2a5012489473cb9bd048de0a7 80972ee2f028d2f4b2a15800a16152d42bcc81ca3c2437145bfca495514cb69d 83ef50ea7e02045bbf4f158d32f4b942284e63e5f2b780280a87703e4f7036f6 87604dfb8212ad16d491f0d56d7b311b4b24888b360c36b5c1a1129db3f3a8aa a3a8d82b787407f866a125572c62efbc1da5db0ef23fc74562d4390c68aaff56 01fa56294a12caea1c202ced527940cc24c4a89dc8270f49ae2d18e842400b28 9f931197ff4f05f68b25ae4a86de55987756793579d84b5d62de550150164c44 b61458c7d49003834597f78d4a2592d1fb486482e8e7bc3c3a57f49ef2b8ac42 d554e6418a72f0331d05757d200c3692558f334802719b53927648acddcc3351 cbed989db9983b608bd23cf0f5dbb80015add6f0b67b1b6774dfa96e70d506d1 795ad4295025bd980139455246590abadab9203a035c50846e4e6bf5faefc729 75b50ce254809aae0d537d54c0156197e20dd20c84bbd9a62e2e301590ee0e3f dd8006d8f8db4216f3a0fdc27a872b9f2d16c511d450ef8ef9204f10860d8453 9903457d3aab9decd7c2e07202cbeeae6191259e348d0e05fc8439f06404ac53 40ef0206e8abb47158988a82b39fda91d6f52d592e49ddf90181bf959be81da7 baf85bdc56b8033c1e262e08e123e5353cb7f7ddb2b7ffd74ccfa529227853c1 a4d2ee759a828c54e976a8bbc55294e0f971cae0f30c4ff2fdb04f07de39c7c1 a0d47358f5ffe1d742a0eec679ec72cd1481f7190cb0aff2baaa141b68899de4 9cf118c576775697f38f65e1605978c2af376fc5e87e18c7438b07b48cb4ee82 9f022677e170ee00cb689b13de994c7ae9f5bac789ee8c8ae1e4c5e7e179e880 9064ec6c92d15bbed8c3ffa9c54dd4a71c3e940373033de467234d6ba7e863ce ed04f38c3d6180703052c3cb1150e685ce390ab1491c85cb317533f10fa252fb 5b71fdcbff0fd2e0d68d25f03b750e7ec3adf0c4455b0e06bfeae8437cf746af 7bd75fd7e511a36f6462dd1242f4c53db2b6fee823cb5bedc26bcc9c3bb52372 3b403b21997c01407a6af4215fd3c8e21b4badfba425c032623b182bb2e22ce7 2d15770f93f004a76c5e4ccc25dfabedf39e57420ec152fdfeecd75eea79d139 f1d12a64020bd216a36776fa960a50453b3a3cf398ac5cd64ede354e8b882868 f1ee519a49f43b4d6eeab6922191742c70adc22d3eb88f68f285114600740f06 8b48ebb921c0dcea1e01d7600fcb33fe4c50a1646de0f5feb775cb9bd87b8988 3485e0a10bfed2eba8dd4dd81e2ea42a7daba5c4ec4a035521004ef90274565c b6a73a9b1b67ebc907bfd0429107f58b7867a029b9e48bde23b821102f2b0ffc d5daaf0ec5ee5a4ae2a10fead09449b44b165bc5e657dbdb9aa0ae2a16824e02 58 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 +generate_ring_signature 33bcbd4c5fa68af0c24eec449ea51bb72ef7190c0ece9dffef244eb90d6765da 732fdd3197aa6855d284d6bc4749adbb4c265336b62300984ebcf74d03d31ca1 1 878686a68ba5dd5aa696fd1078dd94d627486bd9c11d6dd328ff0a9b6c091f0e 658be715fa02ba1b7f4eafc02f985fe14c9f7d25f6bb4663ff87ebdc2d63eb00 0 cec5feb9a7f2c6522bb28e0d3287a0f6fa646237b29094dbf2670b246e7f670d22bc14e5b6674931f4702e824da00be5d922edb570b4d9cd99590063318c460c +generate_ring_signature 61c98e5693c58afb5c7311d89c4589e4669b52d8ff4571f293ff1f98af9b6224 68535c66978cc85a04be5b88c000167008d36429547ee67230abc78d01b3a07e 2 244b5e8cfbc8ef701d79624bb3499515be5273e45b73fbcfbde5b238121567b6 04cf46394b267c0bc9a5c9e2e5f88b07d59cd5a9bb056f94b46e816db4789be3 f0c934fded787d254b29eac8eea8e249d6217a82e8e9d5bd7565611394277404 0 a050dc70373e2d18df942e8efb47813dd670e0308ab4cf85543b299ce2ecd50d72976fe1f3ae0091edf5420f8119c44019a96db05a583ed4a7fdc6a8f02e390447ff270eac3ed4c42ced54d3bc9e00c86bbf3942e14e6f4570fda2c4bd97a804b35d131590839f91938e8e6e24da8c39875fc1d1fb4d1d7aabde2ea12884380a +generate_ring_signature ccc5dbfe3a1cdf9f9c21948ae48b7cdf305a2054183d05654f6a5b8f1d93b6d0 406a3a1d1b23710ed1555c857e26bb6185a783eef109fbd102728811279bf26f 111 2921b78ba30bd3557e4b772b3d61ea6a16138631c4ba2d8613419171e99e66e3 ad1f075026848ef6bc1680d01e676f8fc292a83df780b49224e9b62c215f6eae f0ce3cecd97138d3819ee595d9c3edebaca5e340afe2f07183373d0dffa0f4be 26eb1a7d2b2c5bb31b7fb377b2523ca36648014dfd16c7f695bed93b718e8733 92523fa28a9a5267ed1801b4d606e0fa5c1b70d54c4634ad0365c6373de04a81 19c3b3475cdfe8c9e801d0be4def7e2d002cd570fb9d9234fca3a0011a8bc5ee 0e9593813368b47bb51b706641310e983b927386a90a00398108e8bb790ce5e1 5d46bdc035314dd0de17318cd46d886dea88c67150375407f34c0039989ecbfb 0e8d745fe8777c695390abcbdc771c9a7038cc327c417f3b754118c65b6d6f99 8b05713d11a953c083ede9778e7e7bbbf4410e35fea2af5b4320b0c7cc4ab789 13761d8cf0742d4b60bbfa4d205c49d4231eabf718ec4234f4036ca168d9d1ec cd2db44254c778fc88a7737e400abcce5d893219d8460c6ab3511b42512657fe b4534bc0527d545be7a0192467837a675c47e94db7ab43ea0773bb968a5740f8 ae5ce2355ada6f7780d89d1f33a249d4dfe7e079b5e102a82314bac3c04c3f6a 3838cd930a369c5458933289ba73002c71134a5e9dbe16c9dca9471987882c26 ff437f8c5906e641d47e53514ff94977417cab286d5f9998c0a7b8177173616d 9abfca55d6be1bc9d37e412d7c35202301060b89e1e700d5514d02d9011aab29 a3232deeb8e763d369ae5c94553aa0e264705dfe24f1fada06a1be1ebe93dfb5 8f51c13bfcf2486557450ea30970171fb0d428c02a823c7f9c704da2402b6594 1791024939f618fe68b0d73e853103b1fcbded7abdb65fa15aef63f55d8b7f44 ebebcd04a35a3eb5c9af95cd67d75289e616092523b8674c659d55209b9b2d61 4702673f7fa85237ae5f20e68b966f4fa9b68c8b6c900316e9f3864a2720b509 bba906384ec35445dd4fdfcd246f38654e8b9d1e3b24911e8c892687d1bff04f 1242ea27621579afd6aae5311988fda8be14600d5fc64352af2ebc4dd383f7d9 7dbe2bf95b8051ea0adaa52744aada889d89e6ad189ea26d8e8c355eb469571a 4cdf70da3f89ee7210375564f8d46aa5fc3a3c47e13866abac7c0d618346a042 dcd45fefa6e3de7ddcd3e105f8888bb6749cb565b2d1fe67bb1b56fef790fc5d 9507267fc1696e5c35cd3718490dc2a853cd2f6a249827f0235d6cb95ecea192 fdd370f6de86d821dd2ea27158eb2ba1a9f6bbe1626485fadd01a80a92a3ded1 575e8265225649995b947201fd76719e51e56f15eee0d5e6462331f69650bc7e c9c8a863860d12415cb601e9d8362990ee855a1e5d1d70cd75e15cc53c07e7e8 dcfe0f0f4119063c29577224bd9a7a1a3800d645e0db7547ea05389f45e73c95 76b4cabbccb35f51dd5f61dc72c717ea336795fc71d7510feba7a84e5beb5fab 0f12bd1eeaa102f5531d9fcb6b79423393fc47bf0e7f753c814f5c273a97ff75 86292224747d0e179c14b7a3e65e4561281b6a827aef6afa2dcb8f8b16571b92 1f9378d5cd626274da52a2b71027b5ee6335871550ffde522ff0a6f49986eaf2 6d5daac0ba917f50cbc0c8502489320d6130cc4a2b332b34556086c5084a5324 9ceb51482de662fe631eb9009212b401fe7138b667b7bd8cf94d9181f955f3ac 958663234c70ff625e10a10779504e267f643aede28861c4a0759eb01fadb1e3 d906f333761bfd3b113903255c1589cafdd20378d85665af168d0aad0367f83a 0635c64549ffedc46dab199ebf89fcc8ac599c8d89970f7133ab5e235e19f832 decccd21d763536ae6d62e9c56019358437f7176b0c6620b51bf59c5f2b0a518 62bfeccab34d00e92ccf718f671b735d07fc475bc5e4fd783e487666b0fff721 adaa55bfbbc3f50b640ccaec02646f4b152fef46d323065efda9bdadaef91ba8 82bfa52412799a07d83541bf6a3de59bc0af127e4310f09fea4d1971af8c6aa5 4c796345e19c94182721175a198a8ad535ec0f547558c7f07cbc3127a1ba0d87 ac9bc2d8ef7f43f80ac9d87142545ec4d14e54f64d4af3aae305bb5407a819fd 934000e2895878f33474fb25b205d5064c181277719336e36e688133a93bfda2 1b3ca7399c0b5508f80a645e083627435056ace47a15f8fe9f9fda75a0b17baa 9e360d75e54b81e3434caf08a8341bfd70abec216f1760388e7d68aebd87e6db ba19f181e552de8ee972884cf82d87abf397949851f9bf867a7bd57656fb8d80 a3d028b2702f532fb6dd99154d310afe882a709f8d0f194a3352f800b855c91d 6c477cc3e4587c389469d20bd69c196613bd50208f91324404ad58201f7549b2 a296d83f65b17869870485296b1df3bb2245aa4245abfad85e826dbd93ca4e21 23bea6d1f3a996575696f69c7b4f4e4b276707eed13cd00cbcc97bcd807b9bf9 5273d520380cd20c951e725147ee7aa942b743b8873b0ad756bdf30851dc2d98 85aca67f1e96a7e3fcf7ea9a64c5eb63dfddf35b692f631f89d179d5d3ecfcbe 84240ec649ba87138abdd7d1524c2b580c95d601395ecfa75ddcefb52fba547f d11fb311986843cef697a42c1db914979eccde0dae94d1fe7ebee7d4974be857 0af06bab640a620fbf4cc5c3a777e209c5421641b8ab610b3c5a2a1a47ae2a0e ba30f319070ffb436f5a5853d00f8013241fb6a6bc472d142f303623d33ad465 34132768b3b2dfb6d97c8eccffa9e4009230eedb6e84ddfed5dafcac3763adc3 c5903c815b8bd030162bbdae429032faca5d73777ce3a8248dd717578f0b8541 adc10a53868cc31d0d81395ff25be93e04212b1f45c00ab5f6eebc4c9b28aaad 1b841fd24b0e7929dabc30e700c6d312a8e3d976c95155a3bb3102fd9e0227b0 56f8165751e6767f607821a630ab9d2132661b4ac81e2f693e5c4f60114ffec2 6865e341bb94717a4de51578360b59cbb07a1660f70b0048d9475d28d7adbe3c 3dca83f1651d518dc458d331c9b9e7c2791ee1019cdf392cd722214e169ff2d3 72099a12ac2a7852c982c2345a5b13d7ee8fd6cfcecdf989430e365dbcd758cc 400f30e5179063981ae05f55129898e12a61dfd6379670fba47f4af1f1abd042 771d8631769dd24075741231cfda6e1bf41d075c4c60af3521546b2f6f2f7da9 1a4ac92b9c6b0ceca0a0914c21934774314b7610eb65d81639971606e2109a13 c6555b566f15c912b0fe560cfa4b5df5dea4e44624b49aa8a6209f9131109e25 944e66c093a3b22b7b64434839dffdfda5b8e0ddb6e93b3fb4e6c0d64ec80ccf 5682de8256dc5f421323d2e18e4fe8e86810eaa87c6d58535dd2c8d29d27d6f2 ac52d43a2c0fe2b23e73c67f6b0db159498140621b13b4bf2fa6311de6cfee8c 24db498c9238003c869f46647b4ec96fab351438cee5fe815ce700f5a83aba83 75ba2f7f38f6bbd6f58b59357fb99a74b46cb4252758fdd4e669d327a28fc693 74d45357edbaedf1f26950c22d83506ab3477bc671e685583418c81aa4c11f4f 61c814f9c7d4066bf95ecfc56a6b60d95eb63b0cdd4c0a45ff4d4f83367aff38 b58e16527d8d0435434e83e64c6ef570cf3717f79f8bb142a3510dce185286cc fb771fda4468b3ea8ee77c23ffa586486cbccd347fcac9fb97960262fc4ea76a a5147a14b7ef157b8288f781275b06f0b785c0888fab930c6a78d94ac818ff89 34557754636e143800091dd6e2a233b47f140010f36eb4ce27b48855b74076ba f95443b3d18f130e37fd03856ec8c6e38ac04dc9d528220481cbb49ed27a9f03 3a6d4cd695f507a0a8a404c02d1e0bd2ac93f4ef2e2056da9ef7a73e70d82f7e 5420f0d5dc5f296057a98a879fbc0d64605806aaad6b574da9a6e2ce9cab60b7 71b23bafb900f95b9d8d0deb139f0cb966ccc1078542b32dceef6849de962e8c 2255481001bf79311d76a4989dd98ff8c7f2660ab70f273b52024560d7d9fd66 2d291106b2157d69bc98c89e4034cfb9988d54b69a413a543074613cb1cf7923 3e38943714f3d3db34f5c12f375e73e99e6947fa661e86065c4041d15408eff8 7c79bb5943468383d769a23b260a0179587e9fbf3224349369bce1e5a49e4869 fe4fbdee077a24b3ac3fabed5c8708f4a5d9f844a8741cd6b2f539932d1a34ff b3fbe8f600c1f5a192bea732df2068edf5ffd6d766b2eba55ab7f6e8a8e4de8e 242b451f824ac319d890214a53a0c84ac7b2555ae80a02cb758343a607bfae93 2dcee51f5cf0cdcae0fca85c195a0f1ff1b3d4e468c9bf8d5dd6979b46bfac09 e35f7bf7fbeb114a5d73bc5450a2e24d171d947268a41c4da4ef322f387a20e2 5247a3383b66dbecec8e74af6fb621f5ae3fd77554c3c3f34f0de68a5802706f d727e6a804a5321ceca5df85777121c501e00cfc1beea4455cf94c68ca3beb8b 64a875b077447051c23ede119427c11392bc495a401d0631da8eb3ddc6af5c79 a1f1595cedc5db42062066166a58c45cf7065af7e52d54c26e16fd98c6defa16 91410d274f804c5ad21393f0f1758a43d0003d604e34fcc9ffd545a3d39b35b7 61ae9820c5041ff102e5232cd43fba22d68bdb5bfee2d997ed97f59edfefee53 d32a713c0ae6079b57526da8b355edd35cedd2ea55b9192e6e2bb97f2fe10119 9057bacde18dd4271192956ae16433cffdb67580478f52fb9e4145658f1fca55 8bae0275e1a2f5b71e2c2beb809e5a98d02b22abb8ade1c5356aeaf8587926bb cbb581f34ad405175e6b591d7f0d68272140a303a4044ad386bcd12489cead56 477283eb5796ec76bbdff973d760fb3a25f5a776d2cbb9f9d3a6e2391064dfb2 2096412af720af30473b8db41ee7c88ae13c2954d7078d28d284aa5bc76ae1f5 2086b5fff76bbc94f0df920c81d101e50708d68f0b18f3b2214c84b137126a8d 68b883a806d347d1ab2efb8d975c12725a68dbd162756d50454408fa12390cbc 427a77fa841f3dea30b971fdd3e26d79a6b1378674651569ce263b68e3654d05 27 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 +generate_ring_signature 15e1e8785c6672c8c9bd42e8b0b9dfa73ed16b7312e067bb23380a5662884e13 df79782b5900dfe6d529fffee15fbbc1768ed0a58b535232124ffcc89073fb56 1 5f5eedb18339d1ea19675e00cf95acdcfbfb71c56a86c51c473752b1a6eddf22 d2494b222ddf6a368339062b29abe06a0fffd651ca408844a13e8e9c1483c501 0 b79ffacdbd5cd1a2f0a6c604ca3fbd8843b4923813e0736dbecc35568cdfdc0e1fe24ac519c32b3b72a7b5e4a2fbe2255b06494d868c2db57b6f1cdf4d01660c +generate_ring_signature ca505427f45e3f3327ca3206a0b5da1292e0cd7361f6a625dd9345ea0d03da47 9fd40e7e4bc7f5c892c8000666b514a73ee6603def5babca6b51285c40f27309 2 839e8769b9dd788743f455e74f7253e687cca012d0ddad7cca0e4767e4bc79a5 72e824806950403597e8dd402e2913d458aa49d39982318165e32e5de46044ae 76e8413823935c97bcb8c388d61482247026874a53b8d31daa616b6f244d3c0b 1 d34645ee57a5637c4f9d7bb4bff466e37941b61a29908f59ba8f933215cf5509a8abbb61dbd6a2059e0ae785ecab78e22be66f54503e7f92cb835cd49a24e70a7232f6008cedb6583fd61ee85eb299642d5a7915991d339775a979cbe576aa0942987b0120950b3424981c6db0807881a397b97763f7391629766bcd6204e00a +generate_ring_signature 640933f68d149a459fd5d65fa800ed1bc733ccbecf94b17a8a6678dc6e90e3d0 7b3e6f1907ad536d7bb54b41827c3d9483da8e87b5041faf6cc7fd235237f3a7 199 e1fd6f2f9381f01f62f9027760c178dd9f5716898395fa150bd04f9c1bcd7257 0c32219292a9a10f7902af43cb0b0ac820d2618dd2efd266e36d6f7bf375b546 44bb2452da68ccbad071ceddc6bfaa5a7a0471e67235b5db25ae0c401c848ba7 ef310ce28bfbb3868d079d856042448a1890589fd919796efcf0958a6fcdd49a 6138d4ccf0a22b094bf5f6f4bb25431c73194d4cd455225e9f90e890ecc258f8 6cd95891a2d29e19eb1f2368ca8c5bb0e17765269ebe249c2c9d6e4cfec2e701 518bad14481f59ca818908ca5290b892474cb9da9ae78dcb4684df6758a12fe6 486ef59a6090636d737f22e6f3c6786d600d7dd50084fd5a6802f4d1c14aa8fd 7b7ba8bfca6105c550f82244e8dc88a3d14f2573721cbca36bd2abeb5dda3361 6a8ab23a0f9a41e4f83b815e83295d23f704b0a46bd7787e017fb003111952c6 6e629c6afebae95df966e02ff8ca6589152dc2f1a8d79ea4ec806578a861bfe7 bc0df98eab5b4834f520506a48092bccb07099a8a57ab0d05d73a1b644ce5a9c 1bf49181176e9be00603b8697bd817908ffcaa7f5b6d3483e4a20f86a14ab144 2ee400bd275960a00316ecc4f4d62b0c07c77b5b39c9ba35aa21183e01ce7576 643c7057cf4f13239a05fb4daa429764b6c4812e6b31ff31990182c486537fa8 72c592d097ea1d533270ab38045068d9f8d3de716633a16cedbfa5de6ef1d94e 397c51ac125fa63b5872e6ab21da9a04edb4769975f0eb50fec6022b4163ad79 0ef1c332ec45f12caf7434918b5df896d7ff57dd0c5bfd517a99d1e45279dbd7 b85a252d88a0f3c910836ebbc1917a5fff542a8b6e193fb17de53aa7806a9df2 faa62a1b7452db23c98f0e36f6a9978640636d2a9a0f16713e5f10c09fe3e508 328f24953c88403511a3544cda71c6011fe7dfb9d56d3f24f0ff21368eac61b6 df1d055e26e6a5ef462e906fc0deb64d8b29598bc9bd85b5458082089bc96ddd 6c212c22396b7d5581bd5fb81bbb666ce3a184aec90d58d5e44ba1de5cde5bdb 4ce80f8e5c3097fd18e3bdaf8ba2c9319d2c038fe2133cb567699bf8ba797e32 da98eb0d9f2c7b7f966f5160a318169c9ac34176486af194cfbcb3d72860fde7 4660b2e8c795df61adb43ae7c80fd13d4f3291a55af278dbd315450a0c729656 b2847cd4e5196c29d705c1117de6dd6e517140346ec2331f88fff66555b453f8 74ae53ec473006db85d690d8241a46b390c62b66038ab2cc19fbb9557ac410f7 60b875aa3122e4bf0b8404ea36c488f0dda20ff1b4a4f3a23d13b03e1224456c 781f2e0c5693d7ffe37ea904f72274a969f3ca5362dff6587bd7731e3c8af2a1 2eedc4786cced370cc96010b5be504e587357a9fec120022c6f417874e885aab 57f3046490762d405a2cf33b0e42cc077f962b4762cad12d73acfc7812e53752 95d804b52fdee15815250d2de834ef304b6097fc5492370c2e2377290094ec84 91e241d7a90145bf0320818a46cee8638b8000afcf8a79c4573b9d63f1aa75be e5c1a8968de7e4e022a29419db34f969f0a32cad3262f609633f6fb7078f3836 da909ec5404bc643cdf16d774275fecf796a3f114c333dfe55b5b5f3cb605571 3977d5e358dffea1fb052a1cc7aea970ca6f1d5caba77633c8a019c099fd5c5a f4fc33716b9d5a9aaec8707fdc0ce658cd2f45b389c8d0e5cfe68bd986999389 816a38588fb04069185b53c8e7a152992387822555e6a42678a3aa09ed256b2f 73c235791b37af8bc5d20251695df714e2001301c2c42e6f4f0f6933b68b0b3c 37a1f5ffb8877b39e7f07c497b079918e528943284a86ce6ae4bbf92111c63ab 81127e3f9e51799349ca316fbbfc66b9615b81e34c1da957a2523cbede998e5f d022b7db7aab2fa830ca163e9db126143615a14d00784d029c1ee583b95d4ffa 518e4d4eb6c823e6ab52675ec57090510eb1cc5171e21ad531e97c1ebd9c84f4 bf18ff3b5f363af34722d8703b4ab8f6c20a5a5c00e70b29b4a0e2011248d830 09dd17995fba7f2bfcaa29dfefc5670acb38139f95c015604150699ede968e11 a10518e114803f176d8cac931c689a5b9aed0719fed4f3cf724121f2396e2bf2 840cb0975d20cf39161e599dffafd50389930787e3c9f9d5422818074490d30c e079333d9d7a6e99f86881d2383aa810fd16b12bea9762f98a3420f14fdddcc2 2d966bd97f8f3942e1943ece7b23d8125c4ba8899ce0f9f46784a2d1b38e4d7c d65bafd2b7fa8030414db8d167121da88d4e623e43aaf7aafed24ee837069785 672b6a10e067b982811c24a5e83cc2d70e92d45c2de5b499f906a8a9d695bb6d 508d519efbc059adc7eefe047c8eda930330c27d83fad61c2a41b502f07d4e64 239b57469cf421c31e765b9891a5d1a42251bc9e62c5dd55be426c500f5d7e41 bdf54bdc32858ebd44760b9afb27ec803fc6ccce43f5cb72290456c31a120312 4b42e3bf898e45da9dc4c59408e1f5aaf40bf11b8a4d09ccc66b4d626784fa04 0ac47f6b42bda3688fb69a48aa126d607e26ac91a443b2d6fc7669bc52a8dc2f 940f30149014968e9cc01fec132785bb6990f01ac0b7bc1ac97b3b5eb6256183 f81895b0ba67d9850828ccba479bec869c188f2c2d254b5612d627ef719a88a7 854708c1da30f9f98cb05ca5b8b8573321d4f729a7344921a9f376bef75c9e51 8e34b500038eae8d855ed7b80b3a81c05d6664958cda88e2518bc9e7eddce863 48fb26a2d6987b3b5dab2991b90e8a149dac0dc5021b198d2dac0a5900adef51 ff8ffee9e4ce4056d5bcefd56d6b06b481b72f96430ae41fe3320e165d122d7a 0f35e5b2d3736b6a9be73a6403c6ba0f98a938cb6e06be3f700bacf83e2540b3 07334dca089b23c1d1cd601e69b5d64c1af0347861f3754274d9b556ac9aacd0 e02f32c3a031698d5b6eb871798306b9f1f083947ef081e37e7f58226b6d09b8 6a0ce596efab1e09e24f83c816a2910c0f18d054a914fa059c41b1ea4c78f6b2 57f619f188c0a869d043f4c41cf43236c8e1ce80f12b6168233a6f452b667392 417484f00663dcaffd323823225e1cd0cf76ad7df724db16cce584492173e15e ea96e9c65d7759c4a0a9be30e0ad102f4dd0f47ab4dc75af9a8fcac816528d5c c01db326db562a48369f862a6057bf152e12154b9b71233f0b21b80462f56ef1 32050cf1fe635c0df1b584a947d370f1274e290fffc192dcd6126203518e47ce e6f2f9c2565ed7a334c0ca91efe58820010aa1ec1241e1b8827b23935f6895cb bc851af7e8ee6501beb8b4d03a7f0062442d6033ba37d5ac2f25144f7d01aa45 59cf88f92e93c57c35d98a382be18f17c24df3d41d8c8db2a91e6d5ebbb42e12 31f592ae1cae0de2e4f399339798f72f287afe968e9bc56aabc323a9ca0dd278 8ee9c8c5b1d3f378199fc47099e415fcd802651e208afece1284d94b5f45ce3d 508b5b43b6344dcd99d4c13df8d80f02055f094ff3e9d7f6db3447e01bc441a4 74872c9591414526444e50e95e0006a77b98c41b70c56a647772160c77603d7e 21302e5c387885ce1359e32b0988d0c3c0b645002d361994ee2031a1c9c06834 9bdf64b862161a2556140305b68339c517f6f54a247f96f238d45e1834596414 1693c3cd7e03df5737e6f206435972fa8c100d68e5d55b1efc6f26ae85e16942 1aa6e0e8cc7840effa32f20a21c92b48cf8a676f69e3465cd1594dbe800e798d 97598a6b0042768ffcd605725132c323250013d9ffdd4cbc46c71995803fd6a9 be9c2ff2e3b3e788f89547a687a2d8990d51c1cc70be9715840030715f14bb6c ad23094b33c609916ca52ccb48bfc68cfceb423ed2c230b4230d34409b1701ee 98a4bed71cc89baf62675cf7a8617177d6ce4f7c62014274ca9a574e974e7a26 c71c798ea3ec9ebf1f59b949e539a67aee11b8def522f6ed695f433b71b159f1 b298b7f06fe863b3ae360a12e6cca2d5ad1d105ae139fc01325be21f78d1aa70 57932261b773012ce60c5e26bd7a2a87fd66d47f0cc3b94437fea1cbe0b4145f ff35cb6db2c5ebdd155010503ff566ed6d1f5b1c9a36626ade48d76254250d3e dce0046a37851c5026c7a4ed303d870e9766d84a9e6d4e5976dcdcd60f34d4bc 6d37a87c1f685b27af20795e89487f790697b5c99b97dd0a19ef0711a1ac3733 f7266a5cf5b3f7ef28fb4e2428c5547c670a056b110bcb9188ac0a4452e39c25 a2b19116391e6ec0526b4af1f0fb04508fcd4306c91c7124196162424f6191cf cb1cb1c1dca53fa0e7b104127ab69699cc55aa750a9474b9517fb375faee3862 797b0ca02fed4c418405d88223eb001882e2665c0e631dea72205db3249a9903 104956bad09c091477f9906ed41f63490a62fe6e81898b8bc7d2044c02e7a620 74773d104bc903adb07c4e8bad78bbcdb44b5eea9bb052aff7ff96daa8f97365 8787c10d273fc7c43d5b055cbb631cd6fa24068ae2ba576049e029a174527222 6b13581a144e59149e402649568811cfe67d363c2466a272c2503861219156d2 61eb9b1780fc73fab757095aa7731b0a5da2c813cc36d1e607363a37fef27d0d 7672f3451e80b4fdbb01dc2efc655ac562defd71fe7e9c785f8e2d43b7ca09a8 2402e629ec86218046a59177c682f07d298a2327e203b9ba29aa3a7cda2a905f 2862572827a76baea9b113cd3057dae5021169ffaed7353a8e8a150d99914941 95eeb5f30313df74b524624cb8ca9397c97814698fd503eb80a915325d4bfd65 02d6feb3e2e024540b00f37b5b2198d2ff05d1398e1d1c1f3b73399befa20a15 5b52a566cbf14cd15d44df91d26109ffd242010a5bba7692d8b4e180e79aacf3 a713f0c2e91fb5e99e2974efa91de6fc0609c64a0e0cd2bf849cc0ee7fa3fd36 73ba4abac7c1325dd63f832e34dee41d4189d90e64f775f904bcce4bb3db793c 0a7857cd3c77a4c8449abea91b3d424fc8f7b1a39417efdf5f1b85827e65621c 0bf93c473af049f8496ccef2672503d3c75092f1dafcb7da8a60b7c6bbb1386a 5487792ffa3566c4c3c551abda71b6d5b461add6fd81c2db459017af4d3686c1 38bda5d44463d0841416199cd4c7b5a924b1965a77ece07a069763893a9cb75d cdd3fdaa97260218c247273eb293d4e90e4b0a0a2bfa1f72302fb98e1249fbf4 cddd8cb104fed1e429b08285ae0b471d5d0bf74fd1606887171f7176bc9e1253 eb84cafe4857855499e373ef983a2143e1b1d6155e94a3407e2e85f164ba421c 46f8579c8618a783fa34d0d6768d7dce4c4460b1ed21a24d4b48117ab148ec3c f8443fb9597919df3d9caba2a9836b1a3076b78675facdb890a574090c94cced d297d85af7014563f80c4f1a0d1886f17af1a43de53b34c449d660e35d08eaf6 1855741e4cb18127641e4d80db0e585c6f3d357eaa5ab9cf134e52f3023bc2cd b3eb8bb92cbbb2248a347b7d439d6e7deba3e11c0f491dc8dda1234d33ff7e59 48eac61ceea14de3a054bd98e687cdb860ac9dad6f3aa5732c1e2b8c2deb8c43 05a7638c5fe710f66a02e55b4cebb837de550a5ce2ebaf2f036b371f366baf47 6781eff113890f0dbe3421870aaf39fff6f64a9773208450e3c6cc5180fc0446 c52ef31914ef680e9940a5d04d6faa9d5a3bde6f30e4392a9614b4586ea11fca de390cf19cc66beb0772ceb5713fc9d06233071045499e7baa08f0aa398ce9ca 50a4b637e93b15704cb72105fc9e0a8c08e02d4bd386421aa42df597cf32cbb0 5e5cf1bede2ca83f83b04c7a3ceb54283e769734431060946b4092a6e3f1043a 90107a3e5bd79cf0c9d14f7c41afad86e1564a2bc87b96b78f64448278dc83d9 5c12fd730cfd26bc35831b953ef6c88ba99c02f2ed682fcdc5a7b45eb2995e4b 6a5534816c314480e918bdc6ace3924ec8b3ab9f7aabac1e46931df705d0d6b3 d33821f1f4480e39146c5d22c5f514d12de2acac4ffa1add24e94d0aef01e3b5 0ccfdf97d8f4d1c3bbc405a6c0a05cb10c84e68a9e828e91bc95613184285887 d8a28eda02b6054603560444fb09c586c851f6d7dc9cdbd62b627f04ffb1d125 91d7a87a8f597ccdb99c8a1fe05cc9c025aa267c63a8512f4ad9ede0f598817f 095efc60133065f2367438149bb8fe64be7a8e2ee6f0b6d66e7c1d44546863d3 096b3016663a9ba25eae4b5420d5dfd2752753526b5e300e6632a52f581246ff ce0f9ef751a001b0ea6c95c8f93f6065bf242b4ae69d8f0300243e223023235d ce21a3b1d7cc54cbee8c3b2042e2251d2476cd0e2f73119ecbee806492eab3dd 93976f4fe773f35761b0a3d56b5f260358c7b04960d6b01342c13319e11c1ffa 09c8b32547300288d6e9c3ecaeaba6dd15c7fa037a565b201c961f7aee9ef1c1 decb1e86aa6a956e687aeccc633c688d76fa9d76ca8d7b99961b1591b4c3acec 530080918050c0f671d21b63e4cce47b639790caf570a32c88700998b61f77d0 1cfe24c75253c93e025d78117ce0c2a1571e2e89e1687a28220c222b4582718c c4ff26336a238471bef959ffa39222ca67bb4eceaff89a104dbf99671b92d7d2 5a306e5353c2f33d596fe151c616ed716d9bfd68237038714b53dbeee2185f0d 7c0699c7e93eef0f2cbdec06332b23fd9804512d7b9a709790cad1291ee62329 07b843fbe8bb4882fd4bab8c042dc86a597985fe6c031bbaaf14a1ea7b1d2a8f ddcf47a01055394119fbfc49ba1dbe50eaa73f3cf19cf8b60a96326333bd13b9 6884f9ea3a3c4684547f6f8613d1087ce35d5b14dac078dcb27d63a5c3a7c626 c965f6b81f78472b1730b1444d9ec15c9fb6b54918b7b3f4993ea21c9610bd34 bc587636da4ec349e715ef7cedf3ede92d7a3cb0905b2dd35046f01dd12ffa6e 901f65b107e0217ce7569b32cf50ad1cfb72834ab06803f5b53db3464c6f05dc 51d7b3ee2af84871f009a8caddb325823200ae4462e88f3bc9c94b9bff00459d d85bf76e475ef81747d3eda905cce4fa6e876605e102b9b2e8f72cda9153c8b1 9d9a63453c0525302a0d2e7737449abd52163c08f24c1e37f15a527d6be68c95 b6e86edd5fb169911f22137f1111a253fe2bf493cfc989dda1f9a880f3d5ef9f 7d072839af8950bbaf6313a4cadc4a04f152f16ba3e84ca932d1445f9a34afc2 177f7508e693dd881969727b67446fa7eb9a47c26e826d43bd3a6e0ab5834bf2 901823191b933476f034f77d166cc5bda91b0c41daa76c781bf098e13983885b 922f40a9eab5b333199265429c4fcf25f459e09ebdc63d5e077bf733dc7412f2 319fa49be35d561499b802e63d8e2c61849b7639c623785266bf3d6dad7e3b18 07cc2c6e39549e7f76fdd89aa4a9becd09d31822781a94839007720107462159 dee6471f5a489e8ebe6ccc9b1e2b16a2f6d7df7919372b2115498781ff90efb6 29ec1cedd8d6ef03d011b35c17debfb9d4b202d964164928daafc80c66c0de08 9fa044d016d3ae76f4479d8831f4005efcc6daafcc78b0bb8cc8b65f63c8e9a5 768c5cc4a18fea67f416195fe7e1af269ad1829cb8861e19afa6384239e6894e 914752c736372d835b803db11dcd48156a4123895095f124b39279da0dd5236f cbeee34f7cef744beee1fda22bff75f4423bcf170e5abb20fc7bea38cea001e2 9023bf6f93a11c44043ce93f694351453c492f86feb6b44928d253473652f5a4 124a47bc0b26b26c43f6f23a65fc74d995bbd282e1044f56298b54b599c2cbb5 5c2774eaadbdb04a732dbcf9c23c77c335bdbcf686369e6e8223cb0274253508 f46bdd8fb828d1177c62dba969af55e292901774759d2c79cf8a5f1a57acbb9d f2af226a6a889ddc46eace4b559a7ce081395056ea030e1c0f4547b539c4b0a3 faf7b038e862ac015e8190049ff5cbde4f6b437adff070df511866e804ba4959 827f334cb6e5fbb142890c745e63905e0f0778d2a170369adb64658014ecb0ed 7b43a29455e7bf9bb18c406d8220c9dd42e737967e159697f38fd77174949c27 cb633ae5fd91d1769d88557b5a428183ef703293f5065b578e9fe3ff3b1bdf15 fc811147b7c40d424c287edbebaf6d8e7242d285103d1b6f60487287afb4d848 32ef999686ffbb7655c4aed56d167d2d7292f711448e8847a1a05e55e6424735 86389e37f7bc902081321af80c748af26665076e553bad8bdffae84b5cac4466 39033a1d13f762335650c32db88aa2c19a128014946330e09a0a03ebfb06f604 f47a687b06ac083c8511527bb3dcc57b8483e295ef2f24b3e84280e739f7baac f8451f5f9935a8713f1eccb30d1800915f83e0736b8c71c62cd34720c75dc7b5 227ac01feefc3da4c2e7b452e1cc37b20e7b5f4effe6061ecde47332385355aa ced1f5d61e7b24c1f65297ed6a611d92f233473862ad54d1a7134007ffc35e03 cda1925c58a914d8b11ebc4d2668340bd55565aff5c118f8a707141a4313af09 29932f04e23bf8c4e235571f2ec07cb384da86c855d2e3b45fec4051a6bda5b0 3fe044639d70fc0e5e6757db4e45df0af07385c3a25aa4dc8294a477bf39be08 bd398f48990e8183d93117a6162841d3df3eb78811f8a84e101e5931cbca754a 52b8ec2637c8327591ce0f41a81f77603ca5d508353486a5b380f3c495ac2b2b 2b6fac9a5788ac550314d5ef4a85d855ca12f866dcc8e55f63b7898ee77c1c17 880a74bd63ec12ffbadc16c57915d3098476cdf5b25c4e8cff1de4b35009b7f8 96bb3115b7d40842c7ea3631bfe35184e2d16af4261bd3fba60c2913e4911c9e b3d442f2d897e782bcab66f0a1de170fa5171f588761a3ed7f80a04f59644abf 4da03bce5db4b41ef54d3a5dfb5140fb1794332c20c2cc80e4184549ec38ff68 cd6abefacad45eaa7c9e295c08857910943d9b0e6945ba77199ad93b5668eda3 6eb4e11f2e62cfa6164dc0ae1ada61ebaa6949a07cd88303c633835fa98c1e53 e4705bda82e65f57781a596d1e54871dc587e1a614b77eab59911c1721d0090d 34 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 +generate_ring_signature 7864676e28d3c4970b0debb0e6f97ea408580a98d226dafee3dd81f5a3487cc4 40d7c9c8b56934e5a5d9a07621a15fb22374327fec4fe966bb846f06dfb62cc6 1 494838f14fcf86139012741ad7732de1d344dec1773830005b3602c49e363c25 39dff26442e1ba3eda6724c73174a46d8fed8eca7523ced7781fe134b2f4400d 0 289cbfce67060bbe8b0a69073250ae29a3b0d5479edc896874a080274378d302ee48d0258546a7cd64ba74f013410c99082177555a4a48be9961661dd99fda0a +generate_ring_signature 2e56246c092a45724cacd88af27591f7b36558138dc9f84551e343f3e5f9795d 79b775c12d319addb422da0e67ba0569d1d04cfd608980caecf219b65feb465d 1 fddbe3aec2ab6a7c85a14e5a631db26aeb656f75311c48450ee02dfa54a7a16f 2de3c5a26614cbfa5cebdcf016c9a87afb79822485174be1ae85544aa2a35003 0 4b64404c3fac63c251150b8efd7507970568c1688b8fad48b107622c934f17080d109d4290855748f31bbab239eb09948d5674b72c8ba235cc22b04609d54309 +generate_ring_signature 7815f1d4b85b2fa3d55770abd44e7d7111f47c5571935d9e5abaee6bee223095 bf1e67b2b20d957c19b829881f3654396a78adbcb44e985f7aafc4f5efe39231 61 d3399fe1944fc161ed48c41e5199c0d1543e1983de4cfd5d2c410f45311b9f00 e2166c3a7f15b793bd2403656e289d1689feb65f8e6fa9b7d46a34005b261107 b800cca2346900c2e4a7fffce98677cfc8847b83a5c69915a3ec51862f302555 8f8b9048a0d2f4d0e0de1d8aaf9760766ab3b9e7cc5fa3254ce88f951029b04f dd638dac03e070da9c635e93ae6250be11a35cfe9bcfdbe7df3fc5041b11e63e dd85beb9d51168206681cb9e2d07315dc15c19594df7e2119f073566d80d8d97 31e92e147b4549910056a05d60cb44d95c258ec13b82e57d1348265626c938d1 f6d071a1f002aa6b543a8f3c5749255d8c9e659e1ed46e4800976e953b82bb1f a6b081eb3489da635b97f6cb6878848c085a60d8b567f08b001ae48ee1591649 372ce8f0c084f59732aa7312dd360760dd3019a073c8cae656dfe2fe499004d3 01c7206287219eb32f90879dee2d05f3ea36557f828e4b91ba14d30c6c36273f e8220e44b09d67dd1ff189de878989324d964281b678e238dd5ef329332c1b19 226dc13531650b0de4c419171f4265fb88bf9b645396c39835a627424d3162ec 1eb7fdedfa46a4eb222797815aebb70e1f3c0a1bea9bfa3a5bf999d2c2588684 53f0fe809deee1f45adade3acf4b4514a1d437639c98cc9562951b7e95d28e3a aea6a6fc2cb0b865ebeb9047309270eaa1442c10796f8b2fced7458cfcd0e57e 214b0b9af85917ceac889de8f197bb26c5226a60aae4dcb812395e9830b7b185 59ab7c5277761232bb784b937b97290407dc2e22e0712270c18561322dd25297 5da1f62493bde6c3f398172047c7de1217bd463249a3279193df9b6068d2af55 dad11f986df301dfac98557bdcf96e36efb105e458cc3157494319b9eeb90cbc 6ed23b5f3108a39439aed73fc45b313eff7b198585a0de020ebc72543d4c735c 90936fc627704467602d21b46ac283168dc6a8081d0ba0330e0e08f7d8e9a255 0fd25a20ea3a833592279b5342ba758ed433a3997677e84f36a96bb0ed48c985 48b4d1123003cd14d0a9e7c323d1220824f536deec12a4b887a31a35fef9707d ea8c6a93e31262c5ba1be8c81129da5c5b38f4b60290a43bea72ba8a64bc498b 17b8f47c4b2ad10e21427ce62990cba355a82827add46abd01b0a9c6c2bfdea0 de19153bf9d58038d4f0c6cb613e037b2572c641f4bd71b1447aa4c93ac75438 26b47b7e2b2996a659afd62b05add0068672d724a4dc18a33ccb083bfe30d760 fc8adaf826a43673e332af17c4dcc381d69c5f05f82241202f799ab0c75bb58a c25fb0b991261f8b531bc5ad19e62b1b8055db902c2b1a435823c3e9856ed4e0 c46d960e1541d03db8b945297fb8cfb6febf632a151515ab0579595ab9977695 0411911de3280f44aaee23820e05effb2b3947eaba456a246a29d3c41814f5c7 1531a1532463934f0bc7ef7b30eb947a65f7b6770c55689506176dbf387553f4 f620c8e1ca6b327fd3646bf64dd2c94e9acfa3b4d52a008ccc2d0ad6db5ef896 82a462271505cb720f9f9234ac367fa6608edb83d33c1de3d92bbb3afba19b16 d443003d8fca22d127eb6acf6b26c0e8c4feaee60bbd276e19cdebfa2fe20acf 2b3faa1881c5ddd2d4f4b2d8a15872e4c74c1c6d3bbd54c5d1c2e334857369b6 8fec354ba1f19ded18abd2a28812c09019bad7f4ad07a12fe4c3a0f7e5be1521 ccd228e8336c7edbf92a2faf42c221b890a6c2f5d48ce59cb6858551f93429b5 c36dd157fad2ee13582891fb642397b4ab159de4b55fdc5fdaa6a01dd6763249 6d750ef9905133a6073dd0043fdcd7ef1f0d0e7b68aab2e79321b5f904a9da19 800055a80889361483f078c8be0f37c455919ee300b6fab6e637d31e00433b12 0ad3cb33206d1f80995b7ba6518a7626739c1b4057d5169db2f39e78de3e23a5 8e077ff44226cbee60be2f4d75befbcc46e691cfb60c664c1209e1bbb031f868 1d4fbec878de15c747915bc2942331ae6353e2ea2b1a562fc93b264730dd6c24 5681010b12e8f47019e0308f2952ffbe4daec078a63c6e8452bb95cd2ef6ef09 53f5417119d15c1df61673eb903a9509011c0ed83fb8a6863f8d972bd0f1c6c0 a5479f031a8eb4eae48c0881a6fee4fb3a3cc4e2a2d372594d5ff3277044fb02 c07652126a9845578a02a1512c77ac191d20a8318f1f1756d59d14e9f32f2830 8c8bafe3ce09e7721da3d52ee6d63013650d18c8482e57d501c3fd7ee5b0e9e4 f865858cdbb9fb50898b084136dae15caf9574aac8b712679d4318e9edf7b04d e318fb363e54aef5e7ddc0aa2340c2afdeab63e262688c95dd6efbc7f5a2aa1f 4b01b80161b7bcab306ccff59258d11e994258e9163bf55cc8e652416d817be8 5975d6d8d944547346f31768e953db73941c6bc1a189836012f77b200ed8bdfb f9e4bf1d84793e3702091f8ae0d833c7480e474666b169a0884cb84d6e5f55a1 3b161766200c121ce33a1ace049b0b65e29fdd307e1dcde2afa95a4dcac3750b 9e7861e59e8d3dc063aea6f094eefa2914851e0a96f12332a4dfed98f81e1f7b 363cc8d62506cd8dde52bdd490a3d3de6c3314303166ca2a8baf8e753fb3db0d a1e2e309a4dbecf825cc4dc6cb4a6675c1c4c66bc77cf63c5e19e9554de3e70f 282113e165a5ef3f6327066b407b464d2f23abdcc0a6366bfdbd10b1f65ecd07 7522f8708006f4930053063d182a25bfbeac061d4a499d1aa7687f910a2b6274 879fcaecfc2dd21a62fb8478768194e0efe3a920592237ecfad527bdd042880b 3 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 +generate_ring_signature 4c4e0ad8f2598b7d77a053302d5a6795c381364241b30287731d6c7d063e5253 765d90a45d3bedd3c6ee22b5783e15ae9d418c64dabe2683135027a4e0f0d47f 1 f0aa7e8a8283be703ec37480d9a1e445ce42c58dad7d275752bd8ffaae075f9b ba659efc83361288e75dace789db89084f3970e73518e0e8d03f939eabb5fc0c 0 650cb1656a6956be2c4c344830b48aca0ddad5b9cf76ce77bdd3336b5567e50feb692a01f802285617656b59c622c6102b650bf6a42b230a5a146f2d39a7c108 +generate_ring_signature fa75d79801a1ec122a36862796c333cf133a930d25ba2faa3cfd8401b1ce65ec 64c40ebcf87adc0ce335ff113ed46236769df40a1bfa9dad5ef83d8babae3ffe 1 fa560cabefb92c708a2018c978743b79a348ec2c3908c74c44f619d4a437c2e5 c6f86b60576c5b4f0f03bc9fa8a52482cbdb490b0eb9d99b79e319609fd10c02 0 16d8fc3977456528256772969744b0bcbe92fccf8323a1b7a1d197df85ff3a0f5f7e26380aa76f25f40d53204f847f7939f02144c7fdd30ef807502d7c154205 +generate_ring_signature 7c3fb9bb3ee4c42954cafd7b2b7e8cdc0bc46262e1c01911002435bdbbeaa392 bda43de0bab94f0f16ba11829801217e25b467af70657b746544a48667d928a7 196 3d7deb9d2aeb577cf0188c2f8e3226415e5c4f641e83da62745d8f20120a2c46 4f74fe1cb3af7a94a70f3c562eb98142765e1dfef4baf9f38bd368b922515c10 ba66623e0a2b563d871badd3c5dc6a1492d92839cd3aa5d2c0eb5f70c5f79581 71b8b0d917a73fe39ee5f2f3113a90b9b26abd07f56239ea5b326544359b19d3 eefaa73d07640c1019bd2f642cd443e98832f82d7890c49a2ea7d01abeb71455 f9d84b3c3389860cfd7499393b13ddb2d1d47ec3c782fccaebdf892d7341fa19 1b0bdd06f4dab389ea44e9d7d1005d501af618687d00940c2443b84e40e72136 3e1f0672ef333d52cab1cccdc601f87d010c82611598eea47c8b445823f5d489 a8aaf0ef9003a56517acab915650d7dbbdd51e702c2ee3d84f3e62fe0d8c86a8 eedd4498a0d2c6810091b0dcba02ab3e34e8dd4a4efcf2dff9ab5d91056181a9 d020f2842103fb4d38bc130cd14439b4a4957fcc666dfb3f8e9cea602d0648ba b2dd26957db1ee390466b7ff7b84cb95d8989a0aeaa0ddce683b254390d6a6cc 4b72466a6f2eb480af8715b9a37cde092b5beaa597f4e6e00746ad6d2d05b398 f921877891f56881d08de5ac9c2981c54e6c1d0ae2b16c7cd1a677b198864ccc 41f35918409892706539e055bb30aa7f2fa282f432e13fe769af5b0f636cd69b a2b4d259f5bcc195075eca1ff07997b0377cf25d771716bd4560238839867e8e bb4fc78175626e852e68fef83df8968ca5f5c4f81e1e6112ed6451b9d5f5bd7c 4edfcc81529f6e8888764bc5e41a1fede7049dd960f5a5d197f229a5bd1e707d 58e5461abca133964190a634685bd0e149628bb202ca0d5445c7a852765ae82d 0fed57463cca6186faf243735eb3ee19296afe91474c492f5489f8ca8a9028c3 7274df448dc3ec321473fd02de58ae70c0e27cb95f0720826d7853fdbdee48a9 add935fdef42a91396a34e19659a13fff9ee76b437d4084594e7575a3de21b4e 993ebeda5d18e86f53235876c9af7e6d10f3fb65068da9bf3afbb1abb464f52f 1099ba8fd7f7cc772abe480fa5f216bfe48f46e6340736f452f5e59b10182349 1c5a734cab5a13536221c7f83bebccdcf2660425b358a30a13d49b8a2c832cf3 c0d64b092dc9db3810f59e3fb8feec10188f38d31e227adf80496f775becd04f 755a97fd034508b8bc2702ba1250f5d71ce48e86c7e351e86790d2ef1ff825d9 e47db52ba46c257338824e3adf22706fa2445fe44805d4bb94b5e0ad8c47df7d 6b2ac3928ca6dc8ef22afaa034f66fff380bafa2674a4cf490960fc8b560dd9f 9c1aeea7d25156d1a58b0252704b71b3db0228f17c4cf95ea71b2b076a8b210d 74215b03d16e45d3b251a4c6367b54f8ae438f6965167fe5ec3bb645a5885bc2 013aea76e7a4f7c15338d048a54626c8fed0bd291661963e1f3567923b1eb93f 97c048ef8421b828ac7c75253c51ccd77e427a6ca6390d554abe773a947e24f1 a28841ac91711236b0e4e6f12fd88bbfdc09e269a6e26d7aaed06c3702efcfa0 e0b8ac3c9851b8aeba1edf45b2fcacc18d7834757c4df91b1e14b102b215982f cfa5948f6bb9b6e5678f5fe5c45d266c7c9fee864289ca3dfa79ce248f0c0b79 db95bdfd0f2429c78c806dd772fb934c3acad4fb5f7393e25b521afeb6a35c38 6200b0a613b936303102722aabeb1212b78f6af51735a3f0d96bd76058ce0267 79e29d799a6afaf916f0b5ce30feeb0eae2c9952c1ae4d7708a24067169b4ad5 20ff221440a6bb518535f42abdb4d5df26b3297a92b74eabe8d660510d103919 5fd147c22101ad4fbe7fbcd32931d55b13c55cbad3db68a1ab3f6996ea25d03e 01f4dac1ecd9e01bf1320587ec8674b88d34205ca51ba8483ecdd27b07f7ce02 73227647ce4ebde477e0cd99631d977fa049e3f0d016df930d38794d45ce7c32 829d500cb72ccce0680b7445877d1b1ad89f9d643f7429aa103a655670501f43 3f3f0ada3115f1dcf6079c0867c0c9e3c9ecd63c5d02920b12581cd67bf4251c 9c0a5f030055125abf6ef7631709f06c386af32ba9bc659647f6f6b349588245 56ef91cc69961d6b417ac27d82ab9a7c1b56fe8ed7935e6802487153eb8bba15 6943def5c2ada8d0d78fd8da01a138c16737992bae209444f4b02d5b96f3ac2c 3517f0a7f5203714e1b2da2723af527b99acddc6b48733b6cf23d0cfb6a4afdf fbec53b91419e5f4c1e9ea47c499808c27055492101ce15c85592dfc9f87fbbb ab7a6bc753aad0d5485f332d260f351b75115bcdeb32d1b0a1fd0d8421ee9ebb 6d24d7851f0cf26a3ee3d3c29f8e69f4546c90d9cbd3402fae623e07d69b022d 1ec91aa4a3898b66a1ca297e32940ef75bf5695d62408b11e46b831b25617f09 78b9628ae4e16b74d36ededb48245ffc70fb823ea0e2b7effffc34d4dfb8d308 e9980856b66d6e29bacc3272d8d94ebd638117ccbddce2f8357dd45ca32934c4 3263b10bce76a36c53c3ff5cb9d439c549c7de8d9e3e28cc29ed094ea304ba73 7d15f57f8ba68ad9c179b94a752888ca27480d439b13bf7b22e0f09c30890c29 76806ce6f9f66d86d585658d049c90b7a55d55035e7b9f426f2afa2c295fb6d3 da9630706b7b980a5e17e988ae2ff5dcdd0928d3baa3b736ff8fbcbf5e6acb4b f8da823972eefbcc84a68d34ec0cb69538491d96d8b9a1ad25ccd89bca2eb227 2649b2831326133828b22a7ae2dd1c2d794bc80fc92fb219bd038e20b4087aa1 41dbeab376c0cb3badd9ef47886d8e91a16bd176babd5c93d4222eee59583951 507d4bf45b583eecd177a2d7de1d303e908a9e7b326ee66c384074a19d0e8986 c4327912595750e1b4c774dab82ff6251392fd3f2901ed495552ab943896afb5 de7c4677a46a08361d3748d31c1df86d6a677a46b2fc52fb18cc8c17e631f9d8 bd154b97db57d73e1489e4aece2e891cc90689461a32ece0adc0252f2ea8cd0d f85947ac2d27b169e3f8668cb5d309c93474e2b4e39d303ef00cd22bfb516488 ce68cca1c16786b5f84d2d1b6be185c50bb7e06b6587fd12e88aa0ad55aef1c8 fbc677f0efe1e33b870182a6c970805dbd587f7341577ffaa2ee0c20e73e2b19 062ffbb81d55a0599d07c2e7cbafe69b85f1562731b7b6ff29aef4910c83f8e2 516bbc709109e873a712e6ee502612fd247531d24de032f46d104c6968887c99 147992743e4b8c1e638e6c84d6b426544cc49051f098366837217ec6839b2832 283508f305a819032db1b7d8e5ce5f6e9c7591fe555558d5e18c1d8308acc36f cf7ef848184c876862e4414cd556f787f880025486a4932ed1428ea22ea83e5b 688407f0f2c3c3e1d46c2481b4507245be9e897b6e6bf2f71ec42ff60cac5233 eb82880ae90623b8601b37b8f7f1cec0cf463aaa4c7041de35da6bb1e8dc3383 be18599f4111c5d903acb9dfb4c435768a3003f1ad1428472263292dfede4e14 036c74f81ef0d9812c60b77d4d996fa358d1059b806a17686115cb91fcb891a7 56c13bdcb883d9ba092af5ffab17ace1bfbb6a020c562e12cb02c8ac4aa56d78 c0e519110a5cff1bd58e27124f7c2ada7c4e337bb8c6df93c71ae1e01c862bf9 58596e856040f9da1b9996da7ecc4eb82201b92d45c7fd70f7a365b95bb58b1f 58c0e7620d52079f74559b40e84bd5206ff697e8a96a236017d646daff386596 7d9971daa6d9b033d5fb18153c941f468874eed0db6c31597e7339d0a6abb824 1266519036a3cb221de554081a56e9b6ab0da26dca30dd1cda0a08b8f3ae2e53 7ba8112ca27bf3efe3fe5d6f839dd7c60c904013e0c299fca13447cdf4046a17 23ccdadf7fb569338fe0880f84c81c843d32fc8e51d53d0e6cc06288441c12f9 89ca3b7d4bcbc5d983a9210c8e25a5e9ba55ccb51399dc4f87bf766e87a803db 8e1df71b815b60d01596821f77f20e8ba714e13680e4bb57c3650110994106f5 56b73066872d8a4b86f780e8d9833dfa56419e278da45ba5e2db20bffeb66577 2a47099d3dcf25018cfce34ceafe9d87438ee4186c41490fd403e6e42b5c2d3f c7a3399f0fa1dbbd9976ecc6b4f939c860b4af7115a14bbda763632b1427ffd4 9e95ec90e3f86a6ba34930bbba2f93439766b2c1aa20d6b372f53aa785ac6503 77790eee24121080bd6cd771633b58fea9554710b771021f74d7438a99bd783a 53a887bb398735352c8b991478de995167951f2a985275f2c38102937bfbae4c 1bca9a852dc22ba46db7b0bb5793346a905a6e45bf2a7373dbf8960b5b42594e f03ce64633d857f3d0f4b267c6ed14e3a82664338b26159ff25dee6ca784ebc6 7d8524ed9d52118efce4fadef93e0a0bc66011bbc9877e66c9649ecb16aedcb3 cf65cab677b16ce2e76b2e675de6f2b324c6cc4ea82fd3d9ef646876ffc59185 d84478e2ff8128c73b3afcef77cc2f1d9f08a49ff3f0587a3a6d473f55e0eb53 f59c7d8fa9eb320ed90a86c92a02ebdc016390dca8c9722170dd5198cd1e9579 f0b0ede5391b6c9c584a61db76a0cec84cb1640472365fd278f6cd5da4946921 07cd121ae416d38443e3f9ec281774098c4779d712b0b7a85d31721c41a7044b 6f33a40ba6f6c8fe17c1f387b2a15a440afc0b262628c8c189ec936c7ccce868 93d3c1f4187815f7afb9bfb316594bbb7bd194dabec5fb906b83fc2153b4e02a c0514cde62fbd830f585c13491d6567b0e287b3b4a7ee7b7816b1e91a34637de 175954ea8c7a717813d62813e3af15ccd10935e95aebcc4ac60473f3d24de202 7f3f6c6efbc30d15995a2e1ad3d5baf1685f65463d19b98d14d7c22edcd33cee 8da94cd37f45d0993b6f37761dfdbe699fb00446e37766f1a8d2fbed8919aa26 ca869ef84d9196b289c84b0a0f90281d787a4505157eaa91f4f1f6b9e7443a5e 2eda08be6e1d26b9d6bad8360c5f30c2f47af50e07b647d69e0cb6991fa37898 d3ddc6aaa0883e6c155f2118c5e2501ef8d182593518889792e50b1403a04246 944b3af2047b28c5bf51427b1c29242cf2a2a3f6882c6fc7060086bb72ce26e3 44579a1b2fb42179b9e10e232c9d11e1cba5e6268e3e27e22fb292c75b550732 6713824a19a140834e3181023eeea4d9090d4c0ef7938ca5ac760798807149e3 d99e86bba4142a398a2dc7852aeaea64d710e086b241fba4fb70ffbbfe4ebab0 241c2ea4ecd5936b02fadb15c2d763aabad2e7531892a1448c5cb1b2e540a928 6cf74d18fb775f01ceb9222574d0d704f7efe797b096dae146c2d7f860d6ae60 2df994259a9e9279a8c08f7f37d1333cfeff7d4c9b00e273ba0bffe67ee91d58 e1f86f218491f4e1297187b600e17dcae2d71362b0aa051bd241981b4b694902 a85a6b762a221ae263dc0f8568b23388879e94454b9b588752e1a16105e4efeb 213b0ee105d7df0ca3e893dde9f50a57d0ff2e91031cacf2cdfc6547c07d189e 9c5879307b9d6957f504d1b2cf3160fc787f747122abdc423526640327ac59a1 ec4fd6c81d070ee743061c36568f2e02cd1e1b75caef5aff94a6143005a49994 2002f3a945a9d21bb9949e8747df9e40c1bca2d793eaf979ddae2c712ee6f85c 3f0eb01b2613ed363e129a4dc8d820fe325c25911d8a480a62159c7c53ec845a a8164cd59ffdbe57cb56c7c049b1e95f3693b0536831c840febbce5a723fc5da 154861f7eb6cc3253cffbfc3bf8e5dbd79171aff9244a205454df5a827bed731 224f573206dbc13fa4621c6b73b036a241ea25619c14628b0d9767743b7c967f 6cdf85e92acd2dfd4399aa1bd45d803ea3d0794c76945e2d80274f53cdca5f88 0d3b885c422d389a29a0928d6b09883f4a309bde6573b495c6f6a268eec2d519 428e5249c0abb96946314d6ae67a91339e8920d2d6df6bd2ab01618a81d353fa d699f8d209ef4bbfbde089705716e162ef404983be581dfe016e0c49a9302029 9eda3826a1477e2c37e40e687959331664ededc5fc4937d03e81da5c0b34ed68 f8fe870c71cb553166802db6027fca173c85ebf0f9537430371b2ed7c3a3764a 622bbdaf0a8dbc4430d89147f9092de7a2637d0c5ca77d1a2269081d85c3dba0 5c372dc15cf0c42e3f359fd4c1a5c2e1a019414a400e0ebd18394b96a40c98dd 91bd292ce4c3c68a5f2579f90b4a8b09b8030e31f7e773ee844c720b079d1e2d b2c171f58346747d6ed7b02fc65873f33b7e08ac8183144fa59ef23f2bfc959e 5cf6a61116fe8d0b9f4804e6fbc07af6ae15207b392c8783e404d5fd293c543e c6646612e88da493c7944943e2e7bc2ec432410e0f43bf7dbe63545a306975b5 ac6f8b9b72dad35d5cc636b93a3b4c3dc77b0e2ddbfe90978be8a66e98e3957d 83171e32bb5e628424811c615deecd0f89377cb0279186374c36d874b5ce2a2d 474871f34e82e8aae1f236fd7ece6b9bb8d9627d12878e64fba94ee0ff917e90 697ac8f1dcbf582bef5162d945b2dc2d1a1969bf59161c5aa4e6ecdddbcc6b75 d0ac304d9ab860d7ad0ca2ba9b3a2c2b47d937051992b547426502dd8cb74fb7 775252729d52b7fbcb724b63ef65d2c14607fcd3f57cd9277a10c95aefcf682b 8e3523b50d6ced51c5a82b2aa13f2d498b504ecbaf220d23665f5c55645faaa9 40460ae2f74bde032b31812d53a373111a7f3551e0360aee6a0a5468324b29bb 2a971e6b6aea6dd849df590900fc1f2f527ef624b7f578ce23a43b7da1766ad8 64228053b65371ae1d0a5b3823c3bdde6ba4e9ab15cf84525efc24ab7810d7f7 673629e04c5f248c138f987e346d6f62aa8b70142768ed8faf516280f1ea6b56 aceea696d75ecf12f55924214699453432418a6ed52b2954dfdf1d6eb66028d4 124b855dc5d1164885ea22ebea5849b513932aa42feea0df88bc146b26062102 2043c7629e30d8554739ea06709d746206c08cd7998b6fe7278022855ec96f8a 114a9e312df49f4650807d8d568da9c868508d970437d843c14f23a5b5c745e0 c6150dab7d30c4a57bbf9f74bddc9775d86d26bb9c51496b5fb0887faf32ad8a 24335733fea5102fb726536a5f8ba5cdf20ff37b4f7640b116dc72952bd617c1 bbe2bb771c7bd5fd1c79eb68e58bf4d49e0c45c00e274bd5876df1049242a729 a3ecdcdf9b4af0bef4676d65a25188742351af5648c9233a76e1c75a24eb7a8d fa75c3f4785cb295c8e4b7cf4f95e9cdd80cbc14a9dd67a1ca7d544afd7ffc17 b02c22ee4e0d7d797a6d7212759fc99de5594b4075454495f786aca12e919678 c81e4d5e4af72bb134385df0131616470a16e312f2e660610045f5d3031884ca de87536fde596ff29d65922de1d67d596238e5a03ac0d4e5251dafda619a838c ad6c7c271779001b676bc498d945e90fbf6ba0db589c5b2d5a2e4a74bd6e8d01 4aec1dbdb3e2c9c272606ee77ecb170e6e64b0c857ef9790d612aec230a8475b 82ff743e813f4ef077ebfd66ec61c32a27afb8978bcdbfa69c8b8988998acec3 5a0af108c17d6deead0149accb66158f8246d4939930b8683bab88c17d30d30b 0f46615ccbf367984b3a89a7648d557ac69848376fc56e77ee796dd124ee47a2 5bf94829a2e3afb01140433a9d57e8a59899db28f19e64aa46ff28f5ef64cec1 3e01bf0f93e546cad6eb526f1249c1899a784808ae940f4d15e0a896191d4e42 86e649034e59402ab71e9e7e577d427d917a4257d65a283f1d7ac023ae559fef 29a914d0f4951aa24e2f0aa63b1f537c2081b11da7799a70258d7651a35c5747 3f0107399325655f8b6b33023796e8e55d75525a31a9e5c256f24cb23fdcadb1 6b052938fcf90cea2e5caea0d9cd4e183990f1efba477314b8ed59faa89bd34a 1c6a32ac2c6d3cc6541da9afedd51357bd81172dea1eb2d03a1264a988f761dc 889927d51a0256466f031595d94b95fdf732708efd504b9d22c6ff54aa3d4c59 c612ac8c54634bb1d7cc614a177c03d4b0bcd024ba4a74a43827af518ee607fb 6bd3a9348b3e2cf91c5e9431dce292fc2c2322d07ca626767479639c654365cd 9deebf112490cc58fe510d7aa8c804657bec78642f236df79317165cf2f206f0 dced935b8c9df181c26a925613e96193d52dd051f2001e74f9b7e6348d9148f0 3f6277b2f63bfbe985ece514161452767ade8331f20c40f3f0d0a1035419d533 4d95e5dcefe000349998e1a3130b7a7357453129503423a0f02683aa941cc0c0 84bf7e3dfac85642c1004cbf84ca5f9efead8b8fb4ca98b779e9e5f5445fbcd3 c3aad5fc72c27162dd18f9fa38b371cfd98b70b885ce7e0c428527ca7d8b7569 c716e52b55b748463b4aa1af2f5e178536b0ffb6bb62807d0a51960ad5cff40d f1bcbedc26b50cc7de6f7ef24a1f98d58564336922df6e6f4a70337e6670c6bd 65323b25016172bd154dd7336dd6beba5ef6f45a8713797a6ee39d0979c746f3 4204c9aae42fb89fedb2270e6e29eea1df504c91a9a50f33bb3cabb506412d56 6113d4806a2e2f16880724d125ec7fffe7c1292ff38cb6c6eb8a8f5af171d781 0f022e7bae4d0615d72527758f20be97b6ad2a574830b1d6f6c754ec4b478a1b 25178ef51a568a7d23ce35b29ab02a618185fc258aabf3ddd01fde845938aa64 f06519e655fa5a6ed6cc80efaad8db30ea29324c7dc983cbfe0f3e931bd5b558 46b4b06ccdb3670d7027499daddb0bf9a1269378856cec1700cee91ecda64497 2399b6d1babe50a8c854a3bec66c0e7cdcc7959b03d8ab9f7963063e3ee7cd25 a7a4f6c54713d2f6305c2800a582092aaca32c34b20aa07d0a968cc1ba45481d ed82f9e92b53a19571b5366ae203f7dcf90f19fa2edc87335726fc22dc09d81e d9787436fda6cd8e5791574b3aaa0283ca7c4a5ede9b2433376ff45160b58a0b 82 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 +generate_ring_signature 6a7c21315ea9a0794f13bcb92ebfe303e1b0713cbd6bfacb529134a6ed01585d c86de54a568c92e9d6a2be843389eea6397c740fb17949b70fb10a9a58842e2f 53 a4eab03193f38a2e0e982a87120a234f90b0bc7944f51cac35a25176fd58b777 d23b91b0325fe014f6e53b9fe832d97042b4aaa25cc5f1247658419c48a8bd49 1bbb20d6fae0893cf5485c19db5e675d999a0e9dba0e0718801dd3f2707793f3 2b515426826b80e919c7b7acf9616b6dd5572e0d5dba19bf9e4da51c00335487 7c9eefaa09435f31121d5e355e4fa554668f4837a61973d30dab74d464cde65b 37a99f9bd561f0192816187d019987c0ce5f147d4c418bc66f1a5cdfa0e883bb 8638bfc48383464f756c3664e864d326bca7855cd4f8741e29c74dba9cf4847a d67f42eaf5b97140183b520d329b27d245e46cd7bd00c2a171ffcf3cd8a0c9e0 4e7fb336b76b0304d312f2d75b8bf75834b7398db6526008a74874e4e56e6aac da1afcb4fc99dbd35c26712046956d72c6ae8500c3f916b34d670e6c9daf89c3 3d982fabf70524a3fbad979afbbcfb2d0bbf8c2aff2305bdec06e5c79d98b47a a5f8ac98cba7822b50a7073a987e71de73ab843465b744a3435b4bd005522a94 08ac7bba764eecbd335e48c24dd1c04c69e0f2b24165b12a408901dc5da87043 6a9232cec3fa118d16cd669e6dab9a8ec07a0141b3d3b5c97619289400168432 cdec045aa9b95db4758e28ef5d3375c539019188ed4994d59d932c5147e7d84c 76b7e24b615b9c211c78a8b212655d2abd2ba6da10ced987e827163c9f8d80c3 48da2559b00cab37fbb05f10ebcacf51650976a020f045d7dc83024afe1b2f6d 4f16a0f0e1da96f7b885a88f5d203502d5bd717ec8b5836707b2da85accb05c1 80d6ff504ab0531ce476105fc6c6ab4cd39e75f9ba0bd781b7f6e9ff483f71dd a063b2575fc0ed77466d817dadeb051e1264af664b3baf2fab0b3bf3c7b5cbec 69d8a67beb3f99a7844a980df676962f97b9971a1b084a5220bd830cf279e181 33acd6c839c0c7f438189e1f67a8313be209413fbc7b0b39d1265a6d757f879f 97d4d0006c8c7deb27813cb1235e7c914a20da278801c2f3697b462071114276 f006a40b43795409e5c5254e5486c9522ee2fd1a338ed26e9b40ec4e1c29cd52 eb6c0ccb68a8bcf2c2f322652f6e0635d46e214f0bc0961e6ee431d9a6e70e6d 10a6835fabd12b737505f67c3194489ad1f67e2f75982d50c5eccfac7661c050 2743f8484a17f4b8ab423d9a06e648638f50037a20b453f91da821bb8dd98737 ef6cbc0d2dfe502227ce198c737f0bf0f7a4931444bb8ddbbd82cc317449dade 574b33bf68724f9217faccbc97a60e2e6a7497582224aabd262dadf54a73453b 1996d428c975b3ebc9504f329e76d724f2716fd2d6b09436f0241d55525dfcf4 4aa00e19bbb3aa17adead7dc76b7c018a9afc20b424fd11b53514193ebb48568 346d12690e9ec83837d4f402b0fccf731d999b38cc66fa1bb8be1e46398b04d5 a819b6df989fdff76ab04fdd6cdcadfa2751c54e14c359b6dc63f285bb545ae6 8cae8ebd0995b16248b6f1e3c7c61d9f0de44b582ba27f155e1f315b81c0af60 0e6ab1fadc1ce2f6473481649a3a500a86e4aa00a042d0257506022a7abd0965 e2adb81732a12b14a36d92d5ac877c7eb23b4d365a31f6340ee0e85e3044cd83 557afb592dc585c70ad082f601b97ea5d53acc1e8c1cf2acbf73cb2e4ec8ed20 6e2edee22b8a26501186cf35808472bd9c5343c3763d921322398abd5b524e4b 321503c0c52728139ef0c745f510897978d1805ec1366245f14c12472c8f7926 1e94842bf9529a263ac929ac90835961315297f2d01d83fe9212cd0c5d86f662 f278b17bbe1236d3066be0bd4befb0e914a524f85bc146c117e05db1abc54126 d62acf5d9572433e91cfff5d9d319723e0d49dab4a3ff4a7a2c27597ef4171f9 1cb00476f95508a5c4b27c7de7ae82386bfed926cb335dc6bc934b21460abd7f 32855938be63eaf809c44abd425f69aa8699cbf7f8ddb2a94817692574f85b31 6d16cd460eef86fdd3a4ca2642866ce01e7f09d9c7e3158ab61fb4fe7b1f1866 1382892cc72eaad23a9d62e3dcddc3c8e093177fd99076db600ecfed64b60977 d7757e0cabd39e25dbe09943b20145c8ebe5710004c53ef8355b9e72027f6cca dbcccfcb3708dc00901fda1044bba7d6528a966dbbd4c7fdaad104817a37428d 42296a58204e10349dc6b9e58625ed27b7a0fc30d56f275e5c492c78faf3005c f40a1bd0bf96be276a9a65ce584aa7be335b762ac9adef807c31630587ec85f6 4e4e6efaa2112f4a9f3e2baadd787b09546ae6090f39bb2c2c701ea2bdd8a36c f74d02271c39444a3d2742e7e4015fe3f3a7f3abd96e4c04d719ab0324352638 1f89028e20b6bbd28eb46ce5a94886c0fd79ed9142147991750b7ea512c03be5 fdfa920e8a966735aa26527da416a60a777c4e9977d85417cadbf32400d27204 12 c01d6cb418427af7afbb792ca644ce9336ce7ac9c4dea4ad525fd431f6ac1a0e0113d2842ecd445c64732e197f34fe02cf5d0ac0cee9d6daf61afebf9e9f9507310e99cce3b30e0794615d60650e38327559e0f0139605638b763e3af85e1e05414bbed64c828745396aed05e5b93dd677f28533d3c1cc6d6c8be3e65fd1c3070a3fba978c2d59228db763f6fac16d48d3595f558240504d0388a45b9246260e8a8aba6a4f1947bc8182d80de663c963d8327eb994d2f7624ed3822d5be02b0a430e2ad697f48adfde90d8d5479bdabb5c90fa822ff795dbbb3ba622c6824c002c2204522c94f051c86c6cbb7da443e17e6d04e4337119536df847431c036d0ce7a2f9a1589fdea991f81aef7775593ca0add81c742b86459ec10eac3b745a05a23c6459c51f742c9da61b1d749fca0e1a9b470a9ce2b935afb1ef6eddf1ec062ae7fa3ef5ea5d8764e71351832cb2dff6b0309a0ff2891f02bc679b5db4d00d9188a02d131b2e254290668ad6675773b6d871664cbcb00d3384b3c62addc80c40f6f12116e3b3e84fb7ab4734bc5b9e09b64fb0c32b4a14315916c4e8b12600fb762eb6f2f19a068b2671a2cc968a4b24e161057f587bf24ae8ab1f2a4f39072c615bed124c101791679d5612186fddd858086ad9fafda3debdd230910fdc06f89cf810d85c410b6324c8a629740204925451ee69cc81f786584d3c79bede03c0790bb97e8073aa201162b0de9cc455b95c5c0cca7172331008ae60020ea50c0349b999d930e78cbbcafd0657f57cef724b7de63e70459e4921ffe76678040d92ea7e0d1817eee31d2de0b67d3c204fe36bc9dd61cc0a1071fff0ce798d77077e464e4d035e8fa5882738514f6c87d70f6ff23da373c648b5bee37d773fd30cef270ad09ccaa28be0b59d26d582771cbb5f882b6984ea43694e326157642f09e7fdf0fadd20b1d61036b2f107fe9422cfc8eae53a3570c44f8b330671002903cf6865ce3a8f024dfe7f54a1899cda525102b1de333df7aa9b35884a922e0a01dd7954c0bd55ddafc88cff982caeddb497c4f2d3dd5e366a6dad8c0d5984ff0eda628268fa150b00bff73a7fdea43ebf1f538ea7f0440aab77e2713ca8497e092f179ad3269f34b64f09c5ef8254dffc52a7aa74b2542c17c55dea4cc6f8e90e722151ba3a01d87aa07965dc2001e4f295f157e789d419c4886b1edb4c5ce50ef3f945adfbe7f3fd79d8f74211e54ad81bd454234b22ea6897f42d8a71a40108b2374a6efc028e50205df6fff4da404325c405634db665c4929b9e0f494a1306f2f715e84b97930a122d9efddfeab90b1fc40bfce7a0780d275c518a05dc0902ef96462e4b42c077b4aaadcd9355046db9a6c167d498f83712eeefed6319520e0f58e4d294e0e5622f2976c0f6d5e16d2ec459aa79dd471ae50cb27cd0901f0880ece376a18904364a24e81434987de9bc6dc1fabf9d1036fc8a2bebf59aff02cfb6aa21723405672174a1f79b4d92f1b38d603ab693e9224e25aec51bf26803c2468916dfb2e2c1a0dd5f8a9aec9ac6d0aa489f75f5963fa4506f914fc8800b36028bcc74303c8c11b349dc226ec2d744c4463daaa4d584320e15cfae83210147cf23fcb2f60280cc39a925d6b6bd26c8fd35be3c67a74761e183fac274aa0a39390ffef2a28ba4f9c2f27fc8eff5a1eb54f190b5aac51e94f58a82673901036f0ab01d187e4ddbabd9f2c52aa5739cecc097441a31e554debfc76da0d68400e2b130db60720102893afedf7213399e3d7286819b35f0bf962dea2c68794100bb4ec91f5b8d97bfecb2e2069d97ef6e0298889f14f128ae4ea90df45c2c060ea136b8def05336f47b436833e8b7332dd265f8a28bbd3c668720e6776e61340fe992c3440dc79da73362ec6fff8ec929db6bac08aab2555d36a30b2143496506787ab770bbcafea940f1c5c983bfb2a1fddfdc6a145fd24af10bb15f0f99fa0342f35db2a1847f49c2312cb4281c6e053f437e17b542b5e9839267693a5975033fe38b7779f1d34ac6e963f85d4d168319c47873d317751ec3c597744104c907e762d5ebe2be694416e1c76272c4fc720eb6b5247ffc509f65ed8830cfcf840cfed01f47c32d789da505af45da3bb64d9961aec551073e2e1c9b796c4adc8f04ab77acc1b730352b082334dfe8056e3b8386d0ea417733b747fa43f1f20aa80b5d94b10c83c3d10a82c574f4501cd2d31b95bebac61f9ee98d7a16c5a0706f089210f001c9a830529a44d8af62d394aa7ead10b9674e0a0f9ea7eebd3591ca019b71e0af91a81b2077e4d32bdbf907c39b13aff0196632eca310a20c4dace403dd4a1ad80d97386a5ee8c2b5ce1976ea38e121b1581ff27d7b6a4ef2bff2da0e1416de8a1daa6641d3f7b940751c2b0bc93c3367a3794a5a118d74eec9ab560c466d45b3f5b51f024703d94982c4e425a12d0d811fa171ef5ed37438867fe600d247fc08def60ca1d4e0a096b2908dd99347b4e58c495ac64dbaaa02167c620ba677880772c02da8ee257bf79c683a7101049d5dd894952a98ea0550e34f9a0532972c484f7a9f0379e6461de3719fdddaba2e3892afebf1f755c2d0a077110be04be1cb0d6823d848a140455c142b7eb98649d35fcaa10a764175377b96b102717959814ac071cfe1549100651543e39f4c72855b21f41bcb37916521e8b50d9727cba4330223b16585fc0138db67a2277ef8c182cee0b4afda3fa4af67950ebcf5d7584d45d546c13d07455b9a16dc347504888312aa67d55218c9b8f8a30a18548390de92893fb7d89b3ef0ab95cbd0bedb5fc8a9da03b9785d1578b1d0048ed384c18e7d1e3163d3702ae21f81041ca25c83b000313d557e0e8f57c1bb09a5e9a499056638f46a87edcd2b97131fbad44e39406f83e4964e996a0cef630a94cce99b8f0bd7063712ab23f40d019303485bf63b4f6d8adc54fec4614de2029ecca1fef6dec10256e65d99b9c2d30c84bd16925ac65e8199182c135c757508a8a0025b03a81cf3cfd2575d55e5eb7de974f59d1b87d66434a27661663f3d0009f70b97ae71e9f0b41023e2da6ef1de1d38d7294fe004e3198d8f63057ea40f096d37395154c8494018163039a23b060cb25afc2c385dcd309a82382653a50a42f05add0c18743f412de3a50182dd97cab071deaa2db3cd2f1796c9ab9d1b0bc70c620c7d2f1bab4052c50086d75afd753969155c66ec867463fbb7c12a5106c9e9d36074434e8cff3748712963119648314b33bec178e0494ebfc8152bff0855d1c7f377b6f0f827b4249f56a775fe5ec1cfe898b39ca6e75eb0cba7b52002d97e937fed205e2311e2983c35a97250a5cb0fdff19f261d44b7ebdfabfe600b5fab6abc7f93b79940172048046f20d09a8362168cddc062ab1c57d700afb20dff95aae285c494fd3f7fbdd0787743c9802c59996ba27320d78cbb3517ecb00f8754b3668a456847fdec90f137fce970c76ea2df4cef926f9eed02ac70c6880ed8e67cadd561897d53a0058576d6564e9c8085be6a9172e1f911bfcca39238024ffa59fbaea72840c0784add45bf9c2a8eb4038612552a2447e8e5fecf0cd108b3b62705c5a8be80fa4444589be4faf2e878b1abdc996061990db1a89b485c0c4f73ee2a4ce3c91c1595e423f5c55d6233e0f0d6a1f88f7efc04076fdf97fe0929d649a893004739be54bf5617617eae6808ea1a5a8af0b136a3e8e8771b2200d567067307dbc28e0c71d5e96b7c82a1288ab7c91edbd96eb753dc60082e2d076da509bdc935ad5ba97c4e553fa6c2bfa1e3561663080d482a74a6039290350c098d2b874d1b5366c980627cbbe6a3dc07bcc630363336dec6dfd65f4a9a5c0d559bc99afa62d8522ea2aebda7863a98d6107287c7ea0cf87a50d5cee441f30a1a07aeabb6bfb197fd169cd93e0e8e147cd01a31c5a6eb74ce425e38dd6a2f063112d18d5b8fabcc3fb101230903a52e7ae40de2b3cf4d9eb0c17d3e3098680ce81cd33c356509b8b9e93cfde1c3aac7d24f6f6415ab56f822eb0da7e4bc9f0f1ef32149f5b664fb4a16aeff554d3a15e5f2084720abd5e0b562a1cba24c3a0ea36d8bdd0174f354970c2a53154b8ad404c770c9e8595a4cf6dc87f869c5eb0d56ce145dac923b980336ebfd808361eeec862cd119b85c4702345c4c78e3210ee67e58cb1eeb0a2a9bea6080687d72f2a546c576ee392682bd2d6c236876c30d3645a160c7a8c7416bb3229aaff0b79cfae866e84b70660a42e38d6af85f47046a3a4268a5d7063d1cb14301596ee8d56b4fb73ab5a1174597f2c483dd1d81073ab0a4b26c681fa20886475454e769ad06fa8bae0751d1a45ece79268bac2b0a1cb54bfb1f38cadd93f55eb5e5abe7a4d49fe33f1989618376e81a70c54c3e026eb7948bf45b8e3faf7e086017413d024a8ddc448181579be75f4cc89a87aa05f14c93c79e9b3172f444b47d6020f0b13a68afce3245bf138e336a074a130509bbbcc64b51f0ad467f8e16c10b2966de1ea54442291f044ac68e2a8355f7440ddded1ba83b1816a571129b36d3faef75348c36fdebacddf9799502da63d8410f2dc5e4456f82fb5aab1b11f2756b4593002caba548be71ff41ec73ce9d754f0aefbc1a4753efa967876e854f38dee2c29c84e42ada384898bc13065c4ac98200daecd16e8cc1d2388fbfb5ae0143af42906d9edcda4df0e1e6cac95b29726902ed97d94694a47a56725c5fb188fe93fd8fe3e2884333822df5d34e7a8d040002 +generate_ring_signature a4f99b4aebecdbfa9f6c5fd9d62aaf72bf17ba6b85b2b86f6857d4eb5aa4e2a4 903b964eaedb5d9df0b0b34f0b20d58cabf1279e7254300089735c55779f6d06 2 6312750888bfa7ded17884f70275bf7e07062a1df46e580cac091363ce7030b2 155806e2d34207010d5b4149cff7eb191ccd3d38dd5a1cfd9dcaf19891878dfa 04ffca61416f5b7b5d918e456a81e4f50a9d4bbae583602f8544be5a74c35006 1 bfbaa60c508de15b95f4cdde7ce7c26458daee388d5945558b86a7ca867c680a272ed6496af299cb4b93f6b9c82b3c7beca3795ae311cabea4df69dbc7dde40c74baaf2c10c7c20fa0c15439a7ea90c3abd8c01cea7e93a8afdee69d5f29af07a11665c96886833359fc8f94591e6d34e30024dc3fcf2d339d80743380a5190b +generate_ring_signature bdc62a6efca6c735edea0f7c692ebf61244271d37dcfbd89d538eec558460cef 615390da874162142d31fe5efe83e353bb9a35a06e861b6fa96012afb6606e53 3 f0927d23a105b3550d3aecfa2c3115c5730636fb068080dab5f9e2a91455fad5 c7a262ec1e963a0c885a967fea2e3da4374e2400ba9645db84ea1c785d13d07c 38a3d5ff005353ffd24da4db56e22636e1bd2c0182cf4e08a84cb50af7752351 a31a2f30ef28f312d39d35032878250a53ebf5c77325eba642299bf98b567d01 2 6ee9d0b249b5b94f7ba5386935680ad8e728239d5a9ca1613383aeaf3dd70b0e0dd3c689ca8e739389f34368c86b2c4ad67f3f7dc6ef53bbcb22a9896cff720ac933b923c5d470746620f00cbd9e6178e99e64336211d0595a0a38d9a3c04a0763237916002bd2963bd50ffb5fb46dd2fb04b4032026ea967f0edb11fa77760eba5a42d1bc2cb2a8d13c09e409286f48e10adc629d7811bd76fd2e3fe5c7a60d9f50db398d27d4fad2106c63a5c00693c91c397057815969d04f8c18ab362201 +generate_ring_signature eab1439501745d1a9b34fcaddb7a42e8d09aac0a4070e49c193b7eabe02f3e72 6ce8208563bcd24b2582f5c8686df7670c4046c6639d9948bd844d83c79e6813 1 df7698d71575f97f8c3699da593b61ed18f032140799e2e62c7a14e191ac49f3 004c41b8110c26fb97c3ceee44a7423e7ff0fdb3e7911af60bc4a03f2efd5f04 0 830b019484f33343ea13032817f2d514cc55977ae1125cb5cbeb7abccc7426029d3d734fd40ae517597ec923e5d3d0ff2c7a6710dd64c280950d9f14eb7b0d0a +generate_ring_signature 50d6c84602d35a33a30fd22db0d5cafff513d3947624c0185dbea80caee90c5b f686926e40d3a434315e5f4ec24c8282275b89773f52a4ed817025943ff7f022 25 9a30a185b0624525d23c91ea4f28bb3721a797a790c5cec3a7028bbb8e191027 8f4f792489a3796f4c9ae40b0e7fc91a7de29072db0dc09d3c5890a294d01a8c e12506e001bc9c5bafe5301f3df40bd27a974ae162d1446fcdb268a2406193e9 e250ded73cc3dbf89e920217cfca4c614d4eafb5a40c6e36bddc349a4c686597 b8b0831d43d7e2af8aa0d607b3ac194c33dfdf7d3efe78edf3cf6546011810a0 76423bd48cf42c31fc156e3091f20982c6bdc3db8e792893528279ecf06384c1 b7cc082b2637338f2530bb5340ae7c4fee3a2143bd2453970ebaaef83c997592 f85494d2c98b7f25681f18bc32565d0039015aa5266f65dd232dd731b09b4cbf 3ee9148bb2f4dbceb9c0869f3c4e7a5245e6e549f214bcfe4d91f78fcb15d6ea 1b250b0f1e2114b6cf2d6c7fdd4c7b9da1f7bf721172be560e2fcefdfd4813db 9d1b3233a32073ce52df7d1a307de6b836582afbf0474351e7f0a2b2a7a9213c 83c98a063202a587794fa6d5b0fa0d3c18a21b81a43cbb366d26a91735117f86 537697e77585c2097b51341c2811cda8fa3550cfbc44e529f0a63d63ed9290e7 5da85646a0b264efb575a635de1ef2c955a765dd336351e1b2ec3994d2c04e5e 832efcb83d53c171206dc4cfac510358bba39225f385a551897c4139e5eab6cf c6c37d8fa87c45ddd9c6d9f1b770c6faf56f903b59afaa8803ee7fc6ba5a3e14 6389ab8261b9771d991039e4aae4bcf58fa807749905593d1479a23dcf6d2e3d b6fc1558d3db2bd362d2aca176659835a3d7f34d5ee2c6da1209bb2355b4e954 91c3a0980db59fccc7a90a69af24680af4bdc0d17e0a72fa7fa5da59bfa997c0 e6f8b0e3e397895d57639d5aadc9881aaa3d8ee04d31fc68d2f5b9e411683075 0a4503f9c48b731d1dd8b2280a575c15e5fef2ecaca934969cffc5cd115dbf26 1327c1f73ffb2ac17233d79624a17b1aac6b645f16f2407de8a92077c19a3c7b 6dccf4059e35ab49f66e199315e763efe2815a503eab8bcf44f4d25534f9d200 f947e8966541a52c0835c2a064c2cb71bbc652dbcdb1dbd3314fcc8e75a01f3b ae46f670527d4c0d9f04e0a4ab67d23a4e4089107c3250ef62c9a43a27c1c4db ab8a1a9091fa8089477cb325d13df16b35fceccaea164250309204415733760c 21 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 +generate_ring_signature 24b6afb3f6d03575e6b84afb6fd3787b6554e649223fcc94f0c3f8aefabf9457 c34607c491db77c2a81d12dbf15e28e3fc50190e43560765d84b1d88a04d763a 5 37604db2c71da54aee4ffa062a3ce264f6f968bb22e195de69667a1f6d8346d7 92ff0f511601d6610f31f3a53c956265053e53a94a9b08e841da63cef7480fff bef1ec8aa444f5d1702357ccf31de57d9d08297471c8071ca27d3e9f30302f6b a0dc011ae5cdcdc8ea827b893a02feaa74556f6a50801ab1d5994f13ffffd133 77ce2aea1d830beb85788d5b9b9ea39a1aa0383807299c479547e16e7c633acd 1c5e52449305df865f8156ae662da8e69d334ee7d0c9ac835a359ce5ecb0eb05 4 e8dfe8292757ffd5bddb66f751489759c0ff150a629d4b8eda0aba4868e918034df2cb0969a882479c463e15b522eae4be19356236f870a91cfecd2c54109e09471635282024b84cb3feffad8d59b8781e63034e3c1928de4a75923640217f015fed4beff5303710480f50e905e1e371a99309b76b52dc581545c9744e54ce0daa63b476e52187faced15e357b711f1b5bac1dd6430c4304da3507506f926e00e8912d151a48e404191db06e10b112d43babd1585c57494f2a7e49087bd3400449ba829a3a443ec383241fdd9adcd6a83c78be44d3c55819bed2c5059be0460b2051a5eead3a5e0c7088d294c4f387dd57c42c20670bf2dbe4c47797dddbe205e7197be0c4300e7f229b030fff670de1db1106e870fc7a992d6d10584e506c0a0deb718e6d0dea6ac857c4f2ac6fca93d6bddf0cfaeaf8a7eeab77505b0b190a +generate_ring_signature c5629b2c40a6c6c737f5dce8411acc9c276e6f0a56e707f8e57d60a7071557d2 743c872c39ccccc663ca95a73a624559e470c89275f9451e99b943a12c917508 4 7675eb1b2c42c881247435df509b540e8af4b715b863f696cf8f1d7def9492bc 2225eb2d6559955c01988be31a3dcedf4cfd6eab26c1b894f0c89b6625bc207e 287edf6cc3280b1a0e57115d79b5b762b3dd404ed1749aee4cdd0f3850bec996 601df0bfe882a553240b1bec04f63aa6592171d4f1da9f9bfd6509f1f76b463e fa9e98f42c3d58380216f5c6aa0ddeadf5a8f7f7e94b0f5e8d68215838d3bf02 1 528ce4323c607b5aabdaf6c3ab2f51b4abbb6ce136863f278e219e93a760db0db49122c7d8c4d9ec7d26605c282f827c421f9324bcc94602e913eebc819cfa00523ca90adbce632efa800cffd47d9beec3162b7a1bc396c29b78f9ac38c3be06425b5afcab4c2c629e38175f4bd010dd20e9c77b0de8afe03af853591381fa081c81b20ef5dd06a943d37d9235ab291446cd2f6beeabb75d6fc2d817dceccc02488ca210e44e4b3c345a3988de2d053729d6723223aebe9f8fb2f48ff2589c04476f10a21fc6842535bb4f36a138b37f65424d9f3bb517180e4f16b2f60c85086590124dbb590c8f13f4af8b3a4e0f3391a9025c6b901423d32638f3f1cfce03 +generate_ring_signature 1a4197dee423f190acd42720cc120eacd6fdb3bf10b79234630b8858b6ca9767 b4267203b4ae75d442d1ff8149369c96273da7aa9eb82e40b905e1dd1637e96c 2 8dceed51a14035531d0438a6e2c16815792a3e4d76f0f7b34b5491e4da661fdd ae627eb1310b295996cba5c7958b1d0f0fe5bda5ebe6bfb1b4b75e8f82a46b10 0db7b3861e845b76870c76b143d4f559cf6449fdba4bc46075817caed034420e 1 f3bc0f0dc7cc65987c38cde66a6d9969cbe48f9a0e2c3559fcf2844656860f017eff136e9f00663aa190dd4dd055e093987a705850723f91c35c1d0d16505c09de23032e8cf9af9f70c05bc7c496a1f8d21313c0cce4f1c5c87ba01ffadc530f04884862db47a58c155cd790fcc1dae9344be6e88075a49a4c5ff4bee34c6e0a +generate_ring_signature aac5d207c0aa7557360adc8f06738e1881fe94b73f57368d845f5682f8096f4e 552caa3ef09555e0a216cf8a78b2e18271373231c4758eda7a270b2ddd71b92b 53 6fb3972559f40e71e36a3f1106a7866ee3ac12c0782692e78c10bca229640457 e883af1eeabbbb707cfe9f543956f5bacf9bbc169183279e901b91a1d2481e45 f1ffd5bf8f58e9e1474d1305a55939efef176dd58763423eb3dffa481e103c71 18e614da426c877dc72f4229ac2b4811fa69f56feeb194b73b1df699b14e79f7 a1ec96815246af7cd69ea904d218f724d15dbc0eb271235a4ff1be126925d4fa 344278387d740c1965901597ba56b536d71aa9354b209819bb4a0feeab3deca4 9ae49f5ae55a66e5b3a4b78e1c05756c13c7f7955805e984e8955bc79a7c8640 1c0fbea44d7ffe1a9f1145a760f6f42f7470e8e4037ba9cf4da94228b91d5380 57eb35ad73b6a99178453a88a91be2ce87e886f38b50167b7d121906883bb4d7 2a7b54e7aaad50e8c817096733116f69a22a72aeee7d23b9ea99a8a381015bf3 bedf676e37a4e4dd53b92a8a469184ddac922854327d98a02e5fc648232bac01 e46ca855f80c8e707cffbda4f0cb6ddc8875548aa8d30e1699facb2b1912ef43 89d6e8228d7a16faa1b37309835249ee56870557877394a039fac2d2dfaa27ef 2315f8280152ce6b1e5634e2419b22dd94aea973193b61d9296dd8bfd93b9ab2 12cc102744cfb58b2c388e52fa9c581c2f4ac84e34073a2a96376c6030880a62 f6974ceea92b921fd60f6cb02e275bfa7f500eaa682c915aec114068d6db88f5 138b0b7687520bc45d8bc3e6d9bfa314dcd1d8ad51c48c449afaaf7e7f056d71 e3cf7715e05664a5cd498f79055b41a5bc60b4b8827fc1fca083ee55822eebd5 4bfb5cd9dbfc3a1c41e59f9e1c00237a46819643fb967b5b92a80e7e386430c5 04e91cdeebb6eee9643337c58c719e44d401eec9b044969798f92fc2208d6ea4 f4be010794473e1db3049ecd4d84d05627dd33be6858ada87513d89bebd93778 b422e821b07ec1531698e2b89d50997475f78f8c59ddcf7452fa7094f8994412 8ff811aaa240794bd5e8cf5d21ead05fd755678656e8f0e7ae030a896ad0e3a1 b2b31ee946f51c58dc3d1e831acdacb308da4c894ada26d92cf885b466da12b5 2e333a1e3ee3b906b058bdb67db9884f2286d53bdc14c5143054b1e6348ecf63 cdbdc45b81cfcaa2bdde6d4319b0234ca2b8c464e6aac3ada947a181463a27c4 846eff34251f5c0076e4e2c854983c4044b6fdb836b1d6958084404c842541d0 31b2b6d776b38f559c1e8f6fbd7701a1f9cf067bedc98b91d5992579a6fb20a6 753c3a97d7a7ac59c3e32b3245b4c1e6a8c65fd79e2645dfec9e08196bf5c5c1 facda9cbfff0b7f8bdf25dd6af2534f64f3edf18109def802733de31abe06579 288da7b095382a572bf2b269f3d2f0dd91468d458a2c50be1139dbc014572af1 7edee65275e7cb061af3b8538a02dd1cb54c3a0049d722b3fc295af17c95814a 90f1b088ff7cef4436e5cad92502d21075b84748c2b4758dd0c1fdf0396c45a9 e1e9df368aacda8282da3cb81ea1758599413bff17aa9b3ed4d4c58a26c27857 7d59b675fcd945c0cafe8c2ba2623064e066fcca4127b04e1750baea465528f0 74e8a9e84b57bb4b07e46a3ed620a85ff609dfaee364bcb6c1dbb28de7f1c812 14fd789d3530800344d64a8b0173693bc41a2a909b18cfa88a5ca700acdc726a a6b766d16ee81a8570f6e7e3fefa39954260442b42c4f51a3b83ab6100292baf 6c8a23d96bd60ceb6b63e8353c2fc37efdd85b4af8ef9d6bbb6cbc56b78f3ce6 2fa3b181f1d202dd58d0b064348bdf31c1dad990dbbc8e059a1b414cd126e918 d2621e0e30d4c067701617544e8c86a0d4e2bcee498a419103b500868d9606ae e654d8b768ecbf0b688d3e513858f9c9515de599c70e4403236436768d1a1660 6e05f7f1c282324b171d197a03ab799a0bfdc371ec291a5dc8ab1407bc0d7e71 793bfc7db631e1edbd61fbec38831f9b5e324d2342ba6fb39e1f066e2d8a812a d869a67a0a327f783d72c395cc8b3319fc55edf427f2233b40200a7a76b3e4f1 823c7157e173f079713580b594edb97a0cc24feaa2356b5c493d927b25e576f9 1f52f97a0f224dae75244213223daead4262a21324f336affcb1186301dd851b dc4d8714ba6fb00db603e63b71095e0c0f48375647d8328bd1f1a98ddbd758b1 52b458e8782e3afb49cf0b4142fdb82de0b9a9b02bf66e396291581a96ac660e cc7a1833b75ca30eb566ec98a16e444022cd0537e9eeca574e5279c72cd402ba 492dc7df7860ada5e7fd7c076a7ac5515934d345ce74fc7f4461b19ee0c95dd1 a393560e00ef2187f5baf6338066076d72d170d8f3f76d53058804ff7ff76be0 77a6d6591d159cc018704b75d4ed14a0040fb8ab7924a6504e31263404ad7c20 d68bc46912d5f41a65b74c8cf7b0f387363e2d02b1cac744cd4bbf48c072e006 13 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 +generate_ring_signature 1b9c52310cd90de6486e3c8b73ec646b0da895b54b118acff6ecfb69afa6e346 fee5ae2310a6b91390b1f30f2499faff560fb74ebe4b32f965af0edbb140a740 1 8084c2112b5d153f5086f416d6d1c059843bdee8f391f547ba9460225a69cadf 56320a68733e538cca2d2bc41b01634fc3b9e2ae3f9f83635b2574a4245ae00e 0 c5189cc07ebda73d06b022cdaaaa2441adcfc5af69d199d3d38213f9b74d4705c29a243ff2e9772b4d41501672090d77cf46771b317dcc7f178c6d743af6da0c +generate_ring_signature 65e7321376ed6c6696528042a65a9a4f6516d65fcef80214808c0c3230a52087 fcd664a50e9adb47d9ae24dc83f707e5178d3235b84c17e9a6f586c0bbc52a47 1 42fb2300246f28cb82112974815f4c14cdca8750a20b25ef861621effd08c45c 8e82a603216e1835a583482e580e635a34b431012284d709815768785245f800 0 eeb2c18bcc4f1f5cb758fc0e7a23a20f5c4ee01c3c1cff2a68093cbbd8a6d301359bf9c5aeab314222cd92b02889c2d95dd3e833f10a3dd5810a515f0b90260c +generate_ring_signature 5fc776eaeb6aa0303db0d4397d093d225c8cc0e00caa55d5e3110e9d7aba1aa7 5745637caf7435d578fb680de1416357dc6c6ef0ef7f00c0d98952cc3eca7d74 13 31b7451326d0a7a224f17225a19e946750d81bda5a2f56ef09fb60bb2172a44e 9665dbe2e581c02838c7406b1c2632ea5898f527c27aee64001f13fb69d4e46b 43522177f2705f00ce314e061859663485afe95dc1103d184dd8445b51f8d943 d087ba1e5c49e3d7f627e402554bf365e115eb049d1f7101bfcd02bbffc09d5a a76ea4f37eacc9214defe54f2d59017a3d410499c3a6c7784c538d480764e2ec 881632bf12f572675667d5b546c761b3448453c771872793058d7e74975d616e af5bd86056c8494bc987c9c38ca25b9479c98749dc1db4a352ddfa119c436afb bc6d378f748e912b350e8716c0965c91fd00798534a25148a9cc8308b0ef1922 bb0e87d6c20206a4237b34b1deeab57891c6750e4d152e28a6477400e4d5b3a8 3556aee9033cd19cac0d3aba95b99694deb7dec82a18509529836cb013f7e656 1b0e39b149d8425fb452857732ef05daab09881647d5e5e648f57650a5fcc5e6 c2a218592130b95abb79673da2204d97970894818e0cd4ed17569c973403aabb 3a3a3c9771727a8adb3029e1022d766357396ac444aa17f75ecd13b7dfc4f25a 20fd014c0ce804e8bc23ced4b22b168bc3c94b8f76b7b0f2366c91e4196e070e 7 09342a79f92ed180608094155386526f92f408bde4691d8afd347c8b22897b08beae950df84aac57afbe98522c35dfb3c022fcd7629f5665afdee45d0180b60003650f34687a86caa06add5d3d5479537d2a1db672fc7c1d5b41384280d2b80e86393d7afd9991e7df8674ddb14000fba0eee44ea5b1295fcf60f943e289dc046c4b4b8b6de66125c068c32ba71d27d69a6df1eca96f6cdde2ef51c48b572304238efa7d43bdda3f49453e9e89780c849dbb7ea2dfa6ce0476133adef529c40d2aafdb0644e45133be798d96e777a5be88a4e12c7e0d19dadb854cfceaf84c0aa13544cc330e92c331ccbfce0710f94f1b353bdcf0e31bce049dc688d5473f0436083c1f01f5150ababc127d832f4e5d6ca6cc28b7a1ea9cc40f99f5bdaafe01b0c8619dc62d01f1ee11b17438694d5fd7060d701ca3f9ee596353c4bae05a0fa20a2d6a2b943d6b3629506f914b1b4f3c518185fb1cfeecf2d8e915995e670fca45c4dd442894520840dc701fd4749f40b1d045ccf86d2e0f6134cf9b0014025d8e45a672fc1b8fb92a47aa54eb60dc745e8b2365a36813c3b7b10723fa2a09b616a8a7dee986e5965b71bef0891833b8cac2db7ec6bcf331043def964a30025389a8fb642925dbdb34f4caf4cf43d9656cb2ed82d474e2a325d2c4599bb5042a8632693500fc9b2888197e7c2e9d4d021793c1f5eff6e1701900447f8a4d01db5e01ade4a84a0de213fc061b49602247c9a757216e006996fe9d34665c4d060d41e49584a10e25c6285f2157290035ed8f2b0f5e6259509531616c7e013c0047ca85a84a03b27687b85f301e7509159d376e46876ce8304c33db5ce934b109c04cf9eac528e6550b82811ac472cafd4b9acaf0aadc61d660a52397e1718b01f330681b1a4e4ee43b7af1387ce1b90bbfb7fb7be53fa75efe15b2412f13070bc56be891946eade5595aae00375d6aa3998b517f38db9223333d4f0fb7d5860a8941c58240bfd8a920a0112a3276a740bb9d7334680faf2d01b60b6049fe660943789821109482838d0ae202a87c768190f61de98d9979863cbbe11339126a0a7f3af2c01d8c850c6a130ce1227fc0b9362caedd23afc47d2f5fda265d26fc06baa48dde88cefb588891b98013993260594fa6eaa2f267330d185ecfb2ae7f0a +generate_ring_signature 1b670fa7fab988e6f8fdc8fb107b3d075faac101675f315f48f069d363482811 311bd02641a786377befcf7f879163d21693f0eb1bcb162e016f16961adf8cc1 6 81b31e3da8c61e445c7f342caa50aa1f14e957cbbca3d541c909dc5040436732 bd9772f8dcb21506b557824bb497ef50079ea93d74b936ae6ee40fa1ebc5e261 7a31c4a1f85d63b66d38c7656d27611f99b933c8b97c1181376acb149dbc2446 763dab71cdc26c00204f5d24ca3dc0bbf122401d0bab86246774d04adea8d2ef 19d20452c993dc154c00d764ea28ca9c18f92df93067a40b90cd98cf6055f2a2 0765b3b2cb35ad43f4b64d7da4ea43c89d080c201bdb45d5b546f1ede6eafe4b 8ac480f5d3827bccb2bcf68e45cb0ca7cf3e9c876d80405a7c455b22bf68b70a 0 e9f94626a35bef08510b5c952b610e15a12981fd6d293c9d40e820664fab6f087b0d3f240fe5698b8418017b2634b851a2a9d8e426284e0a124e08895e09f303c7f778190b997a4aa697a09e0f99d674194f9b7e1d748a485540363f747ce40136668f861b42d86283d41e90fddf83515df339fd186d36031d8339d4dd11d801226df23a16381527adee612245b3ce8145b1b001d4097417ddfc1335d344670a3344364026b202b25b42b67a5666eddf17a3ad0daba28426fed51688edf42009d7845447824566b6ee580851b3c51056490d3d788689e1928a366e1b1518f90bf9062d5cfcb2fc1e84d05021d6c06ea32bf5059df8a8963e5985eea1f91c900c0335377491752000dce817bec9f53a948d81aa07caa2450deba10dca4afa900a717c0c86f42ec95b4e6efcfb3034725c22267fc7f7157a082b606ffcee1f1506d584418bc9dfcd31868afb31c4bf1f00644b37d8b58c7c0f3bffda7a008ad10438a38a5781772a7bdc07fabca076fcd7ae93ca7feb3da46cd056139dd47e5304 +generate_ring_signature 89102300bdccd553ce352ef36bd8cfbdf13f099c02bd18596e3d42e6239bd3d2 66b67ac092566c2a368b9a8d9ca4c4cb6a98f299e5f410c662017950512d6031 116 aacf971f4cb8083e4592930c84c2f7e1e814359c56cf8595064261e3a57062d0 4286968d242a26dfb7144780c2399aa1b000e5c64a7fa136663d9e9129974657 914d0875d0b0ebb1a309ba776dfe0a0e0c3ccb37d57da02a0adff77911fa6cb1 25960a259e5be8f63b901767d00eaff9e3b5b920f6080b957913c065036357b9 f42f1612df591adbbd3075dd4d7e13f632262a2aa4692fb66a9b23f929520ecb 2cc95b8fccad32778dc53e534511749bb98138621eba4b49df2ee579c12970f8 b613d3379b8bc47e960b43003a77dee82913090ef169ec2c24bc1e2e849c6ac8 a2fdff8411483e8012060880b6b2ec460ab8c4092dc88b48bd2111593221a425 3991843e89714483490b27ae31f275df2dbe7e29b0adefd7cd2a985edc5e69e1 b04e1160aef718f8095f6d74b592429a04998db7e3235af0805e2393ab257f47 f56c8839ad45f551557e2f0207ef083f0c5ab8afd19a093106f079304bf1fd8c babf3b67c8a305bb3fb26c0a0cbdbf11bb96df24e36903e5d7931d8acd8a4def e08078fa1b5592ea810f70aa9ec2b5af155d158cfb72a4339b06953d203a98f6 24de47d9b5fb0f83502c076360a5f84ff10fae7c178dcb6899f0e54d04c6f744 bf656a168108aac05e7489c23b7d3aba492ddad0a7305b7a235cda9b5f28d62c 20df1335f52c54cd9a273021327eb3cde3927a2a1c589c0b8fd2bf5305542255 6932a7468388e9361a00b61444b2fb0eaf68d975c554ffe92d301fa54277a9e3 c6878450d4032a0a632133777ba8904cbb2e6034d05d5ccfe183d9189403d913 27780f528549913bcb7d6bcb96e14c6cfacdd4a229135dc06d7c5102219f0110 92a1e11e5d0a1e83ef1aa41bd739c136fe4d3b2585c0d8ad15061d93de77d704 7ca5bca6af948f20929a81e95d75faedc991ba2faccdc3f2d942265d0e60beec 7d0299200ec4b03843d3c9c78d33d9cb871902c2da6e871f5328e1330038991c 95250393ccfb12b976d783e295fe5a0986370b05c48e564c2aa5d5c3e3d49a05 81ca61171b3f4f312a2460fe2f3a9a3d70a4c648a1549ff47ac4f621ec00e8d8 8eb43535fe2ed47605beb83118cde781c3699ec00473a56ed1ebb72bf177b356 03e96f6ec4eea800c6f3ef8b2c43f31160570d383285ecb1738a481cd3d5c335 209433cb2ab66891b1f9dd9fb74a75dcdac2639611f72890bc4c2a90ee0ce990 1c64633169c011513bc0a3c23dbab9ebde0d84ec021815b5efd749122a316d39 aeb62e7eeca2e3d46381c5411a47372bd9ed18db465d99a055a3b47c8be3aa1b 8253bd9c2ed9610658e5e339f2531f19fd147d0782ef9f60917e9d06babb7e68 2728a4782111a52f676bee5c3baa8bfb5c346b560510f38921cad69f9de907ba 12d57f3b4d36edf9656e67cff6dbe2d6bae85ba9a4365d04c066cb9b85eb4c11 e458bfe87a0561429dab19d989c37b09726656c8a399d609559db03680c946d8 e273d0effd007e930b1e9e130b4f87497188c4ed48fedd3bc34d169f83735576 31b09e291aa05bcfd743b3da58eaa02c772b817aff414d469a1f668f41ca908a 2309b29e52ccaec650074476470410a53fe1091621881ed61e30240b7d8e5ad6 f26e0a3ae0c0b5d5c53b4fde3a017c0dfb1cc1e67c7e9201c484256c02fbf584 b2369e479b65aa0e85c6d61e312733724eb93cb2c5b34b088adfca7f61c939c2 bb0e268150f215a3fd664363b2ffda9c7f8cea4c47c1efc43a9118f09bb66cbb 71b08cb319616d98b8ecb176a8d109ca5adfc90e7d88838cbf6a92de3e8c7ecf b2e5781e43a4b2c32d0acd5c373cab979b290928728e9ba476791c4dbdd9be32 fa305e51d4f7c53dda4689c34856a691ae3d6a9d01ee043f2106b4bc3787dda4 fe970cb89108b4e704e492c8db64cacaf564956bb1c47610ee25245a842fb210 336aec71dbefc4e4e44fb1e19239080446d9299b0149e1fa171c48d601a41c8e 554b235718cac2e9355720d4acc8838de199b59ace20cd1ffd575f0f4631841d d3ff0d68b3ff9683e5bfecdb8e8377de4ec37ecb155cf39c4e63dcf94b1ee979 f2521d0a0e9836e48760f0dd9910f229175740e2c81ecdd62e3859a0f4e0c7ff 66b07816d226538b578bb1df23e408d754a8a07f3ca5b6374ec386c5134d2697 ca59cba4793221d8430c41eb4ef32de270d0c89eca0b858b420a57696eb30be5 c3c213d1c7effc9e43a51d247f0fda635055491dc26a23201ea60758a37feac7 cb0f2314b2ad60b4230957199a9de58698da7811f47847ca973102a66f0d9498 c928cf24971c0890606fdb0b56f17b9409595764e7e398a2e729ee7838b0de64 b189e86e14c4ca5ae8b4cb715feaac84b921f3bed879deac20c9b27799176d88 65e86d5133b1d43edb8213bd3bfa7babc6e23628e52e36cdec478d39759cd6a7 3407636c7c04d71490e9edb5839531aa4724402b3c663ba22857af6daf6c9353 3445879109faedda39c091848b3b49cdbf61ca6e95ffdde56bcfa28da6d9d27d de4c9c94c1a01d5d177b47355118f70a68e7cea90d162a4ab67d7f8b8be582c4 cd847f96764801152575a86b30e6ed3a75acedbfdb16a5576d3a094342f599bf 6890ecec3024edd3be7e67817ce51b8de27b7a4feb288d8c4aaf6c91e5e909ad 66e74b36d7939f347f0acd6699214d4a78a016d9c2ca512a6f6112fc4be6bf91 a582a1c2948b238fc1de90feb779b9d11e57b06410ef58e74f565b6e3dec4fd2 1d58c0007cbd13072dc8aca24abb0b6cccf238b47c897a1010a300cae267c021 a309f20016a70430700d55c29521f51dcbb9491ec7a7be3666a0183f7b5cc032 23c15ac582b1d2443eb5b4e1aab30a44f108491057a87064a1784eb64023e96b 49796b6bfbbcc45aee369a4cd875e73b43fc6e108ee97d813dbb82f4227cd821 008de8724f40b50fb90cc68e804d395de075bf3f40888741c98fcf0df2cff0a5 c974385a5536e2e7018885cf4efe028760084ba063279d848293ebf7cfb5cd90 827792ebb3a8a1283d94fb063877561a4e92c709e9541b7c87817b28ed185696 2fe3aa80686718b9739256c1a433a37109c903f0be3abb74819cabf35e0c1bb7 e93816be20d1dcdf6ee39748a1f08e06f8f39490991d3058abbda941329c3be8 ee1b391beb2319d8f67e7376e68c069c0011ccf712f5351a82c13552cc890047 eda56aa82c4e114c8aca9636db3b356e7ad9c76c63acfd1ee135d3a2ec3393ac 0bf5483e4bdcf85336f82b77f70b1623d201ff601877bbec4b7b4963268ab62e cd4567b648634eb4ac39958e55ef352570122929639894f31abc61adc2609fdd 0ad0e927718cf2b4eca2e50e0d27d99c75cb7cfd33fd63b7fa7ae38387d92e12 6735f7d46c51519a4a2d475899fcae2f47e08c91a08d28faf81ae21611548f64 210e26da394508be17607c6d23d08e6d93ad5009f0677228c754d212a8e084ec 70bf02ec4ffebbce2020b5db776c6eb463b24989f1f3f8aa2e1bca91f2a4e315 498b3093b6563f383502e489fde1cc1201acdfd6fe776bfd68f674c4e4a2e8a6 8e3a7e23a5cb28de1bd8e28ba5d87a1f1f234fa405dfb5f9206dcc1df31378e7 9dc0a522c312cc2a6c95d954ded0023fa95e049848cbd06cfa85798b91d9b96a e84f3f5612a23c4399389dfd2ed6972e6744b860a8f110ea83ebd77a3a7f632a 670b5b7c96794bf0300575edadeb40dc40f30c52ab560f55a8f7219c2c7be945 b97fdaf538c771ef870edac92c52b266eddf2f41a662c3b812483423f1172f32 34fcb11256ef3dc85e4100bdcecd84e89b64d9c39da22b7f7383ff1b172f0327 0d735c44c9c7c5502d4b4b280fba770b284e2eae7f9446d0964bb6ff7b4e2f92 08f03cdfdeb880a685504b775045779c86135aa6dcfc8e06899bda0391141946 865c08b9ca9748b72018189051fb1282dcd1662aef708c62593dce09981a45fe 647f241c0da6d5e897f96f709e4c5e0ee7db1a90026e297b2b98739662599656 b424e2d17bad69bee7e51c8c8c017a3689b4cdf52cd016af5e65e7084b3c380c 671455db63d8773c5e95e71d37c3bf7d3e6316a39cb2fe7d234899011458c83e 28119b556f4048b9b31e7946073be2b62f74b74a56cbd31fee1cfbc2f5f512a5 a8e89c237d06199bcd94c030f5c58ad1a3caa2ff5bda6d45de213262d038cd03 4d6ae40c4e28276d908f10fac7db8fb0954d0b09f3d516cb61bd9bf9b5df9fe1 7fccc1bfba50e840563c220d2520c9f77afef38d9dfab6e01892e6345ea100e2 28e363ec69911e6cd79ef7ec1c6899a531ca6aa1b00d00f68d71cfc038043847 21dc113dbc94fad84468f32b6b654976e9e2b7ba9caa011fc46394cc0efffab4 513c7e81377e13bd283918a5a44a5ea8bb253f54d554fa760e04523c27978471 f121a815f969fc0597b1b5c518cd49ba4589394fc511633cfeaf0554a33e5bf6 19b4883add93f293a640f138d0599d8abd50027f605f68e78e398568ea444647 ff453b1975ed16f8c0e1411dfde72046542032a9e753b4cf9bdce4cff141b734 4d39889a38efe6d22a0d3569d79b2d5d27a2caa9d40f8d4232db0ceae78c4980 471dd89be76b7673c0948e9dee567ba70acf98d02ef82b8ebcb73dba23a25aed 21a96e9e7fed5e8301c71774469297fa1d0e095ba317b916501070d18be35eff 1529c4c48b69e33c78314005df30b4e24f25341538b4e4784187f8492a95ca4c dd5756c71342bc91146a6d89dd9a1755b2e67297dd08ee2ad47da6f88712cfde e223d3cf9f77cb85b9443da601d925305edea5d1f86b69db533edc032dec4132 9df21b3f335c553a66f4c6b1dd7ac870dc885de1b3323e86dffb116d3012a430 c545e90cde0ea37de654dc7f6cab3042b9c53ebb923580740bad667891f34556 cf75bf6c505a45d0bb8b966e4fd8fcdb60caf6998310f13ef23d48e9f8da5f2c daa6ca75877e1e7eb9c9a1aa990f850d3748ed84dc65be4ef4509ac2dc15a50a 93d1f3b4a03ece48c32a6e8f2ca589953ea4eed5c53798a388e51f9a6a5b9e57 0e41584b69979e002262d1cca78e9ee773e22a4458ebaa53de795a9885051fae 4aba7f5eb551ee6c25d9290c10ec73cc2d1fbb0fb3646f2c3d2959e620d6543f 6e0fea29e401d70f40f8be4d865f7db6add2fab1ab82090f3b85e53bdf9a6cb9 743899b36c46807eae625a8fcb717ae77e7119dd436a6cfc11a7876a1201309e f8fc487e376e13bba04de3825648ddfe435e78b4bfebb43e5b0d40a33859a500 6 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 +generate_ring_signature 39fef726944368533d166d84ca3f2ed35aca6b33e5a3ddcbde30f1a60465c61b ba1907948b591f4d5e7faf586b3f95d9d259ec089ba3ab71ef4b57beb3e5830e 4 cfc47ad6292db3248c65c78fd2db49eea2c2a6ff4c6f50771decac7631c4f866 4454dc103cf1ca4cfba718e2d34dd2489b08e0b350523dc9477dea5f16743e73 74d30aed08a71ab71277adfc83d8e0de28b2eba61edb0e94acce6309973b6d45 2aefe7ed1319282d5e1e01220850c933406384c6a931b0acdcf4957de3891eac fca4d6c4cc291b9db974d09df386a7742740068d0db8e96b1b4faede19f06e01 3 46779bb309eed60a3d4fa0c97e7c953b5c17d56b68fd640072e67a0ab2f70501f14c793290f7dc314ad6d7f7a515d400d6f2e6ca28267086e1cfd87b36c0ae08b207a9a0795bbba801eae04406953f67e1b1a8b112207be1f6a7577bf2bdce04f0ab8eec62ef50071cb931be6b5fcb18f12085940e6d82c012af5c9f72c7dc09d8a7fa0401ae53e0bcb11b997640d398fcf3232505b1c6acdd1b2de5c799f90427751ece69a45c76e2626e115c8b98b7c462db0ed970c3ef42b86e4de820890b7dac77de5ecc7dd03392583f9034d42d383321bf65ca3dd5918ef99a4db12e075bfcfabba3adb845ae04cb952286416ca5195902d7bd34942d1250bbc9de1e01 +generate_ring_signature 7f0c29493bb36b01a82a2f7077d547890e5bc7831ae6a35a2f31a0f902d4854a da08db64452bb864c36174d98a4e14781c78b7be3ff474071c0afc444fec84d6 1 bcf34b4ed58ed15b02861434750fb724d3101346d5e8303437f56bcd5eaa5c8c bfe6a1b8cb2a570d84f6df232db97b7a8e4fa3dd8e6af54d09fef6aa6f67d305 0 c7a0e607f15e84452d9dad48cffee7069b3e41c62bc5254bf7a88cb8f6b04100c60700decf672a6c52b3817fc5139a2cc6d362adcbf05a0fccda8ab8d9db1f00 +generate_ring_signature dbde6983e1560c26fba2a47c5e5d55dc182a12985b43766992a1e1f119947126 bd9bd3dba5bf6a2d3e986daf25c2cad584ae7c3afa7c27f5a98bc220ed0378ad 14 0f89f5a886f94ae576b8e5d8b947f0e1c7430d6187b9cf04c718ef3e99d945e4 d3e5b4d8755f61d6ef6943f8ba572fca1041346eeabaaaf4d53b6820cda40b3b ef305918a04cf633ab888ed026dafce004b79e96ec7bdbed5ed73e7daa14f5d7 bca88a261ca9d4ac8b51c8880ec327b1893d829605be97a299e9f29998a90d42 aa06e88145690e0e77549fac710a5c2279c1cb330203a88efc44dcc81465ed19 a2b43e260b1ad8a55ee794ed03fad1cd4a7a80371fa5799451593dbd4d4c7685 2fcedda6848e5af9ddbb3c94e181c8153a6229dbc896098e1dd4892f4d4db92a 117ea92dd03c8e8d8b54d680f30ae97884be678c4a868e672c5f78de1012f66d 20b0511d897bcf5c00b6d601dadd3bc7a879fda5fd41644dc07015fb95de9a13 38ea2cf665769f2661fa7e08165a9bf94cb807ef946d2cae10fb0cf314919620 d7d6c773b3294e5aa5436ed9c61ed5f03213fab5b30b83ddd0e7c12a412533d1 de39e3972890dd3e175e30880c96f497e180070bb64d726b968970d2e3be7ff4 fec305745ffcfb15d1e52cb29377b9a029b555b6a4470f0b8165e32d7bc8afcd 623eac57d7111b44d17da4b98c585b59eace5b904538060f2e4527b2f08d7d96 7817e9be56a20810243bf96eed3585470b75dfb717ccd52bed820321c9999e0e 13 c4cfcaa8e3f1b2bafedfdb1f7ccfa211a417d7066e32f76d6eeef50b94c1f20ac06a841829975c9adfd349aca2aaf13b4a932d655074654b6d356c0dc95dae016154234d4bbcc655da1b70044a42fee89d33dcea06c61c92c372fde61515d60be05d1a95dd4b876d0dc0755268a22b3425a5691ca0b3cd94c9c49fe1fa856b0db1c90d0f4ba2ee0536823a3ee56e243512b33047baed42e45c53a30f1b6ceb072c7f2179d7b4569142e327925cf6a2671470ab930fd435a01d181b74731dc2005f14908b74638aaed591134d0181fefda1231282c6db8ede6d932ac4cfdeea0b5e138f4c0f465145e4f3decbe0efd9c01398ca9f0aa3c1af653934af90b7120d3539e9f388abeb832c8b5d9ce73b0dc8474aeb061542869611e59f201b2fcb07cbe224066962c34acbbde66629dbe9d89707d385aa238c9184775d06d70d790dfd8ef14d4ba94cf504c1b6a9b311ec8f4c4037ad4fea31f83d7e48045b4402085c71e988c19932a207cb9f39fa112d9173742901ac4cbd37a22df6d810209106063a5e17aae1e545a72747a23b0c44130839b4d26db59c56b7772f91bbe26105f33a401546be475052bccda69a8a0cd8b29ccef8ae56370c37c9b8932ff185018e5feb6355099c79065e480d99cc57e5b03d1ffe7a4c2da43001fd1cbea37704b09bc6ee66685112568b3674058677f59075c98ecbf6d157ee18c5b6732a6c0a9a9fc9ecc4040cfe69d4ba083a460d2db338bde4d5828e7fbb40824e18e21508674806c738bde7f927e3df9bdacf39f94338e4daf331874a5aba23365bbe6606d92d8b475575ac7a37e7c94fc6d7bb75945b4877d1ec12b3466f4a363f9df2033136dc21bda7877c2e5730afb30295919b0c52578e8cc5ac235c99d34a43d2075bdfcdfeb1746bb5941ad0080483225fe8597128467f5e7b9249e06dd32ecd09e7be1878d78dd04af525c2e21f69232913986184594d6fae597d77d07241b50f340213c984fc70779a00c94dcd5352b2b7e96c9ffbc625d6007dea365ab98a0727ea14bed3c17f2a1300aa5ef6ba9b84f691e83b8c944a2857535d40c9a318059e526631bfbefb8ea6a4d93d874c0fdc88e6a2fab1c2f79c19ac08f7e354dd0f92e65f54d73ad0adff902e9dd21c08c05e30da1f12a4be48835401860874670a4b76ae4ff24846977a48f728cbd141f99b12bbe85458a8312c0024580ca0570395de76378cc73ac4e968a4a7ce248436f7562380fd2f45baca915d6f99a8930d +generate_ring_signature 4a049f0f8bf7379759bafc11f3e9326258df0ac45b612ad5088bef00d28ddf03 d4eced528b619b2c7e3478ca4325d630c3e79822e59327310e1e58f2a5bf46a1 1 8e1cd22c64de56e319bddfd26af3e8a6213dabdd844ced186eba1fead7172564 ec5b99eb1d24eaf612b507786695acdf1d15372e3acf311457d7197159059d0d 0 729e9adfd36508439325678207f24cffb868a0dc4b9dbe93e6eb2d21b4d0e10a83b8a5ea0923d84439b2fe3118d81c341d504dff11b9be90b6cf51b62b29cf0e +generate_ring_signature cc597b17e1ff8657ef92c92504a0a1638229a7960b286503597687714d90c0be 55ca58a01832cfe103ee846f2a11e237bd11e22a4baebed2548e75ceca9b2eec 11 02c74957d08764bb2dce5202466669f53b66570d75afaf9d6394bdf325be7c93 7aef7a7f9f34bd0716ea1483a0a4372b437ecdf14874b98455ebf4f6ea4a2314 affa26c8824fc326e2024d05c1286ad0797e4921c3c75009f80f965ad0b6061e e9946e75782aa240166ec2d39b2232303b0f79774d2a9a08310b9336eeec17d3 a7c3963b8e1784fd9004e58fc205b2de95f71d24ccb474cab1cdb15080931520 80a6a8dfde031883f53bf598dc1c47061487b20f393d0a630f0b15fbc71449d3 d9583c14e71f5d28c474e25fbd43336c5542ee1a4ce603f5299e0273f889f9d3 2ecca88312088b7e4e346b72d37ac2c9f312d4d82a842eb9393ebec65a0d7fe9 b59e25c663d8617339865199c0500feadbcc5e2b9d00819a3b91304266cc98ed 9acd42dc028bf3b39fe1fbd98d8eb7c7c3ad85acea86efecce7e41831e5a0e03 3304c25e953f30bdbfb6ed159e4a344c804dd52aea4d104bcab5a281d6a4a594 53cc0ff1070cb40bce44ecc8de8f6b189239790afb0545d951992845cdca0b05 6 679c8d32388a577be890855b18b1712c66e8faf1484b73a9add5c0221a61430ef7ed2c7322647720f4a688cb917927e7ce62752fecddc18ad4170739ae06560da1ad8b3b6eab2b661e508031f801f40ce4904c39c9c025105d51f6c18d1b3d011b1689ddd2be039d187ceca5fed24d994b3f646a4955e7eff719fda67f571f062552046859a3730d25b8386776baecde30baa9db2b195c3cf07ccc70d97e300e867865af98ca97b08769e046aef397d9857a3db45850c31d2b9fcc3fd5fb950cf55f36965ce02b8cf366578b83554ff571caa61126e247b38a6e62e40e66c90ee9495dcff99ab1950e24ce34397947200cfb1eec0f8db976044c529b10b3620e0a6d0545cda31ca43f8e934a531ab805a03ab401b5e3e90d93c34f1ae9e55d04f5316574eef4b860691cd6ad733f1872e2c9d2a5992b925ab64cb1e03b1ac50853abe0acb8137002d03bdd0da920ac686f2196f707a4b27ee78a454d5a126e0fc8b3c168b284bc38ba02b4beb37e5c1b25e9783b716134cf0c5008769e878b0755995231f5b85b1a6776915d9f1daa9c885fdb6c5aeee4b216e745d177a6e20be90b2af615e68ac4b653f8e20402f0e71a70a9a4f4e78a19ad8242bfea15670417d6be5b580fe1e751f6eb51993b4b77e276989d082b7fea4864d9a7324d7703272100e82b0231e7b00d00ebf2a3df540d714a6e99c09ceab28e52ea45514b0c99f3808cb0b6b8e2cb220b15ab4038b15cc9f3e5505fe6fc0f8dcf37c310440348c32c4deea855b208830653b88e2006ece357417cc769148ec683c0cb6f0e05b2d285980f87228ba801dd02b36e96ec4f6310c650deb2e9b8ef69d3166ca103d17f287373951d0dc70fe4ba015ae3c24584ace21b92e151746d6f0d5644ef0087b1b0017248267f03e80b316520823d15f2ba68807e0ddfd8392544f551dd0633943c4f7b169d7169e98c99ef9c4b11bd0e70790bd849ffeacb598000fac90d +generate_ring_signature a1a10532175cdd68eeb82f0f46b27f97cc2bd57ecbdf6e339a92c61d67056fe7 a7cf65fccb2a26a3470e9f90ef57f9c406df48f0dcf5e9819553605479d54cb8 1 516241f236a13881ee4aeb786cf686b340ea9f3dc8f142ab7939b63ea948f9d8 0666045383e7f9829c827c19f36ab1b57e58988af20ce494064ec1783c85fc09 0 f6238161808c785643c423949bd05be0d83d418c479adc8ad9a4b4120f09880a98f2d5a02a9b70491d2223e45e928e36f981f3014d323cfdf40f82d26ce2f502 +generate_ring_signature 33b853afc4a8fff7ac0b290b524bc23068dc3bd098dad3cf44bb96470ceaea6a 13b719bda608fee66c92ed1f005cd7993c144ce764fbfaf5349de4ccf5b6c319 1 29b8fb819c8be48673c0b35b8d3dc52b81fa528cfc91ac486b7751b1ba88ea73 bb666988157a61e08efec906b79f3e1321fd06d1f401712c0b4c47a98de66907 0 36f668c324361f15ec8246927d1b60434e5e2ea4adf6ccafa07c853fb3d5c7084c89cd6bba3da896045493baa04e3f54d2a7788b9a8ed056a4a280a4d7c35406 +generate_ring_signature 7267598c7cab03345e1d5e770ea5cb4fb41d934079557f538b0fc4115962e89c 72a4cb672b3233588ce82c8aa41613f0e1f087a370871ed79b72983d414d2dc6 20 1fbc0e3d207a90cfb27c1619a4db82fa106454b554910381521071121f7cb756 3abb94f2520ef80147aed005c178e6ee800ab93d91c284f924871ad3baa3d607 180edd37508ccb4ae708ea73f0e56b0bf4d4a0367a7fabb67803e1e2937aaf70 947f5548e9c8937ecb3b13d7f8c17889369ab8302ffb140a742659c2d1744043 54c8e1ffb3f50f9e364aef8d7164980cec2ceaf36edce662252f53ead9a784db 613208344207cd0665eb79c8e0ce0fab7f8b864bd49014c7d3fd20552194b947 338aca305d87c2f8792b82136cbb7396bdb218213d5e282bb4d29cd713389a33 ebb825b0cb8392e3dbd324e009fa3cf5f22662c70b35ed38ad32155942d2e7fc 2a6a57bc6115aecea112235dfcb6908a5305b54c3e1be6ad47f4286b4d94fcd1 1e9131251f0cbe92c17dbf1cf67836afd9dadefeedd0011f3d53292e889e750c f1d339e8dabea718797095a461fb2eb70e536fa2690a639d486c027cf5af6cf5 4f4f6582bb2e5eea2f1b799635680b34e5c7aea6069dd434a5b1df7ec53eed40 00ef708cc6a3843468e01fb87abc5a78fb3e44d1adde671ef9f977652d93f0ad 1b441c5ffb9d966ebe924088aa42718a58e5f21129fbb5ab4710b30a5eab0bc1 28ea41a63a7c05801ffa3f0775114b52a07540e024e4f437d15c6f596999a54c 5d1635b9996f202342826c0462a030f4a3926923201d97e2e97782dde4232e8b d63ef61485f58a8a8421c1030c63b13e7f9285b3d17a97c0ec617156f3d87e12 22e861e8e46894f227e0c5aef38e7144d61ca338a95c8ac00c222afc157a012a dd99fb211e2e4fcfef75cb569e9a5f751bed5f29c5f69e4afebd558e1a915b1b a79ebc1f781ad0bc716d9d20ba4a4be3a41babd8b940b57419d4090ebab97ba0 77458fd9ec7a1208f2ebed73ce83b8910072cd2e4658cffdded55675eacaa305 8 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 +generate_ring_signature 43790ade135a2bf9ffbec0b7dbf243f6dcdd40eb7b420d849868ff7aaa0f67d5 f454c7087f82361c3912a9120b4226db15f0d752d96a5f445e19ab88d0bb32cd 2 5513355588936c635e602614de59f0dadd566c4e7a77fa151830e454838fb72c c00a25f291c66d07365ad72d80b0562e7a91e990305a0bf0e5b01a0db499c8e0 30c8fecaa0b7f217aacb273eeae2ae495f65dec9dd62c17965c5f46beeaaa705 1 7f7517aa6d8966e19941065b1130a98b9c32c1537d4caa1cc9ba7ebafcade40de7881fa0a15756e90b93b29c8932b1762d080f298a42e983d154f7f84cdda8001f4e6ef214ff4b563c331e6431d82cf6545250b7ebd0e870aa5f5f4cd8d3d00a7b36f232cc5ebc2f5c9dc8862db4ba9e980ae791ac257e872058cd3f86da0e0f +generate_ring_signature f745e1b2dc48174a463a7b510ac8e6bffdc6303c2816ca05195d9ae739db3ff5 eb4669ddcb40d449366daba63b22670bf36b64ea51970a796f07fbe78b6e1af2 6 fcfa341e9f83038e4f10b48ea65db8dcc728b2324140891a0566c0cf16017af2 3abe9c454ab3179b0fdd96e644d37285582e54423cf27904fff0cd060e3522ec 202812d70556c9afedbfbcb2b863e47bbfa43a0f0e366d50fb369cfa9ba40496 f3280be164b445d7605ed53195350d332b6c4a0425993782d6f5974520f433e0 8b368764599684ce8308969573d800ea8e4e9dca46c25429005d23b8c2ef0f67 dac4c7e0b261d9ce63a7afd3a1e7f1d3c04682287567525b1696ba305a26b42c 40e0ef7967fa1af5d40c8e74b5aa2ce841b04634e8eef869a3e25b4920c6f405 0 21e48e3036319fbb7b7e4a164381698c863607991e66354dc6ad1dfccdbac703ccf8e86fadfe87d8fe8d9aecb6e7429118c661c02afe97e2e3fd338883527d009a66c1cf0cd196aff556cb429417458f9989c8b6ac9a83fed4d4fd2b30c8150ec579a8f9e1bde499bc7e00f67f294cbdecd0956393305409e9eb38f74c5e4b0b4030fde83679c0c498da914709541465edfa43dd2f181f5f50a2261e00ba9805fb4d3e77ce3bea71698f0230d30a0df3462dbb04ff7495c3a6527acd34163e03a0e39bc63d4c8df652321cb1908361aae17d7f539ed366af353225ab2fb3e104ff969baae5083c4f8ce8a5b995552231c96b8fc3338987120c7462ac3282b80f9738aac0b380f80e58905ed86e7048c9c8f7d571c210cee03892bf2ef603a808c15cac0c70ddc3a9da893b34dc2732a74a0616ce7cbb9395491c380e47b8f50e0d54de75bce6d1fe7117480c106ed73287e27967ae78d603f4b1d41031221606deefef29209e04ff2fc95e260778152f895cf7b46dc59b98c37de30009555a0a +generate_ring_signature 0c1ca4f91f49d1955400c6f4f0ad43a05b4b8e5bdf8c10da751c98dd85c47d95 ed2b4cce5bd48fa761dc4b884062ebfcb4d51dfb6add0bcda77488c533ec29a2 1 c31c24cc6088cf25e09cab4318376a3202945099c5b2117ec04a0d03da2afea0 7297a530706b0a9826fee21337f341f3a7df6d4b53e78d21c0ce596ad2c4fb06 0 b10fface876a1daa614d6e318762e39cbe8b910647bedc5e865f5c128d848101f617ddee0dc15579a431a5381d1267947087b8ec3ae09d82a6c7290b94c46d0f +generate_ring_signature 31e7df067e668a7056c57de9230390b3b21832b0aaf26c1d136442f138615387 5a53279d3b67d60495984b9cb94036d0504971c6f5d582b8a9c868bfe5856de8 28 d8e11f5cb385732a6b28074afb6337a101560a0015e9772d3f30d3948adfa268 4da2764bb6febfd8c8e04b2cfa881095a1311336854fd54fc4b6b1d3b50b3087 03601a88b19d5bc27bab15b33d1ff472d91e7a928a3ac537c709dab71bd56e0b d18d584e85ebc1788a95a43f24242a33cc9fd281a25029934850752ba44d1cc0 a2696d71168201625a49011911d328a514d6ffc61600e807450349198bad3d8b b1c2f0574ff45ceeb330de965a3ccead9738da629a941436b22f709939a536bf 7d024af0ad9a8bc11b1870d4e4bb34a3aa7f615b47728c80e366899088627861 5e16ab4a356ca7682ef9b89c2ff32ab2233393c1f6f8ec39945fd8f68d29df5d a4b8a7093c7b2f11f4ef98f3e17f398c05daa7f6778c4ef6bfe8da1b6ad8638b 0f3c7ebdd53bfd02e2f96ef56487d96efcd6c6d791486816317d624ee90f31e4 744845074f17c4d32bf7b9c0d4580e94a1e86f2c5521c5f3a2c08a815a0978b9 31298b4531ac19393a103da8df5afdca6312fdc9bd467bd488e4aafe0336563c 9127fd630d5000a395971aa0d908cf98a5c7711e0f01d460a2a7684f52d059da ecae915500777293d1a23bdb2d70c17c964b9a63ff8dd4ce6dbcf45772c3ad3f b48d34c124988a550b37c4a1d823017ba38b39b790880379ab0d9cc0031f934c 2de61fe61cbcaf6ea1f10cb8ba8f4fb8df780cc00c0e517bcaf9284cef02bc46 040f04ae028b915b6d1c7d906be11eeb401f7e352def5f7613e211fb0fb558ce 551d509feb45aec8e434baea8603a2ff77b5e3a07cbb0d0b527c8558c4c64708 d073b898ab4ee3836c67d0e5d1dda2085f4c12aa416c81bc340b85c3b8b6ed52 435503b90a2d14f405096ebca6b42282534834fe9ea39a6bba5a4caa4f079766 2acd80251b3515fb625a9a18d2154b9ad1beb8d8b010d8be83ef0b749c5dd6e3 e5215f531238d2c273de542c6f4fcd444e82134080f087d0afc64f6fc8bd44af 22424ee51118bf80a8cef77b8e113cc0330e24a3844dfd84917fbead9b8c254e 2fd2a01313fc8b08b276862efe9a959c3b1a19c26615d90530bb81a9f7bb86d3 ed488f41eab4fe62d9ca4b7b84264cc8320704afcbaa174d0cce1799d577e741 4294f3ccfe624c32b9b2274e0c12e55daa840db023085c7e25ec32e00e889bc2 0f8c0b190eb31fd4afed7e449e6110176f33ccc4d986e948104607a326c879d6 3bdeb0e9895a3814004480cc6f992bb3d35b747f697bb88a04147e419c5c2c72 3e8890b916eea212d4e1e8c72b2775339eae8c42e4ae8b43ed09e24c694e7e0c 6 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 +generate_ring_signature 74cf9d48387f68da96ca0b0be54b436b877a40b8d7ce35afbae4930e435245d4 21d51622f92eecdf0071d205840bb1e1e1b8b26d69942dac91980a694df9641a 2 b06cabb47b0111da68931631552e977c5d0f7391abd7e835d4865ca6b6ddc4c1 c59a24c4128d29bfc1d676496b3b275e1623dd226ddb23f8b4852eaad13038b7 880eddb85bcd967112fc751b1512b490b11abe5d054e43126990afc8226dba0e 1 2117033f93aa6f9c14a268fbb10806b96d9dfd441652978914650f5cb6c11a0ce7347bfa9f95910526e4afe71f66b21ab9d8cec18c5a84a644d92ab0f444030a0e5803d238eba46fdd3d47672342df4f6626a52c467d7207a6de697d1765960166f94b05ea182da1c4e3dc60b2fee2f07dc87f3091f0390b3561eaa7348d1b06 +generate_ring_signature 9207d102e70ef77349166326193c037511f13940a761e9caa6276c186b3eb2dc b935299ab3141f7bcea9047224771b9eda89b7e65d5bbc85ca163f1d7defb31c 1 764d6791a583a488cdce815e5fa424f70de370e2669d6767ddd3d553c6199343 f6a1a2a2a3dbd61d40508ba1f192c0dc37fe3d297f3df14c9730a6f084779706 0 8fba13972d87b08b18a4e6d8e5d734cc3e997acb786efb14b6ac68edceaf430c85b093fbcbb8fd8aadb7a575d526a8e17d031e4277b6d0e0a16458fa550c490a +generate_ring_signature 8f1205e1c7bb2c98ace5d21dfc38b0e52715a4dd21f9b7de40d9dc516c0483fb d27c1b3252173f413b070231ffaa38185f412f2fc8af2dfa34c6923146cb8f8a 229 52c5784d3cda705f4866716a833c47355b5fa4898cdf0f719014b1e06da6e6a3 913c3f015930f8ef9ef6e7113a6d9dc22bd50d047517e2551fa3eaebaf108502 6492b0bc2eb958caa42949a7a154c2900bc56ed651135dbf4b1b170fe9cd7045 15511be2cebf723622ccd3683485b7643fc64514f97a882d9254f4dcba06aa96 30b0cebff8941b4295fceb60692aab5cc46f9080e27da45272545311f81f211d da45fd73c50d7fd41205025c634b92098ac9d86dc163fbc5cefb2bc8c50ffc5c a6bf60e5242b2fed9b365e5e30a7a400c1ed7a182291be8661340f03a63ee265 5bdeb86000a7c98f5c7c3570e807dc75355909ddf07ced6b1b8a49b8ab5b4b3b 7626e7ddfac740421e4ec2f375da22498175b569cb9ecb7cd0ff729f17c77cb9 33f89703bcc1f9888f44ac7af120c14ac800adf93302e7fc80b6953318683540 15ad941b050df08d5fbed5646703b809a4b2bf59fc806f68be975a1659a3d67c be0d234f31dee1eafdb19d6219a12ecfb0cba4b276dbcb9c7926588efe936bae d2c6f00ce060342eda234645e3302365ec1b1634b24a3b48bb83f7c2e38a4c58 68e9268bf9af8e28e84ca36852a5cdabf74996854218b84e62fe1821a6fd3be4 de95a3015e45e1e1a20ebe69066248bb6d9091c33fb5f0fd99c99e2c98b3d9f0 175f159b521035a0d4244455f49c292cb6a84c4820ddfe691d34c960ca04f7d7 8c2334a87ffbdda21fb11cb805d7a0ed8ce0bfe34974660956a8ea56395aa4d8 c7edbee25c17019b2202d4d0536bed6c36c0cfe9368be0a937587792be18a73c 42b6ab41fecf4dca2b1150f4d8952ff6d3e26c124d1abe310be551f2d5f5275a 3622119839daf53fd79c3d53a87e92b7174a4ca560cbad31f906b8def47149d9 1ae04ed9d6599aaa3208bb092eda99dfc9e9b48f08b73b45211d907038f38aeb 01cc92d5068bf3d9ccdcbd5622d574a02bfad10f4efd4b38d0f443da3ae00e5b e862f2cd0bcbd35d523302201f9bc7d15ba68b2c03076e475005de87bc5bac25 0a9d2fd156f8c3e893f28bab84b7b9384e31a15d1131386bd66fc345e5599653 ee3144f7734cb223aca913d15b02900aa7122f079f9a6247d37341be18c7493e 49630627a6644da9ee51fadd02c54dba4abd237db31d8e7f911f9b3669c71ac3 cc1323b8356b0134cee1836eb0e42282f78e46a54ec1406a7d28ea639fbdaa92 3cc0a3b7da1acc1ad6d518029595b1221e9b632ac78a707ed136b597d18ea8e5 1437804f33e10dcf092b2e2de5ff4b0e541b103b05b160e6416fe5d915b3d867 a28c48c79a7694db14669c83277b53961a86332fe3e488074b3b4b637e7b13a0 0f352d25647efb575677787de2e358d579be0aa9bea73dfbe3dc6217b12706c0 ad3a5789bf9a2500ca930d64d72f5166516c71f42534055b3a945447bb0a4fa2 0e338d303c59926ff532b127bfe7f5275b6ba6110631ad6932059d028fa49b7d b68a76cc12b0825d96739793cc5365d02bfe50ceff68afd0b9865f65cb60a3cd 018de5869e7859cb475b48aff57f07f0aa8c1e1ffba1e8e96e87fb32c6d684da 06888fe284c0789eb6e33303797f365dda3cc8f2a2f9ae7754ea1192ce14d435 7f41f8ccdc6f2b5194de7e0477302d1fdae0a74239d94d481d3147ebff4f635f 1ff844011bc0f9a1044b23ab46fc2acbe00d939a9fa90b32dafb8d52e25c14c3 1559cd22ca6b489236f6854add12fc7c2946c2f1f02d378539ecc9305700f87f a597e24bc6f4dba4354d97eec4ae6eaa44428e3f35ca2d060b85bdc2785b2dd2 861635da1e9955e43980a21e4885bb8998c8d86a047f382f94f93da569985c35 66f0dd261e45dedbe26d5e060b60cda4da5aee59cc0ae63387dbed7baff10649 447477689524d8c7a55799d1133c47352dbc5d1e71f1355822fc984ad6cdc2a3 1011c08840a7436f9366091864d940e93e6ccdf7b04189907ae27e4d7e00d96a 954b68b72e15fbb72d805b79c8137d01f8a83546848f8e84d99d7e049dfda8c5 160761e382b3dddeb20b285a60335140f03f3d75acf9005a8274769d3d2b3b60 3fb8f5f3539927e5c4d8d254d696ad4a2eee6d8850d9ceae857851a608dc11b8 5597e4539febf5cf5572df1ae65e58ceed3d7de6c7d8f48d4fb0f3b895951b5f 5c84d316987cb2949689b99adcff5ddb82e0c1996f9ff5e7ef510ad3b679ea1f 2721a20b915b3e8b3263055b1e819947c8b6acdea2fad1d5f2799ec3f52f5423 abbc7b0ba883501c0d07f898df3d11080eb4780ad610e1e8155b4b31458b93cc bd7254abfae24aa591fcc630b3fe13b2f6ecaffa09d1f220ec3d2cc166709ced fc3646f77bd6635c64a53e50517ce45fc7a60e84dd81e4ca06235693d8cfb44d 9fcfeb091e1bf9cefbf395dba14848ffba2714efeb80f49e9b00b00c9f05be86 8c6ef973374deb3c15fed4721bd7aab0e6cb36eb543146d69ba5b99cceeb2ee4 3313b1b042d283088915c9416960722098d20dc06e0805f9d20dc2eb7b31b46f 9e44b4c47f110e2940b199cf3ffceb69c711876cf5f44b3bcddc9424ddcc6218 52387c696e8b95cf5ab7f9fc26fe4a66bf8e1d84ab56b787591619fa2c3e44fd 47ecdc3e664495b46990625452266fc65083351cee005e2a769986e161788ad4 93b8097c3c625640736d2558ff7678691cde0fc00fc2a4e0c4e7bb1b54463447 d32b0abad912cbed3ea7bbeab6db254e521596bd6fd944df06144a2cd685a68b 6b2a2312bdf27d04cb2aacf4a26994dd4b307efe7dc2b1393e815fdea8ad6e9c ebced6a281ec97f6f7ce32d1e62da1ead1173bb873770ccb11f79f9d196b4307 16fdba74bd5741106023583564de63f5b77fd0ae433253ed67d554bd7bcb2826 f1ed0bf4e6f4ee1fd98a9a9b69645fdfbe81ee7908dd0c21cb1860b62e356ed7 681c3a1347ad98aaec4d7031be4969b3f26bc09b03e30497d58d30bbf95f036c 0b9211db6b2a938346aa0ff7df2800f81b4c45a58e5d7689503d584d0a0a5b0e 7dddd689afeea27ecb36fb61df6a0f088152a5694f4cf4155cce68fa2397f6a0 accaf8a5f922e97e1e740b5e8f60674563ef8efbd6daae9cecefa048705ca80a a79aec40aa552d5d2c8564d40860785bcd12aaa001bb3c1beb6846908eec519e 6a8c92275c25fbc29c8b9e9ea0a7eb2d50dfa48836a11890adb27053114e730d 604d081c0de894e8a44412d641baa0e067fc038347ac1302aa2a9b0baced9311 0ada2bc88e8648a5e0c01a90a72ef1ef334849a5cec553309769ab2ff98618b1 3e89073127cc5f0fb823d9d0c8b7ff60974413a12754775b9fba0efc19efbb3c 01e8a98e41bc850b040d84719c66b985e798a624749dcbf8b358ff7d64c233fc 6feb1c7182cf86bd80f8eab7f4681e6f4af6f2701a024d8dc6e581b4a4168ec7 f8e67fea54bffd71c8629a90d50c7f6134a0c2b0c4526795ca2a5e07f146f392 069158fb4cc625c32daf2608bf603d73b7cf3cd344670e218f3e8e54ee691ff8 4cd66ad442a4cfc55b4d0e913daaf33cdfe7dfd1da22b6c2e3a766d2e60d772d 1d0bf5a9a0c93b83efe4143b4cd759079984ee4b0b56512a3a0a5e2c0c9d287f 4df2310fb9561413b277873f38428cb814f221dcd694af87c2a9dfe676a64b2f 370a267d62385479b270e46f8578fd2f68325de6b7c71f7bd6ad678b061b71a5 7695614d59d1ee67af6684e4e9ba5e82cef5880b53b3070a9ed5520757fb2f2b 5c95cabe47f6be580ba29dfc59a01fe24985b9cca5ad1c8f11d94a3c231efed8 520519e1a10836f288b25c7c32c15469bbbe2618d5193df95381d1cc32860847 0d1f46f19b2ddf805247e8023194a97e1f25a23d7c9fbcd9ee75408b369f89ca 6691f76d727a9fcd6729798328728e9b4991ab4ea23a0e8fe35566985dddc1cd 1e9f2fafd07dbe67ce07bdc4b81cbe6bef69b5f69e90db19f37bc88680d67513 3a44c7187849ae084e96d6e6fc5607550a96d597a298c34804edef0c611718b1 f6d7535c498c428a792217943664569f4c301481b400c11a03c03fc156fdcd51 2dda0f1b716a5a96014d1ad7c0b0d6c3049be66082acc5760b70db40591b7059 97b342dff13f2ec104afa7ef42af22d053c0d4724d5c150a600309f679783c10 397b9cd9cf85af509978ee6324ea25ce2ad46f4b6fffd70fd31376c411c98b8f a38a93655b55c9ade39d4d1e6a81b5e3014066fde7e81e91ebf5b82f6dd139f8 1cf789d950a4748478226d2cdb521f75a63c6dc3edb4cb561c2e57b38750cba6 4644dbd47839e1e94946ace12b1dcf5c64920d0c0188649ef4a5fd11b5075599 765b04257c56f566bf8748ce698d77f0961dce48440c50673e838a9f24233a88 6b61314fef1282d0eae6088f5180abde895a022e6cca980cc193597a2854ac6f c2baadb820f257ca6f3d48de4c9768c4b07c7b8d4f7342acecfb12becc6879ff 0cb01561b6391e1493e1910575fed3fc3c314a417313256912de21c61610a077 1a1c943bfd4be26fc17ab352e30988407bc7de6de0899e3c8aac2a575b84705e 0b2dad0d3b05d15de7f035d82acac91d21c7772aab52cf2f35ee17cd1f7496b0 7e3b55ad8e3a235dac80156c46e290880d9568752fc2843851e6de584d7fce99 2cca8f02b11d269de7a1790ba4ab530b9f0d893d6a6cc8369d183170d940e860 3a7191d183ca61fab0c82a531ba5cf5b1da51ddeb1bccc8a3a5de1b3a08ed590 3ffaca59a42c9a06585132bc401078b1e69659c151876b562918cad9c66b080c 482a252d0b29f7fb876666d565f5f67aab6d39f29317d31236129632585b2ef4 4163654838c2ba6d17590d6710cfcd1bce67f76b7298bfcf92139d2502b899ea 94a1dc49c5222983b4d843765d51526f0f1cdb54bfc9a68f62bee58da9cd0270 4887f9ef5441a1f87896339506af632b7d8a9c2df05b002b42c5b6c32165fb66 c53bf4a93bdaf03f2e3c4561357ff9a247cf019dc38b621b916f2c4d3395f9b9 f94b686e0d068cae20b55014454f50fd950ac9f84ca705b629dfde4baecf1ffc 2a3f77e3c18ebe3ec45879fab23e3e3f1db348d06eb30666e3a185484a91b7a5 5a40ba01f1427edd310b9408c5ab2488e5d05ce48b8bc85f8c0081adf11cd9dc 75abf56aa4921954d4423e957f680abbf1e3f458a1717f21b69d26bc7132d484 08a037168f337c2f30ea5db11153eccf6f2cc847e052ef0f2dcca49e446f9c2e 9a88ed5ea6035728e6cfa1407aa9467df401bf31e5b9661160bdb48ff7e1fc36 5c86516712f28f11b0a96055acd38d7819d497ca2e4283fec8300da62612ece2 b8a0708e9b6d8586fc9bc3279a5f0a1bc99505f627bbba52d9cb4e313ebf4d4d ecc9011f2f931508fd5b199f76df7bb96ed8c1345a1787567d80b249d2b0eb55 18275f7f1472730153d052fe574b8e890a4a32b012934ea236b3663dfa28f14d eb3014649405efbf8bfc962ee7706e9bee6a4ef5625eedeafaae0051aa721917 59fee3ebc15513a0c63a4040bf31bb02b6c20c9246d006b4f026c1db2e7a49e1 8bbaf1b46137d97273c26d93918ac0baabba90084bcd209a0a172eb8e7ef9b65 8b2d7272c1ae09827cf434578ad48fe3ebba74ce2d3fa00a35c55523e3a9de89 e129b195950d493e3c9e498f8dbea5b3e1eb4dea65fc03ac2bdb26df885e4dff 3671edffe7f5fa8fe14ccd74930c7ef620eaec25534f1e0db04046db3a09d3ca b086b636c71efd2445cf6281fb3fe8c858c5a345a6ab38314e3d4cdbe962c34d 7ce5992f4a5b9ab21f3b00bd9d03eb3b508c4e8d472f6ce75a624bf69c489cdc f709e736c33fad590fc82f9a7147597d3ef86a3421c0cb90d4f7824f19ee0643 0a758da68465fe3fae79ad29012b6035395373d0959fb27bb440dc9468683f19 5de2ab6d01977528e26cb98e22ce5205b76ec3fe33dfc38beb8ed1ca8d65f41c 0718b9494418118f2da64066b22439acef7fdf1e0f8b14f0522d42d4ecff4722 52ef5deaf9620304b0dc480da5db8e3cf017484061de018008e2ca1c2a6f0675 cad10726ba8716d69051940c377ac5f6a82e2e9a23096597cebfcf06bf515e86 9fbbd93d71ad8ce532ab9b2024aa3cfc17b89137e91f4c3f93097e8a34a10e17 d7d5f11eacdc7cbb053d15d3f63bd0e33554b9dd2eb8c83800f8fb9d0b2dde42 07027433acea249fa21af4cc3df4123babd856022b1a6e7e972a80602a5292e4 4b1cdfb44d28cbe272563682d11e1489f4308bdb836b6ff4a61d0d38be1a959c 9f35f5c9b5b382dc4b6476d912351a322cf349d8b5861df181163a46cd393fab 210cec3467f2c3cc24ef57caf3f7fbf6b7a8b46edf272adbedd8cf67ee954aec 6d5fafbbdb69bd02b98a2b4bdf24065092c0fae33cf6c6279647675cf20f5fe8 6814c20e384dd2298476d630badd43d8834560a06e4a5d328268f03b9f65f714 d8bdec2059ee9a599affa6e3548a00524dc582cd194a66b5740332d8404e43a1 8e446db99e8e579e5059ac28440d2d2c6a6f1838bdfe074f2da61805b213c11e 50a06a07245c8319c6f64966086e439e8445382b79a31513ae10998537568235 5efecc1a91a9a9df0fffb1050cb1ac2905100ca92c0ef87074d50e17a54c4696 ddf9201bb6ae23f18cf6ef069d183d0ecd22b08e481d2f1c4760f3a029a17ba0 6c1f2b0a8ccce1c65d4f411584c4a4811894b96a7c74dfeb4ed9680e4edf0259 300e358000c2b357e48e532f4e02dd6901dea80a371cf4b4856cb5adf2f97c5d 49ca50fd86f5ee0445bf9292fd492e4140e550fc6a520024619501179732d503 026d202c9bcda09cef16ca1c5dcaaef6da40fe42e533562c530e1b4a69c17277 8e4d82f0a0384babe7fd0a4326952955832a37d1152d0fd189094fd0922cf106 c3ccae4f7e60f4fa82bdb101fbff68cd2071e2c7c5729b3e9d7a0a6a51809807 e2c970b2577d34c1a4849fd4ddcbf48bc88627d51c8640b3cb2ff73a0ca852c9 054bdbb5411a58a04ab389997a4c85e38f2c714137252db2e130b80947c505d4 491f4b4d406f6e89833f4255c2f53103a26e3fc9f2d3f04ab6f5e034f9d16a3e d7f7a5fe433888c71ba0567bb87dd28d719e92c71254a1f84238c7a78937ea2e bc03db54203b141f413912cb5a0cf4aca06609dedd432042f8775aa2524b0a58 5e59b2c9319d9e6b450020f4b19b4c30bc5b2be4d32f4f635005f3efdb40ddc6 4d3553533863be129705f3008ffb8cfc0477860675c0ab53a642a13445185e4f 10837c90037eee815d50df2304f1c5f35ccfe3bef086aac31ea953fdd5b1da1b 5783cfc3d851b2043684d08af46bcc28c218c4800aab3e4a25192990c3a3c143 a529b861e4f2a800c334f542c958072804073d33ef707a324ffb950a0d9a3bc7 533de95bee68271d28cf19a0cc1eb17310c12b00516d8cbdf11a0af3d90f6ae1 ec2a1aac02d4a55ff2436405b7e821d9612406a4e1aca17b3e05f54039d47fa1 cfbb9f0fe10486fb902b329603cef2d1ed5be4e50557e366dd2d9c75cf535129 b0fa5d3efcee11d9e75ae5e77cb0363f64278fc6958114c6896c77f776ea456b 92562a6e185be15eb3dba54eba90080b2b556ea4e3244195e97c289f2936c09c 1130fefded4d6afe6bd3c775c6f3d92e7c49dc0b5f4a64ab09dd94efe5bb27cd 03df5ab7e0e605c91b33709c625af020147fd3d14594ef3928524b3e41956276 fd4730ba5fb0ba5e26f9bbcb8e24be8e92768b874ba84bd850d3d6c6bf14fa36 ff340888ba7d0ec25503b411fba67bd3eab35e778299f4c7b8c4685ca0e4073c 7cc168482cc27ace90bc3f551975052082c33d3c74244cbf423910d00122e760 b67e965b6227c63f7b1f7c1cac3f4ffa044b499ef2126be0e1874db9fa24a6e8 af6ba3f29ce5b209c40565ca02b58dd4380715f6f10d872006488359e5a468b6 4267ae8273f14e15165df0be29aeb50a9a3bd312816a9be63bb554bd6b9f82df 4ea2aca4800d87b6df9995e3d83240df97e309fa4de089f8b12582cda536ca05 bbd135a87a41a425b196297e060306fc2ea93a1aa2b9f3e6ed2b66b52f4c1f89 d025ed814116ab93c9bac3f9a4272502bb77bf9f71562de1445129e041bd2831 12ab2d4d0972a1c1cb4edb0c36bb60f3c347a8a651b814325f85b326e48707e4 99f3623de0fedae77f920301cb2380861f9844fdbf0d71991b0942331449f9f0 a0f626fbf3ec494ab01485e7e9e49f97a28784231070d4ae3c6b7a9df94c37ed 580d0cb132d0204f173abefcf7caf3abb8bf62bf65bb4954b29f4451f642bbac 8c97a982ed265af9a10f3f8093be8fbf23bf583fbc5b85e8bceb0aabdef3217e 66c73b6297879ab3b614c47308a3e64501904c7bb61e2896121b3c97b12d3ba8 33c536581435b1ab7a93b47ad2e8ee25d3358873c7f13e07e38ea9d1fde9581d 358af96d40f33c96c703a54970c329d9cb71777c66a41b3706b161730e178e6c 973bd3b32a458e0b238a95feecc044bcc7640de370863919a517629d26a0c100 9d3ba5fac2f6aa8fc46a7558bc756ffed5a1a2ae57aebf71360681fed878424c 95898052706ffa6d889c76a090e8244d2e6e7d339610a429da38c3e454465e8f 6604e03547ecea591a6d36ed604582cd8abd72bdb2b49e0a917771da20bcbaaa 38d80837cb55b1ce698fdd5b8d44ce9bfccad9cdc19e0e3b7bb7de9f5eea7833 16bb6df962e6127a9b053dee33aa890210c2afb63058011a95d5d6217aad5d41 09d9cd42fbb4bcafa7fa122ee44a13b420e77c58add73a305eb3c2b89f81348c c5aa1333b34398e500bb2cf60376e5dd6126f4d3db3034259fdf55bdbd3ba7fb 3fae5690d4a5bc412b86d7618d36dc4ec01009aad3edb77ff776c673109c7548 b28456140a3e985c226ab99a6c80f87afa3519e955faf49227c7de36f93d6d5d fa133b36fbfadd578d68199bd44c7e2b902c2ace06dae2ec52034875ab963d0f 3a5c007a828fd572ff8e0e713c46fc41f5aee958e186c1b88198135b116e5ed8 de33d23fc56054e68f333fecfca5f4d576fec6c500a494b008591f99c2a6c126 8db348260e9bb621ed1ac68622e551e852db4e8bfefb048e31e606e71cd9ab0c d909650ed9a50ffcc7f26fafdcfe91064dd187eaea4dff027bfb66d734a94bc3 2275d3df45c2e67a1831735a9852351d1e40d7903380cf3b33ca7ad4700ad8e5 9bf506cd884abfccf74b7ac9899e5430ab9be9ce1dcf4339453cac9308ab4867 044e10b3a3f390f0e44eae198a8fc246162762c0303b9326cdf01ae02285cf27 3423e004c3572f016a2711b9b7d5cfa4be8327185f4782a83e719fbd880ec73f fd57d3173d91f4f5b7991b70a4a7c17993e783c9a250f909d8a452fa1d4a7d89 4fc2721e8e5cb0f0e49791437299a6969485895295be74f63d8253c3e0897622 c370fea6b41b19482dbffa79495759699404f5b8aec95c42d022e710feceb4ee d76fa502cf3ca64f27d37460208b45d8bdb4343aa09f60bc86b43b45b3bca456 63fa51cc0c431db9458fc137148bc7072aff9e34af67204b0646139b5efb43b9 09ea32768ee291622d18b4ab9b182a0158604757150dae3692016c830f19b508 f2b2230fb64c40711b943000fc9faee75bac64677635f21b141fd76aebb38dd2 5e39938c9c977fbf84df5ee0f5cddded6d55f17eee0a38dd5bf01798a9df1c01 855f49af12792ec85075cd22ce20f3bcdae31749371e906bd96504b1662c1466 4fd587a7358b0de45ad268c237bb9b299d6a9fb06414aa30300e237ba1a3f72c 3edf61a65c3ce5226dd877d6aa70d639d52ebea7fb4f3aa7259e0efc8a5ea1ac 5846a56eb003d2b04f8d8a5cd02391ce10bdc43ea6114b740f590070d28a7003 c842f7022d26e8f0c9b832102efa259ce5e77ac2453fce14a364c590d1ec5d50 f90822ac98bcb91651e1f71f9c0849f821e2810743ff1e8e7aeae5909908f451 45091874969d3c9792356d245536a8da824e9adff04698cebcb99ff8e9e20f3b 9542ecf82586fdcd124636a4ee4bf2c4bebfa0f98dd76b45adac28227b0f455e 38c69a23cfeb562bf698b66058d99e63b5ecd7b8ca0b1354a57e9d60140c35a1 f7f75d344ba6ecd4ee5072363a6eff47161aa6334c86e4f3ff832074fb064b16 f7815c6dd6946ccabff6b93effcd8cdb8dbc9630ec5274dd476b27c3344438f2 b21ed1f01a74f7cc86f2ebb376b203a82bdbcc17a6acc4700d314012d3ca7e6b 54655a6c6b8e909278c760828a75b2daf5bf809aa10d84fc68bf4e1d3636d5f6 6b69083974fab0a280295796253901ac813b657efea7348aae3e2eda762ff923 fbfdf4bf87b4bb696d14bc2b350acd77eae89f267666a092789e0af07a32740d 38 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 +generate_ring_signature ff48702510ab57e5c8d1b6e81acafb78f7012e10e03ab15b0f1827ef34042dd0 82eddeb24599f7945a021098f99c7a1cb6edfeaa937e824e2f529708dc25ea77 1 c2e3e864568b78db05944261bb131881cd05c85c69033962d3c4f7e2a25a98f9 bcde8c2f9402b56df766a132e18cea4bd2d2c70cb537b599c2e829b7e3af4700 0 58e777057635a50541a903863ddb09177fd38f3c5af7dd93b87464e69f1fd70434c1839d66744f6aec5c5ef658302036c442067c36532aef55ebd901b7194608 +generate_ring_signature 417b4e63adf44a5a461ff2ff030a1757fd342e7f93ebd920c25b4c8e6d740187 bf738513972b08c9078a1b21cd261df99f52670326ec59dc94279e626c0ce9b2 2 f204e5533b350d6232e62308092afee62c4ec0f4fce45938a2bc17ec3bcea3a6 50ccf363fd401389de4f584b3597c3893faa78316cb8799ec6c20a37596677c4 a1bffbc16adc7bbed80ece0ae2b4978a0b3325257a96a7e3c3c097584d096e00 1 a751d8846efca33cf77a257a9245b2dd217a627683898d1c527007c4c9f2250b8fae55e0d37e9cfd97efbcaa48f7407dbd52e2257a1b501d1ee8a9088d45650e82f980b5cb0aac14d91ba6c235321cf6058d5957c59a2c4b3152fc07a9a39706f3c8e8c2e1e2acb7c6390247702b8bc23703fe766daae010dec7f50824b8bd0d +generate_ring_signature 030be7e561c24a2c9a75cf63dfe5bbb49addd7023362f7688d24ad9369967bea 158ff2e128941383275c97ac9c0206450dd2f16dbad1a0f30b045cbdbb76c2c9 5 205a0dc801db4e3d217a9a9e91bad16ab78ef983f799b8364ff9ab44add8ad6c 0a6f06fed33891ad9f778c3689968dfb1283af71b48c1690dc941ab115ef4d69 a19641d3c2804dd2450d313d1ab0ea95b16c4cc1cbdfebec643ba05604625dbe 93bbc7d65e865f094d1f7e7cb5b07f734016648b7d3e104db00b0d8899d19e8f 68e6e3257e7e974b4ceb1f7c4461950e60c1e5d1d8e935e02f4116bf89f5d842 0e0e85834add085696b849ea3ac806740cbbf7e2dba4002934fe022efe25f60b 1 6b1167722628d30b0b0c467ed16d98cecf39bdf78984115a5ad25f5df4a1f50d384d0595b7a48f6c713ebc4e128aa3f9034e470793f1618831a96a1a3e06570be13b96f42e73d236f5d842f4b311b90e804c0663ea21c6c71dc4a8040151100bfc41ec2cea4339963f616956d9b85fab18d9db84469ff7f0304336361f65840a3ad7e30af1291d2e63ee864c3a0948a1f28613dce51acdce88f3ada73719ca0e80686c8e9a05a40aac9b7940da2eef5b4afc3c2e22ce481982cc6b2d60574d067ee0b18f526ef3de2282659b46f57ef2662b4fe766125b098cd3b7e764f78a035c277520e637f4da2dd677a29b2dd82899b5c5cbed6659457b62261435ff9f093570672c750ac293ac48bf3d248b14f52366b8f3632d8dee37b5b78111747e09331bb6b3a930338ceed708e21a8066bbda232d68eb53e1c6747f2a9335cb550f +generate_ring_signature 676d9d3f03cde540717f27be188a1f3f089b9de4264a66906be09441f3910378 1b768edfb4e27ae223a513c913ca9122e2da6bd2f88efa1718149068e6a000b3 1 fdb9b839c1c33c111ee96c1fba14a6ba9aa851737e89a629ab9be2c215c1bc5a f8eec233f256d39bf9d6b86bc1858e47748c5686abed539c8c44457cada7b202 0 4c0f7e8cbb16e653b4d2de6b3a1016add36fd3e0524fa0e6c905c5ef86098b09f029298c240a8b2d26ce1667e105ec57a55b4a0b06f32e3fdd25a9625130ed06 +generate_ring_signature 6b1284d1a3858c8b7932de78cb05afbd1d97616929e31905ba975dba70d7507a 4ace77c3426f132a65348c8f2abc450307cfbb5aab6b83748cdd9da470b37162 32 8e02737d48fdf2acb36863a26c00930d9d7022156fea101760d6f178ce30e0a1 7dd3e2d772fb4626db9ceea8dd6e455d147d86a4aacfe0f8dccba90937dbc2d0 413747d1db30c5a9e8723aca5d8e2b105c8be221c1bb4337222689f184c4a6de 297bb55ca843b5b0b291ec07dc6af5746d7348920fb57138bc2a6ae208239223 eebe4b70a7669dfd49a6996775053955a4f03e98b74f1ac029c1d3ce1579fceb 62d36715fafc49f61c615704f85ef67bf6c82c876abeb029e875c3847e9e8d21 c003d25e8b139b9a40b1e169a8006e335b7cae4a3736026a4ce0ae55f1d1154c f89a5190779476851312b1297ff0d8bdb0d6032edcbae23b48f9a8241fb7b54a 22a64918ea6e8d63399c1837210716fea97d6022c3657c869d7c9255cae853eb beb2dbcc8a4ebb25afade190a4b396df94791d873e34bf4fdd04f0a5a5f86753 51779058b46699ed76f017f551b53beb6259dce7238fcb23f62553638c0a0721 077f6bc7e6eeaf2cb3beb60ac00eca6412980fa9eddd932b9a408edca4981ec5 82da8fbbdd764bd252885dc704945be6465fc45cc30dbe3eb6fff9692ed05210 1df2acf66b87bdcec1b2d8e454e73fce0e6edf521d9c2ce5d8a0a5d8e7c4bfc4 c4107473cd90199469995334065883df47143ef21704bad6fef7db88a11e4799 616adf3cdbe84f04cf90b894eaf7a3e420d8606b3f5638feb3dc57684b63f606 180972d031b5a05c43c1822aa2f391de533069c98bcda58962e8f124a5816f79 e7fadf78edcf92bba764a30e00c626eecda4fe7b732e588f1fa668dfffae6425 369a2989333a13a52af60cc2400536292333a78735b5e2cf12ae1405d8e29c70 0036cac6d8ce1a2a5e623db6f9dd8eaa231184c85c1b7661e4a391288d82e7c5 dfdb8d0684014a38ddc314d51c948bb1fa93d2f491a0cb71c0119e7c3c677023 dae655dc8a1f360aae2d2f97cccfc95244703e91841372ad4e19ff62bf7ef77e 79d75438920510587b7e8935b56e1182a6b1736ec651a624385215d8d461820f bc7705ff99d0becd021efeb88f032a9f1a8afb6e4215da04aae62d4ccadf4b2a aa92d90286a2e97e8deb50bd1f88b0c17af828c037f5d6ca756461ce5aa50947 8a93227c8c929fe5668877d141cbd701b9221505a0af068d7de66651c3633b1d d8c07205cd999930a681e3df4c93d0f0306d2f7af98f54b7b0f9cc6c856164f6 71027190c84d4ecabdf9c6e5e4e441532b31da01076940d9ec6f8212674954c5 16fa8ffdb9437d1ea18c12820a0bdedc301adfbd3c525408784a5af4fc6334d2 dcf6a3df67483bc91e2cfcfdffbd967f1c50724d15754c08f46cb3afdd16775b 6982f0182fb32a36fe007faff4f28c411a686f97a40b44c4c825e865f9487400 2b4cc6cd754512d8987ebd79a820b681787aed6cb7bbd7cb5ef792ccf181b228 0b9d7dfac5f2c2203dccee3bf001cda08ef2b12f8cb201e2883df36f61970405 14 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 +generate_ring_signature 2877c2572723b6c1de6b392c1fd7e6b9b06be04a33b2c87ee27559a4f440d301 6be1605f102b685abebe480e495a6ee11b401fc4f8ed2c7a9d59372677c51133 1 43f61d5fa46d25cff1552dbd032d2072537865b23f7631b16355d6e04f57406c 5768afeb110865a5c863b330dde198fee80d775dbd33ce56e639cc750825e60c 0 e5715a14bb474108b60d0446c4dbdb7e3a3af608115854eaad5709e720563500d8bc8527ee0957ebce8a511b498a108a6fcab784597d7f8f01b50ebc1ff63d0e +generate_ring_signature e85672e6b328687d087e5e27a222d908708082526eab8d9d1ed9c741309ae642 1f47514331ac0da99d0bb8bd185aa97b127a5c428ead41a49a1df9795df80a21 9 5d81cfee1bb4c5d9f12691a0a7f099897a6d2b5db92a5ad6e4f16ddf67ed1546 b352738407c3d1b642ec14ce4e87783c3461995d4a759f213a302d2f6644be10 2561702e1179fe38a61701da52b2c6470b7ae222b7be59aac2a4850a00a0517a b8e838d471c530f3c0eb2b6ef7a5e91cba4fe4ae976f5b9dd34d388678ac2c7d 00e859925f2b79171a96df93368feca24d15d9160aa005d86343f69b2147319f 59a3b6c9ca5cbca2b1b27ee13a158565ecff5267bfe407da2bf94c863afd94ed 51eb2c685edfba3a962e435aae95b54f866eb1429ddc3ffc79573c076cf4a638 bccd0d7379c0efd79aa6f27515826d350b8cbbb6713802a834a1f34f49a09fb9 5b7b1cc1529d4eebc5fec0b0d478591c0bb0bdae91eee28219841262036a8a60 4442e0c6b2c4e6cf3f5a1a33cfd304e8fd6c0c1cd8047061a19d83525b50b30a 2 69bec01f0eb6405be28ddc493a68164e688839a0ace810423eea5bb9d3c9cd0317426830c099ce0e7e65823cddfdad0e9d3071d877be8fe2175088ab0bce1c0e93fa53ff7dfb3dbd441834b4fe5eaa122c61115d189d1f268b0cf97c38d25f04e1aa0c1c47835708597bd3c9a2ecc4963e58bd22f4df5ad9c477fc4620aff30df536e5824fd040a52b9b74dfebe2266c4d84cc6075adffa8cfcd93e3fb2d5e058ded7a1d6fd37a6ef64e65c9ec6513d1baa49b915e59129b2c44064d01c54d0db720508bd5df28f4e8e01a8e6d82c7417ba1944b30e68adb10bc03e3e325c80a7d0f373ceec9b6b659f973ec70f092a3ec3b1e078d6bf5804edeb98d4de4ec05676368cddfe9ef8d2cec608465e8551ae3b6d8e23ff3262182d36d2f65a822076b49ff4db7af9f56d34052483638d87b027903fd287711a44d8fb87bcb26c30e3d1c3e82f385e4d716fb0e1a7d329bdd06475766fd320ca4a6382bd3c2928d0c817a0f0be38503f7c4c73b21081a19b6f1acab268bb658f01c4bf470d7478f0a7a1821f6102f2c96e299b0b83387758f776fca8283edfaa0292bd5c5d8919308cce402cf866116bcc080e9c18f05247344f0e0695981f1f2adbd6dd4ffb54303957d6474f3cb968272b4c8cdc65f3c356a9b97eacbd9ef2a0752e07454bdc90ae69279030c2a36813f15bc23595349d2de0d8e2956325e0a4b69f04c7d38ef01ed3afcea841373f72bff8f334cad9aa2ca2ccf0fb268d1d0495e4bfcd1e30106ab251f9cb9533779ed47637606ee9f62946492d9c25a1768daf683e4c304eb06 +generate_ring_signature c960ac5d7f59051cc139e56674bcc5a3f0fd10f6d4525685133ad71da9505d03 d110909f0a37135c260f7198ab302d84f9980cb0f9fcc863b9865e0fd76e88ec 1 5cf0e409f6ce507bb1d619490f4501603aa0b5b11c2040681f5691c5e7af95b2 1f795ee966c8a672d15337e590b1d327632928970274de649f6d9a6d71cf8906 0 c7cc15d92ebefad8ba3bfd54acbe42875a691976b7e780cf10c54176f2953306455c13765534e933002c952bbe4d194f523ad80a90a9bd80a82d76560c7be60a +generate_ring_signature 00480a8cafb58dd4fac3d4e0b78615ed33fcea74c26ad9c23d6f610dd131879f 2b7fbd562eacf805c3bf9aad99e90ecbd22a521dddc5030c2777dc9f139219d8 2 66f670b720ad778de82b255292fce0291b5729b4dca211c9f0def3ecd0f8c143 58a740373134543502818f2326766e0188b935de010814e3e61fa44a2d1944bd 118bae54eddaa218b8e7b8c9079fa5e42666d38b08677a64606708e0d6574206 1 427325e6827a366d0f8b50a68689f5108ea332c20f7128e67cd1192e1631a00b99038d5da9ccc0c6be18a00f99057a03c32db69c01f8771f7a8ece1e54675f076ceda7c7a7a93b07ebba2f3b7ccfb4d10f0140eeacea4d86551945e7984c990f86c2bfc95cadebb594ac4bd517337fc74d5b629ebfedf5a55bdcfe5e2fcca300 +generate_ring_signature f92442a7a535e39ea68305835767d33b4a1527539ad2a184188fa473673e583b 9f256d40277f781e035f26613b45660acd3f41f24a8179b60a56999115a83d77 172 fd881da6976a55847f9590a313352a1a24a7c5b3c8c568bc37b920abf088ebb1 ce48a50c2e6ce8edf3a295368278eec1c9b73b56435783886ebada20591770af c1533314426eb66f59ad0f7469d65e8019f902b053502e03b0dac849b7262414 284bae0be6d2bd1ecdfb9ad7c6857ee9a9ff6ed1cf50233e87a997ee2bfdf909 060002eb3f3b22f173e4ba9a50b9140c3cd5c7f7c3c307369d3c87466ba9ed8d d7d32b301bf7bb28ead0c666282fd23a0cf445219423997f8dd30afdebaae9b1 56367289441de9f8938588385f9a3a9f4f9a63f871cd3b72c471702b8712cc2f ea5c570305cbb52ba6d889d8b7a340e9335972d520ae71c9c13832e491567464 071eac248b47a2c4653eaee65e55030239c5a4477254f12b2edf3b0be8367ac6 3f3b3221a7fe3ed062a4d5af91c3246cc7d2bc30e9d3f85947970944058d6be4 bf078413d79661eda1d8774f7003a5816a93632a8cfba1f3730d8a127e28a9c4 e889d95ae3eeee41f3debf69be540254c8e68347e8b2d19d96b7759dfc14e377 f5dc25d2ce32defa29030708ae1d6d36673f8b41146cf3d89c7aa2f0f2b6e313 5205a7793f0a4b0d6e1e9257dcad29614c9d0f886fdb16ef4dfb4fc36af632f1 cc33629b3226d7404851fef79927fbb90c1df81cd95b7703e38ffa526ddb206c a37b372b2c312ab90f771dff4b2053d95ef3099c76a6fba984bf916b29b56341 f4044c8f9a9801a5a04a157b7c9aafe40c019207ee66d29fbd3a356bf710fe84 dee92a17e7bf79f7ba3d6b6d01b213bdada853621087e1ae1247b115a98768ef 0d696f6a9682a9f2d4c0e582925281368f16efb8c3cdb700154db78114377dd8 57728b15184b062d286f942fd3a163ba68cfca54ae3304e739ad3076e1cffce3 82ab1f9afa7f7f77289c00080b1f98a487a14a2f073cf36bf96a30440f20ca52 139c5e0efbbf51c5af2b9117b7fa58d6412d46d67eab6997857701230a94825e 4e17a9d3cbfff868b70ba95e4243a2da2df968ae5b0b67fcde527eec0c084244 923577965437137b6a933bd61505ccfffd228aae996d25fc96ae9db5b98d07fb d841ba1679e8ace379aada4547333b839b808c514f6d19e38895ab48b1a9d16a 8175b06c4a1b58b90b367aec2e81dd9c41db930a96b3e08cf06ef9162a21415e 818abf49a345f93c1275d55321fa70cb50f458e9e67fe911aca8e9a4a253a34a 2f521138d0edd239f6e54d5e4d94efdd9749f6b520fea327e642a0fbee8a5c04 9f46910d6268a0dce884a538bec4a81c3bd550b739bf5d02035174d1b6707a17 64656d4ab3a6f1c92cd71ddf45659176f2f37789d0338dcf124b1e7ad1030f71 f8c3b190e7a9091781da8ace4b6019b2d68f05dc92e54960a1a8571702b9c77d 9ae039b7b615745cb4e51634a5b8a10484d73b81a9baf555e11efeebdb5fa24a 75157319ba0ed1b0208d3764bcfe60cddfac56aa2330c76439923d245bd7d81d f997a99abab99f25b18d72b7d5b73d4dbc1902dc3e1e01d1fd0d12b633772533 aad3267d5679ef6eae0d094ae5df02b5228d3257d9a1edc0af7aaeabdb9051b6 1eb4d7c23a4c40827eefad193fa0c778f1f84a07210edc51b42d3150048f90bf 70e8bc3d0136207ee441333ab2f463ce6a456198aa7d7acf7d1c966f89371bdd a6041cc33222e72a94710efa35235937f843d4372ac73668217849e4f908f4d0 265d61d8b2272325b2b69dae4f728d3fbb3073da4c4006d49867abd4c1575806 502d8c2e6f00025493227c87f12a1319199c3283503748b32b23af0bd20eedc6 41d762110cf7279095cd2116f10ec88f99520c860d3ced6ef72ae99c53468ec3 1270155b3fa3602160171da175a36e4ac52adf90a7f52ae84d8be8471863f681 f4bfee7e8374801d097ba1199f24c2750bee92f29f5f84174200dc8f25234023 ab8ece6cf4ff2b2bf545f8c57791685361182df280ff1bbd925e8fd3c16dc329 04f1c90fc0b45e41ed9cc34a012d623d0a71e726eb61a157f7e5fdd331cfea20 ee65cd19e5b17a0dca4706ebfaae7474929503051fb26bc70c7f78f986311e2e af5af1a0079b7b62f0b2eb03964ca314a21e0be6685c1c6e6dde44bd4346b943 96b9d0ba83bcd6f976a964068dafb5329d349380910d3eb67e550fbdc46ab884 1956cd083ace90b869f0fc7041362b47a5317164ff30d5d4597f205d53a71474 402f7334d4db7dba7b1ca8572cc893223cdd7fa520459080f70cefe98a093635 ba1053f093a6d06659433238b107558e26a28d2db942a84d9747fd05839f5056 89b8acb7bba7b8cfdb045e158837a4beb36c65fd064fdfb2715ac78a95dd76c7 7d16961a37a25cfd9020b44566facccb9ee31c8663c3917ad7ba0cfdee07ceef a731d84951d200dc2dd94d18c77712c558bc3704acda6085d6bb46d0021dc7b6 a14c510bab57377909416af4573bd3b8a551d2d35421a706758408880bc4871f 59f8144bd5690d28f29907c8a958a1a70f8bd305a36162e310f04f2413ac55c8 0d56e71a5e55aa4fb86756dad3e4edf87f3a01a81987d1e13f86099dfc3b9494 5510c0c357755864b4485fa43bf7dba01d33052918604ec41533610130dbdc35 9fb86f44b481cd504258ac3975fb5a8534673fd77765f5ed90cd310cdcb4006c 3298a93187801ec62be93c5aa5900916e6ef57a4e19331597b82dfb9c00b2d9c 55b2800d41d2641fd75a214efe80a565fd5f27410783232f2a44f7a774ef9f2d d6e2629ebc2413e4f294af37b2fd948a7d1d71728fb59794fce78ab173f32a5a 23617f3efb68af4f70ba8173f61b95356389c4cf788e3b8f72cadc0d681975ff b06347741f5fdb84b017a177fd904913a409c46e97cc00440ed449900e9ec2f7 e88ad1d059d2d9aed7150005189836ce56dec709b8a22f63ed2304ad6c42c87a 2fcb144f29caa8d4e19a07f977ae6917e8fa0c830c52b0d4748ebba4801edca9 a432e7e9cfa465440d9a0b1df528d974cc32d4c7f25ceb53440e5995e9b8feae 0b0428e6f8ed8c90dc54832b15a20fcbfc82cb5f908f36045b1dcf6b69cfbfca f4064a72fdc46314d3652c0bdfb6f08f1b248d5c747998fe412cb86e97c6d83f 45cba132b9b9a0ea8525b70a158d531e0f4bab123078906e1257558b9904a24e 9b41948b3d7e5d4636bb670ce3b66d16a939f34320f0317ce20ede8a9651b700 bbccf33c2d44e1e59f62fa8144edb353961bd522a1e380f95ed006172c88af0b c04093b6c7bcd3446060f9c18cb62503acd1b1d4d5c4e7818292065bb29bdb88 5cb1f7658f73d542bfe7b10a988f45db4bb9d777ed6b0f780049ae54e82b6ca5 3a8cdcff1cd09bf1ba1952514ffdb00b204322613221f6c6efb969a36c164adb 03f8c02d0dc951aac9f5b70c1c044c06c9c98b0f61c5b30d6045f9f1a12c1fe0 0e7c767d8a26d57dd35d5aea58aa9d3a6098dd8ef2732c66bdf0e183ba23f6b0 1d6d4190d0b0f4b8ce1c53f1ab48c601ac7f4c487834f2ed355255a62813e11f f609212468d6b96a6ed41dc61708c2521aa924711029801e8e994095bb5361da 87f496fc9296d7e4a2b3757e555083f89192935073915fc41bc8f4bf447bdecd 1741f6e096f8cf208f002cde14274303ddcb25c2533b9dd10f0728e41f28e501 b091eafa29e0509f605d0671e4c207a74acd926ca791824d0e8751f58124bfa3 8fef9d73d54f5984806448be3a3b469b1b9a50ddb6c7a69a53e404ef3940e32a 5da7b39dfc6181a2cf1ee4f9f2e695b5bed73909dfc32f575eb815f53c8c0484 5e95b7c9f65a53d07781d57093ab9cadc813bb153e669de752f5c97e05571507 505ed9f5b5ae645ef41900a40d7157b332290bdeae3d19f866af304989d5d8b1 1f8959af3cf6788fa599a3a00d84c323bcf29dee02bc65171681fe42c76d4b5c 443b4dbe3217e35f436a76531ee08d19024edc0453c2d341991a8390fddb1568 7f3f7aaa9da801b08f6cf47eb23b3cc7d098c5d21bef44ab449ac00fe6a19299 6ab9c1bcc391acb14e701e26b32b7a6f7fb09da69d51b289469f2a977bde80d4 8efffda82d82d52bb1cefad9ed90fd82956db431019d040f6100ac161eb7779d 59cf1ebb7bebd9e07338a515fa9882239bcc77f6e8709f4765b463388a7f99a8 efd4bb0ff013d411e7a7d220f792ec5ca72933777cf416c5d7f2a2945071beed d1daec9942d6cfe1c2a082609eefc2c9e831a0c07dd21570390e2cca7f2dff50 bd3adce1a245373d0073f2430729aa57954748d90e3718399028fdbdf68b05c3 b93a50fe5a835ce86b56209a1057babf323e6dd32fee9433db6ed3695de7d9ab 3a1f69a2825eb6d2c90b438e9d7fcb3fe8c1e38983aadb0126aefa31bcf6c645 ad8be22685e2be87180baf881ab3dc90cc636da658175b732adfdd968e6e0246 9d57a848b3079857b0bd7c7f961e61f3d6e3d52c2194e3c3bff28dd1bd5080db 1c1d0bcc04c7ce4cc76effd19c8469638abc1e044dc2a79c7eaa0613528c7c67 f562f27b6b50c3cad5d14e7c4f12ecae046dc008d5dc888a89d796aee7d92272 e292217b111114bcfb21cc886b628e57eafb81a6f15eb72478b3a58c9fae5ed7 0398e72c9373ab5a0e21048f4fa031532ba8fa7072d08fc12fdb9cadaf0f160a 77c364f1d84650d7cb383dbc06e3c4570dcc2a343ed4f0cac0bfd76e1a0d250a 067c1fd7d8f49457bfe82088af2622f1d164681e70865f2b317e8a39b5b1d5fb 32a06673ae1fafda5af9e2a4400b0b29397a71e148ab0a10588d97cd408ce759 5a9d9c4d860c661e86742c4b8a2f9f641a50abd42b85a702f0f9078e06189fa2 939d92a6c0bab1d47d8eca4c7a2637498e41d517bfe0af1578ca6ac2d43fac67 b95cee77da3467db2e20ef20a9b88a31f1160cd4c96b6f08cdd41f719471086f 36ec08a5ba086104f1e20aa1bee9d911e499d0a83ee3273a9afad03c64d86885 d322470a709b5aa95a584918ef8e80351984e58799fe061c8112dbb8ed166e00 3bf94b5d1bc3af26948c9e95f0efe70707b7567f6c868a26fe0b3736f4eb84c1 0dacec7f9473b709d9d08eb0ebc09f8d14153596afc5f2151e21ad5f4ffc552d 91f9062ae066dc0cdb72a9caa0dfa82230fa2db6df73e69d4ce042a8c060d813 689f47516ae100226f511b2491ce607d33565d036c270dd879f725fac4f85ae1 38a3a226fb70015ede495dcd52d5317c8f837ccf80ea444e0872742b959617d8 2698e10a18971e5533259238128acaae4db48bddde16b3671e0ca608ead5705d 41e5a86e6e2986ee7803d5302b70e50086b379232a81b8985de0c6d8072ba128 9904888e211357fc304f14a141953565774a8681ce718cd669ff3d0cf1b796d3 6f7470a432f921806f7704af9e2ae3db09e79a98691f5fbb355ee869c824a9a2 71ed2c4844a82c9bb02a0ed2ceaa1bfe5011364c90ee2bb86bf2eb9ea4656198 2872fb459f19143c897500e78f4e03ed59836d14c8a99abfe1c45c25fd9dc225 afc7929206da56bfecb5fcbd92f504b8840ba109f2bed578179316f2840b7493 740e6ac8f581a0d48d1c890ae1efa021348711b7668c2bf44ce4df9de3900d8e ab637889c7cf30038e81325a13de81d28096719222b2eab649ab4dc46e306abb dcbf3053b800c54b354f4ab29aa1470d2cb41f516deddfe7dcf37a32c6baa4b5 43f4f3389d1301a51d22acee3a2bc19d8ca3b4051279ffd1cdc43a81ef0f3120 d53a2897da965ed3ec8fe3a64c84e94148f5a44e26aa618f2d7d6ef6e1fd5f45 eb36446a8f29a00e560e3539910c595e84159b0097ca45e1251e211efd4457a6 fcfc38062f786c990627e08f21824cb2d7aaec22f7b375e5f9dd32d82fb9ce7e 8b639553c2a999201727a1b7402b65f75e048993ba308690ad9ba2b65361f507 e71aaa0bbc4e864ae50dc86b9ebb8644320d91352025fa0eb0f60d0a3d054334 3e0aaf77018f0588e9bbf0adb974a83cc2fa77f42cb4209c24766282cff72286 52d0a11678b725c2199ffbda6814f92e9033c2eb5c5ec249d4fd4fe94e23a726 8f8c15d5ed07695a7d4e815cdcf4dd3dda0926d0d752468948ed919e4729ccf0 aaedeb70ef549d4196dca9e3fbb7ae4bfb81e2908969840c384d2afd34af9f1d c4033ba752ae96463c8c6d0d2b84ff52be33f3215de8f78e89d817ea24f3dc76 f1207b72213b423c405c200a7a5fd7f8023e1f239c8e606ddf71031525f23b37 baf147ae7bdea07b53a5f5e75ba469179543dd0ca592095ff616ed04ef9beee6 2cce4a9d993261d22aacc8b5846160c0d1c4fbadca7a70479fcdeb550c959c83 c43edda5a8413902774b1f8b09b27182bec45f69e5889e202060dfceae6e9ce5 22832c1ec22d2ab3b19093ac102a7aa2b8b0bd38952b9e35e44c223de1269a0c ccaeb8254c1836cfe80e63c41f1b0b12cba744f6252a115ce428368eaa19f561 aa56531344d04ac78cde18fe6182151d31569d6989ee9d5dea5292b21da8a3d9 543c8af32bfbd127e6719470804887617c42fad95fcfcb653d49009ec615b5c2 9c54714b1fd93b07226cb356e7e29e1fe9c093a22f3832f3498b6fbac03f50af 0a1d9f709bac257082747850c6adca588a7497f5853cdf90843a4deefd0ebb61 1accb6cb2ad322986802e1cf695a77856dea76a0aca440e6f7ddf7c6995bf1d9 5a077b219652fe5072cd730e904db6069475fa9808c9cba94668189922e3fe14 90a84ec912c8cf108a484d9305d0435f6f8aeaf48bcc4e11f86f5bcfa27f1f94 0600ebf5b2f516607f12411699f6dd8c8817c88cb9f3382d854d4f943ad23f29 2559aba16f4afe15749840263fda8974a76f6ae4e5643e3f6b797a3c62cf58ca 7ab8110bfecb7a962ae0c9c503a44ca616d3fe93adbebb1daf376ea312adbf6d f43d50e52ee7398b0fa244e144ee76d30d39a41e7199424950d4f00e9796f9ec 78cf72929a258d65087e8568e2088a6ceb6cb807a9ed07f5af1af426a59c5eb7 1d840f3efef11524a202b6b4c55d15f152ebec1fbf543292464bb3de84a3c0ac 244cef52f6ecc47defa48791392fa2300201d8b10310aff5450038c14991948b 74779637e05d6c6634b4639a77837b33a5931db6fd4669514df6fa3a95db181e e2f711df4622b4ede67c2a90f1b54e90e8cd0a9e9233c30ca82ebab46c68d97f 935c0b5866b20fd6094efea23ec5a44d9f38dfc5f9e13aa13681f6c944903946 d7c11734281c2918cd59b872819af1fe6808b67aea22aebcbf9dae2289eeab50 b8496e518ba54a9047c61e1c88255305f43ddbb46ee1952e5261728f6f233950 a12f64dd6adcefacf9a68dda0307f97699f45069750fd2842dcf49d30d9ed03a 8f98e2e04a873d27b24032446f3802d96921a3d364c825e6b918f4e8f3e8ab85 03b646a54e208cd8e396a18b43b96fc1e742843437aa917e6cac0d706b0782d6 30322a0e721a026ef6ff39158e4315aa2a492cbf3763723e7bc78657d9573a3c 4060d5f0af5ce15d7a8d1479313e0fee2b20f8e968cebe186761d6c01317bd05 825b5e2c98d748a4749705d0ebd93e0baca50c01b072dba309b71e7c52be9e1b 57deecc6a18a1eb81dff5424b8da3f6a6e34ec7af818a361d583b905ff7296db d576304b302f68dc38dd385a2241268c204f6d0219615dc123b0753ba0cf35ef 13f693db38785ee165adf0cd566a7402f0d4181d2bd633c081e86c5509013fd9 258de71f92a436777203c25e57a22fc51750bfb959022cdbff5fc1d3eab8b41b ef87aead744d41649ade14650cf65f719a7a1083495fa3908acb756f84468a0b 99 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 +generate_ring_signature e46bda5f8d177a85b3d4f3f9b52ec30d3675e7239eb271e9756c1b9dc52d0c1a fb375e609a51a1a54d30f6554e5481a94158e49705233340357ad15f25c832b5 1 d9515348ed96ba26f155412e0b4b7fb190f48c1adff6d6f7bb0d68c4ebe432fe 70df55444de1551ddad38c3ba80c388032316cba280052447947c02151dbef0e 0 8002020b542f528ad5e342b14256981876923480c89931cf94f99468998b1304cc8bd25d12ea3cd021b45118f7faf09bf7e012456b50396108c8ad01a94fb40b +generate_ring_signature dd3a63be8c1d0e7c20341ff51de1ae69be6ad9a4af2494d969de4b5c5a3d1213 bed9efb67d0318e6e2fa22a32ab381332b38f0894f8a8ada7f8b4372ebfc967e 4 066b617b0fb79775aa1b548de8757a121e7d0e38459a6bc5dd0a587a88fa26b3 193a48039163ffb32e1ffa931abbee6e1aded29f388aa635a3ab148c8d5e2568 4732c8e3a686c813b657069e304e06df196259ac5f1634bfb7713438345f053f 4f1a2284c22c27aacd12d68d25ab10b1fcdef99a708fe2903c30e185fbc99c28 79be700bc846a57a8404540767e0c3f22a32f812668276c2d6b9a2938d286a06 1 ca16aa9926e99c53f24278a84c291b482cbf608f61fa34c5b2d593dcdbf6860c766bb673a021d23e7b3bf755c1063eeb70804680c1a9bcfe6e715af229fedf0a408e206819f3b8a83979fd3582a9a005f36af7a1e541064b4929de3011e34207422fd67e7a2c7ccd7880085c205de71b51360b9a82618697555e114821b6c500300179c2ea6631cd6aefd2cd92cc379ec10322d683637c9377bcfdec1bb03906eed9cc9a717890773940a697a60385463eabfd73f85e7524de8081772a845d046cf46461a7211049135a54de00f1e58cd9b974bc6eb775f6b05028ea9388310940db5c8f09e0666452aaa73b5ade37e20d908dbc2300771e48629bcc82411e08 +generate_ring_signature 2a3fecc5533445d1ff407029a75e714626b2eaee3f6479c67a27201ed06b2b9d 01c8dbe8167151ed13b296b133178b80e39a38b0c0c38051040ade484b69e4d2 221 8b859d51a272d7d7f42eecf840f7fa9149a4dbd6a7724f6afa17c4a1bf26d8ae 8d6f021c956ea9a626077dd81b5fb6e459a370b56deb4f4fface816bfaf00668 815a27ec056a040e436e299d9632876500d90f3dde3eaf1107d9503788cc0c95 a24932b33273a1ceda8f5b32f270fc6e0df415fff64ad6b39017af5359242b6f 9a0adcc60772f3f654b3b417943433b00b6bfc27e8b8afe5fbbf844147e8c5ab 90f1e5a5891e354d4fd02205a33f49657a5de15d7ff4ddc31f39d8643d62aac5 450f08d11598d355afdb687cce5632cbbf31e3c1e0766765ac352dcaf036a67f 3866d2f6934814b1095f0e0a1f147b93c50f15716e254c9e7d74645a4df78e0e e3491b5ebfe4fd7c5bd3f1dd3a40ab2825bec7c4d827e0599f1145fe51629f3e 62c9bd5660490a1d2e9ff39215eb040f736051a242963bf2f272eb9d73fe132f 71e01607b9b65d973be08bf5983d862bd42ef2c3f0fd6be7ba33a54a5cb909e3 d561622d76d33431f0a7881258e4906e5774696441e93194eace2bede8d5d095 9e1c44bf1c3513bcf7ad2c087c0eb6f0d19ac9288a21838cbe629312543a7d32 506331bba887f11ea4ad8c9044e332c082302838c750f0b0ba8936b8dfc70715 a1f5054ef80b2ec1f151f60451f4c982280f128b8ed831095ff4479f2adc8b19 19dd0493e1890f8e0ac05b9fcdaaa0bd9688e2ec9f47e2432f02ca60992e4bb7 8d2df708b2ce601d1bf7d762da0d31681643d74b8ef61e061c1f67b8e88f3975 b765132b1552f0c34491edcb6d601849aee7557ca805edc5296334860376838c e4e824505152dc5a1800451cfa73437c266b6a0ddc9a6b13f8a82f2a308195e3 33be8cd89800df491acc53ec6eff8132fc3875a454d2fccd019fc6a3d4aca291 f7289f047047bfe7fb28bd1466daba43a6b73318aaf082fe49a9703f2650c54f 85aab4738840c444824cadc97dac6f1b738102ab8d495c5760ed553ec8cdb8c9 eb87a343835083e45d815729559c3e1de67d69ce50f0f1bee874a3e90b8701d8 c58861edf4520042f37e873b69016220706fed7fbb5f4ebc1e21b9fb5018e20b 9febb8ed1c5a2cae82c73149c0fd7accdac0451b8fdc81121b954dcc500e5dd0 c5825602f9ec7f01f1d7905c3b3e7a4671178863672f3ef2c83e1abee6788522 fb3fa6e53af880f0cf31f95a65b5181b4be788265f9a1c0cdd5c3f1718b5bf83 f6b63d638100268978d89ed0f6005d24a1b143c112c73a918ad27b6eed6f0f1d b4589104a456ee51feadfc532a6f52e5bca5eb9070d0a77a02624d774d4d2eca 1fc0934d38877661c56143af7277eb837868e8465f0a3351efe115d1f61a6b20 bc4f9dbd0695c462a8b57fd6b0af3974104bde49c6062b5c4bcd09615d028b7c bbefa2f48cf69f7b1df407805e23764ac7266494449ab9fdef0641b4f13fefc5 1c9ce4f9a6a3931a3ad753ba874fae5acd3e85351b3456dad3c0a8ef85028633 b378c247b6855244af5246a0760ddd1a703629716b16b50f2f7afa5ebfd57e01 88adc9c2bec405b609d7190671cd84ca990e3f2794ab3550fcf5ceb569009fa9 d063eb0d4f7ab5f0b7bff340644c61590014570207189c73846322e0b77f8392 7ef5e21552383ce730b75abb6de94d8623ef8987e2d382d85dca46d2f5b94324 7aeaacdda090144ac43de8e04075421917f57f1044871738ad85c3933a7b92ce 73efd0833c7b48c215c0f92d2e72c9584bf1a5d6f15c9d99e19a6f6808a9ed8b 65b8c07bc87e20fb9ca0fb72787720d7a6653b04e11d4d31f6c699fed3ceb5fd 250511f67f3ec1d43778d1c712a6b72090c1812349262f5aadbd37e6f3cb69ef dd168f71e4b227d7417b3a6d0c6dba72b1fe04e47b3816569f149ff7e736c6d4 e1837515ea0184def7085f6455cbb2ea7d957942dc3a67d8c6c2ac5c3f588528 be818f8f702a06b5757bf5620b6ed5c110924a73252d5818b4903036b38e9ac2 9348070e09c4ea8e76401842a74161a94a84a46143a1242e60bcd7769f8c10a4 775b7d0938679d7a173f56742e08d0eb911378e65e137548d9ccf8ac6f61e00a b44cbf01cc2e599fdce193fc44b58c7e9f67532e6aa0cc18a771823b7709f379 2452d9e33927a56350678ca3975ed7b2c8e6d4d567ad7ac0e4126b1a55dde552 75b837f6b344b941183721fb45bed9ea0f5ad890e05f465b4f0078b8c860ea30 626ef8f4b4cd5a655548792ac7acb47f3bd0f22411a91d39a6460773b8b962d8 173a57cf7b632d55ba237914c471a75ebd5023b471406501db025318dd7c5afb 6e50ed5141d31c5c71a32b01dff6c0f9b4d1fafcdb59e7363d0b0de0f6f22049 353c625beb6b2e3ad123fbb9a5b2596f38021bbeef7b5e0c10ecc9234f6d553f cd24fa2bd9e36f5ff131b44852c0bcb99d82f055792ed8dff48e837d1b4212ca 2388231a621404db213c4060ff612cb04291828799919be7462d9b0ce8db9642 f05660f72b5d1b9c8713a957604cb32b1713a8cbe32a3ed4c30f9f581d1b10e3 a9604a2437780030a1ea1fc481a7d2d538570c08f355696156a8313c4dd6e00c b759e38e1dc01c64386765f177c8aa429cee8ead275d6ceb7eb13ba22780e430 aca51ddfbfb7e7d73b15a6a620bd5be30c5ea0fff58d2952f2764ea5378f8e15 7bebea82546589b5992f3990f088c948ffc03551d65275de4cf379fe08a231f5 637176cb1b76867a4a07c3f4a7e972ae621c128cef42937a4f367b5b52688ae1 444b6b8d2ad3f031dc9884f1c8d33bf92b0f8e51a9decd2d1853a613a09ef956 d2cabe5ea3d6b8e8539f6ecea33ec239ece6b1d362ec8ace8900c7f5d32b18d0 12ce5eb61291c983d787b75b4bd4b4fcec42870f7f1cfe8d7864d955705863e3 ac72fb9e0b6a14fe14a7e4313c3df10a5f6a4e424c8467547d02ee590df993b1 8e7757946777d73b44177c05b9beae59bc440eac16f548c95931ef4d608401cd 649919d443bfae5542ed3d35dda9d4a8f5027f8529eb735ed8cb27ee408783c6 59510fe2efccbc9e071932f0a1d6295e9f0c23375af49e4e1ac630b6b2ef7ef9 bf061ea258631a7bf55c1bb2e782d745f8fef6433688f4a254b5871f1a59cc8c 37542533284da65b04bb83ee315c0aa265552d9583d7805f02a4d683ebe87846 b32389352f301af4a588d53580b2af6d76947705d45414e18c4ba8865dff0f33 a48963364cf079b4fe0128013c3d937ec06ac6d3cc4adb28165c39a37a0319fb cd8c533905d1ff627b1e69130e3758472c86174adb5002f0220369d51133aaeb 61e6c4d613863a1bfa1f9124380cce995ac5dd90732f5979bcb29d42de22eea4 2d0723b5254153eb2a17896b7fc15b8059d29e5005020ef172aa50a9ab7ea7a8 8a743f0297f0efe2ddca293984ee8d3db4f5cc461c2aa9a487f13494b59fa25b e6a3d6ec91a5aa85079c7580779b393a04c54782b61e0bceb0d0d0275cacea69 0df4d37fb5c42f35624003a5cfca5c3d6eb240758569b5d26f16616551574ab3 c9a427a5d45f34e865751f516eb16c1645fc0d34f9d3f29d15defd41c90d7c11 d611c94f2cfee7f21c74272603f669eed93b9be74f5e0aab045bdeaf02218e11 4a414aa192df1dc95b7bccd5352c3dacee9da798a587be8d0dcfc2d932e53c23 d432cc97206bf2028e875b0c39e098029670e2c499b88ef451b95c526bba2f09 bc4594e40b1c06c2dce163483efb045e8378d73d819d4364f8fa4519c8704a16 37e6a276d50c83cb2ab5a9f7ced57f2b229edd17e2c91fdacc32d93925f10145 290c5152fffc9d95e8dc1d815fe633cd79b1427d50c8db67e8b68aa2c4b98470 8fc57c77048100572648ff75b9c5d82dc1c0d0fa5e06f05afbf9f201712adc4c 0bded12b4809fc9ac013e84373728305e8464ef4c098932625294a4011450e25 b8e535e32f58d625101ff5318e30492fb54507ed21adce526c366d5d3e6830e0 f8377198a04f2faaeddb95b3184eda59ab45d52583bc8e6277e326817f5e288a 8ebb388549bac9d0bc58a50efa290860bafb5c558ac5ff97014e5e91e2b5d6f9 80d45483e6d7e55efe1cf485514b7c9b15ad69550f8228adab97dc7dedb77f2b 860df3068a952468d7de7b480ee3c114e2af6a1bfd57718ea70a532156d316ae 1e7db7133690a920da094aaf299bce31255ebbd1ff89019334069563d97a428f 4f729843f70c02f0aae4848573fa65fc44fea293545643effc5a0414cbd02b72 f6ea093551a609547278602ff331bffcd788474b51a4ccf1576e9c8f4c351d0f 0d1425e162b53dad767159eefcc68e3481e7aa15cf5dde15c560e86e9cb0735a 0e8af77622167bf235723615c1c3d7a819ff60db6c5ae32e80f5a2856a68daaa 1e59be38167c56a186e49d712150083c5c1dd7588433b428e23062de4221fff7 b43c12e5bf504f04fdc66bda7621af9e8660bdfccb2816075159ac2713ca3f2a 9f7666358a33abab5fd147f4adcdf57bb32e12150c079be07d8fdeaa9ea8beed 521a52a0b3e192d19c0d35c561f27f6eeca58ff13e58d529beee488b93d2f3d7 7e7effff3b399f59166c50e33f5cfc0bb5260ced230184bf8992be8dcf887b10 ace89f0a5fde0334b8c4cd6372814c0e424e477a71838d4ee4be6b063ef83011 c6f19f9441c7443c9aad2a73076f466f5e4f905ea61c3f294bc20b588959ee2a 2a635eef90451e80ada03b004c75fab54e15e69f569f9c3e9129f58c713f2b49 4e822815ba216e4e657c7a4ef7937215b6d62196d294345f321589d5dce6e209 a68901cbeaa21bee99f17aeda62c6fe986a2938494df1fac1741511c6c11cf88 43d3eb9c030f4d9964d5e9c6ecf2b639525d633187e11f0da531bab6e5ee8a01 c0f196df45d950b38ec8d2629d12aab07856874494c29f71c6881c1d9854d2f8 43c9afda75cb063deb114f4b37dbfb0078f8cbee6b8cb740b97227cddffa6a18 d75e8c0dd232a4a241372836d8f12afa216dc4aba3cca2f7238d37cdaa54e1a1 edf772170c15f645d820e11095642e27a7fcb2a1850d1fd08f3e8f17655cb480 9c47f9140a0615c1532835e0f0bd405ce7ccc8b385febd11a1bdf68f3e921259 9d73a698ad37b84a11b02b49d6bfc96929194baba505645ef1761bf23fedcf61 2643526f0e6e1cf9f2af821278710b7065f0cae0ab880e9058c329ffdfdf3ec0 bb76790fa787e08a246e71857c921d4748b40ac6e8451baad291e7424edb40c8 35e56823de9d39318ad185de2a1d4568835b54a6abcf49eecba5f97ec49006c1 9c705590ea073318a4982ce47e67d422e751ad1043f7510e6a104fa8a7a81496 1bdfd29ec07987e54e8c928f680cc028dd1672ee6415727a8d66639cef804fb6 6b389fe787a31b450f1818ffaa0db20cdfa9b6880fa0ce0a7c541a90dca40242 dde10545b8e2fd54ffdfd483c18afccd262e204605538588848ea1c0c99efb03 4a10e9ff89c15561cb1157fc992e6133281504420f132623b9de3174658d28c2 c05d11b8468a9c285d195c40436785b680eff853135ad3202d85fd6b3b71efbc 709d67e136f6fbb15c6b209d56c894a0012d3a3010bf785ec6cf46565c7ecaa1 a551208cb6283ff8ddab393d47d2f930957a931a70212bd55fb83eb03497ffb8 d65abbf9e83cd429a72a2c0b11e878e5a4de06c256eb6ae8b7ece0ee7ec4e899 a03de6ac90e23e9470213a21b251e70e74ecb35077f2485ebb2f7d150c1f79a1 83ce4ba9a0d68fe3ce9421f42b8a010c550fb6100c2f8ab008be42902f3c036c eb4edd84bbf5d3299f3dae898586c55b4483e0afe6f4c253a779b59a928d21a6 10b0465dbbc0d6ccdd8fefadffcdc6cf636c7d6eda6ba735718e6e0bd4ea0ee7 f77556104aa4371f176d65aa01c0c3dc4eda40e10df76beb443b450ba666c16b fceac9a002728d8175618729f289d0e9a1dfe429ef2b9758aeaa63990daf74ec 96ac9c4c4680607dd545ce646e48ba793e146988aada0c9c0581a41c7d9de1d3 0f749c6dfa9b9d40996764cca834443751a654c1396161ff146f145158946816 873a8cfa29fadc9e3fa66fcdba54a99c0d5a645880fe162ca31dab20003988f1 a9138ec342b3cfd9fb544a5e5c148d2ca59bc62f54d27fb22c39e6f6915ccae3 e43bae09f5a5fa2596ea6f61dce8d81f0b9d51ae509cdaae1a24b963c274ef40 7a1b36d60806fbc951852e66ef531c403925e9bfe7ac324fefbb2fd81a43baf8 fa159a7bfc0fd40d2bc5a70a1bc9852bf10bcdef8d8e2e1ca9c62161b719e1e6 ca533537e8ea96c9b417a07b70a3ec07d0ec256f1bd14e8b34e4d1c89f72097c ae8e7c402fa13e037cc53e9fcabf06811b17afa21020b647b1dd686834a2d67a 6ae329a6be8103e2e4976e0950fc024639b41b8bd921ce630667216be4359db5 1a5b42a72f462555ea91f9e43c52f9154feac0f2b4ecdedb450143d090b93d06 f6e54cd2ebb518244dc737487da1d95e303b6ab78196a6c9c59212f18824b0a3 51ad7925ae3bec9cb057ca255ae54aa59698c225e5a0293e09d0e83fc4e5b7df 4984ed3a617023b33947a5644cd4bbe8ca79b562a091f7f61080c96de880a9fb d9fae11e8d2eca9d88188fa1b5dd6088ce1875eedb85335003b8aae6abef11d4 e20fba3947dc0003f5b6ebc49a40df8c029408546659375d5b22974c7d3ed1fb ed2616df75233d9c496a1f0d130ec9bb0a318c0b05047fd8bdcf1ebc2edf62f8 482f06cb80351780d5d49898014ed4f4582348c4ad33f283311027382516c54d a59efdaecb58328250fe5e506a5afe36662a5265cb4782eac0b3839761e87b5c 8870807b28a03b28321d06f6296ecace564cdb01d7f37592168b2d2ca075c7c5 62a59c15f0a3dfb0c1949dbe156c2294db9f840dc3bdd4b342b8405aa28391fb db2b5cf69db1da72690f3d0bcdb621e1ab6bf2e8e40e1d0202dcf35d49904067 31aa4a6adbc872d7d62189c83880b5ff945bed0da282b75dad30a60790c0f33a c93ac37aea14d028789d9db7fa08d8ca9856c4b1c101e5f212a2bbd71e1784d3 c8bcacc9a538112417d16664b694a837e6d397b1a4de3aab80db4d326750cee7 a784aa9d92f6e9379e576afd1175a0e5b0540f3145173fb30784a830e85487dd 0a564ec2c2d56e504bbc96330a884de705a47a25142e44e039b915264d74fd3a eb71a630f352135a48b03da1d0cf9d96832fa4ce940e6bc1ff73c47371b47754 36431d4d8a33fc41e52add24baf42d705860d5cfc83aadfccc6e4fbe7c6c972c d16de71a298b57cb77398f2f0226415bf28602c439bffe0334b0d68905d219b5 4ffdcfe47d26d0d30ef567366c6eb46275989a8f847b39a8f30d89a74ebde012 1c1832371c681f58df93c6c4fe33292285a801c2e21ded6e8191f80800b981ea d5fe4823f4b5c221a275060de1d1bdf72672dce31bd3f2e0a474fa8c38c41077 bab9b85dda37d0559958c8cb542609ac95a5963fd4631ccf14a6535d320cf9e9 15f589eed4f67eb0593ac0cba466f4b1be1bed4fca49aca54536a4a24a77f29b ed67d0fca43e7dc33c83efb68375c3a19fa8eb4536c49acc27621ff542e86ab6 ca9dbdcd0b47bf2adb0e773a0cede86e7dd2aabc5e6b95c2fc3c1b8c5210ae59 5e915792e97503b657a9338082f5ba9b24e2fee4d1a2938a3acc902e3dbf4997 d633420dafefbf863766da7c63606d22239d6548894e26f06d891bd406b21524 cf4f849796892dd5adccde35a74999c25c6ad3c803718becb4243ba6d8c7e1d5 13167c9c0793e87af248369823f245d99592a43c60a15349d44fe233c5bb9f2a e183538bc5ee8ed570eb66d393fd056793e269b109043eae5c01a0a090d18b3e 276b50ea1b15f2a45809d0b22cc7834e406c1c1054c0c7f7d8525c32e10719b3 191e9285d6d24e95fd7934a09d44920af2042291e4c9a8586e0515225c8413e6 de9d26522bf6f4ed113d33a1443c5f160de08691daf09272e7ea03232f4e6e84 d333341edd7b38a52be376f8287d13f89bf6b01dea8a50aceb421d9f602b05a5 b8a0364136c444f623e4dda641be4088ffb270a4c455c6e941d341681c6d6d6e a62fee4d42bc6db241ff2513f2540f6c7db4fee24b129717e3004f95960397af c259025eb09f04eb7431f508b3c6999a3418bf6bab8af9b55cb7d3fa4eaedb87 c27c59ea6664edb562515b3f4c71715483aac96657e26017b054f01777db8887 f91c66dd8483e994c9ebaac3688076e8797d4d67668909cb2192d279d42379c9 9f58c7886468a9c83ba1642052eef85ed2a45ce928fcf10d173f4ff4c89dbb44 4653a8407b6d1cc000eb05b1b840dd14bb6188ef1d37a8ac72e12217fe166472 93b14e264350b8c30798d2a39b9072feee77dda2b52e375196b3106022b4bedb 5273509157346436df1b7f67faeed0c0a43e999f398466c246bc2e9286b87459 10017a84966ba1304aa896dc9fc5708330f19054d064687b39376a9fa3241fb4 9d9063ccd0d2d540300637243750c6bc652c1f119651f81140e5322879d82f8a 940eb9dccd7636d1f891ade6e4306521419fe57030ad7175cb3c8da0fc72304d a820c82bb599fdf8d086d39acd194e39f132a85f18d8300f4cc56a8220d225c2 233233f3420506c6227ac4a72e37a4bc907d63b291a4f32d4123a7da47159514 7fdbf1d6f41f271391410a05f7a8d30e55e1777905673b8d4b3d5219a47d656c 2661848fb57f9b929c0982fa6fb2ed2e504d2d44448cf087952dde5ef2ccd758 07621d43208d862972ab719f654d757ceccec4f52dd70f013e2cddbb6119219d 53f0af85e186307dcff8b2ae1b87f9dbfc5250f5bfdb77f36ef3aee934853150 34c6dc33ff9b31f5cb61c6cd9cac5a57494ac89ff81f6eb768373507e2331f2c 9dd70bd2b9228331231be2a27d40d3d9a1bcef5c5065ea456f091d554b47e5ce c3f51b37f9ca58c36acc1832c7a0ae39d1a4cff8fd2f754d3d05d546d2c0c561 362b58b15e123a74435aea20c0c96ddb5ffc7413018c4ff6540b6c3b941d1b88 445a8726a0fe3b24c15b4d1df672059bace0614e07f61b3984a624b9eff63aaf a49862a6574460fc5e9b3432da844458d407ab51632f28b02aec0d5af356937f c9d3ce57149377557ebb03ffd48b85bfe30f5fe44819e2d589ebeefd05f4da1c 9184c6dcbadcc0425ca7f69ed9a5f120cb9fbd9126c761cfb10307c90f75af22 e5b3ae461948bb71e5d5c1c408cb68a6fc1773b89f2a16fb06bddea5bebfe84d 78717fce1d774e4857b31faee17551a3c70a161f9733b9e82cae3839de372e16 5259c3ef1249d01c1b4270759a51df4e9c04dda8a96eebf5031b9b49ad47a5fc 2c0a3e8f2ac581b434d56652e75893f86395d8e34e0852ddec0496e35e286b91 3b2af796e8f040399653cc212a709de714d5259e74869c8ca1879c4c35b16acd db2975a318a9c2e4e8fa5be0c62e49d88c4b6606dc1d9cf71538c4508d68d92f d5c78555d2a2a033d104c868c3d908855247a0a9b31047b29d169b1be2eb20f1 d1a7e0ab08e9236ee740f2c42c57212be40213c9a5507d1f383d1c8371b47669 f7b7d65be98a75555b03e382aa01c790f1952dc8f8b019a34f2d6418ff64466d 773bc5294e59c1a624f89f25b359df72dc603234815e17abc0afe586dd33b264 25806ec523cb87bd4c3f5425a78fd7f879978b9d0a5bc2efc4db3a80340b91c5 1a0d6042f55fc72643c05ef6bd3a0c3a05589780b9c37779dedfabfa12be6926 4474180e2cb3f2d3ee664c63cda703a82d49c0da75dfdca8aa10c173a85d04f7 d2f254cb36b039214a42b95fdefdb45ccff86bcab3f38bbf3f06f7bd6bd6c324 fff1eb7b3a6e85f22fe1cf95d3d7e28b2c750a3e711b75ecda1f21279301cd7b d82cdfe7dbb0d0d15a39d392e5529b61256cf6dac2ca0c04f10c81feddcb5502 1f7426796d532dbe452a65916e56583c418ddab1d655dbfe9e4047d5fefa95c6 acd10a2211b93dbb4ab82079d09b712f7060980023a09ce67440af525afadf04 190 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 +generate_ring_signature 67011525aec41e62812368de7e56ad8ed15cd4845e00871483703bf9dcba31ab 819d1090586ddd1ec978a2f24412bab7d583208042f35c68d6ad5ec98752bba7 76 dd964f5695c3a008543c185f0a1b5fa461e9c22fea98d1af2a1e5d60cdaf6e01 d1b04957e8b634589c062eb1b743fa1cffb725a8e272703bc10f50d1f5a0642a 51dbe51747f44800638559a63971289e43845c9286aded8b96d55d982fa22637 81e0b148f3ce2bfb07971eb4acf845ea0b1cf1c08b27ace8b0714a78daab6097 9ba5b03511558e8edd7b3c0336d9086011c5adc81aaa03664841d8c62f1fd2f1 3ba3b659ae309970f3494eb0ec612a5cf70da1357bb5beecb2fe946a9913f6f1 882ea42f44c98b4e0d85af542d9de44ed889c3d65f9ed6d24c9eb751b640c12e ce38c8d666e28094548fdd3dd3a9e9706e0ab2c863d5e1c43fdbc0682bbc00e0 b0998d216a9ea0224668c114c8db2efa0a565838075f96126bfcaa22085b4745 c83836b02f86df9d9c8f753f52670cb80ec5b6b2720cb2b7fd7fbbfa2d838e5c a441967d23071f5a95a1f82f5e2ccecc2dd3d31bd1849d137c37e9415c01595f 0322b7bd2b2430e428c8f1273fcc36f45f97892b5572bc53163675abcd987753 b9e1f6ea22472fa3db4957c448172b1d58aa61f6048aaefb75d3c647743c87fb 348fea709d69b0752a6f382577e2149d83b39c5aeca6f0474d13b1d4627da825 50360c7ac3a214e93473db297a3e1211f08704061bc868bdf06976a95db2e6fd 8a5ed26f5ceb633b0e25b2a4410178c89ab38634fc36175aac9847fe666d6876 9b2690089def921d1d5cbf63ddd3f58b5d7fecb4ebb54b9b900032ef0d687084 4a22af02b3ee18ca29add712fb0890f5fe0bcd52848f1f8e38df6f38dd5c99b9 46b943bcc3d9183b473a4d522e4a1febbd713e23b7ec8959e5a4fccbaa9a4e58 ce8f7b05f9e53ca34b01d6a5bd63ee14991d7ba4e42a236a7248855832023dcd 851d02e432b19150a6f451c82eb384d730b0c3ce3c35a4505765785fc307ff36 7ede31e63912f8434bb525222bdc771cc1539e42cccf8953ed50b7bbd152f87a 989a4e49e2169c52b2e8ed72378944c7f4ca80cdfeede413096d6bc6bb481987 8d197160b9241e31906172e6e59aca990939999d13f247f5a5d63feb35218761 cf685e95fa014fbd3a7d23c9345b54c8918a82cf04519dcce9aba2064e703bf8 7b7bf2a667d37550e4e55a37e728ccc78cdb856082abaf80f30bf1b9c75805b7 b63b938e1ae69254a31620ed6db8a682a73755ed347b020e245209f4e5aa344c 8e1bc9db8e3ad41682859991867e2096c5e39067bc4157bdc5564c3391902df7 998290f1542e57fb84928d36aa67ceff21910f22bc8c3558a0ef10398fdfd3a0 f4aeaba0a6d239ea8a01d9cc7daf6ce0109d26aa92cb30f4456bc5eb2f3d6738 17833eee37eb03a9ae32973d56754808205ef421688f18fdce0caf0bc66e4f27 30b5341b038b23ae69a365a896790cd64aa19eb31864bb1638c08285909d764f de2d29581951dfc59b9c1d2a2a4ddf67919dbabf8a58651b2fa527c414a5cddd 0457828b3514870bd16433cba46f8738c173d41eb59ded65acc6c7dbaff5dff8 5c9fbb3ee625a4c846821074213e505f9c51d5358abaf3148a8d154cacc6d6f1 6c4485b140aaad6b9e994c7d2e5023d0940d85e19af437fd21f236ec3a4733af 88e354a64180b6869ca2192aff2b69fa306c43be47a4f110b85dcc5495f1c977 6a6a1de9b1c8cf8b9226fc675ddaf1a032205f897d0727829da84b8b89b22d51 78d1502e1cd1fe7c525ad2bb4f7c9f742d679f7908e1a2d4f7bde67ce95b8ecd b6ec7b175273d7aa77355401a3c36d43d003f6efbdc0a961564bad698e8264b0 b4cd90e8ea0018b56c069551b6c43f45d5e330633ef17161b85acd7418294d58 25281c2d7629d25ec3b0bfe45d621b5429c1588f2831611c642cc7dabcded2c6 6dfc0172238b46bc6b48fad9ffa9ca9e8dffd0667ef95611bdeaf212ecd6457f fd8836213387691d192f743f779da56e093a435d355426422afed7cd71d18cd3 d32a9bfe7024fd29b185a1308ac3fe06e21b181ac51ab2de211270a503ee93b5 d65eb25830cb331b5bf837c591ea4e4a350fe3cc01e795e0bed07d38b4f84991 c521b61b43eb63632c484c6955c669f84095d769f226524f2b324d4243398cef 3c282a717091456d676299112eee95a854a7a6a74e890c295071033c4086760e fdfa169265150e45aa61bb1450d7a1ff82a7f9f076bfd1ea5fcb3fc35b527299 139659524a57f89d2425bc842cb106d8c84c9dba73fcc03d61ef2b7e6ce2e002 dd28d9609d1d3e4f53c48cb86fb6af584275dc00ece5322836b89209bbbef2bb 139e90fd22032ea389767357866c7b2ee9a19d9637d5911e74556e89687e79ca f09a6690d27cd15743f95203885b89545c0d31d6f745a0c1830e9c2c613b94f4 b39a46aee128baa794634dfff8157c6d3971de45ea87b210a568b21d4cc2cd39 8f63b5d7703ce9dda77b5fe3a6569482d1a42a2a7e7aaa46e3f50a1bdd217e12 14f4e2881ee2111945d653a6c5ca978361671932c50890bb355f277be25d2a77 e29737b0d67fd4b843c907975e594978ece72d400eedeb0133e875cd65710c3b ea3cb93a2202ce93bce08902a70149ed46a56d01d646ba50c39f8fc122e19926 e60ded286f6ce5f73348f53cd99e4a3de0c5e60297be0d7f066fe19c08c13c16 77754e38b821d49702150ebf7f43fafb0889c05cdab297341578cfa18128133c 434012a532762ae1ebd6706d4740128e4f1c4b97488de8844115de50d7b9149f ce7d22e2a914b82c673b65b28172af3760540a84a45b62bde70bfd5833c33509 7af0361c2aed7982fef7782873dabd2d0ae6adc240dbaacbff15409d916a6a01 d3bebf533d2922ea2539d196acc3e160a8c776bd0305992eab11cee72b51576e 68bc2a53fe9f28b0fcac97ff57c0dd6469b3387741aab8bbe8779b72264f10bc 97741abb965b119d339269b289ad2b630e8152a2e8ab33bc9da9fd155a2453f2 a549ea88e7610bf3c7d92fb93bb175146bca920a8a566a6b8bbaca0c73fd31b3 fae4b40e6dfda8cd353c561aec3c9c8da0954d888b9c6adf883621b50c3c99b7 55e367e48d3ee954646ac39548bd79e9e56d216b1ffd07d7cefd5b99bf08ffa3 b5611452300c2159de3e38795fd01a3fc57dfaa516ade34e288e984ef3a0d604 3ac22c7a0b7ffc3611cbbb883cbb1fb6b4fecfbddf4d43c2c4fb484d4b103868 94d7a77a15bf45726606d1a5f4ebdb46609b7cf029cba1e51a629e1083f3d76d e7c85510fac98d7cdf17ff2c1103f65411fd196c37571a4d2002bedb00258cc3 023a807dfef8c1e036c0a55e6b1b09ba9aa0637caafee1fd1b283f48dcc7d88d 72638bdbc1acec76e018aa9671b04f82e1e0711f708f6424bd77f9c048060ab7 f19bab5af9575092387a5070f63e2c8bb72c14cc9f1ffd5944c2c24d82e880c5 b5a3a51d296fd23efced3457f883efcbdce7b2e7ac1514e5c51211be8c328604 24 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 +generate_ring_signature a204b66b297db8196c5e43fa172a9cf72d610c1a3e5c14a7e64b6e77a902a7cc 360b1eeeadccee686eabb2475524e968331807e166ea52bcbf4b806e056ee332 6 3a819e2a86cbb7c93d82eefb25ffc9d557aaba2e76ea0cd35ef017a0f9db4a74 fe4bd986465cd8d4684788e3abfeed9a49365cf9a40225a9b5f7a8f0d27d4992 ddb1f912f0733db94098ad017feee9b550c2afdae5e0bc4bdaab634dde7485e3 ea08a323f76486e70dcdc071e43b7458b070d5e15148e57268b4801fc0e9ecdf 16e7e2e0736b76d75013cf19835f4b3130b7761fa2f1243e513b1940deac38ed 9330ae8956224cc4732f9c94d92a3470737d4943400c6b837d8a5e4769e4c2bb 5f961793fa7fab2364e40a420192a778e214079b163c235d48364ed07808b50b 5 d9d377395fc9db6387bd2e0deffc0dbea9c0039dae2729fed1a5ab9c40bc0f0c998fafc48bf22b7b2d2ef2c5fa8782a0917e536c7574c2e4cc1e5b6ce0164402479427d64aadcd801bcac35d1daadf573d239d8eb8ac155ab71e62b373fe900901d6191f67e8feadcdcfe7297bcfbeefad34ea1586de8d086a7d17dbc6c56107bd9cff11490bf9c9d679a1477862619ac421b1ee38fb7b686f27b37112c9010209e003cb9c7fabf610a2b355a4e7770e49cb91cfbee549321cca8fc26f561b067d1e4d5a246d347f9533fc87953c822c60f629d700ea43fdf31a580ddc4fc906ba4f7d1396473b1dde7d2511bd5ac53f17896a06183eb9b9c9c320dd542e52062e30bd7f06190fe1288f8d7140756bdc7395ce3d7cc32fc582d5d59dbe31bf09ab9f3d3761d54d3d47159e0a4546ddea1b7eb378808a29b5a5f458df4348dc081fab8e442fb0331e650f4138bbd423ef4809a2066614352ebdb268cfbd9ef50a0f24435d4b7f80daa08a2ed7976d38174d8d5452f7609cfc44ccfcee6c74000c +generate_ring_signature ef79e077a9e0e9424ccd7c150414f789a14759ca964a0e13fc01fa5466c81e78 f946890532edc31375a4fc9e0201f16121acea77989bc1f44f7cc9e27d618cb5 7 7833f5dbe94cb5307fa63720d352767c4b1eeae31307e89dc2bab1b483eb07f7 a7c0d7cedf45355d0d2981b5f47390c3e452becb05e015647e39fc4221dc242f 883664c5618118cc6d2e9982d3e3b6d28916edb1db5db6db7bd5120dc2ed1f7c 1227bf14d8642d1ec64199c7b955557194a4bfd8962aac9236e38d25a8fb47f9 eb41c810fb20bed74105bc9cff98bff7526462572cf709a8b85ae65462769d60 55e0ae0f1a539622d44ef3ec8fa1565017e9f763c45f27eb5cbf6b926a414bfd 7af96fcfd866484934851fda064375a00816e21466ffa8fff2425997adb7c190 0b0c659145f52a67e664d6c06aa96452c552c1884cdd0f9e5b7819adcf173003 2 9263fb5d94e7365fe3e494fc4500ad768f81a9b3b3666bd15936850aaad6b30ed45a99ea1b31e1e0bcc35913c82d516973199d58034da218ea6fd1bc1484c1093d0b07ea5069e50240f44397c705d0f0e318756f9c060f3c88a1a61d7d57a2071e2be256ea12f47005b426e4b27dbd6e0a7b9ad6901c95aef1633344cb82150a2c37e718a0a6435506ab74de4eda571986c1f98133378f35f09a3adafac6bc003d58f39b9c882a1635f383d85f1709eedd7a71c2600d00fb70f843141ce0fe0ad68a4d5f3bb987673bbbd8f7d0cd245d0e84be2fcb646576ec9da62619674c0cc86a5a02fd68aea5844f596ca3bd7171bb6c7ca1b9c858ecda2591fab0335f0b7dbe0bc5152dafb81af94de5c4df035b4b7dfbc4874b3454e8a32effd397010df5846a88d53656f5e2687f0c4e81ef68592a98b72f4691c78f2f43b4fdd2d30d45a9d807f713d047d76dbd423223eb20598052cdf6a49b8c9c43dbb9c2d1250b1ca180c32c14873665353c7e316855738eb0becae0e9771efc6d40b3ea4be9071525755640de265576899a314b1ef06c5f8fadc737fcf6c2301fbb8515349a0e988cf0d6d90363ad4ed0eb40e7e63e3b54367967455a16de7327d1bc08864f00 +generate_ring_signature 78e0172eb16bc072a3b80ca90d93b44df26ffbc7dce563174f5865f7c16e5f43 7479b29e23de8cff8858d8ce192a594e7c4c3eddd8b898300b3994efab06c5a6 4 ca91beaf2146e06879051b0b1605935a0df5b5eb1ec9ea4f7f8d0c698e7c5bf3 567e5e858d217b840f50e66af8547d3bfd23c76290ee017b1c5ea07abe4ca354 c24d4eea3e2e636a9a24934ab8174a05043ad5612cef38bda772063f291d090e 7c51495c749ae14fd8ba542a7fc76aa77d4160b73f84e67811c1087eeca84d05 ae5a08468ae07c2ae86e46255bad3bec88fc27a5697b88a0a426c8ee41372102 3 50f7e31413f75f5f4c5707a2e0b246b703e44ccfc7562767cdf7b85e44249e0f72fd6b79a1c4f4e1e47df0bf479bd68028d65093a1ccae83e7b078d2c3594000979687dab48863baad8279c266b1e9ee63356774f90defda947cc31a11e20d06dc4b685dbc1ae7bdc4298d082f97dcc5891b265f912648529f97ea8a09580a0999f9620e1faee899bc4da7acab72b2c0f1b97fd7613c86c68b89bf254eadca015c68c79aa819a5b96b35b265c92e7c485dc7e733119f33fede7ef4bb9cebb603345109857147b716e5bdb56a9197663ed0df89c30c0a1142cfde91459c42cd066b02d43ece97dc229b6badb3ef08ac66f51e84119b508131463d5296d6e5bf0d +generate_ring_signature b2b17f8eddfd010da161593db87e352a00d0f915b3095657ce31bebcf0531d77 6d9765acd0f77a17564da4a5f7f07a0b918bc309f136baf6b452eff47b5278d4 7 0dec43ab1cb7836dd07b41edf9013b8f8565502509bd853b73a3fd7c2d8332d7 d007bdb3584697e80ca791a489452dfaaf96690715738e9d0a9772761622910b 3bb2e27057e5cb52140c29f86ec9072947931c4496da0bf88eadea327b45e13c 85fb98fe49d5489a55a67860a4dccda34a81b00bf5796565a5bca4258eae531f 3d1c25052eaeb43c950506c73a61cdc464c3718a502d77dab4bd23eb34093bbb 386800a322ab462444d1bdb3cd943642b4532cb4e6304270d56606daec593bec 898e99644703e2ab485bf42197618479f68c7767f1a81a754254194df7bb5541 8ccf33c9539ce3697c1ec001f6374d950dc0f5888fb2459f0bf5f1c12dd3fa09 5 10e8243ddb88900ffff4949bc87de7e1f03d84b0dabf6e1ac710e5d94b1b360e28cd117df72e1150e598c9875b5f8578186555645a22a887f400093f90623f0d3f02603e35beae29f56833451a6ae410405fc0c51cba8cd32936ba65b9199b06b7ba48299454ef41d90171ee26ca81bfac2cff6413afd2daf15e7b5c1b826c05c6b80c63253a3fcbf6c6204298450f1534d2601188b59915c6deeeb4fada850703e07a4d150456c7451daaff2f2625a0c2b51e973eaa4a0bed7875ba2dfd3c01fded17cb2ac3117773b764f7bf88bc594a91857a9958d8fe0b4f5363286c95092d4e945fdaf51bde0fdca132d3cef76918ff07949666bccca17a766f1efbc80cddf79e9cab89b307a49f8cc6b8ea54a5817e51a1c7c8c2322622b83e9da0f8049300c71fa454027c0c9385dac052442d7dc9bbc26b98a0e67b680540cdea58017528414d5712eb5833a01c5f7dd41440d492ec35cefdf1280f0a0c3a42393e0e7917a14b6f0f25808cfc3a7d2d9b4e603dc881e50a7ff64f83d1ce0be0c4dc0587083b4b062ba5cc97a03f79a7239bb581a259170e714dae4461db10cf26950a7aa391ed33ad28665a50803ed4bc8ddc0e3a0c5deef15dd6171aef30b0af4c07 +generate_ring_signature dccd54de1c3418a71890e09bdaea34de43197a723146a148dfce50806f6351d6 beb57de477af6fff12b965fcaf9ff7229f670af5466c040902abbaf20ad26281 227 de6f898395f9d3acd113f747c1ec42b3c669642e954e078a84625e04f1203a86 50e0ec8c3ba80da72d39132072ab6db97355bb6d689df8d49323d6519f7afe76 33214ddb5c37f8ee1f71d77ef8f8389cc93ebe3e0750f0ca750067116ba6dfef 624036187cd190236a3af52cbd8ff1551af9ea618b7ad46c4039956372f2b37e 4d8a76e47fa3de3b4230220d19f147eb2ac1ea9cb0e815d5210310474bd722a2 9dbcb6dccb566b9b4ee3d9f4dd096ad64b86de505861a4b27007ed26bd7fa057 8afabd34bb7fd38de6ac26b47d135d6a0c05b890061de8e26e719e87d1140637 7d8f3290f75e81a26454b06a408ad4a5a025586eec86b8f1d4a20c006b0cfd5a a81cb1aa8dd7b2845b6f62cb21e37327eafab75c305977a487c7dd9cd9b72285 586bd7a57d35523981bb88c3a05c38f6ee6f7a4596a5c70d9bcbe72ff94d4230 75c17101e9fd6868e7881f5dede9b009aaf2e6945858c286ed121c3b912b9466 bcb29dbd41f103217282fa56c1c3e49a30bdc22c29f490a0c87f15979e90db94 10865f15bbda6df7774693537a26ffecf4f8ed4a9be5ea8256fc5128a5f5ab24 79c038c008b87d3425473433d22a6ee12f6a94912b2b473be3525df20304632a d2ea981b421db4622dac964447a5fa0f0b91253cd985fa651a0a94bb06a2e531 40360e8d38645b50466c06c3d2f366fd3b41ce9dfd854b4b6a6bbd91b9f2bbbb 85386e78ee0cfdb9c053759b698aee59487b080a3f9bb73636b6e9a36e80ff91 938980150ff4af1e402456d64d15e1a932f5b9ae0d03b7122c952a35456b6540 aa274c87ccf47e58a227424fbbee715aefb91a6a624217bd3ff62f4295200849 17ba30bae32dc6e3aff58c7b865f28ccfe8ad56d1779c3a40c9091dce280cd21 40182f7b319e2332eec3a96ae080935a8d06376a85d50e1dc1e54459b00538a4 18772a0589e44334bfdb0154f4ab5168e7cb33c2aa77a7603425da7c12d6479b efdce92d903112472849ff28ca2f7e312873d9325d28a378ed723d5fc2d0dde9 c874df6ef1ad049bc46597e1de0533c878070fda32bad8dd6139e98b04a44af6 09d67f7cc7632824c92065fea6024d80f1a5c9c2fc97d66150a5e77e9b069fb3 7bd68164f521e0c47994aa974693f8bd236564ad73add045a1f06d5d9a42da0a 7aab16af4335f06f3f24f38806b10c20ecd7f75e16905a97caae144393c880e2 096bfb98ae3213965acb6b92a60066b8f8ee495df93e5a2944de1646c369ac30 460ff31e4a5363b5aaca21aeedf944a713196ca387f438268f5817de68c22293 2ada78c71e899bf785980d8cd94f027e365684eae7c4292cc7da633e00edcb90 b84693047173cbc9166b0ad16a918d2dd5cd5b4dcb3175343e2a061f83623e23 7fcbf67da417193a649c5ca188c3c330d1615cf12e6854cb45a7899c24e08aca 1324e3c54e30e3276fad872fdcd7ba4f9ddc97cebe3f886658ac3767d60843d9 e555257d3f2fd95dc9555f8d89ef1dae813d0f6a9ab1e181f7d5ada73c8efd3a e52d868d66be401ee50f7eb5d74746beb94f677a4254eed91ab753f738e75da3 1d7355aa5837df46db3e8e8993e73c4a294d646d190a73ba40aa3ce841a83534 1aa2563077ff97e778155ceb8f8b4c98e45295e005fd9a5202e62ca462f995e2 f4e6929b34d3833940d5d30d2a7b0ccaa425360c42effb1940a10f49abb4b8d6 960da78fa1fdebf415e0baf03b63eff38b81ed99639186748188c348a3d5d8e5 ab52db15249b26d53920280b2b4686454ee211ef81bc330128e7c7365728d36d 72182c9dd9736c191efa97312318003e1550e18af5ae7b5f57b75a78d93462ae 8a822606f03874e68a1297636b7ddd645966b342ed11e826390a85d6fd13c3e8 77ccb0cb46f40123a379e014f46103cb21169b8f8dc376f34602a61ff3a164f6 c4a730fb9e281d183e142c9c6256183bba9f5871290071ead468d2b5479e2cf1 def7aa66dd688039565fa35a223d34c83aeefe5a6e702889eaee554028efd3e4 c42af9fb89579eb04d706df14cb7c47aeb844fa1c81cbec70512323ab608eecd 6f7331a1adfd3751d3edc5dfa02caed59d35813e646c474854241c7573beb1b6 91573e6964a2f69fba125d7897ee25fef6b0227a51a2deff1dc9205ed0778ee4 ad9bf2a571f586d8368024107021af31d5f5751999b25129f660f5b63cec9c97 0837392fd063e15910d2192b3c180228bfc7f12dd2428a81cfab8f91cdd44bb6 9c363f58e7440049d17164c4bb1f5a8a1ff444e1c26cc1ff97e43f4fd21f1b56 7e3e818d6a8d02896dcb8a7d53add542cf205c46108773495810bd8848d13e3f 4788b7a8e7b695a8ce58a3d61a7a3bd37d2c65cbcddf0f8402dfb8a5b1996394 fb352441f47b8f406cdb638ac64e7b6e8088eefdc9e757b9eacc7d3f72222a82 02ae8186d25a835ea25bdd979a85e2ed9681180b51fe5812ed67f431ae4c5f62 099abc67b8f2b1411f365db32e1973dcb2f6193e674f5ba9615cd3665a509a22 f140bb04214d43c84272acd28a16c49e2b6ac054ca2edb06542c2c2a764f6a80 cb2a56e6e72f1017eafb033c66e4899cc0da2b161c47265124ebaf0ce5c4fec2 838c1eb32105b74439cedb6bc89f68fd1e1359841994b58a4a7aaf5475c54323 e1c28c4e44817363335668ad1b2a38b2cf8ba1c0da151c1793d6cba07af2c5c7 3cf16340f818400832e2f4d3ac53242aa822b581835c701be359124fa74d51da bab07fc6e7065cfd2ef24b0d99bdd0a37b7c3a94890a0ba6e112ecefd9b59fcc 69ae4430e581881a5666177cfdfb2aa4d076e7c7fb1fc1df85f4a42631b652f8 5cb788dadfc2f0a8a71a53cdd95e973eb56ee8d8120caa38c9075b1e1e00620b d37ae42bacf5b181aff456091f7142680b056d866e1dc537b4c9c7c47d892068 5d8879fa016d9badd76b8e69f77bd6f02ad5b0ef79323306e8cdb3d3175fab59 b7e0d03bcc3356971ff4e5f2014a1ea9e2b8a3f87a170d25cd334ef440f1cca3 1cfcec5e2dfcb2243be40ae986f597f5e62efe2056fc0ae0f093a1ef8eac4c10 d45fa110c2c973d529ee68f8b00a7599c9e9821af0006cedc1ddd6ab3e37d9cb c003ff2afabb78406fdd999a1b48796082f4106fb616ba7afc27b475f2d78b79 6579d1ac0b18977a0b4a3184901abb13148a833b29445112fc0936e7710834e4 d2742bb8b5bd2fc348adb9121eb048b842ff428edb4cc0e628a51b235453c183 bf09a5bc58fa250176148cffd82244e614b0fadf94c23e53abf288facc92510e 6d37834e2372f26ad0ba8c510660ce2d74a495419065d78480332253bcb686e6 56d85f362ed1b9d5cf0cc9b22b58f704d7a1d18cd9799621c158e0cf6eac263f 15c8bd061f78d454c02a67973a18883014ea1a506740e3231a9b942b405099de 444188e9d62b697974066852422a091f9f9687895db8036c4baddf71bff17b63 652c85a355ae256e65bb47ff48c0f421633806c127bdbbc99b11131986a17476 d6d364039ad279968195fc81f2b2b1b8e315fdbf21618d05976eb434533ddbc5 082d940a66f319b4f2a26578dcb0277c9dd241d209f11059aeee396c767d6943 0f1ba3b82c1278d71c7ada842514e9e8a6b03d49925f279a55d84cecf4b8ea97 64369ba0557e73fdcb4fab986fdc58db1965fcb1b5fc2baaf7c86bea7e4cf0a8 c612977b21bde87630763327ba5fb9bda6312a03fcfed6aaf40b56e65c945789 8463e1860d65d4b64eac0d5367a5af5bcfa203c16dbfd083353917a61a74bc14 4ad00dd4cb6e7b62c74a36ce1ed7720b8c6453b570677012091f47ec7632759f d544467e93925c0fbe87a630d5a2471f3b67e79abfa1f8d3e89833e36d57c7cc 1127b1aa8e3d8bea0b4a9184720eae39e1879fa973d87966cd3fddc8901e0ed1 afae49672415a9cf1aa4f5d5a921e6ade299a517a5681c5888e1eafac35caefe 1bb1d53b9801aec3210277fb8af2e473a8d1026495c0900735d89f91adb54508 53c979d5d09084b0d729b5e740ef1ed51f99cc416b3096869eca4a287598cf60 42da4fc63c86c7a13bed979e30195d45e73d0b959865411465c2ccc30983a0e8 b0e4fa801af1c5c2834b31cf80831fb11d626020255f2b0bbc7c96465f523288 2af31e59dcb552b4eed7558885de0cffbb5cfa7217b423c590017588b488bac0 6acfb4632b22521dbe49fd353a239848f53e7265d43c89b59da8b0cc3f8303ff bd720e79385f6d2ca5f70fe141d02b50e21648cb3f959daa425de1e4392e5c75 0e3e941a4fb0c523195cc6a0dfdea6f52c566ab82c25483b9a10a9d11465589c 85fea41341b6d49d4823e309d4468d7cb655811177bb8a53e236c0747368b819 32593bb228b2f454aa091fe6b2e4716bfa29be3089306895310b1f2f57230c56 4ce8bbf39404f890dd296a2718624b8845eec23023437ad83dd3f90e3ebeb52d 434fc3946e64e1d07b97b77988cb48b8ae1133912dce2b9c1902bb9c83f63886 14354e897eba43297579a03878669d513e37ac42bee8e7c64e354ed39ba6ac3b 67c9bd298f98c083736bbd6511fed9fb238ba09634d630acf8c13fbf5d4139cc 3c77c3a7286acbf62237efbbae13eac56c4c0bd55f7fae2176550ae2f49b6b46 5149f6fe63a8042b6fe16c6e31b5b3da0245bb49ec249045152b1814e777efa0 e9c51ac176861a0c5e72275c34686f38e8fbcec99f81176a4f280e50c1d68de8 6d2de0ce0adf4eef46e9bc7a082ba9c45384c5e2766f7cd374f6e7ecf767afe4 7defec0b1eb6aad14ba9f886a3bf94df39f8f9beb4bf3dcfdd8e9f30c74b62fb f816bc04b50cb419e5342f8d9c1c45f61e8f7ee1021271cab7f60eb938619856 4e740f39bde4b3ca794f5218df1045ad330c992f198de22c7b1581e585f6e8bc 2a707dd3aa3ef5a0fb89987ef90884797e9b679941563b1b0f0fe482df2cb704 780363e8eaa858601ceb6eca2a95ff77caccf4a4ea15893dbfdf1d97f6196b5f 7954b47f519dd86d64fe572f5c83746dfc6cb7ffe388e257e5a27242705a615e cd730bc5c83ab9fd608d5e4d0ed2fb3a090e993da29c0341120f94940fb31a54 50eaa1323e56b6cb217c2728120f51cb7fa19c2dce41be26baef95c6f61cc276 811817719c3c0541dfeceff7756e80f7c868d56d6bd06feb1027a0c37b9957ef 1221701c18e4cb5e606260d2a85c99433c136549ffcbed18cf2e843ac4118695 972eada79c154e43a5ab8797202f266809d163f8a1496bf750667667d1f73659 812e63c9f4f8225eb94880915c2142e26163ef6d27d4a240b9bd3424ab0568ea 65e81550555313646f8ea5d2e1d998039c087825103a1cc9aec56489d6e7cb4e 4cadbcd7d0be79f6f32dfaa6a45a7479081bb824b5029c3efcfd51cd218791db 163486ea2d379505656ed6065a355a2b5a0bec2f1c56121047e2513708af0ba6 e312f142355698ac9e4705286e24ce259986cbf9c475be9908484ded0aba457d 5cf113e03b26cb54d5f672b6997a44b28af8421d258d1a51244abae07783dde4 7d19c56181925f1502281af675823ed9799978028ea3fde25e7cb7f2b2bf1af5 561035986edcd4fb791798407f9351b9d15ab7ddec1b1156211e4372f65c081f 9c2d63e65438f187250b110223fc1a41600f1516b75299d418698ebdb278972d 8db1c5443b19e83d124cfb93cb7659022e0ab39ca30fceb1cb7eebccc04c33e9 2a0beb68b0cc5fb35a2c8ad37619b7faec3a573380101bb1f3f8f930e22f17c5 95a8467c529e347700ead64b0f2b2520edba9317e1988a5e05b48d88de6b23c1 1f07b7c84d37af770b0d4dd3db8031fd8671db285db5fb292bb24b4cf03a66c6 03c26aa45c9344f2108ed8bceda99db51e2b3e476a9507305f4a264cfc22487a 7acc92bf21c416c9c2853cdbcb75912d17768c0558f45a4f9dd89f9950c04925 570dfcad88ccc890f989f6fa90445433718d1a33c2f6cb9d06f01e105641a0a0 0e703be79defbf776eacf28e3c02faafd451295528af4c3c5abb85af27a26c6c 8868637d4111edc6b9967b4817419116ff4e08342f94a1c919f88cfb66511db8 ad34c041687a0aac2d5b95645c3be9a092854f05ca306fc4df87b66fa20ac854 3c9c07cb12c72cdbd9c0a53a56dcf49286ccf1443bb46e389bc7f98e9c1e5a08 0a73a13db0b8a4cec8adb5f49b3ef1aff9116ea1b40907e7d7d53747914a6165 301e0e2771166d45a7db4739b33e67ded6f458140e03b77f7dc37dc10e5795c3 456ac73e71f674bd8436300971c616ba64522aad67f199c8600ddf5de5a5e6db cf529e39c63f83fdeaf309fe226248dd7c0d8ece4889249b1ee3f42802e84bb4 6c593de6e012579b5cc3f43dff7ac21e30433117f39e1dc5d17627dbcccfa8bb 2310887b528cdb93fbb62059afefb5dc8bb1ad99a6c26f470e8dafea9a21b75c c874e7cda400a4a7d347b9ccc3849b871083bbe16ba4a0961b5407d885d885e2 7d85f52aabe672cd6374d1f45ee2b8bb64bc9aa713c9d5b11164358dc0618043 ee63fc1d84e5ce7b6fea05733df25621d53e2f8b59d46cf6d3c206e0a1a4bbad 1945742ad66ed67a7e7be7619553eae5772137b123efc125cfa56771f73628c6 16578d8f6792c063ffefbb9fbda79cc2cf4a217a15d09fd6d9e8c6f5cb3edfb7 2fb93dbad3bdd8c52e66bdecb845ac12df250668987a46533e64ee1702586c11 0dc58bb319f98d536c5aba1b410dd591de2cfbbcb9626004e73f953989a09063 8146f9ce2ec99a5581481f5f9ccc32e31550925b16239c20adebe48c2a0dc8ed 6fbeeda5f57a6c3bec5266808f679ebe1786ad8556df24452d9465ba0163cbca 434b44876cfb72d61daf97f0bd8aa85d323af4320f52b880dc55a9c06c3c1463 c13ff3702adfcd8acc2a0b6e4e675b82f503549dcbf14a7c29f66393fad8093d fb76c1d8836c2a1f718106011e3dc5ad544b893726fa72b941d123ec6a20f785 2b7ecd72aea8643057327b542103b08e00b79ae6198592dde61cd62929089e83 e7cef581b5062606b00a2ae4310940b5f18d56d2742705a8bc3c7c54042c1694 d5e7cf1bfe62c0c6abb750e4b22fdc9b11355e4b34e884c94571163d21a81d6f ce69ce14cb9153cacea90c7fe3e8460653d27c61d239718a937f1fca35f99d17 b2aceb0c7bb9a7f865b3f01d06eac0cb1d3ef32a4e2145a49473135641276c0e e0dd5fac25d7e724aa18512adf237fc463676a5d1c9ce42c6a8b2c5cda013506 f7e58fe431e81b6fb8d5db68f69a7e4596c76227c0291f73f9754640085c7675 b63f41f757fe3f6eb32d2b7ecbcc86dd06d3ed3c68f22e41db42550913169a45 3a143a89e143e860c93e71c71f42a04ab75dac68baf92da4fefa6c6b173523c0 7417ca2eef7e735a3ab12e4a0e3b3c2439c71dfad03014200b8192206acc78f1 3e0136f18d38405b67567e2ea5165d8782a1ced39df60f06980d3d2ad9d24f3b 4a3e58971a4e4f94ce12c054249d1fdf9dc371bc7b5279f78197800c2a51bb46 269cfdf63c238721dba6bba1b839759bb0fe9e83d609a2901d141786090c3f94 95eb48427cb6c4f471c2ea568ed9df6633862be02cb2ca025c73b2d624b056af 421e453d565a46650ef8227bace09af7c068466da857357cd9b2873ad1ad09d6 822692d9465ea2005914901f30869c138f9a6351ee06b318ea9a26d443d97d39 fa23a03fc5b0b6e1150a54fe2bdfc78e925f4a66443f7e4a918a7c44cdcd05b4 c40394856093b0f40c439a94508d1fc3cdd5d6f1747d7a876c3250deb24261f8 0082526a179e1f85f2c456b87355d540144ae21c53cadf9783c5a00cc145fa73 91265fa8f7e3ccf55f695c17a0004ac429cfe485463c2dca00a116b84883ed3c 81dc3104800931b6a4c5cece8d3e2e8629722bdcc210bda4cbcbf9871a43edc8 aeeefded266eb59949423a42d3ebc1af07873e1e954696bf44daf3a75e7dd5cb 230cb94219fe81dec527b602ceb442d2fd047f5f69f94e5aa5229e18ce6eeb72 e495df1e8aa30144401c58dd35d99e206efef5800b42ae2c855ba2933ed1641f a3aea8193f840fd72d17b18a89b937a4892fd267a117d45db566c334763275f5 21df42a8e0ebc06d0be965488fa6bc6fd56e9a8071e7d7066e9c0be8a18715e9 199b10cff8216a7ee22ceb37cf3c03d219233e65a473f26fef00137d8c52be50 69375507f886578c829b830f5964a71243a21a88b9aea1555bb34b136776ae64 53d95e59a7cec2ea6ba975536d48a76fb560f61e988a7d5e27b2564c4e429450 9840ea72bdb5e374a4b515fdbaa737f50be2d4115e4192d0973a652c10d553d1 ad8d699290c6ea3864c6dbfe1fc2df282a7033a115ac050af16cadb47f1814fd b9b84b4655239182a7c635dfda8444a090d56ad9f36b39e49c9cc04c9b903d5b f5c7569fa43ac9d2639d582f90467c15ff8edac68da3368307be710019cc73af 52b6e9e81e004a4d350d87b19d86dcd759429a09954105b4b884508d0fd2b022 194d7708a9ae555cb73ddcd4b5e41ae54e297c19b03525eadf28030b16c47388 d158efb1f35f7d182a24ae62a543440c932d48b056d62a6bca8da8fa388fa251 6aecb71bb4a7ffcd6c4d15bccca66e1f2bc16d4a6c3d75990c3dbd30800d0282 5ecab698f65743d8bcd619885f36e574f28ec1f665847dd87ed66c7bf94bb8f9 5824367f4a299d2f99dba1bed610b421f6486ca776d3b1b3e8ac8e9c7567b4a1 9b1a0a3bd2e544a7cdec5b13861e77c8103386e57710ee6f31ee7ac777d3e089 eb852b565d9a9a4b1175a30bef0ed763c6d2d0369dee85bc28671c7d50dedc79 845b3fa7475922b76431644b6be2f0cd48c997ee497b0e3ad7ea8c3d1061e1da 1e9b85af0b4eaf78c85ff0089c6888b8cfcdd54f876d7111a3df6f96bcfcc678 d30f8e5b89b088b901c943e89f093b40838b706757139eff1b47c848edb286f9 aafba65a11d917cd3b38bc357cea2ea44cd018cffa6fcb9045e8b35501f93ed0 931de2cdda585f0ff0f7f81e747c1c5b20ae49a930a943871c8581dbfa5467e3 6f7ec2a05580bea3790eda02264a371e19ea10a05818b2d1f9df342945276a76 f5a08ffbb5b9317ba9281c7c77f3f6b91b02a17b8bcd51b7e0b2a84bfa0399de 4737d5fea3b9e3567f1c74a6527c2be489002195ec96c75fa7a412fa020c4b90 8693790f118dd039b89e51cfa8b7887c98bf8145dba4a981adabf3e354e45d77 b8a660ce9846d73f1ebb888faea6345ddc5c2124c9eecbab120d6ed427c59f2a 4b1ebf45036321b68ec8b0543203d21bf9a639027fe58261a98b44c0af19bfbe 24b6b654c8f53fbe508e669b3804cb9cd55056540a9b7df24ce403888b3999d3 fd9930b13d52c5d70440304d0e1e5b54a4b6b1ca2a435677c5f118f07e2b36ee 717eaf9e1090b2f1894e4678602a3cb5c0f374858af6b0d4fc723b396353ea1d de9c034a546b2c6cd88154fc9eb766f30b986dac38c3cfba22b16ddcdfe9dc7d 93c221d3be2d20f4ac343b9e67beb6dbe181acfa2e03e80b536b74bddd754f38 4e3424bb19b878f1845783d33117f315a972e4cb8a4f5f39218ad3eb081e07d8 4f254a776c0f3bd7779c82c22c33390aa41909c89ea9bdcad91dafc6e4003050 2050b427b2a2ec9dfba6c86014777901852742c5783c8e89d114938ab728ee18 9dbfb19eb52ca6e2ae0ee44e5df65bcc5e7439af40389244cb3b54fd9866aa26 d8b8df21ed6caea91e075382344d7e63de02addc86beb7d76be24ef2155e8353 22662c59ef7015896560440498100035ee0763c5a6de0b263dca397058523c34 0b8d591914e20c40bb5fa99de44ffbaa993b8fb08938e3f5033c07f9e4bfe881 55f9e2ad6e2699c81c525daa2008c323a0978a3b85dc99d591dda69f0aacba72 d228415156119c0157cccc74483b149d443a4ce32971461239627b7aa02a4b89 e8c7e96a2ffea407a803eadcf5ddc6254795c329a6f7332fe8220bd26cfc83f0 6e14ae550d01199ae9b978ace5b382fde0807d8671827a75f3951b18827527d3 259bd7e461198a3ca17d4336ed9f6214cfd10404d3a6f6a9a0bbd87c26bd9076 25e4b2650205fe5dd3c4b1ec5677389b00a4912b5810622b505d72125200a42c b38caff798124570938f7d2e92aa8b0a37229020355e0525069cb2c2ea16eebd f6d09aef0f9a2820f555475e44521817a2044a407da71731aac20fc4b6f2c26e 1fd4bd9f88327912a6c6ccf04009e9bd3cf0fe43fd654e1fe96382ff0ca4c509 35 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 +generate_ring_signature 511e40c694c62adccd1cd78dc759ad6f7e6dfc6f65c233300edd092548e6837b 1f100b5863c7a8cecbca53896f81bfb37129724d1ac0482da5e3c041ff57c7dc 1 25fe770727b3555d648a78a3e962b1bf25f9733c0fffed8837ced7e2b3214a07 805b31538ebb4de57afbd5abba894511ef846fa6c94906865803092d7302fe0a 0 dc36936e89643be02e4859dace1105be15ffb8466014663166684a8d7412c30e114dbfa4a99635fec9ba0ff3a8596e5619ae787eb6c2d375b47379aa4f0e840b +generate_ring_signature fd1acd2eea26d5ea5f10a0b1e26b68e4e89fb9760cb610bcee9a0e6903a25904 984b195e9d1b1019e51a1a00ef3fead39de4a03464838690084b5b1f5b49eb4a 26 bed2706f07b60e6e4ffa986002009646f5ea5fabd1b164bab9644b690893d9e6 a4fb36914b96a15fd407598ec221d6d6a06bad7c21bfd0079e91db6b64048f91 ac5d1a9778bcb740b0a04211516231df150d714a929520183c6dd54153b07eb0 c82a344033f5709ae3398a87d909ae637b24c0b355d25b76a04fd436c0c01488 56bfdeae80cd043158fd30b06ebc4605b4dcafcdf90db2982f1cfeb7e5494ddb f6d0da924cabf77083bc07058088dd8c4074e33c1839d7137b59cd665ed18637 d4897cf986fc87998d75784803bf73a1e9854612b9cabb0d5a91754a9587c83a d0261ce00fb5edefe2cfc4b2f1152a5802e64bd8bed7ca4d5ce7ae8e6be671ad d5d7d51abe48bb01095b73590a322c95d0c2d8aac5a30cd9c071d42fd222bca9 f6fdb08161059d27e267b29730e633e405365951a79a9af34e64b2831510bc5a 5dc9b05fb96aff4ba4d6589ad93d086044a0e6483528706bd65550ed154657e6 a7766d3acd6e9abc9c2925c3d1060214894f6b084d42907bcd8ce486a100348c d681d22b74d9caab9d5f8a39c2072a899fe687e74c04beef4dc50c856eb18407 45151bebf7146e8115b238efdd4a62e9902d8ec3b2d17bee96e177e6d7aa19ed 9f0f1064920ea54f315688deb2138113e19a1ca6ce6401fe778a01749a2a8736 e862feb485334845db565de4af0b91d08cb2e4488553054918a4fcc5cdb99ea7 c07283ca458cd202e47d486a82345801fd8351b6d511a7bb5f4ada80d3c6109a 7ba6f60b39d016bf3ab7752a09d9a9bd72b34af8dfa098fdb1f75e565e5323d4 75a784cfc3245741caf9e5d074b516bdcecc8e27784230f92084850460c6986a 1b852eb3b1840382e80d8beb354567e7d6ac15e5abf7e450358b70f067388d68 9b06b82abcd972ffd5bb38d7c6bda7a4e50e79350d0d22e9ba34231db2c69d6c 0a65a8633f5152b3b3514e838be2c0a6cb63c686f3be5163044812ba73372779 e535860453422af9b12fad4a50fcb1c233b303c4c1cd254923b7594ec0e1e95f 5c70df9727b368bcdf48d910dd9bbe2d113d468e22eddd03bf268c6194f5e46e 934174a3b129c761d997d0df693377e44c5303aeb2036e6b26fb0b6f7c688146 a3a8c856c73b2c20025a9db3d15ed505a5a3cb453c7dd31f318a76fe5098f59f e7def0f0562dfcdf304d8ee8b7483c1292e92a39a2b6616e0763719aeeb4c10f 9 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 +generate_ring_signature 5a353b51a4b8e73c0ea6abc2c657c04a77fdff66fc6725ef72f3ad627f1d475c c9900fb41f580b8dbfe112df57f0c06e1ce7fb0130751cd61c16c51120cf2805 31 2082c30f4fb72d624bb617a6a03dd887a65bc0f54d266caf486fbac1aae5442a 0eda2f4ef08a2c05146633a297314ad90dd695da99f4f765c18c22c0c808812c 749d789d269f4a8d46b4af5ddb19cf5ee7f86c54e0c08c6d93691d96a1fb348d edd996b1ac97ae752bb02bdd19976097ddcba82f6039f8115498fbe93cfc09fc b7123f37c63a6ba41ec9b4868113d6f66cbbbaa8d80427ee6964172265fc2e8b bf64bcfb1fd3669ac6664c3e9352e5f30ed3060fd80c97bf43105bb062b9beee 991ec7c190a8f7b9accadd7c2b7ed031fe9c579f343499814c4c4d898855a3f5 420ef41f473736a88f14d32ff6416ee906a4bd91c3a573c9299a4f1c054471f3 236a9c9deb53c00f8668443a9515510ab1e9b968f4be278a94c3bd17c1bf06e8 0d96fc77c34ffa4ef13b0de637055983224a12c1dcd206b283c797aab5e7127b f11026dc54d653154b6f4a9c29d188e9c8d4633605e689426cc3fea64d70b114 04b312d50cda555c47641f109b9f4c6778d9a7c52e2ebd57bbbbd32c459b5c96 b1ba5c22e1a25e62c099f43f3e62f3bd082fe17b2e0334d30b45bddb8290fda6 b69eb8187d101ca4ebb8d84c72592d77f57d04943f3ed6ce93f56bc370b915d8 a0c257d7c690866b100211a0555956726db6192ef9ddb6569b0a452e7764b0ee 99cd8de3617f2f157fcf318c43e96e37df9ed7303c27b039bad46a8ee337b684 e929eebe671159239cb71bd63468e94a2cb90b756400a389b49376f84aa269ce 8f56d7e009725f04ea1ac3521329a1572dbce6fa2098cbe4ed7132fa5ccea342 47e13fc70a64213fe9d3278cd08ca6aeb844bbaf556df1c57d927c30f6d2c75e e4632e8650a1bd477c11dfb50e3c48c77c0bb5ffbcc2de1c41ea85ef50214b7f c8d0e4cac23ffa3b13127de2c01f885d110620b899d6d1ed4fa014c809642284 33873c867e6a07e795638df98011dae680049a28824194c4c7d5924d0f7bc18a 7930cbe3c49a2067ca5a88383454ada7c1529ac75665be86acc0906a63d0b84a 803714d531449220c83f1582d3a0b96462e6a1c4fac0f73bf486fbecfd99a216 6ab2e19ea796cd40a1973def711a3c370edd3afbc452afec3a27375c468232a5 5f58473e62a5a53727b3556b0d537a5210c77effa6ef4c00a00e6ab328f29133 228455d4ae9f1cb40781b45e6bbb26562bc01fa91b81f16f46e018f299454b57 5ebd456bc28a81eb4399fbce59a8c8ce0d765543e7d1dc876ccf2401da38e483 edb57f628c6675f649fb2947c2b7abb9504e00aac31d3be494b258daffff3935 44d94d6c395ebbd88bd008d0ff9802d38e06bac61a71f3afd0c1d6b75f5517cc db1c12682ce582aecb3ae22f6040d3c804d0d000de0b051c8739587850534ecc fa0835dfecc3c5213938d2abc5b71467e1412c22cb0cd2c42011a03f15af9f0f 3 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 +generate_ring_signature 6b0442ce1572d31322392813b8f2796600e1bd3a7f311cfcd5d18db158df3f83 005e98bbb03be89de4e329438452ac2466eb114dea37227d0583067af043e361 26 d753796ecd8caefcdb6d6eaa0b9f198541cad7e68ac70b436a7c5fa4db496797 6ae845a62d710002eb816996c34cfc5534d1323ec9b664c20151c4571617185d faae0348d8ea4771b6855852bb5fcc60d992a0fd9ccbb4418f9f205fb3eae956 c51b9891e997455b4b220b2f1b57dd8cac0e35489e9f8156cbac6b7792a35f42 eacb4149226b18cf68ef4cf0bf21d09d3e094002482accc00b213d0c32010d25 da150b24184ad0285d59eade87dcb51e73222301f46a0b8cff4007576858e11b 731a7cfd4b0bfc6824e2b5cb6e3fd66a77981d707259a9d2dd332168310e0128 b8ed9d7e6d9db63cd5dd9f5effb80843648c18a5c63c32b67ef6232240707fcc e611578ee243322c9d2e3210f57abd215388bb1e79319fccea9944dc8640e294 410acc54a3f9762e069471c4686a7e9e3e92c61811900962d6ca2400188a6ddb 87d32d08f2338c3da64bfbdba28f6b75d46dc4ad7fa2f018f033d09b608871b1 bd0219ef9562064deaed5e8d494ab9a22c32f468c5573258d6f8963c5402c62d a56e1100ea7ada74f25f46b738a3101732b7fb2a6a24e860fc42a122cb295603 b5c1a4655e455a01e68e3f6002e6aeaf2ce8e84d610c5e4542fe2d3100a01df6 6d324750ad63ef0f6be7ba47418601b0a5b5c1317d151a9449c53d27425131fa 46deeb14d5108ae9456f2b8375dee122dd93f8c03fb326866e6409586b44c7a0 ff9057e3940c9016f2dc47f986425e3d4f7f751ef2f54ee3aa1aae85a2f32460 9598db5a457095e3d02ea5c1ea0c56f8d43a2febcc64a089907219992cc8e4e5 afba70859ebbf598a74ae65fcd63fce51abdd43b5b6485bc8dcf9a2eeff66d7f f0d872a622b64de9d6f5db16745b7b7dcbce78595217317b73637e9c253cced1 c244cc03d464699ce9f3c9fcebc80a8131104d03f2fff938dfa1f76dcaeb6ec2 ca824fa57901f10a1ad1fa6c51a444064870adb920046153246b60176229569c 2ca019b674ed3157c84475298abad0f6b62dc1cda2a11a92fab49f9743567a24 68903516c9127c4e405d1583738f2329755d88724995901269931006aed07600 0f8e7fb6d91889ad5a0aa80048a6a1d941f666e2f5c9ef5b322bd3729de419a9 6f87fe92f681328fca521963539878521e1549077f5851e04b200e3e5d9859fb e4887420585b1f8449d75da7de40507abcae71e73652b880ecfab2d43a9fad0f 20 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 +generate_ring_signature fa878e98be7bf61dc3b35153e4ab01e1c444b109729d4428288fa17dd1277318 c711a0a27fef0f9531030c710cc93fcd675120c2b44fda635fc3fe58ce68d5ac 2 8705fbfb8783ab5987596b73b4d1ff0156795c951e0c58b8091724678d9d4174 aeccdc9ec7f198a2f4824e33ed96d40215f9b22fd69cd2f0f84546093fa44c67 128378ed23f8edc0dd5305fa3e39996706a4c77d63b5ffda8b294b057c3c580e 0 dd67c185b6380c5d6c92a7aa559a730dc1f370abefedcece38423a448c30da0a90733701e1b0d64d8be75f74f35b65a23dfd3aa9ed6345fb781c462ff556e601b473d16e2b2f10a5215bf12b67db1f1af8af9c6af25ccf62766dca726bf80706cdb829af6cddfe770d7220865a1c5d6c931ccc1ea698c577daaccfc36a46de02 +generate_ring_signature 4dc38ce91c25bd6cb03ed5c0900c0b3a3d171ecd3f441d8bf38218214082d784 4279f878215bf5455ef8c99444b6a8cf0484d54010b0d1e8fe7adfe97af85f10 114 bd939bb5f29b32bd0b9b884328cb04da64b7a77b9d0f1975a42d74c06222906b bd64c1eef3f01b60b4c60765795c12d9d1e67df40fee313bc7b0cd7d769bb669 85917e8366e4bb6557e7e3d6d0851f0bb72cdb2f5605cf80287dc503333cb4ff ae20b8d284cc742818c38e284160f244b157b868fbb088f6125b8d039623d282 67676a9bcf5d35194deed9e14a41c23c81f5e96a82ec4aa28d9c54574c27cae1 c57610fd10ed400b939d00134aede8e719c8e4a8abcd18ff1b32f7fc96b9c937 494be2c5d57bab3e0e2df1715d4ab09912124a8eb65d44745b6ed4bd50718f10 d89243a7661e6cf3d7ef223ad3eac26916c71f9337e02d56db8bb710a41dca38 bedd21b55f596d4fc3ca8577ab48af6d0e4caf878bdbc81c61368799da91b655 c18ae2c77b4f87e07ed8564e9eec44a7fa841b9deaf425ea1be3ea7c800cfb94 789dbe3cb82cb86630f62da491b353336731b43ecacd9d76841917db6e265b50 d983f5d7e4980efdc335a6eef84da9d194aea20eadaa2b1cb2a2dcf6e510cb24 3fe08f0aa6a0bd5ffacc337d8cfb3ffa5ed8b1ad2717d0d51b929d9a33806790 686623a9f75270dacfeb22784afb28c0fea864434b32fc76a7c7908c378f1e8a eb2af211b6ec6d3a7583c0a264a4de602ebef841008dca26e06a659e933994f5 1e02ac91f995e252099050a2f9bf0a107500f689fc785f1f9d221deff9354e50 526b8e6185f40078ccdf886172921d276549dfbdd3a0cd27fc65f172d3bdc2a0 8e3d39b85ed3a05da76c47c8f70b76020002823548f8d45fdc27df8e6852af9d dc0915a34b7411206b4694438d629c17f84c2c07aa745284b1e84133765b88b2 6f1070b084301889189f7db4aefba51bbf037bee8dbdb086ddba9e9fa316502d 8cc4b03df9b06722f19ee747f5e4adb7b6a5ba3f9473bb33e98f06afca0155ff 7913b5b2a3371c554ee75295492f120e4fcc1761a2e90c163800e0bc8566530f 62a6ae54a6ad56bf2cc867132bdc8ed65858367d7ad38ffba12b25bc2f44a923 afd37d8701510ff65f36a4089d28a116e923640d83cd013c9ce2bd232f689cf6 d2b980b075ad35c7080194272558a004747fa3d4f54d52e54d7eb15a55fe47b5 09dde581825bb3e27bf96127461b67b50bb5258077ab5773544f29fdaa4cc48a d5e555016be782538646c00925362d280850ecf85d9c1975254025187739a0b4 099ec3a3c0b2448c583d9279b8df8d6f9d95a524d7ce35e5ad796619559a3c6a b1785018039ed1f0e47624cb17cba05a29daa6af97847e985c77b5de9e2f90b6 4d1d4f2af470f9e5c21fdf9985312b217dc866cd3c99798322d4332a75ed3f83 61bac09466cc764cd2549229e63b21ec0e00125211c18d2e784c027edd279198 e401492fd7498a1281617bbb9750fa4dea2f7ac1c05d4601d7b4d6f93f05e05b 4b50fa467dd7bf98cfdfa98b87a924aa5122b6b09fa19e2c6b1aa82e4f109d71 e4c8c681e9f7f7f0607ba801fa44816a802e81e8fc42faa343d0c0ebfe8e3e78 8a0e62086feaa8a6259ce3a21c4063fd4cc807c1beb371372f45e7aef1493123 fa7a5f9e71d90eb5ba18bdb7a9337243ba0d8735c4721bb9b65be880ac4ec6e7 8c89e1ad8f42ee19016d782eb7489ccb70b72be6ed9bc3861647bd742fba528f 339678b140b4c32ab322905eec017d40d039ed7e02c9ae57c68d2fa7e8584626 6c2ceb1dfd2d66f045bd54bfd7e5908a57bdd5216b7b17ea808e479c0e4d7d22 f36e853ea751ae307fdbe0837663f823106aded803139620a9cbf8d65d85c1ca 1514c9820ad846074be5e94a1a460efdd832703bab36dad44b04f6723e6b983f 4734b3ad5971011990b5ef237b152c24a493f304b337f556afba97607746fd81 8cb350acbb7d6e8c4da9dd936645a8750b052a29414c450a9bc886f1ee58bc9b 90f095ac9e66ecd8c321797c8cac0b6ead2328db02968466cb2a813a14b97b63 b6ca5b532fb55b28dd5788905f16a4c017617e45bd9b59ddb916a910c004c906 2acfe7532da865b1eb9f8ac6d344f535c2dc9e6f38be192986a02ff8968af635 e656d87021f86642a2f147b58869913e1721e8c8320ab77acdf32775ae4b816d 45847b41ac23724e860ede8d7fabed5982702ce646484b7c008a603b48b08a4d 6d0c71b58f122a7c9e6f4a71c0a8ef6ab1d598d67118486fb704c4d1fa8adc99 abc2b523b9f0111245bfa413450546125e29293df013aaf0783cfda5db038302 8649564fc912d27de342dec94c8dee22da9d5953045463bcecd0cf111a2e19e4 7ebc13266c2d167736b1fe30b6447f51d915a09cedccaf68726bc2dfde668816 dfe2f28066a7b2489f85153ad3fe8c42301efc3792e55764241f0377b1df59ae 53337434326613e0a7e86c87effea7123084637fd9ec488d6a5cf79678418d71 2fd4edb314b9ed004f702e97673312cd247ca6cec9dfdcae83ad266cf70d70ef 63627d0e850e46d81bcc136ad2aa095ad1a451f2d40d0954b5b9a99009c9c723 22d3231a1d7e59481188324c8a300004065010feb4408ae9bb8c5a6028099005 00452956c834dc93e022257d4ccf84a981262c21e5b0e364d606e5b8b35ef10b 8e4624bafddf2d0659dd9568425153ce7249d66dd796ae9d9a3958c207ff621e 18e20d7be6b02026da91d6a20212fb83271ca5c0e41d31f7742f9e5d7c9f75c8 0321996b983d708e35a7062ec8de17bdb8eed2aa44a33da0d2d1fdad633641ce bd8512058818d365f2a894bbae3fb48a8d8f683cb5b7ea86c20876fbcfacfd4a aa8206c4c30cae28a9539f34a06071b321f3bfbb1192890beb6cfcea066224b0 208e753a3e2ad56bc88aaeda6673781d74c4adea302c24bb430bc9d2ad99ffeb bd60707aab510cfe9aea55674eab81065c4481d823653bfdf4ceed5aa4cbd2fd d73cf31ffb213b78260d22a47f44376c188231f066635944f43b5ae6c487fdfc 04acf87b977a025d7aed687524a1612b4ec58f042f570dd537e2b7bf1f374819 b67f9de08052c5fb3a0b62ccb6ba87ea75cd0ceaa251708b40844267f6b014e2 1ba734db12fcc7ec682fd0ba5e50f8e201f88bacb180be02ca298bc501a04334 36d7d9519faf0b07448f93704963f2d5be500feaa60567408b62c2feee1abf63 fb64b38df7b1c5c931251663722e1bbcf64aeb53da9d97989e62eef5b3d33185 9934ed813d8e4ff4b96ea8691f2a73701443643065025a46b8d0ffed57deedcf ab16da45b8ff0732acd013c1a3574d7a76d4f8c510dc7dddf54723f8bc9235d0 cb6174b0170ef65b191639424a1d18c67ecb6366d5e789d006718ff192b74e31 5e832d1026ceafa167e47f8e846d6f9fe37d337fcd63cfcb0327ae049c79c253 7495dff8ec7290d6672d5ee2f5bef600fe0b573dd51d4d356dc3093801b1db78 218cd5ae20837d084034d5de568343e729c8c38c4c1aa9a7129eadc0b155b2b7 9466ad947fce451cf7fadbe9aaa5c7b6084f72b3421abe042121d6947579543f d221ba32ba6279137c88c55d22a192535e263d14033e775ef45eea9c076d0dc1 c428cfb99f6446666b862996418db4a552bb045ed8d8fcfd2b08deae775398af 8769dc3e2d1ad107d4f0d96cb5823602daf842cb159238809a9088752d340ca7 4083c2735f5c674f4896893952c90d275c6d28ec96961b36e75164b42d63469f c1f161d41107d3e258a1f77985876fcf02f05d98183ad77c5c943944024c4ce4 7e5fc3484d81d4f393f6fafe0dd4357ce73d08b6db85aa6d4a5dfdf61586f9ca 5c39e84b62a9dbcbe60d5625491f3cd44621d990ee50b74b7b3a7862057c7c48 34383e8918f547536c4a41cc91b2f02f642905325140b52f53589bba81f16383 1cddf5fc7808b6466f75be06c1b19b90025a85e241a44512e65a94b275058179 141df5ff0158ea408546d801ba6f0c6af9bcdefdf23ac134cf932835091c2f22 d476b262891e7be025046acc191b5950f598d26b940d883be486e5032cb31445 522d85cc71685afa492a62c6f4508207849af1987a7116cfc90e4c19ebe400df 1d1f78f69b6744335233e84495b0511e32d3c720e2373bf669c27a4990668e74 905d0a24578ba9bd1bc7b3686d1b08848b470ab12f4956824cf3b0fcf056c0fb 8a3768805b5a09ebc505e5c0d4242b617adb9e0f3865199bbd2a7be7579024c2 e7c80d659dbdd822a62c5a2b5580932a55c9baa6dc0818e8ae5467869f87375b 1b32d833d664cf3338c60fa3205c119e1ddc8c9cbeb44702459a97512575c832 12abc274c96f4ad4062309fa3060d05df560ec075cb78a80251cecacc9000a8e a01aff1dc079be3335a3efec1cb3be3eaffb22080688a4fea7ef634f8b1e5bac 1f4f6d983fe92cbac643d9a027741439190bd7d911d90c50a86bde27d8f4dabd 5d82c7c2e907bc4f46744c8bf1d8e441c21e28d3e194ad9acabad465022496bc 8177edd83f79988face73a00ead13d6c0ecb1db4f365b2e3f9568ad58cd8c641 2ef4116bf37982032ec32ceb4e1415331f4fb988957d113425ae1268975157b7 58a2d5b81c539077063bb9d470cc5aaa3f5014295ea7790b6bb002ba368ec551 452b24765b3f19045dd8c1b37e16823a6ea3c91d9500709ea0aa83880ba159f1 2e967b6d4aff868718cb1a7b26f50384b1012eb02313e8947d8e9a7c52d28a7e f160277b45b9b94f4004260a2dd9b2682f13081a1490cb873207ff96874d296a 6b9995916945798f3a838a968e36a030e64a240737da517d6c29fcb56e2e033a 3d3a67122086e15daa676f97a1f704008dbc47084ddd75bff2d52de83ef44377 e2c2c8614448e6b57b2bff177ce01d466211ec6cc80e26e9c4a9238657b13932 240762e3135c801ffc2df0714bc22bac52f23089d3698fa14c4f9dfd1eb09377 1b120c957aea684c4babc04fd213fcf10b20f56f8873a808dd707982c73b349b 468c72e026931e245e55e916ac2d0235c52e4255826f113b35c9857e171b2901 4dbd62c32aa0b9fa0cbb9c7f8174387957f23d2b7cf1386f39400b48f40802c8 a3d0a864f3226f810e69cfa3c6fe0e2967af9d69f12d39f85ce0c2c43e6310d3 3e7bf7715c43237de8eee1de54dc56b73f8e7982b30c1f93bfecedd49be9adbe 00ee10408bd89c7576d8e154cac0c7f743aad43ec26fe575f3a005ffadf84606 44 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 +generate_ring_signature 52ab38afe83396f4a7abbbe478732d39260c8086f1b221f37018ad83a56295e8 52144c557bee42c63d3943a1da22bf53c53cf47e18e39ec7618060fdfa2a056f 113 2667878a43543a286946b627dba44ad682f51a0ec0dd5885c0c17706e1f27962 56070ef37ef631a894808bf2998c18079451cab0c36076b94ba7046928c7a1b7 09d61f61e982a1e500603b81bc56fc727b7ab3822a8af511a213619776bc559e 3d16d0811f8d8b1ff564124ac0735d77c2b62ed3339a2542deb20167ac8d78dc 8d1e73a58271f020e21201b77b3e1a0d5802960cef0da9c30f88331d1e53b7b8 b15c3a90c6d12c50c12ad1f1cd4f5cbca77abfbe26dd1003c5f92d256b7d9a2a fce4121de27006176bafef1742169e769f3a25a075b413ef0c3f7affd5150561 23e7a79af125e2cc0907abc7b61ebb2b6d712691a6c556474ca79c1cd2873c0e 1806559d6d2e9812dfa4d97efabbd8ecafb8331b2a836e8b94212ae21d9e935d 3d825ca551aeb017319626965977dac767f90994d4574ea52b0600086f745c96 9e5d692b5e82670f6284fef4efb6a3dce320ca9644126d52782f922e2f1cb62d b04d172573b99e1b8074d362c5f6b997b05ca74a5aa4d35c957853f9078ea90a 451d26bdd2e49368fca9c893cbf9a2551aa0bdb1df3d919a75f16da4615ac00f 39123ff66a0a8cf47643625b997f3febe9b843028a733213f920fcb0fb224321 2e344a31a1f4abb279b66741e22b00d72342c93ddd66332b9480f38ad010dbf4 174dad431a88a820abab2a8ddf30bacd6c0720da30f98ccab7c821f2ce13570a 8fd6651dd86f87c6e9baa019e3222459a3495c481b5983bc1f3bdd43600538d4 70bd22972b4e8c895d93c5313a2c4de3f096b2832401b34492d8b63e4c828b93 724ac189a333456efd5ea95bbd6c3174180204a0541f56c9d3c4e82c1b9a9430 ee0295b969e97cfbe6d47f879da1a789cb27f9bb2af514fd549b4c8d8db67ea8 6516c5de7a016a83efaeb52dc3810e147831cc6a7bf6d556aa711e3f26ae74f1 3f8aa4e1f31046011579a2efb2ff2e98c2e94868bf61f529b28e0c9dc922e65a 40f502a1fc081d3e0870baf688962eaeb053998be9e61627a99ea713bedb7d33 f5de2cbe86740e20007d273d240495720423986ad67d13022a69f67eb65c9db9 a72c9067245c4f1f7d3c6411578b2e02e18c373f78957b0c011d1ba817d5fcfa 2a6f3ed6fe0238355cf8a1bbab5f2c1f5674c2432cd8c964f4bde62d1f84089f a1be89b4e0cd03a7080617e61c08203f935e63429a34f8ae637c6290a5f855a9 dc25b39ea362c07b69225919ec631e1de3e539a0c99076421a03888c136040de c42663cb57da0d67ce5e40583deafdab17af7f37f4e9cacac7be29510b77ae60 57e85e3d5bb0bfb51da145a2345412b3d4f1bef0a9ff125c2533e3a76c2fb261 51d82c0f6c42340c6f37f6a4d24eeddde756700a2a674f0e5745b35b0493cf47 d6239694cf291b89f96ca1f448b250193f738547b70c7627a72d6d8c3edef2a8 3e3ef92d08a0f37954c6ada45ef29204a7dacc626c7181d7613f2fa613a7d515 479b439e8cc29f89d9dbbc3acd98fac89603d262b014a2f876ae4646ada1d401 ac9c823e44caa76f6d0d2ae5da6684a6fe0fc4c623cb28bb0ffedab0de052047 bd47406403e535790864051db0c1c2d09b0e7a0fa9df52d23036106cc5eb915e 19abfae288790ac7d77c0581167f78415897eacc19ae8d537d118c47fa2b1553 b5a5323c096b566ec9e91eb9f4c870869872499205d05cf3d7b58811d60b1f58 36d46886bca44dcd834fa408bc22275efd1264644143dc3fde9814b06d1ca44b 758aaa67d8781b59b605c687e993e1d43913e3693a351d9addaff6a21cf196f0 32c1e4af3a5597eef97f47511fd377a961dcf5e3ed4c1b8ffe981abe8ce31a84 ec3619a0a1928ce8907e344b0c7a8e87e15fd53ba8693341138a5714442e2c34 c6bd33f733cbaff02918e91d14855be7966fbe29a04b6149833010293b04920a 6b8a52bf35bf9bcdb80f5c22fa241b7342b4f6bbe085f78e5096f0647f0298ba 3222525c78358332d2571622030a2c91873a8912f815486ae7f1b38418cccb2b 5ffc8527b801db0fd1f9fa568e6fd8915afd4d2a12c9e760f8a0e3f65c13fee6 65cd0954290ad98ee8fc0ade4ca8931b1f6832199e69496a57d71b25e0c4da6d 519dd0ce81bfb0e2e2aed5c4404fd08cc5dfc32cdebd2c4eac8e8341a99593dd 028506245b4782ff02e531921ad41f33458316d2a04701949c9a1130170f667a 65479d0e3b8c5e054a42165784f71979e44c5ec86edbd9360d364bec827c38ad b056a8e8159cb51dd0ff6854f0b5cb7d73eb6af8a5056f7a157000fe950956a9 121bab1f2128a355510aff20a2348ca726015f44b14247ce79d17147a4c4060c 67b7dd5f52f743bf4421b83e735123e1c17173c562bebbc92f241f748c45c682 1e8a956e74016f5431b773efa5ecb58a388e94f91b9a5a4d928c90b987298361 928bca6f3ef639fb399620438c215df701e992d50c32a7d519c9c4029777d8a9 4b928f62407d82ea63fe4ff44757b0e2c99b3d809f473a2d9856a4e7915a4048 2638494a4220023d7abb69e0663e321321a39f10ed88170cad8c098adc2b5762 b4e4fb545e5daad738d95438f9caafa048eb5b7b6cda4984f0d98b218f8ecab9 4e1da4093412883d96f6080929c73604c9b918e4b4eb3263edd50d07cd370ac2 1825bd87bd4c8621c5d585e3a150b810734249c5f8b98826d4fca4fe17a479c0 afba4add454e41364dfb8f3f10e613f4379125837d809f9617c0c59557d8ba06 be6c78f9549f725e77166b209a3a62be24858c6fa6730b751b454d8db46513f8 d72dae253fef5793e2c4b21266aa5fd4bd4bb298ac12024c3136bacc698bb5b7 3cccdd128fb4279cdb8782fe4e891c92b9212ca7df38c1281a7c23bf0488c7bd 38d08fe57e0103171b5000d5f7d6f741eb51c405dbcc7ba351ced61d610b5e0d 7877f90fcf24f4cf3fca2f456e942af7cbb7c713aa9a26a437870bb0dff5adec ec4175d3e5369062603878430224568d1d9f6b01b48a0377dc82f66f9ca309c7 eb039d354117c3df90c53e9eb0492b4cf2e4f6b4b57bfb6cc809c22621edf016 6ceb1f244447e6c4fb2f4b7abebdd227271ae511383515241e146e3401b47afc 65cb32f44ecb9ce88d08bac89c7b36eeac2e52fbafae9c104b65851d0d3fb689 7ae2db115d82335fe2d49f12ef8248994b958fbedfde2f99dcae864daadadbfd e547d52a6eeb118a7cd1147895f5a75dd0dfca914d50706f6a7033235e3ba07f 6ab9a84a88f767a1cbc69b2740c05acaa9fc9d84ae58cdc77e01b0900cb19ed7 601efbbfc5cb40884d47fba0a5e1e5750685788e4225ad69319f0dedc8053cd8 151f98617ce7dca0ac7bdc7910fcf5afceea4b8acb144110377b458ee877eab7 7dc10dc41ad38ef8c879ac0c434ba7dfe0c4ee458285bfc0b07be3127c970bca 171ce0ef0830d4ed99f42e0c20d063ccc3c6ca50b747b36f24572535d28c77ae 3f55caf66c98c9d773a90472b2432e6bcdd84a286b518a3f3f95e2ff104847f0 98ac27c0ec172728c1284698b62bf64afcc2cd1535ab245b6ef9e39e1a1ee486 38a2e914fce5327a0510a04ebfc2843e5ca25b995ec616bc1e214df14cdbb2d8 6ede2050ccc3ce325d911fc26311bc74f9f09f51096acb61ffff4b751705e68f 527e46d547a1337da68feb3065d017f1fc3d37fea430714287ac3bf13de5e43f 8208fe6fa4af1af795df8b07f36dcb08d87f9b5fdbb06059b6ccebb6cea006ce 41cc08d2fa9ca82df528502af00d1d8ab83840d3961cce3a000909322c393b15 c04393bc4ae049524110432433f0290f23a88dc4b0bed266bd3c139180f4571b e41fde50f6a402f874e366619f17cf3af987c3641720207c0e48b30f3321d462 d680c870d7b43c6ae308b818dd6d14b29758aec61195bbd3e354221c897f5458 352582605e62e595ee051a22e47c7f10c86a0ea59896c907afd853c418893bcf 39b1b721c361d5cc7d3455cfeb782aec7f122348a62caa0d67f4fdbc98665503 66e0b54e8d0d0b0b61a6641685c1f3acbe72bc1e55254d88a2cbcf50399fad68 c3afda12547982d6afa86121d0eae5a549d22192469079100f272ab6d8831338 3d8021bf75cd1a3b64192e532e21744cca23a32a7a50b459b635d8cfdd6e28be 176079f943ba5100d89a6f665864407996e7ea1d554cfa79322d38300fbf3cb6 735b236716beb3d302ad5518901b9a523d51fac099752fa0c1714fa342ecc944 d6d69f6f715109ba6b81cc303efda0abd38a312f526b49bc058ccc44d076be32 1e2dd2d69008482d8e7a02b3d026e549d61455b1add013bc88e131dbae129b16 e02a717aae13cc6ec9a9ae8bfeb952c42d8fc709233cfd1ef7ccbc1bbf912bbf 009b16fd9effa67a4c4c8eda2b15fcc67adfb5aec379d592c6b80c63d3750a9f 40cba48b6fe177037c2d2f652e35278d5aa779ec0e37a01a3338154b0109c7d5 fa94d28721ee024c3920937cc597b6e440056d873da9183a4121740079e91c52 b87e5b2635dd6e4bbe8d22f83e55a9b088fc79bfc79b3866ce37aa3be95a4783 705a31ef4484a1d621a26ff0b0250ab8f4b4feed12227f709c41b03aef4739a3 5c424ca54db641680633f09638dccf23657a0fc34f09c2ed97b3ff0193c330c4 f00e3bff74143e2eb81b5aa10d4f8e110d6f82c12a6ecd870f786d120a863ce5 2b57a48a8c801c44fb5a193e27b51a3b63ba879a68a603f282ee29bb06dc7b20 b02e81daa731f503076e99d7e975ccd900b8a4f4a20768e03225a74ee7769c6b 2dbc9cba9c5b1c99149fff8f97be8faa42fc16d0be7bc5ac77dcf8886a290e32 0027178fea8c180bdedbfcb2bb7e394185b37a42977afbb70ef8cc3f5b2b1997 c417798c3869d3bef770f05c7eb4e89948bd4c76031dc429d6a52fb199e16b02 829c84deef8ab603af8fd2a06bdd0daeb12820c32345488d074fdf0c8f004879 4be25ba569f1b4aa9c55a3e6dcf232d3b3ce4cf9990a6f8698b24db41ca20eb8 37165ce3e5c4b593456f947b9813754b44e40e8407b81178db50716df2352374 b899ab2a46ba764730d7a822b6e24afd6d6d276c4a73ee66fc39eaaf2ed57b84 fae3ccc4f506532923a8f03d2d227f60d7870ca2c855098aedabd89abfebfb04 108 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 +generate_ring_signature 869c7247a0b0a1fb90d96cfbb2e3d17682be83f64ea5718718768a7ff74bdd41 cd4c787f13645ac936e8e981b3c725d1bf042959eab770f7c28179f6f37f959a 50 64a0db89add71f4dacf4b369f61a58504533ede4d3740cecca23b82f3a75f4ef b37094f708fb5ffce04e866a09c3aa4ae4e9693abdde06a7b22dff21330d2865 e80522d9eaf7c40d7ebd82c81d893dae50ccc030c67eae697aa0f7df696b87d3 603bf0a35d784c9788ce83017240d87603463c6c41f61896f24ff3a54e5183bd 2879ca5cbcd35d10079dd6b0875cec28e8f177fd12a7e89a597d4041c60b28e6 8f16a24090b39a5295926e9f7e1e73b85fd8f12f96e58862d5a70b5b8067fa74 af4aed48e14d50dd553871225b4cb21dc488041ec203ae1f4140c3a46595ba69 91619b1d38238a1d1ce66c10b3c474893e0484a3af833c55a346d08df4520b2b 4fcd543fdd76e2a7d5a31e6d0d39ec96e4d70b14ecf3419d8f59f8a87e31a26d 84fb3a395fc0fe8ac6bb8fa697cb62d3d56cbfe568c24ed6f6c973cc674e63e6 2c9215c4af4e6ba4447a7ff5c92670eaca21bcc140aae3ad637a93ffa4e0c707 5384ef060ba220e21f947772eb03716fb79aee73e70298e74003d6150f4fe609 ef2500d30e8ece7ae0a2ca2026d4f176ace683edef6326a16f631e42029de6c2 4702a38b0795b6c71a0b8934c2b43b0420c29436fcdeb1ff04c5d44470e900a7 bcf1c1b26acbb158b8d4444fc9951fb62388c9e2e37cfaba70a676a0166bdb04 32d56ab2539721810ada48acaf38e0d28a2dd6e4eedc2dd9c82cac01786111e5 9c3321f4e62d07e104398e1e405823e9e1ed36032ffb78ead40900ec52779db9 8b732bf86cb9368873cbc81c0390eec33c88cefdc66d4063c54b09ba3aa2e78d 2dc91d83ec7a70f8fa663e49c70102671b43eff575c4ec9dd2ebf3abd7c03d61 f982af7048136c5075ba09d0d82da852eb1ff9879a49967cffdb181dbe08d576 a603ae7cd1acd05ddae21bb0803fd7d4af1a4fd56f995abc3343b3d86827093b 296b597866b55b7eea58f80d58ddaa00b7be7058e07b24563c4732a3de2c23d1 1a0a0ebf748500c4c58716300a78bc636d8616b3c6d4cd9d27224ffc6ffd21a6 2a2ccb830271f5438d1a91b5255ba79c629261eda2dc9237d63963c2650e7038 5644c2851b08f83e350bd96db37015bafa8100cdfaafe8d9576b7e7b5d52f76e a69c652a4d177a681277d5c1b4ad6b9ef22737b1d49789380dc890069aaa3046 3e7facbdea7a85a4b59ff60f20d441179fe72d3e07719597b11f544341fbc223 55358eef614502ef018661f3092b076e66612215a378f67e060fdd3a625bd41a 92db53a847ef3a1e0786d07ec6dff53daf37c2358d1b76174406a75bece6a192 6c248b764ac844f7f20317da6ee0ade57c3addf491a6309e19954df847fe0b57 c2b3c177d65920dc7e16352f4d4a1cfa82da74c45c502ffec6148240b048da0a eae88428fa3f81f6a565c6f71a34a1a282550b543d7af367ae568cde957a5adb 347737d568850ab93cdaba356e2f2c932df6a8b41fdec8b05b9104950766e803 40473c24f38722a5db64db65f713d670ca27db39726f32a728eb93774a89ad9d afb366a426ce9f1906a9d3673aba98e048aac4e4e668dbcb17054378cd42ab44 e9f3ab459f7194bc370c362fd7d8a6a75ca199b9ab4eecab528939d27dedc48a 0d4b4bca9ded630b3612d80d468b504d0c180d0cb434c46ca42c68ee98dc2cbc e1a6e0b00675b3b136853539a4e7f82877bee50b7ecc3fa26b8bef50ea81e5f9 7ffb6985097f8b43c0b1d8e645e7a7a92c44f72d6fea1ac90e429ad8cd6bc389 9cc6611070bee3ad7b9ee4cb7019a55e89981fb33689d4ff7a876d543d0e9112 e7bc5ed886bf0e3d7f6f5c226f8fcabf9d1935e7e2d609932ba263f451cd9d27 1c65db720c1282e65a0e49d0b06ef80fb5bdef56c74df1989eb020a3568bd4ab 7cc29b80758c5528e9534bf02225fe899ce2d91bcda453e046f275cbe0f1f9ae 51094251b02255d1ee35ef29afce78bcd0082a50dc86a164aababac34c46bf55 ff25ef58937eac01fffb1d4c73935ae9852a5612d26c13174f7199bf48a6c25f 69c882e768b9f5ab02710125377cd5f2e137d22b25ab1e8e3ea7421e262391b4 c4fda0318a3ddcfe2017ebf0bd023beac85fe29e49ea175b75846fe20a97d461 49eee66a75a60155e24d1337eac7f8110bcd122a9a25309383135d43b37a80ee df2a2fd55bdf1941f0a7d40293da98f050c253827d420f6e020d11e81613a0a3 d56f97969fd7002aa6a3b9448bcb83354ddc3cf148c4e9a5e36c050fbaa7df42 b61e797b24014d16d9cab92b84a7a057a1a05054a1f1de374cd61c040fcc7c00 2 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 +generate_ring_signature 1d0b119ca5e69bfccdec2771ff272dc2c8638c187733438939525ccb8005f4ff 8645d7285139bdfe550241936b2fc8a26757ffcaa7bac9084ff8a85cebbd1e89 3 8a075c4f74b5520b511ee1a487cb31c4cc93befa5af0887414efe0115fbac0cd 5407168cd81fe9cba6a34e7e30cbca17f448f2226131ea57acd74420675830fc 2ffe6b476ff37d8d6487cc1c7e5e89ba0295a5d0128e6ecf8ae64165d6d14d84 ffacc2cc992ccbdc7cb0cc1a695ca31a92f6d6a2563b03349688a63a86f8ed01 0 5bfe16c427da132edafa6533fabba48b3e8181aadfc22d1a3c351c0a4679b10f279973e209c7d8091199e7c089b2277a47e050c9ba36ceaecb05d58060a7da0b86b78f4403bc5d2293661a6f1950ca8a90b2589c5087e93db72c79d1eed89b0ec1e33ab507653bef38b9d5cc26cee03210c2523b4ee58886deaecce98033b506d2d97538d8f6f33c0b1cf66e978f4f7f8ede24dabc43b4cd7b4f3c31cbcd770f8f79d11b392b2c9befc039e0fc2ea7a3d42283b07160d741e4cc0411f357fa0b +generate_ring_signature dc0159dbf72ca06954ef706baaf14f7c84f6d6e96aa47cb0fc100a73f21506ca b0dce2128797d8cd8ea9c4dc13be5ffa76e3c68278d8721835f7bea75d42621e 155 55bdfd958e609cf23a67c353b313cbbfef67c4b9f888aa9ff96473fc9c841e61 5cc2a7c274ee46db7d80a45e09bcb4701ca0b6c651a3f71698df8681f565da1b e1ec3ba3b9a5c1f93867401ad6f4b8f45a81fc04b057bf48198f93507db0c45e d26059d3c9f334e298bc08d99e64060f1c68e8cb0db08904f3f2e989c8eb0da2 06ff2aa52649f6205f044d65d691168f3bf22da79ae46a294a362c23fd674cad 376f687a817012087ac04320874b9e169806b3a384ecbab35aa7caabe11af3af e6f0454df292cffbefc002e20637b78ae2c52993e2f1d7801fefe9894babaf97 965c5c80ee12cdc2b0ef724fea7b86aba5ffa1ef7a8d371f634177fe0c77ed69 5cf4164fd1d89da37159323130a12b0dc4d22b6743f7a14f37d85675cb7711df f43d9857a3c0ced069e7e66e99416b0f4969010ae1ec4f90568fd9bf1ab42d27 15a59c1dd5958f6b8b48471d7fd113b4a761808409dd5606b5eedbb3fce5749d 4e8c6e51b88c5df9d2f41a66e80a5b443be79333309de74e36d26867c5260f29 84d85995ab7fba0a34a50d10c6c9ba52922b7f5f1541e7740dfa7fceba592b3b 04409b6c2ee649e8836796a2d0413dae06f8f41cc352fb00bfb108a6f608ca32 9c207be7f2a862125bc38aba0e04e98d16d0d2ff2d36461c0480716a95ec0a36 39fce2d41d67bf1f182d1ccf23e140ceaba4322266b10ca3c950055b6be5b023 fef4c2cf18221ce0ff9810a1928d9168e1b88db9f42f668d74c2876286c848e3 d1ebeccee551e9c25aaf9c6f1f6334fb5471e5e94f46bbb1d80729919c5691e6 9e7ab6f141bd4ecaa6d7885514127168338ff935f1ffc56eaad972e19b807aff 4aa10541e1a9124fcac6896b065066ed0d73150c9e9455f914e4d96ec07adf5e 32ca3c20ab39e82821420d6e2e37cb9a72f19d1df5908fa1fedb306b16c3273e 8172aa6cda51efb16683412242fc3b90a3a37c9381e4109c1f00521546fced9d 2f9f8b8f71b8e1d5cb244c0f0a14caea1c5d77b13ceb6a2ebf2b600ca2d236e6 719b3d1256ab1d9f286f9cb4bac235da7131be9dd47388b91c6eac952c53312a 14a64d08f79f8b03c321fdc291fc633fbeac766125cd5bb1293028bb7e86e4cc cdb1c8bbcea2d12159ca80158b1d8944d839d82f94e1c0c3ec84c71d00a67659 aface084d21571606d8b913198308fc78bbfe4fef087b2cfdceb8c335d756d43 66502a8fcec2e95a45c10fd5288ecd64e1f880a6b7757a3921e14f432ece527a 63b5a9153f88dc28a9dd325a81edb0bb2fd73fa2ad2aca31839f9350412b357d 7c377465d285f2f6d31834ff61cb8a9cd5ab2fe99b4ff9c330e0d59d305b21a1 ced17c63ce3dba87598c1adc062f3a8af81d4937447ff8991f7c780bfd9d9631 d33c03c444dad20c86164d634bcc2689be5724091a95c006723756544a5f88b3 42c6f935724c8f7f3f5c53645123165daf862cb05366a895eca0a7656cebe76c 4950dc9ec99c46c3d605d97f96407e9de344b0bfb7b19f976c9c84a18b3d26ab c813aa66c11bb66586ad3af0cadcfd7f4678f9ce71478135b8cfaf3f7fccff8a 91f5b936445454387f607698a4b2ca38191ae36dc6fd0ab0580ca4b80b058d8f 9b8741d58259a1f279a397da968d1df565d8e133ee7c69e1ab72448660625adb 4a7c1752977c764cd5ac091751bff8dcd41500f38b7c3baf458963f2133defc3 2d2b4a25e1f4a864c3f45e0bb5808484bb51d2e35b9180e3565dd2945c13a9ed aaa64e83a28293a0f8759ed4cac37082552d3935c827293da30bbb5d3403613d 66452a289e79a5361719e68d911741f20163ef4896f0257585bb9c832069c5c3 a14e0b54b0e02a7e81fa314190c273653926c342c819d74e9aa461300f238855 1c1322db318ccf855d7a5ce5a6aed6bface24d4086cc7b26ac67733be55570ca e10ddca61c7790d94984c7ed066543eb76623923557c610ec2f8de6f79f635b2 7588b14ea4f0e4a215d9a982eda345bdbc6aa4cfd04511867c40f9011556434d 409d5ba7c80a7e1c29df9bf923ce011ef47e284c0bc462533245be82213b4b7a d5e6a2f9f50e6e03b514ed898ac28f24fbec78eefbb3dbe0a6a00627f72aaf4a bf34dbc0ff7eb6c8a74f111324fd8eeb2be93a93c8975635ee06b526ff1b3ad2 ebf00d242b0667a638b7c93c397e45f92d1e8acf73bb2abf73b03490b3b6c3ae f3688388ec40d6680cdee04c6f11d79bcf9eb4e5ac2ae253b4ba852826b76bf9 0ee543f8b280ba4381bca59e1fcfff6dd425851c4119e251a7732c99b8d2f168 d872db69074557c2102d81103935a90bdea94ed0b0200c3ab0847b526e29b4f7 d4db1b4947a3e86d998ff66601af2f2da8cc84e9d724441b464143b171d7c89e 746e4cd0a3813757876862505807b4b78270c0a170b888a3bb9e3e60c0101908 8d3606dc0218adf7c809f52dc2c19c9aea02db66e95b21a4dffe48680bad98c7 721174c2d937c62637e492c02253ee2a7defa7d4a3b6d5bd47bc6f0addf40ef6 97bc500b936ed73732b36010e062fbdf149dc2a5cce48c1a648828156c956c28 f3422baed25571091c63261b7f854a389392cfee89a8aafe67b0986c77f933f9 3224b4758162f6a3ad94d76f096029d96b8542e883a50f48d189fc9ddd927efa 8634ba86f40b66d5e0ae98089bec9c49bf7ed348c857e9a8ae6af9fc1a1f1f66 afdc97548124eefa649ccc49f8c4895e1503a0b86e4732dfe073b18a14c6e0bc 5290911f8661f9a415535158f2effbe89a9178c4194c922b660645825e234584 a79798f044fe2f369b259d2b59c949a0cff4c4eb54b5464a1c07862032180273 36f35784685306db02646934f6ee0734226dd836ee407bc83ca232539af2a10b 1a689224e864e3777accd246ff0ec5ed4f78b44c7af8f551bc9b411f8614693e 37d040f52915b13ecff79dd88fb88f109f091a5716ec289f72adbcd9d1877221 3f8d7c20a19fc64d9ca3b1eff52f6c4c062d6ad85e9b242b3d16618cc5c359b7 8fb07bf7455db11b402bf9548947b6af97803a02577e538e9ad452fe51960335 e457e7a04242381202e5ec2f466205ab1cc3fe0fa20a97eed9cb1afa6f04664c b8b4761d93cb707c2e0fc386991643d770ce3309203f1b0c8f182ef797fcbd3a 4a5c2e5aec7e342cb8e6cf16f17678553cfd06e5359be5994ee6e50bf572fb22 5c16c16457e9fee9a62c4ba6b6dd7e46aa1f3f85d68f08629ec7a96b85118869 b7299ed0fb01db3149fcf30dd1d4ba8c99b9384bed66d70c3580e042a6f7833c e6c61646a287ad0a53d582ffb300a86755164342b83f3a6e5fddd5471068658b 21e7442030bf8d818a79e5674f1b5798a576fbb1ef84472add4689990f62e8a4 7755f1fcb777b9182eebd528bf3f60f6a2da148514e90695acf897196bd897ac 8f50370b4a8db13017296ae820c4b728f46e8244824e590293dfd9db7888ba5c 2fa322e48e87ea8a9ce4f70ac45fec4bad47ed617817a39c6ebb38bf007f3802 add067ff6442a2d93b12b6de049b5fa78541e45dd0a0f74c2223ad7c61a7198e 46554f1886d0ba1aa9e264a5f29b08c957b5c2896974664b222e60b6e47e1b0d 4e0a19f0b65791c9b0b510e49c670cc06bbb324d67f657a4028ed9f03784d8d8 386291c7799ecd8cdcef7fe30f6021f42ea2918b06be3fe8df2f47a0fcf2d616 2f4a5d75e0868c2b8e523ae394049ed0ca390bc64f641ba203b9b4dbc8d41d2f 841f17f2584641774eb003c751d0ccae29152dbbadbba8eb066a2ded5dabfe98 d96e7157019eb21d9ca9ddad08a2c2cfdd752fa10cf6aaf11089c180f6dfb13e 7360d3476419e86cb99abd0a33264327b0b5171557d812bdcf6800ea0bab7131 463083e7e2a8fd2d956876dec974816bde097827365b94a1494d5f7169f69686 44e8016a6c0e2e21241c67bcc8b844793daea164b5e2a14baea66c3c7a3cc773 22764f41e82557790205bc987553010dfc5bda9d8b9cab62def4c881e4ffabd9 9a52e8f5b5cf1bcde87297728a79c4154c272fab3a31505e9de06cc22db12b20 45ecf071a3f952a3886e388374de59aaca3109b8a9424b7cc4e9844de93f3c38 04bfda9f253526a91d0a4eaae8e8449bdfa9d200346509ad9fdcc90c9bf72046 baec1c08bd22e1d1803758f86de1dab9d472cefa662c4db5da8bdc3efbc19b34 efc658768831e5dd37bc425c2d958f14c088f72d86651f63099b6a59fc956aad 8bb4c7e070bdbdcf0bc3ccb85a7f636c40f6855886fb9e5afe3663c78ad39122 a4a4c96cd0361853a0f6e464a2ef681a05d30501c71191f74883a7071b38ca74 1f0eaf33404e3d3acd817f9f8a49200f6610b730b03dcad2c75829a92b67d8f2 693c7c1e884e24acb6ea9f79df9a4d82343d2f00a36617e80b2341f4a7061e9c 57e1c0ebdb580b1ef2eefe50d96d81d9182b45cec86b8c2bd8bc70d8094c3a64 10b2ab4153737474de7bc454ad5f247fd398761bb29f665cba97dd2a446f7397 e80e6ca216d809401268bea920b105ae5bdd440577b7a9ae2981b3d75b39bb55 967fcc98c8830d8374f52e19229f50d39ae130caf369227941c97f432d6a381f 6276cd137870acf4b11d90c2aef851894fd6aa8d8ef3a2e6a7464e0daed09c87 43a43751bf077cba57e404a62eff1082d66777f1e304f0251dc884a472d65730 199e70fda56e43e548af5bff218590ec49467db20d932ba7b93490df9bb79ed2 75621e025d68155e2501289bf8caba1ee9b89e6389fd2ee595e72baf5ea3b34d 6b7e8ef6c4575bac539bc5fb12d6428cec7286e03ffe1f00d4996ac4214051df 3a28bc22d5954f34ab59bca16162feecad41b3a25ed1008b21729917e9e4dc4a 8996cb1d13337dcffb5f57547eb7c6be1cc2af29d9bce46c4dac048159a15920 7b0eb9a962b2673a4c3385f17fdf9059f202421a36ec76a2190eec8ac1680d1e 6da2909d4ba18f512cbc36a2221a2e16d99a78c6e526e802fd9fbd38b8608ddd d989d9c710f84bd67771a252197af590b63b424ad1c89d623181ee4dbcc2acb2 5f03667eafa7c0eee3c741d4aaea93246d9085248002cf92b4fbf664da891e5a 4e885b308279d51ff6ba3294f150cfa79de993e4b4fe240e0383926eb1b72a7e 48310fea7a0b977e646e440ccfd050663c1567bbcf716c18738631be861bd928 2d8e36d9c5d5bf1a121d9b86dfd22dd40df765a8640383aa3a98e86815f6b202 c2ba1b76ef0a6ffad1f816d5a195b4290ea5bc5a195c21b99a2205a0fb0fe19f 9264af1aff612cf6c5423fba55d78357d35f1507961a1e5777cf9324496ce5e2 ce48bc8a5d073ebbb81bf4e4a31d30b43869d47aead425642fd590c2c6b71ad9 415ba1f571226cc741585b624b408f244b226a3ef68112a787b7f4ab117b7070 02690c0871b65ed57af53dfe9ad9af13fffa80e17d559e3ad8bcebec4e3244ae 28a00ccffd9aa89903398ac9b36e8bf24e77b25000ec0cc05435f70caec00f5f d71cf74bd0d2adb4721b4c2a2601109e25b41290716c2dbd20cd71416560042d e497022d82a79c271eda123b3f2cb12d7e050eec55c7ba3ca5c18f90456df49e 5593d828a1c1ad5fffaff2fc0e4b82c488a4a4fcdee2bee513fa7f2b8ca21402 ba7deb31a63aa2c63a9b6de0d018061bfd5bd1305de6cf9be496f2d0b38f0f1d 2fdf34d6c3f7b14cbf3d6dc057f68f9238a01843bd79f65c343f8888c57e032f 0ec1bebdae697a17fd38bd3c2b1d466c6a2cd62b221663dc14450fa9645f8f0d 64b8735f9e0d05b013bd5649e8df55455cf90d0a32e01a5bd47ce4bae2e2663e d3210f6fb94b6157defd835fbf6e24f335a53470ccc876c8f24b9cabc4bdc689 854d5cc84664a763d4ba94fab9f6826e4b6795b2c4c4644d1272fafcfb38dfe2 ef8341e4a2cffca78f4f85382c1bb11231f98e313e8b4b158f1f3858e0f1bd89 721bcfd1800fb89d20114f080b739a7f577466853064735708dca02bce6c08bc 2b21a17310ff3da504aba575ec91cbeabfe7cc7ddba637140f2b7ea4a087e5d2 c9002d13dbd6d60da440acd4e2fa2a96a51cb18380b2304c45f8d55d9e3a23c1 9c5743359406a6ff0228502eea24354ea96edfeb39d4149612a9f84320c3752b 4fc972f7883ce8ea63a0579fc59ba3626876688dc96b3b2774202f8c2d514671 8262e5c2fdc9e2d7add1a28b1ab3acdd49dcbbd4ad6b733de427fdca8bbdd9bd bcb2d7f1ab48ae12ac447d9006b14953c7b75a45eba9d7c28f3b596ae67d90d9 26cc343804e2dca0d14ab0d2a2d7d03b794576bf270c1e79b737191a78dc02b8 9acf167693db32fe00a5d4ec090129992b39c269833c6666c1946d8523bb054a 507659e6454ec03bc6228a469717eb91adc0c14f2dafa266c56522e037bd543f 6dc86ba6eb6846cf225842fdfcdbce3b702041a03dede7e5003cc402df63335b 1677fad719b74408ed9e1b6e2f9e5e6f0d5d54f850f8e4a4307c3fd2a5db6d0c b27e2f7563d41739dcc27a208e3c1cc6d7925820e953b36906bd63456c23a4c7 46a4d38ba7ef139dd455ed55953279c6229eb792833d5360a449e84d31ec9d8e 97d72d2c3deeb90f2b7bbea277bb5409dc5e185443550599dee57628b152cbe1 06cbf2f8915bad92aa93e100fca048910bac864de2e67b786924a5dfa47ed2dd 5f01c55600492999cd80dca1fb95bdaccc1ccc4807e274f5e2d76780a62ab9d3 bf3525ee75abe62a109fb35e297a6ae6ab51d430756ca8a44c2aa0dc558623a3 3a78768168d7f695ea5c96485f80efadd5d0434c256732af421ca95921cbee87 1748b5a61482181b63b42252c7663b9c19d3386000b73e440d49a2602801a192 47fd23ed6490a2ca505a01a2a0216e518b5459c621df2fdf9f4090575ecc0819 22cfab5bcf95785b94f17529b1292b25b8ef368d6d3bad17438c9fc4c41709ee 3309c171ccd892d173085fce4bda373b15bbd84719baa5c86b00bcf2c04191f5 6e8a6e2009014f498970673b8c94765896e485f7f5fdc8d36c97e1daf93c6003 77 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 +generate_ring_signature 62d9fdf998799ad5f0044a6a7c5bcbb9deaaf78ac678f0ca3750aee518456f70 e85e6d34b7a44c497b42634e4e8be3a56e714cf5c44792c29204903769a21091 16 21b726d56ecad082666ffe11fa61408df99af9e47500483421b47a34bcc410c0 314d10d957af2e4da98a98de73d201ce595460aa9f842237ccb0347e9493d3cf 9cbf055445a0e7121e267b3a73e7449e9eb5915b70922f47437dad8f4ec9417b fefea43cf649abf557a369c3f7a11d4812394d1def349ab23e7c2e44d019288a 48360109d5b6da985b6701f47397ecbdc59d97383be7e9b067b318acdd109ecc a97375453701cf393e2a8e95e5b6c2ce365c461eaa62cf1449633e850b5a889d 7ca32230254a075dd5d166b06603ed21cfc4f5215c94bf84ce9ccf3721c44df8 14beb62093b4712b058f10f8232884896e4e85d2ed8ffc1fc6e03b6e1080e2b1 a453729d18b0d90e519e241710b05547b2569dc07ed744dbe3a5c97942e3ca75 5c9896d9305a062aa12eee2bb9b6c8e3be3641528c6d19847081172694d3594c 574a15a29cb4e3c1b244fbb9e2bcaf0cc6c964d19047d3dd44efe0d5bb5ea1ce 0980b5584b6a796bcd0d1e87ecf3be9f1615413e3f1ea237bcaa17108c11a5c8 653a3daca423c001f6f69ecc804ed50a82d0d95cdbdb35c7483fdaeca547d807 18f5a832f606874954b4316e40f69c9df460e505c0a7506f0d42af45c58b483c cee4f248d50d0302575d03de3e792cc5ca9a2cdf58abe5b47be7e1e4a801771a d63afdc5a0cfc9a531b4f099fe8b74b2f9c758c39c1cfa3fda7def01abb4e422 7c23e8fc27aeb5d238494829871baa490fabe516081fa922f3a4161ed0e7c502 10 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 +generate_ring_signature 10f3730c2f6a2514d89bc556346e2a37fc87d7e83757248623edeb9fab8ac049 0add4f035c3579eea25efb66d55d73cc4df230ee3a749cb5ec8ed434d913e41a 1 8c906227edaf3c2236ca3f0e9b6aaf208bcf39ff871919427a7719ff092d26f5 1fd2d19d0945cd70b8a3104d3f0a7548a9acc311648967d48ba83203f213a50f 0 a6ffbcb777150abef7185e4b6eb16690c923503a5d76408338fcacae4146cd055e96a71d566dfd248c3acb6cdae136ad553004a8992fdcc682d89d5733e84205 +generate_ring_signature f4555c7a94cab7fa9604d4c106969a84ad66a469599db08ba49bc24b1e1488bb d97745abc00bb8228a40b47a0344c9556d8dd15964fcf20f0fd82341d6f18670 171 cfc4bef5eaf34348f327005dc7f809d94e495153532aa7bd337e1230de4974da 79b0a445dd281c6c167dbc468a4946bc46d7ea55b1393895ff1e8008f2f53a3e 411bad6789b69ae4a955d7d5bee956a5b7c73ccd3481b6e331fffa049a45d625 c5e8959c5e9f915e5af54c1f77a81fe3cff041c001bf163243bf59c206b9b78f 401660dc495dcb63633517cdfb4c83f7c1bbc39b510caa85d77861bc3f221618 6ca7e36b209d1e1c5b20b78e26ca678325502c504c43e51fe2c9e12d2ef289e4 b295c552bd1495b7b21d99ae5bb7b8025e507a3042b6fbd81cc78f2ab2878927 1a10dd6423205ce8dee6302ca9a40f2257aacc9e954bb6fce5cf4a14889b00fe 4def6357385d6989e58e06f38a50fa51503aaf3b13c2bffa146d2824f93f2fe0 8efd4d3019835bec1143624705a46b9f54dd4f410ad23a75e39f868728585a6a 448e81181967b7c2f211960907184ccc9dc01effeaf2bf0ff3246cf715fa7841 e12006e490cd7037403ccb0cd61a54d6016103d8228ff5bc5b178a4be5b3d5a2 24c6dd871e6f6d1e466e1c2be9779ccf2567abe7533a6d0868b3497346d6f08c 4dc82719c9af722b68c9c9b7a6eff94600c7e6a08240307ec343762f9d24b142 f72f1ebd2e930a6f94e2b3487e3bdc9f8f82c78e8a890635c76455bd12d2620c 508410277ea62390fb737108acb07efd9b4afa8cc3f0492f1735381a6bdd85a8 f98a6c409991d99882a77806afee0f5a4f479f4840279447945b2873c992d257 32e736d6c58b4a36c91cf1b8d9719430db9182e15184a30797eee75dcd966b22 f6fdd93cdc90c61980ea7069933b6dbbd53075b5a0dfea2079a461b4b4ea6658 38cdf0a99c31eda7fc48ffd68989add1a6224503e269a5536701b11e4028708b b1aa00ffa31d1d3d7e645dc9ab2c9d724b3a699702c877e7ea610808dd2ea9f5 1a8f990377f923a024effcf088cc532ea6049d533d59563e398140dbfef2790f 635710a81651e374f11c728151a6b81f8904f4036f70cb3be54c4a1f394780f1 d4c8b7a93f5aa7b5029651f44bfb87ed4e762e9a166e37db35eed7ceded15017 5abde930e31af431a396c120cfb04ae6377f2f653214c76278b5e93ee91c7989 596acbd0cee6be1584cd61634edd8ed33f0fadd3918e8b3398ddee785be0d2e7 197c6902281fba43aa82e272c5cbeec79ba8b28dc0bbb1f1ddecff2c91cf0444 88176dadd11bb0920f9dcb0b53cd9bc720919e663588317d6d48c38fb4c6a795 c623bab71256ec174614b343d79a6b1c7c29f89a94ae9758f60cd5f2c01fc40f bbc6e9dd8b262f08d09935723bd9ceca95667d6000b64d6566985d8ceb02f5f0 e8d10be27173f52da0711d82d8a2ae34925fdec44dc232eacfd24932b2e459c0 05d9f54e15501e036c89fc60c8fdf9ce39a7520d0585e02e852f944a76cc47b4 bb548d6df5b6e342173a857f8378450dfd1c1526399648a05f81b7e72cc5676c 037311c8983b23d7ed1450a24706026c1930d7ead062b4c5806127061c96fa18 41d01eb664f28f27bd51f1959a06120d7eddfeeed185fc4b5b9c67593ca3f750 ee1fa901b60359598a0985f6642fac8604aa654e78f1f3d18a1fc4ecc87536cd 7d69624959350420a65aec671b481fa6ca9f3406e9080acafc5b6dc251e50a56 5315e45e258217f50b9bc1d79bc411aa350d3427080b3cdf5c97ac703861d519 a4ab5d6d62a398b29a4bb0ff983060158e2ed7a81488fb1271e380839d5ab8b5 05985546d407861f5c113c25061eb90876cb7b1d043a74af25c62b406b821337 bad614857399ac6ec7ed7887bd1e9e0fc0320b595233fa0c6797f8dce599ebda eebe0e178a0e1fe78e6233eb6d86d3bd701173831d7f40da0d64cbc572826cea b329aeb55ae0de7a468892cdb57aecde5268829aeb84bb88245111fb438dffa6 fdac8651768a15a0f8e502319d3cf2dc41fd737e975c2b4a428b42db1dcede27 88d3032b6384a94593f5c782e3e7bdb027414c3fd99d8730b2252a7ca744a3a7 1771480e847547152d3aa315218a1c2cfd01cd45ba95182a1b6447103ccceb38 37b27bdf4740b2a100f54f9a289cf58c2b66a4e4f1b13e577095403c46ecdf86 427e01a2c9473a771c6fa5e2dbeccb62d351e429e2947b2cf8c228bb10da4649 15762146795864be7e50a35b2f3155b05eaef4d1b01c61347db5f11d5baff073 69e02c54680cc7205966f38e4a27a37a4a7357026fc38b1b40bce7e7edd5d1ee ef15e86c3ef859f2c85cdf828cd425d4f4ab7aefc11f5a0f4a16daa2b5fd22b0 618cdf2644069de2e8275619d923ead50f93789a4ae2ee8b68b625cfb206b39c 50d292bb61966a8d4beb864d9c120170f1570bd63cf07b41332797b6c29f5c9e 0a34b827392ba1883b610d1422c11696cc281c8b6ae75e961c42be3a3671acca 14730187723cc634969ee839ecf45452304a07bca280f7dae82ab0edc0877c29 699a24951c6ad1649350086f99a1854c89bda4228cb4a472179987daf854cc10 09aeb8ef6645a359661d04a03b7b7ca72c17a0a31b88997264cb49a38b8d7c13 85b0ab6229bbfa7a3b5b7b23811785805f63909500c94fb51d89e8f0554e70bb 3b665ca09ac6eb886900c99aec8e95270ff3ea73c1d8654cafe3acfd40019003 cdadbf8b0087a497967578999992fdb5f6dfbca21531dc5430e41151e051ae56 0ac2710ec9c037dfc4c3f93c5191a14737c0349a2c0ad7f6a44796b7bab64ea0 ceb2bda229231c4d5dc7c031cf687e6bee4d94c75313fc3d662dc8a6925dde77 a530dd5485fb70af577f782c9bb1b3694f832fea5555309dc992c65950137c14 2f55b2ee169c1115ff9eb53e24e1a240b7759af68bf305667fedce45e3f0d619 69aeafa707c68a9aa05a273a1b3fc158a5fdc20e143523cb6362f6ca37f99c25 2e03f9603c7abff4fe2766d73c4a39fdef14d144b0019896ec3685684443f1cb ca18d53a70086097a653b294e2eb531efee7c58909c0a35c80202224e4dee356 aa7b68adc147c53ae015e29d898a72b94ef6b6661f3a54c88a03075c73fbcc81 70cd2e3c6c589814e7a3191ec0f20839bbb2849436b9108110d689abb9e0027a 7dc0f441b3f1c7b35cb5ea301dffdb55e8bfdbf0acad34bd01786107d43a847a 3f08b78c2866d0779ef8a6751b7814b6a509a091c99e96fd3734886a6d001ac5 11db0478b0e9a19dc38723770b1798e3addbf704cf8f5d2e2764d139f0d22a51 f961c491a8525f841bac81919a905dfbd249a7a60ee6257584dfe276ae7950f5 28565b59bedbe41949595332aeb2711fc67733117120b1822c2e9a327e977125 022098f9fa98ecdfcba9ed3a8bf49c72ccd8117cc14d21dfbd22db54deda7ba0 68f94489f7a92f0a9222e201d2b4bba8ad6daa41b4de2c57c7ce9b393dc9365f 34b9147b28a3ac76dbb13ecaeb3f6d6e722a4a8c7d0bfd8efcbeeb187b096a79 b9a3ddbedc533698050e8c4dd60e05919b70fc5d487df6d01b62858b05f48aa4 c214edc1e0d6f77f18a3beb648b37a547ad6f929f3bab96586ec3034d6f9fd8d d04804e17f6bbd4fc3248c049895d3911d3953ac98790ed97f7d038928be2946 08ff0bf8daf6b3b57164169c2b48ca64ada70baa106e164513ff2a5e00a29ce0 bfc8cefb5c9e90ac9e5a1d92e9b7529d813f8041e519fa527b224151af806e26 a07f1068e09111fb6b58ad945f1c7705afe8ffd16cbe5488bc8fb94b8d53caf0 a451ae9ea7500d137403e431646e4ffdf6292489608606042f1a0e373e062f7d 6fe4867afa167c2f14ef976eb6403af05c632057e0d0c5884a3b83052a9cf32d 2e2e29ff51678630871baf5f4b1c97d6474647749de46d887ff31916194cd43f 662a6698e43f9c15cbeb38c3a8f31fb131e1d9b476f0f3a0bf40ee0e8e6a11a2 8421394abfa917e685bec5736e2492f825e7b259b587d6e568929d4a05ae2a0c 442f5c4e472fe9a9ae50496e3ee4281a7945d55a585aa296873e28e2cae5fea9 d09852ea077348503bd7995157301f844afc568e86d3cd18f0b6d415643e3e20 268d7e0eb3a46a11012dabeaba1f7e3574d1e32074bf4a2feded65c12b97453b c122fc5e2fc268e3b10f328e4ec77edc375399c1100dd10acc894903da97b9cd 9f39d95d583cbd4cb2779e0820d40954218f009a7cc5df92e030ecd9329564c3 98e17aee11922bdb6a06e8d5b639097fe9127dbf79d12aa9a8adcab208b36a2e 43250a86c378ab45ea8f34e71a451cdcc8e0709574d40f77357ac3693db3d4b2 f33bf249022052081d7b5da52abccd5fec3330fa176306958c7e3d6291f52984 020c044368cad6dd0e1d4b563ff0d334233c6a875a652e551d0bf8855c9d772b d32198328b301c208a8ffc272e512f909012a07cc99488ca9bf08c8fd8940f83 0832c436f450191a0e0ae66be14f07ed5081fc53f66a0df1315d7358cb299d52 fd2d84f1afa4fbe177b4da82bf8f6a5b46406e4dcd6f308fc54c6eccd018d707 c650a776d5e5f98ca43507f46d2d28048a3e21a5196dbaba699ba1904ff2571a c87c053930f772f7cb317a3191c3c114fc323220d74216c28b9d1354c35a866e 7dc1e344d66e726db6bd8d296dee9d3f04ef75862bf5380e445ecd43b0932618 af34f348b06c894e95c02c6a16fd7e52da6b45663df93c6a2533141959729f7b f99155d1317e0a8014da9f95ef688226097cf59080edfb3cb1a7d8c40c236517 bcffc6582fb43aa29d9df01cfd043166191ae64ea184af279d3c4cec05e46572 dd56ac7d1111f96f932fc79f3b9a33bbe5ab7c2dfac8d3c082c1d07c31147ba1 af799d2346c63aa6e1aff8bcd560b70bf99b3a84780a2186b018f87cdc7becb8 a613368b100cc5a85c4955ad5bc04e5f8d95fafbcd62908e699b984210e548a7 f6db5e3e8cf9f271b129038c706e1a335baed4cb85a23934722e22ed7aad4814 f94f6840a410db8d7809f6f9b6e4898bebe6ee6c792f046cf08a0e192f0af4f6 cb6060273be798eb8e209509a44301993613f4fd5b56b4535c515fa55b4d746a ed1c8d689f250b24e66c8153558ba88317c26cc02ddd3fcc6c9c59cca038dcf8 68d13f2e581dcaa275f2523c351febf927fb6c93e65ca9a293ad6e812b413663 46f723ca4398207c1531aab36297a3f437f1a26458eaa3b7cae6dede9fe8bf91 d74bd9c293e3022a7f7a2a5cb8c22f6da99c4dfac585bc91d4a54428af645a8f 30eb33b7a3cfcb4ce2bb552ff92711152b2b114b9a3dd027a7367b8e8426d5b5 f61968957b10bd9c877b50c5f7c8beb6791800f1f3bbe9b78648d3fa0faeccb8 04e2acbd42014dcb32cc1e7690cf83bc017378fcd3b391ebebc56efb6b515ac7 bbd85c1e26423b3c6c68739a82bb5bb1bb045b8e154ea69faec0c4e55400b79d 87e234d1e02dc9a3cd8167b7fc36b72b2cc9a510dfc160b87e4c3f08046e504c ef996edd8c19019436b04acd173b66a4a881ddffefad2180c07abb7534021af3 2b75cedb11ccebc4875dfbf2f4b18ef82ed352924567cf9b8bedba2e79ac9b3c d012005892ad3bceeddb59a34f98d1717cb85daf2e9fdff671d38d29919c3306 5934b1dac37b15070667de83bfcbfb87386f93dadd3d90abe02115ee1be25511 8c8367ac396509cd1bdc3baf341cb8659e85e597c321cd8b07d8e349cffb27fd db8e1c01cbe556892ea60baabf545c1944bcaca8b03c22d4a1f5e9167b5749c2 26929b9a191e52549d227b3798974397b97d8127911f6945dcd52c3a915df871 bdf06c632061e00b667dff7405eb578912508ce8b1cda679ba90637a6ec9d755 adec4d15f5b6858c8c7fba49da88d68d4bf31cd5b92b34ff29ac5d7cde88cc98 d70026fa9b5753d42069c8def719a909d34d6cab3b1949b5398564bf6f408d70 ace300fd54f1eb3b6428c46feee6824f1ad1b7519c099800f8c90c92f4c52833 0d6a0b164b9b02a3877f8326ba35cce82e4eced1d21af4d2e80f86ca1d8b72ad 3e65edc9aa0612700e957251c766be20acdad8ecbcbac2a645e286c3c42889c1 c797cc975661a163376b9d0ac24abd415490f5c0e5f70f87c40cdbf7f0c76c29 40f0a14168aa61ba89b9e5c40a8548858efaae2990b1a102a6810cd4e14a4200 422dc367b19a024000e1f102653a2db986d13c1be3b0fd9a6d9882f6456cac0b e69f2c3a2328b8546bc48b72f489d782e4f669f0a95e759e2c58101b10fbbbb0 d0b9df63e05f270697be34988384816f750d2cc5f1b058637cc4e494bcb247d1 cf39c2a55ff7c176830e14298088e6482b864bdc9935a880e54000ba2eb0ce9c 47b5d892a0a98abe0646e21bf3acc9414e08e74d9d7ebc46b8c5127e5aecb478 df6c351cef6ffc4738adf60d0f7f995a651e93dfa38d18b5e8be83d6cf7ef6e7 9f765118726950e8cf8f2f6f6db2cae8e49556b0432fe6960fb31f4262acac57 9cf2fdb6049dfecd5cca8e4a5fd17364a89ad0ef7524a28f48aaf7b32309b4cf 13cfdc82e184d2626825ccd9f10915fd95ec8adf1f11dfca92f5fb5771f48a0e a3aa71ccdf007f88880835328b070265dcbec5b8b537af52774d99cad5aeee68 3cc2fa6550177b8354d2f5e241f8b721d2a5366c34494df2cab5ba99864cc23d f2ce0c858dc7639de0154418fdc0f5f36ad7237830b43a200eb1e5b8ed713345 08ed90cab1be91c643d1d9c620c3bf85f3cfe1173c7cadc37ad2dead9b5ad176 00ad99b49db1adf38784bd79bf313794e45de8dfbeadb26dd8a2d475b49a6b71 37f121e481a9282144254a27b07b031e44bf34a47e2ef1bcf7b9b8524db52050 e00d06925df9f5236e69fa2a78b78de859780ca4e8345d50efa819179759e483 a4f6188c99012e9f26fa24abbb7dc87a3057d1bb4b99f4f384e5decf9c17c36c b5a5e73fb99c679b4357da96990a6d19a881e12922f1466958a4daf9af573e88 4a52f4bd038ea6c046ac554f842f88a654a055e5e9bc18bd6172f78dd2c97cb8 8efa9ea083dc3fa22da94cd582a3fee99d6a51db50444b1aea61c4bccc2b6140 ce192be6d8d50cc467a4b520368ab399e880b3eb4d93b8a96bbec74070e7c155 f22f7b08626b947b8d6017b846b258c75d55e1098d381bcfa7440d5ae51ff91d f11cea7db46c8bce9a69f5eef55f9a4131bcb465ea1153c9144fb698b1d936e5 b134a75ebcc9fa5b09567511151c8cc6cadb20af14e11c040f19519a6f613102 59b74ee6ed5cd8ac35f7dcd3b5b3497d391a3cfcbd21afa40a72713cd45b23f1 7f31beff2c2c80200ba74222781dc3b00d1cb9c2a92d0a0deae2032b8b6ebe43 acf94b13dfb0480f64d8f24874daba01d93f09d2d29be66a48e076dcfda39980 d31da219eb8bd9b7ebb4d6723adad876c59e1cb458f66a11b8b1e494940ec782 0f493b671148ad3cc994506460ee02bf973068429f9f1073d2cb09096918a5c4 e7464582dac622f032f7964927c94b2d801f92464c59ee34d533b474e0c4c568 faf9274a260a3f80554a0e9b6015ead2b3c7e39d9d5041cd63f834c5af85f398 424919660a91ecbdf5dc035759894703844ee28939b9eb004ced281901dce148 08df61a2481c760147c0a65a188ebbb4c0a3394bbc7850117317032ba5f7a31a cb51316d6b4d9797ef4ae30b6ea1314aff7d91e1e8b0cdc3d56649b9037cb193 fb517591cd9ed330972170eb93c3563848becb59e905f421afe8fd8f37e5a1e2 9cd6bf970dd2da5899dc28da8446cad1bc6881cea822a9a20debf919b23ab20a 103 fd7898a89656c611f2f499529a0d6c387e9385a1700523ede2c96dcc2f5ceb014fb2da36f821cf3d71f029bdd45588914d52af087a4c27b2e17c18d91e409e0493e32bb78c8e694bf96c416bfb4ee49d39178e8b46f8bc26b206df884dbf0d06426bdad6d958b40a2c5878af339b157942dbb4975ce1b26f37296d0727b7660687da1dacec8fb48a19d455e0ee429621b93f4b909a14e4de0b6d61b0faaa96048433a3e4aef400d3f3edb516db797f3a9dd4b1bc461814553709c33bf607d309fe04c5894a0b507d62891cccad61d2710795ddeb9b38b898e74675c86f0309039173b5e28d6e0cd822e3f101798c3192a7e5a520b92ecf4841e764885ad39d0e64bb5bba7262046dbe0389d98aaf607285659a29517971b251ede5cd78cddf0ed16b58def3f16ec97646249801a8b9c5cb4bbd152a275fa2d7b36e57a6996a0b476e0c2edf0cea6d71af435fce68dd3cdd1ee54fd444d8edaca934d8385ba00c657478d39a6afacf9ab874b9cf47dcbf93a9746b6fb2660381d598f99ad4460101c6ab5b8499763bab936078dfe28aa4a11f46f6e4d64a9f5a6491c20db3ab0bd927f632992338e84a9841c1af2e44d1dac79d0a075cd678633bdd2a68200b00dbd88aabb0fef8ac287f99364ecb57d3d66b2daee02346f0f7450d45bbd5a10485c007bd9aee9238db5e35299cd02d6ca2348552f0eb6c7858239df105cb580e58689a12ea7c3cc78cadd417a88b084c26ed25dd4022a68f615030cabbd00f0e9e9da0d046bd221a1717e75ff6ee418b18a6551fb9f138fee63422e8ba7d2f01bd0b69adc8b7d792d3f6002fe9643a4434b5786daf91eac59bc18599dc19410517a9c337b0ebc4a5640b53fc130644d27380934a62d7a0d62f17c5b7bfb0bf003876e463af980223938df24bd52be82758b1608d8b96abc03023236c0428b005ef05de1c37342fa9d82ba6638aa5ff0cb7d494de5855ffacd126ee705abafd0a2d97cc5a854a1af31b2cbc06e6aa384ce929b34cb25637d02961b233da32e10870461fe0c0e946bb2a99c56570dcd460cef90805d8f7e6544be6b929283d1c0eb9564e6c9d1d953212e7d4101a84ee82809cb3f24cd293e9eb17d9e605c3fa0420de064113c9cda6bdfd199a0b54b9d0f00d79f90c13e64f144dd5d31b48550a5ecbd03cc4fb43c5de092323b558903de8db2c91241c430838b02c4f1e6d120f7d4ff05e6ecae87e2b00042b175b411dc05ee55e56a0546e58f9eb915f77f60781d03ab3ec2b581594cbd7d88c057a11c452e79bc79775788aa73f946ba26003de80bf2448ebec3ebca500dd82630e386ad04ca70f705995efcb18b11b99f902e25884e41d7501829e0e9254da5595fa4b975ea4cea5359f9a70c458234eba09cbf76f8143fb31846242a73953337229ab122a1bbba9317bb321044a380cae0c1cff2f5a0b8a1513d4d45d2b352a648eff41c652a732b6323408260e4417d103c65ce6fad0244dc10b46e59764ffca1fba1804d433cfcfb6c5bba7da600cab0d2fb777440afc3be6fff9f48e9e01b2adbe75fcbf3aecf894a85a40cf0eadd808525622c60ee53c2d03b7f947439a3354b612faeb86e9a3c7fb3da5f5391d670b2ffb49ae20397ac25370c1f38b275f70e0cfcb84df4a20808b7160d84869450790549f28cd754f739be88e9dbe00585597c9bad5a5f5a916dbdb992a58777c00b07ff1592c54e6074b8f5a944fe48cf2c1fc133b6f97dfd91ffbd3c24c37a90eae9739590fcba3880ddbd9303a0ae0dde6c2737fb2fa0d6952cb7f2e36e3c70d2ef32c91d59e5956650ce34095b5ec5d6697b469f5a6a632887322c57c143b0b0a3a39cb0cf91590a9052938a09637f4c9eba6f2f28a9223a3603a3d3f711e069a596eb39fc3f233185d54a211f519990ed254c07f5b10744e4c84c160117d0510c88c76250cfc83bd6b215fa7c3661aac474e1cb0d5048188d4485b874fc305f90623f80fe372f2e53c4d9a8ece5277f993117769ba5f361cd504c7298acc0659eb1d840a155074a4fefacb8c4ef1a7d44b83a1e3a54645cd3528d0ec5c5d03c8e09d7fc70db1dd29798d53100a218e3e32288ede08b094f9ec05173bb6890f63b71536f28fb711a6287187ff7ae93a196cb7dcf6032554bb948b6e6d91cc0e9edb29cb1775bb10c99d6db293c9d9f04df59eb0f10d31b445973b3dac394d0190f9a866301041a18980ab0578dc8a7effb1286e42684c2338eef2bc924ffc0339dd95a5f8b75ebeb0da4be6e993f534c6841e027ea84fb228554b11c063470cbd973c92f2df2115aa3cc681ffe1de5d9ce1afc511d281003375bdaded35e30c4f57d71bdca770e48453abf472c41f45ca4f2998d8583dcac75e7896b7282a069fe79c9e1e6028de3e378ab3ddb26c51d058c9bb68a9825a6d005842aca2ff00ea555d3762365541a215cae9ca5c131bbedd2e98a7d18685e3d4e5c627483b0818e61f7a373810a9831978204b97f2eeec5482bdcfb3007bec4eb4a58e727b0ec83caa9771e8f64f4a645eec22a9b5aee62ac5da753c095a899a1622707c7c0cba5979ed28e53f9164061c7815f6a14fd712ddc3da929ad714960f4a3863df020ea22cf6f707c7fe11df75f75486e9f24538dc016898f4a36849aed7e4d4490b3ed07e045bb6b22407e4878d93bc498c173356e791c2f02621ac7791b7462b030d9ae8e2f3404c4ff08f88c2975dc3f769119468032e03ecbe69cbfafc9c150b272172536a6eb404f87f9cfcc63b5d8311f74522b7f10ec5d40299b20909360281b081deeedac5c816b63352f2a5e0056e9849d0b7e3d99cc857262971aeea0fb64ea8be0fc004a658d69ad12ebba206f20035e49c1e7a9e8d6c2dcafbb2960bdcba8574872a24dcdd05dd7358c5dbf32ee1367a36080306622b314aa27edb0b049a704519db313ebd11e8d890709cc89d19c77d5bf594e17eded6e89e89bb04b5b324d008e36449d25b9659d8892275e053bd47fb01e1bcf46aab7404777b047fbfae64b97eecee9d81014e15e65d4b91ea8c3fb46372d77e2804966cdf600e52dc91613b979ceeee05941c0c35bf23eb70da79d3460cd9f009b177124bc505a75ffc5a69ac1aa624aa414c4cca137dc1603281aa890ebeca18e824ff9b2a0f72894fd8f5574e2a4c464eb5cc3747512ddb309cc13ce3d5f4a40fccfe3ce20fc6fb2a6bfe18e939fb055b85dcc086297f48671fba27f108cd1426bdbc5e2d06ae28b0aca2c430d9ba3c4ef7ceca58ebb31b97293326fde67e49aedf351f90077e0a3c39db84f3f2358acc89d4db2e98ac890a557a32286479e6509d10723f0fd58cb029dee79195f49dda650197be60f55bd2da9f7fd39fc43c116ba3328c06d6b3ddb02f0f372881eb0c8007ca8d6c5ce48091d41e2836299368479a2ece028eee1598acf198b6adb921aef6f6e3d5ab106b2639414131051cb9896ce0fb0f5a5eafdce9ad70d104e1493ee55b990c0f6d5420a1b8ffe0643d20f76d6f64098f94e5221de667850be66cd6b66556074562b3009e2a4ff3233e7a52d1e6e1025e93723e5f7dff6a3bb87107a948cbd249896262de7287db1c48702ce15e6b09a48efb1939216548edfb6f5fbe5f0b1a0f5068ef0d0f16826fa5894512ab870b65d028d8cd2464770ad76b0cb4b7039bd87173deaf8b28fa99c33507dad56b0db8f8de89343910556681a697517166748c206ee68cc4a9ae5c283a4c92408c01436359e359d336ffa0f609828a0e6259eaac0106e576ff0fed29f47225c7330f9a3da1573bca268d12b8cf45ea61396d97cea8e0e675216b9c6e1361647b380a90162df0f0daa053097e2c6110a658b7bd9a4b38aaab017d71fd9439d81ae90ce5e4a84841a7e65a845cd16df9897a092a26a27f5b167dbe8f1b3093cc5bcd0b1c25ef1e0084f8d1faf87786a88695786f898d66de1eb0b254f0eba82730780163ab3a69a66052656ed7b41f5cfff6e1849d1ebbd68ea706efd58425e5364e0455a5053236e9a93a4471689d3de613585288f8b9bcca3ccb9b47550b7f809d0f2b1e0de3676e7db0d25f425b037b8f4206b4bd8af92538e8a21e18699c924d0565f785d25e5bb79e54cf051527ea7f6e9bcedde091bd81f45f099b6d886a5f0ead94a9a83c7dffe90b901c13f4581352e999d6b12664a9db8ea0e1aa9e5efa00c1d67e7ffae3ecf8eb67dc743ba27dd6fb93dc45a197c50753a2a5d83357ae0e015f3689859f4f43e480eb235d46654a69451895f8413e0df35452190fd5de0af70723abdcac0035de81ea575c63bbc6f90b392f1946d8bab1dad68cfc893e0d7468e03d4f0d4e1012eb6105bc762e507f34e4e88ace67ef34f11bc7a307250986c57b2bef510d06493621b930529a8a58f1a519d04e888114c7e0c4bb24a407b88dd15a93cd143906014a9e17eef73cec2425bb6054dc379b9f1cdeab53f1059eea7458df43e34423f047c474ba0d3778493abb3b139d8c752381104189d70532996aff1e9ecd301bdd21df25db06d7a1a8406a0f02e6c58db1a597355ef7041e4636a07f8a5d56079a6d123a7219274de25ed44b7a5425705eea52d3aaa20f10c8a37089cdf4fb3876b6c4b3f37d895132c9f3e5e04b49b7a6b2eba6faf1029710bf2db7da62e6ce7929c954457977af1e85e66f252672e1eb93c4f028a40c998beae5df1368123d69c1228d289de1e53d17e42f54d9b5995e360fb0c8690712d34699b4b67e5a018baef2b8f98e38e8a2db821e4a46bb36fc3b4824d50907e31823f245851c4f564a3797315b1c3dfa4768d9f2eff9d752994c1d4799fd09347228798bb9171a47ca5b69d3d72d50adeb133a8874d62e925df90d3cb75f00fc687eaf1dce521473497f7970339f2e56e933356f27858de9c7dc4338e2d00c5a44cabcd21b0afef1be19b5835bfcbb893a89281af8e42877c7309b85f14e06c05c24f9727d3b2579535c1e573e3aa86a5e38ef90cde5f1aea7c39754c9120711c827cd5c0bccd24a220c9a80d097fdc77feef21ab2aedcc0b1339249626b034be3cb6df1596c7c37a81b7e576c69116e5687c8ad1e34f2d11c7fcd1894df075c325c520d7bebec386a37b90473e74d7fbdee3cb6064612a61025de017dc70b565635c1165e3a91a17821a59510a63a6c19833e7f6c39bd3759bb508a40c80f79e6d2f66c81bd39a79af4d0a8f08657d8d46d3e42517bd0a54d3735100a7f0725373d218aa01947d04ab45c568c858532f26eb72ebe556e1675335b416c6801d4e6a0a97d2b6b74e420bdf748ca0e70a5428bc8c8515e8a239a849b3701b80d01ddd0022dff5c5b20d0f3a3ab547fbcfc674bca871bdcafc32cad29f783cb054f4fe706c8b29ddcb568e22c73557930c842a83e004b254ef40c4128622eab022c5b27b40d8d71bdc945a690e8b62a63163f1360e75f6dcf188ec1b6715713069736d9a13660ccf207606a3ae8d3826f0fdb8f0efd547c53a0c3b0522ffdd505e39ee85299faa4c0c9ae4042b45d65a6ccd9b38707f0d697e74ee900bec8e30803786cff93190d14253f6a1e1db243d9e4b6152d77d52c4eee0c6c6f1876a30fe00d99c1114bb2289276f0fea78dff9fe49f901b487f68b936b3e93e3f9d6c076a9dad40151cd3889623d18fa11c9e03423eb43de66b8c2fd6d7c49617a3b70460e9bab20b94a7a38c1910ddf1dbd79f80174c5d692e2681d04f146783b90e04c6687ed9403d377a13270348721492ee280506d5c15f8242fe5180b8bbfc850daa08cd7a97a0f6a17bf6dd8e8d909f539513587d7637cb9f2311456976fec4026823c1bca22e9ff315c6412145f29bf906dd417c3d33055ee6265045db914002322c4c081c429067e2f500fbd8ab2c3b38d2ff4cd24e2ab340ebf8cc6453eb0d8e0d8c2672ee63d94413c99f057f661b556c62a4e71ce3dd7811a68272957c01a8736ce753f297d97854d225fe49d2680117d281a34c0447520e1fd5ea80830dd610b8a566f63f8c593662b7d5079e62467ee53272827047bac87fe6eb0ca009a3d7844d616b68eb8ca0dfe2caf3c9c62192488d05d0c9515c57c58fa122690248a5215615c74a226a95d7eed4c67620541f023f1ce6d4d6767fde4f5cec410b428b631678640cd43caa475d26b26858657a723b8b784f85153094369ab9de0f0d9e5d463c252c151c339c73e482a13a633785d1ff818696ad5785e2447e240415815c281d355a17bfd041b26b666b4d25d44eedb28846b9af31476cb484880f62d1125c360ee7925afd2cca2990f92ab22feabc3fbd7cfe803d675e747a6e00581ef398cb6b88f13ba318488f8b5b6dcb74564231049f992fdbaf32e0b36d0c3c9d4e1e4e232be77138b93ebc6b6d151928a844a90f76c761af365cca82a90023703772faa55e9406ca9b3e348afdd3aa26a2dbc171aacc2bbb088d7c18b9006871a2f0316c0a970201e3470b7a60142efb59804773bf75b5a71c7e08e9f00798f3305e530b04c25b150aacff157974094d19df3ad5bbc397234324dd31d705b5e9326d60d82cbdf3f628ddde9e54c711cadde9ed08d10bb0940d53463c5809b54f2711e0d1ada2d9e7efb02b11b9e78f6229a65eec37c5fc8ea3ec3af6b30eb446a6ecee39a12fb59053462e1bccb53a735262497cfea7bd2f0442c9b9fd06b746df185ec12c52208a00d35b55cf71b1d5916e8778e3839f55da591d97830d06051e370a79ac3c0517f77f4287b46ddf18b7b92133b264d08d22476bc58208c57f835512687714994487f4840049038e950a2985e75690d7a24b66f9396c076cafec23ba1fff46fd40f5dbbc8a574f21049683d65e69f5778a787b7e6e8503458df1e816443722993924d1a6b5de7147350f06f59dfef3eaeb23ab80dd0500ac5e06fc6f404f7ecccb1cfc2b974cc020669ba53f3eeac2ad351555e464640624863fab3789e3013c2e96b46abf7aec0bae0bb4dc9ce056d253edc892e98e00d519ed8e9ceca094481cda831a370f64b2323145a428b963d0d28bc741e3b30c0f1211a2a86bea654f8a1ed5189bcaf84fec1efb4a0fae54b37ec0cd9e5ee60f89162b44d7dd2c0ae21e64d9ed89568a743fbed4ff5ccec92ab43f61b45b3f0d1de9be5863908957d3d8f128b75064d872bf1c5cfe1d304aff43104f38fc3f07cf201cc9b350b451ed3b2fd9647d6c8dafa171f05e005aeb8e54ea3478641a03c373e708bdc99601f8085f765ca07381e6780e09dafc17c736b875c188eb26010875233f3fc5bb6f6668e503d42d1d5c27538b4393dadc278bd3e0bc540295091ddc1f1f671e64104586d47e7ff4bce6355dbdd876dd9c3e33d6ccf1fbcd2501394437193b038d6a22a50e9db230a83589da24ee47315f30ba95b080c31f8b0685f8ff3e044521b841687ac9e197dc0bd5f83c83d5aa7075ac87118166d9250171d70df48fbca8c6aa20edb8a5e45a21133c1c507bc00cf0f4e9d8b1b7000c0fcc2fe3f39f40abce768d4d178c1d0ada9b5a5c344d75d599433f890eaad89b02d79b8224059e07ce3ae632e0f34be6a7c06dc73618208664c6d5f70445cca20b6609d1aeafa23dc6cb7a7eff9484fd02afde3dbdd6fff9a2860e94e70af99f0bc63f1c405203de9ff59d6f5846f81baf5e09d68cc4e7bbfb4243499187a4af04355430e176ee833f59219bd0689d59b4ba0eabd95166792e9507a8dab0e8200f84e18d493cdadcd375f14e9c72e4b642836e4c0ae46002cac647604e21f46d039a704253ec73069f5315e749b0a91459d6cb298daa0132e69c1c433c82702d0facd4b73604f5c747f03e2a81f195ee6ef75500d649cde736c0643cb53d65210a0bc68fcd11124c5e5dd446a0b9c1bff9fa0a2b19645c85c9f4734c2f3e9a350892a1b7deb812d0a53daf3d606c4b2b211e0234cd56004b9b19a4d8ab39812202709bd67e6e348e172ae16d19801770ee40fd829477ecd0ddf574ac34e17ca40c78bfad23135f027f39fc14154c6332ff609291519ce31fbe1577aee8d8d5f00d7cd5ca025e6191feeacbcf974eb17824b75aa1d4c5b6197ed6419086eb8d430b8edbd555acb5b1e25f3159d6121103e7bf7304951e546f9e51a14e169b4e63035269e48a586abbe1d3a20a34827dbe8b33638e7b4d905ec54400930351e78b0ae5e3640bb5f92e54522d6ac6b57c0c2fc5bd0151378e3c5d954153c0cbc5350fae9b01dddf2f7c8260d498a4af5401d5e2b03da16c299180960196c247cf7406a6aa168af6a77a08f90131562cc39d6106655370dd05135fe676f2e7926c590ac883eaad671415cf051621aac530a7cfd7f6b427a6e6f5ca3276746a73ed200355355ec058ce192b4e1135a77adcddd860df7e3a48b0e978b3bb527e6b929a0a5a23063b7a68efab8369489be72758f870a307f2f64892b3844e88bb2846f709f6507f6dee2a70cf305148e02d85f8786dbf7a58b3bded1c5436b95a3b9a4d0dd9557b46a7865faad86c52122cf777447d6dbceb339c8f094ce41e2cf6eaff0a756c6177c76440314760d1b7e63ea9f59950362ab84aba87c89aeb88dd1a250b90da701840d3ddbda7c433d507daa2f175773753c168e37ec7c4451505f23e0341c438f9291841a4926446b6a0706f4dc6fe32598cda75a4652bfe982f1b030400b9871a82a7c96fab8955f52e7926b7ca2027e638f7ada82054f5e9efd98e0b707d660bf9b54101b5fd9d869bf8532d7c882b6d89b64955267db9e16da06b0462e4033b484f017396bc456174a5ef8b8d2bd279ae1e538d500b09dfa72e8f0f42bba70482093914fb5fc5681aeb5b762f296cd3725348938a95bdf77be7460ab7a15165d3eca688985d955b54bb167ad6bbe3ae1dc3e28b6d77de55a180ea0256cdb74c2ce5571b36abac0358ffee5d46b03f98979d1b5f5e4f7a2646ab3a02d8cd90f586161d5c99ab9cd73deb555053c33b280fe8c347d89f5577675bc004d03418695caf809aeb3c9290537b2bbdf72454ad3352a8f0fce901092d54fa0b44fd56cdb23500331ab63f3ca0a466444506479afb52dac889f801fcab293403adc34b13928a90f3f2ec099838b42d8b5651381be5fcd195c07e56534581be0209302757405b70dd9cb0aa62b674c4e9395dc173d5eddbb987b8cf2b7638f10c9f884ed936b9986bfff8cb2db80df12198a3dec47d702b7b49bcb85b570d6509cca307c382fd6473818cb4d53b2bbc5379597f28197ab5b1cd93aa15dc52e9045850dc7acf005b41143a65187082f668993ce1748a7b482a24f3e0763ed3990746277af4354a99f1ed4dc9c62c8298367ecfebb57264dde18efb36bea2789b09b0365ae0c12e94eeedaced2b6e64ea55dba6eed27e201de5ea5386dc5921240b9badec9061c26843dd23db9918a7573cf75032096d890c29d29606b760c11b0ee0a0534a983923a0ec5b7cb63d7539e593729c0d747d9374a78dddb62d739d020211d82c7f647ca4cbe4196ad1e2137c33b1b863af6efffab810c2ee048bad08bcf5053535b46df0d9058ca2e48e24d856312d09e55800fadd9712ec10b4200af8216f15466272c56ddf0f35595842510f72679f7f9d2208474e14acb29836005de94e99c00fd76c72b250fb83861fad9a299bebba2d2bd8dbd16e143ad7290475c05ba60c6399ef970ac6f2aec9d6d2b6bc0fa2cb79e8df46a51d6ac40d5109cbc9e9cf59514c909fb6944696cbc35603b3f9a971a644063762f5ac7dc3d606b1c1bdd79a66d02935988dcba349dd61288f0f41c4a113ee5186cc1e06ab3e0eb7a3920077bef06dc0a8c7c8c58a7c0953d432181bec10c84338d475d29510055c5b10a4bdb9b8b8c8a8e0cb50a6f31fc7557c9b706569dc29bb773172971404ac252392c950b3e6cd92902f671ab76731ceb165be1360e4048a280b9853cf0688bd3a962764ca80d827d5979a12c7aa13fc38451643a3c175bcfe9a476ed90557a4398414f761a281a99852567eab7ea2f83daba8831e7ce73b4d5232a19c0eecb96b08f3b0b4ac9bcefc0270da0fc215ce76d0396824c5b7f9ff125c50080890fbc848bd95007a2270ded301ee24fea8569c9dd67da5fca4b5944976efaf067f670c8ab56b751f17edb943fee8ed800db5e58911db660576ba930d9d47d50ad0fd0340b2213ced28ec59e1a86ae0d3cbb5a32e62690c33b5595d0d51707a07b5ca4d165b0bab5ff8a8b79eb090d514b723548110469d5b227c61510780190c1ecb70658e8653b39c23b40f7049dd9a8099528c15fe969061a29944d9a1d9019c322d640c12eec0a4f9de426eca6c7b1a4a282c12428a5a86c8ad374cce4b09ae1f051215744bde9fcadb311a424b91d9dda4e6b04eccf81caf1dcc8b9a8406ddd14e8f12445e91a3538425c626bf5d031fd2ac75a7b3bb2f9fd5d269fab6087bb894148ff269653ef9c5afd09c2e147450d9c881d452399d556ad5c3e59f09b70306515679c796d16e159b52d42bee83ccbee122fc02f2e154c8ab02297f0b147406e0d8231b6b5f3bd8e4e9795ea389856b2d673a9b2bb2f4693e8802910b9c69180d04af7b3422cad824495b2ab54383f3aee9c6148b6ec0a6f10dc656037d8a44b6e67fc14101136aa988b22471308e091784cd386399ba676f632db401434218dc2b6194719ccd8c526e5bb77d701d8c37f3bfbe4e038c0c49fd2c880dc674cbb2220d4e2398e5d5a18c7563309acefdd9f4cb5e481ae1b44b34f159015d477f2183596eaa9fc2e32f344458f3c546f160aeeeba6f882a3b31d58f8e004ce3cb16078b4a4880e6961f458fe3a8c31bea0f778e3c86ad33c226ef07930d2266f8f2741fe6a45f1479cd4d58586f4cfb784f4968cc3192ce5329cc201e0545f9f8d4b0a3eb3499268c5d7f1e96117bce7301325d2da552572486d73494092008d42d6499befeb3463659a16d4670b0996922cc2bea44fbf4eb9f33398b05f15d544c29ce2a7af6400f4d6a928d0646cbd515f5787f40bbac711328cca905cbd0cbcb9955c0e831cab63c812d1bb943e38cb63ba9e147bcdf94fdcb4034039af4eb0c2649df980e496ee114a8556c42f3bc0847c5ab40cb68a1fecd1f360014eb467ae4581f69df9535878190a4e87215f511817a8c9f5aa3df07281bc0021e38fa6db15769a65d3198c4bd2ffbcf593b1073a766146e5603591b7ed7e50bc565106ad26a5b728caa2336683d326ba5086c1e51bc83c6fa11f37a66edac0f8d6d4cb279257f3c7fdbb689a1d1d8ebbb4dcc4e1000701462f8504577786e04591f99eb24e2a03035e602e297c463954907b51ec1d73df9c29e2ce4e9dbcb096b0b0b840faa6958181ddd168d87e078195c20447a417094b08f794b0999550319f3ed5dfcaaf826183f283b3c63e85126cfb2efa1601bc771649e0f7b58f10f9e63b73687fefc9aee5c09d0facf9906a7856cf5b27987e10908f4af35edf0086761b587caf8f4e88e071d704f43ca774c131bf6e194de06b3d472ccb7031e0df7234cda2efbf06603473e73d31115e96f9b405e17d76f71f5057899ca3ee208ddcd69e46e10111015bdd7ed5cc9f080c3806b44efb04fc470ec0d170a06000885a5704b7edab4146a4460830ca747528afba5e4c0faf9d4bd90d89db1aecd041b3ca97fdccb3defd5e700e1649818f6c9422e4b9ed5beee3c9cdc2ce4dcf102af35b7cba1d6e6d4f33b30bb618041f0cff3ea6ca96cd4cacd867fb48b98b30f23f59e97569329fc09b48e3111db3e97a6e04470cd306ef3f7956e81f11fab0efe01cf8bb6e79a1b7e95dd98d9a647d27c164251610c1327b0acb6ce7145d00b030ac818aa8ac55fa78307ea7ac38499c8daab06b8ad54fbe9977d12dad97e057f99dbfdd678b50322c97bfc33b1cd99398339b746dcb5be12873e24056a9709157aa18e86598dc0bdb99a50ff33d65726a28d82eda385426255e90efada4506766a5e2299346d708fed6f1bcbdf7af21b5ff5c0448ff3fd3674b4e5a674d8002af1bea83c8f9e5f7ab069a73d3d9447f12f95acb745ff708a5cb8182de49c0b41296fb7b39642d45fab88fb9c59ab551d7b64d6c533a3e7c3777228a08e0a0798b7ec0ad92d0e880c34c54116220e8c5e36ce0b8137b134bd2a350f9510840733d9da822ecb3d2184bc4c9b4f1a640a8eb4ff8e3b22638a8c1a1abaa7088d07ebe2c2b05cc79f37f4a8f714c4107d55e3d4d66ac165d6d801d80a333e7d730489e41386588dc8429808a33986583450f13e4f7a9fd4bb0d1f3e7c2bebe2950d8cb54f13dac1ae3558537ca62b90d119d062652d5ddcd679f7700aa9b18a1b033db69d27ed1c4e772891a0ee68d439537eed11f7dec43cc227d65049328e3e0cfc8bb96b40d664db2d961e94cdce93042881f1185b946244fe521ddc6e082e0dd93c1d3091c27331dd0b1a1f21b5bd85e28bcc335abdc0ecc725c8980195a50605bd2df8b2c182788969c235d95686672ebc2c6a8106946ac667d421b5804b042b006a65695c1a8c659a374602691ce1d5338bcddcef24f898a1dee90a77620560dc55cf708a21bd7f2755fad85a39c8181bd9451b8571a96efae1901e28350578980c1e91b1179b21db39cecd7e5f009e5da5720072f5938f60982a77bc5708f3b5a28a1907d0593d1e07d2d81f6a62ca7996d3a99d309acb4e2aa7be719b010a955937c1db0e1cc700428361aecf5c5058cfaa400fab9c761715516ec1ca0f2c6bdb6a7260c4bea2acab7bd4e893e2345d53955d1b3a2a4a9be9c94196ab05f8894241a130b42c0dabd6b01396014003bed48105a8247c6c682f04ec308108606db89ec6767720d33c42eefc60cb16ca943eb2240e7ceea89a8211b7a1ea0e107213d8e53929f4470e72ff74f534adb36d1c47a97b5386b1a5607dcc6ad20235c350b273805e133075a5aa5be56afcdf06f0eba11495d047dd601a1589d30ec68abb43265e0174808f682cfa48c0eb18deca57f316c204e3cc829f35345c0d98ae766ef8abbe676aa9b9a4900f5b8e0ac1428507d3d1c96863843516e2810168dca38957ccadca1889b3a80a0df9f0d0413035bbe9a9b0d98c3d0a6666c20340f7dd6670bf683cebcadc0e0e0430a01ba8589cc83b08d48b143c8df9c3620305845528af6121d587a9ba0ae90009be31cdb7600c52c686f1f8fc3d76c9520c5a0a1bb9aa6e90e076f4b742aeb4f5b45d8bbc31f45b55e93ba6aa1ed9c12a08c415f445af51c3a39c1f79b7b4cd805236b93ee1ade25e6c7e26a3ead19fe005995c4e1874d964880c97e657631983a455b26a946e711806da19a82bfe6ec703ac5e3bda47eae7fc238c8a8f3fa830588e490f573d578f0c1225e4deea251b0e387b6fdc2f73d3e9835ad508367acceb0826b4037189818864efa973cec71f0d8dd37430a2f64cb49570222a9899004f0f8e4982aa6ec1f7a3826f2d9cb9b1014d415d2eb7ef6b2532c65756dd23a9b72a99b255d45538ed9274d8c3eada6e0d7e31a4117e70a83698c001c2a371731e535caf279cab1286b916a4eedabcb9041dcc48eadb7b8b12569dcdf631e635e202b6ed3b4b9a88e605d8094ed3510a09d93a50ed358b16a42cb7a7a1438113865db26ec6b6136c7841bcb74c9cfe390f868524502501cfd06eba5df4bae62334ead7d7ddf3dc795f968f438dbf4255003676793d15c69603bc7ae94d78dd134b478909d293a10230dc1146dca5fe650b978ceabcd59ddf383421a78120498afe38c1c7478b9eaa58a9f7cb62483cee06cdf24811056f8e7381c0b4d5c60287716ab89ea3707b9ede814a57a34ef1630ca5829b859c8681e34ea8e9ba242f2838c805ae52e03cf7f3907ccf7fc56c570fd099c8382d3fc03269e9ff18a08a3bf5b17a14cd8ce26721b4e59bfb63019c07848708dd31ad4b25a69f36d8755e6622adee57e6bd793e195d07d51420550c0c21f463a3905e8a08070a21d0b5ecb7078ffec7e67746d4257a40799671d49f08664153de762a6b8cd9b2642f5f9ba99b52e0020ec46c460bf3ea51cf7c73e003a404c979319b571c00ea425755a2477b7a79cfb17de52f37019ecc16a7afd30ef89d5d75e6a536f8f4fc9b3cea872bad928ab5a3d86eefb2401cf79dbd72a6017c4771f3b7b39d3672f9c7d5dfeddec6f0253f36b74244a54f276b795418820bf8ea9d9222c9463614f6e2ff359c633d1141f70cd48eb3dec41d1b5327f0f8040c9e08981304797b0682d319948f8a8464230f5b2b5e6463cb952801c739c809469c868d6b142e9ea77f22afbffc2cf54609f6a7507bac6fc4320592b0684d0a1da4060497ce8ffeec964fb7c33ed8a70f85170e9aa32a53e6d222de5ec6c50c1498741649e9355919af33529dbccf6ae611e8890000f863dce6ce8f5f5a2000a097abb669f7746d4b3d22ad120bf4be7be07cf4ff1ee094d13bd6cc6398c203772179736ed63adb10ffe41acf5b1817856cbef577ef321bcaa8eafe4819fd0b26624aa5c4e60588fa18f51629e95b42b973129d70bd80f35f93215a71e7dd04a4e58d3ecd485ad34df9d52a0f8b0c8ecdd24f7f908feca82ae0acfdac2ebc088452d9fbb7dc1677cd8fbafe84e3ceac6daba485bed92c9f06ac8499758af20588984d374928e8a6e398da409cffdb93e456153d82e4e8b3f40bb42ecf00810d810bd39c4179359a0999faa458eab3c779defa34c301be7285acf25ce694740d4749287f7ece511a33bbd999d788b7326c0f65c2297c70f7680b2840917a89050bbb88b67c5b90496495874a552a7adb06808c3aae3ae55a0b3d0a85b87f4503b7ad4b1e8ee558dbc40d44ea1c71df9941b819edcf0fa2087a06b1b08c7de408a0d4b760e781d3e4b073b7c25bcd7f188263fd4372e09d421029dfb08114a30f43e3d1f58aacbfac1afbbf00731590f651194c329a6b3a6af040f4f5b0c75909a42309e486fbb735a70351f1ca9699abbab6d5e9217d01d8243d623a97bbf10789c158d38d02f335d336007d435f98707dd58f4ee04050662c2c3429ce467c03f1e9dbefc460e27f2be88960355674dcc421419fd35158d350652d79d8772e054b983cdc2bd991b9b8e33324f3ca4e90931813e000e8054fb8ab459b7bc83c0439158d788cedc7bfb41f2a1ff6713273229ee9aa2ceb4e6fdf8970234cc05e0b35767c1f62b16509233ed477fa8381ccdce927b13548269058588131a610790911b07c73f3406c6940ef751d29ec243e93e1d311e40411d0c8516032a735730a16d6820138aa3fda2623c5c76318471356c6cbbdc77209528b185bb5b3cae00309a27f3061098a217608dc1ec234434be1d76704f4d2784a2783886cc727210066f960ea421d2eb3d2eb6cdfe55218868257a8f34ee7abf167bf807280c16203a7dcbdc9704d9e22a45667ba10f8532f85cbff63d0715736a55392688b1c4907 +generate_ring_signature c4f2c0a39e10a7d2881c8753890aaac6ac136088a60bfdb67d9f4b17f5670464 8330fbc47f5ef2d5bcf3109e30396640363dab70a4760847e1ede29a99a660e2 112 e47318b68aa07faa35ef3ae5b8ac38acbb0fbaf3def0a4bcfff10395650c1eb3 0059e481fdff16f9b76cd2203d707be8ac31d48614585fccdc232a1e89841d2a b16f9868b930ad0f327f095f2f58eee17344ef219e5119c2a4d23078f3288af2 d375e7d98e7f286e38459c0a90a742c0e9db87f173609b3e088d6b0d1eb3a71b b8aeaad7d8293c44eba8932b8d7ebdc654d48ee3bb99a2ce9320b5356c363aca 016437d4ce1c2ec84d278ad1151e86005ba0757cdb110145110fa26b74038590 70bbd94b724d740a11d7d4a816c4c87f3eb7bcb2b17004c0ca11afd3671d6bf0 8346fdf809bce48d576e43e8005cbd6290633094eb508f7b1b9c2a8225a169b7 d66885f9ef8d956b5f7f65641651e31302075ce1b5865c5a241fe9eea9b29d22 8314224a7d53944a56d8ca1db88ce4f86a63b4663eefb779cf8153e2561fe761 bbaaa6e1e54ca7dbf72e37893f2154e027f4fa16175be97626efbbdc69586e6c 113bd03d75850ac055e90308da8b18f336ce2f7a33a88403dd26f5252506311a 652f8202dd69d0d86855a85f39f01eb961046f598588d8082ff4b4bea0501af0 24342da5fe22d17ca26d88f21357e5d375dea5e293ea81bd8ddcd5727213f196 392997ed25a6b43ff9f800a04131a81fdd28b839bbcf017337d407b145856907 abcae499ea45e168aa579ca1d7f5cde47450cf61bdb768b74f38684227be9a20 41793fa54c828bd0eb3a127ccbe27c4400055b2e7199ea5c918b88ee0d983314 c57bcceec6f61fb7de098dd8ee46f9d5cfc42cf864306601ab6dac9229efe5d4 2f9c53e941b12af7d6d1f49617aa8984be45080837d56c015ef28041d70bbb6e 16beac4e9d17d70a7eb517f110d8e7ab5cf60b4234f0064a884330e7af8f8264 fbdd6593adcbedb594273cdb4f71d628e6922f572ae7b94d560ad1ee543e17e8 3cc322f308c404283bc3a5476b262744a2d23402b4c8edd729b963a1417f08a6 1cd533cdf11e6c7078cce85de6290555fd75411a556c128a9962b7dd6f4d5c09 51ecac75cd208d0dd87edbafff96006fdcc82eaafc0a6a4084444802ad396758 1409b737766520c2d4789b6d59c26341c7aa1ed815f5674e794d9d0af5d83647 ff676950fa8d97c9c227cec21314b2970fd0e7fd688c64737a246eee1ce7167f ee4cef48d1ecb46fbceb2db3768f26d5d41424c5c7263e5df8dc206642445681 635b8c1a27a5ad357b46ed43f5911da74f20df7538ccab7afe574a4ec152b4c7 8f1ed5f84e8d913a43bf95b9f1566cfc3a067d30a28194f3fca347d2b937851e 1b97e52ae79c274e456980c2930f47174197392c8576111136cb6354d3f844a5 114069c991bde006821a4bf4d7981168046477d02fd97826d812d9f16f77907a b655863086ef74aa89ec9dbeb65bd766bc59e600f2fb91c06de972d813eb2ce0 a0f739a4e1b36c8cc807d771c84e081ea83a49ba98e194b0604d2d516665b778 58fb8b5f2a78e34edf2caec39b3f382d5c5af7e6efc6260e55d139a7371d25d3 821efd6c97ca6faa08c9b14624e4e143e52cde411d27c05cd1ad1c4b126f6e67 b20135c3919f7efc856e39bab403fb72d11970c31660a418b8aa67a427a0b303 fefdcd2c9f62d2788aed73c44a3632486974a7c146d5814229132b136e21e413 db6b3594fc8d6e4086aaac78f29e786d988d88818f175d2ffda41d5a472711c7 07b7567fb88ce0f9f467d8c42f1432224fff4629e4e46ab69026340c6b2a7e43 a1644980560aa39caf5deec4a899557be279f3d9503b973450f08c4dd6e82fae 74eb226428afdbcc7558ada5d79a5b6bfdcc9bb8338e75b750a27ccc083d919c b9239985dec6a42c08999efa4e7817fdab6b49301f04559daa1b80adf42b355e 10113e293205f5847c7c8d8f41083e82f3a525b5f56de04359706e5b473babe7 62156ff12c819c07a5b399c6a5694cf81b3cad3182d9c89fe9493399df4d7fcb 0d88e5842e2a1507642926ee6f947772799e27c4276e84a0a377f28e8787766d da17155ac68b93a53b3450cff5c3627b633b2b7464d3f0a74d9f47bc7a9b63fd 027b33143e2bc160670358bd4f206b7650ab3ca6120f163eaf7d52b1f6419ad0 38dcf4d9c7f711c8c3f333ecd93ec97e22abc07670a8c8658e6277d579923d7b e88323c9eaddcd13f3348bf85f5251f593f034ade1ac3b5309b0d542443a5e37 fa14c4f0c750ce4b52d4811caa95d3c9a7ad209966683cbf083e24d00e1765f8 838365eac90f707d698b76078f9ec1d896590f9adfeb5c0dc219d80b42929d63 e599e66bf44e7fccb2722f3a97df6fe782e80811e957a6d79108dd700d46deaf 63e1ac5f9583e1463db1c0dbea5f5780eea86c3863fb7f2f7144b094d52713c0 f30040af05b4f9d55c2cbe1de1c2be3d0a464a3c2a07590ca5248eaa76947ed8 f293f6c22c31534998d09fcc9f83c6711345ef9acb4799297af1a30ba50889e7 6adf66f4a7655d9e80dd691cbb6ba6b0c34ddf01e00bef4020f5fdd993bfa62e 7413a65c5acb2f77d01af852e1d17d05544d767f62761ec4bba98ebeab91db0a a604ccb842e25ad2739ada5513fa55c922e98a1cb47db75cd945fd1821a8a84b 760744f0d42cb0fbb23e3be8e04860eeff2c489c93e39cb7fd3e644313376de4 d3319b1bfc438b6c652aec300eaba43a8d1ecb0b10ce7b1456732042b0d6c219 f8a118056a6be318825229a5bbc9800b6002522e577ddef8382d272513672bad bc8b2c33bb713ed0d4cbd68d7c118e312fcad230965cb8086dcc60e0f725ce87 1d7bf114a3d4e60c584046097d308779be8ebfd81bc4cc2ed7434f700d0f877c ad197648d3c14b3a127c04a02b1bea5b8dc8e369096a3dd74c6eb1ffd9686449 6d70e6bd2eb0a115f51c5f4a1a5fcfb052340110b9db067916687ec8e5f581d0 5708259e096e2c0f23724fc835626eafbc11e98a8672e36360ab580e8abc23f8 64959a011b73de580cf315a0799bd7f4e24538dc149ffe9fa582fe16a1389a4b 987abdaa231434b344aaf7dbe32040701e1c7a5bd7cde69e92aa17800574d6b7 71e094387ec015e8bdd1684f778d544e0868a27a2cce16e3245863e279d36858 297bca83ea72ace5734a5b734743de740fe5d17f2d9a61afc28b5d3174a4d899 4b676cd079de1a9222bb783ea75c17ae3e16bc08b3618e4ff201a9fe849c042e e927115998105d74e0f76b3ce1c3a46b0fef5c68f6061949c3b3fe7f21a321c6 95438c8204ca32bd089293645bc0eafe8552fe14ec29a232fb1ad4fc619932af 5b8d7ffb49e11b950d8cafae7bc3319c9b399dae92de13a01ec7226a7821fa65 a1a64ad18b13235f8ac0c33eef61c152050f8ec646f4f92d7fc9848ad59ecdc0 d728a9547eb0391c9009cfc4ac05409c42fdf5609034354004f0fa4d5441878a 784d8afaad3bf0437067961f1ee47c71e609cada0b97c636aa87a4da8cd640da 9e562362de224ee6178006c3f3eaa0e211fa9c0b9e4a909659e7e0d2a28cdd48 b31b9f4a7e801c99f98d1b4523457a434d623afd8631163f7ee99e14a7b6870f 9164ca548303e3f8e0ff9614e064af82f8cedcec6fd76541210bdef127eb450c 82d00ea6aa39897b10534f681a739925d179e3c25f87d582982988ff8813d4c2 c3cc009f53709178261b9fd064f31bc3397e4652f37db77717cac41430f68b0b 3c6a52119f73f153c9b740b10e160e88a878a15a685c6e426494c1a190bf2ba8 787fd20038a29141633d628f1d9be6c78486db3256641d4c5bff7bc6ddf3787f 5f8f4faa52b8c26f56831f67bed9ceb8a3e98243b5d89944a0e21e78c523be86 ff57fef6e81f2c1d5ea0f39579e30a2330b7b30058d65cb5100f6fb91db481e4 6faad18ac496e6517c09c2ffb99ef74ee010f1a70016477aa92f04f1272cd725 8bf8561b844beb409a9603af71af4ffca292776452278995a2768f924069132f 0573f9fc57a663c0ff3b2cc35f4301465e2c5737ce086d2159adb28100a9d8b1 44273327e8d0447d0205ca23ea4991f0167f82a7dc7dc9a30040eada716d2855 223250e4ee92ab39a66d8c5d10cc1d859f8e129522763c03afd9c1ff982c8d3d efc9951e85bd27fddc0dad8179ad34a125b21a24f0f27dee656e5be965f54dad 2b31f9237409aa3ddd3789f095404bb3bf9557c7d1919227a4d812f2eb7afb9d b4d5426a38af058bed01586fd89efc34fc60cfbc95d4a3a34c722e05c5457c1b fa9cdd9ee59c34fa855609a835d3bde169d545ea653702f0a9b7645c8a8d472f 377077cbe71528c3b0bcf76ab93ba7451da7adea27d31234099289b05b22ab1f 8e5ea1ca5ff58b0d5e73e959b45a650332202e6e2c182672bdfc365b4b19f550 260285a632a4ead67966de806b34a32cbdc69352ccc25299509a3415bd6ac2f5 16c8b44afca503068a5117a0fa39b1cb5866672ced428ae720393e8140e4958d 6ec0f1ba70f1bfd60018d9780c58c09ef50ce619155a91fed21516d72fa65549 112cbf0a773da739a875b800bca212c1dfcaa8a7b006bb0b1cdd72e197dd5fb4 909c49c403a2533b78a8dc96119852c226b8a93e302d9a34ae910a8c61ecbc7a e16ca70091bf8859d39a34dc2fbec79f00888832d287e0bd0a3442a6067b7206 b41959aaaccedd4c7b4ad47f694421a9ab5f18365cf45a88d85dc4076e87c649 aa268761491f71d9cc3b911ea0db0efdc35676bcdd5194952d9d0f1dd82d18c1 cb1fd93f7c9844cfd85a4c0f89f5a41793bbc43cee813fe3d5ca10fca6538b04 9aeabddccfe892522302b7bf3e04f4b94773b0bb89b28f6f19e24220495c0caa 81cdf2134d20d8536596154521f3cc259e5b917c9cc4373c6f7adfa0b19e8009 78154a42cc5ebc11375cc35cab1a274f024301edee8fff0c08b5cdb0dae37c22 c29ad72588fc320a019c6c102e50ed32ff4123df1f8417e0e3ae315b8a6a31bb 5e053eb278d157296654a846a072b83224dfd088d8db57abdcfd8de00b2a8bee 5804ac28bb2465a4a879f07c063dfa4cfb2762fb9015da611c9b36fa62b10c5c 314e8a0ff8ce6e952150be70fa590a975e6629b6d6905e3f6233672af926dc0b 46 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 +generate_ring_signature 2f70a3f91cd8002c712cc239ee2488b0046d4b010eab9d35554f4e1bd9d61b0b ad0464c09da58d6bdb00c070a4e094c0883cfb6eec67fb6532093193b4b1f6dc 55 e19f645f9ee2bd327eb51f336a58e2c9db7b1a64a97d6803d6b56ed4fa9cd560 2c9c1ca72314e021d1cebff7509cd33dec503d78b8249bf712cdfd55895a3726 7bc59484c4005b65ef76ca020046038e3a524db3c456d48bd6e6dd45f38a252e b849fae09d21667f19fab5fd6c7d0544b59bfbed39a524a942d48828106cb12e e16fbdc60de52e405d04eeb52b3b00c0bd1fbed1d5af08f4f35be6428bf4fd8d 9ab4b2beb1c9a8ae1c4c33c53fe19581488a836bb933b45bce4884604a5ffc96 0fc8e4a7ac769f9a692ec80395494b43e581f82aa65b4247ffd7a67291fa3b58 af9c421abc18053d52ef23a6846ddefcd717a96fd90f2b04ec33eab670dbd39a fe83d20f114e98d35389b23ec392dce2f3a110c45710f0c61905bc5c77bd6389 ca5eca751a73bb5c81f1f85ee75c0b6933f364579189a9e010b470495d1d4166 678ddee968928b2be7d171f934fe13a681556c03c4471d2b3a0c106aeb16e0af 58a41d7ce0ed959b012e587542acf3031f7a878d0668573f296e95e79c0c56e3 1f98f698a97f4bf968d8c4a073d62bc50ab6768dc8f0253a6ee7d0a9b8e400e9 203f2fdce050523df6932b625fcd99c5d592853d69594c6ced0d8d1a27e2df4e e682c2bb504201724f9d6831aeda7347efc2aafc78397f237ee36a2d609adafc ded39b9bc8849e513f81e5c22bb93f4d7009522eb63f580e9e5ef369a009f63a 9b4566467f59a6f545fd438293c87f895979da6151e0f713f0535a6a78edf605 b16fd389f7553736eab1855cb33822999b4c4a28ad1aff92776724fb2935e91c 1ce0853c4f87e754e05213c1804225ee1a2120494b20fe23bcf133b33166504f 0ba8b536b491f31696ab1d4dedba8164f7a1774d648b6aaf571e7a1dc00962d5 df770c4d34b57b2cf0dfd5e59b8778e4f6821796acf3e5a8a1ef2b6c6caea12b 000cd6a7b4564634f50f4cb3bb34040bbbea725ba56a0226603e12f16c75c838 68d4b4453419af5172aa54d1ff68004e0e8bc785605c87dbff1522a69fcf5eb6 6ea42b2fdfabfdac3d4e4dd520fd923c25ce1d66c5c536f21ac14af60a3a69b0 e6c455a08d17e0f82fdb4b1d2952d1f03bb66fd20b40d80f693e6f1621261b8d aa4da257da007f817e0ef63694a46500b56c649b6430cd8ad2cd98cdc92fd5b9 ae71c3343d5a2b6124deb034ac1c381121b80e9cdd3c1a3f8ca645be245c802f 55c97d73d6cc3e432460456234d554ebc88f4153ed753ae69a42ed8827906384 7d2d00d52c811603b99a492a7a2459d1c88cb5113a22ebec3ca09ffc126c8757 b487a8889eb4a2e809205aba036adb11473ec68efe7bacb6df6fb0ab34b5f563 636fd45289cc28718d29ec8dc3a53ab20f2dbdb81aa8a7e73ab256f16b075484 d4c8554683898da5f9da8a64c30fb3e343cfb19eb88f7fbf567901a9a98d2d71 160b282251304e7cccc5682a64e5f4a4c7356e199b023ff9818c25defd1e47f6 1a5b8c9c7a12ac3f2470048f0642602e07796a4bc7bc095aa88a30976fd3b873 d39fa1a932a00e90d0c2339bf81666c08f299234846b54124942a9db33365b48 d023e5c5466fbb9f9f4210e53965f90b51efaf8181b4eb11f28081781f618fac 441afbbf59c3ce187d0ea4b7f0b8c886509b32f762f84b64d64cb1ae7e4661b4 7d9521c9c0476cb8deb152527709412eab60f79e6dcae7d6a8bc764b521552fb 7753e5dd3407847543c066c3be5b57568a00ce2156029dced77a7d7f84b51c49 643c25c296ff6b10e044502b84bbbb8066dd60c13642ed568cd3a127269cc683 af193ec7757ba760a786e1bd6dea91abf67e0d09fe1dde9636ee740cb64b3881 97c86f4eb82cf9b008f34d77be77474a9dccbc7a28f8af3135804c4be4d7f4c1 42a123aee5df04b5d770c8d135ce837ca7b61f889afbfe459affc364683bbaf4 82443654c82e18c320f5c5a91eddaf6a009a9ab264e19fd377094165553a5798 1c281ae660b2a48d4ce02e48fc43d19d9506fe50ce98be6138ce2a12f104171b e697e05d9ca04429039d3b472766d362bdd5bc09edc5749244a4e1631d24fb19 c64794f14532943a569709acc96c45ad352cdfe950a925f2d6d5d15461e24dd7 215eaa77ce36cb9da74e8b4cbe60fa4effe632bc03b8ac2972219d7197b1755d e45863fc78b8e87aa3e1527121dc382a16697e8febcebf7371975d02a8c019d6 64c05b4302440eebf39e77dfee67a5c556c28240d204684197c36c61add87089 c56a0a14c23839ebb8fdcbbd53da469670546a8a4d9b988e4283fecba308ad63 ecce137e698c68abfc86d1e30b88654aca22c4a81c5badfbe97db39fd069f4cf 0261b71c4342e73833ef38913e92cf7acd43191b63872739d4c419daaf35d193 978a3653c3a18d1f58e3a222176e34d37ffbc816b80d11625e0ea049554b1778 bd8028231d3f30ef112db35443850f73b573f8a9dc3345ca5744bb7b97ff4009 8eedeeb643d1d8dbc79f2f62d47dad575e1965b8cf1c25dede6f010cb2e50300 24 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 +generate_ring_signature 0ba30de6e6d2dbc9fd491a2874728fd0280ced45df74f8c8d32cf2e77768e7ae 0b3de9afe1359f3f83c005c7631c44a73ffba60a836ae3839d8d5927c4471ed0 152 3a358906b6ff770b1f077ae12d8f7f3cde8cc6d3c19a8c9f5bb6ee11b7388e7e 472a126f08b58e6cbcd37f5ac22cfc6c662546bac3da95da2ba09452f2437a91 fb4235440693b05fc30539541b237b7f9b5c7ad68df2955361c3de5dfad8e9b3 591196da4d50c814756f5ba064cbd38d1af3671a407d8a05cd8d0e056a4e012f ae702c49cb7fb2dc5df1a5e1c39f2b2ce402f2945ddf59241dc047b4ef81cefc a585b5a0091db1a7ab1bedf09903aab8d0b0a844d74e67de526bc99cfc23534e e092843c820545862a9e6bb15ded38458d654c953971ecb97fd1bf7603c1dc6e 322a688cc9f928b3499215ac5bcf36b55b781ea58280315c156841adff146995 ed842c7281842528fa2b17d4d910377ba970d1443a686d3742a18816b10b4ad9 daef8362af755e7e0d52afabe3a44575242405bc654d2c5c59517b98090bf334 1c3845699b373abc21d24b1107ce31e3d3eef3e7ea96c491f7c6652ce57465fb 14261e794ec119d49af09f570dabf6729560be83464419a93d02f0da7ddbbad4 33b42eae69927195bc2de2fb5206054ecf6511312a2528d4929a4a9867002813 c796fcbba62668d7a0d2348a1d9b5f06ab4fe9b157b0d846443b41edb9a1b6fa c95fc5d08879a12aa68952ae167d17993a7e2623297f75fd2272c82e32bfc37a 6cb2f098c37f9b3c863566c29d56939ebdbad47aa24cceb566cb410223a846b5 b77692430504c280106fdb7f639c495d8ef0d7d558dcbd75b23c03f51f8a3e11 4159b10f826b40b00b32991efab391e8f6c0222bcd8ebc0ca35f01c56023e0bf 3fd351cd999eea1dae072737a2352de6e0d35cc5c03b7b66784aae6b5e8a1466 9a184ac51ae37b7fd07b91e062c085b6cfbe8d9fdb539da59cae447ae7a7b78e f3542561f7f3543004b64d6f2d45dddca1fcc7ce148f8fcc240e5dd1edd2c294 f84af966409541a111985fa9c0ce4d203fb6d449f337eac3527765a7026ebe87 c85ae572e78401bbc3594bc748bca1f6996461cbaf8c28064aa3ec6814bb41c2 4aa24501b140eee2efa6fb6980eb6bb4b703eff58c9069b54f1b30dee82f46a2 c61f9c3d781903381bbc07c6ccd2631e6592130c7ef184d2936fbb156ec1560d 146811dcf8fc8172c1504d032ddec6798525e1d8a9429517ad73641cf2ee7499 556394b1a728ad1d4cd280e5e56837702e029da3d8718f50e5bbaf6f0b05ae17 0d694f1df6ef6156bc6f8c5cc2a3668801e9a9f29f8436d22d25feb331afe929 7ba9d54920fa1923eb772fc59f73ec3578fa08866b226d11e983cc8d2f8ca631 9e4f1d09796df5a2f21b9732dd9a217ff85b1acfa8ad071c0f8cacd16c875025 77c0433220a41feb333fe7a4c76ebee4dc10a08644bf530426b99b21dd0ce3c1 1a34d9fe7d8b4503fae56512bfb90821147cbd0d276ced49d456da3aa59f50a7 70f6147b9a07429cda27dbac9f7b69ff87293a49a6bb32e48e5bd7c6cece8bc2 52a798ffabffe412acd4e9afe2e21ca0f5c3b7b83481d18e98c03f916fad4f3a 6fafe4e0b6a1bc4e19439958d5b5eb6300e5685637a976595748955ac294450b c9081e39f92a9d9c0b0d120d3bd1bb757133873ee5e02dd6e428083df7c89cac dfe7f7dd98096fc79fab45669c8173226c19f953bd7d7eb2bb2739d79dfa2e23 3c3856df0f874c2d766f14ec708a366d23128ad13df93d73db9156b7d9f074e6 866dc59ada75d08e8c8ef670218581db6a3fcff78d62d8f058c4d7f767ce6e21 53ec7e68ff4f0c96dedaee098825b83a4bf56c3f6e590f787e4fb02a0491a035 66d5a0aa788d312053b71aa88fdb961ef22eb238afa1eb8a50f739d821a27e1f f5cfeeb51f1238168ad45c7daa7caf2632caeccfe64a2d97e6f93bea5fe902ea 575fcfea8d4bc586a780acaaf079f4a75d4bcaae1ff008cd5e961fe7f7a7bbfc feccc7e6f4619532c2b5cfb43a0e7240b35e7824b94086a93c2f8ff76bd01392 7fefcab77bd3284fa4867c63503d1ff728ebdac0574632be0dd8afbe601f3b81 6bc526e9c885d131970279cfc139e14d213ca40384f021541e669b8b64cf6c5c 864abdb33355465fd8d918c99bb840169d53e1532c8d82aaff27ccd1197f8ba2 2d37d9199ec4b6660639f4419cf184293ecddf90f8d40420e61bea0971ea583e 45890e5e880c0607c04b9e703270355c33cf305485b9c15b9927ff2728bfa5f3 e5778f46b5adb329727cc6f39685138b0ed0932b3542873dd4448909f7d3acdb 7fbc3ad923ce86f8ff5c34ea3b657fff3eeaafe9be2e00ad74e02ab4a579e558 a247dd3e76847f4c67f98e8c62ea0552c69410b57f59bdfcb820dec44fe377cc 31f23aeac4ecdd85e4833c8adf88b7c481a6f687b45920ae746796c878ef16df 7a812f1702f24563d4af961789b40be3d5b7836277f5c96096385d5d373c02a8 6ed55998c547fde1f832dbd3c496c4b1de1d17cb2e2cace2cf188d38ecab1df4 f24160e9814de8c26b075a6f11f085788ee84abdca189158a0420aacdd9b6eee 8255924674ecbcd958d0ecbd07c8962bef86f2d2a5aef852ec8f1fb7f9d69c35 129592cd3a9d7e1463862b37909bfe1d74927582b6c45a6afd259ab07ebccbbc 5d44bbe0a39fb5f35dab4e900a447a42ec4153eb53f69eaa47bdb9bac8137d8c 18eceddf52dd350616f472d7d1b8fed16d25297913d7f2f8ed04883b999ea48f 3af3a5785978cc66e200dba17afaa3b40ce4a5783fa9333a6424c4ba06fb7618 901492fdad5dfded52b21c9959a178334f8e7168b6609bfb077e2a7b93ede507 f7d79b9ec77df91be73f405bd30216aaacd3a055c63efc4f86f0b109798655f5 dbd4023695ec11a04d54740936f407fb2c2b6cbe979e6ef5bf0767a801d0a178 93ab27f15725d4630ba876f4a58ba78e4e560a410aad53a8a735911b7196c6b6 545578c450ac54f055d46e661d12d4d0adbe0849a61e2ea03d6e3d4638da7cd9 3391411ea286cfb663d15115d113f7b2f0826a840395939e8d5b611433f2d113 57ef1e875e3855b4ab4670fed3d630e6cda0e1b9341891e59b7e2f9914c947db 658ef5e1bcf430e63a0b9122ee3a84ecc9f47388f7b31c6fcf366eb8fa9d93bb 2658013beab0b98888d1eb2f795f64f16c8855dfc503d3a66239a0047c5593f5 69277ea51de11f6fba8a43c41fd968d901c4e31e822f4b5b3553318f847b1995 77257767504d0df2a8e5500dede46246b257f7a9f304d5e034268bb02c23e209 06dffc165810f727b325edf311d3839cda6b71ef24fefbc3f455121092d7a938 a50590f3d9193887a33303080421388a59ad10c546a1311e16c8a7313dacebe9 4a0796e932306dda67589cb37f697c2810df1c1747e2b2fcfa293b4f4c40c4b9 c5adb0180758e9a960558496d341d36e639d8355e36e076ad31859371c8b1014 9ee7528e99713c1bd54457781063dea844349199756561b4be6c384b779ed8ef ec8f58b2e690c33d2d30384142e787c7b380d422bc7845a99b9d36ea5e1a3c55 151a797a15a5814ba694cf2bb077185e5b1977d9d18eac0ad772e1282ba5ce80 c08da9572b6395a5cc018f6cbd1da4883d6a2f7d3d76502fdfd72b655e1bb5f7 30ab619fe844790c294a0434cf663d887898c694b1bd374b2558216eda20e683 196b383d573af3795f23d86ed51dd55d9c3ae875464825141be817a0be662345 153ef73d1f5b17c75c970bc76c29e4f2ff6bb212d76e0ae7ac38445c7c76ce97 4c8e7f367d39ea4210f0154dfb333766531983d43313240753483e00d1b72116 dd237005fb83081cc37a3d4a781426d7c72fbf170ef7973256d3b9cf212f2f8e 8baa3f9913024928a3c62e82d8d89ef7438fe7110b9dea1dc138c7618837403f ee427f72f1736d9a3b416b363db0e19250a04cdeab9969f6209bfa556cf79e5f c7662161c5e8c2390fb938a10669beb2713a9eb58fdf61d4476bfef7284db7c9 f9bac6ab6e3346e88b5e48eca67640c104dbf8520f08e240416c3ef27a29a332 cbc2ee1e4553e90b60ff83126c636bb047e95d7d17e941aba994bc5e122280ec 601b1aee63a11d7e9f930d9a64f672280b17787131d12e46ab0140ff01a3372e 90fa3f00483356004def6de99c8dddf30d340b96a065d0e14e7e2ab5929771a0 5f762e1c5d76870eb65f31f7751070f2664a90dfa7ae1df568f64f8478368bb4 8c03cfc38212d86cd7002a0947128016a0131983552f6826d20a84bbb052aea6 b188375c340056fb061f1ae3bb28ad17beefca3e7b5473fc9087e257cae927c5 dffe5382445976ae1ec4261b3370718468ba4ecab5cbfb50a22ab6d38285d3c1 7283670d3cb766afff7f34486489d5a1a5b0bb823fab655657166de815abec24 f7713361d1b7b267f55265c03a458233b8d077007687308da0ae02a3075c0d4f 202b3150f80754ff14b48f57a8cb648ac372fabdd91874e45fd0b6b5b26b2de8 cc9ad47925cae8fadc55c3005147ea9f93b4b8d7b1517104c24bf0b893ab46e8 be42bf5d3f94f09be5042260f359c8292dfc6f7c27ab8da88e9d4d80ee553e78 3bd3222539be23ca0edc229d3eeeedc1b41b8ce296978d73c86e762af79aa887 4080704d2b09ab7ed4eb0b8b0e439ec8a2ead3a06f817ce3f9363563950fdb0b ad35286dbd79ecb282fc7cb18c5dc7e7abd53bbcb26c824a3141fc054b8d15db 4aad9cc0beaeef5482e2950883d7253a309ef56e7fcff5df54f5f8e654868cad f1d06103cbc99b6de6494047a63fd690a1feb3082c52eed0b2ecffd5872629d9 3b55b2070aa5fbbc6f5a160de4e9f3c2f4655278f38d02bc6f5c5987f6a5d46b 8b6e16fef782152e2e03abe8a72a0c961bbcd899b27e62fc1c59a9b703aabc87 a027b3419222bce3f34445a08da62ff76712b33bbb62ff25436046e8c97ab78e 07fc0c70593b4023360ba9026368f270ee095f65cc7ea57f459b739f73328ae1 a2bcde7f605fd6d05046e0eb333081e8491057e369713b9f9adec7af1b55665d 687186ddddfd074aeffc932f3d56fa3edcf50479c2c537dc81c712c80f0d60a4 868475fcfd1604aa98ef79866cd4a7ce314850928880af9bc2e31eda14f07f79 c46158842eded9c26dedcc934ca9d51ce3eebe5a6173710225bdded6ffba7643 1ad3ae4a9d113f8991939e7396f74fb0d96280837f67caad692d18722a93a200 0ef7b4ff25837eedf897a910f445eaefe4520042bce6d666cac0b206db3dd1e5 7734da981ddc91893bc8a527007f824a22b40844d0b4537209e5d3d37bb27091 ebe6fbdbe09907e6fdf2c89841e1c57cf69c6e324f8934559cef075f7ac0e2cb a5ffed386db8174633ba84fb978f88f8217a6afda3ca2e5acf6e70249b0b4937 c130b6a8e631f76d972d0f155949fb7fa8d093e576abdafa584cfd192cabdef6 7edde741298c76767208089c421fc96b728a108eb96e60618ed458a25e62a0af 3453fa314a63d4eb7ddd4ed46dccefbc3c939afb8eb2d00a3ccb4592e5e1c39b 001057c3d37ee9247b99984c5e5270911227156b442a879a9ffa598b9c0521ee 337b79ce5ca206ad07c09efd4b90abf7d907be87cc842cf4c33a4a75f40d03b0 13f81b423b6fd6096ae3e0877ceb6fe79453a2714d72f43b8779d3f9ba7bdc56 a6f2f646deb6f9e205ddaee63ef8a76b3a5b54a928ad4f3e1dd88d16fcff3992 65cd6f6ebc27c988cf885cf88705f1868f66350f1aa9eef50e3e9d032f8f110f bfe7674163556b3b7f7d14d706cb97df910eaeac8e523d564aee31a02d63ced8 5fd0212e3214b85eea338d564a336905fa46275d7207da69f5c94cd76444b66c 0745a8db9d2d5d2cd987cf39a9719da6ccc397dc8a979bfe1b98755b83ced8c4 8d47529f198578fea2df336e62bb2509a978e570d20a03d0cc5ddee398b90489 3c7ab76d75cfe7c749c818939a4d00b22cd55d17811f1e81a2943368acbc9930 9032f04a5cfc16c2560a30ddde438fd67b34f03d067266cc1ed0d6b1f21a8da1 82a319462f7be63add5b1de1c57d4f96b7d01a37d37c1402b8ecfc7c23172e45 5fff19c41880b0ab48f57fc5453d4a14d5c22d78f10ae7bc7a5ec7c6d397be7c 7b4bf36034148946aa80874237e075fb735b3a5ba7a25a085fbf70fc19f63f16 5e367870d1be56519048148b998a8da59d93b302f8136ca1ce8265d92653398e b1ae44dcdc1345606bc107fc2ff729fab2c215540b088e6117fb82f8469bcc49 09a26ba5b7ec87989a79d47fdec7febf79647abfd0efe6ba1078a15b345116e7 a53e112ca9565d939ac0f80c9218438e05ee1cbb40e094c4c6b9778cd1ee9341 4480d3899ff9742956f8ea9686d3d52082cef3e150fd8d647768701d99805550 0cc2d147b225cdeb658984df806fb6121de31e3c43d73cbe979c8fb8251b0bfb 42ed973a0b53fd57c7676e9facffdba1fa56437683ea6839537af906ed04733a 00ff260d90022060b2c237a1a68251d150fc53b94af0b47adc9d661dea155785 8d7bd44609717a19a777658dc0aad8ff10c8fac87e643378a683f0097e916057 47f05593d2ee2b00a2ddaf85ba6a7bb9c56e09cf8ade444503dc4d426e2af9b2 caa9a7998ed8f932e5d50c969b38da96ba85fa5501bb63af160fdeb987f6bee8 8629cfd12d7e4d98962a96d5359d6df658740b02e3178842da6536006b11b20a c181bd65f77ad32482f0e347091f9e6469d6867b55ee420a6201fc7eaa5f9c4d cf322dd9ef25987283f3e35f9f457c5a8b04e8ff506851d068ae1b0ff35ad2cd 7a1257577ef572707447108a254387944435ae9e37eee8b92ac3b21164599e0f 57bb7764c06e796b8594ef58c605ea682790abf86cad7c3fbb6842f18c70cdd7 1358110fd9c8fca453bfe9f048ce071eaf67dd7f1cce4f4d52e9cad916554c03 107 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 +generate_ring_signature 70b22a0dad712049354729ee250c77812c8d958133d282a7ccb5c7ce404a7b18 fe481951dcfd22fe788830a0710c2d3aed379ba59ce250ae71ea46a62487f0cf 1 00677c75a2b2cb1c5b946207d8f6a4ad98d9adacea1e5481fb84af52da4c48e5 e6bd4c1635814c70cd87d7b1e256e002a954c151ac5e0e6cbbecb0ab7cf74801 0 bddd09f846cc0e78939e06d2613a1877d1ecff51bc60251ee462885933aa5a0f24615bcf4fcb50f652c774bcf48d1146b6ef2685c3b741aebd9c4542a5e8710e +generate_ring_signature 70c5e47ad8fea9638668fa564ba969be479001f55eadc7869b102d77b5cc5214 af2e9cbb09401113f23399722b7118d38070d67810cbae3c18e82e7b7da6f472 206 a18422fb54e5bc1a14964fcf02ea976ad907a99c9de543aaeaf998f049f92d4b b51182e7531087236c2fcd70ba1c99604a790e6543540582a638652844f962a1 6f8b2edda8e71567c9961ca07b818c8dae7288aec02c148da0bcf1fc96bdf146 7839c78aaf168c645786b1e646261a865ad44b0a83024f719271bd08e9db5cc6 664a1b716e8f6d679237984ca759520ab88db8dad87bf34d581c61137f93044e 3c3120134830ece01517323ab484002429a65eeb0bb17481bffa97774d5aee7f 933409cfefb692004ee42f1c281c0451050964c115bcd81f79dea07885f44948 ad6921f89907b538f3f08e34c1d253cb0d5b8ff668f335a9cc6e718e9964d170 1c2aa68c5a31e9fe7bbb8623570e67bab36522659cd88321c3f1f1dc468cd8a5 66078deab22c8b165e30dbcdf5b9ffd5734f7df003ca3fd515e535107e0deb0c 4330428b7fd83c847e0949054d66632dbb03bf17f9255126175d6d551b8acfae c6a01a0bf78fa2b335f0d5eba32fb0fed7a5453ecc58042f97a57abb4ab93768 36637941f031cf30f9abad0afa6ac9df869c4dc7239035f00b2536c83eb07f6e e582018b9874cb88b09f9e30ec9b471cd154ffe4b79685342f4959c653c7e30e 9d988d6cbacba45ce8492043930ada21ee880e0f9f7c2bcfe34a978787b7317b be59db2de9e9c18d852a319b8021db050c8684e9b4fd27cdcc70d7972f262235 701f1b7057adb0d1a917d09f9703ca267c6523a15a42d4b2903d1c68bc9dbdf3 ccd77941930d74002e7be55e8cf6b51b2efbb534250352f9841cab4b09d6101a 9bb62944367b74b680de5a491449c5f4c89922e21999e4749c63bddb96757b45 d4f1497d5e1602dc78b67cc2410369ca0b65ca3f43269d48a505f35794abb7a8 545c4f9c95f6387f51da3938bf05d6e1dfe24ce7f47d00673047c6d15b775b85 9e16b849e343e81d0a8e4856e5b61f24e5839b3aae6e3bed70218a831b7ae4b9 6b85c3a6f57abef1ee42b1929198b80bcfd590d2927465bf86a708a8d8935016 45702a3b1ea9f88fa318ca774673c9f5305b70f81eabb243ebc51a4d456a39ff 14e17ab717131d76747f7f89529456ed4b7e0b4bfdbefa66b479a1cdfc2cf1c8 b28bbaebe6e5a2082179a5d40f82b858120207ca642c4bd208f86d1981e968ac fde5f21d0002ee5fb68b31f336de025dca70152f8fefc8c96d9369c8657bb45f 6b6250e0a9e114274c470d03b3a09adb267eddd060fd7180a3d59f2b4c84a255 3f912637b519de978a550c9ce554c4cd8aea77b7c67bbb4b61b7d35dfcd6cfe4 2030f7603dea048af9075f8d5f94503afc5e9de977d18606915200f186c7cc91 b243f8f735967e6d2fef727ce4ddbb07260033eb06e22b2c2a6e7c573ea8b957 a4d61eeda78d420b95dff8eafe85b94c4876872f1da29b344d213ceefc4913d0 c6f13c6b465dfac7794fdc9b025461ee81a20a5e12aa1bec8169cfe89c66ef29 a4653ef4b4897b15a9842bff5c3dc1511ee1fd1a4709eb9bc11d479628b5a49b c5b6f5f523e94d64365318fca8eec9f9b69d7517b9d0516273478024c07a552e f9e16f2e35b355a188119e38acf7bc16afc4e0e239fdaa97dc487b9789ad2093 8e32ed09461857c41eee4eb6f4697107373ac5bfd404b2aac521aba53c1e4606 da10a8ca7ec34b14f75c82fda8a295339db1a95dc0ce4d51c92dade911a7118e 00ba18bc2201748eb0ac8a35142ef36a1f054f45cf328ce6d4c3a7399434b51c 77e93d9c6e4d0fa69e03244504cf715ccb6e1771a68c5a4bd01e7a7ce1e89ba3 cdfdff3ba97751f3181e617d7303bf4d8dcd5163bcc40af5390ee071a729370f 36e2b4cfaa03c516f3833c40d9d8ed3e5f123f81fa878aa7f56ee21c687a1c2d b978726e14c14fd17ed98d7124feeae05714a8109e1dbc14f503a7f04178ac0c 29dcd31fd684e980ae3fc46e5da92f7f5e78babdb806087ca36ad8703734af60 c1c96cbb9e90a08dafab66240ec2a427c9427dd6cbe2c649aadddfe2f2cac4d5 ddf16af1d9f17774b2d18a01f21633c88e676729fb92ad1ba2f5a6e4515faf3e 7f3bfe385a2aa865c30d151d1d70f7780b9404c3ce0b80cd8d76ae0bfa2d48c2 33cd6755c2a765f34711898c5cdcaa2ab13ccb4035809cc714b8ff1b49e312db 6a9c43c587cbc9040a1bbbb5ee5b31b5fb15c8e8bcad62df9ee4234c0137b330 ed1e2acb487769fcdabedc3a39a4a33f00689ba64d2853c247f1a82ab5d9c900 a7d0aed414d50b92555e68b1627c84600850b2f67023eb90124900fb54dda7e1 9c6072d044134b540033a836fd2cc23887a8a82559355d7e05934c46257ddfca ff51af4f58762907aa34f99131a60a7d303391b059d05fae1d4d4e52e9a7ee12 ef073664eff8f23d2db789333d15a35901822b75146bc40e6a9a60bc348b0f43 b20fc9ed263e55e0d3b17ee113d43547e373cdd165339861d1a5f00824954bf9 da9614943a2b671472b15a1da5689b2a22503e468857e9fcd5a80c8fa0616927 b1d8c70e8927f0a0949c7ccabe0f8420c7ed3db8d0fdef72cfae6c34ce3c236b d2229f0f33a9fa68062a177416c13ec529f36dc95429c6b3e2030e7998137076 1cd7d9d9e748868bc060399946dc24d156a1b392d6894bc1ecdc54874eb26d64 870f6592e775e7787cc3141ec39a4bf8fc40216d768b215ed2c37c020663f568 c7ccdd2c40f607a04ea79b14cc3f0e1087c1c1aec9cba9be3e9a040153878cd1 4efb40425203e4db182ce267e1ce8f9fddcc7dea9c231875dd2b477f6160f93c c77b8ff4f3990a4a716d9ce40d9dea47d675d4e2e8032eb4e158e71e22b593fa fafea62add24d9bfe2c5678c3dc32c3460686350cac842c68ee8c9dce4befd5a 0d9d2879be4d5c54549a652a0332937b19a171d08b87355a057c155a49dd3511 7d37429fbd0fe2b2188a93c537c7e55283ef4fccf2ef28dbf393039edae68d1c 9647f768f127751f8d2e8df5bdfcfe0b50ab08d002b859a36be77319d2f626b2 25a2befe5ecd5c5afcbee35e708c513e9980d217b9982a894decf8e723f4267c 49fb16a530ab7e69538cd98e63e69dc602ecf3422f854d0bd9dc0c56a6fe435e 9a4cc03169cccbe20d82c8d1c88cdad2c0e16bb32c22fed4a5325ba24c5da531 92ad7fd060ff5e009df4146670aa6f3c48add5eb9201ae12c3545334efc68d8c 5508d45bb35097749c0bddd3041a15f3f30a73f8d8e6bc26edca97d2b3ed8eb3 085d6e6167b1711a5f0246198a0ce033445c56c308caf2ffb67ed4bf492a760e 814453420ac7935b45302b60a76d60ceb3d875e27d84181cd995ab0cf7c194a4 66a3b5485bdc1fe37020e728315e4952d501260adcfa287640a15e4ff29934bc 7d3202c71e8352547fef9f2effa942969472ba6b2b711685f1e7ddf767bde373 c603687740f6353258d1563ed82e5e72b7ef7738425b829089e044312668092f 78a2b79ae83a3be22e894c61f9dd9944816749201ebede34760f0d97bea2d29d 77915a974635dc324949da90d5a6414a9abfff9c6a1fd2de2397ad515ed1ec4d 394e0b6cb9bca29f0889e679730af807cc382f846291fecc23ef891bf4303352 03bf7c7d9e5f15da8d8f4d8c8242eb7d0f8173f66c9a709273e1803a073e7c0f 885a745d8efe981be6a9aa5eba6b24b23032229968d62ba2f680a437051957e4 bbbbcf28ff988f39a47cb062cebac6a1ca52cca0b7553f1e64503c9508ee27e6 e4253508f5c9313bb1519bae17f58c685d49e4194ea7b369ad0e079878d253be 33e5fd5640355e45d35e4dd7f1e8e7cfa2998a9ef48c9c887fc31046881663f7 8aab3224dd2af87ddcb5831c1282df4fd90b353f4269d4da50252aba203d19d4 be6533d22fa31ffe42c80e1a1eb71d65bb27a8e63c7f382d1a00c254dcd986f8 9c0652aa08322b9db87e6b8bea6868994d9ac10fb89a5c1fd79e6cf05e4f451d 99c615eab0941b915fcdd01beba0f79d841455986f64b211a74631c04adc45f0 eb7436280e32dd1c1fd11ec57d44e4b960630debe8fd3fe9b16f7e25455153b3 dab838aa3a6646ae8523bc8e612c5f76bb5cd21bae09af8ae035434a9545e1bc 6b0f31df949cbd288c5d24063851ff1c107938cba425be209728e09dbaad55bf 83eb14b50510e48cb3f336fc4aa0003c1fd2dff27e26484c9e3cdaae21e0f73a 37be5905a9f43cd4e56d974dcfd016461c3d066d3fb227d6411e942705892208 53963e49426946c393d7051247a746783821d70b04889a094a5c99f0107a48fa 3797c08b0780ab73b9f4897a12174a42871968f024f767ad713f8a7c35995b5e 35f08b38741b662a557627dbb793e4ddab03a144afe29f15d2582f528e3f54a9 34087c19447afa9ebfba8b6312969741fa38dce9a3c52294c08d949180cc79e4 7352d684d1137c23c8d55ff9c01d6dac19ab3d6b8f8a30ebf5f9789920e5c3b1 d20ac3c612b2b275c0c708040418562f80ec07fa66d5b8bb166d115e059421d1 b34a94287b0b92f980fdca1985f12feffbc33e22194cf83f7c64f9db3959d810 b00a64ca8cd8d6dd32d2e23e22fcbbda2c979e3a25e095d9bc984b75e29263ff 88905bf24369828cb2d7789ede9efa19100e1de11fb23fff84c5f919caf1b200 f550c0946b5bd38adf6cb83ee5f66a33f6df9a352920a0608cd6973294b88591 b84f4771e6e6bbfde0ba6380d7b0adfd745782a79c665ef158b35f30c3f2aeb1 6125547278feb8959d7b44022834dcefacaee1821a2b9ad98072409fdd1fc5a4 2bca5c5a2f52ddf22fb94c1ed7f094beedec8423c2d908530d56bdc6dd8b33f7 d122a98f60cbfc9afb08c4a3665a4297bea2e28e1aa14248e534792ac9be9754 0cda988e49b35ca39b860348c499ace34a1cedef1fe980bd791e85cc9a3eeaae 50405db106877d4f79bba49df0d00186a34ba02918f38d10a6772a08516f358c db86f45ea5f440499c1fcbddb9e094ec839219d90ff65ec5db7f00e401f294aa f2b186741767357374da23c9c787b00f7715f6ddd2bc13f4ce0c7fd8af871af9 45dcbdacb01ebee6cdb99b6bf299a327d7600f911eb178b6b040e427045893a5 7c665eb4e236b8fc0df26b4e7006ea202158ffcde5bcb01bdc76955332dc4612 e5c13f2bf51221881634a0b3be87f9bd3b77ca6fc5190ba73496de2025d9e9d3 0f5d6fed8deb031948aa27118f24575d129130cf4d54e8c03bdd5b403077b9bc f5f83a10c8257b8571056cf96b205d6e29ae49a045165f9e81661ea60d210b46 04f5cb095be125daa3ad6f020c25bc4eb60fc210c3c55ea6975579c57704e006 310a935599ac84e860c339e951c795d560a8ec6d0a9915e36f54bf7476bcf7a5 02e7263c5f19528ab4807e5cb0de10f754189d00768dfbd2ef200aa1ae8bb2f3 9e7512f100cd122c07927b9797b694e4829ecea344c5aab64c31e2dd4fcd1f4c d5882dbd1118a46af3c624b569edb0f66d6c7eebbbc822a09e74210605d05858 02fa26513c2e35299ec5634188849a3c7876f283d8e6d95875184dcfe90f928c 7c1af6f4bfe0fd44c10c6e17382585eb1f6f6e1c0c0774fe66517839b4e74a69 ee9ccd0b683adee6b6c99eb80bfc58d50ee650f2089b23aad6a53d1514204d3c 7a61e0013420f41c550184125d3810897caee0c1cdb035921461d30c070f5c44 5a3b4acb99a292959c09c3bc164aa35b8cfcd80e8dd1e5a0ac18b4b20c1f7beb bfccdcc76e71a16d7cb5cd68daf3c83ea71ff3ded30cefc9a574d75cd7ed3cd4 0d37450354f70f3421920262eedbb2388b4b3025fa7b7872045e108cfe506a69 7769a6ff5204841123e2f786b9c438157a68763baa0ef3b911b1918dfc908fdb 0281057269fd5c1792dafeb5dc50f5fffc205ef14b1a1b495335d41fe9833641 eb74bddbde03604204f8d59400fe0977d2fadbc4591d25092dd8507ff1ca0441 4984c0958c38d0bf7db3e714963b7ae2be3f14e4247aaf8625a1206bfcff624e 416cc5e0618e97a86a868b745b730cf5082736b28f158a15fe97d46dd18943d7 c0334b9b1bf615d4e50d93c5cd68c004f616c96448640f96abf15a05f259b6f0 72228197fbf42e0bc7fb85daef82dbe1f5e2dd7b173e80b590bc6cf985d5a065 74d54c40ba88a6e7e407696c81045f77b7ca443b5f676f9e7ed2133004c220d1 da36cc9ea4368c90ccbb962bb33c447d7f1c57c6b5f0073f1bc1f453a58a51a3 29346ae924c2c641fddc37b5db1a1cd7d8e8dc6c10f397ac1e4296fc50f957e4 8ad915dcc38e22bbe3808ddd979703b55641e5e082d922ddf95eb55bc1dd1c99 f9602f4dc07dbcae954cb895a266f64f0ae8067aa0de93c828b0b63ef77b1286 127806dd2c84355c8f15d5542dbca5d2f545bf7aeb97da34d09ee353c18df7b4 4808e46928e4e630867cb664a2a594e847858220ca93bfb33e06ebb991816f60 f45ea82edbdbb2b01bf809edd7ed8c7b5d5bcd610eea3e3e65fd3d2d0813e738 b9cfcc23cc02517f75dd3ba4f05fc727681786f67e6cf81edb3bd39e945bce60 e1f5bdd3eb6c2b9315ebc2fc8a2265b6103a68a966992ffc100e00a6bfff91a9 b0fe946f3fd0a6f8005f857f84d96a929971c37caa1b7ec7f8f76781c10f7659 a0f943eaa5354a75121d68f221d7f4fd05820d142c52ba0e613ce40a94ad410a fd4885348d62e21aa70db54056909d38d6a0434958a88bba1b00bde9b5d9a68a 81f0f73e215de76d5d9395ece7e348290fc38c254660d07e5bc1ee3af399c349 6299a39b5110643b1ca175cb95efa2384e6ef5b097e104d538f791b61c934039 7107d2209213b68af9ddf368bc4cb14a7eb4a97c2d12cb016fc4829df353b976 26e8f097cb2958051fab454439aa1dedb6929a218d6ebc0ad71ed240288d5848 03c22c8c6e0d2b2566d02486f8d281d47757cfb55aaddf6e9ce709d0b434bdd3 8f0851c2b5c3ca4878ad6c9b7bc5d0961d2c10181b346bd04024a1c3c01ca783 49ea1b8ca3b5ff382ae05817952efe5b1e492dfad8864520909211db36d9a3a7 4b4077f01a37c8c41d0a841b197f90bd81b0f60e8e85ca241ebcdc75ae7ca7b0 c5094f0a05bfe6bf19b8aa4294ad8ad350c9da12fb2349e19f20fa468a8d767f 28620428aa5d407387a24846a62cfe882bc32222b1e0a11e0878e69142f927c1 469a5d58cda2b621561089a5a84923527f3a7c34d73429b32f12165453fe919c deb95037d7f978e00a400165cdcd21698a9abc5543a86a39c2a3a2a38df0147a ac3a1f62cb0e149eab665764aaed0d534c57bdcdd61badfef5e8fbbff284da4f bb95b6728b9d49af7954d46440c0a38d95f97dc319a6bc801fbbab115a9d227d 51e67336b6a0277b50c6b8c9461b570341de5c545d6ec069133fa52fe0fbe96b bf9ecee1e808820f1733fef3d8b26831fadce90ef25c2c9e69f4ae1583c2ff8d c2ccafa1afd4a0fca65c04cf04372a9949fc82e1cd44d3fb62372c4eef025d49 e6df379d0ae015a6e363eaddabc993ac719fbcbf0c426923cef3ce181bdf91b5 715a8e056a708fcc73e370b8c8189b95be07c48f029aad9d78318bb4211fafc9 33086563a891bd5405a0c4e6c823aa6caa40baae56af2987d0fd5926b7bcf92d f135dfaf3da2b5b44d02fa04f5808eb9d2f98908d5be6084694a0d0f0bef6b6e 86646a742b57067e655ae93ebb181f34b2bf68226725b7fd49b7891c5e8d3c0e 76f0c9c066cdaea4caad46ca803c9aefc3a11dc75aed472479652f6d75f9f593 4d1772db532f9da6aa39d0644867e5ef9c429cd7986f97eea7c253a0e43e8698 57bba026eab4e72dc1a9636f0c63988275e9eb38f66c56b0f6d998fc281f2f0c 628eb7273a6845f9636813f810760b69248603686f21ab695f41304a5259d7ca a83d219f94eaddaf2bbc68d387db7d477f41a6fffd90b307c45342703c987a8e 149807be6e62c586c635336a9cc8e1e12491ff04528da3ccbf4c62dd49014d72 5fced27002f066f6e03292c55c36bc9f4e5be911738f25f889f12d0ab576d690 619142a6d9c825b6b874b1619f723382fb91d1cd94d59814adb195b2df8e2afc 46a9f5f54f2c432884e00bdcf31a1f2832aa3fc08ec5d613e39be20a8e82ace7 1da5ab4a03bb087697f2149715033ecc9fa93f3503c0323f2a4763ee8c8bd51f 481a87a30c3af37b339dc69250c71ca8a922e816667443710671a80dbe52ce92 6f72c0e69adfdaf0dec11ab94da9e9607fe1af9b19d2942499f2f3b06c70ec10 3f27220ae74e591ed12f7a5e53d9899dc3016346747d8ec9fb0d8c6bbb7c2a62 7be4d47e1841078f34a8bceb4a63e3dd7d84a7a15d2180fac6c8cf9409ce02d9 4d781a55176f8de667ae70e9c1bc7cd4fd263930b82f4a4f32ee12957d19b4e1 b5df86e2b91c3dc2f216c0c9ab065ffa1ede0d6ba02fc98df834c77d65b2ee60 448250ef38aa56bbd00f29317b2a48212acd247ea64550dc411ad9b176f129de 90899eabd9f089088d271399c46d2550c63e6b3eee2ca47eb1a1b01220abdbba c3e9bce3229262c0e60a477d16d898464d78d94b5ca4ecb64f769ddf20c5c440 67ca124eedbfd419a80a46588fcda09e2f5fe336b8e69d989c210e613a82e724 f36f0c8aa0d5711221f96dc637e34e8d4cb79166136b77637401449596507b8e 5a7b4baba7c4e9e7b0bf849d2f3734a5b822f30f132d3dd1f262ed9551a2bc58 a528422be9a71e011bb84759bae4421c53e306cd112a78ea9f79f1a2b19b6c17 8a80facacc40636b9445e719bef3a4f732e26fecf9fe9754919ac27b9c53fdee f9cd67c569544c62a0c73392289fb7682d727ffd10e7a79697a4433e06470f8c de9b69ec46282341a42fbbf8de6b54a232ef50cae2ad1d774f3630e60c8eea92 929033db79ef727eb67d6dc4aeea650c01271b3d2a6873afe6e6b0bce5650cba 301ce60b3754afae20c3deb7ca76dc542dcf5e3c37650258e11f666bd9b978e1 b07597015e477302bd1f044c547f7246b74de2e4b069de91314e7023383e891c f6be00b7a0bff65e3d29bee8a690717c412bedad30eeb1b9623dbb7744fb72f6 afefd6e6e0544512a57fd39de6adedbf6d980abc65de3ec99f89ed06315ee378 43dd0a609beb44b6df8459e8dcd769d48e892897872efcdf1783a5a913f5dadb f765aea469de90af8389652bc1cd0aa52fc42e57bb8e546e1618d818128264cb 51e47a387db4adeab17ef6abacc440cea6fc47e00dd448619843ee6aca670536 b2027fd7a8e36de5a752b54332d2449ead5213aebf6c678c54c91e35e6d87fd9 fbc0102c91c3c12182445681f5f123ceebc65bed2d9932afc8a2f6fa78a04b0f 48 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 +generate_ring_signature c9ab4560e364fa2cbf7ec6e3aa25251bcaf2beb043ccacb0a4624058fd88d86a 5d6b8e078641aea54474ec65784fccb1e95d3a0f6c1b97005d6fb65077c145ac 3 56d63e1b1a487fd4d7975e66dc212e3ba4180fcbc6ba777bda12c4a957f359d1 0ba8218820fc5a47b7449974d27f4cf1fd7ba6698f087a6b007a15637c8c56ca eec4a9fdb41c38be9bbb62e86f0d497b8adef1c297306cc3a209a700f1c76981 461bd2cc07b9c8310b74820b6b7fafb962605dc168cdb11be6995b344bf95305 1 8c6aae78c6129cbd10888d137cd1230ec3b31c483b9809621dc3fb9b0a523a0ee37e047bc98d06c1e75f5cc7e7226fd16fbd55e1b76e956874f6720dddfce908c0b34d3c68ab03f3366755544da56df78d68228b07d77a5cc90b165544f7f506f31d32d1271ac18d85ebbb38cdbf09957b461ba326df9aa8d2f1cb38eccb75016e1a7fe7c7dfc3bb74170d816379bf0deb539bc21e418b0ba1904a0316ec3906439c2169107ac6d1c94d60c43186ec30b1f2de72c2ba7148c94525d13be75606 +generate_ring_signature f075672344407c2c73e656aab50a5308cde472718afb873c3813cd31eb083a22 725e94903757033d3ebc8b23440f0c208e60f8932872536ed80050f0ce714156 1 ac769e6e63bf28b0e214931c70c958bdfcb8b7e662f280fe1699e9570b3e4df9 34a4a033910e6aee4adaf7aa902b9bffaf1ec93c9949bd358485f59c45538306 0 1a42801634ba07a45f8c7f4fd070213d36128e7837c214250ebc50d6c766c0037093c580a3536b954637982b16129b68666c3d45ae943d9318da20fe15de6805 +generate_ring_signature b5c9ef14b9a08e78925da00b25dbfc501c26ecafbfd1710539c0ebf3f0c4fbd6 bfc8153ee1fa82bc2a51d1e74adb672f8354f3e11591ffa0253c4a3a7843d759 42 3cd53e438e8c719ef4087516c7124def7dd74122134893d56fc52917f9ee9b38 f2e4139786fbd913a4f13e19d484bf62929447b8afc84612094b0f5bd043df10 5fdc376b219fe822837a4ad8c483f1f392a1cd70141368a20b0d47ad9fe1e009 727d639f4fd6588673837ba332ad5c0ccfd832155dc7e194dfa9a8aac128869d c98ec078ac512c8be32d11374bed3fd019d46dbfab909f65b47052a0b36a20db 272da4cf42e06b9645cba73ecbef4c57b64b99e481cf3a1867ee7c971364904f dfe696e5068344bf3f7994528217694b8b3d359eb52a362423ab2dd23aa0ca5b a2b507f5f68b776722b35012a49fa542f58eb1f6f5a4f2b03ea507e306dcda46 4235b88c24272d62ebfb9b75e6af06479fdac9f26ee03560b53e33d48a820c78 74f869ecf9de6d2b0835ed98600e6c24794e549725eb338f0243025d9945c008 daac00d7a944c053a2e423047c1ae410cf73d0b3e3a0c57072016552cf940313 a6fdb201cf3f7b8aaee0409bc5098d0fbb791e4da2e87846e69c0387ee917048 c556403a2899b4a1288c81e6f4e7f1d2b8adc7e1baacb2272f87407a5987ce4c f9f08e37a0c25ecf700e25fc7107c9bd008931cf9fdc39c454bdc4a8f66b716e f2c59ddd77f72881f42cea3a1a1053f9b4e4723e20e65a1874fbaceb9fced0be e7ea591828e31b78bc7634275bc73436b23dc1eaeafb86775428e5c0a10cfd39 7c15e3d04367d0638758a8c9ab73eabbcd356909c04377d9c3008e70e1ed0eee 3bde3e1aeb47353edb3a007ac3fb658471f6b3c33a67b8224534301d41d55769 8b778667d673944e41147d049effd5e9197f6943b65d8bc47e251c7d66e614a2 a566e5cb64d80f5eb09d5d8fb0c7bd67fa50b2847b7594a6817c94a2d2cfac40 44d95857ad4b5254b378db5d6f5de3aa0c866e0eba2757695e5b955a71ad425b f95a8c8f71f794894ead92d7a8343b7f92c2902376c1ae65891b425d7beda62a 29ec148b76bad44d003a3e53c1cde766fa9918b011696402b0b5546f6cc98c82 2321dee77fd3f088ff04ef45e65fe6baf7cc57a2e8d5887efde37d4e5dd5940d b094fa11e71f396fd2c5efa723ae3b86784d3b4a3ca28c454807c379fd36d8e2 62b4e2eb263e0af951102eb0db0ac934087876431fb5169f04e3033ed66473c2 3043bd14d14c669e87fa0c47de6b5253e1c9b660a200b528d5d008dc6372ec28 81837f200ac02a8ff2949baf7e2046dd41475237d01dbf8a7ba05435d4f56542 b374ce8d68abd8d30d806eeb3133692abff1cc03ce765f4d2189f420792d0fa2 8aa45f186737fc070eae52127397db1c1d921b3716233a76538ef4cf8d98b006 094a03faca408ec2ef2422d1e8e93ea9ebd15ed6793f909327515725fd245d8b ddb31f1ca2d6a32e1d6ce1e3c7935d2afdf32bc00b185ed92832441705af8ca5 cf9923a125eb3d3c6a27bc8abb15c9a1f5ecd97d6bfd4101395c547c92f53b62 70b0954b770448de581288b0c28ef89c95ba5bc78d70302f1b3f8befda378e63 f32f02453664f8af919094f4d8ddfa34781c83f4e8b8e76bbbdda82120444532 a1c063c2be3b23be7ce11920ad588cff49f0be61f4cf1d86961ad990e0d74af4 c9ccbb04e610a9d99373863ff6334908a4218f3a27fbd9e97b76d5a1db666609 7352167d50a292ad64b7c1911ff0d3245ea58be061baae00519af17ec81f1cea 7340ce3795cbaeeef9586e1be8bb45d0e11835db89cb991b1b9042dccca58de0 8486d053b5274d48b7174efe4246d6e0ce405a90d0101558f9ff98fb0f1f684c bdbba1f4e3c95f849d2cada4a88daba5965c9b1707e3b963cb130bf9ecbad8bc d077d77756520959c488b842f761257f35fcd5190e86c4676a4a44d6ce2c6bec 553cc6b8ef0b6b67e23e2a5474a2c74b954bbea6e8e8e8c6e1fabbf5ae4e3e0f 10 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 +generate_ring_signature 9b329f5487db8fa896767fe45c6f92096dfe0be8251e4cd36d07c0919a9c7dfd cc275cc9d60c681f4d00425e16466fa9f2c36f5bb333ec2c95aec837a40d0fd9 4 67e340c96d30549d1dcea389f686423bf0eadc42fda684a21ffde3fe2a0a1d3d 118888e22f09ffecb3a079f729e993bbe3a2f8ad9b3ab98943d7b6d039c93e3d 1c03bb98ac40e56b9101b0a628aff1f3ae682a026cba93ede7304f942261f04b 9f8aab00b42766e651e5d5c5a71ea8399f52bab563afa059823ec0ebef99ae32 52b84d2cd9edce72b79d4fe908f59290c7231b8fd6479b11b81e990097c65707 2 703a05af7801090fce02b21653a6ab04ab2a8b215b053389ac3922b282b2290fc03fbdb7240feacfa1b9db9cbab9c023cbbec3b571c758dc3aaeb79220b559082d37cce0cedfca3493347d691395ba1c0efef5740cfa01b3f175ab64cbb7ed0e87188f24ae7617b3de43af067d49b0e61447c5c076b0e9e5933635f8769ed5037ce00c41bc48d24dd61c32af950f6c5bfbdc4910951f828fce7f73052fd96801cf45bceb64f6c0747c861e1f4c94d8dd7ec86cd909607a7357d0fe4af9913e05d148156d0b6f063f5f6cc7c8790a76e8188d5e059224b877dbb01b987aa2a00d9cc6c74bb058ffc748be0835ef6359e37a671acaa309d0ee880d27e1bdc4bd09 +generate_ring_signature 3e8b6dc355913127e29a053eeaa791f7b9b25c96292970b20617a77f2941ce66 864ec9b981e85f596e34ef440cdab5ac85878584c8bf0990753d53c281430f5b 4 f04f4e042649c5340e6decd37d44afc47a81e00907733866c866d853e10616d4 d7ac266b6fd14bb55b3a4c3fff28017b1f2d51591a8a9a38a921b55e0ecb2b36 c579e81fea2b7202b881513f371e0b5cc4ba5e941e7378cedbf2355e5df74ec2 16cd14d1087769260824246f32fbe6c6e8068e7efed639574c837904fa186e57 1d46be9f88c8a3546d8107e6460b04cde2821f0c815fdeea2a5ee8556b36f006 2 031bbdc49e2257857cb8902e5d3c3c4723d8121c40d1f606357a2a2b50ce0708fbda50324182da7988891ab0094d331eaaf1dac9ad77692c21edab579a0e980cac88a7c3cb40654b0449747ed90f330391802fa4d535605c3efdaeb609eafa0b8ce1065b8d69280a5c2cd47ac139802109dd07a9496cd3e358b43618cebea70682a35d3f334433f1c6af4b06da3508dc65c241cf043625c957ddba9c0f110804805668bd680f215b3ab4588dcd050e6ba1b41f429547791120c454b9a8a43d0e4028e102d337102d210a0332edb18eae1b6800907f7abe70a812cf574135f405401829684920f1d116d53807202f8b3ee4ce34b92150ce9edfe2be977d02910c +generate_ring_signature 4eea1e52284c31388c572c77b4dd6bc18080d356f22b220fb2cf4a1706bc0f86 0317dcfb34494772c5bdabcc64b2661b8f061614472914a82ed7860376853ec3 4 35ac95d061c9f478a387f5b33ee56b5c962c622cb8335e3f5b05a50dcccb9567 eff1403b48ec6986a6f3a436fa75390d47df6b75578cf7c00c9545fadbf9f9f8 bafee79e294e0d60c0cc2c4ce4fae48df86d0ba91e46e4a2e6cd033b34c74414 1161986f00835114de03ed5ac2f9b94de944c1a2b9f3a237c8e3bf9f0b048349 324b8b23740f0a95fb37e26b28ade940114335d0c395200e3df2dbccf3fe0b02 3 fdc16f1bfea3828cf5c3aa483c691fab1b8eebe7aec1919017384fc2bec4c50182b4fcafd2c3101d125165244a3ba5b1e1ab56d99df9db66ac4a1cc93b39750d338d88ab3b7f9df6410ff6a1d15ca8c0592c4417401af9106658d2b074fdc906267b6cf6e361ba17669c4214be8f67d9e0130eef08a0fada6e32a9004fdb5c012d666e4d0768fb6058cc68d8b21555bfb6ab9a3fb25db3915706949508fe5e0db36ce4b75fa97bdc10df5e534dc84f6270fc7ee8eb5c887a4f1c77c984f3850d82ef38d71539d1ee9664b89294f1a28f56f9cfc1c0b1a76bc19bcf2307affb00923a56c5f998ec88f6d24148c1d64815d01171b9d02941428c43a646663a2f0c +generate_ring_signature 3897f3826263809665c0f79b257b70f91ae560f59533df45c79aa481f14ba6aa ed20816021e0870adcae45b087cb64978c27a36fb94967dcddeba7878c43065a 6 1f644846ce53a77e39b3e5ccc0c578bba7b854b801815d27e4a279b929752d66 9370f055164552e621e0ea348794778e844013451447dac7420ba92789bf23a1 58d1f500efc8f928bae7a56d15ffc8b07b65139f4578ec2ee706ccc992d46cf7 07c2dfc3e82dd1625eaf9edff3a2fbc75e6e641a41a2ba56ed0c939d2b81768e c2156a0f6cb0f9d9c49abab8124b36784d2f0c676c9af313d1215357e5203e4d 016c41e09ae240dccf9ec65d33ee94ccc74845a9c8c233c2a2bfa220be6dd093 2753960b51aa5cef3e1fe2f7766429bf0bf3cd91268e609c44e5e1779005d20c 2 6306223916f582ab76de2c92fe78bacd5c14b30236357da5a6bb84625f54bd045105ecc02f042cab9e6cb046b53d112a14f30124d5ed52fa01c0cee9ed631c0c7995eda8197d0d455426a53a8ed3306639d65de72d66987a3a4452765c47180c98c42d7515795c2ffad166d926e6701ee8b57c4be90485e0d6fe0a59ed2666079a7fda1e6c4699320c3779013b931b4f2291bab0a30f753c2122df43d101420580dec454456e88465721a55682ff06fd31f14d41287046c42e07175d31b0b30a74ae2bba1aa26ec6cb3bdead6909dcda77685e0a3f8f63e551a2957b526452037153125a0280346e47a006b5ed111400250487eb0af477ec12a23e6385d61e052a13f6f0433ec4bfce14d3dfae30f40296b303c65ffbd3e5fdbefb2d54b58902298fa13bc4f971f513c9b47377e90fc4b7ba6e8df49be1a0d219f59c6de2f80f53dc3408a1ccc0711bbf72fcea1f8c7e90201a5278202419e3b67e144c2abf049c072625736a93ed4a6d4c6e6893dcfccad7bee84f5975044311d62741825407 +generate_ring_signature deecd93de3b6635a3900d9205d9a0445035451960faea63acfb11ab858265584 1157cad423a531df089ff8735908f4cd8d8804ca6f796839239c18df3adb224d 1 888be7fe0293f3f66e8d0bf3606153505f274fb692431e258bea9ca2d140d85b f8dcafb41c048b60f3119e9537c0e2d44cb10b1e6734aae324e473769a63870a 0 1f1b297781faccda63ba80636cf5ed88bc034e7fffd6499d03ca466a57df790a01beb9ed1f28d112c8c96d7e5b2302e919229b73432fc95e9fc702c51648ab0f +generate_ring_signature 81b47dad14107e991eabca238e4b65e7367928f92b795b2f3a2508c79608dc19 c05b11bf0e1c3e0f47038d6aa49ab4daddab874de20e0886bd6f6c578ff6db01 2 b7f3a03806831c048c28fa2ae2f5fcac0e6d4a76cf9fbccdf2ba1d0e3229b35e 6638087a63c6d537b87a22004cf2364162a52246a68162872931a6c0c35aa5ba 75c26eb3a2b4a277a7cd508b08879524621a628ed9ba713b276161ceccd2ba07 1 35838fcb286004c6277ab807af82dfe30a8e3fe7cd38fa9f1bd2925c01d3e7008be43a7a3a0c944bfc0a08a42f359692d4b4f8ba67b66c95cedc96ca4c10220a07c86684d888ea87a5cd5f6e45452c849cb9f5e1f09458b5d4366222df101c059cf27928d763ef237d16b9fe68a66dac15c5361f2acb393c851ccd70ab2fe101 +generate_ring_signature 27f39c66f6a61282ebe04d3c6116a57e4133798f01a738294eb6a52c813585a6 a9750add17565f877b2b22823ddcc5ee4b89f41c728972523d61a69b78e9088d 1 b02c8a057b5cea1652d1a4db956781e6ce07e6f86e747ce176a7eefa3d4d652f 8ea9d363e3c1ed113f8b6ae7672511441cad4877336596e940db05efd1e9ec0a 0 4dfab61c6d1dc5e889daeae42edbae805d0c88a4d3bea4b2d76808fa19a6a207c87636c6757b49d1808696f59db75893ad56b72f6580a348dde280151631c403 +generate_ring_signature 5c37b80efb792c48e4c99395fb19626df810aae0e617e587415938611e35b37f 952470262e4fc8ea399640c866cef6d408edeb219511cd4eca7006622386f661 14 84cbe808524c622505b5e67783989b593fee2b939b5932b8c3fd77bad3b4647d 60f3e7f2287a85996d5aac23f440ea64c6354fcb1f7013a5b25b081f2dbd991b 3f4a81047e7b9b1b8d642f8586c6f98bc20baad33f75a7504afa7c109b0fe612 40d1ab12988d9c1766f01559399c0e0c3451da872781825364a1c42b46760ff6 549564baaec6c44ad533e9f01a4a133f2ba260da2127a78ce876c30e97c6cd58 82961348f57fc20143b0d6b30e6bafc63b8575bd0a55a28df76af8629cdccd00 119798a0eb51777954ca108539337f40554d4b2df47a4d21de97e135b66b9dd7 ed90cf28e5407fab6b8d8fb70a98d9fd064cc0beb47c61ac94845dcdeca4eceb d4b35cec0f367a4e133cb2c6d4e63c07ee92247ea1033cce6bfdc7a67474e224 d37a52f026a589b51064eeeb64a14aea05420c2bc70d5a04ab1d5128819ad3b0 968604beed7f12f1058ac5312bca68c811064117b189e0e4333db93e603c8be6 b3793cc7a8a5daa5f02ca4496390157df25213562e7d4fcecca72e9a23119e71 9ecb2e012c207c1d09124479bdc8ba9fc10cba28ee51301b5c7eaf9ef68fa355 011a63f6c9050800a210f1015674fa555ae80133dbea7e709dffcefce488f691 ee5d09e9d9167824d3ae704ba8c5b4d2236f69da9002c28cc0faa08954caf708 8 7552e76d6acb53106546b0c0f5b16b8604711f2f94c850ef43d87a91d221d40002baee91bebc7142bb44d6eff871b685720da92e504fa7cfdff2b688e026a00cf3092cdfbd22aa77f442601939c822b5a211b80d9bec600b03627458f69dc80b5c932425d1ab76be1d60e2235876b211ed6a1bd19c84fd543f2887b3f31d3d09096377564ba17be5d7a1ff315528bc4a310ba5b790d61d70372f4b8ddd2d3208dd1228c63c1f9d4c217be9cb50147e507c15ad3ee29eee89bfab26fcd61ee106dba860a678f5352ebf1d9da6113766eb2432b2fbfb26022b659046c08dc1f3087b265d7f3566f0e2067f207522069c83ce7e16a3b746ed8f789ad9030a714701c5b0ea2575b6708a67351da7ba690dbf86c19a4194c025dc7cdf0164de1d430db29dd64913e13c0cdded960ab5e31d2255a83c6895682f0eb809a519484136080dc86e26d9c63d9ffe3a3bbf1d5e60749b58563db5c5c891505c449ef398ea0233dae625c67d0886198db0f456526fc42bc8194a511c3e18249ecbb12b789f09a8eee5222720dcb4b995905b0868b4cdf02a0debc7eca6602e8645f664594301706e7a237f9bb7202c4663a422bae1dc7e9efbd5b73ef2fd5500718b10da2f006db9003b59fa88736c2068df1401b6a35ae4ea315e9225811baee801c2994f09945cfb581cf43095258d0aa56f1b2c8e3587353a152f75fc587d8cb49aec0e0ad1d91a788dfd44b1b4bcaabf5ea2a3ad624e5a7edba26c1e9e7a9d196b2d6f04ddb4a260466ccff2b9b1af5f02c8bdb4517a2ede9ac52e0ddbdc30c9bea4b7047f390f9e26f07e2bbdda3b4116ec064bd9ad2389230b81576757f630977c5c0566a6f903bc4ffaf88e4991a9aa38f004162421cb7ffe2c8bda2649eca2aa770c58c43c2001241000b2fa189589d721b64a1f8a77b655bb2263d73aff17412e0dc17f72962927b0482168f32fb4e982ffd7c4850e7d44b0c0ed0722300cc61d02b7b3daf5564d15e43c2c6264814a05aec13317eab65d64b91ff6982e5ebb7a076ffab8882e0417cf221c37a19410e671b260e214344e8bc54d75900d4720a40a57921bf11e12bee2a4147db8c2892d462cc7e73118f52c5e6bf3b69ece95b00836305f78e29e2b1b1c61a1508b16ccc38aa42cc013c7107e7aa0f8496bc0cc0cbd872a5ec4e43b7954468eada591635978bd28e312c9d5c2ced6d6a7de80160528d7642041b37068f15b770a53f61f9c0be8bddcd0cb7382df8903c9e98acf09 +generate_ring_signature c5541e41e2a344f29ecadb669ec32474ec245ef6b2b5f06717612477a8bda42d 62feedb1dd4c876f4e95c2733a958adadf85d278f946e4c82f222a7711ca10ec 125 2804aafd5a6c29ddff9968bc1d6cdb3ab4d346e83d219fc96abcc5729f6b703a 77521a9631c275477f4163fea03d7c3fd704fb7b5efd379320e005840539af0c ff24636208c5422a9c83e3e8de964ed134553e54fb7e8205d2e77b325c66ecd0 f21c08aebe88ad781e69ab0026121fd5f134720075db02bc436db5b6ce9b459e 0535f689f85a203f3612be098e8fa8f06ef477af3395c6a116bf9e3280f57975 ee82c0276beaf45e6efc7ce81696bfff42f557029ecd81e0df7887b7dca4b0d9 f760789ca02a9fbad11532b7cda06619a32e2e6e66973039f4f843a1cfcfb906 f41125c6fec4783f9578aa8fe9fbaad0dfa5612a829c9d5b055c778f404a120a 0e9f1968af9a915ce9c88c0ee9a1c42bc4d6f606262509404362a80feba773a8 43d5caeaae639a65004bcf71222e8ca2d3b2851b152dbf7bb89aca28c456e63f 16a37a71f407d8ed2bd161cb9d3f45a9f2801ecbe67ccfddcaa31cede4cf986d ef3ad750bcb7779904bd2bcb5561d505c1c1891d8c78e46e94cf1d63a0fadcb6 746178b33c58f06a6685b550b789d398862762f14ba9a3f8331b2ba82e971322 ef470ff38a5ef2fe7edfc030a77d086100965fae7a341afd095867a411eb2745 e8d43a2b8c03e0eb1d64109b1bae138ee4578dd584480fbf9becd4e63ddc3ef2 f466151692eaca15a47af224b8b220c1f71c51a78b581b1f12695947c790d09c 0b064774a419a807e737a7ef8ff52dac16c372448243428c321c024aac33078b c4763dbe8d39b3f2eadfd70260acef19c336a1fd80a89d68bf8d5564c467ccfd 141ba183ad8dbde5e67f98828c4adc018d53db2cae83c34e3be314bacf438591 41927644356a7633faefd0bea5fdbd25bae1e720819d2fe79500a950e3fe6d98 90d8b56157bc869813104b12784c4e88e908186e10435d50add8746552f89c08 9f3eef380682bb8b6e0998bf7e3391992492183d624b829ed3340c34a6affa7a 87397030797108c58eb9502a52a18973db5700f8bdd610dadbc80aa3b6c66e59 2c5d5a0d6bbeffb62f288ee87e5762d6fc9074bf787d5df4dcde7a49e6efd1bf 8b2c1a8dd258009d5751dfabecc24fa5935f0d252871dd66d293ad0185915a5b b1ed2a53a023134c2023a77c7725817a9205f831864acbca58f9c79d417bea85 7f55eb07859de3dfc0a8e206d1d1cf4a0342488987a6d2c18f41e97df0df014e 5188fac915e9e03a83302e4ae128f1dbe63b89767b91a4ff3b9295c30dd3bdd7 10ff7af1f258091927149854228a5c7d5ff271bf4bda55a9ff34d1ba7675c509 38e38959c1ebde70dff0a5bf2257a13281b11d432bf7f51d3737c500c36f7f2c a19df45899c18cc81122cbad000567f8fcda8e789293f9b77b5845c03892fc4a 4c33aed9b6b8ac36afa9892e7183675ae5490d21449940b207aa6466cc1e97c7 4292a31b6bed65a201ee83b71915c238b72072ee439b25a2cd496d2cbba85250 77891645ef71973768d5086c5e666eee6cd22c18c9c027277154c294e58c1107 761de841439e26204b01290f022bb014db8df120501179be8f3764d7c19fd8f5 9e711d6b3abaf3a78048a9e1276e6d70aa4ba0df9673d7b7cd653494125e585f f9ea96c8410b15246095f15b1a080578a3d2e4a42c9ca7ac41d713d69c674237 13b6fcf0056f59eede98eadae5e9308012083fe4986c744e1fd93db114c389c2 1ab06de0e3067113d4ecc48c5321fd6928e8f30c0b4c073e21a629f794c930e7 f2ab29c1b2669413a71b096379c3fc8b21889ba95518e3fc576215fce0033592 9463f8f4a96d456025108c444132060d710a6895da60ba9ed29cb0e7fcd222e8 f17341125a334c6f5ba759ad278014e62bab511f9c7fa45890f99a07463d5299 0cc4709fefdfb59de0bd4bce0f3833a2e3e9bcfe56ea4469f9c1bd9e219ad662 cf4a202bf367be4e41350c1b3a49a90f1faaf925a73af48224b02d8679577d84 844e462cb86c7906ba82a2cc5eb86828fb9bfc790abd59c2cf54ca6c0524b6f7 265cb58a1b994444fd2a9ec13e22f1e219ee2910b87bcc809e592d4597cda731 eab37e95ed3dcd62f3ef9d98ded850d36c437ae0f7c4d360eb9bc0006567dbf2 a9bc3a316ee0f0dd1245d33aa0f2b0a65dab787db3b093b583c1d183cdd87388 c593bcdf8162435ede45858a3f82d18b6e08ec9917574bb630b019885eadc15b 519bd964446b95b440fd2832a2bdafa6fe9dd41f91bf9c190827ecd014817149 3c97c72e64b47cf79222f987d41a9f95959b05f60aaa714ecdb375f6bea2f24c d0799a853482f9870120c87d82efe93f6ba672e361244a1308f5a918f8026204 3fbcbe6e8afab9f595dfc5d42092b46ced57cf4a77a7732010e5435df18bcb35 e7058fd902caf725e1937654bcf210f8a08bbcf4c174127a19bd013a4ed13c5a 3538cc278efd09cfcd347eec14091864878040351f128a36f17f8eb1bc1bca93 d023d792c2ecf5e174d78de4f4eb1c972f05fdc31510ddf285ddac03edb6e9a8 e3bbc9156f2d1efe4b0e5bf24370772956146201f29458902f299e7b178e2926 5ce05d70587d6f961dadb852cbf573da00d3575902e5a111204c29c1c1995524 13d6a79c71d331cc44369af63eebe06208038fc18a35d65a9bcddfeac86799d3 f0c18a55b75b0e8b8e34b5efe0d3227be9898fbaf8b270b82a347c477442331e 6d941ae5057bd14443053028bcc66e3df3ef8002ed4889722a619d27af42c4c0 65d401e25158b5d536010e71ddd6face36fa59159c7147f57f98dbabd6c03e3b 236e3b8f14794886df4b2e6cfbe93af86a369ed36ac7a163855fc84a917d132b 2e731fad62c827847155d6b543e91656f33a37f29802b99c74b5ac3113bcd3d1 8bb40fa5f58d155cb5875f14fd8f540b6c5dd7fb230707cfa3914d8bb76a9985 b741f627de1025788557446cd8571f965165f3b87ba70bf9593d2543060b1dce 40c2cddadde1a33d787f42ff20b897470f6c49a2d1cd8fd9c9aabd4ed20d8098 b9b5944a94b1024f7f03d858245bc7085f2bf8c9b559040404b2a8f1f5668353 229f8995a931a23752d3617ba4c06a74e48a6f3c8bfd40aaeacfa2fcbc6ac031 c97156ee1235c56564ba3bcfb12c645e5eef9bcfa4173c3f7efa755646a3999c 207cdf552b7744e8e68e4721ee56795e2ea0d00db61156784b351b07d91d9b16 cde0f0dc90d52b59a17d9f220a8993787153aa1b2dfb30074633219be62ed6ca 2f8add5d450bd257117c2c40f33b50dd4a85ca2946b10217344e842ad29a3f57 198859b069a1c48e96f6420b89dc69cbfff32867574717ff02965e9ca9aaa9f6 da1c7cfc3af582887f4bf517548956f949e1a83a8b82a5c8a396df15e1ad1fc8 a0e5719a9ffc23af748a8e062ce1ffb8c82da607c2ee26993b0e76c01c1951a3 05776203a11284fcd79016b18d7b4544d10b9ec88a861baaa3b980ded424da0f fcf8075b1a91c94ec4b6f8412da739dd74d749a3cc55e9574e0b9d982d21ef43 d567383f5e2709fd6b640dad0915a229e62d8e44880cbc20b71637ef6c883cc2 8c1c065394f4585c0244671370ec3aa9f31c73c109f50ef0290e82b41730f3d4 a6def36e17f8f1bf3225f801454d57b2f8792adc94b1933fa01af88fe8e967ea f61371c2ab70bc8012c87fcd14f12d7ab1a2eb51875c764acfdfe3a2b3f69487 aa0303635376c96892e2e2f609d626b6dcca8b19879f5add956927ecfb6112ec 327a716cbd42649a2f59d3fcaa59cdd2049e94a96bcf21d77249246ffeacabe8 50123f75a9558eb33656757408e2ab0250269a03f9ec1dfa8386b38ffda39f6c e38b6d66bb8d6be42b76fd58aa01f118da2cd9249adf097f1b3b4f46a54d7ac4 108e7f9b934c25bc12d2fbb18031bb211dc7cdf996f111d0a2e56d6cb9c6a9dd 5074acee3dc35437abbeb588f5d942f968d449823b29942c21c79a16f05e65b0 6038f6d5324fa1e378010bf8ce3bbe897d5165b764396e25c243db6906951f3f 969d74fcf9d04f95b465ca2b88e50a79c678cbb3d1e1cfda6002379972eb676f deebec572142847258635858b17708930be57b82404f14d028005099d670675a cc8970b85874d414e741607ab7a9692512cd3108c0622c89128101fde33eaf83 ddc7f19c8d9a83c0c32191ca81a3430383c6de882741218a4150c9779559cae4 2270ff3129579cbaa7f986cf738785ce9fbfe70ad863cb39de9418905775758a 6e2a1ad2fa32e93d2dca5ba62643116e6b0788fcda52a9dd74c656e358370580 0d7b0a579493f836a031ba1a45411f36e4174ce06998bd231bb22e4a61aa4340 eb7759d06fe9444869c5fbfb6276a97ca4c8fa577030618ee50c7684900237da 799b5c7306c3f2882eade612689f64b84e03fd984f229b2bad363e9d22b33895 271ece66610fdafde9ca4766cf6e9cbec05386e840d0b161e5508b1a21d025fc 74528f7ec8243c31361f0c20b8fbdc3001c7af4a03e156d907048fa5b02a939a 5cc57310e3f8c9b79dba293353aebb162d7bac8535ac93366bea3d4ba7421dac d0440a843f298088834e32c073f27400c239423b5964cd4cedfccfccb0dbdf7e 61b3bd3533f547cf1c95755751fed8295be21372be495dbd6adefc160bd8e3a8 0a62af61f1c5b60e5d8e0a73ce851c3118b3a33b3e98248508ffc21c12e1aa30 a2bd0986f7ba0a3e2acd06c9e5bdefd96e901ba630b261ab1dce6ba18628513b 87a2209b6183ebbf569c618925fa782208943c0c4ba3be4ccd1dbbfe4fbefa80 c929225b641df9a42614b29645ce066050299b51fa4f76e4d5badfa50f62faf6 02b21e01e28dd2f197fbd265b82c6febf31d13c357e2e524fe770938786c0898 e224e1d91b7f496640c10c658c983faab5626f2ef388c8573262a5c2b803d737 f7648874f6126260ba9b85d3dd99419ebd95a187a00f113efa1cd8e26e24e66f 70d018da92f36ced31cc9298b8be6e9b7d1873b3443c604e0911be4cd6bdb190 0f7966f0a07e18ff4715fb0d0cd23d99c8c6aefb0295670e86eba3100458c466 327b0f4c5a5d34c9e69b5f3c2d9e32191ea616f31afe0cbad2db717b29cc4e15 e6c620872b328204fc60016bfd6ffcd5f475868e9eafdad2f90fbe8fb604653e 367bc5e3d53ecfb280d5bcdd33d37c3995a9ea2f4488f20b0bcb8bfd84b9e655 b826533c6aeee95b7f8aa6b9bafd6604065aa3f048e55acddee13898e7f9d41f e7a4ad5121e7e60dca0ebf2f49de2f19f622ac3bfccaf7c59d548e08f5176156 7b9802431d797c61656841f32129f8a99e23f625013df856eead6a0eb63709d3 6a7337412e7935d128dc296c0e35be814127f25ffeb42b64ec0dbd294985ef11 2ad88ddc9f00c78f253edf8a26757c38f2ad59cbfe69ce6cc0cb6577dc863782 d8e3961134ba49851ed743543d66a85dae08fa786e859ced4d4f1e9eae6c148b 157eab6090d78b4383f756450430cb3a4a993ba3f19e73d04fde2425aeea0703 614ac9e9b8f848877e3ee8e24d1b4c597f6afc2e518175b02b209a69c0a565c0 0a4d2290321b8aeace3965cf602c32739a0beeaa91567df3ca40efa915973447 8ef0ef41d7e977f0c0f2b955e8868d331a2cc5e1aea3cc014a64d96f1653b80f 6f8dbbfadd4f875bd3fb7860e6b522be87b40a36a9aeffb7d8de0115f2047b0b 66 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 +generate_ring_signature 6050b724afab4e33fc1adf423689add9c50984ef8df4b93034fe824ccbff6d6a d1588a8bc29b2df0d555b8b0632841b68cbbb4623ee615c9499862aa5b732cff 120 ef87037b6f29edae32f566f14ea179ecf470fbbcabf36b62d252b85af30f35e0 0adbf81b03429adb494d54bad3a726c919e81df09046e8f237eb9b5f82882a4c 3539a4bd1b04de484d125456d2135230caea0bcd47d76beea4d4521918f7e769 e01e642c44600e167c640013562d0d83d62e9eb696b70e9ca217725dd0b46ad4 9e748c90a8fc9e8839f770f94ed282e08b2d0319dc1287bb2fb3b240d84dd055 43001d2b2c696470582c98b0410879d5f5afd93d7bb90cccca625d289bc6a3a0 dbe579be20a891db9f42ecaa18e45ccbc4abd200ab7258131365a4d5c93e776c 69f3b6889f8d6d446374ae878b38da35741eaa4e4a88ef220d16163703c244d9 f8b561dded476626a7c0ba1adea2c1dfd69d96f0dfcace37406cb1bb25b19d14 881e289bc813db26f4a718a6d790d553c8edd952fdc6e70f1434e0cc81918098 0a56f9f412b6080c9bbd334a6a0ef92ae6a61b038d6a09b0b4f1fb38611bcd21 2b8c0b64bab89e760d5a74376f331ff45e5a5756619836c00ce5882b08e3c164 fb0b6c65d3823cffc4fd3fbdf0f7d867017a8c2d2070af7f69753836a10b3346 d58bf0a33db172ad6cd6460498f3fce85fb3a138694c3beb46d48bb5fec7fe26 0ab01cf3ce2a8d87dfbadb6477bcba61ef64981fea057acc295aec2dcc9ad983 3936b64dd7d013462f90d1969d8c601bf6a4f0bf45b443534eb2ccfb03998ede 412213951f3a59b88d161c057933de94085d7fff3fd1e370b22b16855b6df2bd 5d6a58959691c9c8a62c09bd015b84d4fd7a4c8ab3826100512dda43cbbb4ff9 7eb29652b5ed2b1080aca08c6eb2bf7a41e30df6c229fd56b5d5096905b2acba 732bddd78f3cfcfd342547d80cd2010ae931a76500c9fc073cc193a843839d02 e48eb1544264647008711c351e81c32f81e41f5a7c85a7141056c253e8e856e3 7288c441a034b859a5056dfe0fa9911c24775637c5f707c2eb28c90961747514 f06413f8ed307215eea8842d1f6aca79eb1846c21e1c4c243b665ba195a1781b 01b8892d2d57f8bf7cca182387a6d0872a92fb1a72df366d873307ea3927fa12 d729b986311d8c0da3ca87ac439c5fccad8128a5be990850a3f5820846147146 4b4d2bc6efb964a9581dd77f183a55567cfebf196353ded9b03bab6649ecd10f 4f12843900a11cb9802ad2474cfd41edd21405a2bdd740e9739c66a5bbe50223 d93acfa9256172f808b269ae6faf49ef9cc3c86026efba2002d2eb6a1da504bc b869d5d99868014123044ba4808bb55ff416a7590cc23bec4d46f7a517ba5b41 35b15cfed88fbc7ad9034d47394fae12fa8287dc371b78a7970c51c0697d483e 24c214c701ad51ac08e0a57a8da5c0459c2499910cf99a6a851cd435b47627ac a92fb963867312988139b9e3c29d2076d1a7f051513b6f2c3c24d74f377f2e37 7e4054200f5643f3437795f83bdcf506d97221196ea711b1d69afa5e4b345978 a9c74fd8309fffb5f589dd48f55e29653b8d0638473139eea572bcf4356bfa13 c8ffc26337fe41548090425edcfbb21989da5914326fa7ea776b9214252ec87e 3e25940afec823a365f77fb1f13aed2180167df85773ac52edc44f2346ff7c59 ddd96cfccaf4b991b9fd6f819ca1ecf8e0996e42862b9d0ee71f0a446620822a 50090e56c723895660648958c033bde07fddbbe89149b1a8c8656a6a35a4bbd5 74912093994ca326fb15659020de86bbb291c425b8937324a0070ca4c60a9165 68fd8c81aabe602c09f4b37046db3fd2c15267d974c3697c5f6f35f25efc8183 44f490d63003625443747a7243287d28b3f5fe4ec2a273131d8bc7e09c461d05 6359841de569f54123834720941eaaaaa59b8f9c2671fc7c83ded6f831e9fcc6 ea75a676b28568f3330e7d9421ea92f3ad3cb9ea67ca6a1662c45eadfb67182e a6c073f05c29b0ce08c57cf36d71490d5d40187d51d382e09fbbb2a54114a376 f4b02dbfd2253dbe13ada78a09b53ee799fd347705c07a9538cca79fe719845f 4535ea3b1f6aa90a6b98e0b940c164b31f4787b6a847758e88ffc7fee05d5cd6 8772138c613d9fc8f3f62a0373d7040616a372212328d0acdc333d62fabf9a40 a8f52f5a71eb7d703f5478f4f382b2cf3b0efd6538b24ecd632178dd432dae5a 97215a35ff24137d83c793bd9057ebe8ee7e310964ebc5d41eab6d15342479a7 e7ee87976fac8c0a016d83d26fcbaea4c18103ce971a1d695333632432cfa1ca 00d81de15264f2c13b567041ed3a8cd5331cec6305e4ce7772138be437d62437 d452fc10e867349bcd7f3a783012d1b4e26befbc821b29f8fda8cf5e5b8c9b03 96eee1a1c980b51b51a3e47cd893a4930acc2a61ecda8beda97ba416fdbd6f15 a828686eaf20007dd299f869ef52fae1785b0f25810a8b8ef5b47d2294b77349 bcd0fce555fc44ba05a71cde39e36de093d44149f803781cec70a1c040d4e114 e5d10dd7877e7feb14ff7ff3074abbce9b62b7845de46880a1a3e400269e23fb cf4cdb04cb0158c1397ebf413b9940424f4eefc3aeb315b134bf1c012de95886 e99a22d2d2d0bec068aec00b14213757b498140f6a637b3d14244f4a83391640 e1d337d2a691a786e85f0f2b6be24fbbc6e3b0916986de5551f2e04eab58bbcd 1dc8e63527bf9ab5699fe1b2e6d6aac976da2fe8c0f3ba390239067f19168d03 f32db1edd95b03ec7a6cc707383072b2f1d9bd7553ca3213a76246ed050e5ab6 9b6a260abe2e997d96e528bee60949c7c79d22e88e3f97ff9740a40c030e05d2 ba6364da3293a9a53a9068e15387444500d6d5a91c45760b30b900cc5a44cdb9 5739ad6c057d2c16e74312a7123fd6dbc46a1f34067f1a6d3f8751f801fad433 e6bab56a1a5f21bfb687e77f65d0ec0cc0063576708f02b204a6fe716f8db773 97407b2907cb431220e5553ee94eee4b92fcbd7d3d26f11e48399f5c9ee85be3 861f72244c53d41969ca914dd57e15b82158270e5f133876664d689d541ed165 0de2abf3741bc18b0f5937818f3a1e33523630ad8e1cda086b955c2b13c4817d cfc22f7d43b1effacd87521b5463772e8453a2798f2d48c2918d264f15c563b2 26c67ae82b3c310202c1908af303e69ca94c0ba83a8176d54d509781da183e86 75b7727257ace3fdaf28bd08606f4e8d471a805858a4de3af7ff1b295a8877b5 8cb68849c5752cc92d8c718605eb5390ba07013bab0659429981cb8249148107 10e3bc9b4705f0a5545deffd9d83f16268f4963d4d12225086432dce3f317d82 994e0e93851f6565314a797059f6a68746533f6d8afd7164538c279e3983bce0 0026807556960aa20611418df4ad89b46722bb4273305ab5beaee0518bf90b4a 5df227da750dc157f18d54abfe7ea27bb64eee746b41315c843b42ebb60a93af 6c3d71b333bd43ecfd9bed9e9c6a3438ee386283c9de2bf1d9cc6fe63eb3c7a9 5862c6323eeaa240cbc96df54754b7f9b38a982646dd58b29b7674fe280afa47 e59d1cbd91f6a1da83f811068d2c32d3a4dce1cc87e12dc670b3c8f4cd837668 e01b48407c6cc98e591279d215168d45f8a9b0bdce74294c863520a96c1f3578 d123f51fc47d4a4a23d2589b3ea6afacac1523ae68c9c3e987efde55960da989 b24cbf3af9e8598a861c21eb667e305b275091ff54d619de94427c4e8107b4b1 ce5ece118e978a798e3bec113fcb05480ca08761b12f4d82de6aa20c351dfd4a 881e216b3ed4aef9321ea28d6f31d565356bfc4b1df72b877881273b55de257c f086d77f57298e4001ff99f30c1ce019cd81a74fb77dc8d3b5e286a972b52b78 22359fd9b4985eb46e587cf19bb5094ff334ea115c12eedc31b14a0c1a883306 f4ca0ca1c5e64f8143edccbe63ce32279457871600f83f726706a37274f0dd82 2aab22b4fd2e8d361accdb45a9035695c109d53d69ca0bc4b6cbec1c5a5f73e0 d4b27fc292dfe7d49fa7cf49901503f5c6fa53812247a99d09fe2b540c1393f4 136c4bcec68a9a9d675f590e35ed6a9e51a85be74c269c66345265620f5f196e 2903ea5a2ff85ea2f92a411467005858b3a315b6b6b9c7a7b406fcf2906a69cb e86aae3208c02700d40ea0c63ec911ad32aa67fb4d5c7b055ea2161a877cced9 c2523fc728db90b1111de2a58e424cabb7dc53810094cbfed40e0f1899b31cf0 239b2dd969fdffe6ae68c2a227fd066b0d08fa305c8daa807db24925d2a7ba90 2d64e595338b931b929125659133566e25fc56874ef3eae77760e289a4e12227 64ccdc4872ce46da3421e9404faf86eb8abd0046239c71b8fcd9f2b7e1fa88bd 85c0e8646ac761449a58f53106cf8406af576c36b70c76410a038d36762d4abc ea4dbf46f8653be48bd964ccc8171a87d06c3ee1874eea739df7de9c8f06553f 31ef879b28137a2252476dc796f988465ef7640224a5d9b8b75bb890e8a8544a ab061319d1d6fb3a9cc5c2cde8201a208b82e5eea782b88ee93aad24785c2d6a 43d69deec91854813f55eff328db76ca3f1973eb498eb0f1951a15c806b8d9e9 f9f07b9a4f5969d9ced711bc842836faf8049d5feb3f4cbcf094089d0213a079 efb00a7103ff7a73f36a3b7daad7efbd296feae5fbcfc8aea798a5921fd4982c 9ea8ac862144b79a9715c672a206686f4ba6790c08159746b2707a8f20845b44 22f9d130216831692a2fb6be1a5956179794cf0d3ab5240aba781add81c8eb7a 2e43959ec556d13a5e30403182b5d786a6c90b1271333bfd306b15525c3838cd 7dd14d4250642888be66c827013a345b63ef223c79e5410d86fedbe880f49511 075559e15ccdaa2be0d98e6a4e9248189168612117f1161da8523fcdbf62e725 c071bc9b096c8e911e9f6a4b05726b4bd8cd54ee358d611c0bf0caf467764aac 82126c2b00980c6bbca68944706644332100586eae865a99391c3a99fe206209 955eea558bb0799db9ee5994a88e8d323e27a63075def3cd6d16a2ed82359240 23a79218069842b0364c4ca540ca80374492d6d3bdb578515eb5c62935e5cdec 8c107f0b24dcb8d4d5bd749b90782be058a6665c71e09052e6521a5a23148ecf e55ae85f46ff1d248b12fb35c35df934f4da4865c9969504dfe03eac92112b11 9d4c8f0d6c14ccc7a9c9438cd11224344b31f50c9231fab574d3923bd2ab6276 6475135f9644ca979ce611a47ce21f55f16da6edc548a88b7f1f2d5cb828abab 3f78644f896131d3080551c3b5dc669884f66a90069fc02d0980c8cba93dab5d 032cb098c9caae12e929023e907322382e07864e0e03891710413bc9baa6f628 03f519eb0e73ebfdfc8791829aacaa3c10fbf4a69505e658abf61ee87b6d101f 8dccaddabddeba280e5df36ba751d672ed25f786c12a8c725f972b6f11e3c638 e567bc025376197432a4459ab346d82730c42b604ed31e27b6f16fdc61351b01 16 500bfee92bbb60178179e716ddc2ca5827665d277a6fc08daa0987a311ab9b07420a95bc7ddaa45815fd02ce10a71ada7be19e9db428cab843e616fc6d6c65036e662dc88990e990d041d32a2273f7b12e2b22b6eb200cdb33c5443b24d39901601b4456d8c2e78069248c98056d87a31864f6573f22578f6e52bb33e051b7001ccdbaa9e92272cc890c678a15d4fe021a12046c600cf6573e3d959f9d2d4109a9d09d504df479aa0409dc249524983f2d1ccc1745b2a117615727f7b54a3a081ff8e975344e4a53f844212b250f9df26157938b5e88b3176743d3bb6997990a0d4a8ddeda9f44ed77619f24c8eae3c629cff25c72444b38a930ccc22f6cdb01b30e88ae1a9434efd95a6f83f0811a658a511b7ffd516b56feadc495a5e8e9011a91017eaa8dde202b88c570c609f462a94fd8d0660c7901d81e397402f8f30e035b2d2bedb1bad1da5bc7883d612994f2f84041f6ce89cbbe861f637999c4042de22266a235ce7d1fbf207a7c5d109ad7f7f53b1ab85e6925ec00ccfa2c4107ddae90c516d607f879fe71bf5dc3fb676ae9e7c5ae329131f84b31c8fbd55b06caf450fd9411777212daf834176026a33a9ff8af1cb5ba66d389c3c58d29f90cdbbbd0b53cdc90f8f3eececa91b7a7979a291dedba23eb4da3218158a8e0ff03849803e89a3f6cfefc3e220469a79b505772a4fca5beafbe8f907b0c9ec15101b75de2304eca53c4ad01286b0850fd92985e12e220b44636337541c68804830676c2bf964e3472fdde4cc94bef9e46bb71cb14e260449def5f976fde3e62110cf76e9a287fdfa857e7b09deb5c56e4de2f691d8a37c9eec0bdb77e15e119850e0dad9de524ee8e70e051c4b2b3a979bb36d4146522a33a3f860f429fc92bc00d3055b9ed2abc1f1bfd9663f43458be6e6fa6867fb822f7885e1d7b1adf204504a1327707993f19689980ae90088976e2e0eadbb2022bec03b2bb207482d8b506e00d84d21c96dac5099dd4c3f9ab102f483ef884051c841d7c8c19bb452806032c244f26458b540e9c4a598cab9e4e9948a03e2f608542810a7a0802ecd9650e8471eef282fa3cfce8d376adce136ee8a26ca948d4cf97c67d4ada0bcfad1c08088e397c6bd2438a679ff711fd930052bc41dd2147823aad5929e8ce2b9951078d680d6d99f32bff4c0a20806d634242a18462d6879829fad65b927102fd5d0fd861d14240c8ac7c37e936b48da679bc8f4b057beeb417248266d952dfc0d90f36a895ca8f58d9eddad833a77de92dc3e6ff268a5090b81ff9a6c6d73235bf01ddcd6ae5f6b4f548d45a1235c6a638ea8ca955ef54aef9c44fc6443934252e0a41d407f1f0ab9efd20e0967684b7f44202c15663f9bada2f1885707daad20b02346f117dd4d6dc17f27357f5da34cced7cc24cb184b62248d6172d3279cc700c179b9c6292edb3a8f49301df355a10d739018d43f796db4599d2d0b723a7f10421d908beb1485058dc80db7b34a9667945ce9d7c8a11d6b2f5e6dd021cf9cb0e08b824d268f1127731d7570c9eff6480ce4b432a7b7e9865c234e9b715ef43048f54b78c9ca48d0b4f082375f0b4e550990db8dc471186f41c482de929506d0a0ab7f52497aa25d696b1add056d975e170289c7ccd6448aa426fa6b2118ee909176deb487b65c4be70d1aaf8ae4a82bdb56bd4940700fef315e89a7db1c57804dc555103a5528c0fe5dc4352e25cff7a0afb1f489690c80e00f9dcfe4b0b440d812a662b9292ed76f944c456c0eed7de13f8f29b88428bfd549873c98a21e70b5c7611f8a33100e24fc68a73036ee6e958ce34cd040aab6aef49d38ed3ca150b6ce8c50bb91d67db121e1b475c9b5cd11fffc677890fed4c8e5be250daaa6c0613d5fbdf7e3694c8347492e97824787092829edf1adf123c46695395d9fce70d961dd5af042bd322b85b937034ca0026f975be38033ee3b8e6b37efd73d84e0a0cbbb79fe3e54c2fa7d695b76b5e10fa5c2d82651a9fb556125da1ffdbe4e90700248aa8a77e1d89bbe7a66d7a59d356494ecb8bbfa4329c99141b219640d40cb0306b5b6305f430e22be54fe8bd2bed3d0da269fbd8daeff76b27467e54490335be171e16c2553d1b8825d551f3ba5454a9553407b88d0bb539c75de2c52a03aa553d3516b41dd2372f0f046bef9d428b7fba0e34da0212238d315a81d70a08334abfa4ae77da4909ff6b9ee75ba87c6726f14158b9a09db14960091f8ad308751e2b1c4d6714aeac1a4712384e9cafed2e0f8c7d13e23413ff8c6bbb7cbd0f8297100c81f35eb6aed0b12354dc16f62ec9aa1a5579a9d87920d0e45468c206327635e4f377ad8e0e654f4cbd39e358ae62153862c9d64879f05c2f20560f0969aa2d035995b4f8c8462f3cd26d6f109ba21e61688ffbfbd1d17a6bd70b4008bdccd875fee97d9840d220efcf480cb14b4f0a3f745ac12bf14b78cd4b9cec044b3fa3fb035937b679170935c2f542afe98f5e823ff6dea2cf027a37fd6b9d0536b532c80506ed49c2da71cc0432d32d9ed841cc76fdde20a0fbb728b3e52d004ec8266fae951d419582fead9da63b4130311279a17d439f3bbba557bf2b820e8d726313ef6bebc791889201a0779a6e979bffb166e0356466542b89e7815a0d9769119f949cdfaf24fb773c795b7f56d29fd9f72f1cfd025a25485629a1a70a6dd4e81e5a796490a9604566e376930098f038b2b17cd5101480a567baa72502d88c6fcf3f4b728f8cf7dc50da26cfaac90d4b80846f1a1d1704c632dc2f6a0ac622f3fe4e3c1fcf0f337e79828915385e0d978c88c38b8ef7b4da8efeb67901572ec9a2dc8e76639d37b9c5be13dff8993accb5c7086f634d5f50cd47cdba0496a067bbde44e31619e0c8dfbe1071a7d06a06e51a064113f2352c32f7374305a12fa85e70638f02022cb9206e0ce8866f446f7431f81df1c32e694419a833051fb9373c3939de2a355a740d61e855ded0e2c52f22bb7896e48fcafe6b23ef0300984d5b4974fd0421431112de1776c30d03f074435329bcedc77135f84c3202caf1b0cdb7904704d07a1fb0ddcc22c496bde7df179cfe5989325dcd3437890d85537efd1adec486fd8016a5f4256dfde3ba6aeea8a250640e0692ebd85a520b843fb0e1725358e4470733fa2f845fb143ec227ed8f05c12ee3c926111b7bd03d8d16467eac562eef2e5adadc2311d4be59f058980699b86e2bf22f791b70606f5fbe910677966ff3b3adff10d74e47eaa55a43b1863216be494b81ac744670257ce42e9f69a1ce1f03be88d01b8197fd413265e1babcf435958006435323c0c5abef8224c9306413d5f3a8148a49a7fead11104b9ea836f9ddc81a3b61c1c0858452bf130d8a246042cfddb6e911fb64709169ed88c1ec7986ea5bc6d34130746fbd94ee13ca3fe41c5e54789278459cf3f56829a79822e95b434c57887e300e007dce4391a161c62989eb9b35bf2daa57ff1eb505a8cd3cb4bd328a6e2e30cd310eadc819b09401c5a6befcf1512fc82d3c3cb837fdc8501735d659862ba0c7b7ddbf8f438847758f4205a46dd5b24db770dbc1337f1d121b8c2ca404afa09aab6bee5a07dbba0ce316e61df7ab80534549fc3d930baa75355391530049f0df07d4b9d2053825b6f9118caa462f41a1b411e072a2c8da577e700291c133a0356818890af8702fed546525c4554b0b76c6238bf8eaa0014cc3ce3a94dc3c40ec25f3afa0195d40358a02ebc1bc4297106eba901fbe04206ef8af3a095ade70b1941f1997a5a1e8b4d9ffdd58df2503dc8b2d580607bbb59cc2e8f5dfe3d02011fb2e7675a698eaa1296f912b9380bb4836902a3f4e225f3241153ed19003807fd637feb7006f2d0fd58e0cbc273b33d1669a44d54ac23ddccf4d8d09b5b4309b22b26068deec69940edc20254a0752910c9728188d23c132a10a78545971405ae464e3b88f98188e9e4af212642aa78be1586b17effa7eeb7232387cc2329066171284d7b98d48123002e3fa0c96ff61ca56b0e10a1803749c522a48a60bb0114f320a5e144d097ada55e8052eebbc9a212cd62fb5434a4ec8644903bfeb102ccf92fbaba64152bca192585d0c9f3634d28755f565f51b815526408920ace081d9e3b8af53443de673d15d68451223f902886f01b855654c7ce3f900c0028037c8f3fd72c83648c448ba98fcdd166a8e1ffa700592b69d522775fe0a0cb1b04f30ba408c19054bcb54e554fffc0e15843795af5104dd6ad52f9ea2ad410530a556d4779d4ef20291be755db134e42a6c6d0ece5156b30cde1a15f5654954d0c8af95b0142af3708c3c0413049b8f81f689658f56cb29236be43889b3892510a4e62fe25540d72abcf6b72e0dbdb2bf236d1f6df9b8ee4d09f18f2ce7477180e1e350ba3880b82f41ef752ac3142337b963b45b43e81c946c9b8fccb42521806d3fca4a3aae3f9d39a9d322179dda320f1f0f93fab3daad351b98db21177c10ce4a1df3e77633a08958c216d2049363217abe4cb8e07c9e28c7095277c2fcd0846f346e0f98cf1a6895381538606ac02bbfe793326aaab637a55c4070be54e0e96c96eceb23392f5ea40b9a2cb84ff07fc3ed8ad9a3be6903c0d01f393e9530b096cb2bcfa82a1aab8f62b749617aa9916b8ff86be454ffb8e3d2cb3a45e8e07a14cc2ea96331e827345d41211e98c824f63bb122af6a3e37297ae007b4bf9021f9e7ae1dcdeb5c13e1190c6b32503fa09077b86d13c5c1e1d501455f0d73f025d6e9f043fe218ed91a71dd74c591d1d4eaccdf487984c6e5f246c91a1c6e50c9bb981699fcfaf50da865e6e45bf33ebb740b5a2eaeff82b225d46d0a87b380bd561b32f5e6cd2cb84ba75256d67b7a0dc933cb40c8fd8432b4d5fee4c61a106ffd768ccb897454decef6496c74c3ccaf969514d7134cfec8fa24e838bd9660e47105466ff2fc5895bc62c9d9de2e441e1b78dcfd8b88a802998eccafff6e70a722c494774cdbe5a5ba97918148432b1d7ad64163e018c6128aae7ee544af50a0b9ef82815540b4ded09b38ed1a33ab9f008ca0d6db75e4f986fc4c3a0fc080ae7679b04be85324b65e41f02fe5b578cd551d719c57f925e72596ad1863a200cd8bc1f82ff6b26cb04f44005c4a7158aca2e982c37ed0a1eaa017ae05167e408ecc7a63989ac2a51d3877dc14109fb35b2b862b83d3cb36d96ae2e65af1fda05b1597b97cb21fe0f333e11e41e04debe85c5a6a25ada1a3e97d82235d1734a031e385d1032b6cf6684ec63c80c6cef010c08f442d937ec21ce93c74bd0153b008ae01203a2c082435ad484c431416ef1be6eb518053c8ea11262334ce9eb400de54e572811b3a5410cb1bc652db14b06088e4dfc5759efdbc864786904f05b0249f8bd391c339b3bccc22dc00511c48480eecd480ff51219fe5f2f1fa59c3c0894c4eff1a987c02867cdba30ef31ea4b8030b564b342a6915c3a9a89ccc9f0072d6ecdf17e3c3d5b20241f84bf91989ac8fad026eef9bfc68e72fe8491c8400db9100825e8dde068adf9db7cd33f52473691cde4dea14d3a7b67bc251894f20b6e6e0d4927d8f1ef7e9541270b827c342197ce78af8a76816222a2971dbc340d22bac2941b043072ebfdb0d3712555c34c5a82a11095908f8918fffa0ff981058e1b1d57137688de70e0c69415ff0c3195ed79e9eec2704f91b1a9e723194206c943eb079fba9dc05a2b7d2db0d3837718fd6cc7428ea6a5e8de17d9515d0c0d8eb3f9a66cde38f92cfa889ec6df2f09615556ab421efaf657b6ad5b27906508f1415dba9d2ae84214e96ae1dfcc02ca43c6a76ae58f583bc42b5e542b869906171256c70230eb1b5719df8bd55026e426a90ccc6a4342d50d871155c98c8d0cd072a24d7cd876b39670eeb6406d23ac481dfbb99da8bae52e2f50c59be0d20c8ab29f2382a9846c3581fcdf3e7dd14e8fcd53c4bdd615158c2dc71d045ccb0e8d524b71db66be503a2833f36fe941c59154a049c957ea4ff2955dd6c51d640d134a07862968eeaa19e71e37995954e1acb95eb527797c44a93a14416068410700615a7399c9c7db46a34eb0d06346051e5b2a2ff399fe3557794b749f7136025e7512e67c11c7714d10cd6c5a08a879921b8b76fef134d66dd09e9d714eab0f9d67ffd31e694b690a04412b16f9dfc72583a40712dbf840d60a9c80cd2d7b0ea413ac52165704748d376303135865718887d86ff6f0ff469b650c3a220b4b0afc7faa3039c0dafc0686d330eddcb3bd310141155916362f632441fa541dc4023d0aa5aa48a4331a35224dddff52ea8be0cbaddf3c244c950bd70f5a3764050b81e7322ce667166c5c3868eb5c2dbba54d1b6b982323b4ff789fa4a07c987d0d1135dcfe210a8f25c73504966c7f62ae7d84749da7fc23eb4698bdaa4d94870ec5e7c128d365a3c682c3205e509eea68fad4c64fcfd939642bf06b9f79fa6c0852c17f4d989b32c68bfc0fb3d3cd8ab590bd5a0a7a17efb8c58159e182ff92015e0e85cf90938e5ac8c0c64532f2ceb36e41bcd8aa517211390f0115d436e60a382ddbf438bcc94a3168be3a670d19ea024ffb293093c0abc7dd39163ab2ad0d8e3be19b1f72ed43028417dde792a25ff6d1122eadeed1c771a35bb64e87da0d9a0cab215c2ac2e27e080c298e5570871731d244bd1dc1b6f7aae0633d156a02d6ef8c5dabeb74d2c1d72bb62aa723c09f28c9defbc4f7829c1f1f2ef6f82001c6f273af1c1b8f0213a898489207dfcebb48684399f5425d487fafeb8f7cfa04c19d636e3b043293b7e16503230c36b307e18e6dce9376d32d7a0e170f3d8b0a935938faa07c0bcf0bc3226c6a90f64628c320b3fe3fe36d1ae4f5f9cca4300abc294cf8ce1d8488731269ac5e365adf64d9787a44ed58f4d0df24ca73e0f20a238fe51e09066a9c253f7ff229d8c93fbd176efa83896340867ead9de28c4f0882fe3361249b8fdaf16352be941c8d01587b4f52eba300ccf1213285d3bca603d2dbc7dcf3f2e9c7fb8c16da6da4ac8a310d33c3fa4c5f04bdd174ccf522f90b4571606da2c95a84899c43b56b0e605c0d3dc7bcc63158a0193ef12c52b3540ed0a98d255f03f876107bd668a726480c223ef10e50ec8909448a5298865ccd0895990fc37f9f6e6de9691b1c67cfad59fb97ad234df24ec69331525bac93420b625c50aab85bbf8dd401871231c0eae1376bb0b3c450f3f3e94fe3bc7ccf2307281fcd48209c51bfced2ef1298c7cfc23c63bcaf803330abed62fc0b96b11e09daf39525ba5fe74605dd323dae6286f2151e1a7f663ac47083d954bf46db490bc3180647109ff86d33d9c1134c5c900d2aa7f1879992c5573c607603d253140b9bc73677f63b6e0af854c48201812b1ce2dc0ff6376f2d0da8ebee69b985db0cc2ab43fc28f2f2999722bc853775e1320d0573d213abc3fb9b648945f8867f0e4ab08632e5c786e45df4d2b0275248ce8d72bd39052e9edbb685da350221d90a11bc2c754ac674220dd55b1ce608c00096473c065703f879b62198aa6ad901061a77f5365e8c28812ddc2c1fbe9c215f2647ed2624cbd0f9cad963f3f9357f05b061a506becab14789dae2641d56aced44862d7676d61f87ceb3db45d22c8d027a849e0f8424e6bb0c275ee051d70f252062ff9dd7cdcf107bfe839d95d49c06e50cfc25cb7e64b04c1ff5170014130d8bfd07ef4faf96600c956d1fc245280a7bddaa51ce33268ef57e7084f580c4d144df9d06f080db24b1c93af3880476064502739945fe48fb43a05db3bdbf9eb0076da4fe98df6e0f21cc6e25951d5a0af076b82ab260f0e6db120030e698334bf80877e298ff1035126e731d0bc5fc0a48468579c0ddd99ddcde3235db260cf3a7b0c65fb68eb1b8cae7646d5b9b9907f29c3534740dd6a617259e4b6382b0054cd1088f6ec2b8ffab72756dbb3a930555d9dbc8e617a14feed61c43805f07bdf2aec064b6de362ca81bda05889c8502ec62b299f8043c9ff6a84cd1924f80f3d474d342b5179df1a70bbc1b1408e60f40e9f6e92a3d6313c5914f0e00786d1b2ab46a2ca546fd8cdab7926cc21ebc0a251597aa93c949981cd4f944d29aa46ce20b1fb7fd1e3a05826c0aa9cf60920974b3287b9c995ae536e2045ddce2cd4d0cfbf7b534865af4411ec774b953da03c87c78b1c045aee12a71b0d9e37e2ada402829f0d611de44693ac2c9ff6f070845d2c1e8bea6d5d1af778ac5aaa022832f97aa9f2019a65f9bb728b8b3a4c30ab2db37bbf7f5e1aa602909cdbc6ed07746e4bb69825accf2fdadff05abf87f0a8907e4c2c8ec3beed33587d234085f333cd26b82a0ae1a4af05bde04b49cdb02b9c76c6377fde2365e398c7eb567b608a7619599da27fa65df7f7e11093b220c220d66804a3f146c2d77b210fc58590e6f1c9b2fff1e99b6d94ba765c1757409ca7f20aedbeac56d5856aaba165934a633ba69448e9070d22e6a1de4bfae150b75844f4763dcc1a9b41d095a542496c33f6d69143daaeccd5d3529d35df86807d213388d79e0a3c2daf99b7e0b7073f615088106e0025c5f8700bb7b38ab18017504dd7ad23716be61ed7d610fadac9728254a62941e98d80e5387a44c84210af0d80964e9bd2a5e5875fa4c22e9182bc4a1ce358e2fcf9aff58f99cbcd48e0a7d96394fa6d3e96642a2456d73484f2cd91b0ebe14285a3ef80b184fd9a1320143e6a9e2c47babb0798a4082422bbb8d351d6a124140710b63842e984f023d04a176d9bfb60fef802ca2f9a184ad5e64dffa1ed268b467a8fcab9bbf32246a0cfac79e86270c4000acd7373a9d3be681efff5127eace29b90ac31bbe045a8108239666e8ff89bdfbcb186740f6e8588e336cbc954868fd2c33b53b9a2cb570024315b2fd68bfc08fff01ad4f437f4c47f8b04725874e0f766c76bcd190840f011e5d452f4394d554bede29661103c117a5df8ca70d107f6cfa3a3b1993392b0375e37c805aec67470f4d7157c775e6ff3acde8e588ba8c8130df439e7427ed04b683e7906e83b92d54994905a8853758390b3b047065c9b4a440ac5377f0700b4b797492fb0e71478b721fd9e1219919a8cb583b1808dfa99e2ee7ee9d23b1094fe83c4056cb416f16281361ada2fe024f659b2ee5fdb581ba92b4dfcd20c000f263f4997ec8ea7ecc38b6ebe5c84651c6fa542f9105863f293e8febf109c500da1705984fc99044c2e6e91948331aa7b095c5b1fb067067dcf607cd1cf5a00065f757516c47a106dea45c4846c18284d77a581724497069fef949a07d05eb0e33d0945fe45b5be145186c07ae2625a33b9ad68a71d03ecb08446777bfe8080136ae0648d060c0fe8b0db26ff12ff2e15a9b4eb9e8ba13fba262fed1992c62060b9da94596a3876fe84794a6f9591a89379293780f449d625dbb33df5d76fd0af20887fe66bcefcb919dc60497264980ec2f3bf85cd983f89c4d2faf96ebe9024940aafec8df42b54344ac75c53156d27158830adb93be28545cb327ac4a4e0a2893ebbc3571b39fd59b663472910b2c9d2d8f483d5d8631bb889a9bafea910f6a5c5b4e09fbe9df395eaebeb1c3926208380bc18573f9f893e81b2201eba90a8cfa7b71a62d576d9e07ef551e89e0e55568223e19f85be9a381584fea8d6a09308d2f6e340ab7a5870188dc17f80080f63536cb685b7f6870f04d161adb7d09cf4303a18cdbb6bdc88eb57b9a3e80ae12530ef25c6f1e9b3e0746a6e11ce8010ec9594afde7a83189c94b9fde62d9bed9972db0e12f1212e4db2acc9ff64202979b580e17b312d0da79598901759bcb9be3651fd415a4dab3e57c843f73a80909f4621ea4f62e582d9efce3addfd6341342afb5775e0b627a2c5a26437fc20c4269b49ee6831e42096f5a5ee1757f8d28fa5d8f4252973157fd31b80796e80f0b592a9cdf263364cde5f5c0cc90b2739cdbc9786922db93e1dde08283e0b5031712bceb7b896a16e20e3e519caf6e05a46e9b067bc4011a090548e4191535044e468a929b60c38562a7da82494f868217bf7b0489715eae8d441edb6cfb950e5776da439d67f48b66f8fc94ee4b42abaaf0dad1b920ffc67a4507e624a60d0ffd465dab5fde1e00fae5f3f3c8aac90b8b3bcfe371c6f623b120555536e12a0acd3bf5a6b8cafdca7f28056f1f889a2f6dceaf78f33e9fbc41db2233205e8d09fcd18d0a7e21ee9277d9389dde0649183589d7c87c68bcbd5e56e4978af361052dcb3a8111e878fd4f718f32f6ebaf607246728aed5c376a83147fcee2136c024ecea5f9d6f019bfed7e2a769dca53f5fac81d3fd32210b6366ef102e2d4ba0f247516c78581b1e2231bcf866fdafc749b2872296a50c1eea69d67775d660e0d5df26453a11912129ce2a9ff89180364ee7059c7d0782944a9b4aaf25a79e60c939331916f69cbba564956993891f64e47bf5829325a051a0b201165fc1d4b044285172b0f12caf314ced876ed0380218ce20d5ed91c56e1c431b61e3922c206e759338c8531b99eba872f7bcc0424caa0255259d4799f046907692b2dc7e40bc51c5cd4345aaaf8c47f9854672f9f14557170564dc80a2c0c2f3e187fa52d074a26439765a40f02cd99fc1b17c6f221cfd941eb11a092a914df4fa02bb7c20c5544a89a12fc85ee9f67f710e11814160b528d2852d253d5c3bf87cdc912ff001df7df72bbda72dcffcb1cc21a057fe74031f69cd4f7e918d17ddd848e176602f19c6a8790dc472d72cca8749e1989044897a7dcaa7aa86334461f644063ee0d +generate_ring_signature 9dd907994196494b8125e30882384a88166cc89ab3d0c91f6fde9e8ecefb5e01 90dbda83e0a10b0070bde90aec62e4dc65910a922c21ce75f37c425cba693876 1 b8780402a1279c031fd5dd4cb89f48bfd15b5a8dfc140d9fe0eae67a51d18df5 5631b1eed32e0c03cc92739379fefaffc2389bc6059c623a2df77b13f41e3209 0 7093e2320f7d16c5c410ecd022e42b3e2b18e6faf7f76a9768cc4fff110fbe0ab6c21d80bf476ebdf545075af44c54c6c4a00f2b8d821e8ec556396db267ba0f +generate_ring_signature dc57ae672f6691bb5adeef2f47e8eb0cf0c5af0d06d479a1b1294e5b3d41c06d 3025fa55a862d8127dd4c6c3d757a2e555e7d50356c3028f6a0027aa786c751b 2 e6ca090d9d3cad0b144faed63a19b9f263b793259f0a84d3465d9567893893f1 ae20f4f7f9038da72a39b4618b1a9032d77bf1787ae00632e19b50051db8de04 0c51d9cdc712d60c0fa724e226ba82e337451ff47b69da5acf95fd41db1d8c09 0 3d7da055ec6d653010938447a506563c9df3ae13096198042e09548c6698710996270d59170c5dcb7218aa4072f43098e30e6083d4ff9b2ee779dbcb8715fd0d0f319795ab1b93983f4b7b3c44c45f7d7a7c329347ee032e35760effa95ada07c57e9d5dad18f069234580ae0afca8ee33e6795fe36f91b6036ac328f70c4805 +generate_ring_signature 2e3eccf3241ad759efd0759054ad22f235e33e882f8b3a0b8dcc2bad44cc13b0 46083a5c582071ccf8cd1c9f33bddd7b02328a1d68cef46e82f41baa171a2fd2 2 ea16dfeebbb925edc360cc2034ed4a7c45dbd9a2ac5c2699cea5d822a31b6187 64c01e0efec188fdb60bbf359b073f613efa84fb51d764cc716938a6e3cbbac7 1742543972b8075a2df32275289d6be641db11e78bd88f72215a5d2376203901 1 7114369d440eb8b3afe526a3302eedcb9b924d597d46188ba72dc1d055f7f30cb9f25851c28a8b25d89d97bee2b80c6db6ee8054bf2a0069dc4bc62d8d3c01056404829a82883f46c71bed80ea6b3037d138111d982c8bd479569e59e0544d0c7fbac7a0fec0c015044e96705dac80a2f1e35094fc9025a19ae996214e500d0b +generate_ring_signature 5324c8a8ad37bb76e86edb6127499fcbf161e173ec4cba0d426e25a26aa7c2e5 a3d91b89186b32fb14d79601878d9b5cf0289b0ac68d19b474c86f4288c8422f 1 ab633b5c1c80ad6bf183d24f4f37eaba1c4776e8383047290503e920ccf3ef59 a7afdd093c3a4e7f64896c7fee5b6db5f6a57a6f14c04f48df5c4a4a1219cb06 0 1edcd76312463140e43470912ccabc72e778ddeca534bc43e01e9a241a2393093ac6135b166649843e0d1193c847797f27844d7f94dd0415dc54b517cef0560e +generate_ring_signature 9ac64eb93443ad9fbc9abc23cd255253d3f61fbebe818fb9436f2f12397ab717 0d24970317c011442316da2d75ce0bb19dbe3c33ce6efe6495dd185ff0b77a26 3 29316431df8bca23ff0440601e07bac7ca40edc4fb0f948d1cb5a4e62153a1b1 3af36e933fd1d37481499f583155fedbec8bd3e131d278a28b209d5d6938ed7f 5ade6caeaaf734a3f6435719f88871b4094ece978b37ddf6b0554aba023ad626 94c2c27e71b84624c2f55761fd6b36a2f0f835a67fd12bf7b892dfae86c03d0f 2 530701a54e43fbd9a70fc4d3421f329e25f12c886528e83d5f692706761678015a73b223c2b1c48888e781103ebbd03d824961b1dbf090b7011c47537b88ad0755e580bcd1829089b3944abac4b7e320f4382905e4137b9a65cced9516486307fdea39b119bd0fef51989cda5e6a390bfaafbb36760e75b8d26b5b658df221010cb4147be2a8f0c79711c499a8c4d4b9f7705bcb2d11e683e02b1c88e69a7509680de59221d1bec92cc6bb0c1dca378bb7236b9d07c9c69b09a06a3d8cd49a09 +generate_ring_signature 733c77641afbcb27266517b8f24262be24609a4729609ac2bec71b4aa86f67cd c2474848d390a19e55e10d80834f6426d2421d3c0d9348e81312b9c644072e79 2 5eadf01c62bb7ce2e1cdf66e49982fccd9965769d41846e1526cb9eaf2d15395 ba67c3a77e88593f8ecf2c137cb0fac4ce7d2259010854396991fcbefde294f5 c3c9808a7c62b5542b5c054bc98c5f140820efb26aa6adc2f48f4d0550536b08 0 e8dd66d54b4a2c6858e3fed8f6f1ba341591a615e323c8275f6e9836d8de2f00cd63361146c735d4513708b3a787a3b1ba087e85daf8d75ae5458a3060ad03041f681c65d4a1e8f81210f7739f42218ec6d0086eab19b1689b10fe46b73c9a056b415a47d05ce4d885d4f4e0ab89abad3884a842d380b67be4991e453238e302 +generate_ring_signature 1792c680135fb955b884861240d9c55b6ceae3a130059fe1b3ed2e9ad5a9de97 ba66d0c9bddf46eca50a3205269fd2c427e40a9ca780d09d68b953511561b396 5 bbbc21787e57aaf4928a2de53ad1d1c7527586f1f8337b1f3f8d4d37fecb35ff b00f959de68120641ae043cc9640ea2a5fa040ee950858c1e9f16b427128a212 c5d5354bfad3251768658323c092fceb2918d8a700557c79ea5fa638c18fe516 e731fbb5657553ddf378c3d60e0b12b1a5e375ba1154c6b79ad6d276e68f75ea 1936e101b0e7612be29fadb4d8a17e3dc20c44a7f065fcccb1f372bd8e3b0c19 747205001f75da90ded4f907a518903090940432f8959d8ddf25413fa3381304 0 b5a9cb708a8fe730e7c0359a12bd576f86b493f1fab80528cbeacdae29d0b80331b61c41b425a2bbecee013ebbc5f041c824878d69c46745b031d9a0a6aa27061e554bed88c5ca0e5be767c28438fcafbf6f556ad87c18db8180a3bf0116e308883cfa9c19651c20d6ccdb8584102e908514b15e93efc61e627b7e970f567a0f564f023d64a02a339b9870fac5862dfa8b4c9c607b1b08df69082d1a5d627100c425b074647aa1e7c1f75cd5beb828a498971f82e21a902005158e0625249d07fa3541af82ccae70c7a518c6ec6b2bda4564bcc4996b6d5ad547137d7345370e44cb5904a70da55543ce94dc98891527e2c5f73cddc2dfe01f4a93ff47e4f809964ed60d15f413b602db2a5459066beec953e823054fb337e72f383cb41cf806d308688121811b3206c4f81cbc4959c6491611d91e246adc6f6d97fe07cd6f0c +generate_ring_signature d432ceeb293d5ea12e583f0e6a858000ee675b292ace24d2ad53d641988ff416 03776cc64fcfaf6b9a23a85f9577bbdd429b653f732b43a0e8f43d67efa63c87 4 200d574e962228bc5b74f2785ca3aed1662541f7300c818a4907279fb763f5f9 4c89d8fa1e9ce61a0f8ccb300b598c795baa7dc1aed979f22fd19958412c6fc8 287c5c314c26c80e50266bfeba4676980391addedde9789756dfaf37f5d5c120 0c294071658273a2f36d3bf44863fc65c8732d46e5f907c4b68ec8aa0ede4643 4ccc770ed00b9eed0888d3d6346bf28324e98418aff1d7903daf2ed68548090c 3 845c2ecd1617260761bd1717196a2c8669c677bf8f6e8c79cf19a6e2ee39b30bf716ed6167eb035a69ea3c152c538c9d49619bc1ac2bfd93ddf522288f80e00494158815deed830617a064151e191408e13444c58ac38b6b4081112958ef820ec24320093871db1dd02fe0dfcf8e9a7fdecde8d2200a1b2462fef3cf6ff5500e28c7ce5d92a5cc2831565dd32a871967c6bab1fc6dfb8482f003a841c54bdd076ac4aaa9ce3a99d2e05e1c1e56d89f3d420f901953ea4a7d0053c80f09ca6e073cd5e3015c6552575e86d394d4bd12cbdcb90e6366ede51342fe7c2f33a2d80ed52686062a619cb57142f56f11f7bcebda814feeb121e613c7c7d7cb14d0ae04 +generate_ring_signature 5de707be4d1ceba4a9991eda597450d72c752ffbf85f714725b7a53086c2d611 ad59d7abf4332dbb03984884318194af02d41844ade4e9f91dccc65be8467abb 1 a2103cde970a000902d7bcd98045d5a688cea83d1a0cdd1bdbca4c087249f11f 6eee07f5e11d2601d7175b90135c8328c797d5f4952a125a96f934aa82aeb006 0 0ac3bcbe66f1cdf4d915cd84756fc41e32d9f2cc4b915e1efed9fc225dace800849900e22d3f62f815ab096d48d5982879840a6cd8b0305d95d7c8fe1f24b708 +generate_ring_signature 1516afdad27c8277ff77ebe9cc6b9889061ab85d504c7678b51d1b453e656f4a 77eeb7c8666282fa03e473416d2b495c62e9b8423bd30aa054cdac22f0173b75 4 294897bcd480edc6eb3f302bec49fa75aa38de4ea0a5b3ce458e284477a4df2f d7b3729fc615104085544ea277352df10f43e24e8b7f47469893f34df7197e95 9e4ab024bd6a82f3544a941c0dd88b2985601df873cfb6c82c669562d0ccb2c1 768ca9255bad7ce9db858bf51271f6321620424e7e24e5422395b10e3fe48a04 7328152575f971140847e181482617d1220f0cd933535cbd8a5492e8c857030d 2 409f3509735458a43ab57e9f84b67fab661fb176ef966e0246935f09ede6cc04d3922426a197b95a99774d89b1ba2b317864e86c1a4ce8eb8afc07e8adcf3c0982f5ec7f6a9741e76a343fcbe223b485eff8c67563acadcb16f396c28b10ad0e8139eece87f2ee7f0a0705934929dea9d44c59ec11982417b3df1041d048c50b29574cfff6d2b82180d0d7920fc83f796541814c7c3359b4c7ea943aee76f70191fe1414a96269d2a01a9959ac4da8aacd3e5c2ecb59fa970fc63bb9040878019b668e6656e1816cd248002ff65eb5ef5e6aa529feeba3d0e2697072ae3b27062054afcc6c476e90e5c4ef3cc41760e0a28953cadc26fd4ff8731b3d73e60c02 +generate_ring_signature fba004537aa4d6db41185d8c4b12b3256048480c65d99eac669d156968585162 ede0caa2b77adaa6a0ff9cb917a79b644d2587b7d3821e5632955403ba4c9d68 8 62c27334f32b1587534ea7810f3356eec492bbacd7c6bfd2cc91b084dcc38643 c6dcdc2bfcfd81b385864f46dad8d1a1f608eb4d5615debaa651bad8eeab6588 806806bbbe254061c70ae2ab54ccb2c10886f792d9b3d0569fa9753e4c44562c 9e6598f7e3b174857ae16fea6948156db8093c3f991bff0da5a2d3c8f302c9cf b4df03f1889ac5a3b21134d6be2deb378a4c228af70a3317218fb34acb3ec86b 00262c572aceb403da34678e64368766aa091be815bd42bef5db81946488b366 c77fd924daaab02e4f95d653c8689ef3d3b5c71fc70825483bf36eab26280ffb 9af7b0c4033b7f3a8de1ce74f80b1ec03fcc3b92f2212ab8ee5a9c68869b5995 404d2882583e961947d1903d8bf28d3ee2fd467f01ccefac2d2ac3431ae30506 7 8ecb5051fdde8c88d715f835becac741fecf40ae9f61855396a6d3dce87c0708f0a69977784b770c938baaa0b21302712c8186f49879caa24b0be0be947cf7001333448fba69748a8976e1d2138bf0b8c35febdda4b71bde89c251b6c362a90b2721613cbba18fc48536e21bdbc523a9395995e51bbb187c34daa5d81c8d21049f156611382a5b3bec2486b2ade41daaa40a6354b29254393c6abd81ae05b502597a9fc1f48f1ea027d9fb9d70a9eebb825ac5718f022baf5c4a89adf4054a0205049df98e5f98687315124d456d4f8356c38f50329bd31f8657c17176d556027a31a59a59378635a55da0a6026fd726bc8557d266c5e5074ec6b17ee2d826011c1bda6bf8bfeb943eb6b14826e5f671f84c297df49b2adcde7d95cfb28fe00ca77973a598a10c75b5eb101a3721f0aadd2603adfc4a0f0d765f93cd796d140a29774b64e78212347427444afb38e62dcfe2b1ee6e3937544f561de6e44d93003bd082bf8feef5c0e1b0301b279cf3e9f2723faa9adebc3ad6c4bdddc296450c7cfd00844b02110de3be7406194dab771efa6f1dfd0241396493f64f296fb6020a6e4a01f915f8b1ed37364d1ea88354465031b5e6bdf36f930e8691e4d9570b68ff6a51e1ce6e8b39bce4f991a85bb19da9ac4e4d90cd2d8125e74bd747ec0440e974b505fb2cd27a0c3ccd1df2fdf237be21cb43b13ca44566f55db9ca1a0f +generate_ring_signature 3ae3d9ef2c81e08c3b85166fd60d74ae81f1be0abcac3690480a1ad0186e68f5 27e97d10d75e9108d8c4e89e43ba75a843f4b250b3873aabf158a0379f55986f 7 1ef624898a6fb35a3396c517f90afe615d97e1beb426a8bd63de31e3f4725ff9 db1b81edd507d1773035e62c458b4597707bd5f7abe52f6503c7e94372699daf 2d0b80fa6db1598fa34207dfdbdded71c01c7a6e0c48a9895d103ea21f88a765 b75766e4545583a57ba86801b55b63f7f7c875f6ccf2e567048d191230901a02 6c633936bec4bc1d110cd8c1ef9ad728d43871ed5c25496493cd5f853e871b42 37426776747c40a3e60b35730a93d3aa3753431e7d8dbb2b61a5aad33ad8f6e1 79ecff41ce5665dcbadad024b05d9e26f9e6c7b9a7d10d6d608ff0fd4364895d dff0e02f69750454db98ea1c0486d8a27a105362ba9b8679b0bf2725967dae07 2 0b614f42376aa5f690bea1258c2313a1900ca5c8bb56f2b386c1e07400bb350b8517475d89b6864a367426842fdec6121244c2eccbe9bccf4bbd5b753e523e023581a049fe5d01444e1d4478f3ee4aebb5d04daf870e4c0a8f22d22b9415c0006d3e8d22af77d16de11c1de7bb9dc6d5b5a3df99535c0be2baac77a5b1b7f007a4a4923d2db20dbd80a55d23c1210c49c3a2f0ca93e9d58e6c904cd8be04ea0090b0afd8fcc4ae481aa7f32e1bbf9656e22f0c53539d1b95c7ff437a9005a50a8e9f2b290d070b33bbe8eed37c6a61082c6ce94125b26266c006a75aadf4c8099514809a9d1cb686b9597a8b49dc46a39b47b5f116d8f03d044dbec4e6c7500f545d39176cfa3b926eb4d997f886baa9f3074653fee031f25669bd96554e350e0d2a1f75aff85615f2b29285768dbd4a5da9a2d97c2537c9eb3b7fbc7346500dc7e3c917c9ccbad97d91802ba1fc02c197a332e6307fdc6525bac4750923ca08bf63d4855deb5fc02fed01641a152daf55ff11c3e203cfa0a1a0e77adf92800ac6fa084097c8b71db55a51b719b9629aebe36a296a11a6590713795d80bd230e6cd4b38bc2217b7c9114cea413059d62a26a10f81f93f857053308b47e0c0405 +generate_ring_signature 5ee5ba303fba3f86f72178eaf964147c0f4728181baf66d0d69886ea57304f1d b252f1d78bbe4179682604610e30821f9a161cd81ce886689a1aa9199ce14c19 1 cf0e634f021ae9a7741780f42dccdb7ffb0c5dd00e99b208872e604210ad5926 ed4ecd59c016635ae665994d6a1698ba6b39989fc31bee19aa099bca24bca605 0 549b973efc55e355e7d87c29f089c58a99dd933747c759cbfa25ae1c1502b40db11ef22e3cc0e5faff0cc1bfeeac21221ec168e1e65dd3414be68e212fecb40e +generate_ring_signature a168acafc3f3634fb3afb2fa4c85302807788e0b1d6db633457c343b83d4ba02 2ed829909d69d8bff8cb268783d3e844ad3539ff90fc6bed846c15406c237801 3 8eb8412c40ec4e21cd9a4fbd2d7298232370a4ba83ac5b0d1e316888b817b511 badaf9725b5d536b6f3a66ec3ef108a4b3115025df7f43e7ab249f3f58059f6a e30cb9b423f01c24bdc64c739a31419cada83692fe0c4d64fcef6bcb1776d592 7e76841378d75e2606cf68cbf75f3f3db2cde74b2faa01a701a3c432ea191c0b 0 02df73f983a07122c4887d2304751cf1ba62ff869bc19aacf956196cd8eefc0d1dfbc359669c9a5c4a541e36e68929adb723469542aba5d725aaa9193287a10b5a7ec45e99ac92fc19be6b40b430532ed6d6f568fe948262a08de15c8e23b501f9ed111b0b532a111f3ff688d78e25920dd0309278a9dd4314833eebff963d03998c3a1d1d5e3b0d4e614029aa9431979f8fd47d2211219e19f638bfd02ad508d682978ca5be9bc67ecca0476e11b6e315f132b06ee88c8327b3c234cd42190e +generate_ring_signature 76c197a029a4979d0388b7ec7e68ee11ccbc66a8c504502adb011f718f46ea51 b1490f09967c786694043061f7b498ddb9b064091bc8437ce133d71fabac2f6c 31 72b83a2fcfa3b21c53d07c617a198a000d5c4446bc05f142f8d42e94938d3c89 bda3e253729f9b6b189e923f6a5cb3b36163b06e8e2e5c1c6d685cd272ca0ed4 a706710f83c922e3aab795c56883186dfa8dda3408ee314f04816e9b8fb92f90 5c0813cb343b1cb1825ea4378014a6953f5884a8250d5766b23a9af5b43d2dfe 506171faaf0ee551b7c2dad4b1a4edac2239be4e7fe76479cfaac59551deb880 9e58cd307a14f6482f0c00d9342fc0b08776deb879c567b53c9a5ecd58d96364 aaeb56ebb9049870bbf2c68ed50c74c74f738c282da33a5897213c7e305826b1 d0e9a71c4f7b38d6e32f455107a814d6ccab122a3d027f320ca36f072f58caf0 a7672d1d2178777608f058280cbe24887cf1c80d54e4d3ce8c6572600887238b e550d5bef941cea97a3ca5587654794b2cc95e4ace85043435632d6fc9e6c239 08eb2a4f3d70a4e70bfb340724fe58e71cf75de3952c474abd8270a1a4145c67 4c69a16fa040d1904535fc5addfa4ea00c6478c97fcf349094fa4cf540fba173 844f1c9064fd2337d653c08109662a533ca1ba3adf29f71ad52fec1d581df0d6 1f38c8da9e1841686caccb994796b0d462db73db8bd5b023f47438da226212d5 b0a333c00453586b2585617916edfb5d7c1e0e41a06638e8131960b9058e0486 3e1ef31dbed8e4ea54aa290b70cbeb6674f2edd2f1e187634e7489fa52bc1d68 cd5dacb09ceae7dbfd47d22450197370322d2e34c5061ff0f886147a4cb3b444 90b87ee3103b7ca76cb968e6781417438fa9603507b72d5bb1abf1157576bcfb a8977f55e6aff38511520a9f07959dfed92a336e0aefcc6d10d21bc9937ce18f 5efc3ee01e44a3a68febc8ab9dbde69bc47f943de706c9e1309718b18b66d7fc cf1fa8638d4113d43b9a9795c37891dc10d1f6bd71919b014529f59cf2bc0d6b f03eb4af7517879ea5d377e49ddaaf2533e4a1e61935ea0d857fdd1387ebc899 763c9a6765b4b5ac7f6e53789392a1ffb43a0bc850707018f6419ee7fe8c7d0b 8a524e3d21eaa69a18ec74a26dc2d2c6f93689abd3fa4ec469a9effa1cd4bc89 8b6581e491580aead5297d1415c29bd12e15c79ed2d0bc2a25246b97a8337604 7540c5547acdd0df7dea03b49e2cc77d255385817bf3cf6ffce2caebff519074 45dd05c9ed02f168c67efadfbffd2a95f0f1cc84f4292826083bd10dcab56b14 bbe9ed0564e875b45735b0fcbb7e52ea810e54fc1f8fc7e1c704a16183f48d12 0d8c787d3134f90078bd47ec104b03ad4fac9bc6d61673c780fb445bed6c6da3 83cac99ef2be476a29ed5a3af28a348574576a086eb5ce2afb477f5ce5aac752 d5d7bcd8f0c14dcf5f621aa4f9dc1670efbe7b82dae76b43698fc21a2c05b2cf 019a7f813771d3f579ed6e3bf4722ae6ec129e1efc8854fcdff5c992a8e9710a 14 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 +generate_ring_signature 98a0d34ecad7f93a524bdd5bbf05df6aabf1edc86e6dfd555409eb9f12b970b6 9472ff1d85dc16f590c6b034169850cd9a7c61aa49991a2abdaf9924eefc483a 17 808f7fe95ba368b13e3b5f5bf8375263e293056dd4c0b946b15b6811047a07fb 8b7a69805ccfcea3c45182def8cc422c1f23959e156bfb4b94c5fa3392589454 d56fa8d5afe511e42e28e98f7e24aaed8fd49280766b40781ac01b14e402a94f f9e92df33c3a7deaef73480de48f287a96692bb05f964f331e86a7314ac3cefa 44bd6fe3e84c4b5e931d1751bdb85138dbc2497dd25ee0acb2340adabcc3d2ac 5e0e3b4e8610b3ad968c0776fe185d5821b440b1044c3cad601377b92792dfc8 701052782deb012f529a3fe3636fc4e6d4f3c5319c5727db36b7a76a634b983d f37e7aeda09d6da3b5f9d06dab4c809a9a70c58c9cddbfc81178cdb90be5d511 ed952f75fc7fbe0c454228ba22ee45bc4d54438d88e5544cd74d33c5e851e80d 60efc3617bdbc7957d8511526338e57e34f9a8502a8911684d24de2f76a87ce6 17323e276a428b2b238a5c03460a881ecae3ea9622f35add96322ef1b42c1ee7 9e51a49147a1029412502883ee90d0b683925d611e354913af570c8be1549f3a 0ea8252e6e1faf7fbbc70ed8040f9c57c87bb42876ffd8564032776d81dd5dea a7924de7fe171159aa57a7d22a5647f2e968396e6a4e424afbb070b98d0b12f4 f985bff093c1fd67d92b225d00bc4ae37ca856075940461b790c17c1a73debe4 247c72d2e0916bdfdaab6abd05ef5a877b7f175bcfecb8a499b59c6577b93e43 12ec03a07f4f01fcece9465d8967580241577df2d6da53db9a23f5257a62ea6f 4b9071d06ca415811ebf1038c1bad7d7a2338f82b500a3a61c0312d48b09040c 13 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 +generate_ring_signature ffaebe5a64fa21b3cae1f3c067113c4cf958a4287801c6a10ba0d63a82a16c0c c44d1d1d668711d4ccc3cfa257b24e2ee233322f078e4e6f82a17753e4f5c8b5 1 47d76caa6562600ac2e06caa3b861cccc17d73eb25df6c34308e21876aaa54b7 005c86d012510a55a17ba3300ea863c7179c91e876ee0138f8e987fb4d7e0d0c 0 4e79679fd2b743c8eb30398c0341d12e3041872836d382df1432b06df442080932d634ca472cc291faa3d57561daf4b8da4f8058e72169ccec1534fa4e2a4807 +generate_ring_signature 73733ec5b86946952811b69e7bf7ba5c37587c91f2d34cb2370d2b9be05a22f7 d8e042940c4c896d6b06bdc0fa35e077a07e6a39cb15c2cbf9ff5c6df99b1cce 15 9161d68233642bfe6035afaba1645dae605eb345093bc46f03d8f142d5fb9fb1 128cc56981de785308fc47e1edbaeee881f818971d65a8a2c0100ff1921288cb e3ddb25dea20e2fae36efcf1c8cfe7d3514b371157a39108f4b0e7609928c716 d08ed18856d466f1ef3f50e49d0986e0cc3718be4a5dfc99311070f7b135891c 56cd77bf457f0ace98ecf454913a8b6940424c0e12e183b5bd084c34122084a8 232fb54db3f3758c5329d8d37726dc8bbdbf44403192b6dccfa8d3783f657969 554b67d108192723af618ec6024f9167100dd252cfff52cc9288da122350b548 049a7ded353d5a0ab8661f1342bcfb123ae5c8369c8921b5589a0ee96ae49512 ea95222a7f00d7c6aff189b8fc0c3844e24375a511ea4d62386dd6d5599f165f 558cad957191b01fae7f274202d8faa3b5b71348c1ef4600302a84f112bd2f37 c046f7d11f1a0eb7dd6f25dc1e83c2ee571e43241fea595625b06b18180e64a5 2f203ef33ccbcdf41813ddd96364179f00d04ab0c475744f66eac76524dcccaa 1f427b4add5faad3d81832802e23ae646a2ae862c51575d6e753b35fc87c51fe 9fa5579abfc3a715e844651c5985800b8f77f4b2d2c1ec4168e6817fd97cec7a 56144586fedbe763b3b0f3676cae4e49507c79fb23b7ea08a8b755e70c46e634 5e508d8a5e99e8ce441898c87d40de7b4a0cfb2bffda4b57c89d20065c9c3604 6 588e21bab86c0e3bde801919df4808f87a8e58888470dae51e84988f22678d0e0cd9b3cbfeec9fcb7cf397c285092bdc7a4b9d37336cbdb0ce5b23277e84e50f2d21acf77e1c43043adf97b6f469d2eb7acc473483695654ae26f981fc11a10176b563133b0606dc1cf556a82df8d7461735717ab1b080db78eea881412bf301ce34c592801bbd5b6271c842fcc39725114a257474d6b749158968b96d9cf0020ae568273cbbabf2cb5d2a0a829a51dd8875e689479e5278ecfe01ce3ef6340e79f64f2369f9f08f6c387baeb9a02b0a46ccd3ccc1ef388b7c43cade99f92302df2aff7634221aa5b00d1ec6c730696cb15a95debcdfcec41b71c7688c33930010c183a6994a757bc2a2b92a2610f803d4fbcc5435d223d205460b569532a00476c310f2b178be1dcdaed154923cbc437fec882c49a5e78d8f5687880a22470404c66da44b25903ce2582079bf3e8ce1223886fd4ff46e3ea9cd2d8266b2c201957e90adbda51b70460387348ac700fb151d4b82952837f23bf1a641e9a55e0c7560fa08b4f41dbdee5231222eda2a1213f47e870cd48a38040ccb5fe407210305cb4bb118836e978a9b93669ca7494ea5fb62004bacb3bfea65ba8106b3d3095bbef52461e4593506344a5f9709ba59777bf0e84cfe7b1b09e60aa1297b34034055c9268589b9331a6d7d6ae1890cb4fb1804b02665b9a1ec9113d6d4e6240310c60f144ec333dab57414523688bf2b24aba24a644df56ad3404890194ec402f2283359fb524b26f20f351bca9ee0b8c17b2a9d1b5d80f6f986a6afa7225b022a4c9e161ab17148a6c6bae7977398999fdb184c5cc07d83a63375bc8e46a30aeb170b4c11c7bd7c29e43231422061875d28497bc2976721f0c0e9c07218990840f7f1f0bd02a730569450691766a1da0e81a6d87f504d2934812a818cbc0c03c98e53fd26cff6d37080463c8070368b3565d798eac0e495b65f48af612c9706a3fd5130aaafee562fc7adcc68ffd31012ed98bd073299396a6d51ca12e2d30a08dcece0858cc80b392213868de96ee757e3ce85173367571000a31da8e188021c4115b9958c1dd464307d84cf98d184e49dae66f0287355375b04021b9df50829837e9aa3896537f4fc6896fd2a2836dafcbac08f2aad4e8ba563ba5ac8400eaf54ba7e66595c5b9b47a9ad69737de48a95a26f18dd03048096d5b227185c0d35836e59ef54c28d706d36ee6c075cdac456e2eb6ecdf67742ae71576fc96d02b1ccb339d0f66eb52971bfaa98514be4480f0805a4860b82ed15c909210aef0238991474bf0af9902e6b19d3578af4a16a8f787c3f0f406fcd2db455d7bfc708 +generate_ring_signature 778bceb8b14ed5f0f51e4483bca6ed959b851aa5ff880a59320d30d0e9c9ad06 d8508c6187929646cc7231cb18a959d0c181e5f40e550c32ebf11dab277cb36e 2 dd0e07b025b266a88482d72d7d3122d2513b11966b5f86b0b3190402e30343db 903bff8f1f2a393c6f31dc6672be383ae112737329059fc46090bb1a9d684c1e 4a41c53827294ab03c79424b60a5faec6f44fbade5e01d59228680eeb4a00203 1 43df753705f56eb6195fa39a4c75c47a842e32c052f1c87f84bbbfd5f82829066ad473225b7e3ace27666e293cffa7cce1d2889527388c8970bbc53fddf21f02d78635e8f92c466cc7dacfa5f21dbfd695e1744cfc92d0f36cab18e1f5c48704479596ebe2d5c2e07a57ecbbf4febfd751ef2c9ce62eca04e5bf1f271c833f00 +generate_ring_signature d0af946a7168a2b284854db904594d1ad9055cf337f25b80c56f218d3c0d8dc8 ce5be5577913123659cbafc8e7fe1b31227e976ec379307282605e229aba392e 28 b5bdd837cc0aac94b3fbcfc27fb023126a3ca0308d6f9ba22d24322d5eb01d57 e1b478d03240bee41ee60b3ce5c2875637836588696ea197fa4cc240d9f6ed44 4edf95184182c3034efaed72684168f95ad8ec6250c25b075f0912e2d4f63459 1e9cadb7f1407262d64ef55add50c2f6875160c2fb645c8c8ac96d2605915e77 4d888e5b483d209c20b60c5e5601c42deba7f05592ec656cd665576a0bd3f742 bda224dc161b87b51264856b6478fd355106105b80380ceb36d2e18e5981e6a9 37f0548f3545620b3ef1515fc5b522bccfd8b8a068598495c4d2cebabff9cc02 e386b54fa02234238ca51c9939d2e3fdee81abcb94853f033c615422babc8f63 4247bd9140878709938dcb0432c0ad95159a00c66902c004d2ea09e2335cdee3 93ce5626ab90afc7f16c8fdd870e9d3640407fbc4c29cc12c11108a852208774 a68380092c8ba661fb24f30b21d7df4b840dbe8fce869394986c7ae4e2edc0de 25be966db483ab07c610bdd83a5e26019a21c9cf65d582d3aab40025284dd4c1 ecaf62457619b1c1362b35dece2209aa5eb9ee8cdaf59ae1d5be775fdfa987ab 5ba393fc4c396411dd2e3e93455b31b17037e14f9564d9896de7455a1994ba29 16b37fbc30dce9dffe460ded732c588b2a863563c0d724cd909cca18df6ab50d 4e97f0370be8608c175717e554f34aa4610daba6cb16fb96c4136a57ba230b9f 86244bdecbd028e5be7c98b2d347e79647333e71784a584eacc308c094cafd2b 25839bc668849bfe64fc9be62997fb93d1188108f7565498c33f3f4ea4e1bb23 429f58dbe7f3eec5dc1bf30ecef4293381c828c5bfe7b7d7bdb6acf942cf858b 2e852cde3f41675c3a1aa901653dd6f91229fb5349b59b95a86669b806ad6d49 b0a6aa5f72e0b404b831b691b29c810c533abad713128efc640b78b46b8bbd6d 8bc504d0ccfc3d825a1de31f005b02e5d7e8396b213ae78dee2745ba94af12c1 4653b7942cb6e119836df837d39f7b43339ae6faba28856d987a50ad2794b292 454a9c491f09eba303fd689918d9ae6ad662f8adf029fb687dee072d8809d26b 861cd74d161b68c89564fe7621ed75778aa4fa86bcfd60b981b8fb5dfdcddd16 da9d169079abbd9219fc9d1ce674378a218433cd3058d7f48e71891724f8e3cf 90e52c87f417b04bdb42a50cd4344c89d2ef87d722ac451d8ce89cd148b9a69c 6226f09a0649ce2c264d056d3dfdc74cc8edca34091423845c78bb691bb6d89c d06d01f7eaea9f5aa3836471b07f66cb15f9abf5191f03245633a73abac12609 25 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 +generate_ring_signature 32fda91fee7ffd86261cfba41936bb2a57a1babc1e41c93bcce51132d3e9b507 faf0d72af0aa2f1935f9dec6852902445190d777581a778a7e1a92c1bda327bf 7 6e89346180becc891a370752d14a032274b762a037103e634b45bfac60809226 97d5764cdab85f5c11a86546a36a96bae26bd080c451ef596daaaf5ea684086c b60d1e57e2d34be3512e8a2be4b3d00ae2fae3632b5f9b0ee1c71705600b1c0d 3f10de099eee553e1b45f8f68a760d6516e2690ab993b9bb75d57a09a0556f70 070eb1a8fcd9732847154aea827954d8eac4034de82aa78cd391ae8c8f395e19 49ffd7d2431e8db5626d37d6220b630a431cf592bd72faecd522feebba1f2291 cc1127fab637befc072b81cfc583d2d93180133cd0ead88efecddd89bc46e4d6 84eb3ef42330604ceff1a7e02b17de15c717f1a904f34db6c724f1702876480a 2 a71ebd450b921983dd9f5012c2be6fc8a84ff7f1c7d5774da045f913b12e400bf3a34a9c0177ebb9bb6e4f5f7985c4ffd8e9b571510999fd6bd9c3f74db30005f3d0c2f92d79621d2e796cf82809fc44291fb86ee5a297a191dee132f7e394000f90c61e8b7fbff096678e5765b20c42f22a3be1e053dc0e6ca4de15e9211b04319c811242b5814e2b9d8b9e77be1e2de1ea0a793e7653e36a969996661d5704b4bcadb0dfa0a0f5e152a216f7c2a4d5aa8ae85f113ba7ee9e8863a7edc9a2059c1be1bf081a5f31c981930cbcbcd2790fe8ec1cf00f5022ad2ac7fd51c1c20b520db3d9b5d6f30af2ff2baa2cdfd1984a4ba744922688aa8b313896b547bf0f96854547f981039048ea97a531eda340af60836ee79eaeb0c275720f4e8e8b0aa724f4a2ad75c3e305be841597ff93cdf7cd585a898b2e5c216e78306d520e04ecae7c883c256bbf7b0a451bbfbab35df144e963514d9aff4482259a6c5214026931a8f2c1cba9a949e63087d4133f02d7d0d877e4bf39eb79177a43096c2a08c8c845644300f1ad8b253fd63b874e4529083ad6661d9ff2902b5552d113b30ed4a6b0e5007f2103e2dacc345df4a3ba534b7023382a03a4d7bbfd4b9c93a002 +generate_ring_signature f95f58b92f28fe5c8cca37b620c77466d564444b3c4b27bda95be071949ee7f5 0c7a668470179291b39470d30af192a98277cd4c831bf6fe9f3501489ddfd8fd 57 9e703ea6f7136edcb82cedcbf43a68c6782e8f1e57c5c2303b4131d1d5215b78 2ca97ab38e7199a22fa6cc16ceb84711e9f2a41a8f997386ce5b60332e752d32 15cf730ebedadf9fff98d1d7c42b42328259a37645d31ac52a1ef24d67208fb5 bd41a6107e68625847b3eecad7c295f58cf612069e47eb4a713f707452687a1b d95b91d6438f3fb2cbafc7977aa1c84e9869cd78915800f9560d3f0274b2accb 698db750d8b5ca89f0a4b0d0ced5f429626aed733dfa772cfa6833c2b97fdae1 4cadc08cdee26ac4f3f3cb932ceffa9ed5e936df7bf97492fd07bea007d5aaf7 5ff610158afae988f8cc3731b3f0613d1300df97a6822626f845d8a73f14d839 46aa6f92903c682a2897c8d73559f1db32dab440f857d9d3bee4e098fff99656 20bdf6ed73381e3da67d3a8dd62e82bd51afe2f750b7ae124b08583c450365b2 640e7073de6dbb3a8d8497c4a3f9c60332b485645519b2283a238742da08fe46 c9572e5cab158cc073919303f7c3288c2245c49de1129aae637b38c5bb62303e cfbb23c7d6ddab8a249ef1e1dcc823e9bece5a2eada6ab13fbc1242131daa612 8afa786d231a0c09a13d63170fd8226330f81f708147a1f47fee7557ba27d3ed b365ca81fdd650d274f1ea94c492a4a65e64adb7b0fbb6de9528782a3650118c 10984b7aa7bc1ac1e54125f0cf87f802a9d64ef28ebdf3dc91913a4eaf8aafb3 cc880b625163e20cbfc65210c127325e4b3a17af070d1b74126c7227bfb6d065 0344b564c3e1b91487e607626636a5027dd2a9590951f55647853ab8a886bfbf 5c568bf19007ceeac73bbb66d53c2cb062eea710fa82590f76da6845517aa8f8 cf31e75da46ee36623789933c452326df8b33609ff549b6709bd747f3a973ea7 c3af861bc2c38f2d94889e5738e4a756b231fd38b39d9fdfa307a6af6a26fdf9 3dec71fe173c27b02df24e8989cf7075342710a13976e63bb740be0ed3cf8881 71221e35d8ff84de6fbe8a8a23a6c94d4a2e5c9dd5e0806c337b78b40972d968 7433536546f072ddf45b1cb55fbe68a3c3b6154b4f43540974df4c96c16df3ab 62b2725a6f4ddd4e5bbb0728efa86630b41d8ab848d746f73af95767fd57fcec b6f19566fde140878f4f1fdd0f64ec397ffc1ecd66d780af774b35ec329d2139 b1e53d524b31832419ca5ef8960245fcaab7cf1ee7211f3de92737fcd32a2256 156c9189c4541514c557e3767e3ee07429b397cf1cefdb7eee9c978d1b11f6c4 4babe5081a6e5a1dd8ea579522c8f6a44db64bd48229ab6ba7f9758990c333e4 3f6ee7d39a89bb34bc68f02557cde48c0f1e4ec9654d65bd704637d16fd26721 4512838f751891c81732898eb640c8512b6a77cc7d63a3e61ae0827b7f710627 a69bb4cd67c4d72585a8d3db4000429a3ca1691f2da44e01ec0113ff72dc895e b737c73f3572c71efe7cb285879ade2b174b65cea150f180eaa17014d7320cd0 7d472b19d3b3a828dd67749dab91cc686c0aefeac6f10b021914362e9e3db34b f6158b35f8a7d3bbc700d39c43483aa57ce38c8e6ca1195eeb87c673e5c2eb48 5dff3f8b3f1d276f142d69dab6f425f4f78b1a18182d1ad207c027114a694b13 e54fb93a3f15286ce5f2284f284927eab88e48b8213c1a41eeb586ed999404a5 7dfe099cad93d510b49cd166c192e813c3e512a62dc4ed11d9b9f781f0194c80 773cab6f26db9c2c36da474052966fcafa308ad649ceda337f764428948abaf6 aa7946ff4d12c48703c04f6bfeec86d18c4a854109739b3863e4b5007999e2c2 b386b4f889db963dc4daeb14893a3b0b6c3b09a3920a1bcfd04dedd217e573b1 0726fc793b0c7493cc0439189bd82d5d0c3dd117b9aa33d6a0d9553de873e88a 93f9a1f0eda3a75467c99b01005ff16a4c8b006649f77533cef185c4f7a30b08 377b1b8895d0b601d45a5dd36b93eb460ffd9e30a0cf1d96b91f7f189f4d8732 5730b7cb7e779695bd04de02fbc180f8a7b1a7e6d0fcc066bb28d4c94b3aa021 548678ab5e2fb6d870d6c05e39b3267101011c0a842f373b0c9735313fe7c207 788e4bca36e99ac9bd39e7e4188f88b78dce485fd8ce7408ab5d5588a82eea61 c7fa217234c15a4b2af0aca4ea58af4d3762dcd3b17a7be13ad882ea91539416 12c3585925770b39fe686a8d04ee10251d504c94a6c16853f7ef1a6f0a525556 f8748feb866849ac48f120940c6731791a593e5973c9228693397d8e3ad65268 8bb30ab41ee5221c65b21919b8a784de26c55983fdaa5bf635a1156b51213f77 70a7fe521146c4e2c6d0673e9e31f9931c0fc79d516439422dfcb86cd52d6497 a85e0367501bb37a0c8d92a311d3b6ced453790b116246c9c5b7a3f6022d7dc3 062fc5d81991c3e216ddb0caed6fdfff321d73c2c5fe54b9d956d18cbf7b7c53 fca490659c54bb57d385e33e8b67773bc912ed88506ad07f33e4acd1444ff692 1cfa1c7683fd787875092bb812b4064d0beecac871e1af17e72d359f27e2d87a f2a11397ecaf7753c18f0a6970da0573a2804bfc4f48c099b29e71ec6397c2d7 25a78e09d6d2bbf9431db8891b048d8429eb7768ad2fe5f2482a76e03683e908 5 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 +generate_ring_signature 3f9d1e8c4afb644f791e59e8cd50f02ffc79029629d27d18462bbf999fa28537 6b176e3de6c8e0d8fabe2e2552415c02af6c8d2352d99c208af199dff42d0a89 1 0870ddc2441fb0194765bef22a548260bca7fe9f8480a961f108f601798dc115 8c1cf72b82661277cadbbedec6b11e35f7bf100ecee3cf1fa9dc46de1d9d1201 0 082136646f5d8d99f59025147abbf5ea4a671b01ce0f418c5d2855a88f5cba09a423730b3587e5ed054fdcffe176190361bcfb19ff8aafdb3f7b74c064f74004 +generate_ring_signature 21021e77c02b18cfd15c18a1a6a46fec6a5473f49fe7f17f408c9c5ad3bf9f77 b34901b76b34408675b429898c4c3adb74859e3577bc512353ce51e338bc1b80 7 bf6aeb0c9fdc617e09d5fb43f98f77c0e4db61b442411f17612d8f7d68030d8c e3134f86f35ff93536f816ee7c71a22658f0922dd6d977141fd3251117adad6d 0351df4a97e005521dfdae09511278b8789a7f095ef151c134fda3d71db05438 31ca8ba0c25b68cc7b0cfb6d37ceed81333f87469880e8a4dc431daf9b3213cb 12887b59f4b5af889620abf19a52a7bd1973e04d7b949ff683dd3da922457017 2aaba178d00eb926ecc67d750d6ce2f10402e59cacf46e1d60cd2bd2dacc7c06 ab66bb5959bfea90f0ab7f1d6c78b6e380a8c91ae5b77ee24357abfe128fc625 9e682a0ce957782de7ecaef9010f9bf77483a51ad18b513a8acf4ef2c7562600 1 a451b12db182e2cf259e95937107c10bac6b631b4da80d62cfaef01076cf3702907eb478cfbe336eb433385ae9342f264a142be6cc16f7dfb32b5f8a5fdc2902d73fd5dd586cf7b1e657f004ce85ed8e5063dde75c2a64e7854ce9cbad66c80462f76732e094e77ab39f571cb2a43820619c374b179249d9124df0b3b451aa013e00d0a83a6ee0a9d8e6c1f3277b60d90efe76af0f86b10e222e01ba2e3c4502e1452c4c9bf630730c3f328a77c047c1923aa4529117079e99df869f3130660f39f633527c16af9b521068e4df354a6eaefbf5756f196df4f7b93f90d046ad03937be0e6d35bfe4b3fe9d6a625b257cfc83e4fa875771b39208b3cfd68b3c6095ff30918d149a3bf2bd4417c3dfb06b22e536b817e227345605116b153e0a3087c7cb67a94405025aef068322df11132ab228c46df0c34bc98942cf84bb02c01e5605072b4080d39e60c46f7493144a490511dd01ba081d39eea1dce58a46203a3094532097a3161f3b9106645e67f4debf15960202230c7cb78d6c5938cbb05fda3ba70ec96d4059ac84f61e7d152c1ad8ab60c5282441b699c9c2f727123084f12d83ff39c66b90eb41a404ba162886b78117bc834d4590632266b20adb303 +generate_ring_signature 953630fc2044cd653f7a0ba4d3413eb62f6e17867d2a24283d65c3ce6318f887 e901f99a3e172a3f7de853302c9ca5a1ef79f5762c13ae654c4259e8cee66e33 4 de453f88739ae0d8339d5176fee305db6c4558ba79cf29f7cd9d578ed6f93f73 2662a16a5721e8273db4eba161eed7f6c55372ce1b57ffab8347f94ea937ba77 9b838a770120cd96e91ea3753b6728aa50c8428a6bda2dd55ebb2ace9abefb72 7555929a6e983390a6d99b9fb21340bdea436104456f7345e6319e772f17fa82 47baf5064573771c80e48605222461043b10259e4b1d5ab00ee4c5109eaf0509 0 39b5ff90ce3a062bbd70b4ee11341b7e97aa31b7aa09ead59160cbef81254e0523623ba3e00ed3045db3b505f3eec5bd239b37fe944d2be3b4e0823cac7e0f0f398f419a235cbb36523c113d211ca539e5aee6d623ac2b1b13731ee0c2be4001e065dc32623e96eebb01e32abb8695e5b7f0331498f6a0f725baf15587234e005a9f0a75fc1c418c26f0dbfc94fd80534b9575f1e29aa1eab32f85d86b28cd0e1cd72900234eee3a1d7999e80cf3e2ccac676d9a59ad71517f440ce90c0300008f37a6a1d366322d573d227c295ecfb2b2a902c7a04653a75a58064e70707e01c5fe94837e8c7a18aeb9ae9f2a957a528933f39e1c2d1c544fc4a5401df0a906 +generate_ring_signature 389429172b85700ef011454e82461e30d9df22fd1db8366c615775683e19d8e0 999b6e454561a04399883e2349d36225d208c3426018c8a5140b5ed688601c1a 1 ae6e602587bb3d69854b8ddc46a38071e6987cd8dbd8e5317bc22ba20e568653 1202a2169995970dbfd88fd2d6bf35111e1a13e6b0f32b8bc93d3b0afd206804 0 6e0e7a04af181eb79f04776dba2ce356f1014b3609e9f30f0ba8ffa6ad9f80021d3e65ea14d91e2082153ea8403d2175da81c0b4a90c52a0bf42a954ad968f06 +generate_ring_signature c37605f12deb3cc9723bfbba6a865ebf42b6f55ce8f3d6f097771ab2b354f3b0 fae39afd0699fbd2a2ab9403bcde544420b66224cba89e6ef4bada7ec9f7ddf2 3 7f973eb742664756b20e8dfe86e1e12a62ea6cce44e987474d3f0d5fd115da7e af79056ddd39d65eba37874cb91566c6ce0a60305380f8007535d2e7dfd7d8fe 720f9e325b8d682a17ec1e8c9d118535f2102e9e03b570f5cc74b50e8ee1d12c b57bfcf6db2519fcc43ca7650cf3248d8385e5cfa280d6d90dad4b2154e90b09 2 d29f3ff67e8aebd7b4f15015eab2647e976a4ab7ca44114fa7a20d998241c40065197569cbea57ff4035dd3962bc0441b2c04f620fbb2492b56eb8d1187dfa03621dc1ee23de16523682eb167ba66486c86637bb7de0f3dca69a205eeb48130fbaa592f446ea1cce0293ff92c2ab010c78bfa216e0f623e755495949749439040d835ffae4c0dfe8e3e3427793b4d6d0eb359442d9211dfc5e66450f96d6720253bd827c746625dfa5467823eb089386979a93421794a1296dbaca28f193770e +generate_ring_signature 37671a1d249e1788e7c6193b699c5e54f6be1ca35714a3a3e4bb5f45572c01d2 e0e86972cdf25612d13ee325998e27afe1f5ca20cc558021bfeee6b8437062d7 14 f41482621e6d7291ee1837f511206f285589e82270c54f3528e9188dc39cf6f2 ba41a5e2f314fc05a8f86861c2e3a05318556814c9d209e4363e363476591f6c da784f4125cab4638fa28b78a7e1040b68b0f4b782bc53403d9b311d1c8418ee 1c765f10d5c8315d648a1ffe3d3c81bfdfa6ffd0e32935b3f4e63f3f563afbc6 107c411025027e2d443aef21a7587dee87fcd8d0201a679dbfdaf4f2ab19a2a0 67d5eda8542bd0951035449c08bae062f28a7eae03acbd4a85c70e98321df6f0 90ea7de0f1638302ba6017957756f60b85de1f18d415b613c0c7c9d1fee2b020 714f410e3f73569ba9dbb4b8f973b1432cd573d33d24ef35ae7cd2f7ad385cee f2c0ee9553a23167d0e49f274abc2dd3976c1cfb91ec2254c8c88477f46ab46a fd5de7201cc934f74b307d5f5f63758e633e9d60fb9d3eaee47f2fd2856fe9d8 086925bfc05dcc018b7b0494d8743328f5dc9b7d6078c3db4f03e2d8be5e2aca 8fd012389212df1806ac761c9a70f1e358870177b639ba7431cf708279e1b77c ae9c72de597032207f452e71b0f4885a4ec933c9908068b41e9a1a5d08eddef6 668fd60e30f1bdeb678c538fb5d94a1836b1e038f20409c6608f857dd3c47bcf 1a128edd23b4090c4eb20ad7ed850a3bbfdbb4bf0ec91066d34d3b8d90433b00 4 227f08dd869e69cea8a82c55730fc389a7fdbb4616616702a9a7744f6c40f101fcf01fff8749d09327d01d9f43555c615a46425dbd8a9a8d84fbb5a6e1adc20b77a98d02443bc95fd1dd0b9fc6a993698db53dcaaeb2b36fde8b907a971ea40e7be2bb93a0f6b9db81b8749bd8ed63e3e913b51d57540e731e600aa41cb27b08324451405e27082707af1d9a94c2dd35a44cca16c7a03d2b0a74476aa675e20063c92b8e3f187af70e52f6dbb5be071a13b82ed7920167c6bbef74605869a70d3e3a681f05e065429f760e04e4edd0e2093dc402266d77280a4f0ac462c50d0e1198f316c354c0280737072c86e01dd92db04515a4730f2b82c3ad102a96ed093198fbd9b164977f7469737fb7487515ed435d1e669759fe58637c197b147c0d696f617c0d1039018cba398ebea9cf82a3b54b795d7cbd2b48c75bd230d23d0a32cfd959a4468b9fb173c1da7ec13d418990c9e428b43bafa08361c86cf3e90a24ffc09aeedb2f37440f7f47b1f710631574d12038547b9777d4bbfe960a6006fec38de2c7a6a648c96dfe0a69535d2a645a584c93011ffa134efa5b07734f0bc55c960aa8677ac168a7e270c19d50cd395e42a3998c5df8a6af738b58f991005d1226172772099436eaeeaa155f823d9f0b7485a4e77db908fd19842bc4ef02ac356b916811843a761cfc9debb9d73eaaeffd5ee37818c6a0ed9deaf383cd0f6a07c301d3b2dbbb85aa97489f47f4eca5976fe6957528b61e9ca3abd56601029f94427e1c2eb3fdb42a76244a53ad4c0be74fcc3c839b1e499d2349fd4255069b446e437a649a8dcb1804fa0b31fb5cfee9c5a86c95ce5349aec6cd8202fb02212be0b7af075cf677260f60ab9c45b441ce4cdf711b7bcc6ae83dcc9462f10b902dfd7b028a209b6f86327e1c5e43aebede9ea38b4833356ba01170ed4ca202863b1118d8c7d11aa68cf3d9c11b7d0ef47f0afaea54fc2c3917f6f39fa52c0cf83831c2627252336c4c18f5f2b0b3f84d59f8098c88ead35561fb3b6a4e09032504f8f5437dacb1e5428e7538fa7d1c5263435801f84febebc77898c0d03100769817f683565704cf34012cfcfe55746ff0fbc93845cb38b8f8b51a75207c0f916449029afd11627d09116472548de7714b9577fc6f2f6641a0c3f67a34c902e5a6281622463b17519112b73721de2d52492e364f5e4b2ddbb2f4fce39c1e0c57021c93fa2fd5f2bf2af02d59aae8172ca12b590317e9f78a8d78f62729c204 +generate_ring_signature abd653f7ad7fd63df48ac6a7e0192cd459c65a8240f9d2cea3676a8bf574d3a3 4ec5408a2203919766e99425df38cf93d465ee4e7179d4140f743b780950f7ff 127 f7cc7ad1d5529686cb49d9a39db137ad1c4c480bad36c87e9874db399df6e2cc e5603615a39caf26768f8f006d8e7fbf75559d8f20f1d668603021cbf5b06ede 35c398f97a395727bb667e2d1b2e4ee561ade6cdce28decb955ea40e3dc81b19 39f7d4ce324bfa1d831a3ac2a26784f4d9858a1a7ee913f0d753560f0fa205c7 3a70187619d98252083118eeb6c43d9f23a441d081c06da5cf1538ae2f514b46 324c0c07fbbec5cf493db7a55f4f2944a88d66fa29495c17d2ddd7beb799a981 8246ceac0bfbc5c3bf76bf1e188c6edfcbe7e8a8b92c0930a0e9f6d7d9bc4efd 46510f6fe33f0246f667ecfac5e9d01e62f9a675b3c9b43267f7ac6e9e055eaa f0531b6c747fa76dba4a033571b5adc2affec1d8ee7c3172aa25a35643118ac6 c3080d681c17a1a9294552e508fbc3a0183a17a1e2708fe32552580a44ea4cd8 dc56dfdce49cdb9221d288b78779a6bd84c4cf8e3c5d7dffb0c5ad507715f174 24b46cc382e88800f74d1eb5cd8f81cf60002b5ee67fdb2f7fe69aa3f921bfe5 28672e60cb393cd812809e8092b639c73e81cc2e0f8867bb2f136cde06c4876f e1ade5706d9f09a98f177a310cd7b8cda1bb72141283205abd27a1db228d8778 be543df678f6169184ce2ad48e7830679ccccfc52a63f8feab3d5ee79f0c1054 b464788b8d9c73bfc942547d9a2726e2c63106f18e322f9b690efc813c68afb5 4fa40c9e5d07a7143203d40e401198a589eb8751b4dda6bc8cd1681586150590 ae63e7c95e21ee618a4bf5f51a9bb1349a56e13045c1ffa54d51fa732dc88a98 788277e0c0c724a631417c4caa078aadd6dd7ccce6a2dd3b6126490f9cb29b03 0e7f64e648f936b92ba48d50f642d4c59bb972837a8d0c698ebd3f6e8d834756 8c9b5957c1c93c492cf3ec80493c9a2ca5c8a296b47c45a6ece5a9c1829249a0 8fba8d91bec11803d4c5762227b2a87248ba4f468c2ab1b4b99d37f605b6c942 25d297ff24cce2c8763580a2cac0775cd77a4625f877b6ac39bf8b8ca06eb121 983429fa4e9308edf662f138a32bb5b5d667fbad795482bba974751c1cddb922 a4bf3f834a9f55d2667a98958618e667207557636d212af92a5f6334c812f8a7 f35b326077681c3290f31fe27fc154716e58b7c9913a77cced12a56d1c492a9f 323c052da3cc1228ee8c14a16ad1c955df440e58cb9811673f49acadcd111954 f01661bdeab726471018f51d247c872624fae8e5cbf34071c49a269957756e0c b67dcde3c5613b2b3b599264f06050fc144b0beae6e234830548b6af5a4ccdf8 38af053d20c292fa28d084721700d138b911430c73f397ad67cb878e115b2beb 27c40d8f771f20559e775713e71ae041abe5e1814e6631ef3eee841539e2d262 7a3a321751c2b1e32dd96af7d33d60184d8d42aedcede75d4e22c9572771d6c0 166a8a31964185aab43c20927b122f4457005786e3d8594cc5512ff88f6778fc 37d33c370f64d5c21fcd80739846a39fad9eba9803afd1e3c3db6c933f600845 68ec83d3d23e6054492ea161ac9fffe1a42ca54f28038bb1c42d3b7e29fd333d 5384f0857de1ed5fa5db5755828eb4e117465dde04a15a90215612782e29f4c6 f93dfef70ec9bced9b7830d6dbce44c1aa4eb671d5ebb3b815d654224db90f1c e386cfd691fd2c855bf8a5c86ccf228af6d9481e38acf5cfbaa9d8accdb6f740 9380536decd8199c51bb9cfeccae5b75d423f18e1de0651bf9419cb9b484084b 4689cb44017f37ef8ef63fe68d4ad26018e7beaf3486bdab9c6c3c459c3e7835 2baa6a00de237bf2bb2fcd3d106601e57f33c27a1214ebb317f53f20052bcd73 c874b88ba9c5e2ce74996d132be4879f2a589b21efc30314e80d0cfade1958bd f1485b76e02c7e9b402c577182a4a941fd4c60618c6f92f7ece4f1f03caf723c fbd10d5ffeacac15e16cefc049ae124ee6dec10c66b6f5b62bf21d8aa41acad2 f48ca5d7ac83ea3e8d9adde2745fd6f50fa7639824db2b311bab61adbcce559d 0d676c1b31a9de877928419723a5eba5d37b2378d2b3d9e846b6cdc865cf6f6e b45daf0605d323651751912084602a122b3a39611bff1cdc36fd74d882e17201 0ef240390d83a22f5e7b9685545e94434d7f667141e55e9344d50753986d4a2d 138d36e66f4cb547e3d2e2e32856a10f04877cc45a4d94d2853c7ccb9c29a05d 3c616b6f7303de221b0eab85a33ce48ee0fb91b125b69c2bc13bde24316fb146 c808d1403d310e1128b18554da2a8dff773e7711104495ae2d4c4cef80c4adef f00a9429229a6c135aeee20efa63cfadc5cb264f965d5bb99c2622283688953c 9f763318111c6e949abe452fc29319e2c0cd855ef13973355a458a3b7abfa5cd addc8266481e686f0120ac9537d03348a12823ba9ad2064c8fd3c056af87d9c2 9e3163d748d6fea21146280df9c2b01c6b46300a40d5d313749982b94caf43b6 09daab1f1bcb2f17d13c0ce3024631c834b845ffc29656cac32decbdceb36dbf 966e9351376dd899b4b8dbcae80f03764a7f67ee0d1c883ef1ecdf62af6a4c70 526b72a160bda748d06fcba2acc635f2370c642defd1c19280ce29111912adad aa37714f944dc1ebb4a5bff29adde7ba2b3bcf1298930cce423ec8bb71b46301 7cb9588e9e2a967a8a5a1486864106a667a277e28f65db460b3086772f06a97e 94fb2fa586d2e0850db9c6d30b4cdabc2f2f12f59bd1c9536fab74d9766f134c 1c466c9515e20c18a56bfdd03bb7478c965a7d12d702d7d4957a63a560d10266 609ef0ebd972a504c818929e4b680aa2d3af312353eb0f8c886fce2c2ca18434 102793b591bdf4a26d4277b57abb796e5066edfc167aea07ffa014cb58960e75 4a94b3f8577cbcaec6b0dbee10ff8f66320707497543846b19aec8f922b4293b 6697ad22d8ce84fdb5fc90cc5af87d5d2d962de46cb53ca843e9938681484d68 18457de093c4a00394f250ae8db6cf086e33f6d5d14dcb3040efb86b3a3f0b04 aa9742d9efbda738d62ab7625bbabcf258ce112757d0278d160b15936abf3cf1 76bc78c14142bd24d386b391e510a448084640fee6d5c89e78912563a30c6082 5a31d2c3cee04912b6bdee1af63d791bbbb9895c97d40f64268d429c29142985 575e2c99943ee27d8962991068c135d934f8d7189ec84114dec86da9f8c86d7b 653841686d1dd0025aa32fc36e2ec002f602d6063433722d32b438d5e2d75319 522bc0507407007529b25d2eec729a59c0f60e98373a0f539aef20df7f53ea69 67feb74336641ee284e032ecba89e02428d2829af28d12b0e5bd9376a60be00f 3c865f1ca2bab0db4eff5eb9e4108ac90e1b33362d43910ed423cc670035f039 d6e4c9d3d9d3d99471e5973327d308fe8faf93727fabfbb0f748c4fc9fba82d6 d70a8e2810c33e4f5ce14666e6282b71db8ba4b4f25984761a61bf21a80098e2 20202ef0bd6bf3faa3dd42b314b620e15fa03cf525b7fafbce8b1f620c86bfba 8576732069b9c355cf922f86b90041baf4d4d44f79055afdb35a958f8ad9fcc8 5844694e707777f2f9499d4bdf209fafaf286fde9040b51657217add3e345bd9 ebbe61e0c6be3cee2b8f2825806423b8368a7f649a0c842fe537873674061d8a eb676ad1281e502de98d3e9c4732a095ad28db45c164ce7893547fe6d776cbb3 ee6ae2f3a4e2c55c347644afd43a8e3ba646259a4939ca5d0acba778d05249bb 377de8f232e2702372e38e93858ae04ee8729ff65a76fefd8b961e64c4eba497 a0ed9e2d5ff4c1c414edb066792f9026692e49855bd6f0c3d69a1ac2413feb9e 1f6c215399aec9b4d8bf289d372c2467f560896aac9b941d3e3c0646c4611f79 a98c0268b55e338c26e4494a4c8a8022d9653647103a0f1bcf91dcd8b3ccffe2 7ee898c856b5fdcbf8003dee310084f8e5d7553febd3d4d9a4dae9728ce7d8f6 e549734c11a2460d6a99322b248dc590074d36a74635666c0167f4d6455a9b10 801df1a8e2aa0edf9d00861bd977b0e4f5d369c182765852539e4eb98d58d9d1 6b17009bc4da1114f1c40a128a5f9238a5ff65e43b0e3ea6be474245c63be927 86a0be9a8e802b0a83eb58fb288e8eb0169085599fabe73df43d98dd538e4fe3 b52cc90b3082ea8bb1c16f4398fa9852f1d7bb3984701dcc59403ed0ea11756c 2e093e60b05a8dffaab61ee017987832247f2980afac47bdf83cf4d4c9b09fdb 23ccba870003d977788fb87907888460551f208dec112af68b493e339324fba9 4336845a60783d068c0693181b155ff8a927e2ade96175842294c5269bba5fc0 885cd6d8605166246c5ab4add221064ac3307ad12cf0d76961527722baff5b45 3640a825842e15ab7fdbd183861ccde121bd494d55dec192307f6e26d7257d42 51e8532b10c76386fa77df1f0972770a67b83d877946387075f159f58814e449 775cba5f1da6c8d6ec21a32821189f46c4acbf8248b236b1e14ae4550607ae54 6a4853aff074835c48ac5fc3288f185e2ec3888ac41ce5fdc6d7b50abfad9f66 73789c6ec8839b4003a2045a47c9602f75a55fd2632f4c1e9361f939178ec98b a548db9423100cba74cacb67611f617ba18b0b65d29fd55ccab9f81a0613f653 e89c5116940301a8cbab6c88056e479ef6ab6605b0ca9cbdffda08dfafeb697e 77ca3397a46092795d90efa06d1bd62da05986b7fb733ef666fd387e39dccb91 b16e1b9bce92e7e72834af0964871ff655d94223f297e2a916bc054b0c4f8a73 b53dc02837033e165910df5ba952c0ba9c3afeef594666dc0994bc8cef844cef 16e983fa02cf9303daa709d001566d3683db349cbca4ecc9677f7da6a6a873f9 dd6a59c284336c7248af37f73cd62638b4a1126028f3088f7809093bb9f40c43 ccebd0ec548dfe03c8576949bff066db53c08d2ea96fb7bc3eaa2e35bc4e549b bad4168d208766a192af7fbeb089e80fcf3ba50783063be866b2afe7f2bb392e d45a233a18f241b0ebc2e27342eb7d059257a766409c5471a725cb13c4331ae4 99dfd92c18d6d113ade3042702cbbd6bb9a79c0c7aa934fcba3382c31dbd7e7e 62ff7d2b14a161f835ba981bf2d97470a2df1438e2c1252441555a898e1e0aa7 ae772f8ce1d252f53aebb7307c17c4e0e7d62f419acc3a5ef596ac80f5f95d49 95abfd3722194601a8532044be8d20e29d027d0e2f4055bfcb51c000439dbfe8 3ea674df981be77af3101ee05efbada58aa84c552b85528c9e96137b0b317f9a fce584e406a2166a6e4bc7576e45ef838e4ce27d2065a45a19320a7baf163f01 0def1fecee4b5330a6488df6f248df22ba92af84bea002746a0b647e50941c07 d692409668548677cd700cda6f35836b205eec4de848518b6a883dd1270839ae 7e1d912ebaaa566002057b1a6a174539ea9029cbd86342a8aa3ffc748a36da7b c281754f3176f07b395486b21e69fe80cbd853438f37a25af70b8becfab39fc5 d0accbde0cfb2474ea79917c09a5c6948393d625f29affecf51bdc3578e93e67 0a299a649e18631ec310b45ee09d737eda2cd32e6ba100ed3bf0984ff88b18f5 e27bee21a8a3745f69a8bb71b60907892f43bdb270af1d4e682a28112c80e4c1 d8f5963afb20f917aaad9e0d0f329df6daa524c0c4d80627c537eaeb7c6eb783 0828b7115e8631dcaf475cebb907e6aac977d9938b7739617e480846e8b0833f 4c50e16ebc84e90f0d414526b053d3db85e9c0f1273217537805d9d7fc03d001 82 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 +generate_ring_signature 1bd71e0dbcfead5409660f7e8c3127a3d0c42fabf9ad6c0d82d88016ea624ff1 df36b0898025fc214088fd247b1b2e2c49d8b7112158410e9c2bfe9922c43dd3 6 c2c9a12dbbd3c694aa2dedff6015a22fd8a849edf52bcc7bbf8a05cd53f6ff23 437bbaa4c47db3859620b779dd5d2a04962d006d16f9bd04a7a6593ba645794a 4a32f65c25000f76a5af3a41ba8bd88d0acecdf6aaa2c55688deeb75625e2de5 f3a5c02e272bf7d1028f201e33c3549631c89ba801b5ad1cc7981424cd1c7c25 ae2910331e8e8b26f7ab2075d3bb9608f666fbf0c4c71063c58c2bfaefd7c055 889845375f869b5bb75e58c169cb19db753ca9f558f806b47c160f1dfff52084 4cd9b90686b4bca0ae584a8c6aa7aedc6d22993c380e03c55abfa047978b4a0e 0 1f340877720bc941230ff5c60fc10403b51074fd754f3d9b344debf33fde6301b006a4b473eea35289ad772346098d0deb46d3fbd00eacfac088a9248eb69f065235bec2e733164804aadea00bf2cb17a98655b313732d97ff8430653a518f0b4511babac57055214c7b89b5c72d1ef284813d6ba67d925bcd86d493bd4e3606124aec794d51912a37dcdf91eb5906acaaa831916f888e6ec5fbcdaace7f2f0be32110c078192b91056bf83cf9371b2187d7b2c60049add10b5a7e841d48e403f4918ce95df12dc28c50f26ef040781742c2882d132da1a6ab2ca30033938e02073696c119ebc33d9b5247530a99336e94d1dca046fb0c1af3dfa530d09a6e0b676452bc973355f8db4d6e052f3b1fd763bcf2d582f6a406428cd80b7912640b88b69194d9f94d57d0e03fc0252fe20621f9f79c5d8e6a0a1d7a04597d8a2d0f629bfbcfa1813a647d30d6094053f6769d65b3d099bd1f0b053e6a4000ae1d0dcf7ddbcafe83746a13028ca7387f09d039f2bd41b03923782fa11bf22cb58b0d +generate_ring_signature e424f4b58872a89f8d5cba2367a5c518d6f33932e829f1b82ea361005fd789a7 3881cd8adb14d6d3486a135de75961ed9ed7cb92294019d81adb8eb07344173a 4 08af7a24d14e395c22d134f5db91bce9bbbd0e05625a0817e7925c7f5d3a288f a0833c919f066178070650518818c09a464418c0579ad6b6f834b377035dad02 72d51c7e3fd7f62b2c2e108749a71a52e59072f9fe9d9eb78a9bb7c7d04b5358 33f26e4db6b10c1ec6205159c9292d852a39d8d4eff9b34147f9021e15cd4021 b0d7f260e8c049f4773e7a7957656bdb3426b3ed2b77a92963e25351afbab80e 2 1cf0d914cfcdd73ee6225ed2053355abd6177c5abe1d622a62c6fca1ee202f0b68d55c831c1e613e386ebd9a831815a102da2981be850a29fc25801f0cff1501bd99fc1fc35e6934306338c65bac442dfe2ef27877bb90ca684b8edb893e0d0c482499c5536eaa91641da509562ba6a1ab4277795441b084ec2400fba8809e09cb284664c0da6472d495752822227434497e3b429188b851453bb1d15396fc047e21bc2f6aa327281cb75fe6a6cfa73117fcec675c3335bdc134e7edf423470a2951f13b91d25b096977248701883ded49ad21de4f29b9e0297860567516c505e66ab6b392b7851b0f3965253b0d70eb916ff8c31cbb9ae98ddd7116de96920e +generate_ring_signature 5bbe504919c3ec458ead546da6a26736d2502e6a05308cb5625c39d40c3b0c12 af979abd7a21ec14aec19f65b49717be0e48846576d34c27404b0df29997b81f 13 d151a6ab8f224c3b9b2bdb438d5fee09275d134d320af24552c67af777d396bf 5627dd6d295bc9bd10039aa49cd520ce164dfdb98b5586dcf38ede1cab9e41dd 1e7968c3440d4a9994dfd89fda5d7f399bd609d7d428562aad4956efddbe85ba 49058138f3cfa317adc8439d479aa62adc11ba92670252048020952d91a949e7 206246ed0a40f7d750ec28040df4d659ae116b1dd5863f4372eda67025952d13 d3c2e54b9ae6962ea49eca392655fbf8027346ac63dcc309a0899e62420dd273 2b13248ac56f9f3bc37b3d49b2898fd783668af84f8a9738e610931e59e66842 b76331e8fac5e727716cd2fa1b24a6c5703bcee81afcd923b5efa452b0d6a869 87f3a2689803f1d825b4b7d9591c4631e2319b9b9582666d23b15e738939a03c 83179f1ced3540b0293518d30fad1b29d8227da77f1a32a19132b638d72d6d8a 7d1ff46774fae090d9433060c2c38b3e0543d2f9291f469f4ac0d75d6b8e4f90 e293f3c438ee82c0bf1d5b7d0cf27f9daede67da84f44436e395aac9021c1d3d 49541a49b7d1df796b7def54c7b0f8fccfb1a6674680d18f67f5e7124bf0a8dd 579e68d5f338d7c7e0e07ac07e0e592c9dcd18b87291a19316e66e57513d690a 8 343099596852825a1145ea009e44d603ea84132759cb9cd2576963379075f40d9c02c70a0f6f5693a3facd023a52bffd5132fbf7aa3c4b0fdecebed33208760db93803f5466334a45a1577b1e27da9b25eac4d849cdeada60f4b1d08405d570ac4c1bf1c01d6e0c9ee0816c13a2b248afbd5e6b1cc2e4da4b44e9a9ce5beea0a062377aaa23ebdc9b3d6b104e93d8f02df7973f7759cfc7bf9ae4818a0c4890ae6d38d05cb89b3611a3117af7f2e0a12031f78cf4bff2dc5172a877d7d704a00d513c70e065c392ca73183549a919fd0111ef3fd567f4144648b3546e56c73080f05ce85b272c3fec124f2f912859ec93fe0ff2abba2e1ea8d40965533bc000ab46926b46156142e05c4bfa6ad2234e2708ecb430bbe33239e90748763ff0d0e192c50c76fe037ae878795ac1ac5f16bdeff6cd2bf3f73f219cd05cb87b3c202e653b0edc52b8fc1cb1267e0427a4f7b557866ffcc8282218c5f467f55b4190b1e4aed5d016119e72e73b15c49f0bbca38c38558f785f83de2103d1e3a76cd09f6e1f47f82c58f221b7ca7440e046db6fa87da4d4f4ec830aa1f59022130e80786fa3b9a6bbfa8a03bf1297105a7b93cea4a282c8e94d87ec39008cd32f945010ba4701965a19998b0276b1552e9aef87be65ab0930abfcffc50d509b19a820d1f044571500a6aaf401cdfbfaa23dfad9f48c6a8ae37d19b823eb0da28eae20320565408df2ec7ab7106b2bf251b561f99f42068894f2f5ec573375c1be95b02b9f7212982b814b7a5f4137a3119fb242c5df8f7f92ad4c9ea42f61ab69696098603c0a3accc7eb6685bfeb90007ece294df95c581783c8add03afbf2b16a50bee9cff5539dd57667cb674e3c6270448c5b8b0130fa7118d2e98d3a32747df0d0e8c3d94e6e03afe6e93d24891555ffa8cdbc5dffb4e63d026a9bc48b588b90236a35fb5a8f27334c0649c1595d116862109d8460bcab53f39dc0c46eb88ee0f8648e15173cf3df1d9860d08ea6a109598d20e8d82075ffd35b7a124298dde014fbb2321be2734efeba897ea1d0115e81872a4fda570f5742bc30c76669fa304250a51b0bfffa25e15480154311a6dc2c8c477a5efde1ab51a7841101a31e00eda10e498d6a8950f2250110b16d61061b751f7cad9f675d3c8fa0ba84572c600 +generate_ring_signature a0859f82b14dfa14725b605a1f66c4e7e3c5703096a3cfa833f996b5e105ea0d cc280d0af6534604494020baf8cb120bffdec0339aadcf45b3d97a2b7965d393 1 13f43d83ff833e7b6ed996c43f01724dde26aa6d0ff8bee55b7f2a7ae080c893 1693e87cf56c39b63aad39216be18df69feef1484ef89a9d20eccf59584e360f 0 966052e60dbeb9b615c07e03596e4b6c6fb6d3b0090c6e8abf5f0b4d24c0a80da8aeb9e007e98ac26f7c1b6a459388b6f818225f93139d8ac3b7d15a9aa0160a +generate_ring_signature 0b93af27e122fda8495915b5038a4135290d292040914c8322751c075859176c d874a4e8dbce217f1f0d503daa4d2833dd8457d2d29022c39b63c2ff18295462 1 fb104b44d767fe74de8cb1c133c2e1d253857eb003c6c63528d7cc67b3f7e49b f39fa6fd80c7a487e67ce834393545ccc91891b663b57ae879ce6ba4079d600a 0 468cd65178cff5ea5df7208c704c0d51b156270e086f009a3dafa859b2be2205c164604494546a09bcb4db40f9d37eee984c6aa2a045fc0ba66488fd8ea31007 +generate_ring_signature 88ec571618126ea8a58e3d9d6d3415253a7a9e2a4833ab4c68869ccf369a1aa1 0fa962ae711149af59f3923efb7e275ecd525f065faddc47b94d5b77a1d058bd 3 147eef3259895073beefedcdbc2d0373150bb6dfdc255b9c58326fb443cf76cf 48b26ceede8691804ed3476374d36b2e820ee44c0792361a511080de5fab88f0 2798e56eff7a2f665c67a1b615e19834f2095580047490ed3998cfa1a5ea645b 55597215ee22059246d3b0ca241f9fbeea9ab39876dc981ff1fe7f70ea10cd0b 1 b64c45a3303fe8b3f938008f940f638c91d12cecf831d39cbdd3c33022945400baf9cee4f485be1d7348b3d45aecb3c657362df8890d3bafc9373b1cbd782d043fbcf0dcc585873dbe417b275b6930a0bbd4d2ccf15b937f0cf3ecc3d9b71603805d070f657866ae20a5ee1c64861f7bae2ebb5b2f0659022d0cfd077b0af90d170fd0a6bc9d84a9565349a9ce09a063ccf4710ffbc3d1e1c5a93a4369c1cf06dc40213c7ef54c2018e7ff0acb0583833890aa7b5c8a856723f6592ddee85b0d +generate_ring_signature 7d0e728c17d84fa5a6380b5d42c2874053f090ca9619c72e8f856aa878300a78 406841c5266b911d87602974d79515ee3cdefdc52ee5e319c934adbcbc964735 26 e134815b7a0d32a792a347b2f87e63aab51b90b3e63b281f4832e2e18470e452 7b5604ae9a247eff5c40efa5965808a9294586dfbd6d96ac962167a4134acf4e e7040750c32328c80ac5608f9a0bf591ebef09d0630f5022e3628558c91ab2e9 3c358a038783a448cf3286470996f23f42d97e3ca2cc4bf4fe62ae3a4f974466 5ce0c0f74280351838242547aa953e6ef42f3830c9763f1f201c95e116a9cbf6 6db16ea86470b1e4bc1aba22ffd2f6a309b8c442cbc82c9ae1d7503ff44ba235 996b564c3f75320433dcb6e93ae0c45f1d1bd63268b2dcf97feccdc2ce8fcb02 2a7ea0d2ab7ecd8275ff6c47dca7ec0fa796fa4abad68d20384a1314ff83db12 31ecb4133c92846d600a7004a619e5867595ff17fd4b4c4b6685a34b0a64a212 e065a64af314013132daf153c9d7079292340724999e9b9e0e2ac22c4be269cd 44ae0fd0320230f57bbe081415831d4da5ff3a4c6fe4ae24a2f9721df86e8de8 8ea50a4f60f0c9d389940d28fe7bda03dc202a8187b2287c5609d0a86d80b970 b0fdab7d002af49b410025b061cd946fa32b4a4fbaa400d8b05ad89ec6c102cf f39415c4eff393fecd622a777af99d13d6ada020e6b5f154b0721f91bd36e005 99df2ae81c858e669d81270858e66861a9bebc89abd36b232d2fc70415f32a66 a3bf1ab959108e6eb6044b8d3cc8ef0fac7c56d326b225948974c66003a7a49b 3296005eac9a12ea9a9160bd2d224e549a050f37f7b8a6643007f953cda3964c ad1056f0da4946f740394f3c044438c016bc31ef30bd1ebeb4da58fedf91096b c69e1a9512027cbd747a968593c936fab41dfc0de4189316f49d731dd5032cd5 cfa3c7a19dc9fe7654556910f7e6332cff284d94787d3f1c142213b9ab388aa1 a8a526d7c0cbf45988a265d3f3874bfc16fd3e972b5c6a02151a47aa44f07394 1b4b025ca5776cb79a04b73e1cd207f7bf18f388bb9732279f870a94c20eb53d 9223e36a7f6fac4560bd6a82a48d6af7bc91bfcebee656f6f014673a0289b485 9a8601702f972d76ff9959082fd1ab159e5607070cc24c09633ece1f65d65aba 73980dab5271d0312d3736daa5ccffe20edc58040be9a59d833ab288f2623b38 9838bf0467b2e4c5b42c2558fe202360778154a2df347fb3cbe950d677b7caed 9da3143e8f9e479e66ebb78947eccfd708b8dc2af91e13ddbccda8beab2b560a 20 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 +generate_ring_signature 65915976dad0b79ec2f06123198fc3a123c37fc4a73773487e857da9a5c54c71 7073df50257577f8b723f2b7268b6d026d172b9fa7bafe8e0d1712112b026e09 31 a2b0a4460179b04820d33421d1ed3c5f984c770738e6e734176c1b69ba5be705 d172bfb94a40f6d5e3a512f19094f112ee1ab673f54ee9968556b127169952cc 39c3b2c50c49fbb9ea7f49ebd3ff1b21c6120fecedd83b6fbc88013dbbebdbf9 36fc7e7fe71707ca4777c30c05d7020fc7da04b333676201efe55e93a1468797 7f1971181921ffd10a03172ec2726b7c95b714214b94d040e914a4a549d24623 2013ffd455d969d46ef413e6cc8114d2b6a25de9e5fff6aabd4f1c84fe28bf58 61e67258e2b7ffab772eb1e68d832f940bfed8d3ea7e56f9fcfe7ea26a8d1999 64e5efb93d450926f1e6115688897055b968f93a6972172719d69cdc21e93e9a 1db41b3664617a8e5dd42df836433ccda0abc7ff1d94590706d506cd83da9c79 722a3ca714a18f10ad273c30a5ed6104a00bed41e5c6bf5f955ab7dd41a49f1f 32367aced52479bf495d60e499e1671537ac2d8711fcd83ef8874c667fb94fd6 d4052c8067abf0112c03f4ef277f7ee5e0c351b245c1f922d2c82bb855d6c341 537ff1cd54e1e52430585be5197b3da8954b631e423beba3e39dd3dc6be19004 66b18195c83e626b6a9c315854420167a09bdb29c02175eeca18bb1996893a0f 6c8982d18575be7948224abf0157ef3f788de7294ab6ff5c1cc6d9bdd5647527 6251ef481c86959a70d700a5ec9892ba415d370dd1fb140eac186f74090b59ae 25642851c0c2540c4a43e28ef53f2923af198546242bbec704db549933ad6498 002c5ef9e09a9065372ec5c408cdf6975b9673d416d78204ca1ff40b3a2307bf abc5cb8512bb1db9b640c4890e68dc3a7e0b492202e48c68c26ab68501150352 0b8a2f4c3e989eedaa91cf4c308738a050b33d28cf23940ed9070a576b07aaba 97d865b7b22cd95e121679e94c5cfb4b1870e4779058d308d565151de1ffc754 b3ed05b092a76c0031c064d505430a15b1bb4071bb70991dfd111e04ec77ad44 99096c10ba7981946e06381fb36672c611c0aa8ea97a3bd8d171a4a188d70e91 fcef5abfcf89053360ceba60f1a0742f6a209b4e9bd3ba23a0491b25b18d12f8 61c1720dc08e8fd3241ed1c0f59562dc5a39337f2a33443ab4f041ec9842e216 cd5d30ee14c6d6a6ac28024b55fbe2c306a0dda2790957ec2ea3806615e9965b 65c60d4eff3add02a38c4876bd36586378abd726502755756b1ce232b7fe06eb 3e7c1ec3ef42e896cc5564c1881ccaa0ba7a5b5e616f069a185cbd6c6643aea9 521bea98888e7645384b810063c034332ea7fd15cbf091ecc24a9b2d629af997 5293f3c7583d6e5f28b5a08282ee05a2aa2e8afc2b35db0ed6c4aab167de4273 a18fc87524c2eee2b4cf3c001ae2969837e11bfdc9e135cdc09a3c5854b3a04e ffbadfc27c1d36aa85dd83ce4143d666a9fef3b90820373fb96f7976117db103 1 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 +generate_ring_signature ac3e3b092c1e38aa072cc4210d9bb2e4ce013216d06cba6049ca7b679bf4822c 317219905c41dfc83057f3a6a0d538f47add4d4931b087b6d488aee4b93ff7f4 1 a957ab83e1decda794a51d72c6b411a526b193dfcdcb97941651ca61fb40a066 cafd4da25098d3a9667da2474b43613aa07f58c8cec919c02067c70b02f18902 0 68a6f5062f5e82de3fe26584e736d3935c60642b24f07438bdd47fab5cdbdb0fca8a948a2ad17592fbed8c1f9b68999f49e9a40d6bbe1c2c352b6e360f4e5408 +generate_ring_signature 6107adc2ed0507e69710223b8f25ad15872db003a33231b30b13e693977a9a04 28c0cb6ee37eee1a2282c28676b5b9b3ab652ecfd46c4cc29b8b6f4ba8cbf514 1 ddfb74774075531723882e838680b6087bc40a394ddfb6ad1235e233491f4a7a c4aae45c82526a21a7eedc6caab8558a2bd4f54cbbd11e95e72bfe372bd1bb09 0 6865f46628a8ef33d4fbb2fd07506aecf43918cc4a99ec6e79981bc526bb090722ea1e9defdc335f1c42adbb8c148f0756742aeac9ec76ba4069339900ec3207 +generate_ring_signature 2100a5f4e410e5dc62f19a0c5e87184e1d148a8dd98b2466964959ff2381da66 d6d869463615fbf48380f9d11e7461f8cd5bc1fe91fb99f685743aba5ae70101 28 793ef8c181dd024839f3212f25ae757cb80bec1c219db4246c6ee2fa052b6f17 2aba2b63e6491a35ef32789b0c7a6274377cc205254e9bf2f69cb0286dae5523 3fa876cce9035a3e6a4d5d1b7a8c09e2df305701c39878bab4da23bc717f2eed c9e31cf9d3551e3fb2af4fd1608af9627f0a417d3cdaae50424f7ae0ff69783b d0c8613048181c9a3694afd2a02589c944bb3eef2b82b77c250775536449aee1 b9ebf2faf7aa48e64ad3dd91d6c719ac4f765c31b03bcb8fafc869c8c7636f91 e9f8b1b1cac9b84936264a4752dc97d3028a209be61bbe6bde32f8faf5463a72 2e66c163b5b33bc4c675b99736bd883533d8cf58ff92a6c6632cd47898a8060e a993576fd3d80b0925a900c3072aff58cd46dff9d10f166ab52fc57182b7afa5 da828df878c59586d46a4c49696661c3bdbdfa9f36a053d5806692c42e3f36f4 d2f4e92d5e5d70fce216e8b6d243fb32014d8abae37bebbee14ea9b8a3d84b8a 2f1f24c37d5eee2ae72a2dcd3b1b6ad30f5d34734a762fc4ab7b8956ff49dd02 cc7d90c3c1c794b6406cb1fa52f61a0045a2fdfe1bd83636c848f18a100bd98d 481a170059326d8eaf5a6885213b915fac4cb27a8eb5318489a75fed10cf50e2 dd2cd3093ca1a6169b55964de9003e308736bfb3903f3c8f8d6b02f252df474f 7dc1c9c1fb20dbf1c50b213b43df2fc31dba76b9afbee67b8b0faff9a7d269ed 50e9f8e8964df954a2c522a8d373e52d2187bbc76919287a59d9b506249ef137 8902dad485e7e3a7b9cbb784074a11b2f75686b7bd6d613027a0bd91f0a96c2e 33f2908d1fd2d85c821734bfee6f1f08a1b70b82b95a7b592d02a3d09e858cea c70aa472bbea4d8d55b345cc2948ffcbff1f91294eb23062088332a5d78b22dc cf57313df41a81100e9abfe9d50146d4bd97dee3a4633db1d47cda8874de978e f661b18e8576915d55a6a23e8d201ed5286a576f2c81c2fbf4ec7945e9b54f7a bcbfc29481405ef6941a8865ff80219df8f16f972e6db14ce5ae1f05aa3e04ff 1c5b932bed93ed0c1b0cdd46325126b6049b4def7a3bad6b7edbb8c6adb628cb 089949b4a4c24c2131989b09abdd0aefdc12c1c1f62ae87e04fbe0e9da567544 0da2fd4af5735a1b90aa73c411039d41dc2f61aa1d1ff7bbb76ad39e8e2c5082 81073bb6dd2b22897882b3c9d865bec7f568b80ff23cdfcc22421fe9771c3395 5b87191663fc83c7ac5c0a1936e414fa357bd8c83323c08c5aec0c65be085458 6a668a19b1bc83605e4aa62bc2a17c45bcd68210cf2b05980ff205babdeb8508 27 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 +generate_ring_signature af71df96a0ce2242af718f9f36bf7b1e2e54bf52afe541127dc2b87f6ae259aa ca8423fd0e91f8872e0a32bd20940a577b0fe5939ff8c684a67587c699407cec 22 1258734c3315b929610f4c8215a30412459f294317eaa246b5d8867d12c69363 aab540da690563ec5971895052762a8e8998c754f895201694a17c476dd598b1 74990fc817461aa56686cfd5f453b41a69f8aa901fd4e8d4d1f1a0b5f6ff8c91 be833b7186433e5d760182cd8ab18751036d1b0e968396cf61ef0d903633991a c174deb550d5ce869ebe3ec05bb8fb582cf4e27c35d5c190b7da5de77f28dcdf 8dec97e5c5778667e0ddd106fa037ed7c45eca6ae55c3bcf25503d41bd807fcf ebb1afb03b050a92b8e559eb8e067b545f63d8099821e50b1c99799b7d1991eb 7e9eca4eac87463a8a0706af0dff91dd9000aaea65a691255bf3d4891b55244e 51b1223f80ed22dd385f378a33a14111d712ca3018ba967a587bed35d8b798cd a1c58243c6446bfc860b55045ec7607dbb23081b72265365fa90cb90eba8ee23 41910bf9644f3f9fe19c5a219d3b7f96ea6168133c19629a2889a73de302b5fd ac0940d8dce80710286d7b2122907d0c2a8cbebea6493e44d3ebc88b131e98e8 e10b2dceb0a93a22d8c62e6e4f8c7d766c0733316e6d9af29f6a70293b2ee109 f2553f4c0fd73109c497c05a0524430184d0995adaf87df4b35b48dd589db98e ac12b75019ecd593017d62134be2c9145b530b80d0c604f3beedde286fbca385 366ffcc3d9f2704507e10f7945ca35af510d4917ca6a0f320b22bb9bf2d126e4 6e8396f83467caf6c90a774f7a35dcba54461a71e2ee2990df127a5271b8093c 3d1e476c5c17a2a9d875e8e23243deaa16b8ce4bcdc2dda4f11d60a521fd83f8 c52b53a7882356adf4167237b853e0605029776fae814d3fc7fb9f5bb8722f2d 524c073fa8195ef0ca8eeba82d2182b8cb026a4f0759296cfc02e5a240e6b65a 0214ccd35e3432dba23b879df17a8efcc9e2e56826be4d0ed4cad87bafd20c9e 9e572b2ccc41e5595b3c74f6b1a571dad53ce4efdd29e04fb953b7e8e5abd8c4 c379fc436343668d69d752ee38c2e4f989cc013b9926f3c54568eafdaaef8603 7 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 +generate_ring_signature 4512063bb19daa1ba31eb0145d48f7dc9d06fd806ca89540becd2b5e6826c1e0 89a8e66b8da6a4002c7cbd2dd887bdad6a08e3412d1972c1ddba31be29ad779d 4 104de0915736fd728e8c86d2458441d876f459f995c7256a276534f438a614f8 05fd6561503fcb29ce98b70157dc619b5c4aba732aabb0b0d10b8298d1f5e155 2c1a30eb5f25ca5ef00b7806c934794f03dcc5ac58606aec2081f9522a216749 133392cef31dc52c7de272824c7d487327b3320b2eaf1caa827083872002b16b efcc49cb457ad9394617b802a3be8b9292ed7e88c782508899ba39a152e73200 3 d7fda8eeaefb74e325f37c9aab7f3793933a88ce7d8d6b1c165b879662b77e0b30beae70a43e88e2651a6f6f3bf9bf8e2eba6a3b0eb03d47a21d28ca102ac402f17159fe622ed601ea97b97130e958becc793092f9f007629342e951d3dd7503518ff7a4efba6da821593529d5032e1a8875bee2e2437f78498eae36bc0d410643cd91f491797b409cfcfd3e3a36afc606d6dac4a0f6c262b2d4b72fa5f8e60cd6625ec61141aead0f1c82e0ac502bcee41e6920bc812dfe2a1596d067a5420bc9ba3b55e2350d2b468158671e5b4410c90f746d41dd711df216b6a00013f50b6c406be09f1e62e0865e4d82ac47bea3b15725894bd24050e1e67ff95eaf2208 +generate_ring_signature d4a171b6e8c5a7881d47e5e059129c134a12972e6cf446760d5ea3f5d9d8a526 4995bf794e131c0a54e6b94218aadb1062967bc29978ef1e04a5ec2a622bed38 2 8a1e660522cfbc1da70e1f269efb738b9efe941435fe7ced85bcb8b2b445015a 52a0a2d5f69efa6666a07a177725d76f60a1fa078e7328132ea81e2a1aead5f3 7799976d0f2f488ab7dfce43781bbf6d8f64f4c17c6dc5e357a98ad83f23a20b 0 83a85c50a6dabbfadd6a59c5048b125977c64f0b26c7e6926bfe06cf38384a0ae8b5cba8b886d47d74e9757fe8467de538701118faf961bbd43cb8ac6088a40bc447e84e14ce6bc466bd9feea5293ea772eb45c9041b515354af619e3017de0d06ac23f54ca908f40fbd6e5603fd09b7a7ed6ed271ce90ca6187911dfb50720c +generate_ring_signature af87b1fedee0e438f10aae5befa088392ff4dfae1546b8c8f779fc50ad51da97 90e690a1501ff3a3fb14070bd46a4b4a7175bb31f57956486ca61f2e49cd4ab0 9 35f64d12ad8dd1c71084709e6e868e68b934eb407aae5fcda2505773503025a7 c80dc8d3d3abb474b56a5c054df286f87f5c58881451feb22cdbdae8f3f900a7 3461ab681e2e79261f83d37d82d4982892320fa386cc6e6f5bed308bc1c13d12 46d70d6342274b6fa1e9e3d5b5de51c4627000ba00432606cb4aeb362e25da6a 2b561ad67dd4aa1e38a5fe1c8454218127a73881a206b24862e136cf2b255780 31053ebff5a815b078f8e94d9f0f044f1688b0133cd883d479a94ed066a1d1c2 968233788adaae5fc7466d8390d94d6198074b114e2ec9b52c4d851ba6832166 f668b4ef8431e75554c02db408f359ef81436a0891490210bd509923a7e0a749 fa4407f6eb50927d9c17ca60b21e8129a19684ddb746e4c186b88ad5113dcc86 020bec4c5ca87f397f5c0919116c54fc4fa83c1a650b045ee4385a3d7bb40d03 5 857d033564c56a0d64f0066dbd7cee44aef0392496875d1e21d4aae4c645280d459f36990dbf5c3943f6313370eeaae5401d4e9a10fc3f12839bac17fd49b70854a45543b801057ac84d24218c4e0a0c490188bdd2a1ef8880260db5e6ae600ffdcff73d83f7067f84c566b50e5d10a424dd800f25aacfaa64a3907c37a191014eb39129dbc48ee48a346f97dbf007f1c1d599ec0e50bbd05f3c90d67a4c32057357403af89d6aa073c5e69b437061a646400435dcd4871278c0ddf8fdc7910a0ca61ab2926ea7013d1bdb6ed8d8f8fb0be4bb9cc424c00b7d4985f5169c07041af96beac30643101b7bf19d15c08977492070ce11ab4b5e048fb9911ea40a0043cd96c1c119ef2977a110b9c34b63c725659080b3971fcf2f3caa696a6fb2006d361edf59a644d3b79b1fff23e2ee1581f377a0d130a7aa2ebb75d132e468098f91f561c2aee9ecb13a72ec54e963f45da92e4c4a57d79811518a3bd0311a08fdaae767b1dd2bc33a9bd7cff77a097f53d0c4c88160ce7dd3d4caaa02df1c070562020278b369f4950ec0a494fe33f91c83e290b8562739977371d2e5dda60f416202d6c9b4bdd95e4d48494a8ebb88dd83d51787fe8f2f1434ab3901a8c0079dc640fa0e3f6c3cb687dd7e11b8df4b47873773d1e0eaf139aebb940f98be0c135c85fdb6d54d5055bf057644a7a2dd2227dc9c6646a336b828c18f4240fc0766c0b26a5838db51b9c262040434633979960e86c2d2748065a92bc11187c8044115823bc810f4241754ce1f8ca2e64a49d23011638b0906b8f9e32f54d12d0d +generate_ring_signature 2d2c11cf68486227b17b80fe6353ae59abf53ba0b8bc75f32a61007b557c53ad 35e426514c73e7c66880bc26f90365d770c31fb753926f24d23848697bfc5a88 57 a9919f6a2b7acaa39c078c3b24e3487a89c1e98f72c6deb29190efe461915b1a 97078cc1079d661dd75108310685f568c813d7486064fc35b2f69b38fe6e94b4 d6e58715307fdae6fcf242a4413b3264d0550ada54a02a233e3488d63dac0307 a6eb853278a50ed8333786b3b15dcddd3d8d784cc647adda671f710a3cd46bce 204fc5f49b9e9247b2245d0b29b32a697e6cd5b1c4347430cc2002ee6682551a 19f3496ab38450705b89e6ed8fd2c725a72ab9e04daf81b3e84f762c6f368858 cdaab9c4d1337195fa27a23ae9beb85e1b421162b0175b01e5022a8a6693a2b5 da64b3606b987f43092b844e787c73e147dd3f1401e5d4de45e6defeebc4c542 8636da56ced937d7942364cf6791b38e8819902811b071d88a7e9f31c9158318 24d943b065ad70668edf4dd47bfc174333547e92fe95a4840aa1cbe343ad8c7f 4f633908fe98dfeaf22d5f82a7bc5c591f68f0a5c087df556804a218ce5b539b 550f1304058b94162f04b4435bfc4190006262a55c326750c93aadc37c491239 2a8a480ff6b6e352d3eaf025a8a2d5f7170e8c72063216af052d14050d68573b a7a57ab7e2dbb84b1b687ce4e37c966aad92e8d63a80a67b399c3bc1775bc570 b1b394508b9e74e44ed21f6f38aa8844ff16856e1179b51b73968582babe8570 fd472fe1eb884e3f57567ba1ec8d6a3839e944cab78e639146224f141aecdcfb 5ca43dd0779bc74b551aa2279219b77dd51b6d84698949e23a5fd73663f5e5f5 4e4bbaa324ff9e710ddd5f5e837df67df9ba854afba57819b919b3481fe374ff f9f50fbf4109310755f80a3920a2bb47e297e4420b5859045819b8f2ab68bad6 4bc0b971d4bab80d4013dd6cf6363ed852b6b95a94b83380eceee179611f0126 9f5fb2b0052f5a19f77eaf98b94282e1f62d09b3dfd090074ba6a99d7d3cf0c7 570157fbaf6de931c767a74e01be9e00dd875477c18a556c93187cc9aa9f51b3 5b581778bb48ba15fa9bb4e03524b5206268bd2ad52aaed0ce60ac577cd3ef94 00c51c2ea99904e5d933635fb1715c3abb4ff07642aea7dbd46624fd9f1d825c d50322d0ead2433b3977ba3dce5964d17979cddda84a13acf5f5c824f110cbf1 bf25117e9f951431febfa8370999db5159ca8511fde188cb0166624773c5f0f9 4c64494a15cda58cc9def65c4746cf88207d32d24b90a0c134dd0ae01b09c144 01032bfc7e3f6e6b0a30a3d265e01e385771c8886aeaa6948965c05728b056a8 060f286518d97854b81a3ab11a55141d4edc97bbbc93fb0bfde999234b05400c abc25998dea92a2cc721cb7bca4ec8890b18d31fe9b130e706e9f9c231933aee 0d462aee190385626534a8642fd579da27e8cd596f90b3d5f5e7fe55407bb405 04042ded8ccaebe4ba0dc9d67fb8bfd9f51c6a43f4dc154f3858b2f34624573e a8c3ee54ed71f11805178141dc71af46d0218cafd72ea5adb3b54ebfbd2ba1eb c4d103d2800689c4b1f2b984ee4b0565f5e214b8209fe622db3f0b8b8fbd3dfc baa5fb8c4beb0204f6be08ef6aa3ea2351a81ed5f169315206a089e7abe8e691 9f69cd4518c0732b7e0d34fdf8fca4f449b391d66986f4032568375532a596bb 2703488d85817e84c47dbfab7d96a741c5603fd38674f9a14dbf9c0785f90a3e 18271655568f950df4aeeef27efb9c59680db900232da356f3bc940e77a661b1 a260915c171adc5c17beb5b39d073adb213ec6206ca8cd6656ad0207f0675c0a f3304b1d21a211a6a64be267512752e8fe7e4682fdcfd42676d4fd7fc49605f3 7910d249a3c64181a1737103cb8a0cc85dec99873b99169cc3995662ad1c2397 b19fac0f51b23d973d0b7daf502321f1abcebd28f6f8abfd75b377db40a0b99b cf3cde5e0b30b42c5b610d5087e32d21bbc819a6ee816bcaf928ba20c45670d0 64f3ce114419a4bc0eec99a1f65fcb2096c94c65ef8a5ca44209c48b6f364045 7f757bdfd7cef93d1ad0b987041bc741ec64dc3cd78293506a5bad36e0926d2f b0155d119bc08df378af49e9eaaa856742bf7783f3ee16d9d545a6064f12acb6 5b29fa21c990c8b43186c1d6d842152a2fa26eb6c0866c10014baac7c82367f4 6fa38c3bea221425d2fb979f5666b6b0214f9fe9ce0abd6d39427dd22bc20c6c a6f86b5127deee81e39532d897d37407dd7348beee9685f0cbece5decfa5d3da 1827e21b68bf6d7348b325fc74d8f65289f30a38ec4f84bfb126d3d94a6e8cef ba62987bca2eb991d123ef903a7377415eb9ac77f244042a87b0538e233fdac1 be54b474591ad0d58a89c6a696abdfa17005717e6b9360c34cd95634210eb8da 78ddfa3c43d923ca2037e3774c9c4c8260cdad274487ff71dc1f5b739e0ece84 6a2184d5c8013feb86b8fdcb6885ce3331320d53f4c02245bcc90c34f4f29bc5 db01a4dfb62b753a5ce1109a566604b9eaeca13064b13ac2fa24b4bbdb859236 de3e15f15f67e61b3f05022c387ba7029432f417c1ed96377d0fbaa9b9474f4e da88bf9678f4d1594a8899ebbe347e7039f5e23287dfa64d5809f0e70a359f2e 098a6833175b819831237a5b135e325dc1e10b0d348a07ca831c60ca31862806 1 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 +generate_ring_signature 5f538e02b1461f07c98077400e3cf540b0626000edcc0ee4f184bd1f72604f9a 6be7e0a471ad7fee54ade0d6615b22f36f5ef44992917c3981ef7a0a4d561da8 7 4648fa9cfdae1cc58f504ea9031acb69b269d148e581e01294730540f5ff6930 9dfca258921efd4ea725792ba16046d64831fc572f3dc72ee4fca1100b966ddb d7f734b73581e4fcd011a57ccf613b25ab32c3e61dcc3aee5b65ee0d118f3858 e11aadc5cd441dd0c48f584c8f92cd17d1aff66ddbb7f86e4ee6deae1870f0c2 9893530b57c30c46ffd006059cc5ccf20a35632060107d8ee0272da1cf219b7c 0f5a132da48e2f8dd651651c00026b9ae41d909503fc5e7b64c808201a06d2fc 69fcfadb6d9b4b296d86583324f22d124fd6764ce0dc6331efe72adef2ba1a26 02043a6d949d79e1a8c63c231e3db3bf406bf741d9e4a35b14c41e9813e90a00 4 e1c2364eb6d2446de63b947f3f091bc48f2ec86b463dc7c9a331c79d0c23540e2c076ea46a739c7b8a3c2ec3484bfac82ee0df9c62f60d8996cb0dee83c0220ee54632928c7db75036b24c9285408d5ac065da69db304ed30bd29c68bb8a41030b7af12878b19b7e6990512e24dcafa11c1955539b6691b42380a87be03e26033fe95445e26a095f30e7ecaeb8744f89b5bdcad600ef2ce7e3029d9fa6c9e90d86ea9a4bdd61a7d3cdf7dbaa4552ea350c0d3fb071d0324d6b699e73163d37041e4b7a60c29f5744f422f433da5e38e084fc74b836a1c7c304519150105c9e0e002ec6491e671409a7a697abff5ad58b91c709a9f77cc49e378dec4e3a4dcb03d292be27b6ce65fc9874bcb258dcc73a2c65af240fdc52caf37ddcb1ec6c31053b6b5251b2b272bb97bafc62ff8e63ea1989f4ca09eebcf762d46f57e7bb2b0a38909fbacb50de71f8408632ac66d5e3f840143be0790a7d4d1ffff925234d041447802b03c8e15de3e4757254718e203b5526e13f19c23d84f9a8fe6ed107068d2ce2aca3f00193c127caf8fa38bd90235d292e303e8ad92068c8ffd302f50a70b30b91ab281fc548f2d1dc9c15cfd0d178ea865a3673af91d94949cd2a2c04 +generate_ring_signature 39bd24a7043973bd7a7f4c8e448e7787d1e5aab98f333b25391f624a492c1d35 e7551719351d2f367292d49a58da045bc9af52dd31cb565a2020f5fd3333728d 253 87211d95088dcae2b1d8db1e408b1eea3050193114a62975b8228d69364c2e16 d8080eb5ff65b1e88262670190e68166ea45b3b603b37b6d7373cfaa636f165e 241d5a6bf98df975d09c3fd82f28daf686e24e8d577632498cf47a80742fa4a9 28044c0d9ec190be78c95859877fc3c71a5eafb944d87af6657986098d5df61c b5380a0808e51b9bb85a54c703ebec3c1dd5d00ca4c776d3a4d88a3b15fe13a9 9b02e613f1bd267ab8ba9f17e1f44dd254e539ac7c4ae51db640be7d43aee526 b4dbc4c9bfc1aaad51e0a4605f40f3e4d86bc7483e9034c60412b099eb36dacc 94af0b33beeef150aac1ed32fab925099b688b72a6d854115507e893d15663c2 7e8e137d9e882f0fb9e8eeb29e607cdb113578b086780a0728e926492017232b c025e69848c70343a238a934746b0dc0edcd2d545af7003bc00e647cee2f635a 80c47dbf387d8fc014051cdb257585f7b85b08e41364e3a6267652db57967cf8 2f16c481aaaedc8ba701a58363f4574d21fbe7d9d3b225c200b7fa9725f15948 8ea6e2ff9ce7991d7764a92cba2c865f5e2a5e258588a43f76e17e41de039808 75ba819f4fbfdff82330cc7afac927e72fdd861cd9243693ba5745891311fc15 23a6a044fc33f8f2e7f8aff58e94283ea45fc8202f1e84c71914073fefea600b 3662f25a290356e28770c62bd711ad6ad929ecab25da3f515a3c053e6212311a 192b423ccbb0d6d329e42a8d0317c8a00db0e5a2decb455b79f6b7d9c0737c06 054535dfacb051e8f8cca57c43ea456cbf563fc80371b8ab750b4d9e660270a4 892ebd8b4d5abca1c059e3aac1cb2543194108cd999debe33e7a65d112760d2c 6627c6b5e09c06f9329edb030089e2bd60212ec499bf9e00ead218f3b4c4a94d 0323b5f1c8df8fc71595693abe6a5423cafcc7379ea59a1fbae58b1c820f5f66 8cc337574d514c3b74794eeb2cfd25a2b0c10768e631bee1c08499ba34b08c50 42ac8825861673461fc8e350040863a663fc03a8c7822d4d97ed3d80369be618 c4e5dc0e598b2d75087c6fe50b411588803f1924ac9cf53882d952b6bf175e20 f93279c53d909208453b55837953825d8fce2dd9d88d98917e7946016653d867 094f2ff19126af7b3c0f71d8f0d569edb7d4ab103a7b541a85defdfd3f516473 00da2bfcf3f2f224fc3536837ca93891dba7254213f5314015eb6be4f365c6aa 99fd38e293ec436c242c51b8d7688a1e0da8b8d9498f568c8c67b7fc7b03ff35 e8b3c064790b8c6004889e828c28e4a13c94de102ff868c0cb30fa7a1b310455 e009ac341d6cc6f400c9aa812eae38b983ff1c3950ec0ad32f54a637714207c8 41d6e1013a167657aca3c785b428458a53751a3ce4f55e7f69d1c2a732dfceae cb6646dda6cc5d0f46c3eb31b6956d944b63687ffd3ad12f0d58fe4a1412021e 989c30d40c19570e0fce6aba0e6789ec2351436a0deac9f4bf373a5621583610 ddc4aaea5c7d9b2619c2cc955076f63ad67beff0f57cd678a43b6aaa935629c5 7137f11a9d15db1ecab14ea167381fa81bd092040a9bce49661788380f5deeeb 92670f852c2cd07a97830d3f4db9577d9e933d72b46524dd05c65325d9a2f875 d053e29032574a0eb93bd7f30dba833b1da8181e2093e3b50d28a5f39dca6b6f f4e4496e938470ad634e61275427d3fb275fcdef514164975d93a320f5882e88 80e0024f178225cb0b40aedf698b8f4b85e413a34e29df3e3adf9bab15296e0d caa36897b70299c47f3a0cc3aa7433b9c5273e803dabd5986f84763492a41a90 7cd4fe492d5fa570d769270c0cc8ebba8fb7253dedb141801482ecc5fea15a98 a2a76ff27b18546a18b6bbbeafb1ece1272a03e2f147e9bce94da684f018e322 90a46155d50366bdf2a2d7e398aea33224a295aa3455fad40dfb4515d365d60d d08d9934354be29e663f1c8e50b6e3610d8fa15c10e12feb4cbfb1d64a07a059 8555cde97863f54e6b9ed852e3c2a26c2ea56d815d710939d89eff70153d579e 265617d3c9973965a217a9cefc0200f5300f3ecacb1487add5e1bb141400147c 6a45afcb5a02430e57bf0af7572dfff1841b9740f5e5052540db3dbd64fe3cc0 1744e17c9cd258c8a7396e7d704bbc4c6c13b06cb92bfd176ba1567772cd4ae5 9236692660d3647d50a61c688725baefcaa8675ee933596c42886d7e57d81b46 a8a82c4536579ebd4e35bf3030b1d18b00f3b56befdcaa94e6e6dddb00b3aef1 eccdd01e8deee3c4ea8fffc8b41bcfe089da7fc2d0d250c8d81c790a0a340127 a1b33761a1691e68c0ddadae7965b912a0a2578b27eb6e5234cfd1f6bc175dd5 65df31e331e3a1f31f01892821485c796e18ae9be5046c567c2f9f31edea5eb4 f51b804b2b4c7047e874db85fc1f827c78facacef789bba5ae0bac362a8719c3 cefbc7087a409c7bfeaf01713590ab8ba8cf200f0e253ee24513acadd14eace3 5e24afee28b5670695148232ff4ac7aeb6d028430f7e52ec699bb8d2fa423543 75ca63027ccfa35301adda5929b6d34db711287e8c20049f04682940a2574cbf 6d028deeb9f33d1e2dc9a7815aed9d46c8bc5ef5a24ee180c51b992d02447feb 0b4862a56199782c3db8d96e126b52966d8857c030bcd12bf78dcff477de2dee 6f5a8b4bee8f6d5f58db280c52b72b24011168a95f856460018c6e942cb93018 a8866f4e5582371713d07a92b9db45fb32f27fabdb45fe78b71175af9b9abb05 f9abffce30898c135700ac2872cce9820f6771733cfa615a271529c04e619c2f eee59d2fd563cd83bf665f28f327f28f2236e0d7c72e034da73634668014a050 22a58e501959e7d96664eea0a947f95643cadab389bd257649bbcb75e52b101b df4b5654604c4fa3b69a9303047f39149a9ff62e5294ce1cb9f03a6599128759 892b52449e8ade9f51e72afa4d16cfd61025a0b852b4aaf0b62771ca4e4d1c03 e922bf917ec5c7181a864a2b0fab689c90593a47591b3ad0ad442ce8b632aabf 09622f5fb64ce4b5d67a424a280af79dbaee60a557cada15a72045f27c839617 791107d5f62b4de6c11a38bcd84a836ac5799cdb4fc736f1f5e14f8d4bb56d9d 3279edd7b2fcacab9810ac647eac12ce8b16994829f283d3eb83f8e13a4d1429 739d415d0f7d8d65675ab5dee02fba52b22baf769fa331477768e8fa21341d4f b6bfcd65dbdb070b48930d06a83706aebcd7be61fd7595c8402da87f09e8303d 9007464c9c734c561094b29f09be140baa1565ed3c09196f399e82b489ca5aa5 be6092d1c575e39349a043b24d3df2a8e9b4938e8ba67796428ad0a7309f808f 2ab34408c3bacd9bfea53991e4a6e69ef5c6bb25978bc25f62244b143f9bf52a 76a04b6675637ac67513c8e6f9d89243f059e3407a7d04d534597bd0c7e46897 06325655016660438374f04b5190d361b605d30a2df103fc4f1acb7e28b7e6f0 5f3db63b41e7c2789a9839ad5fa73abf78d9ee2a6ed7fffa7ab485ae0b1c21c0 481f3b51347b46eabc5136721c1edf697febbaefadbd1d0d72f8f792de0fabf0 a8fb1a7241ea84c5e50739aaea6761d538a042bb33341adcf37e088aa1d51477 10c28dfb14d43cb7914d21f8a5875d6825d44258b8cd578706befdb2bda02092 5fb5866fb47158c2a5bf8abcb52a9c53a2d4f9c0c549d352394aa96b79e406ce d3c12eeb91a1d62781ebb072b272ab1bff02d2fc5c0c8f2af0db54696121c282 d7cf291e972479633e7b3b3c6fb8019fbcc26888e6048d9e78eb63058a5ea47d bf0a952706bbd8adf29a83b681560fb826be849ffbc69d7fada22e90fe83f9de 83b805751bcde4a3174a5f6531efa627a47b849f702d6e7ff871ab792f0cc818 c3e23cbc18a7aacac51625ba45f180e4fac85c76df506553f5c1864fe17c086c 3abf67694d6026a2cdc3ac07aa3281e527594c551319a2e6d9b257b7d46b58a1 382f03e3d26afee7c3f7a8aff90539d0b05521bb3458161f05e472717e050924 1a2dcee09581ba083f476068b6e59c97b3179c2a9759fd5062f6ed03854e6738 a1837059296356f67330d65f3ec669a77140310381bd40b8833038da9ac9467e b786b45a36f1fb2ab17fa149b179db91ac9214a6331990f899b9c9d607a96948 b3d9d31002353f99de917df0fe2a29bbf9468cb39f3ac6f15cd3693b9bec9500 afd4d04039fc38e10cc42211f091880c106b4ee88cf223d674b72691ef04f0e2 779fe4986cc325cf9d43a81527667f5477bc6b0dab67b5deaecc1c78c3b41228 6967bc33b9751da2b33cb217691bbd5fdbc87db54e360c236725df760271a6d2 20b279076b9092772984b180cfa0984e2ed6588a2c970d6a406b2773170a25a0 26109422f9bc97fb8374c815a93ed9634c8140a8d0e14975d7f1e52b66580946 7eeac26b1ba8efe87bb115537a60ee5a2bf6b16a269a518d7c60c3a17b3f89bc 98e996ba603332be1162e011edfec5b73a3a6184918c34d81a6d8b43a4badbe2 f92c62570ca18eccc7778273b29c5c817e19aa5559a5104cef66e4e89dc9ff9a 96ac32b1c4d83ef670005b00e79131cc3bea1253d5c082475e6da0b399b8ec46 13bae2d12ee9264bb9291453cd7019a57958f502960c34e42017c13a0d428ca8 a344ba1158f690728f90eff634b62ef5f2ce2b8485e7ec9eb3d523df9ce9e20f 540926e4afd31183a2d64de8c688960ee63aad78f8265810d24750989af3703a 827ca48a9bb00510c9c89c629ab3e7fa5870fe2493bc6e07b86390c7f893e91f 7724d7adaba57802ed1509ec9030323f08e6408afb4cdfdc05655161b75e1525 a21c61d032a71dc127b1677cdf43876169493bea45add0649cc9d059bfd20f9e 62ed1053385cf71c7f25369a405d4b30b726588341ed822fab9949216c55269b 0012dfb8eebda069b6b178448c062b01df2580dfa68356ea9b18c466d7c21a1a 2b87f48472bb3c7e4d2cce4ff0cb1ae568db0c8731e6c368252a791bf83836bd fb4c4da5dc1f72661f0af5db7637f1b7940d849103c430d63968c320a02eb9b0 9c52d72249c8cfb3821117962383eda8c12b6e3f8d23986ab4afd3a488437fa3 d2aac9ca8f90feecac1c737690c26d3b3ca4cd90841001749b22b16bdc1e43e9 0392f0abb11ce9258379706f9da4703e71454fc7d8d67536b1f607f207751b32 78a67470664d2bbc9b352cb4b14ef9009d9e90bd4cbb0026803d1968a3cd1078 d3c46ae28f78b2aed09cbc451d9923667908a5d43a8e092b630ee4be84394500 89e4bd7046c2f12dd51effb3d2c800f3ab40ea4da49977c1d552a12d7f8aa959 1989bff2c64645d0364924db8586d990ae186ae9f313e91dfb4b3b70d05c8f93 42a1b41f6cca4410e04819ed22f20c9182e7a9b9bd7e8408c41a2eaf48f1d192 35b4663612712abbe565843fc2c8761a1b3b0fff08fbaaffdeb0e3a7f6853638 3daf4ec635bb2e54e527afe6df275c297f7fe217724781c4f8739ccc9c9b2fb6 5afe40899e4e7b817bad34de512ee2077227facc7bf4d3af21ae52fd13526623 b0ff07a6f55a5b48ac6112e029541eadeae416e99a88a2805f230346eed89629 7d6a9122f5df8c327f111e1b3bb934067ef9d0070c3e34681560145cd3544e61 bba9cf327cbd4ab53e16379ff673f14ff209e9f69fa78507504290352b22f1e0 09f78a7968c74f519ec07af117b5937a93445fd1292b3f4c6c048ed3f2ad473e 4cceabfe35704957d8d765ebfbb4b25e7aef813bbb69918e328a82ccc9cd0ef5 4d072bdb1e147c44696d3ac42708497cd14bd5b2053c4231e0f269ab68801d38 fe2581a5df60a4be668cf4eeff3b81b1535b62a8a073663d25cc40ae7e727bd7 201d6fc7a1d66b80f66b2a7e7461ff48c2f7f494ce75cf6a8fd07994315c7d3d 4aacc4df48cb39506847e47fd1de8aecd36644ea9a0a3715aa6410f90bdd17cf 391c4953fe0d607a5fe0757d3b6d89f377eef9472e2df092d84330dab9032c3b 7c0b6f25bcbdfddef802981b87e2d2602e796ddfbf38c612a1ee279575b473a8 7d918f300409fb5498d22dab33d5fabb006e03884a8120342e8c7de43a0ddb41 b472faed5d81a2ad3b5abad7bc4254a17e227e6cf61dd85f808343ca66d04dcd 56046d829e429c14ca5bdf58c1735f9ed29b23d82dc82b865f4404bf2164f78a a777c375406fa5771e7014fd9c7f1195047cd7afafbfbc4e90895f07b25bed88 2c8a6d21d61e1f11e8c4384310f41a6d170302ed1693767879280e6d26a2745a a629e4931c6b0932c982fa5204e98907abe2f36060e8571eac9faf4214983ec6 26b14959b10a5fc133763c1042da576408b7ef0722e74c7c990771ecb67194b9 33c948c923205f23965294543804368f8d60f355d0b812d7ae49100ac3dec0dc 5e334c7ded8a7fc203e7b4b7e03842582d3f87bc6d2e975091c5b1749dc3afbc 9ede74c0b6637781bd4d617a1ce397c5c6d985f56ae0a3a55292139e636e343e 397a7f6cc7cdd493461ed52f39dad6f3250a8463472c95ed9d549d6d64c934dc 0faba779da6568d7f50b60ac6c02ad0abbc93f4da87aa61940a159b4ae7f96bc ff1543693433d98347ca081f5450abdaa0cf029ccd8654b31920dc8630feddde 333f205783f49fa3f0c93d9b97791d7d477a9731131559f998bdfe978885604b 1d3b152f9ab2ede0ca97f01ae350441b4aab27bc99419b2b65a499785c4fb523 67d42536c5b0cae6b6613aa4f2a9655fb108a1cb9c741ec0e8acc47b0f50bb5b 0ac2a1b9379b4eb1c63d742bf7789f3f9ebac237ca1890cfd527762b7f24324e 8ab3bbc165e4d338e6a06221aa9d7bfe583a02ea4e411c5712f7890e87206362 2b570b3e4505e0c909b0b5c8516bf506c47f4a46857255536e9ed48cb668c8f6 c88352c9f9f561fd50106608d456a26849fc9b94b9b6fe630685500c8c0a9374 2909dfaaeafaa66a84f68336277f17295af6f389bad3ef74fa3f998fe1d7aabe b59fe7f21465882cb99b1005442917cccd40b9991f9ddd1c0a5caaec633e2a7b 0af13e35bb870c074cfd20e6488817842223336da2ac422534a4e47b5096e14d 31c21003ebf459dcf7d60d87619e953d60cbac7f3e56a3006f783d7409231169 58bbdc210a0a3c9e6d7a6c1a739e71385d260acb26caf1971161f1ff129cc850 a0c1fea9d30b676be2bacab78a0a803cb91d0d5b7dca34e7414b623d31d760cd cfd7370b09766f1129c6f7154fa9173b72b15492c96ff5423112d81aaab345a3 1c4adf684aa1c063c88f48b6d755b6ff3e234b4abfaf11e669b4b049f3990ed3 10287329dc43f6f23651cb0b6ad8cf44a733a6d62f5e3bf0bb564f9411b8fc53 eae584bd1ed75c877553e40e71f0fd3368fcf5ab466f60fd51fdeef2f3163ad9 20723ccd0d19029a89eb5a705cbf37c67fa7482b2b5cf32b269713f9e82df0a3 4b435f890fbec0afa63df7ff10216141b4cc91f2ef43e45960fa369643490fae 3946de1a98c9dbb03306cb44d1345352df983c0ee81c599642037ec826a95a73 81f7954e59f94dab306d170894f26a64a3ed794e58da478fa4b1c97d3e7f702a 7b17975da7e5f925b7c00c9e49ab67c1c05fdc84ecf7c7c2bd9052fc1792a993 c2a95abe1d8563d55b71d31539718f81588180dbc1e7613ced3cc8883b7a4ddb 4151bc7f598d8b5f51c06994350ce4992cbd5cf5f0af19131f2eeb2930e0c2a6 e6d57d2471095e9557746dc61e51d13d23a13a39c21cb2f5a025e6e57d955319 f6948af76dfc38f9f369132e61275d3931f73cab4be55e0c74c26f3ac06f25ce cac3b7a21c358d6bfa6b75afe0ac3ccb00c8e1e42c1cad83652d21f687953df0 7f80969a5e9ae3b12dae228ec1a9705e9e5cf8822df26f4b2e01d33d01960ffe 7f88d5c21dd827ae7133e3685fef7cd74348ede6ce206f77c48bfbc3ca8d9d16 0137e2fc4336f7f6e5c58ac7de684ed6fbb80b94f9a566e462397185a83aa3bc 4e09fed75cc9ac94c945f26099179285d323109b9e5e6495a5fe70352b47b23d 014decd861cb19767ad2aabb1df2a1a9c39a90ebfb0f9bba99336101a3caeb04 6a8e6bba480e9236ff6d502a670c9c3214af2c2c54d68ae26373be3ea9f6ba54 ee16d722d807012e9b33dc391fa877d6ff8b4c28d8a60bef98407d595fd84bea 01c76b8e1b6a8bc8da70dce6e764ae7c3a5e84299e5ee08cd549452e8a7ad5f7 7f9dddc19df35383423444f76b977bf5f9f8aeca8ee4d12b1c2d47050c4865aa e31923c564f3331aca4266e02a02fbb38082782bf920c73266dafcf5c584a938 e9e1a4257cf560e8c93178a567c31cc5b0da317989e91fbba69e19fdc144a850 d99b31b583a68991c6a729ab3e014e8efa878f4d73428a3e7837b4ccfb7ec34d c43dd8c6692eba9517699c6ecdcb4addf074078005e66901131e3a951c1b0edc 0c4adff4116912e3cddbd8af1e0a54252745b18c8069f00848c86fcaaf1b7aee 71435bb799f392c3fac1d37fbf25cc104123c4200deb7027a25c83f14e1376a6 106deb263504c267e112d2a5a0119a2c56801262370e5005798474cef408ba50 39287346a77fee5f44ad898f17384b4f8d6fd9f579ae9b1a247c0092ea61a459 2227d6bb59ff0f8b917decbf5da7fed3e6b1da14d1acff753c24e8900dc37e74 2bb4d37ed8a566931a8b423ec83989cbf87d6c95be7348060bece8b781706a01 08092eda20bdacec2c77841cd6cc4c5520f526f95d6f0826633bdf037d9d4113 1c2c619b184d8283b6fae53673fb2b157236ac33610eb5b83071d2ed211e0ff0 8e2cfee0c3e50d555312177c397f1f7e28c137f8c66adf4480320f809feae542 91e29a009e5a842cc42d63fb6df9c01d2d166b97128e9e30747cdd6bcf40b27b 015e3a83975191cee58d69290ca0bb424a728c4016bf7d7a8446045f3b445038 0e1644bbae9ce4dcd9310271cdef3f5a1e50dded3fc252ea67d4622f6cdb3f59 15fabd6e07c43e4fd09387cab79bd79d2d1167254e03ea4b2bc14a79d86d3d73 334c7d74257b32240e6cd3715e5ccad9c9854e499e2a0a9a965b05e66a158c11 931728bb4e71c9ea18ca56741a4ce91611399a12d55d24c5e926d860c9671f67 e8f5006539db80c08d514de53e33c196fedfd6cc69d25cd854ec7e620689f605 184a126faeaf6f5a815c95c47e9c04a7944eb0bf9a333ad1e170cc214e0c89de 30243847c6842b53d49252ec2cb97d6ed6380c6a1b51f38aa5c22734eb444af4 4fbbf2cee95f7dcec26c8dbc0c6cd3933761707f72014b23754cff935cb17bc8 9bf3ae0a3eac604de96bcd6601a8c7cf6e4b50a0cdb19564202c56ca566f7e76 1db713ff96be67e88510ada404d59b61cb72233bc848a67a49218fa7eb03c580 11e055e9d596101236c23c1ec2547d92d43609e34f9df12b5921a1eb86d94c6d d2577aa223e766db511f51c5b2e682bcf7bbeac3f1d62688676eae35d0676a18 94249cd701e10680522711d48a1c700f65ee7a588eabd3d14db6b00d3b0a883a d3565a2fe13cac9f6fdb94345fadbc56e9925d6f4e23a724aad18f2ac389d0c0 e76aefa00ff29a4f6b79828490b0cf6a5f1d80ba4b6a261c1e92db2ca2394f53 ccafb3c0c1bf893669cca0d35e6cca664e3506dfeedbe2e9ad03118c97101ccb 2f93eca42748aca9b75b35d4e93605dbeae6899aff2243302b90dc708b619b91 9c5f644fffc89210281ed0be8025d6f26bc199f6acef6c7d540db9074d22d480 73d571d06399b629e06ddb6570e0f8c2bbd1f77e533ae6299f52d41a5f7338c4 15ce90fd29a054ba8b0b6d055618880b09bbd224a023ea05ab2351fea9d803fa a989382b2acb0beba1b03b963333f871eeb5d33d3fe7458d5070ac2792197585 42f972b27b415208048a2b9a889b68da93265253bab8e0734d669999e1aa6d0d f26d0f678d98edbf10d7cc58d02907283cfb4af65ee711da72d049ca2d45db46 bbe344aad8977ce28c67cb5a68877a4d7c17f386a04a5c17616d1180b46e02bf e0ab79f061bf88fdd6779df98d9dda293f3d2795aa708a2de6490ba655834006 88c2506e0a3f6e896df79e698020e240452b32c6fac52bc977b25747f19f64af b4f594a10eede8ad967bdfdc073119224909381b7dccd689adab2fcec0144fde 397a775a0664b932a0d72a7c98af6d08319dcad3c32db270120b0e277d79a3c3 7d63131afe8aea760a530344ee8deb6b7da613e3ddab7f85c3e1f7035769f782 8a71c81729b06a8c8627850015e8d7561040187685d648d0e4099ac2dc090836 5d17966c6bd9faa7cda178016d03b4aa310d78bdf42eee6de5dbf5466a9d6c58 9791a2b9abca7e54d48afe35fcceac3910298b64474e867a3a3a8593201ec83f 65829bef7805b4703ad88fc1a7cf848b38c3e40c0b16a7b7104bcd0741403e56 60512fca2ed6efb77f8299b3b33688bb3e81f71265a1c4fbe1abdb266ead5057 2021516ef3799cc02c7a956d40f0efa1d4f95ff405ce8dfead6989b80b32bdb4 8fd4b02b418427901456dad0cd1ca52671894ad62abfa6f227ee2fb62538aa27 1be3f560260be66bac669acbe18472ee86b338e045fe6821d0de255ea839cb09 d5ae308119a926b3a4a359e0114ee2f938158c61f484dd750f4489cf0e535e10 e218771ec2e03708e7f885f14d9b233e1b7a7d262c56d4f009311a2aeda0ea4c c01c9457d1ad329799a61fb10620f4c0c0b500ba26ff7cc5c3351f1ce90f5b3b fa27dd75891242297128724a5e0f2cb0050f3952b21c3028e29be67af64d7747 8342bfdd59eb7d54a07830ae4d09a0d15064fc19fd4f174427cc33e46d8e535a 0ced66b48f6efd8b0230dd1bbd8c5550e0019d8def29913096e02d39292961df e98da021b8ec628abb0ecc8a6897f3324d7680db16ffb46dbe762c30779e038c 258d59f6081f46450745f0f7c8a5fdb41fbb4ddc0a0149ddc267630c2e677d9f 0f86b6e98a65ab1d035e0fd02262daf83b21c8ff9cab3cdf7afec0c43af3d1a2 25442f835deb1d4ea6333eff39668c84a94e30c57298169935b5afcfc36d7adb 303b1075bc6b497650521361175962ec0385dd87bf864def6f575c2adc3cd0a2 8ad76afc1d698b50abbdb1d94a5c86ccb49b17d49af4d36f39dfbc66ea953fe3 b5218d6cee39e1d1a74e500958b718e406a89c7f468754a744ffa8a39b54e8e1 fdb05ef89c3a19d21e8bb34783a60888a9be53e1e7672d1a3e6f5c6cda4e7029 1aa8d8d92f535ac3bcc0af296a3ffb2c977953ac1e75a25cb65c4f4456bf5ca9 890d1506854a507ae800a7edefe094979769b1e9ef9e376296e7b328830de625 7017bf0e6491806767601a30572fc2dca74d1de7cd3e0ddcf42d15373a04bc8d 71c0cd41b5e501771a72c57a6868c082d4076256afba7569814caec598602f27 376b3198ab6e5849451279c39453c528081337f80ef80e882e954f60b1410600 22 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 +generate_ring_signature bdd604377d0adea441787f06cbd71142cf15d55ee20ec1bea85f573661c71201 2487ddcc1b463edd2a754b037e4ebce25e5fef7d87a227d6eafa588404345543 35 b089255060a9bfb64276f30e0f156291d61ed74376751cef0c3c519bf97005cb 71344fa8a1d99b228c90f79d26b10a0936b43185ae7e456376f6bb527bff449e 2798b734c642a9ec401cf1a33c14c239c2a59c5f48eab81450f06b8824589ae3 3aed394a9a3077b2b7b6254d4ff647bb96b7438be120fac9204096b5f169673f fc7b91dad8e497665fad7726ccff5cbb5c611400743fa25dc395bc95f09c7704 d4a4dcb19764fe5a25a5963903ff0c0b9134c4b8be2cf7f33e7bbf42b59618d1 38b63cbc455b1340fbaf53d4284ed6a0db201b4e4aacfcdafeb6273b1a307e3f 0b8d7c46fc803560f12ef832de6079adcbc1ef9f787b45de01a737ff5e95836d c50649bf69d8dcaf869c7e42948ab1784cfdf39af5a7e4f710726f439b25fe51 cb559abd56c267e40422864b8e58cd27ee9f9076f08da0fdca1939d20e6500e0 83c0c2a194cb48bd356a96e50ba828121c00be8e57a8ffe7460fcdbd543ec13f 1cf20a067afc5e04c12b6ec9ed5dcd70d647fb13e390b35b24503db9590faa9e 77ccbfb6fdc8e4fdc4b9f1d5b642a0be86ecb52d0760e9d37949c2a08be3b17f 95061c0154e8feeefdc01a2d1fed47012266721d0fc3b81f1e39ecce4f8b2850 2009e95362d812eb87acd566bc521ad12249dc3b1919d8af30ae0aabb389b6ea 7a8431ca2ce7199d1db1a3c786fc9405dde6d0628952cf95174f0d35267a41fb 8fe2a2d24ca5a08caca966a0a5175b9807f3030631c5b93b7ac35eccf25724e6 67a3edbba5207baf306674a7c24b2093a4bc41c3d43bbfbd545175c8c6028bab eaa0962f91596cee665815b64415daf81bfca68eb9cf5eaedb9ac0a0c4ed0900 2f87c482a8ebfa50f9776869b0899613d31302f61bb9a8066182782b738db442 1fb8bfaed14ae9aa8f13807f7a07d705d47cd642349fb1787734233b7c85a3ed 35be0bfdf4b725f01e4f05af0bb9f02ff0dd4f612ded87a2340a1574b3aae315 4a0fda512f352146f7859748681ba33d2760bcc72a20db5922691856f7e603ca 33f200d19c8fad76478d2eec8699beee2061ea1f31a6f28e764cb7025691266f c968d9bc39daba4299986612b3467ac3d45ef0b830dd62b497e52219b175fccb 22460e30d871caf28c49e4cb59cf296682dc386f5eec6279ffcc150faca7cfde 1f92d5efa075ca1f939b27e1b0aad182cbca7f20d2da676ba1992d5696dd17d8 73cf74bf162bae040c2523789a0bb3a96cdf781f1a766754a2e2ee1bb200791a e669e339a639b731135147dabc872053f458a767ca38c35d3e9a3049f7e8908e f8183272074d1f826677ac9d576cb3f558fec821f5e32cb337107ad6cc85e63b caf86118b2e212f253e171c428e935c8eb6cf6ad085f25af4a0a93f9ec59ace5 9dd75314c1d8ba4bc81914778dd77308015880272b65bc37c402b1cb832a69d0 bf83ed74a2f7948e17828735a98afdb798a3f8793d1df6d4d1d8069ae7403dc2 b553310ecd79a8254d329a3d6e2002c89a501c06b6ae3b7feb152293dd26397e 7d483ab7dcec571e016a577f74301a6614a34734be679ecbc324170dddf06aa6 57993693eb82f28e7ec9a7bb128da07bd30e23fe4522dbc460d96cbc87482706 9 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 +generate_ring_signature aca251d46d3b5ba026de943e11da65c82565e3661f1aca050799c330dfad3d41 b26123f9a3df78771873063ddd286b3b07e8c622f56903f2efce7499de4478dc 1 332885ac700a35ecfcfd9d4b87366e052b2b64a9b71cede41d1498ebe448e3e6 e884832fa0894e874fc141dd3685f50e5db4e63743002c9005997948552f4b0b 0 8863a82063317f1764f90ef62cf948bbe5388fbc1904cbe653060c1dd17f730b23ca5ed50563c3cd4dcf2b29ff310fe744075388728e4fff508b74ba40c38808 +generate_ring_signature b775c2fa902004d9f8b68d5e8d02f5a8c1a5368339cd1e9a5509f9cb5bde73d5 7d0c3bbc111cee95905b30f237c3a948d90feaa912301831d3b3d0d765056b96 1 8594f65a950e1a254db53911145528dc04b86702259d209172a832b7886d2d2e 007a01d31abf4ef99af89f0054b67b885b1964b5ecbbcc2f1c9e5dd1157c2a04 0 f84f63410f579ae67179e7cf355523d9bde5a52c641e783b8da71ab1bf20ac0ee788afa8e2be6d1d18fe7c44c4a83e210750de994f9744e68a0b6cb147c2570a +generate_ring_signature 677e5736293b69b1f168f92d1f194d05ced68b431ea47d89d1805e285a75aa96 c7fe04a57b9bc912b8b51cb394ed14d95cf3175482764e5a9e311b79669acd05 3 bd2dd96a9f97843f6f9f67291f4ac742f7dd142e4bc174d83242322ea2ed6578 519650d18da99601cfe0ddff1cb8a6c3c5a3166ed0f4b4d5df08e731f1794af2 cb6f9d2a06625c1ca76b07ed61ec15de053473ddd9b648ce6c912a3d176ed6e3 7fdad023cd867a5981be27fac5ded58a4fad51750510df61abceb2cb6cefbe0a 0 3d93b5219f63d4b32ffd18377b7693247b21b6229fd8858447fb11cdbab8b205c1c249053d6785d25a971def9408debcdf30904d250bf10bde283fca1a1c2001cd692f685379eaff3c9bce57b0eea62f67cee43f835a7175b0897dc193930e0781b91ee35ff20e21de0b86684536e5b5cac11a944ad10c3368e48d9d867ea906fec3195aa453432c3b4a11a7ec2af41a771bd726f8fc58c925bdd4b76b5ed00fc2f27f8f81d798455d2db1a9ece3afdd06974752c5fde9a7b7f7a29cdf6a2303 +generate_ring_signature 2c56d0869d611a98a8583af24571d794a9f7d657bc9bb2668f54c91339377b9c fc4553cdaedadf367b81758a5b277e20625549411a88c7325bd8a7129bcc476a 2 e82c7b44deef558ac8ca40818f843d27480d89f5851c2e0ead9e2fe58eebbf9d 66b8b0b3f84eac9fc67ef4d8f5324dc53526d1906f0f830d21bcea089e0c42b7 7e23cc4cdb791d7b4ec1ceb2ef16f65d29edc81cfe5786a62f4abc457c4a600c 1 efaf12bd9c505de07d2fed7abf586f6ebce41dd24e079e9c497ec10a84f8a5058240698987990c4110a3dbf9d475e17cb0364dab7102ef2ec904761841478306cb96d28334dc1c72086ac2fdcb2d3ac70ed264e7d41df1d0b04aa50234cccf0c5d81c9a954e9fe2cdff13b6a11de991fb9715907e57944987ec54af775466d07 +generate_ring_signature 8446c895fa03164711b6289f8dca06a575ccd8558fb070d1f07a053b6ac62a88 8f78a27ab3ca15e3a040e4ac2fe32902d418b7317666becf389f520169099aa5 1 05291f379474a1eb448d27e66553fbe9df2a5133b15392f6a966ace067a870fc 7bb9bf9cf9611b1609b19513734454f28f49f896fcf29e689a937abcc07b4803 0 454655af64c9668aedd70bcbc9103f774b96b1198d89def3baf5c5fe9042c20cb7dff1dcfd9fe05885eb08d50a82f64e457c4396f36dcc00c6386bea897f2600 +generate_ring_signature 89919f2cddcd14dbbd6510687053b794e5b8f01565250bc8968b781f24739668 0279f476b72eebe10b6db1264b63b2b074144dcdd4c0c2764cd4d1815acaf713 2 f82d16dd5f4d75904b7b9195713ee68a1595aa8d9de4fed48c72c0529734f52e 04569b72e8939aec2b6db3b83ee34c21326a951c83915e1f318435f609445b41 824dcfe5b0051072ef13f8c9e183c0d1ff5f0dc9a2c6f397bcf1bc3d626a1803 0 b2cd517ff0d9cab3919340a1439df08f03851df0ef165f59fa1cc90970a36405e9983b40237abc84acd69708c28047af1cad04b4e9df06ce2fe24f2711ee750b5d36b0aaa948190a72a6ba03417800119ed6646edcd35245b5652f8c239e9f050ba934a81092fcb2b93f00922b719164715f7f0bbd5a74c90f5059426914cb0f +generate_ring_signature 0d45a262ba21084d5b11dc6f7df59cbed5aa38f517ca4a814ff490923916a652 9b86f1081957871b7575cd304b3cbaaa38d3f00703de9cf9e8e184128f864375 197 d0f935d39c2c505fd5a8121bd2d4a741896f55ee2470792d924dc0101a6a0366 460c54ce55f47189b9ef38efcd9c2677e4f3b7705893761ca701d0fcbb17530f 497b4f9949d0021f02b66a82223c4cee3471218d072dd5bdfd3cd75f22e7c0a2 86234ee6f836e7a59fa06e91798301543347f89beb69c47a5610cd6a48b80f81 eb8da56b6a7011e63dabec4649def5c6b1e90ed607e3526ed329dad2d201681a 2d35789d85de0049e0b401689d2cb627e88d8fffa91cc98cb6a0cf41d596c936 c3789543dfba6c37c771f175366171d91d5ee954e9a0626df83d371e1c03600e 19096bc68e91305027ce6f497869c5187fe39a606064f01dc45f696486fa24ac 59731aa199ccc0a87aa746c6e6cbb76295bedcb6269906637ebf0ec791706b0d 608f849ac3d56aa72ea3d80df7d5a784dc4210ef2196ac1fd972e9bc7828b378 e98d5ee1f8de14bccf0abab68e749a9c3288d3d0fe6406d668f912ce03e5830f 3ecbf97e70c7bb254d6afe53e6c15a9e240f26fb732e9c8ad1f13e6f5bdbd766 bb32c560feb78ac2da03f973c620b99dcc06c726b2a570b732c862c95a1a8f79 7475630c541b4b636a91e93ee3610ab5ababc266db827320a8814c3a347b9b8e d0a372bb94a4850540f4796fea6bb38d394a47a935d2dd4a5326d86d501c767c 74c6fec0ee4b8931974d59e8dfdc4ee0e28e3d1418d23428234b48ba8ad5393b b688d964bdd826f6748bf989babd2c55febea15e51bc92d3ae961509c0e336c1 90d569472bc45d3201db602f71869cbf528b2b6b3fe19105278ab39bbe1073b4 d9a36d7afe645436cd02b3e61a86cae1999ab5242d039b4097508861a5e247a8 22c1541a04cbc85028279c5acf1b54b6151b82d09c16513b646a14c6944c3f5c 958bd65d4e627939b83672a58ca806770be18562c061c2a225dad1efe0d95b6a bb3f7a2da142d46d520a1741c9c24d85804ea3da66c691d836cc3b8c5f7421bf b5194a6a410afccb0a4963cb71afe4c177cf90f9a7a3a3d4e9660f1ff064ea93 4f7fd2fe01c9dae2050735a578bbfe329a5f8e6153816ac53dbd34762f87a8a2 6596a10ef0c3eaca356f8873042150216ea7df61d25e36136df4746fa77ec0b4 860402d1f5982aafdee30a7f8830a0f4fa64877255abf4a5e2abde02f43e5c2c b86ef36d3b6873de1efe9e02e2083d3bfbde0ab81aaa37af162f1a6fa0eba0b4 5e7000837abddf0711071b6d205f999327522033d068d3d029187b083b5d88dc e7c7f0e549f921bfc164a4b724f261759c46b147b8bbf0e6e68c39503c198b64 fa55f966b88976d859d6e4776ed2dff074761de70d589a1c89c86279f0005a3b 75900a1d92813d506556b6484ca988d165f54008f1a8b50e0ba8c7b23bdf871c e7bf33d171b351a061ed80d3c52029b6627c7b73167d04f11e339da701cd0d6e 655314b8659808e3993409e198dbfe6555053ed5e0c195d39808ea0f45972b49 89f9d50a6e5f312d92da3763101453a9ecbaf69e84f47c21d855a05bb54a219f a64975ef5c421dad5eda121b3c3e58f818443428a05263053be3da99fbe77df2 5fc852cc8337bd39173274d4f3cf102e0c2fab30ed3d8ad70c753e3c344ed4f0 61298f604f8dd7e109b8600eb9a84001c3d7dca3efae6229dd12adaa4e3d2c6a 07f4d5b629d9c2efe6705f2adb2b9342822e615a9fe6d98897d74fdd89fe2878 5e0f62fd8243023c0b9e7dde96d4ef14e3079f4b0d7e76630c670c76847aad5a 345e572794d11d758bc761d9f22f977c827ed332108e810b21b85cd6378518a0 8afce8fc456c8724baa05516fd9af2ef8ddd29e538aaf1214756f683188a1bef 08897543e204208ef1c1118b4153c450245dcfb2b7746e48e8e389275e816861 d10372082654fb3dec772174e0967ea577c5d93d4ecdef99c70867d84829a10a 4e038f0e07dfc7e752952b19ec3ab3355b2b92e7a39182d3eca79b6a3f87d14d ad67fe5388f5e92e911157fb2b034c1a615a1eeccd3858f255bed067540dc711 c40a5eff26f7221382959ee22dacab3668894870fad1934eb8ad8a7e40ed36c6 ca5f7f63c498e39e135e8c18f0262702de1348dc79f8204c216651a9c7f9ac71 e578f8694a5e92e48f06d5709ccfb681b9c8a738abf20861aa51d61872cd3348 b238cc4ba4613e26d7d41996e6a15b7a1b4314aa7157a984eea7d2bc0706d00f 52a762e09b64943a304ac9c2e110ec56493d00ca752ab2c715ba72f7d69bec89 b5b444ec26de88fc6ff295056545fd65ae83c012a45683b9a22a379efbf186dc b74cde735535b0acd9ac6da6a18c10c4d3e889f1b0ee33aabbfe3e942e9f6321 ae98eaed6da71726406457e4fb6b8fd6577e545ccd7aab51e0c5d51a44265e4c eb366a542d43efe8e33f1f3733dfaacfcd97e215a44ab0cd2aea54a485bc1ee2 710ad4431c43814d664c3a3e0507f59cb8c65c3fd6f6b9382e84bb308ce2dc52 957765427ab11d99da32c054c7c68f888f02f1f2fc10c5883fb866661b3f0e1a a453b57b38dbd7b2af86ba28379d8832e3bd57f3b54897875b458ddff98e7949 a9b5ddbc6bce04caac06aec9761a507f0e09a8bc3f2e7fde93304b5fe5e08673 e8854e7fb42255389b91010d08f90ac2d86da53d338f914fa5edecd400d29a7d 15dd3f808f9f9a4e1f0f68a6157d3541dd24f5e3e51b0eb51543c1ba1dc7aba0 4f187a0886930e1129c97e3373b873c4be9875f745ee91a2e20c2e713a133d8e 64f4cc62ffefdd1b73eba2cd09c5f7ee3f2433faf82129ab79ba6884040fc3ef 735c79657390255c9072a9852bb1d92425811a7703b9809eb3793f4119e00463 5b88ede31e1f160f65b6063921a2bf8b5a28788ec8c3f54089aed3d5aabb983f 7c1252e028be184bdf13a60a46bd476217cceb393d19db69ef94bfe6f3380ac5 d2ca845fc232693381d777903751160a1fb43e818d548f0a0151dbd23815b260 d8ac75db6b5eb39e3f5e23d0b88f82a51552150419ad35e2ce1eeca110df4552 71686dbbe145ed2962b857fe2b732bb0006638ec2c91889f6ff79e1729554bba 2ded0ecdba64251aa08c39c52d0ddc5eed4c85df82f9856cda1e0309315ed47b 765d23651313db76c45f44ae14865aae2c57f8c67beaf102cf299f8f4f5d856a 998456c7aec76489456b3700990c3bf373bc85eb5643a15225819c91c8642b85 340176f1b4bb47be1b0108d75f4f06adc449a28a3ee4b3b7cd58d186cd6c7c19 7d3293cc9c72bbb56250a56c44225e67c63cbaaaf65f2e3671e3a8553889ce75 ac9752288d33835a09b7110f63c38c74a3f24b97fa26471a9d5adef3c4d27373 e152f9eef552515995ef4e9ce1257287e5c7848da1a19697c0ab30f14f7d1d97 08ffc32c3134d2e1ab2f57d3b287a8f6ed83231e756905136b42c1b3aa69928f a5180c65796b1a1ab3bb051ba05483f31e84f49c1eb893392fe987187ef85c63 8e5e0df1415bfe86c31d128a94174622e9323cba4e1adb06805e92e7b0620fcb 8bd78cb19bfc01c452f2ebf461670e00a3c3aff5f7ac6a1a789aa8e697ac324e 4b65071088cac227ca7b21538cfbc0cb09d0be5736b852e44f1b02508900cea1 6256b8a6eb474cb662edf8e72d45598a24d9c9a5d0c2d4ce90e6e4eb4ab72f8d af391f1ce7788799623687e8f64fb61e742273a8a7344a6098dce9f6e1b1d78e e74249c6cc363e2017d459fe26ff53745f0ebb45716b03f735b00889811935ca 5010e69034d8eb2d46d1a8b4f0982c2ff82f6a13e81c61ed262939eeac5cf3b3 88f249e548a21b58d4e63560be38b14054257f5b88adb0c1b2db7248035dac78 925e9971e38bab4865df5368cfe172581a48e8d8a25ffcbbca2dc00a1c765488 e3087dd5dd33f774691f876a3755f311cf77bb6972eb2c6f56928346973d8e99 56c686807919352f157d48805535d6824158026d99dadb72a104764d7983c2e4 46800e442d18322d36f6978aaa3790dd145716459f3ad4a04be9597725af3767 b32dd7aa461a9faeef0e495886d5d8c7fce4f8f5b7fb3fa42ac513bae5903793 b58508c057d5cfe3a4c4524c96c74f5af636b5a9a56cf1bc4cd816e6d4d465bc 5cfc9b6f9b677441ae34f285fe46e36c922c15ae955a9169d490984bc8b626a6 d58b254b005b382262704dac32494e11e867b30a92df690ad0883a5bf7bebedf b582fd6d2430c8651f15e80ce36cec80b79d7283bdcd5168420fcbd779d1e9f5 3e684f24aaba4b871045cc521acb81cc4a9068e06ae0a7c0c4a7d5ec7e2947db 809eac13d43c2fff1e919d0d5a93a17f97775858fd822b787cfd9d040cb0d341 6a6b279a65c84c83083de47e5ddf51965103b6cfdc39be8f0920cabc138d1b32 11753c1fd004eb63e3296009423f7a455019ea6122a22e06d300edd724dc054d 2d32f6d1bb3a0761755bea3b77ad838c0e0b3fa3fb52186d2ff037fdc3c0f198 3f8fc50bbfa21a30257686beda5a777728a60a3d187fcdeb5e361ea75b4d66bb fa0d4059819fe819544297431c1f676d1b486f9daf8611012e8ffaba1030d767 1902609eecfabcb88c566f1f737acc62b41c4131178eb8a8ff68506e2972875e e536199a16fbc159054a32e48cc24c7f151500e82c2757353cca78df3b72d22e 659e8fa4ee5592b00551f6f3c6e8746e6c05a31a46332717964ffbcf24643b30 594bf8cb04d93a3811fe7bd3d3f1a413775aeaeb28d3b06f7f29617e58e3c3ef 7c9d7a620d47d9512b5dad55a6f4fe98940264b316372b74c0d39a1f7b355663 ce45006b86dd046a5a18e70801360901b0d6174a695418bfef4dd036c55753a1 f199d0a10dcf37bf413f9f8617863577ee4a3b86454e3e4c34833dc51ce8a9cc f65ea29258bd880c7924c54f538b08a9795212830240e606e5d751b3ec8e3b6c 4a4093fcf50674032c280905fdcbd285a626d87b9d077973eaa690ca95c4c71f 2f660dc6c1a14877e7898aa47ec02bdfd278385536fd9fff368f5303f1b82f70 05821ee0f3ba4a2451eb951afd27a624348f9bba4561b1fb9089e974aafd1316 af33925039e6797a7d7663d6c693ecdee23099b60ff22c559635b5aad147814e c3662d59040b9dd071b53edf6e41943332e09c6ea7e4e2ac12062992376e7b9e 67c71e230ff2274b8fa392df01d43ee6958d4e6f07da64410754ec5c5ba52881 e2d574143ce458f5886f24d031c49180b3f78c55309365715ebcc8a3620a7575 63160938651dd3ff9cd282fc5aee479afa13705c7a2c43cf8fbaa286cb216070 e51f74ea5fc1d517a12b69e5451f3f6780c5640e5d590c380f18a3300b935c3f ea8345cf437c679dbdc05fe2bf30dba47b35fe45c5ab2e5b68592c4adb6167ba 893d54c1b4fdca988943c4d51d87f37185139c9cb4f8e3626501e36d6a6c5042 92722b7d3ecd3d5f6a50ee26efb4de32b26545b58d83886da5d09518880a6ac1 59255ac1b983a2a2e1551a8f19b4ce70575d7ecf4970a250e6ce5634e7220a39 e76d98db55a8444e9d82f28903072fa1b9a940298b2a2b892ec198bbf576cd39 0c624da5122c9be9c1f0f3d6cc3caec5eb3c5666d13241be0e7f2e0f8ec303d8 0b5b10255ceecca806ddb8fd3f09448367cc961d2cbb6e544811e5a6adbb7b82 264ab5191f54099261d36b2fa67fbf503042ffad98ded6ac5caeee9e638b5a6f 1ea24d52a43ed3fddf2a4fde7d13fc73c8757e7446cf7e95bcfeb16008895c22 a369d000754b106a32c7105623859a2b44d167ba2662474d64ec90103cae1782 87e6981a1eb1f422b6c482628204998236f01cd4f563d9b883decea4781b65c4 26fd4292f36e22a31a5f17f918364d0fa1af7038b64eaf2c77abc071ff324911 1f7fba3490dede66a8ca0b0f67f069f48943844c22261c69d586cafe9d3f86f3 ff7c7a106db23bf12f87313679605e6b9e0c5364c20da190d5af82b5b6b22fab e33cfd1d5133ba44214fb24911a44deb554830bec522fd27f0d9c3084613f413 6dc71dc6f84a8bcbdef2d72e2fe12f21b29fe1253a015fd95dfbfe755486313d 6ba2e3f0a288699640458bb12023f8b1c6cf01e292f386730a7e04ebb17462ae a1ffb0a73d396083ce3a51fae7a47c10bce4e53f736331ea791393d9149ad791 fdb87a472b97c99a0c6bfa8c8ce93c6327dd796f3d71a3a34c4c81926d6da322 91990deb0c917e2d68ab5177ea86fe68552736ac7b702fb81dd994581f60bea2 093beb91bd66615026efeafe94795e5749797c8339f61f9ee3ae96e8a1a5e0fa d1bbd9eb353fbe9bc9c78fcdb9f49d56d310e287dc698ba37f5943660f2294b4 8342b638e5299018ecacc42e496e7b476d7f35ffd6568600573da43331f36226 0de99f05c276e608427855984b17f6a513383f9f3fc5914d59b85a214dfb85e2 c9013f923e6e641de8a15f21c821c00ce771fa5f36a35d6eb1cf71fb4e633296 a3ad1f8872b82cbf7e2607b5058ae202ed1c4f6b5a963db93c46722295f31479 f82e25aecb0428d36f2cd0ddd00a066b4d1dde1150f0a098c2df2c51003a180e 0b12cb3bcac1c79d798fc51b32de043cba54ead89ca92ebacba60d25c1eeb057 d5a7bf94666cca12b65df7241020dadb44f4321f8a1784a3467c2a2950723465 c439609c1bf47a2dd78f7bc5fec76ea959e61a531ecce3c5132f0470a438ca75 88fc504b3792b714cf1a6f09ea06a61fe625aeb30656061e42d839f0edb32db6 e2564ee229515f37c70214195c39dc123f988a4ac285f53676330739b5622da2 ffea0d4088d7364d36827ffd49a02c5e67d2d1fffda60e2268a361f9e665dc41 b90a124da487e998d333f782e11a2811d686dbb2387fdcdda8a5d03197bcb4d1 de4c52684e022e46d24b2085c15ee9750192427e7a9802e1a36cc1ed2dffbdd7 656f299420103185383c44c5962ec031388ed71a73bb7044d789f2ef6cbaf1c3 970fe375583d4dbcc1c7ee1ab99dbb0c96090524ba6eb8824b1675c15dd88d60 aab8f210d3a0fba5dfacb2d7173f21afa3ee0d6a987478f4feb3ad810c5f6f03 3396e08c2650fe809a12b5f44bd599b2cd4fb31c4f46ef409a49fd84a77a01c7 834731fb9db2e5f2d6e27bd7301e26be7bdb804bf83c1937c3c4161aedc86cb7 f242fc60275cc30369ead9e735952f6d7dd15057595ca6f609dc5d58a4791703 14323f5c93b07305aac7426b3799b4887a475c67dba4765ec8a70fd80606a399 dbab57d98c775867d49d6c52423c0b126804542d411ce9ce25cf3318c4550e13 d3311c559c2b7a814beb3beadaf4222bfb4cac71bcd7983d7217cdaa543228f3 de0667f53f27ec36fc2ae62706e8f1f31ad40b7c41c75ed114bf0e330fe87e2d b69135ff45f3dc2aa4801bc87c3fef26d331bc43ab564b85c13b068af18108fc 661d565d6920d157cde619ef12b6a1c5423c76626316733b2f292d9cfda997e7 a0c95af16260540b15491b134d8edba37295aea89c0100a1d48ed2c2b6d48503 92526a2a4f3a617b69c8f512790a038a7108df70693170aad803110083c50aa3 721bdf17a1d57f5d868618a0ecc1b30e5c7c532d4313586febd088aaf1e6e0a5 b15a677ed4b10725e31febc960832c10fe1aa4fdef17c7689dfe10b4ed11981e c556abb91a48f5bf50334d76d1a57a158b724738b1958de18091dd10c248388b e15542597c42cd9489f86844ee28eff51fedc25230ba60b8cc0e4364bcf91b98 d393f580e3514fb5b11a65053286acb28f27681933179ea9a876b5f8f93b438d 89e823eb75765537b62451caf9716647134188fd01e20fcf5d64c91de0fba39f 3c2aa2372f3c532107f71b749d27c2e6ff868b6284ba697cdd6248a2282f7abb 47cfaaa08546aa6c24db8b82a782231827772af391cece7b743e458a4d2f27b8 022d88759e90a3a7fe32cf5d4a589e2b6945a534e72ab513416410d5e062d0fa b1fd2452b06dd3cf267af2838907ad6e951be731fbcc7948b41d4ab9e2f3e6ec 1e669738dd5d5b4c60d68ea7b83543be705962589858f38abf7c94154778340c 6704174c51e37e606f2f59bb4b0d81e7911a7106f067275bccc9cc728167969f 27c3e5582d3ae50115cc2ed27ec69dee741d220be586a8e4a15bf11061f5199a b3e3cff7095f52fd5d429ae13feb9bb07d950421ce8d6eb5545c9c9f37ad7e98 c4e86321804d5a694a9cb01c250da8cd8ad9ed0018a57f753a9727939ef43636 8747be44c733b2774d99dc0ebbadd1d5a265990f3a89ec700cf2c2bda2432055 f3fb7830410b46dbbba5df560109114c9b93cc53944cf66657bbf67a4a3dab16 211000e8e40923d62ce5d876540ef386e9bf3d3198644fcd5aa5e3e82066424f 2013502249fd648ff99a93f5c1084e6b241d048348cacf5c07ca96323798e31d 3785d7050ec2fab2bdd440022329e791610e489f9a295b71e241730578e270bb b58f968cded07722e0ba9b26a0be633d011797d1a98328b938aeda8a43815466 81b119e54b8a5c218ea177dcbe332564e8f58c22c08965e6a697595b708dd9f2 569f521c520a7bf7c26733a9cafa9f68da5c35b0c66f737e632a1e8789e68dcf 20f86cb06e37a7a714ac5dfec96d1b59babed0d5635e700fe647de211074cb96 7878ef11b7770e557684f57ca6bf19292f8249ecf579320baf1cb189643f0b9e 80b6f868d06af612f5b7607126bce9df1dd538b90bd227074a493bd0f5a3f67e 33cd0f98b0d746b94675d42147c90b1bcafe16bf4234388af6cb8cf5672e372e 96bfdaa51f13ab4b987db32c5f6c2091c930e2141eddea4e71060d78da517726 f04903094be80d8fadbc7adfa9dfa821aec0e7d7c412c43752b1b18fc02b2f59 1e1a145654e2c3a77663dd13c2e83bf42b183438281cc5ee4f9496120dea8405 50c1b066abade654288d38684a982d38a346295559d77e14eb87ab9c951b7300 69 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 +generate_ring_signature 4b99442b09d30a94e40a661547b075704ff7076e432907efa34f28fbf8f98c3a 8c817e1ac218112b22b9f47fd1d7de82f36e48900926febdb32adcfc4e4503e1 2 3596cb2eedbe31599dd34e5577a038571b60800da674802f977182ddebf3cefb b290773d661bfaa5cc2d1db49b3633963e714e9c1f3cc8d843fb7f9e57e199a8 1452ad276c1cff34d8ed225e848e5f61080b131f2500d6bd06b7e85f85d08106 1 1f88679a29e541d1794d3a1691939d298f52462fe6129db19615d99230dede09b53919725baa2fa810c86929c2ddb6f5010a52a79ea98c7564538ce4dc6da805e5f8022c00ad401fd9c25c3c1b7073be1c489440cc66ab235d4122f804210105b594bb10b7e0469519a6db00c246c091ca4768f5b5973503b825c06fd773210f +generate_ring_signature 308bdb322aa460f8c564d2134e23833f4e567150599cc3cb027083c5172a9ea4 6025c2ce5f391b371ceab7d0e0a0718eca1a660603056c887e0117f0c838737e 72 2c78fa1ff09188a0c4c26871aa125e9078025ac1e49d77593ca0dfa1989421a6 4dfd23fb69675f8836f93cda1dca1f2c55b68a16435d8ed3902c45709f11ce2f 9562994d83657b04fc8a26ec25ec00dd6c2650781d81e866a1e4ebf78e0ee80c f5d9c7e8ad13a830598f6f587c48910b3cd4b8d338c90a3194f3cc6b8c0a1a89 515aef296c04dc838810cd2dcfbf8f4f42ebfe4942679929cd3247f333a7734b 0f0f309eacd4b8ac55489aafba5cacd746a1643399130d56ddfc77e826feebaa 464b240b5fa690508441a556a6e7043451d269ba3fd38658a46dcd78d449b781 662cf10b9f6900077f61ef37bf3b21a4b42e0d65ecabfcd5c593ec23da6ef016 48095d922127ad39050e52130b408147dced83e557b81f237e67864e68e2103f 55916c66cb8086f42769ccf831cd4356d31eb6c3411db78d8b8a8e5d7e26849c b72e843b6a252e3d6cb4f98bccc29bc494779c107d385cb52fc9d90fdbbdd43d a9264eb06d803e5d7c9f5054678d649d87dbfc7a2c826a2346e6ac929b55fc48 df7e5cb855d1dd60f6efd88d00d9439c92fde3b71567cb46aef17c76fe53e51b 5c3b976629247f7f10f4c6d6c52846b9b4de1d7a258d84ee0811d0a417939e98 55a366725e671d0136fd0b711fdce650b77559adf56753f07c4130f18a36f024 c205931d4633f04b17c931fb00f2b47b8b7fe2c9de6def25496ebe5f61640bca c3baf879f8a858219e26c7983a5cc8618af19acaf1871fdecdaba355d6ed48d3 5fb47938e220e2eca446595c8396c75c28d0e180c2b3b6c3b4d9c9c1593d3ee5 ba26eded826bab30fba456ea53f5c34c97a1b5a985dccfaf6718d1231db6bf50 d5c01cedcbd2bdde6d37011766d8a864ca0f53943501cc0ab3933a86ac0a530f 434dd5d7e49617695b786c2ed3e851b1b76a5140369e2a390168d21cb99864e2 f87c29400d724f5c0c8e4e48049538035a4eec610a74d2730ed76176efbd84b1 ff55b2cd5d13d4d8da692ca9a0d1af104e1df3414e4b0b1821a56ccf676d3562 0cd6a4a67367d58f553ed01253582a17d8c85d8434b790fe0d79157e8b7a3fd4 27f75211c127aa1f68a3d22dcd83200fc3916cd1c7951e538600a31d19202599 3a23e03dc653bdc805cad9a038cdec71a0bb2bcb6de17e2db4467df3639ca7ee a1b76ca66834623b4a2445c7f369cedb1b2c0e884f938598bdadd245822ae52d 57e14ac6cf4de2ba8f4a4fa39131a40ff02398b2a2217a0747b4645c5eeb5703 0bd34d6cc73e4824f3b96cdc68b939fcbb3f3d64f85db0e2f404189d39e1e3e1 abc73c606cffe36f175a81afd69e3bdd7a6d534aa8da4541aebae0c5d78ff2a6 23eec063528ed18f12792077cda4ddcd7623b8ad7a8d9f194c0b25495d6d774f de751896b52bc0803437ec63efe0f68e6c25b17211373a6c083e9233cecd4c2f 88be6f30459ff0a926a4d7f57b9a71b55250e9387208b19b235f4e69511ce887 d64854d2a0eedab738b9155b41b30d425512d2165fdf68b60963e6586f0a75f8 29a1235869a8d737511ef31916570692eaadc9fc5a836419d91157959bc7408d 0cfe56ba540437788376011d248c5b0addffd76c8f183e1798a81a05995eca77 1d14bbdc17e017020d8c6696a1780ed8a92c1d25192da8ca83a0835ae6ceeecc 603114e5f9220594cd088b81a0cfe4b54fd73e0ef821e478fa1b3ce7dceb32ac a0fc34ac08c99f31ed89e5e310ff55208bc3fa2b53a750383992d460c2a12dde 83ed317fa3bcfcd2d5119593bd6e24db04b15669af5384d08d1bf32ca220a60a edb90d89c6618a866613546e755fb50ae469b95fc7148baddae72f531090e1c9 d29ec006b1a758c0cc9c6d3d9f2493295c574f90d6c6ee53840ad28c629fba2a 1e8eaaca2c4a8ff4f4dc13490237a0a97f061741c0b06dc5ce2a6acff153bf94 68df50cb1ef38e0ae678b4d449ead853d4845db7c1d41fad198cf2aecc594d13 e01e97370bb7b5364dff8611ae6da78f1a38102bd5e03c5e24eebf24f4ec00cb 5553e29cbf778f6b48e8c5e2a68c9bf3d81442e1ed81f25ec700a9e23a662466 23024f3db8eaf17fb8e0e05330a1c9760245afcadf2efcc400df7c7d17a2f767 a827106be8428f79cea92551f543d37393685ea2a286c66cae92f8182cd39605 0b08a56085462887c422032a20128ae61ed97dbf5e74fd8d93cdb1b6e19461e3 3b2c211dbd384da555d95b648a128b56ab6643b216cd0ef0b3efd2383428be80 ef5b4344e2685e2cd651042f3f03dec4e83d3fae8e19f7390756aac1252e8a2c 6874856045a450c60b61ff651b69e34e2c834ccc28f7f483485e43f2b7e619df 397019b0b5f8892c9cd5578270342cc060f29908a62afc7833f2132ddd890492 56cab4e804d55cfb63ce4827aad3984945bf52a980afc5fe65fe9724217bc007 516eeb63ea2cbd880702aef419a1a7d6b300523168bb60c1c2f2176cf1d3f0d9 0e9ae60794a835ce5d1988d7c461eb18f25ec62fdabce76be9ba7937a9f69217 0cb857ba94a45956dbe3c9634d5c0cfd5bf97ad640af92d0b99fb0544d7693bb 2095075d719d82294627cabd25b7dfaf7158c62ad211c771d3644c29a5e8bc7f d45ef2f378c76e52ff85f3586e3fab64411eb387e3a68d54834160e9d4f75195 28e2f30d2847b093194a3effa41f01428cdad1f2d20cfba6eb5139f9e0163a5f 65bbcc93001475bf68096f7cae42be2412e3ab74a60ee2f4926fe5c6aef83f0d a61e3661ee0c48cd01ada4fd2be409d2b461acddb708ec548cc1bb0f7eae6f97 d26de17c60cdb8043f11c087f8cbdf014dd27c7ca80a08fe8aeef96d0a1745d5 1a493350e3b85b91b47d8f1f52effbe30f2927f6f86b73d13a1bba57eeb6c67d abd5c231d76667750f9d4a234631bf3f72d067f1b88a4b0926dca81004b3d0cc 1a3e09ab6047738e738872c6cb46d5157a0978ba84af4e4f4436fcec61ab6e6b 29231906cfdd684e0f4f21ff0b0ab42e9969bf6d6064b38b735f90428296105a b4f5a4ed8d4169c040d9a4c387eed3e2a2282668f95e5d59cda02b9282432bb3 321e8195768e71c1859bc220da29d8b7315671615da6f7a1c70a65c08a1c435d b8b37d590b0147ab67db2bd9cade249369b44bca21e7027d56b61f375e643a7c 4f8253bd0d973bd1079b792ce8e714edfafc5b30625babd7c6c2a9f04a25f074 466cd2e93630e51c245a31c4d6cd4c6918374d45324eb23022b87214a23d4fd4 990b405d17c5c8583ba5b4967781da5456316385111c52d4c1761d44062eff05 19 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 +generate_ring_signature 19b59e689992b33510cb3a4641a0487214eb16b6c4ec84f17a725a64d241eb02 35404cf6de872e69cc675a0c374d23085e607a63b198b243575c3aaccba5110f 55 96bfedb655e4ad5ae088e1170a9f8b58daafeddb84a3d8922c7a695e82e66963 b57b0dd3ab098d2e5a1cb9df3b9ecdc5e05a5a79a40c818eaddeb80ef3502be5 679c0ec82de8ea3d0fbbd4f41f61cfe30d486e8d2807a7b2da091c4e79cd7efe 1859dc973eb9798fbf6c7cd07db81acce29d707577dd72eee64a3d5373103ff6 4749c0e2a2595df0cc7608c1893942e2bf72f1ceb3e4609d0a12737f3268378f 34980ffb911d8f163de0a1f2da648b989d2b38f41e9525b4fe2e1f5647a15263 8bb5ae4cda78148b7b0333f2ea45fb88eaf413880cce4254f6e84dcea809ce23 e02027de37ca5fa4a7490a35a52f26d3e1bc1a462f8357c3ed9db7f7ec1bf6e2 dc30251df7d13fb90afb8a6360bab069a15a7f18b2db02a80da3a3906b96b479 e72e6290ad812eb649b4a722ffa13919d2e4fd49ff4a44d5e1f8d80976553fb3 70caa5ef3d0766d48c6d9a6728d0d539290b4a68452876c9b8554590429da46c f57560f08f8f42d053aad27a4387fb09c0c914d921b518f1d158dfdf16a4e17e 4655b554d751125b469451635239474a94238a5e59aa3ed0766083e11ebfb9a7 259012fdbf5f5453f7aa98d6b021c4da9214f34f297b11e32f1effed4bb13909 81b66e8895b7411a2c7b8390c0b20673b1ae12dffcbda94d5561646a6d461dee c62b504e655ebf52bf1d72cf50cfe4b4e25a67cf6e968c939e8baa09fe05ada9 139ed705b0a5f440be69de7d7d3ad3a2996d36f8f809f02bfd42398b02e91dc5 392f1fe7ff4620ae2a3757acdae3b4ab011418e843153628c3193db731eca520 33c7d48405a1112a28fe51de2e6a9a9fc35669d246f23b66b88fd65480c23a80 2ecd2cff507a023c57776b03ceb8e75536c3ba9d734bb08672b7aca0a81dff95 4608c674e9421be71e557739fc5b2b868c8e46717d893c499a575d6d1f6af1a4 5e89a1023aca7015745d6e134222ae6d36574605626c816396755f0be2d68bd8 004f0204e19cfaad23af654dc4ac284fa89229c2ef95b9bbd5aec1e0e106fe02 20087f0163ca1244c5d52b7d9c343f4859f0fb8151f0ca44fd58e9fc28622cd3 d061d7f431bfcafe091420eb0bf49476ee690e680f63d2cd8e57ee04ec315d43 17107bccfcef930b408cbaefb05256f430fea8dc5fd4250ac9dd5f4ed3fc2547 ca339d35f0fe605eb0587ec378bf0f3bdb44e11438f999c1bb1c3c5637b7e2f5 2f89eddb111d0b6d8ef5a6a5c265c2ffc491d0e9d09d0017f494df2dbc360f0f 88719f6e415b781c843652d420fd554d291f2c0e8cbebd6d7e0fad80c04c809a 6e0b292ee1b4bf0767a7163b61c7d9cb7d4cd45276a78913b07b73f1c3c1d64a 4eabea46bd0266491d0228719fc8073a404fd25a4e837accd5251a61cc87c02b 2017496e7854f8fc95f17df21bfae2c0afeb43aa28c245ffa1b5047dc149e89d 24589b406b4a7698016ffb8aeaf5185993b8502e46d46e3bf37bb078623496c9 e8e32089aa49dfe331db6fc798abbd5c3f2daf7e1c98263cc7869e66dc7adacb 05b2f33d72ae54e95169937adc6420774768db8a9e3d7236edea05e4455e18b0 6a4b66dae9632c12f4daab911b0d8b9945fb75c25360549c23291cd63744c3ac 8f423495dbf74ee63563293a66074bf15713e1d3f3a16ee4d5f33d414bff6fa8 3f53e929272cc0ec8e023cc81acdfd50852273ee9274732acc069ff56e8644f0 f0a84ced9df533d2a34935af3d0bd07d544b2e84ada7c3143df14a529302f09c 39100e3dee3d1985e04694de6a49a082df90f3f14e07837dfd96298ee8019252 895b06215ade6268bddf5c5accbada81af003ff3a8326701c7c4b2e4af1f3f66 a99ddc831aed70624f0e17f8e1ccfcf5add0d30ff448ce7bdc08d6464fce9e1a 60ce654405b62dfea39278dfa49bf1cd1cb640f60d3bf18fe3dab964832bb7b3 0f755692573303969da6af7969a990f4fb4d0d5a22c1c446338c7aa394b8ea55 10da39906513a827a213081f345f6253bf93cbe5717b8add690d76499580ddf7 b363a3561c0abb151066a5a39b623c9c1b7745333dc16e3ff858b227588b525c 6436c0ca822aa4068aa89054638665f1936cd2a00ef7c68c18a200d5731748f6 310c66d3a506da4d1cab6649b14f875c07df63139e6c4424791fdd7ededca9eb 5137254f8aacf7b9b331927b27c932f68a248df87954633c08bcd84cf7bdffb7 1616d9caa4875622e3802ec550aea5d449b648ebf710a77d3c22eeecbbee6f76 56441b786f910a220f80a7312b1f58175bea544c2831d29af67671af474cc5f3 dbb337b8152363bdca9c7c7b15992fbf2797f113c6e035310becf222ab12b970 36fd79a1708fe543dd785cb28caa54f1d2224b6959821294d8bad2ba982ad4ab 745e169e91122070e4320302d73305504072395f02a6eff85884be79abce0c07 870a32a647e2db50d03544860d834c1c4666eba0e351ff13c0198bbfcfc89c46 f708b34270bb6c3817c74e5227e43d13c13ce3dce8162b8ac558da1c2e81be01 54 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 +generate_ring_signature 4672f905fb42dc0475983eb5a48f658a06268290809009c1c1b1d2c76fa8b2e7 1e95cfc5d2d71497ba502d461fcb7ea9f9768e229b9c268e3f8341a4f254990c 1 3d62ad8a5671f7bb33e660429e1a8d65f454ca409bded90f89d659e10284641f 303c8f50c931bd0703582650568fd4d3382117c521de689e1630abaae8a4440e 0 c285d9329ccf56ca829ba1734fb0c2412b03400c6080c75b087d31116561e40e5e36b92eacd53683b7bc597c842296b5175991207e5eb0be45fc168e9181550c +generate_ring_signature 3c562fe4a9bf99c509f2e8d4032d42128a7e92b168392d9538b06fe8f57ffe7b bbf7fab81426cd9d7f448815014c590fdfdf9438021002f067664326bf4c972d 21 f766397c6872286d33fd553796dbfaa31e7b3d1fca071ec0a4460dbf140a9f1a a6a61c5ffe6b77455c458b3cb3e48ec99c70963f3d0b7476f2f3fd49d798bdbe 23ef9c123a46aba32944da02867fe6dbb83456fd81e57ac37c04fb398d748e2e fb3870eee10bc2a23e5cf82e0023c95d7de15ac76adc77a78e4a4c15a743b52d b433b1ea0f29c61a863315d234cfe7abf86106226da82d4de2a59efee82d4a97 90c7cc26068024a6a5ea19303358a9768440254c5fd395e60770dd114003b12f ebdfdeffcad6e468659e5e55c0702cebf169e0b6505bb802101acfa7936b5971 b558862930e7fded4b64474777d7e762f252d7e5ef32cc0862f259ffa0cc074a d10554549af45f28017be503d7f9d838d8c20afa543b0da9cd28f45089401038 939c678793f7619c5985f478b78f90ffc9b3de93a2aaa1674ea9a3b3f5b4f369 e639f8e4a4196ea5094fe047663e959e329ed2a9c5b205d4192213c5f3c45201 1b4d75055248504ac3c2821e2cab34035c4c28941960bbd177208e10499f0bc6 1b6e7a5ea11b4e4a042e2e197f06dbeba08163e681566fd83737e209ecb69678 209c34fe577f2dd7cc74706175211a65b87489553fb104c9da0ff1cf5e5c402d b1ce728ee6de1e258471179dd350967dcba276f7faf60a9659756e1d545811fe 8b8d736c76157dcc516cef83ac9318921e9d6adfc0e4a40cf686fe71504d79a5 96331d76ac46063e2d60b4bd809c91e77b893c8d9e2c53d27a1c378c20ab40be be0d16a05eaa11ec4ef8283d5f1b3ad1cae73883c059d855c7d0355c1249dd23 ae7000fefca7f670daeed94a5f3ad56697fef12313821842c0981271f2142d77 8c5fcddd3f4b3855f1d17487883f33fc05eaec1c7949aa9effcf1e17eccf8895 8900e46d54a0a2ead552e74ba2753b5c8d2b15e381daaeb48569029433d6e8f1 edbafd6cb274f37b1783450c83485489e72afb99e07afebd2853f9997418980d 19 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 +generate_ring_signature f429996a2c98e465ed627943859394523fd3edaf7ab2a919b0d190789e34546a cb0dcebde38589ac7c0859ec7885c7e6952debb5cd69e6b0922e73eb31ba5068 14 7d8cf927a4b89584ee99103b0203a51636d454aeac07e163065565f37a22449f e5390b19dc3e87c8f2e8adf3fae09348f3abd92f936d3a4c1ea8700b29e31dd0 af63ef0b26af519197bc1c456474274d00301c68111a6552a781de6b5989d86e ad8a74a8276ce918dcfe1f633b4212d61782b38396082709eec6547be24cbba4 dddfd48e4e8599d65a87c7ffd853402dd1dd945df61402d6f5d1ee5997bc6f04 f5ed6a7ca50fa4352ef8b230f8f043d2109bdc4d914492233a24bd51571c7bb3 e9c6b1dbb79c841d2f39407336f0536b30466d76dd96c30634acfb4132718d99 06d9d6ab1381c4b6e3f914ca3273965aacb4479a575468aa84dcc088f675009c 4bca1da62da88b5c0194f893878425959abba8f1b59f70f8fc35e90fcf04607c 537de67dcb5b0515251c02ceefe5edebf29f96c3dfdc4cbdd80f677aa7a86feb 81979c19b915ed61382c40953dc698d9d2ab5487d8cf9de2958dae69d165f8ec 939b33105fbc1114c67916681405b0dffd88c6b9d265023f1889a0ded6b6f715 1da95472cf9ea935e2225531660b0340f21d8db50b8d7f9ef889ea69386884b5 bc01a282651fb0e13e062be2ae48dab4533bac2bfa7a069d281db33ece3bbef8 9f70dd260c97b39abfe0fd3a4773ea3e31f4d4a440c3f998f68482a6a580910e 6 9f6801f8a05777a65b5c4beda6094adc33aaa7d5ebdb2f0eb53405b77a158908c4f15388b21b5fe972b210f1cf99e482b04ab679f72dd0e69d9a3bb4b707c80601224b6201ab48acceef0486c3b4e4c928d34e23ecc163d9ff6d0bcf72acc9012d0d8b21bb98b18d6a3f979a325e8b8c67e025f48c7b8bb98c57af6bb8d83a0991429a7bb2f7ac13bf975ead5974e0687db035add0e02583014c1960cb6dfa0d24089eb3071c1ae33345913b4cd876902c7626529bdc922ba6964e67807d4f086390c700fca7e2672e02c36e80be27f750ae158fe426df4747716832b8d9820cfe6ecf8ec61c5cea8629b9661bf59271f2befa1e84bc08ae759b1e9e51fc9805e38d289a60f604a9b040e724a75231ead53bf712cb8717a82fcbc9f20f63b70f779f38800d96cc5faf80147d5ab7f60d23f9c1b74edd1e4c297a921932825a085cef4f8507d00a6f98878e01643bbc55563a3ab6e249c565e9aa5ff55cbd27076c4f11fbcf8675bfc88ffb36e20261d80a1b62119bfc032faa6a1788615e41012e1b490b8b7128f57cbeb05ee7271c1189e9586d3e554ce46089187197944907cfddef65c4446506c76be874942d3569a6f8c769e6315c8875d7ceaa0684690dc3e42a5b6d51c6cb5f3376c38529adcf45a14842bfa3fba569a7765e0d81c708eb0fa4268b2a9db5eb4216472524716997c0de4ca2a9f35569adf07ab4b4ba0fbb6f90d783ae4ffa53c9ef0eae190f6059b24d9165fabae62639c3b74583a0091b9a8e8d5d6b8b5ddf2acf5b5dc298f0be6038dcb2a4d29e54e5140d80a4000f39a66a09f627276eee4015ae1aa00ff9d24a4ebb9ec99acb110259a272d4f608121e664fbf624b4609059e2ae13083b87d80975316e07be7e4b4de6963ab6a0cb710d30fe4c7eab72aee4bb3a3b4f57d00df893d3e46f1e2ab659345161494033aa75b6878c18b6ae2bc364dd01be84d3e1dec2919d230a2cf941844e9e79402562152f67b6cb838b016874a838deb12beb5be486ea65e36ec804eef3ee4ff0fa9ac607e979484b252eadd34d0bdb430d13147e079e4a8768ec0595e7d4b460643c3139d259536752f2b04a6c470a14838402c797a72ddc6e51235c647b5640b7c60259ea3b2d78c1201cc7746f0b13201ec7c9595ed3a787194505a3edcc30490db343ab3780607f3eb390796ba094cca5d7f3f26dbf16cc01ac072bdb10f0affd43cf2a5ccae647f654c583ed548038c6ae0cc227af066a73c57450b665c03 +generate_ring_signature 8d14132e5e17124e6b09f1e79ae09c053856be240e8c7382f8d6c420f7904300 96eff4358f28c028507c8e7f0972dedb4330b822653b2b313f4730d46839464d 6 c616538cd58a741d5b8a384cdbb2d17de994f61c90f280f7977f1a485c2cd43f bcce7c9de27adf25424520a824e71ed3e00652f7a08dbab59ef38b690bc64d3a d2ac5e67b93192d3714c302e2c933c9a303d484ce2c69c242fba97913dddb0dc ea7b1655ef60438b22f1e7d37324d92b4b548aeb12d7b870f2cfceb28d0977c0 2cb5bfe3c0d79f7fb25ef00316e250bec871a4ad7f103b6a9d0c0ac7cea10375 0d5bbb4a6990c3e1c33f173354732dceb862bf580770829ee361569a8d77b44c 1196427b5966709ba0a1ca8b6cfbf60f91fd6a2c7c7e7a6609a63ee0f801300b 0 5293fd36be926312fac50ea3d9984e1feb15a8bda6ab9c019538169b9516cb0b3b43df41eb8e73fa61701396ec4d011c8c32139bb261b02bfb6267d5cda7250742ba5cf2613267e0fda6258e7da769546a41b75f7347ad0f806a055cddaaf80d37d34bc5e89595f0a0c86413819cdfceae32e442749bec9f71d164dd53434c0235cb94e061389b8a6d5da39c80abfd9a3e6939c559f9e06281c6283e01f35700d0b8502cb342a117dfe675bc8d58986f845b6f8c9f3f9107083b87fcd4c2ee0af413e60352f88377a2b30092589220726414e82bf764967f45b3306f59cd7105dceade154847140312d3050db6a5ed77afc203d9e0d7bd9ab7bad446bafeec01947d03253820e53681e8365d6e7ac398b262905619ced8b8fe9d2791b286dc0c8a9f28947d0d08f424b55e689703f35804118f6407b357dca957745a1fd4380b1f59ae56ab316621401cea1f3187aa8a7e2c0572a6008fc796211b96012a3c0f5e7b8815840a499931d4b2c13616b3cab4816287ab50490ce0e68234626f3c0e +generate_ring_signature 05b70ec90350d0aacf2b9be53ea0a7e0912c456b4e0fe7f3efa8c7fabb1de215 db3f8c06eef1a728af728ce5e028068dbca392543d43b30e3408e70a5301e4bc 19 fd5ead415e17536a9a92d5d8063001eeeaf376a4408d3e4d3f3351200f2fcb0e 05fcda741a631937b631b745ef0451150d9442798aa28288c6a2f7c02d12b08b 04bca31da70f07d8e34aa70087d78dc097c478267db53798b1a4003ca02d9e1b 8001d9b613fc98a7a3fbeaa7382d71a02f566f02e1281abfb83888e3c83c6825 36b1a72a97fe92fff3d983c734cdbd2187f34763c98e85e9bd42f90541aae212 11d585e09e6cf199be4e13c2bac0b996a4addaad8b1451e5b0afe18b53cd941a 766650cb51e01a611c1724099e9999c60634e1a3cb36295c58ed35d4d8ce6860 8151bbc0a9b80790b44e6ce4542749de5e5b91171f0240b2a029d27e51c56836 a84a16dfad85aae7dc4f86f3576d396cf2867961b129eefba1c40a9b87895f0e eeb46b381844257d051435756aeb6e235b92545095136c1db72d84edb64fef7f 78ca044b9a1ef85d91d558d71046768bb5ca5e4cf1a97a693a51e25c3590d514 953c11498b63f8cbcd143d0515aba347c20c61fe47168e7c862466ebe875908d f11936b0f1dc77561fda254ce5ea7998bb1c00f4e3e69e6c63b0795d99961d93 5de09f7a41ebe987ea155d42edd7283ce1548191db18aede9bf0ade990936baf 26d83642ee3546f8334921be1fe4c766739b3e92dd8a29894e1e348bb6fb428b 48a98894200a4b25f10741c42195b8700bcb390b790ba0e01000d3477b36549a 4bf26521935253ad92ba75a2cc88b931d82b3c79fef8e5971f228e34168ada07 6a5cd2c7a32cecd50514eb46046ad996bcb2d1eda668a7f82ea105756cac2b08 63b28fc379bba0a51da8d41d1d89ab5cd2d5e514fd7ce0830963bbadbbbb236a 15af32d28b4350f74faba181075479bb3c5527f1ed7172c00ac28b703127b307 8 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 +generate_ring_signature 8e7b0209eaf2cb145700a9519b958e08189855775468f752b72dd90602caebf8 e128395e02c5766dfe8e16fa00f544a0f7e6cb5e698dc00de3683278a33a9d11 1 702d51626defaab76f436ecbbefb7a1bcd953735c1b585149a4e6ae7c87ddfec 9caeec6bceb4ad72ca57dbf1562d53ea0a93feb6a69236f8166f061d93f2c901 0 0f76b858369550c770ac42ebde84b23ee1cbdacb8156108d01b4fa3bfd3796098c855147c24b4cb0878dbe70afe1c36ee316589cc134420d8d1417e2c6e27d0f +generate_ring_signature 8bd72f709b787215cd41c9f7953b0287d08f4e6a73780b558ccd03c3934b5918 8d3904d2c864c2c47ded0b25d5e6b125a902b075738deceafb17fe51df3357bf 2 ad75d42030a6426aeab0303392ce21c936df265c5557d800604aa7c3c0e390e7 7d31f2eea57234b7d6d6f09d4ff58cc4bb7d4be04d9c40fa925706466bb82f0f 807012275c28d219e1b973c1ffc62aaf43bda1b49fe3ff094879f9676253b102 1 deddf650adf1ad27663c1195ad71e87025cd7340d2f043f61268358ea13ae20822e8f8a267a1e38538bb1ae5392709e094fe8f234fc8cf6ff9fac571a85e480b4c0bdbdee87ee2a1b44a654585b6eb3162d1b14b52bd665646b2e0d42d07940a5d900c0d3a418aa612c6b45e28f23ec5447e8e70461049361e5951cbba77220b +generate_ring_signature 21a6e77355023a1ca3e620126ee0d7f247f9a814e40125e2586bc9c6773928cb e2814a98af57ee26de7edb7da847473008e128902c90ae796a9980863d8e1df6 11 c81a625349ab970763589667eb533b4fcc76f764e525ed10673e5bae74bf508d b2143c5206e143dd966e38b3d6e785a87b631bc5dab23df88c2e357ce6753e35 44f17cfc3e461746a121975377a05cf87c6bd41ec84a480fffbf045a4b17c0d1 737dd0a57c5bbb2c5038fc3d084871aa281d087040d47b5cc36c381fb25e0620 8bd71c4407f1a7e9048cecb474fdbb527f15964bcd2f9a06b540050b372bc542 f31ddccd182e3b9530ac13eec95786b47013c9566499c20fcb8b31d6b3dd91cb 074096dcf159f4a52337d58bca2b695a95f087125676381832a4547ae6161d4b 8536caa0bb2488682c0c5eff2a2cc7723dbe1741e3ee28194228235a363e7f6a 3ad9404f37be6a07cc9de38bdc1893c172c9674cb186070af90ca0cba027035c 9cbf183bc430c397a8eea5cf733dbf92f7ce3a0365319b979dd32cfcc3285cfb 817989a15ed0e35bbaf2d62d94a2a6bb3025c795f830753679c3773a8dcf6cdb f84b370bd4c5aee8c383a1cde66c5ccdb497c2266a6b15e53d4bb6cdc0535305 0 fdcf73436a15f9719e40e4f516613baebc5bef3e16a0c349dc98050faba40c08fdd217834fceea2eeb6fb1b26183f1c391bf18514d144f3cf948fc344107ac0de9a7740949a4ea8027a254357e28b6bb22926809751794fb1cd60d5626b48d09607906ee235d2669f2f9eb0b75523577e082664abfaba3d5bb3b19d29ee09a0f8d24edd03bdad7376b9be8c727eb1cb88bc913d9f24d62adf671f94aa1b3ae0fd62516e4774fd62ab3bd031e3e34096568da1725cfe5b47bac6734f12f994c0168cf5af8ac6dd2dbc4243b4418970fa6365cf87ddb2ed92f2d9ea766fc14430a2b41172f53a5a9c676ba7fd9372294b379549fc476a2df4991878437fdf3030017fa4fc831ac7ea5e0b251f0abf12bc460ee8167bba7f5516c28a3bfb1063e00b8d9ef5f0bb0debc015f77fa0a5be2db59bc735eaf5ac3d40fc5ca93ba09e408db166493edd9b417ef502a8dbd767bebde023bac5f03e0c7d7288bafbd0a2f01b9b4c8c0f890bf04e5662d76380d5efe870aeeb16bd1f848b7a323920f51840daf53c3efae57ea72279c85e8cd8aff4fa2f10bf9d74263fb794e18b95b753801d2a9b241e9481c296ab19a246c1a5c357a9c031b5de0192a6a6b0d80735b5401e295b6adeeb5378c09d52909abb3a7683a8eff68860cbcb3fc43a6e6dd0c9b04b761c51ea626d8a2a58e9e525c061ae0fc19fb8daa0c252e65fb4bb874e55a056bf63e49405d6c248fa3c2ab492936afd7e06f6c8094dc06237f640b9e986a0fade4c1218dfa65025295daf83429cd5aa062027362d96f3d64784fafed1d3507cde328bc85c87d14b9cd8ad94a4b4a04a146c12598643cc13457d34bf2feab0d8de25858e3046ea19944cf57d0f8cafce406618efd7a1ec78cd947cc9914120b558b1ae6b72a3ea581f3a331f48ba5272af4f75cba497bc77a465a55981f080aa94243f1872a8b0765fb471d625ade22d903451f3deea9b39bd8488221eeda0c +generate_ring_signature 267687c04961afdc4dd6108ce46e82c9c5a60a6db9b613cb071a86dea4069053 1f8b194a5dcd594d315df03b43f6e6c6d8ae58b51fcc06678c93ef532a7c2ace 1 6bddec7e07d75ea37fd6fcb93b7094d1e73a56715a904647d5b0d572a6d2413a 83e12ef8c17ad0741746e1edde68f34fc3a241e9d612df464f282e449ecc600e 0 1a09dc6d305008203c03829bf58fa4c96552dfe65348182cdbdd545e57be87087fe382cf122737e2b8e850344a287776140b16bb0852259cb6f77fc09cb6800b +generate_ring_signature 9310255e1d6492094731550312eec4fed0f54ea5d706cb2a611434e94de2f67b a6b30c2ab8c81f1e2b826258e3800503430825f7f111a5643034ddaefb4a9fe6 40 41d5a10bee397e496d882d7dd820e3854bb222240d4fde670ec2340931bd16d4 dad6b13bc8910f762c3badfbef8a686fb787b6511eb20e7f6fbe390036b2d3a6 100588d38cca1dc9c852d2f89a1f11a246fdb955ec2f73b8d5f8ff3e915beac1 b8b3ed919d7d75574bad2a81c5057b596f62796d96acea022784cb653bd4ad0e a0e37438540bd74fca28cddf345ef304b579ca4fb60457b02a9438dab0cf09f5 e5971444bb60d3b5cf42a088f0e318d2b3c22e356f97457dbfb7362d91f866e5 a159413d63e3466dc7cf257d0e5c094d0d5f87003c9bca4a00e0898fb137a364 38af861b033f1aef2c996952cd44a0120bc4d04d179e74b2ad9d21596a9b8730 bd0a348d3280f6b986c74e6d3703729374158bf1a069701f4aba16f73254c0aa c857108270e21b98d602fef841b56f0411c12305f38ff38d14372c8718f7d2eb aecae0afc964ab34c2f5564c220cda5182896dbca21635ac81026d3c29d0feb0 7bbdfc571e773e399b569f4ff2830e8d9b518d0b5d113c66c78b7f4286a97848 d4e44123919ce55ef7753229180e82335c43c064d515bbfdd16af5459e6fce9a e9454bb7137d5562ce7fd1a5d387441792a1d252af2e7f8249da3c143e7ca5f9 f8ba4561c33a80e40c7ca29743aaa5f9ff45831ea41af4e1835af4843311b5e7 562e1b85aca51bfe7fc455fdbc0060a3107836ccb8e72f197ebbd4cae6c38240 314d5ca7078b9cf66cc9a127a84346dc7a07934357ebff1f03ebb46a71c3b29e 15899bb4e5e5f5ac515e9202d3be847d7bc4a5d2f8b10606a5c25d8deea117fd b088006581f476a6f974389367a8d751e3e77db254b44c37007512fceaaabea2 ce728b492bc3de4934263add7ec0e8b8e8a9befcbf6d303804e8d543bd00935a b18e46b791bf0f12877386efa7dbbadf980d2f090fa2e59826a8eca0417cbb8b b1367e0a7711b395a74cbce696bb16102f8bfcb550ada075fdd28ae6f91ee820 f9d2d946be5236f38240e7750defb8a2e6f9c938dabc5773e8fdd8debc50d6fd 4423c9426972d73a83f73448e6bca19ed2edf3230ea018ea9cad3b1f1d76c4bf 97522c269b46cf817c95aa9fd186b9c09f9ab2da7af3ab55bd562d3cf3b51ed4 9f9380bdfa737fa00f31bfaa185c89ddb4a431e18f4a17c12afc3233e236483f e9544769948638dd359c9fee61317f0c93e4d476c457238c7f8741d4fdd20ffe 033aede3e0d40659cef397ad6250db441c97dea5c26ae4771a9f4dbb1941cc87 a436a016cfcddaf1b1f1fd9dbbfacd6979269f0772526309cbbbf7f40fe45920 d40b3ec269a31e412505088853b395405ab22a54d2fc0b7cf8f36d3746ba3e22 5127aeb4f206ecb11b191437e41ae3ce2e8734066ac559921a470bd656d56c24 89b0e22e57e9182a1a7d02ed51a5e6811f3ac915de5164664b296033124ec6ee 5937d8236f189d12fd6cd9a2ba68df4d5ba2bf77e72ed9449bce95cc0105c974 bccdc7108b06aae759d5b4d0e7e03ae74d5dbdacb6c5ae6935289e231a1bcb7b 15b5ddbcf9014f7f31170a82731321e9cbaa1d3b1d374ac8e9baba8e301fa1fc ece21182404939af7ec56ffbc46d8a72ae114945aa53baf864c7dfb925506b47 fec8930653c39e756c9ead78a921a02bbf3cd46e48053766a3ea05efce314417 bc04ea71c8a2d6774c477819f1e2be43fb4e8990b064e6c752756cd8fecd2ded 373a4b62cacd09fd6ed9e3b8354445b8316d15c11dcf334b28c2bb7e3458e848 c81605bf680bc260a7090ccb84ffc13e1f1e78fd94c2320642a3786f3fb2bcbc 299563329c5dc60a5689618c81e1e4edbfbfe96dd877c27c30e96258ed287405 10 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 +generate_ring_signature 657d817c2d4d9a393b1d9eda25141349f6daf11cc4d6fd7b8a1f279c12187e46 e8c62926823b84157dcb6145174f85084425a5c705ed0d37842430352451a394 1 6ca123601f7636c3372154cbba220818162efea295240761066b059d12148b96 eeb5e6852d87a410c402eae49f12242b35702470b648824c817adb253d119704 0 387666ab1fdbbec57f7206fead638de5d005836362d02cfa8c4271980e58ab0ef23736557c26359ba274370859d9708f240112a1b9ec84e1e09a684399c9610c +generate_ring_signature d2ee8055b5e9fd86cd9e9cdeb95450590ea7a48e976337e8af699593d15d6232 cd23327ec509965ac07ac7f31509833e47fc56b96dda646223d917c02c292ba6 1 ae47e38a341217de4e0562f9b146299c0f7cdb971d314ace7522fd4fa3e20fb0 8c4730239e8f96e53ec2e30b856645506887527e7b6ea24fbff166a727a74007 0 c9dd42ea905b7379fad61d026796bbc744f611e23068f99e19129d95c3e3aa0bfd294900481281d63bcbeda8eec002eb9a11fdee8ccdb88a570ccd5cec072e04 +generate_ring_signature 5f6aaa96065ebdadb91cfc017ad7e81c1052623a75dc979d052c43d025572d46 e96c5739f208695639dd5120c89672abd6148f185164bbf7e17c643f2441ed18 1 71b0a7ac6902754f376699e4526f3c9882787ef2ec7477dc2cca2b5d6791af28 0dacdc8c2bab9aa153b91ff96e7dcdd6736e8829632e92506efa068500ab4b04 0 e4817dcedcf759aba2cd024d93555c75864ea0a8b9245035a0b4aa797e11e4084fe217b0929061cedd3e86044f0f160e19f5f1c1647fae652805adfe12ec960b +generate_ring_signature 210c782e19ba6264cb91745cb5cda5ce13b234ed030561310e88f6dc2722b483 b439238aacc9b192a9d7d1b73f845d24f574997d88c949d54d372549419baa7f 225 385d632938755662d282c477ad5bfb19bb1d153e5815077216a4c4e2b394e211 5e180c966833b87b3003a824abf2c6966441760258c201f7002e823306a9c2c3 5d040395bd315a7bde66937473a7d96ea72829d2f2f868258edb4cb265aec30d b5f068ea2e517abcd21e927c7ea996c5974cb5c681805ceeb348244594a342b3 327d212984e2e84026317ccd150142a955be2dfe34d19e194a4357bdd221a9bc 752baf4d17686fa71a2534a6864477b608ded4d869f847586fc6ff4e4d266255 05c39810cc10183513ab20ae2caab4448a0429f50673b239286c2843b43a9aa8 f60a2de08e5a77b7e56777d6ef84a5b6b546e6934cfc3a635378c9af0b7e2f1b 9986783276b0dd845c3b0c56ecda1b29b28bd7a3ea155ae6fab4376012a40180 0b3b7b391bb34851c1720cea7925614177f278deb37b16d52197fe8aa45118be 9d41a41006737c046947fc176183ee7baf4c37114479616e89d7517b9d039a56 d057fc6060c31d7629edc250791ea60c9f49bc5ca3872c6146030bc08ceec217 64bfe3083a136ae58ba33130ffd58a60b338245e368db66335d4844bbb0e25a4 4b7b5ae9dc755559da17de7325ad60d80b4f442bf508e304d2dfdfd9a3853a5e 2a5d589b910884a9267458678333e8a3818a71a45005a7aa3a9e088ebfcb88b3 eebb3f88b3f7951e243d7d8db9003edca9f0d9001244476efd46074fbd904fd7 a9ae02114f76adcf94ad23a9079337f1d1edfd74fff2438ddb47d0cabc1f5af3 db9edc21464cb1d6a8001bbb2933214b5ed3a2824935d63c05a55bc5b681953b 5afb033005752c35a5e1fcc95d2341640f532d11107b3a54c212b610845db203 8ec392866d432fa11d21b4293ad1ebd421fa859ef7c5311eec1acf73da95f366 2d372298a9b62e508013d83cbf0d95ffd72fc8fc6fb0d623db98a47e30640eb9 7d13621c703d7bbe44a196819e192422a9211e53a8a6ee138d99f541c7c45bbb 00a26e1fbae064a1c2c800ee32ff1bec58ea68e6bc3d9319d0e6f7d9d4858943 b3e674609b98360bbb85e1f9b80b779453ae635c894adda35bd100e7c6b1879c b9fd8cbae04c271e2e59702508d371c15f180310b6b5b16bf78f92c30cdf3451 c7d7b20e3bac8ac1a104ce0015b29d6ca9f66e4b921f3b7760d14b0d0ef806bd 50771023cdca6100850cdd2f60cabab98e9e42e6de099a1f399b898efc79321a 736e41ab6937e217c5ecaaf37eb7bb7136e8f9e29089c8be9567e8ec9bc76002 52cddd12cdf1c506e78e29591392fc24e7be5b9c5b6136ac2ecff15a94fe0768 132e70b68a7ef9c5f401b812458745e73c3b1143fbd6d548266d446e8ed21800 a5c2587a5b911408527f894750bc2fd3ad05d88fea96eb3fc521ce217cea614b c36d3589279a9754ed703a49e284243064bb8201823bb1e6c65ce1f1cefeb3a1 f352384e3ee128d4d9f5e53677e193699a4a0b32b87b494abbe9affe461c8224 623cb978cbe7068f3f5573abdbf77acb50f1fa21456d6c426ee7d14d925cee2c fe4eaf7646a7d7edc86ffc7bb3e02ba1bddac47517eb676a73c8cba574ac7583 74564c30fe7b0bed8908ed7550c7a1c0e81dcf9972c5588223a5c31f7c5f24f4 3957b9c95219d16df5af553548404c6ed013feaaaf3311ccc19767979f81afac 52e16912389caae211a4ca91048df9d62541505cae921b1adecd1c92a5e3106f 9aeb3d3ba84f8209795c9fe000a920d7b58e361c2ad09856e4b385cf1d3fabcf 52e159e9ed060899121461c71906a83f47c1337db4d487590c1d7b742e23e29d f4042896920a3546282ce109658cf0f1535d98aec685a54bb653bbb52f71f560 81581d762fda656949b3c072d157a16cbc96e27f73410fed70cc2d816ab76632 01d2d48e6e5599d24534f3482427eb4501508b8c1068583f7354074462aacbfb 323f4706c986053428d87e580cb45426eb38eee25fb956345607f71f76e2af64 c48ae1b3e86ab129abbf82123f987b773cda8a621313d5e3e12a82504aa4b4a2 764a1d46d895c15e2de0d8953d4a349c11ce203bd8fd5853c7acb497040e818e e59cb3843b69071cc6a876a73433694f55ad77999c1f2d9840cad6f4d46cddf0 f0c7fa7f51616a2b8b3d3c66fcd1b999ce236223d899a24d21d7cf51c7f8320b cf103bbd9665692f9ebb884207be5d48260d16cc118184ddeebaf8db303372d5 718247883127bebcf88b3c0aa856d2c82f205f0ad882cb40fc308f011d4c6ed9 12d01937773a71a29ddc4fcbe01005e7f3736b25414dbeb69f1f15504d65cd2b 8570f352e0cce7b04f9a415cbf78ea49b22c6dd1e199d2bf2a36eb7863b52633 72f0a2aaa9927f98bb985d97aec6cc91caa36f06ae37fd49e717f3c465943bf6 955bf1291296b84cc7f1a01a9d38145a747cac1f901739405cc358c1a791543c fdc3c3ca79c46bbd3226776dc9ed47e1ff3f3a7748860b9894812132f0290cce 5277b50bcf94ad33066eaa0d94885009bb6a2ccecc8748ab5d2b053d1c4bc8de c82775ef48623297b0ff928b04c03b1502645d58ed9c111478bb9c158a6245d7 88cd50b04d60e049714273798db1af00d5106280849efed1a9c1e37ffd97e253 d77f732b38cb637343ec20a66da97c5b39c9c3e8ff4b84a444e3d32164612791 cab9c3f461b91e213008d896bba641ad24993f98d1c7c872626c00a8b7c001ca 4c62c3d7c18c0b5f240c56b6f20e1ca4eca30b7d8806f66aa43f5df8a8d382ac a70644c6f3c2cabee8ad982a2994c09e81962abdc94f0fe48a5de7b155941de9 3ca3119e94ef5a78db0e52495b37ee42d3d87917cdee4cbf8ff53989939b626e 0df77c493d22bd419c3db7ee8f464acaeb6d83d607a7bd5a6083a62c1b318f94 011fdb5a7173b0924e03210b8ce3d0bf52a5982574faf3b110739d0288e5da3b 3361b6da469b5eacd5a5699ec7474c764d1426ae5caab18133252b5d186c1f41 eb68f27174f1dd2d342ea6be42eb3635fdd597031142086cef689f143e149faf 1fd91c95a7eb4552eec9f60fa61d3f904ae3c8799fa1a80926dea02cb8b69fcc 2fdce58215cfcd09250e3830dd355ef53090b5f8ea6c65ea7db805d720ead1a2 b1678ccc6288b290116e3d8341eb32e9bdc0e7c4bf1872afee58eb9430f82c45 48eb663ff455d22f43f0b6cb27f7d5eb0943d4b60b683717198002d7b76bf4c3 2423895ba50880058a75cbbdf5a535ce176ec31a14ab32d9de4dc3855156b8b9 06043986a58cfa6a7fa0668668b39f297b00dc2aa7470bc9608021165442b15a b881c686c1b423b1c36eca6246e5bd5d0dbf2f1bcba8462a008ca7dad7b8ce9d 1222668bc17ed0be0cd5f58172d8c058cf3869d26b201b850e46e2d1ba6528d1 1bfa0e56cb48d57372b35238c12746ee52345d52526ebabc79bdc28ac559f1ac 0dbd0538a75a12d385837b24a7948bfb3e7b9ec2e10b05516396041628e18a30 99910ae1888e67a0de161a454574c19c1f008f1c8559204e575db88dc80f1a94 1f000d2ec665610f784536730adf1b3e5b9b9db13a42165d9544acb881b0b92c d4970792197ccc02b043555225c505be8495eaf84b6a70d55139dda4c63b20fb e4601ad66a30cd9bf6e8a7291282a91731c303b459843c73d6b3538bfc3656ef 256a7723b4f9b7d7f652579beb53a1de9e7bee8e75833cf73b259452783f3251 613669fc70b3044796ae69b20a3fb3ad32f2e0e64d789a00dd880ec974e6afe3 0a9baa39c17da06593fefecc921b5a56b08e41dfae48234f0fc23d8f6a376ac3 8fed0f0e6b4d42105fff2fa2f5d17c1a29959a58edb4fa15f137f0676c6ea7be 630f0d0f9a93c58f56d9cd2f6ffd88e32588b5a2ceb0e1888429d3a38db25ce0 7e12a83617a864086ecf6b8c440f108ecbffc96bcbc8df5f3eb3c72cbd5b4e12 d267956f1075d0755c7f76b498b63e7f51c6e1c4902067d3be637346db102f1d d2e828db06faf7dd49e7e5223c21231a3b4cc4c3342cd71a3a92f06d727214de ce057552eb966328262a82f0106561632761a1872a5348c00e2fea537a946a4a e44b42268cb4127b29e47f5cc6499e67b618afd48462eaccc13477423abebca8 f9f0712fed976ab4091ac0dc3c15b3c2dee4bd54eda3e08c6dd2f9a4e4acdaa1 0e65a84589f21ec3b9ab6aee1d24ac1be5cbf7734450bef6f523b1052601341a 12fee1a3b1c49e1bea073a7bfb93c8879582febb9c28354ed5ce0268077fd176 4bc6cd65e4451fae3817ae3210d8a59303520d0eb1fe4c5d5e43d8466dd784d5 b96717f2b1ff0ae2dde66343dc8e00268366d0e8688337f6ab7d18508968ac8e e095f6be7cfbd4143c065b3f74abd9efac0552e91bd66c50fafb075534539ecc 750c8f66ef049a2f66dc488f51a125873b97569c692b9c31040bd4da3759d5ad 7612ac603bee6381390e5a20fff937b2532f880a0e51671f2641b67d58135f60 ebf737d8044309797fb792a059b02311943c12876d3a5c1384166ee2b717820f 80849e5e6d4f4415d77a52dcd6fa289881920aee19735d03fcf5979c2b001993 c97589e7bce4464b1f1921265e8ec6af29040970f09f2c3475487e7ecf1d489d 9c407322aac4ed8983ca8b8dad19b211f0c0770195119157fe44f1bfda932ed9 31fbe13706f2716dc25b149e77da52c1ecc55b70053e41e8bd92221b1b385783 b6ff14454cad1917030df735d2c9220b40880d7fb0ed08841e9e705eedf9036a 06afd0020bd36ca861f8202223febfb21eb5c7e338c907a4ce654e457cb2a315 be6f0907e14047eb8fbfdd1f878550770c6fc2630832b81948927b6f80617372 163f776a0f464f59a6fa6bbbd7e93aca17ab04b04b7ce06d34226bb7e900d7e7 f1550dd1d473f38ec080a6dc9872442350179aa80ebca3afe3286c61b1ab732a 38610d484a664c9cced181b42bb7a96a076921437de67f6be1c922e07ca7ca25 5990aa4aa00146e517e50f3eb04336597f2f8deab18ca1439ee5a90863d4a72a 50d7699edcd2730a75ba37516553f0548e2abb5044ea89cac8851026aa73221f aac4a77bad6ea4d5dab8b739c0a01c9fe78dac1fec94fdfb1168bd5cd59798a9 95022a31b8a904b2ad50d8f60e7779fbed16e47c07b1ea65c19a13ad8ada2291 439ad6b57a6dc6b7dbe15edaf44d7582f0d6b316ff823d41cf85ab381d35b860 38bfbeae4653dd4124de9a1a3e53bfa3066d4e5961412d6c1de12cf77d27fbbe 55992a2b6cb34982966bd89eae451b39c701e79de02d7f3440a8c493a51d9d9c 4b44ea04e75b073a4d597f4d1fdd414179bb7bc5b8ee9001a3c3313eb7a81028 3bd990d568b7f23824d36b441004334bc7d88d6552e1b1b9a6f772ccd02af8cc c6c13ff416fe823ac2ebdd4d8c96c9dcdeb678ce832218eaecaac26d227aeb93 384e2915e3003d1e5a32fe42c165eb31ce1cf2f7972ab7080ff9dc95146cb44c fa79bb9d556b1063924ff37f150aecc8590ebf234550f4c90135fd301010d020 a06676590cf910a41cbe07a80e3711ecea47d43343eeefb106027aeb81f11fc1 359028b96cf085cdd4156f29c48aacfcab8974c51e31d1920648d844c48503b9 f4fe5c34eef748c3c9a3dde8eb3a7cf88f894f7f29275ea11ad9d21c2da7487a 7af8f1af63e71d95ea3c26f57a9a3818945cde9f1f70c77678e501a6ed2c5b53 df5347afdd221d101381ca39489ae4a40c79e60dfe914640b7c9a15695bde31d 9d68f3e4e218ed9d94181094ec24d78d8e5e74462edf23a04e0f5c309a488ea4 f69e67c58bf7d1f54daff66bcb9f967f4a800bedde5c1e8e3388594d2b6162e1 4e522383f361282994b5df8bec583c9076915963c387cd8fb79c5a143b77b20f 649473a9ea78b524cd53b328a181eb40c0cc67f93545baed9fb9d013a218829e d3dc41dd315b7390789ae65cef880d5b87f4b6f1806877f4828313e8842fcd02 2f14539f942ee6e9b0f10fcedffc6c2928737cdefb8ec12d1100296ceb74d56b 9dcb4fea73d041a83daf21a9cf9cecc054749ce61b55161cea8533d0ffcfd66a 8683d13dab4da5823053c4623a860b0f30990ee197a528780a276f81c70b639b 700509bd43a4d2b1cbe027b952587f67bf07617ef194f1d182718bb1761ea6d2 41a1e9fda04748ddd5fec36d1178167776ad5fad58ca7ae08c83ca4fba14897f add8a8ea5b584b8eab15afe856925109b90a73f21700ebe6be92064968ba8766 e6db06fece8a3c69c8345ebcd3a5448348e3ba7b3fd15a05f2eea0ee45783d5d d4c104b6d17052fc549dcc764684c848cd7aa470cd478752b814010cfe8c31d4 e36fc9e9c235d35b997678b41b2702b931498e32d22911d3c47aea55503b0033 c46fd9dc260f6d25ceed78280b2d5bbc08657efa5f7b962e30e22ed3893f768f eeb7a4cde0a142ea63cb9580b0938366b3b95324d18b17da2be4d2249106d3ff e4987600c30314a65d4ba41c132d4aaa6df9bfdf43c9f6edb4aee71afb3b1ca9 26c450378bd5de84dace9354dc11164c0df30a66c2623ffc9821e9ba96573474 3768619c48bbe89a1929c7d18f71dc321ae9147c29e1e9823e15389af035f1fb 65c1b6c65fab69cf2026b344b5b0cf7e312d8554c8ca9fae97b87edcdea5f945 79be69b0f629b18930c38f588b76f86a2c91dd5f8ff77265c58004639539767c f5c4443cae1a272c3ea900331bc349b72f7537e4ebc4ec9995a5388ef922731c b71e544eaa0ba427d75dfa2bbbe03694da48ef2be247833d143f81812c7b5a47 b7b2457939c77d5ea8ffd71ea933e4efe986ca8b455e53e0ae148b4ebc4d48e0 10fca1960f5ef371ad93ba33f223b7d2851ec0c9c76f70b2d629d6581368f90d 988f89d0727350eb720066e198c14229bd9c6b30a4313419df9ed31503ddb02c 2f81e060a1c1d035ff2cd062ff432329b6b16dd5e5ccd3ba1e3c64907ca41351 335def56d9aadb5e550a9a87df2c4171ddedc3257cebd96a88ba2ed0b13f7301 1bfe59272dc577a9821aa956551cb1f045c67d4b9228a04e0b4449a8b462ff0f 444cb383eb3f041882c5ece5a3ba472f6cc4586f101c63050d8ca8e4ccd0106f 39c3b97d1ffcca4f7d0560f49f5d913f67a3903789743d29b49b902b897774c2 fae6d7e20a850723d9764e97e3856dd3863329e66705d8d0ee2b9889aa70c327 1a095ec877ccfd6ad7c098273feb65d098e1f573626e57de6ae4dc61784c9042 d562adedb07334daa8ef9cbbefaf98d64b24c9741dd72445a9e120e183a63c6d e80223440a373cda0d6adad064bc2148b320113d7406e1eada98f1de93472b0e d15f5a5ad17f8a3ba30847d4e85424da0114eb96dd2eff269cccb4b3cc364591 48707fd6560c4cf9cc8222491d45810fe75673ebe2a7de749e9dac85242c1104 8963b85abad1a6a24eed9b63dd46902766eb8b0dc13d02b9e80e3ed5dbfe6511 49d0fe1c91a4037348cd6f6b8c2bddb8da46214c33e8c39c0630483b83305ab6 f803ac0ae722d368b352c47dfae3852904bdfe9bc7d4642e1126a482d5e9eb72 1084f0fbc396d6ac455df3ca4fdc22a24b8d1e00b3f904ffcb6d2fab8729590e 4314465a59abb470b1e05dd90925da4035ba6aa20ea102c56b6365865cd05a9e bdb6292729ed47f044cdc357e7081b249a275ba904149ce9719b57dcc144269b 033d157a3b91aead40b8a4f029b61f2a40d39b86ff38e8e57b52c03c426dd10f 138d03ed71356e08e6ea8d29c57dd8b2802054587a058c80773a75bf74bfe371 397cfd01c6fe89a34b41873338fbb70b4dfbe8a954d895e88cc87ab2cbcd7686 292e2bc17fee6d9bc8f09c710411605ba57f8534063ee3608ef39bdf73ec4db7 8150e00b1e5b68586aff8612515be21fc803344d3d0329badb0cdc99b80a1362 c92a75c221dde7e996ae5f8ea43a5760563a0532dcc6360a60dcb0c7abc13f75 49bebc69b650aeb8ad9b8382ecdd65a74d640153ee047060db71536e5166e58d c03564454188c4a7c29c94b4d128246140bad2a621e400137c7c8566c3ed98a3 75ccedb4415bd43430e80668831b2f667bcb086778ca43805d9b67ebceb0138e 47a95d5a7fa6e64dfd42fc92f103795e8bb26d8548cda156075d528f4ea79c37 ddb756c6e856bf99b3cda839a95509f50a9b18b87c8d9e07395eb1f37f351004 d813a9adfed2a92f4d2a386acba181fd12d26e8cd139e67e39bb1a45775b3f8f 36c6a368a17becb5b42b43855f1a1ec9b958077077a9ae8b2b6186854f2d7b96 5698732e696ef2306c582231ff9d48f919f4f5d59bf11df3e2bc7a9511a8555f e0f7dd725ddf4ca25c9bc32f1d6b33a562325573cb3bd9f9bdd03eb15a568bc7 6ecd766abcb6ddf79fbc0b7b510d7be17bf5497fe57e54fbab5f44b59522eff9 29ccff9bd63867d4bdd3d99c79bc54b9503d3312ce4792f280da7435e22c773f cee276d9b36560b5078d93780431258456ad73e47b98741c4d885b7e917a620d c465fbc35b063492301a77e868a24728a238335f1eaee5e7c94173fd1d5c2bbd b8a805da943c09244669e79bb62d6a58e80e0cdf069445905b332e0ff2e0a4b9 081c277c8956e574ce8315e55a4d1bc6a1f7084e3ef79c565c5c920e09ccf7d7 62a0c62da5b16a818926f5568bdb97370612c34391831bb8fe60ddef00333e80 e98bb0d8e342ff5ec1041a49101a848ca973b3143373404be9a6c2045244abc6 4667b53e81243320173ad6bc9564fc5249fc89410c70b915602a8c164529342c 26c435b82bd68d0b7ce15e81bc391b2b60b554be5867e72a9566a101e27ea9e1 9587ffe6e571e2e36fe80649da50c303ce81f852ccaf2b2e9b7b4664260c00c9 3b28089761856fa94678ff62ef7f5ff7bbdeba5ab033f2bd71ba5850bccdea9a 5d92b8261d4196ba81ffef7859087b51a05ae5121554181cc687a4a9490699d6 297f21664140a48c0cb3fd6e6581ff9acafceb152c76fc4bc9d31d946e2aa54d 87d4a74090844bd351a393e7c9fcd7fdde317947281a8680ef950e5b71cbf8f7 1435d4678846561678bf9d5600b2a787b6339d4ea3b8187a47ab5c6541817741 a8ddb8e7b2ad56a9d46dfda69e17472e610b68af71a3f7ea908c9bd69d68ac62 d8fb6e4733f9fb707f77994667f77e4e3ca818bf8a6af8120e50ddb02ee65f83 8c34552da56de382f71218a665199132e665a1aacf11cdfbc77e5ffaee59c61e 098d1aceb9cc5ef48ba98dd731a3440ee771b9ba272a2c3f07cccdd192f76661 eec48d281e1ced0a49fe3259dd5b4834e22da58794495cb12b14c50f42f352ad 01bf24b8be84788a89206619db1cce831a71cdc4fe0b51c61d0d93144557c19f 53559b4a639f13b09851a396796fc6ca68211f3ecc2a00a687dc3a526bc1efcc efd8b29f481a043c230077c3eb0afa01d99835eb6c5432bfb855b4edfe57b43d 69cc325592eee89f8c1219ae28e35e515f167491b1a1a99987fc1091e3d7ec8f ee3e949a0957a440e8dcf6401c7483a97e78c90248ebb05bf3fa2259fa3b767d bda559c3325659ebeb39078896a9076f66ebdb69b95d21477d422bf892c81c0c 435a8f4867263036f7af465acc3c052161c75a6e983e8ada56e5a88fe04b4a6d 2fdfe818559614cbdc8428e814aef218181d888820c66e8e92b3d0e038b7d971 9f7a9fb7d041cb442104b1042a85085541b4e19332f837a6bf8200ecce1e4e70 97b37dd1b11cbd70c90f0c80fc8c4ae8ee7dffb1ddb1a9b89fbbf94a53152516 238255be5a20745de3541e9e269b10bdc886707eb44e6b7677ad29f57c2e5380 18203e567a0bc5b74c253fe7f3f55632d245f17e1acdd0efbd806129e2c57ce1 183149a1e04a061ccd380488268820b73083007d21f9f09ed559d49b2ed9cbe5 2dc198fb09f54ff3988d9c90d94238ddc96197722d71cb1793164eb352ff4a5d 45cbacaea04505e21430785d1b66aa47eddb172a078a578fb976b018b3902743 98938e4ccb446cfe999b091234c844e2a6648de95ea4b7408320b1b37a0157a9 d6b18d00da6c1f1585aaecfb15f8913fa65cf12466dd5ebc55fa84b28cf39e2a 56fda2b69037627ee3958547c0eafc7f376c0941ee1dbb2dd5885b63727392c0 b3538a6ac0908d7f225b58f2185a1735e2f0013d66a5fc5c7371158fe97b1005 4f4ea02eb4ab62fdfd94367557069356661e2d2032e9ad94b04e9ff3a7c44a01 204 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 +generate_ring_signature c94de04cde5cb97d00fc58347c9d43c5e2ff19eea4318f3ce8eeede86e590181 dd0cd265cb990195247bcff884ae711d6d6e27a552da53c3871f9f1ef313119a 41 fa1a0c591987eca8d52794fdfcb34be618b911c96bf95dac8383b875200f160b 5df51ed1944ca217cb3aabdf05f9e84481cbfba603863402a3b0bc3032345285 aab3f16311418e85c428006e09f6ab4cb938193554381b480c2ef44782ab092d fa2d0b52bf1b930a1f0f482813498bd527ce090daa3f4285477aab43cd1c45c0 954e9aeee405d40869ae3c3ac2ffddae7c00e08574f8e28528d9efc994885f51 1ff131463c64c2c3a1b7af41435e737718ceb11fc26df0e48f192cc78b49606a 05defdd1653a375ee7b758c3d7bc997beff91c486ef9acd1f7407599ef9eb509 4db7cf256f884cbde45e0e580207029b4f5fbaa85ad7464b20e36100b70083a1 581797147df7936051e989bb4881f330344d5733220ab185292371438a9a7660 606177bdf0e2889440bc7c26fcbd0f17c5a204d1c20205dce16be9eb561361b1 94a10e3d908cac01a162fa1087d08145fb3db70cacf955bb70d51bd0c0cc2915 a40e979b15e9b750a010c4f924a6da214bd0a0356aec01f392e676c9f9d42a4b e4e6ba7de1cb51d81bf38ad8e9bc3ba7e3059b170566e6188e5dcdc197f424cc 0bb2355397a31022e06f6edbea574aa43c63a063f8287fe3de58a438193cddbc 1994a036f18f48016570cd7ce9c56458df51f532738e2fd45fc8e09dd53ef228 0ab9a2f03402f2b2d2d7e850d682cbdf1a82b34566059897b754188b09f84477 338c19bd0bcbabee027bddd1b819ad49d5c37fc77c7cb6d6ad64862e23ef632c e91daf7d75e20f04693b719c473fc61a15d3076e1e372068316e0ef056be00a3 f547d83a8f49db95529bfb04880da8d1856c39a35ae73070dc84b3694e49c82d a3f131eff367e0c26660772e1598e71a430daa4d7ff274e3c8da018a40b7f765 205875d30d48dbfd44277116bb0d80b478d1f8a0a83ab789ac0404fdbc03617a 92c1fe822b784d0dbfbb2ec60c8c8e9e9a797b807648554bb5105b951a3d9d6d ff72f514b8adfc2861faf09820604be178b7daf92202088a85d2d0e66bd57edb 223c5ca852fabf656ceb333b5bf01d7f1f37f2566b54b7c4c29a86f18d1b8ae8 14a1430cd78fd2039ac5d7df2e3069b24cb36b12f2576771da0c1911f49a273b 69df315a3694a8a96963810c498a765f95eb4f84478bcb38a8775797de768e86 e94d3267a6fbec3acddc3ef82a82bab6ee8b0fd4a7defb1332b936a5f1013fb8 ccf5a0bbf7e6addeed9cdfc3599a5a94e47c5faa02a3ba4671a4c008bd403f49 45f5cd60d7af60fcade4173bc0ed1a36091f206dc28e13844a16c675422ee1af b1907d4d139c71715303888acb530cf952f70e777b3801a0f402f2f0585d6930 ca8744c0d9e716417589570bf615e2f97e01a83992b36558af37d7ff28714523 fc201c54527f971e930f3d35bdc20ced6a666ac12d851398a7fa9f26ca509f53 6efe0cfea913636b65c218d9eb260c3b9ac83018e18623135af56184a418b565 e35ed29a37ee3eaf9d9c8133a0ffe4d0b7b4b0358d5889ac0b3dce4bf4bf12b7 4f336bedd6f2044ffb6866bf87bd50c3bc3f0d814b18be816f51beec2f29f1b0 eb40611822d44136ae6779a5586246a2ded4d005c83334cbeda1aed834b7f888 64b8c042003d59c3e9e1c4ae0d2ef6c1d151e02c4c5e7c36c7aa5b59b7a74357 e7ebbdc1ca40f25c085c1d573b4951e9d0e15cb0c0ad0026492cb6b815ec2595 2148ddd29c481bb590a19dc5091847a0a86d1a1f6cde6a8df6f594be8dea66c8 96c16cd72fb2150c2371c2313d1d24520bd660b248c5cf3ee368f95d7257cc0d 9cf1735d67ccbd6c29457094d09bbe4b18c3824e97168d9fad6c3b97a177f9c4 25cd26b4ae877a3fc7251903d65736fd36329f066ef5043d715032b1244cc803 0 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 +generate_ring_signature d6ebf139a45ef1fa4b4be6a9def628430e9a0ece08b67e60646b44d7581f62fd 009fd2354de45de4f50f4171609d01f3af1da8c4a966e6613656ab7ba547bb4d 2 6f791430dc6089fe5726dcba4999c2f277ed2515275152c3615756c85ca7fce3 fb5ed1804e5b50fd5e0faea33284e7b91d9d881a69067cc49560ca97e1828d7b 689799e5ac8fae88a1fa82a03c0dec56a2ffa69f983d929bfcda6ea30e735f00 0 e683d76fd18bdc776bc62ffdade8f137b48d3e34c53e711b271230ac03ee95065383f3093739aa689779d7ca6def137662938b25485c46c65d38f31a935dfe03786ed9fe359cf0b1c193c61124bcab078bada60ad9aa7a479e534480f30be70ca919f585b99fb5b8eff57d905c229aadbbfbfdaf75ca387190bb2d8bbe23bd00 +generate_ring_signature 0ec44a65dc63613b9be298c6039f1c13f58071e1b8f642259fad92b82e70ea6b 9c1b7841db55bf2d432d77363bf8f7871946d1028ac185176bd270b9b1c8245a 22 0ac06d71a291bc9cb8a65166f6e267aa94f67345780fcc3a88990a1fa5ddbbae f4dc2655b78a75a5c02d1da6fadc0e7df8d10024cd2acdfa75d6b926d9df26f2 b898a4bc2437e9c7aca7ae42b40b9f55801251be6a22e06b35cfdb9b519fbb07 5fad8c5d05bbf6e210b426f1c85cdf65c610189659bc1dee66cb48e155b4848e 06c86b3de6e5b17a6b18bcc3bea96bba1f0e53011abdfc8d983e7128686aa565 1981523626d0ebc509c4975cfe7855f5935518d53bfbd8020103875bb04c54cf 71c3b087b4ac47bbf525fbe96f827dbb8ff8cf477ec15e188df1f7468f12319d 76ab284bb2b33394e49a7b9b6ab4eb0fa9175f8cc0549099afef7a425cfdee73 035ae37614df557e2879632c43dcb2a6e731f45ed71d4c24813a2fd0b33e27fe 4619e99967c91eddc5bbb3326d8bafb2d91a69e99120dd426dfdbf0fece87b2f 6c25581aef5948e25e70cacf2143b8aa5d09c4f0f71d6aa72b8f97acf504c9a1 035708993aa26e4a03188068a9053b2c4daaf5e7fb6fb5b63e4c5b3d5fced851 7046c37e9f70f71033fd835f432553e867df9ce1f42bf67e883fd1eaaf6fcd91 fc9c1fa387d94e42b000d5196cd36b4d9ae84e1a4cf2de91dd15a8e9c655995c 80c9ac968a6a22f994705609c7f829f80e9c56786ea24c1048814c9bd8ae39a8 4d7eee539bdc72685a3e4239f78c67756fe3972e1b88ec61f5ce7de6e90cbca2 9f080a14a10352a412dc2067d03db1e23a55fc00e1c90ebe2e3edf4c9067f8ea f124e82150067aef668390263f418cf8bd5ce9a01fb2907e6847231178f4cedc d28e3033f536023ea168cc178fd5c9a9e3ed795f8598f7cfbb973122a860e43c b501e956550a6e563a89978557633f9d61ede3fdcb4f5f73b10fd98961369c19 a7c9d688441935ef112dd091d6f934bd055fdc508e39f78035da02849b5e374e 5585b13645eb85ee005065fdebdd45914a3afbefcfa4d5aac0b2807c21bfe0d5 ef411cbe80bc6bdf3cf2c9ac140669cccc0c9355fbd42d32c545a67b3bc96a02 0 a20a7f326b5a3c9424ed93132a2875eaea9730c10ac154d3cdc4b242fbc2d90972f604d5058302e5b4245123d0db5c4eb6c2d38d88cf45618d20e2efeecde205171bdfa037244dfdce15bf69a5d11111cd515ae86c9abc85910570a9a52c8f03ff4561e213cfd106249f91f174c65dfa983748112f043b833698f9c03f3d850327871119b75593a393b2537a4eae19d194aefe2fbc99d00b46b7068e296e1908a2162b01b17fcf4109eb5881eebae4dc62d05061d2324267243d4bc5ff1f740ab1550f007bd5a65ca265037f95e60a29b43c81cc150fbf45dc28c8e758f99a03308ce8ed92a1c538ee62b178cddccb4db5bed88bbd6aed6b08a8068c2f427e0f12b73d9b880c7a2bee47bc3a54bb6aea3792cbfb2fd3dd0cc076a0502b0a0107443b552c8318473588878ea5c9b6f8a0f56d08bc6ebf07d660ff649ab808da01e7791129b542bca8716958c1263340c543fb15ebd69ef62d19e7df2e50da3209503f39cb4c3bf19886ca5ff7319d17b17e6fc1f05c9c8297c1352b195e1e9b037ce5f86f7ef1a776019a92ae13e3d3cd01923d58d37aad6b8e266e470449af03a75162db2fa06bdba544c9f3a4de465c41d20d854e5ea4b4e5dc477c2decc60a272dadd8cad14cac3af3848c79730b299aa2d9c29431c2c6d60412325a0b020427176e4677da5159e6d9e4bae95295d938575cf5ba71ab4f11d2ec6362e36e03d102e2cd038c1eece1360445e222bd3aecf0e87352c4709d3496ffab403c430bc7414a46b36316ea0d60d5679ec5e99f66d9fa84dcf7cb4e5f831ae50b416e057408087d471a859468ceacca8078e787703a2e580fd22d21befc8c4c5cdbbd009579c91a032a602b621c81b749bd9990bd0da43134140f70ba8c4db4092c5f0ee2269ca42d80411cd4bc20dbca36a5c973ad46b98e57f97bec1c8599eb65d107f5a6838b9e8b6fd4d3271de5c46a180d7de863fc93a8411dbbe5b2b84388b300896f18183874902cbbca7ff444bb12b699898b69ca80f59829a195378837550ef76d2a17486dbcb6a75135ec1fb933202c00afae798ed967b521917a3d0ea10bfb99ec952c4ce244dbcbeffdc132b7a32931a1dd4afd0dd0f786fc5b83b4a50637791eee9c61e8c836f5235b31ef87b3336e8a2c660a4463ae93b23078b1d808752a02c965509851de48374f4d815d315054f6076e61adea1f3556d58debf509e635c872d5b9fb45d556aade31586f07b85367aae629381f1782b73cf1cd440ae44b78b444519911ddacaf8d9adbb4326b7437204363a5dc7c80d710fbd459067f206205b8574a8a65f6583a90e3a2a12e439431423161a61e9487514ce83d0c7b478ac0d9419551b5e80ac32dfcdb9b6dfa68f826705f763035ad30874c4103c071149831bb872b97683f182b0b007365e1586fddc4c6eb64efca247f685404a3b85ccd70ece4bd82094789d1062ed1df48b58ed7291b3a39ad08ef92962b0f9813ad3b90b1ff8ed941a04ea7b22937f6071040feb853b067185d456b96e309ac7063c15ffaa4118614691c65ec26c503ba12f9afdaf83ef8b7de515fb3cd04f6bd93ccebeaaf6bf530c3382b80ce6fdc7fae3b4a0876adab9e71fa529b750a58eb3fe7591981a2067bbb2bbf9b12467898300503a9797b5e07bb5faa1120096eeaca0c5726d3097c2de3d5786c952cd15b8be17a9e5c2c57dc1abbd4ad3707b8ad0a93d11c27224a19d6b59ebec1bf9a64a36429548dd02dec123e6661f307abca70834f5ca1c332304446bf11e08cf27a63597b3d73e94364edd907af7708adba1e91f21c5d910146decbb1db0ce8707de1e57e18a6204e0b34c687e4ad0b4abc43516cbe5daacaee9e5122b7013da1ecb78883acbaee056f6dbfd10a57072dae7e4cd4ad5d51cdd1bdf6b5cb978766750adf2c89d6fb3117143352b4970338f4459d1264a29769bf6ea2ebfaa742da62e61a2bcba5fe47eec0ed3236b00a +generate_ring_signature 93493d23fb44416ee09be43865923d0e1dc1066d56f5a3d0de81813af3ba0dbd 7748c0a5f3f87b8261d37a2fcf576f3641db82845d8c9baab1255a025e947fa2 27 2d160aedc903d73ca9290d7a6ab88c0e9f34d8d1eb85ff0c2123e1e619aab827 7bb969822d0b461e0f71f8582559be4532c9f9ba4b98a3bd8037f3ae2cc99086 3973974ed9fab1a8bfa2bd46370a22e6aa9ee366333379802af5647a360dd8c1 d6b7ed18d47a17ddb488bbf95b3af8435f2beecd767e1cef3bc7fc0a4ef7c4a2 0b30df77534bf83ade55d67c5525d900a8a7a4e45d22af5d3fa8036ab3ec3a28 7fbc57d8de03940bc6ee8cf3f5598cf04672d58cc53793c1f62e0f193a2cf264 300807e7fa48d0b41448f7307d2e53d080ca6da2dbe0b49856acbfb5ed7e126b b8caad285713bf9beda3f580194fd57152f67aec0e70a93c28928f5f486f59c6 a07af8e32900154e837d3b7b74d5eed2eea6b5fa431e09f4927256459a381021 73aa4e3f354b1059b14d1cd48f52502231c181cd06d3e377e93ff7d7e4493348 ce6d6cd79f36aa44b40bd05e6a087cde2fda0d82d4cdaa6e2b0cd36b0b3803a2 038030ecee860ada3ba07323cfef9534ea0a90d2b5d30f2af5cbadc1bef72e60 dea728c4b55cd4db70c5c69438fd75ea5180675a5b9d66c02fe1a7199e9bdb69 f27326d480de4e3b79274bd526dd79d24f11ebd046b9a8c5b376c44061d23a9f 136ba04808b1ddb0227d549f18e8322002c8f9e75600a3abd5c73559ce0260ea 601eed6733db13d4cb81bc73faf4f9f5af74ce56405f4bca0a048333bbc439e9 3c0c6f776ae4ee29c1c691d0b57309ed56b96a31a945079f41d3ea89e80f32d0 7249c2ae5af899b9283262f07f522602c6d1bf3d88ed92e0c1b9996d76f0447c 9518aee525652a3dcfa5a37d3844e7b2bc051db5335ea438673b94b01a04f8c9 2843e804e929b6da93b04026f44ee744eb364f20610f686d5a73fbc43b92663d 6b5281b6cd170d9cc7ba7bb56af507aa3dc21e816f0acd1659a908ea9a416366 ffe9b0f145fbc6ea4dce6273b27e9287654cfaf82accf33885fae7b152fca9ce d1bb3f05ab3be0fdee933d8492e1c5cc24e7488e44c4258dec75b4b650a9892d 8203602357f52070b4bcfc3c5240704ed87ecb93a0b4812512e3db7d9d6ed061 1568a18b7fc569e1cef7a211eabd5da6fd118cff94cd726d1b4d988598a51117 0080b6bfcc6e68ab3bd176987ec4f0ebfa08e2d5bd6901cbf24586bed9ecb4b6 6b608f086d9d4c67f3f1daf684659a389c5c9140c7b6e5ca71ab5b107cefdd79 dd1d64ade0adf36ab84cb537861c99b79a6d012ae1f994be411baa76db298b03 0 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 +generate_ring_signature 47a17eef9aa4f45e349474251fa7db40f4dc3b2d9cb74a0f63628730e4f087fa 67206377b4229f14b901ee725025ad9067500f80708603d343cde543f6220070 16 b9d6ae2e4275913b39ded0e04f23f415e21d0755e6f5f15398ce24db187b80be 7443760d12012330c27c0d958be3f5bf3c543ea087b2e710f1df3aea40a3597d d58c7950dfa2cd1e5d5958b03665844c4ec07d3266238af73c026b2df9c9d749 22c2ac91231c9618673ee8d8cd01a3fbfc915f6da971019e5ed1c04cb848eaf6 bf376c083d6e0298d8e0bee38fc8a296ff9db39661ff0acac51a7cae47a528ba 4d84063c54fc35ef611c69679d6bf8252aff307262372e127ceb6ce28a4eb57a 191d335866139d9a9d70172dcb623d9d0d589bcfaf29d639db9408105350a6e7 16d1388ac89e6e7be13d79c597bab902ae51c727f4003e0e32d6a9944155f5eb 7161b56af7340827dceb9215c1ee38f21479d7deb8ca9aad4cadad12dd190762 eadf42743e1b0f76badbde7f1b5600c599eff2855e4af3ba1e832b56c745121f 0113294d12228749802c3502457a95df6875abd7dd63631232e319cda4ea7176 517b3628d5b1f6a781dc2a65084e515d45f745a55acf671b478d2553006ae2fe d1a16b1897c1379411ea2bad7ff86ac19c519141174182de83c372da21e04676 9c6e206bf2d21ec5f36fdc489e51f9748d748a8064e5ec0ed21e7210b6075d71 fa2fe7158dfba5f1083ff8db88ca7510fa17a08da7da486f3194297ed4ed0afd d467bdfb269e9f5e8c72cf6c27b5c7eb4c2beccacd7c0fa37d22cdbe2d15807b 02584ea85f70c3ef4912ee658341e6b6dba3f2b9e3cef23d99ced95aa50d680b 8 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 +generate_ring_signature 9a7086a8ef73356a7a113ae91f791ea57a32bf63cb15766556218bcb2f7582fe 9eb46385239b056e240bc6a1180c51a025b0837da355c5d60055da138d05cf09 75 d716b1fb66fc9eb0d801d13e48a4795600b8afd004cb31bd7bb69ac7bf26a5b8 facaa9a563716b9d22e3e8204e8c38ab90e4329812d9bf33dcf49322105ef8bb 092504da28d4089cf7fe33cbd6cdcfa5ebf9ece75d42805975564bdcccf34497 893aac484591284d041d6cab92ad3a0e187834520d90b3a6686276070ac380a7 4e8670484c0779ba9975ac8bf55da8ae29d278a0334b23e670fac6eff5bc133a 7fe32c5fc50564dd44faae596d56dcb817232c1e50385f248e6dabcf382d0d20 5560a7525b10a96fb989ffffaf9c2a20291d0d28be117be81cf7292344c26a89 7abc90f8cf53e7b31349994334ab3388d209b38b0a1747d656b064255933b80d 4b5931de92f69f1272ace927b49149cc942276296ae99a42e52d7d83de3fd414 a2e67069563571d1eb1f16694869da1a9582511ea81b005eecaf1f63adcd779d 23c1f904a58e6ca0d91c4caa3dbd7cd5baae653299b339f9859ce870200db57c 19d779d89ba045aa643e717f548b247156a41d35e7be773d5775eb452587d44d 68e999d5a013b3d945434a46adacd5a2ef18ced42ee0259d949aaea9f06479d4 f8c85c1538d967eb627ec666563cfa8203b978a8f88a236f4fbe179fa791c596 19909e7839625dbff33ff26ed186110acd7b34179b0e55fafc84a71b7a3f7e31 53312455ea259a3056ef247f4b25e63a807fd2fb463b0ffe1417cff46ff4dfdc 3380930deba9c016b036d71ca525f349ddbf582ecc80ed127da3272f6aeea4ac dbde3d341c05dd02ad333c64a9bf35866b1f44da659a07135875cc65b4d65439 06577af36ac3f0ac371d8a2167f637c741b9d18a79afedafed8e943a081733d7 944ef7b3bab2fd90c5a46437b068c23d4a5074ccf0d0a6fcb960ed9763c0b880 01cd86208d37c5512d16d459a4581904d13eb862fbf9e34c24e8a1c3233da0eb 8a10901b4799674e91e6c496deca1f904b720dca6c3a81364bc2ff03a7e57897 339b3dac7330ec98d76e59a6e414629a1cd465d14402c6404c9655036cb5a010 c0f2a7cacf16277a4c84b115d21db048e8180a15b013af3f295739cb0e5e8c2b 9bb9566b6ebb7e992a2e6138c810873127f3406860cec5d3e867f676f23cbb73 3a31153daf08deaee78252f49b658c875d195343bae2a187c16465b4615b64a8 5047c33140837bc18466fc3d1e178179768860faeb7ff166f65450d53c7dd290 bc66bc18c1d6601746fdbf34d4f9c4e7213079d15eb054cf570edbb66ad70591 fdfdd237e667d70a530fc4f387af0473f99a1f2988dc480ac1606df7798798d3 d982e4a92446e08a2e9dd91b155e580f3d181bde1d5f5e69a6cf5e82d35607c5 f8b566a67779c1ece46c432d20b280c5cb8da1184f7eb242c33759434d7fcbc1 6fcc2b37559dd4cfc22abb8b5fa07eedca9d56ade5372f2e4a038ad1d0b92c0b 15ba3fe0679958f07c6deb5369d356b48b668ec67d4832ad33ff37b0abcc629c bc70e3eae472a511ab3e547f91aefd53e40dccb0b030fe7f0f5c382f41337be6 e74bbca25c9180dbf84ee1feacbb9e6d0514cb6acadfc7fe9269d8f1441c4004 0a681694b9181b8b0eee8388c9714f2920c63b46ddc955643d9ec4781c2a820b 377e5e05a7d1fda80259beb3d2d4067cf955e08089a74a45b460799745a52532 198981c0b8d166af3bff21e762bd85cfaa43cd7241d7fa611905b4fcc67d6236 1c533cc6c0bb0f4eeb97e36be210351f39b1a4ab10b7a339e92aa187a6e08679 955803e9b32dbf08ea6a31dcb5bfa460976d058cd5d35fa2cdbd446dd112b3b6 b6eff72cacb508187b555d67f22abb6e73ef2528404ddbf17411ac4510c44fa6 f55361c4f5dda43876eca6af215d10fab43d1fa4f029a370a08996e08fe5610c 38d3a3e8c7d263cf018d96a9c81737c34aea0b2d3092b63d79ca96a2289046e7 5a6424e37427e45b539c65f46272da6b578868ba83a76e6a0ac240c3004ccba0 80d9e5a24fa55306544acb007c88c87a5c65b6f3f814d3138b56d914a7c1f046 7635087c2fbf829094a693322f3f3ade9c719ffb418e5265c0186f4604a294f9 00ce84cfb403560546340864755a5e399e5b2c061645bb7c12a7c99b6098ae82 dcf0053ad01d6cb871a35dd4f255956e50f487ed81b0135862982eb4843df3e1 ae49f8be1790b697b4e8dadcfdcb5786ae07e2623798d494c18f22181ee1d4f2 36cf774f577b9ed47efc0b0b8d38dffc78e6372ff1c3326e336b71600789f487 e30e26abc6a8adc3d0e8a226fee82efdb0462b698b98a6a1878c640cb1cbed61 11ecb444c49b4a7571625fd56f8e30c9008cdb5ca45acbb8d8b716480ca9bd6a b89f7406af985457210d4e406755e995cc07515a414c0c6f751c4269ecf03eaf 7456e8c3d729f835db509c26a5b20a9349d73cd5a59c2f09978df89650f7db88 378ad7b8655c6acb0309dee66ac1cbf99454869528c5cd45b17cae0386db60c8 86cd4f6a7bdd988a848508a368343b0fadc1193111fa561687db3cac67e2696e b62cc61b3a0e5cc7b99bf1107caf5d810d95ddd4102ed701d862426639bc3735 01b43550d9efc0413fededc10d91ae556a36c29151bf36e94c391f162ca325ca 75c92f49af4ba741ad911d40d2c4e021927009b71602601d9432468069caaed0 4952e76de4f8e470060e655a18c697523d7ae0563ed61dc70a54cc3830e3c988 562ef593d5dd96f709bb82c1b59ae43ea34b365a05026a7344010abd6c419fbd 4699941b91092f0cf560e7f9f35db0295f952f11c5821635676538495f663201 ea0d5276b2de554255c56fc0589e3795fcc9f39234b354ad8cecc554b7b8f6bd 685df7e6f427618f22fd206f70ae5b44d71f408de837502005777fdd92bbb4bf f364ed496716cd88da9cd2b9b404f620868e8195de8d2f367f2c4c80e708a16a c7c368adbe6409674f1a2fc603ae4fdc1a7cb31ccead9b6e1443a6bd90fb35be 248ec8d63f6c5cf526819521d866ab1bbdb6cfa84b0e87dd8a7ad7d1a47a841a 4dc9ca992f062b7a011c372b3e99f87d54de6883627d42cc97bc7a576a551d1b 3dcfa728ad76ab77e634add3524207937374f3eeee11a566b5babddedb647fd7 77fb0e227ad84997ef3a5f33c800b7ad6033aeb0f3eca8d688abc8008dba62c8 b8990b5dfe159a6db927724d9572270071593aadbed7d4e9b9acc4a1458afb70 72886ce644da16d21a4eab8b7d00dd65f639a40a5dea3579ad7923cede155007 6ce176ac239a4afd1d9f61f7cea9286ee6b5a6c3f5d8c76c02a3e6c59600deaf bb67aec3e0b94a73aea72380edf585f9c47232f471b81ba1725beb05d6352cdd bd4034fd4c3d280c619ab29786e48bcf7bcc8e839941cac09d57eee9a67f0cf1 2b9967f5aca1eb4e0601d393b1989438c1934a0b0dbdf515637c2fc7c9709a02 17 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 +generate_ring_signature 9d3b5964da0a0dafb5a05244d09c44cc052535bf41794549aec9b85b7a238998 b7d7b25d39766c953ee51d4057e3746b82c88731470657ffce7f90bba173c870 1 a0dd3438cf05d1a81fcb179ce77f0a61b8a47525d2faf17808662ae3d2127d4a 9046bd3b0ee4f3b9f6874301485110cc7a5af1806eb93acef62718598a837d08 0 e23aec06c42f522fa27a26c07f1126ef76df8daa2fba3e2bd281d1216e3b8a0211cd314ae476e2eee93b97bba6c2cead7902c19b12bf4f842e8b2876048ee80b +generate_ring_signature 36c2cbcbb47f9040cb04a7e8e1bd128dd73240ae49d6a91e793c624f9a1b5680 faec603891f4e9da1cdd3e6d205a4173aa202867a1eb5959cbc9e93f353f36ed 2 2d266206059c398811fc3ec5e99c37dc51af758c47f094bcc5354884fcf0e83b b76f2f51b0e270cebb200499466d003705c19d8589e62d6f2abce941455aad68 5b96fa1f454618fba2f17fffe6a26238269fbc0cc08b9361aa03c451d1fed50f 0 c450e33cffda6d0c2c20c5f48487cd47df88f46ff8be685acecac655bfd97b0956d048145f354285818aea10763c2612c40e898e389642163550b8dac1fd6d0c45e4bce67a9e204b1d9eee9847b625e1d85b4759d3cf0c69a79b3fe366cf46073cd787690b291ae2946ffaf4ae40fd2738eab9c963debd4025958916e01d6708 +generate_ring_signature 8ec53a5456f968a3c524f9096eaefd8df6bac7b84fa3a94d0bea97696520c66c e55faa7e53c815159484d92d413bcda25408c57907fb97debcc43b82bb72454c 81 4e6ec9a062da749b4c7ce55c1771c5be74038853f1ec913878dc89b65a98ff82 76f3b513e21d14585ad5489f7e7614a99d0f565ba1d9c74d7d3ac6f4de6cd0be ba18df4320a46e06f5092c242c34b1e5780ed295992b8988d8b58fb4f4af8fb6 038270478eba4e0041656da105b78146c1934c9e8c43e54e37e4103dd9b2d84a 1d88989753b94a019df5b0d526a04355b5caca57eb89dafc2ddfd166cc2d9b16 a18d580f24cbc8814533279e50c1b76c62a3f84c8149a5f28985330342a5510c 8c97df0e0ed3cd10d4546368038ac04a493fdb4f776b71f2883da82cfca39ba0 d51124bf2d485048464f1292f68ac4f2f2d381ee4d776f442df04470341e5dc4 76e1c7489de49f7c029256219e12049f8868c0326dcd9fe7030d4cac30567dfa 0481ffdc653eb171f9f868759e310680c494d060876e40ff8259129ea672e213 c086abc24ec1e5d6c8f1a88fc25aa1b8ded0665a092d57678eeefc7a8fed692e 63068e1ba561aa0b5b7e3338583da9dfae07af9198024cc19636f2ab864ca457 2523398a630cd53e849a151ace8438fddefc758d65a0983556ebe4849cec0e69 05715bfef2fb4e3d04fcd6caf880db87df20232d9e6c22f3e536a051833eb97f 79afae0b5d5f0340259f26c0ae49f2d7b2efcf451f721386bcbd3db0cc516cc2 32dc102cb33a1dffc0551aa87f896bfa4ca364d7e473855053ddcedad08f6192 28772c16ef4767cc67a4802d334e62b3cc366320ddcac5db6ed6da4a3a518e48 ae62ab17972d879f26be0dc8a4e0e72cfabbeb48a1f6c862a566744c73f0d5b3 95757dc182b24d6e76f770585632e8e2293ecb0b2e068b1415c5aa6b8844bbf4 a9a01f9794d39e2135c734007c792c0170211b2f31d22ec855de6c2c9bb099ce 809e8daa0bdbf2845adfbff43ed329bfad793cb1d50964b76b0d2dde834cafba ded1d37ef497ee99ab7f47ba850d3d1592469939b25fa0dcccfeffeb6e487256 5f0c974156a91fda39cf74c75e8418f5dd735a30c3e1be7fccc6e66ebaf51bb3 df40904f087cdb5c2d375fd9e9cc1b8fccbaddd8f8b366bfd6c4c73d548c89ca 86786f17d9de29de6a6f3a96c1f15efd1b795d97f316b2945ea60497416c4d22 571c315699e3f94b0b49c31c9603c952c1cb7b4f501ebc975e7cb9aa76d22486 6b37e86d97644021c4aa8a7570dc5c75697d8a5f48c3d1dc40c5d3bc534ab466 37bbbb806e9bb6515f1b506b554a53590b078f3fcdcce8accb1503d83b4fef11 ad7c90bfb7c44aa341d1e52e1b2ca429e29ba4db54dfa33b061cf6ea1eb00f73 a6562d8af16e8877bc51ff84af564dc25a03f7d0d7535bd2c5bbd130b3e762fc 15baabaae493637cc08130ebdcc165d6250f863613d137e986c3318eb1e1d53d 30bdc4dc44932cda6b13dd13848dbde684a136dc36ddf053c021a789875fa5e7 486d213c4c340c96fab9ceeeb238077f728c3ace8b01862fceda8d0552b285d0 31b5688c7137a1f2caa7356b494db41e82e22dd6a8fbbc1d6f7f2c95bede6e04 df368afc6547d8757f35c2f1e925b2401a976e3dd656790c29df95da30aa7d41 5b457edbef079804a73b9b2c07ddf6795cba1dc7b2b378efd4e090206556c0e5 1de5856c9fbcc5b9320f75715d93718fc5ef2e131c202c109ec452576ad8c0af 57efee62fcef10bf49fa000f0859bbb6bd87601ddb2fb92c8d5b7155ac088d37 a66b2987ed02312dd641783d5e0667e1962271ff175d92a9cabd9f8ee5d7efe6 1d295ca90c2ca4e776946f589090f8b29ed75cfd4912b24335d1d3af6904a165 5836d1b2feb67fed61162fc0547a2989cff2b8223a54e304731ddb1777a53ce1 cf6c69da62ae9770b7cb9258bb6e8b14ecfc4d48157742c2795dbbc757bd9730 15d960a1be78b06fef10a1d748f4b7102e16e7b9b515b85e4ed56366bbf4d347 6f4084468f6082c7a3a09ba66ece708020d294c17718c8a15ecd4c84cea2e269 db08f8b2fd5a814a77a829c3d81da8aba108bb0a30d0ec79095f6272fabb29e9 bc4658cb9532f7dd50cbbe9cc3b69c42c684f1baed27c68f7bc61a3d0ac6fbfc 70118d671fc682d4ba0975f6db97a1e946ae1523a1602e980be873b3bdf7e262 100e6a645828abdf759c25a993f3176bfd861ec8b14fee0bf2257c6942f3cfe8 dd4a958e1f2f175763bc424c37138f7f6ace5505b4730c1474f13e29e9fee09e 981f550230c2ecc818356c5978e09c7bdaba2bfa50a18cb65861c757fd2a92b9 c4591c778f2af35031f0b8c10a9ff2076ebf4743dfcc683b135af85c68692734 ae21b69401e1dd790b5d0ab2a9f302f9596d399233c527fb03a3c04c174e9deb 1a479edea2a50f19902e1a6f7222d5dca50220170d3031d932aabbb2a2c60a50 ae222e075a61554b2931b48ffcced2deeb724b0931e57a7fa42c83dffea81be4 e09cffe50c23b6b501416c062abb82c4350142d512fa7718a1a7b4bb0c9c89b2 140813e40064d016f31c79e98732ff2488d8f5203755206ae3ff8b43ae29c2b8 755adafd8cbfe400bc7f0d6c7e9a6745f805094fa56411511cf71a842dcf5e95 d2f4bd013ff2a5614a0f46d8f8291a727974291ef07d6304cf43a3cdfc8020cb 77b077c9ab0974d0f7feda41526b5f3c49aa93128c71c20a32210320e1f64b76 5658127bad4fe2d7f6dd4dbc60a73717d42208a526b6d0cc42a0cfc72dc5de47 d990e1f4737f9389eb33c7ffa8b5ace778993c3e7843fd8eff9e5716d7dc3823 258ea018c125c4f407fff137b02e0b3f5746d2ea37e5b3f0ca6adcafd4d9fc36 15df78d82effc9eacf8420cc9e11aacac8d5e909cc54acc9c5bd7c4c871451d4 dcae2deb75447b6ea9fe455cb32c80b6d9e756547da0645f13d1089069238913 fe5566a38dbd13b5a0a18c0e6b39c5774a98c588d2fb2fbf062a6a313dca8e15 852091726bb4ee8baa253c406c0faf71cfc6214aaaede4a378465c6b8bac7d21 927934f87ed1e0f415b63e60145baa00c5974030a1c5eb8f24b7188f10fea32c c7db3aecfd44d679199341764a02c3be4a87466677263b8b7d05acdb694c124e 3afb101244955d7befd723e91c81a286ac7f651be08f9895d2273e2d0c49a300 2500f40884d6d748b93f852b6ee47039fec6db5d3377d28569d0fe76455ea246 e1b1e24c5a4eb749ae2e2cab6fcf3b86634b426c3743aa9ccb25f50d99ead1b0 c344cab976b25c1785abeca1946186a1b4d5c1ff5bbab59d8dfb6ad5db01a8af fe2baccb1e96d61f5be322ff3e39d5b72d5cc799a758de1313d4793b5a723fc6 83779c08a1567d1ead921064d6637784b8b85a2d18bb3facbb48e530cd5830fe 5560502b0c56672bcea621eb22343c543696ff0f25b230409984d89b083e399e f78636ef78c66c68d74165c4635fae714db6ddd9ad3b7ad51c7c45f125189b37 f344bdedb278b1a78067d1effad38e71921c10c7ee69b0f597e4a481b4a9b014 164d7bf3bfec8c94798fe21c02efb54b58665b26d7796d0ffa3679b5cfa02b31 a7e4fc8d4ec066b75bbe98d9cbcc648ea13bf6b32646dcb58e5590edec327232 03220e9496c7b992044f1d2f3dd65b6d0e8dbd4bf2f5fa7036508d9fcb28a147 6610c3995d2a266a69d4205027ac22196f9817d66da97a547a2d9a41ae582d22 e95249c7c9018c9c5e46e59b620e8e412eab445e832cc46cc99b4c9178100504 68 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 +generate_ring_signature 713c4c8803fc00e35bf91007f00baba57486e0d70d332c9608d09b6682d5a554 794244933962c44feef2118a18c784f069ef776f495f075dcc22870eef06fe25 4 d6ed7494656d90bc14042ae12e0dbbd7b9f890d2347417b21830785a32fb3b25 dacf20780d08fb684de5ac429259951b81deaf781a6e31dbcda6ad07f10ff0d2 d0e455ae02f0be142f67090ae09f49ef67d65c5ca67a2edd0e612bff1b04245f 61b716ef95d86ea4d50645d4ecd717cce494c2d4d42aa30fd13a45e3370a7f34 da2cc4f0ebc2d7f6020c9dfe8ede0c1b216075c6c2eda1a9e10969a69a35d10a 1 fdd9804ac3f38adac249797af5e7d9b17ba749d4484ea17f942d3d567e3f19031e3afff6187c4fbee71f1d638639a0d383aa4b70ce75b6eb1e94afbf9ecb2a05202966ddd32231ff7c89ec7e5ef7d50eea7f3c6a88503993b5526e276941c200173384381336af50a19c2698bd86f717ed7e593789f240a9906720d1b557b0018dea9f384c053291dc8f5f7137ef9da1294c8b164728252b4d8ca63054f60b00f3efa5e410d244ef2194bf98f97774e93203014bef4e11838a6fe285746a9e0c9ff14855c8a5ace856ceb4f7dc54383f8684b6b61fc7bcb27066775668adff0cbd8b1f8eab8f856975ae28e50e1c341256526f0d16928d6a1b40cf346e39e40a +generate_ring_signature c24d45d5956e2ff05c5900e0e3cc833784a44af630d7aad0beaa57fd879825eb 359095816f878d15ab2b0a2186ffbf5d95c777c21ca2cb72d2266d083a4a5809 6 bb3e5f6ae5df3c4a43310d86dad1560abc1f6626a09d5a76eddfb78d652654d5 7a4ac8d3528abde1baf73df38ad03a857739fa446862d1e28c4ac3c83edfd15a ecc674b53bb166ac2be28a7d51e66edfc9f95a324277a2d9d1b908e0f65c5e9c 5841a26c6b246992664b8d8b58769db51a4f7a194fadf2c7a15046a0e2770023 75ee9e843ab7975fbbdd99bb16392452a10f7e7b38144f29b9d706bfa22cfd65 3de3c211b808c4235fba01b016862f8305f0deaab1fb58823f1be27f151acbc8 9b8031370c48fb1cbb36f400453a00108841cfc20f4ef9d9d206f33159cef60c 4 5b1e4888d319e4f8899f6171af18ec7b847b45aeca3aa6498291ae3afc92840f989269e0df79757717c4bdda0815ff6b2e2daefd87dba9b1f408922e8a3186037b5ff96deaf5cff70629bf9d1328090b03b8bdebfbfa046e19b88637cdb6db06f20310fab830ac92fd2e13136b063df1822f0bf5cb4c8c33fab24caeb612110fe3c1918e04e8cf05619d2d0e0f0cfde285892b2224eb9b035ca92997504908036ad5f8e6199f22de4f06152201d036dcb50b902ee958ef367c8da7ee22a4d801d76de5c352036c4842016aeff55ab6e5f971bd5e2b38767853018a91248e25024409cc6e2d6eadc8afe4d657e1cd6b44706b85a55a74f4d4854818cf1726db0f279a4f870241547a43c8d7568171b2523e9d46bd70621675d0efd8f151b02d0f5b0e7aa38a7a973237a93460cc459eb8ac62bf4c6c99a66035159b9819d2050316588e1f5a1c99fe093a868927c1153e342737dadc3d2f8216a0e752369a200058e770830c2cc45aef6f9b768619c081c1e2421b1f7cd1aa8d0c87696776ee03 +generate_ring_signature 9b9e3fcd3f946f6741e6186234eccbf58f97379d2138b6ff985ede15f22f113d c3b4076a7f669ba7d594c52e660da73a565bde7416c9bb99e06e9259d325724c 31 c468ab3f7c3268f7a1839d256c30bed690689a39994e4afe3512c765f2b21ae9 9e8f235c70243e95b84ed1e454c1c86b10446b699f059f66c46e5a1b37dd396e 5742fde4cbfc7422341b8a5449fdd125d30e41357237e469bf0fe77246577442 5402efe6137d07e5b71f0a1192ff212ea8959e080d32b012f937fefd0edbf337 2331347eb9271235c789b6d2be8c6dc18713e878968d77f72b9d644b16f26dc6 0bd583c1d0d8b4b2f8b19609c8d928eb4f4196a491ca45fb1f7d27e9b1a92c5f e1841b87e3d529490cd95098d08b589f51f0c84321b656ba6e0820c41bff4574 aa142732d8b972888a704821a22d62e92eb09b620f0de227981a7d9612333591 d80b7da6a8b938599b5dbba5941781b1217e4ae5a90efd8fae4a65c49c30ca3d b6d8d385a96ab10a4cb6a82df537be9ed042c8f6c42ae261baa487f7e927a384 131a2aeaa5db3afb87093ce9ece283ff1c3c8f7ae83f016612a4d3c866035a54 23cd7cbfd909e99e696f371875e9d7d6fe1f99a0a091dec26dc79fbcec6c29fc e496229d63f8c8b61f17f330dfc30417adc1306275b55adebd8b2a2863f72c8d da2db6040913049257b6ced576f35e4bfa431f25ae137c6cdfb562118bde066f b658b88b06cf34f1897ed99a26a20b0eef67ab280913d42a688b3d862cba3d09 da1f11e2eccd81c0de8498f22659197dbb66bb0512188ec900d44e8036bed70b 9fbf6c6e3f494eede2ca88646a1f3c3e3c40cbc0216227e0c474f5ed7355275d 5246031ef62f9bb1399d8c444a9e3ef99b0da76ce5cd7ecc882dbe9847d1d62e 8e4c0645b710436a74749e8d5531ed8719df52a68293713e61fbc45d5fe8a68f 18a5567a6e61cf2d3bdd2fb0a58a39783afabe754ef59dbd81e370e35954f1f3 a4c53ef53fd1c7dc628b6cac4bf35a5b84ce3703c07040924d2db4ca523cdf73 7ade9695fadb65c56bdbeda04307b304a04b9d5876a1ebdc9dfe35f7484a3ea8 82c7f5919c40ac93fe9c30b9b50b6353dac39748634b5afb52eda0aca5c00c68 12ba3162a1d7ea4b0c110e4b2f7b6f83a3874ebc983698258e9bdb187efd2ec6 62f6e20381447fe7c19968f5eeaa00c04df07ad01f96cdbfed367b6d34fe7b33 f27a9baac0ee08596f753298a41c704066556ceec1afe5a3c300e339a709225e 6b15357d01194d299f5dac3ac8dd4ad6cd02588038c3d9a8fc4cf322cca7be66 bcda402e1596fcea31ed893a65251f5fd60cc2b3571c5fcb1c8418bb6ff390cb f04d671aa35a499ff64ac633e18ced492f00946d4e3bda70d6274350ad1c313e 6b11299411b8c35cf07ee188537faaec524cb4ab00b28055554673450183d288 cc0b067ef56c580d768f01f0efc8bf7293e408d0369d5c3f0666a2ee4c70c553 28c2450bf0e73521266c017a04fff88bd10933d316572e91a497ffe3e9a48f0f 15 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 +generate_ring_signature f31b094e55ac7802f86f73c3525a6cd8e769ee880a8c63aa2f5992c255149a75 b17df6621687c3f37b1a5ce5ac09d95546679313dff994083f079b5cb462c930 2 9085d0eae6ab0e2b4c9289ddd4b4405dd818dc5218188920df043336d491f918 5048e0efec6bc401a73f920934508f4d9b99ef5ecbb439f178b7e65c7d08f410 39467bd15083c5504b8e2a161aa69a6e54d336270f30814bae129f1a53972306 1 9c5ce73c45d1224c428e64dde9da2f8640759856b4161a5786a9fab3c65fe6046a461b19e7db170b714ec09a91f1656cfc731c2933e4b8f2c369245c97e8090c4497b8f327e851e12ae649def66dea0f361d17748ef14a89ba332540671f4b0f7d4b7bedcb372b8c992f5e4de6786e5f365568272f0332f918ff9463030bf804 +generate_ring_signature 2b1ed38fd7d880a817ba1a9e09166f4ebf6db200b718496e4b0e1611b699a71e 71dddaf7adc360a91390f506b386c69a1cfdd89e948d803863f742d9fb9c5453 11 7670293c88d3439719814fa939089f77b31911384f46863e903d78704c004a4d b0bf008c1c329ea891d807a1d7ef55316b480c19dd90a00233ed6027d566aad1 726dd2e15afbd42415d0bfa6886d84e1f3eb9442f71b4088b04c79747aeab11a df4a86c0db52362d3beb62ee1083fbb3c400553a99b793ffd20d4afd8cea6a14 ff9ca05329874655d5be3d882099ef375017081b3b16a0b7da8cac1ed3820988 88baad2c438cb5208973869e561254d3a38f4848039b445b9a4e8edd2522c325 7285ad0124a73272138c91e701daa44aa52cc647a73351f1f842bd7454efe5ca 0cd91d92f61536a7fe4f7c9a6dc04e2dd74dacc2f2f6a93af216dce3f69ebcec 0062e10dc722a08dbaa346d3c2070973ccfbd511dad2db35f77e8c31eb95b913 a9290ab629ce61f962650140314ba4e6e23ad47e1196460bc33f6ee92b18eeea 6cd25a8510ff4112e5f2c4d15801b7a006db3092e24e2db9cc216c7834fafcdc a5d6b5f4dcfc705c6f42f3ce3854458503a5b82742a2857903bf9a57f297e703 4 23a65c466076e1e95a0381ea2ba6d8611af7034f52042666dd29764055f0e501d649e84623173d42a4b5a7ee3c3794ae6dda54d47a6afe2425565a4ce255c00fb6f44251bce0d5d083ff6cfea3e6122dbc504335c9ee484f238b910bbc1c0e0dd2117c142caf33fc0bbc08bd3f1bf3c1e3a1d87005b6fe8705e25d0fd484bb09e8cfd796ea5caf5705dbe3572b15505d46b33d2cac8be84131d36abef689ff0865acedebe7024e59cc058902bf8aac64fe2624c37c82101469ea9f32f85f2a0d327fc91664ba9c327fac963c6d438ad381f07c3ce2afdf1e8ccefded9b06e3079f990dc7d648559740cd2e295eed8e7a093a0a4d91c8f0680e6ab1764f752a05123ffecd5777fab647739b996c2c0db6f2f45cfd4331900854b4e096ffa5e801acf3f46b98fb73ec9d49eb0af054f427a080935013d163a5b1749ba659df680a15c88fa87036f1b74724a8d5970aa99ee1758965760413a41157d14bc3b25702ced86941277241da0d5a43317b40452a384c8416ccd3081ba3a4bce937880c00895c50ce6ab097705bf767aa5dfaec938014c76a8bc364caf08fff1c1b7b570e3549d741afe0a4e257d522f29e15eb08f529b36bf1d9ae11dd5878d14c8ce70a51553dc072ed3d13475935a260306dc261ddaa8a053815a1a9e0879fb986ae022928f46416f8ce2a36d96efdadf0b37bb7b146309c6ad95203d092f08cbce401d0fefb0a56c7299dd831e2ceec14315f67dc8f364949bada3cd5767016d7d30cbe7d2d29f8522c7adb5e455a2a892a8de82428d7415463e602b9443c8fedbc0d431ee3ba18d5c934285a770cce53335765ad8fb9e628f5def6504098d4b28b00c30174831f8bbedf2ca3f407e9418d79c3c4f3224524ba6667b03ae52de89e05cc60f057bcc5231d205dec3e13d827ae9f740aabb33b7b9a5da6ba539567020eeb1d79754f16a9bcea076337223b1e441f2598090e48495856d9aabc0341a40c +generate_ring_signature c5093dd27848ac8566eaedc9052fcd6197c28bf93c33afebaa7ce2dda5876a00 323871a9a595066bce864c151cafd777f14afb4943761ad5a574eeadf5cccb1c 251 39937708a3b6828e2561d337b4bb62a05329a677891317ef1fbf021efde4a32a 7d853d909949ca86efe934596d599e2d77997f771aa4877b6f66c9ef477cf18e e983c352edee9ff1590f1b148b377e4a2d5acf31be2fe34df8f6a8d4c4e4ba05 7e1871074a0892900d96e11c48249bf88d429d7bbfc5f0a1029dd27ae601cce6 053b105d261dafab41652fd16d5f6fd87e2c3802d396097745891a1f41af5c99 3499b5ae6a1a148a140469d676a0f42c4422cb71202196215c5e35b35dda93b0 cb14c49d87d8a24cfb716a35bfc392ed5ae3695ce41a9c65c34834f3c820ab4e d4d25b34a483a582179cb1c171532f16f1672c5350950936984484e8f2256c1b e657b8c50f8c92b530cbb8d9e77f3db440326b397a54ba56e3cc6a0b123a092d 4dd6a6ef7f8d5bc9f80693c0a886b0c4432eeab776c17346ac19504f46d622b5 130e7e54142cad6b55cf6143df37f9d206ecab657e1fce433ae278806ca1d26e dc7113def3d74145205db0179dd574c8b00b0e708ae5eb7510c2624500274532 7335c7e6cbd4e8153b9c1ee028e3412f1681058440bf04e6613c49fe1f1bc75e ae3948dd1c2d07972a05cb741943e766fa304e2fea461cf909eea69de08d4e79 28408929a927aee09552e8a162937eed73757ad37ba996365672f1204ad92717 2fdfbeda21d8293c0594ba9671d0110421fc35888908603226cd7eb0995e1ac8 3cfad5a488402caf59a69746fb5cd739782d61d6e2cf71c57bc8c1127055fa19 cea1d4b9951267cdba6ebe4c6bcfb7ff7f465582a73f3b8d60726ee1ee4564ef 36049feba81aabdb2b44241538d15f60fb851dfbc19d13a6e4de240be745fac3 d4225c2a253f2cbd16bb65b500ff4369240284ef1a4cb1f77e6e8143300d0fae e8ce1f23cf3ec0f98eecdd9c744f9894a5c8b3dcb0b29431c4bda4658b4ae24f c1456aae2024890d5c914e9e0a2926e7f004c2e2532572ce815a9ab91f8e282c 959ff70881dbc4521285d80eb7941cd4ba94418da70f041ffcc7479c7c513ccc 7aeb49c0c8b4256f7a718665b575b13cc0688964a8c947edb78eddee1b32656c bc18deebf265b86a577800c425c3c194a390b295063a87aebdf816315e04a0d1 e3e9862b6b0ef2c15cd2058dc35e03c2aafed007e25ac3aa59cbe2654afc8d42 00d1abb0f3f487207b0d764a621ec24265e35ef7d5256647b7404976a8bee167 9db522d9789398ae5954197c166cbd9f876c342836c100364716a3d23a3cf885 30a63e8040c68e413514de31646a18847214d70363850e40bcf5e9f5c3d92ca3 2a78fde45151e821a1a924b5241a2403ccfc6ed62d2463b09e7070b7279c5a9d a26c48fc6e7e82af42fa3cfbad13812bb6395aded22dd250b79f47ee7dfb6581 a801330fb5930a20ac3e1d928ad94a70faa44e7d8319cd6c781d3d5e0b7ce0fc 7ced5508691face4c0630aeee6dd57f510911092109720982102ade5361833b9 2232855cb3aac2d84031685bbe847619d358070216d20f681104f55bd100c2e9 6e49a809ca9d63a6a21496ece8bc4bcf3768b8588456ec1d909c2925f60e995e d3a035827bad58e5a65284003b112160f3d2f45c103bbbc13f00a92f101b2e7b 3abf72f7ac3ffb7fc6113fc42e26031badc02e4d8fdb3f7f08b436514c3f5a31 2d3b155aa6fb6ea05e5a8367039d257fa0b334039d5ea0ef11fc56b8117c306d c7fb3b153d7b88597b92ae7d79f0e3185716dba81744ddd9ac1fcad2e0543fe8 1325b0d92f95fa8ff2cd42384cdef4d2976e61e76ff73072bbcac1369013789f d8cb35a8558bec532c929325f135119af32d6e46a2aa9931a7464c6d469cdaac 7a7c8d38b604d98886d467cd766c40abc920d751c2c94574fad91bbd6a8aef5d be6b00d3cb61d3032253e1a7347e346dca1bb51a92a3eb8b071af0c891665b37 0717cb474be340eaaf4a144b64dac510b6e8e63e3bf9e8bcbb3c46fed88b0f52 3542fe85a3882427abfe0b026c12ae8d195a3db1534254a8d1af81d25992489f ac694745614759040e5dd4608aa75f9b570f77d2e166364d6912cbb21fea0823 5cd8f7e533b3c94444c897c8c91212f0a228fc719ceb8bd55a5c033700dbeac2 872355c0b5f2347b4d2d7fca96f8df10e41b45b9ffb72043a531274409494385 ff1d9017025185587a0a4cdd7c884cc70cece019b26ebc15b09f716560dedeef 186ba15a08137c92659ef620170b35f6b1bc9ecf4c029732451394adfc999590 9c97f115d584768d386ce5204bd2d3629aa63ae97628146498ca37b61918a442 79f55796b89a671a06bfebdca61971130b23fb61eae4704d2fac27538ac499e7 b90a0e602d78353e01b476c3a2c35a5f0c7e5f415bf78d46ede20024a1d3c4d3 a670570bf89098e8eab1fd7afe3e00b01c07049c3722d66dff9b359fa895d70d fd465b0756c76e548d9ca89b6523c153bbfefb1ed9f32774f9e114b60a551d1f 936420d78379ac16945964a1dee95d71940e87c2e88c0a309f70ea710ef1a1f1 7821936f936122f4adfe274bbd32089d4cec99401014b67f0cffbdfd3253bc51 30d8216ea0f746b13f5e4a43f6c4d297d7e6db7e19445749d595eb028ab09ccf 7681954cc4cbb792670aa9a21e64b4723d86495e4d6d27b3cd606b00114c4397 e9663cfa339901c3282b9d2b4560015f5ebd7fbbd4827023b224e54109933369 dbe9eaee8efc256b605483f862a3dc3d5f70a4053ccf29fa4a52d008441decdc 633da88c3db244e95ef373d027a09cbb954ad208fe938f44c3dee2a5c9bd7a23 a1aebb8588a8f423fd40bf80763d0a0e5c4b1bfd3fbe76f14f9b307561ed03a6 9863117a21bc64aa4a8a301aa9798ff1fe6febaffb1e2958b259e1783fb5737f 2eec0edee3b2793b4c35d7759054e7b0c15d4d450b06a5025fb65d8a60f15372 8ca8ed9269c7c5c7ffa431228e9f688716fcc4133c8f4394513251ec26fe3159 f345a4005a7c36b6b78d97a2a030e84cc8157daf4a5a02d63675ede07529dde0 f7cfca247ffb2ea7cef102761986bb68b2e5032245960d800d5fc65d3947f9b4 59afcb1a6088b9530d8bb2435c23a885ee82c3aa0c2e685631a21a228cf07e16 1f4b5692aebadd8d08e8f4468b568a94b2eb59d5d4bf26d5343cabeb20f80f01 897ecba2d98f671188525193fe5dceed743d68886ab7fbaf5be3d09564b619e7 bad4d546d08f62c1e14500f7e340a2eeb8d39e5aa99b9f66d329dd0bce311a37 a6fedfca7f611f99b505df971c935955e2a5179efba1f0323340d67962c4d84a a30f18f05878d4815c755fbe7569d5c042331ef9d94571b0e506892355bf79b4 fd7bbe962d8a76822895dc0b08c9fd60cf1e66e7d91cbb4d88a32d876941463b 5cfd62b1a9c70f8805539e08134011fda0bd8512815c04a96ab1b79f84c6ca91 07477415ae11c9974543d373acceaa7ffac870868220a69e06c3b733939b383f 947545a4a8315cfe81d61a3caf96f5f1a41d7cf354d7095891525ba18d5edc7a ae3e36b290fa5663f46cb37b4d8785778b6e7a5b5da34f28f7a1771ccefdc084 54d701879193377dc59c6df056652fd546b4f3accb0fabc6b6019320cb5ea088 18e49c30704466549121a72ef2756c34a208791ffee54ba4838225c88bb8a8e6 e569ad0ca542a034679e69d502cb792d6a6f8c864c6abdee43efbd188008e9d2 54d46ad00303564a2ee8ff3360eef10952abe041485f2876016994dec2f7ac1b 612af9076950f88f166138e7bd7eba7ce342273816ce9f701b6a3ce6a385159c 527ad33d10c16c2164c4493cb5ac7e3322cb31282c6abc8fc60d5c19395c291f 85b25c37f30e9b1e6afac878fb0fdef3b5145443bd9ba551bca138ba379817d8 f1ecc0173843823f14104228e526537ba7d80aafa2a3f048cdacb2c0640001ae 1cde7b25a4c9b20d6915df9262e220cf42af1620dbe43fe677f97a1c5e021194 40ccb1739d05ddd2e883bfe67a4b4b00807aeaf758a68251b109049674eb627e 541beec1429c13d96d5daea9a75dda434c11c07f445326b1132582caae01d282 646f5b9cc6746bcdc22265a54b7c8043cbcbeebb1ae15b9dee7f6d7c7ec0ff2d 71471b752190bd2ced82c80b406ae39ccc88db4ccc597a24cc1cebfe24e42e63 8cc5a53f3eea773c29cd1a51706f768177f0f388b88d74b2b705fdca00d41cb2 dfe6ec108b198bf4ab586bf12f3f337d341c1a727348582b02e9649a2efd9ae7 02a64a9f14c464086daac1deae485eec3b15b57ba73a3cb6829a45942df6c885 7993899437d2e12076f3311006ec58cbdc36498810766a5825434b3cea5a9fd4 8a99015c83d9788fd6890af7711c4a3701a18cb6691d01c2911daf81a7036e52 6bc9edf373af0048417561db069c88110da2929002ea335ec61b7869501066ba 212d2fa1f059a592c9698bebfa9fde4e1a42a7e5cd3ebcc5dfe4cff5e61150f4 eb4d38583d7578738306c3d8d49bdf9536403765691d7397dfb870b056806878 5086416d7d2681eaef90d4767bc362717d1f75738fe63fdbf399fe987db43485 164a5a51776f41979c044ae85dbfe48a718dc637e7f77602ac4745da472cff14 93cd3e88854c1f515ecdb84622489175df9af084ad7f7072cda98f3b4ea76031 83a6a90b6cba9599afdded09ca949ff11c59f21d715dbfe1b7bb69e8cd30e39e 1411f05a4deebdcb245c7fc6e1260963e848d2d5093bf81567abcf9f84823b36 0d7a2530fb5a816088760d2ff8268e77dae532a31d162fe4538f75faf017560d 0fb071cf8e1fe1698f021a4817531138967476a396b75b3cc904856f2d973caf 030725321cc53ccb7f6131762f53c5e56e9267c4b43acf557be855e62ac1555e e552bf40c1ffaf28e1c467817ef78ef8364d939f5005f981e3c15af2a8e1f68f 7e11b3ad88eb6d844a993b9de6b85439e897ecec629a27e001482461dd40d0ea 16f0aa77b2720fc1c010682081d6cf1a4dc995ba28641cf5bb3ca92be1396083 0d74a5621aa39cd36575996f46f70cb2e17a65a48544ef8153fa3ebd092cd2ac b07a03f471b407eae66bbd77e5f32d7df9ba2bd53600644a6c43ccf2da37380e 2453ee3f5ebc0f2c92ec0b9e520fdc85a5bfd1094774e89dbcf7c47f6a3c8e44 d251b156ff019aae5893d61e0a97d790a6f906970232452c420c2accc10150c0 c5a56fd86a0fd7b6a17cc704b241840b377d47f47eeec7a46b966354655f8b11 9cc2e36eafb7a43d447577fd8ebd8daaed083338bce3c7d150a562e5c77c56c7 1f496612b8a0a887f9fe7ba917df15a26c2a0e5367528b7dc207bfc731bb0ccc 9e53a519f3f0743b9b02d1869a9acde5ebc122f764facec61fbb1b344d71c26f 090a467d9f5b6e63f1d891861ed4b07ca59c39957c94a58b61bc31b0a5fd7ae0 0ef42450c94af1bc08b782b5fd13d4def2d845f1340e911cb3cc1a99deef0987 f56cf062d1975b7d2325078fccf313b0ca0f9bf47fb81a1f9496c59a56c38c9e 72a867219b50935dfe77b3b1df2962f2693f35d1786e586c1106f275e2fd43d1 0ce8053f27a719156673574afa97f4d4472cc0e61508e5e46f34d60349d70a24 7ae67af34879c1a48f48338f3c6a43e28b7adea79209cfe307929d2c213d18bd e8bc556cf00960590987c6b8e92c034421699462da965550e042b0394ce5f3c4 006ee6f0266bc3d1ee4de3c4dbabfd237dad65f3d8d1883be6e8261800a3f504 8bef60f2f5d2a4b6f92113fc6e6644e25786cde40c5b5756f0f0c00660905ee4 d5ddc9afb5043d875d63729e1ff1454e33b625c4b8809d6cc78a722fbad332eb eb9e35797e0754a91ce08ea61798563703fe8209ff6689c88b36d6a30440cc23 32e5d527199ef20bcd81d4a66bdc2ec4e06cc46ef4fce8f047267313b26b7739 bcd9bd9ca2c136832d0469c6e38b8df493072badc35ed90bb6063f10f565ef95 587cf5785217edbd9406ee2210fee0b0963001048943eb4360da7a922e09a6ca 66faac7543d5e35abc41ff40e93d26dc3dbbc0225b283e6803a8586a25d8f83e 481a8dd416ea4cb95da47d4df364da485d7733bf9544956082673aa41655fcd8 87cfab1ca3d4e95aa3419c6c42fd3eba0ec55dbbb4c1dcb2f344a10e0a4c1fe5 66925ceed101bb8ba62b1023f59f4caf1f30ce11d98971e5d26ea31419849e5c d5b3eebf8aa62351c4b731531ef851d9fe093327fb7a4598a5e3b0fa11d1aefa 144b857e9e1fd993dc9bc2677345d5cb721171e42eb90749675e782664e6c002 b93b6b29b90149848c2452df74b309a91ba6b67db97f03d85f0337ebc8cc624d b7b8343623c8331428a87549b7b93cf932dc3008a94920a95987226883bcecb2 7b4538e82a894a23770c06c18aadd0806ba8a9d2a001c07cfaf4be39913c7d2f 925df872ca181459906b39330b8238642f0c2ee8455e79378077064b41615316 c474eda94a395af8db75357c336d7093c996d9d73572fb646bafd395c8ee14e7 0d73fbfc77b3fe3a5750280e8d5a5427417a5474180efd55342fdf464a286cd9 64be1caece30b05367337ba9e0cae59a8b5fca0f872a256a2ca529db87bb56f8 8be33680a41f61ac87e8834991bf5bb066d6761d6b8dc1ee3261ab31d9489e2d 181df403060aaa9e45775e7711244a3eee977179a1a8b265ca469ca37ea8b918 c75c38b856bcd1aba8f0b39da20e99454a829a64aeda962211501db1f44fea65 ade8b070d01fa4825714e9cff03d3888b8e4494aa106ece1b5f19ac93ad662a2 be8cb23501c41cc8da43ff11695b06f03a7bfcb556eebefb3ef756a4d3adf39e 635c8c8532405004c47ec4f598eaf557d0f190101f2dc9092cbfb5d2c194a632 9f0303816b3161b9a54ed048c58f2aebd4b50dd1fd74759b77668d55aeca6966 6913a5aa387f5fc1df608509e94efeabbe1e645a7a0b2ea1731f5c2b76c4487b 3439a5b52138d8489f8e4ea2b6eed403591ffe406c92517fd92a0b94699f4338 e37f7d0be2eda682c76b916dde8e1f59e49a3f728d0e6a384a70617d20d67b1d b608f6462485000a57441392ba0a6f3e080a5702a2e1c2f0ee076c89396e626e f45b075f8bacc04dc537a68e3152714f9ec771cca01e8dedbc8ca0556bae3e50 ab88abef0ba0c0f80019a69d3edf35bb3acaec3b4cabbb999c2811fe6c0e5201 4131146f23703cd3a999104ad4de0e6cbe70617a18db2f12fe205ac0145c9939 7533bddc26066cbd331ea83cd47bed0803dcddf53e44efc8d08bb25622008642 bd4128d7a66046ea22c24c4113bb19550e8190873148ae4f8f7c2ce5088813db 97b798c7b5bee39cfbdcdd05ee03cc41531902fbf2510e2173fdf65f77d33e4b dcf940ab3e938ebb84705381e9bd8fbbf28d38147333027c931969294a73c5fb 8847b8216ce4370e2d6af86d9078e9076dd0d1254d39fdf268fe77fd555ac582 1164bc0ceb2209a98e74b2c8b0208d87e7b22faddfb85264d193b9e635bbfa0c 6389eededbc5d132c379c19f329b97a17504c1d15a0d1394f0c5424d71afed2e 23a1015cccd6b3e32b86be91c5cc6e284728e7361365492b643695ca569bec6f 994c0fa0662667820fe339e742f682eadb7363c2f32bbedb3c0581eac6103130 a07f149f06097c6867f376efdae00a1eadd77df6dd962fef3ff384aa62dbd994 132ee638838203d2f73abf3d2d6565a2b66a49182fd1efcf4e74f337dcef8abf 6e88dc3ef36edcc0a0855b50c9b74918c2a97c143158015391435bcd51cd997c 2f667583cbb5396449332bbc7eadd753dbfddbd858aef3427c1a612d5816233c cea8feb61dce52b4289a8d5340b4309b1c5eb6faf13f1119cd4b2bede2a197d9 784b19bb39c04a0c64d8e03cfa02cccf2bc421b68641a909367d0328917b707c 75beda4e48f1475b63c4e878d44172bb4c4c8223af792ea94ff990bca6b3069b 7faf00a416bd08e6e4ab4ddbfdda1a081a00a64fa0392b95e9230eee21b652d0 2fb7d868c25ff5d388eac019245e59490a83650409c4e6e577df9b3c42f0bed2 b69baad2f76263308d1f073fbeb2f1e8c00bc4bd11191eb5def5a9fdcac60ff2 666f450028ac20329193551b9c2610d8b25dcb9fa8f5940f43e7a60e9c47b7f0 84a1f6033685833b55eac7e04c741af9f760a50d56f209d222b0d2b46d42c532 f227596d9f75206ce74f2f6078986571acf0eba96100e76e01333836cca5828f 787811688624da50922ef60b9fed8899a3734ed64a553ea174255c02b775059e 0c38b0514b4afa77993790fd35a2313f70e2a5c7f2e57504e86b15b5be965b92 33e697073eedc087320c51d1ecf61b54d5578e355c636418b217f98ad8fbdc53 4b64e1c35f9eb38ad17344a4165489e69ea3407101b409465ad17f8b47dec206 7d6d53cbf0c498461fe18a8e68a19ab04374d171951c61bebd95dc4564ce1c98 17066d4063e136e4ca567b7a2dd79aa7aca40634f87793656fb38fde733dd759 fb9ac5740f31fff598eee443097156f3790a54ddb14cfe02aa6cf2e5b3263f46 b7f18404b45acafc9bb8cb10a186a696ae7ffb84126e5458f50a2f1794e15469 929ec779dabe57da88b1281ce1792624c729187e4fdc0d50585ab8528702db2d 8cb2b46ffcad9dcf356bb089b8beb2a461e4ad8cbd5d2532780350e37e41d0b8 25125b917658538e1d422595b7c4a5917d81e47d397b74baa5d713d1babbd730 6ab9febd5a2f5836ad625968e702dacc6babc7fe52d428d7bbae17ea7c3ad61f 4874db513848b00dfa108c53669ebc17506166896af48e3c68148d4bf8b99939 89872f5084d9875e216519bf5a6c0b9211d3ae603683f411ecb84b381895e863 6cd5ae3853e0abe7ab6854b6d0b0926d92c144293ef4dd4f9972fef1ce5d6e37 ab3475fb2007c87278a0b7a48147d165640842d5f67169dc0f3ae2fd305db10b 1ff198d5440e28b78e48d730cb6c210adbe74d42862b41c5ed42515b967b3c68 9cb44a35a2a15d1aa9a94b71d06fcba5758f1f691b48d1817a063b4be7f2ac5e 3b1552d31a70d241c3c33b5ef0358cc846b2565427d7c66094f08fdf0dc553de 5ab0a9edd5f873c69035024f5ce6dcea1fcbae7c75a35ddd3212783d0c692957 ad1d6326f5f0f122e8702a8494a3cefda9c5ecacc61daa3b3fc1dd94fd58e5e1 f8545840aa70b10af0918892800f095aaa228d8cc94527e93b1e5040d1413c88 9209e8b69e44f10f57fd5b60ffd7ea319ee94679bda2321cce9251f1260486ae ef5b023e360229edfcb38c0357ccb791b337630d5296f505763d48ca6d332114 641bf6bd2b1b1356498ea723e0018eba1c4126bfaaf51cedcb144ab2d0362398 6f3e871c296ece9eddc5461072ef8566bb4ffb9071eb591eea8eedfd0fa8a97f 2487fa37a0778bcd6560c8a445d09d5c7fa8ea4f5682c04cc446cdaf1af9f579 7126fd6c1918ff3feb8cf821b586142a07680460d7dfe528aced2980dc403076 d4d6a5d8655a8119d0686d5a82f74606037da1a7a2996ed25e9f3fdf77ca391f 8cc8830b2213ec306c201584340f4b4f5cbd3b3fa3eb36f75786c822e22e594c 32d173fabfc93d005f3ac3ad2366703b38907a2672b5bc724241ed87289d48d3 231ea19cb8dfd1538ad9358c94f381884e5eb671ebee6de0032dfbcdb53740c8 81346e00b86ca5b96febb07161273ebe427f374522df2ebac148d83fb1c84b65 6622ad031e4a255114ffcc1b993d8d3e31c6d65e40a59574905b216a352a37dc d74f5f46d0a64f9dfa77600f3f30b38d2a0143a770e664119f9f77ab9d2f09c6 8e653adfaf5064ea5eeb09d51dd65dd8655fa7fcba239f4ec6ff41379d44768d dd71ac0050e36750b6e33c90efa389b856cc6d06b4a88a2ec732bc505886f114 005dbef9166eb9d661b8954120bc5d3a26f0019ce3f3ed9323c45319e1820551 f5b548cc9af5856e732b3d2d40d73ed801d809611be1b95d3a0a4578974b2d20 defc412b437cad2fdc7299390a68aacb97e78252f38a80d9edabbcd3a4abf3ce e0af56e16a967fb94821b853f6197c6d9994ee0aab2b081ec16ee21f228ec0fb 2853b9be2f74e4731ad0d77b05fae3297fa7087f6e9a6a61dc8295035ed081fd 4d6a31f13950296e764b25be58d3f379d79b3bbd6b38f01fb6d3e473a4f51712 623c7cf4765775246300ad80136a7362cf5c9d862708aa7a19f57f56cc06dcad 548e4d75e578610781844f271035461009b327954bb099a2c1e45ac9b08c6df5 191e63823ab830693cf02c68e19d49e9307c7a4f044b7698dd94d476df250862 e8fd2c2f0a999138fcb936569f3f470c4d683580d72cbc1bd1e4b36faea2d972 925689b1d36695f45765184f979dff2f2bc70efe57e37d9226319b50b90dd469 8fd4bb24b442796650c1f0d825f468b955a34c5b61189a1c44b6df47feb40d8d 0361ed2dcb2a570f577b35cc6d7eeac9b617d70b7967fd4d30f94da25ffffc39 d732a6674821514311651afe2142d14be9526596e9f45e9c8cb658cca6fe53bd fa76c7ea0f87084e9543939eba23cad3d3ea2a0df03733044e73fa25859b8cd5 c8ddeb6e648cfc07f8ebf7a677ff6a038e747e37923849c15c45342afbef8493 5c431e3a46089c0b41ba2136374f0e42ba6f9555b0019995b690e02d1800d814 93dbc3d9dd0820e634aeebdc808ccabfea052b77199ae04fda47859928a371c8 df9e4ec31e852616503784e26457faad8ecd94428884bda9ee6d81c575394867 f9707e1b484adfcde45bd506627735685e0b3663ef00a41c48bb1c11cbc266bb b123a4cb6366790bac198d2d3d400b201c75cc4af7a3430c8a546b9891ae05dc ef38093824a8b47c138e20844f923934f435dc18e84cce31a679a61fe68917c0 e81b5c08382f256377a7fde70b56421e7962d4b9ee90378b201666a0bf88c6ab 256e4f321a15a634355690e49bd7ad6b92cd51c8b1629f85c49260c0c3431f63 ca7b3fdca514a286c7e8f440e8353af4a030c31e5f27ecdbde302a1f8269c482 e6a199df5a488561924613397989d00c595ab63019c2bd1d8b5df37fb1ac7ada 4610c481631c285a6acc307c9439f8f8acfc306f47194e2343cd74efb7007e4f bb2d60b1aeeaba077329246a5a406c310a98f94f3c51ee6dbd102f9e6677198a 834ef843a1b0508f4862ed8013d6555cc21a23c52fb5609c2698c20db9912922 f624c48256355e29be4357a424d2d5d6d9d0d4d8ed3045fd28957d1b747d1867 6168d8666d802eab8552a1908420575c4cc9b5dcda2bbad9c10df93d7b665931 206b2c718e2f34a009b1f1ee7df74b9e813831f175ad5d06e520af8d0012d178 61981a77843ffebd3625d850e0419fbeaaa7a08688d92266f33100d7b6c40d0a 141 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 +generate_ring_signature 590a993f96a147077c4f5cc32f91a7c802e654a5c8586e9598d0b6e4fde6f48c cb9194bc59756cdca58afcda4960aefc51304bc4f6ed04c6c2440488f42b6a40 2 87fde03c5506336f088a68e7bdbaca0f4f0e8a9bc143808305a7047194242664 8b7ef8a586c5feec0dbb2e72d8036764ff5da197557bf179192e31aad1d5beff ec722447735f098024e362a928af39663703309bdb68b3a5e7e42ef7601c720d 0 2fafaa16c3f6a89441a79a8c7f68d08e68aa192ed0f5e2e82aa9579ecbe21d097e1219fb5a16c62baec4f08b976539fde2cf974037517a470dce811619d2990b175d0cf9b323b4e9e49be5a8b61ee99e26e5d43bc48744ce9202904cedc5aa0869cd7281bf84478b46b252591c02035c239f5ee2bdb93c73cfcc4f9f75dc7d00 +generate_ring_signature 0f36247a48d15d7ef13a065c7b1a1ee40149510d7297677108020d7b2a36375f b0226919b26683f35354c80532460ae47ac0c70b2f18a7155f9582904058976a 1 24c4f1e4a4d51bab40ff04be8bed03b4337518300c1a0073bd59011b3a0fdbc2 3dba1bb1ca997825b955163be13e92cb7f823c13db9de96570a1b539c4c1f607 0 139cf18166aad0e61f880263059800a974d424569ce604bc2cd634af742caa0d09fdbdbde93a3faaf1e1ca07504520f6c317b54bd812ce94c5f5c45bce82ea0b +generate_ring_signature a1831c2903f8c324b1693adecbe806b81454c15fef50af931c62204b3e135bc1 261a8904b68f5185ce1657f266f83cbbb7cda81229e313d568a15cc55cc86521 40 9f6fcf297cc2dee2ae973a51eeaa6e940388bbb75065504f449cca9b25267d00 98e264b0c531599a8a579074b2d927f85e0c8b62c437f6372267a275c4e10169 42549d197b01ea3544e172e32b102414187e707f3bcabb6b175a48e280ffbdad 5cbc67dad405316a18ff8863ff2bc32fbe25e08f8c291e790733e39e83c42947 dfab77a0540c2ae33cc85efc014987cdc19cc435463a61152c70336fbaae0715 3cfd622fd739f3eb972eaac07aebf78208c6558bfad030afe4b6b7af38ac5581 2625cf12b9544cbbb8cfb6c43d176cc0722487328d7ea20a7ea435c7beeaa4d7 aaf3c52ed69792553ce48eb77242d350a8cd10ca9cfef151c4634a284338c15c abfb16ed19fe8aba99218c2734a87c62966e7450f66592a47199615d8f08073f bddb2d703ab7e9b711ae268e900ce8ffc7ea314ba16f69a839c8784a22dc1cde a4a71e5b7225ca67a6ca194f5f650cee3ab4aad608f27e05c2a72d5ab1417399 397f57af3d7105156e93c47c7e75205ce4b199d3d668e701414f62bed9f30a35 aa89fc94e7ab1e9c47e2be820e4b852e2841333375c7181534c1d9f6338b2b22 12574a1031709e503b7b55dca440095b5ae32e7e49960df3f13af0e3545856da 2cd8ad3c4c1479a755671fc233c1ca15da6d1319d58ee7fb46634cf5e6d2c2b3 f72d700961cde8dd195b2bd34b8b33c27cd38ead4ff52cd65f32597d9f845c25 dc50f2aeb860353b9c32c9163d2f371cc9b1966ea4099b783db95615d1b347db 02f9a85d776b326a14e3c116f3e34706f831e81ccfdc4323500d28e525c22fde e46577f6631c36676b6cc24d154902c03d8cdc427b8eaa9a16bdf1600dbacc5c f61fb173a89280c2c853240f345f1f4acba37c73fab295c6153d5b0c84ff5f29 78d202b46b95461b1f0850005668ddc15e38757853e48bbe6f531deeffb3c5b7 b4fbd260b5c4d963f1f1467eaeebdf072c22141d53d5b87d4b8b98a162977021 496e1bc0694a985482d5e4deb35a8f5b048d3f6af8d0d12a8c7e8d1425c16cec 5ac968233f0006c4849db8c0134ff928fc34212a6955d2fbe6c4741f29ddd1a1 4d29eb966788a97031479b226bbc1fa8b8124ecda89c039add1f48095bbbc2ef 3c721246302983cfc7fc5505fe05ba883e54bb4b50e87eebe01a44322e356cba 634e670cd777a9df99da4be3ab467801b4d87a42d93e057fa798e08fb239c91e 7f972510a0eefdc9ceb8ad6bc4051d8743642c8899ad90f81882a972042aa120 431c662db985b69fdb1492a243237c0b6575a137065ffd665be0df48773453cd f0c20daf7e7d96d1c1282bfc919af7cee54795c544bac82adc854040ce5bb142 b7429f8a8bda10eb7e6993550f7e967b69a4ae04bcf1be65bdb252f0bde3f097 ed293f21c6a1269a56ca8335e5c492d520fbde3f70b877f22a6a780eb1109bea 0a6b31f4ca18c8cd4e1b6860664e445c32a314b3cfab312f7485b35701b8d033 ede2afc010140fb9b7e89924c1a3696d1883d3255da5aecb64f64ba3d471a90e 1dba5ccec546590f8a9ea6e91170f0d0c505ddfc6793b150feaf64637ab6dc2e 9398df9e62ad755ce37bf7d03b555316e7a3a54714031fc3630e997e8ca226c5 39cd3807d39ae3de4b43789511593e57e3ca4f44d3ab87de4dc50fe8c79fbf79 678358781b39ff78d276740e2c8c2cc482c5bad694edaa12b194bbe9dba7f78d f965175ebd6af2efde584f6bec3180fe5da01682603e7b9a54a610da393fda68 793abfdb3fffc1c2669b18d68e3239c0662766c5745a0f715fe9af5530fa6d2e 07a99a07a14dcffe0a3dbd5e14332410dbb5a035cce4a0171ed6540eb09b1505 2 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 +generate_ring_signature b9ab0b10afa5860d279a36ca738754958805e5bd3290604096442b8a4dcf9730 425b3eda70237941990ea68b9889230fb9badbbccf08a74b7c4a59ce552adb78 1 a15898bb31142d00cea651b265aa4ee7e73189b383c616eb0f6e37ed23ef7eff 84c6db89df73d478f2725b0ce36218d81fa68d1cd5ceaa8a1f8f2f10892c3005 0 b38f61811771b4fdb6ae6fc3073d599116b31fea917a12bd8e1d5efd0da2e406ae986646c96c6e8ebc064dd073197c3d757492a92c6e356a3b441fd1a747230f +generate_ring_signature 77f35661d7757d7d03c765f11350f4df7bd28708a37163e7520bd8c8fc622503 2b129b323db1ce4fdb915ebf2ddd4be3ac0798b4f9fc3e7188846d9993764fd8 10 ab241334d6e35fd6340511d9c72d5a18159c125336c76cc06eeda30ab23ca126 80832676389cb95756b34c8df992e88936b79d89114dfcc8da1e6eccf6320239 c5316c4465366ab16e1922a835d9a8b2f2ac89aa43e2f6c254c703b7cdc88519 74ea52737c3db895c2b38faaa7d1b47496998d4defde5cc72d070a15d622908d b1d7742def18ea0edf1a0bb3931b3777d85902d969b9a2a4ac30d997773de9b5 8f6ed97932d63ac5c74dcd60385536f4d3905e5697e6c27ee1fbe15edb0bf7e8 be4a83371f1d524c26abdfa898e92049d4f3471acbd5fe9b03cdce08d7fb3f4d 3d1d9750e65c8d279fde02c4c08a86c781880d3747b0d1a9ee063bd978c0921a e9d2250439b623b02e4915ba6f3eceb0a74bb7af6bd8ca70ba49e477f69f5cbe 09aef8291d5f369067a350126fb37112cd0550cf6534ce110100066ba0a8a7e6 7d6228970998328079db9ffb11b5340bd972a39cb5fd090f400fc2f4d9261008 4 4a746b3e0e65c0eda373022eeb59b7eb444591cdfb65f8e34927588c8f4c2d0ca30f8a380d0dcab2467b6494862eb03aecdec5e1cb89740b28e6fcf85b7bda0f0ff923f3d399f64b7a1b08b17fd73d9b163f7370acb5f707ce4dfa33d02a9602de10cd7c5c75a85971b51aa3bca35353e335a62da4bbd1da107860ac60c68d0a9ff7aa166d68ae2c40abf916eb1016675ae292cf9b13c4e4804b904b5853ef0749bad3bee2845ef151010f2a751459534c094bc79b57c9f3571a51bf2140ca05bb721cc5b46edf826be10c3177f11aa4f93c6509da64a281a5cf4371629b100fcf8387fd520a510ab59921f9e6832e8fad969f0b64e5b5bfb0cae5c8f966190fc61ce0e9ea6693667143d2e3c07c81833c32212386f4bc29fa470db389a15d092863a1a8706258e19414d34f0c2b169880e3420ffe3fb7c486501b88a12f130bf381c73325325ed8f0beb6c7be95b9056b7c6d92b4ad6afa4781a454e031680cce9cd6acc635e4effc31d4ea9f297fb77bb7c6b9cfae906b1046a17b8cac1e08f3288eb1771b29653e07901ec3d7f16bb6ea3f3ccedc3fa1c7b07ce1a686a8062ea29b435700eefc01c22048700d460b2423c7a2897d9e3802f371f557007306e7e09451a831c7cff801b1d8ef9b2ef7042859f71533534946c32e0bcf57f00bbfefeb62d4b0ab3b1f534ccb7c3d632c823838025a3822b8ce299adeed4f0f0b4e05fe38a0d39e5a69fa2b3fe9341e468a4fcdfb83bcc752949eac010777a2061ba65fdc8a08be1e26b9ca14c1406a00c7e23170645f37893c8c8b287024b60aa665c676099056ab7562d43ccdde0c3e4fbdbf8046ca65f366d51781a37a5c0d9ac4faf147b751b2d7be538f453f6818118b65c69a56ef32038658fb935c4d06 +generate_ring_signature fe0e906842bbf5445baa4ecabe98dd6ef27226ecc2b5ad9834e08c046d0f578a 0e4320a4732e89ca8a53cea98b44492a77168316f9e8ce95fbdb5197e9d14d62 30 b7258c82c9b3e0adfadc33a81ca09cd307e70ba065c16144f46f552414a9a629 54d94e93bfa71f1ea7c1d64902bd8df7602d7687e43b983ec3ff6ab88b4765f4 637d164f669b1111c41a5533ec52a4b05a515ee5f46f74ab8e50cc481157edc7 66fe4748dc0ea965eee04b152c0dcbe2a5fea11333951d568491103296730f02 acb9c2c966da9415c9b09bdce3492e7962d10ac1c2a5e46938a6651e09fb5516 c2d7dfd2f498249427aa0eea3b192f4802a3d212f7fda58c6961e231ec0ddad8 c830fcb8aa75343dd3722955964dcdb9864c7922b872c1a209f477e923944379 bb23e3cba803bb4750739171050a55f31d479ec0ba27f4c0fd5e8a207257fd29 a6afa3958567c006ac5a61fe4d40b5e34aa0f796aea13c2ed3866a1f12fb3e0a ad6765229bf2c6c88971c254e49acbe6cfe0310049673e1cdf346cf09da3f56d 0edae6331033f401c42e320be461975a86552f196f495b3a4e3b0f547617e963 a920e55b3c7f3a4a8653d75ed1cc731e31ac880e175959f6e267fcfcecd22955 b4d509383bdcfd434c407c5070f125c46a46733da20a3f0fe9979df94c31d5bc 25daaf9f93a6284f702e02395babcc7598031c6940e7914a93a8e9ec722e7fc1 2f1c7e264b1262b445f4178156119b3fecc1f458f7044cc4de63304e14c97587 a487d33950e0d251e92691a34a583e13aee472b4c841843ba5fec5b3c7656ccd 48971038b01b0fbb7ed269349420385f1231bca51ce21913572ddb33162c9619 f222a85417740af8ea34ac66322a4f494ca309d7722ffca6713400e4be4fef81 696f40d88004d1a539495a61f35483afbde4fb225483f1bbf7c2f82c7e59dfde 9a3b1cf51901567f6e504c0c8b08a503b8cd633d6f542c9020cc4d238e6c00f5 3fc2d5cd18e5788a96f016cbff76554765afc0428cb260219b81dcead3edc978 ab62d587fb8948401a9a3cf874a024457791d3f2532803e39e00b7e522cac759 3dedef9bd6efc320fa1bc5dbf0b0313244efaec9a7fedc18667bed47a1e97af7 b0342dc39ce8e3f1b5053747f6fd3a450319d7568779dbad042e76b31dc816f3 8b3365279c15fbb8c7d2758fd0de17503c48d87aa9802593c22ad59a27d845d4 4566ca51354a7da4bcaf7f457bf803c6e32ee109a939a69c342ad61534831c44 da8e0ff478e7c6b7fe83467d5a5cf90fc769db0d8230eeab2e79424c262229a3 2cea0bf3ddc9e0ad18757bd6efc37a6e5923dbbb76d22a06463f25177223f3cd ebdecc636abbbd1fa2b166bbfd742ade21ad6a22dfc49fd667cc807b8f51db2e 5293d8afca91f70430a90bb0d05bcc4e6062b20578ff2cae721c767b6f929fd8 33c6805f3997d25bc420affd33636816459bc9b8cbc2f2c65fe2ebca22879b0d 8 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 +generate_ring_signature d44366265cc5e6e8a13f3d2f55c79baae89befbc5ac99d063e6e0dec1d5f8665 345925032111e3150664a24dc32937232ef1bb457d164c57c24ac1160fb7d6bf 1 0875f733705d14f8dc398a529ca0bb633914572d8849d084dde057b82a946fa3 f51168e99b11a987b49c956969326d5ab4bdcaa1313fa7ad146b24932208d607 0 554b462d1c629572a98bc59f8a625c9de19f8c112498a550b078ebd6d8c5640088b85a8baf2e9d0bda59cdd44055f3aeb7b7740674b119ceda5f04c537241c01 +generate_ring_signature 9b43013f26543ae86b8194bef3e6999d7a787ac7d9e69375e117de5f6a963a83 ff20e8a898dfc4e8c3ee2864418a757fc9c52a5a6941bab0c745d23846a4a0f6 5 551ababef74f99377fd5d68b2ad3a2bfe14ec6b4afee4c39686508184f87cc8e 25d84441eef268e987eb34f24749b4a13044e341e6399a5cd6b155a87e6ff0b6 c3850ee99faa03c06b6574ec52d2916e32b399aa82286fabf4936b39a916e431 42dd11fe00b24c64342341eeb6643d229ad1673a51f09192b3f9ab4b93256cbc af4d559997026bb67abd8ee6e469dd35577dd529ced3a657726d0c02edc3d5d6 b34b5b99dbb26140e778ba6fb61449721e4c7c8c1bda6e70eddbb6c0672e9e0a 3 3290b43604813da826ca2137398f338522af64bcffd8a026b5807705be6a2607d1516aa150a3299bdddfec5109923543724ede193c9382b3a002d35f39a8ab0d31e21594e26dc4514043021911c102968aa0c76ecc5c5709c6e4ce3c405a0309f0c492b84810d9fb513929f94b2e01a803043548549b2dc5669f3ff19f7daa0e43a0f317664ae4c1828680fef4ed11037fd7700a58e830a219f5646a4b17f704b9b4acc35e661ace1a7d50be841209f5883008646841fd49745ca37400a8cc0c39d231acd5f3610cc65f7b741c1ba7288b935e0ba3f6780437b9687165621705a983219641a895c0db7b9afc4ec7870ab23eb7879056a56b5de7178c9e1f9802beb821b64e5e13caabba6a0864afba25f474d50ed6e63c35f192061bea6ea8082f1456fa0df87e9875aa68824d033860e835de5cebd61c840d5c15ed403bff0d +generate_ring_signature 3c53431eba5c16dbdd1fb2f98d6388541b7b85cd5dceac9238d6aa7dd5e8ea8d e9c7b96e13b6225b03c9c774e90d2e3f71b7be553dfbd22cf1767888c4f83b45 16 70b95fdf50d68749f55586737433d11e0506886dfcfe08a82b5b01c173dea87f 9a8bf41dbb914dc402d80b6f1510e0318fb908181d765b578776b034d6359ceb 87a438d3d769aef03c070d3853f17c4e470a4a7ec5e4a118a8f00bb0966490e3 0ff0242f7714946d5b872f9fe6873d237f1f4fe501b88119795f64f744e8428b be4c9bd9231f25e1743419a2858c014ced12708662761fb36083aa29710d1120 94b62bad7ce972fc7ee236c909cf19203dcd46fa48552d86f85a2dd6379e4e6f af00070c55a10d7ea2ddd2953e593fd5cfb29eab6c6b676472d029152120fd95 e839d97bfcee72acce077bbf20856232fc8e31d27fd71da70a6f0600f85dc9a6 f35bd0d64ca12db2c9548255626727e57b4eaf37b42caeb5c4160e5053b54903 7b23cd36d3ef9cb17d8afa4346fa949be91492241c2eec7d02329f4ef37be3cc 7f5580e1ca9c5ad57941951ed0de16dce9a031761dc476b0a3f4733bfa76eb75 6bc5897d154e23c56cb1216534610d1d75241d7462aa11b8a80d6191dfed1354 99884db56a229765f038e573fb018af4e2c4e75e9750908a6dfcab2d4ec7a821 656458506acc81d90dfe82decfbfbb6b5cc2462b6e18ec798b486add559ae372 0d165d983a91a7228b44dd25f84ef8246fca9530a6f7e15924c102d4f4b9c038 83169f90ec014494f2e8dda969dc1dd5fb60f47e3a4386945b787928e56817d4 580db78b04c538d490ba0e0cabd646e357f6bbbf3752f0ea350165b3fae41a0f 15 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 +generate_ring_signature a2848f3b36302284378d0f599c7fc0b7911a94281e33d4eb4d47f7554971f7c4 dbfbd2c763cc046137ae025d4fb22914e8e7182f3cc727d2177e5670ae95aaae 2 184816f5034af3d627d6d835e5c2913953f985f597b11370c779ca34048fbce2 85172db3a5e5418276b0b57bab2962b26cb6bb159f3608bd31d5eb6fd507b799 d598ef43cbb2381ebc6a1585786dc1afd6f3b2fab6ec7c7c020b934bd44f8405 1 0449104b79691eeeafe974110edb61df726edc00ad052b104533acd4b3aaa90dedd69c8d0163e3e51b60cf3a5a5a4710b2ecba0c68a3e290fb8b41c8acd837031909606fc222875c3be02ec06c85f7cf9dfa1d96d88970cfd6d020374f9f460ee56525fe33e3d981706258ccd4b3c391fa8d1d5c30cfe2388eb01ae96f0f3907 +generate_ring_signature 3bfa708865ea752237a4797383b6ae2d4d3c41482ab53d42ac8feba9f80b62a2 2e4d774207848de566e97eea6262bb6ea87dddf04f5dcf911ce9914e9c97f528 91 38f7acdbe90c284805550b51f1e9929022e7d533bfe75bea0dc33f717a523e4b 817262805accdb4febe4c20a8037f50aa1fa7a00592836fcd3d213fcaf022f45 13c55f83cf89d5272dd1d638e2b3048653167468c11a8bebd335cdd72e7158fc 71d23b3dd7bcc81b2fe24b32e9d3e57d638c21ebd4039a73c15bb2d6455f3b8a 2d30c73750bf6f92c3bb59771cdddc7d0d6e0dee4d4ef60b443224b418b5689a 5c0eea3463693e350aea35b9b75c918ab6782971cd4aa830180fff60f6084ea4 72d4ba8604da472325d32ddee00e21d844275c3896911c26f94038f30a59b305 2d09540ad3704fb6791fe07161f12cf7c634b173b4348dc2fa2b2d91b5716d6e 6cdd2f19ce8037aa1d0a1b933e2c619c65947fc732acd11f115c62d40e77ea41 db94bbbe5548ba971a53006889f253361d986258b9a641737b88d6d1c1a83aba c23eff960fa6ce574cfe1f74248c29b10843be110f8321641c2147baeccdda1a 47b9f3ad5306af76c7045c93b914dd0a90370ff9e3888129421ed8b78d5b6725 b749de5034ccf7c0c1bcc7a76fc3b71a90b395f8ce74189101c8b78dd08f176a 9c5c2afa18b46a710f5c2bc387d61eec6eba8c59a00781486a5504fb35b8e46d ea7a0f8cc1e7896b4de7ad84a8f2223c1f4cc320e466ddf80112b01e9f7383e4 8408d1626f6123a3c60271334ab9ce1568f4361c9e8961a9813b2f82947dd0bd 5ffb6207a836af8db9df4bde8a1fe896f864adb6d4a1699cebdd134250d3627b c719c4908860d4a4204a100951cd6f6a5f523fb1c25af8f4e1a7d91566042583 1588e45a7cd74dbe403112737070ea504804a951b592d86308aadca05e19bf97 2bc329ac65a06e56aa65e146f5ca37b15c707a1a856681f1b6438b876a257a62 6cb6add63061cb03876eee0de9733db3cfd194b529b92638d74ad1e3197ca55e 869f1663036ae025ed0696a551fd6153fd0eab16437e4f5ebb740975530cb4ea 565c6df71b17757170cfd147fc7ef7ef5442d60f420779de08537e4854242034 ee1361f2ed36794b34210f0084ed1e853d79403287ac7e422a9e2acef5d43171 396a2402d29083eb8514421bfb8b841f699d607565131c44aa72680c47ae6cd4 bf3e71778ff37c494d0d588e4c240a7a1fa28dec561e5fc95ce52d0795d30b0f 0b1c1afd2a06b982d99df49358e06aba690af29ddc2f1c6d5003e6b44b670eb9 0967624c84307d50ff5823e51dde55c2a0f4dd3e54c478bebfc74567bd7a1b27 12a0cf3cca9791f9d9188e21f8d5c4c5632ea737e4a548a29c6116009b1f583a c26300d73a72480a4553d325bdacc91f0c3b10b7dd53d490cb3d9a69ceab15da f91ce4b28de23f339c6ffdd175ece69c2718e2a3d9b22a80961f6aebd990f09b a5b04ed97ddd4a071ad49063c159c6e1e5bd53be621c2103efa9944a504c430f dd1ce2e7ad25135322058928f7e0176d77097063eb384130b19e30357b4d1a31 2987d815b4fa2b7214a0eca3d95b3dc8bb79ba433ac66aad97f3e5ecf8a67575 dec31d9c26307ed50d5ad50c5698b88d561b3732303d0ab09f2ceb106b2f0af5 7ca0b73fd6dc919d8380b22294516103ac26831cacfb46e0907223290d5ecab8 aa97e38b8e804aecb8e2c1da77776e3d0582341b2d39be6a45f8c513c99cd5f7 cb32604020edae3f1ac43f49a50364a09e9277ad9481f1632c7e446ff24d376c dc66cd2e4cbdd497703f1bd0953033cfb6550f46412250c4b62a8e44f20ff7e5 d713e361ad8a2b8715bc3a8bd0a64cdf4fe19d6f4bf2c20970572a5aed81c14a 1952d47e81a3e2a02d59f47090da2972b89d8952d498bd95d24256efbcf56fa8 33ffff80dbb6a235d0d6c0cc52dc0dcacb4a692cf09cce398423eb8742080853 1e328b3b594f3748288881bf6df6c2400fbad42e1dc53099f98945d0776357e6 e45396f2fc37f54c9ca3af36970ca0ddf908dbec065b232678d5fdf9cdc115cc 369cf4a82d27c83b295dce181970028fe53d6265380cf87c01819e36d1563ce4 7a68d3887599907fc20337d5f7b7fc4cb4f88dfc6759a0a35bf7a2a077659f20 0e579c35139219430eb86bc0da2d37f269893ffb6d10834a6d04f0a7f283dab4 52101d8a151e0a535bd2f5fe4db6d1826c47e6ccbd8a06d1ea8e05537fbf421d 3cc96ec853bf5d99eb69530adecd6aafbe9a95ba14ad506d33772c9de1cfe1f4 0ebb479ce8e81559493318897f9829cbf14499fb639f99c5a6432900b955befb da8e0e7f63a5f460d64b71a38263100afca62d6ddfeea1ac0db0a657f1296af3 119a595ecfa1514529f07f7a90cd78d4b7a98544fc4ed0141ce1c7fe2a9acee5 d9faf2641c4726c711f0d4136ac280e2972425b5ae7a3c27bf5b1171b378909a e807cdc919a38d3c286abd67ae7f0dd3376ac8e9ac55716b52b5c44fca5cb5c1 59c7d6c794047bcc905097d7fd8569a5e4888aa751065b66de32d8d00890bc79 39a5852394a61ea8ef293b244f4a2e3251939dd6dc383940e4b0e5f49b963c10 7fec3deb4d91e02f59d75bd1e7ac2e92b5f8030d696bf88463288e7a12bd4ede 9b1364077d41d4c6fc13b5e4a77e52c27b2fd1dc7765c1696ebde46a07c4abb0 2f6956d8fa81990810a2ed1f01e04b4484c0fd3a76cd84ddd2a9619e332e1d88 5e135779ff608a35cf5da0e30656090fe76c2cac427604b732fdc826b7265198 8c27f69dc560a8e8a68310264d9e65e7ac88beb237a9abbb7708266844057ce0 efcd93dca818910bceecf477ea4334af40922e56c9f4db357cdfc3321abb0f68 fdba4d25f7845c2858ca4e6c1b077a2b7f0f54bfba930670c255f254c277ac2e 04a7e77ee772a997a8954b709cfe1f660576adccc0bc828042a6bf9978594618 917d17c135e20aea7caea1dd22cc6752e4fd5ce05098d2836a146c793eac61a8 b45cb5ba80a17e6c0646adaf9cbea1f7dc5f3799a826c9f088722a5cd527b82d 29a200178549a18673e0eb92e8bd384dfaa695e130c54dab6cc44e826e7c3112 c8303040ae302f47eb64d676166d16b6e38b8996a88e49a0cf1a679da3dc40de d0dd2eb2093b1bb607c5b53a9df148a7af9ab8eaf50e56a9a19c4366a4b873a2 54107acc6285e280bebd6c5314d9ada8311dce901bc812d700a3e938fa628ee9 5b6748e854d70e02a91b3642e600fd32898279ece0f10729127de0bafc7db0ed ecd46f5a0d0719d60a71739ea93af27400770994db68ebe7fa98f9cbb97f5e86 9a5cdd5c941a30e5840598daf4e0e4dc646775ed5080ddc03bc88e74e57dd7b3 b76f4e14bc66012de09bd3fb98724759e0fb3cfe68b17ee2f236ca35fcbc058a fb0f82776ca7899d5cd705d784cb0a30d9a705fb5817497d66c048709392fd8c 6ced641a3d4c402a7bdf2de0d000f9512d6245cd946971429ce8abbf13ff56a8 fef493c6555d43b0f2303815f086b7de4c13eca9fad0bc7cdb75a118bd433392 3ab468a92ec76d5acd3837aa83b7ca933984be9c167dda2a43e86f5b5a70cd01 155bd8eb9c7efba4b2e45083e6e70539f68b0cc02a23aa1ef40d94424b0cf257 e51320a48a75b74d223cbda29a41403195300d6da467c8d636bc909bba0d36b8 3fffc66702b2144fdf6fcc3be9545f7f5ee034e399e4db1c44f7d7960cf0580b cee707102ff886386a1afc90ac11eb95ff796df190068216737f85da4a99a85d 27a33317c49c01e292d23a085ebc2af814f406665c43f9f8e064234bb9022a08 de53a7f01a8b11731298523138bc022a5def631ada76f4c513a71e5398674225 585c96a449f6712c701e231b526202e28a7e7878d8c09c79f103f2c734b106ac 55dc8746379b0c79871bb5c3fdcd4d07f16567e4ae20fb7ec2e794d27785facb e9a7d69695afde442c58da9339bb8d00fe3a90a74f813f00880f28784797a309 6ba12954a1b735fd842fd5534d28304d9819625ac0425b128850b5369e2c88f4 d41537e1b86925fd180c1dc27f7c6491813f3344d4b9e7bf26062f3c93a4ca24 d04d80299b1f40f97eef90c85799b317154baea13dee98f721fba3d6736e99ff 9629084c2f4e36d15a963af5ae25a8ae70a20d6d4029b19f313cecae8c810163 5eb7b30d7c80f24c1cd46f488db56a4b930cf1c595878682025f0315d1595401 43 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 +generate_ring_signature d9e4680311d1cb9dfb01254b08fe8cd0dcb7b3c503d6859c59dc47e25615024c b8f8617d742f1a96ab3b79e141b52c76545b39f00fd00729ed4325c2e8e839ee 35 c67863dc9547745b0a1835bd2bdd3c7f866df86486e79b5b23c60dbf330dafbd e837d13ecbb2a5a0bd620f59334475bdb332d44f44ae4220e5b30f4134416a87 c00aa3422f0a2f3a5a89edb8eb7c99d642bb33d2b5d4ae42a228ef3dcf990ade a132684aae1af1909b7d32035c7853359deec9fd5ad14e5548cc2e241223988d 39b05e702beb2ef5e6f02b67d46fe13923ba2629cf6dd4d813f92b88ce94e049 d3f8732f7598b1e7d51388a77e409698b1490ba56ff02df6c9091fc3723ace03 54929c78aa0ac34a796a230b66ae375a443a067a07954cdfdf4f34dee0a08a23 81ef7d3eb1c810cc7fdec70dae0a75ca8084651cd9a446005f7af0a37ff68c8c 06081276051edd0d6f829948a77a1ac5c8eae9e492880cc52c3a3b7e9442ea86 6b8762b54c942dfc5a701842fa7cb5ecb20ead13d5e72ed2475e00ad78f292a6 031c76372a7bb536cac58af77c11daa08cfb59f990cbc8c2eeaefc4ac1a598ee 660ca8b174d65ee995bceaa95e922dbb701ddb6c4df76e7cb46a75fc19b13eeb 81822888504f072acfca4da1c30575bf5efd17a769aac9cd0ba165003de67927 ffb833d7a1d148e158172ee880a850d83304eef3c6746427a1ef1370fe147474 23234646c19c1022929d56a62e494ec2d45e7188863f375cc2ffe681701112d0 227bed9c4db50f0e54a70edcdd4be63ea2f6e7b3563af10e01c9a9c5997fdba1 d5aff7375658c886005af953d831d6e4e2898b1490cad7d44a1b428e87e8c2fe 546e5da5f5599dfd4cf7139f92c80d70e6361249ddfcc36a64a4a6a4579ed6f3 4617768b70f157ad344866c8f0d9575c7a8029b2f693ebd75202fe238c9f334d c505334dbf2103cb24205e0ae4a660a592921c5132906cd7f634b78ebe0ced01 688761e17fbe6024f8e51c6faf00112256440cc4a2c7d37888ed4f5692e26b71 fc48bb2d96d7ade8b51a189f4ea1a1a427669fff066da86108899e2e069c37f4 e80d7e7298e64f4f273548bf0e2bdfe3cf8ff76f86f1291d28249052605dbf46 23345ed9e65ee1d2f9f0df21ec20f4fc506f837f54dd024ef770a81b12588302 b572cec572366f8fbaf5ad8ca07cd1cce301e56ada7e15fe2ceb03d6f7c615b0 ad65e69ee23a2d216d437521cbc41a946f1a0e2e350eb1c242e53d845e664a19 9d652c7154706b781272ea4ff1a5b3b84d83b2ab86389e927b6b0bbe611a207e 05bd82e4dd30ef4ae5041ba77652e173ed932b90ae8f26f0c7a1c924dbc16bbf 95f6523d233a5180cad52fa70fea8ba013a1f565f9fa5d56e6099b99018a5948 e376bffabf575bcc111d39638e0559a8d7e6055e594f5f43fefbc5add7904697 022b90003abcdffe3444bf899962aa0173489163c45d6f3a1c023fd8f089cd6f fbacd6c6ba0fe19d9d48ecb207c66a7578648a77e9c7e4475721510afbaab99e 88f5947ac68fa3b16c1c768a9bc70ebf76ccd2800e6acba428ef6d8be78b8b34 c4a86247b999e7c8460f3784603080ad902ffe2e71c986278c7a26db99c32447 1b83e2998db2167cb4f9133ec411f62fcb2246a84ec1ea4acaed25ba5fd60d52 a3480165d43b66938e0169faeb99f7d09b4c918620775b48e699b9e3e78dfe02 29 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 +generate_ring_signature baf768d9e42fae2c59729a1d2b8c1c90345ba669b954316a5674d1de6220a76e 4d7d7d439f8fea0f37accc6bb4b1d9b3d2c6a8f1de4c4080d058aa9aaddbdbb0 1 782b450055215a1e6bc07b6003187d9560cee16e6f5262521df26ece593c89b4 388fafcce2f0aa9c54a2cdeabc47075bc4c6dcfafcf8bac5a99cda75c3e61b01 0 3430f9b7fd78d0c099b8f7f13a9e4a22048f06d8735d004cc08247f1aed266026c17ff42f93352a5ee7775c0b47d1599afafddd415db324f081252854f5ac200 +generate_ring_signature 01916e70c1a168a97075a7d873849f7ac03e65094ee16f44ae66ad4a3e0a9a61 19388d755023e1604e7a357953c2692ebf537afcd3c5b175b18b4480c1770ed4 53 242cfc91401e49fbe717545536ff1288d9929ecb3fc5fcf431ed7e457bbc4b39 5720bfc3064c22d0bcb46686feb470b9483cdec909c4b70c63a8144c603de1c5 3144d1064b96500b9fa8ee6ac4f95292f6d92e7c6ca34b5974511c380807739b 90aa403c95a6a5ea6866ce56913201a0aa37d5c09e3e0c0150b8f23e6a8f7074 29a6167a49da7587f4a4a05e534e194f7fb0858c8b187e681104939611678220 47a0530a95b6e548ed923ddaa08d8cec94bb9afd43a716602c73f7a563485426 d7792a71e94ddef9dfc4300d460fa547d0318c04a0f43513e98fec2389fd03a1 84ef4f5e3c509f8110ea7239b531431da9420ef98bef880020ef1565915a9a10 1a32deba9900d23de6dca4cfab511391e4bd2ecc9d153f2cec3a4ce4fa4c54df 371d5595b2a49bf72d7824711067e3248f2429e086383d77de2035a5da111c25 68bf85ebcae2c713975dcafc9200acca99d4d740f05bca766d7eb82391767f66 837dad3d55f3fafc1717b116c0f7e7121ce70b4cfb542b5452a08f92dc59ad55 d66ab88fe75167e16bc30dc727e2862128b938292e5bc60a5eb03390edf0b133 32f67f886be12e0bd1c98eeeb1690acae74e7c6e321ad14bf6dfe7bd843176a6 572c46495fc92467f1bf1142893e0edf08ae501f806402ed1b8ba58cc767f8ec b845884ca93520147dbfcc37a28b5d899faed2f821235f2b055ff34d2ce0ca2e 00617cc79d54d01e4bf16be365e673c3cc6bec51a5c337fb736a885ba0acd573 6a8278978430c6e99cb857f4e4512e8278aef7fe70e4b2cbdb0aea6d5baaf14f b0177887294e8717c7c4300e3daf4e5d35721a54fb85aefb99954ad1cf15228e 5d0a7d23e13f32762fe5e66ab9be9aa73336f9c385772269046132a11795caad b229f7653c5630d1b2ac5605a5b2419d7c8ad9879d6d296eddd14a1ed788eda4 97e01654bef78ba3a81c4bcb36b07c6dfd723a867bb2d1e1009574ca5a4a4444 05a16ea1786cec3520ded847a0addf9ac3dfe96c3315e785927d75834f73b5a5 995498a9ea1ba686429c39efe8fc92cc2bfe7a4a3da23891b302d56b18c61075 e4f2da569effe699c788939b58b7271eb5b63347382d7b9fa650e0c16caf7dbd 62b2acfa240fdd2888dcd3ae4b3b60d9aacf48d627ad4909f0ee3614d2a1d8bd 6d52a488709aa858e528c36acdd35cac6cc7a1e0d612ea4dc68a4393ef095a56 da6aceaf9e86d64910f2f90e7e7d30a3459260c9dfbcf427b0704f5d848ddac3 84c11c1ddf0fbe484e80c375f0bbe985133c72d3be646e4a62691b3ddf02c93b 132529a4a7796849c67315835700cacd444e85a11b9e71afb5ca41fa81dc8373 69d1d9c94d25a965f96c89bdfe92d5bd5a10a145312a46d990d8747d9b54ce72 a77f3f1c05b8b70a0203e373031adf0596eed28b5a434cdf0abaa7c2221c5a93 a611e3a402a42a33cd8f832dd46c794c6adc9df2bc32747686ac7614a72d0c2a e8f60d367002f5fda4a024992dba1b161fe1802e680977b2e2f55a9c3deb27d4 e887fde0d2c22351ec22b8aa8889a80c0917613ab397c978b2871af576c76fbf 9a90e74a7e602b11e1085681ef5e08a59827b7976ecd8e14f5c7a81312a9b84f e35b60b7564725d9a7dd34a6ff0dfb5d488e3cebd79f8260a7057b2b2089c233 71a3cdd1e3f0840ce0cbbc9049efc87f376938c4a6fefda0e4364684176e6bac 6dabcb53034fa276be2e73851d9a39aadd74b3ac7ecb0eec92b43608cbf4b02d 13477a1e0cfb62bdeb1a30889489446cdb3e37bed0e868906ee91da6ee4de0aa 1bdb6348c889278979c6064c256adb5e3bc76b61e332b2981a49fbd79a14dfe0 e3c6ad547fcb3afd9dbce9593931897d8f736b5044f543475757c7775a58168d 379dfebd4d07db29982a708e4a03ef03a583e869e704f36dd62da8fc41867cb2 4249977ebd5483286439256595142ce68bf2a88d40fa2a0e204bb8918b2ab1f3 08710fec6ed8004733e622281bf186975b7c7ec6e2a85d9cd7fd146f9386908c 0ea6d13d9634d24f6aa872f341b2bfaba220045e6dfd752f0746cc1b5e9732b5 201ac295b1b5a10a4317748a29f94ea0e5b6b069a8759eccf5bff9067bc1c829 623ea94a4d6de8a3db5e0c19026fa2623559fa878030c98495111ee9b2951247 f1382fca2d626d971af139e3873405119843d0b0237b48d08287d893e7f003b9 5e536ecd5570c8ae9165916d9f14688dbc8c82130e1c589e23ac5ecfa8a39435 f18095254b9f272c5e5f10322cbee3cb62cb40e75a900bfb69b1557c254060e5 d1c0c862d42a95b7008215dcd1cf6c4516df9830ea11c217042d0f3df720814e 4eed5da8eda2ca0a8436e337346fc54f3dd38b90748bd4023580e7fbfe271dba 8b58a9e402a6a320edb50825a07279ffdb434d5bba8c2b93bdf568144e098a01 0 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 +generate_ring_signature 0fdd09cc2513c1d346346db21cfda3bf3da4d65bf66a91dd87c83fda9b9d407b f96cf77c4abc31236ec66ab0e3c56d25860cb2027897a5fae40622a7908ab147 16 a5f687daffa9505005c73221669b1a728930db51d4d40b78ae6a821e9b319440 07a6ddc48dfad0383024bd700f46f56c88129345439bda5e7bb7f356ce11c8f5 585bb3d7f53e474d75cead5d1ebd12c68757bfe231091adacb877b09e34cf3d3 bd06689f501f10bb2f4d5e3cdda3954a6d55ad18c3ad485fa98a4e83b163fa15 0908f88df8ad262a40203ba72994f9bc919d79acf8f3847c5ae72205f8ec29e7 6ada309079d68bab1123ec762dd8ac04166d8ea824acd9408f502731dda08a8d 80d9f89d04bdf2c205d6955cd4f285790a4282a6d75bb555b1342138b42c9364 77e56ccbd4d1ad228e32d2be7837e3871495df21e94dd1328428251d7bc3729e 6387f7309b7005b5073e718b24b2b7fef3fd84749fa98e91dd1f83912487cf56 6b7e693dd187ad5c38f73079c040366abbf2990dd30eee6f685f0360ba22eeaa 819f739bedd0589653cba095292e436678a1fd38767d4a6e9449f3d4246f12c8 5b0d6f09b5ad89d7cd8ae24e8ba3c2c4440cb8858c2483ff1363037491953fd5 e3a579a3dcaf3ba92fb5f57cc4469d1ac00cf048f0f3950819875b1805e43a46 0b650b9de62dd063d88549fb717d3ebb8fc15b3bf7338457c53b7cb4c2b1350e e8ce03b5b89b392e9d2de32cd39416b7c189f5ba81954c37bf64586dbe707ea6 feb0d23239826ed5813f0d76ebc0934a4ad72186f9e43a7895c54e5e03c55b32 e01f9713a2feb7d4f9a06fc9b89f1f438d990269f8650286146ccb2df251e309 13 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 +generate_ring_signature e3495fc2ad438c8128a655249d4d6b69b6c17ee1dbf96ed1acea6380d07fb724 2adc1d2a97ca897fe0342c2165b8ac198eceb0374a7320da794d1bd38a45c962 5 dada0d56d195390308e9eb9304b877ed930a1c15de8c0a28ab04066cb0cb379b 85e9284587832bd7e59fbd7d3fb9b37b4b63e801522f187fd5bf45cc4f5454b9 ca11ed3ebfa24d358807b3ccdcf4c623af574b8c07c825b4b4b6f68cfbe9bef9 f77887b1191a51859ab5bfba228a360ce889059a60aaa740a5de8e9d0a7a1e57 c445962d9a4260693d6307b3305fcfd65807ffaeaab251349e02ec4dcb4f2d02 5d0db6d9854ffe9d26d8df64f9a0f5ac01aaa30ff2819e6377724f76d5c8d802 2 9726edc17f4d20ce413103b6f81e8e072f2d8b32098007e72e344d388323c309cea34448c08ab6dea51e3004a3252091713dbee920fd4b2bd41890e5c0bf590cc13450809d7f54f02e880a9e2ea1614c1dc9e354395c01e9a16a709e6308e4074f85935c344701c7a1a4576633b468e2213e766f2e552359728dc87b22a2f709e0591c4e50b0b8cfbe82b653e22bd53bb960fc25e193490e5f266d973ace360bbaa0710a99bf7d7fb82bbe7773857d9813a6d9b8cb76dba48cd6524813764b0bb49038e8c2b5c9d776e847c5cbaf31c4b48c37d222dbb1f483831367b4bf210336b51a0ed9560e1e49263dae8c6a880c80384a10bdc3b87ccc844dce3d08d00e54dc88ca78fcf3b8a79ece99d0ab959e24117a79ddd6df8d7122d68262166400710d37f0f40fed5ca60d12a88e5335ce5b316e3b0432fe3579f852d17390b00c +generate_ring_signature 923a11626de7b0b613c07f95a600a1ae1b62ef2b0bff338120f4aca08a518f0f f12c207e70b2dd9bbfc6988a0ebe5f07f915b5bf2b1f1a8ba23c5db2475e8d26 4 eab9a7d80ad2d7e9060076bda332b1e2b31860426710e7071e5f34afeccd51e8 8d48bb5e57d8c7b0950384093d6187ccd03b0c535a0edd6da35a6f015f928cc6 079e64c24eee1da696543bfb274ead55ee33e3633b9601d9e3512371194dd4f9 6348488a0884315336961ace563bf106bef9f2c5e745e5204531a3e00695d5cf 2d4e461db0a3b63a7c05d4699b1c790f86351dc1fc96d1f8365ebace89d9db0e 3 92ded4fe90d6bdd6f2793817810ad82fd6316c3d5dae08a6a3c21c554872c90f407eba1fe8f74a9fe685cf9a950d5953967e6721446e9de528b7a31204dcba05b56891ac75b91d0b3db4ed9390f2da951aa0fda93ad333665d099b110f50fc0b6c79e9e795369aace191c02f5c6830aaf00eeb2d0ec2bbf6c97afd2842c72b0eaf3a257d6747b5750b2c8e80e01214d75412879129e65eea19e9ca51b3a56d0a70bbe2c0786ff70042c5af0be5e70532c4bf9f556ae6f6f6a701ac2490dfc9090c22fd4191d8bb585c53bbfde6da7b3434f8594c9fe091970b4d702f95b4a701f1dc5b5d5da8d6de4ea4d8cb3b075dc3b5d19ca727b7351f4a688dde31799b02 +generate_ring_signature f7eeba3fcbdc35c01d69774f6d1e4ca270680e87e1af40b2773dac9e9b0a56a0 6f1f04eabe8e9213c7c5d4c4a4df1b5564e63b054d3e09ad81eb6c4d930ef44f 7 ecbc3d0e415e2c5360b40747cf604fcd6e4751e125ce2ed8f7922a317bebe282 60887705484f05a205b5e6c98ec1be1df8cdd4115f0f3edf9b545370d81b2283 4310521f1828d60b124567720d381d203d81d07b8c66434011e29bda436bf7d9 4280fb5b19e595916a02527cb77814868af83620174dcb21bc8da271ef680004 f2f8b898e39ad301c969cc191c11b162995a5e1f813dd63aae200a718c7cdb86 867556a39a4dbde3c7fabd5180eb0e7ce275ea211db2fe90e13c4c040c0cb28d f6c1111d0bdc89c508faad4ef2015ea98e1f5416324def724136e030ae647603 f01ce7ed8d9dca5629b5666899c8aff6ce0b58ad2fe04b77ae75c2ed6b9de30f 4 d1d5c570070ec989388ea4d44364ea27aa53ec4c11eedf83758f400ca58acb0a0d4eb20141613145a633851b8ea16201d5b22110a2266a2c741c215387e9c80d8e0f9ed256e3c9b4eeb05587f955e55d75dd1aded253f06d6e0d04d2a3244f00b25e1003621b78852f0322b4d6b01b6d575f53c1dd15afd2da777db269b630060693d4cdabdca455e04ec1848d8aa7284ff21cc76f28ca23d802746d7d78d205453269094b5e447d25b542b82971b530e9d29a0062f41b89bd7e2fa65659420e2052231ae20c626305ee1cd70a0936e6eefefe45c6054ae1456adc7bd072b40c43f1bd106771a3c60a089de39917b40a1bca7ea2db73179bd83053819379a00edee0138265135e9dc5112aa2d0039fd46da55dce99cd7747c78d1ca54e4d700877a33ab50a5461715385117df6af1b445491eb912f4276dfa9f29cfee8ba7b0bb12da734954ede4898f69ce027ce93ea727c44a4826663e515591ab7291f510b85ee8206b08eb23e248a4cf1946889ba4dd044c5f5aca34ea97a88ea99a54609246f3af9370417b950a0a4854c08a9e750d5b887418cd7bbc7ad8cbc0339880d9df3d2619df12ec19813d790f8827d3ead780ea4131a3908538ac673d348c806 +generate_ring_signature c4dee30ab0373ada5dee59e1362d805d6a2eb83f1a878dc9e82e1e9dda566d60 66250b52e8ea438a69f00cec532367c889ac73727ec2b41f696bfcec68b5788c 169 f2f2b60d7675c181f68eabb0946ecb76d12c2ae176c8d7f2b2f5cd7e5390b732 743abfcb7c102fcde3281f0989bdf8aa23a38aa28370e9caca172f5befcd9fb1 6925c7c3b98df3427d346866a2063fe956404bf6dd718ad32176af5f55fa4932 e13d9ea26cfc623476efdc90ae5e746d5c01ece1c662c1b93e9cf19a70830b7d 05d454706821b18b611d100393ec3307138bc84b0c0958cea0bc4eb1e9341236 cce2645b7ce500aa4fb89088e6ba8b90d488e7adc3403850b6fd762500c3317d df18cc2a78fbe16f092a779a7f0503cd26e45a8258379e4535d97a01e4f3af7e a9d9437498986268c6e2594b4932f8ac8798254bbbb9f17e9fc5be12aa35beda 9a8f7b61754085f10a5ddb5a7bc293ad28e8365f8b51e94a18e974b7b536a883 3295ada3db3830f1a2887c4f1403eee920a836108a42a748414da663e7fe9108 80545b9db676fd424f717135f3978b39415e045225c2aac5f340af7169e68b06 3d9d86d009b0be89558db01f5ab33c2bfa32242167d6a7afe06ac195f6c500a0 37662037db5136dbe094d1eac43c18c9239969f9d3e0039df9679cfdb4f3d18a 3bea446ef619e281d5fc24c358629581d78385b0556d72fb244c66d97e2c6483 a28b168bb36453c5fc8ac19c55ed117077e0f450eab8972815682e1fbad7327f 6e28882488bb1a06b52d716767a61584235e7351b839b84fb2d340230dbb75c7 52a7690a81457f57c9e79fcea48a019f3bd405bb6b66e61a6f63d9151d719a7f 9a80b4b0f25383a2c2f70d94ae5a4da7b15857d3242d05669e84f02d66e92edc a801c63fcd5ae02c607cc766f3ed531cf1e94316ef2d2989ebc611b200a300a8 34e4278c824bf5d404204de86aaa1a806ce70fd062eac373faf51353e9fa6202 4b6ff12fb5ee85425a5ef473502e22bb78aaadcf63ad4d93ed327bfa691d5a40 27dfd189f1ba9b2fc2b0d48bc6086b1a4f242130ceeead85acefa3a92ef86ce1 37b68e0abc377dc3c967591e5615c78e49ebb08f1b77952b5bbc8d9696f2aa7f 6bdc04cd1004485d5c703f63811fda02ed60d3e90e0dcbbc4e870027807f7db5 e106081b39c6bb35c5f5607e57b1eeedfba6a6060f21ed360faa2a8ca5af8d1d fbfb46345f0bd2e1711359b292ebf8bd6a7e39e531f986591954979fb09fbb2c 37b5b8821be52009c9e93c3ff1010474644f5b2872a8736650134e21b387ab31 c83fe1124f489b72f050473d52932fd5d68f2dfaa2dcc21136599cb918b135b1 cecc1ee7fdfb34c04581d11c61b300decf57a42e280edbe70320993be72af60a f2b51106e9a9d3d144df1c152a80a090331df2efc91e310403f0a05b9eee87be e17858155d4549918dea501437c1148710a310d0f90620fea070e83e02e53d12 46b090083bd9288b6acc4812e363601ddc83c03ea67b482eb55d2a790b77e4f8 bbfbcc1daff1f526118950dd3e2709c845523e19026123c5369a13c4d59939cf e075c3c1ea09cc5b80799103ec90cb60576c33c3b93a73c24b0d1ceb45d295f6 af65af5d55b0d0d15fcba45eaaf58ab174f985bd4d41c2d20b7a4526247c9714 80bb8136d6e99bd8016b594c39e7b137326ddb543eac6fedd100dff6d6b4b5b1 5339bc37bfce89a3dde58c7fa4db847a4158508bb50bafcacf80255382ac7671 c81b42947cc5f69eaa5c203eae4df3b3d020dd3a0c5018f8a9f5e34348624d0b 6d510f05dbe39d83d6640cac35d0a60068331cad220b17c520f23fa4552fcc87 d25684244293b811b3551f6dab2a5050fe9dc2bce52c15740a2467009222ad5b 9d87b136332a86b9c5bedc40467ccfb345ca8baeea24b84ca338928ec5eda14c f2e3f7adad9febf75773a3c857d62d3263120100e2022ae9b77c58b3c7b894c4 d7d5c94f7e248cbf878428a2b144af620e4681da88e766ae43b1d6dea2169967 30efeb1e0e068b2c359373c7add7676425c35d7c7fbf3bdb90b82dd824008ddf a761d5d202b96868e878551709c2b5ab877d7fe56995504bc9052ae0f0200bcf 55aa7d97269864c26740e4be038efc3b0c5befd21ee78be97639826f5f0f28ba beaa56cb576bc41b36f5751c3c7251a70398e4db0a3c09ca35791e8981ea1f91 83d7a2343fbe5165a375540f07a124513fcdc269f32c397a138f8af02a44ded7 26efe640c840ea1a9322378e8e90f84a17627e792190d3753a4d87bd730b18b4 f1a97f521feecc1049496d25dd3648443c601de11949d575b0c550d8baba51c0 d3a56987efaf33ad73e78557598c79892562eccd7a36207e1b4a8f2580b77bcb 5d74020c3d7c93bbb99d658b8fcf1cb18497208ad1c44bcfbd8a8b956646051c 0a0c3a31f1d7cdacaebb20388dab4a8ee07765177f8cbb039719985a5a942e74 e8fa5aa4fc7d0821c6c013cbafeea5d28eb6a24c9db8779e0be56f87383a3acf 78c803ef1f3df340b6cdd5855289dfde75746ae4fb6e6f79b902da3e6edcb510 5bde60d09e8518e581b09e441d9e9ee10fe68d206984d8da451be2969dc6351b 9f0d4380fe0bfb2639c08219c7c83b8d0dd4f8a37b9e7f956315cbcc91df1fb3 ee57237455930f2d6a13257fdbc4010bd95502b156592117befc744e68b6a4bc 05845a51848c70ac4ca85654d54962644005fab916c14b572137bfd21c90e893 cefc22e0ae4f7bdb5981e9af5226769bbfb4117a75bbfe9d0c0aaead403ad02f 79df1350f974a43e500894a2ef4d069347a199579a198bfbfa7309818f11cd3d 0043576d4b1652fe8a3006e223fe2907221a22c73ae9dfffb4af218b970c422b 178c74199c65363956e4c567def65f8ae5fc0ddb7aa7cf04873db552a18631bd ec64d4014cdce524f52ebaec746e4cb7985db07efee7f230f7a45ba0ebaf2667 61b2796c0984c0d366679762172eceaf6cacea13c448f10c01d9b95a3c0bd932 78b5e5e15304a5d7deaa7fb92d1dca0db3e8caf4a621596fb5efc9e45b56763a 8307fa27a58136ddaab152cb540dd912a5f9cc467f87529fccca7be31e3360b1 bce231185b0032910b1983e47b427164c87735004579b80ff136b48dca7dcaa8 14b20e79d48470cadb4c806df5af9b034d8df8097a3be1f2d7928fe34d2b3cef 4247fdc58e6f242735df1b4fe9ea9fa87c0f93ec02b7a1f57314325ffb849cad 45c59346b2e561a5ce513d69d53d60b0513d0c34fca33d1a82147187c05da5f9 5f7f797554373b48cc0b9fc19fe98fdf53fd7dac6895a3f7a7e773f616501c35 aa2bbb46678024ccfc9a9087a282316f6af2bb04c3757ef7228831d9833dbb83 dc399f899363da744d9d4153065b6b684bd658c393efd3590ecdff3d9c2ed52b ef6d0d6e6176b560256198b8e349dee4afaba86decd2bcce727dbe95e2b70636 d32ebfc10103684af4d1d40e94d595541aa541f4580b1f772655c653a02051f6 7eba6d64022bd3abc8a5c86a8895bc2997d77dc9a1945ce761b65b15da53c6f4 cff49af65ffe5745dca4cb015ff2c06015337e90d3eee87ed64de0490989c684 4c63ffd66a6dadb52cdf67ddb33d710dbccb0207c1e5566ac61f22a21bdb129a ce65e5281d0168a505605fdb278f1898e30d0a941f8b0f9764f13179b3401aae dd903cde97be0cbe8286e4fcb959f165ade330f86c365bc5373cc5d6921082f4 38346157f200df62a9caa5b51c0b39266e67e8c8b22f31876a0737ecb3924c64 7a59f714f0e320e8decd66d486b6aed8285ae48f77cdbf8db8496e43cf327dc6 43549791da8e97a5b368cde89d57dde61b4c7b1826d2bdca03c98547d6c1f210 5a8087729bcba594809cf4a31b6d2a66713d11f44282fe19fee4555fa38f33a7 80de3bf86da79e5ae3c839ab0a723291d3495dd3903c8f64a1aec3c388e774d9 2953ca5866e7d6eda4551ca518fdd1d8b88f5621483cbb9ecaf29097ef6876d3 bb9814f0e3957bd5dc7ce3fadea884545594cc240806159fe497ba5888164654 335a5909bb1f4401db26d7e55f726b209d154f632e713e1bda691e1346fb1fcf 34865ced6ca72c9e1ccd2635f6ff2a3689d3b968bdca016b9775e4df7e58377e cdf0adceffeb97350dd41a3b6ace99484a4f4f7980ba08c3c22bad35b2d25622 1095dd8c0c3555876d83821ef96927bcdeb3c33f5785b7eff6b23012c84e6bc7 e04fa71c25a0e3484b479825afbaed78bcca81d1ec16d0e02b0ed26732ab70db 383dd6af2e2638681fb025379fe1a58438a5b71ccfb44f62082fb711937dd982 3dbe16c9dacc2a7c3d4f2a7aadd7323208de7e81cc92dd4f8958768574ba8d0e 1b724b508e6f688287fc9adb44f097748eebc537b8a9ef2e5ffcd5eb0db256e6 a8ed0d0d34c15f7b9bd8539eb4f0db1a73703f7b1a684590737870417889d75c a1ab8437038769c0677d621cf9bcf25c02fd4ea19386e18e7a1cc4e27ac591e3 d8263c35b3be8a8054c7bae2c394b6c6dbbab44c0a3a8ecf0d705dd1fc8cba16 b903646b44e144d83b2a5338054fb318a0cbbaf2d4ae28f4e683241c72a45645 f66868f006d85e3cbea999cc1de9aab9dab8ed420e887eb6d8b8bd5cab1094e7 f062cc8d8b539657ee47edd97f11ff9b863157b951af13a736b8d16c82a84363 8c9fcc3758b9ab2b89d1ee8457b0d666087169ac25bbac716414ba5587047695 bfd1f74391c25ee492570d813899533797a11e321ea9e3461bec229061206ab0 455a4eba5a915e05782377566b72dab647d9c633dac408aaea6f8ba97581f044 e0c54ce9fe9341fafc56791db8d5ea68e8cbbaf222ff855120afd8dec9f62695 377c0338298c3f0f80e509182a3fd5a40c81f40d15b46b762c0e5598eed8ca41 1c107e944813fe33970f7d5cf7e1b12539e36364181450a0f60631c3b10f9813 8997bf02ac05b9491cd822642d487c72084752b5e4150b0c703e032418d754ca df6b6f5942e2fd0d674c709dc04297c935b33fb597edc3a5734af6196318a617 ab7f3b2f0558840dc839c5f281a190d8277534848c9f64534d9b47f887a54809 78ea46342cb94abffecc038e4e00ea9a5699dc34f89dcb625b35c09c31c20090 209130802e9d6511db53dd050c8c20963375343d5e47823fa970c40ffc553c3a a7b4251d7524597f481c5a5308d1bd3b3c0254d352a9a5b78f18336eb123acbc 7dc00f08f1299dbf52bb029f19685213291c8cc9508a1b2143d5e7b7b18b1882 ea3bc724e789117a5c484b5b84441b515b758399062f2bd98209706bc9a8c3fb cb0f6539b7b8dc5dc22b2301428b9e9a2f6ab08787853b664f6845ea9e85d9fa 315c2d8496df14859b7901592b800da7ae4db9f8c92653dc6d0c108e8b4e0eb2 980a0e7e3ee524d557a0bd194d2b81c5c305aba1c8c195691e4d4ddb4d257f52 41763dbab5729980d1bc0f26643e657852421493e1bdde3b0ecc756780fb6c57 3ba8348fe5bfb2577e997df67623e132d5a290c2eb381144bd42470baaeed8c4 6d9b9089ee7f98aae119f6c6b622bdba6955abe4e874a085245635b8f2b94393 4c82127d23c46e3053c6490ddb8aca8eb567ce3bb1c3972e26a4d47dde728567 5a9a20efb7bf87a0e7c91eeffd12efbbf72d7ae4c0a8c25b9d9c3a4ff8411c67 1d186b6ce7892fa7a1c3f4f00a8b1fdafb82d97e9e7aeebe18750f45d114069b f367f4b4179fa6d22d6d22a828c33de8ed0298cde5fb5d17863509f9417af0a7 2811d5b3ed14736137126bfbf65204cfe201c5298f70aba9d4d3d0470d729ae5 cf4b99cc377fcff0b7ddc95b4f4b523c2310394ca5bf1a17e802afdeb906cf32 e6a2fe52632d2367d577c8092a66c377ad37ec2cb209c7786886e5704bdbbb25 4ced786fa5fe2666af4caf36d267efc92906c327c06d449b601005fe4ecf2ba3 c742a00349add70c374c25e31f1e192e97705e210bcbe81294380e8df3802b51 6bca8c87b78e364890984fddbccc8c407e512a5e691f8c9e4e04f526eb27db32 33f41b7270fcceab849b60835b0c5b8f3d0a3362db18f6428ac8d6cc629a52e9 f6ccb30dba421f16c87224c1fc6c910c28d928947aa80a4aadebe14b5472e3a5 b75d3c6321f144f78bd014df235649645bf6eb8d15a0b412c8791f97dba6ce96 1ee09cd0a0c0ffe069acb5feba91b0d1eb78b810977acc83131b03415a3fa2cc aa4181c9559f8e935047ce91591939a372dac2b5daee47209472f919c6035a02 147b4551c883e364fe17ec3d1e9a40592cc27f8052e1fc7d17a6c5ec24e2494e c9e70b872854e07077e80d0f66a062e15c46c3e108d7cf656a5acbb5097d38cf 32e3e959f6dfb3e9e3bf1b1fb3c822bd8bb584966fa11dc1e444d2ce4cade8c8 842e0eee7a3fe30185d75956878c418aaf33dbadf2d95223031edcd9334a14fb ce6acedb380e0506c71df56f08e37c9cf6a6a7419a0a84d67421f8c56524ce82 c4dffae7b32ae71007f42fefa57835500094a53a7e59b4003da57be6d752a1df 7c3a885c38d04251b942ae97223b302ea5f38383fd01eab497709c42d5798a6c cb5531c9cae36b968f165726c3918cb6f0904779851d8ed46fd9504a90a39776 7229ff35e6048fb93a2ddf96abfd5642442d91ed4ee2928e2dd2d9819604b79b b79d0f869bab272133ec14603e03fe4cbbe5fafcd859b8751d5cffa2f13067b1 49759392147b1f835d36bb592ab1b387a433067c4ff3ef27c65046c868028b51 466ad6d9a84e0662e61b8a8abb0bf5df7beda276d68909d944a28ffdeaa8dbd1 a3b15d7dc0194fb2f1aab6a358d2b113f8e82a5effc3640a89671c76e6a70dce 43b84023745566f7628a0c30be507cb86dfd35b80dc8eba994cd1d2e0af685f7 b8fdd27e4e758747e0d303623d0eb13a255037f5154e0d869fcd2912436d0036 1070a72d4d5efdbef3183f5a0ac7699ca4f91f3d17883f44bf7fbc51b1fae1cb d4506ec0ae0bb3ebcb7d481bf5ca8a68e19125b15df4c15d955dbee943294e55 858799a67150b2fedf3544b0f1e6e3c3d26f7f886926f57f53dbca535c8f6cd5 3c2938a328956c51e42ba52e7bbbbdd2d85cd9ab1807ca2451822ae8002a9f47 2a1e89c0299dee6608a8652416d21ee18b71282dd0772c65d6d2af8174de8890 c710afe34c83d62d6fa2713f8ecd695ba6f7c3556f7a84f9f9e817abde3fcd14 9195d5d5b1a96ddb0f8366a2ff9e0ba783767d0bccc52449136ed07c05eb1729 8324d8cfbceba7901fb55976c5fa6acb13005fbd838dbb42e77495c867adbffd 5dc1c7243b65a5a6de9bfe9493ee49c369548a1b0f7a707c50b49fd0f9273e5b 8cd9443a7faa14d017876ac6116a4de3633059124c9f55e71687317ec4a4d4c9 0749cce6e8c6eb0b30cc9599b9d1e2e8f536af0a52e3883c9b1a0eaf60bc61ec 1900841d34f0df254a39a2d586c69ea435e108c903e9dada712075752da3c470 72fba31c4645db0e3fdfd6c4bd4bec66dccda0e3b1f39ca0963dd6ca237eed10 00de416b0503948f1eedb67da56b1b6b529f648c69f43bcf1a91bfe88a8c0e15 40b401518efa872876a64431ac7463a297acce71697edbf95bd5a4584385a91f 6300f0d82da691b8d88cfe2e2766f7547cf1f60ffbe70ab984cf1b8946334fd5 fa3eafab921b0a825cbf4841a68094cdae5734aee61725ae8c598ed4f66d43ad 45f89106066fb315ab9004ae5031b1f914599c3b0d9f59cd27ae15c9289dee0d 51 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 +generate_ring_signature 23427a37b63e16df40a94a569475e086585f88042e3c6933cf1c7c089b041a45 a680bcc8da17f610deaae851e49a1153a41cf2a0e7b4df452b0cb0e06fed4fc5 27 76ef12c44e822d190d8591a0606a6246e3e339c3c0d09a3e4ef9b9f3e537c783 dfd8e238c9d58b0b26de9d6d577cb9ee7fb353d5e624577d8a7089dc7ba75c2c 75d01aa0ad629f58acb073ef222e20cf3ed9cc497ca0c0faed5328da617201eb 039651d4977f68975edd0044b8c69aef742b79b553550bbb89d03996940f6a65 2e20014f619c3253a8ef76ada8eb6b6a90b48d80a0442afb5c49bc677ca30633 b6172170bbe84ae154fc5815d4736578dd9d30e1e0436501dd36b09da27bfa7e 8cb4fd174df4dc7db427d121a19bf938b4e8aaad7830e9e638f653ef0011ab54 049bb382150f20b7205ee71165393d59fd4cc0d1a690a088387f8039867f5b08 a3ea8ea364079b4a02debc3fdf1b6d7a3791981efb1688a876b97008d3aa27a9 ffa5fa37dceb7570f33e6c757291119270ac62a9caf79c61a1f73347996b42cd f3d0898f92b979728369d0d9abe73aa690292800f3e4efb66de9544e95fd11b1 29291a457166cc60ec27368846b57c40876d1f573ec9af3f0adf44e478c1d561 195ea8899ba4e879cbbdcb3946d8158b0db04d9f147a07342e73089a7aaf5c53 0cfc96a760e8bba3e0a54bd8f64868fb7230f025603bc1d7517d5238f309223e 0beb14a39881918f54137e99f016277f66d022faf43dd0a4312de3611ef62167 87e660091dfe3e75636c7dd731a7aceef1aa6509a4ed0a5d9dd70b5ff02fbba5 4e1dac7838a601b8bf319f75d333a2488feb652d3f2c1610fb24bb66b5dbd727 6e2959ddd5b086f020527fb71362b3d902b030a27a873654c22794471312ee44 2c75319035311b2f58593503dc6f6f0f5c9d6a5b414586818f48452f5e7846e5 f204e336a2710b43975568558f6845fc099637b05cc8921e0557ef5121672e06 83210f8e7869415f49bb722f02ecca7b1a39aa5cb90ee5f62015c26b5aa7e23a 3ccbee824b4d6ba42ed29e238af0d36fb4213986ce70582e2b52e8e519b23c1c e42edb639429562afb90c78af73c0966e4a38f892a13e29c778af7febd30267f 1bb904406811cbe96212e0b34bea451f8fc119a7559e7bfe57eca21b43eb55c1 8414918482c2104b258f9095e099492c5da1aab97173d21dac8c083206ab739d 65bc67958d05c81c80d48855041e321e1e74aec3006c2cbdf0d9c6adc0549271 12fd3cd5de5c0cea07d92c01871687c5dabee74bd383fe58a0721e5c0658127b e3bdd2c25f7b73bd7570bb5c6d3dc6469dac206a4483a6d8dc173bd2b23a6f05 2 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 +generate_ring_signature 4a79e4858cf84189b1a787a39042ea6be11532c2bc4c1e87937546cf467d05d1 e6e7e9b18970c931eda06ce590197f03131062d3d1b5a6ad71ca1e5abcd18e3d 12 2fb5a4364780ab0fac68569071652025fd8b48e74aa242c27adef75f375d94e4 3c46616f02f3b6d9fcc70f74f9319547b6114a4b2af80da69a665b9edaf6a4d9 1c4d1f6b0f21a6b2a975e2a76e7c4c735bcad9430ae693d69b99db3623944c1c 2be94122483ecf69df0dd4920519ea1ce71af7036f03e27466ba7272421deaac 8eb99f028055ca92189f78726acd9b93ab452227084fe718ac4dab9e8f4389dc 226f4f356c64efa694b8311ad07d4ed444d940d98a54920d2d1f9fa687cf20a8 4bbfe2a4a7b779fa5336295fff9be27b165d9a01920c3fc3ff28d4861997c3a9 3c50a93bcc8b0ac7cb7904cb370d850c81750e2de67ac9d4a769f551bd28727c fa5880974ca82b96b3b64d419674cc7efba182815d23f8424e7e354cc3e63dc4 710410134c629f3565f3706878f34c8b4b049625d520c4efe0b8d0ff9ee02fe7 b0d02c0f6de3ec3774101beb260500d636a2a48c5be06472d17723377f82e0c9 7fc89baf0a1f51aec3e249259b8f22194c406956d27410ce5ffebca081fdca89 1d8156cb422b95597ac3b4ae844934b8e729b09dc95d288c4826fb2b3b8cc90f 4 5652c3666b00dc7efb76c431a25d403f71848ea7b81d9607e4873c8a24b29d03a346f5b06991ce8d333635d42e17f4f7b40e69a2969ed05c780ec1c25788b2051362c18393cac95cb1becd88b374490ee67f7a2dd67d7354906d111dbcd98d0d27e3a17beada0a83569038e26e466d4a1ed3f178e976cf0d3b735a4e5a47df0d92b9ed4ce2e2061a58fe222f82b410f8b05c6ba110cb980dae1112b20bc72b09dda21a37e95bbf69164cecca0153263e42e7bf712ac91188f9e4ac68fb560702761d7c59d937e145ffd7944750cc6c10f48bcce0d3e1bafa2329e3953ea64807c0e425be0e1834e3caa8410cbdaf7e0a002e2e8b0eb3b8cf25854320c499530331ff11ad2f104cbe05fe396d645eab854e54d5f1b6dbb07f3faf1af45e76b80b567808ab6c190570473c4e20a4ba88c9d7e1caa858d9093ce02c328baedbbb0d90c28b9ec6c54f43d5c0eb329df49f661b79bd3820e5702b2618151dcc8a5c07a68ca6fc7122d989f12ff0212ae240effe37e6114bf15c32aefa4a7228875f0d26c026b7da686e77fb5032ce4d9c9edd88617131a3a688c55b55827cb991a30c3656ea417a49e4719ac454f351c989621e61df24b16400125a74788294313205f24a973d7b6e0513e1a02d7c2c56f924dc8cdb0d9d7a9967f58f4e51f4de0307714a4f3758078f5e88c3a5a11a91adc138927c51325dc2203206dbdc7db2800d845ee9fa832991be73ddbcdc524da46e9b4e6ce0cc450c70a3180f8fa060a9053e3de5ad375342ac3e00dbbfa6c693116347d91c105edff8d99352e987022309b568435dbfc33dc35854f580b123f8d8350d325e4464a91c0994df7cc8a22e0b8c75704b72c5de5ab2ab7eaa0514b1e2d6f65f9a6d0605b3c1ca22d146ce6503babd5dc58b4d5b12fbacbe416c841aacba6117cc250872affe84735d7cc6b40df2d25aaef27fe3334ffb2ef904dc6186a6d35acc5c93f5f42dfe585d81b88107a8268933e8e48264cb61c0937c5612bba0196e9fd578455cd682b1674a26310abad7a75852c22677e35a0528efedf45edc40efb60c75ecf6ee6f02b14a85760d +generate_ring_signature b3a73b35af9a583cec3e5ae026c0974460a27f514a1e57863ab5b18303b49bfd e40c3300a1834002a79553eedb269f35f9d7041cb646e3e6db9fca5f153dda0d 10 ebcb749e504392105e194230671d48c40a2122d199dc6ae4e0ba73efba82bdad 7859f6fd20abfa37a3c77079adacf378ca5e510c878c37c588a9646e93fe8388 427f5fbb4eab74be396e86079a6f7efa6cf50d058e9f050686421abf936cb4c1 0d6be5c57e41a58ef7f994a0face6c73c93aede764b54cb3666453d57c2ff4ca 7d0a29ac592eccd5310a9f6ef5cc6ebcfd854b437325c38254981fa83a35e333 67d601df6e64415b9113817e05b525ecde13d8f59020680a700768f9df9ce0ab ca677493bf0e87103de142670672bab6afe534f83fbf59bb7efbead953f2ae79 0146d12aa7dbdf94c4c6c9fba9ed250f5edb2042dc0a6b6d143155f2f5352452 2dbac320da8dc26a2e4483bcd01eae0ad7748c28e4bb6793f182f976f80108ed 87db7f074e179a7998b44b864409980beee78a7ea3befcc7fd1fa697735562bf 35b98eef6f934ddf49deebc1786ae2a7c69d7c061a108ea63be86644aa65510c 1 a4b27bfa1dcd8ccc35f56e6ec9dff9e235a0ecda2d9529a60c2e1229681f0f0ef5e6b50a2653e5e7ea376802a446f280d757d626609ada1cbdf5a181178e540750626012998206d8a9960c765cdadfe838668e318e42c99226f309303db3e50ac89dabd36459757c656f2326b3ed98228e81ba2e5ca514ecc0806ce6c4a1b9020d5b17f345062c5cf35c242fc8331bf4d1961bb0c52edd8ec4be508194d2f609778810927d1ce895024e9a918774a94e0da29e8955f62c0840b6ab6d665d7b016d9572211f5b0cd270e2a84db69a580ccc69951b5fe7d260f3a908a193fc3f09ee9b0682740f16a4c1439819270b7cfee359390e8a7e01b2aed3070acb382b0ee850eae68f81b006b88aa3cbec661b8b64cf95c8e6a0f52d1aa6a8d8959dc003daa69aee8da4338b48748277fd07cd1ca17ee6af345737ba4ca71f9fe5a98e0ba637a1b827750023c7fd15962fb5caf1bbec3fa6d6de7c1c632871b49ff34d0c163a07a7b223e94fd68a3f64815ba77d83436c921c639ff1c46bc505febc820b363de545a914ce3827c193def01f88f62d038baf7d5839b2b4151f7bd47d4b04ba9dcbabc7c0139c89ac3c21664a05a6b246edb351439a09f3bfacb1b4557d03c43647671ada6e45f9eaf58178035e6f384682189a84934cda1021f384b5bd07b94252bcb879ac412e5678b9d885fd1d1b5fd20632a0025be3bf4355e5136306e2ea5712a1a2beb2d7bb3336ea62230b205c30058404c3ea87ccd47c2614b6022041762d703e672ea0c5ce283cdb506f0173bd8c6814eb69ce9366ee924df10f9641a3a43660e4b0ce07cfcd2f861708c39322404bd4b5716c4a2634f6898e0abc1741c87e1f81c55b800c52b10f3d73a37c25836eaf0e95a72337842512d104 +generate_ring_signature ba2cf253cfce5ac728cc5bdfa9e02621cac271d7d640ef00c7bad3612f7ea07f ebfa9411cd1911793cd8c3c3751fefb1a4f26ca477020409303e36d624ba31f3 5 a8dd3253a8e5d1aed79cd6b19d6f8f006a6f755c8da0b20e2c9187fe203f6a18 f7cadf8be983339ac7aa073402ff1d5152c7db7a2b1ab927aff355d4ccb97538 beb5217ff6e8217cfa07a89e132171eaae685ffc7155e1349bc2ccb6289970da 6f7165dcfd5f3310abed2c531905a5c69b118b2d708ade5721f0a452248e458d 04201b3245cbf0b7225718ecf5aa71db813eb5ea54b21423f93fc9ba202399f0 d5d5570a52159caf96724aafa56bb402e9340bc605d665b4fb283c87f3404306 4 ab760ba9c293762b69be42ed73afbe0f7042b99a0ec098d729140ad7f8b00c0f57aea8cd26dc6c7c75d0af39bb5cb494d617fc822e7b52c1b03521f5eea9cf0798131f16522c4432a6b684fe9c21142e605314725b4ac7d73c97994f5005a205d10764cd6f3688c41bfacd4dfdbb268aaad24ef447c8196f20966fc4d99d35076e25ebbe269b317d48aa6b3f8041a7d74f2557b5cd46d0af02eb2ce25395f609658800b5074193521bcb6c393c299002d03471e66352ac84d5fc851011201007f7549b188b77fe807bac6db328a0392bc3f70b76aee1362eab1fdd64734bd60a2e0720cd19e9ec5d7611bdcb41246d7494ac7592078693dbcdf08f94a6ff62064f453f423823c3a18c66bd10d818060378ff33d253f398968eeff4e10fea1e06c320008101a410935dc16bf9d33e0549477d3725cdda3d5cf54b28ae95700506 +generate_ring_signature 07d546720ad955c6ac191f0ea16e5f7d843651501ec655bb7352f0cbfc540cb7 9c58ecdc8162a18d21f31152b55b98c21529b1b918752e05d6440062b320e36b 34 c5de097b79f066a3bae592e76e4f681f9f9cbddf2d1bb9819d8988f12e657b28 3f2e00f51eaf8c766ea0a750a72aa798c3323c630bc6bbf66796d9eb1dcd7814 0108036469ee5180b39ab609a7cb4a4ba3f4c6ee1399f5a5475cd7abf56f6562 c607fb7f081e02725de17473c3358cc3863eebc8306403fc097d8a8cdf56bc5a 358cc0d47937f554bdfd5cad829d6d4c04bd7b4bdeb8138387409f51f5bbd233 c585912932e94cedab2246ef0f35ba86de9ac8816c72f39fac1b74ec849513fa b967097a873c451309dcc10c8a7716802451bcb666e7aef43c23c4886e958f59 edf0437f0789c2f1280f946e027b9e9d3cd7a7450b77c0c29cc2d1a3a4048e59 6e96fcc4fc42ec8113e21380f6e34dbe8a1fc39c8ec605413a6e4ebcef95a5ee 3540744c779e95429aedc594ca3e7f144fb36f2354c82a215ee3921eee58a687 eb13aa3f8418b863153d0ffa0a185060ea881d0bf26ec385511efd7d5af9a9f2 7f6f7a45c10655b51e31b6d8a8d718eb55be8263be321b959bd31d8175067833 403cf1c69bd4293df454439957b0b82b4fbc10de841225dff9bfe9f09d0b1e00 8e79d62b1b537f5eb4f56e876c25c5419aaffe859b9a281792009937d39e3a18 2c69ecd10e42299b2775570761c7f256084b0ae90d49e77a84f1f728e1ed9eff a15aa70042d5321cb041d4bd2204a7b3cda423ecbadc33aa57c4bbdf22e9464c 8a01554c542f2df7d9ca32dbad3ee49473c064baa299d3b659f30fc0cbf19b9d f2a1a19157f813c81ba6633b903d7c63ef3aafdbd1001206e1b6b1334260eeef 577dc9dae2487db1bb743f56d1a016e8352d2eef75b8439f7a0b06d2484e6329 c405f1ded4cad4af0084231859177e971c5525f1bb1854113ad7c5bc62e21dda db561e3f680279ff441e82c2a7251ac1e763ca0624ea03eb64fa2a6ac72b7b93 a38531b78756f9ba162cff58ca174efc1d776e9c3375d43a366c5da19e854a6a b12e648ca8bec1098b935a509295024ca47bb4f2f0f458cc371afd286ded5bfb e0e9d1e673bbfb6785f45e855cacbfc081725ee4f9572b152976c70166ff6f92 be23ab7ffbe883d989c97c708ce49e6b7847a4b42a78d7a2a122de8e7ed05aa0 d5a6a40407c2aff52cb6d80fe6fcee2cb265517744e655dfcaa45e9b5b159e3f 90e4110de219aa004caa3aed8b67108ff8888aa4857c54ce6d7191e8b11365cb 9dff22c48301e57a059f72497b5b04695bc6f69ed27d12650b8b5e48c9f8f8ad d056b92a46fb72170ff6d95012156b3c75abc6b19a70969ec132f93e628ccc4f c6bfa573278be6a28702532d85b56cf3ecac307a53474f1599bf35ce0c39f692 cbd889739f84e045de92495e182e47d1b87f2979de5eda0e24eb15078756ef4a b56c32d9e333345df49bcf546e4b7555e5820429035314341146e2eb555b736e 1fabeea644179badca2d5a7660fe89f61ef1e1975046490dcc8ab54a35b2ea12 8576859fe085697bb50b74c16b8f8d75e00ec1f6bb6207ce506df6b1bf8dd8ef 85c20f8768a15b7819a3885ecf1c285cfb1b5609a93007fde3e1964d014f5405 13 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 +generate_ring_signature 0b1546a77f70112073985f8a806f191e83e9d3cb9f19e41f15a07671a7d7d173 0ac40cb07f49b58cc8d7c8f9eda97937c5cfb83fdaa0e897e4aa8507cf55f2dc 56 fb504b3a12b0e8237788b91816e395f566762e9d85e276592b9f42eb46b932b2 2de49b9fed2a1379e27ff9df1387c5704728bd81a61381ce8da4d0190e310cba 4b42cb7ed8b175b0d82c6f6577b3c2ab65bf0e0cbec21bf00a6d0a532d508383 6996b0dc98d6d30c76d3424d16591495301a6981e8a4afe7b0b7b0f1682c0c8e 8c3d881ee3a14b52541c96ea7ba2200a17a9ae2123c15774efff022603808f16 c7bc7b4e978d13bc12a50ce744db1c964ea624d53d57ed21aedd761fa9e5dc56 84230301ac02a11ef46e5e7dd0e2e73faf19b28e3bb579374a805a3a07feb800 0f5062ed757ea9f3a1d9680003733cd69ac3077de75e715da4c72774fddbcb78 da0d99811f920053e451849dcb82c6f9c5f6f2e1e0435a52265dfa695289bacd aaaf445a2d1bcf716480c3f552efb0335d76633b4ab6b71ee6bd9460fc24a1ec 1f7884f7dbce7ede89ebec68fbd6765b2cc92ffa7f8c819b1a98c86c0166f142 5e1592fd36141e29de682b90ffd13d68aea02e67c8c75e872ba66690187fa6a4 78f92af4fc0e7fe8c117f1dec9d225cc1a690abe427f626466ad5768a1578932 5f34d7ff989f08ff0839d1df276a0905c9ddee265d652e2be032f59b86686d95 7525ee1aba8272b610df2377c0c275202fe06cc0589b9213e70a127a849e198b 43170ab7baf0ffdd0fe6bd391dbdb7e2dcd1b89707bb00dca9bf12e5025b0fda 8b84df55edbb4cef851c9674e435639a0b147456333b55f2ef083e572313e347 fe394491438a5a7860e525035b70555caced54a2ee0d0d7b23a85abb6b8c6a49 682a71ed5b369424431725db66925de5175d081d65f6a4fe049a5748836737fe 45ad3881f548cedcef87954b2c02363e0a4571bba5c5462d16bf5ae4f2dae423 8c3947dd8a8959059543c20250f6e83bbe841ea641759cf6f6cf0da204dc3fc4 11f235ed2bf9246af8ba9fc067374693fd3150529e05b138dd6b2942b7b8ef0c 57a1abfacc42c7ec4f8933bd93b59fe01f0e49690621379993bbb03ac100f036 0ed848133ef3457e15f0977f10a76d7e535b26eebf9dbdf97264a964214a05d2 fe282180e425a1bd0a8b7479be259067de45fc6e89243f0d22c7565148acd310 81857e68f244e6d5bbb6cde0c7ca8e5b8662870472f78cda46ee11f21ed85b48 545ec00ff569c1ed27563608e09719ec282f47e8517ed95bd1398ccc0f7f0404 015730048da5e50a112a705cd3110fa035634991efda22bcedc9ca6eb6940979 0e3c5354e7e30d619cf5f89a31817892507e64ef94dd9ddc36296da893c60389 9f16a094d0358ef39bbfae78c967677fcb3b701245f66de2faac17fbd9a50b3e 3ea3265959f6857f1b3de569fe573268e3ccd4f4fbb3fafe0b63524c13df0375 1b510080c98faffca1796b5937611e55d2d91ce491789a65df068ba7a06e2fdf 2d1f63f2b1f54755b4a3d328552f79708a3fa6db59dd970eb068845d8536c432 d9f5b0a6f2f92e8be14dd2ce300333d20579d3fb6f8719ef8a8d5ba5a3e72cfa e4d7b759782849314e443316bf297f0ea63370eacb54839ad9a377a54f72be32 be3341838a0f2bc12009e688ca22178361db99df8060bb520740138ddf5645f8 11d8b6d32bc7a35768648d631e4d320ea8b56e932f1a2cbff0d40095fc29f80a af23e51d53106147d060673d7fb4f2a47bb2ab72b2cc255797fcd818f5135220 3ae4c97b960f65673fd5e01d2c92b3220f6b285b748a546027a8b1bf59e8ac6e 76d0434adcad2173c4259116139ad0fde9b2ae309c1c6e332571794cb588d152 08d4b2c32fca4c8879102396427058c720babe1e39b90279bf202931a0f621ae e8e3cc79d0e05cfe951707e1c903524084e4aac4c30f9179c0be50b7beefd7ee bc9c3ed0a2c25b1e59d70d738dd9da4ae3fbf7d535fe58846d523faf47bc42a5 127d126506b2c410e2c8ac9ce472b1d261932e3fe361dd90880864d003812be3 c894d10d2ee5c17280e3e53c026084229c4e9e875cff20d608a1ef71e4573320 02b412846cfa7350e024294beb8fdc1e2587557e8a7b4452d4e9e9eed14c9702 c5fea97e5de8cdfe09a77f6f78a302e9db64df2137117a848c46c79079b6cdcf d7d0505214530ea4cd905270f664d9ffa08585a7ad28123156f52bed892f5055 fc78f270e04a04f38ecc4b754ed926fab86d7fd5cdb959e91b9ad15ab5677b6c 6fa027b87aca6842606c8f8bc4159221eb056c00d56553ff60884ade17445fae bf5e94eef26a03762c215cee6dd95140ef2ec454c2faa05d2964095992a47705 29440b94f3701df4472ac2647af0de415c2fd191c23dbb8b8f096d3f7ff490ff 6d6ef06df5e113380e27e8ea590b8548c81a715de4b54dc9a5d35d1dc45dfee5 c8ead1f8291072758ec6bf2c68a6d31e5f18a9906b3f22b9de6541f4d09f4068 179c75dd86d37ae7ad1ba856d31f36d6a0089ee1a363c540f0676e8dc727be9d ff186cd81fc7dffae43c919c60cc0da74e722d269741c3694c8ea925ead329e5 901ab283171d866625e3b45fd7fe13b6b829a44224a37795a61683e6addd1704 25 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 +generate_ring_signature 246b0d03ba218cdcb8142ceb5233708fdc1f453f1a492cd962e0dd9b191ea00b a58a14933f07ddd1da220d588cd863ac95d4745b46b0bc581c8b608b8aa48f94 198 0db161f672914d04b3da1ef8fffcdb431771826fc0c197e8825f2b16f0e1ff2b 6a77d52d3688f88f6b8bdaafba20b78065cd9a9fbd05213a96a125ca224b8eb9 e2ea7c4d07361af255042d42a83fa1ed8c49a9f454c7a8f6953ac4a25efd7803 fd944b028ccf14871fa10383afe9e30660a86635d20503c3001960c37de2e69a 61410433de0ad6345b5991355caf4432ae0f6d68de7b8b92fbee59a8ef3461e6 b2a13b81e18cce2587150264dcc9a4b7d5db29199601ce267381f912f3950b7a 54e61f2d4c10373f8ea74c8c262df8130e8d9b92529d9f4010822561ddf431f4 243e9f19ea8dfe283cb4cd1532744223a9530328854c771da9815e411c3ca262 f7c880c639b2cdb9f5bedc069e18dd5891428036391b3872de804d2347e06bfc 7899ec95851d38036fa9305b0d06221227ed571c0f488f99357e74d0e97f2f41 b55d7ec0e21c1b1c397775e2877af9d50328d9bc1d1d9b41075b2c82e59c60d1 86da65cf84ffa0efc5d851f16927ae1ce5cfe37f22ca1ba6bcb0b0d0eb64e5f3 a0baec146642142849fc2bbe21b3fb8dd36c5bbf4c4c8400a9a718732be93895 18e7f44ad2e9dbae18937a04deaf986794c4d1de98423a0ffe9e838505218ea2 085fed1c67c7a5446f05ca2258b1dfaf302d2c357c5626db2f6ff1472be6b789 9a7a89bb811e02200372ebe05f263dfea069011f51616bfeaeeef4d06b471123 c7da7fabfc31f636d3357b0153cfb6dffd2ea29dbcaf79a51b0c8d2b9ee141cc b49528744efb738fbd350f830e7c94d14fcf929490b1a7a7ebef9cd3c0506bec d392408898105d4fa4ef7a113c5e51fc9ec12e73d3a3b681895c5d1f8d64f9ec 14c14d0a7083d434ee67caee6b865733aad7e1c6b53260adc4a67ae429001630 d0a66f5a0b9f256542b2f47d20d9ef0c9f0ce902762e794cb6bfd0223bb03309 53640b7ae4b07158cad551f8b87080c9665cad08ffae960cd538eeb202566880 333c1d4edb0dfa89b137577862e6280720ba32d5a8985cba281e9708a350cdc1 9c85633679a683c2c00a653dd983fd6e6939e9a5b3fb1a91857226ec720de3e1 bb1f5067b77b9f97c17f4a94e9f23c83ce86290fa675f0af3a88bdde6a41c8c6 0237b12838ac6dbae1e8129a75907939d6995c2823fad75c981dcd983ada76d9 5222c496e1219b242efb961b9061080da46d7184ea84ba3f443e5f56e6f8e301 1a73f7cfd54d0c215775175106a40c23a418861b0ecb10d9aac208b5cb917dfc b2ff34e86f46a9e541444950f04822c87a9f3fed09eda2e354ee00a25adaf5cc a37896dbb89f13cbab665ebe009de96110741380b6ba0fa3303d025eb2328c60 2e123842381b4b15f6c08d5dce5b7cd375414fd0309fef0f0234da74f928545a e594b714f1b8cb58d6c1784233d1889c036ac446f4a109db65ad3e504759d3b8 44e1e6f6481996fdccbc53330ec84315b23f2e6177a04a838557bdb2bd967ede 21c095ad1a318b4cb437bc85018015dd88f7be33d7a8dd9866c1748e68586c5d 91c5ccad9252630c2ea99586a87420e8af58c3348ee379c2d1ddf0a221b8a6bd 406ec1214dd65890ee515b98612c06de1fb192b5a9c79a62a30119622a63fc92 b97aebdab39ded19b5151cde77e0dba3bf884b20d76e989f998555379e279d1b 2ce46bb4e29bf4020c8f89041a0127191c91609c94d10167a8bfd0a05436c7af 38dcc4af14c5ef185e7eb728ebd9856666ff74e289176bde4e13f2e89c916b64 22858147faef84673a869220da42dd7ffa011b3b344c2e78d5f060207d030e34 efada635606131016da8e1cae06032667d020a4647fb543730168e424a5b8e3b 267cc134a2557c011b156d1b9d5f9d12d8cc1ceebf5e3071fa96878aefb28980 ec9eaa5c03b8773659309ddabdaa3cdcd7007935175ea3a6f5b3b929b4b45994 1832d72a8c8092c0d1edff25076be448986ffb145a7eac5f4bc99665bc4e636d 76ec16c44937efe375a1923cb4cea0d42a394233d00ed4e77461c0bb19591f46 387cce667b9796139aeffe1f79997a0d019299a8129b946a849f5f537cdbdf6b 79106c954375fcd054ee0e558d8959a6e8b100c1b2475c1f2a30e12e936125e6 7bd06529c0c944410e0027d4b418105022bbd479d2791066aea07763a2beca9d dba510ea42aa855ccdebbbb71fcadeffece08803f3c2760c1822a1e5f4fa9663 c98f55e44c5213fd51b52e869c7096ea5fe9620f8b183d484d447ff8a7779778 1dad1ca1319f93621fba40e4b7ffa7c939cb43525421df2b096361be1b8b1ddd 4ba49cac2da0d71749bd8a99f60bc231bfdc4304ba7d33323a362ba045003af8 823f604a64a454fae850acd9267ab3a7eb96deec9476d2ac69c2f013023ff2b3 afcc56fb9d925c8c7172178f518f795dd100013a35a22469aa01850d5a2b8933 3b02bee1a2346707050462002b2e0624a7f3beb0f61199e8082503ef7bbeea13 a5bf9d17c3fcdd0678cd6e02a3a44cb04127c3cbe0905dee1ec3e2f207e8247b 167cf06f2b5cb320d5d8e82a25312c768d176c1a8d7c2a978b0a6b355d9291a5 121f682795848f0cf6881bfaf24cd161e1d48ec64861a2d3d6f5bd5bdd8d1c19 1c9bc3a726a992f1e7afff27ee6cccfcea8f103dc018161d0bc3cd3367bb8424 4a5293fdea6a697bc9a561326b2ecb6a364a38d28d5b51ac517f8ac36a598633 fdb2f1a88848466354fb68e56ce89e17026ca60d049e063a67d85f6a29848aa2 8056d4516ab1042b2f40fe62a3e1df9eebc350f4cd39d7c60744a25f127f9f24 43039a60e66e80cd341f0d915608485413cf54abd00d6f74ae7d6b400740d82f efaccf178d84c5bffbe97a3f0af3f982049f3b4f7ae981e80b5caa19d887b606 532b117cf74e4766c38d3bc22de22b831a81496e04eb9f30cad2cf1a08c2e371 517fa25d585f74a45202d4583f084d656ea1854b0d03219792f4f3a28f23d58c f472a57780e1b0043e1c06079f64664ae911603ea663becd80d6ee23009000b0 eb6d7f2c9d42f5e9c5341ae6df2213ca5aff31308b8e56b6d9600fa2b3283a29 224239609d5215fe464286cedd2a04cf5be2b4865f3867df83543b1b9405ff32 54ce5094e3d07710882a35a255de37cdf2cd31d9b9c121b3bf91ab7bdf65c887 a0665b64ee617e93e6b2656ec248f99b568dce3cdb93d0cde77a59a63153f467 7a87b59a3b81eed644cce872635415ac56b14e8ce1d57758e3b17d208f802ae9 cd266d34ce426739a6817e41b47da687da15d0fccb44bcb63afe3e6d21808304 91d6a6f62da7e9086bb77ef0fa1652678f4112bf8c58966141812a41bde21014 7f11b0dce98b3b5b753547cad841a49bc70c50979cb7e26931188b2805562c11 6ebddd1fa58696e991018d0bd21507c9fac9670dfc09b83460831d0f99d6dbc9 d2a836ad7b06d482f0473cfcca188e2667241e2fac3c61446616d85e2873209a 0787949bbb01720189c8c681c73df597e5604d268f8ce00990f2e3d5f21e2cbd f7597c8aa7d943292de1f422b9ab12ae9fa26e6b029a8001fd6af739b8c5d16e 3938d0588802af284691bacc09e8924d5339abcc01664cfbec99510906fb8f06 0655a083cfc8ced5a2428b8ac6d90fac5492cb59d492b50c82ec706a9ad621f6 e67d8a5f62c1d7284daaf885e438f79fdd3f473cbbbcd7a12955ef107ee85c17 fe075fc6115e419d5e51a05bea69b864323bb3223ffd2cecef6e0c34e5b4e1fa 231b075c7044e047993781d57fa4d637f5df0cee973f033702ba468fd11a1e6e 63be8069804734a71417e6c6492aac78377a94411dc38f6ca94c1687fc0fa574 a71d86fb97b927e7a2c37baa95b6be30bff078fcdea7cee9ffb2ae3032631867 2868f924fa5a7633a1465a19064f6fcf49236cc893570256b5ff83def889dfee 9327dcd74a80d8e531c1355dab619058fd5cdc4fe01a06f037818a975a7fe74e 2499435cfc2c9432b3888b7a2807f192ba19b62b45d7d273d7f5b0a204d3202b ed5ddcc23a3f887ce3fdb9bb25d758312e7909f9535f9a3ff1624cd86f903a3a c32b0e534cbe8a00ebb0576d80b80dfb4b75f5b17f8f38c9c84e3fe49d13bb2a 9fca90b55ba9b6c5f2c050d2b2f1dbb3bd9e5e51e7b8476cf1355421b0f59b7c e7f9c9aef7db8e8dd1078201a3abe2293b43236ab521c8b0792d56bdd3008246 c09f4b85470610997c9946ed24c314d56689990756c11f8544420cc87826e683 38323e53c2f779eb1622324be8a5fb006af48ea5ef5e3ec00148a147b00f6542 1a06eb4466f0ceb6a73be5b1d799835e86f6ff309a8397a7738351b9f5cd1a00 f1ce554ee1a5e1bb952ae702018ad3ca23eb11ddcd1bfa11b0c1c55256b1547d ddacdb96a51e0a4627d47459904ac22d64a220a1d1bdbffe16f5aed08820fec8 0022e83f981f666993ce52fef3d82566be91bfc1954673b07b7ca3ff5fc58e49 4fb2031fc2197a88d496854b3935daf08373093ccce1f3e69486e4b35c35961a 12f5aad6c8f040e99b9426b95229f2498481a69f4555fc2a593768b68d8df433 a356628599009e89718a1d1d6966f28da025984e3b7dbb310de1e39945606db8 35a5213725ccf4d076a71e87981b63097228bc1043506e1c2ec429f13355ad88 1ec779087cfb19cc36ade2d26f64f9bda01057e81ff21fba482aeeed4ac12335 a913b76c8eac995496954feb8bcc402d6d6f4e800789ba28bdeff1025d818bff a75d75ee55b992b952ca5cd226383b3964322796819dba518628f2b4ffb2fd84 e2ea18fbd119c70d15f4223d594d40202614979a08ca9177ed2c8c76862b2e22 a89ec97b2fe0a79fe66416bc90f396a54b020381e2c7942fede9d56c8b2a36e1 1d27f8fda1fb4ebb4ac24e91716e636398c702214188591e68243123e126186c 02cb80704c2f7e0b1776e82a7e16258f0a8a4c3ebdfac82423e3f72b7ee56d4d 9a524da42a15229a1c21aa734d09e4a71c0ee202f5334ba972c59e00b0871fd3 04cb489a417d31f07b8aef25651e7ecd6ca857605c720860839562f66bdf19d0 d543251d5e015dddb344028dc9325456e3a65d33c5de7d3ffa0bc4f77bfac4fd 70f3c9efd0122620789d9b67d84eba1218f40df0ee75fc6e82566e83e888b990 643ac4025e417233bdbc3b1de190bbb1a0cd3c2dc8de7b9ced271bf3a067e391 1f86b62e7e9a8373f99508c94eae94e160610de9a2885dc75a4704f05d569b37 a329f36a793abf7b70440a1b88da55f88de436e4b65e75cee79957eccc454d94 20493dd3fc860598e2953e9fd29ef927ecfc661443285e7f44b55aa2853b8b40 dec1cc91cbbead300e627e6aff37467273a6deccfd077b4f016bb2ac7f54e591 49bf801c8c676cfe1313e692b56aebedd91546d3e3037d72cbb957253777313b de0168b980e3e80133c7dfa74f76a8eaf7a6e39c4c6f5e2bb9cdf9bc8ad94055 26385c685bb1bd0e809fc3732de977a3fdaf31e8547a78e18225b83120bc6e69 90dae46f81b1994f6952fe1639f741006af0c02c44c72aada46d6fe9aab0b879 cab19752deb880f776f0fe03f32025fd7cf1258638a487698a90302727eb80ce 90a85fe21ccee828f07c00b4c85f6d54516cd4bafd16a8b6a6ae81b2b5466785 430fc038dd9548be476dba2c31c6748c7a354e3c67966d3250900dd39c809e28 49a2d2e4c02a5b94b5ce54609f7dac32aca0a4b2051b784ade638db8df4eecac 4d6ae1194d575bfea52a4e09266ba41676b7a552346100db98908e927ebf18f4 1b0bb0578845f9c1f7c568ba36e7936729fa907f6c1a8c1899229cedaa1aa306 10d3aa986969f9c45562adacff4f74cf399294ae3d6a56c6ae72135f51ea90ed ac69f664f096b6a8684c5f014a8b984f1eb9ebc2cd7edd2b28b37ef25e3147e7 d348cffc84741e63d73f26e953e1a0c6dd8349008edaa22da7612600561a5ff6 d8513404ebf2c16f6f7775d3586391168e0846a973f2229d569a12a06429eb93 fdb70b83761ac9e5f0efaa7af09e44edb8ffa0183b75ce52ecb5f6dbd0abbede 595b8d61b840a5659888c9bc06ab291df02f4cf5199157e0a5b509c382198067 54cf1293b535ff5aacc99099974dd99a1261249472edd6e6b4086fc1cba8c90d 97c875ce3d7224207c85371c7b1def7eeeb5b4690762b719f9f04bcfb866c479 c348eb0c65094a6127d7fc807507c8302a1c69895a97364a2f01ca5482a20cd7 b1308b60a84a9941dd55462ede7f9a54be15fbbb3cc28d7d3479252d0aff9563 c9517163ac2088e0387a0cc36e85345d134fa4104cce020658fd8f542e836edc f64f3d2a5ee687e1f8dfdafc7b06b3b62f1829d4510ae5c41d1e637141b45f80 44a63864b9473c34d0eaf8ae941eb127d8413c6629b8c36fb08b0ca4dc214df9 93a1bdf9e791ee990bf5508b6bf513409cbfb4ebcb16852a38fcb493810ae898 fc94f570800fb6581c4eb3d277be0a34891423b22e1f3391fdae809f9e75729b 12122063caa42018d7beb28e347bf7c0831da5a492b9faa318f822ba6b543008 0a6544c33ea85db30ab5ef3944aa87b5243c6e44a3001f64ef98b86edceb9520 64b6729a7871fc0f35ec31ec51dc6e444b2a5afd02c508e336305f46d5eaee60 bfb50061c92ceda81088d5698f56c4ec4c554354060a38711460332d38e21a33 d77091a9d6d90d9e8d68d1070ae328ce59f7a6a6599068e7520af35fee82fc94 d09449e1b37600ad3a249b93f2decb928c3ab1916c38cca9b56c38e93ef4d987 bd1feb8de1340e0ea9a15ba6ea5bc4f897f0b3d86ab4b882743620cf7133754f 00ced965f3ad93b796fc644f608b94f5851bb8be1559a5ef9a072f07437cfadd 610ac68246075026e34fe339cfd31c413a4fdb201bd7cfe8773875ec5f08bb79 10ef02726da9fa5618dbabbe19e3670ee4167b7c9228f0c9367a53cd8c5cdd95 0137deb5bc0cc9a05e0f12f261da6584942c556c0598db0bbaba1704362a8fc0 f69de7e6f5116310708c3395a3e4e95e4e58aee0cf39670a69d167cb308daa8a 17a8dc951c11526dc54a5b877c78de0267a21841a3fb137f0037666f996795ed 28d84bbb485761c0177ff4b35cf8982f98f7092339e8d2fc448aefc8845c0876 540ffb7709f0e719fb5125e443b79c3bfcdac655671d33187b750bb3a27cdd59 b7e545642adf2ca59cbb67c5161f4fa5c82d42307201b55b55dced00107de1d1 bbabd53bb8454036ad63cddf866f7e6942a5e65d740efdbaf15393a46cc2a5b2 6a19d37e31a1d58fb394814334fd5a85f9fcd1bfc3b816990292f8d81eb2519d 98393707ff0ee3143d5c0e397dad545f7edce40c334f791df327ea542d31cd75 1f71b20fe2cd0064eb2688696006fcb45d5ad0b722891bd7c8077d9717914e01 3751f297c85b2064882e0afab06492cf1b103824cce5c111e2d841d8e8f459b6 ca24b137032418a3d5805e53f04ed21bf57524caaa5cabfcfa19d48061f5f612 b89270edc915387df517efe1ef3d13561001ac485733775779affb438e71d8cd 051a33c231cdddc05ee22d707ee5e8eff9d1ea12dcee617f7dad29210e08f6c4 9119b076330d06caee1dada7957dbea09e03144a122ab049bc0564818823ccaf 04e925699f33291b1ec77269f0f3a02ac1013939697ef6e1ed1c040ab59d213e 9ffcdfcbc96482ce62bcfff69719e9a6ced6e3cf172d0cd234ed9c7e8e5586da 9c35c55dd07ce906697dd1b1951fe1149ebd04cd7f31a0261804db2990cb6274 359f282831d45f2d2f915dffe9daeb8acfb4d99c5e2f1be17ff3671b378a80ec 1c10d7e23136bbdc3b829338ec8a11bca411d5faed84fce332ce88f7426c43d4 6a60603aeef94a7bacc061cb070fda7db41fbdcbb654a4999637af158acdf1c1 97ba1f621d285ca0222a2e31ad7685dc7aa40921f8e9dc0925bd84854d05dce8 6ac558b2d25d64f6b3ec05a6f1515f50474071883e3212cca0f1a84deb99ecd0 e490ef89f3ae5442e0e7afe3bab29cc80801fd82f32b65237208a5644ba942f2 7a904de44a30db4455676a6cea297a0bf420f5e9cfb9fdfae8aa833995fd7c65 58f12241a8a1ba839dad5b602c6ba45cde6113125e59f9052da4c832d14a66ca adef9f1a7a83deb20af284ab72e4fff3c573bd3dbb991106d40f4f725f289c8c bc3930af2f43c34e6d904ee625bd2beebd315d583eb7523c18f6958526bb131d 86e0d0697f039e5271ef13abaa28ff801f90e6bbb79ea905df55801bd0462286 c239f19f3a2be47fcd0a23cf95ec09547157010d8e6efc3315651f23e2655176 99e7300e40160c9b8dea5c066c1578aedbb8c9e35eebcc8ca77f2b2ea2b02dff a1a55f538026ddafba163ba90b5f348df85a214e35420cb11477d8391f62031d a298dec7818c28ffb74b359efcc38eec4b32c1e73e0e8881febd3bd04da66040 b2bf08059fff6b7ac09b835bcfebf106c4386ffab05295dddf769653be295a54 6a3938a46207a8cc52ff35a881a7ff5fee19b918c8d354ec074a2943636508c6 4e96f1e895e106ca0ee4fb9ccee77b63ebbb14c1d514269affa917a0249413b7 4f1e9be08fcee2d1ad61a1fd15c8f0c9a1aae378a763e1a953c96254f38b99de 8321c7ce4d12a3ea5003bb741646c771079875712d53d9ad50068e88b7de9fb1 d0a5e457c374b7d188834afff3ab9aae45c86f7db697b26b21b7a8220563c46f 4565759b70e9741178085228485c81e1bcfd8a8ed97b9e80850b7052c3bc7ee8 133d0f3f9a55c3e714eecc0d582a6efef92f78eb607e03bd505970d631714a63 83a5bcbd0ffae9cb2f11def4f599cbec5bfb02705415ab68dde796c121523a06 c9028b0ade18d0b941882b9ad366b079ff9b1074c0dc2b9b1286f2e3b8e6d15d 3fdeb6bfffd1afb9ebfd745e369eb82c8a328985803ae385f265e7c7c5417370 e24eb8851842daeacb0f9710304506f90d32cf3c49ea8a8463779a8ebb7add0d 25 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 +generate_ring_signature adcdb7399ebe573a2e88f555775d8df55ceef28b0f51d1256cae8f109668a24c 447ef2e9196b56579e07bf5411b980ed2bff6414024f79852d9d4af70a449870 10 9152fedaec98aba200129eab484df0a6366db49094419265a78ddc2b57380e30 b79be97e80cfdd3ab77c6855acab29c655e3d1a07a6e2b53462aa7b9ef83bcbd 69864e7c079c36ee8698ad1b54f66bfd101bf1c835670beca641f9ed37736f99 ca0520d1c7e07f43082c5a46ad0dbb4aacb97e88d7246a60a8ba3667f2458c9e 053d4ad64725e121493158de54d28826417808669ce746b807d65b1f11839a6f c299d75d2531a842aad42ff488b2b76112caf12bbd500d503f43dfd9708746bc 04dc77ff1925242237f287d9ccee87c27ebd75ac6e3a45c357d9bceecd937f63 ca3895a0d1560e67451efdfd8cafdc838c7f1fbc22a4504323ee47e7436ee49b 3a8185cf5f418483607610c29acc87d2b5b0eb5705a25252dc151d28168f65a5 7ccbafce5134beffb22c2906ab4008a62e784b46bd74ffe5bcb2386a990adcb9 f00cac90c0731f2c2eda3e61a2bbfa99255c22990d697a1008ce4a53d42a8600 3 f5b17bd39061b099b82a924350033c9443f9182e39a71f2f4ba3dd4bdeb72c072b390015382e17d0e4574105939e326609c7b8a29a28e9b746f3741dbe670b0ae80edd570ae48b4edf2d6c49566e901a83d120041ad79dd1a384d2e06be7e307e4d059e7ff9f808e5a95e3a4a622af0bf9bbf2e7409e216b2e5459ce33003a03e870530a46200f90267f0f8ba23de6b341ea93c12956894c34e107924ddec90c5e281278333600a18611b95e09f0ad017dd8c9cd0e9c7db469d0bee9f67e700ed2a18e8638e65336724c3f01e4c9f5950fd403480598a35ec8572249aa00d40f5e5679190aa41870d02bfe37041b8d558d4e48c11f58c214b4b807a3cb70d3052af1425e7d28aa64a0379268bb2d3cba6fed543077bf2edd66cb49a3f0faf90bc06d4196e2f23ae4642960de37fae038ca0aba32a8158a3d2da02b0f6a45540002cb5bb10d3683f030f5b06eebd7a216de197a324ec9cf26ded4647176a87d05fdc5d09bd7842bbfe6b9ee2dc61b57724d650edb8fe93aa92f654132be7e070a347ed37f9ef7fc7a79db05e264133feebe319ae96ca4cedf93396db4a4933b0a65fa7b8b9861d52e3940f53e9abdb3a80d5b130f28f97f3cc7d84044ecc1b50763690a2513b170f6c55e821e867a258f855a497c2c505c408adb3074e136a4054761b807e099783cb64bd1d9110d05f5c184aacb5b32b4e0cf67764aea703c0717ac712db5687d1ebbe5d8efc99f7e243e5a2eeafed6fa7c6cc574b82bb1520249daef60ddc79c20bed3262245b4429c10ddaec8edc5dcc7fd7812c6d26a9b0b1b3582cb2fbe34d37ca8ff312dff814eddcc454793c51c4f2dd64cd9aae4720ab07dd086c7073a38a204211f3519be043f361c2729817945c477703bfa4e2b03 +generate_ring_signature 8603bb45eb1799e1bc1fe6038b19a52bfb9ad7cc9cf44446f164acc3ca40da1d eea6a1e1451c63be7dc890f76883f56b1fe5b41921b4e9a5f7757b92df2b6a49 10 278124100668fd040c4da5aa9dcc1961b3e51c0c1c427757e00938d4584b9a72 1e7124d6beceb0fc37efdfb8e2098b24518f431bf8c0b1d5ebe553402c025b99 73f76c9a7b6cb8d8bc3996ce6fdaa00ef47e3c4c0af2fa6cbc794153d4ee0fc5 59bcb04b3649b9d1c6a697ef8465128d7ffa20ad00d4bc2f3651ea8893e75e17 8a996eeddd61f604a74434deba30fdc66efe9a92ec938471b11f88ded7365510 124691caca477ab72bd7b69ab0e991ed6f6d30e910f34997a8c826e5f9c3e502 e80acfb48cd74ae789a6591ec70de50049fdb9319c8b4cbd814e463113e97c23 4be725c440060881b1dfc58d506b5c16bdfdd539bfcf02ad5dea50748ca0350b 57f42b791c1ae5f5dbf20e303be722ea94fd993241ef302e94da5cb017802ba9 dcb72d6d16b55946296733c9638c60dff04002c51c55234878846bc1b6dd1864 f0dacee794abc5fbf38c017120a19c7e1c65637c65b4103fcb8c148af9aad201 4 10cdb120fcc7e93dd61487df73f67535a01f55236bca95d00bb778fb78c0d205bb748a233cdfe2d461e0bd08d2915a3123d8168b1ddaa46796ba1ea412262e0e8295e8f542c67673dfbb91a1c5d91450631062dc743d5dc637490b076bd9ce09cca2b811e2aaefb8ca7c27bc7a579b2811ffc9f52eefd38d6c62a063234a5d0ca6c65d1afac6be94bbdcd00be2f0a267b80f0d7fa2f6ad413df5ec723a0d4b0657680fdc474ad054c1bc9936ecbd1c8f7f54b0f7a092a69dab108d377ca2b5002afc381491ab0a8b218fd021443c7e416a755c8054f9266b1296e3ded52bbb0d18791b0f60290937e3d652fa6543433b189b5485b4ef63f81fdf4339e9b976096057d5d0ba4398da8c32df9161756f2fcf29aed7d9ef31676ca0af4425016a0929be76f8aa6484d3435db96d0bc4ad624750b0bab16ea52cc746ec630120e7073bc380b531ca7e43d3eded6e3d2785ffd5b8e6429012bf059665eb62ed54040af283afae57da2ae8e4dc861a55a9c07f195cea9cf372494ee4e5a356728734086d7b3b232f7f9a8d51a3450e50077501d05b968cdce9d1c63150bbab9b50a0085ffc7a3125aaf806f1eec01781e9d024e6a5d0e8f427c1aa65114622436b090bcba6e48ac4562d6252a759d609206172dbd11eaadf88491578208b2e4d2cba08415faee3abe9dcee7d31205ed702ce73d15abfa7571915393cb0705519d4b00db319212d7e64e1a40be768a65163cca2f493d28d90b041ac523e73314133f80ec85c8a044d46c44067a3d35f1d57e021007a2b826269384a12b62b054780660ea213bca11ba1ba75c77cd54f5bae76d4ed35fb57d7eaf501acf5107c961b120ae96bb352f926f28ea2747c8ab0750f399b99cc70bd3f27b07789d25e98cdaa09 +generate_ring_signature 393bd6d7e3d18366b43c7f64f94c7f3e803c05a357fd4c9ccab41f235545ee23 ad175b4b3efde3db1a37d5860d51d8c1e71bbdef25a0d88f29fdd6ed07309665 4 beb4f6cb5a63cfd76a7e66a78ed35d788947613b90e7bdc25ada761b87ea430a 0e37fe8e05c17b8ff67e4fb79a6849eae9631a41fccecca28618418746d0a9ea 087f54a5745a7fd38e45534fa0a878b582fd7d16e6705e0bd195d9c11ffe9638 3c91a5cb9c704c6f70c36cf483ff5dfb14b45958ee50b244de2f8c60e3931a82 c022e13c7fad4dc5e547e92919763f8276ba20a839ff4790f7423bfdbf60eb03 2 f45340ef1eab8b105021d39026128329b9213d8a095b3041cc455c8866238309e3eef740df43f6f941a3f814b812ac6837acd8b86354f60654650471566563099240058fce763c2aaf0615e7bb4ebbb9102f20fe387fce55fe55e78f2b526d0c962b9b6153fae64ac50ca0d51ea88deb1256353ecd8b2c56c29e7ee67b3fb905f760fa6c59ffa434895e3e7219d160bc180d892b0eb92e87dc7ff642ce9f0701e4ea9708c6c04414d1ad075f8971e0a1ad235b52229dda06daf8b15b7637080a2f2100b42e0ba73e746f4a9c0739d2dd4ce8dd8170da95d6197a9bba9c6af307e996bd712f886e4ea6ed6fd13b6dab7a8fe97d65f760e90e70dbf4c806d3ff0f +generate_ring_signature e565abb91e365168b01e67f4a3c568d32789fdc1e6dab2f448e9f38d091a3d4e 9408b7dd8b3cad102645c2011cbfb0edf8b012cfde69948fa41745d9b2e0d375 1 353fd42821e9933571099b5e6cf214b0f20f3b6d012e753818641c618d20defa cbbbb2095f92ef10834a02629b43f7cdb9c44d638c6972b9030d793472a63207 0 02f8c04e3643cc44497cf0ba74642b684d6d77c2ffdf0d6a174233633bda560be7a46414ecb3fa9fd18b6564f2d2ab97104fbe007b033e5a9c8124d23188e802 +generate_ring_signature 7ca2998d7e7f0adc4ce35e5b474e47699d5460663aa16ab449609fbb00d500f8 7fc9c544c3e934782785e9f73fe032d96973111f922034ca48bc825cc27736c7 64 483168d096ddf7c014a148e53be2d680079bdf94ddccd86b087f8b33d357b7fd 86bdeea8a6d0fb1d4c7d5a173d5468a55f6787f612cc997039307ad56f2ec6f3 c60a76b900e4670551e578ad687fba402b25416433d72af5291ed69e630337ea caaacc734c97093c58dd64102a4246b2a5840c1c813c4e338394bbac7dbebc75 1ef3e4e217cce535fc694fd8c6d3e113914f0a519038690ce7324d06e4d1f8be 916111041980474203cd2afa9043cf5d9c3d636fec3498e1f6b06115b668bd1f a09a5afac52945be31fc7a2e7046862c8d4806649359fbf8b5f7c69628b4f167 6b5d1fdc1a962a295746d49938647583ea088de7f8e241497fc6b41bc9121e95 0400eb6d12f71290e0bf2e6af6ea14c37198a7e686b63e0569f6741844f0db28 235285f1e1e1a1bb6daf5820e3f9db2f5ebcf8a3c1dff2a988953d60d77c2c90 847ebd598b288b0052a82a35c58fee0e477556cad2bbf15dc60208ed14712b08 a8a54162f2a6e4fd177b3c727dcd2034643d6a43970f2bb9804cbb5f24366b5c 37fcdd2a3b035e5f5f4951d3ea120dabbdc219d9a6c385d03643a7037eb26af4 c3c68afaa4e7cc9c7cda7569cd3b0e880fc2b39e418383c4f7d6aede362acaee a14729c01c6f8c78c68f4863e384162a863d304e780cf1d87835369d6c0f4c42 ba8de594a2ebd411901147db78dce4c6b5dd35dd2c85ae6ce2e2f48f3e47c122 f9d0351c1c41aedcc6899d3c963c410b3e33510f747c1a3cce8ab1823a3414ac d8f4ac38ce7be2c45d3b74880338bba84e256042ddcdf30ff25089726edbcee9 4b33b840fe9c767bc2fc9b8f989aed3d8012edc993776b1d2476f6542ae15cdf a7b39b9014bde6702c0c7baf60a3245a70f8db5abac0fad30bf98c36d8b201a6 3905a5aa52ca2d61f49e770c53c6663687c2b6565736b51527b8332730d283b5 e9932651c0ae63cf3738fe067908dd46644f1d2235972e027beec99724d013f0 804f17dc20b27060756c20a2e3b1bcbc8fa01db1672c7aed51c20a868b0360bc 138c0ac27cb68eac5dd51b8f75d1c31a215f26b14445bcb3642fd00a176a6639 0f283696b934fbcf7ce30f78f8664d8f28c986a202a0c340b2d7d5782cc7bcee 36415f082045b4c3b1b0f805d2e6ade990723d39db0a53cdd723d10a255d41d6 16a9cec53d35cc2861126070e57d228c20f3350b93ea4b46d8b62d01f3209f20 a5c9112fefba9ad954476e87f670af6dd626898b3953a31cf3ffb57886f10d11 ca10bbb819ce71f840e69d53750dd43adf4cdc2c785e517c7edde54034a3baba b1f8df73868c6f39af5d6a71b16fae7c882cfa335115f62f0b093873c308d06d 557f9033e27f5ffa3268c4a3f3fc94dc73c2e3bc70908888c3644143503796b3 f2cad5e736f9839d99cf515859fb8464fece1f85450d5bd5558ce750e60e2942 9becaea439d210fd173a374e51586d125508c458ffb0eea0257416ae62813a81 a56164a43e06f4da3d2cfec1db2c1fbc2641b9f86dc4869e06e55f0a9ffcf751 c8a1abd87b2837247515c9736804424e235d61d6c41f90e748e72859446633e6 210074f11031e5ce0d2ac8cf51e9fc7981155fd1011745ef1e74b342672b453b 8fae668e0c5e30c77823534bb06c660867896f016907fa8b05f5a18452c7714f 0e1a32d6619800d7c2fd5873d124c917752f058318d43b66b2512aa1667c5151 6803d84d7b5a3574328f3403b2f4a79b5262aa31e6f1c971c179c4ec2c8560ab 44c61ae79c631193c330a66d64dab906514cbfec06c8bdf57d5cdb1844b2f789 4000fa60a283326fdf215ceffc849f6f58cd74b60bf19798cd6e54b6e3d8d06a a78e6293da0c64e26b788e55a0afbd8e4273a226a514cab6e3b4beb8d214c9ea 12980cd87170fc759380afa60290915389ff1929ab5de05f1e8549f014fb2b44 a1b83d3f280f162cc37feafd51e90cf6e1da6c82d25ca9ae12b4acbee46a949f 6cded174a9447758824a50352936a539d97c0977ecde4eb9df83c0244a44b89c e6a9d7f60b9d6f367befcfb0578605aefffe810cd55081232176f23cd4901ba1 13fa490eadd0b74699af3be95e1f5b2e488826a104779877768d5e10a506bdd5 5ee53f2482db49cd3373a9195fe2067e018a081189e9e0ba2500357fee9f11d7 0cec68b56dbdd3f61c5b5f242928af02ac0f1bdffc5461b5855fe58b582f54cc 6c17365304dfcf711494cfeeed75cf5e121ee6b59cd67219edaae7ea07db4250 6e801ef00a31b59ad896ab91c68c67ec24aac24b03436c7013c18df945666875 8326bacb4818132db5ca61d73897c1ec0769d9833b9ab677c42bfb9b177e0f09 2b460dbd272c99ec3ee39938db0555df0f23e8090da8e115a912e15d51aa913e c3cb48550117623033617d274569087b44d1da2dbc0257bbf45f35e3581b536d 110d6abeaf7b20668c3891fc61240bb2c3d67736f5e80361217156a55e142f5b 79e8696c0f50252f81b5f218eac91894ea15a95a48ca68594de8aafcae37d7e1 7308404a054e1005bdf9eddda7a5d0ac0b395efdeb81a655f4b8e8819bdc583a 38239bcf14fe4fdcb14d6943c464ca8cf401cdc46d3d212b4f1ee52161e3b4be 3a8bf4e796f2cd92a78240df064c3520f4966257b89e49ffa2ac6b4f70322a97 b4310494a59ac8bc4ccf06b17f70ddb789b387215fe2b73d180b3dc1779350ed 51275e0ac22a92d506d12e7969e28f060ee7fcdcaf100134af046d622ef7c8f9 d509aa1c71eaf0259e74c41d404c25ed03fbf75f249214b7525570eee1eefda7 388f6ce354823892c1cbe49d7fd79d8c62627308a48291af34e16bca292a6ac9 7831cb8fc935ac1eea198f48f6632475f8feebf686406eb00d43f4054299f8f3 d62eb32ea87d2f0efc686cf9d79d111ee668a65a48c3ae2606bee28d8dc54202 15 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 +generate_ring_signature 4e6823185a8771ea63ca39e1aa4dbb7578a6fba3da566cea485c82b3c0efc115 0f0ffd85c0de4993b1c69e5b0c21a3811b49f6c0f4097a81e33448c1149afaef 2 cad1c5a19a24b36c12ba2812652309ba4234f04ca20812ef2d76405d7740afe2 4ff3063f234d5d7b4717b2c2b9e4c09966f69f1c1083099420e37baf84d8c9ba 071ae9ca27b1072d58abfc39b4bf143d61845202748c25189525172e1d081b0e 0 25edaec9d801496716a0cd9aeb1e5757d5718f8c76108d108a8a1a9f8e51070f640e50129530644f64e09631c6a7082fab5e8a551ce32b5806e74091322c2f0c27c93cd9b8c53b561c58007173393a8b859bc0e4ac2ba110488c6501adf1750802f13377e9f2059c623393c2ab2ad3c8f500e87e97dd35b8b480d9aa7f839305 +generate_ring_signature 91cbc9e360956a6ea91cb542dc70d6cec885b8e2a1b763a3e352389041be1aa4 077849a2880ed750d786a1f1f0a17cc01c256f896373c465779e5154b3f7d955 113 1f4bdae2817d67f27dc0ceaf976717df975fb8353daf7fa01fff17ae37770146 fdd656b891d9e758069f81b2b2daf433fc84b3dc8eeefd2d295b7f5ab9d75c92 0859b4fd8c367923f1061c416b7e8e9ebb99e3829e50d8d21fa659ca4078330f 7e2da8ad81daf87ae03a1f42ccad8d8f3c8e1d4f75dd89416119b1c71e8a2416 c32fdedfa2464148a62c7630da8f598ff39f13628b221142f7f2d5b61fd5efaf 76737534abb4dfdc6ba72c40f3b406f9cec3a51fba44b56284fc62db05394e79 e4e6d4b71a8e963a256a300e4ecd265dadfc6ffb1fb7c46a68b9badf18e3e4d0 b4ce84dd04dc6ccc4b85eee0925825b4436237ec68b324f66f5f9684de4f66ba b1c379e91b9b72abdf75c4d25174bf029926cfb3498beb075586c9ae3cc105e7 2267492b2a3131012bdf68b84d681f03824aafbba96b2b9735343abbd74b8cb6 00ae5b1f0c470c254facb1b12ba8ac6a31191cdd01709d2ee6b37c1caee74cd5 bd859849cad2bb97e2da3908dd8b90578455599705674fc0016ff46c3549fea7 bb21060aae8d8503dd930512d7a080a6828223b5fcabda0c161ec3ecaae3fefc 66bb5f6b1c081e0393d2224ea522cf385115dc03b1970c2e7e3a5c72d8e7bc50 33cc10d158229e8603dc7895a81a8b6c55edecf6f43a506625074261d402fdc9 43a36814c2c72f6a273fac7094f9b00124e0bbd332b9ee61ca41ea231b018816 1d7f55694bfd332d08164d331fd276e56d365f2a7c5fcd3824c77a6809b65385 c2eefbf1779a3dc88c493b6512ac8d2393b2a65f195681baa41bb05e2e58f689 981ed644db662419628670953465ebe2ac3997ebb4d8292b24d2ddff64fdcd86 123dd138e0f62fad60aa9656d484aec34ad87fa623b69ca4f77f36b5b903d71d 29976e6ae7245518b0565907725a15e1445bd1c0730b2c98433c47e13f34e4ad 541da01c43ea8445433cf70817e7fccefa13245c1d6ff34ada5324ed8dad3d04 82a982aae68c079dedcd3455d266bcef67e4d39028afa0df883dfdb4b36ce979 7561dd51d46d617281a314a4e112228a6abc1ec8ae26f59f5d691cccbd96663e afa6f7640f981e3d4ed2b85b74151061aed19ff5390c0ab3791cccc1a21ede59 54c84b57a8749841027cdb4555f8a8c03dd9763957d801efe96096ce6a58a1ee d4186b3f8ab4c4fb9256161f632c9fbae63912909c22636357b001ff34486de3 e845c35b7b319a99099f122f0acea3e39e82bf536c9dc0a7fe5875d6b0739c74 faf9769154330257db19465d7ae0f2f211f730e4c83220c48d7648596e91aba5 3bd9d7b85fc7ae7d7bece942d0ead33b882d0c35d96d491eaebcd6fce5f345da 1cdbd85712849004e3e4069802d7387ef46a4816ffb84fc626d5c1b9b7a60a23 d284ec26e2df785de3542990946152a736f729a787913dafe58f8745b0d263db d23bd5efd82b47c8d982ed9e1b4dedd39a3ee3badfee703dcc33d3c32b2075d0 f1eb248b21f1a5abe42327d1f203121a0a113fb1cfd61281e639aca1a15798a7 dc124febbf2b8b75ad19408ba905ec2660f8641608048d4053b137c18118285f ff0a4193b301b36562d8c1ffab7bbb9c62834b0116a48b992a85c1ebea6b0a81 8ebd75cea0d1f657d506b3cbdb855a9db21f87d8e0cbef42849383f093b7eaa0 9e254d83820a33fd0971a3c7efe2ca64c35a3d5d50ac3884bbdf7d6f77d7dd5f d2a69bb8e79306446c6b2cda1ad9c3d1bb571720b43e55491abb505b6aed4f6d b60e0fb3e1013aa0c1d196cb9d2fce8c1f201c0a013e6634fde756f6023c36a7 262e4efc7730fa981014d1567de9d429eda860bfee22ede1c9941ef94aaf2159 8a40d305e04999c66638cfb169b2a991c0995c814ad978eb9f1e951bb3465c40 088739da61d37ad97d467ec8bd7ca4139b311f7f8b6cea6469aa4e8a4972ba51 6874ee85e75171ed81a59ee5030a8f5af72373719a8faec2680c00af75fbe0ee 0ec37865399810603eeb33048982fd83b25e9e1fcbeaa91c0ed06fccc47c3f80 5ea898f527a48bf7a4fddf87f26d13637557b6214da4eb1b0e4e0495111f9f36 b1dae8a393bf959ccf33a86ce48214f4250458661892fd8bcbcbed768f792548 25a26575e7b663bc898396ed9ccb961e9bcb00d107f0662edba72d2697a78d4d 927ac8a2052c2635eabe2602f67d1e024ff0f04dda5a09a1abe3475cff9b4f78 ef6c5437357e0b31c6a3ddc3474ce246f49a669ce06acc00232a4cb170e0b7ac fa6ec2d86e6f12a008a2415f6bb6d62d8f4530b7ee264e6335421b464033b6f1 77027c9a7b41d51ec9851dd80e52221d541330c4aa65ae9604bb924874dce56b 6229ab07ca58513e9a5fc1db57e4c1bef34e4007206e440b26707594b3cf88c7 137f3bea2550d2307d8a733cd7ccc1c6f80fd9b4f307b75583193c826805588d 48f0e380c36fa89f755054572914efcc6ccb415d77348416a33d5512f8376380 4f5e4429027959682771f088b7101e1cb07d0183052627e44191ab65a4d11e98 d40ec8d941cc48b7edf706b778d736183e05856d03fd929adac4eebf3268cb68 8bfda414414ad854211292ba745ee96f200c80e3623506fb8525f20fb2271fc3 1a615b1e5534445656037b118b8b7bd13ae02ae23436b4ee338d92d37c3d4896 9bc163d094d4f87154cf3593c1edb359a903dfe7509524d9335623a29c656663 eac712841f6694776756f6a89d043bb062861a4378cfb13af76d301c71cbc6ed 7ef33bfc75e86390bc080acbe35bbbad5ddc51da165009bd0daa10db962ba996 054e6574ef55c9f9e94207ec107352a0dccc240ef20c033dd6d1182f7f62909b c32880fa3ce928700ac24530ead3571072e12b03a49b26ef6b3d35d0f4c59d53 b98d0748298b80029c901eb4ec4cd8a436e83c7e01f440c786fd16e15107ac49 ebb0e6eacbc9c5f35484faf27ecacac6cc694ef4b09d807029ae6f510efdcda0 b490c1cb481c3ae08a73f63a1102b316d286d93852adf5648cb0dcb6818126d0 d4f4da3f84eec9c39a4c7cfe27a3bcd39cb9f291005614f1487e0f45a4f1ec00 aebf45b322432696c7b67d3cfc0aee50ff8e40c51ce8cae8a626812449d3a54d f606c7fa4e43f558fdcd80fe7a73dcbb249056b368f5a44f3dbcb9324b503c34 106f85af18b3197ad3351fa8fd8425d260e7aa0c05918af757bbd3361bfd69d8 32256ba58423e1ea10dd4f501a5d238f31499624872406fe500f498e66d008b4 d292d6bd8bf7432aaf9c61d7dc96c73f0dae8132673e85fd3aac5fac1a93431e 52b24f1118795f20e46b90c1b047ee5ee2d3652ab2bce842a9cec609fa62aefa 449fe393def04380cea7cc4c3db08cebf0482f2ff57127ffcd987d92c3fa6163 7a8d3c4d6eb1516f2fe284e496574b3f189b5015a489fc50e54a9f414dcc1b0b b39077b6c733c1de5db7ff8fb3873f024b40fca72f9cac1fc08af28b18e1b932 0b203cae9dada2034024effca44f99b52a36ed00a2f4b67f03a4e0ef5b7c5dcb bb56bf108fb574114fc98c31e713ddc445cbbeab6b01d4e568dff3bd169fbe2a 059819ee8457141574c6dda4edeecda5e62993b800bb2148b16529bf6c0a7d13 79688125c0e6b72e56ea7872416735714947f586635bea64120945fa37cc59e4 5adb1c6cc2ad2431222dd58e8a6f3571063b3ef20bb123e3a1071fcc60ecc9b1 cc3dc8f1ffec0e5f45293b94a5a7bf3ae58a4d4f572a9f5ba8ec3b4f34138369 3999f2af3d71f38b14e98dc84e2530f037e83e7394bced0b6d681ac73029e563 67652807e4ed16e014757a70974b4f8db9e6f6bfae39fd0614ad1f06e525c081 d3813e43348dd6866a69fe1755162f250e8e3de00b7ff0060cf6475d2445836d 438dc90ded371c003c1038b170b925cecb796c3074ccbebcb98e3168af4d39c9 740cdd1999f72c2a29922d6ea744085a4d9f104636ea931643943ffe673fb15e 585fbe2386bebe0fa46eca5ac524a3cf4665498c01929b98854634b0a0d113c3 de3706dcad8c44c755bd56ec422c99168fb5f8683866a13d7cf8c2145a49ba38 da4157d8f82d2a54744daed564c987c996120211b30d482fc0bed011e8f94fd9 721a665b9b6194d077108c0797031347aa6b2d6183812e890ead8f7ede04fa99 67cd0f8158601c13c2f85d32fca57f324985a20c4766cca265693c77d87d5143 9e8803213f74d6e5869fb505e8309245889a807a48327769b8476f16992a8198 eb535a0a39ee12899ad81b8327bb17194757e760e134a0bd34a38ca32b7fc9cd 1a94815e92a49195b30d5c6d08c6011f615a876d9f84562d13e20c8796bbf944 ac695022107503164727535604598ba50cfe2c8d2555345948521d94851caf8c 4819c71ab8e12d613df31c3e4302178dafdc21ae33baf2ee3a9f2b161aadd640 c5b8a211af4dc95ca5ddb7554270215cbdec87c34dde54c484e1bf8ed7a5500e 375f63727c1dedae8a51f8424156f97f9ee3b54301423c8be049492638476587 cbe6d761149db8e9231283d7d3e27b6bb107068127e49ab0ea318ae47a52d941 d78379ac13a4e4e05a8ff9cf451d22fcc16d17bf4b06f66c55f8da8584b08fab 6edfaf19c5dc75df69facf72eb82bc2c016b2650f32c4afb731f7f3fdcdadaff 44d3fe29429f69fec91ae3e2e33b227fdc00a8ab78e3510b2bf03322f20683a1 a859389fd668d9b8a8a5fcbd3ad6c49c751032078462fdf6aac4e5600b8bd37e 6808fb004f96d638abd7d164167fff230265214723a7b65344011667814ef5c1 6c3654047c65a6312b5f785a9246e064f1d223913b7e11db00bba27b8d6e728f f1383ffe364151b77625632904f34bda76a33df6561c30d591c30cc492b0fc41 6cabd4505bd1a98ff5f7c1c75d7d4e328d691510f4a23ab74098c3b54a08ac03 c4818a93d8e531cd4534694bf915b7bd5d65baf66976fea183e3df1ba69b65ed 4ed680ad71299f0ee843625af25736e020ed7bcf82ee266c0e34537b1cbbecdb c8a92d1bf5112f1781f2a7a528b196a3bf4ad426a48c30174be6ded892be8be5 6ad5557af5108ef9b99735168c733031ca356c49e9a4cd26bc6f3a332d9ec219 5c0ecde6ffe8646985d4552fc134f6d013b984474f29e62d6626dc941c23cb0a 31 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 +generate_ring_signature 5354b346c632fb825e3d4facd91c90176cef0f333295379b68ae2f3d646796ab b232e87202790b0f139b5abf06b5ed9dea9fa10b45137abb748bcedec49957d4 2 1d18a97357d5c6f3660f9cbaf1d05bec77fc60225b96c643af06888b41d560f3 e4943e8f3d243545a50e1fece9b992cbee891844f6920144321f5026d51c010f f0967d0fca4c4f72d2cbf40eeffac2483d32aec3c862f83c0e938e8788e95602 0 f89a4d8fefea2ad9a95fb3a811c3390e33576bbd75a0b0783113b32360c06300528705f2b5a2647438fc9c5ada50bff7995456348b8e7f66682ecb91d3e5530baf14edec93b76f68a74831d4a652bf81144aaceff49af43ef76580bae06f900b3636147d941586bc331199ca501bdbcc5c5736b91c9c0e518a42afbc9c4eb403 +generate_ring_signature a3e9f19a6821d12b0cae5d619f939c5d9beaeb9a361f9d7bf374b3814ff23ac3 5be7e561234f7b6bdefeebaf9a512ac4d97b77dff058f832100634dae4b222f3 4 1385acd49f2edcd1d00c3e69d899ff286d76ba1ee5e7684e480d914d31f57a58 5c43220a60eec00974abc48b6dd95e001d4b1e362aaeda5b712d8b6aca644304 02365a93fcab00824d25ce4e4bb58a49b9f68ff7b1748d1f03f8e5edd6fff416 a1abd0f71d7c05bc675f911d3c4e54c1b8618c603951a1de691eb38f030199ea dd3b77701253a786191b9d59b556f2b96336027fe8b0de80bd2b059acf610d0a 2 e021c4134bcba64368a26a56f1bb05c1bf9cb4d589d10bf3ecfdc42210718f07f0572d248122a84336ea6246cc9597963a773195bb73dde9357bfb2a5f5b1107cba2e958f3127ca96ca83f58741867e834203ac86625fc57948a8e80e42da50aa9bab187c3b9b8923e418276fea5afe5272976e4862d9984191fb792d20b950aa2cfcb4a4f8be1cb8f0df51d644b5fc59afbd9ffa6a7a1faef01d3ba21676b0c98d732b07fc9057dfff8a3076daed561b1c9d454b3a644778cd49d5f7804270a0bca066cf92167b0ea910b209de29c7096340f85f83ed9907c2ff1cc86d2d104a90ae2cd880141266a175dcff82c6ba2c9aca04b9d1a620a2f5e16ca9cddee04 +generate_ring_signature 095549371963a6086a8533f8182dac9a9288863a9816d457484aae549c10c454 034fecfec4129e575a8f79e4a2f329ed0d6e804db3c6b30178a298acce98562a 2 80e4e87a2b4f800d02c125ad32c11b8d667705547775533c48d73f12f39e1c41 c404cb7233f19eac34d072f1f24f9edef448ab74024a8ddd8d72639079be844c 47b6e374cfb1b6ec4adcd3183f7b9f54812d7bb6d87adab41e1713b89a918c0a 1 bc8294c878957b7c740f5342c503018ee020eafa7df83523f082e2b2f77a8e002c1d8cd0f062af3b9b0753f7af2efaa0293e1343286ca26ab56b217a0f3f7a0f7ee59adbb026a0c151c373c7696f5af9e7953efa8ce474cc747d93228656250f4ab0fe33dd238de41f4d6bb55063db979677fed916dcc240976df29e73cfcb00 +generate_ring_signature 765d32e597159be85cd75d6f4a26b6afaf0eb7618a10bdbd64c3629d5f37829c e5729996355a7f45566941b16bbbdc3e9645df09d11c7a4fe0297d9046d80876 4 ab4b00cd5d57edf83bb7e34a17d61fa41fd2bb00eeb8b182e03e05fed0d63047 1f121a1695b39b438807592a0364e537459d9ecaedd7be6ecdb71b9534ef74a9 02849420f9ae2c064385bf53eb6a49ef1ced6fa4b2a386ccfbbc279633f3a4d7 4ae5357926a9a9e9204bc6f2c8d3c05bceffaded63d44c2e52792fbe87964b89 fbb4fa26dd9caef9daa40f9f451d01747fb79eb9bef92b680df1b0f52588fa04 0 db3689e1e4f5fca30daedd5849ec1b73262307ef350425bc1eb81e8fd3253d0542a82e5a208735388074d8552a5702d7b098f774c6a691cdae124433b792d30aba8eeffad30f9a461e0dd234a1fa9d7090bfdab4d9e1df0cda9ca105d1bf2e09b42ead55dbfd02e5229f75b6df5aa692867b518555adaccf3f5020f15fad6a0812609699dc2f4df2add0083066107269afa6087b0fa45029d151347113a1200e46d6f385ff2fee5a20908e89fb13a70dd626c674e5120d8f0bb3b92dae975702b1f9b998139e5e35f2e7960a6d54a89ac3ff95953179ecf910e35c5de012dc09671d4f91c3c87f9c6718fc94c46c23fbc28c6f6c658e29286f8685ee0350c208 +generate_ring_signature 5607d2ce8ec511c95bb7a1ea452f4574df04bd5bdbaeea20ac0e508f13feea37 66293e624f791235be8fcd3944938a213b1449de9b64b840f46ab25c244e2eb8 15 252083243400c45f44300a90a5a72cf124586df2fdd358c3f2d8a10a9d3b9f84 dbfc0f9a60359bdb13b1eeec597ce25a39019303f53e214106c1b6efa039f41b 1799c271c54721cb9b9aff31e770a27db2016d3462e8f7cdf97e58f5d957d1ea 0f3e0b58254ed1f16875206a5fa71d8b2bd3051cadd875a85c064fd43fe972a6 db61f4aaef31bec7a76142570228880bc1ba95aa3e130efb815c392daf1f648d 69a59d101b46108998f7147556e1a489d50a8de2822cc4b616fb316ba6308890 3216e6c0b89b0e9dc558f22b0646340901d4bff8dd6d0d37b428de10e1fb3d8f efad5c615373f47a5391c88bd7fd426915d61f772f8813fa1998007ee605b032 aad7a20871ffcf814a70a4964aadea64a2ca043ea3ed90c04bc0c581ace03197 ea57e5ceb849204391f7896c7cc93ac01645bb955a35e7295a6201d3888072b7 ef11e7753f6973b1f3c06b2b7dbc596db6f16120715339b17824086c12a18686 8a8442aa38bc171b5fede9ed5892c4c6f8b7834f6d84d6818134a2f61125f86a 12fded8c7ee0e7511d3f37d7fecb900ee662c3f7dc36756d64fd7bd5221ff607 97e073bf305e6e79f257fdeb5d5b126f12f818edbf3502a129a71948afe94933 71827fa61bc9bdf166378ae6e479ab50eff55f8498804bf26e92fce047f1a76e e1c93e67a747dff61c24a89817f62f6f84ebe585721cbb46d0139ff7d410250a 10 eb70bbebb7c2dc13930ecfce0dd9a4d2b4c74f76574705338969a4e4ab4705051ef9107d5bcf53105f1cc89db703b7df5b7b96a7555398ce95299984f8e0410891160f3e04a10e4bee31405e6a99df74e10e7fe4063341a18e8fda5661778d0023f90660195bb3b86785d4a94beef49ebd1a49b1b549ce87915a0068492b180f06db36de4acdbf2696657a50ca4426b27bea466933c69d7537433d35df494b0b6820e84113b53664c05b5f2d69daa2650f0a1f63222061b4fdd208b579e1700946def763f7f13d8db8cdfbdeb408cb1f0fff77c2bcc8f2a0368df913874dc4022093e14ec0f82db6c13359c2efd0eeadeff8c5c672fd9aec9788e128f50cb503b6b5e519d17cf3f1ce24dfec6ad48e7a41c0feb946db4f6619be90b1060f8f06a1023e4b078bf46a2de38b5e2bca1d3ab37a4a0e10511f4b047ab4d6325e850f219ea4d87ab278f7c515ccc5ffdc49b295a13d165d3aecad8f4e9cacb03e030659851e4ef8428e0b3d98ced0cb704d68c54bf8180ae23a57b24226176a7f3502f12f634bb8713b68b918e42f1ddb0825ce18d02667c0ae9cdacbb3d1aa7d4402bed6eab1643ea25c05a4a1255a82a14a9ca9c53affccb451c2d47287fa70150ac8ea9a7f034773310eec5906a2a15480e7d4dd96d2c99e9f9327fb41f66c020c9cd8e65314531fd4fdda191793862858d2ea8aecbe60542266cf361901b65a00beee47fa3f5733ad0b538bf3048421657e5fbb749797e8a1d14462ded9c4af0164e9fbf417f721d58546fb5d4cc467e2ec8d7d640d317a6d1d69dd76974ab8081c3f3b3069c9e1f9a37e5919aba6876cf6c7c8ad33e4b1e032504825dc65fb0d04a75968087cb27d7205e22571e2816daa33a89cd5417badfc7ecf25a0ae4503a1e2a7e33a2e0bc370ef04ca445cd0666c09e4f40e860897e05019ab97e51b0061470490899446d9eefe8378e0d29f5926e441a88b08377c4d3e879010ab080137fa124658a6e37654f4506f6f036b9ac0c85fba6cf2c8a9abab54aea1b2520077e10b3942d73cdcf93f0ed26cde6ec701f07640741b3852f1838fb6239fdc01cfb9159d012b4e3f3b6b92029ef20f0bb0f15fd8928f70ae480787306265a80d803778650be9ec7a6a014fa27b82a85773d13f1e6812880b94d208275009130681ee8a9ce27eae3aaad40c9d569b7f2a0d9eb70abf95bd6ebc6efffa4163a40c7a191e2830002210da48acf04436b2827d1c3b148f72534e6a9b1a24503a7a03cd10e88b2d88288d258e5db848276d3a1b19860dfd3243d97da2604e107fbe0086b6419af4ddb1ede8c35472b05174f643588b7a026f6489e7e724f964fbc70f +generate_ring_signature 781f7aae6916cb86442605ca1c1329f08692a28c5cdfe0cfa95d964ecbe6f9e7 dabd3b459a7ca4562fe5ca42191a402e51cdfe567079cffaf7ebe599459490c0 49 6d5bbeae1447773bb341d4f6253c84a563d776c81124bab9c82b8b55966ef9ee 5f3582036521d737a102ab0878f3482825882d869168795c8d29501d25741e71 52f9596059344eaf95f52e49d2ec46868c01a0612413866c50b351c5628fc8e6 57d139af17d71882f6a385f6a87caa657970517595baf226175248877f5ddff9 a9f4ebc8be21b9348b62361a712c90841c4ff4c595b36049efe2d101c4efd321 e8415eca3390ef846f46259c0e0fba6dd7427a7b5f1af4cbdae1cdd34abf7569 4f3e26a193a4cd0e338fe5ac6b4451217ff963c1ffc7ed2afb8c86d534b0bdcf 438597f124d1177200a93dfa9d8d0a9cbcceb2cbae2d93640147ff1eef7a2233 f5339ce166c0ceeb926acfe4a017911f9e1e3650e4eec6457e20cf52355ac4f4 4c59880049b15c24b6f54586a69b8935b5d8893a7dafa1550c5123cf0a253cdb 18a2d68bcf6db85d092a4362767cffbc973fdeb9eaff23d260c78777f8f57681 0d45035f8548a968acc0b0815518ea3024360446580b0e5878d75b0610911340 724763763a18220ca705b3221d8ee2231cce67235d0a75ddf076e8ad5523cf60 65236dfaaf133b1dce26fb478a81305bab5dd30e426ada4a399e29a7c02ba4ca eb7717bf4521a54e02db70fcb96c20d9d4d6673378f6b2c196bfc22a3d5dffe0 6752e1853091c6b4aa5f88df39696cdf2b7ab14d3e4b140d1c3905a6f86766a9 ffaf2190b741ec45ad0bb7070e66235764c44449ab408c6769eff87ee92df421 9a3fa68c3398397d68f7eac4a19e7235bd4256243bf8667082c4bf5bbc06b386 c0cbfc6b9c6b2e6c7c696cd7a89e4c79c7dcbb394199494981a6342fcffdea0e 661f99232ae0a6143a994c679146f2756cb4dcc6c465145b05d7bcf57aebaace bcd4b4ba71a309874300bbc35f9a9a541a7ee8055f798a4ca4dc546ab021f25a 8937c53d0262f927ef14ae7dda2cbd277363612e98669e58604547676a862af7 bf01ff591c0a495d7938ee4e3aefb0e20b121823451b1d902dfb8f2b460aabd4 6e0d51f94745295a30af485bbd46ef078fc52172f142f1f73e68d5d0d9ab1222 36fd64b91f05287e299200deb9fb4cb0e3de6f0240e2dbf274912579a8a75eac e72d9f05f370aac2cc5e0777bad931d6e4e193179e822583f02983f8c6bb54b7 d589025c70a128d8fd4b6364ada77612879a039ff49a61b710ea5ba856eb4cde 78c4e48f85675999752f7e6114460354ef4615e3ec05d2f6f96b85a0feb2093e 50f02e55a8df0e9bf0c44c66403ac989c630d21c2389ae73f3413f1d07f8fd2f 9d4879da832b2027ebd9dfe0d5d361a4dbf32158d039d6951d20d353d0129c6d 9e5f72821c4ac472b040e19d85234f46aca39613013ac66788c3143eff365d85 9d1d9d4be6eb21f591cef27b387545a22dfa1882a7dcb30fd5f2141b398fd2e9 35147ca542ae0c529dc9818dd8e4bcdc300a867254b9dd0317bf74a860a66817 17c55d7febc20cff8ad649ba7ae32318cac1750da6b4ec47c31c0f49ee1643f1 f24f5e7d6a9a0e9c457a0ebec586b4bb0a3a5564559cbf377138f64562df2484 952e0f4633631f3eb0135819fdb7aae7742ac5b2024c5f15ca1cc65e1cd08f24 7b9adc5c33bcd0feca677012599cd9a7fad17de30a30efc0981029e15c4fafbf 11e437c3869f6f8d822ee753c68b860560480a37eb57706082d076e0f601e54d 7b89c9df6a8a9f261d298a996c3a1947a6f676c2c7be4ae7643c2ac5d8e89c62 ff3e6f71a711fb28a24a2ea10170ec29d4fc3f3e2f2de6a8698783b0664d941a 919436ecb0dd620ea94686ac3fa07bc17a777d48f9c0224dde1703d7a2ebac63 7088fc87666f3a284b325d1a50ef179e47ce44f546bee688bbee3377b5462e3b c4bf7d3009908f391b0a36d2768394e429a4afb69d789d64bbf1377402f39b01 5626037572ef6d5c06636c8d2c7a56e19e4eaf2bfd6229204d4a60157b7c3d9e 94c3d100bdf06065c3d6c21e4d743d925065888271afb52777926c1bb49698d1 45591bae02bab2a3b21a83305a149c0f1ad63d16f23501ac471fc5195eb4c934 fe5634f879e4007ac0ffe322a23d96d428ad09df6eafd123e67009c77d3826a7 e131ff9519e778753cbb08ea67fad0bf1349f8bcdd3e2a9e30556d11ead0dd5b eaccdcec9531361e1b4559e4a9ee176075cc22a6770864c21abab1a28fa062e9 b6b0a5cb6c1acf7b032fe3401997b9be29ae854fa7d6c1dff8228a85426e8e05 35 93c3888f5366b3811eb99c12e48d75e5b156496deeb9179f95323f8fd54bf502a5c60f24e64f68346109398cac87dc824eee4f2f79c8c585a641eecd2d492a0f798aefe426c3277267e976dc9053e06c8ffa0b3651b028d3b8a938fee636760781eac9a87abc390e1e52051d6293f033a95776710b6d964678a26ca53e31f304767c0a5bc38a4fe74bb2e893d0b2818d2520b6f5ca03d98b1e5a0f9caaf23f0117ab67e80ac2f8e5ed463c178e477c31d5ba7747747ea929d4404eae1fe62502d5916bd01e4b433ca555a00191c7ee98a6ab4876e3fb756abf89cafc4c6e2d0965de89a8353e82d8a6c7e71e80bb9152f854824f046823d22a4afdbcc3bdae0c8832138fd3bcbe238d21ed29318ecbc9db1934de24a8449f683cb97bfc7615004a7ed4f1adb76ffe520e2f65242ba6430e12eff1e3ba757e96e34d38eed6bb076ccd96cbcda1f3a440054c95fcbe1d0057feb0b1f0231923a0690000f34a270628ab24614d456e73ebc344324043972eccc9cafbd1587e92a02a61597194750524ac9b889fdcb444a7233e941fd064d732010adcfa8f0cd561f71113a1efc80ce17a4dd4bc829f4574c047bc44451920b5d9c33a2f91b1ef0a8f8f9ee8820d0a0c7e8de67f781f350ccbeb33fbf38f868c7662daa154d48f782a154470bdfe03a19b9f56409bc2698b8feff1f5c42a4cff69680d5a46d54d7d4c646447b46c09badf1bb306eac33d4e634576b14dadb4d508238ccf9047e1b40bcfafa63bd40876231ebcea85f49d45da626c4abab62537541c69671ff5753093ef691fdb3701f51ef9098ce1ffefda2b13d030ef561bd7ec6674dabe8b4e99e51f2cf323460f920b46cf82aaf32072accd7c4a8b1ee4704b790d9e3de093345d1765fcc8c000bf53e301d9d034d3509d81158eb5d8a4fafe5f70ced208dcf99481b74f0c5f0a08a8748de728d70759e779e1c63941ba6ecb44c1db1bc8da958430c0380875071326284e65a1e7c782a11648e2592ca7888feebb0a82cfa56bd1e394adc9350f7ec897707cb8dfffa8c355680b951ab1acaaf3e5ad8b95c32a4f0482687c8604b2da1852c6d25fdbe7729f64ec4d14056f616882f4735456980494378673610d69943f0b071d86599b8c3d2ce96657b8b3278a5d12d318fb2a80d057f77529007cb74baa9d88e8192be73af2dc9efebcb2aecfe5a25b8fde39ad0b98e448f404ac9b7491f105803d80680c04626db1c2cbff3d62e01640b2e2ce9bf9bc01c206b0446df64d8e0d6c7658133b23f7176d44cec7db3b07254d87c5743e40fc6e037db751b6862775844a80e90f44db96a49c9d9915bd3c4b73673f5c29471b140aab6e2405cea4d49eb47a379b14578b8524d36e9c2af97a9bf6471552fd83cd0eca669a6fbe1ef0e95059fe11630e6fd50211fee54d228f96a06a395c0ea7da0d6fd3258e34f9bbb22c0575dc1cadb272d30ae02464209a1a7d16d3982483770c46b1774e6386cfabf6c5f15aa41b58cb2f4cee2c6ee1163baf1737ffae792f08644fcdbd8b95b45e742693863e1c8c7572d4b4e323f80ae277ddd94da8e2020b1dfbe0b5caac2264677be7df5ee2f4c736903f37a51d9a8d29ca37223152a80edfa4b3de549d9ad1ab986bfbdb5199119027194129aa4b1105615288f05ce2042ab777b86e21d47612d176ef0c2e552e1b1bee9658f317724a7fddf56b8512018f7c0e7c3c2c0854f31a28c66f58c3daee5335787532d7ef973d7bfeb27a0d00c537a687a5b151e8fe027299498fe368f52f74d55984681c7863e9d3930be402d119a3a0d9d1a0e821efd46208918a8fbeb78fb15e902f858945f45748707a0685c41925e8d405d63a2bc10cba9ac882bbb14264edbd34fc0c66d42eaf63ab065c8f157fc8d58409be865a9407a453b0b46521a3dfd9ecc893895c4b597b8a076fce918ffccc50e0d75b163cc2c01cbd0d98ea1b9af7cf49044aee271f7fd10ec964cde6b3f902fba7bb442b693c8014dc40097b64476984d8ddc13ad2dfd506c21993e99f3d298830ccb988a73c445f77dc3d50bcc8f3d374d1e4e46799b30a94483923106db9296aaa47f8ef757331b229b37650c9a04569828bc8ada3440cc7eeb92090c9dec8396bfe4d86c0a54e810d3592796728c7f62555c27b8cf407cbb0e4b833363254c20275b548cb4ea414885c00c3e8019e0d31cbaff384310f727796387be295a439bca86a413a35a2e89eaa356d763bbb0cb38b8c24553b03cc1db55c9fa81ed1302cb0a6eefb8b1b4796ff3c536f372b7dae79760145f90e7501ee1fd011347f05080c8aed0d16ebbc99740472186ca262734fb606fa2e0ec1376657b8a17bcc3d35c29319c4bd01f901e34350b41e9914fb1174f6c40d0a5dce7d5c797ad8de98de8088b96107850d3e0b244b4352962e1a8cf05a696a03e25cc2a8768eaf6f13b0dd75c0bfb0f5925c8b71c429c550b7a5c5936207e406dac01fe56acbdb47fac950449cafbaffbd29d03ae29fa193f542c5739f0de3096b03906822954117a64d8c73fb9b3e111fec9b20e39413820387249fb6f2ec03d5383c9f1843b84e276216d91abedde856a2e25a0c5fd0672bc290a5347a8d0210359a34caa1679308378eb7dcc060fb82020d680a29aeaf59ee454527d8520eae56ffdef605df2448830da33474ab9de5bb03520ee53202efb0d7f143dbcd0299fb11fa7a22696e9d74c38c083ec14ebfe926cdbae09e30c8353ed325290d05e7751c0b2938f4cb38d7941f1ad88873e2d38a724c0900972128a250ba15ae095553ade49b7f603ddc98e6010df032dc085126128ad310c3e36bcb86e345d00f5c27fb2ba230cc6b54156f52b2576f0c9859dad33a117d14f92306392b4ad502b950c585aa48794fc99dae2ebb5d16aa0c09dc6b56db16f43099d1ca53ebb20dfb715c570ae7299698d610051d6f4a9705ff8449483f74a08bbc9af06a3336024e5c0dda5478345c3513d1f3be09df2b2332e0ca14dbf93ba4061d3a4e6da802a818719173f70e47438f8ef121b82bc43d3d9ed3c0534c40c1abae7c2d83ef066a36c5740c0066b3987d35893601072fee0ab5683fe7441343546fecbab19c070763a3e8401e3f56949b1f9c56cefb19a0221814902e9eace4e34ab0acf7c50b0e9472042ab13daeab0eb360135e0e9c778f240acd343da06570f4f4ce4ee80d363f695bb44b06d80070d48461e19108633b69c38b4fb706861f6b77da5ab003ebfa10791fc429622515d376eba355837f8a29144bbe164efb6d4302ee05cf0b2dc576f8be029f89a6ae804b7ca2b18c6d1e19c9447a8d328ce248b6b5270c0411d1685707a5f2deb12dc88d20eda06b4bafbf129c6c172795627286940ff80ce4c8f31a0780981d13ba77b8308fad2ec8f9af4ebe06ed44f60cd3e6355d4d066cd8fc14b9144f9d9c211b11129d1adbd2e292f66816f42b40bc1910eb13860e3efa5543277fecdc41cc4ccec5497f02359a97757e624eecf9ca089da69bb30da173e24591756d644697a1af48955f0c6f921f018a5155873077fcaad53cd20664376a43d9ea5cce11f0a1c0a2587202ecb324923e21bb24f2c9f5e777b97d0ff2e6dbe54674cefe7978de834709d43dc818f74b079c1e9e8519d6b5dbff1e034e36003f9aa537fd32f03ff521dbfc00d09c93663ba664e5ba17eae9c227ca07bf52dddc20c5fd3c002c3676cc717596badbee0cca2aead81dd5fe619f5b4d06ebad8ca85b21b00c1fdfb8517828c94ec177fd780d7be7482abf830b3645e40e2f84b284f810757da394d38324945fe6a25aca815cd09f8039678a4c22cd450b48cd382ef8d822fc55085a36de2b4557c6c5449006d2d967c2c3cdb125165f038b9e012dd1fd126cc1c018b1f97513edc43f1ccfed8fca686f21eb29173dc4017649f391480046753b7dde1b4a063125a0c5c0b05799a16080990d6fe995ab027028efd492c31b5f535f8a616b10d3e7f21acce57283f0c933f0d22e1467d6033f35e4a120bce8b7d0df6fa720de2e7e77214b8cd0a3219c293e544b63641d07385c1755dc6bd0e8f59f209044b41f5913abe05d9f81f86a0ed46a1bba47a10c90218ede046894bb9a2aac3883f83bde00d3b75b5c0225c87e4e9b8188b8930464010272bc7e42c6b9f4269d2d1c0557259da69eccf1dd388c11fb9b7b2c840ba6423c9dcaece7b50be0ef9b76fa5f7835cdb2b37b05fb158e3ede5368b1150749d8ced081a22afb66e2e6498af7649644517d2ba0c06332f98b7c68ad7bd707ae4f821c55cded10ebc20f1b2f07542c7c548495ada0cd5dc6a35a176366320cbcce9d9dc58be36728bfd8d9edab17d16b4a812a71b24658a4089edbfd3e2d0415944eba3b72d613ae0378a2033d967d66bec1c484628e9a74f37879d1944505 +generate_ring_signature 0ca6be8442f73c39adb0992700397888777437a7de0da8c8f80ac7397c51f46b c2483ecf2cb22c97aed88f73d621ddeb6f26c3417ed263dc17a486ff77274806 1 03b86aade5f2eb2b8868d951161eda03d4a47efe945a9dff7d630de9089a94f2 ef2190e473cce3732bb33ea3a62a4d8172a78336453c32f4419d1437ad3e950e 0 c1f782ba4f341d60d220f9b5e0ca9caabd2e5695647d3d37a3816d0faef8d108c154a4863e0dc093d51fa0b19be6a79004cbd7ce29c4d97bfcc0cb4a1e8e3a0b +generate_ring_signature 79c5aa9e030b432d9269f7e35bb8c1ed8eca493372526a02ea1d6ebcfa52b385 9b9a27939cd35b70d56eefed6bf3473df1bf5e1cf3ebaf7de8ea58ef212170fc 16 1e6c15fded661246e31217f773daa1c73c6b5a535dd39cdeece6347aa89981ed a2dac02c4e2ecf3f06cf95a267f7e1db2bc014bfde9b8d5e4698279429848a43 ca579ff489a24164edf6a84c9bdc87374b47efd80c3f994184b770fcce575296 2e247431d695436c7107a280e966eaaaa4d90440d824f93d1c96ae49bc16d4d9 f2609d17a8633257d1cdfbae1690892339e49f9a46eefa9e7b97d5b0570f9cf1 bdca7e43816c3c6fd0013557b1e0f2dce14ead44b6ceaa381986cf6c3055adbe de1b17fe16b510a67e0fc049a5cf4f801a9d9550e7ab8a5e4f74ada85a4057b4 2e9281c688bb6d020dd8a4079acab780a40329c6c54e1947f0e0e7d90b614aea 51dc71ffbdba2913ec8e578384e4d25fd2bed760dda9649155d4ef3f49898c63 88d6f98dd9e6c2a990aa0120152a372da00c455c97b22767803121f55b9d3433 6ce4fc262a6b4837e5f7baea0a512112a2d72dc6d36570cae857511197eee9d0 ddf3cf1ccbed6da657be10b878abde58598a07eb6be65cb870978429bd6550f3 5469427cb812861380add098f93b02d766d7b9de7b5c34d17bf8b2105bb99cc8 ae7c7772243d1b1a0939390bf562946634fb8f3a3df045c15f622aec4a19b05c 62f43f2a86d3cc9a59a82ce2c087c9442c8f0de3d648e319793e8c7ae4158735 1fa26c1a7685ce10b3734969ee68b9d8f441b0ff1beeda2a6a5ce41d7857727a 7f846dc0a1378202cd26c66f6d80322192979c9191c9bad913accbe8f3b4030f 7 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 +generate_ring_signature 80e43999bc762b25fa9d83c6fd111032ce5582d573d6f0f3e82e0f989fb6b8cb 1437aa8974c08719cc58a5334921c3201e9f45a5290f2581b26345a659b86475 17 40584e3d53899817ece3a763d73fbd5d5a09cd75ff713d3e06c3eba2fc853319 e4b87de4b1b936bf74e0bf1aef738e47297e65f2df50c566a9d5177c75917534 98449fead3b69ec5ab2d9f524ce8aa5e6d84f14917b3b03575aad4d4c291a634 23619e368d268b186bef7a5fa0165c31ad8a3bf4b0220bc262f484067d9ad4c7 06268863803442caa2e603b4791a097a8f33c45683ef55befb3c0d7e3055c36a 61ae5b158be8ad2e489dd7b0b78da17166a97f09629f96342e8712788c1dfc0b 4852fd68ec5cd1231f48b79a8bca21277e347d39af3349bce848312452874d59 5446a777840c6f3f75aaf437d1f84addbd22b5d5c848ffc3b7fe16e1157e4819 29984210fb9b7462a3cc598bfcfaed8a0d704d02851f1ea7d3e7e3cb8d73d3fe 93d4243ca3db959b7f3d7af72a0bc85e27226d1c716dcbe1c5b3743ef5c289ff 7efab8e221de5b67335eb804564b60b5be37ea20497329bceae89822d9e530fa fa084a1bf2c317822a31681302722b4a8001fa2aa9a0190e45b68346298b9aa7 bc15f7855be9e63f35567ed80b629c270a1cb1de56ed670714645261edd0acb9 17749387d62c8c3f725f1acd5b44c955bd4b35ece33bb5b3fb121ae52dd07750 7b83783748d179d74bf5f8a177a8e400ff4783ba1a24b7966d99b587f6e4210f 235b414cf437b43c611267566496a834045ba01b3f16c7b83a838aedb35e5863 0e326a30399705ca5c7fc10ba5f072fe06656388cbbf8f2417032c6d3e1f1519 0be7d9b1884397738bd4495a62ef77233f1b262363539f6bc3834b3430c84408 2 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 +generate_ring_signature a1cae1149c356e23100ecd1987c21504dfd7eb93e828bd3e67010b2618b67d12 41ef904648e97ded7bb6cdb675c0eb7c3e265920e0ed3a43f6d9d52b9cac4950 4 8af0cd069e8ed1cd5b5210d4f3b1234fba3701a51f71223a642afc1ab7c2ccf8 68a106230168fb6b767c70b9bc50adae625609a4deaa23607eb431a125d62acd 7f77b78b984a927a28d64f19feb63bab35f545c419003dc6804fcbbd0a6a7d89 02e2ec9fbcd3da1d36c4426320a0ae5dded7b03e360e801c842d6da1479119fe 9bc45f2111dce6e47ce84bce74bdb15374994ccfdcc33c497c8c6d02621cc402 2 156843c218f3860a2769c3464e5053d2664fb392d5351306d09aa7cfeb206e0e4f4ad7d4bef3823a354070e62040ef3ac0b7d86be55d5b933679e736429a3009ab5793bba0a835d02b34d01fd957c9c43c6093452473eb206a3ab5f024fb9804f07365c0251c9c2e0071105902d7a75302937fec8dbbbb99de36294c7a43df076dbaca74d71583232392c221d96262552781c1777e886394ceb3e35e7fa58c0f7c4f1df0b90252dcc5b18f31cce4a8c9a51a7454f740911e3b110be4bcfb380e378645af31d907fb7bf01ab538619589b7ee188ec735927b77c95dcf54252903d75b00caa3c6ffdecafd83553c69ae23a27add068b6627be48b2207b72836a09 +generate_ring_signature a4a40107ca42f136d1a311b9dba01b70ab6e9b488c9d4bb1f82137a8de045b0a afaa82207be08f51be6d9e58d2029c812fca1215e9a4c9ce7614fa9b1ead0e33 1 21eb68d3bc8a11f481c4dd1aa33a7eb137bc0266faa99ad02035de1940e96ba9 4fbd33282caac0fb0207af80c006ae9da1993618bf7f2eff764426fd0fe7f204 0 c776d9fd947af4adf0b26a6d79bd13db8f5d5e99f907bad4a5d5bb4835e2850c74b54d432f6c7ec4290c92621e3944c49e0326df1c17b00e7b4672352623c406 +generate_ring_signature 856142e92819b975d12e0fe26c75ae88da078d345246b985f3d2ee7b2c2f7c5f a7869efbf3517f7b3217cc10c8d34aa79dffcbcc332863aeb9dab30c14f2c216 4 c2fe2e312d4d1b483105304f0790bd832bc2bb194157b215d265ff8f1fe5688b b6db213bdac6431e7a58bcd7bcad322ac7dc04a2ac609b2e2c1942aaa2acbe7b a9a365b5196b89e4ead8efe752dec4900446c49a93fcaf75c6e01d6155adaab7 ecbc8dbe05d49b8c9ab8538a959747d3c965abe9bcdb090829e109aa9af410bc 4ab503c0deb81e5867cb8acfe683c713eecdeb27bb51b5cabe78fc3d287ad507 3 7b5a58320ae655b07094aac9330722109c0426f447e1be423e6bd617870dd70241375c864bcbbd336a207d6957abfb655a767e3f20635146560c97f2a3b2340ac91510e5a98ac51e9cfe14a78023dcccffb780a60f5f040bc7e8a6cdbad395054d68c25752b29c858f5f67b5ce2880fa150b3633a58bf9461b7de01cab220e02fe5cdd8ff75ed67b718486e0a3406045f890854f652adabc70cb1e166430f90b91ba02283279d577fb16a183a7f843d53ce20ae8325837f8a93114a260e97b0383325acd1bc9bdd2760fd9ca0baac82f7fec59bb3268a14e3b1c1bf0ed04640ead596f59f97992e63d6455a5e4eed92043bd71af938b640af6c68b0ba1c81800 +generate_ring_signature d43a0443d5c3325225fa5986febb44adbda0422c3198fefc5c6f004c12eac890 48a03abbc676e7c1e6595e7871d3e47c65756783745b6c83beb3966c83b24426 7 54c73df736d858d956c6ecc78f71bfa621f1668529798aae794a2ebcc0cfe8a3 48f1b704c8549362e4bd701890d49bbc96f029f5b51740cd9af23be3c8e330f8 34d8123aa5765ff6fab0fc962b525c8ae0bce152a59c8336155f62b5f8261ca3 82f6e242df725fa43241d94c88c371eff160c9bca40e27c1ccdfd5465f8d1195 75ea08cb3c88c0dff75d744fe587524a5b3cb012c2f4e7299673dd24a07cd85d 8a3935e33e50f5f9ff79a529f18ed5c88340893bb688622625bf7007e15d5fe5 3261bc8eac8e3f468997a2bcded49c910fdf5b97056bdb5e81535665a23cd13f 55cd53ed388daa9179037a611a241494ad182883ba0fa337a9d6608a6f554309 2 11be034c9a2239d491decfecd34352b7fb370cd2c793302e7e096816cd75b705de97e726a7b1705bcdf6570b51f57f057c0e7c0d726982743626821a5e13d90c6781536d18d4d951ef72057e33ef5630bfcd0ebb97c1411be638b8334e8fae027257dbac258eeceb8b9ac2af58e078cf9de5511cf879346eec992afec6aa100867a6d841dcdd1bee994d7d46e0f12ce84cf3cc4d96c0e022d6fe920e456b640408b30f1754c6ddbaf25c07b53461f1389500b7f9e6a6804065bd8b705683970abe2decff602b629e74ef51d3d320fdc749cc6a69bc0bbd36107a0181fff7400cd0e9372d7b1fda95ca7034d86e2a8089f9b4efb2c46603257d238cf1131edc01c26a988bd80f5761da723ef71f5bfcf62a988cd82f131b83afb41f9575c1f50169c6a5dbf382e308388837ff6e5c69c8b34ecff7cc73b3bf0e37cd256791a505d57b8785b35f5bd1a61a012f883f6b540bba2a966ef744f86749fcfa6dd0b40f4b0c56638659e2d442342a9871147e29c6a819905d8ed723af3563aec2a7c3013190a442ef1c539bae09bfa5db942ab699ab06ee670afdd882ef9961058ebd0a5098a7f0c4764ebce980a6f13dadb1fffb8960db99a0d02a21d1f6ad967c1a08 +generate_ring_signature b2a6d43314f32e184b6224f1d237368213d205e110a06eab248d8ce14dc66b35 589f05748c0e2fe74f2d93e8bf91c6dd062456acad1a8c440151142a36e37366 5 d1015e1ee08e69977d25d7e23692136b840a702afaa2ca04c7a1ff3d844ebcd8 bbde63dda3a37b486f0f12757b2e5a560d47a041f4bbba732ecf55846ef97288 839a000be768e6908d46ee701b19eebc912e346f98cc523c2d8ae63caf9c6c57 10191593db747ecf070bf88ee12a5f8c16f8ef506c6f5caac4fc0e0d0dd2b6d3 446c82636100dabcd3fd93bd36eecd42dc10ded9be9b37fd1c868ded993a8bd0 c188a0b57f2c52f5ab7ad0e98f85d05d317a631d20a45f2ff8d65e4dd9d00f09 4 b0a6293bea8e9755d2960748bc6dfdf76495ac6de8d8b0bd6d0d5d7d96b2ae0cb0ce07dbc3621f08fbc32281a54e8dc5767dd64d2a0187f5afc87c8981a3480b424f9107e16e479846332f28be65e107e567ec9606542d0b42fc3b2da81b6c0280d8c2a6ef162dc3dccec0e3fbe863306160a7d2212094c9e5e734cf694b6608500ce607c79c51770432541141d5d62ae15fb0a2b5ea912b14e825b225a43302de6b5178edc9b45ba932a84358fa0becdb5efc3b93bb82ed6cbb80e18a3eab0cfd4d9ff774895fe4fa667910fb72ed966103114b8dbc10bf3c38433332c51f050edd1ca753b6d66c6682ee8a81b585c6d861836475aa2f55d817143049723b0aeb09c07f3120d59dae206e474dd9b88a84be8e3672dbc9dade795166988bf40e6e69514a71b3b617d5e742142debcaa94452f054291b1d0646ac9a3f0e4de30e +generate_ring_signature 2cc6d7e8e09924db18a5cb8454d9d4651e68b7c40c10f2124c4178819c166731 8a63ba236ee52e329eb0cec80e8281fec17a4553aacee39d386e7023e8c49f1f 211 402a41ca99cd815d081c2481ea92da40524a3c0d1115380d080643fa3d9b0261 c643929caa547433cd00d1e0cd02b77e37f5de0bd28fd21018040431e47ceac9 989a1efbfa052314e3f222b0d6a1870ad23a7759208790c4fe0dfe84f9a682dd 28478f7385c01c31b55f667e04f71eaafc7615d65f818155e4da35a160cc4d85 94a4beeecbef6b573e9fd9b3e959fe53b47de4d0da7b9030066e8ffbb31357da 090eb96dfb16bdeed9a02046eff14c0b3da54c8d93d4708d336ad86355ba116f 7b77baa8eac66b27d8c3a7b0156fcd94d958be2551351438d075b91b63c33a53 a58ed775d98bc67e07945599536d3d2b4cc06cc37e4f230396218bfae0fb1c44 29320ad589c514098a8ec72b9349f0940737f2bfa36e9330f2d42c00a0120386 3a9a27201c7bb4bccef5dc6806d040c30a8230d34eec0d685a6c4e40751f49a0 13f2730c4bf1c2b5a9d35cbefc51d4f74de8ca3271033c7c4a9d0944dde08c1f 73872a978fb3ec59c4f7f86f5c008cd9ee9f54736b180ec968930983176bb464 a657bf78310f970b68ee552e2bda5ebe5da601b5245d2454a30c0c276ec18efc 5ec07e85ab34bcac5d5172a700868c29b9ccbfaad9858276df0f2eb75e142996 9af36317b0c92e94bf9f88b3cb32eac5e2022d67c5843fd761328eb8d2f85783 65631374959a3b4b0fa5538d510a13edd1f616c1a7b304f1916004695dea5eb2 3ec33d71054ad6db9e4c10680d2dd4dccaa408e8796ad3f04f63e6fb6c9436c5 eb7fcde5107a6e168a6bc7bfd51604c60aacf0ffbc41c4ee9f004eec92a441d5 4d6264610c118362726519f09cc02b1dadc926ad5d3a1d334d3203c42a7eaa9f 0053001c4a77bbf3aebd3956aac9b8420bc67d84947128c32d651d78634f2890 98c403100bc3d1135388a8899718c67ae72d86fbe32bf4ad6430eb0e5a871f59 1f0f066060620f72fc27072fb04d111d7890db94da780753c565114b28fc61d6 c7bc71f7658a142c8c2f32112d5f2fa2bda5140632b577c4ded16dc0e0324bc0 e1d43f558301785c73f060139a114b59ba8260645d3a42256fa1554b50d7d1e2 92b26634220d7b331cf050d947fc8610d91f129412b01c29969001e7eaa9b770 a6db9435005617130ddcfbacd5f432cd688054c7bbd5d6c74e35a6b87b36fcbb 8fab60e3f2b22ee77a896e2f244f683e0215baa6c22124227548473e8226ea42 231600af4603f92dceee9d17187e0218993f6f60a91205a361a63a1edd23f31d 41065d0f4a7c7bc1e0e1921ae8db77c6e8bc58ed6eea0cfcbcd8ed75b7a657e9 83db2a59e355af551f2385866b1479993bbf3297877032f14a53893db3c0eacc 1f286383aa01569fb3cee63a35dd32f41c575261cb68afbbb832b3c4eb9135d8 14157b52262d16b5b2b03e0bfb051211b111776d2a777872dfae2a1f3dfbf780 8b499e0ded8c18e93b012b857352ca03f7c53d19a7b662b45bd6f0ce0fea230f be7c42646fbf9d17dc2c09924595162813a1cd92b41ca029465240f105ff498d 5bcc54cfc168b31f99d15c2e23cbbb33889107430b86dbedae47393121c7e575 9115043833cbe33d775d09472a193354f00cca070b86e2f2c55a3c587ecdefaf 62dae9a21077417d38636f9766d2b23e8f31c11d371b941600a68123a0e5852b 2f880dd8a7785fb4f6584ca858b7a9df171393eb1dbb997e049c3c74bd5c28ad 36f51e55611ed2b0ad671bc3b5a67dc32e9424baa52b7dcfa886fd16e32a4a92 cb88c24731f1c01341bb16711cccf0262711c5d538b5ee3d91e618a0aa94ae57 774ee3b25c731b1563ab1a4023808d1083f4d019438eae312a071e0963320b73 80f340dcd9f0edfa672adf1028fbe5e7933a5f412609062951c9c13984477c1f 846e5bb742c7d2c5e540a41b112dc6743c145a76dac105de39dfec0c03804934 6c3731202f8f8da0d540616f32fb1261187b0d5dbb8f4f86e36324adb50379c6 304c36bc24065978e078b24b16bf8811bece463f53926d8bf4cf14141a8accae 6e39e3ac724c929ed1fe8d2a1bba08b81b757f32ee119a07f8feb66c990cb484 2fe3718912375419fde8d55acc1e9f7ae8f3e8e4f7e8c253f180967ce9f6e277 1422514f9fd55ec628162935e2736205f7b19562e10f09a24b671fd3d363e807 ba7c20056d4c14ffd0f93dda7c39233f2b9f005dcff265a9ec774d54a16f21c6 4e024cfd9598522249b0940e0a532f8a2e460a06db24702c8503a7b88d8ba9a4 8bb41c4698f0c4e1afe52d5110012d704e063471ae568e4ec407fd6a7f97f179 1e5665d9af4551c32f5b41cb376f6ec70dea9a3b7c8568a8ce24c525ab1cc65b bd2af664fa7374d46ed3a2d6de4295b2b6d6d241af3df086abe5b9ee7765c8bf b598e6304c34c0a3158998db4877c8025e27de6ea53305f445f774a7235c60b2 7817004add781de4c2bb6afdcbcc88165a8620994a27e96e822c8b599cf9181d 402afa1c572a3e19f68ec8dd5c3f2ad4af9ec3dd0685019da41b208fe624dfd4 e1ff43e5787e2832904d4f55ccc3f24a896a673b5841cfb82590ca8889074818 2b8afb146c7f80094e3201010ff0f6c0503d4c916219e7f08523b6eaabac0627 671fac59f003840250f4070a05f89d73abbfefa4f105bfd8f85f377db6409f70 bd10a4554ebcf405fad8a7371ea2aff0589d0c554e83dda524a04663a7d3d694 81c03045a55f1c812b2280e0cb4fb6e122466d47ec60e10975eca58ab9a13d1b 1b3dae6b495af9875c3705bf1ea6695e7bdaf39c20947e061eaeb820026e9920 d89c734cb3226910d0ce056da4cae31648f5f7689f4879cb440afe2b783cc92d dfe58bd956769ab6129bc2966895f3eecf98d596a15b90dce4d41fda89f51908 90b7690e81a72de5b64b94be37faf4cf2e053c0560786cd3832ac0a887b6c2a0 97f5440f4fd3fe8928b1da92089fa2f2a2cfa22ee836e84bfe6f0f0ac2c0b639 78733374ee6577eb4aa1fe1dbe30fc49a26ca6709515f9fb9ca30ecec256e525 0cc4bceca6c04f76c8cb0579cf41869b523ed6dcbd0a7cca939040b113c5ecb1 a77eb08d2f61991f1c5d2d5c17ecff62b6f355f2c184586458aaf6f8fe1b0c47 e904d9ccc3b5d0727786b623997e85477572f374a157dea7a2ec15ac0b8cbd5b 529a15c0030b5ef91a2b172d050ee093b6a008726a5f30b4ada8e51272c89e61 e484b6e14d164bde5bdf5e11ea0360f4b3751add6dcb86e0609060903db9508c 678782c7d1fec628538b8bb22e04867e1cd37b82fc3bd27af6376049edd52027 7b75224203be14b0d9648feb66944b90a538a38977dc9def8515fae3d3b65446 471cfb7f41e6716e40f1e43fd3bf60619bb61cfe9647bae7bdcf159c6c011b6f 9a9abab7e9ba931b3e07d8b5f2a6b367e83b7fd27b876efdc15ab64c56bb3e99 3907d8e20f2cbdcb064d0f0b5a9cc39869aca703fea645e487ae7569fca87229 46a2823791014ddc54c9d56e45f469871e4f14f33443f7dc337d5910beb1aa19 b30317411d74a37484df3768877d0e92b5522e5622cdeb19db037688633a764c d63f7433d699967d4dea7f0353aa6d83a1db6688bcf05eac535d806f2861136b 05e06df4e9ab60de679307e3b12231ef37c0a7e8bdcdbeb792a140e0236486ad 543583fa163484a44a43267e2ba34db90e9ed2cc570b7a25c0e45b22b9ca1eac ca42a5c54f83e796076e644a436af8565132ddc1d075b95ed355c7f2b0b556b3 f3f5efe8d35449192c8795d2cb1059b720d0e1044a3ca69b1f57962fc819d56a 89bfa2c9258aa739d4fdbc65fd3b6f0a544d9cf4b22de25be25b036e9d9ab2a2 092f55c0c3bc3a275c4ac457c0b15d676c8d5b2a072472b624f1874fbef6c372 11595707e8ea5783c592db350724d7463f8cc141fcbc60a9863ff890d783131e a381570de73bc10fb7f4b4ea3876d21bde840c0cd5aaed2c2521cebbff77d258 c629d6bfd1ea0dcdd46444c5a560a4f386735c7e1dfba644e119da62637e6edf 4605ed8bc6ad9c8734a4f9fa61964edb5b73f1746b568a3525b088b7e4e28738 d2bd09313210ff4eb285b2c1171af27b1f7d3a14cdd78da5d36d5df33821097e ddecb9ee20cc01e3e00884943e5b284088589501ac73c033648430b6403bb0bd f983fa409d58a694b709658f79f488051a5a3627a1f5d3d8ab4f29b88ec85591 11b78bd153835d415546c093859342a069c2f9179fd77487ddd724441f8a1d00 a1be919083bb6e1f0e9ec941588f3ff0cc80bef966f32c1e57fe51f9d740ece1 c5c5a8d4f9a3c212c8ab2cb9bea0fe4a2d1b28ef78d0d92948ae2bc58d879924 2ba7ee31adfff772224a6915cc1026733d9750ed78b0a6003090d01b5e4800c7 f31856d475a6d9e542a8c52940e65ae76aaf239c58c7af445011118479ba2e97 d8ee080399b781b97e9e320be1efed8826ab3332ccdac22c412b96b587e49f3e 046b156f6016b3e8c4e28ec46e6a894a14bd085fb98d272f954646aa6a68cd8f 67da4100ca141d0b335ce9aa673c8ccb1c241d54e8e2d33cefd70fceb5b1d25f 93bf5b1c7a6ea142589637ede192df057328a7ff99325e8d143f5933e0e8d094 2013b7002841ce5b4c162f543ce204e55ca37c290241703cd444638b7e1956e6 e1fb9f7f35c2ce2f064db2652a494fc4132d67f1435d2c422651282e2d5936be 6b84444a3fc1f4ed71f07fe9807aeedc3d765e86a308cbddb549e41a07637540 6922d129dffb6f2e7e05e25d67a675deacf4a3eb7591cb8f411b4bb02fb352fd 807fa83b273eca0d0cdc181b9839f806164eac0da439354f27bd4c999fa3e112 ddea38959723583da1265d5bbbc23fd21d95912ab44ab7bdd388b8f816d7c950 d31e177c298fe21d24cda414ce09ab970fe07a16247afc1931831858f682913f bf212d78a9d4b8141c0e1e03b553c0be1bdfeb5b17cf2b9b109a1dd2f08fdc19 07bbe8caa6552571cd4fd46f165a89c5eca829e04ababadc29fc862625ef3415 43339e682fea6b57b40f7c199386f392488077429cb491f0380d649a87324411 46c1cd36c1efec4e065c8e64700fa8e225fdee7e7b5d0455184acb459785e924 09ea83b1d7d5a7b580b54e8e95f3204374bae8ed92e1271a8573d9d72baab4a1 8a7700e99533fcbbf456c9b22d519a25f1f5bc3099c71aabefee801277d0c19d 909b328ce25f2e5f270ed63fe45b43d242c03c3f74f3ff6001978ebeb418cc61 f8e3cf614e7bbee6985e1d5604dba2374630bbdb9651e91dcdad5ab53409630d d6052da08cf10157fb2a2e3b44c85cf76df325fc919c588086972c6bbfe193af 9a3b931fd12fd1f0d68fd76d68e44ac2de9f0d82fa476f50f0dacafcbc38dbf6 f07f3e41a4f7f79500cebf1b351ac5cf8346b068ab1cbef602fd60136b20cb6b 15f00a7af5e20b918db78299f63ab9ff993ffd9b9c3e50d32b89d8d68f1cb6ea 0402a24ffea45621cb1916265651c80c570a55e8ef7aa8577afbe2b15f3560ab 0ca97cc9867b2edec0d46d9d0fd14071c4c904025fd0c5ceaa5b13391a7303c9 755f312086e70719cf72de5564ccdb28288ac1fea0f41611f5437754cbbb360c 4f865ab94b9747b5219e5b62f06c8acd434b8ba71f9a49656bafef74e0fbe000 eacabe372936f28985b08db8fb4c2f8c9b4a48c261d698e77ecae3c3232c69ba 66e7c6a7231b1d3fa2771babe3dbbd42f1d32cf5f80e8112dc65ac08ea630c05 826d230e93e779a6e5d9ba481cead54668b91f7934e5a47f6d2067356d88a432 38d8c90a333e211e35d18433fc8e97a2912a4481a31007dcc3cfd7d02d58e445 b89ce70d879d1748dc572e179124da2922b52a9561c4e5d4ef787e65c3092bc3 dcd03083e2edc956b86afac0b6b72eccf61a96c0b9b1d8c49ed5fead44c22164 0b3b6bc0b8dd2aa42ab1909e31585da82da55ace9c06a9075120bb1584c4e65a bd7ded926e2626afadb1ba4c6a6484b02fbb328965bee31607f24c1f11cf35bb 1b822414e321327b717a8b73a68759528b22454ae4f1efbbea4acf27553bc7b7 6fd47667514ba98fb485a526bfd3eabb680eec1e6f6ee9b0ea242f051dfcb62f 10eaafcf82fb0ed3f7ac45f994eebacf1794bc7b484c3bcf1d4385534a7ac8cd 2f874b03e03e634e4afd81c541ec6061d956fdffa59940360b6be44ba08baa39 415a29f704999c6a1d57de28f50b6c8a28aa3a45e0f090971f0350169cf10442 65cc454756fe9f0afcacd7ebf5ecef668966b8d0a689ee9f8a80a0d672662d93 ae853a35374a5f088e4811ce400ca24b7292209f5591fb286a840f811a1a3a4c 13fce6e2bbc79ebe247e21edb3221333aea417be828cbf7dec641711cd009c0e d0d1c7e0df37e6dff7fca30ed034b174b6395667162b7ec2f81922433700006b 11700c2375553b574770775e7ecf74d356024c6cdb73a12040f899b072febab7 9f2045dfcf371ec181d645514a7200019f6917be67e5b29b27a690fdf434720e 9211009b28ae0d38739fda0cbc46242b9c091dc864e3849463f7d5cb6eb4224e acf85b5927f99c616e7f0119c2635f9e56689f1cf771e94c29d2bc6af30e3b73 fd8889f59b8fdd47277bea541ef26a7861a890898a15fa55f19df6eaac438054 dc0db4e6550ec7cd5ce876416f54c3bc59447b83c02415fae918adea6df7a4f1 29f5752cd58eb91887c95c38cd3691a9b404c99c5022e3e644947c58a62405a5 90d99d090249b1fb30482224f3c6d3dbc285c8a2f35a417a1a4559479a5af592 81c3b1b54dce4e4bea68f2cf57d5d10c6eaa396eb66880590a9d68409ee96e3e 8e78d814062170b9da0f2df53876e50d658e8abf5175be44f1a847b25456adc8 5c8e9a46ff66124cb418455a16ae3b78eded90d8d0e6b87f69e0d2dae684553b bd3bd4c32d490375d0652524597c89eb2a8dcda40278e9e17eaa0895fcf3cd63 37d269d95abc4010b6dbb4a1f13b0081701a625fb496a554ef50fa790503a0ae 069716673161003f4f4e03e91e61e4c35307be3285e9b9f4f96fc87d9256a112 3bf47bfecfcb4f13b54c8a5388623355fff92f4e991b1439ef4bd2c04c25abd6 8322ec655d08bd2297a67c7d218f22caa679139679f03a0bab4c0c07e74f5a59 4c7ffce48eeb64c719286644bd4dc84a6ca8a09976cec4365ed8a9f1e52020c3 1e66c12636713e73ad0661b537ec450f53bef1f34c814f53c780068c3cee944b 3606237da7504cdb79140ae14dac5e9970763a3c9f4a7d74a3721c93c7e1431f 1fa3ee9449761613dd39dd33e274e6d86709e83d747edc926b115659fab77121 14c7b97c2462aa3bec7a691242367004906e2b2daeed42dd2ea8c0aac75dbed4 70c011309fac84d7b2e71fa0702b49b21fbfd75204605c5bacc0c74dc5e8dc33 189ee51670246ce6697a111207191553afd5580f11cdf6859746993754e7ff80 1131c9a3307f39ca82c6232e5852e4461d0ef37afdecfa26b5022a93a7e5abff 9b130da9fae53bc05605bd8b9b7a015713699c5be1f02227a9c74da3db31a018 2ae654a588871677c065d03dd1d1d4232e1fb67b191a32573926c62d70ac7b34 a1a6f173a6aebf9df3f322eeb425a596e71bfbd8b75148232328b593059397b9 deb8c6156bb9b1cdaddcdcd83b0286e746c59d2888dbfefcf77e5fe1cfcd72e3 d007cf856dad279f734fb20b0e5c97839ac2ed18a607f8581b43fc5b0dd076c8 990073943718cc401ddb885dd082049c0168da46cb6568a56a4b287c9d959fa1 dd5c9a93ea17ec7174a091e41d91f3a03666ebd3411e5ea74938ca33b05dc162 c182c5d4f1d8be0d7a5f1b6ee8d126b397fc5d7fb52dd58b0f42f9b1d65e5d55 7adaeb0744f933f647464c92a39bf738067f6e1b4b996b4f2919289f2fa5ce9a f9adbfd726b517b55912e28c83f19d182b8df969ad4b12347131fbd7e0a8a2ee 0073fe5086e6319f79cb9243f359519f00da4d3be8855fa79f4233f8a50c5874 a6c4da072b6da74e25de82ee19976195b8483fa6a054856792d89b1e1f68ee44 d5f638f1b8eaea5e2da06bb90bdd5466830f036e6093df3bf23d03145d315529 1483358755a29f66d238dde5e62a125d50f6d22ce820553e207172859000a96c 72e77707ee4d52fd0ccfa34c57ed5d2339a69f39e6aa6f371080a3d414e25505 b7e9e15b52f4402ca9fe210563a213e1dba8bd02d0da57440a03a98980550a80 4b1480c24c531e5bee169e7ce570d89ecb0f0c7b3d041fd93f04abd1ca8bdae5 682b6bfc350ad26c92b229abbf92aa82a3d1c789f124c63c166555f4f960f592 94e2a267bcc92476200aa4d5fd0b3d6fca8f2c6a2c69623a22931b8e9242ea40 8d09501afab7b3142a44a531971cdefe348be311412347c0ed1ff2be5bae723f c6a8695fdc9043bf1a698ee3e2df46bc211ece66e0a5215bc16c8db3c676ae26 fece9504781b2b510ce438143395d3ce8f6ed69dd1179b9615680746b4260b56 7e43c14f5b5b2dbe7e3b37f9726c32a04244507d09cc1056084afbe29b97ea99 feff4768795d67539c95ebd9a89f8482775f595d8ef3852a988ab14fe95f5227 e88d342f5edbee919220c56ce616a548f801da5186ecf00a3fae3ce4eb163fe8 bf8e39152682f122fdf93ec892eda4246911194534a15293badb5e09e3c110a3 6654a6a6b4a0f3111b9c1bc051403c3d0a519a5721718e370190d833f63a8b88 a05d4624f0b50a2d8cbd071ad862012b3b01e98b69969f9e5d17b7660396eb4c 4bc3d8c6921685728332e49f6f4ceecb659504966c1d3bc49e57a79422c1e35e 3c497afa0fefe3026683a39fb701024d7ba204a2077ec0daf03d6bb1ba9ec005 3034c04416c57bedd19c75e57f79e9330bca3456c43418e5a6bf002d969b425c 5aab8831da8f0c192081f901a62c8768ea530c96a3b249aa9cd0cc83d404eaf6 ec54beb7e480aa22d6fd6f0c785e45c7f2a191bafdfab0bb07d5b48f092d9c5f 9839537dc7da3a8141b41c159b91c769d0cf2ba6e68b94217c602ebdbfc6a599 ed86db43e4a4868efa115d887acf04af9da75527a4fcd3c6244b6c4d61be22cb 8c507a0484046c536423e8d9af4e35f74ab7d30e0f3d41378b95da880febd57e ffd1a7b87836064b4247e77e6d4e88e944ab3aeea5c6e069161227e0d540482a 038230489f2a54958eba36e8609ead2529e3932f8b89c4204fc21ad19920adc1 ef2b4e6713f76a01478aa2d01d3caa45467de753c810df2f9b61caf0a526b699 abbdf138313206132f30d3c3376318e3c2a1754d95ea64e14b22e60d8dd8af54 5d3dae9e4dd24dff168fcbe2b21ff0313df82a1180b7d7aa0cd4aa1d9584bb5f 1df861a9b7b185f0eaff1c005d7c2bb89fed2ebe0f32f478d2f345bd678b49b5 829a61bcd2a3ad8a8d419c5c8b7fc26f2d13428fd97b7c54d6f888255640762e e6fe97cc23d26246af4db30b1860072a4841915bea8e575ddc5d7739a6b96954 7e5dde760460e9b910e216540728b4ccfd67182c070c6ec2afff9d1bcd0674c9 cce6c582a6b4d913727ed464544472bf199cabdd81769de5009814887650660d 170 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 +generate_ring_signature 68d6b1b9d874d51227c9f0a28cda04d8172e7cae79e06b58aca4cb5fdabf36c0 3438eed5f743a6715d57581bf005efe4fc4cce9447e6d296bd602250d8c16fa2 32 97f5294c86120cfa379c931f3616ae5853e5650dccf93877dd3d22a949deae47 20456187ac5551528a6c1e1e6e6ae511a8835a1e17c2d8376fb0d3d68f8ff749 0b8117871c4b8a996719c93ec132408c440b9f0a73d36ce619e4ea5099f46f3d b258d44bd5ecceec9ea3b4fc8e95496d997234a63c7b6e5128b39bbefbbc4bed 7c68933b4898deb06963efe87110b3a446466a13b18660dd8f550622629d0c0c c2a30c8b5167c28eb95b91920dc363bb6f933bcd64986c3434ed89fc077536ee 3c98ea89ace2a89cee7bc6e06f63cf5ba9297273b9044d4c6ae81b9e411bb440 cfbad8a65a06a22fe90f2bc11ffc003601392504fb1b3f85177f769e22481b8d 8085897e5683d6b33672d6e2e7532337eaf1a6c47d6eab0832460f5460f9f495 a4545f4596f607250e5de364cc2e0e070e37d1c330a6ac6eabb3d03af415209a 9febfeb7e7bbcfc9ed9d663b81671638f03555fdbad469150cb649f765d60d6b b7240cef5233c3eaf7ea031d7ed769d65a7362c90448afe2fb5fba997ceb6d45 0343b7459f99c7ac11c3d9f829f5615c5bc60e35569dfd97b78e6ae2e00f5d8b da9d89d8f350d85ce47516472c0e73dbe1114aa92de1e847d7c6a1903651671e 3bc5140c5ca0e3df7a69f91bdb268dcfa28550c35d64da809ba9940c03dc842c 85eb184236053a9e30b23e189e446a46c11be28359c0b4f70fa696e88a425b39 d08857473602cf81bbc7b1b17766fc09a7fd97c3994f8bc4de94c6aee03f3e99 7edfc9671443ccc734800a1479d6e7840689872b8652be4e97c9ea7aa9971e3f fe172c59587584facc28059d30713ecbdb2f38d75e967899cce7043592ad3e02 d073e626d083698553eb8c7d60e5a526e06f9e288f2c0216cc71535b443a3528 6621abc1d1d77e0e65d363b1dbea5a4651a810fead6d57fb116791f83824d668 fdffaf67600740168caec34bfd37b0fbb16275b155de1eb1bd7b39f1150d0c88 dfddcde4c8ac2861c78bc7df7cf627f7bf8d115c825a10d470ee665ab72bbb22 4d93013a13fb22587ebfdb63e9d8ccb1f7c04bd51c199346461fcf3314094887 f008c557a5edfa69389b32f0da30d88b2e6b91a4e37600c14772ffd578a67930 d1ee1579b8fe43e9faf76280b8c012985465491c20bfbc29d9b2f2e69083e16c 5056cb0d29f7e3fff91d6f9ddacb545f2266163f049ae76407df41c25101658f 80b56590de9d2826db4bc73ca7f18407fd0e5c5c03dd9841c9ded9b8dafbbea6 62571c909782c70567e9968ded1c05a4226a3e04a07ae9db48e0153a56b2a468 fa3243902d44e63e78a23d70a6706efb6e453d3ed42d087cabc7655fb83ca3e4 976c32ea460a47aa3596d836d70bb40a84e6f3d9ff1e2e01a516cfeec938a2f1 04d573623956db0dd22344c139dc7170d8ddf6296ccf558cc2bacf230485aa05 041c83987a208dcb9b7658b567e4baa29c0fd278a85a7ed885d26e4356250908 11 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 +check_ring_signature 1eb5a959cfc7a40b661728d352c6287e9dc310fc65e4c0a918c20139d7607d08 7184fb63c48a07960785cb450cc4515b97e7b659c762758189a4cbdfd15ecbb9 200 543feea2b11f4c1999fd15f1968c57a31d76969ec3c84c25573b3cf2bf9b5311 f7acd82c5348165412cbff4df40ddd3ed317575cf11e2b47e2ac6b5b7934008b 2442c5df338c960d7c9dc1b3bc18c6a3a532617265d74eb65bc3d2f8c6bedf3c ec2e1890adc73628519c41299c4056b5a517b614401ca8eb9d1e891f48805adf d49719b604a8c4e7733a9a8581956224e5e9e814562df70c5c25a0a7b5dca7ce 7805c4fb95bc45642f87d5abb0c407f519b5664010294cf57ac09f59ac28867c dbed4e7268bbdc7dad3f866d8ad59b98ba855ab32834e6df09ca0f9710067d4e 3eb3cb8fe7eeea2ff5ba051e32fa3a2e3b7c711b828d8a76165cdf7b2cc176f9 94df9911db6f6d46b49115349ed48e8fa4fe32fed831c9b31ebb0c85faca116c 992c65174fa348e589d5f550a95d83ca76514fecc90d0f351d92d9a6c0df320e 225712dad2f04909e6d79d01ce8fb7d33047f972375a0ef54e8a5fcf3d875f7f a9a86880f9e0078a4947421c95987187dfc52d96adf363c502f30edc6fcb7aed 504fc767e317ee865214245e1410a400133f52b83badd645c3d2f64e48568bb4 a820199ede446a1c1b7ba39c3158128193d1e6285a1c546d7b8dd9bcca63e17a 8c9badfaca415bc7848f951f197edfd7e4da91cb0fd14d177b26b82c94063d37 eb82e30bf22d75c12cb67589bdcd56f9c2ee3486a1818e54e7b0e64bc23e00ea 489cfb0a793daeaa0bd62951309ea439d363bc1ab2ae5f08aaf8d6a0db866d87 db74a07a7f44f6262e709b945c4d8a21ab57201e3bf0e0571c022b8d7c927226 f347a3bf74560dee12fb32bce67c02e2ef61dcade637fb7666567d8e8f689376 0422c442ed56f7210722910a5138b93f885928562641477ceec412f895a6e48e f725928a066f1205d0a3c7c06124b1060d782dbcd5faa053ebb4c3fa376d83be eb0ebdf89be52235d34584264893dfed22d15019d0d0e6046f8bf35afa1a0f90 1578e3bb1eebd60e77205a9cc7ddce1d8cd994d8c0a57c683444622b895c6c42 d5e7af099509b7e97265f92f9a232c2c14183886209f9e5e6a9f04369cf87136 849b1e0918fc19c02871083ac8637df704b1179f03ae7fe0fb535bff7aff3d9e d258100a0f9aa386969c161ec81f8ba8eb5c33db0a2b6318dfdaf1e212652c0c 6f4e276c39fe940712737352d9aac0d872a14bfb0e20e8adb912ea9820a772af 1ebe7ba5c7d9787b4d448ee29f0b5a7df81886be38817a75cf099c1cffc8e806 a68e5c9414aff70b56a736ee21682beef2c8a446773abd14fa65ff4d9939efc8 76a2a0ba74d5786f9fd32f0e0e4ca5ec9c2d915878f629564b967bead19d03a5 e5d25bcb19a15506ffb8ebda3168a847cb1a4c3e1c883593963d0815926601ca b189a35b6584635e2ca225b99d10f935e5e2d9aacad94deb7159cf41c8057ddc e6af85777638abd5e11c416ea03972b4a874358e2b3d64dca64ddd456535d128 7c9ec2eed774675459197aaf4e2180bf8e9bf80ec7a0442d5f5659c71fa2c897 49b298e3e80b9c0003008b62cd6c5a3cc7f4229850300fd5c48fd2e24dd81650 f95d9552653ba4d6f3bff5859d6ad269cd7291b2892001080888bc619dc4a046 3680c7fefe69716f04f4314f8b409677dfa82557e994d65693dc7d7f8ae5614c 6e506622814f5d90ec809cf2302d5cdc275f29665009656fb1f941754c649b3a 667ae2afbe462c765f0b8cf5d2e9bb5b68560aa570efecdad57784585a1c7720 2890a34891ecbd6788bb47aa0681962cabe54f06ebc27b019408d7bdcc6ba637 87bb518c7d847f9fc2aca39317dab6b1a0c75c091b9f22a7f1848364b34509d6 0c838af55d313fa455f90656f7c7d97a1ef503417a97a74f395dce0524d789d5 6ec977027721921b53909973a702f24a8d366a45f0436a0113d7cce6993f53ad 71ba0e015bb7be397b27dd1789c94c4c017f1ab681a0d3846f0353a85d057293 64190fa9576c454a48d898256f23ae30fe7a500d09c68634366b5544a5ecbdcb a32298df698677db8fc50477a0043ff3bb022d27d63fce6de0c913fcb14ac637 98a1529478e55bf403fed1a009503bcaa71391dfa83e5bd0d1c3c74783c0208d ea14c8daecea208f07aee92f4edc7e00fc5397bdaea6c5a486036c517099cd9c 7dafd59d7f155aa634a26971c4106a24c172a30cbae48bf6ea1b1d72b6dba1fa bc7967c001f400998e18fbc53da60ba187a1480b731af2e09762979f7c4362d7 6ac5b82e87191fce298281d4b3520025b0eba743aeecc42ac9d218b30a781d91 e8c482ed4b62e158ae0dcdddcb794110c4f73c5abe540ec3fb7ccf8a9dab3a74 f7d52dcf00ebb2810331d1278b4ba03b0384f47c0f89f92e8e037ddfa03054f3 f123cca20321b7e73faa51c8255ffa7bd8266b1a39991bbbf8115570c667a306 ed8980dcd37a86d7f7d1e720548fb6ed8bdf33da32d8e33f681a93f6f5459883 c85766a5858537a13822419b9af7136875a760e4dcafdfe13176755499e5fbdf a3a94fb862d0e1c1867d46b6ec614a9bd6ac5164e8de19e29b8fb38e2a6436da b1fd45e36bc57e1c8672f4076dbffcf2bf09035dc5e4c47f14a6c01eaf3caba2 ce5e1669abc0c7f060ea303f41aa1197b90facb7a2fa2204726e7c57ebde9665 cfd271968a4967ffec462606fd7b195b03f2af58de867bc5278657a33f710d06 e3d31e9be390c1164c32441ac1fcfebf65db22c2d3b7b29f4e054894d854b217 809148d336d7f80f701a80e5eacab1de50f1165d03e5e352a7113d6f1efc6a2a 971ed240b6a0298187f27d4dec358f401040830673b07839f74e5ce7a7c82ff6 29618c8aaa9af5c68825a87aa8be826876e1814e854c86b7d76933b449d2d279 26353026e1c4758ebc3c432643a7f611590ab32bd7710529f2947d47f98cb072 0cc7ca72f7c934e5334af028989c07a49229fb00e4096c070dd24b87c2e2f690 c814ab0bd6e63cc3b2d7a6695dcb30b7710f7f2a7421ab2871ea2a4b5a9d5f8e a0b3bad37c0e765c22ffb2a526d0c2b8111f16e59c7cc3be7e6a1b07e8de767e 3902bb51c23ee908ab925e56fe904b5e661fd795b4d0ae83ee111dbbca78a819 10546ef941398f600a29d7eb6036bf371b11e4ebbc953b9c5329b219edad3b68 7323fcd88ba69cd500283550e1fc13813d73c6c8927e3705eccc63866bfce833 5bf49f286f1292c986bed0f67522965665a461c38852786845ba46ed654268a1 97d85e168d5987d1fc79b0e887aa7611bc298143795e9bc346b235bed1f08f46 ab25f12c7063b2483515c5b907dcd34fa0db8e94ab1b06bca82a0a4d7a21f166 b3f3794b37a43820d44a689b2b7b1a8df269777a21957f91b4308d2cee66e45f 1117043a0689cabd1960d1ef742bad37c510731992d024a7ebe7a2d63667e7ed d5525971a5cc476083846c310e77ceb540ef037fe181acd00afa81e29b67ae14 5db681990d100c409663fbf6e24b487bd7e4e915704fd0d841508630a613f097 56d7cceae4ef1712eb95a782dcbcdff8d959861b9a5ff56d395f0b2d34f4f12a 017ae0cc1fedfdd445b4fef15938cae99abdcd0583a188e07557fe2a65842233 4860520043dbe07024a476c4091dfbb17e8398ef825f665aaa11ed63a62a4b34 99913d4fa4a13a2a3732215ce2adef2951d4c4fa31191c62cc8cfb5555e27d23 d2d029ee0272ef1ea773fedbd8c464a1858bb4238198d2d4121393e6c8326b3c 87fde213731057da37cf5701dbdde968af42a328079e52157e56a4b2b6c95cf3 7b416abb2b0081c4205a614f1de524752cb5729e4431f28086ca888d7cc87860 38244112fd3bdbd05733434fd81a649419f413c0a8c14bb52263a589f0a73af7 63f4dfb6c5fe738cdf13cd432954f590bf00b4e81893ccdd5b1696e0049c8d58 723e7e3418302ea27987ccdf280ec556ad72cde3cb2a596f3349098f27a794c4 05e2cac03c8b1b049c9bc473f0894b8ba9b34aa506831e06723b416140308133 59d4102257ee505cf877a216aa22c840b7214764532b920bf8260a7f58a5dfca c4f3578faef7a4ff279ef30a71a06f56b037e0231c3fbe5ba778c53d524b101c 73822d96d4f8c8dfb37e8eed6aad9f19e9466b0871c917303957330d900dcbc6 ab3220323c42fac9e304170080e2f77315dc5ac77d46892308fc76a721c5773e 8ebf74406a07554db8abcc8713a23b3031c99dd6d232d478ccc5ab9fa54e4a53 59681c4bd7a5cb32ed92a2b1d8cc6156199921a4f7696d03eee11d3dd64b86cc 2a5e0eae43611e232226409667f02d74412cf4ff1f4b7135458040d935462a31 0bcd81359754353596e7e67369dd00812a607c48d6e4db6141ea84a70b9e9d30 14331aeb9f5a2f2128d40fc738cca6346ce2cb2df0df94d068c5ba0623cf7c65 fd07c4ae1e3fc78b95d7ac73a73ba18f6c1df405d28e3661ba860b3030a835a4 39f3ef8784ff04275a988836c1fe13467a3b2c5c538e34cab88ab03745531cc9 7144f8f4e2ac33178eecec7ff144123605c1f1303773d049dbda8b2aa34f163f c40805c5886287f2d2d7246128b5f64eb4f3d1428d3605a06ecdfb7ef66c43ef 059c6721140ae041d768b7384689981a13f998f5e19c4bbc03df95f8d4fa866c 9e995343b7855a18d916a9913aa7598b7b108ffd35e00d2510f17e842e71f45a 7d8a69025c207109fc0529fd604b76c4523ab439b00907445e2424ffffa98f46 6c568bc59db99d2ae9f78813e483de0039137628715e481870a42215502e241b 9972c9e517db11d6ea09e48c7db0222e64da5e7df3f78cebae553d4f8a0d05f1 3238ce4c1788fe041a12cae1fece1b6e6854f9a8499b3c09a4a08365dd89ab74 1eb6ebd1d5fca4b4caa9a1e08734c15057daf9aa135cd9b5c81b6b9838b690e1 5f84f99c4afa11c9d03111be7077f386a34869930f1c620619b296f297928728 ce6d586bbba966c28d152af4644e21f519d51a074e9d51d14aadeb500b4171f8 979a86122b24dbf7787836445630666d28710f38622b2372687724884de8feab 2d31c50d507f0340f5428678b5339f43e677c4a46dd9c3981a1a96cbaa251895 528d682b3782df90300fbccc325f62f11997f660a168444d69718ccfdfa616fb a819364888e956816954687dd809ccd3a1aecc32000e7a699a6c24771dfd6cc7 6a720408f24f4a5c0bfa9865513f41fd9e55c5bac0d3e7cdac06a7ee66fb50d0 4fce289cb8c7b82f183ba968834165040eec796434551de337d05b5f44bf0e7f 027cc53385b6d116160036a9ecddb3434b2562efd45abd0823839b70508912a2 636e066a5802d9504b86f1022b5a8b93474918be38a2962de9660d358e0094e4 c509514ef85df5dd5a66f619c963b5684878d1290ec2976e1702963eb97c794e f11e96dcb3820fc332652e6e973399f6f0a990ee88ea90b1e3710161bffe6797 c5e990f41806973d30789a085ec52291431d3f66e926c9a7b0fa50bf7b234f87 281463828afa2de23dbb757568330562b49c3b290aea675e47363fa3918b45fe cca71fda3caf010902660bdcbf6dc15faf08b04b345bfb6d4414f3e019a7bcee bf57436908bee12116fc88573ef538ae22699e66fd7d10304c13f5c83c2f0a1a ddc2e241acac4159fc35e49a8937afcda1c85e92ab47e1f659e7df2053ee006e dfa9a0dbeaebfc6948f685d905180e3dbe629df2973c961e49224cf1a104c351 846ca19fbf02abad29916e23ccfa80d7a89ede3f441ee77becd2a67bef045094 4849b1f596c629fa04976f04f1d1b797da43f6ea4130aeecc07bab8b37ff047a a3d2d94b33f852cd770fb595ca4c6b1fea367dd5c0fc1553f9168b94a5220fbb 7add63f8fadbeb00c6be6be1c36605d026c141cf4c3cd38bf83bfc296d99db48 6ee0daf17d82d17d4d53bc0b54c255e746592caf7ecec281bf0a44dcb2b5fc49 3bc952eda5f4687969715739a6892d53975a0f6dbffa12f8adc2eab46ee29d6d e5fdcde88c9d6175f3ba2c3e9a499033ab1a5419a70f3b6ed2d017c56da92f36 e309c4d435010678c8750dc2b3d8d4e250ba9fed2a2d7f46668878e31282853b 391f19c85ff9bd2e38d97998a41446207b044c6c5293f50a7e47e4f11edc2cbb f1f226812c18c243bb7caa6420e56b85378842dda40b358566f6dfed0dd0d48f 1c38d642cd012bbb3fcfc6e3ae33f0d3a9ea0f5dd6f7d9f55b6b51dde70d3379 0e7ac1cabce9bbb6012f866b5457ac146ecf181df31a0adfed70cc551f33ad3a ce6d87fa0d789679f90f97bc0ba84b149907f73e90d31af191cd666b008851b9 d70c3fa70104ac187ff11e87c88c3d439c32e1bd545e9fd03f0f623b3de40742 7a3b502186e37eecabcd2f59c5245787f4c9b9eee5fa5d41a1d9685bfdfba5cf 29ab3109d98ae17b91b533884a50a6ce720ff3559b94991d9a47542a7898253b 6401b466925bd5e24859cb228f22e0c2d3d1cede7a595daec5b53a1abeef7c80 3d084b70ca1190fbf49fb87a7256fa81af5dccdda264bd0fc4e44e9652c2144e 8739ad8e09f754b81cd511d55fdc96f09ffe2d036c7389014eec318a4090e7ff 1d0b13a09908544823ef82bcc0ee0702f771677396887243e9b855ae10fa0d3f a0dabc3212ac005f328af1b67f3bc40bfd568a3bfe23ff1d17724a2fc0a9b3f7 47ab08ea0a5d1ece88d24e91608cb486d48e78b428eef7d5af5b70b804458124 532dde7062bb3ac560c7341edad20cc4b3d1e55ed5446189ac3ff1bfd6e1b375 c26be2d6baadc86a620565d30fdb3e3875c04679f5cc462fc090c2ad1e9993d6 3f24a8cec1584ddcf6a36f82e21f5d5d3d14bf5fa6693d770bed98206227b5a5 8c44348acb609a7de70b5b3967fcc350f2a6e6fbcc3bc8e5b3c0d3d85668299a b0fc060e8f9c61cf0a65d96e40fc1eff32f878e8efdf2b9aee1802900c9bb812 a7f1cc91a33b8236620adb78493b4986f6baa36a9fc0ca39de708aee8b03a9d3 d9f2debb03723b5a5fb3f1eaca7d757cc53e6a1add37fbe97a44c6c995697d43 6c8b6bc336ed423fd2b8c688355252219f100ae0b3f7dd49715d2fa54f4d2dc4 0a5a6089033274496bac02a0be66293bc08a6323a7a9197cb5ee8b881b79b91a c6c7e200df00a5c8bb5cebd4819272446669b1a55dec6b46f9dc395ee5122518 317183a7f4bfebf4b8eb9d45abaae34053d561a29d4a18fffe4ac424aadf9a1c ed2719e979b9f9120a9fb07010dc60d4801a2a7d0988a7f2cb185693ff6dae22 93bf867715511b241f220390ea0ddc19bb430ebcf0197a23bcc866174c9ea270 f811165233275b8883df148c4e0aea9d344c557c965592546fb35057b73c9941 6413323625835409b033e73cecb47c414b7313d74c0cea45b231b9fe4371095a 4b3494d57d4a869dd7ada0b5c02b52c6eef052a60160b6a61d05872914569732 b8f46e5c2b7e79fdcc92aae87d8fd60c8178dd6e771ff15094a9da652f8269f9 195b6edada34c6068401ccb49b9f9caabcd9b51d59877ea6a7987253a7c570a4 944627fc5a0a7390208233ef15712c2e4f4fb0fa4f13f356e6d5d226a4b028c0 12e4921b4627591f5d4b9c3a704271175ae915d0ae8d9e350a225ca2ddb6902e b0614048fe6f4850dc31eb26140d577f367d022ad4fc13681245152ae1775deb 55406f7f4b2325cf39a34f916591155d671605c4519e4329a0f8e468805820ff 9e9a6827fffc2b03b4dfb4a018616c99e3bfd904857fa557316c2a16190ee91f 827fe24e9360186380c8373f428be2974709770be3040afb6f165f55cde6cd98 035b5472508d2b6599df3f46484bd5e2b798b8f2407074c2b3c5deb7ef7d1bab 36b3c7034a6a0bce5fffb24e89f5b34f52ec666b6593566d2bb019f12dd1d5e3 bd3fb3283305397254bdff0a0b7eea8edb3b8eb624a59a05d379d7b9a75d9482 5e3646050305256601ffdd954d32c7aa26bd1ce5cd64bca3ab158392d6f39813 3ba181568063a0920047f366be38f8e73eee814cb48b90a01f9496ad8bc63bbd 572777dffa2d63a4078122cc97fba3e8f9eaf0da391d436aa82d93374a6fafed d3d57c5790d18da0df8b9f8fb2be00eb3ee2adac775e5117d86c0084f3ea7787 73b4509bf34adcc3e4bbf20f60eb771c173f906c4a4cf5e59a1f74c29d4054ae 822e5fd7ecb36e2280d3fb300f9e2d4221385f421231937bfd634c5873892457 0ec5b38fbccdb87a07423ee0d7e787ab152e61cd4ce85820c22706f6d899a63c a5b289d4e5a8afcbc5fe71209e9af3b0922e1a1dea7fab4029932d1e2359fd34 dca27c0e7c2a877dc3ef1e000b0bd9d74eeb9defb48fe33ea19b185eaa551fbf ab288d412f5928b81ea2d7c772cc91414280a9e4ec5c7c3c8bed0ad0aa446fb9 e6399d35535d7fb50125496965791e751a906159d92920e21c147ff920a7f33f 265c6d002d46892c66a22a3ccc496f74983690e9d7a00096274ca4be1ec7356a 0d0d5998b3c2bcd15787e24d2c7325aa7c76155632d68dbf57461665b61253b9 0c3691ae2daabbdcb784ea3c0f6f68560ab548a12ad28e2bd252910ba78ea4d8 344bee7a3fa92be3e138402eb69ced23c34a94d7a60b6bbec466b156f286a013 9c76424430af08b8f5ac377c84660321dac7c87b02f55dd69f4151142ce7aca2 197ea5230ad5b754b94de2da099a842892266157d403b498a542c93a642d38e5 42ceb7329b551a2ecf1c3377ca2490dae242e8d92359f6b5d619002bacce37b1 7d24dab492d677ce092a87be26a245482b7e89b79205dbf76c8ed491a5c66518 5465ff982b133a9e1281c0ea318f7801915ee2da70f269735a0e17c7259b641c 3e31784aca01ea6728de1110ac04eaa9099348d0bfee82f920fbc0d53e1a587b 54dc85b634b92b67b53a63b955f5560c600c0921e7a788a826f0109e4db5013b ef2117c227b0f301500939f2d255bc805f066fed8117f16431ec7865015b3502 6bdbdde97c4c53684f7733531bd5ff5a0e6a0b5bb786fa193d1b81714ca99470 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 true +check_ring_signature c70652ca5f06255dc529bc0924491754f5fad28552f4c9cd7e396f1582cecdca 89d2e649616ccdf1680e0a3f316dcbd59f0c7f20eba96e86500aa68f123f9ecd 1 9cc7f48f7a41d634397102d46b71dd46e6accd6465b903cb83e1c2cd0c41744e 3e292a748b8814564f4f393b6c4bd2eaaface741b37fd7ac39c06ab41f1b700db548462601351a1226e8247fea67df6f49ea8f7d952a66b9ec9456a99ce7b90b true +check_ring_signature 3da5300a7aca651dc3a85016824b0620a19973eae4af8910cc177faee499358d 8d39d8d877d74cccbd5fad872b8297eec3f4b3f5187486f8c98a2ff27f994800 16 7af6983daaecec1bff70b05c7369fe1636270f8dd606d39eba974b8c1d5f6091 78c2676d12505b7d5a63ce29f736124b48a02dc78bd0ccd1e9901344811bbd3d 957251408e9a8b255adcabc52bf15cb8a05501e2892d7cdda22ce672adc0cd12 73e433a1668d056d9b651aead47658476cf23c39cfeb4fd23625ed94af439677 f58dd3a46e0a07000ef6e978cff87604c32cd3df487acd220b53b5ccc46d0bd5 3480f2437e01073133ee9cad9651665277b09bc0a46618f975a746500f9f34bf 0ed796ebd217fcae58272ed7c4c0b058f558961f95a68ea52f59e4e6f0374d73 729e5938a034b2f50b583d4ada5541a12de09aa1776653a821da7d6c6b057716 1a9855ca5dc19cf11f49a87b182695451e83952f2df4ee9009bf0f72d6e25194 c609386fb270c7af8dc4ee102fd33ed3c836e7ea493dc79655c9feb1cfb9c869 94ce9f9d3fbe4848aeb59231d749c6c9f7bfaaf99c31e4317c2b5b1b335f20f9 9331dabe4d6f230a7c45417dbbb28b0808b4b6bdcba83b774583d784413ddb4b 437652a047fe0872b264c094440625cb5cca5cb8d10cda950138c97dd09e5943 5c470fa7fc2684336917a626e2dd4a09d68b4ef9499857c11e8ef0aff77a9262 df3ccf869b0262bd33952ace2b1320f809e227949ce6a2e89a245ce5da75e250 4ec480b685a07d091057e73954c8bd5e4646b2bd0bb0a46a38f74cc44e0c940b 4e7ee4fb45708e2bd97b2ee4e134224714c2fe1c0b679b7de838d715e281f10e4da8a6455bf4683a91e6e56be119fde36ccd61f35aa4867e9725dda7c18bb40afa097778cdcec51fe2d205db00ab9a00dd5f6f0a2a3b8393a7ae2bc03d6ff5073b25f72be8166bdf2e21a4745841bbff68a54d6fa3c77577a6b5c0f0b7ce0a120d07d704e9a30f306a63d5b137534ac4b60953abeb420d526f4b501008bd0a01790d806d86cf96391953e8b630833a3d6a01f023da720e26015287dee5c9b9060f43fa3574626a3673628b6b82c4b0251b5251173b59177fdc8f79974205090da7a3d93d1d274ed39654c348870da21ac66ee7a0e072e504aa01ece4051c3f0c93eb6065ae0e4d05e49144b986b33ee741c406860d39c953062531f2e993140c43aeeef6b144cc42bd13c2aafb10402edddebdfe0b426730163fd530f7b2c3009d4b98d761131c5ccbdcb737b4a1e9fc72c1313fb45eef13ce4d31c40ec94c0466cfcba1771229b0d2e014d716c9a2c10f6191eb67c1bb05e72f291d1d98290c2b4542d196df41410992428e36c62965a2d68f1fb99d6d4058b7e0360dae2c0c56d7980a546f547d2944c3bb6672fdb7d40378d47b0bcd9ca9ce55abce22ee0d94a7906ff1e31d37578a919dd92b4615ee0930fb33cb494548e13b731b33320193bc5b88e5864fe2d5d9a1b2bfb343177ff10d647337205f22a37b5cb385090bd2a050d055cfb9fbe01cc88ffa3fad76eb5b7baa50cf5f379ac6cf2636da8308c945c859cae02e772e432b177238a6e3d75b5cc6e676d1f3989d78493d86440cbb5552586755101dc4dd43bf51cab188fcc919012f7d9b19db5189fad02362059c8b3cacc8f80413e9a43f41cbe154ad55acac98287edef98240b6d8a04fcd0a020c8481164041bd7165a6b90b8560593c8848d29995634392dd22f3e993bd05580e41349091cb125eb2048c53dd230808019482f4b22c83ca678d9b01931b03f84ff3b4a78c138fbe36d013c9a423e0233962be5f278b535b20f05c829624043641b8386f7cd01a77c4077a5a6da0eec912042c60d9b6bcb56cac9713dc7002ab69ee15e0013204f68d6093b158c21f3a09e205b15e627b3fa33d9a0cd0300d9287b5d75ab7dd914ed95c8ed3db0bf05f68792be1492c41854a2e36c123d30427ff0fdf706d5a01f6cf6b1c02e2140f7b165b2259904528f12b527a7de76a0d8f90c3c027bb2f71cb1b345fafee0628b3f15049cb577b780890b9b96c53160b9ec99cea512304c94325b2c894b6dbc926c9b2b8f497a765a180f70425174802033d83980e2b28cfaf767d6a4da871d6adee474fb093e89df7eab67255b1b70821e64bee166892d1e5ea9ff2dae7b65231427e01c63164b5f3f84626511d2f077de2741fb75e3d940646480b595338c6043cdda23f0fb48d875498675e686eaf false +check_ring_signature 90660b84dd3be5705c7766695fec404348af6df58f8c5d58213f3b70b8b67a23 6289b9b151eeb263fc29e4b5e90978db7670f06f408403c8973bbfff2a884dd9 2 4af96f2c3a70ac1860d48132136989c1d38551367025d43f36aec0ffa8e7f28a 376cc178d8ae3a68ce467bfbe719e88b22514617dbd1e764e0b94b4f6bc961af 4ccadd504d1d03e385ebd25dc51b98c6f3a0e1c1be7e5694e44dc2377898510ca3202d7872294cc04b65d8c109e3a6e843c327b3416ca3a2b1c585fe4152260555441dd7b1543549f749acf5fc9a93a3f3c240425c5f7cadccdef4f06cef0702ae4ad477d0cb60a1a48c1da22f5a8b20c7c5672833c7ae13f78edeb3db1a7b01 true +check_ring_signature d280b24c280daade9d2bcd68c6dfd39d3a13eb1b0645c4f7d2b0613dd4b5af3d f1b943daa1ef225726215f551dfd85f56a3b429ded8608a09a8310a90b8aa88a 2 2d4e494897c24b1730f018df65468c2647b2dc19f650d1a9e055b9319045ff13 74db9c16b0cb4beb7d48ec77b654c63917529072aa57d381b5e3b8dbb06e0f5b 8aae0a8523d65b3746c87994e4cffaf437ac147a82efe34389d270a976183006c7de37ef0362e13aab9287a85445748a8e0e1a357c6a0ba090f436937a1878b47b41de38a3737152453ca3c0c6546b65ceaff3298329273b0808d35af376a20c1217c85b153d40bc154108eca199175b3efa3f190740325c734d82cfb054d50f false +check_ring_signature ddaa005f46bf73a6bcf4e20d1597e2b7a00d1b802e5efd5c097fbf2b3b027276 2b7d48c34c5f2d7a45e394397e8e1ce2541cec34e200d17cf741cc4c0c670421 23 24f44adcc267f707ddeff7ad59a32b31f9a387f896f5e493faca8183ec076c5b 7809bb7f7225f1f94d7a41538e9f94258004eaacdc6f12f7c3066d8503ff476b 915e4b1f43e0d5ec16ebd365eaad151411aee0cf4ef8cb76171efc70df722b25 37869fed481a3cfaf9c6882aff8145bfb4cb015bb1994afb9e79eeee68f33f58 08c0ec7c18e9998a92c7136a0f2441ef273d1ccd72893ef41a6178dbd4adc25c 824bcd3648388915ba8286b3d6bf775cecede4277867cd419b8a35a119158f1b 2f70964bb89ffd5d2bf10fc00b08d95892a3a347934dc78bb733a0b92f2ca072 a57525ac8c2ec09756a31a9822adee8c2f02b018099b923fc5ae334b8abea96a 02c070891d0f602cb8a985ea4477a071329da3a6f3c692dfb1979f615ffa50ef cb359906601b2236fa25d1eb6bff9c446f12f9be84d5c2df5ed7b5bb12cd8d7f 1d8648bb6f1ef73aabbe99bac25b81640d1700e45e81c1e890c91b13ce7d268b 5e5eef5eaa1603f16710873a283d398f2c8a06119fb4c6bdf86ffec4ecff1c81 1d087b05a1ef4c126087330338dd1043acfaaa1dc46b02ced5d8648968e0b4d5 92f959ab46a78cdf3a2140adf0be0d25230eed852891e9bea8b0fdf1f9da393e d1a7a40aed14c250f020b8fe8ab90a36d4966415be895372d00b2f70f666946c 5b7ce6f2dd8f9d3b82cb19e17dd9a2ee1ebe21386017207ac467d2524369a448 124276b082f8670f369374b390575351a67083ad320544794fc20851daeb8f98 93bc4d81ba1d22b1d83cc8b054a59508dcdc31235b98cef1c5a3423cd2f21c3f 4833bff261b927e2b648376dabba5483f3b733892edca16c315b9fbfbcca5f06 f9e117a70f818cc66b6e885e66295a3c14500e750964ede22b274b4a4334c15f 9446e013a5659a6cedcb4e785dab1b37e5a6338e9d5ad4d9c1057abf1efe0e7d 6866b5fad7f65a3f4101de405ca3c5c697afbc6c08027e545843f45a751aded1 e7b1822a7d7b0fede4fbdf70f2f59977b0dd88c6696698395b0de57639f4e7ed 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 false +check_ring_signature 17e1d8c991803cf0747a66dd16a3c5069afb0f604670b823b675bed5de59d6c5 81abb2291ae3e208665370f4fe07c1d82d3f8f6a6ccafe7e5fb4819ce1d2f113 3 130f844d2ff629d6374653997afec462eceed08648daff08eac4c58b9006e6e4 f92f7aa2bb9273830b966f71c7d7aa0ee8473973d65fa044c74ec4d4628d765c 8c1f5b3b71c27ebdfadefed2594ba57b19934eda6fb7b5c7e63dd0ed471b6e2e 7e799950f135343936af6719ebcedfe6e4a3fceaa86047923f592e1fb69aa909575174936ecf6615813c0a4620aa77161d8309aefffd6d33b8eb31b37aa36109dceafe0b8b49a5a280561b204f71f1c6116053ed1bac94b26fcad0ec947a9b01e4459a956e4644f7a8c39719164a87c93d21971366e66e0409556fc93c4c1d0f7db9b2d221fdf6fae05cca363b5e9ea1a7c9b0c80080b9c825f9bcc0b734030711b981b71f0c193bdf51b41bdca81579144e1d7ea134b93a6ba40bd18bb74f07 true +check_ring_signature 9a751c0464ad7a400ca1175d0e31323e2c5d718db9cce3e8029537911c89a50b 15cc9dd45463de907e092e45067e95c59f05862c5bd272fd442b097caf9f91fd 223 25c598823a8a735daf500b17d5c4c0d560eeb27d608e36a36bcdb556fa84b43a 7e58ed7359444ecf2ddcc59a5cd53c0644c46d2501d427cbf3959335db9c315c 8334b9a47e8d13734a75d8e0d155d4cbd5a21f2a207e43943116c1871d285be2 ee50c4bc3bb52ba8d24490859d2340f534c96ac4123d757fe5a73601ce53e69a 47824d0b0e0c98000bb9ae22b32d3774dfcea00dbec527f2bc8c80bbb693ba89 d263c549ff299531752a19d33c90df2385adae47f39bf4e72a36a7a5abbf869e be169b323d85cb8d61890c76e28e67191a03869c0dc747774b2df339034012bb 5dd112a3678e0161f7311c54611bff5bddf36fc383ee287b83996e6a76da45f1 8034238bb8209cc534f4447828206d2ecf40dd8d8b0ffb7b93de12f2837818c4 6b9967e8e522c15c8fcce95f81e85518da8cc3a9996c085978d8c6d996f9bd5e 05c81777f078c266df47fce956db766809304a7ad3af7bf37e0c653d1529a74c 332c944af0b2fed432a617e0f3f8a2ccbdaa350a3c38499935a1168b67d4a422 ab997861bafd195270470b3d89aae6df2c114edec83be6d773822e36900a4fb4 f0d7a7bde6ae61eba772bca3965319f1ddec9f0bc4c3f2d27722f9eaf783e1f5 ba79f81e9b7f6643f80a579132f7b9abd30f14ced2102e748699205b5d3c8fd1 397fac21149573b980ad8a0930bc2bb8c8d5c9ec5b0d0f56c4aeffaaf5182a95 a9ba777bc93456ab55557beb39a7074580c049d65efc543c8b183a8ed1cf99a8 1ee12f652547dc4e28a9408963fdb980955af57ed29e799940361044ccb8a293 1a5faff369cbb244b8533409fb93286b03f10328b5f20848e564f8bdabb57d93 3826b0544c0da3cd989bd2502a05ccdce3f0b30b1da07801d87cb078f24977fd 5c7d09b3bdb68a368dea02578ae0b7ed90ba4aab0dc51a57e4de61c043f694cd c8dd22831cc8eb4f1c7e27c01404fecead57dbbabd779498ae88c300ad7ab845 9f60c1a7a708c6496c1ae98915da4469ef6e09db36998cc6083ba5cc81ec0641 5d6da8699dcd1257a3984a97733a6df0dc1a0ac782f530341194912e0325f870 6774a88af95a82d8bdfd118d5863743e39244de4f3b8988ccbfc63ca96dbe39d 76b9bf0f785269d6f487e7900c888f5d59c3b90a6dfcb1a6b496de8ab89dd1e8 6aaf7894f166c1a9eef4a2c741fcb62cbfe11542f44370a7d284a63b2c87266c 3617ee65a4efb0c5978dd00461bf8d64ede4e177c6236e0bc46e36045e30dbb5 18d02379080b2b284b1ef4611639138c74e6238106ce927c1379a27a6aeafe47 3b8f4f5965cb9030c61c26140e9176fdd380fadb354c7b401ebde0355d929e6a d8db5dac1cbe0e44e38a84d1641c06c2d4f35b7a1b9904dfce447c44025199ef 1fad9f875852f4579d85d3a995b9cca5a4b143d5be31be6e0e75ee2e5c7df1c4 2814bfec0a867a41206ccb3b6f3b1d68abcd7bcc7f5aef834ba291653160bb4f 7e41a4a9d2b4c8d3574432f8e2cf66efd9b9d821e09df86b6f4967c7d9fea9a7 7f3d5db7dd12350d5cd2576d3ab73909d255b384c15fa42a6f10c05f225b8086 73e33b9a5a64dc4bf4b8340568f462c6664781bc312c076824e1271f1944367e 2766236897171b1b204025941d0471b2ff50b31367fb7aeb7671e5b811334ba6 16c62fcbd727546a55e924b59375461dea2330d55956e7990645117512186a42 501c43a711240806888749e69bd492274bf06f5b6b6f815a6b7fa4830bf5d3dc d250a55f4c31d7244e8cb052dd26bf8c7ad5702b763b9651ab2edd89b41c67a2 113abeae74073916d82527e52fa1edaa79fe45bc43fc1f00c34668d567827507 010123d5c37d6e29a65c00a735b1561bd5cdb8d331097bd34725287074452117 5bd84f8fa4d53d360f71179164d5518a35e567ecdfe03d4d8292108700026c35 3c48988c932e2dc2f2b142706d1885f3ba7e413c74a652b29ec426fe5e586d05 ae4e89378858f4f5d86e8550c2d41a2c95017716f1de219d08e7dc0df738f967 3538db3a0a2c892b32077bd18f4389bc2d14c44d9448726118b3a69770a827b2 80743f15081be89535b8e85220784c68fb2f6fef84a76b2704be48c689a680bd 2842cba67feaf7f51e413256cd20d387ebfafbb292409e163c3dd275a6289670 9a4525678768e99594c4c82d4c82185459b5d951ef3100aef625e572c302471d 2ceaea82e157eeda802df5b24c3eac62ffd977f882c938c161177bd5316e04de 42afa3850cda5c1f63ee49c7465aa1a1af9b6d858ed83692766b48c94c6e1649 f65613f62b746e6642c7c82d134a4f52c6037b09c7b7461aeebfe3d1b9105064 2bad88604db71146c4909146e3975ac00c5ea147030a0734c8c00f9cfdc751f0 fded6eb3dbef57d3c0036dc8126b7f704573e1d2e637c3dea06d34ca16519733 f3f0ec6fe98c0065650beb8b15550a9b4640a384732ba29575fd89a288c6519b f8f329bdd53124c963da2769437315ed477cb79eb7cf5de364db4fbffb3e610d 5f7f4503e25dcf6fad5388bc86f2411fc3f516d7cb445309cc7372c38aa63166 4f40e010702240f0306b9e2ae700a267fa4d0c61ac64c2edc03d6422b75e805e e2405d45011abec0970a5f9dcf846b3cb67c286ec137ad1d497346ce7c56e8f2 956827c2dea5d34817521897c3022b018340e82fba6a1c47f56972080e2128f1 a8fb4628328dca9f4db64a67832976deba143d950a52b4eae19d59d143705c28 fbb5250782bc2495bc69d23ec3c4539f0f2273781f0b02f89a8e3edee866d30f 47fd116be0716750eed397d4147c223a0ed6d39b090938981d2399ebdadc2645 7b17e37f0ace22462f688340fccb8d38f85877c9aa46527993ee9000a81fd1f5 8bdaf542a1dc9f84ca90edc696fbd4bbc656d51ab884f16dde0833145168b4fe 3a170bd7b1a925972c0aa145ec8706b7b54f70259af9806b385f7d07f7b41c08 4cdb93fa6e8ad54bd0d41c413584bcd4514071f06d841dbfb3494d06d7b53a53 25ddf71c4a0d466237dd9e86cec96e867881b95723d3b9119439a201b41740f3 5886a18ea3b3fcffd0dd86ac57803f23a967fb98a15d6f9268a8b3f21b3f83a1 d3cf07e5e7948e87d7da5287e5ec15e6bbe1f4342e73f11d19b447d03e60e474 46e7356707a2b70d2395175071cceb861d1254a8dde7bffccd979a8c956387d2 b6b7e1fa7e1a08c05c097525dfc06f3ef97532f99a7b4fe673822397c1d19503 bbcf2916a26ccb1b3036c3f56c338341e7872f0a65733609ff91b5a6136a8674 f5b788d61231fe9387e041f93fb91ed227b92ea68660e942eac35c26692b738c 2e41257d147efbc687960b10ebaea135116e136bdbc13975578c25112040d977 997cc5cd12021525be4f3e4f36c5465ec72b8e45d7111cd89271330706c862ba f6bc3c467eacf8fc27db5de2fb36d627b5c18b8e708a09d166075210ef17bed8 eeae52598737fbc00f48b08f5afb521a5938136477d54ca53bba06bb11d35b26 c4876dc57ba45b514b7e2f2d13e9a6c4d8f1d46f1a92117befa6dc8f8b2e8e93 7a28faedb9ffcb59798d9930f82d1eb86903fa172c9a2ea9aa8d617d2676e43c 6c06ed42808dbc2010bae6a4746ffe2ca956df13d021194d6f50612306d4e02f bfbd93e37c2ca49c8c14116567a440e99b6f89344dcf3ef72db00b5a6a0be694 942b68847de2586d5366f2cf99da2a66bc4475ab3f715629db74e3e7657ff7a9 63cdffe9b55b5332ec5aaad2253c8fa8047d2afa7e94432d29e48caa1da41999 ba535825ef36c814464c904f7377c290c25995f1d462211e2665dfaa5ad00e09 1ba70f3408b55f083f3bacd6f14afd25e257bd417bfc105da93a828239c32f2c fd833ea7a72f44e26e5b5fe2c611c5962e1289412ff39ddbe9546d2998aeb333 7cbf0eea12e33abd78e86313b5591b049cb4e95ee5117e6c2e6e93e7dfef2abd de8b4d1f9acab938ef8658784c2730793221d7e25ce06682fab7022c5ee3eb08 cae4543b0e0cebb2744f21f0b848458ab6c7aff77c54419721bade64c5984b32 4c643598388738756c6eec565ed374a5ef25829988087a85d32f3dbd7423b103 cf28ba8bd1eeb61c45ad60d00d46f59cce2293d45765ca8ad0934f8c7ea98258 5ca2d07680787bc7b939748f0bfcd352db096aabb8308a561d4d710a6e395779 1ed89618645e1dd326f5306d53d7b5931ebf087ee7eea00b4c13c742ea2584fa ac11eb0a62e1fcdb3235b056d9e266d89dc1aed95e3b9e9cc81093ceab4e2f5f eff8b57e387572f7be9ada25beb521a320f0644688aa240e6e22c000262135bc 6406e2f60436644b2325e5b52d1861b1fd8296664837bc9336b588d9f4224556 a75d15b632b7ed51a31e5b54500c1308681af3d97af94ea958b4b3528a1f86a5 078ade13f25a704506ebd3de860f80ee7c136270920356b2c4075580cb18f323 5fe35bd4e7ae9b62474651b9fdfd93a5f0e56d7f4f108c5b10747a7c316859e7 291407cac6288d9d300e19cae8243058a1f07d82a9085506031b26dcd5d82f6b 3b67be2fcef32c4c526e9e572321d6407340596252a1532b90ea6a1c8b06aae0 ad2d56228e0bc3b369633f2cb110280381d0a6db250ce7d2f7eb400ee71a6d7d 43586ce67b060e1089a265964ae03f9ff2d9dab700da2a8a86f62253a55f5462 0af1ae2c29c04c9e5b72e6f2705f3e75a936724bd6e5dfc73feb0b12817447f9 89e04ac77f7b2dd0a0c5b2f7767ac507d73024bf300e77455883defd1616e967 fca3654dbbba3b7a005a2a27a200cbbfa09648c613a5b5fc9e8d3223b9b160d3 62c872244a7a958f7dbecd263a66b590c0664128a035c6683d9a5a2c9844f7c0 89e5db265c674bd94959f1ecf40351046bf9b2ac64c20714b584bcd69b06e648 ab012dd7acaf16236b4d44a1efd1b0aae6e45da2b19319e6586ae5ea84f6defd cfb7d1803e50a97081125afe74e90142c16f2c170a034423a116804f6592bdad dbe3a3d30777abf9062b66ae764a5aad8c9297f481c0925d15b730486836bd3a 9a8bdd110a53c6565e477f398a792d34fc1a1738a6851bc52fd2397083d44f72 54337e5daada5e303bb694df5d9fe5df49c82f75b3a8084d87c85e56abca3922 16f77782bced3600b798af539d9c142a963da361c682dd56764c563a1f0c573c 11461a8d6fa8ed7b1b5b043e905039a7bc767959aec6349e58f245279c605c27 dc9cc8c35d65393e6d4b26bc49f8e85939e18a141a4a2675d3a53ed652be2e56 2b048f81d0255b3ddc07e5b568ea8dfa83a6088922a51b66e07d7103f4d53b47 ad117a16448286f565be2c14be245953381bed756eec61c751f2fc3116c59eee 43fe96e449befceb4e5945c0b795d3f87ffcbd193876ad40ba2cbb9a373e059b 9a47ef724ed5ed09298339054c62abad7988f84c95cd2d4626faccdf74a94e77 6654cfe4e18d7eed08c14fe0523519db602f927e60b9b41e759738143be4177e fa2ad87a0a6128a7295157fd7dd932d6f7cfd39128ab8aa98721ebf6826d4f6d aaafd93b6e78a4e01f92d35c97f9fc28298d849de7b14f5b4c15ca52bc77ee21 7d140b826bdd7bc58b84fc1eb68891ac2054bda10e937b969268febdbab8e760 45c044d3e7e54721684d7a20b43eb1b578fe1d5a5354327bf574309dfbd541fd 79b386ad5031c210072e3c36b68bddf2f58fc76d45893dbf1a310c5e5685f64a 0674ac42f081abede7789b72de96f447e68f9fbcb542e0d6c6f9099fe5249735 7421ec266f8d241c124062f9d3252a250625b0e4b01952be05f01b3b1c9f7102 18d95eb62e2aa9da044dc13b3654a7ce3dc26101c07b8287be5b65eb6dcea162 089d5b9806486966272458ab5b6d0213f0ef53cd32d98972360f1c6689842923 ab3c2ee98ae88e3d4d3cfb47ce9cc67ee308f911d9d0184cff586f17cb4a5454 db4dd96a7cfa09810d00595c94b55ce3e78dae1d3cd027ef3ac9827a84b2c603 301c49686bc2b6ce5e948ba8d00ac01a9c1677c7a455f38dabc4ae7f28495977 3c0f3199f66efb19ee7f7ef8fcda7a6262c50ca15a440361cfe4392791d1fb30 a73c427b72f3c6633d78c9eae4e0dad0132cde43b72097b814863e3dc84dbf4a c44dcb6f299885ff77ee398fbbf3976d407d32f786f0a1b146383f7d58798d71 6588faf085224ae2be5395ecf64099b8de7225582786f36b982d0de75b37f448 79ec8a91dc6d90b38b3206a3fc187f58e995a2a5727f875706747861ae5777d9 02aa934da4dfb1c3d2a1a06c26e285467b37d5222553b0f742791457c1b4de3a c5b9bd4f2fec8f9c4879965043e49c4fdba0cf067fd9e5eac615247b0cd01cf1 a055e9c8af9dc14831583c792e026dcf69ac53807940a93d03d295bebbd5e4c7 23860c525eefae3db5ee58bf28ef3a5f83bba49622ad8f93f44d232f9678a48c 22953dc0e7cdc9475f6925090a55c7d0c23d4abc7565dcbba3c6eda5bd4b217c 3aeba840bf54d4a1ed2df33ca3fe7702b1e1448ef80210f91ff48b6788babcab 2a51682b860303c91b8f6e60972fdd056375d756067ac17b9094221a3f503017 8940789eee56d1e29c33027687af060926337cd742b8175f7d56ed1763c3735c 48f16c2c82988f402a439d084eac1fa4fc78d7b6c8deb7e85eb6048e37fcf096 24990d01c9f418669f93c955e6f880098d33c1fc876fd8aadcfc825f663ff786 aa308df651bfc7a03f5f02c3fe62bb77db055338e9a888a8c7cc7d3e7f85a4bc e3cf0689c432421e13978a3b4a401beb4bef9b9b9cd68ffa6981e3957699c534 bbb8005c88a34de2bca5916e637c97ca4db03b7cad6aa396afe230a8d0214c59 55a9252dcc37ff0db7c87b0468ca2e994d04fd11317c6377c2dccc9ace7f10c6 745917a3d4fda4a68343cd48a80d7d69567c6c7d300f32e16205f3022837285f 64f67e01a86790e2ce64fb9d73caf64758a5e916570cd46877874489ffa5fcb5 62fbdef22107ff12cb4d9c239408a62110de981a19b81e03631754297490f1d3 d0da367ac7d0651132058835c1374f72404ff457418b3aabe55330686c9a18fa 7f7b0508062adb69452bee901bb94a2eb13b3d63a9697417e85ecc639599ad71 d8ded863d86f1a9ef88c8ddd3a518da1e29702f3a555a1fdedc3ef48f45b347b ffd886eee0b044e7fc0e90108d0a08dffa51dabb0c92d89e7cffe895722e25c0 8c8ef846d34c9e7b14408d10125e34f9d05b4212147b5feebd6622f0a2179f7f 4293f9c41a38ca39c543f8b732865aed338eb5eb1aa03504cd415aa853220781 6ac2da76e9d5a71c2ca348037a0ab29815d41493c9452d342433ff936af1870e 08ab24021e8f7ba38859be3fa2309aef57ef7bc98092def4cea23ca21288f6b6 9166defc016d8b3a980a43fe69a67565d0452ce78784e1df60b3961480300f2b e8f0631f16fdbd7b0212793ca277cddcf2c3bf14c5498bee63f6d2fd2849f5ba 80c82310cdbbb3ef7a3d5f156222a91bbfa087f16d37d2311c2d2b4a9381de1d 41c55a87036b38c76301a34a3371320f9e2e23c8ee039dec7e060c1d25dbf594 5b639f9f7d89232b92b04ca1181a01f9fb1799b826e54609cc8e4105beb05cd5 0cea4fd125b8ebc82045a538d0d9f49f40e53e063e84a11bcc80f21bbbd8f4c0 8db16188cd4a16859fd0a8ece3202fb5a6c61372787b09f550973d8ccb4b3841 7016271244f18747f1edf0eca16c1bb8a519a20f51f934978ff636eeb604049b ad649c09099dae5aa85338204dd95115bdcde6249c4a70ceb4396288a0716cb9 9f3f040296c9b3d05a1377e586ebaca1ee2da41534c4a613e60344d1482d7fa4 3d85d2723c6ec81a7e034ad166f61e403a4ef5288d01c184aaa2c573fd23a748 8277f7c4ae7b08f1f0c166e4ecd6ef1a5b8463a6fa843a74521016a5c36461c7 bdf23d739866cbc08b5bbc00acf836de8bc16c3dda5272dae2528cfcd000e943 1cffe59415c4b1dbcd97fd1f531654ece25b300ef8497d7ec66f26be272db636 03402ebf534bd9543ed4a0e57a407a3b9f72d9533a9ffa3da4d221993cad666d d40c73c453373808967ecb2e1184228fc12c6b14285f398ecf3ea103417a18ff 1de7c816fdcbb4f092f7c4a2e36ca1d15c75ba6306c390e25d49ba42f504518e 49ca14afc63c17f3e2fb7d7108ae4e14b56126b3c326e4981a87ab9a26eb71f0 9a9eccddb22fbf73a3d737bc62ec0b285713941f57dc7beb95f12be195b1d076 bbe679d78baeafa45a78c3b006fe52d116ddfa06c383b37b8f02ea968cfcfa12 4e5d55ec282fb05c8db535b18a04aea20dc33e672a95ca4924d98d6829e1b349 c67bdfec70c55d683d89ad686a6beafe40f1f605225282768c9af93e28576dce b7d4a7c177c3ec8be02730abef39b65498fe6e82e8bc296c94dfb50b466f0eba b0a4d93fbd26ad5a2f1ac8e7f401aaf19f87a5832b7587f4ac65119f4f324ab9 2447803c0d1f0dc070d98a14c2182cceae5a7ca65415bd16f0288dbcb856b70c ab38a4618c6ab6a440be480269b0d381a7bc8b9bf847c0f106ec61f36df007ad 026b3846d824b072ec3a4d177161bd1b83d0f98a215754608b3ff5710d7b4adb c2d2931764fe31610d80bc768f9d7bd9f142ef08b6b63a82d2fa77a51976b640 877b04d185c0f1c8df51953b5908228710570bc8bf69b569ca664b7632e1b5f8 c8d77ddbf5defa854f31aad040f33de853e717d72f36bc46e113eaf28f6c21a8 5583fb3071cf817cc1ddee10d9e05877ba0fb802fd5be4f87b03b71a3f01d59f 221290c0546d2e77772fe5b0ad84089176465c838dbc55e29ab7400db21e636c aee14e5279b5c92cac5d6f2e62607627b86403339a18fe869b1115e8c41bf7fe cb278c2f98fd56a56e0ddd1198e7b9d4288126796c78dc4f3022600cb85aad0f 209cd8d97c21f85a744b958886fe3881581f5e141f183ae69539176a976ac668 1c80e915980dec7946c932360e37f80f6765c48a2d66c64f0325639903aff3d9 7b076a124918539a8ba65ac5d0008e9b90c94b350c1edce7bda62f1ff1433234 757176dff1e0bbce68c09029b4e8a6a2537f043ffb7cf7139211378bf4a034d0 73b9382055a6a4dcb700bce2946705138122f8c67b6b7789d7af4b3427baae18 1af2a9fdb0cddbdd9420c1744cbe9f47997fcfc92964e143fcae30a8aef7acf0 7b12c0bb4b17f7edc2aff342d1d1a50872fb3949695db5d22c9b4cb5251c38f9 ddbbc95e13f0df9332739088b30d30ae4775428eae4dc55256cf7bf5faad42a1 df49d587fdd4781e4379766f5bd8a31caf9ff82edf917069aaab25b4754e23e9 577b3dc6b73a4f8991005e19ddc75d1a83ad7114c9397c2e2ea4e2225f8aec0d 438dc172379e0c2e88a34b46b39ef2504082d289c6972da1d46b54057efd5abb 291456b3e3e85374452855cdf1c6e9ddeb47e7f11983095fce09e90366535d54 2589335a7e8432f9e8ae1f35c4e588aa603db8ef9398746daa422bf27dfe2aa6 86736ca258ddaa6ffaa1c5d7f2fcee8923d56046c835f66dd5d81bec5ccb68fa 7964251a87c86b8830d144bed2ecf202b8d4f8d3e1589af201e29aadd7ce0160 27bc3b3602c192d2d02fc9d0d7cc557aab927235172576193a104abc4ae0d747 daade7e09f9ac556e4df3c3ebde7a2ba438fd4c6753b1e7a251141e0e74d26d5 59d6c261a19d28febad26f83c2d76556832b42229b8c52b1686516ff9dbc246b a0872d3801bdcc5338c804fce9cb50d49ca570172568eb88ab297bdec90d6b74 2fab0afd9303a8a9099c0b8afc80057f700bb09edb01c6a55f9a24ca98740791 f8859bf2103a57a35c6a40e001cade3cc399a13d99d9f526b3f41d7f38fd500e 3c2ae69f039031f940bb23b94766230743946cbc592324cc4069a2422876a280 36189c2f84bf1c3cc9659420e687b2adb1a2a8a806075769367efd29f5cacbe5 be98d82986f49f7604b0cb45284d2e2f5b4b367e9f5824d250326e3674084b33 2e848b42f2775e128e1aebe0be8be5a5fe9a176ac06d0480ea8a9bce2a94cfcb 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 true +check_ring_signature 01504ac79366978307ff9ddf25e051817a2a94f1f71e5e03b6fa0353ed25e6a3 c26444038d90ac980e62ae2b51e8bf08eaea3d9e42ebb9a024bc19ac641e4826 2 f7f38889ea8803c737651de3a1be85e5403f4d742a9165e6d36d760e1b1b9342 b193744ea1cb8c2a6e780fda538e776343cd0d6c469c16e60a62793e1fe62bc9 77ab659d67aed19f3a98b3a79d2a11fa1dff903ff3588c343ac6f43139e43104e2861a14a787aabd4f9739e954a07276722d8dd9b567b8b7bdff3ff97dc5b30efca0e003a4017c33d224bf4f2ae768ec6ee51284a06b855faa9a50d643754908f6875872fb236c17354024708e507275e061096d7c19610754161ee45c8aa40f false +check_ring_signature 35797ec034e82d7115b1afeb1f25d33a74924a31d4a700d86b3d86229fc61d26 7f4933b759d6858bfae06cf5f75920dd3fa9ce3d69617c99f3737b1281c577bd 11 bfcc7e37e8eadd2d0d07c322169db608a54167f73bbf741d3e748cd66528a0cc 65f406f067c22a17672da4f239664383b79fcc742bf5f4ac351a79ce1715ee90 6083795e4be4d78df4dbb395a2803e9d78da987606ad25becdff0dad8b8cf554 e86321ed7a2d98dd8141956b92deb1c022bf582035c30aa602a93620cc3d55a9 af1b203c243c67c2d8181dbc3bf5f808c3572b1e68e7328a096a0105eff1ede2 dfcd3d3faa28c1f2758ae832e24a304dc348a7ef277134e174cc9df6b2596fa1 df927d46bb6e562a11abb68d5f424f90a694c74e633df8904ea8207462d9828d b063887cbe1a4695cf3e463bffda4d37938a3551f90fedbe6a1d976f88198f62 f886ae46554fba2c58f14ffc73b7e67c5f15816ac6d37c94d587340bf0924e66 3c27ac545a5158cd65c91096dc05becb17797ff3089a71b9b897478d5a42d64f 4a154c73814b6ca7b9dd0bc852962ad3ac31c40c2090ab2c36c0b397f4e5bfb3 fa7d81fa5aff5ce58d437537b30c17fdba40442169edad1a883b073f4408160f4aa7f1eda2a91b4c41449a5d3744961a4c7ce91c6de28a30a6ad903e2034a501f398f5be17f79dcbc82761e896626b89697bc29db9e6c0720951482bd0ae660b24711cdb8136df34686cdec842e9a9df12f2fa7c0b9134a3549d5c536724ff06a59f334aeed980ed5b347ff4ff8cd17c00a0423ae61262a907d55e6379fa90094939be02fe46d301daeec9423b874e0bfdc190ac1134f47623685e7fa6ff400b91ed7668d2853f6180d090cc6fdc4d3df067a532a49e2dd3d185e2f7656a41044dfaaba739b2832b2d23046fe2f4785694847599aa3811efd34a82b3c6b85e02268b1bb07c39f78b52e6570a852e702991e71ed74cadccfa012be24bb4188f037702412f97af8cbffd29ebc39678c82ef2747656bf84bfadd4b4674ecc13e00669052075ccb6036754c00fea85e8e7919d1aca719783e60005d85101f242a102e867ad893f736efbc00476be2ca3f8c867517025a3739a99e103044b903d310039d68db2463efada8afa6782414cb8be7e36d8ddb4ff360b6ad059165f6a54005ba5a3b57c013b1fae15f53988d251c510735ca7f7a7e35c2c54d6465df4f900032ffd846ce6f962cd53fc3eaa1c1e177b2c0016e4151eeed53d1909f100d4053c23ae2fd52ecf6b610f04794241a217a3ff9ea32c32a65e71f77b067de39b0a8e352d4885635f4933392ac239e1a7099db070e0888a7bac26002b69c5ead8058d869f994b26b15afb901b26ab0bed42d2bd396e2f91b1d39e8b4a6ae144f10b8b23c2fafab267df1e1ba23c27033ebc16584a215b076f601343895c0117a70c87e517f292bfc134761a6675a50246b4df9089422d212060cf335982e3a6b4089045df6eb8abd10bbb70662d4311a3260536abc1c901a2c5f6c7ce6a3f8db102b05da28d030ba7f999ea460c4b25e5c97a59ac4da0e712cc3814768341537f99 false +check_ring_signature aafe6c3ea403560f16f1b0626eac18dc9e2289e4d5b60a3cfd395d0c30f521ba e201127f954270cc047dd65c55a688a0a02c261068e3b36783d312dd8bf62662 2 9ceea5d814f0adc86e394b31d4e89ee8a49d2863eccd92f32c24f42cbe460956 ba91cd9f52abec3314a5d23e9550d760848ebdb386eff32b285f222a8e1574b2 c9b122bce8657ec3b9348548a90207598208ca995e49e61c73493e911bc404c400314e6735969e7b2ae156cb141848bf6f34416d132fb719acaa7ce8e19a3d06c5d049ee5413c51cbae4bde8223a457ff15a0b127d7ce5b2ec29afa50909ff0cfe7d95f2cb8956892f22d8fb01a169fe9be281f83d24ff53b96cc502b9fcaa0b false +check_ring_signature f97d4e9c36389eb32dca83903d86e738b412d0e719fac9de9cb1a79deb5c5f87 a710922602dd9d7891df50d78c8df1dd244ed7258d43384378212a09623f61eb 8 e360cc0b0d54a051adc6eee4446c516d586d5d3abb484c792e15b69c1376a392 b8a788bf7dfcd8f6cab88b156b04dea2bc337c90ff783f75327a7c32368b94c7 4ccd4f2d7aee244994139bebf641fada943bce4c7a5fe96b7f1691a033c97b3b 024d0d3dcec8858639fcc7d1d711d64d0ecff4c51e86b9f00a31f74b558593fd 990bcb241da35a4edd7b67a9595c66053cb6f56a18b28eda8fba2ab1a0c40b3d 628450cc2fbbf75ff8a63269bb004089b46b9041ef45f290813a3ead125d3f5f aadbb083008b069c45bd0838cf9dd55597982deada11f1a6f0bbb12db334b984 f7e4485473d386ef3f6beec68c0c31ab7902186b4bee28012013307604a14ed5 89e0b6e11d9ed3595834d4448516173fb9bfa69bc350442e82f2ff158c72660dfc4f03ce65c088d5d3a988a9d6cf98d04559e99479f2daa4deb9d156a71e120c109472c1d0f0cdf12df970073acda0db505d4708cbc0a974c83312b1e58fbb0318efdb085296eb51ea81de0bdbe0535c864c83851eabd0df9789e75ac0179a04f9de1ffd04f2f4e3b205750858cf7ed6a5694f90a3d7259582e9fb0e644850054ad2bee7f7c75cfbd32d3bf7f6377437d99f818bf844bcac079579583e5f4401d5c0b79b94bf582b2fd0cb9e4739b74d71f235e1d8041361e53ad85e357a620a0df80e51d66476af588468dcabbd399f5a33d003f62dbc34c73cafceefb64c0d301ae7937538a1817e33030c11133029ae10e05b4d89bdc22e65aa73b29ee4004542792c62c62b9faf8c0ad356378b989356c45f8af36d98efde96ebb731b2099058f165a4c15c40182a4b87fe14849d19e9f87ab1bd9f1ec8a24166dda85203ef7e3be56475f20ef58f9a67e9e0ead0f07ac6199825ac7768e4a52add86970dafbb5b8a98ecc0192b074b6da1912a85bd26cd2990fa126a460be05a37187b0e6fe5f20b3466ad71233cda314137910beb7f4a8f92889a1f42b0cf53421cb502d8eeafe6cfdd5c02a9568a45a1db2e1db53451839e39d09dca7426354b3f0904bf941341584735e926e8fe9a139322c2f6bb82bdba106f9e2825ce09a2281407 true +check_ring_signature 4b3685c13ee27fa3c7c4949b799a6d61cf3fcf3dcc0b0b5d163bc523bb58f53e 60e6f33abf3013caf974260f3150460adb67772965a165ea25bbba1ad20f9ffe 2 4471da1870dd4b1d670887c52da935b786155ba1f33e4f285f13573c5ef85b5d bc140365276347b7ddb74f1d9709a1dc706b8c4784a8df0614718279c0d5fd5d 66caaccdeee7e254a5894090ba8295023384d4c34f65233609829f7dffe83805e18bf2641d51d564d53f5a5604e9f0486b234f2465e35ceae867d57cd9885908887ca45cb91c0cb1f3c061200fc1cfbd576ae5c47265a118880dc96ff44614035ff3c62ed6d37853b081f1b397c2f1ad74e96f87fefd502398b7e1deac4dbe0b false +check_ring_signature 91d5d69145328db2b0456e9137859f9e2ada43794858a0f65060b31186b1733c 68beeb9ca45266b16dddb8056bdd44a76716dccbc97ef89dc47cdca8c2350cb3 11 d228faef88768e5a51eb5bf1f70bdc1f37abf92fe02dd3b767236a26f6d93f5b ee5caf80b4dcec7d7227ceb6d77fd7e692e19953700e983b671dfc9d38705246 3d1286dc5ac990769b7d2ae70d65836fdb19b7927b89c4fc19bb180ab5c4d263 bcc29ce010c0a61810fd7ffcae604749577b079b64326f16d86b0f51603c9ff6 11150530c271b48dacc42f2ac180e3838005536a5d8d35e9e613fea9c26d625e 31b189ca5b0faed14d9d44afd6332371cf39c5787ce63bcea9b2a758859a9d94 0f3f6e35b20a11cf37459b579c859fa1e35b92b56f04d1a9b3ee1a0836e51740 eb9cc00929d7ff7617631b5f10a15024be3a1e8e3892dfe7e71ef41f391b87fa 867509166d2dea7620a036da6430d16b92fb6e1ec1f23a6114595e5a57897976 f543b10cd9558098efb7cb077177e311beb27537305139e5e9beb50fad24bd25 e8fdce69689a8691abf8c2349e91976217289b573c7af1c848f92ed46013fccc 3d3f22cf0859853f3954c6f39cdcd0d7338f2baab1a72b32a533ca2d7da50606a2ffe2d032751b2e9f1dd09d165d608895fc9712edfc7fdf49c8c9c0a62b8b083a10098222594efd0760dc5b8ab4761cc4fd32946278c43715f126baed8acc069cbfb6874cb61000b194ea30046c274ecfe7347f9d9f79c8d33f3fb0d5d1cd0fe055a9a0161e676cf18df3ac5722e2984111255926f87e3a768fc237476d5a0fa2161f836223672a098e469f2b37904de7f229fe4d24b30118cb99978a6f3900ebc14a898506224f43394ad166bd692859f015b27286c5fc56705aa8a4d25549eeecf5ee8467bd4287dd6ec922434dc2c87ed567ef9b5e8367db9ab0da1f8602285237ae23be9082ab92d32a41efc6994f228148dbc78537dc97953a6e51e90cda0336f4beff1c166b8a4b9b424e90ecacac60589a466d83d2cd6dd24d8ba4052b9c860df7d53a3cff605b8c21f4bcad637d02e5402fa6d0fcfd23fdcc87029ae17ed35f861a1df56e3c12bf9d48fc80044d09d010c774be0067adf315e53a076e759732fe77eaf82b305185cadcdc01f185be5dac89c5a4e0df908ffe3e2d0a3faa8bef5dfc9c81db165a95e6f98e76ba38a7aaf3a1c4e3445b00b6ba157f09067fe2adfb45328bdcc44c2d77bee5c41760fc8fe14b0ad5d68cc252467df20dfd7dc1825f5aee65f60b082d8391a25ae04511e9a2136856fbe2b863021d1a081c6e1e47f799c9a5195f69264739ac1907f45c4623c49f8b749a105b60ea230f338af872e1928af743297d56177ade12ff67e07ce294f80d13798387b42b07c25c091c580828074dc851be60fddb098fc461cc34ef79cbd57436600d5c58b104556ca5ec3991621dc6dbd79abd387a5c5d75fda3346596599fa1a6cea26c4c09827ff05c304efece79ddb2a2f194cdbddabd54cfb8dea050c72a0dd19af0ed09e99d3069666f4ee33b4a7bbc0c311b9e5d285a5b65d974e38256ededb602ba00 false +check_ring_signature defb20ad4bc0f1625a3a7fa01e434e6e1bf005166da5e57af6ea2c38777cdf11 9d6fd109b16512f803bf2d635af6ce6d7fb669f09c7e5989f1cdf1511f5c0c0a 209 907579631a4adc0a3356241e02757e7288814e7de59ffacf3ee84000adc2c6dc 335038456546fe294e80bb7bde66cd7e9a9b9741ade272e630570f0e5bf063e4 7ea0141d7a32b35e29350f551b547ea6b58e1973e6687bcd985bb904850bd0ab 8560d53670b847103d090f0c12661842d64fd84d9af9d3195dcd76a32f5c1589 622163fa4a24b865b48b4904ee9ac66d751c91e6555b50dddf27c43486d8edc6 108d2501c9e4aac2e51d4831492e8f4eed7e5c2a5a6f4bc7a456ecdb7931c39e a794cf5742dea619ae47fa9bb26649d1831b65fe0005e849449eba7865336221 b3deb18c74fff3bed9827e81b6975091d4c526b98b57123ca9446408584e413f d4b79bfc8f6e2d926fa89be28db8210772fd180518b9e92577b026505c013ac4 9a39b2c0aa7e7e0e5c24461c8f70cb93cf525177d4e208ab1df8196570b0d560 d336137c5f9db5c78c828743330df60c01e053202acc681079a604e41cdfa2f6 29c10001ab4d6a4a0c47db2a756ab14b02f8ae2927021b7d6189f00182ad42d3 c385fba71020a0590bfd1d136089b559b557a20e3d25297c3599f70e5f842536 5d789c5e7cf6fa9ca565425633dd59ce5edbce03447f42095afafaf9dc459877 ece7c9e7e7d444e9f7e7736391050a3ba0143822b75223907f8d836f236e711c 3a5109aaa94ef372ee51ffb1acb95cac27273522c895fbed23a557108f87c7ea b11f1a1ad1ecf6f1dfdb3fb0800645c40b597eb9f01622e424a878864e245b1f b926bef605e59b92dd8d8aadf44ccc8da4207f29bc6023309dc5694686d222af 5e550e3e872bd9bf7b2df50711b2ca56dd2fa58878ec3d9e7de5a3c79f3fd473 327ebfee95bf62f5a13b2a80caef70cf972a1710d77c84548b4af33ee1dfbd4c f0d813961fb47f211bbe3392f35954797bffda90f690725518e664234218f755 ae06b063a398f282ffc7a67a7b196980df904ab13d431445b5c85330c55de7fb ad6260a88d89c0a2a09cc33bc1013161e1d41bb9b527466b2c10327b5937de5c 4ec0b6e5ad2293e0c84c1f86008e6c66be4947be47adf5f2877671f214d8c334 5a5714d03a6bfe53b61587b9a43855624724cf1beff53b2cc116489b401d8041 ceb8664ea417714984100764c8f367a3b28b8a4cb3b6d9012795eeab3d351433 5d554442dd4f53767df674ccb13054265991594505d6086209587039ed79a40d 40f3350100845bca3b77afda05734df0b09e43ff7ce01ea07cf6913d99e900eb 778d4de649442440f14d831ff89bd0b11a07a8a2499d229a9f247390b42dcfd5 5f38935af5b467cf52df88eab7a6146902a970b1222675ccb18cae8a25155af7 fe086fee2b6c6ae919296e9edaf2588244ee3a93dee35292897265b8f0d4f1ed 4c5eccbee0e669b38b37e9265f0fbf3315603c5c2296816de1a6b75bf429cb18 c7d3b3ad8cfb7536748cb417a98e02192f5ed96cd4dbce763137a9c39d1bc9f1 66c1816b86adff57e3a4e5c2cd9c77afa6d2a5a9049bd88f50511639581d3d8c 544f3e7bd69abdb080f1922e8bda2500269cc2d83adfe715a2c6bdc00d8156cd abb6103df565691641ee631c3c6e32de771eb991870e96f8413b824e3d17319d 45518990b77d008838a5fd9b5e7ea3f1f13a248a02f31688e7934543d7113697 1b84c6315fbbe4ae9b5dbca7758326d3cd09726055bc24d3144c2d08100953e0 8e5874c6cf34b75324dc811e3484f0f26d0ef0d6d07d2dc980f7078e7da6cddc 8f78ac43efd3488e98d6455d53ee50dc46a45354ef55b952ba64eab61d2cb6fd eb92db68cb9ffc9acf16a92c9e201c74bbf877a243f9764b6598608f20965738 cf4cd948c2510d5b830291bf28d873df42b0f72ac6d232a8f8b50b2089a71c02 326ec141a2cb2105deea27574a7cea9b55cf1fb590de439c03f7c8280efc0c1d 06c82eb97edf3b002790365317663e4541ca3ac03171d9500363731489d27790 b3409f12e6ef9589d9c554dd8e9b68097dfdc06483372944bd9667ffb1cdb53f e61f05e7e0d6da38ffe8c2c759b224f66c9b04ba2c7376728add648a1a0fa8fe 31f5b9e9e4959d81eaea2866d94b3576f852c785edd5f93f2fcd340815a354ec 4067fcecc0e487f42070b4b28479ea813c71f5bd251e47c6fb48ff0d40525c7d eb24140367a4a54307b2e504ba9e9652e6baf1b280520eae4bc9e98c07008ed0 fcd595e9f02a1e786343a8a5bebd5c338e35a48a282f159f133aa2fea6bbce09 72f93d6eebdda243de0b2cc1f2730948ba7c11e76c690b6faebdc107353eb756 8b08c2bc16f45c3618e6dd630480e9f61256c40206fdf70464c68ea6e20e48ba e665154f0889822967f5b5d105cdb1d02bd629dfa5575f4dc1caecd059cca524 4cdd82a7019501a002e0f46eddf0e5af584bbe576e8912fce300e74412c49c85 8910349311804e919ce48eef679c9d06d254043bae6ce637877815a51914a90a dc088f823385bf5ebbe589b2c3c8da54422f30d17341980934349bfd6c9b0d9f 1683316422987feaf1330da9049ba7ea9b136f73018d5fd60ee9ffe790536901 725339f431e0b9029ca24ca06998b4e942a622d2e98d005256f577d2f207fc57 ae049df038ad8965f7b9a228d1a0ad23b77767d94a2594452a69265874808c9b fa740b0492cb9524fe048ecf1fd896eb4a87fd155fceb0baa3a2e58626d494b9 e8bc1b3559bb8891bc003b4f2ad9ef8255ead8af3fcdee1fa2b5b4b9554bce80 12a10cf58537b8de42d3efe0898d12273fe82360e83de3485711b50310867968 43f2e9142649441cba183e1ba31c69472d06a0850c5d1ce2f92fe3aa28705e3e a20bcc088a09711c99f958199d2fa561daf78105d00ea1fc99da8ba15505a35c 6cf9638732036d2f6e3e07706b090c26a66016478e7eb46725c569df99cce55a 32096a2e26aa4cbb7f72db5ae6fa4115081354c970cc6045a1071e5488a13141 5379695b58add2d6c6756edddf1ca5ff2eed14bebcaffd10e5c2387e96eed9f3 d0b0bdc311e217e49b3c41770a57bc6faafebdabe0ab4eb9d79a63dc843a2564 fba1afbbb053a6a460a8ea1845649da3c4f7d52a06fdc3d6ceac6e7c3526a3be 2ac3760ab2c809cc5b4bf72fb6f03f34799323937e16e2cc0b4b02f8170ae62c b83e07e712fe1b67a5ff4ab6a8f2adae915417dce528cf6f95430f87ab37da88 756317d8cc4d7d4263590f4ee278147affe94c0d966ae0c0a0f532db54f7cdee fa1a96852f6a864035f2a11a89ce0275111687dbbed469433455f61f076d5d76 92ce036dab131c6468281cd0d213ba4bd05549541ba0ef83eb2f784b053970b0 12b4c7eac839bd9430aac561b5706699151947ce9b0a221b6d9e86f4eee505ad ccd7bfd7c808b570f111c3c852b1c42acd2358de66ebec74319b56c7244bd91c 2c817d520929c4ae6a8758f4a6bf0e9d491125df26c4206a6637b712644cbb74 9c0456cef1b652a971692224fb931101daf1b828840c0b8b6e46acb176f2622c 838cb78bf072663411944bbe9c1ca69e502762470dd658073fd9fab6b7732f39 e462125f89dc93837b8c32cbaa7e1571fab79b27ff0c99ced6a9163f5b1b5b68 8a82ad54d6df05e34e220ea5444db184a49ba249fef26fbe8373d1e3c61630e9 06ec42832f8a89f6b0248b10d381636544a756e43f87cf65443fec46518d023b a0dde39694bbe8fe22760123f62b3932fe8a97370c384454024e51f66c82dc45 8417a4c0047074c3affb5b93db8f812c069e4d4a4bcce823e1b13d01b98707e8 261fc5da14f48b592f4d6ae5c7fb83d7cbd045bec28b40c2f564a2d9a1d08ae4 e2ca5c99385a3971eaaa21f862c9227d6a9ab3d1161ad570e1c50e83dca18c1a d9eb0b138848c6439abf81463a5987c56fb2dd7160e455a25c454b1c09a3b3d5 fa7993d710487b5d9fb15f951c7382f4245956111a35f2c95841c5ae158d9992 2a2bab75b87457adc7df69af6f0c50edd96b051924475c853ab7ac96df8238bf a11b833c67ed5f09c295cb1c8c92bb0591bb74455ac1271c7ac2929657189f18 8ffc1fa001e07b83e138c05ff152218b1197a8fc15bb3f1746cd77985811c522 61f8f47e91e0fd4ccd1adedc48cc7067ad92a83fb4aec9a3afb3a8440e87b50f e2fa373b40caefcff6314da7f4bcbea7133cc8babc08b1b772926b55a85e2245 48681d3a48918316910e0e02da52068b736c9fdf6dffe06a3e55b0d50217932a 149bb767361aec1dc684bc3ea6def29ea8f555e426c3e40a2144278e21ce51f6 67d6af97f2037ae6cc880ec745586c11b2a1ae01fb02d607d38ae42768b0d0d0 41a5fa3b4c22b36892f0a563544e8ec6aa25b9c2a3c8e43c76e8cba011ec56be 4b85936372eed7380df021dead81437eabaaa9ceb0a256ac848124c999363b26 812e6013ab6584ecba8e17d3b69a8e73b95fba1f3c6efbc975dd3d1addfee70a ccdd24665999ea67070afdf91e398b7e984e3490281356adb27863ece43a4cde f1810d07955710f13f56ed8d3bf656f40d8f52205ea98ca315fc82e411eb17fe ea6f46a36086b2e42c2de096671a2410662b245dc19de5df80dc2fcf1bd3e2d4 c5d92c7950d1232e01d23ae691a3454958b9c5ecc1696e49e9108e1ab74b9f21 c50698fc4e1a8404930a26cedc488ade9a4f7b9deca94a124e56cf910540ea05 b6472657fcff3ce9861dbee970e2fbadcf6aca1bf87324bc846547937cb012cf cb0c26ea208d75cfdc9ae9e28ffafc62a886f577e2c766945fd4105dbec789b5 b6ab7a39277ed5a94c5900a8f70b0e081b1db6cef66b66333491a044302b7b8f 99aa6fd54e2a55422c976f01cf26e4bb163bcbfe4404db95b0a0c230ee28053f c9cf3187f9a0208b8403fa26f5c71aff91525a98a147e38f28698caad22fc1fe b05417809638411326045f00927a702e6e913f44a5dee440f1382121d0983848 9d2211c3fd7fe17186939a9f49ba97afd0407ea17bd1bbf779c8ae73a5d42a58 ecdc410757fe4155b679317dd626ecdfed39beb317b01b5ba9f7f3d40b6dbc27 a0e2ce926589d49fa5c09918b3a6794055576f94f886208f7d2237ed83797967 4a87853f91c23c153307fc1036794c480dcfc53e2bc8b69616e1094cc1157e1b 00f51ff713abc2378ed9f5b0bfe7f82f9df38fed21f647dff4c2dfed70ca0845 0d36158a902276c16dcf58985eef08db7486195f034b33b567ee570e7b6f8a32 0b3b56e6217914d34062f45e4f0b1235a27dbe08e4da2158df17b465f9f4bb26 f807a22344936358de79dda9e47bec38aef6106840731ee6bf698aeea1b92d55 fbc06d5b7b9c50b56099c5bcc8e04eb1aa7b42cdb9e9219678b9c4938e2bcc96 7193e55d556220822bb2d9f51302a9a8b1c523dae3b1004b68f68a25f318d2a3 206e6df53f4c94af60458d9acfa790a70e059025e0989970bf03b8b52395745c 6d0c6fc06afe964e00c2586cf23f39421eeefcea6af74418409fa7ed39d0490b c7cc15d27774d0db7f3d2fb5c108ca3a3ee4a15dfc65e662d7fe26b325a534a4 31281194e314fd5ea7e10cd2653ddaf940594ea64b4c4be0626b894ee36ee43e 755f01fdedde8d00e617e9941871d65b40d4bb0caed62ba105ef75445e5846c4 d16e885d9b4e62f4d7e426df1c7e613408a482e4ca60d393b16060453f0855a4 8d883ade599534ffea83e205a09bcbde20a8285b1bffc94d0b74c475dafe7088 d738b18ac2ac4ca47826405b46784800f57be40cc4b8af4d95aca992a2f3bff2 7a91a8768e15b9215d228212fd3f961f0fa6d7d8046c4b50c5b663058af98662 a000b2f61310d943dda2746e33e5ac2e123947727010493fdd4a7ac0ab1a99c0 1eab71ec60ab85776d99a118509ef9bd180ee0880f375133d3e25c034ecc05b0 f672f805d05d8116951623e3857eaf68c475d63131e1a3c1926041f5021e1fbd 42a3425b17bb7192dc5d14a7d02c5ca39bbc2a6480bc980df2f9494689dbd8c1 358fe5f8d44f2e9086398133a1dd7c847a3c1bcc070231e58bd7e151893a7730 45738fff039883cc26ce07a94502d07fbb6f39db6f9b379cdb4f6798fe4b0fae 6838ba53a71143549ffa95754782700680f47eb3aeabbc40fb1566e14f4f75d7 a062dcc23b9d1f12d6c4c7485563800d328416f8a2918aa6a1413399f4619908 bfeb27b8ad4f607a8434effce86b8bbdd8ef91a0b93869aacbfa720f6ea4373f 7eb86e3efc6350ca38c7133268e33a3fb9fb843dd29bfb90a7dab5ae4a3b92eb cd975b3cf5d312d163f589cb5ded4d4342e33e8d384e9c302e4876308b04c57b 862d90ebe20bce1570ccffad88ca37a2d1533904ad4764b93bce1d5384487aec 394deb98a23ca8cb481cee4bf9b0ed7fbf27dd917c73a92481d431976f847356 0347f6c69225e2dcbc0ebe632badea902fc9711a04ed89439d8ad2652c6ac603 5fc82593f36b0bce4d3d9c2f67c658f417a8780c8576ed003e85f8878364beac 2a5b6ada0cf953db1d28576641b57616ca1301171e20bec650193fa9ee3a2ee5 d5988aa8e41a6d421a89f11cb9d4ed1468b18320460df1bae0076e76a7af6539 81466fb4eeb80fb46834d318a5a91ca5008fa3b34a62bcc0ed0e0b9a8a4ed4ed b149691a6210f4095ac8ebea4f8c7c0602a4c472898672f5a1b42bb55aa7db9c 0b491955e72a0947e8dafa2c25fc408894b2466c26a47c5aeb48daf642115e85 581647d93c01c738120acce46f3cb3d9692791649dbaed4c35fc7dea89033e49 d25af5457874c5d08e9cff6204563067add715bdf89cc248a2b4b596519e1394 dd86b13501020894e8e51b1caf64fff2e2303ea712943b75de9930fc61a8b104 3ab5c9da8cb31f72b0348275960d1f0e08dd2409f1195c3fc36ec2bdbfd371e8 124172288e5e4453b26e1493e3b2397266f9111181caba319eae25e768b44667 6b7a059246136dffec064f6e346e91c7ff23d1a2214f80efcdf12f5c6741ea39 69ed732a7774e9b1f3cd0293b2580590749f153f6416e38fd17294e3b8cd9d1e 3c874a1244b8260826b135bdcf31b303be6c06a4615af4c16ab1f085cf74bde6 8a2c7bb3f2ce6c395e10e09f1cc97b1bda779954288bd17ec405a3b5efe7a6b8 12651a1fe812e2f4d3c70a7fd37c94196adc794d4584bfb17abf95180f63a1c7 27f499d5ad8d566248545140d4005711b61ef5f421362155a39fea0c39d5ecea d3548193263d5d2b646a424ca93f801a8270e809e9c6c7066951d8ad27ae042e 03eefc3645c3e452e87b63174741657a1a65fda4692a9c3c0cd455fbb3c8c442 a7ccb415c15226b870c6a2eb3dccef4e664d25f62e634c946ceff3da71304e85 d4593ca37c188edf5b118dfc892ed5d013c0bb977eba6cc5e0b9ba5dfda63a18 55b2cf6f8797cc70368e96ba299960ae6ea16bbb5b8d0e708e4919c95c06b92a 874c3c753370983d9fa0e432196e64193ea7e637d449905ade990af214e607fc f1f4b746113dad2798a5b9a41dac8aa70369edbb4c696f970b4ec3ad02aa3594 929cf4a20805416251f7ea6a546d4aa22022369413d9a5d7fea15d44e5c8b9d6 0d73d5982b6249a285c9a5ba81611d686df9bef305bc07dcf5bdafe6435105f9 65c102efcf0d9cb37a0a8b47823966adaeb8914fda8f24c4e80f15714f833f3a 9ac32abdd4483906581e9ec1543cd9c176a7e2e002571cdd2556e4fb0363620b 1b47925adf3b72f03588b2b6e10952ea77018f8b6e8ed435f55e84208456a327 4a157c998cce763c288de43bcbe8286b814e99e14fd8f30c7db222eaa59d056f 1b09a019d03b938eecec2fa1b3b1b73379498b735992f6495739eb446edd3ff0 447be4f34e99d4c6b90050559bdb13cad17e18fb9a542fa9a30cde7a0711bf87 6c0f8965bf97bdc4463bcc8e5429a2c0bc22e60409bea427180547fc22f9952a 2a2def434d54ac01f185dcb39ef40d132f3d6ebf518a72119efef7a67d27b721 2c2a00848669b852f01eee41d094e6ba2b6ca6ebc34b6941ca66ece763584fb4 1a3aa2ec3c953bf81e8ed8d0128dec6eeed1a9c105d7f176c3aa6e719c95f7b7 b6c4899179f221df95a2ad3b91299e90c301061063f73b4ceb3f128f9bfd4591 91013ec0efb74c4376ea9bc9f164ca0928b7bb22863f34ddee082cb88f00d390 890bd842e4448e640e1dbb8baa92bc6b3f35707441efbac04c77a49c2631d6aa da4c461d2ec733f558147f56aeeb9ff131dae54d42897f1471a28921e422945b 8553b568f52025cb263f87101196a8a1fe33ba590c7d4cbc8d4fe62ad45839ca d94df6800b4a1a74929b91306a1899b1a078b1350ae2899546702d67272dea13 31219fff305baca841d0a8fe5f77c5b34b5d5b401fea28b8fe9bf14e65e53507 677e11dab3c7e4a48466d7087883a2dd55f40a5ed6bdfd254c00a5b48dad6836 eb5de00d563ed7bbfb5c7548275d37e464ba7c88dc1482ee7d0e24907817fe20 86b2637d942f9daa5ab8495d342a7ab19a81183a9af3af3e80697dbf461cbb71 be3e4e23b945ac27d576325649c9906282418fc96634fb504a24aa92cffac16c 6bf3a7b0cbc915014d2a96544e517c62e5b6f2c87671a1b92100178cc21f66e4 9f0c42b5be9069ff2d55ca24f0418c8a751aa1832f5ea1b6f5befc14d170395c 84d7cbd1cb628c4c4ffd50b14546432420054498cd05580df2059badac3b427d 8772a3db3402d9b915f7508b2ff1db60d5e3504149f99e4aa07cd3ea0901c62e 591f61ad369fb2ada5a158e85427850f707397218d4d68005c70d5e278f39451 63c2e4fc77326bc1634423fdebdaf1ca49648f97e6a8a1381a15e47217c5c5a8 8f747d581406f6754eeb6948553b8029bb9e56f66fceecf49aaf8eab8cb69b27 37466434cf11cf8e2cb4480c73044f056f8ef584733bbb0e74622305a6a21662 507132e64004254609c3c8c86c9508c8a97301dc19bfd7fd8c15e99449294902 cd1c282c4c3a7b281ef1a35303157cf6f52be2a4d7cf10ca75482b1935f00fd1 d468f0fa848cd9c4bc22f7428207fbe1fe2deca06b6731e02b6b675425193d25 f6b910feb3ea81f554ffcdb389e8480a84e43ccee563823c82da89abbab90fce cc4496c6e6e2d28670e5eecdc1fac2d01881427986cbca55600fa1db796d72ab 0a8e9c08167ee671872882311e27b9ac6e1392b657811b18e2486ebce6062e65 2dc08da9bc599e5c57f608e4a27402499529120cf134d371a1312c2cc7045f66 b2379a3532946a4533417d9323a466e9df75433ecb93d3c8496fc990dbadcfcc 60843044166d026539f89c5a0398ea3c43e42fce6bfd4ef5dbe29635e185cc63 00d9d9ed45bf18623ad1d0369f60aba3be3020dbf49216099768d807f950afc6 d17f85abc4c40f76cc8c46a547d73ab280c84705534ed6b10f7c2b0e4868ef48 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 false +check_ring_signature 4b788281242e705104a6748fe7ea71957bc5f97374900c29d73f36abad7cdbcb 14cbcd39a8f6b7bedac51adfa5d6fb82f08d639cd7f9ec07407b237a7cab1914 178 7de9c6c1667245c7395752cecdd4ccb6b1530d839b70c3eaf1c98b6bf7823c34 8ce0d6e1d49757c6870e102234e298f9a6f230abc52b08a01fad62a11360fb11 367a96186d2b23625e0891984b69a789828f3a6463ebaea70fde4612c232bdf2 e6f459267bcbeb3229e025cfcaf0a6aba1308804f363b1b8615fd1fe569fbad1 78db28d707b6bd57823f0308f8563d504300d2561e00449fdf0763c83203da35 d10f6ac1ed0af50f5be172e06cfaf47f81cbd74393e44cb039f33cc3d92f660a 0b46a24fd76b9588f398d1ed2e48349dd627d503975a37f75a1f051bea260f8a 20457a54799787e3596a62857e7d545ab9fcd8cc8576197b6eb7672d578a5a6d 6a1e939b41ab4615cff7f17a8f4844d805e94955d8b85ea5df487be07d61babe 452d825b5b7bd81bd7307a5db41c8ed76021d64fe874031b39df25a57a9fd357 f95bcf52bf0df7393bccf7291d569b31f2ecbdb98c41039175883c7e6c3e92b2 d8aee6a97d864783ea772d01b79e3209f33113c08fcc044768c21b37fde6e260 1d6182986727d7b365545fcb2262b52c9b72b30405de9109faf1f6a3934d289f d61a017aa45d415f06cb4c4501d4c59e1cc5c23d6d470d678b472d632d089773 861dfba61aa085b018c506d9495ed56ab4d87f5d0e5ee56e0a0049dc976a7d5c 2d3a734afa7f2a1271f03c5615050c1bac5661c91cd7f05ef0e3af76420b6d3c d1a14afcb4ae3a9e4a07805c32486564606bf1db446ead862cdfb0746ae48690 f60e166a993bd69e6532ce7008d4d04e01d49282e81183aae285b68a111ff41b 0450304f936d725241b309e53e960c86f0a4e95ebdbda216bbd4a4d9ee15736f 8faa9e9808360dbadcac8b5a220d46481b75bb034771e460903fc786f297447a e9be5d432774cf00af58d8075cb5c23c28335d836f0d13267867b2813358f89d 421889be430eeedc8a1c1c0b2bb82b00e94128907a89789fa17b379007640c10 4e979321589eabde05ada04f08087f748c793fba73123588df42bf2c3cc43aa3 4a885ac186a0247077cf64568d5b0964cafd04b90e6818adecb047c86748535d ea0546b622246083935685063863d9edb48df4e2a2203832400f542c70e52515 9507c22f22948abf6e5707737561b876394e319807f3a810e3973f619b123d98 e745bd13b0c93a19993e092f064b7bd7af3dbc357631f3b639106784eb484079 959a16a2bf5b819e594cf3fcfbd54f5fac21d6454f2335ce52094082e091eddd baf979412ae03844a35de819b751175eb8023bc10fd03ec765cd28e4f03c1ccf 1114033a03732ed46ca09d914129ec0a9555e62a17cffcb286de45dd4e1a38a7 ac844c746c85bc63eda08a0a0d72b9ea874856f2612fc67369508a928a2ba3b6 ddd67fe0770c35818ee7ec4b4cef91c1082239cc4dd39e67587cf40bc4cc76be 5879d1d2a0a9c89e28ebf2cb788f181a938883cf2e63ee94fa7935671d2a6a47 610af4ff773ca1134a37d185850388e604b2c62562524399c4f8dfb892f08c7a 9443fa52babd6a30910d92e9400c006bd9117a42fcb3f4809fb7b4199d6a12b5 463a06ac908abe86c6c9c8ea3b4d06c8c037582f0764999de208d3285faa7d7e 7c3b073ce3b1befa010493d290b442a98b53df376137a48af5ac3136a3321ea2 775195dbe23923cafb2a93fa439404b882281565a2720c56aa920f6ae1bb030c 2d8141ca49085b028d9604406514ae7a5ff6e408e1a5cf01108578ddd95e1734 0535fd8427b6b804b46c77e5dc9c222e21f3f3f24276d06d9949f8dcb5a62a63 655b7914a0c989d2f9514b47e1a2221c109eeb4a083de0428d61bdcbf0b0f19f 29f0b209293987d750ce13f8d296ed519f2f9c4153a7de7b2191e5ecd1154e7b 82c7ffd05ba215e5c523135128d0f16b624068f19ce0ebb51af255b017eb4805 ae0c0a60a26050379f93bcec93927d0d393fdc89119660e28ff771856f58fa31 79fed1e61995b28ae10acb99f6dbcfeecd446c28fbddbcc0b465762299e96cd6 6bd62cebabb577936eced881b7f649c39969139e51eb63ac48f36339d4e16942 196c16783e71ed38c0c2307b5406bdde16c43b2320186fe2ac31c83ff8e89a07 cb65a6c6b4d8ac90912925fd6596f9c2c259b1df2528debb508ebe7933a0523a 2e3bfb8d0610ecddc157552cc0ec954d4f975cba238a16a90d5fbc86e58c4379 428f4758a3fd4b7b2acd3f5d6d949396addea6055a7ad6b4fb7c1bf9e92fc5d2 e44ec1afb510ea66a74a8d29fe0a834f1668acafa329777d3098ea995424803d 9280a0c9acbcc2c69d52f4ed26388e3ed7479c9cc7297b673bfea141f418d9b8 b6e0d89e3d15cd766b093acb8f93e2af91857d5972c84d6d3225cec5f85a90b2 00f42547d8e35ccba13f1d7c5f588f83466d24a0da937bf0afc5defe16205195 b9adfc3c9cb6d6e072ef967a559a1287f0f658f619215c7d327d4ba00c873fae 810d33584879283726f5adb12e592a05fd760f5ec07e15b315032cb516f68b25 ef0871082fcb8190847d798f0b13a17a596dd64ab41cdc5d5c7aca5dd43cf716 e15ddd735920faeccf7f4d0a0ee349def9102feee54b6ab95835757b0c672908 eb2e3245fc0165949bb02fe044c05d13a7511cd2e187dcb01ba1695064ffb86d 71e0e081b03b7386a56776cf76453f7a10bb9513f2354b1197cff381c7c3cdab 079bfceaafc339d193cef7af26abf1fb95b20cb86406f4d1122979b0f076a405 4b9acfa91c0788b5301cbc8bf13509635e1481fd57baacf4906aa5ce08f9f18d 80910cd911f730ac23d60d64c9afd5e2c5f1791d0e4919127dd1edd8a78fe502 73175e33c9a0cbdfb758d94dcf099697b0dfc204c4279e115e902c733c883791 721ba71ab5f72c777fecde9a002474e75e2fc18b37df770e2b9dc526d42df8be 3102748284282190d76105ac4486b21553317f9e727a2e42850f841362231422 238afc411d443fc12fbc1a803afe441f47502c9bbe154835e60bedaa9906c30f 5bec0fe2221175959c451137b0e937f9690e3f334929d98e0a02172ed124b9e2 d5fef926d94538ad84ef34f569140720418fee78f6c3f6ebe2cc42267f7f905d 5905e7fdfb3c00f443aa2ee70892468dd885ecf8d38c2eb8be7e31ac9d0b4f5e 29c74172a51c204dc99e6f37382317ec42dc335755a8d3b19f55644619d6b438 185893108f6e4a36fc5f13729541305cabc5b9a46b8ea5daffd59b10d1a01a43 c47b607da9ab115fba98ecfa2cb9b7f72a06bbffe198b350ac4f855d39329279 1da84da25da64e98f99b6c001afc609550cba65d58ba734b010713dcd08339bf ee18cfd2dc7d1a5e44d46bc96651fdeed16f50fc3425160042e77dfe16c3f423 a331823f61d531e0446fc36cef0e339839ea359464b06153e174cc934551d0e4 e79763e09083e9448e9abb96dd185f4266488f112ce28136f53d1440561b73a2 7586b83ffb90d9815e55f387cb7d4183404981c42a4cec108022f20b9c448705 c784ec66c93f37effe4aa8465ecf96a75ea510ae1e5571383fef836533588d4f 53ba8b1c33b2fc9ef2f8f9af4a7e908356dca3ece73e32cc480b08c31e43f3cc 57d767808cadefaf58fd27d1a156958e9c0ed4d3590f6def559c40477ae467b8 9ac2f9b972a8320eecbb8b99a8d94c07b14f87faf30e7fe87e7e7aa1e6844726 997d7dcc7591f53e3dc8bdca2022bc381a18c9d36cb7ddf4cccb2cfb4c22d99e 8a28c7e01bc27e073ef836d410019c2bfcdecd6c059281716ad2953acd3a2c4e a5bcf5683d79ed1ad5cd1c95585fad66575a00704d6444b8b242842689313052 de4e63e98fa5ce69a018598a0ba97e01754c1b8a56a7197f7a10b3f0610fe8d9 53d1ba96d0e513a364c5d75ff10be45fe0c6af76ac64142614bc0145d2742a30 b0c6cf40bb36b9faf8e6b07610f8a3f1aebb09d2160921822e42ea9ee2e7c526 c3a47543ba8695e9d439d88c0f1966cdbd5692d86baa1549aa4442f2b998dfbb 0013601ed05bc7f7abfc88e73b3dea29a02ff9506f884c700124255aaad9b761 82c77b03c8914e3c7aa8db489684c7b3cbe3c34312dd50d7f80394bf1199970a 1659e59c7217662a7ae40e1cd7003cf3627415e05af27c18c48446021d16d1c2 c6f031896a5e5fc6006a8abdd435c2ec28f1e7d3d6f00e90c959a5eb5e337b5f dded1ad9b5cad09707226df8cf2d37d862262aa8e6e3ebf09e397cfc8d82b6d5 6e9968f44c0ddc16de8cffee1f679c3f40d8f7acf4dddac68012d5b62199761e 44fa775f82f9a8ebee4331b13adf808a46da184a033cea8c630604524d8b7dec 7924e3c82d75020342cbf6aa6684058d0ceddc6c45b030ca0a3023ce5b7bb45b 7ba05f1c1152c1639a8478dc211e60ce541327cbc373aafd5281335d42879023 3a3397f5d7f2ce51921df3999b3d6e4f7ce6f668a0cac6a988855bbed4085ab1 8c4b693e583275a3b5b88a9217a8d593fd559c104da3824f412ab177edf8b160 b185d9e9a1f0d9ced94161a5d60996e7b8c132ed21ac362b6453a860326e0f6d 574d6603929988c44dcd20e0559e1ac405c100fa63088babfb5b1c818ae78cb2 232b082d27cd2079232e9ae12be1d5d14f0156a6273d20b6c192f9aedb6f4c53 381a0c202bfd75aa9e292401a882f42ceb42c34de412a3560fdb8685baa0afa6 e096e3e9f4045478f09d54be9f4548882c3a91756796111dc5da7da7ce113b76 60facc1697067e7f4327830ca1329e5ef10cf02bfc5da0c8eacee61a682c9d36 1dece56b0597b924b36bfef955b94e7db62bb543f54283adb57156a2adfc677f 103e70a56347fde05614f1c7fff91d95b5fb42614f60c259f1a06f78253b26cf a62f539b99a79a89d3334fcb878733d78acd0a362f68822cf09b981ad363dc4d 47a778c04e01ed8d01354619a460146a8153cc46fb5a9a591ce9d266e4d5a270 98eb8938d43d2f4dd33b5e1cf9ef71c4242c2e745270cb6163ae7c14fd78f273 f7ca24f3a3848914166fbdeea4a58f33baa6cd2c2da7b217ba159facb65f451d dd2a767b6025c5b347da6934f806bf7428424f160bc89b0acf85e479230d9f69 39ac8ccb2ac891fc6eae2afd32d6e2623783b74dee727c86d870a5b8bc4d9b33 b4f382cc9bc26d7e96e73f92c0b3938c94e241ddcd8233a5c656144204f5cfda 028e31ddf31b0651133151d21388ba73f33bcaa4a26906d28a594259b3227d17 31df05a6d8da18fc570c612e396c5fed17ca5d5a30ac5126ab1d33b0089de534 d4db1d7c044bdfcff2e35dfbb2cac50345e09834fc4232dc94d68e30d7d3a60f 84ed79802604dc174d9c955dbaf33512bed9239c42ebac40f14b02fddfad8165 bb08e431d37089fce26dedf9e3f0d9ed1715b04a626ee40cdb4b88a86c1aced4 b9d7cb3593c9cd7cc996824bab772b6501b0e05edba0165ecae0f26bbcb8802f b435ce580a2c5fcbbe83f26cc64c785a9388ecdaf89de763c265f99ce658cefd c3b9002d6991cc556f301a29cff6e3e77e1191aab6515a7d85a13628e7d0cd83 f5deefd85fa7af59366e31744940f681c58966f4cc81270cb74901d063c35b58 b7746eb4a8c981b344e105cc5fd6e69488da55417f3823092ddb5d2bf679a255 a93125f9790e01bbbd5a5a7fd8a31d0cc7c199e451d6eee103b21dd57ae1f09e f1b531ea41194e10ebaa6840292298e3ef0526abccda943d70cedfdc1143b32f 5054ec6b6c1cde4c305947a199f84a6e586cca660add0584978f90e55a1b88dc 06b842f5047177714c0e5418ceeefaf47bc53b5e88ac519ea3ebbb1f2728addc 305c85cd5c25dbb7164cabbbc27a5249adf9ba73b3e78b7bdef99e4e2bd3cf53 10eb25364c66bcb681f443746b1a64f1a5dff74ca073f4f5a6957b7583096c36 5a7c405803f005fec2a635940ae2b8d0cc971c1c164c158305ae8fa509fe3b45 97d06281d6c933004a70ee06647e5dfbbf4c7276f36af0c7fae49a3426e5c85d 3c7fd3aa153d1ee76c849c0a8fbf32096b368a35723c3b1513d869aafa83a33e bd27ba9b225f359a77050a572bd4803b44bda741236540043fc664ce7cbfbb62 b24125a96c5d2b902d4e2630676cbf0315b301f5a16643941728e5c4b3a914ce f33fba5b1f16fa28ba7f5d2a9dd36bb66e4ab33e17be432383f7d52adc5b48d8 4b96e310d06622113d7eb37bd37be967b529f2ef3d3a924a683d2a46058b0d28 6dfe98fa6daf08346618b66aa72cc8b48dc2621c4b5acd0f5a1ef79813c26e19 b68caed00072053de5eed7c26c89fbc244af9e6ff320df41db010a7b0e03c131 b142aeb7c10acffa791d9562505411eb64b7f049769c8782266d478010e08184 d09c2ae929aa1c97e2a1bb650d985ccff49304f60be94a45ca9cdae5e390c9bf fbfb2ffe772b78786c0cf5bad2a64fe002d58902e289e64567e76133e8dc98d4 984be7e81d0dc73f51acab6d02d697a7b30f5841daec9c3b9b5dd1ec532086cf 5183463db5e5894bc208c1c2d04daedb167808bf2a95815d63ec46f451ca2327 7d33e1a2fd50b57b8984e7875ee101ad6690b5c1ef112a1d6a3773d32c97618b 74c61c65a3184ed9d23ac32720db4fed1d874d5017a8210b6c83abe3d559ec7c 9bb6a8b5407ac05de7637624f321bdaa83429bc142501e94495227c8d32035f6 153a262d1c6e3dd7e54db3b899df620a533bc7e67372b14043ef3c1d9c275376 a98411a5ca5ed83813b1452df19cdf8eb10f86e0b07e4e8ff45c35a23052191f fbe83ba81ccfc8a44f32010ed386415977889d34749cabd804773914f5896438 d5e050afc14acc43e6cdeec1cb0fa6498244df0c729708f25b13abba743f6417 77814fb0627a76247349180024ed811a6939b895e2b9938c2a4b8cd783cb5cd2 3176c738723e689b00f2cb11233ae0d55645102b03976f2ee0fb137bf7d41dfa 9d6bf6a9cfc5298ea45d0b4f07d6e835ecc3e320800ae9d695b0c5bfda373106 832e8612296901a149b02c3559d79186ba49855c5f5ac4249bd7bf3129991596 f6cb7abed318983f9c63ceaa46ec3b1314fcd05470e321e586eeb1737bbd4bb2 55e86771b4a428702a0490aa9d88420d30166554b762e3274d293b2ec842eb6b 50b6acb5a4c722cf0ac50b6f5adfca7f2daafd263afadbfaf20f3859d84c236e ca775ca8932ff9394c2c2570ca228cf68b0535f2f7e9b561d2e708840e170a75 e07ecd6977cf330faf544ee76b6c6f5bb5f7afe0bb08607c48b2fb867d54246e 52e1a3a011085aa9972c50c662c0c035267d4a8e7bdb816986d8c5d7b543afba 9dc20dfb25a0788b652ef9054a166fd4310141331d96fb1b947e28225d259712 ed7104d43fde372ded634192fec82f0c696e7f501ce6432b80b4719e4420bc08 f25d51351487ed8d30a32b77e95b357e5d940aedd7d6eadba10b74e9a17fec4f eb0e5546957d234ac6e1eafb62c8b46d9681ae8b471f593335757f324f504e04 38ddd8566266fcb029cc196cb615cbed2c6de3f9ce0fec0b889ac2300a494f02 8477009a87f5f93ce00407ddb653c48972cc60649c1da6813fa08035fd8c2dbc ad0bc8fad36c2445c22267277f930a5cf46b7fa1988f8351cddec19a51103255 23c48cd314eea0abc548d8d62c7a7b94905fc63726263a7344e9e13e813dd0c6 1511cadb88688aa556532cf0bba41b8b6d53d134f7168e8609157a02f84ff8ae bc1f8f6fd20d98ed2f8269478e94f59696a3664527f6bbc2a8f3345032cb3b7f 37528b1ba18f5bf3a575e0798b4f62547821ff670cbb254698f55fb326f1b11e f0298165e295dd58d413437bd439908ef7e1083decd896899c077b59fcddc472 247532fa482cb7333c43e09b101345ab6c3425c91c198e23dcb9a370102cb4a5 8e07f1e0e2722f18606095b0d72635df92698e233ba12636724ca1d1122d8448 af09554e1f2581d59b38b3ecb7e03dfd910e90276e655ee02ba81ffdf37b50d5 b730df23f6adb39608a9b41d6a76fb2a70b4ffea39ad1f4893d1a86367ea3b97 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 false +check_ring_signature 2684f8e51861f569c0fe97f9ba96bc915133016bf9c4b5d78e2a5a25e53d4bd6 cd2f86eac697799c1107d4cf6fbd6ce5ec933bf164e2fea94208b1b18a032492 1 3139d08878da018064cb874eb23c49bbd3e9fe05019f03e0ddd168e6f9c4ef83 4eb9183536540da0c2cd9068201879cf18348f7f18f2d30816266ecaa9e491fc2dbbe38df202a9426090d6aacd182d06fc8a79f2bf7416188b6648c1fa90bb0c false +check_ring_signature 8905840ba2829e2bb6b7f834db939b7ff006140df120170253e73d6a110adf09 978803e051ac24bfc730d0dd1f746754dce0cf527357883ab71536802e4100c9 3 7f68e1932829141a4823849121662b5ac7c8c50f0a3ded4359896648875bda84 c0bd288abfda7dd2f55ba0580fd0b240f7c202c889bc9de914c759802d05c984 aa0dffcb5ab16eae256860de6a14fb6cf2c474b828cab2f25fdfb704fb247517 741e3d899a92965d92bf4dab092f647138e28b4ac06ab729333795872b26b10cfb5bcb8ed397f5f76b185c6d8a541c3a72bb925b3ab797c3f55ccdcd14215c039d0ce5c9284433be61c16a44c5b4555eac61265b346bff52e926b9c7b2f2e40e776b60386568258430d9f4e2034d4e0eb5dbc737058e8665d1d9fe123a06680c6d113440b33b70a0eeb4a625ecacf30b2de1aa86795298aed80108d0a27ff602d689d89ab73d78c4e7a4c2c744a7dc25fc82372e76f1a4df9b34d68425b10708 true +check_ring_signature f9d51e98ec2e48852e71852dd03092e403ae335d6e712c7ce7a135bda5a41833 856dcd0cedbd4f363b4d8ef3a32588cbd204f2206681f7980d096505a5be2296 5 8271049ee2bb50fb308eb6a0042205494742c4ef105b3b9aa0870f8b334e32cf 5c68f45750e9290b069b8860cfa4d0f08f6812989c8f9fa1802f57bedf67c59c cbde7ee9a3b0fd58d04dfa282e9bcba785bdb1dc60ab660676faced58f691189 b0b7ccf22728c75f2a5238eb9b677cfc87a34cbaa203ea1845ffefc518b9f449 670b179d3efed230f867f3caa7bdb61b4ab8d0cb9ef89d99ade0f58aadc69093 364ef7f698541b4baf8c939806ca83aec12f1f27ace2d3050da0895fa0574a0ad43c98167ac7a36901f2a2f214b0026e317207068f45de05cc4ea67fbf2b060475c1cd6d24be47b99c4f3050d84488b84064b8d307994a0361453e7b88450c0b7b8131f8a2ee22b9d41d490a45e814b86c10a4ef0b074d5dd0b5df522db111190322c6fa14f31b43577ad9d2dcd29c2d5aee632846b14522a4f722ed4647410f1c59bd0788f12ed2ca64670144c2d2ba3dbd6164a8e71eb68bb5b7a1bcbb22090936524629c736ab57bbae68db652fa719d9d45dd20218e193fbe6bdac195d0d2a73260e2e306cfce06aa220d41677c25da6cc47c21d41efe6cad282169e830d902e636613123ef44fa9c4539808a507d867fec3bc063f2fbf8f66ddeea67c07eeebc52a03ec566050f634a8f6f543b94b357bc2054b04f819c31fa16804c400 false +check_ring_signature a582c951daed8d5934300f4f62dca8cbf4afced14df907723bb998ac90ec12c6 238b52edd9a58b056c875871eb4d5091a03c63af2cf923eeef4042f649aa4f3c 252 7e777ef0e3d120dd0b333d5535ccd084feff7256857ed69bc5d4a38cb8ef967e 7b922b179dbf6c782f5b5ba3deff76f3fed7923be210261fca1315f32eadcfdf 6be26c7910b76f1f489b1de8c6c35d33c68cb05e718a87ba6c23f583cefd0223 1c01742ccd62789422afd1236a81a1f0bf23fecae14e525a94b97bc4d337c35e 58364d0fc67af86879e113189d561386cfeb7d2703698e265f2a72e81c0960d6 114e1b802189d26234849e711ae83de1482c9957a1d96da438571da544550837 06ca49298a78979be29eea3112e61a7103abb873e31d594b10f2a6a0e86f2962 27bdd7e9a8525369473f7226a29c8609ade4548613f4d12567958dc9449245da dfab8a97aac47a260e833c97c99784f105eca2c2b266471588b2caf258e49da1 29cd7df8c9f0bf34c0f0d9920498a83fa5b34c9fa5a96391ebbe554a62e2aeb4 49dc207555e9acc438336583f3c6c671cd30e955b5d03b84274f95fadb5522e2 bbd8d1ae66dd2034330428727878e1b720c8f57ccb33453262c8a55a4554f111 66b8f8d8cdc368ad72529a73ef6f6c2ccd48e10e91d78fb411cf6ea2c703211e 05c05274fc5d0777a32b94dfe697458f97a29040f712514e25d0541007f301e2 f0bbf84dbf3162a783d5bedfaf590d00a4d521a3af7a4fcd9b62acf803aa8951 ac6b7380a45753ce46dc4959d8138cc66e5ba88030b8e140650d34fe5cc93b87 6208e49329a1d34b7a83e30a5329d989c7a52b382d7ae056ca119a108815bc36 f824724e0b7dc12c2c0841fce07a1ecd9c77b0bd8f84c7c9250312db037632de a37293bd8717467542394c42c4b7f200922fd513963c71f62bbf97f63286fd67 8a670ca75ac7ca3695a99953fd7e685959b1319e5b17fc3fcf53461ac3e5ae18 ee5d487644b9da61ef2e07b111c4028caca3ff4993adfde12540cb0c265bfc60 4c53c2913b5e3311968e9b7d147e473022173739c7d2a283f4977b358150a9d7 ce60d435e1422499aa9c207ee1cc048af47f1c605c257acb93276341b3ecb310 1b71c1d9d02fc8e77469d335d7e04c9b06d477fb0d10b3b0713767356a7f93be 2b3fdb85c9ad1028faf36e1e8f82a58ae85a0da04bd4f82a3ef8a035dd83c402 43b67114e107da5f5199250067cd9c3e6d2c03ac32ef9f10b94b50b4d89144e7 2e65c6a2613b3fe85a12812dac5af331d67470a9ee7254ab63404f30cc735eb9 d6699c569cad4cd4f24270477a4722c48c6f7216b6163eac31d6305f7067afb5 5a20cac4b501f0813d94c2f90332d45ad4bc89f20ab3825e9b694d26458288a4 466602c8797f666114621662a6e56c5094bf7f572bc2efc2f0cfa1515299b7cf 73ee2bccca9e8aef60c3759902d8989cf26d47bf4a1f02e78dfa8cbf7719cf23 758e7da50e467a485644fa130220ac21ce21206e92abc52b5de4b7b76632633f 3a2485a9d6928c4b776b5dfb776e4052089314c794b9629bf5308e8cafdb4257 1cbb272cb8f42c6ebfb5ef2cc2cedf29a942a1ab62c2bcf9e04ffe68e23352e8 9df54116d6e9da454067a67bd8b596950a25236816a11ed8e3f93d6ef35bd4a2 74217360442ac2659fa041595e4fa94436fc39eec0f51a8206569c4860d9ff3b e12ace7aa27e1eadcc982a916c31d004c871353e7dd6a1960997d67c9f7df6ee 8c4961aad8ce7626cab6cb536eca3a34570313672674e858dddcf1431ed6526a cabeec41334e621a0647bca137e679996f58d79a6b9f21e7b2fe91ebba7c214f 950ea0ed8ca85d2a215bcc940611e74bb8ff45b9a308813d7ccb2ee1c7173702 dfff2636aa7ac1d8bedfbe5bfef16c81bc56e71c62bbb0f67a0d4a305c4f2364 eb09350043d2693c5710ee8e89469c4a852932b8bc42b6cf812e116c561f176e 86801e1ba4f84fdd4f2a37016494e6083079bad1a035919b25645667a8d814ea 64ec08f43f4c387fb79e7e2e29d0e20364446db52f24e54b610adeb303b65008 4f561a8b4655c5ebf1a24d838457f904e705198850e8b7078a042d4089c032ea 9203bd689f05c6b86862be12c5118a689ac4cb97a20b9a47c4534ef8eb8daea1 438387551c640b3e93bf2cea525f09c4bdff7232f7aeb8c0d1c8d16b34d1816b a5c0b15550e9d145a7bb651e12f9a6c3d2f7d6ee4ebf649446553b195409e118 a8dc6ced103efbc01c54b7c49f50d4317cdbe52f42cc3284bf5f8349ec30f255 42428a0d55adc561f0afae568e714581f9150131a26be30f14ca04693cf5cac6 b8de18764096df84c8abc3362fdf35d8e1cddb1565535dc9c4129d791d7669f1 5a48b75815ecb885fb1e4b26a5424f054b504bd95d04112e9d492993119a2f73 5808e7ec9ed1d720f4e0132ad69a3995489a4a5c04d9d6a9d9b2805b43db0575 14fa1dabf1b8ee746a30d935babcd4a0d0973320c762f95259b3904a978540d7 fceb83981e37d5b8632c248c2aaadf256e8c8e779f6af332943580e5d22cab6b b0e8902ea99f6e207cbe709cc373179693361af152085f52e15dba0d928dabce e3194b10a9ee8fd345bae01e1dbf69a3816acdf95d0ee6401f34540c6c1ee304 f89ed083f70a1a71df076746ae63b1b654586c08309578e42bf7db58238b88ed a167ece1891a8888710f783127d8459681ef2b128707a8eca673fc53bdd3f621 427e97c7bda0632258cb6d04887226396fd36adf4addc850eb3c31644cd4e2fa bdd318ae0c70b010bb3d9075295f29b46a2734237cedb5fdb814ad9826645a6f 4b92c0194000f161831cbfa1a358a5fbc209c9d247e554c4feab5d8947f7c359 062e62b52ac8e820e85c66691cc5ea4c5d389b110ede32ea28e438d1cc0b298c 49ab49baeeb383bff654b14105b7076dcca3c9328b4686d5ac9482d624fe361e 0066eae5047d3a56f8d55028ddd2f560cf8ef1df739c8542d33a57be057848d5 06b726f64a494d169b38d1b3b80604058bbe2ed88ba22f85845bb01ae6b6d7d9 4ac0793f6fea64c54a1d8c1e1b76887d248dc8e87006a449c0e2a42f7836ce93 e007476790e068ce71b954767e6c33af1ee388673df91c7e450964d3ed1ee5ab 872c3a9ab8d192ddaaeaade4211dc93b14eabfa59d3a7fc7c8cf99e1b2709293 c6b19b41b19a45c9424bb665e1def554052367378925083e7a5e666093fab893 7b7bd3121d8a1284dc8d260c4344698af9d90fd5ad93c3012801457547038443 ef9753c4715cda8fdfff8f703a6a7d339562fc78a496bbc15a1686576bb2a7c3 23eefde0e4701468bc5a0588d30dd20ef1feafd2181441731bde5d62dfc1bdda ddabc1039fda5d3acba6127e2de56d863011ef403e88f6c9efaf4d7e5c1d7bc4 c786f77f9d06da2d020a9900f746716584c25ac75e73ea9d77437634c99fac64 29facbfa218b579acb3f1c6157980369904dd25c8b9bba3f9b85655b707ce974 a1d56bff2b43a3db39538dbfc0a0a030b9457f5ccad059a313ec873587a8e26b 4746c8364862d918f7ed56fd24b449e3e58fc72363b41516fad0f7a603cfbc88 73a9dcaba1a7fecbed9fef18d7ba61fa94cf133fde4a8c8fc9103bcae075d015 a1070caa8c9a71b70f2aa2167641fee3d84b54465dfa613f7d31588ab92591d7 cc28051cd8e0cb33fd34c55c41e2e6d58e12226c27ccbc7db8a4bb991ec7a148 d6d2ddfd553bb4bc300574d1d622d47f9574562ad9f2b14debbc89540909b6c0 13d941cdab477c153e535996ae0c95eaee640c903b57c4b3b018a867389b721d 402458941512fc096591e76a957e897831ef55383ed8f61b13fae2725bac8ecc aa1df5777501b688a610c81359851c426de0adf15007923f00d6329b47789b34 28ed5fd7b6d2c7de9d011e28694f6b0fed9310c5c258e3f7c7b3e1c0455b4d0b e9157b510bd88a4099af2fb74461d2930a1edd205216b78e3dd7008965a52bbe 8813fd003213d80b30f9390b7662bc0fc7483a79eba148949bc2c412c52a4ae2 1f10f5f2d4a207142eb48a4c1c06f93ae0a3ffd17a39839cd0a867c6e7c0513d 1b18aeaaabb0853e60bf1c08b59b707c1d375c5216a6632b7995014550bebfa0 c660572d346863357a6da32995a421b236bee08447a9dccf34a6d9f0033c83a6 9254c83a3b926bbedc4a77c5aeed4ff6c395bc53c1cba52189b492883541778a e8e45c363933d25b28500a33fc3477d7034aa935e6deff9421242365d50336ba 11036342c257b80f34ae01f74a0511f587de23a14ec7af5ffeaa0c05fbdf2b9f b215ff6f745771c6b5ebe783d7a59ccd3d9ef5fa49e6e5d7fd57116f7d67dbb8 8738b2f086398a81cf9fa5f691c4f01757b4ea9706ae18102e14e842d193ff26 b5b979f067ffb730ea01994d1fd368cafcc0745fba6f207d1cfa47cb1e31deb9 e76150888cabf98de831b1360ae31f92dfe3e023d81d3416696e1a726b79140b 4f0e961cf1b7532df4025b74fd9db339fa5a33bc74bddbef5a9612b44411a00d c4e55b8a2ec30acdad6f492866ed64aec035d2d64a4a1b575e21a521855ebfb0 7b48df08a10e641ece5949f0375a3b7f2081e7c22931e2dfdd87f41690dae72a e3fdcf909780380b7e6327318d38690e91b4de031b05b73a998e6dde02a3cdc7 8a33aa46e3728a78c5981d2cd1a2ac7dbd3c417073343c5a7d273ce119879e32 263eef94470be426658d255544839620342824cce0c99931be680468cc8d18a4 dd5866c6b98bee83fa4d06cd74100646ceb89255860b060322549638cd68b077 cabfcce35916eb6b6ab178d7d4a2237d78a329a205b7cda732965bad88d32641 0c28b6490f8c8a0f1447c9af700a6bc72f07f8258f61179325fe2a89827d52c1 4317b07c326dd869790dd4dd6fcc4718f99b4c4c3d0f029f2cd70770ed050bc9 769b9b3a5b3041f2af835963d1db78f5aee35184f502f3e3b5d879eac31cc4c2 445107e823cf3999b83afd38a2cbb6e560583362d8bf7a05c7b48d1778d50239 f0f66bd095b53ff80fab934b7f9499e13fcc1ed34292a0ce7a55dcdf42cc3a28 81a51f110ad7dff181f0718298114982881cee0f58cd9451a582a9017b1e7216 d4e7bc3d880fcb0371db432432562d828867df68ea9a91ddd22aa0152a9af45e e55136b9047cfd2bb63ce4a5dc0baff0a2776cacf12f7da2e9517e736a408e3b 03f6e5607ccdb46639cf96af33a6e2ed08bc44114a74ed2c1a12b6654901cc7b 7edf02acec618f2e35c57f0b948055084d19ed1608dd176dc7c11028e26da083 1d6b6d835484f15e44bbfcc8e9c5889e0bd657e23d90803e084b40566943e9cc 1eae0d0fadae3ae260093a9f7d20d3590370bea77c1a30d6792925e3b3e63eb2 018b489de6774689d1b75e12a80694279867003175ea9b481704ee40a2443039 a0bf7730c7465e230bfea2aa80f19d5279793fadbf88201291871a0bf57fba54 3d73b9e5868fc16ca57d3b23567946bec36de5e735071f4d80c987ffbb249d67 848218d42e5d95da5f1946d6a3f1dbb60762acbaa94da7a8b5304a6be59c4f6a 586bfc8fe9396ebd08cadf8ed1a21a3ebe3db657bfb6310f82ae27c98a7ce0a0 b3932c83bf4a1115b20b4e02f392bb5543f84062385c93939449ade29e7c0d01 52ababe6202d262d9f0df1ffd29b88ff557902bf18a2da7da67dae2ba34e4720 d4cddf9ba86e29ddeb4d39b5a54da08cd181a1a13e1ad171c860eacc9a2a14cc 969c6362503b7873b2ac2c5177cb4690bb62a468011dc5363bc4699b641053c8 43e0b337c1a50c89ef76544c638d20dcb623274dd4fb771f143ed83781202fa3 23811ce42f3c2aab7801496fcda96e2e2ef10f07d82016ebc67e5a08f29a1f29 c2bb7bb03758868d1af742d5746bab95364dae502fad8b2f81adb31e66bc046b 4534db57eaff6904ed218743847e4272219e2ecd171c604961861ef448934d12 036ac2469c261addd54287d94935e0c12194b304d204884f23fdde78896bebe1 accb95e018f5030d4ce9ab2003565b0a99e93620f0a493ff28e7e637efd136a5 205f1bc7c6081f33add44081d3beee0b40a06adf7b040202696cd51c74b1d89e 17d18cf830b2ff3d5bc4cb0b94660020bdbbd307be28a88f9a234e10cdba8af8 7ef4ea83c78665ee3fd15ffe8be1ce70d3131fe63c3cc9b6f455412139397fa3 fb60752a4e870b898e7c1da122aff9fef8c806ac03d110bb7f20b4b423849005 e0fcf678ee4bdbe854949eddd52930d45ad6db460025e92e609de4c7c65cb80f c42ea5c3097dd762915598dccd636fd00cd8326d174e9d76058aa8a169075d02 05de71cd2659d352263648b4ed0e3bb3da1b6995c24436153c9f035dc0f53276 ab055e5ba753271e3e0802100f0aa47aaeadfbd2d09fe6eafbe4a9b76861ab68 a6b8d764bf652b856686bc41353e9d5d25b353dd7563268fdeaac88d5fc0729a 22514bc3f06716ab2497d954f4f84cfd1d91ff02a3ea7af56d34ef32326a4ba9 56def77b87f9c0be6fa79d52976625f060c6e3858b210fb72a82ed569d5e96b2 c2e59b5e646385224a7e7642ee3cff28e3043ea25237920b4eaee43d159b377e 5c97cca046ba9457ad7c1007b4fe050d155499cf7a8fec6cf12ea25aabda8f66 dd94bc676e43d7b01ebfc5adbeba11fb34340b942b9e192f6171ddfe501b7e87 6d1e995ebe50bd4d1f2cd9ab88e985311a0a6637a7aa7b390ddaa72ee3af02bd fd7da877ee9d36e1cef8f6ede184ba029e828ea9562a6adb4b277fd11482e26f a80eb4834232090f3dde34fea84780eb94009a4b9f0cbc179d074d377e51bf83 aeed805fd70b1cb0a01e76494d96c07c038fd5a3632425707378582b810fa92f 2c4d509ccd0d646aaaff34a3b5471a53687265e3703360a1c40d5fcf9fff0cf7 6685e32dc4011c90f0c16e1c60d6d0fd761a372cb4caeaa0e4b9d6b8107082b8 c0056c29ec6aa1d91bdfc6446e46c2c2191ced61aac796047f17b0ae8194a55b b40d597762e5c9ccd8cc034230abe7a65022f3bf447e02fe6ac5cb096d0861c9 7aea51bdf38d72c5cd982e5d360f4f360b965336d3641b2fc2d46b08526a6526 d42c2c15abcb811e69ef2b5ccd4841fb22dc7e9e30b2ed5a6c473c887e54c9c2 886abdb44416c9d6d01901886f639028138eecc3f492d6e684e38c9d6fbaf795 486c66114fdd7e688c5796c7b035eb8e5b46ada2d9645fbb6400d5bea63b4202 3041100d25e70ab6317a23ebb1a5877486300b4f0c850c0d06b01f7f351887ec 41ded15ba5471bda06972bef8b289ea41938df158b69f16dabe205c7f3c660ca 348f7da4a13a8909ef8a0ebb34418bcf78c384a5032e0806b01b55b943809f7c 75975ab8b8b041087f3978b876f57a4eab205939e6a5b97b2b5408deac941e2b 6495eed19b590fe2413c107db6b9674d0f19062c6e50b66d40a4749d12395118 618de5454c06accbbe39a2adf79dd2a220e544c6f1eaa072416c02ea129053d5 5c70eb68affa529603574aad33c9aa2eaa177d4c2c0050c37b8fe37f8de57274 60528440e957fff5b2df92f8f29541afdaa9b5f3be156d9e4196468ad83ea7c6 78d27cb54d8484c38ee2414806aafc2817f3e0ac41bfe2f0bc656a307dedf3a0 754ad4606300333ea68309a72af8e2bda16a5ce9a724afee3aa8c00e9f2bb253 2f8c2cf6f78998b7ab6d622a75e7ef594da389d41fc3be026c75643ab0ea5ef5 756a7b18cb85d7217b54ec63f21fde6524c610fdbf97381a39d28e67a3698867 729b775c84c83458bb8edbe6a6b4850276ba6d2c773e1b8f50bc4849c45b8d32 be8446cb0553866f692d9da970c1cf133fb985c636c5401415d2991836114faa 55be5bb652d0206e534170610f24345c8024bb6249c70376b59ad1c540fb57e9 44f1a4d77204ed76b1f52a4bb5b6701d74b060963508fff4e7bf77548c14e117 178f6aefadca48daea6f324db7ee845ecff0ad5235bd52e2fad461608c54a5e6 1417f0e49a9660e18720fb5728bd717156e6a0d01ddb4769b02023b2aa46cf21 8451aae431dc72b5ec1663eece440e91f66395aa072e0320d4dc367c86b9bae4 ae08120263907a46d076791ab4659fdbbe4ee78dd3b2dc13ebf58ac77b50f935 1c3736be9370e2276b2dadb6a1d9e7475447e51d251a9fa4d9f562f9c6d06ec7 eb07b2d04799ad0b2c5b67052a7adb6ec4b2727328430bd7af11b48729adeff9 daa8431c0f322310f524fab93801eef5f555d2b3eaed468932b8e9d99b4c12fb a9502f0345859133e95ea5c1088f0ea30dc77a59fd6dd876302f0f4403cd2ee9 881cce607c851c9c3af9be56ed5efeb810610190bd97a5e21cb29b2d99c35880 3e756aea2a78b6db924cf264b34995d9814920c680d768d3a588f5729b3e066b 6a064f166e48d3f5252eacea19c638f7c82d98f9cfb596fda236874b3c0b6ca3 18b4870e1c41af197870b467bc6d9c3637f7023b6072f3eec91b3ccbd91e482a ab5a825f8b3aa69bde3935f6b368974bf589ba0e7169cf008e43e2fca9d4d079 5045c147d2ce820ec92e3e0f242a8396b3ca87a7580980818380246f846a5d96 698ddac885ebf3a6779c42497eca8b7311052d698847392a1727d14009eb76a2 b67c19acf0c557909cc989a41cd7016e59bebb26dd69dc3dcfe14cb3f7758d33 3db9bf055459e8f65c80600e1d55c2049c5cada1832fbf7d28df560d98aaf2ae 6e9a328dd0d51cd41e7266024796d36b09c704df07c4e1a05a8afa77e725e6d3 eb4c727c362dea12b823d7e083b892ef253a7d4a47e5f2a063d80af7bb626a57 f935e42e8d15cbf966199c87518799db008d68f2cbdd776f71e1584e779764fb 276c5a136f0d601cb23f673381cb94352fa3fd3f17d418ec8311803529d1f5c4 c92fc337b78737465212db89ada40b0e3945bf72dc0ec6b7248392defb625440 719d06422431c811cc05f5fe4a44d1e78b2fc35d49684820e046ff6525863121 af051e0f78a3bf31b09844db1b015beca614903502a4dcd5cb182a77d719b72a f17096eb98eca84a9140777409608f668855c948feea38fbc7dd5b03494b6f9b c439e2c4f328eab3f16a2dbc8811806fdffd6f2a090203f2e4d6d69769c011f7 5d91fe161986a644b9834029424fea942738c38f3367b71cf2dfadd5929908c0 7f9c640d9ee198f29b878aa3ec222046cb4896175dd8adec8503dee054dabeb9 61fbd061f15c4b1a9dddcdbfad6f23c5864dffd69cba15a767bcd76ec4344d8b 2f6d03b695c63470dd198ecdc22e497c9aec4655cc4b56ab93290892729e095b 5866bf73b926457785303ab0d238f2a2ac7d65960283a5420ad9aa481aa3aae8 b5e5bf712c9c334d251d3f6e1d605cc77a27961a89782fdca114aa4ca4727990 985c78db864ae7c352d1772e069e308fb1bb5c0ccd84c0912a78324d7ce68e12 86f7ecaef27cee2ce9e751519bbf94e50d209cd51d1a5a43f2a0b61babcbb397 9e7f2cd1a3179299196f89230660b215355c5a9e6de9f014b1c6c459f09ac66a 9e29e28928b7637bba2bcc8dd474430a60c53543ab94ee0b7850322ed8e2121b 661f1f9c5c33ba9090f960f0ccef9f9267eec73de53018f84cdd126cba1f3d4b e279e2c7ac9d7016356757b2a0e3bf3987d07d91e6f9838be6fbcb4bcbe57d69 bf081d226416a70f885d3213d5c9b727c329aa6f28e3af1ac92136f56be78035 c1e23dc3037d3b70fbcebe2adf18a73333fe7782a407059b1d91bd533bc12388 7a47c8a805559795dfa2c73d5a87752335a1d456472e9133fea8f40f589c1ac3 3211f0978a16a3b589163fc1787099f22f98f76fd5a75a8e331138ee64c6cbb8 af0c2286de54908b55e2d6e2a8b3e6416875e97ede7d53eead15a4413891d8a4 8d3d65bb52cf50413169a284d41f3aad96e019a3dd2397e9e00833ea6ff986b4 70125ac9763d647c33be36d7215abcf3244ae1d1b5f17ebbbc8400ebccb381ac 6c101272b368dd7328eb5f04a0f644dadbf2f92d2f972b508b286ae8a453fe28 1cc7cb1f04fe18d893dcc632d62edcb69fdba849163efed71da6aea8f056359a 8d04551c0e670766a80c552215426cf0c90332b2592f50b84b95048385b7afe5 33d5d1c2ab7599da6acb7c0b998128fba233a9bb547859d61193105bb4726d71 765980b50cdf49f16883649c1510687265372a1e03055a6f2fb4acfd157e65ac 47c46f77f2e1253b1e5776aacf8373de6fe2ec8e62e96fd9cbaddc1bc5e5e5e5 bf49253e87a9adc917ccb83071c81201d7b914f41f3ca53b6480de67d8151362 fcaaee825f1c8c4c5e4015ae97947f599db355be8929bc9a144e2db453ee8205 5f2baf493fd8893e09bb06dd07e58eef4d1642e945e4efeba2fdaef0409546b0 b612d4bd57994892e2cd6aaf453e5180d85661a1ef9b178f7531b9b99c7424c4 e7285ff2f86e42362dd946c635ed3f88bbfb6420e2a147f2926b457b13d16e57 b8411d43b3d19b1662e160fc1d549f2f139556846903ff9e1d2e22c38aec7a6c 25c2b81e7ef19e900467c3cdcc044bffd56b83900cb1629caf2fd74b6cc05ff0 60ffebb8283a539cfbefdd3c721a4c9f34370617f98e31590be0438697a246e9 b7ff6f8a03b15b02a1111e67ed2f8bd13970008ffa4fda4630bdddf504070309 c9c433a869678c6adda26e7cadf5cbe7091a44c184aec389b8d33559f5c793dc e4cb03cd5fe163c8bee0f22bd93d4d604b965bb5125f0d637a2d531bf468b846 492cf9787bb24ba079c69f179566a4dfef6fa7f6b063fd880a0b3fa50ce7d761 47fd32b65edd4274db0f6a6eb324c99de51dbcea2d6960dae52d34b8592bc5ce 2f58dd0050af8b9b9c3248f969ab013af43ac9070cffa1c77f80098cf73c2f9e 9f06a9325889797f2ac3be70298adeb75534e165cb39a39627ee631dfe555e2a cbbedc42b4d56f8c4af5f2bd446e7053340c4995bec4d40f2799963ec062e348 e04a87bd9d07c2b67b52db8908bd2ca3c9b062eaa8b11df80d2c5fe0f5f2d601 7dc1f5338c63fdcca6a935a2da04a0f0baeb984d4539a1df81fbb79baa176378 fdd920dc465388e08560ff174191b493ce97891b888f3a451ae59c9314db9dff 8a25cf6513ede70bf4c5594d927e04bfb9c48c43f7a65c5c73ee9c34e664a294 7b780a216daaa053e91d91c6a4ddc2c75d7a535314f1f07aa18561768994d0b2 92a027b8b5a143dba20d5e0f5ffd43bba074dad028d268698631ffb9f09da66b dedeb8293a7099838bae80eabe5ecd081b016ad0d63849302eed21471bd315ce 3e2f3bd5e3ef44685f2423379dec6510e9f6d14a9d6882039888501e0966c4bd 0145be38e28b54ece8b6c00627e45131cca7abf3bfdbc58e6ca496975525ab09 56a3babf870725788bd05aef02debd57132cc0445df84c8b450235e8ba1cd4ed 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 true +check_ring_signature 2220a2888b6ffdc3c0967d27127205ba4ad99f57c7e36d6a4f65a275d53f5c6e 4fe553645eea8feb25e52617255cbc98198aefe5fc8afe3a696f3c5848393bf1 1 a7b8f77674d544d7e7738c47de264190d460ef274b1308964d3466859c9606ae ef44845001fcaebd9217dcf97864f78e27b4af78b41970fb706194ab3b8904870e77951881df0ea748aa91e12dac74be272f2333ab6d4b9ef0b5f06ecdb4450a false +check_ring_signature d69e1c262aa05df09cfe8f59b70c571461f61b66ad143936b219386ec0c31168 d47e95973064f67ed8b6ef8a6ea485a2f8aab04b6fe2262119267bd96abb2726 39 636f4d0e79fc66f4564d1d8702a83458dcebe3e28cfed5a7fa076ae64980fd78 06f8fa7f7c9d8c621727a7412ba5548dc270c575362e416b6010bcaf3a7dd32d 49e78b3af8dee176de28ca1ddc56719a5f0913a25af6f03416e656fc2ae43f51 edba725f05dba3f8e3a0c8157da50dadc84ca82554b564a9d0d6e8b7a6d5108e f5751051e02054033c344013ddd0d18a97ca69a34db0c72e3569dd3ab4ce9ff1 ec047e554de40e1cfcd6143b90fe9a3df87a9cc069f09ab4cd77ac5b0939580d 890dc03884426b725de8e320a109e944a43c2e8c83dda93eaf19b26f91917668 68292bc3ce09eec480026452dadaec3d6012274654f7dae709e1bdff2aaa7615 a170d800806ed7a6c76d1db96c1b964dd3f22bfa78169d736c54df0adb56d230 af19ef4ba42bb74df89f8070e6b368931bffc85c52b1953bf270b7e00508f9c6 e757aed65aeb9e3bbae833aaca498dd4ec3896a37d0daad4f571514373286feb d3a6ab236017f24bf13bcd7231f3490e547662df6b0134d43340b1b659465e8f 969ff171e33bf6e888336c31581e81dbb38cf45aece70caaf6990224cb908b5f 1108b5f9b8b4b2490ccb932291894b863a617bb79d663da6ae3926788645bf0a 15bb2261d45649f6d3718d2a820e7922ef5fe999c15090d8bf7c6b4fd88da3fa b1f459ac340287d9a1056903a7b80911e02d28aa5dc149990287a3f90a56b947 25a6eb1426f4efaf746ac1e39192072fadaca2b34c46081da3003cc4129b4860 0c3a2aa296b4218a3bb9b04e9416cfed0057f1228281f6309a0b772e6c6f280b f396521c7d511c0c6e3e0ee7c43741003110e4dca3933393c86ee1959168f20d 63469feb596957488ead69ae9b987eea1eb7c8619792adf7c35ae3893c502b2f 32154754276ff7784b7a17bb64f096487dd04f292b3ab9d8482f3c4fba7acae9 f7e612d338d5588690cc01db4b1e89d5fc040e1b121b5226f00cfa0621a06642 b1a5c6a7893c3a944ea854b1fb290cd54d0f7a9cd3411d09890495672897b2e2 9969a5072f81f6d4a7d163097defca41dfd192e92b51c7d67a2d0e3da15f1d19 33ce089fc6716102296a39ede7a88393459e7d6a3495c14ef5f238092bb3be18 ff839bf864d9673adbfd6aa4b4dea7d02ecfc98c6006d2c65ee4a3df6da3cf84 9e57d415d41d43672ee185c4637ebd5ef0f8b22d6e04e5b5fae49fed45f6fe89 54e71ba2b81958a13dee5932ed50c67a30185afb4b62a965efb4bf29c2656e50 6f126652b3cda9da6af572620380191616ed689e023a8d0a0afbc5f5b36a2a8c 03038368fd6d0e4224d8327e78b4661e0cfac31f0b9b1e6b18ef05e2dbf5f124 3f0d96ab9edb8d78888d59569b3a4fc76d2a5508b627b92e45613cdc727c3704 79f18e43f844e9c830a6f873f101dda4624dde74a19ab4bde81f7ec13570753d 0f9132ba826b1c369aaa2f4992c01bfdea9036226dcf6c2df90674e5ad05b463 4fd57072013c73e151de66093326b85b92d4a84b7c942a506ec03495fccd98b5 afa79395d3b84874143124bc6f419858daf4345f75dded822233df01a2766298 11b9c5104be95ed9f9be1a48fda62ed4a5b8354e94c96f7758094db6d9649e01 8838fb089ff06216c494078c8a659c58a5e61d9cf600065d0ed896ec086ef693 8c685a3247e753ba4c1504c0295a024011bdc597d41a3a7a92eedf58b40a333f e0401dfa86159f8ac437deaea4b5f335ee992acacb2bf79ba84fdf0130a00c66 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 false +check_ring_signature 69bf851ab2aa7617227505dc69989546d8a174c817a5b8acd23e9f89e23041ae 86f5ae0dd1e83e177561a04647fb417810003f1ef43a3515da4846141cc22cbd 13 b8830752b6c9ea66f5d9a9b6918bae38ceea7930d356ae071ca4f6efd5485b47 d4b0cbe2af4e709e3d26ef0d68904545fad1c9f1eca8e5e8873f64580e2a926e 59baa76b34d77eddf8b0ba570d9c21308241c90c335a61d7b0d6b41ba2a63b88 acb4da32f112afccceb4608263239767e8b52b240504407898cab43bc29dd0c4 dbcc28d3bcaded35a3a856dbe9ee47b99f713ba0d4cb180ae30187d8a16c212b 4001f55c971179cca4c2d9873abfc027fb3b2972f60ce8989765d163a2a9af4b 2f9c5579d0189bff50e5f5f116c4ebcd18bcf696803304f6530b7f9ed470f786 c6e56ae66582816d20dc26c9578423260f56af3d351879547aa279b3a1b04dfb 6ae678c861d529e4b3b5e0d7bc68db149e56e79600df6cdfd6e8fc67885a85b4 320926f177772c56a222871f3b31e2dfd04a86df3c5b201e2d7bc1bb3e2b1166 696e96a81c1e1a5692a2ff697156d7c2aec272e2796ea6a2d5c408c8060c2472 93aecec02b7a58084941996d5609a2f50cc770e3b42b5e313203a3a47afeae96 e10eb638b8a46cf20b326fb6eb2df67e18bfb8c8b26ad69f478230a82ec89f5d 9d494e98cb4a1463047937fe53e9bc45c323b37d5b196270df4b27f3cd96a205ca4c451a8ee7a3213dadd7a891d9e8edb3e5c0ea7c8b40d46d1fd0e0e6f9970e8c43e6004d8172e4cd097045cd98ce20f330c7c355c16963ba7451572f8f6f095dbefcbed8fc89ab0fbf57a19875872f477acea77ff1276268e81fef3c109a0e2fcde20fbe922468cb6701a72176c8d2592b20962d738269f7446056bc02cb0a787190c8b9eb5ea15372a37a22618234c95d63d072a0bf89614bbe8becda560d631ad8e9c31b53a5e3428ef5bc711f9dcc0247f8c6096af3a4eebb3819c0200dbffe031785a5bfac7a83ef921b493889715fafdc43665d6687338f56b19c3c0fa9ba69e567473cb807527d6bf93888746b493f0bb80b3dd5cb1d639bb2521f0ade2268f07b719102f42f13be3c6f0c86984821aa5ff7646bf1615b58ef9ac40f77b83fe605dfe3188dac7d24120dfffcde899e411234a103c0637def15978909b3524d6da1ba746890184f73d8e900beeaef4b316fc89593c0a65ecc616bed03fe3769676b99778972d962e217a40d67bcdf5d085cfff0613578322d52b36c0ce1198b298a858264b2811b736dd8da68c5cd4ae20c7df53c1788ce2da5110e00fce0a65baa73ad56fd079a9fe6d4497983e097d2c6f67e6b5c0794542a6fd00f1ffa07dd41641a003425349fbd9f8716dcf45f6da5e71e6820bd78a5d333390d1690c1b39f9df5f171f2e9d30b055d2c4d297750f221c306f72447a107f8aa028b68688c0870b68d012abe165df0e17aa3c915123bb8c5b37a1bba99ae716f0bbc0d42b4392f2bd744a32d5e8d7eb132ec99f2fbf085ede76a0248d8a757c20064fa82fbfc5f409ee101057ed6048f5374fce0a72ec18284ad459e39c10f0b048ee3fd9996158ab1fbe6338007d001c71ae9cd314dcbfff3da6bc1a56d17b00d1c0be647e64846b01c8a7495823c53653bd2bb32d599f9f8f1bd58a03d752b00081a4d9aded0f8fa807d374b6b94cab25e7b30834b9d4bbf035165696bd67708450bbf81b89e98c842e13427c062cec9f35763a1f2ed43c8f281a8d610150f007cca6da161f5c74e0996c4de0fbbffa0965f52916873b21273763f008d2cf70f1f97f513430c49ab5b5c9e303c19707d712f25b4fb2acb06c506b05cfd46b50c false +check_ring_signature 871ca641081e6ef935695e0ef3422d227ad4213c27942c22697d4d2dd31e37c2 909c958014dff37b0cf50a88997824485b05868c863a927a22fb57fa9f6bd4f3 7 06a1952aba1cdee1415bf87236ee45913bdc02d7404fb9a29afab39b8c9f4796 02482af960c79eb86b7147ebf25ee40af157968ffe192edf85a21e68a2b8d712 28d19654571252b479fe3e22f98ad94dd6061c23e6e3db207defe12e1477328f 9c802a82284e394540e1e6395009999abcd0852943ab5d92a8c3acfba109e614 d712c6ab63b481d0f61a64e2d8768d7773e0cd62fffd1a3fa8a7f729a42c325e 14c192a54f3dda80bb5e6c7adb713dfa8c650b5450423bf7e0790d223939fcfb 38d9cff822d6b5db04b465dfc99bdfd44e80a83f26c1df837c0676d8d91ce1d1 fd988034edb448a9496e1e24cfdd1a1da0ea9f23c4e470a8f380918ee65ec10c58951104820aa36cd6a9ed33513f24620b20a4ad0cdd712827fb19be367db403506118246e50312d75db6e623de81b2d207e7d70ca3db0be48a545aa496a9205f93dbfac04ac32604f75d6d541c745ed9ab7acab5eab3d7815596d04f658fd0e054a71234fb742dd3af0b92393bde83ba909be2a285f4022330b064c67af830416b746bc75cbf41f9ce888f06de4a81caaa4e16c2a3cab654329247ecb4757074a2c445b87e915281c3c2a9901ede421b5705f74d3f7ef962e0549b4a785110f87700b2312326d4f0c85463249cc186a945ba318cb6bdf0e01ecc7bf57d0f00a8991bf61bfecf77f959c9e5c8a6896775a848c56c424ea5451ab3d0c2a18340314109f968594a1c59a85cc3321044009c16315b7ea00d76ec34af3c4bde97204f83382a9681df6caee156b380f6160a0e83b22f7bd11c5a54cb2c15fd97f840163bf8e26f969c1faa2092a9fd9eadced3463398da6f0c8ff03dfd4ac0ffe8f0faa8448fcae622ab552eac280dcff6d05af617a771d93e55f4e85fa134872fa0f2c00d7a7fcf18a6a97eba23b8870d98d3ac3fc99ebb3a09e2ae4f2b0fb7ba104 false +check_ring_signature 60cf3b2fe41aee2a4afb7b01302c091f704032e2e505d3cff82570372df9e23d f19d0e74228e3399ae21a4f783c8112074124e7d7293195d9669c00ff1a3cd22 15 5b378245a463f89a0a3614f459674f4c273a19a4e2d5b63baf6fe08fb87252a9 922140d1cf8c18b555c81743775116d356dd773f26c201bfee20851829c81a43 f1f9163479224b2048ae0b4957253ba64060a1faf5eab93f1abd7cb626b5b545 e5199ba4b537c18afd86011b87820b8641abd5aa1bd00c14a4137834116380d6 e8ebc325dbb9c18a96bea3a7a61bc51896893831536b94d204b2be8cc5828b64 76d8fbc5df9262a26d0c0891a0528727703ade894a92ba4dab053bf905619fcf b18e3f3f25450b9721df09dd6b91344ee75790b3a6d29cdc82338f78225595f0 3d4eb1b6da1319cd46c93798deb2b157d1d9ae8e5494d6be6630f61ed9a80249 e32f76a5b15be83ae37aee9fe5a8d54c184753bfa879913cea27448f319eea27 3cb6266359bb386660f4338e25d433f43970f071dd7a0eab78492449c469aec3 eb08d93d9a6b9a0a67056a9be82174ff6ff2c3f9f1c4abf463246f5dc4576064 a164ec54a4fd91c2e914321229efe70bf21d710339c6a0a0c29b2d0eb2ae56e7 2e505428450e564aeaeb433f73145cd5b919e94ead044aa8e1f7754d345cffa0 bc13fae8bad3a347f855ecdcbaae5b65f39729a374f848423d57d69c116939fe f4418b309f7e440896661ff1b48ef45110e6aaf1ba0e8843aefce6d7f4ab1971 54ab2f194e52034ad6c6d86a3e224d167110410a2cd23bf408e8796af5b84b033fcd587ed1aeb85326d1d1656f5ccd5e8242b66fe71dbbed865ea2f8a99539038bbbbd6385a1cb0cb02f8473889976ce37803cd8c048b327f449f7b01a081602844b85d0dffd44edfe0883203340f8a96ab87845c06b491e9cf6ddd1d079f70a9068f26fed6cb053395dc7e32d430c5fac0dc172fd022b3c886573b2b7479302debea99a8f22531869e04666b16aac7a36709219b954f790685a778303ca6b0b46409a05e4a38a47d6f88bf233535299f82770261fe1b410800f61011a8a7902d25be106d963a9e67ab89471aca11b80889cc87dbc8e6916182af03e8d01f20ac498686b5a038673cdd8c2031524e50338ec781c91efde7dd14d339327ff5c05259ad7d514178322ade2bbc93ad621413c0b705a21eab889831104741de3f90fcc61b800b75816a1a28fae5680e80483aef295c8d3190386b9c10de6e1428e0702a68ee396ab365e415104f6bacd970384bfd2df8cb914b906c007583efadd066a2be8b1fc7e957029d0355cf88050481279efc57a66ebd02dc6ec5ffdd1680f808b98f776ba58b6c7a8b762d8470ca1e1693b3fd3de5081151be01b9c159c00bb7109ea05efe8b0596bcc0b12a950bf12bcc4ba5cd2823986ad5c1d33b9650b013e08c123fd32c427babc712865804c9ab02c64112845abbaa3cba06a56690d4014cc048d3b703a6dd0e3924bba293f0b33cb17417a0c75a4cab7299f971d02c8ddb0941bf2bc6de97d3c0a4f578445c4b6e678bc4f4b2d56d7e44028935c0bf74a1d99887746592bce4f3a0d7fafaa5bd6050353fb215b8d15dda2be757c0a8c57bc12af156d83f6fafde7a5e3573afaaf932cc9fd6e6fbbb8b1cecd38ff009c05146f818702835ed2fec06bb1a09293a542cff2daebfa561fec666e51da07d6337eb1428bf345aaae5c5cbac8759b3267fe94c4c1479811028585b6f78801a9bd4fb8c29748680136bacc88e59b94c2fa2dc5fa701f8b673c1d37ce200104eac24cbe9702e046d8673dea1caa1d502f5dc5ef05be94d669361e1b9d9d9603aaf7333666a6a86f8437ed94efba75e134e61549c181b5c051068cb3ee95d30df8b2fcf98808d5fd7b7e1ea78addf1b264a8c4e5a89be7c89d835af3c390f601d6c25c7223fce7c31f48030264d17e066528c97b2fa38e908ceb557aed9edb00aa40796da20e2feddb361b1a40108196cf0e6a3d00039e02a88062b75c13bb0d2da2076484e78e475d45c84e4b66b7b0caf3e9d15a00bb95781f70a378d9040f56c243d838e404590783d37a6a69c09d7f99a86712dea1d516aa10c96f894e0c false +check_ring_signature c26c9948b63c992f69612457a103a7819d9cdd0343c039d673daabe488543da5 fb3801ffa7cd35df464b3143b6b88af766cd9b879b982300d4b9256b0ba2b85e 1 670da5bd422002cbd20e80ef27a750d9cf66d9ca2c742f02bb14d8ce94befb77 300d41c28ef26fa3ee2c04c992ac75e9da5981e1335ddc8f3883c41df2c3da01de2d51d205b7adbd4cc2c95b99877759ad62abe37a070c798c225a1ec185c803 true +check_ring_signature 07879521b7e1e3cdd0e63effb4b8d71269eec14d29d97ecf87c04f8f4c882403 9c6c9bf2ebcea1c52966579d24cf53c737d5615226086f8d139a977503785087 5 da0a09477280e1cae7a6f64e44b9f0fd6b86718e5602bf4ea46f1ebd942ee42a f07077b0d98b2dc670431c480b422ee7a64c6094f154340e807f734ef622378c f0f1172b16fd76e582411109ffad8be4987d6fedbb741670693c023e0af9d933 1f9332a3b85d5297273976022d55d5cabd6beb7c9f9b18f9cbec55f4ab7dbe03 0e3d171020eaee67c86b54d806dc6bcb540ad3f41f98a8f1a655875168c4b129 ca1771afe52852629e111812b4d5ca008cec40f64041038bb25fed30759b1d02000df68cb2adde9f9fef9e490b4314b0511c3014498927dc410f5b8d47ce57069748f9e612a5a5caaa3568b6a0fc52cf195d0a842f8818e96d2f7768aa7f420fd6ea68236c970afcca03ca9953d384667e6dc80d0492139fd1bffa39bb2d640df3d571a435469869c8b7c6014e5bb996ca925b9690d6cd1efa600fea3f5c7d028588f7b1d6c757bedda7f34aed8323d72a6981885a7b298d33a6154d9eeea104b6b04b9c1a5fe5ec679fb6e98f3b9f6a0a7ee070d55972c87de86654658eae02e10d99ac83cf367a1479e7c998f74aa095b20e511026be359c9888e9dae5610ab2857e818ae31d4fffac45e1b9aaae26fa5cc8ca33c2cf33c6d37e4b01b44a0a60b27d7d272064fc1ce3ffff0c9ece9f510e343b2a07c74a1666812fbab7d201 false +check_ring_signature 462eacf1bc595251b47ab6e307077043e9feb7ca9e2ef9de99ab957e1d25010e a5d80a5310a53213a2218b316bf431d5690d9d8a8de6757858ef3d93625f7ad0 57 53bec99e994ce5c6270ca474c9624f88a6789c34cba5fff0f34b6b53b6a13468 acdc5cedf4fecc3eaa2ac90d0fae93f9e982a3476e77266019389505916c2acd 0e661a865304645ef405df9c25de3ebb73417b04b6ea64cc9b39587bd28bfc00 a3dc7495796383736c9f526533bade9582ed62cc5a1d5fb392f759af4aabdf42 4596cfc37ca1d390a93b3e1a71e6aacbdba0f39cc6df36f35dce9786f863e44f 088020cd3f0c048834a32c87536d706f8b1f6180c1f887032223580288ff7759 2cd1ad25c394ebca74d46b2691dc71442883ac75d86fcebf5adeff4f7bf82127 9ed8a6764df736f12f4aab7565794b4b43e0764d04aa8a6402773bb919039d1e 9d98ad0c503931cf5678b2528f9f33fb0218ad70cc643e88030925d1143b455f 784714ac794e968139d04d5dea523596271c54ad76e0cee587819bf0cfb1450a 4a79b0dff474d3dc00715279133274cdf1ecd943b299cbb62afac44a167cec1e 89107bf8c47bcc78e678fe90c56ce6509284090c7e850aa8f663f10cb8b029b8 05dbadc150a2e5638e0358b43eca67ede4eaaabb3b26076a672c311b5a69b49e 63d0b48950ee0ff28f2dc8a9d56b13bad2ff8f4c98e2fdfdbb5955af6794b62f b4823ab50d227f4aade616aba2c96e3e1e7b3a6c1c2cfc85bff8f3f35bbb8aa8 a43bcbbed123092fc751ed02324ada5155263683aa0626d67c67e39c6bc9af44 2953bc15cd52bf38ae59da9ce019a8f641077e9e3ea8b36687b00caeb915b79b 42064b4d5469643eced6ef6e468dd16bed6fc91b2dff053017d305be59a57899 b9b98c39597ae4655f79293623593e64ffdb7008b2386aa3557ecb97204ca006 fdb42cec5be1374b1075c0670719fa85c05e99d8b623585dc743ff81cbacb392 873cd6be573af757f6cfe512ee7811f9c1d636955371f470d8397f1b4cb67704 2385950df6b4240914225e7b95d3a6d4c534f0315c35e45d031086f141ec5478 53e5f3457da8f6e39e9c0997618e3005567f4ccee0d70c5b6e22696cf8e90864 56b193b9ab413736983f6b59441c81b82ecb6ccf2591b696cb98acec6662f53f 6a5751ab035f53cfb6cb217cf25ac4cb955e13d5c5372ae12ecd34207614f0be 1bc110c060fe1a890fa2adccb20694877beb01adb14f1ec5ea7456cde1724732 7935393b56d6899c9f2316370b775ae67577121a0c229d535438d1c9fdf7d098 b2e6aa3a1c1e09288d779dcd042dc13054f6160c1270db080383864bd481f23d 25efff42eac3bdba6d767e587cc69d7a4eaa3725ece1582814008c1bf2c5d181 eeae96975a4cc90acc0f4ce2d8740ca9e7eca2f5c90daf290f9e5b9c9a9f3f43 54a91da4bac8d284609908d905c002d1c3f9f0820ef4b84dbb95e7c85df57760 f8bcabffdc4e44affd1b33c953c5084afd4713a2652a21ffc6059517269090b5 c328cd9d3a4314ea17657aed70cda2f8404478c3c00752d77bab7b531a25c94e bf41cfbafab1c7e9be9f70ad09a0f1c75c034d57d9273609597d254bdbdbb4a6 8b83fba8ea736e0676eb61aa0a2af9cddd12f25e96e769d64aad1d3253b47060 883566672913ad0c3cca819b596c3317dd7e3d270df754297a5bc3635725093c 7f1f035f3f32e135ca931f3ef52a6c1b637334b825791295a0e71dfb7c6dc7b6 ee4a2b3d8bbefc28653753f8599f00f585b3d92752af82d9f8af3de7c0e33945 cf1b28bddfdb102717c7e193ea06400510c329c7c77f076a06f68be812ecefbd 2c0171c0a046522496c2ffc13129abd06c914941465dc656cc665d230db12bca 689ade56403ba2b1abbd49096a65914df07abb4f83ba2024cff1ff15c8525d01 a0f611eb98d3ec2b4716d5afe0849d883dc2ae1a6e3aa4a4a97948579aa94299 11ffe8c4813922040cffc6be164b20b589e27c755efa48e6f892c9e810952194 8a758a253b7e7267703e41b5e7a8ca1bd79b2ee0e32476bdec1737307f60beb2 8a4eb7462de74b67da02debd40060d41327f393757067156e996e68484d7dd54 024e6c5f664f18978b84e10c3321826fe6b75495d0deca0134b129c0e0b51ad9 515c73f1f9932704e8f432b5fcbf55f7181cfbe3b5ee966c39d48063a9a22a5d 496866b5e13b32ad8438e8159b4d2e75f066033f3a7d5a289e7bd556e75798ea db99692e80843ba18ea17259bed041c005de2c7ba5702242bb26af7bb821f271 25ba60b0835570bae50334773f63539fb55cc2e9b662ad4e9cfe5494dfba9ee1 f18bb47d5d3b77e81d927bd00ca52ba24bf22dbb13ca89b68ea960ecfed9c5b0 078c51abb3046e59659f9beb53ef6283cc08241cc216477720ded958d552e42a 2c8e87cbff9496b12ed1933ba01702973d4466d66929895386e78361fdfb462c bfce9c3d2e231ddc7839ed27d6debb7b76c599298889aae8a0b661d7f37c97ac 73cb9507bb349719b3a397fa626a6b19af761e1a80084cf33cfd8bc9f49c4525 ca909e2b23c0da154a338e6ddcf9ac6f7a7c07365ca40948716a09f8c5ab5586 a91c589c0051f22b2467c882161e154a339cacef335a6841ec895fcc4413467c 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 true +check_ring_signature 0f46efb9b2cdb697e391eb0925123285afdad53896352000a817b83aeb508c03 c26394e1aca534e1084556b02d9ebff7e57b69ab1cd45a02a402f3d90947af05 1 0e7d3eb4218ec13ae1dcaa361e0765af870354e6cd849bfe4189a2736c85287c 5015605cf9abe4ca679058578dcddb00c6aeac81273cfb6d85dfaff755588d01c6fd9a41390bfafdff88e4141f0e16826a2d04493ae316b3673d36d6a25a8e06 true +check_ring_signature f6d2c5db9f57fca3c124032a588abaa623e16373c859cecce4cbd95f175edde5 be3aaaae636683d032cea44982b860687072eb87bd5d8419e76c19075f8b3238 4 0f73c60791e9d89110da4e459a9c8a08df9bd87f95ebe1553c9605214e87862a 57dec9cd6476939b62c0d1743d3f2da84551486525917abd866415d8bc42cb50 627a0c2a9a5e279f17b1b949364cb62706bb6c56f01eafe7a6b21dee06858218 82e0318d21793d7a50de4cd3210681fee3a94db40d756de03bc8e73ebdfc3946 062f6896ea42d4a27eb2a760b1b3941ba7c36e655bc3e58499cc83cdddea1e00e07d7c00f7ed3accc20830485a5c561dd809e7fea35553cb7e5cdbdd939b5c0ea60030190addb34d76155254f5f290370e3ea93aaeadaab8be2401b1204a920d16e4e63c8d763bfd379b49ee4489de92b2b2eee1acc704570fe594d22052ce0670925c65613ffbc6d34c4202ccab7862d5d89bc567f8f22e748ff0227d2dd208f4fc34f51e511a28921abb92e7abd56e7e2e51996a30d7c5cef55665e5346c035b7b533dc0bdc490f347be660a8d95f1a897cb2c68fbd88927a3a969ef9a610e63594aa6d83863c9c689b8a51bb59fbc6076e3718a76dafe715865de4f62f104 true +check_ring_signature 90a4f5cbb309df17742da1383d53713aeb3996e77251e941cbf2684b87060ed8 907eeeaa224dc1f498e5cfd6a70fcbba470358f6e516f9f4fcfd94b5e6e7fc51 1 f4f44d7eaa108b80b3c67246d4e31c4d7daa0be506f42c38c06f92c907eeb3af 5cd76cdec1f8bd3ab899e86a91fc55f463b927ac8dd6d1e958d735b1b9e82cea8474092c7184e77dbda11d6f668426923e1001aaa73b33f872372f07c4867f6c false +check_ring_signature 4260279d1c39ff2e467888228089e6f5eb74fb938936874422b740c2d58b7d5b 1ceef3d3eddb1cf3ebb73a347927ca158e569d38481a26c9439cd687adeb67fa 1 b1ef542b5685e7b5b3ebc2e1ead4ef838d6f41acfced88430453e37a753ee50c 55352bed2aa9f74c1650ba961aecf8b08edcf22298cc43a13e074bca7bc10f0a7c9003ad0a9bd03c10610634670eb5b8451f4a3cc51ee4ad7d66f66963b1ab01 true +check_ring_signature 078f68c0315b486e9d2a79727800e80e098004b83e5702d47e4a210366bc6277 22458794f5039ad9a855713b008133a3e55c3e0f5cbe9436e5d4925d5d045dad 27 6642663257b3393202e0e00743892e10bbfc8d67aceb59900af4afc31c3bf435 223803fe112bd3b5bec88a4534fdf06931e967eba5e6d44970bcee04e828a397 7d0941a1d4903dae638c579ca3dd6c6abb1cabc1a1626a016d2d2f5af5030efc 0605232955da0feda4b223a4ef84366520a1e33d3207944dc84b3b0266b48ffa 39c6077051b82495eb3230604cb3c0f948639132a557cba7c2f1ec7b7f81257f c604743ba49d0bd2d5455bae57484cf3bf062c6e0aa34c38c48ec4d9e112c6d9 07200b59910aec496fff19dbf7fa66c37bf173b3743b906df498de032b456c09 9d8645b86afc9ac82770d96be610f74e711dd66360c06533eac56c7416c450ee 94ffedef7845321b38eb7a73ff83a1abae62a547a2518756867f081bb34c0116 4326d831bfcd094ef75e2bebef22d26593d25290101ca1a780d5954a3a73f4b7 908843a46e769e47ce5bf21cd0de022b5bda63922e3ecf80f35aeeadaa1e1da8 926b13018ea1f048ef02c64618af07b9f0e80dcbd8d7ea2224c866f354193aa9 56ea78aea1e267f84ec0400ed5b07df0c7182fc67634989418ed0c9828468c69 49dfa7dfbef5923a877992273c77233d06c1a72dc203d97cce2f6aec4a48a54b 6764dbbcabef9659e6184d1235dce63b38f69fa52e78c5dc5d958c6cf8f7ff0d 29d0bcae8b2595273baea6cb9e3883967b7d6512ea14ca86e7771511a80d6509 6466e5a47b2608bea1744ddc9503f03204dceed5544d87dea9bc53ad5cd29302 37017a1ea00999777402b0aad57f874ef479bb972c26a3cda8e2d535c05d4041 58c165d15de9d2724b31007af38b02486a9451c907905cf0a85e83af1d00eef8 8c9bf0b3afcd313d2c360105f6f7eaa1996fe74a0e1fda8a61aae48afdd050ee 749ab1b27af43a538432b546709421ccc6e0eff17989aa3fb373705147044e9b 6c3c3a779bbc479545daa40060f0db24c52d920b93c5a4f1aea5d12e9ea54d14 eda041363bd80adb2f0dfe5f5e5393f257a26e7e24549cb3c8ecd70b26f36a07 b903763e43e8f11a0d2ebb2b84fcb4526f63a42a86ed1dea3e085a604a574968 d40c88bb3fc7b7583079b0e1fd720f0894fb3114f7201d79c468e9cf291a80c3 ce220a43a8b6352bf018e573f9592fa2effc6ebec7db716254c149fe7eaa1b05 0347c17a44fbac174a24346bc0c3666caf361658d706623cdf6f1722a7caba34 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 false +check_ring_signature d57acd9f961f03d020c1e2c4b155f20f8d0bb389434f35a7ba0dc3b831274dcc dba7b9bd98e38277b02d6637e44ba9fb6b585652cb6a99e2cd84e6b46f441ac7 204 281e7f97f6678e7ac4b1d84c49f9542b85ba841335ab41b77cda32e57314b55f 5add0a60b000557abb5b35ab987ba20f0bb97fa3588df749de6d875191d7fc2f 73844505872fb51a6c54edd20dab20603bd09f9326cc36d6453efd421d157b0f 5e62665479d6184e3daf6caa2230e000f51a7217f2373b6522a1bbd7881b3bde 98fbd11b914adbfe0638d8c951f6e74ac02632ff531660656cc7e4671ea747fb 28c9aaffea80abbe262957e509f58d96a9331267610068c7aabade22192e8387 9d1da5c27058a79e850c8585368295779dd4e3090d85b45095c6cbcb5217f5ca 53960f28b78bd4caa3965d84028866aa85e453b7ac6857a6a923c7ee222caf5d 74407ec145c16f553ae9a5d4eb7cb8e395267a22726362b720433e39df13cce2 859d7f7572b2babd26767547069e991432a0614c4b0a4809262d3d8f5580b6e1 bcf2e2b6d645adb6933239e2eae0f1169886d1db7ba996e53e9b1eb66fb0bbd8 fc1b11a5ab8e8f842c7e702c26afb01998de23ced3d27085c653566f263717b2 44b64c8d5b5b14cd60c718385ba04aa62e53b91933d4c80d1d717e54899a4249 73fc5be99ed164ecf2283e4c29a6cf42cd8ff0ac11c204e13a6373ba3cd3bea8 aff5b5344547909ea04b1a4aff8c4f76f7d1e723130001b5b6a6956e578bfa45 45f71d2e3ed8f83475b17993dda8c2ac2966407ec9de45177d0612cc036c9546 cebfaa81b699771176a6be3a7b28ed87ad7d68a190f203e6569a7dadb32c8eef 36be390aff4559e7a3784c296e65852d84fa0b8d889867172807df18095966d5 1db84a7a945cf0c447b9450d73fc69efadd030a5cba2abfe5a679c583a035207 0be1b764ed98315d47097d0d93531c5dae695bf169d80d12dad66b831449683c 7612cc610f420e82ed53dae19676962bb365bcd4a32cf37e1e36a65d22d63d36 0487771fd9c4c7c035494e869cb166480dbc77249f49a242c3d2ff90dff02cdb 02f0e310b38befa937e00b1946b4b8c56315c95dbe49ce1f59e2f8d5807ded07 65d5c361c1fc85773c28985f1701e30118543336cf6e77351cc1c4ef56fb1ea7 eabebf9b278cd9e54d1c2583a4b6a5312d7ca3ac5b94c9d1c2de831d7d16fc44 f7c5fb4da470539069be252959580afee5121bcf58d8640908251e261d20d306 c6961df1a6499674c2619f0263de08a36f04fd13831345666aea78ccedc5c4fe dfb8e854a5641a63e79cabeb4021adefe613dd7fa3c75243a9c3150faf4cfbea c4de367213a60bd9b71628a7ca1d2296de9750b203ff69c77371972404b0f6ad 2230f3de91f8f3364050623185cd692ebd1ed8b834ceda5545770ff0a87c92fa 79e8fc72c9ed4fe8fd2100a0e0d937de4e80c678126fbe58df62ee1b00fe5a66 9a4f5585828603dfa07169b28723a8d004633e04e8a327cd54e081dc71eff26d 2f6011ad43cef4330c67a6124b69e17e179c5f257fa08c3232e17f717bf86160 a40bc928f8e272046f86d2a1f906f3367fbba583cdc5f13801915334a1565d08 6951287ddfcc04df995c3717513e9646cc4028fdcc87d4a70098380ee924bc20 944a983d1e04c1209a32fb426aaa9bdbdd5ecc7106799b411a1d8397f86f4ffd 4e752404fbf9b1e2f1d2545ef4cd518e4b3bbb56740f6f3bdb9f346a29f5462e 74218f9aafb22a7e53d21b082aba29aa6a3b81847ec8303fb04e9cd5cf844dd6 3638d3ba38b61c89354e8b5330c22b15613ec801d677e9e52e0c26c2cd6fb658 d15a3277aa42f9c846a6d6fba375a29eb4a07c7ee322dcc6c3fecbcf1aeb5a13 f0dd01fff61b6d5b5ab24d147b80e173450e781d2c05ffbe8574b30294cb4bf2 09cbd71d52b8278e68b7987d69f69efca680f0261eceadbe165a8cda00cad4e7 5e5b2974b0a2ec04e7653b5f05c36a2ea8490ae87114d4dea0245059c5c6902b 90e81569a37fa3c3d8b6c1dadd6039990c382447872ad022ac2f8452df86eb6d d019269109eaba807f75e0906cbf3f355c28e65653e80e1437bd85fe9ee4e111 c20e69d8fb16a03730011a35a4f38e490431e4a71edd96feeae9500ac39af893 72f3eb8464ff664d54c5a33509b712fd6027f5201ab1bc32227339661da0fb45 4274db6e853e683c388d439cc33e8092e0d3a3430fb6c2a61d1e9b56076d7b26 80987ef66f179fb9c0ea3eb0f123b5f6761a2cd65ccb9f39caf7bdee1d9fca32 4f4998578192e9fec25979adebb539e2975b48c1f6746758888fe1566868fce7 a39e35f59295a62c08447b0fc9112482d51e4c8d8bad4b5b5ba1c0c6fb3fe301 42cf55bcb4520c5bbabdf724ff4542050b399b3bceb7ea6fc6eb6dbf16630575 cc5bd0ff1979f6f916b107fa99b63a2aaf0d72ee96bebf100d481323508f1d9e 14872802420ae07e2acf34b0cbd869c7a6035fc25b5bdbc475a7215810a29cb6 f6c4aa680b41c78ca604f9abf7119cf4467d8ab0f4f53ada7f5d870c281b45f3 3f4fc1833ec96a047f7c2a6c971c2d243ce884ae903a6956b4fa385dff412bc8 9fee026984a3cf11af9bac3c9314ea598161ddcaff94f27dc3d83ba84f82f799 4ea2f6684a97db81024fdb4ae8ccb7ea2c97a9ccc27477a40db5b0de00b832f9 66bc2fdac37cac239a8f83540c63c861a0e0776b085d2889e317dfd0b2cbe7f1 7ce5210650243c02f23246c426c85ca437a05c2d0161ebc43e7baadd76eddcaa fb59e7a2d3338e71cb3cc08769ce54e97b0052d8c06814d3cd579329968772ad e9c87462e615a56e697f6fc5623ce5e56e39736ac21096047fc93e1460af4ad5 f2db548eeb0983ff9692e970530b1106778ced1e5e63bab72b42fe9b8111cdf6 32bc863fbecce3a2a034e57aa9388ea1ede341b498010c02263edfdb88d575c5 25623db5f8ce845992a177fa210b26d798b46855e833affd1b950c3c446e4878 b7f766e7560dba4578efe8563265bde6f198cb2cf855d275c426739b901bb496 741de81ad1a339d7c221f1925258560cb0af44d07e317dd9f834324aae62554b 33b28790157a99fc931018bf3969d9dde08e1a350f3236c649b1def3f3743319 32854f81595bf66870ba4cbe342ada7378739ec28760565d40598a95908c9fb9 b0fe08e0478b944e3be08eb82381b894a295d627ec2cd5b11f41527ba0e41382 06421751b370b7e5b0e418c92bac5bf6f0d1ef4b9446154f6543387580323d2b ae280902a457cd0ab0895dcbb2233da644488185f404f1cf67d42be3c8e267e7 92a139ffda033288ebe6ca01e1ed49d0db82d66989e75a5b9cda0b5a3abe0591 1e50a0a0f2d63e7a3c8aa4b18523fdd384fea6d3e1b5bb5ef068be1d6d455c72 32bcd0b784ed8ba984676cca01128b618dadc7b7095472d65d8ff541567f0ebe 39a714fd44af7ad3bc6de41a12bce5ffe2ebd6e7cbab18dcf915647009141c0d 505a2d5c88267b154a21af1e1316e3116c5605292ffe36e099fdaebefff6f2cb f12b7cf3bcc432533e4f4aa532e860f3de841171b524e4b87c50eabf39f5887f 9e343817c230ca86806cba7b52d96bccb02fa0de4d98c2359ac78bd084d5dc3d 46144a33346ace1177cab024aab3a573208563ccb4c7ae683d8aa9179c407c05 63bf2d6aa3a36e862fbf0127b1b0e67eea5fe2c3c38ab4df7243c0f63c732575 7f7178dbe918fd8c28f51a0233aa684dfb9095d6ddcfe46d48723d386aad2d98 7c619bcd207e18c773047d58717f74c6b666daa7d89a3a9e3de88bd27b807817 43dd31bd4a2d391b299fe52077fcee810a8b4f6fa79638f93dcdc15a426d1608 daf0e61c1087c6bf92f82fd7363259d75a4bf10f31ed61dbe364a760d0306ad3 1eb1fe6f63510b7d481a34397ca74b755dad37f9b57de11010b332f9e40eda34 97ee3c25ee3c03e99c9e870876e2efa7e20cc31c5a4128b933a31cc8b0ddcd55 fe98b1cbe08b00e0f1047339b78f9ea6fc7583e26dc5a11ae6293b7d71a5dc5c 40bc1d2f8664c68021866623eb255eb2e58372bac10ea4c6909c47f437441ff0 a56f095574f36a501ecd62ee26b066bc26ff32287b382181941e33f07f2e4f37 fbecdbc0f866d5278d456cc2334e0f038758ea72ddc7f0186677636567d1f6df bb21fa7902fecc3f94b2af3ec051bc4be8604327cf146617cedae87d0eaf9ca7 5065fd7f2fa711ac6114201e4c359f231c1b0d45702c66dc158e7810fdbfe8f5 5ed2d10cb8373c5d88b7d17b311e688b8010755f88bfd81ef34abcdcda929aab d40ef74342f58fbb8aabe0b4c11e860f8d437fec6ec312b1a9c2bae346015f0c dc9f74789f73ee6752be42d533bbf818cf997c2cd9f30fc0763226965a5843f9 71e29e7d626fa257e1309f055c08754cbeb11a5d051172d0c056890febdb40f1 f8ab52fb743bcbccdd941ac73e0fa3c31d9f99af1008302e9407a2bf73249e32 ea44732dac630b1031ce0f8f7ba4f94261bc42f02807a157fc0f0ea247dae0b0 25ee9f8e26f9d66052b4c187af8b4970eff5f74d6c42a55c9725e2ab540172e5 a1477fb2007910c18f2a4be7050ccb391274dbfc276de7c263197815aa290c67 1ea6c88b8659932aa6825a00defc07a789489a0c7da3c5c66a69aa4e053e2cc7 cc957595f27299d9efd0dfdece42a1dd401e691bfced05635292fcdb9c233044 a454102f74ea75b2d245473f1d8b572c9911990daf8a5b10e19c86059e59fb3c 11bd987767b4dcdd54bb839af2ef3442193ecd9846edd69dcd11911124edf46b cabc53f1d6aa92eb2ef20b2307ff5e6bca311908a992ef1e1edba6bb8901bb17 0c993b27a9527c3d32754eae09041ca5565aa64fa786d8d0f3f7c184fb0d516d 6cc49eb6105e380d042c92a9eed94fe13b840dcdedf2753865e8cec3247a17ae 453baa34cbce39da4653d4d9d9f0167a5817995ae6b95823828ea24d9c9cca42 f7cfcbaf46aefdfebad2231150c5a2c969cb0fecafabf67f752bd959ade59ec4 d3b00a190b10179d2f55cf94cd887e68a1046d74d6f0db189f86c3a30fd7dcfe 77873b262b1e58c4a7dfebf9fd09b2ab1f18eb55c2af06ec0fd962130aef5b91 ac5621cc9a4b3dce4767f0c13f5e802d57fd45f91d98b989430526adb1961f4b 0e9aace66fc15ca79769aa3d707a20514629c3c6965ff8f1b9a44815e5f2aa61 b043c10a24ea3bfc6c95e2668ecca40a2cc803d44e042b72620083669da1e2c1 dfd1252dcde6b38331d86555b82a960573f5773b31a60f510b15b5e2f4e05c9f 5ef97e60e61ede58c1f71b0ac9ea0e9c6861340ce0d7a43cc905ae0054113523 a5f0d8a77ac865b935c17d5b1e4e5fd5b73951e1f8bed438bb327c83aee53d6f c91947728cf11d6c951ee6fea97522c1b3412e24e4cde66b5c05cbff46d20990 2f37eb8f3a0389427e1e660737ace30b97e690572fe4afefa67233837d58106e 70a89ba262706e43e71429687e70dce6d9c0e4b4cd5d776a632f6af6f806d2ee 9068743ea0dbe8c14d29fae5d32c03f6829c4b8eb687b8a2bc33f2ea2c5ea269 7b7e3115788695cb86a45113bfb97ea4a8d04e7286737d39d1358b5f67bf73d3 8bd6eb8d5fc11a8ffe90aaf5bbf580167a6ebc4eb25b04f13603aefd35b00d17 b20f91fbe10f6cfdf80fdb88bcddebf25538dc780292e6c7ed404e4b59eb5804 5f7a725ec083ebe38e18cdaeeaa8f0cae4e0c67ac9b64fa9cf4ac4f12d3df96f 386417849c427e5d3ac81ca8381cbd8a3fe4692e66a290adb60a0cddebc6d45d 430b121235d585e2afab4f3ae640deb915329247dc7f501cecae5150345a8149 0612dcb4bdf808ba171496fdc44f0ec607495b58aab981f5d8bee300ae0608d0 5f6ee4ecdafad5ceab6506f076516ebc2e8995c4561462e9febcce2f7d9d84b9 e18326636c1780514062a9973c35c6470a59a98240c6c9e55474edc16ef81d52 f043f0ddaf38bc8546996f74d82786e8a2320778db03a1959e3f4a19a54426ee ee78035756872f786e71d0f0fb57edb94779c3f38d6ec2b77172c80a2fc01968 f2e3974f21d0706043bdd593609fb23155d3d5964dc43849b13250c0cbbf7a0b 471088ee099131aeff09933f94374074aca266c9ac76baf0f799cd7fe6b3c3c4 c574b860f345077439b9063e3244d1096fd275aa232d93920de90b714b44e290 37e8badbb33e85062735b4424bf355a91539e88863419eb145ebc0c18687f70a 9f0c4ecb98049331ac55cd8fcbfbca8a18550d8d4f7f5d6570ade2b07915458a 00da4ab18f71748ac9077829a8371cad049593fb0d510eb56d0bdb37846c882b 189ba8d172219d13e1a403da9ca9f9f5c31fda4f5646c282b0e319fe6bfa3aa3 e1d450f739d1a1a3568d7e6cbc24bce2ae32c410e2ba989de1416857248b8639 1bfe0a35f27302cf7cfccd678b83b9ed33e32bcca6a6bf613704651b8a3ebeaa edbce2db84439a5049f1d10722feaa35ca4c034f4046d5b80d81895feb071da0 e12c210db4e6121b31a26722ae217068f8a41f7a74ceefbd052d5886d530091e b2ad3355881e4d42c4523214d08edeca603a4f9f6f80ccedfdfd2de2091cb43a ee4e0b3e86b94b3288b75c3ef1e0d5f55832fc6caf0977abc3e0592f6456de52 ca8a524c776b56dddaf5286c5194a0dd7d13b0eff2bbbcc74c2a543865af78f3 cae06b934c051464b8ae378dacd1420feb85fe209441a0d5e2b89dd068359b5b 2d892e1c9f97494f52f6c389b682e696a3504ac20aea7e16655c31c16f008b33 94e2c6f1738a436a203f6ece17d2e97801fd23e768aa196c3cb530366220aa8c 7cf991f5a4e4f7d1dc09030f16ceb5b5b0f5d7d156dc1ef518fd58e67923a55a bf1b06c6b10ee23c8c707c452347f012a6fbda63e348a38a0f8bf5242a584435 baa6f5ed4b54e4fbb4de4f6d9ea364c17c5615fe1e6acc934dbf62249e58f7cc 730dc51128d08bcacd9469c67ad924a4effe6173bf3db2c1dd2b2d38b2e63ef9 d6b2743ab86cf65df1bfa337e71799a26c196c52f6d92bf3bad76e9480acac2a a71313793b34814cbef9028aac476c794f36acdc466ca265b4aa8b502d791781 1fabccc3c004567fa8bcb22b09aefed05cab522188e589c05b1bbcf10f9377dd 9804e7892030503a2dbbb909a40ca79287c032b76bc036ada8cc56f7fc11a2b7 144eb044094fc9bf791e8da68c08fc5cca8791aa42343b543c2da19bcde9ace5 c4c5b5ebb2c0154be9ce1df35126c1db53d4e2f3048ce221c1b9be50d5b829ea a523a8fb0620536ab50631b3c4955f9399c8a7783603f0587fc7c43c2756eaef 6fd5ca552a33fe3767e9d4a9517ab3b8f46bf12941106379e873f90e154eedd6 d597e14fdf1fd752d633645710874f6cb954d4940157b250983fb95c9a73bbad 1810428bd7b73441499051086cc249c60cf4aad6a4d9cd8c5df004afc5770ac3 b9dffcd0823e90d4a4439eec1443f164238a63db323d3abb22cec6529eb85fe9 c42831e1d00cb821a144f488065e232ccce6bfded05c228307d9e7de8accfe3c b47f048255e9841ff3e1b6256cbc2faf828f674401a9e948833ae6deccb5b394 6cb8eaf0b7cdefdac623a16282580b76bfb45ace818f2e7594a59b37d58b17b6 4381e7ce843e051e21e3b627279f340446db0b4d1bc4e39a482ea5d5196881f1 cf9fb6aea25a9d85d216a85dfd13fda5fd20731116334d7439b3daa9fbcdb3dc 1dd72c1f00000052f4f4a5d5f19b5727b3eb14c04397a4590bd083c2af69f7dc 33dbb07005094071a732bfd764a36d9f6d2a3eb10e20e7b92bde85bbda4863f7 d68834f3326be28fde67ec7238f10cb410101ee4b438dcce62f76058bdf58fc3 3921247e65566aa864ee434670b6820639e504f5293bd24c46bf5af0b8faf59c 86e6171e5a4621acf6f542ed5430cc307204f916b7bdb1432e8c61bba46b1664 8477d518ff258669f5961762221bb8af71b02cd0c41a74100e7f866fdd29ed75 20fa91baa8302fcb2b8bfbd29285257fc7146ddf4cae837ec248373a9112ff6a b3f4437027d44128e743575eebfb10bad35b2b145ef0c24e0b34a69db276b0eb 04abc96834e92cc37d10df851ac319a64f2df014cdeda8d7c9d29af0ffa17b67 10a6813ad27bbbb367fb6ba297b3f504dff3c3a6a7cd7d99408b8a6e0c778fb4 ee2ef6c297891aab5413b81ea99656eb35c944a194cbea33b7e9934d439be9af 9c45bf6047476879ffb048dc0477dbb3a3063c10268e230008f9853598f6caf2 aafbbfbb8ac70c56ed7e27125e0b933a9872769cbad2f72316405b2185dce853 33d7e1c0423d82ac413fd99ebeb14549cbfeced2f99d4a1c790e6bd3c49dfadf cc9ca25dde944e9a8bdca747162db7840ae3b5449a5cf61b1b8dcf074b3691ee e4e570fe8f68e76493b9123c6ea50dd60f75731eae978f0b7f456af31f4753b2 ed672a3b22eea6f1db96138f009a8796d280a8e7b54c81edf313d6b2c38cb847 de2ae189761862cbe969f4c64944eaea4b11f2aab63e499203601b1946d3d4df 38614b84e4e2e2e5903fd746e020af0b530549cef308b6ee832d65247e5ba2ed e13deb6c3c472bfba773379a40f43d4d00fc70dd346ba44e4863b4958e18cff8 b029ceb4f7bf2130df481407c9ac5cce9037e4276017792a6de1993ebecc7180 14de2e2c49328fbae99488c88585d558f8a7ccef8dca8371b23f4813a8ed998c 294157f2653c1e4f0968d55e16ab02343f6832375170a5fba325a04c53ba2c91 205e1a69470470d484a8aeb691cb327a46934152df090841441178e9fd0a311b c73ac62c6028ed29843d79f2bfdf5930b1de34c5de81f3bf24336f2db321d2a6 93076827490c5115156f6bbe21c61f72885f234894bf752a7d003eb6ca9dfd83 878b7f094c7a05a511996636d0513d4a69b8af4fbf7d5467bd7330eadf350e0c 1793b95cfd331a4ffdfcb0ff399cf0f7fa1a1ce14278943879fed2c38a47529f 3e4d3a998349512547e073d0fdc6f8560abd867bca08d4e2d20889a31baf71b9 9829f94a0ada8ac7b43668d23126a35f09425ee85fe115c0972ea53f2fe2a744 7eae6b08e798d4d941206cce8f7548c5b22718ea82d69635fe5aa4edc5fa6902 3de4c213929b27241f9b6471478cb559088ac24e9950f18212b1db0baf875a72 068371f64e3c794c449432f9e86fff34f1daebcedfdf9e81f3c51f35fb12bcda 971c3679aa16d9591b73b0ad0a2af612af6273879a0650c909c4c9ab19c681a7 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 true +check_ring_signature c9c4d3c995029038b2b6fd2ff66f3b6a1d6be1f99ba2b4d79dd6d798301ef60f 43222e62e2d054a5272160474b60cdd5dca5af671ec240c6ea7f680094b3172d 72 0dd72b567cca9b8afdae809606f94a13296b0408d921d5cca727ce7caa97213d 1e1f6ffbb446512b6c87e8ba7c59cd25033af78edae05dbd2e3343bc347ee197 c7fed83d060108605971bf534e809183e88efebbdd338b29230438a3322bc0ad db7e3ba17da87cf552510e1366eb83e618fcca50b0fb53ca3724b18f793260eb d40b3f5a91b30c2c210bc1c218251f49c302fa493c76d2cda4aac7bcf2c369e3 3f917491203e15e660f114b56a074ba0d5f6a82dafab2e077687b679b0959c1f 251e6c7b08f443b4f3408779566e47ac9f3c4f8ae971a45d98c3e40b30c56970 19616cde555599f15ebab7f25f8cc9b6b4fc0b12228a8ec18cd0aaa689c6daaf 90a70b653a338019df13f2d73dfd9192893cedcf613fe551aeaaeb12c703c2e5 ec4a3dd3e99b1983a551a4d42b7f4fdaf0db3c92d223ec572a60da54c9dc46fb 8b63791eda73c69a44ddc7e6c12135c0d0803ef052c56706edd9b4e24e4ac4fb c49553c0f1f3cd28ed3836b210552cd87fed45a50ade59b0f1dbade833113d68 59affa1f402a907a57b328c9d08d33b021b160d2fcedc077138fa65afa7728ea 05d3ddc7396decb031d15f8ab2a700c5e5f2a824528c977115702ee116d83c21 2ac6631a9e8b4527f7f85bbda3e8cc1dde98d7c585ff089bde2020716345cbf2 5269412fc2a67717dfed0d9824b27385cd7fe801a18643101b2b0554478621b1 4dea4e2650e463d78e3d0639928c974b62956449bc0a659235cec83772e9d53b 20d7ee0a6958cf6f6298fd53848e8bcb4a8dfb22ea1bdd5cfcb6e61534116603 2d47138c7ee95d0d9a5b9faa673fac6ba5f3388de894e5c6676f65549cc8cecf 0ea442bf754f421d5ca8c4551ae95e9c76e6ca044bb55bfdfcc84ade4f7b68bd 04828487065869cca8cad1cd05995a42825e7a605ff19fd24bf1be8f0dc35423 c329c5833c057171134bcc1581ba28eef5ce177e81862d96f46447e2d670f556 faca92920c13b72f0cbb32fa2995bf2152e1f9856bc9f93e520a86303b08c122 1863492710bae7036c38656c6ac93d6d59280edbff8407137a54042261c9a26d e8c956a26e888d6ee276375a4d7c9bbb673468ab0dc5e8f2fe6f52b078970364 e9cc81d21d54a5afc9dc40f3a1db3775e301599283a1c97e13940d75a45a72c9 8a5993ec18cb99db1e8ec5e3ce03a571ecee5fafb4b4b726e4b13a85a0aae1b0 e58e4e8388e009820cc118e3bcda0a12f5d58c54e17acfa6cf6dfbd169e0eb2e 11dd4c8609f4127a27d9e2fd75cdd1cef089c8218e7d48f845e84ef883db5ddb ff627f7136d6c8c5320ba73094f8161e1604a02bb1b01c259f9a7367fa529089 8c15576195fa82911d67c20d9c4f167790ac5f8a83e0787346f0bb82cfe24780 ff4018253715cc2245ec455a6ac8d654aae1c8a1b59d034be12a00e25e064187 a3dd7d80e1e6e8adbf347055a70725784b2fa15142cc2ecf7364fb8f1b0123c2 e3f7651774b495c1feb8e803e6159864fcbf2199d75ef27d116a2888ff32b660 c8104319f80e5ef6df8da9ac700d2f233c195a1f8101a73c1e4c61247d4a9245 46b19082513ead7f109c09f51cc250ea13fecfe7183d761706a77fa1fce3e699 f1699dcdc6173723de7b3c9f35d9353fc358e9ec8f0f5580c110bf5f1e14e305 8c97ecbdccf3756aa4e8fbf349640988b1ae909250460d3588a0969566470348 0f076cdcb3d5d2c3c8433c53dcaffc2ae2a1182fe1134783b9c2a49f1f91efd2 7d179933c0af80ab58bd73a34d5680bcd25026bec47a428c769d766a1cb63142 be7803532216f9f0312e4330b5844dd32555cf4197a867daeab0e03e18a40861 1720840759966059a92a3e2264dacebeb887b402347a7fb899395ec6a3f644a8 3766047fbac7f577c2d007806c0ea37ae4f199a6c7647ba980413d023726aaa9 3820e7d96dfdebfc8534e143353f603b72ec1455af2b9fd781ae4665a687fabf 13379b02706042eb700a21a85269c606fdfcb7bf6ac32081c2cbaf7b65686b7d a341bd3ece057aca7ff27b54e01df6c35db0ea53d2d50771c0a9dc34198e6971 3bc5f74e792a5889d91a8f7add27024408e216c05ce66d61917d952fb1aba11d 2f002e4150e6a411e796685bb813634b1348ebc3b123780ef3f26248b409b6fc 9ce87c2481b9a36427714fb76c79b955d04a95137f43f550beebbcd58a2db407 e6e8b638b228f10f872a661f940f6d40792b5a5971bb0c7503636ae8eef99096 eb7d11928921350ffa48c739b4cdbce1b98f7a289b8eeae8bdb43c1144777f81 6fc0b7ade87d4a21e7e145ea2519814c679ca816583c6a320726e86af9bdb32d 220336df2bd5dfd44f5449caa325b6a05499690fb09cf9e3713614be30eee998 e1c1b03a7f72e5f6cffaa218dcbb5ecf41bd26535d809d8be6c6bdf19ecd8674 872c640d1f7c833160989de5dab2bc3a85045cab04bd5a8efbd52df0f825280d fbb6cda280893430e276e842f11c871191f4aebc4216d2f0ae6e2fe77a097028 eef28e6312360fc0524a56845faf32312eaf85d1c56bc2d60fd790116e6dac4b d6569af0228a71ef25aac1f935cfd4daaaa079059e5b93b70950436ca129500a bbc51dfeb6b097c0120398e2440cb091375a16a1d9c9ffd44ca072806f783b9d cb2bf979468fc9411d4b0d1d276e6599666fb81d817186efd93190089decffae 6e00e599d18b8c338ae8ad24b810f88f9706061172e498f2527ca357a56fdf78 d1e471bd944f7fd66ac3bf84476c657c091f82f483f757ffed6252c0534f5079 e296c7e71ca65f60b7a3c39e4a93d174f0e5bec9da0d0e202a6c9a146183b703 ccc50dbacd3c373724b9af51150957bdfd86427a691b59651fb2e4b9cd073ee5 3f54eafcced0e0a619f6dbbc8ee915c44733587c77236dd0b8a2facc12f95ca0 ec971b4e27e35a0852a9711942df813ad9497eb8cbbccd4933d668303f7b879f f48a17c77c0eab6ff4c077f8d5556d392a6e6cbefff695e2a2c03871ff7912a9 422da9a40724d8cc0c67bb8f54555de77126aa02761190e47a1a6deea3bd7d5c 855253c1b2d66f39a929c9563a464403490550993bfa0861e78227b4907e1103 51eeadc162033a913952a1f12a78ee77132d3144905cc7b840675d0a18114278 a094a4f1e9d6c814854238f86f84cf0fa78821fb7038dfb598a37d71df6bd3e1 e3ce1a829885c96df163b16006b1465c7ba2938c58d14234239b5de68c9afb34 87a9c1b2b6b708e7ae2d09a5bd9916e956d6e3214c1cdecfae720c58d0f2b107bf9df4646543fc61a855fb240027ebd49eced52d48a14d2413c8d1ec5c19c90d6415a7c36c6b9417f4e30b6904f28c75c2d8e32f74f877d3e3307dc3c7ab51082f4c1497d1afadc22cff146e8acafcec7214232dc73e48ad30c29c8856f53b0eb9c2bb0acbd45395882211f4f60b0f4e79545afe5389a4ce20d006fc6942000ef4f12d8aa35751f402e4ace0fefd37e113c578f03d4059314b5a87d01a6b35021619b015485167726e9fcbc35fa955534808a60bb35c0fcc3246e4ca581c6f0d80ea66bd89499db770f335c7611ff86a19233493293d5ed17b7a896d77e8f0088a026bd2e083065afab0bc483a572240b3b771b64705bb5aee788c808d686d09c23115590d8b021c40ba23b05aad34a8751e4424f77bd1713968da0e4257dd09dd97b4c8b9e7a87ec3a4df3ee2ab96d43a413b129618c7fe38f60cf1f87957022630d38a6242e726a4b2ee77fe10e39819b48ba1595b589c0ebf561a4dcaa30b5f535d721f3d0c463710165829bb8c05e93b51217c6fbaa5933cf6e9241b19084863f842c5a0eb5f841d2059866c8b6be2296ac975377ad97549de449a944a0098ba73983077b91ff29363853d3feccadf3d3f8008e234f181158d29264def011c43a606374c07db03a07da389f585fe00d10394d614133da78c85e20d6dba00a6323e3e2dc9f0d3e9778d4a5cdfe7de05e33cb330982d95595111d6dc8cdd0665001976de52cd0972ab3d50469e9e3bcf84ab13dcc18cface6914b4bbac490f2c6753571584b5203dde7257cd8bba1053fcacb9bacb25bb701648f0890be107e44036e5e684e06e3d2b37b191c2f783957434fe79a2e17f4b18104eaeedbc0a6678559724cce428ec9d1094905dfae189aab7d3fc64c437e8a769b1a2f5e90ed3e636d7376b3a2f17951d52e9fa21ab64ef3e5584394d9426dbce25629c56003c16502fcfe66def91d5505914798addb36833927d850efba1166efdfd70ca0fa3088e62631cfa379d4c7098d49f86a4d4a6d4d40da524772e3fec0d071a8e07a541360146eb9f396d2172a4a22a145349eab8a6c5c42f965ef1e5984db1980979a33767b4fbb529508146099d6b9278f19dcac8922f0d4d9ee9b39aba6e9a0794479a5a50910a6403994fe324d3b4ff0467271676c00286096f4822f9d14d08af11143e2bbc723023db6d25417b05560a783c6bc6289bad6aeb1f9a46f348082d981719de5ddd66d206a49a586b784f64e778e3bc0384a400d09f0c41266d057d8b90c631370c339024f25891281237ff359b76a4fa4badd697d06096024105352043fae6bb4afd20ab3a85ade14e47252fe7668a194d8b3172233ff7f2f8005cee9e716d89408569bb14ebba276a1d2f3483001b65ae905f9074792daefa034f659ac299f1365f73926cc737518befa6c085901979c2eae8d1edd29936460298dcf785bf1449510d3403b4af8cb8e33d3da83b16a8f4f3d6a27b76d8faec01bc4b628fc726676673da6a2a780b5803348f4436f3fb28d338ed723762c5ca0e67cb5c3866f99ed3ae8ffaa3760b847b5c681431bb8cb45ad02b0f3f7188e90be0475dc384669a25ea121c88d9241205260b5bd12f76995f8847b8ae2b588505c53a861760f81f88f7c99eafc3cd6f91ef881a35cfa154182fb5c22a7ef1ac00e5fbd8ac2bf9e94394aee9b39af3afadb6a0fb19224e203372629c9719f1b9064fdd52285d7971b1ac1bbc7d03cae28cbf9b30c8f0c4653ef707a680c3fd3c03eb18ffa155c887db2b6433597b1649a54aa1c9af226bbce77f0a1ff444170e03b013f9ba96111c0096c14a2cf2aeef6a11640938e3a80c9c5d9e373ad38cf40a605dde9e414490397a01e96493046c7f298de98cc3cd8d23b49a30f836969c08f446b3fc265c8c039f0128c2db5be024f9ca62f53954b6437706ceaf7b26740047e7fb28085626f8e775e0a43205e8c1b08b206d59869340c87ceb386f62e10ee64be714679e5b5647d1827877ec4c438b8ae15c5dc21e02bcd0367b4499b40cdba0a38d429d045f108e1605223297dec0651e427c9cc924110bbe4983017000c16cdda3387489e6f40a520c973ee3439c731917529efaa3e0c564261f9c7f0f9c849979f05ca2c6d134ced6aa2e0ef487f1cda236644ef3433cb3a6cc1b510029cc0018b6a8ea029d56e892de3caf2323340f0f69f824808f04cfb2dba7c20dcdbb4b2ca9b22f0b62c2d85e38ef7b2fb509f579f907bddc8387cfdaa6a7ab049c4bbdceb0ab0b7d2673ed96be3cbd34072593e82d3d037d437672e582b0b20347e6185842d7b85e2f7d16509d17f444cb1d3484e06c114100ae8e550c08fb05de968932a5044e674bfd77a67387e20eb242ea549f1aec08627cedc7ef012a08a0c9e47b4361509194a35163c4745c48617de17713a838082effa2a3fcad410cf904f29a4c3fe2aaf284ecf0b6b95bc439b2d280cac0b2bf37042e7053435106e11eb12e6962ce30daf94476035a49500a2f3bca944c01a7c89d538d1f371f0571ffe64e22f5b7bdb15932794d2acc7ac63b975980ecbdabe6b19f588994190d5d5ad717d40d0859a9cf2a7d05751037a5e03e9cf68433100149307b7f658e0b9044389f7cf6bdbf57e818b4292837f1cb0a4cb053a9130e2a9974d78b8fb00939154f42f08885e2ac815fd4e04ec10195f4fc63e5b6a88c46387d79c249980946d18bca36d148cdfe09eec8729a9d2b46abdff8e0b71acaf8024e23088153024e2c3d1ab334c2edfe93690b137a330de5f26b590bf29878913ea8e59a7ec50fef65d61cca84fe07ca56e3af8362033d5066c8f7632fdb54cc6caf50b7932d04cc72acd990c1ee90c0d6a0af212374f1c335c9aaea17e18b925692e4a852d304da517dc2ad33dabb6f377dac848398f3856a7a9730d9e4451e66fa2c7741280e1e6c2d70b51175c63c79c827cc6fa9a74976c021b7c9090987a3530a43f0730e546b0b74d2f26ba95c369033ac517446e319851477de4ad5cc7e7d3e16576e0314bab2332eb7d9c64d569dd2a232ae6223d69eb1015807df2917b16716267d0b192a71670fe3c856d2a44569dfeec1679631813ea7d7adf54070dbda325ef4021d2c61d9fee24de1472b4679172edd65c1a2a341de01865a9290e65d9f16790d4c77a7b4b6f59b66387f1cad630ca6df766c8d88b309f3dbf15da29399c7640d2d9d5bfc1373de27301ee5a2b1372e18c8c72c5da8687b7216c31f7527d8810cd8f47e846726845c51441f7f4291909594456c149efcfb847031fceb02d47e08c6f9db229bb15f5187a1d17f89c03c6d1349e80a7d280397ac718c3f09b23706e4fbadb4123a7f4aaf4e0efcd60968ef1359f053a29fa58beb55e8b428ba540b8f0509243ac8b8ad2191dcbed716233f026151131a7e6749dccaed56ea97780408ead7339b5a3c54a84353f0ccc92945360e17ca7764f259f8d1dd590efb29098b89a8b746fbb057823267b6bc4eb880c003e4087fb6af18a062ffb0f8dfe80ce3df1b27b9794fd50214ffdf03830d5cf2026c0490e1689015f111b545dd540841b5c3d99c785d0587a5a762db0588f0bf421e77d4de4a7f41341ea48531c407d50f2b0384b94cd8ef1c5944c5ae4f873f6e044f2fbbda75c43ad077ccb22107bad51671e5855869aac2f3bae311134479273e2696f7bff8f6d7ba6f291e680bf99c785c2574488148cda226ad4680606ad125255b9c9e9700e889a56c960604ec598ca017a7227495a0a2371107ff7c2fa31a20ef5418ceeffdf7458a1a12004fb6027e24ab212c1c09b03a7e4577638e395e43edae19d86cf0fcdd7d844a0ccf4883bc02c863886bb6eb7999a5d997fc384a45a22767d4d375a6c71931d20e693e2ec3c6d03309ff005efd51fb6bb820256b8875e18e580cb75f9da802b804574d6572ca0f582926db4b44b197a866b90df3aa68b055ecc71be54c658ccc0634d001537a7922a47c75d09281846372c8f6882b833815a207e7593d9a10b60cb9579bff64792c5e77e925d7ede5140f823aced3af4f307e8ceca5232ed49909c479d9d3f908a479e5b10cc525deff2437de6210781169d487ec15f2336ae907833efd033f24f623d4837c9d19cc6abd5391a800909d9a39fbe906f987b71004aaf81718217540ec2438576d98b35d07be99aa238318296cf15edea0c42af608c56688dd7fbc3d6afe6afa2d4bebb63915f5c6ff63cbfc087b6d0564fbc8b1053d0d9f4965331fa8913cbabcc61a3721e4ca67b613a6162b8d67d16da2ebf80bc29027c698b5bebc9019c8dec1b7557acf633bf72de1beab6dc6353737257c0e65c91ec6417323eda83adcaaf3af72d4ab8fa6a57b764798fde9fc4aa06c9c0f133f0226e47efb5ebc97d5a871fcfa87dd7fc75f04d2607552379c222d08c607bc388c663a8153be0565244c0515356f2dd72dd850b07ef03f8354d7a56d5a0acf7e83864a5e93e0b24fdb0aff24563ab98feab457424daa14ba197c17d8670b33240531a70732f8704ae37b69cc62ba0d31e5d8f68117f599fbbadfac863b08b94648a8df920eec8d675e281060826d590c793f065035ea216a9022fe3e66026e24e092217663600cae948918b7de410d2a65ac935f469e1be6577f5b3c090d4e06ed26e8c514a621b6e4ff43e618bde0138af1d75aedbca82a91363fe1eb0ac3945a7924638d6704f60404c6f21e2be4687d2bd86a4b3ab472fd329b33c90254c5a75292fa4f185c01db6d85bb6d944f1432d12ab05ce95cfee84641f78b007186c553f19a5df53d2a04c9b9ab446188230ad441dad4e457f39e428abdd70a16fa1ccb5bf745bef858b3517a7e73b55b37f410969083b8ec249f28c611aa0cdb6af8954e1e5471dbeea5fb89a95dd0c55ad1adc53f747cdb4d647c65ef400fb1c749d3dc0697c3561fe803507d7f330e0f595db9a5d4117dc7a73c04e74307808e7a94219fb40cd382886f807223af3ac023382d4f8df124009cd5642a1d053d2eaad11fd28d0b221410bff2fe382907531b94fe613ec4e4029ea7159cb905bd9e34cf5f4238f1d95bf479c61a98b26add01b8f17408014e1d456a29a9e9077d083ed8c7c6214e2bcb2f44d48a0027a48e6dbaeffffb71c239c3c504f6f8038a6ad7104a5053582c97f8a568e4d86451dcae14d69722a4e1d09fea602de80f83fac80667b260d067335d8efffb610b940210b9ecf23e6fe2cc277ef4b12b02c63af07bd49a33c4f20ee85f319edd02137009d38225e3d00ca44c449dd71108a84290151232e53c27f5c67b1519055283d9883af1a2327c6d5c1832550eee0209f0efc4d8efbc0e63e89dd7aee633811a4aed173ed2300e1d5d90d05663cd058f1de3a534c772dc438510378466d67c7be53a5379ef8e5e70ec0320ca49040e0c1fede3a93e4d0f06c76724ae5590db17d9b2c1c4292fe971d7ba891126f300bde5b547cdec443567b21e2d13f62c09ee8a412099c018ef87df8c71df9bfe0e4c8d25cfc61665097410188b5d07319fac6999ff5b43fd1385830e166bb10509f24d66b53783843373ef76fc7a9bbefdfa83d9c544efb5e5a815b44c2e8dbe0e888b39225e4c3c6d93f1f4acc639673c2854a7b801e215c8029583e7a159600e8a16173ed907c5d118cf119d2ea4b8f35a784627be29654b3b16c560e90259059481e3438a370eebae26278673f5e5415a1d6a9f73d51a38fc1057f9621a510fb47a082c3255e34f2823dfad61c8f276644fce9b781ecfc5b0624e85c3d63700f67561d02973fda7594edc0921f0918a56131a7f86484a451a77b172652f630b0fcee08817dbebdae8d9a0f4c17ce334e2aaabf3eedba8ca2422dae5ab2ea505f3a33f11f0981d5c23a401200bc98c813fa4eea2c4998b0d5c8ca79002b87f0fa659ceb83431b2e1c3095b1cb59c177b77a373d08baed8326e67ee20ce801e05fe910af69ea948cf8a8a96ddf3c9db245b42f55d12033b099720bffae410c1082e87a637e8222c9ff1d6e22b21027614c731e0920caa7c5be7542220629b550d199e38ff30ff99400ee7cdf15b5a3bb898407f4812f374c833ab6d627af2e90e64ddaf68c2398878d598a7da996630611f53a149e6016e7918ba142429656e03bf75fc07d91f1f76c7324c731895a9b127c54bd1eab9a0dcf71d4984b21ebf0e53958897c024d00d71d4e62d933e2baf7cfbfed5cd943f13cd7942d5342a72082d9d22e62158feb6c7976ea229f36a845c1495a835837c6d5227d08f38eb3906e898292926e13d879c0a15c93e5abdb1d2385254175cc16d05bbb25dfead620d72a9ec3861f497aedd000faf83451df749d20189268a123f95a73c2e0dcc9b046915c049bce5c2e08383421ee934c1ab942fc09dfbe3cb0ebe091a1770c10e080858ff9c623e6553c293ef2feea42f4bc1d5280f0dbc88ef992e5df2a1d3e10b true +check_ring_signature 88da38073a8e50479ce975749ba773ab9b96034a078c1ebc1c419075c0c14e41 995bdc0b9f498e5e0a9e5798ff40a628946c426fd690782bb54549ddf9354722 120 3d73b8a72f56d3011e26738180eca74cafc417636fb8eb12a28eed5e5c020ede 77a61a1e26b94b089a0e5f0b821ec7c1d364f00d802eb70642eb120752b9479f c5cc265e4d408b3a98cb1088dbfa76228471bb34aceb459c79e903bd4143088c 8ace4d13fd65135a3a186b053bd5f96940a0b99ee8c635cb753b4c85f4883895 e52e0cf6aca29b1b2c772e44dc3061af0826dc05732ccd5a5cb0eca295d9f218 524a4e85d543dd32691c8895c90f28d64860f3677a3cdc3c0735ae0bf7c8d7c0 1200e3f459aaa28a4d6e77d6529ca7124c0b17abb17e480fa26a1c482df148e8 aebc3f933f50e95d6e369fa81966ce2d052283a7bc5cc14479d6d693f028094a e8276370bb8e6c3e2b2d7c57a28e313200b33ff4d035586a776a72af01e65c69 045d206d343aee003a4f90e192f6eda0fede9b17a0b3f5b0495939c152c3c0d3 64f36d698be14de7f195088b9fe0b23c6091fd28aafdbf048df9cd16265ef501 03a63f73e1bac8dcd6252b5e21eec55bbd149986dbfedcd957fb80fe1cf79a21 9d68e7480c57fa70bb4418f169cb3fcbf69776a0c04a2c1e4d6dbd4055323382 0271f373d76197a55994e5a7f28a98b48b7eb3f82877b9e486e7e0338dc0e979 cee355185fe7b5629b29f2b62fb4aada54dba8d85deec535edf9cbff443210d8 3a793a2c5149d4193ee2826f2dae147b10c33c9767ed502f8660b0f373a38ed0 a9c51d49f3f907770fc78daf62c920439021713cc1498af679fe3fc8f12f071d 1d9b4458bb104fcf1a08618a41d1d5c41e15406c63028b9b80138fd7fc19dc56 6f6283c0ebe1664b6143aab31efd47efe1f06622a0358aee5b592e09185327c4 793c1b0bf5eda91d75873a4a5d54fe20f5fcde1908851d9b7b480bf184df9273 19ebad7c0613f37ee4497b47bed41ba20f7e21d9601d6c20ed043e21f7542dea 58fa7ee4b0c2a97e668d501b0817f1a0f86ee469af8b32f5730098e56960e88d 492f13a69f36402514367801cda191e2cad64eff738928702adb35c1f781628c 598eea4f360c7e62c82b2918853e351d07f3cae1b3d2535e3c1531671d0a2801 6e4e56ed2b1f5a9dbde4e277fb4506bdfc438e6004a44b5667dfab7fd2e9ce61 5ac170949736c9d23d1573c4a72f2f549c0b8bbcd21f1148318205146d365e5b aa821a1123a537e599ed1dbe7337e89d57d1349104672969df03017d6d40ec7b 24ddb92f970af9d57d14490fc1aa79482a3af1672e2c530fada3eb22648d2e17 759e125a3c573cbf432a176b8af8341dc4f6afe35d59ca1e432d1b51b6cce9d0 7d7577c12315c766520553e75e8be4c2832f97a7caddd2071988f840b643af0e 1fc599acaf154739335163be3e7e63ec549cfe1c284934c21064d8dcc9bb68fc 05ce1a17bfdbf563b732da3d40ee916c7d4b75bffa14f9f78ab7e325b560a57e 785dd011c1ba635fd95f6e01e7c29237bc48d6a5000c559afb903b3528746de0 e9aec84c6b7ec7841ebcce27194c6b7cfd58347f2a767f80e90422bfb8d35b9f 81aabc1db28f49f085a449d199fe4553f20687e8388c004ffa6c5669df53137c 7b8a5d57cf2071a5e3e2fd1d85a0a42ef15f883fa0d59d9146777d97cd87fb31 695025bf31229a5ff5140860c3ee721f2a9479b1191eaeb73184e09f46f96b52 b6d45e7a63686a5a6b96970e59351368bf63234743e45273fe1ae19003d1feec 80b3f9d45429721197e11922241de484323095c8bfdcd526094bca1c4ee0ef49 cbd921207bb170259de405d60afc509b971fcca83e4a9bc8cc6118b26161fa22 1204ec4ba9c54ecde64f3b0851dd7e1b173b03ab67afdc3e907f21803c5c549b e5e59fcb9f27e21318654b7a9867ca4f31210bcd42be240a2b8ebfe2e39b8655 fab5646b8a2ad6bd91efd96c1091dc2864fb8aaa9323f79235d27ec60ab3f2da ed37c8883bf471d637d9f056f2e519d4810f877efe47909da52752d13980d5a5 70c368f71b13a6e310b9a1508131112f6e5c295fb8c80f79a954c69e61f74576 7ef4b84757030da3ad73b34b0a22e5cb3f06e6dc38d6f435befb98ec99999f25 e9f1199d595b3070d516e65b47d4f38c1cb27aa2c4be54b57080eea64b3e52c7 aac9528f2eb2d5b957d863e7cf32851c62b8748029ee1bd2d0ba6043e379368e 80eea44ce7e3c2a082f52abe8a355ab3ba27946c33a937e1495c950b9500a023 2a85ed83d085790bd1451e982e942b8f9a4dea23ccb7012641592fb19bb8d678 acd1005c8348e61eedc7b3c3cb4a8f24eca1b0c98aa3284f3492f33392b8ef3c 5dd9f6423e311ef0d9e62753245b8ba85f9171b52df586f4738985359ba1bd6a df586872a9eab4c2c405fbfc4c63f3023c15f5c3b1ef9ec1a601a099e29595da 6228d6904cebe52f936560863ab744de9afe3f374ce64997c62f06e564f761e7 9d7c9a0a5755ec80411f2d57a6d6bd7e7565286de11afbd9edc2991d5cc0a184 264ef3516bf90d8910b5aa6da802fbb0c1065bd4bc1950ea020c2bc231343937 1e4e0ba005992f57144604a75488e023e7b89c57bcf2410f70ddf508c8716852 88ff7848c84a4a1050f78b9930ecf5d8037979c5a43552b13a6b71c6b2fb3049 09720cf45f6a0f92b97330f9c244374fcc22d2b9ab705a3868953a05a707ff90 197d309dafa7663229722a2a35457262b061e09cb86fac8e5c02cfcb16b96709 93ec8007bf747d71ac140130a86fdcca106f76513b2bf0b25fbf5e92ffc9739f 2aeb4d510a230716e1eaba8f0811d34ebf897a92bd65633a6850ae51b8b6aae1 caed1bc81c1ab6480e225757c42fc4ca832408f4fe50f97dd9b909927fb36b40 79d53b27abaa825c04acbe118427e4aab0f8470de840209aa622c6ed1479b427 543903d5f0a10fea741206af2587cb6d56d13e42df0b6fedb04ee2f6b93c4dcf 4d40e956c98b50f079e67a432c39cd1fa849a289661dd31b5b5818b58cc860dd ed92ba504c616467314cdf64e907a01770ddebae765abe7d39ea1d62f5661024 b6e3c2251952c66fde9bebc8143e864aa2d8bdfd81b6d72520b307edc77a5b42 43171efab71dc7f729d9721e36e4879bdbbf9b54a4eaec0a4354b1aee70e906b 6d2d3677d3478a11c04008844c98cd0f4d3950415120d2198abcae61df255a3e 3a141b31aa12e76fd4f3e74e2ec4583967fb40c88e6cdd511a187417a4c399d9 3e6c6285a343420ac60e09d0bc505f08d5933e5aae0e99e1650fd6f7eb23b3ef e9c2e17171dd836d529f678f15d6aec24c68a0365fa13475f5cf43dc27564e9d 8a45a3c0a55775b42a8d6147649b34b7905c08306dee7a628e1d0df7c5430d45 230eec781f02bacab0c59f0a7b3b4dbf576352f829957e06e0709adf21887707 35ced72bac9f7b23806b46a62c7684a8dd0bb02acc04ba81f080f2b59325e149 228cfb5eae60f02675f9381ecaa5a442bd6a77279515e5aae2dbace9ff85a5e0 d2fb692f3fe693947c25378939f1cd0a071f1c5ceb14783f8437e028395c6504 838b81ebb77c651d2d32a1d1ae8e5d827244e312fa353ea345c25c243f438d04 3c70b68602a323893d12f9cca7c66a293d2067a4808eb9c65f2c4334221a86bb ec5153cea11981135eb9ea286285a731b882ceba58bb861cf444e9e8f50e49df a54575c23cb18527801f2ebf809128bfee486ed4095a1165e7cc1b6daba06948 a2bd7b37d96986d9a8f532413685aeda2f4931e265ffed9c4ec418ad43ac18d8 bec53b9de2dca7e06b9569b5ed29c08161d36e692ca2486070df532a4e88b4cb 58bbb52baceed728c745a53286d1f15e7670171c1a0a18a9047787083d230d82 0aee6466a9d85823371c7a289f4025d1d780bb2414f1c38d6b66f8b903d8d9d9 7378dd3be222f7ae892a8a87ea8fd0b90614d09b6ec7ef300fd4e2f3c5e96bab dddbd6c33d0000254a96a32b246677bea5c4eaab6e04697bc4484830a8c1fd50 52b25bd1969423893717e9366694f4aa15378a68633438271cb3768fef95450c 3532a3e005d9573f1d75dcac714d36655a075abd2115febe2340904638932aca fb96bfe55b1e3fae1b5778f2104f1e73ba315ca7f074488a41b9a021491aea1d 434ed6688cf936d6e831a86b073e354e091b6204c9e854957c3721427e9a990d e68aadcbb2461cd93c474bfa56ea1e0bd5faf987c98d9a7defc1da612af19c6d 20bd884b92a60208c1e697b0ee7f018ccbe0d5260478c4df38185c76944ec13c 26464ed5aec89e78005e6befa192034f8ebe1dc02aa18c64936778a88bc7dc75 2dae9009b2bbfe549aa77a243dc8e4937498662c6a860704d5aaa17ce2f1d856 c02aa69041078bb2bc0a97ac0f84b8ca054516dfab6ec5b67f99560f0730ea02 8ae1c92dded04e4fc5f48449cfa21c088fa252bef5338803dae66178af46bd7e 9a2d28b745bcc8df968f4045c65f85e0b2be773c5aa96699248995ac61630795 3654d0bfec2e91713320125c4ecfb990ea02f2ce463eb0e8454a665c7d10d47b 7dbcd53637d3ff250535682e2c8160e43437c6cd8cd1cd294f4f9c667006e2e2 2e50d31737b755542391ad648d8ac2df31b0401ff32ba3144f1fea681c3dde13 99fcd1b0a9069ec493060a05c68b9b4576e22ff1e669c3c855b711abddc91011 8871a0b96363f23a396a3e05714a75e440e2f26d1df6b899b5eb1a5e26e086c5 c42f78d24c33a7cb4c51cd002f8f35d610e91d94f7a17f95fbf26b40db3a296c 109ef0f9792b8c9b179d9bcc4b7c998b75d626acd67e1201910595989dcdbb1c 122ff34cb80e03ca899b284f5a369859d64f06e3924c2d96734812efaaab2a09 7a40363d5997104a79e4204e8c95076ca71860844155a884d1a29774c861c3c0 9c078619b3639501b9eaacb92b68d3c9f5f8cb96dd4566b210519cc5ebf904ab f510d035d50489396904e8f508ce3a7aac1377b0e35d5f23cd7c94b30d729920 7d51c816b0bb53e533ce43aff9fcd78fe093953e452e720e556c3031498c0f50 5186612f845ad2e645229b5050f3765964b178ae56827d10bbe525d1274e48fd 1a2f3d46e50abcfb9b2bccec34d8a777f43781b9284b4c02f7f0bbb6052ff14d e0018ccd6e9636e45d370baf9aa179889e8419352f1209c40d19b0c37cf35924 af58965bf0d6c911ebe62d84c685396074a0018a8ebfaddcdd82507e01df58a0 111c64b429b4be6deb018d064cb79947f1679b0d3e8d9c58493a64ab07f96360 339297d8de519b640ac39fce6c8a7790717bdbb417bc67c5dc691c799eca1821 e92eb1a4933ffb854e03e859fd5c379b2199f9e2a94b74c08bd3b1b599273d74 441f623d62ec657d237123b77de0ee8668ef007ca8be8d325d811373043b793b 39429688b1b92187ab5169fe71a75423a59953ee5befa46b39a19d5b75d31eff 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 false +check_ring_signature eb8de94d8895722d5eecb9e5891244b398cac50bbb72b1757200bb7c52e76c3c 335878a9c221bf48247f802564476c343a5a91b23167e0ccd9c21085b683c25a 83 cf92c9c7859a2e81aa428feeed1e136b74c4d3c709a3c76d2cc06d01cef57b75 5ee6ed1c43fb19ff1ecc53c2a28c17412db548f2b99d1b79fa653d076cc10703 e0309f836fc0ce00202eb71c1db0238805dd7411f6f5a29a7cff751cd3e6c0e4 6c1d8801062d0481856d8dd0fc373974896008b45e8ecbc419b15126d9b594ee eb5c02e71651a3e00b1c1fb755116936f777aefcde55c52d220b08efa7516d93 3060fcaaa2ec882d9b1476977c62622c16426c529fe896effa1e46ede0d93ae0 46cb20468e4e87afa6c78ca0c08860ae826e34bb1b9c61a4a995686e2498efec 0b468dc85d19cdd77348d5b8528e0cdb9b02ff4ed55f90849bddc66c7ca892c1 c95fa18397d9bac019383ee7441c161d82ce53370929fea4d9114e083780c96e b32256c040e59691b4b97a27a35a99aec0412fc45c62252c59cfee29ad15e518 374d3985044f7699eac0dc127648460e22f9a948aae6080e38def51729566d64 e34776de37a4e4328d4476a7a7e900bdc8d2050be19cc9c825d6ba869a3e7d53 e67c5102074dc6d7b9b8ac312637201c094205cb9e34bff35ff6acf87e299fd9 9f102d80ebfefa302c91c5d091e409e815953712a1c5fe4b64649e479e249936 6267301a26ad01852720774dd69271b80475143b270f86015a8e827fe3bb8fcc 86b76c23c2811883fa171fe83dc5b83785774eec8e29fb501cee607ed09ef986 59d7084b2ca3505bde548d1114b4c4857a5af806e99c73d37716af9ff66a02b8 13f94e09cea71c75667d530a915b99973c7fc3fa634936d8fa8c8cc0c8351797 84cf214d35d5f9a93b2be79765e338a3ee5a89ebbcffac4b7b0ef92ecaa64a8b 1150e21bddfc6bec5f55e66b7beab22a264358de513fe5e84c16f1618dd7a129 10c455ba4ee20d61c0a6b1e45f3173fd4194a4ec7ca569088afce819264aed9e 0e96e03ca4c114367d85cf8ab79757a5532f4f0d537802e570f10718441c7922 49422ad9b741046c1c239edd6b722c1b8357e7109f2f3ac3cded85c9325a2a71 be0d1d95e8db779e3fdbb9a060e74e0028f62b65b6d7f3d46fb3bc93d054d07f c70f6dbddf4ccaf14848284402511cb52b608dbc3c4cbe1cc3d3d4f5df8e4ff5 1826bb96f5a35d01b2b9c8e0b1c4cefb941840d800e83a34d09a0eb6f3e95983 e050c7df92283991ff34fb2fa0324645a6284df1b2d80fb417a6ae44470837d7 f986ba66eed89111299181004ef323bf7a0f5616c11e2ce6f39a8f190bbdd30b e55bbd645ae59378b8925e754a36c24ecfd97deeb8a35199bc4c4dcd3d22a579 bede5aaac60dd25406c3e394aca147f9529bd863afe8ab17e78e7d4ebad28cdb 70e3d7ef71ad9149510e22d6a217b4d3b1df6b8615ce06176f1fafaf2bc2d66e b134a8b7c243ec3398403e53309afb609f349e3cca05655ec442b9831ad03f79 8265a59d123c62abee1dd9b871e5bb99c7595d23625cf08988c73e3765861798 86ed479271a0adaff0e982ea46e3b972dc76daf3f7f89fdd634b9e013236b5e0 0f6394e38017323756cebf793905a6c2e7a35d04755637f54f45427b6faada0a e15cf95b2b980f32180c1f4a859dbed8c8c6e86d7dd76d714a49bb59ef0bf12d 16bdadea39b9404c246f99a04ae8bc01d9cb60b32fabac3ce0e4d827d98cde16 854da10f8c66afce7a282a9a0a606385d2a5fc6fff4756514cd6e37bd9dbb21a 38194373e6eb360c4cbc5d1f9c770f37311d14f4b11de37b91684cadb4752dd0 c0ff87c5dabf174de9adceed0de96b66488a8fc008549edfbc818511752a3a0a 80360807ad760112d6ac33eb61d63df4b535da1bde04f7399132f361139c4943 5d3d51b898093dee0b52671de11c16ed7d11d34de718d538ec821bed86fbccdc b050d61fcd37d22f66a5e4e7ed21965872092b34a8a790f11610bd099412f424 cae876cbef56d6ad39b1de55ccde4128689bf9b0bf1ed68ccb386c8b40e38fef cf7476d9ffafa77a81cdbec7e7288e0ed838823fb7c2d932bdc9c1426fdbd355 64be8e2e2fae29ccf9dad553cc13a0a7279e1dd5e8030b52f23211b6a1cd90ec b708b0805402b275dde661b21470bf606c9cbe33117ce3c0e5068dcf11965b5b e4c80759830bbefe51ec2209a0c050f516d067be7d90328c776c3e3710432664 a53a5a5112625e83abf0ac20e69e0ee9d7f9c1b94c8eed63596ad61f7adaa466 09e12b94e03bddb5d1dca8b85caa26ba0eebe697a152566dc9b3d5f18ecb2397 6cbbe549de46b40a9a175cc93a6bd20c5b1f7a165579a36552c8d5826e909d4b 5f1f78a75cbf4bdd290f1333509412a2f60a51e5e85be5a9a48358da375b7430 604ea971f7043b3afb8a3d57ac5570409fad5044b82924f2664c0478fefa5509 8c1b2bafe6f0a6f720952dbb92c70ff10dc7d50b3d56780cdb1a6c9fa62367c1 5a3ba8ac3951e1e895aa3966362d801a8fb8588c7cdc329b506430300a208e14 3b0aa0d5bdb79026aabba2b3f7e12ff020c53038b18a51e883280d1dfc9345f6 6359e2130bc72cbb2c5f1230c5d72953a60e23965f6a33cb88b7967485956233 97ddf1604fb151f2cac2054dae51c2531ba4fe6d5c69a1395638e4fd39d86f41 e1f48e35d8464cd2a3f95142474fc37d788e4e21e6cf29849c9cba0272beef48 8866b63526d2ba268887fc546cc2fb979213e1fdf3122e76fc05b520b0720e5b 4bb06ad260bb1515c8eba2b5830e8ad2678fabcba27a644106be305b880c8bb0 bbde10610308ea36959277dad8dc55ae3be2d5cb2f4f39a9953fc520e54fe469 d6dcfc0cc7b4e18e2ea0a696ec70d00b9e4746978f4a87668b6a89de5b8b6663 cc0cdb6d7d3126220c13d6278a7a771ca21909d205448ffd72a1cfaf81c9fdd4 3e2d83e0ea67863e9d99ce9e57a1d76bbd9a141e23b55fedc98a8d681e2ac515 4669e63db4e2c106989ebce63071c07fe5e008313e09ea5040208fe236a73597 6f45e00972ef4c12e6f04349da2d5160de1a3c55f020d194a7fd5f71c4395aa3 3b554b3bb5cd34537f60605c69d2d6f2144395028d01749e1dd7b75b181d9fa7 9783ff43215b25eae3edb171cdbd581a96f4991c32f2d0d99df1106dc687bfee 85cb5c2e08bbd9d2ed5f151cf5da2337bcec6176742a0999489eccd5fd59b236 a4e075651abf81117830055f8ea81a5e06d46222732445cc9764e0596ae573b6 9460ad7fb9c4eb3413457100fde8220563d52e536261b720d4ba4af953d3e95b a5240307ec4d5c2d441307bd1ed5b32bf1630ebbf8f2fba3713a78fe869168b1 ad9c6cc95ceaa2fdaf85ead4d2bd6ccc7be66f1f92e1499e748a72101a26251e 23bac5599cf6dc687d2f9c3d9910b273020c9469b3721babd53ec3dd042f8ac9 6cff0084632d38904a7b01d3c2db45a754a643f48b11db84f935af36c8964115 bc92f68e98c41f2514a2d1a9a95a1afd749daaf506bbf4763064edf9d1cfd0b9 5f2facef058a503e443def9fe6abad436fe8c8063539d30fd8705964175a4cf1 128e4d76bbe02bccea42b217be9ceac6de735a8e80306cc8aa9afb78da4d4fc3 7f571fd3fc183783ad6ae9b21c0737f150b5fea3ea9e4037d743fc823db410b6 b701315a285ec5fc795fd760673eda2ee14bb53b1db6b8bd8ccd4d94659cddb5 d3ab4b7232291dff6274671518f4c76b1dd7ac2d6cbef7d28db39647584999f1 41e3b280391b2ab6587595dcd02a2f7c3010e6d659051088de0059ea791ffb4b 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 false +check_ring_signature 480cac7c33c8cca87ed98876437d22cd635f0824bb4dea3c6945219ee4a2d616 2b4bdda01cd4fd5c07dca1ffd358a02b4d03470e3dc74d01fbcc8f6c5dc2f944 37 40ead6bfad4a193bea00b8d871001b53ace5b18671d4ae8e1fb54ca9c8571c48 b662133699fc64848e580aabc7a5e1210e01749314124cec971ea4afba6a0f25 6fe72515b7a44d7ae0efbdb5064797cc4c0f6411eca259e16d779d307860486b 1876f38c61b26a04f28213d09cdac29c857f01acfa1fb0242c3a74b442849e30 600d3be8303ff1b225b556c82488578d58e050b4222c7af4de3115a53713743b 6f370d983fffaaf8b2f51bc1d5674a431d986985197e8840b0a994e08bcc3fcd 69d2c90bdcde3ec355223d06f1f0ffe09f97c0ba11a5f73bf9d27ab5f4d509a8 1ab593a0ff5e1a2b0086f85f299801102fa06479d42fa3a242122cba53439eb4 8c3b89b15e944e5ed129d2bcef5fc558974afd4677bd17bf8d642573c4af3cf4 05188d45d8f314b947bad271a1148de5ed376f909d5bea97e2ac51622e7c2e18 2bcaa3bf286e1773ed78b71065c4086cd3c2728fe0b26a326763e422e60a070d 06a6d098e01ae9e8bd160fd85bf54560d7b8064adde6eec425d7cf3a34112ff3 19dfb5a6fce8857f73433e4c5d857160ed75796ccc4f0379b693511c9bcfe60b d34cbdd982ec79345ae7e0bfd0adc3102418d713d0883d4c846e8dc25bc1b8bb 843c087507d8a62e686bd96255c6113819cf21a373810daf0aa5a87085602c20 6ed5fd6532bb8ee038a609390ed3ed6da0708874ddb06ffdc0f1eef0ea848082 b57e351f995d8e9acfdbe56ff6968fbf9eff7f2d0f4ec802ac9d2059b5ebc636 187e22e04c34fb611105803d4dd20c2b5b32214f328a5bf0e4a1e2c87eff3873 51b061a5b3bcec64f5f8036caf9db06e09825e7a73c01e62dae3428fa1aee17c 38eab88320ebc713e1fe61839e2e2a91021eb93989444bdcae8145fbd7a89434 2a186adbe730c00a5cb3d991fe41ab3c83759168cc46452fe2ea0454d8835f16 87280219bf29533be4f096e272a4b2e44fd31443f4eca11555f3b907ea5807a4 cb6b591c2d0db4b96de5d0d378043c602ac0d619b5ef17d5f9e93834852af4ef 62ac8f38d10a194df254cbd53e42b87f1a418d4a6d553e4e67ae73da1fb5eac9 a5077b486e6d2bb816c92c3757050e706e5067944255d753793ec1c30314e795 046bdd917dacc025c639e5d904985de0b31d8a72d1352620fb5168a09c7998b7 08feafaf935fc01dd66d2d0be3531d6a748ed52b1727573226c89c85821b2fad e35f33aaae369cec851e0497014e8d66135d00533b0c7a9729ae8cbd6227aef5 afdb0038ec22b39e1d9151f842cb51dfb6819d11976a6d12b57b93a2710d51e4 f26e4f244f43f5d8b685dd6fb3a598e42e5c2e6ac0e2343dfb7565d1b926db1a 94edbe859a6c031cbd434d34959df37f182b26b849d5e315505ff2b55c2692e8 080ed927a16dcf41322b4c87e5d22ce7d0d12b63bc1401ecad6b57063344c42e d2e1d9db0b842a7ab9d2b558679772fa5ebd7385037a92601bbb9947af5802af 3ee80a182ec3f5ce240b2b91dbb21b2e824e9c8b8ad4e60b24e4e0f1727bc5f5 7c29953218bdead5983c7ef432fc40dbd919c5dc08b29b0c4f9579df48205d7e 8e822669b2110689f7eaa047fc7fbac39f6d3d053b5fc03e8435659f1a5daeae c06b8ef35d04857e762db9f5ba9823182221fc83e6308fdd1acf6f714e58e581 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 true +check_ring_signature 402f572c7c2aec49d99da3fd948122490095be0f7be9c14055e97864d0128e72 0a4c3b978fd4e7b4aed8cfb47e3218a8f6d2701f0a100c129bba090f6040d853 5 4db607e7ae81a6322a57a1df78ab87d6ef757b7c0cc896cd6b4f1d7ff947a3e8 b81158e5ea313a37fc577340deeb038cae917a0c193c1698281d1648291bff8b 3bc1c11acf0cb6ddefed2106243a5ffae1593d1f214cc10e42fccedc25e35152 5a2aa82840cc0fd6386b1edf0d84027288fe0051aa07c98d9ecb437ce4d8a148 11f0c2bd85b41c0a78b7d1c4964ced217797510805bf4c0fec22da312ce2cdb0 bef56674fa2c6ffbcd9248c5f6726906a2750558cd09ab9db00969fc711cac02c638af4a31a002aa36e081f2a8d2442964601314c318a8ae336af643b193aa03f0324816eb32a837952efe63adb799f97ea5e51403ab4519f7cc271dde2f970fb2a02c9b0abf087932d192e021bb51a0692b8393665f87ae36ee4853f2240b0e6dbaa47f270415348565382ea222b5a7a20f57da194e0f25c1c9b0583253f20849841d78e243d2f48867faf33647b95a39c02c23d8ace08a41fa965dced76801e03fcd46fa4ba09abdc9b8041721c8ff70c91ef17b542bac5b7427b7d236190381bfa2db37bd3737a2d6412d12cfca7e3800c1096f8e886445ae3735092d3e04f720897ad6f05be5b4668344a339efb00778014be3c31f805393c01cc94a4c0177c20bd612cecc5e44bba17a2ce1b730aa8fb9723bd838b5c1baa7391189a208 false +check_ring_signature 37daa1b0e0034d61dd8eac8d5ea02c6f6654db96b48c1f56621c5fba68972e9a 33a2a5668e312284f4a2fef389c8a1e4149c72c42029849ac49b72d1181d9bca 27 22b95230c3ca0dbbdbea1b46561ab3d29d5cf7b0a3f7da353d37b4c322d9627d 55cd3099c9a503a7ea3b3debc6063350c5400d387ff71f95d38628d819e109bb e60363c732d1272648381971971f8279fa6b54336d0cd3747df07ba3df942edf 801b670f34cec6ae14487aeaff6e60e697c916034294498ebe365661748b95ba 08c7a9b653471ba4fbc1b2b670a94ca4fe285cb33c4855d34a68da607a3c2e2e 895daea9b2dda1c38ec00a63ae12fa70578f9917215af22dfaf399848803ac74 7b390624a3338f14a4cf2adc8dc7c35156629e4108c3fd5b0501847fd7f61ca9 2fd34afdc817668ab6e35dd2ac84d6f5e6bc705f2389c3f2b6e3669229b4a178 62ceef6d78cdda2ccc42c0eef5deaac1265003d6232bb1e911c219ee8a6b35cd b49fc87e6a661a4caa5ea9d51884b1edf228e1f5750b4bc34a3a57b95734e33c e46b8f6991a1a94c636980a8e9070f31accc42f36b79c4e1148a33e20cb4eaff adf145829a899cf383a97178d7d48bfb0e0c6e56941b120fa1c3913cdb330aa6 82e505f01409a8f3509996212298158da983406962a0fbe13433510d2d97a7ae 7444ddc561c2ce132d2063e10eaf4aad61f37099579b41c38eea81d0d3acecd4 0f0b81779ab1703652d5dcb073be8aa2a4c127d4e64303c0bce0327a64bd6a32 806a043fcfb03675fe342809c02a7e6e0ef6345920a33e2693f4cf722a0be4ec 0cae21dddaf1d8380fce4177e7f6a9e5e22bccf9825ebfc1e76a25c9ee30e591 05f981710c800940a2d50922768cbf6a31802db1d0b535766ccae0e068a47a2d 121150281c8871932d5bcaa9bc6298048235131fbe0141fb16b268dd193afad8 2bada6dd0688a4fc9ebd54cd69a08e9ac1d724a0b97642565f8abd8dd185b2cc 2c061096e4978e3f1393efc8036bc50f1a54f131302826ebc174397e152c0c85 2f3530dd899aaa800f750a30e2211abb634bf997f387f843c9d792fd7b4d1948 64fc63e1b314f2780e2dfe7112907c1fdd05daf5293407251dd31081a66bf73f 57fa2912eeb28530ae6645ac012d9f1298a82f02336b8d242337e64e2e53e874 ac494e2ae4670d68cc88a01fa77c526820765ed08342ed0b588fc9a704b74c76 6a06f2667d80d9997e2a18993bbf4813a01867e8b244b1ecd6a77a059f04e10b 74366d49473f590d25e01d7efc568370222d8a86acdfdb403255718731cb7852 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 false +check_ring_signature 43dcc589751978b1e7ebce1771e400f6a7e54e34e7c0c954d63c904ad9cd1441 478b3e0a465cd2210a19d97267a185601707c17c90b353db4b66914718491574 67 73bf02fdb22a744f25978fe86b8500c138ce46773910afbdf9a2361863aad42c 96a1893dcf66a4864598aed233d2346c5c4296698014ca8d7e0c0e1534d2903b 84c561c3b004c18bfd3f6c715b5c42544a2913885c38d4100abcf11f5652b87d 30bfa895c8938d158cfb03226627b714deb2d89b1a8fbeb68a8c852d553a0be9 a063a3a898502fa146a605afcecccf29e79fa15ec4f70aad9d289e1e68286d9c 6a39fae2c70cc42957f55a1b48bbf40d652cf88dfcae4fdd34678f59027002e7 ceffa9cac810e005b8054c7c689e217a58bb22c95cb1e355ba30e2e040943765 b40fb838be1869e08d2b95a2e04564d47f5da1e90b13a632bcf1d762decee8e3 b9a0d92a52c2ed325223eaeaacf0dd18b18fe63ecf1f3290225855397944f268 eb33413f9c57ce2be2ee84c7b62b85bd2bf3f4d0f83a478b5d5cc585a974c92a f64bf85d22bce431b25c192b6fc16fc48047a79c35b171dd031ecc18e90fc5c7 9ffa64b55788c27c1151f5f5bf985c3c02a21f84abd9ef34f7233a976e11d58c a11688436bce7761dd15e3cc2b2725f8468a15e4052de372ff977737843bbeff b82412ad83cfffa9bca97841da9077f1e8fb180975d8ae1483cbe8b858154a63 e3d4cf0789822fa8dd8ec43293227f28bc5ea104a81130fa446e648e2cfafcfb ab2c76db591d47ccf99afd01e074a835766f7e059f4d3818d762276640d9d5f2 a51373e3d718ecb4700a1f0dc3751b9a2b912b5ba3637ef80dc1a5e928d35e07 9000399b4142b64436e22255fc5eede7a643d16ed54f6092f2d8e66cfd252583 ab26c07c75d51a11cb54fc227e57490d86e01f000cd10269b2cbedfca30d9c5e c7e563fbd7b9e6e20889894ac081212a17022b751744664d80269077d3f74d4b aff51613fa3012dd13b46ae5edf8c4d642f7dfb20cfe0134e83e5dc940aa7815 34d5a089cf38d139b23728966263382e9d47f6d90b88c57454c5c6ff6e54a126 671f5c948765797b91e0274993682c1c0f6a46b8e71c8fcec0b0ca0b62fe3758 dbd3dc472d2e8412f2af7afceeec3bd54917bc1591450d0b194b767d624a17aa 6d077702fbb8b3859df14bfe53408356549cb77f6f446436f4d2201b364fe92c a1305e412509bceed4321d242a29c1517efd086f47c33c1983d8c506110334f8 ea4dceea8295ef9cdb8dcf44bee2dd8a45416823c93e0a22ddb403627c4e53c9 eade4d84d6329fba762f363b5b39ea70507ad7f75a9ac616f3201f58a1482af8 8648c2d5661d6812068d43a7563651b4f96c5bed4e1efcd89bea097ba18d9776 ac5bd79495a3878206db16473137e8b3623ad668a84718d45bc48ca6c026be45 6f208954f2c38255a12ead575cfa614919d51d95b55c27425ca82a79daa6bb23 a83da116bdfbdcdd5a8990d04f560d535f74ee42323cc8e90b5082acb6b9f061 3fadc427bdcbe3a7c0bc5e951bd1b817f6f283b6cfdf01e17f51089041ed9ab8 fc5b80dba3d85bfb9281b5eafc10c7976f99cac32c63900a9d118e2a03f02b7e 594e3a87a3c1e6bd581a4d35b69ab1ee2d835f353a33bb8d2a315de51eebc824 63f76ca819df300177c42fd7b77002d28b512b9a371ef146ab3e241ac66e35c6 e053a39214f0e02cf1eb05e3f8b83f1cbfce39151cd9d88942506dd3c650c7bc dc52ace13294301736a76968679dfe94fa7975511fe93747c489f798e3d705cd aa6b4711fd92dab481df8d23f631b4222b84854821d71b659cdc7bbe076a3571 86a7cdfe7b7f46ef03036c1239871f26efed5690c4b4a09a39d3fa85a0e1d1f9 ecd7a94baa92eb9b91e5d1316fa9954de3ec902e022cb4476c1e3c048aa934e5 f3f4e33e75d8446e0431781314355987f2ff975f80237982227b36a2370d2aaf 2e56cfc74193de957f0723fe262f05f57c49737b1754cf562100f660f5de0598 ec457c5768c9a785150429e66fc988175ef69e6605fc0f0165877ad29de05d16 9914e108d362b23bcf72a1604a0ecbf83cb59c67e97afc8619389d1fb3f9183f 3c9bad8a7dca5d6b162a66470c2058d53186c6910128764955132704f91eb76a 3882df8c047b8f0c28762687f820cbe1c69fe4615c709527fb6513e324b03690 197c3c59d459132f494c87f4b1100b86f20b05e66d33cb2dfe3faa1ebdee0aa7 20f38abd0cd0076c4a45a9bab77f438c1ae3c6d5fe3116c2ab41e46da8954cb7 f650f84ff601b4346bfc7b649a10d1636fcfd976663ea8b02cdcb1c36df93df8 aca1e0d5ed6d60bc56b7f2f536ff6109e21b42b6dfe5ff83dedb1a5fd2f37016 af2d657e0bf239978e4de8b17e9584b594b06f6142c8be5409903ff3eba72c7b 6f7a2f3aa3158e6feb53303a631695f6a433642d84e83090e1e8e36690f7d64c e267a243908e564a6623f47a199a490e8a2acbbbff2ebf784063213891f13d7f 5686bb667b82827e6ffd70fb34f4435f7f9e05a5214cefecbcd4b94ca0201bb1 fa4bdb13052408f4a1cf8beee0f95d862d4c014f476784bdcea6a55766e56462 7223d5ab71b3ae32b297a44ebbf1968562d14a365f9bd4240796fffcd67d28a2 f46ce98c7a6f07688fbce3dd9156e403124782f257a04aede2c8d647e48a0f97 14e7ee8621f1a68d0d0199447e68382c717753e7a0474f03ef39fa95d9c7a4ce cdb7cd8e295e730ec66343af15e53206755934f33c8f18a8360241b2b716bb38 5969f39987a9c6884c6c350763e783e5a69412b84f2068371a3df1612a6f2281 d670c99fc0985ad7b812799ff7ffce50f1703764ef7bd28b7982326de22f2c80 c396cb270ce89e14d2260038c431e90ca6375b8c2218008f0530d4185bcc3aae f2e56a8d5fc54d594171711c79d5ad7816c014daecb554a4a9fe9008b91c4f75 eafaa6937cd83f72ce8e22896f5b860f4e0a3260a56dce1bad41246ff7165079 9d9a2969f3c4b56fd41d9964b6b4f368aff04872e89382a2f1ef1f410bbba9f7 068912f8618ba09be486a693d61c270d460b5c754dd88d3fa48a883ce9f1672e 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 true +check_ring_signature 85919cdd5e08455dfccb02a00f872d9238cd305a69ea46cc183c74df7d1f8da4 59c029bd06549d4b03f1688f0b254b487b589d259e7696d036857fc6eaca83b5 116 30e9543be528164c00fd70bb15a04807d4a589722457f01d464a53baa2ee72b4 86e5af830c867bdee0b1c438e9c5a7fd4be049cd5def62e38592ac1429f91b04 ec96eb3ec1102fa9f6df5e33093896ac61ca2fb23a10fb3cf7d36f1c5fa32698 9c7b9f8668ca86256edac07b67eb032b356902686c0f5d707de0b570374a5a75 d4ac0f3dd29c1b8b6fffd862cd4bb6ada853f0b1fe0cd2e3220d7954949d4d8f e204fc2293a806100b6e34c9f4de19d6d2346adb06e0981bb5fe50da3d3a0f0c ded372a3164a232d1509252ed4e1236608980529286e159fabdcdc5b28f0451d 6c6829cb8e8e8aef7da10be454b7e299465682d41d9949a65d3c0524447b9a6e f53b4e93545101c067ad404f2137e138c5ef68b3fe44d181a574bfd25c58c264 1882b403c4ec7c9bdbf0f7958d5dd41fa3c5cdc51432e7c2df5592f7afee7eff 5784235087d3f4a25ea2a13f968f6e7212d24926a20edab822be5753fe459447 70125c272507383f127cd35689e4142a1dfc0c735f433be3a5346abe41537217 aa047be2b0244d5c729c090db1f0a77df47c5d4c6e2ed7718eba3fdbf867485f af0a24d3a935f5d7aaf9e138e1db96e1e86dceea61fc36ccfa0c6e2f71ded80c 6ab2085994d9865a7372363c7c77ee737d386b2ea0e7d9ec5eafdc3cd3ff8aaf 279abc30e52560040257f43f993a4d0b122f4255cbac5554c92f2662f58f768a 3858a35b05cde69818bd671da15c4e417f9c6b2b234a248268bfbdf0d0e35693 3edb2773000eda195d84db462b3cd9d518331d27e9c6e6b1b66d41178edee99d a3e1056862e34eb6d4fd068adcc6e7f71f5771e8e8aad7f6ead1981946bbcb32 6c1959256f8b56e2dc8dffff461cc6c8e96f3754ad289939ba94045db1832779 c05e8e24c6b6b8820b58e959f4a041573dea025823105a33e50519f9e6574175 6a6bd30c6bd76325eadb776daa8036bf1e56c777ca1f290c45c8e18cb8ba9578 e6a3b25003bcc84b3846c0d4cbad407b77d8d43fdd46cedddab05f605374a404 cb404a1bfad15945462cc839c4fcd40b7ec8006fd2a91ed5842a63a5f0cebba0 1ca2d5aab6fcba3713c4836efe7347d749fd3ad414f608c398b127340f2c49e9 f8edb7c361155eec87341ea1bcf0b329af0d2ea618549906a963aa3f69209bce 22d7c785878bc71f9cd706fdf9b892fce645c88cab4432cb760e2c40a87ad3cb 737645d1cb47a9996362095251b8da9e05ca786bad735b6127bc44f25886ca87 3634d004893181720cd7ed37e52ca6b362e484deb44df124115c411b52ab465b 12072175c95ef3773535c16a17c3a190904701388a3e0303d11534502a87c524 2a306e05ff290f73b1e993f86237261017f77f74f2aa58114d986843f2dc5206 dfc9cff11a13510270cf1cbe2599456116a14ded7078e29a8ba3af9f4c8a45b8 5c8bb36a6ca17d6d81574b8d44c86111800033974f117cfbe3b37d59bcdd3184 96ea595700c18777ca32cbabf43e34280ba193547aa20dd72066004493977930 2550940e22b64d96c2e6fedf22e9a022da1cf23b9619da752777cad62dcc44f5 17e5f605c12b5040b7e41ea9f1279ba4989e029d697653138fa67170d200b38b 6d1f926306d22e10ccd58b9d55ddf912fc85c5109eb4743137f33c1882c46d82 4a524fd27a55197fdf1a64f0c8dd4ae3665c86611977f7ffedd527240c2158ed 8fb541e01c7402737a2b6c1a036dcc71fe789f324759e461bef0278c098f4538 d42c6c0174b9248f68fe106e5dd68f04c8ed379b75151458bab28c54419d85d9 4b55c1436e81d6b2b71687dbc2bc5a3aaa4e463bb001be8462006d3a2e3c40dd e3b037c43e24b1bba8ad64dfb6f132780195416a7865ee48078301429da44b1f 07628c6e37694c2964d2cb59c9742f56d22d4e98ef440c5842e844667e26e3f4 a2071dd3740a132c2095344cee8b972d7ad24d7f1289d0281d046285b8a0bb4b fdf01639e3c3781aea49ed8c74e7bf4bda8c303e5cc2cca5a59060afdc8aae2a b2f715a8908273cb08b59c873ed39a4e1431b8f4896e40d70510a1d433b73622 6299ca390640465fd3f6cd030657f3c6a53bb90019d45fbfc2c9dc7c68a7bf78 52e0246fddbdedca2dc04d0019038f8637610415f966b490029d5c9b7971bce7 346da8d2325afa0922e1bf8a1b296ad83b2d007c2d8df2fd7c0e55259ff1b608 fe17411c5877a217537811c421d0ddcd3593b210c5299fcabcc8be7768a62c03 44cebd130c11d4123c85c2d43bca69bc9e4ab3bb622f1405d99176f9a4543926 85b7c48977b0112bf2b5b80037bb47605596ccd4c570d356eacadfb8f6573f2f 9c3627cc176b1b3623ceb3d76b0d4bea47e60db563b4afeaaa022ac156aa2af5 6cac647c79c469785669815f7281a08a54ae38d4cb1f27a0a0f8a23a07bd31d9 7dc66393f7a683c93118cbac286150669c90a66f17551ef7dabae0d676857e7b 4e8d652b12a76423f41bcf7cb756503e3550d2c039c38376f27f79ca47be9799 46b152c333b6ad5c2e61193340ed8dc08308db63b37dd622130f4e5a33ab6d76 b29a7af62ffb071abfa8af61e45a35ddd78f51fa6aa6affb25622c7fe6ce9080 40bce790fdf61bc6e500a4455bbc87788609d96b471d8bdb1c80494702708e65 8341733aaf38dbb336d462cbe478aaf7bb968a9feb2f9be848655f004692fe47 0a20d7df975f05a702f369f422233f01cbac3e6adc8439a477b280444e8eec47 5b434777964a5084900e2eff629ab8aa7dade42d37203c225ccd138d10487f71 06a464a52202e5668951aa7a624f034c925e2400e2f585f1de03ca0ed025d7b9 3000e767671f15c36793543e6080b9a55f38e3604cac3742a55bb23ee5792c84 44aaed90e21b033a71139f5606298ace7605b355528d1eb95cd204e10556deee 72cf84f5c70fa73bee0385ec2065934e9991248e444071cadf40204daad55835 a63efec33c90410d47ddc540eb7028bb2d73dec776e5c3f15fe4ccb5a224e070 056ae42e07ee14c810a905c75844fbdba1bb013de018b0fd7bdfeaac30854d08 5a3389b99abb942ea16bf63b1ff257d06c01fbb564ccececb39e1d258d05c99d 8b79febc5a9eb3eec2e288bae8a0ad9cca5ac63d584df941ee5c8e0f0b2f250f 90ec99e002e0fd0f44b8ef7015e5790fabfe7f69bf479bd2bd71c538410ddf5b b3e347d1b02601f54429755bf08e38f3c5d37ed4881622c776c420dee3e861cf 3d649f6c6997f1059b747265672e927614bb9da1619be64b8aa64a77478d1a92 57f2802756fa9acdfb65dd1d5b8267e7585bfcfa3453f1a47f5bfefe40344b6e 071bfa5bf138af95c961989f0054007b0b95bd08e47dc3d883a1d60ad8437a7e d4f84c680401a3a63af8614caa1686e6f46213682c9fd75cdf2ac20e4c90ac77 83aded75b9259b9df01a3183829cf5f6eee5b55f8228dfbbc50b4e3a33910c27 16314395b013e7a310afd666e83bc06c0be1732bb7c43d3f44db2ba77d422bd8 4cf5b2fa58dc2842d492056faa9d87afc1c4aa95d7ab111f8d94cde44213837a ed7a6468b881c68820cdd6dd78a86d2a035593c71d651926855d70c8592e5ba6 11161763a337afe49d28bbefdf15fa11161bb048fa85c4482c80624a7c64686d 87ff8f524f6b846688fcdeba8ca6cd95189cca1cb4f009a81932e92b439a75dc 274f5ccc817df9ad606c3ae4058723c7e31c8da10d95cd5b6b1f1ceaf168f60b da1fd59fb499662535a6163b561de4075c3c924e257751a2ecb04987d41169d8 a08b5b569af9d70003655d0954ec5bc8150fe31e223c57fb670af1fa6c7ab704 40318267ad5a4228c6a0493150e0d39ae1f1721f4998480ce3d0d0c636f0d0c2 684fcad029ade48ef92be05fc9ad3f6cf37c95ac7ed351c4ed6cc2d7be6fd391 df486495d5663bf502d97bd933b05f62ddb6111049717d70ce50efb8cfcf11b3 8c61ad6f3a41e66fef2fdfd37ab929e094c8836f92b44a83d12590ea451b37d0 167c89c38198ca427471cdfd1921aa6d33fee7c7b8150e1a05c8679d4500e4d4 09af1c7743c264996e5aec9d7c89e7de0ec75eadcb5d5fa5f2139a7340d1e9f8 a7952149344a15ce7ce7230c57ad799b72f764e488951b2cf04d3b08e7c1a994 39f52b8dd70b2f78a554488b9d38845d6c5f567602681c6ef29d2055d605faee 26c9285904e2b40b524ed65960ba65f0cf87066139be4010ec4a0872ed1612cf cc1fe621049937ebb37dafc7b86e62792faa5bcf15108032e3c62d22bd38dd3d d4b023ad37c6b40839063363296059c0954279166b753ddc2d04d02d1c3fb8ca 7b59b2f12125b5012ad44e2ae8fd925730934d4167ba2202ad88cf9660135cc5 67a6f91bc66b68311dd15b9cbf5c224b80ba40c3f1d965403be6a22f2ffbb765 3634e9e0c1ea06bcfbfd04307ab694696929c379fe175d2e5ab582eb815b808d 59b5779590ab5ffce7545c056aece949e18697c7143f1e8bc857d00638db0e33 2ce1f30759c7b8043dccf6a82eb6a924835a406c6f9939d15ecc3d148cef8328 07838bbfb84ef0165899f9fd0d82d4fbd24639b40963227b6666a8fe1bce9277 b99c35d9dd7652ae9960b7b675e2c82d2dcd7b2b207fe54d31c6daaf9083b077 e2326bf991f8e390b8d59576bdf7ecabd91c5c219977b7660733affd6157d594 52d2503ea1a62804ebaa9683fa5dd278d1ccac455e3744b893575727cd1b4f52 2d7e70818496d0dc540ca42ba4a756b542719ed88486eed3c657a77c42af6dc0 5123e031643a7ba28e02a8a298fdc8dfc4d62dc95baaeb0c333a6cb706eaeb5e ebe7f0dde7140102a2954cdde2d8af1ba4b24035e47b21843db454c26492c44b a873bb12eda015feab38a9da64f3c22f595fe3df6fc91ceafc5cd28a805b3802 940e5bfb1a828c3c2466c783e2e1805c25aa1561c55544b89942f5f53dc37969 3f0f9ae294f3c64597774b113bc3e451a71092a749f8bf1e31e44838c8cbb16e 34b2c229c360658fa49b06ca0aa716a3bb4a4b551f2b087c5225be78d877b547 29cc3649e9ae00233cb645286a4918a16421204258939275888a2f875abd7834 29c34775fe36531784bb20ab10926a8a4ec7fed36271bf5a9856e54a62e74030 977b5a57f61875c61b18696bf876242338e95d0bcffbaf5a8f641a92e327c6e0 3b2a7036477c516dfe15bf19840acde75d3b7809db33dfaf9189e9b7424cf0a6 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 false +check_ring_signature dfef6e070fdf7c59eb55b33a1018ed9d2c2b89cf847314ce5cecfdb546a02a86 ae9edcc89f462aa2e48cba8883962f20efce779acdeeb8cbdc961a73519a3856 14 a66b01c9162a2513427d1fa617b3f57d21ff67d6c55620fa06f0f62b3086ccdd 6bd16e81006c460eb0a465743116a285805e8ba195c2e0081582c063b8afa3d2 efa23112e3968bad38adf5c0533e4c7edef6b24b6f177b92b70e167ec4d76d50 08686f9aae7e81ebc98675fcbed68f256c756c9f9b499036b223e04e84540a4f 67dfb6ec3960f108ecd986502a64393612f1b7b5d765570bc721c43100d7e395 b89ed8c9e0e0dd7c7592d9fb15208d2c931f8298a5a4814397eb43ad8314c1b8 e19888916e12f0c7192f1811900fed48964284e2c54e92a70d4b609a8ed34814 c3242bb3b62b99f74bcb5b8441c340b8f8856613ed67e6a214c3bbd596cf0350 de332467c71f6a69a631a0dfe4e8df859bec53c4cb74cceaa33d8626d08afd20 db5b8c9353d45cadb8b13f6a82773808534b210927d0592de88afaa2fbfa133e 1f5974127e9cbe1b4dcaec8a2f8186ff5f92ec3db036bc3f7f22ecc9b2121a6b 7dbec4784bc2a6a82ae7ca805a114508e9e1eba6ea71e7171764ce650ff3619c beb69abab304a89ab14045088b1e990784aec640e3de396f4848665c29522ae5 cea6725269bb0017440bd00d76782fa428fb417012a14324b3f78121399cdd9f 5bf3622c8257cbdbf2a54191bb557b5114ca1820aa0739c6fd17f2c971a32003fcb1096af423214032cd555950e3fd964293ae4260fadcfad93eb7ac24cd87009818b775642084e2ff449842135028a6a23ab59f555c02aeceb978750e7aeb06cd7000255fc4ef58df86ee5bdcacfb58b1e63cfdc27bb7faffff9770ea943809543711f5abe846869703999232de4c4f7e259aab668148d33cb31418e3a6060baa742afe08ffc49fae1b30d5bc6ad0cac316905c11860f0113b29e1431637103a512be722ff6276cbeacad0568cc3f502b9a3734a27b88ecafd308ec3f9e3606f10bf8a730ebf101309c28131462f207547eeb323abee8771ea79865126b3b0ea6163053f718e8bbd1b09ac5ff5cbd6743f81b6b51e83aafa7bdc9015ffb980ea52581c7aa40a7cc32f684d8356615d3f5ac84c246f5c63704121b76118c820ddb560cca23293aaa20a0abc5612c9cbdbd470344cc4359ca7a91650f032ab80607cf7e4d0a98250e0d1ea89506940805d0c8e04a357003bfbba375b8ec607d08b250ab42662b547b65b6058b8a103b1df51eabe3b093e68ab060eaf7fb580402d08d43c6b72896d7809a3f30ffd9f01e7b075fabf1f449c3f4be8bdbe5dc2709ea3aa8c1f40db0911e75c9cb7b1e9ad94bfbf233c0a3df11172c586f5627520f13692f79b120c9fc2656adab3aaae3491b82720f4b714b6260208b53edb7220236de430b083c4f9827339c591e336b2d17aaf97a8308d7f36740768a2bc294022af99087cbc68818aa29f6a092c573cbf8c00fdd7a5085f4d33f3050f49b4b0af607af5514cdeb3496ac180063a71d60cbbdbaff38fafa10f75d3aedee0dd50f24115616433cdecf9985ba6c147e7b05fbf5e197dd47dedc61abe47a43328b065bf30d5654eab6993689b8e86aa327f78b4925197356f8273fa7b312dca21206f31ec9128e2d7c559e57338dbb21aafa2f7a737b5c3905ff843cc54042f8c8019eebe5a7122af722943dacd8e98d190a69be520aa4c9ddfd3715846f5002910020a16c27fe99549c75e2e6fae1eaebc340f28ce2d12861d5ada8f839a31dbe064c2fdce6a620e0db0ad280b955ab9b17d3c289c121211a8155de526d5badf5057afd52499e90c750ef30bafbdd0d72cd1287e8383d9fdc654bef69fd50e7b10c26dbca946132499a61398bddc81b8727dda7505793d14f3e4fddec8dfeca540eb23380b3b3ebc3efa0ae37fddaedb4bf7213a7bc8b877056b286e0f830c27001 true +check_ring_signature 1070f4e3fa0df30bcee28e33a335b121e8b90d1686b7f2ce49374e6f2bc3c2c9 a59e8663fb9cb89a9caf108f8477109c844c5dea7c22dbe69f88342bfc328a4b 61 f464e96ee08be804e7f29764cf51b5a7962d851b46c196878c0b12730b4d1cb0 40f500a9bad2caa6a6c95d52f5059f56d2d58fe63f3936c505fb78abc94b78a5 441dd3e817fab7b0b1f667e1f6d9d85f0a211f23dff4bd19df19976ffad4ab9e 1c7ecff02c74f5467ce13a2788524c5bf8027a0884fa3e88097c14f47a6a439e e0ca8116cf604c93a7191f85f0546a2f4c1fd71349963630a569a8f4ddb67845 c5f0c959e05ac670247b9284a6401cbb51c5c09581575225f2bd6ee37783daf2 aa1abd2fddb8f3179101e53262fc8f7627bd1027e946e34af060e1fa7e9caafa e0e97a173690a10ba8df5b550856198755ac966fae96ef5397adcdfbbb1e4cef f16888f3800f0541ff2fb46be4738739c1c77c9b3ee9ce9efd1bdff753cf7f8a 4001e2a9856998f2e820686a9f6b3cb6e8c5964302d832189c014b55a56e5ef7 30a8bfecf36d1783793919c84b22cb884e8ce37f40d90068a732d49aaa1df010 931f1eaa55d904daa79dce95e2c54d66a279b700836b5c88bae78d382f36d91f b2aa64ba030353de9bb76012d1d41603550ac594da611f42053138d22241c62a c3e63c163b4fd570df2fbef8e25a5cd26cc831c3482ae50f2484d04d663c3b2c d8d29b15c0fba6a4731fd3bfe3fa6045699d38667633219b8950349f24aaf340 313f5627e27ef7304a9edb78f79201533c10de7138bdb1e5c2144dad7d5fab3b ad88d678b7eeaca413774db2a895b12bfe860c14d34e5d636a5346dd28a93efe d63045e729810e6900d9221718fc8d40e83e0e897810044e0769dcfa9a9bb4d7 42629688e7756d3788f78216fe35bf16d85482acb81ac8fb229c1b52424d2f27 407e97e45d5c2a98cc4200f6a343625b7e125ecb43fd9ce9e1b13a5830642b9b a1fdea10376ce0beb1192f800d136bd2f00044fcc89d772cf2caf40d0825936a 05351d021e8547fa2a2b92a5022a6d2106d8368adf53972bd2357ef725415d58 75080cebe0e00331b3864800a543d45bbddff70985543d76f36dea85d1c6d46e b808d35529d72c461180ca3c1f8e60d01de111212c67dd81c373271a81ef3348 1f9bcc3988a200000348ea84fae8c8ca0b35faf0ddcaa2dcb13464b83c263fbd 2d0c365bed0422ea3db9e6cb1a8000cea0ba1e89797f8c7142f062d29ab22ae5 5e8654b7053c11425e6a5017f71a228b70a0b73438a56dc0a5d55b8221fe11c5 f5ebda6bf1f9b03e92a2d03c2496dac2de9475c4611ca2cdef43d6a19292bd8a d5e4beea7ce2ebe8ea55bbf209ade16c1427de8c2ed5269d5f0c64d95285cbdd 1a3eb814d05e447eab2c076590e976491bd1aab22e44c9e6074c9b5ca1f257c2 92c0efd54c7f0af52eb2528ff10e70453e54b171d80630d3f8fe1d08eb418e1b f11e2411cd41d4ec19fbc6bad886a7ce3260d85d658569856ad7c6c5c53a42d3 e1ee1a500ffce398a1a46059e68fcb58e94974b20783dfc4c374c7285bcfa27d b996e2d21833ab55f0dd32652f38f2b974798ad1ebe639b5295af13141a13ab7 25384314a43cad06184669a071dfac1a4104ff1d3a25c2a23d1477da49872750 0edc6b97b6495f94de58b4dde4ca69c01071e480ebbaadf986aaf950449a34f8 23a5850aa86f7664779bc782527c0c471590afa20230c00a439c843d24eeb3b5 5d82109646dfbc20d98d45aad80234018c2bd10d4078aa95b1fde8c65bb74a08 670f583c03248b262f16aff32c11ec3d4cfd1f77b8dcf0f4d3d20c4e681f5543 e3e17cd0d589197f5441860fb646636dce53e88a57a28060837f9ac420b89b5e f90edfbc8ae35bafb8610668a0e5c46deb4ecd092713c644cae461e5aafe1254 56edce6d6d59a1683aa564088279ea7dc1721b7e71477c5d32af8430e64615b9 20afcfd2ab47c766ca06ee6fb27938be34c8280d6af6668d05bcc1c80a020d4d c7a216d414fc2e6a00cc63736eaf63c7bef2d24e2f8c4dd3bc268cf57f6d6571 737ac89de3d6037288c9d5c7d489ea6a8605dffde648ca95355635f8e58f64af 3db513350213a93f28453b789802c56ee6c1cd97a40e989547d439cf1e32b4bc fa877b5a803a79651230ea30087a263e2bc5f76d62ed78ab69ea13dcc622e9c6 e8c7b3279dd7f01e94eb25ea64e7426c42e4d1e33bee6f3d9148775ee5754eee afc30aad9e2edbab26b54505bdef24e81152d90982761134bff3edfaa76ed19d d92bc3299925ff48f688c6de8015f0d9883cabbd737cde5680fe1e1d204e6dab 48d0c7265269325c51e056df53dea11f85993c1c41ab58ced320edb4b93151af 86f179aec7f286a03b9d75fa7ae5dda5f386118928b8749e1c5e01323a025a90 076fbd42f4c93f6ad8a441626089ad896bbcd353e303e11e4b223f8b2c547dd8 4617ca54e5f80e5a7649683d73cd1795ac58a38336f3f6bc451b252bd3aff42c 2f98550965b07bfb1878d503e3bf25d70ab4afb54812a2a8bec5fe2320dde02c b1f378b88d1be4f962888e21f7471714d70eac205d759b8ad8e219985195935e be1ace658ca6b128f68ca2f4353da70564f4daf1e9ee835db8f6a57ce63ad9c2 cf15430c300aaf391c9b325cb179255d2f16ef38f39e5c9e6b302101117baed5 2574b913d15a6987f66e817537aa8aa394480dee3739a2a5bfee02fb2b7d3047 374d3ffd96356a0a153b3295a5b27da5e1a42e56cd9e5e60afe505e78a242127 01c3f6388b7cc47129ade2eec2cc6fba05e0b0ee2824d0d7d12b0daa2ff68615 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 true +check_ring_signature d26f225fcb6ca8e13089a96e17d1844cc0264af9f7149048b96ad0de6f16567c e3eff7c3e814a43140a264bd49704171f93baa8806c561b7448a0441ad1a32cf 1 9e5ba7c35a5a809999bc39e543adf5a1bf007c7236498c3a772f4daeeeea30e0 cf80ccacc126c14015e06d5c631484d659f75bb87a596e9e4a988957533e5307f8cd8bae2044231358b1d495814fab2710fd47e7529625a1f0fa2f2093e8a40e false +check_ring_signature 60c40bbbc0c6f7c88760327824f34c37f93d86a1fdd470b57fe8331f96f493fb 4e1e0e2a8ad9cd1ba1cb8c1e57ffb7344217c1ff2adce7625d7b930feb5cbb54 2 d47adfdb4f7e29ea75f6862e76dba8f8ec3448d3d63d8af1486fd120851eac3b ca07d1f4df4af7b418b3a97ea87ce14a11f5f0817d7e5dd10a1917215a5aa365 f47f9a70e41946a3954de02a30a9bca17de337b4a61bbd09ad95bdca1d5b1c07656f2ba6eaf95e4c3bbbd5b3d84d45972e6ac4983aa683a2ddb3761530513b05da16d1dc034cf3efca7b2f965754651c203f4fc6fc84173c7164e0deb3a8df5083a9bd7bc6fb6f4f8ba99340a302e72da2c2ffc2eea0b2b14cd5024215049207 false +check_ring_signature be854a650c705b8fe2cd63a59e364290bdbec324107cf340391df133a0cab5be ae4aaff151154dd3c53002e56845294de6f3769affff0321d7c65b149d7333b3 38 82abc93fa65513dbf0256f7219d67a9491fb3ad7841f058be31e48208d828574 bf6a8f0a172527eb456793b08768a9556f94903abf1de4318ed03d382c83747d c050c91a9412fd25d7840c52f5a10159b46a48cbd0832451e383bc5436c1785c a557190e9a97e8a7be7cffdc62cb80f8853283827effff7c92ca80fd1d069a73 219a429b0ac09dcdf5ea535f43aca5595b15700f47c875252653516ae2a6be3c 7e0f898350af57d48693b3277b443ffe79f3360487615d2695f05224571e69f9 d09905c6c0bd99ff90e5fda34b2424642be8cc0c6f49f7eed93276c98f85b22e bd936cfbdb331b80396b983442ceb3be2053089da042f338a16ab46642dbedf4 e2a111fc7ab82f95ba4f9ccd50e340212cdd50d1edf6ecdafe1607ff013dffad 0ee8f00209841acd2ab707c013e6d3eb94fcec44c22e9120bba0c3ffe27f9d1a 7a49e272e511b5f2eaa8a91ca1ffd40e84f1ba53b61954ac633d9efd9f989905 2ac041dbda72af6d40699c9d9a4dd94f3287c1c45225db7f204e2c9e5fceb5de 4cc8b884b24f1ce2e888ab20f69e5a9ad14b2e9541763f0d3c28032ea94a8355 fbb48309868c87fcb44cd5671c0f727037968eeae2943245e066f92562d45531 8d02e9d00ed1ee613c6d7021c61a6e7ed4707c91071e6f3011d7938417ee6953 9da510d9caefa32180ca25867103237871ae556f30f2e7333c2027f998395a9e 7b90d5da78594ebc3aebcc8eb357b8cf2acde0a21e0ec7659b383ee892eef9ed 87975ee2bc29f134228662a7ce85fa260c26dd700ae4751ca60be60494de8d38 cc1a8803ed859ad92f08eb2ea6da51c6c076df872ca17f7a9d4744b8abe15288 29e403ba9af50705079cea5986097280775d19105b92682d5b691d7969a7fb42 dba1608834ead3f2b894f9d5329dd3040c12b65cc3f842fb01135fc3e4ab9d52 138720ed69961adbb151978559894f866ef245c07d01b7e6d647c7926069d7dc bb78bd42a34d27fef0c8efd8bd07ac5ab822eaa09c06db30d4f6db7748915d8f 1abadf62eaadee2f77d0f61242b1e8c09ddc1a92c09eb7310c56848743f405af cf336a8736fe1ffe69f021f69b9bc92fa64535a368efbd59af44cce8f7bee0ad bfa3b72a50b7e28f041e841a082db218ba8535e1b11629688bfa95e8344fae40 6d7b2b8b98559d7222ac29100eeeff95649361336ab1b4433455297335503f73 e0ba590a40e3bc0528ab02ab724879663b51d1c8199ce470359cdf39da34eccd 9a7855efcac305662b0b7b429d6cd32a4cb84dd969258b44830e18ad39277be2 2fb86502a0cd14cba12ad04f3031a4af4809ac349d5ee10f5dae3706ae91b084 67f6c7f8d7575589ebf4025ed2c25e70f296568207db0a2b03052f24fabc9129 4a9a1ae9ef5904f32551cd80a1e7a9be2e80ad90a06a74f6f227964ec5689b7a 07b82291d52b9b6133b9e97273910f16f7586c691e95722205e7c2b618ecf05d e6fc0c3c677ed340abf3c5d85ef84c78bc46a62de03cd9711f91af68c811f79a 0193edf9b1eab1ce89b2e1e2db011c105868c8ba10ae205b5adc127fe0be514b abf305f714d393fab65b6e2e8edc1a42f90999bf8c8cb410f4f3f7523fcadb41 5091bd284b5377e736c9fdf5b4b0c2527d780dc4650605088e686b8616baba3c 3ec4556e8276f665f4a11efd7cc4721e142eb2cd77fbf6c0fad37abdf8d3184d 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 false +check_ring_signature 7910654af7ede95bfc9cd5141ae560dc92e65a931fcaf4439884a0784620135a 61121e5e2fe3ff5ba5208a3f1f2bf187c7fb90026f5f6b705815a03a3928b0f2 126 9a544bb621392d7b69055aed9036feb160c4ef704edafd83bc63d45185d4ce7e 49cc88487f385d1e20b36393df0805681604ea5f54a773f0cb474d8840d12446 dcbedb1dc43cbe64f08ce6951bc7d010b3ce32bcc7a4cf8ce1e03a12b9693f8c 1efae200170d2c9ec89b0309bffa36787ca340963c41986296c7f91213117874 ac602fea0e677c2f9418695b29b1e6a45012b6227c3baf1b4025152cd74c9248 2e74bced178dc71904613b0d13c7a9e58a8b757f947af6fb0e765ef171bb6648 df17581758c97ea5d166e18340030e09c986af57d1aeaa08bddea8e12f282c54 d09e05ca3b2043a887150beded3c7eaf6ec8f7b58c1423c3c36058be092f763e 74d4bc0b806c9a39c158af01099ae29d78e97a47e4f08a2832c5018dee6e6a8e 5a59774ae94ed10df92c7884663b3138b3078cada62fdc165a57d4b9feec8ac9 336a7f5dbbe8d26cc20bab073f9eb07c0241ef2f3b46c10be44758964d013107 7db3b997d7623abeba4ea0cb28fc281401be469c54693d28038b54aa9f532136 dab4ceef490281cdd20605afada06dee473671a30628810f8af9af8ab6cc6f16 f7a56f34ade6fa2b7bfd964cb475cfedf94da86cba5c2bdae3ecc1e04b332852 536c90942b71a06264043bb59b1f035020298d3cba86d586b945f78ecab90c3e 5c532dab5114bc73cf006f7aac2844d8e116490e21032729e1f49c9b74222ac4 8f1ec3a92532eb59dcfc6aa30005482915ba1bba42800ba74ef73e1e8f49b31a 94c929f4d1ac625134ee206ea2b9ccb51b6805b6800f71571a9d41419e69bc66 1c31558b0791ef3b34993b666c5537f118f28c8d5f33f4239e4ad849b64ec4a8 0d92fe2e99309c3b31201bc7adcfbd8926512ecb7d7d5592007c5c17abf0868d 1c94a93100ec03dd2eed3c161f9370c1d4b1cef1a9ab384efc6c87a72c1681ff e68f903d63f712b3537c2a75dd6752f9bed725e9ebb6137bc08463f5cce05f1d d53f41a9cf754a041decba1a459810d8f5a1811f37c3c795b1480b6afa748b2f 984a3fa3b92d387ddf013f285bb6ef75d7762d387ca320213eb8ac3c53d39859 6f44c5a3c8f2022f1701d7fca3e44bc096ffd1ff6847d6208595685bf629d200 f0ce952fe40e25d63bb8b4ba838869d39f0488353b17b3b3d4e119384263e8cb b7dfbdcfe47eec27c7ad51791bf410d5712d18d4661acd1dc966ed830ff71244 5c3af978ba28e055690fb897f86d8ceac8ee70ec4cd986daf20f0e19989f9029 898daab6b67954317895003328abaa1202916a7403b6bec037d0716a606e64f7 dd049fda3ba0d4f65156dee6f4001bffe387ce2b37daa4734204a7bf821726ec ad63c4eae01740b6a24161c162788a3fc94a4699d9ef13882d66a3f88e411d0c 8cec5fd1ec1a75c829f8c5ec29c13a19be60d82c873f07cd3dcb372f39e6005a d20d6a6c01414d51470aae7b30cae1f330a853103f3ee12b51767cc6598668a7 8301ab8e745a8ef1dcf85f7c108f063b5cb3c4b2ed944e3eace1e04a47d293b4 e0938c217a22fb6133f2d3e383989d8ce8e35e64c046a5ddb13d1688071c33e4 9af12c4f327a81d6aa2d5889212196adb4df3e9b50cdda4c96b6adc634feec9f 86a7a023ff33e3c6ffe8247b3872736bccf0cafb7cca44795bb8dbdb4e61c9a5 4fdd024184ad5c2bb665a9443861dbd9dca7c5140bb0397775cb49d5177c34b8 bd7a187c49ce4e74b6d98a55378e1841c2310c1d81c3124b2e2f1a730b56a516 d9ebcb2daa010a2d6deeb3b91a12f3ece1481d5407dd0bfb13d7e0897e8c0b08 cad14427ad6ff829e37ccfa6a6231267f44593418e6fcb4174c03c3d7d100331 8443ef5b52996a0d614bc3d130024f4e04b5791fb7fd15afb3177a2698d93737 c66f291f9e5eac69798173c950ebd512e63324e7f9b8ddf1c5f46ede3ca36dfc 381939bf0dded42a36a5c63c99209b0f2b738704abca1df66f435e18af1c8165 131b67a834ed1feb2171ae222fce82cc6752fd50a73915704f4109c3569ab4b8 cc7bfc7cb65d10488933fd2f095ad2597f2367851673bbb9187c0733eb2a61da 63e7159154b29d95e956e150133f120fcbc3e48edf607ac6cd1e68eb4d7e25bc a81bcca2c340f14751badd5f64b1ad2ac0b9f45c2a146ddff7f5611ae61e22aa c38422b90a95117c112c43017b6f5942880d26bf46895608e2a7d34d3d207b27 87de3a23b36fbba4dfaf00363ceeba9c4f9a22ec33d6fbb58aa5f4c95d235de7 d19f2c67df9ee61b85aa7085500310deef0d364e334688dc6359d67ce347492d 64cacf1d7824788e27194e776a5604352ccf6b8b3dc1481d14eea3d36f6360e0 81674b59f529db915c5740437da3820bfcf9a99ff41f7f90f5fcfb5551fbfe68 fe9006e3e1fde2ff1abd6976fbc541bf408801742dc3f4b673e0a4dea9ebcc98 1510263a65b22d2cc9eac5a794152658bd99de6f36162403adc7ab7855f14bf1 0a434ce0b95ba212e6ce96371dc29dad62fd81d150d74b87500c0f7e2c19a014 2498caa5b9d238c0fade1df7dac0259690455c22432cbc88ae74622b6c9db4e3 bcc2d6f11b2fde0103eb0c8f209a43010cdc0e33604e8131c7258e936ea89ea6 45e0657c1fa5c94e750bb27d657a97b2610fc7995eb79a5cd089f8c949b5ce2d f30bf7177230ade8b6309fc6c84270d11cc92eb67740174e56166439c34e5f31 a6565a77f5ef0aac87df82ce6e891c6cf7d953bb5ddbfe31edf45b5a1691b809 381d66c6679bcaab8e5094e754d2aecb97012d839bff19a589257c90cb4741e0 03569079baab5afcf7c4a37cf5ae217ff3bff7071cdfbaf95f3fc880e399e690 72c977844674de1b64f974765c2fdccc29cfd1c156eec6624ed798a2d314ebf0 9a9532b183dc4f891a84bb5e56034afebb894bbf072c9b849f92dcbb0bba3a82 03c23571b1c1763e6dbb91cd440d88fb69e8b9311e5817a62ce0f1404dc767af 427ab3432f1c168c018e3bdc5dad52afb4e734e30e57683c700d095834547212 b7badb9a822cf4bb0b1a67169956f4cd09c5465ae69af88a3d349eb73d98a74a 6053f833915c62a4370dfdb71f7c0421ca46a60b2838f6945d5005af7b9d4ac4 c113364c96187f3b11bef9c6fa0a0cf353f78b701adcc79ed56cfa0a408be514 deee3e7cbd4810b3362f10102b275bc56092424bfb5d150e61536f62426ca083 72b38101b8a1e5a8163e2acdc08521006b8aca702aad6cd06e4b9dc6b8d58a0d ba505f4925d4902ceba21351361a1e3d81277e6b3681511609f49f98ef49d831 0cc0e11fdac66f6592b1a46a2f9390dc3f56eeec9dcc47b44ae19a0655704db9 6f33894e9496a23cb577391f4be82977aa445050f0b2240aaa6a13d0e817a039 7f809490893668af9a52d1be6fe9075111e23e5264c89c9e5634b9d24c33fd62 06af02e971e52215532724e0746e2d90f3ec8b28bef9e51fa1233af957bd89ff 5d8c9e316f02a1b3a0e124b4ace1f0dc28eb8b457dcbac2049db979e5d5a498b 435256fc28ce12b6e97973c4e3eb8dd6265b7a40345b0a1bb867320c70527363 01e4d35f2482aacf54449d8356d7bc868fc47437c617254bb38a980d941906a9 6c97b2e111867de3c41f783c3d50f4168f8341a5b688e13bec828be7e57ca098 702e0ea1dc04fcde15c17263ef0404d37855232413c57c58d9160e408bc95192 9ef34d139fcfae9835c62a1bced2fee52821bc9bd7a6248915968973e5022d6d c4766ceb35e3d70663c5b582f616446e39e4968dc8efa579c33e558be60e3cc8 d6b620be9bb1009701009a74c652be58b28fa6c052b0b8f3b8a68f613a01b9af 09747454f63f968423153be318ca453bf7b7bdd954f2bbf43a40f2190a3c8d2e c017b71d535d9640de4abd3750f8a3c19342e15a9636d7b6cca1575176af30c0 b1cc18b8b7b8202abfdc54b87f4668f573b8600a7093a1f1d03ac4af48437c58 90c7cd1e222a8f1349ea819b56141908f716459bd4646c4abb3aff2f9fc9136d 61b2cf0d73d9fe74f19477e268022b1eebf829ad39ad61c9e4fc171ed5a3d362 2d9886e62d8e64811ae52bcc81dbbc9b17ab97c137c04708eff437b3decac131 a4e3dda637c3652af5ca68d81d4b98eb53ce242aac427ab11ed4d0c86900e5dd 178fb949cb6e0ff46750b9c589e4f5267fca0e40b23821fb111017b6eaa61f3e 9443baf841e1912af153e4e8afe414dbd7cec401f71136c33721658f2171e1b7 8caf966edbdb53078908f4b82840d994cedbafbcb2a54cb49516b7766a1d13ad 7982f4a59a130440995758147f49b5509cb35319d6fec7b06b2601a6439c812d ef24f11a7e4bb6314c18a69cc987cd308e4bd084a01784e9cdaae5524aba5e8c 52c72d407a16172138d90bab5c2cf9dd009dc60b8d17ad18758e4547b5e02193 389b818187d645b2cbff1860456290476b84cd0ba7f969795e76d6c285a59f0e b57e3d77d85acd8e7564d26c02d409b1b2c9019fc8b9e4f3cfd4c4df6f27ad7a 237825a48ee5dd94916c57efb732a964fccb46a3bda93c8303588b04a3d12d79 7598a392b1218d499791df30c862af0b963b6a77c30e6b20cbf136efc92bfa33 f98a5cb4269ba7b81748f282f46d6a4e0aa86e3aab701b36ee9a5204de3368db ddcbc21640959f2091890813bd3058056e3df75034ec51a8948c4f6c9e79157f 2391864df935bc37ed90548dbd555bf57c9a9d47d3114a7dba08f6c9f83c388d 08a5a9c2e81984bdf0abafbdae8f685d6be3aebb817294c4a4cbd92c2a36055f 0dbbff1c9e927fa50a16605e14f67c4caf9a24880efd1eff338dc7773f6dff10 a4e560e69c8353cd00afef3c7fc1be98246572634437bebf6c35ea353829f067 dc1642f3cbf23a14b87b08fb9bbbe0d3e5a689bdab01e025ba3b41f3d19a1c44 09664d84a098ff7c5724070840c43089cb8d398a79d87c614cc3d3bd81c35b49 7ca564bf425d69ca7d13f417c76bc29c7a091141a3675ce874de588f77154b35 4b063559c2902d59da67b0525832af822e1a1887e3bcfc9177e310d79121e062 185a2cd1c9197f7557fa0f02c97b5b5440ad8067906becf86b8e5c19256d793b e8d844f4f3626985cb0467ba3585d4875d9f95051018aed5ea2caff7b9531aae 9a31abd129a19ec6560f5e2fb5b11500f1e6f672951a2f3f892863443715cb4d d0286d57fb16e9c84e0ebe9f97841f84c62f9fa866b22b90f564ac442fb15678 b6d0489c21a2d4578fbe78fbfd7790f5e53c194af0d15d181a5506f417329e4f 930b5236b91ffea56b5023b8051a3b802425c7a118b4c4e14cb0856f4f050e6d 77e3bc999eb13b320628e4e66116d14bfd03eda1f4069b08f59baf4a66ffb96e ecdf0bb46d787bd3bbb74a34a212a7bef948897be52c22abe298165cc9347559 77fb4a685a357b2aaff6f2d09b4dbafece8eaf0a90182d4ed0b8fb4562c5b6ea e0482ee2e1ebd89628809cd96c3a6d369bab86731a11fcea7ae00c0ad31f80c4 19dec8e94e8dae8526fc353e8231804d5e5dd385f238451c81b61e99eca68a6c d3bd6bfcf4e6ea7c04251ff3efcd08bfb23bc663eb25affe741b4a6e24974736 339392a4d2ec13252afc021b06b6a4713bda955a606d4630a1675b05d3a59e50 99a07dcdd4a7fb1c79320d0061f2d6d4ad84daee2f32fd0b7a4393ab219d487c 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 true +check_ring_signature 573af2b453c9af913387cd3de4a66e92b640e2fa1bf2299ab44d5e2d703661a2 6401a85119f5420c503db6495e6b06bbae2325dfbf3e24f5ea2e1895b62bb3c8 15 3a7fd35b8437499d6a143c43087d2f348d16bb08a614b433265ec54c406ef203 6defb910d7afea7ff2ca633ffeb18a0d182597e9db180cb0f7a241b2db704c63 e029dac4dacc564d69eff9080e504aa0e639bd098077b4789039955ba61dea20 225ad1b5829687721d277e24ffbeafc99c4234097e392292d2702f3695bea1fb e4b78323bcd8e8aacb0d66c57c1eb945ab9c413a1c3c7bf7564650366dcf08c8 762a63f8f0cff95b694e54bcd3f4fe2e93d711726779f2d206605c23d620233f e12e1668124ecf13e8a3768c63a91f187c7c2b03fe2677f07db793476156ef35 71cc3b80418fc74f75cbb7b12d72b53ff7461b151c827179684198d046efa0ce f44a753e64ed27f53aaa4eaf51d562b3e3dc6536dc9e20fa7480c208245fc7dc 4c0eefa52cbc2e1e7dcc7461f8f699aa114b8ae2f2422c2d438b5289136e0fa4 47d0caa1c2504d3ad4d3e2e80533d71ebb10846056f4e7e9191090e17660e6c5 4e7eb9ae71e47f16c27e2b7b02f7601fab659fd0f0961d27cd6f75ca8931422c 42c691f0b5b2d6a3cbebae1a87b4e8f005384d99995df10ccc507dc6341ebaa5 e320b54a0b1ead2d71986f6ab57c2a64d60790330ff00d236a339335a20cf3be c90700df4b881e4ecf06a39cdafc2779ac5d76d251f80cc3b3bc9093431d47df 42e43f7070d486ea68812104ac699a4299d4040bdde7ca42c4fdf0ab1f91b80d2c6234ec13595fe0a0ac76dd8279fc21beadd427a6972d3c525b6643785b070ef865960ada931baedfe702da97a43177d80aa14a15b8cb0c90d61ab0c923b50eecdce588d946f8280315a05209d07a7b4e63300cc9fb5ac7151aa4d0e5f7db059ba91fd0b2475be24c4848e0cda27ef03cc14808e832965a6136731acae4c20639f1df8e1e436ddf4e73e6663edb11ef1d70ab7bafcd7239dd125bd7a97c26088c109c33a603ffaaa6aa6eb16faa3b2a00b23e4ad59517801d4682d356228d0d1cb676a685c18c7054c8c140f75a2d4cc7c88bc8f5be3a03a8fcf0d5bf74ce0601ae9c7e3df70b1ca74a5d1e05c140a59d681369712618e785bf56cc68ccd20d3b1e4db2c99acfceac300755cd37701129becc8bc066298c3fbc6fecaf27920770dd130eacefa49c4e594376d929dcf87778893c2d26d4f0dfb4b5bc065d0888d231477c47e273f740c5dc44f90b01f165345263818f124876b8ad2c32b6970c1fb90f7bfbef6102fd313e0b6771c893042019905af88c5639531c75c10d0708b957f611a1467247b55dffe741b7cd241c58e7531feed9280af525b02d649901715743976d38cae5abfc1876a1b31535225bb4c7ef67a46b242edf05ea105c0cce3c50a1763b22747ac4a32b5b6fd3de6e30014fde5f136465814b56dd718e0adb73a99b1c4c6895c587dbd5fa0cffd13183b7384ad53b8e3775efb7a228f00315202f5d8ec37bde813318fb5e4486e2a1709419156430183c9a7f56df59fb03f4dedca0f4937e1c7a50d330ec13ffcdf9b580d69e0afa0e08f961ef77923e0a368ecf663b01552c71fa7171e671b4c6e8cb48435a9f87e4c5b4178009cf5a0714a0a9f54f2fde51d99ecb3e5ca6325aa437ce787488d78d811d41c00b2e3f0428957f4737e67c30a693529063653a45a4e307b87ee1b015b915ca6bd711a503f5ba45ea9996f40894a1458b32aa0fc1e32de2dca90f0a11e450d5ced6a7bf0d30fc6a3d7114915aff388032ed8fa32ab957d9c9ba711e1a82ff9a3ec7563d00bc531cf3a94903c4663c543a85eeb4a0d65e5d6610d5000d50f8109a039f18089d0d9c35f8f670bbbf140850e3ff7f6ebcedb81896830fa07bc6251384e9140d541c2727f4663442b31da6cc14390803a5f6e0aeca4a23bb0a0ff307bd35f202a6515f46d8d0645e48fee405f9e9ca6b84df663c5f72015ff7aa9bcc6d323a04bf3a8f498f4e5f650193a15ed84a37e20a6c5613ceed5871e3a1d97dcf064f076a3935b79cca7d22921bb5fdd2b6b2371fde7b2b39e501b6417ba50e02d1cbd7 false +check_ring_signature 8e3a03f1e02d31ec5221634578fe8e3c09f7f9956a4d51ba52d26462c685abdb d01e65aac9eeb8019c18cca456c8c247fd56cb5e94b23e95b462625ba1edda0d 14 7638f7902c57810a229750425be5a353aa2b1f739d19e09f6e5d3b93f0c24e87 d7e9a5a92502d00fd3a271e275b936496a537872db5d746556180bab6b1cca0a 097a04ad3c8d342b700f64fb159bc5009835c51c43fe20da119f5707a6fd9a6c 39bee7bf5d4146cbac2554074a1491decb22f2f4eabfa0264d852cc67ac2786f ed547494c54c393390b15ee37d7c9124021eb2aa8bb99e46a1768dd5398ab370 371d95e9df48c470f31732c5a6d3b592e65c63a3182eb1b0cb28d7a5872ea50c 1601c6c8b26e3fafc60ef397cec542a436ff4fabef2feb179bd4ded6d86e0f92 6adcc59d0919387d80cbce1b0b5ccf658930e8221c648413ddd8f4746aafe88b 20f784921e1f202c671087f53bf37499f6c49dfbc9a87b65803414523b9e0e72 506d0ed581d757726de1fb20388fea43c27115ea1868657cfe51f05c9d3ac333 23ce2e85dba374d1d990d40357f85119f90e7a18ab640d7173331d1786e531ec 68b4259e30865486dc5a363a956bce7aa6340e5489c82a7c2ad5ccf6318d6e6d e43da861b135e3e3feea1e145697b77754d0788dcc652c49b9c03b95ae15bb4d 1598eca4e7d2f817dcdb4bb2707d079db65eb407012371ee30c04dd253c0d225 33edc8bf4690a52e378368d4487352b7f17f569a96fdfb6415e056e318d9080b23a4aaf60830005826533c5d45b0b125b96f748305608144b7bcdc9a6e7fc807bc6521eb3ec67e23f616181f75d318c8f0858322b52e756ae32fb069a5a5830688edf6739ce7263e450cd17faebde2a58e7111ad50041b658891dcbb465ffa015c3dfa86f65bb6468095670bfea924dd10ea685bcdf30f4464a7876fa6be1406b9fd111bfa75be56f7641b2030af9028063c2724a511e7f4265c5791e720620e3aeb64b863ee9e9921a10e9ca5c173c3eff213376a3b54eee8d598a0ba9bf80571749aeec341e35c7fd1e8351dd1660b2c829375ed014bbf3d9ee8ecd417ba001aa3520e0f9d3b32e86dc8903fac81b7f74cf7d2f5434e13ed1b1ccac8814c0e6ad8256a80aa0134c4ba5b5294b06130902be2610feb4539961def9cc4893008ba0a3d9dc51e8a9bca43c9bb54f6a530e3c7624bf2a036c478f5e5db224d480dae63e289eedc7ed78150160f85c345582d92911bf1422b8f67b7305a67885a0515a9ca51faa744ad804f95aa2fa21684a8eaca4e516f5090d5687a55c7e1830ee75ed66f85f3340ad82a0736dfafeef06b15c636546bcd76ffda970dff13c00702788b60bb38fdb7b736293d89a15a685edf757b012cb0160f3744c65b880e006cc18dc41bbd6d7949815b48919c15f47e72d65550f52d67212c5ff36702a50ca5af1fec9600f198a657d3b5b49c156a9d7ed2dfe085e23975483e8b1698640e57d95a9a522e715cd19a12319bd5bb6d618f83bbf0bf5dd41b939ea50483460f6b764be9fe9ec65870a0046ab1359e3876d4e090ea152603f5ef968c230a5b0a9afeaffa74d85141654b5c9db1270d01a3cf5268057366b2122c42bb994d9d0a32f8b1569ee562730598669a2393dbcab9d70d8132ac1db65ccc71f07cab4c0720fd73c7603e139e5bbf05452f1141e0125ea290d4d7e06e5972cfd8b267f10c5e8ee4c4b7431460174d231a719f76447ce63150d80e5b827dd6137eeb0f6e069340ce97bf15293f63e53dbbb65d53ecba76573a33afbf31a099a5fd4cc6eb0ec1d7c69e4b7c766bc89ff555aae633c716d4f24415408d706c62d0ddb2606a0c8bddb2c33f759f3e4c33d345c054f2ccacafa6d596a69b298dc3008f914f080e909127de7e8c40730e30f2088088194d52764631a726fd48ae14206f289cc0082a8ce9462a63501c8c30109a705abb0c42031c2dc227c919fc29d740d1077300 true +check_ring_signature d3c41a4df82ded01c6f76099bc24f1c353c9381129d7f6c148688ee1491ead79 4a251904a72a0d9080a4bd6329968124bb0cdb5d04ec48f439e6892eafb42000 13 d7b0f6e24fe5503b1d0e0a91e88212e2f3bc73e159aaf58cb8150bd2e4314a0d 39bef5c890d5068b46ff1e2938f553655fafe73b1588f33faaaa6543d5781b9a 2e20e5f64314403c6a9cc03ef22d36daceba581b8830a594d253c3dd86962a7e f54e652a7305f6b98823172f5074bb88c128344139f3586eabcae08be6aacdae ccd142840f7582e7b3b44c05a2984bc175c3bde9aa683da744847eaff3e4f7a3 1a47b288bd44c5fa7038d545b9b94d1a4f6a7a23cd2243c85e454e1664586ea3 572aca36e06daf8c2682b03e60f696ff6afe00d0f6330e4d531a629e0c3d94d0 3a45fad69dc22fa89e4d831526d431dfe6ac351b54be87a40b6aea18c735de57 f7c1fb05c501b5dc0152cfe089d511af649eddf5a2374d705dfd89ac05a15296 d25a1acdcb325be6ed061a183d17ea77339e1b6cb7893d7d9d9870bcf7a2460d b61d961e87c6b6c51cb9ced65f677e5dc45dbc82f2612f1cf07101b55b6b8108 6b45a51c82a14ec3218c831948194af7118b949618bbf9db615f7c6d0e763d1b a9f1060d30ca8c96aa516d4d91d5c02307f332ca673bc5259ba71589437df826 197e4ff0adfdd0e725ba5b6028362e718f9cd3d30ae4f9024d954c4e07c41102928c749787d4987bc126af511d2a2363158a7dbbf9123295b0d9172a4bf41602d41e108011da97583618ed1a185a4d6ec627dd252490efd7de1411fa2248f5051a5539837304b761ac2f97ab838ac95f7684a20c9e237ea938151609f0768b0b69d4b8a6b24454576a152427bebb0201c1c00d4ac9b0cfd106e663232e06680f9076c44d5e1d31dfb8231fc4279d9978fd068db6e18a5fae45a3d1cb5399a50c4bb92802ee8a8a4edf6a37b596ed6c097bca281ca8dbc2505b07e1ee7b6b5e050f95f29618df3cb311034116b2c8338ae3104e15d5cfc61a89b3e408ec2d7a01aa304f2481567ce8985c07c3be3daeea65890b6b1fc34a6f4d12455a4cdb3200d4f746109f9095a8ccc65b2e9f77f1b54457d7638dc2acef35675dbbece8340651e248765686ef4347179b4618d7774ef241a6c0ccbbbaa1194ba2c2cb239e052412bce9ede88af04b3c6d3fa1266a19c1f80146af451e744f1a5e188978cb04a1b4e5531146256d1fc6013a5263a1b83e69a21deb6a087cc6d039d9d372ca0e28cdd5a4de3f0462e2e7b17650f6746bbe10867f6fe965a99b9aed6e783a1e0d87f23558a9cdfc8356c49c791aacaa01c27e0282300a3ac9e0d34e0100c39209b29eff329f7b5416c1a78ed53aaa1b591d897dd11dd61195eb37f5409b21330e016f0e2b5e3a46be0fd6c968a6b36097888c053b872dacfa250b5c88f7625d09acf1bfcd93a43722beacb2e196c11140ebd5afd144d57df6395ebda9fa284b0c8a3b1aa149f32cdb3261e8bd4f537c4a1ffc3ba766095d06b1f1036afe19e307ea678a74229a0a13bd5df498d8c91f547467fa932b68b4d4f5ecbd602ec88104dc3869686b455c48d848990e52ea7da7ac0c4bde714965aa78b256962c81cd0351ad69198b35ab7c1291c6c7177b2ca61e3271d37740ccf5e4df3d6f9aa4850369ed6654789775e7508263300c494525336e59c54f2c80fefa1b5aa3cf66ce04ef0298f8ea08b67c902826b9597b6d4d62988ac559b78b7ba989f74319f04805069db53fb21af8c69f1e986a48441bfd68f9eb5ff7fc069671d408b33f52e2099bcb4815d71cfd851552ad72ce16d2583a31e27a4afae39e6b68ba3f0923af0b false +check_ring_signature 188c22e8e859c966a0b77b741aba8c7b391398713ae8aa59c749dd8230f6636c a0554aca43a9adddea95d9ca8c95e945724dc9620bea878bbf3210d0758172ae 30 7483e06af1e62b20bf6cd094e941994661bd2e684cdecc6d699e2a1ecfe0173e 6b55a65b5014d72a7c29e16e5670aca1acde7d385855424caac30283310e8bcb c15b080554fc7a0d8e0a438079ca1f470da2a873258c7aa26e381090daafdb0f b2e5030d5be8c8356de7978163aa996e3ed2d791b584284089004381f7ba22f6 16adaf4f0ef6ee681dd2ac02715a4f3f8f067a1bcfecf952e916d98ba448f6e8 e658c5ff535c37e42a8728ed0710fd0b566e40aa746f506ac57a5ffa075a6502 c0a53c2f8a7f3768b0475eafb72cf7aab4d8b7bc80154743067ca5c8dc9f2b2d 222798cc2a4ae9580f9761f19bb5a2c1d9f242d21b011ebb0b3fdaeea027d578 ca994ffbe308098d45cfa07630136dcff7ec46be3257f5f1ce38bab723465bb2 8733479cdd5ba4e3b4c5d187f9ca69a1af4f1a265ecbb6abb93f3a9db77bf067 0ff0d6102443ebbe27ffcd47cf1ab3358d57a2253ef50a35ed3f25033c636b0b 81f0a510ecc0e31049d2d9d6ef31145d0fd3ea073652839feda1df223d0c3794 2a4555188d203db67b317b20bc6ef9251880b608875e1ff622ecb1fa555a2e2a 661a7b172fdf8aa8700d3cf37eb0d48e6365fcc749487e099877ab52d5d243a2 a461d80ca1b9be4a04407491d34c37fe978d5314ee4a96b4373d62fe30b5a115 26c7934fcc7ae2372ef24bdf8f7cb17c1efea30c4cdb1c7cc389b2a6aede9385 29867e558127c8f5f602b75341bd0a160e8c3afeaf08f491785e6c486105e13d 4ae003b39d4c4572908e62ba711aedb154f7da5c3f463c1899d09a862cb940f7 0b3d2c7f61c9f8e3a7eb3cf2e7ccf078e195c6d853ea321124a935e9f61148f2 6c3c204017a2ddab2db70b9a332268884daeef6902c7429035beb2f11378bd45 c6b727f2978bcd1c1c9b033a36d2e93ce9b1d4f86fd9591603a3517b8f70cd17 91d642a70d021204b16c4ab788b20c470569798bc02f97d7936608f571a69da1 1c74c5f106952a9307483e624bd109f4969c818587f48611b8aadab6130a55b2 5f98b0d4e58bc6ff1af191dcb35081dea678bdda680dc8f822ade7a56cc36893 92a2d817213b9e0bf4c7163a398cf0f11d335d44836ff0a3cf945b2a1da544a4 bfd7fa807e734b046f2cacb9bd806eaa726858e16fdcd8b20ed226ab91532925 77d0b8131d8fc434719d1909e3938fa12dc60aacf89fad526253a5549865e2a6 9fe2a61e63499b0933c232105109cf367762c99aa3bb803b6b4d9069404a563d f11ed64dc6f438b494b9e7a336ec7c94ea4ae3f636947643d6607717c0e9b5c2 c57d6ad42dfef81255a4f96af83456bd450c0b3374f5a76072c9151b0ef06431 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 false +check_ring_signature ba5855a4dbb7a3ac0e18790bf3c939f4d8b36d8b427c09801e4dd229965ab62e bf7ed96c4069eed41f558c4082d9ec4448005b32a1608b42b8a41b30fb622c79 1 d37da1af046bec92cb1bdd8dba0c5899e22b4d9c5639007416c9bb769ac6d0b6 72448130f5606de66aace7c8d8b3e4ad1ad9e9bbf7e3d027ea8bfa1d131302f8e49477292a0fc244c47ab4344f757a3b5ab640f616f8a87e35d36e72603107bd false +check_ring_signature fcb52d1486b4307942a8909c8ff1b78b20fced2d9a343e2f65448ace0a5dcecc 398ea73d11205e18bb33c0fdcd3a3b0100791753b9dc59428f1b2e964e40a301 7 d4c9ec9583a9cd6a7c847dd15f974414980195cffa195587a198dde5e88f4eed 2e9dc728ac87d8b28870be5cb6e32d1996dabc4aad0afafb0c790fe4cb1460c5 5212dd8adedd63097cf04f23ddd1714ee2db45cd81d86c8890302e74353788e7 bb22c1184fc89e6c8a80ad9116d78a40b2e6c27e289a7f6636bf230660de8611 307a0d71c0c495ebd05972f79a502fc3476c1e449293199000dd64a88f13ac45 fb1aaae67510ee2588dc79dfa67d1e8c027d091ff549e595e5f27f038f13178a 2e544ae0c899420eba31baaa09dae09e912aeff0ab3693e4656d0399924de820 770accf48b380e79766c88e2b9774406113aea5ffa57e3985439185b7747570fd71e558309d79f8b4c6fe3973cffb858f29f35106e2ebce928f57e692b30d606fb08666fd13700dcdf46ef6e97cfe23f306351547d918db2ec0b0b2bfa3e6409475a8551b35cb4a469adeba5e116b8703a68af9f59c1eb627b5d74f4eb4f02064a42570e221d8a655e3456be4afc6ab3b42882db780bfbed2483cb31e873f90473094eb2dd82270f84d7b18676a72645273b8e2ba7edac7fdf244904e14d5e07a4b7ea0b464c6408e094cc12adb03400e14b01cb2a8a95b25d951088dd03bb0a945bbd207f9f72d7a9cdd0d6eec98ab7ab92ee916bf849a3fb1b6da236d23409ec961f14e804dcb91fa5030ce99d85343ac566259fb943dac3a00c05fda41e077b4739e8f47da03a401a63de4540c40ffd8c2d3f9ba35ed7daa404119f6dd701d280158777ac568715f0743ea4532965ecb0b09b935d94886782acd155e1d00940a79ac42d84651eec4ea28578f9a4ac9c482d3696afabc2d0b692559eb3fd0e4dbae6c1a16797bf05bd9bab74504acb5663d9834757736bcbb3aad75a8f2a0adc0e2cb02cd35af2ab7225f8cb71b85b7b09d24a46061f75b39dba5d6d95340e true +check_ring_signature fdb63fb4927078e3a16f5ea0152dbfb8133dbdc68b192409730489626dc1636b ec795ed1ff6070ad4f875980c3a2428dddbcde0668fb3669700298ad65776cc4 14 8e093f6c9c4d1ad6336da76598c4e2ddb269546203151b629fb3788fbbc17a1b 98c9eaa2e9dcc11bef292f3443cf18ed6209e72450c3568bdd438c5e83352ec6 be86f155bb112eca8a61854c376c5ce3e83fbc88f86ebe1b99882448fb805a0e 10cf2535ba4f02d743030843786102eb586889573a09932608b2c0ccd918885b 21b7bbe117132c3fc3e6325d8296238c3bfa0072e73689288f1ba2217f4f6b1e 05e38104a5e022e3e11113544a8071fb8279ac8aad81d6e47abf56ca17ce994a 3aea77f84b27f897944bb25b73516dd5339a1df98f766ae480161faee9742070 6bf72b1dd1833cc8e3794c5d3a472ca82910b87e06f2de1e96aafafc0e0e6100 1177ad157fbd3c945250eeddb94b7165b4fc3fe7002ef18eb836acdae76fbf2b 1d067c21cb163f104318f20170cf3c7826d8f8765582134ba29b614ad7fbc61e ab541c483a88841d406cdd83c0bd2735a0103040340d3ae4fd2b0d4b2a63103a ad9fe41e986b9d2a85aa1dfd4180282de83b7cc479aa8f84d10d4f8fdcc3cbd1 ad4436ed4aef6c8aa18fc88f0f77e7033f0f1e5a1776357d1acced9d46f27b2a fff165e3adff4e9c1b214fe67dc999f594fd73170a862c00b02364c1e0ed3f26 460fd0ded0648e7959194269aa4c3f1b7a3dd720df73df20b2d07f79f4a0460eae99e3d3ef6cc64ca9a0025e2dfc49e55c02f4aba9ce8b579901cb9cc8f6d20a8b41f728ffba629f92569e8af8ef2e2840a4620bd8efc57c50f3eb7ef866e006b9101463fcd5787393d6c14a8f59452cee0ed4ff81fee67922e669bcdbf06203acff17a96ee53f1cc5a81e56ba3b15286d3dbef806675c7ddfa3629a0280a6002cb9e6d647777c6d89748adc17674e1cb04254a384c4b420497fd61252d9160d8f0a04580da3956a33e01769ede4536a104d41df42dcf6589706840fe85d3f0b5b5243bfd271d4cc2b21644fdef7446e01320f85a76d408394f5f4a4737c8c02823dee9db2f069af71a2a891692984ac0b1facea92ee741d40483ff7105c9706d1660a84e5066a9b9201bf20b5917623224abb99c0e521b7c7b6d36d0a907c0cb7cb96c2d4426336f3937cc656b6ac279e1e4da14e86367f1ff83d5c05517f0c2f51291469529e2b5313c46af37bbcf70c232517bfe6d6298037b87af84d2604d1f5f912e13fe78e5d9e5f0f0232b5c3f9a26ab31356f6ed0d467aefc254c009f1f1104d142bf57d9978c7e618a1a1db6b50dbb9849c1e9fb47143ae0e74715b3cfa2b6b77e4b35340a0e190d9f0eb85fe733b641bc1301bf709669c9ec26c00215fbf4215652a73b8a57d6d4a8762c236e073c895416e3ec53065c963ad41055f4f3c000654e70abd5fefc8011448b7f23da21e7ffa88d3c05726a5ad318e00cbdfdb2a999d93324e94dd19be674b62b17f4ea2ef00766a77d1926b6396110909238d5b69d9be747042c4871fe553a52eb7c385ea9514fb488a96be15af8909a407b99196d99b815b764d1376293b4bcd8ca395ea680c309b7bd427e0213503bece36702398caf7c6b5212a8111414e5fa0d8f9ec2c38e3a741ca9f0192bc0657166b161b1590cf3f009e1e167f72c89db1e9bb426551740c5b68be269da80bcd4b587b4ddec560a3321e3e516edf129aa7fc29f823c3a4d9d343b0b0168208b17fd99973b3630b661f08e4299269c47177efc1b67bac189a16633cf303ce0ea6e237732f5b228851cb7d156e2d6345d6a08bd7253d3b30f32d953c060b6601922a355decf6ae5eff175d7ef66e495f22699449bdb3b824f813fc259c9a7005860cb1fd13c3a5fc04f02ba4a9a20b139d0c103ccd648ac065a1ee07ebde1e0c8968891520f64089d647b3d863af25c86f742dd61ced6c2628ad300d6ae1cf00 false +check_ring_signature 45335cf12f296e8b179522e744a9d90557dc004e0f91b7b77fc08cad3c98d476 c06d2e927558af6f806f771001f2db527c31ba21cb01877f9f7c89bf869e54da 1 2dcf0da39296aae6badad764fb03e520801b2453f80800f4eb74080809ba409a 953d98b122f30716fbf1ac8a972eb0e01f13e6f9f57eb90b0dcd19f80b2f1b07b24d030811faf36643aafc07872fb8589b95a593e51e35efd44da6d44ab6190c false +check_ring_signature 0738b0f61a54bc710961cd7fdb5873844003a482e7b4141241da7fe915fde669 2624638d96b6a0a3c28590dc308e8a3c0887ee32cce27116e9dd30223103ab8a 9 d77e559e816c239ab6434b48911590b5ea90e59ac77a8ff73c584d3723cd2652 a8952beff5de7c8f439dce4b37da9c856fefc6d616ab64d166fd3ca8e7b78929 b0796d5612915004a9e4cc6ccbcf16a79b5dfb3c375bb635d326be276cebf27a 9a6a88c7f90058c29cc4c5968e6384eae22bcb38518526aae076220637a5f158 c80ddb084dd1169b327ad39a7e0bddf41c6bf0e830e6ea3956f3f489e670b42b 77f9a2e8e763ebb2cd4bdfc3f01e242f2d697b12001af9ff724f7f6f865a13f2 a2f1615c8caea5c6cfe2afd69d48cb019a15251627fc13707d57be6c159ab449 b52ee378165c9b2ff5c8c891ed75af43032b410e701e8f38bd2455cb5e36c430 935499f488be9cd4b866b01d0e90ca64f9448f975bb56fe54cf925947f084a32 8296102033c0ad1235963c17cb11f8e0e00bbbba9e189d55ed3f7fe7d0083f090d204b397a5152ed1499539f2cd2e16888985065da82cd37cab8fb689cccd0081fd9a919f644820246e19deabab851e20558d767086ea9fbeed1eede5f5c0203b8be634a7399454f0cb388f38021be5f5616e0644ba98a7ef69db4afab0db107c891c3920b9d820e73cb46ac9f5b705057a868321cd99760aabdec30dfd4980187b0f53bd3336a6f8a561c034cb88ac78d984f20eaea0d495dc64605321a450b226f5760d0ba29b24a41098b3b69a5e7cbbb6d00bb43007b35766954f75831087e28a49079bf1d5a09d825b0b260ef9ae1e1d7c971f80e6c2e763778fbcd9e07ddc6d5a7c9315d187ecc76c72dddf3ae0bf4e7e6e30598a8282afa5bf553c508fdb49e3f4044f2376ef367a877714fbdf0685f5118928c8ecb03f29f2a6d9e061265462f944713e29732ede4274377ecabb026515f4b6e34eed48038208e710f230765ea7468d001dcd6bfd2d422e0fe8d33f1c0244287d3531a6d1d0c30eb005bdc9098c93970f437fd839f9b4fe002625ce9f2ddface30bac1841af0a6810cf13142fb9974eaa9e8291fa2d21ad8344be19ac668beff6b93f53742bc44f30dd39189240c1021e4378fc6db7bb47723ea4d3ddfb85d30349f9f7fe36ad6f70ad3b577eb2bf3caad1e7b6b5910beba128552a13560d760ba074cdee00651df0319d79ddc3b50ebeec3c04936c7522a4c6bf0f6b9337dea157558e03218111b00950b22f27470f5db6ca0a5daa2b5720ea54c9d21ccd5fd292dc8393d068a920d true +check_ring_signature afe96fe95566c3d3acdc0e1a3e186acd5c6adf602e0d74e76f1a3f9d6685246e 43ec14fc375955345b58e15d082676973fe8ffc378e70a2d59070108b24401ea 1 b8065fe7bedde0fdf56d54bb1be8b79aff30702cba7522cb95c47a3a35ab3daf b8e20ce9d35f2f716bc9c1066f3b9d16558f7111bc3eb257d880fc5e399f890d9d1555f4d3a4e132cd303782ef231042f4f62dbed6b5c14fc06f359d51b400f2 false +check_ring_signature f3387d26d154a2f707c09fa6efef0d071b546b9a64c6b917f34353bad5cfa773 b94163c19be88cccd690607a9ab0ba5d760b19f934c6184aae9291c1bb2c194d 1 eff9902e66cd3784691c9246a4645a7708643c05a07cb1e9e9a273fcf5d5ead9 09af637beddc0316c988fe18ab2002b2cfe424925fbfbc931198dccebe6dbb0332d10a54b0bb8b923145d9b18178c4f36a063abeacf13e3858d18ce6b26d1e07 false +check_ring_signature 6f664b839dab59f83cccedf309e3dd788fbf4a60be528a775d0f3169593fa278 9977618b062c20571f65f1163a3b8d3bf92fd11334c2a70c96c2b7442dd61e8c 85 ec639fe5a93f6c57aca7e7f84537adc707b13f81603b75e095ce23571267edc0 604bf7606820019f69d28291913b02dcdf3ed23c93ae092cb283d79d273e9189 8a44294f58ae11915129b323e974bbed280625d51ee7588b7b3c67637680f618 5975ca7cc8d3dca177c51fd61a8806175c3283eae0de95a8bf083a3f1ad535fb d15b4815f0efa17114955915ff3a59b160945d1c841008516e5c5c907e23d034 745318b810c8ffc5c5a192aafa11969ed31144743d3cc49a45ec560b8db7b29c fd819ef55c0cc5b8ab5b1280b50c1ae9b9313e74025c263463aac555da3095f3 019b8f8ac307fd49dd07aabb0dff0749780144bc1251a15ef5627c3836699105 a6f2d32ac7d073bad2ef78f8fa671f39eb3f620131669dc60760b3871714ba8d 5e9ed4690b0168aedd8a0cee1e387614ffb7db7aa161c2cb106804ff74f5f88a 1d3be87bed4cec413a10989ce9d551b02e6df48e3c5309443cf3230be6d79622 a35827ab81493993ae3bead3b5328855735fd7897d21e78286c84c9c1ae4535f 1981e8126c750dae73285e3c29e212a44d45687bee4f4c5ced0454258bc68b44 2e0b0b97ca7e40572a668caf3a22c6fdec98fa3bfc926edcded17fa5040dd88a 115b01773d0575d600eb786d2a2beed8e548b57ed78d78cd0c000fc455a4401d 613d854c91ba074d97e53138b5e0b987721e6747c2da25b04088a726d7663a2b a66eac0ea800c6a30d1c2aeb8ee53c370d41ffafb67719e17ed375a29dc48b01 b2580d540042d9512a14087cb8e75c56512a78c9b54ca6c1b373d3d481d09f0f d22aab000c6af4acff9dcd63317367650ae1e282ffc09b3834f09902f12bba06 9974737c86e04710e7c1162e1fc0da62765bf7b0b3a79837af7827c055ef33aa 154c24dc021ccac26d2f4cc1f3cf390eeeaab3949f6691bfd3cd6ee38d9085d8 dc8ee1996da88c346bf481475741a8d39f3cc2ef30cfe37d9ee6a512569b30ba 33c71c50a61182882d67face56a84fb12e06cd970984b604366116e57c788dd1 d9feb68e888c12d8c6bc82131e54a6f1fc66bac00ccf515994a9bdcbb4e960da 32f4080586d95600d39a668db453260a9219a6f8fdf98e0aa2db9bbf6ecf7354 cf71f0ac428b4411f1be2e7a53f3cb4a9da4b200282c730204ca003c1b901cab a9054890ac46f1d9d974e8416dbfea167d82bb34988862763bb56dc934173b9a d404d2ed2ca07864e89879913cea390cdf2ac088490dcfa6dfdb40f244bea65b 1ea50b763c700061f1337e5812d0fefd31fe1e0677efb14ac34dce473488191d 567f6cd89f868316b1db745a39e1ee682fb85061da2041a6905a613c0b52bd8c 0d466bfb462a33755db82a98b086101a675656cf2eb3fc6a830b6caa8c7f5352 8a7675dab8704f36037722da9120c503c6488cfda6bbdb33e7f303a0ac969a60 975c1abedc5191e7ce27fa54538045a2a49328bdcb32b0eff085c1a8bf1efd74 136f97486ff1bb4e3bec5bff6c911368a714c13be5a7b3e2657c6ebff93a5376 82f13def0509ad1f1e98be1fe420c701fc311e3a0a85a6a1017c8021252d7e7e ff277e64567bcc710cf0989f7c28bedd92e396cfa100058e5676b74b1bcba114 725fa61563b94bdde0dacfd58ddb56d2170680de9c13bc75a9070bea31bd5a52 090fa623eedce0f7c869687c762fdff213d5a951917ec9360cc78f8d5e748ad6 dda72833b432cb1dcab2b5f5c769442e3067f18932824bec80457e3a4415727f e6d74d2e2dd38b102291003a5fa169a57d6a87fc9c57b4dc65355d593cf14ac1 ecce6658e59d9d6decaaaf0b25b21700dd28dcef298fcab23ce040b02b658799 d0633727f77dc0a4221fdd053df42b6f0cc5778c79841788d10bb450c6a282e0 b785bb82cbba723a9d1cc3a845426545cd350d15d1e17216c7886ad2ce9b90ca 57c13d8a1c659bc3cbde1f996ddb280157999238b3184facbe5a16583b49cbcd eacf3a5e02b1bab6004dc09cff716a5ee8ce6660bf3e82fa31384e803e51d9a7 ca6386e3e6343ae0b64a753aa6b50cdecba752d763b6ea2ed423ec8cebf3f16d 66f1551e910074bcdcbe79cb6837ec3d35f3fb67e11c726b70d33952f05a11bb dffccba52f8f994e803e8cf4c061525d65fd7ca8c79adfcea209eaec9d77f8f6 9e2fedbc3758ae19773d6cd946ab78e53600b3aeedf076f2e6a512430cf799d4 394f68358a0073b8c9ba27f50656c3fa69aedb59da537a5a4a2776cb7e3cde97 80ce888b69619f34e32680dea4a5608288a2f37052d5deda500998d1b5857fa9 b9477e570f3b66bb82d0e10544c93f40c16a40e3284a8f6fbe72ce3de1f04c0f 31cf05456a65ff6a8fa403cea308cb6509ce0ef33c54df8429380f22459c36f1 af2a58b88e984036e8fea07301f7aad600c3e5bb1a8b0c5a153f4851885670ed 3f3776bebf4477eab02b6ef3325199c73631d936983f92ae53b6f0034b254575 d61146f8e2761dff6d7fc8927303a54cc1715e0192a00697f479889030b19d5f c9e8c254ff6f4c0f5b8257b5789885f9177184cb241bae54c872b00a82c06e76 3fde706a879db2b2a927a57bbc6e6d7bc7901d2b3827a98ee4648b7f6131aa20 cf396ac56afd8202a6dd8984be3dc2dd82bc412b12719a2a5fbfc03b26d7e259 91b0e5a97e1582cdfe2c0c528bdf51397e778c37d63cc21ee68b21c1171cfba9 049aa09f54cc8501144eee50cbf34a8bfcebdfa7f127e63271996e95835813b1 fdd03e102c05d75a811fe44ed2a9adcae96dcac5e4bcfb0139d3fd3c32bcb658 9d98423c1e6abcb6ba6493a7c40dfb77dc5a073855af8ca555714c85507568fc 14918d8ba5972a3c4ee9a4f6b8cd0addd5a1cdc79ce08fc7f31ed6947981d091 a27f9c4183b2b6a0c413813b668c33573741d511207e5f5011b59a21d88e70c4 f440153ed292e5cabb16b4ee22e017372590e7daed83c34a258c161a9bde87a7 d531f248264596f03f82629d70c6209194111216bb2b976f0b0a4253706ec0ce accbcecb119b968c418109a000736ce89103fdfeee2f21ff622f876f4d88fa05 c445b0e12491c61379c5418c6d91e4811ffa480b045315dbc9bd65e42d02cdb2 6f34ca0b30da8f200ddde7b71e53cc9292649595a556220a4bd7053d53043e07 dd1f9e0f0cad293aa2d57d729986dda972f375c5a63755adeb550c72ec33fa71 141a84d0170756ba46410e17a0ddd30fd51593fc56bdb0e7d5714d75100a8e35 e22154175cc01d7b7f9adbebc29a3d7fcd2a89505f35c3f9193de872b8b5c0fa 8c72b635554eb634d4cca76e2f0a90eac4e38d5347eaf81d8d18ae9dbd39739f 8c61bd0d25d79a2a04f4f13cd6001fd28e57d252c0fb1bde940bb7c744adabcc 2686eeba09f5e737f3845acd938fd9d90746b93310d36081fcb08ea0b6df5f51 332f1f6602dc4a9fdba37b61bb24a4ea8b795049c842aeba39b0b69cd6da47b8 4df6ab5aa82f77facf6190995cf55eeda770240e86dd058708da0f85dc7bb751 4bc8611f2b5db7ab0871450d9db7ce8f25512883b1fd254fa8b4f412b9dd85d0 1e939c17a56492c7948de1e028e7b8c075858fbc18e8b5293800ea8accd02e71 ac5927ee124a9f49e8b7fc9342bfc81fbfcd443917e63783723e09c5d0a85d54 321b161790a13422d8d1760229d12d2c71a2e608786703ae811ca2e40e39efd7 0035be09190b5a8a1e310a44db8e0d1b9d9d18965352582eb66366c5ba35f104 dd602032f0ce07833f4cd52334b35a735ae882a82cd4d4e6729448cf0a44253f 1cec53bc12b4148b1bbe503f19da76b1879df437269449d867404b5a74b4022c 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 true +check_ring_signature 07ccae3653d74d363fec4a0d597bb262027216043bf4d2673ad678b7bb3e6fdd 31d2deb7febfb87abe0e259440f7539fd756d011f35b45ab3c043ffdbbbd25c6 1 d7a77c4eb3859a41bc6674a799975bf76c1548296db82cb749b71e91314e817e ea26358916961b4233e82ba68ea496c9384ad1ca422566f614f32c49e35884065dbdd5dd82470a8b793314342204c05f1a308db2ea7e11d1812aaf0ae615900f false +check_ring_signature 010d78e8ad76b569fe3070bf47c352d35357c114c9faa3d10d2898d0149c54e2 481808cea990aa3546977404fdfcb5cf67d177e99992e7da967c0ce68b206ac9 2 ba2083f3ebd4c1795d99e2db5f1b592f4538675b05c74f630f704b5f527be1e4 e0795a8f6334966840f44ed84201b9d5360ec544a67ed784f1f1ed2736ebcc81 a9eff6ed8775057625541e711e5548d321728b8614a443293f55653d15275b224dfd64b0fdcc19cb10d7f4033c2b541830e8b25ff728fa21f310c455989bde04829c0c553c334219ef83024fc5a619f2f653cc3cdb6dd6e2ff94f32ac222f909afaa9846b77526a72b08a3b4eb3774c66c06a089403d7d76614411f79a50a33a false +check_ring_signature 63880b0f5dcd5e24080d29503b4ae6199742b5d0fcac50ab4a689093601515f0 729ea7f04eaf8bb898a242d372d9498ed2212ffedc504480474af38fab4a98c0 6 47f977acd250274ac18a0a52c9d5f47a8d242b330cb1baa084f99bc39a62254e 68520248a822c2c68123a77f9450ebc8e911c0eca4230cb5bace3549179d5ca6 bdca79fbb7751fd71edc170fa7debe75fc0a9c93e0b6412621890483c69fb069 94a47b621aac4f139e9cb58e9fda446c068d4da9af27597d3e855ad7ad93f040 fb4ed5b505c488ae144efc968ff40a6c6a96c415ada80733c1f427d66565d406 f3316af8eb3eb6bf45fb0c787ee513fc59cf5c9cbeeada16a9f543363a8d2305 f2f3d9f1bddab6ed55f88c1f2c030401a9003f1621ec33fb6350b933849788029a81ff3a9019ae7910d167470d92af9ff731d1715f696a73661cc4d28768ec07c5bf8292e5a5716aa3ede860f5fcde29b992bcc035fd8753a70762d4c9f65e07a1315e8a39b440f82cd77ce5446585de2afa37bf094697a5bba7f8ec8aa5ed0c3fbae2709905bcfc2d77e99ed81e8325edf8b7de5e90ac1cbc2b172bb8f9710683debb541f4c720d840fedba0c9520d68befe33b56620536a1e753580a537706019536a0c2e6fff1fec67600b6a21f77f07d94306192e975bda099f111d6240efb1a792e1c64712618e110bbacba19e6f453e8e792966e333b3079e8e2a2010cb92e885467e09bc1bc38715a784a292ed4e399f67fddd5b1175e06cec6b4c602efd0325a69b6bc386b0bd4720ee9b11486e1bc766cd7eab4ecf67ecfa34a2f02e2f5117dcefb0f6085fd51e23c54e9be952c8099c6b1d45a6441f89fc89fa0021e1d90894026b8195565a93b4028fbe08b5287bcc7a84a541f1d85cbfba8d20a false +check_ring_signature 56bfc7cc16cf261821aedc6393c80ee0d52c6d974814b6c8869cbc1c3eb04474 98bb5598bcf7fae7a3fe7611f9998db6d08bb0edc66d5ffc7b928a00eb191497 9 e63648593e55d7bd09fb9f5cb2fc61ccb75d65a94c7fd6af9cc1ae60e4420337 5bd5502b2b009277cb60e9d862cde723a4073106b7a9549ceb6c56d64de5668d fb57fe98887205ac18e74c5c927361ce842c78ea8cacc24aed0d6c811ef42828 513a52e72fb19e23eeeaa45ae6136295a685af94b8410e49f3cf7210193a415a df22b4d556aaa1d5b8e0e89db2c2ad46db035363dbff2a02cee39ee1bcf7dadf e748192c62ac37c5d9cbc6949eedb0ac2d184669f01c333bcb5b37927f62d4be df7bbe0650db811e878debc397ba5d5cdb7082a22d1e24fcf0beed163a1b332c 5b977f16774f7a6109eb5df53302f6b31ba8f968c20ff532cab23fa5609f3ad6 709c12448bc0d8895989872ec67827b97e360c0c0ce68cd665a1424eedf3a347 914dd5080de245799731d28f1ecbe8affbdfd1e0a9abd363bb057fca9bcc68021ad6147db44e6349eadf4c9f255e472402e225937722663d240544bb883fa60c68c818bd5e3f9ebb19803f14f1234c49ff7ededdecf9b73e24aeb89a1f083e0917e45fbdfb1c5deac93ba8e7b720f6d88af27e01b0336822167f097474b8100c4ac2d505afcc8d4cf48c7f616df7f2e8695063227aa0bf6bf683a1a6ee85d90ccd794a7f98f7e0ffbb88e2578725401c5ae6f268744d90799e9f35e8ff567602f0c32389e5470f59b486ba236b8085154aef5e873e6fa961206d74d1e9e2d90dcaeee648800e3ab11e224e717e928c7de3f834c99866b7ed435d224128d4a200cf08dc61f498b88dc44c77f52ef8a9edcbf8b09043f6274b8004a41e2c82950a1a47c4d305ddddcbafb809b8dfd221e07ed39fcf9d7e03b5d41cfd6a869f260651b210527720dc50386b8d223953bee4e749afe74c809afef592723057eb790fc9ced8c4116da926e7f6715204cbbe5206f805d31819de49bff68a6209979d06ff4ef950f749ee11d135dea55f78e22fab6eff502f7694f75f46b117991e21030e7e5e189cde86fe0d333d3ba53cc04b65fb6b86bbb0c2efb2ea140394754d03a4746fcf6b5c0b571498b31fcf8817fd417a37dac3b314c76d63c11eb1c4850b137314e58f3ea1f641de7f43495ee4e89e0963139613125b1945192540c00a056bb4e44734e25a0bea24a45b61620fafb06347ad30921b7a5acee61ef8c46c026e1cd694aa75bcb28eec4c56d4d36ee0520f74650426ed510239f077fd55a603 true +check_ring_signature 6a07069a48e95bb7bca1a4d605211c2ec79958c59e95e1d71124474efce2e6b0 2b5d5dcdf0353e223bfec0ae0b67563b95b09c903850e01964af8a5f4b8807cd 149 61a146730276adfce45cce3389e17871bf3510836f839913d913fa03f7029e88 47904dff5a940df579678576956add599a67982fa75a3245dd5c7b881a08f8fe 27a0a1bbb69caac70f8b6c4ef92c871fea01f3b38146128cdb40bd5b25cfba43 0be64d7bc41fecf980ade51d7d02d8adf78bf60bad905bc41eac56f300a1e064 dd7649b831b4c32fba162fc7b8746314cc6d22c78d7ebccbc2776190aea0e44e 3a9eb7b4f1df2adbe7330bff9efa00b7d45c9cbc836c2682a74ee4a3aa019255 439c580bbaceaf2ceab807072f9112ef63b2b93b29501b8986fdaa78b43fc56b 47257eb5aca100a95f51868af09d7d6efafbd5a0c90a90ac7c1443888feb2951 7d3026a0edca07808b228fb4ab0bafb09c461811e5055fccd8af54a580c31f72 a29e97854300580fd3ee19090723e92dba5c1f1b706602c98fb8e97d5dd127fd 790c7136d311ef13ce77e3b09e91835aeae4513baf7312427193c1c04e965c9d 43e6687582d4c437f396f37a7dfc0d437bc33ba6f0ba9c202d30a7bc60a645b3 1cc617a27e62849b260e5518f8f73c00a1aea24af1910231db3253cd226ad336 941a79f0348e16581d676e485871af54fd98731226afd07d8ae129f5bd25b625 769beb978dd24e59f8b1b0033c977fb0353ddb22da805ffd05b5877286be04ce 4e483eef65ec512a7bd4211d5104bc2638613ffe3a026cf34a3037bae2d7adb0 07923722db6cacdc13a14a9cce7eec6be5d339fbc233408a2d98751a8398b0f8 f2dc4808d136526e60c024135cc9a82b5f0c5e5dbfd767ac2d3d294b7ea6bc7e 723c154e20eca32c8e3dd065f6645c45bc22b8c03486f6dc8bf084133aebf02e f83959bf448a4973bc2e3288cd7dda2c59a42450e807027e90e97f3bb6750e75 80c3ad317e6cb2ffa477fee68b81c66ac66ba83aea6e56ca5c32f3979f2b6a41 821df0848e2665845cbdc5958ce8dec6b70df4af816ec43a4716366d155cc57e a5ac5ae457877a808c153dcd69e82e19749d8783d75471a2ae5aef2fd4bdc67d 774a7d1f8dd58f3bd40c6af5208e9a4a3ebf8795adb7e7e7c83a503eff33fad0 6d2489da99f28613832acabac60017702155741592674b6f37984cdfdb6da9b6 49d12d0d8ad7ff50675f3dffbb9a345a51afee100aeb7b2c3eabdd9e6fbfa579 2fe80089db3dce371ba1ac97bdb72db3c6b7c7903fafd0e881c63e8343956b23 0ac84be4f10d0c18212d0ba34ba7a0706b72e829313d5483c3e82b716876ec45 ddcaf7cf09c14666871cd3499de9b051f7077b57594c82a3b482e7a3f5fdbf74 e0aa4b20a6b8d3cbbb7a6d3d68e81e5734a4b28944d44de9a0c742becb57f1fd 11c95337888e330acbaf484e01afd76a63743ae947d6fe4f38698942111299f0 6917f9d796d9e781fcdbbee7a63805499fa8af41dd0977294a67f444179b3062 c1b752ffe20637f642267cdbdea4ae4d65690ee445b21fabc1e7a83d6477f905 02726a678f13c934fa8cf6612df517db4fec50cb2128a3cdeb65fb37cc1154b6 7e75297190cd7e482496a84e88d5cb06805b02cd37bfe867b7d335bc3ca66f73 ba0c3e06557dd3de92b18212bc0de3ed21b8831b2fd4e4953815058e0ba3590c 9598396e1e722b41f47322e83193cd63e6aa2443ed2b92a464a2d86914ee912d cd460bc9e523ea5b9592ea810b7836e3819a0cda756355664b8c178ce9968769 7804172eb0ea9989aa0496437b60417fe982d85944c7598cb4cde769320ed927 375668322a50190f3d6d999e89f61fe1f7514f5bbbbddcc6c2fc4b278b6d5b3b 8ec081d471bb8efe469f4e616af78f315064e973429c7ac1e23f29b352cbc7f3 5647ce24f571757c6bfff9e269ea97bf6269eec5617fbf5171893bc4dbb4b5f4 9cc575448aa61aa021fc875f05bf4a63a971b12e88b1f27e4517f3f344582cd0 fb69456d04c8ef0073736587e599c58fd54fad3f2d2533aa407476780f255f5c 3c9ed2c6e8202d7060897a60788abcff1487c9c997bcd0957c928b83481773ca 45cfcc629f420f4b0703ea2cb124bbcc1d652d9d1024af568360d1f73444d836 fd9d53e2c83dd4f540054932d3393eabfbff7609cc25b56b910f4029fbb2aa7a 5ccfc66f003bc174af26c8711a9f4e0af3e8e43cffa17ec493f6bc3098a026ae 9f66c20cce536ccb73233e6d1ecc91a94ee446414f404926d710d74c6ac54538 e70926601ec70520b35ec045fa6d61c82aa5e2b15ba121a4b2f1c827c1cba117 c8e6eed6a151d978c5d80207e3ede951e7df5d35966545be3779e4224cd0051a 9651aa506b83fd0f355b1581d8fdda3d2de85e627ffab3299f013e82c3fd2b95 9c648ae94c2e491a9daeaf3fe7bb13ae07c10ed5f3c8e6e0fc9fefc9c5e02bf5 e29837ba772408c61eb55dd9ec8b70ef149d20c9655a5e914ac8fbeebc740bd9 38e1e459c56400fcbc6f8682b9bf41cc5fc34ce98e9881f9c473da2f1615f73c 31ba1f1826746edd1d0c53ea60a7f81a259fd4309836c0a9fd17d26510a585b2 fc9b0fcff600c75aff30543d2e861d331f89c08259b5b8ef320d89128e49943d ddb8e518d736d058ca470d5aab0533f04171d5786afe381f73165f5f8530dcb9 b71a0f98880614a1fdee40faf57eb6f1e6e33ea3a1792944df86b71ba699f6aa 659151cf5510fa0ce1d1c740f46797ef226bf6488a8a336f0772844b1ae03cc2 6460f6fde9711a9cac4a6e4afbf7a8d5e7a9972b92b4df6a7f015e3cdd55590a 3f438e771f0d422debe8f0e6034deabe20b4df937abc5855e9fea62dc4c79904 4886758ccb2a387caee1512e9db8839ab42239a46a9d58dc187df6a44ccbae71 25efdbb2b406e0acfd5d6fe72c2d5405161e2e930cc4a59231eac969568b13ee bf658a664d20b48927b336d11cb0ee56fcca17278475eb2e146db3263cf61acb 8c2cec9a9eec588d378a6704ee6b1dad6223580616961af10360ab2b7e22e2d8 a57dea34f3fa11ea45d49af09d915e8025e82af02cbc3013147447ab15781c00 48bd8ec72f764a39a2036fa29190d065b8340c6d348a58cc37cbca425be9f9f9 411397be07715b662bac01fd61495d6c86627bcbc76ac5cdfca7d12a9a8626c4 5f52f702ef5dc2da7509360870a4e1e9e0fccb7bb470986b9cf417e883ef5b9b b3be2112f8862b9b235dec749e631cd6fc7ecc2c1ea4d4b17db621277bb91cb3 fa13fb08ec7a990b4747cccbc92548392a6ec17f9bc139a1248c340f1e80fc3c 3282a1080212b336e3231fc5f53ad25cfb1c0653feb8356dd2c5e52333da6b86 210716aee77fe1d973022a273cb9750218f83f8671b5be27656a09b80ec67c74 f610460f21ba246984a51b74bc0b37670f574d420ac3d3983aad5b019bd7515f 649ed5ef674799ce65811e8748b47c0e5bcd9849ab66a8e59280aa86e7be4ceb b44c6f2122e36b3c4bd7c3b83e6c34067ef1648f71795e28d7b73c7ee4c864c8 413692c39354a3d3f865254fc5e57f0be23f25f026ddff431965c8970e200add c2e3c1630784c72cfc3c3f4d2b5b9d65fbff26ea7212e8f3289e988f7d45bad4 fdff9d67cac3082a5f6da29dc4a0557d98e6d85d15ca5f77e81ed6dcfa5a9004 d23c1e79f5baf35a0c782bcc38a04ff5698adec3660773df2d400b2409340264 0d15ad9ec85461c5e2703af3f27421876de395d4ee5c219424547070ae0095b0 aa0d0e5bf00c2135f88dcac32857f52356421fee8ba3618fb00495b5eb1ae196 953e64a94331d80a4f47fe816c52c39023cdb82ae58d1e0cca7bc29341603b27 e477daf3f777cbf30b8313130a5e9181ddc98b5ae0055ac386c7685af7132e08 afc64aade3b87a842aff9a00e5e1ca5ea35bfff124ec6198e682a70a4643c92e 243ee3fc5d05f7bc6afa4c508a2f099f9756785a4e3631103f4af5bd4d219ca0 a2d5ba81352c1a80bd472226b50432227693b01f5db1e7140eae34c35138d0f2 fd17fdffa2891ff52488110bbe67b50382460a6880df0ea01399f317056750b7 3e5ac402e83fe3760507dca5d0d3e06bd34601ed3b2a3fe1817427e8311db21f ffb89ab0f2e28e1ea3d15eff7ad3bc9a6305066d4bb3679323d03054dbac2fdf 1af8eae8ccefeadc78173f5523908d06732c1b30f22c76d6fee203b1dc0ec166 55d0a98a18768c575bed55f410a9b7823bc9b3dfb8cf639ecfc7919f267a7585 e8af14ceaec7fbc25d340f743b4375b574bd025f5dc6a2bd5c28eee6bb9ffeea 12c0d4deff9aac0451dd32c08153dce879b39a215d39b8c8a660504f172f8a4b 8550c4b676250db4d157ae59b28e77caecee2a0d878bddc0f4633b63df156e6b bc386f7a58311ae3ad3a2c87c43defc24027a0df474a550cbfbe07720e31e341 a075f9abb1612536e597fff1ce8fe416572a4827cd971516a1f88572ab342875 1ad0c286b8b2e737e4abf601793a344c57ca35583f821b7e3387942c23475afb af3d99cc5e1ac3f0250f3eaf86fb6e8a8d8d3af19e1f0407c703a07e9788efb6 ddae7ae51e3533cd5939f2a6cc9bec6ae5fa4c81c6a2290b6737558ab5f0d589 64d503ad47b36ebc770c804a19b19b963913c4c08dd63e98973043ad8a0f5139 a54edb5db706c31b223695736f9b3b0d773b4f5bdbe850817f26c793051af48d 7e0fd6a9fbfcebee9a77ad9b18248ebc7aab17882d2250531c6287b2ce3c74d8 949ba6ce0a5681490220a876d639f3cc5b6b42a69c49bc5f19d4f8e06888cddf d2cb7a82e73fa5a336a3ae2d02474e0708ed03f928da1115d93b6551c564cbd2 75469743425a7e9ad4879d6270dd142746cbcd13a5cc18351aaddee91f87c7ba cfba6ed1e99665176e4630bd17c5812e2116835de2ce7178972310500a4217e9 72e3939462ec07bfd69a61c9b9cc35328101b3815070c74e4d49fc124d8d8fe4 e2d8c14ac52142e92c45dd6e920a1483c6239c421bb4a41c6d6badd34cdd728a 8c290466982984c5158ab7f6397a043e1f08072d82a44642cd922546aa0fb70c 9d49bcd19e0a4382b92cdeb1d9b60528ae63b544486690d371e94afb5bdb9072 cc6f8de4d4cfac2345a0439317364e16e1ddc1f40e85f5590405f31833beb554 91e0a00feac5fd61cf79b60a06fbbfe430765abf1b7092d94aa47f81066288fe f330ab959be24997c14563ac9e37290b1c244120f9a3bcecba4cf584ec669c75 2dca51c4d0340465b4a8b26d167a7e742ed36c391ff7dde80ea7948faf73e597 c5169915cc126deacb3bcfbf6aa7a016789eb508213f34e9ba0d6fd5a8a4bae4 db8c1c9c0124ca7099b75bce2c4a09f1926c05a478972d2da72381cbbc5abe0f 658bc638e6d5cd6cae16fad7685dc42b86bbc2eb9fc3156ab5af76b5bdcf4c37 b448310274dfdbb815422305d0b92424a9703661e0e70c72f27390549be12197 0a303937c31edb1a0ba58fe50dde92901855feded942cdf1b3e45d7209cb6b12 6929612721d2273af1a5060dc25e15461fbca895646b951fcac76f3a8e739b3e c0afc433077135261d70e8435fdb92a0a707a7474598a4fe1d2934022dbefe92 092303997c9ba9cb6c88b1859abd33a314b89cfc53b8d2857adc850c68cd8b3f 0683dccc2306616867b8080ff0c26ec0c4725ca6e10582e0e65576cc5e2a98e5 99a69cc31494f28f6d5ddf7431a139cc9786b2dfdabdb5342ed94ddea9433e54 74ae2a459a5c3fb4333d7b1d67412e83586a95c87befa029116759a84a88a8b2 d7fb799c5c1092bddf136d5beb7d637eb3fe20f55aa38b18c3eaa66de3ab6799 c33fd7fde9a9c86a744ec01b452552223075bb8e154e66c81655a02dcb2e8380 3a1faaa8445d9e3427617c92d748deaabbc2e519ebd05815fa895667e0bf00d2 2103e782187d4dcb0b48bc498d674ddf3b2fbb123f558e031f7b05482c1162a7 46d70c5a475cec230e57f01c1d4171d5c1f3c3953ad8f79aa260a572067a66a3 61382cb1ed2898ac41d7b32bea33c19ef43c6572088aba3ae83fe9bc4190c091 9d84ed3c2b906adfabf0c0fb3584add059c2586d1d3e91f06b09821f2da2328c 93075e448ab7ce47caa8dfb4adf9e0c8be452e3b3c44ef8de2a876f3dfe031bd 62962ff9d18b57559341d696612e8431f26103d10363ef9b7e234f45772c8b42 636b74638c34ae8dace85aee002e59bd99c0dbd071f729f463f9aaa13eec6cfc 49e4f6dc9f0a1a4e6247d30f5bf15157ea0f8cc03cc292020fe5450bf1e08d37 76e49d7d282f1f301c6054a764d72dfd9f4367a3d4c2dcd312906734952558a8 659a5a15e202ab7bb88794ae0c5d220cdefc29c72a9089f22d20800abead1c74 2dee3e5fdd2db5fe037c4036659fc911d2fda75412419f9090d139a9058f10f1 7fd079a4a97564c6de21bdb073d7737e74a4b1a5e62a42037b30f1827fc25af8 6ca9fcca65c4eaf796d232bb50e40f62e3f2701e982dc25eda98bba2d7a95709 5fc07b842ee6cfd08537b673d4f634064cf66cd9c316b3ab58daa7b794ed7aea 0216d9d6d4a706ce3a1778d4173827d0779a90181a9968a6e3a412305b0627e8 7832a7a2941bfd939289f8444206cf74f30cc2a5a4909d3887316b73aed31540 24a51d42aae7353dd9360eea854e4a0bcb30b431cbb47854a5418ce71c6cfc1f 5dc0aea28e02cc816d548116bb2a0d14d29479ff39bdec97d92209da3c159055 5ef4cccefd3fdb8185433596ffab68a844539c546744529e8c26ffa7b3b06832 fd05c125ed8476e6b74e856aedc943283a00d5d08e291aa1e979c80683db1c0d3b462b94fd3711a60333133285cd600a3d335108154fb0490eab2b09d80dae0c122633a28415dd753b6411f9016ee185d00be8fa1438152132b784e48a86b204c65392f007cbea6de3478f66cc2995d9e3d6c7ec1ff5589a9b3ed05e8454b207e698ad482ed65745ee0661aeaf9bb5283bb64599b5110abba87257cbe6f4530f01118a7c6490ccf662ec9c09bccc78e52b47da9fe097e22fc5b479d98458ad01b60e94a4e832c420fddb92a2fbcb26c45b3bacd6f7063a2c8436940a1650a703b7496c89df9735f8de2cdebadd023bd19ea67a05d2990b090228adb2a558bd0027d9835b478fe488637d3f7f2034d95ee2bc8e4f7a48d97f1ecd20e27c0ff40dd0bef3fd822bbe696d7d7965db553a0b9f031502ccc03a0fbf580086985aaa0222349df638643c776faeaff5488f4e2acd039e8772e220958de375b84ccf4e06ad80c5cef8786fa0daf52b8fee39d2e5aa37210ac01ee045f788fe8e68f0100fad48d62fb561aa9718902ab574ec1d0fa9fa53e8aabd6fe8aed53c50dab7230a5784e72140c7fac5e79e17c005d99dd65b6444fa802674fae7f6960db39f8a0ecfe72dd0d123adc82c0287fc8475289d1808c065b20ce2389863edd595fcd90a92825796e8fb85653a0534fe223454c060c39c1c0c81c4bacc00c0132e6fad09684297677c5ec17b81b4222e661210a9b1a3fd464c61baa257e95b1b359d25018ddd2aa3039ff10c4fdb7a72644f5ae05259c1d90f2a7a0d9b18f0c0903523060ba97744b0758506d3dc9d701694e304a42bee1d9ccc3e265f453d88cf160906d480b799d75b1e98401eef84dfedf9605e62797d1e876a0fd96f23d4447a050c1482478a9852cd3e90b729453cbb2f255b452a1aed23118259e3528331c9e802da34b598046bfabd53d67bc2db754b82cee1040b2ff8595328d1e96635eaa8035d3c780f2766b64cd56f2884178f23f8baefdf5b28c27af36ad02a3992e3330db790a2a25bcc587fec695ec6960a3048ffe0fbf7c154b53a44c6bec490895a0ef09e400b278a93c709020de8d61b1b5adeab7a814015c35f364e7c6f38909b0895f8774ff229069012501736f365b6bd94c65cda7868053f0037dad427f5780886c886a563f5ce965871dd49de73301455d55c80beeedce21b41dde1b220d909ea7876c8a6abd6cd6986ee633b06a6a70bed3446814dd4cd5b4f932b00de7d0539cfd46e42bd2648a75c47c19ba21b891a5c6b9d774b1ab9fa22559d2faa1c0171b72f182db64a9cde2cd9adcae8dc16d92bef27b0c7f3da03ac94660c78db0860c9a5cc19b931bd86b13a67faacbc6802a9a61d020cb02583506e8f31b29c07f021799a08bb62471c11a5bad368a1f340d57cb1ac4384f34521267bbdbff80ad922e8533fd8eceacff193c0a87f8f5b2e50e65cca3bbf91a93b7d0197fcf90e694f0e2575dfbf8f3818d66683d135c2526e6e2808afc6d8bb54564213458009906bd308503086e2c91dea79efc4eb7063bed9535908eb17f57b2bd48786d50b934abe9ea2be772968b39d7aa5ca5349e674a610357ef7cf3ce4e66756ccf70b84b02e855379d2113dfaf3d14bcf9f2afc0f08c1ff587f651bf95da919f99d0153465863615ec2e8bf6e00c4fd9f810896e9c4a70ee233c3a4239cb4a9d45a03085e38db486f54aa33a811bb49d71d3dccae1eff8af30140dce06b66f99d250c64921ed09ec89d9b741e61b72b7f4c345b7ee33938d642860d235833ba7fa9062f7c3c73f7b62036f2b9e6c913495b7744b730d61a390d1c89e9c896b123370b0698ef3bd50846773c3dc0eeda7859f986c1c39b0a0aed0691f38453360a430a91fc5cb652f1bd5272fdcae975dc2cb3c46cb68a56e4bcf8e5e9db5bcc8c79053554b0c6e9bacaec55d52c103dda8f5b48ebaf2f2cc76f57b1de6793132dfd024e2a30daf0cef1af3aa0ca24e6379f4c29b02a909674e4466dd113f089c2f505e320cc46d49ffa7e0980e14f0f48880079b783cdfa11510130dc728d78cf9307a7c36d75474304d5db7960e2e154145c24f37c5f047d590843888a43482be40caad70a05640aea4b1f969ba651f286cfe3a52308292febed5f5699ebc275b009593169f7dc220d0c38a2027af2df35ba809e784d93a5e44985fc5e34754da70775e329e0fca11e0ada9f074fc2483a379e17a02ca086d2ceb3057aba5efa9802f07474340e92fa9216197ce6b53ff2e41cad0abecb047c1ed29e5aab6237ef0bc5e0d7037aa747079ca33b14617720806cd43513e22c797351af960c2dbe0708c12c098833d76a7b243dd4874df6b3dc4ed2a258c3f73e105ac2b2d3f09ad10a8655876712ef06ec3af369d61743c6749b1c8b87250a2679870b0170842e510920a20bc5711b9e5a587756971e3193dba29ae4c72ae2f1a5d23ffb99bddeb207c117c2e9510685a4c1887737247c40879f7a8d9ec46de474dac1e15f1fb9a506b5ce9366b9763289495b600254246f8039aba25ec4867874afa8a3fc2a9ea709cecb3baffee498493743dc5061db476b4e0174be43abfd714ffbbbc4e002c007759cc03f344044c9e1d0353bf01aa7e5fe6d4ede2c13b5b33adf16d8606a180dab2acad640b0dc132d8b25675c1d6da725f451404eb4a9c1b25c9bcb92234506191f1b2bc358e3fce3308d6d5af101ec9752223b7e933beb5a9cc4a7091d49092fa500d19539744536a1493acd0d9b44a88502aeb4802dfe5a8215575e5fa808435d2ae7795eb20bcecfce667443121a8576f6bf5f989e268aaaf63fbd7b190dbdd69aea64e449fcb5e5ed9e93f2939ef4741e83daa2732e4e8ff33b629e670921776161206e81452205d442656dd6b415175d5091bb0421e53e565882e660035aaf65d6740fdbd9a35551bbad44bc0409bf2e40597896186e32e488faf872000a71f8123f662f55d7c9f709bf4b52229cfb12f6034acf5a21281d331253870fd3165fa473f6c2512121a06f617f79e0508e49c52a115332f56aacb1c5b03a03c37d72cb60959e45bd3dc6e020c8fcb87505f4d5a685159c83984a17e94f4b01ddb43de97efbd270ce144fee8d60a927b6e9dce140bd004ed54f3e7fa4ab07094c315f4baba91cf0eb6e97016c4f37d6879b28e0d1fa1a1107bca7d59c8f2e05a228ef317dcfefafd4cc3db81d516dce783ef083aaf7ee61c59c2c20611b010302e3659294af2414d03326dd8a221864684d5b51ff5c1f50fb0ad3b2b3a30509211f9f563f50799afb496238f4bfb020e0477ae779cfd3a8cb38872076142e04c1eeb08edd57c801b65573f0156048e86874ffe4b19b713e3dff6a9519e8e40cb117696b7b7f8facfbe4435dd2daaf0ef47b27278e10cdd1a21856912490740fb2731d403b0934da0631b1522b8b483b5f38ce0a718f7ab797e6bbdb132efb0e30e8ea196545624bc3005a41a2a8e314cc7a49718a4a250a212c795a315431045c14bfd0e6a2baa3491287ce4582f019503fc75fac263aeb864dcc23ab72310367b7dec20e33aa1d6d3a74033e8768d0057be98f7dafecadc7df43dc3ab6a3098ba341bd1ed707f4bfcc5e7bcff9498c44936e0acec08feb57db8c7d87a06c01f42fae201a75da42b6686bdf86cf976bc5732f3550450b33823b9a35904707080df0441ef7b7adba5f5c589254f0609489db3883983ef05d9946bf22a94ed300b19e061df3a7a1ef346a226bfd64053932a4fad49e38d57bcf8566ed81a1e2091c6383d1ac6d5f6adfc7265717b0f0fd60e408f09859831e41f5956f4d939e053f0a711d44fb9ee2937b7f1d1ac13932b6a9f5c8a6e5ae0a14f04321d23bc30ad22b02abe729724d7a898d91389e0f5fe718375125521665c942953d1492c4004add8541d2ced559eae215ceac4405279bffcd5d0209e2701a9961fff857df09de024f38f5b81bc5a7cf95eb3eabcf08e07d95148a1fab4abd62a24904a16609ee34b12160bf9ed25850898f19ba6bb367f3525ed0a52c5d3dcaa3c6534bd5081a37495e23051f3d6931373db374933db31849b7f166d5d4c736ab275e3bef0a0aba39c410d71fbab6c6a9cfe8b8e1389e628803fd92542aa2d6316c0d1758042a6e6aef73af984414237b23d7510615263d3311a2d4dfa0647bf889a874210248e8502dd792d5bc2f603f37d03546ac4a5ff7ac790bfb544b5aa3bc12a16d06bddbc6da03e51244f18d9b85c29688344b3a6c9ae59450b1a9ab287f7ecf4c0fb092ff0e3355bd81eb9ef6b4c8fc689e0d665c8e43c8b3f125d0ad698044a404da6ffeeef4c5ff436bac104192ce685ea3a0225ce8157d41ed6a4490be325a0a354cd36497185192b7f5a5dbccecf6d3dee0bd736d42ec42667e37090f2626006811d578857401eae94ad82e597de195b30e1a599df5131f5e03a03b2baa5f0ba795b7a767ab217bed3fb781ad159342d6f25255578d0352cf11d1980101430d8e37e47393c49878524b12960cf5585769c13b74695e2a6d59d999b3fb861108604e0b0a798cfa1328afbdbb81ff96a826a4d7aa67650fe09d364e65c8ae680e36d0ba8ce8161af53dfcfde4fae3b8cc661d0a92422cd2f082038fc1bc61ac0aca95d08369f5afb656d3f0ac71e194f3b6cf4d4581efc2bd7edd24a49c33bb02b8c0b33736c15e04a26bad09f494de168a17258a2bdeb6da6ff2ce0fd511430ef15c49df92c4493d280ee889c47138846a10fe31542c2153dada6dec8c161e07cf8bda2c3d049ef419a605c3dd2998ec419321a0d20b0ae917506e98e60276056e2fd9d12d69ce08f8b07de345874818dc81afe0af3ae443a47e8a4c260c7d0fd2fdaf1daae56186defad7f5402b27f200b369d08caa1a5cfa4299d01b577b0014a65b06ffbab29e5c36f53555cffcd15d929c5434a3bbfc0d4655226d0ae10b2d88bf7130db749c1a48037302e2abb6408c3353e6ff8373ac52c3e4709df206bc7c5ed5be0eaec6cc9ad7e7d451d4a65db2ed24e5323c946f2703da47cf160c5eb2aea73bd0984ada3d9961d0c9867d2b9c0a8038f6d5271a2e851a92c29b0f6755b098fcb57e84f6cbfc08a21a31ab92e20fee73f434e0f21fa5e3e454a40389863d90c22968b9e24a732a00f033a32c48bbcb2c79e008ecbc4449da5514079e27abfbe38ea65b75bbc6614192557660bb4f49956def4304e22d050aa6a000001dada9d7e884c6506be9f6d744d0f443368fbd4d9b735d5725726464277b0520fb6022fc49cd609789a21055ff846461b37e80f33325ae23d4882012ac8600c8970cb97b58b7a9371fea7c6cd25bfaeed1c55926c264293566e0aceafabe07cd071f974d9fa8df9def77f6ad19e9d3adc3cdbb2d3c9ca3569c857d2f1c610baf8aea90c474c7587d629e44b602f3ad1455a79159756f7d03dfefd09e4bc80e31761d8ce9420cadfcc3136247937368dc35fc46a57f77a2a8634fb7b5891b04c9241724af9e01873ec454793731c1b054c516999995b03db5fc9648a8e6760c55dad7cfbd1f482402cb9972f3bb03207febda378decf8e755dc744f0ddc720cfd1048ec00dd39cc61d4effc6e636bfa57134da7aa295956b156b1bb72d97f01486b99ea38e4e9b39010a0680370c83460108a293f66531e93cc57b51ea889028e92b715efb951ffdbd592fc71f9821596c2ca8bcf6098adfeb5fb6835dc1d05ed4ce262c85f4afcbaa355e28aa8f1171c8fed847cac618305a0f3adc043da0ddd1c46ee1c5b2d5a733a280f0514a78c3c57e53789bd7db5f00b0d2be95cae01a4571cbc0df1fea8c7c81cd4af583def48f98d496353557b11463de60e4d3e0516a024a81e4a243d98846ba8733d7d806f0700937118d3f3c7a0b5f664b9b30f3ae58dc43b320c2c91709f97b5ca48ab45be2d825ce557322044b45738f5af06dddd83087e13bf1c2ed771e8f026f7dea486ef2754d1b5abdcbb1f9c7343800128155d0cf1c8f576646a89eb740be8fb5a6bcc15c49b9e275d2d52b6ca0b970ac13085de6e5e40fcf9dd5fa88c4ee4632a14dcfa6baef863ce806d3ce855f609b9534518cd85b0adc6cd8ef7ea5223ca97440a80a42c74007a582ffca17cb70be269d20285f2bacad848403a1bd2d8e9affc0bdd4f1ec691063f7a5cef1f640c436a276f256ce79b1f628349bb966d7ff3669604c454cc340e9ada8e2fd36b04faa6e783b3b97e7e5441d7f1719736d57a3cc3706fb6c033af4c3ec9ffcb4a0f5882dff18d21ba5812025f195f969857739c71739f8f3e43c65661b8d5cac80d46073f8e9ea07e4794a86f3cb309e3e93789247f01b4d40604dc395eb021f30be43bc5628dd0ba688553389123315097cc5cd11f4e9e3493a879e70b255464099525312bb33be494b460fcedc0ce048d94b2ce3c938ac727f447cc8effc06402687d24c0095c98e2bac22de6d4c8bb348bebb3e6dc88a4ed904edc8b3109b407f53ae93bf42d05fb7dc577dcdcda5932100b85449fa2a7e8467210f3f658ab0cbd264963aa93e14d842e7bff3e86d591466d82f4c04c00f30b9dfb210db52901d0cbf42e320130e9a324d206b946c53179e26ef960bb269740c31d0524024b0771cedac2be19372f7fa8de573a309d2d86f931005fe2cd021ce41508e19e2e0ddce01d34da8013960c2204982d5619f73f71419c7fd3c6fbbf258d91298117099d4ee37e91487e2ce0fca8b16d9b3263f1697d8a55132c6da4c13c57914baf065404cace3c31583968345f614e99290c21e575079a46a78926e748793130d405b94fde639bd511dd6843e5344f5aa0fb8d2236ea1739a05f0a69e05b195c7c0cdf56e67a5babbe5f4298632075aba6855f2ea0ac36c358be3ffdefeb1ca7ab020b2c911eb9a2c82ed2455a1685c8d6d0f5148cfc14a918129cb251bc88bfde0bce669aabf1e719c9cf7f25c6b88a87f3873e0a8cb8e54125f6343fc416d2a1062db017f68dba1ac659611a168506f9431325a95dfa6754c1130ecb583be52d060fbaf05e76c69a831b5942ff2079a98e954020d884ae50924bff77ed4dfccc08ef56d53e19accac753aed8a66b50038c2006a25df221cf0a6a3b9fd6f7b0f601d457afd07dc03bbc9a9b3e631d0ae6e88f8caddcdab0e5c647f70332d8cb5a06bb4a147435f3058d5e8c53ab6589c78b985b6c8f99a37519b61e979cb2ef4f0a7a0be971c476f1abb59c1709dc71a69abe55c07db9d1f201f87e6128dad22c0573ed5ba73d47708148af51b2cb3cb8367b91578c98ca922001095a8a8f782203c86d160021eaa6daed4363b3957b33c5ad4f9e1a0ecea8f18843e02c67762e030061cf315a773b3ada0be95be43148af525dae54a2e9fc2ac6c83b3850052e0288e2c98d744615e792e93aa44500722bc093b7754d530031590faaac9715000f996d219304dda0f7a0b86e8dbfea9e205463f1374b0bc904ad45d223626c470589791a146601bf74b0adc2335eb07cd7275ea312fed4135c63a0ef309ae05c0c64a182879a9ef44d733786585f09ad12d3e1b217d70b122f6e537a55269e7f00766eae322bb7ef569acbff61783f71e8693a53452f70a5bf37e598812cbd590547998d33a039070f5593ea1160022627edbeda6f7f2cf1d4311b258038d811022715afbeb839093cbf77ff2f90bf8bf8eb84ce7b4fb9d6780d6a6e0531c62d0abe95975e1d916c96ea1a505630a9c1efbf1bc57a35d3327cf8a8dd3bec48670bf85fafc3c75d88c8df3e85eba4c1f0d6bfec9852ee64262cd326b4b9a6ab8c06b3b821836875a70f08b51af8d35652f92813ebeb17093e168f213a1782d2ab0a6d61a41de240821089f0c9d2cff7372e25ec53b6038eb32ab6ea62e41c2b2100c3447d4a55f161ba9e412c71ceb226bdbe8a2b5dca99f5ecb6d058669cbb220a9aa18f820845a79a3e51487f226172c22dd4d7adc282396131d7d610da57360e3770ecacf5c479b3f6f64f153b9c89e4cd65b1246baab29ff6772ef0c0590a04ffcac6e8a39acbc2db1b8b539fc358463eec3dba06caa7a55ae6dc4f434b9c0b6fe6860ecf6776066f2af8204e957355bd352302a287862323bd90a75e68f702308daa3b6abe9a1fb57a24680b8f2131f1f9839dc435871fb7f660a3da4fff0f11b05fa16a3883593ba34ead720d102d82f0e3965811252f55ab858acb81240139d0cf09bdf536353dd9f60d793a70fe32cec0129c700f6961b39be259b7f509602fdae60c59903bc4c9549cd7225bd8c4b20703992846e6b8ca04870238d803bb660f376b52824bc299fa60e04d204ab645413bfa1c691deed96c5dd4432003ccd49ad85fa0b6bbf2210d3f083125e8c8493650f653acd906b5cacb1aa7160bfa7797cd76221e6f99b843d735f79df715177638821ee04aa4859d4a38711408b5700368b6e824a116ffbc630526de87982b0e5eb0a28cc2f3dff69ce85b0102bf85439eb616b1db5057f743dbd145f29f84017b372b145e3b8464fe6e5e2a0f1bb9819afe756cd948e39ad849ad743e26fc16bb8ff29e6dba8eaf901395b90eb01bc2f6fddfc5c918bb4f52737151f66e10be96e63de0a22dadf21b90e3b601160c609790bc4e88b4bffd852494af7b684f3f55c42864d9ea27b5375c74940482982467530041e820b1226a29568a00dfa3c4e110ef1c889bc8c24500c1c30eaa72a974c761d84c2124d1134e3bfafe4d88d8d9da85303143915d807e9210079de3e3df6e5f3a2ca0554710d64bfae2c98eb66dda9f2d968c32a4aa81ab7a0ab63e56617f78d867a67ad62c8623b92958d158f24302c1a3e54e8d23a22f890cd812dbab1907713901be97e3236eaf4f082a2ddf183fbb19440a177ec7fa28023c70dc4811808c96d9650f8e1feab3abff6f2946729f27a6a91bc560ecff33016f96cc33e0a73944a4cf86f2d55dfa6441e099f0fe82861592b495d75bd0930bc7cbd02173b58c0e82c28073c40e1e12bf37b82b2a583622f834bda44b3c7e0206f560e2ad588fe6b8bee24b680bf77640a92a088d4be6ab372bfc77ce8fe904846b36178609131e7bace7e9432e2f7fa71bca8c0f3d05015bc237c05c2b5c0696e04e07cebfbd594ffb760590228261bf90c02344e912c286e9a265d80cc9058427936a65aa00a76d9f5fe71b5a6c548fb557f9f0d2f379b2ba586dea99c00d2ec12db2033d472738885212d0a8e042761dd47549abe0902104e9f087dae507a9675b24983007bee7a00a8d8b972b6db526c0c84452544ff1080b852f3d93003d1b3a9531155d198e58b08eac13dfb8882bfa01175f8f265994150438ce7c0323a75944f2c09eb1c4203f8af4aee4ce09bd1d8ecc7beee1a08223437d2fd204c6f9e2239c2a48dab83602ecb5ff39a05ffdc68779ffeefddce33b0fcd552a03be0bc3d09fa00d11bcaaacf0fe505dd291bbff2ac9ad7fb4cd368529601b3d0508b4f7bb4645093ab8a7dcee05a80a10c71dc4718e603e3f8ae870cfc3d9590dbe03c3a8bce534f7a4f14a7fd17edb72204fd316db10d414f2c709465730fb0302cd8ced7eae7eb0c8fe11acd05de8ab31ce9d4b6d166604ab94ea64f485680adf59b3666e879705f73f258c18afe762bd0d8282291d6776d827d25a2f670d05dbe31a8ff0e1b84b4b417b514aff1e5d0f7d3fc9f17bc12217896a5d9d9372046d00975802c471fee14832dfbab71cd5e59d9e9b3ec3265c6b1256c2166e1606f3a0052534ab85e725f76c48c1eb5eeb1e9604ac993d5f8a4a34806a639193073f94a0f038c064467053e8efcb1566cd7dec159d4a6b425827f05f3a6723b40c53fc869dfb25463c7fa35e1fa0f837d1ab4c3cef5844c59cf4ad41382856a4086b4cbbd6b9373e42df03ba3ad7bc00191c1ae094c7b4c3bd47b291ed05c7db0beae248ac11b10b7d5f5053a4c2d11c0b392c9a6e2ccfd622a46f78fd66695706148c0ad1ad13722d5871fc0af60a6c5605818bb755dd622fd4b8938532359108b99e7f1c32d9e883d04994a608525a29fc4844b329dc3290f7db19d9be17ed0e8254b0ee1b10615fe5de6553b707638d3c8a79407ad9e1ce0243d58310c6580a8e6b0f14450ea21ddb68090c4e010366dee777f87aef5fb34ca63cb12531900ca5223bf755866ce93837c924a5f91a99e9f682dd62138f6493dd6c293a22b90f3a46079f1bd44e249890e18c0ccb496ee974a603262dc6badb9adc794b1bf40742cbe1448f543a9199abadcfc4fa657fe6acd61d9056911c0d73d28d13c9de0f5dc45520d94e0ec63f946a8c2647a3cde981dba9884e4c0aaa9b62776504f309518bd5f4231c5c4075baed1d0d9bc3bcb7ddbf0143eed35728c89e8131bc680eb12bd95edd333dfc9d841b92066a46f56f7e2ac890aa120a01964585b6bafb074879474392e81980b0389c3634afe69cac257d261d90ea48ea280c39e4ff630847ced01da03030e7b9138f1f9f48a59ac867f7b4fefa82e227b8248f4d5dd20aada5553edc9d162ec4f852ce811bf727f7b1533a90bf60d5389aaac830c65c068d99f8a93d31afba8476f02a9e00e6ed21a5ead797008410bcb4db199b7e430cdd65da2a838d26c26f044208b2b25ba932d10b05a6096a20c8612e6ba55a200bb3442af362707021b08d9e90e4b83ace871e8a93380afdb7aa82f6e7c19d4f0b45e3670309e972e4e7773a153ea1b54d181e9095ca544518b527efe8e8c3d1022a4feaf27d87719b0421ff0f429a7fe371d324f61f7f45d30310ac797598160525c7582141e904008a44fb8c3645fe5d845ee45b733c5555f713feb7e6bbdb0f8c721b8b6fceefd4c1b81bbfc1b4052790bf561e09c8da2e49de6b6ad4960704fabe3c9e4b5d2a7911d972c7c28b3a802a9aebbb772e6c50db181c695f4fdd0d9f641576f529d3fab04cc52e5da173fa1612f9959b237eea697cd2140e74490a73cddf970d5027d141edc42eb5df1fc202746bffb1b84b5757ef88b76e0d9f08b932cd83ba43d2f0277b7c24501f6d9754004bbca6f8b0ee903c0caf7969110438c22cd1fa4d566dc9197533a5629679c6be61ddd856f5522cb5ec6c5978df0e39499befb5baaacd9e94ef157289d172a77a66797a4abaf954b63e70da6ad50bdf0e15467eba478fbaec8211573ef1c08f1441c47c24ae88395c97326185da035977f45759a915b26fb4b0f2f7bb01b4a6d575c7b0abd956fd032994ddef8d054f26079c61f0e69ff4443c081161b2a43221a07bcb000c51214f607d3325b30b9b836bbb8ff2ed33150a500ea61596a37b393c39e3bfb5c9317ae954dcf4600dbcd28d8d28b8faa36b6baa7282bba577f5cd5d46588456b167caace90c6a8605ffbb95dddbc67e57a71a0fcd6aff5384d04628b8dfeb6128959e3e3dde671e0ee8aafa9c1093c9a6d139014de38793c2fcba16e9d1aabdfc9e215e60114c520b7d29d0ec46cb01918b03f4db10a918158bda2c91c54a037ac24e058fff88b5064ec3e51d6942131b2f4b421b839e117492c1d388a5bfc6aa4ed29c5ef01b9e0b7593ae5aec9637b7b7d22d5534432c5aa8c5c2d111330f91844eb386441ca20d66b8ba2236cdd425c4934b0333df2d7a0f0a7917782a27ea94fe6fb20810b6031abd57d4cd1628a4ba772fc97fa17c8a6232976bb2357f2413048b2f6411bb06554c03d1c9a48e4ce57a18b930ae2d2d713ac1a81d770d0f75f295637701f30784738b02ba87a434918d337a0a838108bd918f41484be28bda9f2b53943842099f8d9cfb91346e11270b5a5a2f42f53a6c7afe44546ddab2f2f1691c074b170443e2f58a3f5358fedd8ad310b2988bafc4233b10a3369a72aabe88917cf5a20b525857d6fd937496f5941391d0f46a5c2ed04e7b14501d5b955a527a7222de03ae6d3c950e08f1fafa4408bac96ecb979552e29e2dafcc647fd0c5d3eba38c0b634f5ad02cc147f7c252a7f8bdfb0c2aedd1b4ee74b0bf38e77ae0283936460e2ce42d303fe17571df350edc269c584eb83d4927290e8d759131c20650d7a90583480a5dacb656104363d0f99c653fb96054a68b7cfcb1c67fe8e44bcffe6009a61aab80210852eba0dbe6adf4e6736a81ea9525f98ee4f72dd2a9b4bcae4902bbac213d51d83f82a7dc5ec4dfc68935f34aa58e6a19bbcf79a2603f7e51a607a658ea9d9b146da11b71c3a8d8702bc2ad6c3756ef2728a724528b18b4783701ea17532b491c18af0e9f8c191cc6f248e8aec59076b77c31411a6ddddf87110e113bb1ee1efd72ffea1a33b90f87273dbf5f7b371543c3aebdcfc51c5e16130f69d6b9f9c302447a521299863b01068cff09a1ad4206488f11f4b7d3fd240705e18a6cd88e4be69d1bf2adba70dd5aca1f43bb5e5b8b91d87510f6f40c5b57028d2da59cec656bf3bd978a5f61146d3c3f1a1c74e9ee83a2a12c6b9385d6680bca286534ab9f24a0aaec60869c7dacdae2d4dbb061b8eac41789caa9c738a108b8b40d9acdbe13adb5e3ff3bad44ac3ca50854be9f7cced9f050abaf3f6fbc035e799b7dc1966bd626f47d8b3ab52b192e6adadc210b3a71e6e8385da557f803b3ceb065e2da4ddd97b116e06c31cd5d14811caffa9cbb38138f94fa47459b01dc8a68617a9f198d64ad016fa0e0b3a7637787c49483b66741874ee71814c00fc50aada675245f061e6fa5f9d452a163dd70415472b5da8289cae54ea74ef404acf69f17bd9a5e31a3f255824bad3926e64441b45739310e67738b04bfd25608a193c018568657ae8932f726d178290e07c6693cf1eacbef9e190778e19892070712362148b9bf4b38dd87b42324d50987b1256b08ab9c8afbd690e3b80947023e9791f53b7d0d4a99ce7e2250a364f9296b1f363078904d24df814ec2b4ff0bf12a368567b74d1c27e912eec1568a4f8831f9204e8de820f8dacb1900743400669e70e757937c4eb2e5d35a5bd2e6e71b8257b91dae80514b5930080c38ba0639ba6981cb5b6829da79a739e1b109881c83e063502cbb77506fcd39561fcc074b68078e1bb732a22e0ff27eeb14b1a699b26e34acb671ef4a8d98e2c3b28205ffe70e37a42f9a498f8a12fd4516399b2600fb6d07e75d51994bc7e5bc9df60d2a09f656b872fe916eaf883314fa5614f7dc2bd868ad8ff133ce227f7e27650c194640ff4033e422fd1febeb183d494bc2c305fc6955e3fd16100fc2ef849603640d07284c4a6d3bc6e3d3a6be53c343a5182346cc58866228a749d1536e1402892af294bd5f5ef746ae4bb085be2a2e87dc96e949d79acff1c318604dc1070ef53b0768ed53c5c2df05555fe06de870d2a2bc86417a3d8b89c4d27576573004c3166f6cef11f82c80f199b7cb10a598fa1cf50a5d1c09a37c72a0a5a1312607ab736b66ef881c07ee357855efd5c856c9480a8bc0fea7463134ad7841171a06 true +check_ring_signature c59f518322102572d1028478f5bd4cc573b817bfdf9f94d0b7bbc665ea01812f 4d11c84cdcb3d7dd2c6d827615bf405327f6a325291be8dec6e3eadba05f8301 9 1f9bfeae485428d9a1bd41e1d3cef39213ad303d0c4fa5c5b446366ec4811a55 99ee6b67eca0a7e2195d5a0162512d53d45db35428e489fb5eebb3abd08da8a5 70eb7f34cdf3f68ff49dd2c4877f95b1024c5d18da8f69a40a224ef38400b727 3f4d1982531fe9fe1f9f6fc38dc46d791a269e474966c1ae07d573faac9ac11b 9b946bd0c2c8188c2dab5e6ebe6f443b2c02163ae8c4477ef1165662ddcc6280 42034fa43b620d6d0fcf8c6019a7104a59c06706fa82170082120d12bc9a1390 d5ff6ce764f0843ea8e4a420327f248652efb708f1847b22ad00cd2e3073bdde 3137229a498227d3a116bbc05bbc8b0b6c8320846b5e6c61bc3b28060413f979 7962d1dc9bb2835f7a58ead75ed835eee29d122c3674a2ee48905bfe60423b49 8b2b603a86c86de84cf6e7c87e81913200252758fb080fb1351134d627ea7f0a69185cd21b0bea05d84ce8d6b012e3da40a7f748af7a6c40400a77cc4c6cda029f7a03d20068e376ad21381f981f96c4e5239eed10fd28e488ab8d96b868d8000ac18c09af3294aae8945dbdc48700f101f96ab032bef1f46ba57d744033ff034fc891b0b58e38d0989d7da97bd270f08c8a4514da703fb0cf0fc8dd9e1c2b00fb3a1b7658ad9d4a5306db6af062864639eb756c00f0d8a2d3ef53ddd9e1ce01f31c27d3e199b596d79b1371614bb8691841fe701acec50f839909c5a4c10800030c5082a23b75d5e31b8f72eb7238d5c77856de40efa74ef384ad731bd5b80e7151a3145e0c4102d07a35669b5cc8c44cb4939b7fed207ea430113a71626d063215d065241a2a62fba12e79eea46a2a99b815035e1df2db809e0284cbd79f0c9985d8c9d52c2be9305d261dc2320bf6aebd5efe741144fd60c32e7bb21e150697e338f73c72533ae80da03b7d009328a216221a1cecda4bff0c42069120eb0301d7258a0d93beed36da95118d361dd4d80c5425eb106159a37b803291cdf00143570f3a63ada84e7f7bca5d5d70574bd09508af73d70048140f652a5c859e0b28b4c354e1402bf65d0e32f1ae13678d71d3ed62800b9cd284b32c029cb94d0cce477bac3b6c0506668b40949169946b75a7d6fd811c5a7737103a31facc2307a2fe739d8d670343cf538a694ea61b47b01b7e62030fc060afa28e8fe10273084c551e84c297ac371cc2062c560576e5d71b9a6e3aa02c4b05a5844bf6a61f02 false +check_ring_signature e287af7fd46e917d98aafc65ed0e10056ea354d9bf2f75cb812840e7c5d2f7fd cc166532968de6985a278feb15fabf0c60835fc0a1f6b172f136cb9d0a356720 2 76c77d913d248f51c4c7cd59c1ea2f811df57fb882e702487389027f9f6695cd 152229d5ff1e5cbcec04c362444e11779d06e5fbd959af3c083384868036522a 6fa6ac0994de0346c7da4898d9caeb448b6769cbea5a3c1268884957debd0d7ef334102e6de805542588e562e91a83b553856e7706d755c8c75b03a6cbbc17cd7f9e87f868750a01c7698ab3e42f3680c0fb6f690a170aaf7d322c1b73ca8ea1803d26095427dce2fccd359a809dc41a95585ee1111607b804445412ee41129e false +check_ring_signature e900797f25b4c75d78ac80b3a5daf0f7c860e8c112f6802ec9e5ab241a9e34a0 0fa8872a015b105d31d43e7824681b300271aa97df1373c7faffe735eabd7fc4 17 0bff97d10ff550ac824e8919f73bb1e7de5dae97f954902fbc13f07e2def6520 4c915b4681a663abb74e701ced0cb4eacb82ec970cae4dd957c177c63f25efbe 7cfaacbfe04a6aaa53e30c090b40845d526b821c553162ea044a465d52b58009 518207184a117714fd76765ca1261923a2c15924ecb7110946b411351ea59ac8 5dd1cdc779fd26425c5b7a3514907ee5dba7f4a13ffbfec74c4a27cc63684586 ab5a0f76fd138f410011c47fb720a3e077071e416db0334b2748ff71a73ff241 b8ded53afbae36905eacd761d8ccac6703b5efc79d6ed80030768d4ded15482f 139c38aa303cceafcf9b6a88b466e4eb75c703cf0b5e944e948f1128d934ab6f 5aeb61fa9f96ca5f534ee2dcafba57ed1682e9575ae42ed1a6738fd08662fe2b e33b768494748d637ed67b09b6dd0fd298e789e5f19d63329412b6e5b62ddfc1 2358e2edbeae1a0fcd81c3975d751fd9789701d179fbabad51b54115baf40b6b 4339f4ef70eef44c1d43357ca5368645d09004d554f73dae1ebd98c84c4cac30 cc78e952a9eebb6b8b73d2d6d7bc74d22cd36453ad093f0568de77924bc646e9 2ee1b18a62eb0eac1fd0c35034c82a40efa342aa3703aafe1edffacf0d37953f e21ec9b038e7a09b34957174c3551f689eb601bf7920d49a71337df6017d5f7d 8bcbde2dc9ec8ba6bf96c46d0d77df9521320176b8360b2b22bc3d98b7f5c9aa a3692fdd666bba4adced26b8edee579f249f00c0c2668e407ef937170979ef37 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 true +check_ring_signature a3b3d1d8500ef306fc2bdac3005f0d3fab5bd655d3b30d4083dfb51826f0ab77 b864a820679bc69c9abc53f41e185a96b0d9abc63bf4b914063ccab5e883ae34 30 6c3f54b8a67341974efc6d4a644fb6e6a622e7ff0402919af19cf28b08a9bfea 24f320013bead0beb5fdbec24b9c3e3caed9bc98f080d286af0daf1d7591e6b1 1480eca360d32bfd61bf26bedaae60adf93d0f2288d7012f8966e36d61a9a196 7b11cf67f8fb677046db8faeb0c556a13523d9291cb27eff779fdc59e977032f f9ce9656c9cd21e514329ba6b3fb9606d77b19890a8cc69ae76895443025182a 6ccce3e8202e1d907af01fb9ac25bcb9e85e57c79d10c1910f16b395b7b4109c 6b807a126cb4c90004e8605d15baf6bbfab80fe73b01b44dd10c414da3adcf23 f9e220ae3bdbb30faa05306d37204ca5e27312c8e1f5cfb15c0be3b764075bb9 3f2046154f98077667ffb8831b838432b6ab25068fd9c0cad3038cc019e46623 fc1e214f2fc6dc8a007fcf56ae9ed855e735e2522887348ffb32e3da301a89ee d6d2d9c6607d7bba81c462174ed2687afe7e70182959f27b1dc32279173e5acb 261582b1316753951b4de9759f0abd10aef44d29b07a23ef1125df198c4911f6 8500aa70f775d722f1ea5ef88a2aababe50e894cd2944f38475bd8ad1b9860ab 1172387ec9b573a7d8e257f218e2aa7303cd43a3d4b6c48e1d16d423818aa746 1ba0ae5af3c5cb70970ecae314e8d54669f7da50e1f825ff4edd720aa7938f51 3362252bf90af2ee0da1bfded980ea272b56470e68d111dac0e2f163d7379cea e1aa85a4d779a769ac46acab2edce864b7bdbe5ac9b377578b6ebf99f0de17c2 a7dfff79ab674af4b031feb48233c9927fbeb336ec673d8af8e41b4eada60354 3382b996b6aec0266d46837558e0522a0302b0b1871a9a1daeeefdc848bfc706 a3f6434b1196fe613a5c25b59ab090c379f3b3da3ab1482b2f56500387fb485f d1057e759b40cdf34dcdc77bc390a2f165691c57353443ef829135f9103b368f b3a5aafa814aea5dd3baef1000218fd817b68a43f53e41a3ea48b5ebe88a0196 00abe0ac88ecb4bc95df5b5668bf1ba90e93c083f8a9d6c7bf225b009dd912a3 3c7c7514a6c2a6502400f85e359b535b35fcb150cc3a89b307d2d872d77d6776 0e08b181cb586641ff57addd561e015295a9bffa8e9017dddc69aa7541c4ddf2 6d54e0c9b8dcf5cb95ecae3199048ac87c5170ca639a6db338601f25a0626e17 16de0404b5fb05a552fb5468afe685998cacf5d5f4de284b2e1ff9761d550199 7a7fe658455646024bc29e3e01bf485a83cb81ace661481dfa1eab92e05ef4d2 348ac5b1a739ace405020899208e1696bd5049a974adbb17ca07cbc6e9010a9b 08ad0ed89ccb6236709d0ae87a209f8b7eda6a166e8b5def5236dcfa9d64e7eb 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 true +check_ring_signature 948cda01dbde115387441525942fc4288e41fe1a2d72484118a18710e5eddf01 6784ad4d2d49e4396381c9b2fa9ec7a0b97f0edee2963ac8a65a56abc17fd9b0 39 64090599832b108b9315cfc84ac4f68717b847aeafd22cad75b7630f8542dee4 b2e5b89e807938c6d275758d60ca0a37349221bb6310f023ccb1535153b43ba3 24d3533f282eb96838f43b1a186562a5445f9e7f660e260a267b94d45b575563 6f50054c99acbda4cb93c157d432a3a0b85e261efc8b3881edd7412076c37ed3 36f25690fe54aab1c23450203855146a663146ce7d7fc202195b7f390382f5c4 3e5560a9ee60dc6f1f28ebcf007bca95bef4cf0b5ccbc1ed5013e6be42702058 17f69edf9f821e2bdf908602c1696edbde994f02d2d89e9f96fc9d68ed8616ef 73531b452a0759903f71cdcf1f2f6253adf8d9af294faa4ad0e6011bb84d0df4 8c3bfa8b24bbf8232f0c09b96cea89b0457067d966e26ffa655230fca9872d2b 215c10039c3b88d43a02d3e9298de935b0dc10e9ca6d5e2c7a03785e983f82e4 3b5b637b9cbdde31de0e5777deb2f4fd833061e7c0f128ff43ac08d7680ec65e 41ab923393f2c1703d4e6dce6c68100f0b8f653dd3745e5d536308f880f49ef6 c98157ab09e414a98f2e4faa042f6885b1a9d4257798cc3683ec7400fe90439a 513173f433962928934215b9cf0408b97132ddbed978bf1cfddd13d0c5f7c851 e80e0f070577da6c9ecc49d56913f894cbd139b70b46835a61c67fcd9380416b 492e40d74a024ac5ea1e77d4409feb2b8a40e8eab5663994be9cee0943f7269f f1a75e99e3bdaf1de23243986738ea3ef399d815cea5f89fbbb1113529ea57d6 95a5d0b66bf982f697cbc98fce7ad2df14619b7e0deeaecf9a3d78c96cfd81a8 05eeffee18f082e7ad08f3489f325bfc6fb2e7d5707b69ead8df2c25bb641bfd 3d09a3fe4678709acfdfdf31d6380a1899f74a15c5935a145f8ff9a483bcb152 9b143d76454e7a026ad3562daf6cf43026a856cbbad7002a34d29d3b8ab3996b ccdae276fcfb73b7335d10d81215d9690314cca2d03257ebb45e4f3054df2c50 ba199c279e73eb5a2086fdacd3274f710454e58ad7a283f35bde3cdee84fe94b 18418b210355bb214faf58e978a20b1f42f21c05c9c43aed5d431fb89f3a1ef8 f90191d5daba2b26928c9b2bb54aff71ff13e2ce6ae75a662665b7314dc19909 9276571b9cc823f4a94934e38bf555c050c565b5e9309ca3e01375caae68006a 87d5396e09b92a86feaa7fb59fefba07226f6fa4d6e233bf2207c96229235ee4 5bb87c2fc8ce17bca40f76c554c0e5e79197c5eb0ca5776ac7bc7716ccb16930 1808b6cab44c5ac007706995173c93b85aaa49d16d638f5e9d78ad50b8738de4 c735a4ca5bee1f2c1e9689e94d7b66a77435d9c3cf06ec8479b135253a29d82c 141849214adedded9ed7c72d1e2c1d37bc089f7ceec8b3c2eea5740b1c0aad3a 044e373335863bae65e09576a7fbe10732e9969d8286c75ee84df115bb7ebcfd 5f59f9e717a44515544406129ca1c997685c29dff93cf5e0d8ed0c9daa005788 c47b97a2a9b0e5acda113d5bf6822b3c909eeed20ee11ee86c3a03b5f83d817c aa3ac5409d620589bf3f34fa7ed176b9af8c3c6a6cce7739a1f80c18ca3938eb 1b32db4995b4204ee0c68c6decdd864f9098bd6fc940a0360ff419fb271a2a2a d10fe0e4009f962c8e228152f9d5faab1aaefb4dc6b80f7ef815547217ebafbb 451e6c847941fa6a746fb7fa736ea1127505f818f1ad3d7faef45d68a549d33a 2d03247168eeff5afb9f27a214271cf60952faf0f85864fc8661810bd358566d 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 false +check_ring_signature 710bb47fdbece67849a69db2f7c1f14f7d1e4dff1c3320d65d80837baf11f7e4 37b0b9b0e48f9e013379674766be196e16ee24314eb696304525939e6fa98adb 233 bc80069d681505da44b09790f40fb8db965f99c287d12fadc43ab3fa3b75ea53 3d4fdba1bbd09eab73ce3ecfe604993f77447bdd64c2ceba15d120ef02ff0d32 a3bb3885f01313a1369da0953087deedc986f00b67cd31c17aafe9bf6e195e3a faeae6370f12516cc81b2dc23e46bf0e7eec21c85c44c97d63eb773a8fea1114 1b181665666f25851bd423a4a3d3b1cdf2ccdc6a8be5410a61e8ca9ba8e0704a 920acee59bb177d41044fe00e5ef566643d8516f41375223461f4224219496ae 38d55febedf03c5513f10502c9e7a6b16905a6341b667777bec3d7a266c6f14b 17436183d3224d199159a030e175e2e018593eb600ccb242e9d34c57ee0b2d48 e877d5ddf68802761112abd04e9d6598ddc13a62fa7a21a1244cf79a4236f79e b36e2445cadb94cf9d9146cd9d4a2d28a57735a07cfd4d79f8e6c48d0b073afa 77f8770e24fa7cd2ed33752c18f57214ade2abd4fbe8e8aee901611c5d12499a 3ae92994f4f44bc321233c2ba9ae8bea127f09ff53cf9ffd4291bfee8aa29c14 80e4ba8936fbe4dd755ffbca7f2ec7002aaead35c8118d2c774382b1654e7de5 a9461f068a75f6d911af9b8063c2f0b6ceffbf90becf8e4c13af1ae933c21284 8037140793103f6292c21761682fe7ada52c2bdcab879c02a3f35be691d35019 71031060fb8ea5d3fd1de7ebec6f70c3f197ded26bd0c75fc96d9b35df664f8e b6e575112374e810e1e472a921d905fcb426fd559c5355745b9b35519ba7a0c9 196f4e0cc968c423af46f1db95ec328408599739e49cb6d5e4252702063e408b 4205e2fa9849e104a2e7ec0a538165a49e582279f30dd3a64752042b3c00d7d0 92227f334cdda05ebc6f717ae77e4acbe2d120453253cc86d0c5fd133fedd3dc bd174149600c274d08cee7a567ec376ab5b3a5f562c1351eb92888358c05cbec 88ab84d977faf5033fe80b80627e3d08ce2405a34cc910b2b6a54350c43a8dbf f1d3f7d4e113ca3c9cedd6010998ad257ffdc2af5a2363a7f02053d6d0e3c9ee 1db8f97f4bd0eebb38961ec4198254dea9efc2e8ac01e496b59f37c3fd93fe3a 1a2b88308e1aebe051a99b8c87898d738e2983e085ce42df2d2fed416d2c26f9 785e79ee81116104ba239583e12fec2aa2b1d58ea09c55c90509c4885f07baa1 6c3c5af564cbbee0c05816f902714db649799f387836675b12e6da4249ff4127 97c154a494259a834039cd7aeac46e436f8a398e222eb93ee3f7c45d2ffb7385 6d1007cbe016b2e2a13fcb2670c37131de1136777df7dd7492dd63952e732e40 b1e72517b6dad1df31a1af9a62eab2c55010dfe2865716a608d8fda9442e9c93 9016083021d03ad07cfd059e4bc7082bebadcd0d54f9a013d851795537f23ed8 c96413c3606cf6029f529d2b617285e93337fee09f861f34c3d9593cb009a19d eda607e9f3b42ccb772333cef5f6b8f0defe6e0b896997b1951cfdbbfa501f5d fafb72540860d1bfec37603e55cac2045fc8020eaed4568f3a5d64ee9854b963 9e4eb16562602878c14ad77a8f19cb97b374a8c61070dee8b742064859890c26 0553abf139a1279d0683364122c49b6f947f2412b3af93f53de949afed063a6a 913b50d255ea55d265eec418e7e57dd466575765d5b56db4217054c1ce1c1277 43544d15a86efb90738321265ecd14da46de33a5a6353eedb3f982f71fb80756 ddeaa9c2828367abe3a3ca23df18c1924e0cb45e530c08bc26dde75fba13093d cdd0b203391915502d7e461baa8209fa53c6789b18f9c6399712592d35d7dcad 2f1c754a6f89b98b7b2f18e3179f68d62ab78f8b708c0bdc93804b2b888d4742 b78e2a22a31618c8f95ef91d69c82e3aae4f6ce99b0b2fc22cd59eba79a8ba2c 796bf603e623ef9720be0f1f3015236f1782a1f3c9265b6532e16d35b00bbe90 7b22ff7c4b7727cbf6a17782793dfd697c76cfc9a8ef83e8b64e4af2437c4e21 eef8f90de3d94826e2c7dbe26bd983cc9c927a94ffc2145ddfad3b22eb00f1bb aa2e27ca4f1221c944b8844431e06a235fe4490d947e61709e4c6693f9002003 53d408f10fca55711e9fa98d52410d935ca91400e060dbd62f185f25082e5c7b 4bb18f29885abb5bb19a4a411f821f5df8ca89038536ed2d820a667a76cd4045 66131c1711c5bcc27febf77df1935c017c7777302f91ba1bcb334929e0df2057 8483720b07f73b30209af4899255eea94788ebc22d0f3103e6c77efcc3fef5bd 92b3c6762a86351fcb6b4f54eeae34bb30dcb9c4ddc17439768ce0c1d401cf43 8d0cf24563b1b62ebc7b7503787db7708bb09d31bad3292e33497812aa6ffef9 829c31c2815a9eb05dd7650224835f33aae76b10a1faf515baea1fccc63417a1 fd61bceff6f9859eb7cc191b1f91bec9b4ec4735feecff6b80256b879b15c1c7 6630374869c42f865663cd5859f1e4beba9b8e383d880fc53106ac5383b13c34 f5e08a9f5dc42c23a55c950eee107487346390772a5d1ceb67128d5650d77cc3 4040efaa07d24b282159775d48264b3c9a7f20a8afe983ab52e050a1ed2be158 fd273dc9918b9c53bdf11ac1dc21cd75760e28ff353bc03a8b8ced7773ab5608 287f9c4ce94f2f0347e1ec33803098a620fef03a381b7ccc4bce055a722b952a ca03950ae767f48cabee7187a59263372baef4b0691c42a34cb6c9d56975fdd5 1ac0ea8ab63f1ed9094ab009bfd3021116fce35e7e3a7823f34153b1e5b9e376 4c6d5cdf25d767a3768026d25bba3cf97fa2c592454750d9df3a52cad770b5b4 ba1c2d87572cd99b8f08463b3120d36f8fc1ece539414e03182a1824097055a8 1ec0962b71aa55ab8f3787367b51d8df031cf21e8b2f14b791061a335ee9a0a4 d36628a8ddbd7969ae0de4efcc076eec1a335a22f474b01a9a09f6a9723dfb4a 97d60a303e7066e111cbc358c23912ad33e544c02e37fd7de74f810f72558dcc b449a401d23bffbe40277e878b88bfde15c9c3cffbefbf2cfb92ca34981f8007 fe9d1ffd44cdf777e9df295e6a00e249b6ccb60756cf52602bbaed7b4927dbc4 f2477cda48c4e185998b2254a5825bffaa62508221259affc1f84df7fa87386f a5856e89e7c7dcf8de727271c11689ca32f1121b74f4fb10e12002f4604c5051 b27dc709b21fe9c17e53a88cfc024319e72d21e2117579167147549a65491826 8249a2e462d0fdb90158bb9a12472a0da93583a0c5f2456e31e528f0f4709d30 04e3fb91f5fea493bbfddfaf61eb5d17073c873df83e870673592ea1327fa3c9 d369055c1b7803b017d60eba30c2762c6c34706db5a46c1c2952577083f2307e ba225d5a36d9a157f6d9a4759cb1bafba8ec88b23c7151bf1f3c9244ea757e89 3b098683e463b7338423f38f6b6cca35c5126176ddba65b1f85170765efbbf29 cb6d471c00209f4c3186873cf37485602e9edfcb077d4681121e157ce728ee4a 90a62c92fb669aea4ade00bf311a7db6555ccb8b845bcbb24a8b54bfb39e1cd6 a4601ce2f84739339187a9c21d3417fa20972ccdb0de2a9801922a17ef504f2e 163aa59c95a7b603fca195237a5ce1fe30440277ff039a6eb0b6bc6d5686223a cbee74a84e9e15ceeea58cd42a627a32cd117df17ee0a9926285ef0ed8508178 bc8a2db70ecdbcc8a421b31e37c8f677f0e3d1e76ac8c7cbf97a5cce59f1b532 698988dfc3a6069ef2507f2ea164a2e0dcb8924edc9c4f5dccfe8b9fd9e9b8b5 e1b8bfa048ab935056baba5ebc17b567e0152dd4cce9b9b5105ab5f8af57827f 3fb4a406fd381705063b0ac930720b6c20067d475fc502c182ebbbf32dcfd137 2f49d0d33769ef690b78e3f2196a9db54f891acd1628ccb58a629fe5e8b9e700 1591398f5b3ce8bbfb3f891615db4bd7312c1daa29cdb7aed4aea05600679f57 6cddc7b0d0f3044e4589beac73defccfaf03517b5ddc8122b6b79ed92f911b3c 3eb795362dbc461b9627fad6b5d882439d23d0d70da406b54ad54a2ce6e5a9cd 2e6d7a386112f9f71919adbcafb3f332ce5b740684b6f5ad34c50de50ac2c62a ce139880e5eb648e6ece23d9b193456134280ffc910c140848e5ffbd5f55d444 c7b008eb8965440422b416431f328c8c71c7f2ede35d996174180776a319408f b132a44c95b5eca28ad6bb5d987a411f4efaa845c35c7b977b285f4b6deb7419 94968558fafaa4cc999d77365ec6d8e28f09225832f95214b9f6d1bc982fe0e7 823dccb4a7f2fff08e5a7592bc135e3d8d2bf20ac49d51083d77976bbc4314de a6fe307b1cd06c75c19973f6bbda3bef0bb4a02f009bbc4badbd93360c555a21 64d378fbf09996fcc237da28ab6ab765b764d1b869e218f3752a076e05f24dc3 7321f670a09d9028329422c7f80329656864a6bf0949807b2814f46fff0a025a b6aa384830be68d59ad9e5d0803bb92f8b0314762abd2439e4d7fc4180399ec1 6fc09f62336656cbc5b1602216b9b7669067d894a6fb253c591a6d63669f7255 41d4456419b822173dd088de3258ac31ac6a2e0f3c7b6ec52119a0ab39d4e063 623d4560a075a6b703ccbadbbc3ee2814c8bd7999d4a622d4cdc6527eac922c8 22551f6f1a3e33c51e2fa8616d6067539d2e33cb2ef11edea71366501048debf 8bcfb640cde6df5361138913a0b39955b5976e6234b4581998a0f75f70dd6c21 8ba8822579563cfd832491008d4768a98fea5dc1d41e83eea46cc0e19acc2288 7507b17734cee1d9d053220f569e7bec385b67bc542adf8b465aac67d7efceff b61afa746bf5adee1c7c0be9d1917fddfc50444ae44ae002d0c9ae5bd0a29ee2 c92faad79bb2bab0e37c2694d2812fcac75408376b922ba7b1c509192d0b86b3 34196b86d6d5fb7186ff79f795771fc4d49a7b6092d554a84290ef12f02c3b28 f5831d627338a43824855f99b22f44c5a68d54b48485eb0fa732916d44bf6850 e09ba6b0af925a995ab23c65934baf9b3b2d07aa41fdd9c5522665536a88948a f9156019300701ba407ada5b3407a9149ab1fb40d35ec4432dc03fded389c39a 964f886c18d8e2c30f895f5f63f2f22afd66a9c4629cdaa9c465b6c41d89de21 64b941c50d337074a9e6a45e38a0dc80cc94188810e1072f70c99f7e45f9c852 cd55b2b9afa0615fcbb8eefdf718592eed4a3e19c7d7e2a2d1005e77bcca8638 71a68bbff0f53a9a139953b8f81bafb664ce15d28da962e313531eb73ee3ee12 4985706bafab0647b6de2e5d6810dd248d15c2269eb28efde2f6fca6873d9185 35ef4fd27d3ae0eb01781e8838c9b814e5bcbcc065527a7ff83c0998fb6cbca8 f7495304811ade10cee14bb9a4c7a3d1eb0ec7ff67bd4b2758a2f351e7230fba fdfe233c1daf78c1304e3f3b98c2c20fee470c335f3849dc6fba329f15b62216 9048ea3068af74a7e0bf75df17eae1e6a9a0e0f63794360dc4aa216d9a05e1c4 7db6dd7d8effe4b4f1995ce6e64ee81f0062c7677634592fe537716b86e3f767 5836013c742731f71783874f9d3f89cf22011221c4cec79d4f57dcab948988af a7a0f45a1e99da0b191cfe25403c22161e14abeea6d0dd8d484892a0c084349c 3ac50b04f4007da416a419558d518edc4b77d1310021a7b96e99601162817e9e e2024567815f211c571292fa15c79defe39c9cb56a2c0d9d86341848e6968c33 8572fe88b876f46b5f63ae31e1118ad4581d14b4e5cd9c6af76a383965929629 a0fb3f48870d736dd8fee14017aecdfb090a0f022a0af91e723a6de88439226a 08bbdfc4f60470f196886a7a32b902ffacbf748865d46b031a2208becf56cbeb 421cb011f216c25af06bccdff322bd8ea0d9467631d63841a850d2ae9195e123 31013711fbe2d0633fbd242353f9c5f9e732ec16027bf6c5735de2954f589cdd fd9bab1a0739e42b61eac8bc1d2265cc1ab36d6b499505e53485b7e04fa78c3b f9f2d7ea49a800d2e0510fee03cfe263eea5ccac4abcac3f02f5a5c8d5fc825e 598f65bd3008737117aedb50b1799dc6979054b87a19f5237d990f747992d14e c039e6b9aa5fd57045d7f5f9e2b4e6c38599c2626e815e3e2ef8621450dcdb6d 8ed5e094a77e670b51ad4e122d5dbd9986fa2c9b3a289e6f61e0fcf1eeab1ab7 51d428440d74e0b9e502514b8ff0c8002f27091f49091f1b335b4caec87ba22c b603a54b76d1861b02c2e8c8c23054300f76387026e50e67cd2816b1ae4be42a 0237d82cf2852b9f71f8011d77703afe6d8cfe148e96305349b45de9ad9623f0 db11dfb2ed9fd7f0eacd30b232e7242552d33c03c3911851dc543a2da6a91dac 863946ff290e26c9abd890fa71a17fb3ccd6acad35ff9af0ac0ccfdd4d9a6f6a cc8e7dd9f7ff797064a53f6d5bdda53c2a6b1cca8d3e9804d3d60480d2e2dec8 ecf658a870185a2cd506811ca0836ad198538575290f89df07f9d2c82169a586 d66034b8f6cda398d87c5fb92464e8f7fad4ad094d498186a775d1aaf888216d f945c6ecb12e2a0691f8abc3a786c11c6eb286c197f3cd9fd6095e1bc07760f2 84d8d4e634bc87af076d0fa6df175f15a6d95eca004e28d7008909948f9d2346 7b609bd02dc2de23e9820c5a7c8c56970aaa334c0e0f791c9e14c67beeea4299 ac24e89634d6f0bfb6badfaaa6af1a970bb76bb53fb67773f3235de5bbb06c22 9c06d1d647b2f8e291923f26f262f7a19a7087799b24c14c6b2489c82b3ee498 12db474f3de60cd3824467e72324cf7281dfe249e336758010fc8db585fa6791 dcebf80824a54a422662822d7a8ddb8204e0f66a923132c313cd88712825b30c 4660487319d300f527d97fdc19a9c1e8df2e98813860161b0a8a846b13901aef 8ad7a25dcdac0593734f27208e78be08f1ce9ee02aeac60e988e6a21602cf1c8 f214f4bf80612b1445bf0493e7e1001ec1ef4f4142e3636af49956a2c7fcb0b1 956a212c13a3e0dbdb8e70fd5e149e27b3458317806c16407e7b47143dda7559 5fbf31270fffadc19c2582a9e3bff376af6c76205ff09e85fef2e890dec09669 ee69513a9326e415715462e7d0e1ee5d52997e9b7e3788026503a6e34979e211 f81f25f2d21e0e6fb67ad60d2b8ea9430f23715326ed24e278a1f8dd6a0beac0 757c75c5684416e1e6d5dbf88b2c12abed435123a7f5fbd9d3a0f05c3cfe3f91 9beffe91f4e5280defc3cbeb2a3dbf73a782dbe3d995fdd680b9433917073b9f 7ecd5ac800a544103f4de7924d7f8026dd4e8e2693b8b77ac7980719257e8fd0 6ec4f24ce362a8b3a07c83398433d6b55b02bf1fc9637efe945e111823d15fd9 e917dc611ea921cc0894b24fe413e130444a169866b2898e5dca78a6841fa605 d3a40471d9be9ef973fec68724fe89906b27d7f829c517e2f1e5f16751d82048 0c98fec68782332f2c02a8815ce0b1bf793c2bab6858c538d1c8cd6356b02a1e eef1cda23d7cff9d938c360fa2553c5072e09f328dbcbefa10e5e99f83e1eb26 cb8c581bbba12167dd1713bae8a7603633d68e5a0a86fb6c917b2a2d097bd6aa 49102bf3609fbc259bf4d6a4dd23f6b16899ee6fa7fcf7cbd0b80dcf42b84516 579612b110e3bb4c3639375a516122ced9967418b0967ae00e1eef8ccaa5f42e d350bdaa74b1971f81c85c18e230ebeb33e429fd25611e5d17a381217592a000 1f1b625d8e4d549dfcca099bca9f802ddf241d869f215222b30659e939757aa6 d925daf1db3ef9542dae9a8da9d6d6d36be276a6cc15e779e52ec12669b6da0a 8c9f3de7be0d4ebc1116224a09fcc8d90b1c266b3b1a794c006d47e16a1aa970 d3435ff694981c34991376c6ddc6d6b44553e4bc7a091980745366235b7a15e0 9f099b99a8468b043bdceb15eaff9fad673c87c8fa2809694744508cd7b8e02e 9c7551b9e8e4af5363974b50dc29d8fc2dd97a3a7e0c122570d76dd1c4af47f7 02ddd7dd7d4713e664474232786f7a32773c34d3fbb652757a185e57c442fbad 5815a99efd92de9fb15ab3cb75b50fd0b32ec312ab583250c19e9d84f4d5e045 dc74fad1e8b72004606e40eabac2b60105c180a11246bf933eb4db2c2b5201e0 81fd463e5da413b1ddf2f85caab4e6d9347d3b079604c426ebcfaf7d0433593e 9bef235e92ea461d1c7ce4d18cdb72774d67d00b70173d4064be0a020d650a4b 877a8ec853b0e2678f2f30e0846564247eaf96cb7983370fc4c58569c9331b0d 3bdcc66efa5b647ee39492b21cd53934fd60a5aab142213d541b3d92a443e1f3 b6f9c43605a8710c58ccfd305c6fd2f8fb7bcde913f2a73ae970e2ad810a26a6 fa0dbf029d9f0fed4e5940da174a80510e6d9586940c7157633baa42b203e854 3108ea011e78c25dc6aa4691d117b001c31438197376de607304909d4dd00823 aafa8c03346d29649c0acf87a3cf4ee664df8517dda7a55f9297b05b27a54a60 9d2ed2daedb4261c0d2fce8094ff97a7dbf86878f3f97f40e215f4d1f0bd3358 1fd69e2dec55529c890d154fd6b66b5608e208142505692bdb65d0e51715ea3d 4acb904329d38e899d0f9380c262a3200d977b0a6452a08bd511f7b10190d173 5af548b17b5f25f935343449879276df86a97ff58e1beeb55b966001abf0cef9 7b43a3a6b6e7e6fa2b2ff0745e510364b7335228a75d8e5d37ea72dc1b040e16 8d097028bd633673f969599e02730f6574c7c4420c6ca43a5e81deded730a3b6 c9f3075c9b451cff2754f64a382e6885e81b26cd38c8fc28fc9d096005ddcc3e 417fab96b01052ee9028a2a2bf9298687a95875340ff1c1f6048cb600703ffe8 615b4703e33b00d4880dc92eb1f636a4eed4c08cb57713f72c5aa3f82d39bb2e 5d45400938dfa1f1ce9bdd8bb907e83ba0bf3a77f2959e554d9ad36c1a890c34 64b5286d485b6df0de9c0609849fd33bb69f45e4ba9dbed5932768900ca8cfaf d536d848f44f3513e376da3a9f7596ce44ff0382a8e127dfe8c6239eb814b076 5cc226e4ada5873386ebdcd27bf67314772d11e7b5e7d6092bcf24f5c8b8bab8 caedac96f88544fa6cf59b4070fe7c3acc93a7ec9b07fe4eb04988e6b8f2937b 0e1e60423295f8ed86465c9d2d82d07cd8ce6ff7508949099413ac80a482ea41 8663e84e3545282226e9c6f4e8c6ca8b03baea7ae2a3d9901e73e9595259a30f ac8a1f386a3c18e07f45f600ce5acec6bc65f9b74130fb31033df01fa5081732 6b1cc3c5a576cc1566fdaaa17f2069a719fee59b0209e0a21a38d3d38119c6ef 38f7a0aba1dc2b623f93c20a09fb58adfc0745c25473a17db784476cdb00d182 ccccba85acfe4391cfc2c6e5589a669e6adcfa91d48c393317ca77ac606f641d 78d83f7bb8489f5d152e42fff1e4e2a1c9d2794606051fd779b77854332f6578 212c164ae9b5fbb7051a83cd116cc8215ca49d7ddb625096f06bbbdb12b51014 d280ef2f72910337d75b0786bfd050a4cffde28b899ca6745bf2ab716f6275d2 6e586b7075d7cafad4aff12ea7b991ecb47a8a5d808b626d9c952e190c72b890 05c5a5e0aee0f1227208ba7d85c1591a1d36e38de4918a3326a5a281889e63fc 107de4f351829397b99ad7f44c061d4d00ac5773284a6964e8bcb9247d4159e9 6721e13cec8a6030f83e04617c8f2cec7c92e533ff059a51b5629a9764fe8fd2 251f165ed98f1880dd7a3d9868ca711e167732cac5218e1c4dcbcbb10d131eff b7dd24a11932656fc860053236033413e0b8934c8462fbe4d58b7ce325977603 69d4b106ba61e62961134957a8cb42f4fbd7ddc1f77cce8cc9608e7ba7e2641f 541a16f43bfccac4adefa65341c5ce9f922f67a8231590cc3c3d3de29e6f0e53 f1d0784fb3912a16b8b081345848e598c0792e7c3602048f777044b36d0849b6 523392921869041c89ac0d2463496b089d80a70a319504fefeeacc54a50d52c4 e2df0ad98909b9505efebca9694c95aa96d5dcaf88b062dd14bb1765f49fa080 47f22691794b3ab08c989e339cac130bf260f8121862690f2abe39fc552092bb 3995e5cac379b534466628bcc9fa18445df6608ff27b864d4906bbe734b4179f c65121db8d5e829415d1c3afedf866ba06150e0431bafc096ed1e9f0dee0a439 b7ef82d8a0205f157373a204c5978aa912e2f5143ac00f2402135d091530c0d1 56a7963b4a26aa3d1306b5b9eb9a34c9a45a82cd4365d512d62d7c30643f8954 4c22da178b9f8ed1b50231d57b62b2cd996c95344694fcc0787d9d832c6d24ef 1c57626ec57d88867fed3065c69ea7a2839c6800305985d3b7b867be3378b978 0749b871b45c1f8da2d843067439018f4f20f26ee241815b7d0bc521b4d0f078 67a4b61755336a8d558ff391b2e33ceae60071e977a2f27b5778654a18db2245 9826473df20d0f16f54b0355d48de41290c306e8bd0acd8a134dfdcf88e2f91e 701fbb7aaaf9a3bcc7ed0c9e75ea4394171a70942558a7de1720f851089d8fb4 b33b4703e92527a7cc3206aad9e6207aa00a2c38b9acbc22a9c112aaec565a0b 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 false +check_ring_signature 4b34aa0e8fc5f46e602b2f228fffdc0dd367fd13fb15e38fcf873f1693742638 9c66ae886dcd58d588aefd2a95645fa42ed1a22fad147dab7295942c05eb4b9a 1 8efed99dff83cefbd08865aa49de3e18485f30db83736ba63d4b4ac58fccd35d 5f1dabcb2e6530c860637276c5298fa410bce182c3be1cee8e8f8a3988db3406e8cbcebcbfa2d59bbe663772cb2a6f83d3533445db720fdc1b42fb2c26d96405 true +check_ring_signature 23f4ee5db2e4b8f1adb4cef0f6fd4eb45b4f424cf458abbc5d89a8491a2e16bb f58e1cc5cbe5059dc512b68e4be623ae56e8afae8b9fa3e4b4cd2db9258c7d00 1 d4d0de842a6269a1fd83485708171e5eb51481dc87877932c5798cca96e3d7fe d77c127b3786dc85701c00ef50e41e96515af68f46649bf17665d9d98f228900d74d074a712265a817136e0d4d954f066085fe88cca624e29ffb0c95cf1e4d3e false +check_ring_signature 729250457246c1b17de11cb7a59ebe9e7979062a8d9442beff5edaf9462a24e2 15130257023e09f9dfc9bdbbb2bde261f545af39f86a380fc96933c67ee9a3fe 4 66faa62b9d4c01e0dddde4998da041cbed6079965576f739ba403d9b7354b229 35d2d4912d371cc0e71fe7c53e657a6e3532acd84276aa730638d36228c25adc d570cff0b5700227500a8066cf2c37216f3a367703008d378ca424809c7517ad 9f8f4cbb96d99cb379c277dd1a28d1b7afacd63a1bd2d3132776a4364280ad15 dbb1ac40e2c86e1f22583fc14687483f48bccacc5116c1cd285b7ccc452af601a70d680e7c386ca3b678290215df24bc8f2fb557e54ec220204b2e2cac652f036b13f91482a163f6f3f598e48674946740040f6fc23e3c6d6aefedf35a360e0bac3af01a775b76ff7e09085ec35a654b7d30f07999b8921e0549df085d1acf0fb33b873c77ef77dc2fa5d96e0605422630767546f858ea9b99d2092bcd6e3a0f8dcadac3441d04dd508ee5e0904dec0b4a2668803972b1128b021238b7d00006916df635f2f4f9fe68929163516f8d693f01c40b5db0996b764d796bbaf07e0891d5f1c0fb613033f8e29a7ad271ebcd0c2186bbcf36f3447602b75d45669504 false +check_ring_signature ac54c22451973de5385a9dd43d4abc7789cb4708e81fe5b317d3fbf482332972 3c9f126e5e6cb28dc3be453240d1ee23cd0514a09237db06c666ae69395288cc 7 cb200fc9266274535e2fa86606bbc5816b440de1777a146b47cd4cb108ef1154 c0f865d80f4283b0b2d859c79ede4d694a2b152b493478be5ee3f3d9e58a0bc2 c4e0e1ba9e24b86cff0c9497d61e84542336238937000e8c183a8b519d9fa356 1af3ed4aa4f3de619ee1f848a42eb2258cc252efd68bb18a99ab90e97266b892 3fd7d8537d8e8e945699c8293ccdaff1e386dc21661fd880b72d17c9c6eb4cea 619f6ac297bbc6386490b1d9615137726e5135484a92e4f5a373a53c253a0cbf 56f85d6a6231ba1da75d75bc9c398cf005bcd94b7042f6880aef91ebbbea5ba9 a45f677d603fefd44ab1b7c83b2ccec5d40f1dfcde81d77edd4eb4b4616b310b091e70f03f12d219c16ad48993e030098c9584d53d20068aa385883939c3480c7c35b0b3c6cac5b7a9bc776f4613f83d53723aa19592d272183152eadc0974044ae0310a1e162a642b2c0736a63da974a1eca2987a0d5a8783e9dea872c0710b8943fbcce97f033fddd772c655faed6202cfbb7b733c5c244c8b8d39568046059a5a657ffe03e7a6983b79637a8d4f83d41d93b3ffa80a7e0c7652f814518504f163f5fc1e90e511747f4bf27da726d71083fc7aeef528fe868fd8a68b230e05c5823f0713f647830ecb773e7211de95aaa0df32c3896d58f9d677ff54121a0efbbd4f292b4f7b24d49b571b71edbe50e7be9c9421a215e47e93f236611b5008a188d4be5dccbf57913b82000d5c7797aa83e4b3250c3359835fbef246608b0e27eb4ab4c46c02e32e09dfd57b28490c4defd00a40d094e61e3f9993ae4be5062f0733e15b2e1518be7d27dfffdd3ebfb295f7744dc83d6ebf4c7d0129562b06b6edbf6309927090a2370ed8c2d623259fe9a0377bed544b5ba449381e1e1205ae841a4a30a0a68d6f999cbf65afce7ee79070647006876dd71c9a1701172002 true +check_ring_signature cce67bac6ac20076be1776ea3cf9f23c7c0e23ef83dc7e9e9ff8546ea827b766 811fb394fbf7e2589815e50c0c759e20dd43fc1b535c2ce53edf7aae33c2b54a 34 c8964839d3afe01336e5a252b7162fa30dc8937a428d2b04cdfb7167df8f6755 03dcc6b69d31841740c3975c3d0560bf270a4c012bb0def436f4ad38678edc19 50a8afc07b4f840956c2092a868b258fdf8850db7a315409c89c2df6b81dc808 23fc4e820e128540c75ceba9db978ef4f0e6e6144b31feed12a30922bf1e4eae 4c3c57533cd404e83caef0193c980d9ceb42abcc514226df194be2b9788b4674 f5692f595a97f46cc1b73eeb43fe14e003f88059acdf8830e3938502e8b647d3 913c2cfbf14ad10c9e2517aa4dd82bdb098219bb251e70882dc3ff814a7d0090 0292c797d9df658714358840b97868b0415c2c4a34f2544a9169979c7ba60d54 63c749718b7db041ea395f53627a6d3998c36dd1699da1581ecf95c467a37696 f7db7e025e1939a27ea6216089a48f2a86c101ccd2cb957e8e7aae72838d5b53 c48886853c98ada835903968b1e130ef0718432e3c07dac6d54326bedc78dd6f d2d65c72395b76a04904504e75f83b37bbec133a8771c071d1068dd951b5d806 fc6d1352aa22c49b170ec5a5bc9861d956e1551d74cf7cf1eaa3483ab00e5fef 5daa1a0c8fda5cbf030f7659151b6f6a89e765e4d64e49b23eceb9da5fd3888a f05c7c443bdce9e852c49e7d92e138e4281a82bb7861463ff699940c3fe9951a ca4b191ef72d68fa20b09a87270206780dfc6ccb85f38e30498f2d553503f380 31daa5e76eccd76737036dbf026cfb7305999fa490bf866367eb64c055286855 3ab46ffa5fd36967c85ca41787982ff8568a9b4bf8fa96ad502d0b02168777ed 134b95417fa7d3ad732ecb3d90b63a5a31e61d914a76b114df6d8a46ed002f94 967ecd5a7b336193e89f0f6d1e05ce1134c051f3eb2229000d6c2fecb0791f20 46e25ccc5df0b9a4710a707fb9726fb9fb9e34520865ca3f9537cfe216419277 217b61c74588226b25b5942a420481cc243d6def57843cc36594ec9e6e104d46 533e91dcf1c8d6d0c5f27ccaccdaa049067b95a0b5728920362cb4ca474e797a 155c94bb372ba303f509ba3a0817c89b988c9137b3c6ac4c2f739bbcb0dfa9bb fc20f84c7f6016d4578aa99a6332c45ce7396dcd92439ca602431d4c30155e86 40a6fdf6b659a886dfd6003c45c922ad076d264e07e7fd5391d1a5d85c609f7d 848ed87ca6098ea67a1e5a5c6422799a1b1c7efe74f6826b69ab14f7d41e9568 3a3427143da401dd93fbbc0c05146f4511904aa1a03e7faf0e27ef6a024d333a 9c347d6691121090c18491b7bed8d77336d7fbd5abdc7d3f8ba64a4670ea6f07 1dfaef2031743459f1e588578c65283a31fda76418158f800f3a4fd349e0cdef 0c5ad1f33956293b8865d3fe18d9b5fe40873509d9c114abef51b824527dc5f1 212ec842b2fc0c3acbd2ff86881b7f5ad39035d1633182b9ac71d229c0515504 d1cd305bb6537dfadf2abdd0ed6d4ec6e9171d78e943ced748c3383e44f337b5 23f75e0f8f7a325001494286bc4289bf4966b86790a13e11f1904a2714e6bc52 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 false +check_ring_signature 6ab7aa4d99e8c5a8efba581aa5922997afb4a0250e345b45612e45511ae7e4c6 4836a9337843406fe9e8656907e07636a2c89f2e7661f64810c6d11b2702faf0 33 938eb72a4b6277c163e4cbb29508f74b15da607b6b7d09f05a753437ea194efb dc0787fea3ca0c100419382cfabcc3438655c659359476a2246ee8c2100d42b4 fa50575a8e481a384b0eeeb92f329d2ca333f8e8b0266a6d3501131595725883 29fc674acf6596571338c4312a75514ece2422f9b0c3c7c9f1c4488f5b1801da 7fad7a7a9c5d1bd072a06fa02a09b54dc29d0e44e7ae906fc683405f1079ef3d 4b2cf0a0b68e6bdeba417bb30cc670a3797aac2d14afbae749e5141a725c4892 6f57744ce64e53b84f4a284d1de2620b869d0ef0f14ce0cc2122003e5f761e07 e7030a1a8cdb43344e13e40aa7880116dc731587d8df854b8baa4bee4ff0e221 04404a9c77801a8d3ae21e63d843f244c9462bad85e8fb0a31977b534404abb1 d66a1de4994c485a150686885ad6d251c2364db9bb55abf70511744495297244 e34c8a7c068f97ede8b47e604ea34b9b23279ecd90aacb176769faae04aa1b7d 1e7d3cbeba4a73518d00f043b1a61084a9a23a8e9d852ac994b37ba0ed1b9984 77e46b5beace93b87ac0b4bb98026892c21189a576967bf0051fff60035c4287 7c723ba6897adbcbe4af5cf3fbb9e6d05675116ab1ac1400f7ab7f2cf9498214 c4deff9adeff39c9d5884fb7f4d0b8766c0bf6c89616e46b5fe19abca79999e7 4a860284c4f5d48106b2a8f107143f3c4a71fbc52f922273af101d4d214f1bd3 a52b8c091165a9ac20b72a3c9b720a705d81578681bafd0a85069396e244e8da a9c12c63f29d4d1b6fa37686c1fa294329a915bd52f6e4de70d9ca89f4bb61dd b9a816bc29f9cd537f78d34a607f05d75cb0a7037465f9a89030c99fbcff0767 7e16f9dffe0e87f041579b9a9273b8ef1d3ebb87c146955eb810c1de2f0bfd43 6d2daf4a7516cf5584d8494f61cdf3438368166e94eb160c7bf3c719fe84c9f7 b37ec8083aff9c92a272ed2e50c567274e4ac7d76db0a6b1d0061dc02622de77 30f4b004d38b1f6a66f9a5db09ac3a37100040cbed16ab81ddbad89fefd006c3 699f5d08f7c38c2a2e82454a8571e5776f42c17151fac9d32df6fffdb9a93f81 cb7db031a9fc674b3fd85dc033cd1e430036c4ed2e70deb85852030d4a975855 c4f4a1e40f5e3fcaceb349e0d759e588d81e273097c8d3c414fa1e0b4092fbc3 3c898e87a92f03bcaec35e069e31d7f3c536c3617fd3ce45d0aafc3ed1cb4fc4 9cf40d22f206df7f40c337628def79a579500979a8b8dfa325a3333d8988b705 47ad69a46f4c16723234b0e1e405db9d6a1a7a14bf8abd268e8daaa2a3f6fb53 169f65c637d17635bc362bb28566ed1cce19aa35deecf4563720cb73e9ff5e49 f17e8d9561e9d50c64bea540191cd3759f017a95260494b723bcacd708f57ab1 111a5ce9bb6e1c77e5f7fe761994f76abe6704762d7a2dfad45d638b1cc82151 ef255cdae92146ec4a9216aa1848d7d0d709dfc548be4d52bd727416c5a45e01 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 false +check_ring_signature a5a9a4f983e8abe7aefee8755bf30b3eafb29255bc642cc59d8c21d94cc027ee 0cd0ce3029f01915685c5735d46643475a0262858cd71ddf7231d7419519b201 62 dd0e9db3ebeb6fac15f0b6740ab5b7a8e0e73f65eeae81dc77b0c9db8942b5d0 f3d5631b42a88a5ea89fc4be146de3bf2d98d82e9e5565f81b86c69327f5b4fa 78e9aae902538f00bd726be7964e6b6165bfdee60c714094f3705ebf550f1ca6 3aa4f3fba4d9b6df6ed0e6d42ff2db0fc0ca25c34f77595254510b8af07e0fd9 4a2d14e2568700d4cc89654986e6811ebac4693071f20bd785b6dd2ee05c910c 6a70c4906abee044fbd34e2b70117ce1d9278e4617f6f6d396a63c223a1bdf05 514a98b4eca8fb2b4074f94a6249eb0b9577382c17618fdc19c2b7db3b8e112b 822fc2a833ab3e2091ab8469b4a5912171a57d058a9ded6822f4afc77e0e895b 88ef0b9685b83f83d8d8ccb68aeb5748268ad2a8fd0fee546f94cc4999457535 6893a6acb1a3e399a0bdbe062dcc9584160371bcd091b7b7e5ec8baa69dcf81b ca9f7e201b2d2bd75eb5cacbdeff2917299e91eef907c00c8d08ee103961dd4f 564ef0638a4fbf16b360ebf3bb2c57e776172a39cdd4cf937b93966c8895f889 1d172fa3adab61ec0af8365989ac8ba102edebb4d65393bb6e834a90c920321c c6b5e0ea00841db6dcc2cb151f35f7b91485b5b5f5254532b5749abf288f2689 380ca04a7e605ca147d76575d0e640b44d9318aeab47bed1d9aaa4e3ce6e237d c6859957039be356d7d111db5596adac37b3b848e53a483589cd49543e34ac50 90cc20e9161583eff84cfe0975582c06de758f1be6b8d91f8fbba84faefe41b8 b55a6a5732a689f1242796f6bfc5e8c738dcb84c15a2706d59624d4a4a5c20f1 5d6f40377c3549d92453c4996db542503d1fa1bcc02b7fcfa36edbe3e3ca686f 6ab12c0175bd2d9a7919b8be7682f1adef7458c0039ed19dd1f9447dda9b0dc3 9116602cd551cca91ce9d192ba666d88a4c73e474d35263506e433cd79284328 0eaa602fb9d36661ab21ee40dea93019614a52f821c1d814dc58520e6a2c1fdf f7152fac23ef285a5232a6925c2bbae68195f003e8291de08036e9bb51e2d162 842a1a40f69bd75f5920e6eb4868609c9ace5c5f54f7bbd5911f3f0f48746962 a1dcf0ae09ea108fbd3002e376a72c2edd0af53ac1e325ae17374724546a4ddc caf905cffcf57c6fb56c5649eb1c5f3429bae6ec6db079b5d1b5566add11296b 154e380a686d3dba7ac1ee631c69799d57294cabcb557a31d423ac5a1dda2363 a3b9a7f98001b5e8774b85e1e8b21d20270094e96d829d1c86d4d52dca93b910 5f7d650150ab38fd021dd7c7e7d73c43d44219db4b8d406b7f37dd4f0c59afa7 93b542c5815041ec1bd0224d94f3cd6bf2c175e2d3c21a41f1b7548c2956d2f0 b6e258025636aeee87c5460523cd856b60887783314528f1daf2850692f67799 6beb5d973a30837e01261f7faa4e3d0ed5a8065e9034d532663c6a0680849388 728a27b2cb8a11e41c0d720f011e25174b3b258974b98db36f0fce161ebccbdf 66c171125210bd81d5844dc48003ad28b9a2ac69f6cf3a1bdf4a4e3f1e03b90a 9dc5953b98d958717e92eab197592f368afe656ca1c7106a8be86b7156585377 cda2e327d01059231ac816b842623b99eb721829b5ca144b162c6621f6be1c41 581b6b6f6c950e3a5c2fc9e639590e96172c141b5ae8a9326008cb8cb0fa1e7d d9ab0fadb89e76a8910d78376c4c106725859da7fa6f84c7f51a95e2527f8f4a f90b134e876a7a894ed341a0f78d5c60b4b635a488c7059e05d4a9020920ee4d dd271b6fabd133a97462ae162b40b682c82a3fbf5ea311ec53c83fc9fd4d847d b6c4f4a52d670d0cb0c9180c3b4d870fc9b221df7423c7849f7a3d3797aed696 ebaa0845563864638d90031ecbab161d9d23be3da1ea6dd32cca6463d4165212 7e41fc663837c86616a07451c50cc9a31de84041cdf0027bd89a266c3e2149f4 c4a9336984ac069228526ca2f5dfa52ca1491861d00dbaf461b168c530129f2c a26daf5633c75ad12e5dcd7af4b77c215b9ec2df5332fe19cd9257316f5a2f53 b000b238fec9016e51bf3cf050e6c99feb7740d95b9ae8f4f1b90bf5f9c8666b 7de83da3ff5ae6edbd312eab3d1ce7787c8d860a7a44bb53361cba5a515516e4 e33a27181986cad7e66556463d68ec7adc6208a510c0c32d18f85419043ef5be d2ffc42b3bebbd6b64be72780aa923c4627a4d3eb64b5d4075790f24963182ef 5e2019cbbaea01485d54da629054d9a765de54d566318d5d1959b86c37180f8f 00ec248e1c4e940db301f7bee7db9f717030802b957cb855a02e0ac62ea681ba fae797aab7e9c0043ff5fe68e2e0772d8587dbdee632ef8214db9bd723db2a27 cc6d181dab66c123f308e0f5c31339b1e5ad1a59c8ff38e2847a7752ef4b7029 1200d09ddf15304972d09e325f75ba1b2e72b5775d7c5c559a758068a7a75c81 e1266954a3926f57514f9d943ddb637677a3b0ff784ed23b5ece49d8d26c3f29 374cf46d6c0139ed205e79812a82b34714297a0671a16d18360dba12296c6c31 9210231c8693c9e19969644050172dcc66f81e1e5a06a4b69e878e95b655ef40 6d2cd517cd471e2fd3e4f380df2fb50a6013ce8ca6f84e28716350d6843924ac e704a60035bf5b010cbf452a960f2e06f5064633eb50d04d6324b76cfbf732c3 4606134d1c691635137fd3079d25b977cc1cc0453606045312fd5dd3367a1601 700d6197e4e3fff549ef5fd4d739a059c45ebd5c5bad0d2a2730594e4b5974a9 01dac8f2e0b753c7cecd10a78c6771f04cbfa3fb9d5e32f86baaa505e128a80f 13aafde40f73d97c9fea412c1f0937752fb813c824ed73570187f0aca942d80b020c738bd19b25f071685e64a97c36fc1965107b9adaef0bdd1992f0224ef5054d2d90df2971cd863c42da3a012291daa204f822bce480e43cd456aebea9680a006990a867754a84b602d1cd1bfdf792a38ad8b07471a426537637987f7ddc04a8a2ce468e5647b0a6245631d25046d822edee39290156fba873cfed710244095524119157ce551c170f4cb57458c0f95cce000c19438ce4507e7488c5263e0c21dca0fcdba134bbe9d7dfb3e22fcfe83d578fd939fdd152bcc396b545274c0fd53e47f77fb346beef913fa1bb363024ff1ba7b7d1189116c198b4fa499b9d04c16e61d354fcc3d6802550d476cc16be668630e9fede610e508a021fc74382053bb426999a43123525c6297571f1e5519e7ac3d7b54919d21a7ecfc9a352e6014a84140f1dc95c239819178f5acc59e3c7ddb3c0927e3fcad3db6657045ea20bb329f01b4a6d5ddf31d916da0e2d217c120aba4971e2018637a57d53868f16062fbf28a136a53049525a1f1cf1c1e170661c4d968915ee61f06aee8793b805036719e753ce3684c9d96399ca764cfe96dc63978f191fe8c15ecd76558ec4110ecf518afab1d02d434ddeb5c3430a1b6cab82cbf3b5e4ab25d6e86632fe92300c4de27e50b6b0027c3a8614f71954c6b4c1fa603a9de7c82caa885123810a680047d24e8f14ad86c157adbdad67163130da35b8e10982c2bf32a13fec6533bc0ce3d347c90c80c7fa038fac6715d4711731e28abbc5725aaa78aa7df080c23b0c11629e89f056822d177ed48f38e09a7c0519b2224511968e3786468b32649c04d2e95841c587738a591470bf6801628452ea13cf16942fc14ca8fefe3705330860d6719a34d09ee5cef583a03c0becea6f8d286b65829b638234234620f66c0f62ac51c494a36ff7c3f9682b5dd6b0f13c53654fdec0e3c9f52861074079470e35e6b3e3bf090928362c78f594ebccc8eab36dd600b5c0dac8831b57f2a0510d9343fb26dc66334fcf781f0e8253df58043d7f8f5f02df8164524b80464fcc06a885794a4ecee84dbac30b6a572ef4515573b3cb95aa38572d7e5cad45e4c60da8f1df7e249c61faf16afed522895a4b089e017b70cb4a25fb6f77779eae2a06a3632e6446805cb4d13a996ed504cd77c9925f1c1b80dfe91fdeb6faad33db0ef5f2b72b272cee782d29181fe1bfa8df004fb7e7d946e870f7f7e282bc491904ada0fc2c068f2573f36d6ba2929c5647406a5b492170fa94a7f9296d60bb8f0f487edc7b4e652ef4a8a96f192c5682fa308a1a70a9ee4e0eae23ca3fbe86cc0c4a469db3adc9ed5814f016fe195efee2bc2f3adab7440955b9f5cfb2906b100d8bf51d7286d0820687dc8fc716e1d78505af23e73975a0aa620c25953fc71e09a7dea3bb85085739fbbd03f415cd2cec5d27d30006dbc1c67186d07eb25b5f04cc0e55a60ab8f0cdfd1770b206060c42d2cc6e03e8e1fec954cbad29b1a1de053fe8d419e1ead3eabf95c6bfcc35826805ea092c43dfe4c2a69e9ea43813e904e287503298ae1941b1b0e9e98b714b268a658dcc508d03fdb41a339f482eaa0d219de6ba2949c73f06be0e5fc73e483af75fd29b45c4694a90bd33b46ae51c0d733cc32f2b7e62b368fd226ce6107f26cfa5033902562e0616782d4360982e0ea8a01706aa6e77d9ffea8440a4b9db68ffd60cfef8e233bd5573cceaad06d704ff2f85cd9055c8b9db91cc870e8185426216ac62f10cc63c5d46bdc228a525088a4bd894c47b27ce598eed934d59c8db9faf871c035f1c3e7116d9fb55f73d03698c5be7e67f4e16fb65e56498e61461b22e73cd2b39bf0881fe83973998d60a1689fd1ce8328158a8be3652988e25384e215d451a451ce6448d4bdc743ee60819bd433a6869d0d2a9b06ab2bd2108a19878df69dac52ec23dc9254502024d0cb48b31bd11771d9a173a0b1c746382bc518934c7719a825a3a9a66f08920190a217d7d329ee66d1fc5e51da8a136306c46a8d81acc5601495c143264233562090a0d41738ec1c6450d33a67ff79a2dc6e873d49b7f5615e168954128a8ad18042cbee037c3f35c9ec4123ba13cb956b59ff5f03cca84ddecc028260afcff3d014b4ea1a6f89a89bb2c193a79bf63a27d11db487b670340fb14e2340b0996fb08ecd0d03578feeb1606e85779955bfcd6563ea035a828da413acaee59b6589d00d5f0b7d846929a9466c24b2faecc2a5f99b034206c66a2549c0d548ae1a531067c7d2e53a9d3c4b3afb5652a42dabe7998a4cc3af70f4fad8421826401357808b0e275cccd42903db5a39ec3090e9f0a98ac710a1a45b5ce0a33acf77332b00bbf2ae1199c2cdedeadfc931183d3438867a8209d7b2ce812daf3c76a52b030063200dcbb0dbc76c97eb3244b1a37c3bf008544ffa636790e667bce25b818950306557d9372fd0001c0b39779427625cc8cbcb3023d4aa59747361971b7cfdd04f0c51a064cfa2303a33896f598090c6fb34f4d93f6563ef72321ba100ae08c0641cd083ccafbbb4503a6835750cd0aa9369bc92853180a44214ea43203ce100a99c972f521b8a927f72f6d477538e66ec2db4ba313c7f3c79b643d0c0515910dc97cfa78678319a988a4924db82b39042a9fd3d5d77bec877397affbef9e6e0f8b8cce087ba3cfde378a7a249bc5b7c481b4671bf7ba88a4073b6d4e003660037a7c1c6abf8d5ffb65e447309d46a2660f3e27ac225d550a4fbe8de0b4734e09c01d1739ac5269c1c70385852e5743f0ab52084aeae3771ec70cce3f06f3fc0077cfad9a2077f5e685d0874fea4afea873a08cb2f34b4abd135cc0fb9023e50f0f6a1ad981dadddc4c8feabaae44fa75f92f015bd86d22e819fe4c504a43c608860aa5127c4134847c755f95090c75563a7b84cd3cd2741c7086d28dcf6a3d09faf836eb71cec5d387cede8b6c7f99423455c25b3f8f58afbeb65c52cf2e9102894d80afd41f2ef34ce838e9c192148671a8a1a6b507d7190aa64692de24790ca50058056b08e6303291862ebabdae65d06fb5fbd1e6bc7e6f6c6419b8211306b0b6e1f81923ec800dfad4e950d8aae88003cb8ada8cff5b971d6dde2ecf4e01dbf23f3f3c2587ee4da8232de79e82e943ac72cd79b63b6b965fbfe24535e00909459ab7851eb96fbf47b6a4998287ca0f41c8694260e1ac666781feb8692606da371a172409e75827288e8ee3fac4d592d0693cad541667c824dcb22c97b804a4245aed901c15205f7152b9458e512c8d25bd7da125f404632229ea68face0dfc7b2d218dcb683e23ad45352326fe79b8ad4c2162ad48b9a1486e6d6452be089cab037109855610946840cd7ed6332d102d08f1be8a5f27e9b3cacbcb7f5403ca44c30f0ed4519bdff60ddcffd2afb8d9d8333c39392b3dfd942d9617f7b70c7152964441f32e143854afe661786fe04827a6de1d526706c278e3398bffcd077445b8030cb5afa7eefe4d3bdc667c69e23e4671393c65394c4207fdb461f7054549d9eeeed0b9010a6e72278eb1d82ddc771ea40685ef84d6fae6a6e18efe0e9cb49d621e9f04a06bbb221194f24003c08e05db0e3e5a2f7573f3bd39580505598ccebeaa504812f16b2ff07d85f312a15091125557e6a14f65c23d1fec33006f019a535cf158253fe661b201435a02da0e07232dbd1d254d3a7de73ef9180df892f022577aabefa23f756c593aedaaa0ed185b01ea555fa44fd3dd9ebd7c0e1bb84b3548bcb1fe5b3ea7dfc081140f79c2c4c31d6e1185985db8457139f10441b6ba90cc156e910ef2d562c24ad44b14279879e3921710e66ce5a2413727033a5d245467e98224d9372c4d32bf944e61e25d89b8b57d19d136fdb76da50c003f3932930bba87a1d50eca14c9daaadccc78a5363e2bfe5717ab14a26403630f00c0b4813911540034d2d369903acaa5f1a8ef5a205c023737ae55b948fd9b0202d239792d44ce30d96058588c0fc4f6018154f8a7310afb3532324496b91708f42c5fc234dc24213c15aea5e7c84fcbe9ea57f8a359db156d08a305b64fa1023ea6abdf7c5c101952e256a0ad6a6694eca0c37d53e1cd681cc0806cfe700f05762dc7371c8f01fb1a4c25a30740c1b88af7a7dc181ad2d778d50a2ab99fd400fdecd352ac83a5adeed5c3e5d742ca5d8d19314af04026fe4e46edf7ee882d0824d4b3c9cfca8c21d5a8c478bc866cc47d308837723f3ce663f3f38b1e8abc0863efa1461c3d2ed2f2714dffe9807d4dc42f56415c69904a9a8b6ca7cd8a7e0ae4e0ad1acc5cae0001f4b415378e08abf140156dd31aafed1a7abe6c1851750323c7c434ea380d2c25815010d7c188e14c4fcefc78c3c6b38418c51b16f03b09ed590f9892b9bf9459825d06193612f0ee9400025adc11f88540c6cd3a7b420cdc10fdf85ca75dddcd7c6c51d1bebff0634957700ba9622b078c1c107c57760c3a06a60908a3e8003802e9e13dedda6fc5089fb42e91ed1b0422b629f5abd70d146d774de3e06db9536fc8e3a5b3c2e9bd0d172119c68a4a691a122347a1dc0edfb837fb987c1b1a0e243349b776cc588e4360138ba2f2b18c2fd3d39ff4320d21c85c1767beb21fcd516ebc4a9257a703508fd15e8fca1b1e0032da59f6b8035e8366d58e27a510b4e99921249cff3f47a76e297c7b189a47c9118c6a56b60cf41a6e4d4b9e589ca11c7159a8383db29e9d673f0085d8af044ad045101c220bbbb9f870ee508f12cf2e183539628e333874331fbddaa458746a6355bc3e070171cfe790aad9c8effa7395fb499d0d046d0881d0d5bc99c051cca0ca45efa902fe399867a6414d9f4b15e8d98dd1fd3a54aa40c6ae42d8ccd9c7a0f6cf40290d26366e3690779acce77d8468dad25c1898c4529dd4a29d183fe7964dd0b9260b612b71e621430b7729ba7c03c107af02e0af7b03ae6821cbaaddd90fcadecd093e303d05b2e2376b1ef2625f07a60a6be59f97156917c6725ad8b412c298a60748ecb2666aa21b75fe972c385c6ff200c6c6e0e1989828d0b8e81c8c79610a0e55fabeecd0ff1c3caa7c1d3afd78c5986bd9e29a33b356b3e41ef7bfcaa67305669fd48078d704afc64d8c702d47bf6a853d4360b13c0367d72d4a84f8ff2209a2d03c55292b5b27568f8afd7211fd05ac81fb4121d9833c168e8bfbafe12404a53f945b0fecd093ad7927cc9b00e4282058d447b24a9f4c00c9dfa6c554620255bd0827ec4b3891d628702b02cd619e1126dcb69b3ac30e91c25f39eb9e5700ade91158a4626fa71839d2c71fdb5ea3413e8aaf0d6c95bbf1171558712fc802583c5a6e586def73befdad3c94ecf68d89c6cef4351ad9459801aa70bd2bb8002026d69a420c4cbc582d90d254f3a81220feb3cad26d4863978c5b4f8288f60ab22f3142e87cce15bb15b74feee9a46d13e1c5789a33d54a2a15c92e496931018f71456d1be59d525bf06bc1194962560d49c0dd18e85bf8924837c1cf9d3109a7eef9506bbb1a7ff8b58f029d4c91b924da1616825a4621f3628fc5a7844c0a false +check_ring_signature e20722d599d4d1786bc622c0e473b1637b1cdc0ce821d1321b57aa526246e6f9 afb1278cf3293d6b33ce0d19eae801470f2930ac9c991d1eef912c47146d51a4 2 cf01e21e02f41d5c9e8fd1645f3c24847d73304413999fd0dd9229c549a2a59c d2e980b0e3f58d2ff57e5292d4b088efc13b143363ef94b1c3b5480c97e7a44f 5b5b3e4cb1c4fc791d1640164a887c2beff2bfb0ea3974de3bb8752b36d9100a33cd639cd5884aa34734308f9d4048eb2377983b346890780847ef9f97b7b789ab20d59ed6a9c48c042c826d54a9a9e1f9c95b387bd617ad49d5d9761246860e561394613db034e57f8d37927009cfc98ec9e15cc19904855328fb40aebed405 false +check_ring_signature a7413a44325be45a3c869e0d408a7d7bc45b5d2338d1a26d8a135036feb85e82 5c23bc74f74412d531ca0645165e378e1dcd338fc9232d42e334c63f965d9ebd 223 3452087ad769715060f53ef463caf09a92fee67b35137df2fe4dec3de9e0c538 bf88f47a13b040971506a63e1f4a5138afeef6fbb1f8787d551b704a418a570b a8338ea4939e4c95192b595f96d36e51cb6908bf066dd25ee4d1d3d32eb862d1 f69ca557d534275c5fb4cc3f28abf6a2391f5febcf94f154015269fb88ad4efb 4ab5ce537af56cc2bf1b8b08a3d60851ce435e7c7f1ab99eb0f5459513698e11 17c5911670c538887a61990c0581c3fed95eeaf55b57877340d219f1535efb60 4b300ff58236bc44a27bc728620f938eda54e8e1a9d10f19d3327f7d382edfad 67a8801a0f53eefb452c470222e5ead5d63e31acbfc1a0b77e3be855593d3513 96231fb31f30994f543f580d83c5bce78857c932e6ce74327ef7cdf4862ae1a0 f568cb1f4672d8e55a187fc79d6e7a59adb9b4c94bfafa6572bfce15ee7203ca 299d301ec095fcead96bc3b38f3bf895dbfbbb4d7956f1e44766160a68c1ecff 32a5c4263364146fd9ebb7ce0c10689ea508ad0db38dc5644fd3f307813d83f0 1c5254542e40d71a90a3fef7f3b93c644d2c962b4b394139f1483bd41366ba21 aff56958d56af499a5614caae1c5f912936eea4da1ab538b0715570ee93dbe85 717e8582b3a1ca26035da91d0ca260a16bd46d8b422c34b981a81728f20c13f2 0cb7be355fe9da2fe1d94e10f79d5a646019fff256ab30f9197e28a3b8202a74 f6e6e2f139a7b0ac1e16d53f78afbe3e826b55a5d3a8ac1f08e62a6f13cc6843 8c79c816271fcebf339fa4b9a5eb7a4292bc9087772ed689e69e53228b724630 a418b9598620a1b73edc0d952f630d63769d5d60a5921e80264eb310f4abe897 9be3c13298b4e97a88723989408e47976c2eef9412874b689f8fb285470d9037 3349bb96e662852b09d9f69ccba63fe6f54b9d169271eee1963ed831185272f3 4a6887a24c7dd5debfd5dfd69fea32f144c2137a0974391f45c8e737f03c236d d64ba4c281e57ea0fb5464e4efa9f091ead8f20b6fe8a16c958c6b7fcfb78617 cdce23dbeec4941b517480e5c74e273a29ab795239de066dce37fc44f1642158 173dbedb54ded2220e254e251c1547f70e7ff67580878515c6aa4beb9c6019b7 48319e9d702fa616ae97caefbf332bd1872688067f2f726e38a7f5821b1f57c0 6c145dfdc7f74f4796c56bcb259fd949137c17c305586870ebcc941b0296124d 78684a0c6c33966e1996f534cd19f183cf85f527d6705a9aa00bd39cb9d8c3c6 bd7a4e54e01a10478b014b74e61767b582bd5eec4b3eaef2f64a1116baff3782 8e25f9c22f3a0b82ef28e303bf3f9db5d496c904fb65e4ad0a436bfe598fdf6b ee9f29ba95203b791f97b35791221fe3ef7a481031bd011569dc3f908a28af4d 734f94af35c0adce5419a4731df1fe688389af5383b09fbcf957cfa3a425f841 f38fce381744e2898e1cc891f803b9be4d00bfa07ec523a0d61304e73f87ff8b 46fc7c29f46fef4ab38f4c94df267f648a761eb6807457b261f6b31349040ddf 2a7c1aa4a7ad7cf11e3aea09e266dfbf2d7b47bc709d1d2f6af76ad585c6c141 ee98bf436d84cd82416269279cbe99afd5474ce99d9ff3592aff822d3de529c9 cbb4fa2a1de8951eb96263f85a0c0f391a65143c14fefc73c2a5809bd6b0dc32 72d51a3a6eb93162627f24e1f5c71f27e1f12d175cc24562695a1ef711024e23 c199901ea4ae3af2da84b570ca624b39a5a1575d8418a2c2840f07439e1a0bc2 eb81fa2003d41074f3a50740c447f9b381b3ef450e47cd9109cb745c435b2c39 43d7ce313174316bbc04e5907b38174fb66115cbaca0f8ddfd0df089b00d459d 769c2f0471821c538fc9c40f90ee6074b150284e4b61c225afc682a2e3e7deb1 d3be754bb40ef6d47ec4fc2e8658ad71b0dfdf642570f80d75535fffa5fb9edf c5975355af1b29a8af1a84062fcff80e28460a2400245378d6cf7f3c29849fbb 3733f48f88cd5e56e8a26210d3458efe4f117b0621e1be584b686c88005833fd 1f6e96c4f3e5b38c1ec4f70bb1df118fcde8c6b0aeba95d141e5ab2d7cdea94b b380ef76da440d3e08634d67556dcc4e0eb0151cae9c766a0b50260d9d54562c 7bf920d027913f698ce4dcfac47eadf2156b73884e5dd438d3c63a2a51658805 79212abaf0936575c4065a6583ae3938afffcd0c901120631a68f5091f7c8dfd c0450e36366b2ae6cadb55b302fd51f46c908967b84913131008674909c28d78 8555e992dae83ae354f52eef563c3223fe4ae80a8692eb9843d379fa72d146ba f8df9b6294bfd7357102e57944b39a6ed2081fa322ff7a616ef2076e88d39746 56b7ee74c8fa5f5715726bec19a8f68351b60c70ff2fe614aef0b76f1ddef1de feb0c8ca4068f03e591a7b47c6d6d076ae3735fc7f38181f55cd6740a6167af7 807114da8f392c924bea16146f56c760b6623b69ef69fa6b1c563f443b7092b2 8436b0a41f8560f253f10afbb3fedf553a40ac33f153db12dd5f372d5efe159a fc82c1dce712160138ad6916937d37cbd40a1552a23e7a03513d4ee23ee2142e 052d2848ed9ad5389c072d04d74c87e7669fac736a39405197de1f37e7abb01c 6462c1080fd563b60c486bc039d228efa73b8824e2821d4e592975fc39dcdbc0 c400895fc5b8166aaeb13ca8b7bfd8d92c8cf2b12bede476ce8072d6e6a4f64b f2728b7d927f1ce45e2812f956a7b17e0d9fcfea80179fe445aa8d4987866fed 80a5b3d9d632dce43e76d3f1311adf2f9711a9712efab48587140a5182cb2049 834eaf1d9fc1c3381c5eb39d202013af624cdfa98393c9e36665edf2b4cf2077 a43995cf143df880b63c2af769d43390dc44319a80f7afc3202279c66d0f0a90 3c6360b1c7ff9844600a51e2a0edec6edbddbca4f8a7322a29c918c1eb63144d d9f814aa57ea682711e82de8084ac624e9c05c081b39670fa127bfe67d6c1398 0a511c706a9000d9e4dc31d2d4c53f7fa0436791be5a11eda18c0c0820b86fb5 f7832edfcb10419e7220edb1e02ea930b7fd114fa84faa5e57c87dc7c604b709 3ab4ca537470cbbad2a5df44b3727ac3a5547e88bb57eda53f6f0fa5d0a934bd 27894c73d123427fd8918e077f060b1e97390dd6d583c817ab24118357bd1651 3a537553482b74b003c9eb7dc828fea0bfa11ee58a64b620e223ad641474d52e 937e8becacb537e5b4212d401c293b31a80d8f1aee1294a0fe33e9fc8f317341 1857fc187e4ffde9c3d00f672d7c5fd941868d6ae948a0b857cfc473d470c131 720dd730c992ea268d0a3b1eef8f319b7eb83a6dea9eecdfd3ed951d46f36640 7f9e0a0dd6420078b08b9a90421f219ebdcd7103ea7a701cf5e132cd2d788766 ca4b4776ed810e916f501ea51c26b4f1290609aa653c8a708d6723afd01b792d 3d46479b74fc6e7ad2474468c466caa8be58103471e50a50b26fa7489ef0eeed c4a5ee06a88b8f36a14a640e8da4cdfc59a29c56f48acb98d1ba76b9a03a581b db719528015da7dd7449cd90a4e7439b9bb4058f1391995fc6b9cd89f253a582 1a71b570154de689e8acefa0a96c7c545ceb4cbb0b934f3a82856e5b0af4551c 7cff9111dba0d556d4eb0aa73b3ab0871050c9a7012b922bce1d87a212aab5e4 de289f1bcd9245ab67aeafeaf647c31d6d6323584e2cbff999dd955b7f5a3f35 6cd41f5d06b7916e0af2884e22c7cae7add1d695db12fe1cf73b752f33bf0586 0ca4e4c2b94cd8672bf413a4530410bbfe23d589e17d873467f93aebf236fd1d c407a10e5c50cad676e42b0dd96f95ed33a18cee40b6d361fd6558ae9327442d bcf76e2e8171e5e3e83f62ecb65ea60ab0344e5c93c5a71725787f40635f29fb d91eea66d752eef3afb32b9dc1a058e13d7090c3bd7317a820ad8b1caea9a2cb 0e628de0271ef98892bc5c79fc0fb3e33eb8ab4ad4f0fce5c5f97a741a71aa59 fbd6985c4bb2d72dbd73e92ca5125838c0fd6a372949e6ac71a637e97f0dc15e 8b65cf5f1ad960c63030bbf48053adfe72692860900abb1bde153a4bdc122c53 5ea027382d54352a5ccda02d2b386f872bac9787510ff101ee89f86bdccb971f cf08d96e6d81f75a23ce573551e865c8c459cd9cf48064fd4be5a25d01e51028 7dfb50d20b6ae5eefdcd8abd688e1a4b57392d2a5ba4c9045fe1b5bbecf30834 627476458d573ba3c7f709a06cacd5a7f392a6b00fb486a578df79a102ce8682 0a4744d52f0e203bdbf1154544b95289c2de96dc65b053a19c8ca15a7b3d379e 93af29bfadbba2c9c6234d07002fd34a33483ec81184bc51f945bb85fb0c39b9 10ae3196aa228fbc7528e46fc2266e91adf7bfe21ff11ce94aa50415aba8fd89 71d18683f8f0d89fe9ea94277c909a14216b66cdbc5f12b1827cb055b1e42c4e 91e90aec8639dfbaae9daf63eeaed2b20fea0b06bc154a4f342aadaa7414a774 110d8c2d90c0de8a72f7669f8276ae11fd6ec7a9ac92aa09cc14a082f99eafa0 36477987dad28fc63da4181089f463f4b8a7088b6e4681be81c82e661e574471 df2a844d6d1661136ab30b24223eb0aab77b261285fbf774124b443aa57e4a27 5ae11157b68640bfbfab2626aa698b6e9135d20ec3b8939259bd125b60d7f4ba d5c8e31ee206cffbb65a48a9db3fe3b729e451d907b0eeb39ff045ec4969a685 f25d4fdfaac4ad5f46e0deefa767687f0cced39397accf9904d296852f9403ed 11e01c1abba242d36c7ed68b4897787eef0a76d408dd312fe6148a0c2ad6deab ec614062e9e8a115c4789dc1e180d8e07c72a6fc0379ec2cce88c14b4dbf4bf9 796064c6fa1a45f2ca973eaf0eee646931daf1b80ed36fedd6c464395f3b2208 1ddfdd5e4f51700dcbd462a89d7bcd430d175efb5c682b459017ada1199fe207 9202823467b669789d77b089e8bba8fffb4c5637f7b53214f8e67c6f55c184e5 43340b059c7d32b767beb2d2cfb727c79892af1040f64b63a886b10007b527a5 e6e1acbc321e3ffff0376fc5367aed7b6475e1cf4217db325558036fa9721102 206e1cec83e35668036c4806fabacd41034e783500239081a159e113ee81d533 27fee5fe50e1faeb89b7c7206b07eca276d242afc9fd3b359c3346b05c81a3b7 88b7bf8d66a4b069ae7b17fed0bb428b6f03062c679527f17cdd86aba8c6cf94 611a60e9d9812212764c336df302e2f2e3f37830131a82b846cadb2320054591 2b9ac2bb335cf5177d07efe1318b9f715a2679808df44ee3f5c820e1715a1f64 67f58b1fe4c7e938685a0e8988f87a8a6bed6a77460d213db557d22c368973db 9a9f935e56dde39e139ba6498fee3388bcefe6897447e217bd00fcac180bce28 cb9efd98c65a8eecdcebf193164c6880037504168814baa60c6cea1ce9027373 439deada7d9a69169798625bfd72e467a298f808ddad671a468baea95714aff5 a0a08872b9f80db037fc25ae65ea1f0e631983b29ec7d15eed369ca5e2f39d1b 6e7c331d1576f303f034ab28a3d0ec96fec45b5ccdf2e2d879eb5e2f6b35c9ff 6df03702ff5e7d483ff75f2781bac1ee4bd8b73121d812bdf3cf282861d8990e 5c27451ba42f9db2527b19eb637629496af312925c2c0a81e324c9a920ce2ea0 b01a0ba253d9aafe7ef0722df3cdba942042569214b5e92d1ae60976362434d7 664177130bd579bcdb546f476b3a22f9a96e1318d35f55ff6145e1075bfca5bf 5bad3882f31b4a35357eb238bbdcdd57dc4e48f79da38ac270ee6beedabbdad4 940fe67f9e9ca85c82c3a2e7673fbcbbcc4229f512b03fbee467b1ddf38e0233 a49899b42cc9d53d3bdb82e2acc81f001d62645ff8471ef49c3fb6564c2c67a1 3e5d6560f1b851986974764b810b0e46644b5ae476c7cd369cb1f0d0e5226959 eb01417e9597275c4f71454ec7df183777ca61e140a7c5130d2b902a21004651 8a011286d1fd5523cc76250414a096c6e5b8a3c91c1b9f29c8ec5b40ea1ad7dd 456ed496187fe79fd04bc3029552a8a00fc57892bf3480dd7892d0a1452cb31a 480afbca9fa8ce45d546a51fcde58c404e0d2cf54aaded257243f0af8cf159fe 686934fa2c245e8a4e1ab27c0d60c1edcbcee8d04f4109af5bcbadb8be44475c af019048318f8a0a9faafcd69af33573e6fdd8821c2f1e7b1ef6a9e8ab79b0b4 8ef52ff83a594914bf5c638a2d04691228809abe420a715d368b98f242925c33 9d1aa4e3c2dd57937b4780f65a08841b2a058ea29518b732e79fe62ee04f676f bc96b00867b1fd79993ecf627794f6d6657fe8a5f0810fe13750a6b64947e1da 1d8af4aa533e2707f9ab67c03350a1f900c8ab495ebe50314654c83f2e0bb454 15c434971ada2ad3544d9b012945a9e6c1e30b55dc58a0d8d24210628161ffc7 5379f25b7c3fbcc68043dad4d4070f74c18077f11c6837c739bc61f436e9541c 3ca9063f538e49e1d5f1b8c5b28d9acdfecb0a3193158c460e2c7a8ad8882975 ff9b06f286404adfb62c97e9eaa221cc642a7155e082384c543dbed190307620 b6c593088ebca3236ed6539d192e59ced174c67a05e6baace7e2b6a3d413bc6c 7e030bc251936064aed61565b4bb6df6fe6879e3ea1b3d2bb151756f702162c8 4dabbc16ed11567876baa5d18fa945a9cc8997844acce9d1cce639bab06dd428 3f8a9e22246155002cb97b0ef1db4156a4701e27b28bd018647684f5ae311a87 637ec3f6e43e024fab617aabd81154269f5065f6856a59d1e7bd9d1b5dfccb90 8a7135fb9316f4573dab6244b0cbed9c234d57a6b947f8715167dfc957376f91 39233babd750ca3ee46e508ffe9960ff837247cba3d7a4da9293f695d659c86c 539739cd03ef378c87754aff225a74bb74988f93083b663757f7ef5d78dcf30c aa6d1320b18403a0f982dc21559e882153f65d8095334a62fa821d463842055a 039a555b68e1551522283e1678fd04def6c8ba8f743d83c1256b1a3455f05a17 f69ac6d46e36a0ac02abf13643bc4c603e6fde7fa1bf275da6c86477673d4aed c2b063cdd12b28a18bb3b89b16449fe83ff46a495c2746e7cd8e1d0902912677 28681cf0ae93a2ef3fb878b0f1b24c838e46d8801d5fd1da2d37413644cc47e2 7620b3061bf5b9f4c0fe379e5106afc93c5bf2b02ba61803dbeb1fd579ee0ac6 d247803d16f9de1f8aecf3915d7897869020ccf7fdc4f9d6aa2b03090d6b0127 947e4310a22d32d99ee2dc79e28dddd02299ba6aad05533413122e3fbdf970f4 2be9f470467f17c6061004fad5cae4885736c587da6f0b23af1ce24e4ebf2e57 6f0448d10226eca4b17289a15e9524626450a8bb3f07f11b58689a69dfed8d08 a737119396ba90c9672944e24fa08b2600d1951828576bec69eb9f041b1201d6 1dfeaab88453ab8cbe6468b9fff8a20b81c104d640b342822b8fef4366f48789 7e57252827c335f72c9aa12b1324ef6ccdc94b306154ebe1d94d7773c6bfd203 3bbd29be1bd6da733331fa4f61c81f4e7bdce0021eb90670084f9f74b343a2e4 06e553316f57d466a8b58f3d5b70451fadcc8435f0c718f62c74869ec8f31287 33d273bfe61426bf1fe011ce2b862435751659a548d848b6fe572dceb5a67a0e b2be35a02d5486721292dcb4073b502f2cf8f0b797add2045730eb15f81d8179 e1edab3a0966e771ed497e1db24eda4b511d4ac798b5aeeb21d4d02091eaed40 b6c4e1248113e59981c6f0b1ba167911ef2850f5c4f99fce2fb77a4a3b7febed ebd37b8b066e3712d5bb84c3dbb77060459c2a51c2114e3e19709798d6fc481b aae18991815a6af2172e4009ba74ffb6633b6306e59e60f2d636c9c4750ae6fd dd1cabb5276730de814300d2ee70c35c2fb84409fe4df16d2d21afa9f1c92630 7cd18c446898bda67895bd1e3445465039ff75dd3ee447d2717708ad9cff5275 e96ee1e07f985ad87a60d5f841d05a5cc17bff7ca73a69d6f22823db8ae1a3cd aa1423840c79ce16d7c7e8832bee532d43fd4dd6907724ab69191f899a8c6ff9 fee6e5f82dde85cee4a8fd4b788969a3c35697d8005f2517ecef5e17392bb646 cc96c4761bb7fca1e9722914bf9efd37d2c46f25e18fca1da4a86be0154719c8 4f0d5ff5a72503ae10a50a34e8c9e5d9770bf63fe417e4032ca7e98c93a82b67 9d65bff86aea79b53b888b9ade7c8c7ce0974495ade21a022c736c5d05daeadb c4d940549bd7a8941fd1879bbe4930ac318165bd3d8c44fc0a81ae54414907dd 733f438388d74f2dfcd37dbf56ce23645bbf36b1b4cd25f898342a00ad0f4db9 46c7dff9622e8d4637dc201b6a4a40663279ab2846bb714e187500daba35a048 6f862bd95fe45e181999865e2a9e06829824eda484812cc01680eb90d30e18ba d760429d1cdc9adfa2c8982c1d425d6b117c1ece9d3df780cf5530a14a4f90ef 6d2b27759a5cdc7c5eb975f672c99c2680c613794dd257f144141a8b9cdc06f5 e51d1b544dda604a7a44bc7794db9d1f39597cf15e5887d9d25ac743bb8052ad b6d95991c40f39e129d67ff1b1bcfca7fbe3030bb497911b30f4f251a62ffc47 640c36b3680f98e200369b98541d0e2abe18d3288142cf30d1eaed018a353854 278986e18083954aef1e7f7fe1d28d5d17c89b5ebc658747bd2862df569d83b2 0cb5d039a445b060bd8c2864c53fa70a0772eec2468fa6c86410add3896c0070 440155a46a8b6c965419c0b05757c878dd2b6b0aa38e868ce963e7b251356281 76a6cdb0900b63b39912a2e0aaf1846637690a4c2b929982d66dfecbd12e51f1 1034bb16504122360e84ddb5a5ab585bf3edadeb7dd66609249fee6857065931 007e80e05b82f7d0719151ec21d7045b6e7b94c7c77ff40c282f40933bacfe6c 1969cb5ff8a7b731ac92f6cb1089eac1be0264400ea769931710399a739d6df9 badb4b05d54ec2389d01777b922c6087ce61f69d86ae3d0c18ff3445dd821247 1f322bdc968cf39762a04c0782aaf30256e530587eb6c6f400824839458564ab a91807cecd1ae32a2aef1379824d03affdda50077618dc7caa10ca506ececb99 dabab6863fc2fdada3df2daeb85d2b5982e6c1c96fe26fe57bafc18ff39565fa 9933f30447a1d599cc0f15f725d178063cf7d27bdfd4acc484868ff70af0c273 70f55deab364e09828a7a90a8886bfca0cc62c903171c86b4bd55f4d981141e1 473eef4975725caca93422b0e5f34fd0ba9b38bf6a8a5df570e0365a36bf8283 e259e4ee6a72814e98a613e4e714dc659b7566f8cf19d664fb0e64a461bf9357 d8886947608ac2db3d6ce7d7bd9e0b47d55ed3aa96f082dedf98fd79c061bd50 cc5ce4f7eecd451f237f013c016479d535e163de49606eb31968ac8fa30d443a 347585437fcb1761e04499fdc812b7c6b03c0d12916d5bc8b648cfa5bfcca41a d75441bef497e5390f2b2c08c849c6798124865884e1de6cca9975c742dc110d b9dcf0541fdd05e55eef10873fb68b6d4370cd9d4463c76e529d90504bac375e c788c2a35a7fbb3e9e740d932515ff0d03066ee3f597598c2d2bc72cd63ed184 3f5256ab5bfd3e239ea02e12c897749d9927a59ca2278a374476ec2f243d529f 686fa562ed361e7f8465492187e576c1da94f292cc1073a1645a2d9c7552f0d7 fec1fc4120e3efab133324cf5af9a9e91a220e29e2b442f84ba062391f187bd4 113f6bda2b31cfc3f6016605e7f3150cba3651c2c9aa26a7480fca618b2c87f0 711614d7febee595fd7d13701e1e57b96a9c53cb9a4e41c8c5c5a076fbd0449d c73f990962815a95e257feb616f65f727e5baeadead52e63395c7bfa770072db f534f06dd6f4a2dbcb7cfaa4e33011615ac752848c073bb26e4699a432c8da6f 768c7b72582eae6b69d19176b09126e717684ac12097cb66abc105f47164998a d785be1102d8501469587baebc7abe6c3188d02cf72f808e30e8fd8749195855 73f8adac27f584069ade9d43efe0efa72e0f6924b2337650bb211cc274c45257 beb2650cc093174203543509298060d368f52065f822e2fd6a6d0a86102142f9 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 false +check_ring_signature bb47a511560c7eb88e710f50c2ea47dbb4389c4916ec19edcee04853b9165705 0646e45ef457cd8637960284cb759c2dfc4ed6628569a36676ee466b0d78a7ff 105 758f3a7249beb47702a1f913234cc8fdcaa50d81c399247a3823604aa98ebe6c 29e286e61d14c7c72b1d7e87ca2aeb820bccdd2acc3b7b2a0459436446096c95 9e45a40dd0d4d7a8c51b784d8f6eb7f8093291149e9b08d773507010ab6a43ab f74630b121d8837e8f82fb069c5c2a4fdfa413fe19822b4acd71458cd1449035 6275a3e58e4d2a019e8feeb0c5b23a224110080ce24347a694d9d727fd937e38 c743080586c2316449650ae8ace72d41636e6aa1b1e1f9e0322ce1ac7135d86b c24c4d577f75c313a6dd7c3baf6f76ee8092fb9389e81c5971d0724331cc3c77 9e846b33814bb3d36d697682392bf9e267f4aa444701fa7ddee106b7de939940 67d53d50c0835c326f4112de5fdd2bbca05c2df224152597ccde3d174b7ea937 8f7ffd5fabbd5c2df7bd9db633829f40a943e5857f2966835374d5b81c94e1ed a6ee2e158e6152bdfc5c7e0932dc415d6c57328d040f3e8092d4a6875206e128 2064513d754d54b51cb513a10a7ecc498b93dbf820271f10f74e322dcca1d6e5 c951a89f0844f7faacb67f6f004bf0d2b5d846c8108f45590c9f5d5257e19f66 59edbf51b328a0296897fc5cca6502643ed712242a3b2a3065c2521dd02ba92d 27590db95f5cf84e1c08b004f143d3c675e51e8f49d88711190a3b463f665996 338d243a84051632571cbf601e41195591bb1e061febdb3025a848ce72010f61 3b53f50c9772650a7b1e575b0367ad01a72a58029fa8fc494c874352366b1c4e e90ac22aed7cb40b61fab3f04ccc96a148f959b51e2f1d3a3926e7753d152495 9d4ac0204ffc263849c02ac8381f924ee076afa8756014ab900de18fd5ebe8f5 dc07acae81eb05597a169a9252075d15b7f8bec1b7b36d1ba2a67c448fc3f8e1 0062cc04c740e47766a55989463c676116e3ca68a8dc14938c735e10685ff3e5 fa5c3385b44796dc760172a9543175660d15b8da2324a2a4ae6e9a8cdb063fc9 fad986c7780fd91e23bfb5e6c78c8dd517442c13bd29661bc41eed516d110196 ab267d18c5bd397285ec2c36875c4c811d1243001383d58a196c66389a348cf9 3b35801e80de8d8cfc250ddf1b6004c898dcda8867ba2c1eacc02de7b8d433e7 6a1482fdaf5cc86c1c3c703dd6d228f3f867511a1b02d42e663cb94905eba341 57cbeef71787caba3ba36ed525f0f84460d256193befc90400c81b15569aed4b 763f9174626df632f99a529221b6954faff513c0c0ac38f15bf1970cc08681a9 bec0683b888a739b2d5f2c44ae876ac9440a71bdb9fcb3ced2baaae82adb68a1 9e9375e4767a8180c42f811b9dde2cfa0dedb7a38d44b90bb0c4ba582c4e8f0d 3175cbdbbae5d9d08dea6bd225368eb2f7aaca3378d8b175e15fbadab5dc000b 4eb489000dcf9872c254a5122807d081f1f10719163a5a7da98ab90590dc3f28 60272735e0d4157af04f5d9f3832f79a5748dff997888bd5655b870d9282ec08 3ddc08d88e77bb2d28b20313cbbcc6cdc6f373923608a3e0cfc9082896724322 9de846490289a2688ff94f073ccf41619161adb07b998352184a8346ef830d8e c39f018b6471bb166d7b6d0cac17549eca1029245b0a2a8931d2efa5f764f828 7bc0cf3cae4e7e35ebba5dfa8a205b050dead5d522a3afd88099c45dc7a15c9c dae33af30ac2ef764da794ff5ef7b3c30e43d6e625b24e328e7076de3f75c50c 5b786902285b4290dbe0c5cb3a65b6fcb918bd57cb6525019c4e751757ae4327 fb3db6515c39d442fe96a4780d72e490de7a4e4dc5d12f3ec2630e6bd098c028 32e8ad0823d5f94afcb535ef55776be1ab52d446b4a72be9706550f9dbb4f821 8c5841171cdfd8e5b43d92cec90d93add337ffb2fc61827bca583e07ec63ee2c 90686dfb958c36f4864676c77af5fa27d1ec743f0d8216a9959415b92c37d506 19efdda6b9ed6bdcad8ef0fb0f367bcc5681c714f1ca90482e73937e310b209c 39a0e3c0273e9e3837da7aac74f9951bd2b7c257f8b0eb5ddc66f92c46d951f3 49b48d769b3a510919c09681e65fd1e630c207f894f26da2ecbe31eabf9fbcca 3962b62036a3730b96116636577454d6b2438d7c84346c30b2062b862d0525a7 0b0593ac1b127c68906d9e4229450bac3c01adf2f07520f1468d8284443364eb 24b212d5723de717d2980b9ade1664e8d6e954916b52993d807a138b1e4d1af0 2031a5d37a7dea2cbd1b67b8be8baad204a35b762a7c5d66abde5851c52593ed 1d4b1c2dee82a201c4c5549e496e30fad0d403e511d695f078762d7e4d5e0138 5f2246f226b91c1c043f3c1930a4c919678fe8661ed91bc62e79e5c800896d08 b722154493253251be7c83194b83f9ac9f95037e63f3b4e5b40b0a7b8bf53e8e 0aeecae0a098da0c2f640d48043824159d95132d45b0de7be3cc188d4379d863 c4f8f27fcf58c1dbcd69236fff31aca140470b981eac5bdc54a2c0706f7de0d8 02b969c780af6742265edfa0ced4a8a1452c775092c2a262a446baa78a6b5f74 ac500ec94e34f35b2099cc0219f71324110f9c45bcbc4537363d8f613b73a103 139464b8a4eb46ec4deeba5a191835fb4caa71fe3bc7706e26f452dd3df78e18 6324a2424a519892702bf0c4e930e9e3f7206ce135f9e6859131e49d989518de e5ec76f27d4c3fe7212287351b21ceab573a93fa4035cbd9fb8a4addddf6484b 1a7aee9e7d56f8617889e0ea91b1fa0dafd061295c1b46d06ce7f704e9904e1a 97378108042c01c4a3ed042948b1862b10e4b55c0d24827f82bea49a18bf99db 7a1c0c9866e4af3afb1d7b28b8649d403cd325532aa45e737d6b12894866d482 c3237ea704a143f1c7c5a387d80d3c31500658f0e3a981cdeb9c33537a43eb2c d10f979522cf06afcfa22d8b19b8caa1510575c6c99db4556fb04f070c73a367 11a50356660f05758b619dc80ff75d78d5c2ec7e77e2ef95c77d418e3f7a5e5d 8ac6e8c53f09918a832081585098c681a3b1515438af9e45d35a83ceb51cbb14 ca023cc34a94410dfbc528f5df399d410b572614baad239c505be5eb9ef8d6a9 ecd25718d233f9033bbdad9536ad5c66e04a3a4a5f24c3cc902bcb28436b4c46 ec3e41855f7c1786e6524eca25119af510a20eada566f1971763f53d8be7dcb4 c2d7a25b4a40de91f09e5709cc1ef84664f1b5c23e2bdc715dbb6d0d7e3f3f69 1e6c9b6929cea1ca575a726a5c048f9ce67a99480cc640ed67601d38238dbc82 6a3b7b639048d2c99056988373b4163c4c7c49441a1ee100bab0b2925b23a907 0e5235f4e21f7e1cc7d7aa7ff6f5e4e1bef1a7bcd5c8249741f9ca4ec63192c2 b5cecf25183a6becd879529259f3e1e6d81567a6480d6b4a5251030581ba31df 8fe69b9aa857a1208f9a7dd25f0535dab5180b28e96322a11bd4eee5ee2436b4 3a547e5ccd23e3ac5219212b2e79fc9735947ae974a513dccd7ffd659e8349c6 aa747a3e572145bd124ed8964b076e3ec9e94d80c9593f1813b4c904c443e97d dd5d6619c3ac5679f2a6872538c5f1c5e9967ceac44c33f6296bd6b1219ba3f4 580bf3e1cc1a5c676ca0ecd4de3ae75049558c618dbb2e9fb633d352f75cd4be 8cbde00ce32ecc2fbe3e6e33e3aaf1a83fedf2ae6897d575fd9d5e6aff7af525 754756b21faa79496204038cd3856b7c1f83515744f82faad773c598a043a586 df7865be23bb2f943b7270c9d79aa427841f79a0da937a319d3128b82ecf361e a4974d32c012060dc623118e46c9844187a70c746459721486f1468a76f57ca2 9b2190ddf92a0be5266536cd84370def70dbea9a0c8d43a82acf2de21ab32742 90605a955d7393b210d36b3f758d2994fdac8e677b45cce9affe56880dca20a1 036207315e5036f2196d12493e3123ff512d83a3ed166cb4d6ad05cd36b83dd2 8eb5b7dc8e3aa947723329a760faf010a1c363cba464f13c20364957151e9ae9 e0c1bd13217e3827c05695a74f5c7237dd5221569710d28f063ac85ba60e6176 83a59c461c9bc935f3c451eb081c736fadf1482a5f2ccbe0650f154a6db55374 95833040ee64350cdd0b4217624ec208e46ba1fe9aff020c1f1abb93f864cb32 9947dea6682e80687e1c2a81467c341728c441e7addeca837473b720604f4311 efb0dec2dcf146a699a0944748f34b5f04b46589e9df9518b2036ad9fc6e565b 737f5a77c10f8a457317becd8a0bf1e199417c86b0911611be6eb978743a5d38 ed19e3f79b5bd036a369567de2395068b32dc613cc693add61b22a3d94f1f025 258e1fa53eb01dd9d0b89f34a5acc29e66ededac454646fe001d9f29715cbb20 d0af2b09f045c9b80d17016fb0910e8c36c0c363cff6c4358363346d34cfa03c 0cbd2b5054699cde4ebfa3f8398d2de8b85a5518b8f7969ecbc7e13aaf3ca01b d540c95052467e0d977ac7dc22ec36dd4cd03508ab7ca0bf5deb5b0e167bb55c dfa365f16d0ed6645d908efc104a69fa66e699e871023145645df7eb2f7cf620 f178c4cd2b6a32e7e5654f257d3796ebd398a28f8f45326cbd2eff1ffb2e01de a5db5899b905046eb3d38c78c166f3b0d62bde3425dc536cf5005f6d43662884 cad43fccfb7e544cd06300f1ce7813d96465442612a1b5dedb53028b82c2255e f8b46426a2217b9d903102704062ad259717387425854d4518edc893c929796e 459c91e559dee364075a261c05b96b76444943748a07d1f3ac53c4e461779418 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 true +check_ring_signature b14d81b6094414a9ad43bb61a9e8bb75ca9d2fa088417499ff3b4ed52c088551 5d4589e61253cfd7d6a32eb8ed35e937e91fdd98d4b24b67962a5e957816ebac 1 952fdfc58c8c9099762ff13932cc5e4de07194147c1278bcdebacbd833ce3978 c8ae00eaf1526efc1af9c73f0256af4135273935b28e0ed7183f406cf762e0005cb8e55a175106482fa88f982674f4c22c233de7361485fbc08b4d9d9cd4bf01 false +check_ring_signature 297d731a59fefd45fd399dd0b1e2ad409f01ad67eb8128c541971739e55e4942 f8a99ce84781280be3658e8c72e80ccc1efbaac596709b60e5ed715434353280 53 36274d7275fd90886f4716a7b08fd363b533aedd457fdeb1e8ea3c814becea5b cd28aeb23c28ad7a53a5dc58e47e752a58cfc49ba12b47cca3413b3cb04f7898 55259b53e809e46e6064f555eec026621834f2fa287043d0e4539e7f7531631d 528acd5b22f027003a273b3e6bca73a4e590de1b22a27a35bc5b8d8f73f29ab6 68ccf124607b9f476e07abe64781d16d85fb23574b0415c150996ade07f4ef46 f3dbaaf0f1463e94831caa984a811f4986d199737c2916b8f264e1ce1f444e20 35bcc89dd64ccab57d70fd46100395371f8a53598fc1b138a9c11ef2eb46291c e156d11f60dc2de4f48ce6e4149a79e267103e42eda341420832761ee3c2067f 3178b2123fb82d5af54c45aa6540f6767b187b7fc84aa7f1378f5d792b63e8a4 8b4d1e544aa3b960bab3c275e4b78c44394e2ba1c7da4f6f09ac4235b9887b4d baf042e4efbc3d970596591adca61e075284a412464ee9f0a6c700157e029b57 8062693988da149d1592960893aa1584e83763defd5510c7899a91c1a358300d ae191f4df4c2802fb7fa57bb826b0b720a3ea12c08629285ac14f34816d32e81 c9763ac2cfe5f955fdb936b4b663a0a3e55b3be32dba10e2698f9e2732454a56 2bc8b852d3f942f490d252ae86f5c1b0da906c35e1fe6328bf15c5742e716088 2fe0045f0b21977ef84fa4b2195f59b98078a3f64754aef60cc317235515e6ae 7050e33786c114329c718aa338499c90451ae9af1a1430cc809b1b515635f8c8 d64004d4c2553acd490c38d5a6835870cb5bd353738dbba5e49d897aa54e7232 f5fffb4f6a4ad76a02c1a0242f6e3a57202703cbc3989b58019c898fdf8b08da 3cb1eb44f9b1a59f664b47aa90dcecc71580a61f6e09861843575a0898cff01f 6298b8cc64d15ca17c418adbd4f01881b28b9cac5a12642780af764584d73ed6 cf414b7814ca1b7a7ef55e9d0b1341ef3736331e731682a4fde014632c23f030 b0ba38a7f69446f11ab19923fc6212b2e39b0ec3ed7645c74d988b73332a3843 66d7ecf0bba045b73ef394bb7d2b745c852a2fbf1822cbf17c6ac09f571f8715 e5517dfac9bb68535bef19f6a9853574d44e7013e0b1b7b6ef34bbbe2107a617 1681268988518210f2c8f9a202e045e32d720e958b90eb03e374e92463e184ab f8d63a6e0cce442b6d92eafe2c9a5644b4c8160a674a3fe2acbcd24a5a6a900a 4876f91d5605649c1957a15556c89700411ed617dee1f5b0fedb59b60c9e9320 337cee8759d753bafee2ca4a6f21838eea5efc1643c90e3b260c253683b50ecc 07da21cb19e1ab8084978afcbdca44fc0acafa5da690726d5bf12d69c2144efd 96221610a96be84ef033ad8996e427adfa16ace6d65577389204a9f59c3fea57 0f16bed7039b45632fc432745ab7a273bcef4bb34bb47ba4e91a380025c91c80 3b2423c65fb114b03ba5dd69ea00d3fc5ae3a33ec71a232cbd6a62e454ea55a0 e060d1fc0a31a8cbfb657bdcbf741589fc6902aa5691661be468c3b22f43ee39 962732f7ec5f5eb51ecaa78e4027f3388c586ad8493d35019daebe881576243e 9c977d6fa3033cf2f3ff299f9d072757ab505c2f65ab5c8f0b39f6fa69250bc3 310403471d1857b7092b9f07f5563d758d935e82ebf1a68b350fc0538d4e40a5 c8795d609cbbef4177a8e65b6352b793183dca30b789e5a93b151585a321df99 7cc49a9a936775b0324af903bcd274c02efb5d54d70b7959d03bbada1615ad82 f2646f7a4404ebea70019fc52a30e7f834ff20cdd855e2095760aa4f3aadca9f 751e2ee769db3ffb4a59b995f0e6d26a87563708df17716a0c634162dfb689f4 2f7b513459108bdb2bd223e74097010e29442165d1e80689b249287a3e3e3447 87ce730683ddf6e9150683219d96d17345aaf7c03c0c1aaaed9b981f78053b99 3a762656613ba61a9a9ab2b27a68fac104e6668671ffe870effb71c2d6c4cf6b 4121ad33cfd14107504f4808d6509c90dcb3a84de340d36ac5703845e89c48d1 b47f210d0c5b8a6e0be660af1612027bc38aaac095619d489a802b3788c71bfd 36db42c455da5d405c28df7fa4b16921b74a4bf016b6cc2653300ba6dda9878d f11b91c7eb648254b28298803260dad11785144dca7ce209423aa3fe8c5bcd53 15e4d78ea688f6b9e394a3e39568cff0a83977707ce614e8f1a7d949e1426853 7c808c64921ecf0e36031e01682b909976cc8783bd1b733f24d365c081f4ca17 1b71491aa6cbb8f1db0248fc87eafb616fe2aa57ef008cc74e9fc7b1afdf3550 7289521297e299ef1a1f1bb63a89e0e1e1c573f1063bc3e8dea4a71e81775e5e 23f231e314d32faee1e15257360a5f790af608680c6f4a886d000f0dc139fa57 a591b9fcdf48d3999691dd6a5af500348945656c7fc8244d8f33e623757c6c0d5538b314a9b1251ea78d5e453f0b61fe52bb1f1fbbd53c949f5b59c902284305c5612bfd5313f1b1518db2649b96d34ee703996901a90993da714f0c1f323f02c91474c3e68b15bcc4b3a68afe1097c3889c24b4c0de9731674cb385ab41e700e337cca883164b1860bb1b62fce651d61da94fdff72ae3a7e17fbd1a6c3b4c0219e405e443545de15c2d848f4e6ad226e9b7fe595321feaca7091ee88d3fac0eb360ce88bf91827a19a3f0d2a4fb07260c3a437720ab4e7a2ba2c4fae22da30ad4202a9e3c67f6bae16050bab68c0bbf527918474dc9a740fc1bcde8cf8e01022b892b9b5b1fe374c662d7ce08c08f21d2324d55a921f777ebcf761a24861a06c24bf8c340c6dbbf9e90c199499df2cb98fb141069e6b350ba4f0065367a1300048011797ac47505040a4fc4fa5742b62da119d6c066f4a12ce7912e8098ec0bbd1d6eacbc7fffb70460ad4fc2482427a95b0648c373ab80e05416287e14e707483841fc52e58b2ab5e10e620bf254a04f1d79f833ee46d7bb95469b7a7d7a45fa2933bbd5d4eb8dd9636741a19aa71521a949a924deaddf37715eea8970bb08bef9395714c65723d6d78839c90b023795a03be9e1a627de8cac786f155d7f0fa86a492dc42bd3b814d79861f77bc755a2dcf7d56d0128ddf6cf0d5640a2af00e8ef2ea19e532d6792ddecfa082a08ebc2c6825357ecf1f7ae8361ae1f86e00b16b4a4335892ffcfe16759e0327d772ad0939c142ca6eaaad0e05ce4868c08008492ecadeaf24f1d192f9ae338b6384ee9f111286b3e1ad6afc4d88c6c0f9400f1d2ba384faffce0c3acd1ee1e731d782ebe18e287ec8afa37ad4c00dbf7820163c4e34fb025a655878229dfb37804fc92fe8b0f3f555e2213eb3ed9db1c0e05fe016f3f4a31a660429bc11b0e810a51f30df0aa07e32df780c402b2e8a03e0d835ba75a9e7ba5a62c3f1e083225d02458c2f97f35ca89754b2fe4143f0cfe060aa5fbd84d55b7746f42e1e38ba28137005fff5909c2388a7f7e0caf4cb84d0306a8bc11960b5dfc34c88c8bae8df679a16ab44736a08ab70a8412474b97620eddd0986dce0e522ba32dac1cfc38692ae986a8b8001f13a31ff22acb84e0da011a802e2f19e39529ae794a66afae6d796435e4088bd1744b3844804fd3a56c007688e1462a1271f2e78f9a7d18f4f536f37219bc23c43e39cc0f707e4a226a0ca433687eebe0b2f75a54bf23e894ca986cdae4d9a6eb85601fbd6eb96b74da041998efa06a1206eb368627164997844d13b7eff729917e03bd50a588fc0cf902e003fd000f5dee8427d7b5b726b400943166381d2d95e4bcda80dd7ea38d310784b8ff570789f9006d69b5815f38b526d7deee6f692069c66b129fcdf7fea00905a88702032db31fd74c1f5457ee1306abff68e9fc29f2f0345524df68088807858a9e6157b7eec351be3f33e8feb322edc22a651963a02eef1da755b57bd10b340f5a9c9cc60cf4af189962b283009f5dac620dc27e885e7f63da4c0fa706039b4bb24b49b8037b5a956bfd5142476ddae547f6cd9fa44fe49ddce8f06c230f5524e21d184c54deaf9e2832b39748e4de00d8e20948e25bdd6e745a87202009b5dd16223cf6a931d96941e63c71d17f25e681b78a50f57e8ac276e343c43c047c16eb2e8ca25ccbe7a26dcbda211ca0d5c4c66a52659bf58c2cfd611d13f40bdb2fa93307789703c8341fe4fb4fe4c07ede876f7d8066503b31f831200d6608f9bb73d89c8ab01f6296223948560b8dd8cac78b8ff7d4377616f122fde1f502b29598881ec1901739853dbd0fac330f000733e7833fe23ad206a327a005fc042ab00d59a20a6b5c72a685b86ce91ed73a5dcd039d75b2cc41304ac538e9080793c644114f658c249b1166d65aaa6856bacdcae12b280768f2b6772661f92c0ee3b5fcd701d5136a85fd7905955214c7131bdd50e9e32ad2b4b9c4a850e4e70f7ca9ee2b50483609ec24d975691dc56fa29a90d019c00d654aa9d07c717dfa0d8276bedf807de4e2d48c98c80797083da1f1f9e11c0093c8e08fe7a1f7d9d906f2c9d0556c20a2e972067d0fc9373ccb42711c05647fc797d7709bbb5da95b0578ded814eaadd3af4c62ce1eb484df6df7a43596ec29ebc97ca038afb3e24a0a6619083ffaef69a730ec840b71dcbc1b0466f5f101e070e03375c2b258eca20c32b0b8ee9df3ea982dc99d3088312d3992fc55a5cec822e77fe894e99deddd032cc38fa8f42bf953cc6590e5ed05f1f29b180670322067114044cf4af2b8a50e5d67b9ca897bdc401017224917b1909339a9c948517da30ecfe390d1cc7d910dd472f9deefd8c101e02154e0044622de5707fe134239295dac1cefebc8ef9600d6f14fbce1dbb3234a88c144eefdac383ee687c2f08e41e5df0aef84d4c3970f74081fab1f9076b086f82d5ff5de98c2fe9ff0e00828c55e7507104dab3c220eabda11a0acda53d2c99956e723e0f196956ffb5608791535c4fea0e433c66b05470959aa0920eb8b8c9126f584788ee647f80918451c861c3128e1c010e30307ef21bb6246cf58bb9de4f0ad964121649f2d1b030676972fd631c2c8c57a3c0942e0a79e4dce56abd4fbbda867c140151cdf41f20403ab6c75da1849bba7f90af7075f8bb273579cfe9dd72bc384d11b026f13d4e7bef8f04540cf6e6ebc47075d9962b2d483b051e2e94275f0588a191791cdd5a24bef1507803d02bffa510b7d15b2cf428194fc816032cd2fd683495dab58834ae4ff78d7e16a800253810d6903699ee0f3c3c6b74a4395675108a98fca9203c8358dc6f575941a5bce7609d0e260f9be21cb8ae44ddf3952778cc85a07f7dc6a38c65ad787da16c2ca1d01157029dff5b19117df883fc6251c4ac57d41b16883d2cb2d0922b3865aef48016f5cb24b30eb2e0f1cbc35dab47fb7ff1c5ff16653216980d77d04a7ae6875024470ff4793f079d24a7e70e7ef78f3e6db387cc7b1695af03c54bf13b64acc0791af66e8d3d4d81de8a101b89dfc1bddca0c4503307bb75f90acbc030055590cfc18a7dfd1f3e6c03303344824fa979da672ae2549f6616507c121ccfd83980467c54010add5818e01e63449eae902ae6b3ffa4f2bbfa7a889413cfacb0c1b0d124d09aa24f256aa1563de97276baf3b2a9fff7af5260ff9c01dbd67dbe61407c4c3756fe61acfb28ea85f49c397996bb87bb228cec8f2f69a5ee758bfd2fa0a27ac09d211a7ad6a868bf0336ecce88bd2fded64b8ff35595c1b7c9ff78b480cc8d32887e23251314da0b1722714f052f8b092fee8f9feb2ea77068e06435a0f0e52d777cc3cee9606e2ab42d1321dd2530dc817a8afc3df476f76ed7773b00746cae29e59ec8cd0b84ef45e1fd1563f21bc7f26e8a8be64b6a7ca39027e7a08e9bd5fbc5637ffdd37972e87af50a894d6a4276db5bfcbe3f38a31b80c7e5a0e45149498f1d5e0df1664ff839bb67fd7b664db6980e5156babcba42a22b4d009acc08f95f512aeeb6e86b4d4a5b2502f97be2574694b8f95d45b08809dcd46097182caae5b5d9d7a36bc846567b31d704836f0de27c7e99a7e5a79488b7723014a71e089678f26a493716d187cee5830edb28f5df6d001c69cba26eb5d5b1b08a93b04c40e539660329c3b36bff1351f1dd6b081e5478471d80011f57c8fef00cd07edc64785ac8d3f1eb52d29b6e878af2d1103a8b6f7e76cdbd4af1b868102e90968ede65a6d297d1f71a1aa062b564a0230a500e0486d6a6329b96124fe0f13d6d9c6f37adb3b6b96d419aebf996d4021f6204ce3baeb234aeb7058efb908ae332019c29613c7866a4b9066b10b0ef0b6d919c3bee0199137a7ee63b21f02c4ffcd817255c92f863f7d1e1c7c87eb093fe1bb66b891c0625ccd259f4b1c088088a1a492a76bf8f2023ecd65a774c52488472896595da2b3745b3593f9e80285f9f1b479e00d4c2ea4de19004164679cb51683524198a4f6569a1726b3b10da3bc717521836ad73e2f8df4a71c668312c8703c7cfd2e5b557fd51cb8abd20783ade7aecb2e7121839a0450b2337448393bb5b5c1bbfde5cc2a67c027c8c103affe56aa8f923308222ed74a61faae6c332cee753277055a7d599849aced00932ccf598a1f87c03204bba2409e48c399edc206a45d5ab06739ef202d02836c070a2510eb57ca553165749ff015cd21f874f058c1513624657ecaf840cee4ab07f0c911c5e95cfb6015d053ef172fdb3a97c0c35931c3e8e13248190f21b7350f3bc1540659ae4c10d07b4bf7937436f5189093ea4a301d77337ece925c14ee08fdde310c0db7fc6d59b1480ba23cae676b703bcb06236a74b2fe7d725f96ee07e55abc77761663077488a561e53480dc54fc4fae193ca649a19646d437134a0849da9628a6413aa16e8b904a5304d32d22c8059363cf39d3d6fafb53f50c0904fd9ee9d74408b9a263fe17662c8d3a22e261561e8095ea509e516583e453cb4e6086fc79616e324a16ae3795a90fe1c95be24e512533397492a125931753e7064fc4b310403b8f7cd9f3bef488754ff334f0f5489647f642d2efced346be360a271fbe8f0b5fec82bc3dc97989de1e4433f72f1afc1e0e1d5f4954a344569f0718fbfe53c166645489f41ccb6ed2c7d6bb51e82f875afa8cb17503855fb15debdcc8972c11333fc574748d6f61963bce31244ffcc5d682538d5346a0fd2e1d04 false +check_ring_signature 1bb62d3b495dbc3cd90ef33683cb91822a67e425c03b9e8788061984a1b7024c ef94eed4c643543a0ef56f53cbe840ae2f972d9c0995915a77ed3d2e0dd76a83 4 82bec121e119942329ab5b964c76573a8b005cb42c872ff390f39e1e708b0949 63bafb05b0aaed5083c7b22a3108bb39d18ec71b28f3ec8cdeec037ca683946a a19b1997d05a0bbe00189ea00a62513b7484092636a90da51cbb78666c982148 f578de6b3f29eb1f2963bf13023957495eda47fb4b30ddcdb53ad373d194ed3c 7ebbd275f271ccc80eb94df133de9d5194007faf0c60d89319e465023e1ed90c065d8a560ef8cf87c12376cb171f71f0687514fb0b64e8613fb0ef417264df0373d6b73c4fea55aa01dc53238108ed7d8d211effc8a79c3ebfb42018ea0b380a56372fae4aaa5596e44eb5164b3d42aff306a8fe95965294f2c60e28e75a030a7ab9b39dceea8eeb774c553c27907374711acf18cf209c198c01b532020eeb09fb3a1f38065c0feacd1db5366c71cf560039c79ac475143b95b49bdcc2fc7609418a3077d7ef53792ca67d5bc2716e07f1248821f72a933e4540a251548310081ceb66286c1f876464eef64e5034a9e599fa587f9d89f080012702fc5e76a806 false +check_ring_signature b04b4d4b6c3917204674bac1b80ee84ddf272341de00a513059dbe497bf59952 553f7c3c5ab64565677f7dc0c243b6b69445ecff93969743237708e7f0b2beb5 1 387ad7cbd077f5cfb5235d44dd32a9f487e649c7d9fa4ceee114faf9dd2d034b 62f21f8fad004f842d7e270111f4623037e0471e699ad8911f66941e68de66c0169e1332ce2be9772e35de2261509d0eda65da2e011b111e74404b6f472c351f false +check_ring_signature b458df7d89fc857e918d070106f925ff730e0ce983b715dd2f0190c21f16c7b1 34689cbe6a2f1252959244093d1f6d90c25ede019a6040d5dfd50df80cc85bcf 15 61f1bb12ca5db412fe3d9051d4bfe0e5f2d741cd971db2ad9402c770557eb5b8 37f9a0cc77fa2cdd035eb01a7c2283c2f1e70653898086c75461061c294eb9d5 630c6c7c2e8a7bb028243e869b871641c5175466c9c3a299cc422dafb5231e93 75f4a7a2b665aa3b88c2c3596b4e88c0aa83c0a09cf8e2ca07f47de228ff9d09 b3f3cc7bf731cc6abd97c7f829034912682f027f8039209af7bb42c7268d0cb0 7b092484f189de0c8916f57014c53d97124abae346dedfd77e43a6ec7716d7c3 098a1571989d633dd40da8fc1d897ddca8035d8d02106a059eede40d1703df59 b874425ba8375f6bc89d4a0bdf65b4e74a916864ec909fc932faa6b92dd46139 f80ab332aa5e78df06b9f126c9e5bc80ca6924244582a3174741a16f40453d08 70b76f3f2bbfccab6092ddd9f542ed659deb0a2dbf00990523cb545bdb46e95a db0da1e874e71cf22171bf8b897cb3de56adcfd914d7d5b231aa6ac2da073a84 1789ca90e77d39fa1f07dc99bb77962942c5e1543cffa544faf288f16330c9ea 39f79ffa996a72c5c2cfa89dad5784befdea062e1a2a4e55b9c904fb67ec9a91 cdfa37694bb8beafe891c35b3cedf64e063b315519452bfce2c3df2aac765f0a a9becedc6b6f8386883f3413b87671076bb2375570558f72c38db4310493193f 8e0cff1ae76ffa5f0611dbb2a29fb1cfc01c96ca9566bdc38dd6de80729f01042dc6fa59424de5be15c58486d92850444dc6b121bd33ab307a112c4f0af8860ffba63a11062daa4e29d2e1d8ed029011f06f65659422df042f2cf3e44cb2fd0fe184bae0c013e2e4f0714817af07329371d31eac2f9a2ba71878c63861606b0b17dfe83ccbcdceca3bb1cad4e2422920c933f464be483f456022536216c801010e82832240db9ce0dac540af1636d4dfa145fc2db2ac2c373adb62fe6ce81e084d191181acb2a54bd9b0f6d0191fe9f0ec262b536bf1e25bdd34cb7f1f02f80be2d7122a0712c2836f72fa0c102571dbf27477ce67e60cacb19cda42f11dbb0043696cebb08838dee3022872932d0284f3064a94b7f58137835ce03a7d10400119d6f03d58b881c5b2e9b118a9c9447dca452c8a82fac0a8a5aa37814ea05e0d5f2966782e90bcc463a7a3f862a77dc9fd83b6663d9afbc0431d49605074db07be8893dcfa324610fd81c3d59911c2413847faa0456c35dfdff0db062baf71b43cd06f212563c5e9a5dd9e32d826a1be2bad6069380e3e7808ddd6a649168d0aa31b181200abec1ae42c8526c4492eb9abee7f511fdebe605991053a04888903271d1790b1dbbbe4cb48af8966f78e678def8600d7fbab1145c33a600a5a6e03c6f443888dae6b6aa08bd89698648aad1fb43e26d2eb0b78152c03ec6a517c0209f5b6e8e0a93e2339ce2512d69b6eaf5ae97ef9e434e877878a809f6bdf320a879640150ad5020ff310a6d86a68c3ccac0145a5d38207d152bf14d54ddde608caf9fab6ebdc20f700c65edfd26d3e94f7439a401e0b3fed4a890bf4d298390ef794941935258e32c320acc80a56fa02f3d0834e2246ff77f6fdc7304bfc2a09dedb144d370be6eda8c7dbb808345881f86fc978b3d7bfc762a7b9cba6659508e314fbe57c3a23f508bbe3bac62eceaa5a412d3f6a5ea018749b0d0ef53f4d06d892c71c09efb6ca7899960a2366fd60f430bcac9e6fecb3ff36401041e6bd035f4354a1458755e97af13e2a8ceba3f4d348c92f149b636216e819615bb09504606d2fd5a7a92b06cea7d304cecb54b5d7e97f5dca7bfe18ad1853c8d2c43603d03dd169f88f9a40c5059945bbbeec21585342d350a6d7f09d5f5f7eab9b040c074f8ea66e3a400d820d3f56ee1ff5ce40c2a507877ad6a218d9149fcc42da058d40f10d5a440ccd67e09bd51da203b12b634db61106de8cba916f4353e2070448eb00488c4c0a2a3ec0b660f762b15f929cbc037b5369c64ffb09ea0be59e0a584e63fbd9f4b1fc4a8d37b4c3d380934d07eecd7ad7907a6330251bb1bfd00c false +check_ring_signature 85d30353ee783d9d4edc60a4146e40f7639369520b3e763a1cc8fa83b13b0808 bf7f712e7638017b0111d48f529b09b46258a09293bb6c9401ffecfe0fa6e145 19 3684f0c767681a1cdce39986ebebf8549c1454ea8865fd4b0f4af839afd3e2b0 295ef62e37d00af2f18d71478bd0e08bd7a2e37b633c31fea444832f74874c55 2a63dede5b30700f539eef750cc019836fbfa65b9c6fb301e048aab3ba8e3472 45de0c043a2340e2ac3076eabb7512db98cee55f8778a958e1b2988415677ec9 ba8ecb332999377aa54a61f5dd9859634c0206e0db50ddea0f2412b010d0d5e6 68884ec65d203906716a577f7ba4952d54022dc2b20ff844cf1f7c88e83e6ef4 062e84df16e7db60e4299e1d58141e1935eaf9baa2b436b3dcc2b96947a7aab9 c5dc35603ec8ca2c3c91e3a8db97d5fa38c4edd631d250cde1656ec63596618f 20acda6adceae53bdddd3dc03138dea2e3731ff6ff05c27384bb65ac4b2b098f bc4c3a92b9020e9ddd8b2c8837ba89d180b811d8df73db7e14a1a8650d8098a3 9ea77a09fd59ca73e3c90c4a4d6499ea2740ca53b419dc6ac6476959fed2456b 73d02b0f490c277b375c3cd043ce2b5f4dea5e7f3556d77c0ddb239a225f8f24 a89c725cb007dfef226b2717eb02d34f0d048277a28b333acce28c154751a7d2 27a21becb5c887ec053c73a0707afcffcabb9a3530bb7566a7e7ae2cb5290bbe 4b76f3f974cd4b8f04c636a2e2e1c12fe09982c529b3932ab8480d7f7a0399a5 93e507e1e8f46b4889e7dd264f402ec1c1529911ae23e246af1b236c38a5ef90 75ec35c5fe59557b889d0b512e366e762d82cc795a528ed92933995f08858d05 a0cbacd6f793453f02742609808f3c85f47d54764764e2d969d49d1fe80c8ca4 514e01e6d9f943f40454468fb8cc146226c7c4db8e0b63264acb56bd377a60f7 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 false +check_ring_signature c2490f6becf6f1f9587f3e77b201611ddb5686664c759b51bc438b6ebfc7985b 45070a532857b595db8b016b524659ae03d5a7e406ede2c1bfb00116fe219477 25 93d264a15c52fe97d72f83c27717cdf5cf4babcfddb2b04376fa4847f08c7e54 2811208ffdf7b8aa6a641b620fd90b943e21dee826733c02255cbf8885c9cb7c 40982113e5c858479febe81263c05c1c724869ea1a6db3876135d0a3977102af 103edb93ae47287ad03df3f8b636ce6a8abf19e7dbcf945174a6d9b3c06ca8b6 d52e1459b13334eb326a62a9b38e1ee5ce24c7d5aeb9c579c7c96e57731d2c0a 3609b620391deb4d1b2c2a01967744f1c8e056b51cbaf7933b5adcd2c40b9b06 75a01b936dc45ee252554ab01e748d69e9bff61b5350bac16c2c2fb06358fe7f a654ea2e49e1d79cc53c7f41f61fd0448c16f1d0f325b0a116035cbd64420100 4ea20f1e3eee368d7ebc70bcb5d72351fc4dda029e90cd5b4c7743d1be3c7b86 3b3a8172cb96d76c38c711ee03905493387078b41725e5b4d076b47ffe6d5cc2 9bef5143215218a41442293b8b01dbaf709fd02cf642a5822f2bf84099cf2cb5 62a89731c2c8d8bb398a4996cad19d1c90a7d46ad651c3c5d7abb445c10a26a7 1d2f497d16b82a69b3ce7be257cc911eeff89b7f3dd3b863c9f47e9ddd12a1f9 f6946b1f31f1881fd6f5304d4653b687f1f62f9ec233c2aab99dbb01f29fd8e0 b3a46794421b17c3c8351f6cd6410264746860899cea2f22ec6e94dab482cc92 eaedd48f95522ccb38646d2f846e8a63d6171de9aa9ea55139f8aaf9a6231d6b 79def1d2f0c89432b05cabe96ae7f1c6354abc6c4198671ee27112bdd0ee73cd 3945a0834107b4c69eeaaa15857f94da17c02fa5a8c009604b2c28eb02ccf680 7c8e1967299a5a625b7f1d32adf57da409da7aa67e11158473e9a48e79366048 d25b295ba304454e8a6d59c1bdf972261545884f827abf45b1cf03be835eb6dc 09f5fe690ceff788a112ce274680e1178c10857dc1146b4d905e24754146625e df51c10932d12b7a3b13fa87e62dc8e4f5f35f4848bd1f25afde05869428bf01 6e4d20076fd20016e886a7e42ff851163a893e31e35b76dbde32dea7aa72306f 88c081eb3a57426f28a56de22ec7dbdd64143b58583d675ec1ae7c317a0e7ee3 2bbd64200714361da0eab012835793b63c6735581897958a9ad9a72d6a37b751 f3469ee609384359a4e6d9de2bcc0dc39f2656d22b6d894247fb5fb376d1390bb5e193579b002f06a9c33ce1f88d864d7ea405f028004e8086a8fb1d2c5e0c0e3bb6a56bd29978333e4a366c63ef584c1f31d1572ea710a6a12824bb5c8cbf22dd27a45e12a5b02aba9d6694e6b447471276aa598c4f456f542178fa09d71e06aeda174addd2aa0c2041d77b46f86c386b2fd0a206c6588d1b58a914f3b8d9033fd9bc2f13b952bce6c2ff78ec968c81f83811afeed9231eed64f5c88cf3c00573ce68e3be3d03accb88fdba696eb0ed66b26d1efcaa0394e50f66156f744e04e56d00c4402b6a12bb6f4b1599449a50b8b4b0aefb44d9bdb921597cdae68f0a7fa280d191e607b57789b44e9b8060590f8189eb20473d94b08a0a7f37a0db0cc543478145a5349277288ef631739497251428bb2325905fa7b44b57ab0b0b00a5ed3a10d28c07f0b407e7a6dd6cf55545c08b6445a6f0314f44a96e56eb1c0df0a64fe7c383178d22359abebf86aff7cb61ba89fb341d389863f0cec897fb03d08b03942251857e5565802e725148db54d0ae76bbd96c1d994295e2012de00aa4c20557a8ac1dc18cab328dbc5d51c10c1aedc91c2b7a0c1f4725e5dc09930d6d2965945a3c2d5185fb8931229b7cbe7ee232e8f6c8ee451f11434bd1fcc90a0179c4273ca6d04ab0de5684fc980e9b39c4fa9df2d1ad438c922e99169df30e060d3b41deeef4d357462a9cd87bf9d151ddac89f5d0e3ecfeb5ee3970fa0c0026852501d35648f51563c526923ec023c948152f2d4a61c9d5765deff19ed20dc575c172184454d17c4f4c2cb132fb86d20046dbe3e97f7342c3a1567c7ca50861754327c7fe9c41d6f4fe6dfd8bb2279c7dded2fe6d75ad3bd7b96333ae2f07e7b0732e313fed4804ea57d4a978c3328577f27456e0a52edfae626cf04d02070a362e364679aa3f8dcb74b7fa61b2ef387e22f29500e947e9636136b839c721b8b0cdd296f2e09043058ed245a465692018069157d2c99e32327b03ac9af300df44ddc1908af595f6f19dc00a1a43de38a80e5984487f79d5488ea59eeeeb045edaca6bee90ac81289c15d60fa0dbc6ecf82ede887a6e0c4fdb63f2337e2f0fbe68ceb77671b7147e9fa82df2036643df427295d69fb5b7b1b8f2f58802c806c27415310f65f4609512e6943be5a028bdd14498edfb5174a8bf20273c756009dfdd13fc057ea0b5035cf8451ea8bbd44547d6bf31ab6fc14edc64e0ff8dda01f9c5f469ae3c515974fefc3b73b90bd0f98d3ade36a6f17264a09541ac8eec04082c512241bf375c6cbf274ebdf1d74b7798576f752f40ccdd345341084e44a4bab4c0a44fd9bcc6f7a1cfb80432d309334cd2a270ae64fa03193e94ccebf10c2ce4e061c35058d6f13beebc263a5d991d9e50c2814497e7083bd235101b887335272b97136abcfac48d10080834dd04e10b42cefd1292708dc05abb86eccc0935152f6dd7f6d4911e50006a3e03a8ec6fe9faf92eae34f0053cb34ad676830c89c9ccf2d9900a34dc7f881362a9d081cfd8b951a49b5504685075d5efae920cab63e01cee9ea02b681459f6ac47f823550dbf88d709602b3e047b1db8cb8f05447b9de84a045eea303b9cdd4bc072b9247a8e4c3bc4efc44e28f0f159e01d0b7d4b785ffdcaed869f07a25ad63194a7f6d5e2127cd0856a325ee0eea2f5ae05154604649d401d6cbb04e0dbe6a54b6cd8d1248b2459ca8d1d0714c40d38000e037c81014efa1c855381369c486aef2448366654c5dc69f8440ca51ccb5fb10ac5ea83b0b948fb3c3bf3796f9b6982e4c0b6ad0d67bb0f0062e2e78fe7a2320fedc36607ef4374dcc81da14888876ae8da4ea99033c8f473df426d0d36d019038e4b47a562c3e23b3ca02dfefb77f5d06334cb108419c4e700d2ec3361abe80db72695f424b6b6e83acb7a827505848a99cfffa1c339a83551c1d88e3cd119094c83fa4d6457370cec0435c47aea968d458d42f4ef9177664b684010ea32090a901ec4ee5e1ec0d98a4d9906b6f14e9f214531b84597a408ecee099b2bea6508ee31f5ca326af36969409f8d65eed2de7f8d126899914ca5843622d0104b9106c60bca4889fafaf5759bfda644a89b274f8aaa97508600fa85136b806fa04009d58b94ff6de2242ff23062a1aabe34584d22eb14a433c136429b8ece75d5d708b98bb182a60d3dfa9d5913902c7554a61387cd8faa9387dedf0a4fe81480ca0b false +check_ring_signature 777a8df78cadcb2ae93dc59fa8c0d9a47b40f0162ebaebcca417f503630a26ee 73e2e7ed54f0b732cbf0ce16851732401b7d05f8fa4f5c106220274f95dfbad0 8 245d46cd8f113b0bf5506936a4ba110d89462fa3c9241a18381933af03a6e80e 7ca97c0e5d0c3922a7d3362d53e91a60cb7937e3d82d34b1127481a3459f67bf eba640ae37d4bfe05353d9ad7752e6924c41d1e0326f479651528a31d872e32d f61a6e09acd0a93c3404cbf9e2b89b800d8bc28910b6ec51b4d21482139ed65e 1c2f5e657db4d103d8fdd0bc689c8a3c9dbb32d91b01cb6d599e3bb24fb01e31 99f0fccd840e360620f8251bd3a77df0b27d23dfac9fb8d1c7bd9aa0e62b7a7d 08020aaf3923bc734d6a985fe83db249f762b1aa67eaa94a99e61f5529a48278 ee669a46165493791ce4399c3458d5604bbde9f5b040505d312e4b44da6ee557 b56dbd8809fda5608d06bfe2c172d5e9ce9fd7d207dc12aacced2161e200a40a8bace736efd00461a7e5c1d44f1cfa379b5d0e1c3d07b8810d3ac50087762ebbef408eb562e5866451b6279f9e336f8a8ac8b4e6a4246d60656ea32a13a0450aac2cf0a5d0c31ad19760a1a65270dbffe839e13f4fd789f2298e2978bf7439067afcfdd4b5c8106cb4b3ed288c9e4c75b21c483dead15df96931d6bc276ab00ba2709bc656d2944a68a2790645abb3fb40c29fe93fcedf9a38366a5b7de9e909c95d7e6591fcf1efd4a02c26e1f699fc5f1f0b2a9ed85206a9e1c432623e5d0d28a0624a5dd7d4a79942638c46a01d845ffc5cdb78ea1fba0dbfbd07e54c2c0a18762439dd3fe1bfd82d284afef5b861acd16f119a57af55ae63d8725926b3004484fe7e0a4a3089ee87e8736488bc1b8b33e9d2b5f58a02382f4e96be84be078ecb7aa4bf5f0a039c8f74082c50f5721b10024ec297dc7ecb6275bd9733c70c3cc9979456362d38d1f68e01238e6f9270d6ef11e64fe2523cf70a0689496b0571bd8d715485cb83b8ae52c1502315190fd45cac20d676e46547edcc149b7f0c99ed44e19f8127e91ef87cefce9f3d0339041b275b5476e63864f48e69c8c3087d1798fc3b9cd2f35aefec57738e61a37f4d5311405db267e35950ecdbe10d06c56551d9fd8b7c1f8ddf3f53ace28f388e564df032b865e8099659d0aff7a400 false +check_ring_signature 682fb6662bb3c03b9ed55a361cbfbe07579c25d94d829ab708b845c90309f27b 13b18ffab10b67e0023889543c644fb8c119e8abf54e77d7be5077d79c22bc5d 7 82c4540c2e79a43a001ad866ce73c36dfd1524153da494aac2237ab705791ea3 0f9a6392dd31765499f688e55346536b267cd578253303be887679faac90437f b4eda225a5a1f73db87ec4432f5f7b5fb245fe8bfd61adf2f9ea76152e5798ee e0dd8b02b42c626146bf9c39c9e3106d5c4492103da3d2f2e907fd3dacf6d335 16a02931231f69a7e9edf9437aa27231287c4f0128f2a240570758cd1fbd4a94 7ef9865b522a1a23cbf415c110e745b00b522408e61b6584aa538d57b60f6e0c c6e1b6fc5aebf4a69c26847596405df94e96216546a6dd526d7761de9fc6b68c e4b92d8d97c664e85806bf9900984e68e511b462b3b758b29128dee48ce0e906dab2ca0316ac6de356b91cb0ab092abb1a926cba04a00e139d35042e36023f0f7b3de08ec94f10e2853a78946165ca4d38dc411829a9da61741a3d8dcd87be0046e1800c200e9075f6f383eda59dbfc871fb33ead386d444c61d1827a0f4ac08c976a1aa004e098e5a41f3d5340b1234923b19886ac5a66870810e8d3ab29701f3318d6f4ed017e452c30df08f36676fbfdc48bee5597de979c68448dca51c09ba727ecc4a4f07fa9d87e1443d5605f245f2f8e1caa214b28507e37d4bc1600c70a11115bd5bebf8bb0d992964e9ff0cc81d8cbb1c30c64af55079767a27580ffbd0c5143bcfacf2de5641d63f12daa3f75c08cd842f6282ca507888958ecc0758f7518247a0a4f9c9b07448fc0373ff5915d274c88df4501fef4997399439014996fd2805ba86ba8c4f2aba7fa2fe5ae023e4ab8da07d5b7bb0673a55ec1103bb3fad9dc21e9bc76643ffd77c134f46723dc565940c013b282f175ab1cb460d414ac8e9bfec36a70c0ec350a1e536ce8a02055ccd130ae0cad43171e35cf20f5f4ab4d38e12e7d8eb91567d89a8322174651f035d6180fed41dd5a9f311d405 false +check_ring_signature 44243efe01f46dd04537a2bbd68082baa5c988da04b4265b38ce337eb6ceb33b 3dc130ffe4673b1e95dd032211b5810ca81b8c735f5d87a9a50ba6172395c741 31 6f8a7498b6a6ae08e8631ca74088629583e2e25e8f17770de2c1d5ff5a7d8590 7d86d0aa3094dacc3abe79bd592f3f4e364905595fd672013aff940152c62793 d6aaee1a3e7f89d1d6743f8e7ee05555b87c46243aa5b5d35fc3ae293bff508f ed6855070f73c9dd8043736f0dba8ec54fc23b380cc5e938d93fbbde503242b2 f8c09cfffdf574635de671a35b398a44d5d687f6ffd95935cd934c542528ce23 e116c8df7a1fbb6c72fc987db571d946939d50f6404f49cb83ec7e93988951ab 8ceb93a88234a8080178b83bed68202c1bd7568d14423a438d49588623a80e18 12704bb5e11c2fbac3e246c2b28d59ffc718390d24e1780f77ebbd51f7f1ea7c 19733736bfc4dc2fd0dece701eb1362c99fd194d1a4b517d6d8d37e40233fa57 1dc788224d32cd07a6c63d3e07a9404f5bfd656c6899e777d86a70562a971cdb ed88efedd1e095068e479d538638fa11287b163c9f7bf8d2516425fab8f40142 85e1f57eef298700556b948549085c01602684088ee7751f44dad23ce8e83b2f bb26389fb116664a94bfb93dece10895cb97299275f2e4e7b905eae66e459760 4e8f8055e8f26a0ac3788e168645eda0e6597b65b62f4121b579383ada41897f 94c8868658b4a87af53531ac5ee3cc1aa490b4db371abcb6c991c6c23df6077b a5e982e355f8f08951641129cbcb2026c708886f31ba535f9ed0cc67677dffa1 77e3dc528420fd03e5118cfb483f7dd1721308b18e18143a8d3bb5da0c059e90 512ca3127f280cc2c5a3c0c7fa75426582690974e4c41e06fde39bedff2c284d bba1bc71c16d808491079cde729458cb80feab83886ad9db6701e764cfc7cbd6 de09597fc10ab11d4fe8f8f25957874614fbb7026cf967a3563ca73919eeeb0a bc1d287bf99c5ab8dec40ecd15a950884353c3b711f90744fa709f0ef4baf94c 4317ff3308225e7c84d91eaaadd45689431f4b78c337fbe30849e542017a85ce e51f2247db2ea9b3930f938cbf96bab8cc2bdc7e45507a72700e72979e549a7c ddf0a39e2e3d663351064afddfa6a8d11aac9e895f8849e41beae8872b7c1d15 bf6da08895b7e2fd2deac493a619ac362ce66556d6de8a51f04c692c0c79a81c 948aba46d693fbf2ca6c1d12bdacb1c370392ba8667ad3baa090bee1a99d6b12 68691b8eb9f54030906f58188338e3a56549bbb4bccf3d742de82a4215783494 026df48372cd6b3d827edf21cc3bc0f7ad33e94b36da93efcbd7df5aa41a3e8c 68f6e42d8f398397aa1d419746fd6b0a75869f4096f0c0c8a20670f861c7e9b0 a1ad8e263508c601b585362536a7e0f176b8927c134ffcd445473a1f36b4dfd1 3c60f01f936599eb5fe6a0848be650725d4ab28ab23c76029e138d9a7d0ffc32 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 false +check_ring_signature c97dc515425a9d287a62988ea2b1b692eaaab8a5595d0fdb09f6d5afdc6a7660 5fbb31375c9e41214d8321bb99fca08a004e123edd151a15cca84fce053d184d 13 47e13987f7f3f086268e43014cffd079c96f53c8fc7d3e4356ef1fd9a68f1344 3bc6b9001faadc1aa32048a171a3c6b48f72477c1456f0ee5d31d078c3261995 dd7aed65a9b39b846d94bdc5ef343449b13687ba9d569a7d14aadfa64165ff33 eec386d35214dde26ea9e1839ab2e3d7701007e98b9db64aad44104251facdb8 9ff4ee609750e6104d88395d93cbe50ea4bc56b6c67dc35c5006f7635a37706a 9a0398c38e4717777177844ae193186b2549f05458f860679ad96e8fc723d225 10fc9c7f2e8dd1b1844a124461c1db03673651b2e2893566b65b6af251c31a60 ba4347e4b4d9f93660ee716c2bbf5315d913a7814c9cf2e29e79c90211a87cdb 5fe10077fe98611ae88e1e02c98912d7a9c51f7d45a9f89aa4c498dab04a573c 6c2d3cca8b22f749cdc182cacfebb9a3df64d9f7e3b9242f4b0c830a2ceca8d9 c437971388ec9c0e085f3131478a65b81193def418a4b4156d1106a4a5898f93 34d54363195344177436ed0f0a9a22d5b079d95f107ff7286295779bf15160b9 c6c3bf9836ce5664a7825c8191bb1f29be713258794f4d9ecb65f5ab1947aee9 7e57411c60635be3ad3b5e2d4302a22cf4784b75131f904226762f7948b10e0a018c28b5bc018fcddccdd5afe9abef9da9d568e8e23f5558a3cda8e4740c5c0b292bd4ce481838ffa1e2019433db9ac44f0f76889591035d6f55bc4b2aac6f0de87b0490d49a5694fd0ced58d77759665fac5ca90947a68f7ee381994b7a2b024a15e1d8770139075d778f5004832d49a9f6d9ad1ec976af5a2f01917f94c40144dded92095b8eca6beb6424e125d52c18e0542799cc17eda2c1a07fded3990b1b3f54097ad3e7e0602e4f7d51414017882d25d46146ec2bb299c7d8e069310da3383ae44d69ae511c5c641df8d5ae4eec00c41c617b310434024cba4d3459022bdf91dfc7536ddafa46cb9e11318bdbc9bceab07ff35dd4c768ce57ba9ad108921c3861496fcea36a7a3a5fa0c10d638822f007702d15a5598708c0854c6400f71529daf899f66d16fabcb565d264212a5134d70cdc8028216430aa84691906128aeb81b2f3bbc7f845c72537cc8d024247d272f5b71cce219c856e93b1b00be29152593c54e225a50f4bef069b3e6caa722a77abb9f362208c6888a367050bb42748fc67f17db22fcbabb45fb5e06cb14686c4f8e6fb24368e442c8838480254ad560252758d63a4ae653710ac8d2e38ebde3a83cf1dd1e1ac2d9c8cadf1006ba06796bc32a044d905f93adcffbf1279c6fbe848f38a6b347307e8c37d2d0e4bcc0f9b2251234b8ae8327a0e0a4cba31813a8ec90dced70d34f5a032ca1f01f028a0316a9fa68c772c3db242bf7a4fcd7ded0f564a74f5292c4776d679ca080fdb3deeb28e613e0e184ba23bbdf616c18028c4665c981193c821338241ab0c646f52607c2bfcced2dc58aa21784d5cc2fb850945f2ee57b2125bb78c7f4c092a32b6dd2bc9b01d85e98b000d17d9e1f8678b2f10b57c1652cb191c3d221700b4e274f43929ffba9ec5e62da2ce2fcdfa946e6c20cf49532920b2fdf19d8200235db3690df76a1dcb5ac38509b7dd124005543b02c5e50b3c69dc3ee4fded023c11c72bc1d256f6e50e4b091b59011c44534aba5b72783f77a758f5beb94e029a56a99e592de19559d8a7ee36983097eda29cadf78bd78c5eaf91414278610637d13c7a244dfab57ec53566ac5ad99ee898aec91fed46c1bafc495a53e9ba0f true +check_ring_signature 0c5d85181d08f0eee2950fe5ba636cd14e25dcb0f4af95c3d052e43f878c26c8 d053d357c7dcee9655c43e8f516d8889412328e67b2257d7e328c356ee48ae01 13 3756f63923a5cefe811db32df8c8e611cff35e71c67071f78c19d9aeb29b87e4 a40987919867241b9d66686c1a59bae7e75ae7ed09c08575f43d9c86c8dfd8be a5e0a4001f7992c09361073420730276da694520faaf1232f2256cdf7692cd5e 932cc177793c5d33d7e5bdb6c883d8d7844c662eda8e3ec03effad7224e7e9e5 64a1b7c57c69ffabdf672aff8dd6561a644097e5ab7d0741ea5d96a684c70eb5 f9db2e47f3ff915919ba91b68ce7ac6b849342f0ca456cff6a4aa57062eb9974 ca14127f5f5ead2c682c9a2d963e63a9bd1305a901e299096980837600066fda 0f205c580031615c3f701ad049d21884cea55d821b07b7640a56ca54c9e4763d b16f15cfef2a3e78ce6dd3e48004fc72e34e3e60d93461b48691416443ad9575 afd87d588bdb5f73cf3b07a82716329e97a4a386d90a5428d83c959bf1517c06 6c231be23b95c0e48469b5a95cf262c7d5e9b9a39ab2af1a48387c64609b5555 8bd143722f38f66573c3f7fce9cb313760ba041530bb4d7878b9beb54dc8030f 16f4baea7a30a771a237cb53df347f699c3c384e5ba995daa956ebd1b95881ca 7d76bdc8116530a93023a0216e01eded616c2b054bddefbb0a43ffab522b8c04f3f78273b8ddb413ce13013fcd1717a6fdc8c56c25d2b55e4b7ae04a5dc6b10ce5fedbcf8efca39affd5a3df7e438f29b56f06c8eed9d1ab0733e3d8765f75052733b5b75ca4eec97507a5c3393a65e69e9f3c02bb87aaba10d26d8067386a0d68570cb8c2a97b835a76d253939c979c6d9e50916398353683c51df5b06f0800ec69c2429301302a9ee1b356be550284a48263fd3f58417c054399f0e656230161d92e142973f4caf4a60ae6be17adf89cb921773c1b9e6bae62e12b1fe76a0dedde62fb0739b4bab40b35e95adf027b9815347e983ceb6afbcb97829e6c0105df029800cb3d935094169681444ef6ac5affd2ac38a4bab37b153f11e6e4130d74c98b458cd9da9e75e284f9c18d3988f837a71f12d22c0492341984740b130ac840e777a1ff82244f5c59138ccba4c448081cb726d0e7bbf66a949db30efa0c8d3dc5a18a9966ebb74f0b87ddc6d8300fbaf78fc7d6b824d15b94870068a60a39fd38a7a58f510a5283821f777e089269bae04d4225446f3b971d642a2a55001b8c8eb6001e90c0931628eb45c7861da4ade7f76fd0ffa96f2af241d8262a09e50892baaf349ad14561675957e7347f43987a9eac86a17817e5e35379fefe05ec405d64a654bc8970015189e08e62630724e0679ff9767063e10bd6d0d5e50fd219490bf69a2493fea665c9ae3c5832259c2e8f24132804a8c28a9771b88206e0b8302087d8510fee59fb8113e42c777cfdef4530611de376c9e47982e27d0202e952a05249e7ce5ffaf514e5e6618a0d3196df2931868621accafed6837b392e1477260433020e7d06ef1a0c50d84b961268880b112988bf70ef387102cf0f01692307087ba6610ce2c7fb4f0b87d032bfecd6211326bfd0da4662fc8e9500adf1698f58542c4b69afc4f8a2aa2b33153b66ccea7caf0f9fef5a3c360d3d0b0f75ff376ba80ad4b15d272d48b6f998e89dca8eef667f78abd0b7ee1781db043ea8fdaa5950252a6d3e912185b07f36917a6a6fe4b3093c7b17e2cb0a3bf207d4f1d591243951cba2f167bdc92e0026ab3eca28f5e9be366c644aa2528b86020193e2595b8c0af11072c113acb7f977b9ab01a07a845bb5b70c711781b4a707 false +check_ring_signature add3cc59895480f505942362d3b43d9c85be1dac1dadda906feedfab7514d254 788b2c43cf4a7ffada6ecf40c759da45eb940bc3ca57d102644d7fd2563bd3b8 45 88bfc00f9ec6b0e89e5f4ad5426bbff22144d25b00c8a7bbba0221aff91e6aa4 5fe27a88529c733fee5143f3ede582f8370e69ce70f7b2081208840731a157a7 940aa786cab3a08fd8c196cb4a14e71d78730c9aaf2ce82554a608ddbbde8a47 343cfcd98960c13b56d66a5eb2704133707242dfc05470ac7bd72e920d9a8ce5 33c619e29452b1a59d958f1bcb2b8c0cee3f98d560e86014fcf07efcade56a8a c10a7ac42265a0af39d2655dfda3e81714f1207838cda5aa3a032ff9c8d2ac02 b4f370ed754fa9120c5d3e497323d254b2ad0da31e0ee62ca9651ef513cd9cc6 53c754b03ef667852110862e96c274b445645a8480cadda4fe33ea8462ba191a c41c95cdc0dd2240ef34a547eaf59888015215504f05e92aaf56a1e6bd522454 89890cc574dc71719d759051201b3b10af6946448fef863040bfaf3a2abf6e79 70c29edfeac85382dd709ed76abbc9c6242f0c472241f085ae73b3eb2018cd96 a5b0292c4bf6da5ad59ba693a5cd55f8308814768c0d902a42a73022841f294a 80a25ffaa376a6b620701f185dd7c58504e3c87f671b3628d20f05ea9661e21d 3f6711fa42bb98172bd94ce43d6c7b782c9bf5cf667cc0f1f969bd7e9f665d32 b1e4c2da44e8b8154da3c08ce531812b0bbd817441f6c406df7f45af5f1049f0 3768c9e7ca50fe0adc78338710f91c5ac180963a00692d323db7fa88e3f8ed1c 53a147eb4cfc0cd667df6ea229177e85e363ee104f80c1d5c16013caf8594ed8 27769bcfbcf292d731dde4bea77fe8bbdd41c4e88709f1f57b688cffc6a2d7ad ebb521d964417d7c5e28883752ab010c01356bc58053d3c4c3d35693d0e7d6f9 cd2f29945e9c4c6ead5a5c1c57048a05557f31ebb2426c3d67d9792fe144d88e 65baf8264b7535b9f5fb39c8a066659e8fb69cf3eea4440e691e1d836753ea04 65f6dfefe8332e6b0c9210d536ed7c94ce32232e188786eb32a3b2e9908824b2 87f318867c0e544d70aacbb7aaa791875a665726334d5cbea77a0f6cd70618ca 08318526c4bd2940290a143db3ea2bcd18c433a8207c0f7346e10f2950c86fc4 f8e9b2cf9b6cdaf3c13404b4d607b2f070f0a55b8c0805f228566d537ae8191c 2693c9f34ccec77476b8f676ca6a9e3c3aea10f2558d22f8e906062f6a3d4435 93c75cf3cdd973699ec32b8622230d7166bc1779a9c2c69a687307dba42cf523 b1cfac66d2e57a05177c9cb1556152ebd697824f06d6e5437bf078fb1bbb6f02 088505e010c6d3f0763dae32878c9386338c209353869290af79cbf36bf29170 3acb4f065038bfb1fed2096805425137ba405b32ad532959332c9495a9666fb2 35efa2715c3d9fb611c2369d9839cdd2ffac8b5b1ae15d15969625456597b1b6 a94bfe0c0433e63931a7698a25eb383455ecdae1f8b07a9b508222f2ce32b964 c971662d7517c12ea77e60aa20de64375adf297a246519224cfa7c7ceb1defca 7b08a8658bf569258ccbacdcfa2c4cb0e541af384d0e35419efe7da2b565ec73 6d13d580a1bb45031ee008cd24809264bdff6b3de3678c0b769da8289c642c61 7566deaa128d4fb2743d6870dd6d796bbc5167a9d8487cc5d308014619c8b48e ef512875ea80513692e29605db1a0ca08874773ba87708d61c11560aea57810f c2d42387837745c083fbb5504e0907344cb0b27886d5f34d2e3a9f458094abee 3829b4551d20b2c417e7b50dc8b61cd766990414b697322ba09c675bc2171617 bba9e7848ba1974e440ac78ec4e88c6a4c6e3a84f6f4b8e989936941a879a8aa 087b89c8b63cf26eabb1547ca763425dace47de95a3803f702cce337d1663431 f6988029c1a8401e02715cca9731e4e491c56859a673c88025eae463cd8faa9c a6e66c46e82a2c4fbd6bf5aac642fbb958c842cd632b8e88d562bf69d3653a87 115209679769f9230d77a0b4ed1aeb5735694616eab482cfabfb3446b323890f 56c1e361ab792b69612b88dee6b5fa002f5030a8556dfd8e00174f50d30e5d54 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 true +check_ring_signature 634aacaafb64ee53d6d1f41918de5e8f77bd8715bf07633cb497ff539abb2d23 09b2530248dc106fd13e2c5837dbee453614c3ee787230c7c46baa5d3f64b641 2 ab020f0efbcea8437bb434fbd3f803ca7000d2528803a54c7c0e34cc0f04d971 f7abe91cb0027846db5ac6b6a64b153b96b70830333a8501586b59c5d08e21df 3d9eb79aaf2bc90ec2f28b289927612f88a38a48f3bb740db5d5d2b673543906265ea260127bcbcb304396a0b68237ed3042c4fad2f655b9dc8123f4f12a8306ce9b517c997e1e01c1bc0213442ae3911b638cc906d6d2a547646f3f5ba80d0679498a7d12c9de9f6056da7069963443e019813e37835d8b991de6ebde9b6007 true +check_ring_signature 5ff6eeadace07009b06de18a7b1f1a52bab052f0f12ca1a309f1b3a2a41eab68 716e8578ee13828a4eeef26be96ffcddf3778e490ab1544d16dc5b2ea4a7eaa9 3 acd7be5c5516a435cccaa23ec5ed35243d68eb1ce6178d34bf11ddbfc42a42b1 153363bfb53b82d9c00e0d4bfc39ecfd8c9b4303ebc02dfdd8b0ce28835f699c 07c037a68d8956bf6a88daa7282f2432bf2458ab5e0cbc5a4a88f0f9a1803b2e 0ac4136c8ee9761504b4b397f03fd440f05b92dd0252db0c95adb545c41f1d0c2b3d7a9460cf3e8ec61fc52cfc31672c9a03b5c77cde0cc17b8c11526f71700b79f8ce45a5e459a401a126947935d8064eabe59a00f8802709bcf66d2ab2b405d3c62629c91017daa20d9b5799d7ac9902305a63122da21f57f944573d3f8d08f574e868e28fb449611c2def05438ff08272be2e9b182c3a7972bd7a1faec50887ae8d13eabffbc3dcc9d2381711860d482f6644d7a22531775f18a7e894a20e true +check_ring_signature 8de9712f7be23bd9a8c5d4c917d82bbf4bb3704b7ffb4e0ac671cbb792b6390d 5714b726fae39a7e6c5e9958bb46720c8c51247eeba4891934e67dbcd3acb048 4 5d3c14d793be0fa1edccf3d7ae1ae320d40116e0206347b8c033682bf2ec2e5a 51e5fd3255a7b0447c6f1e16fc50596a5002156d6edfb60c2822261b37443c01 ce959da6cf5b2594ba77a1f164da973fcd718b778b1de072adab957be9609467 9199bcf6dd5501e06348f48e821e21dcfb7f2aa6b33a47c6ef46774363a0befd 5fa3d59afe89be2a8b4ea8aead0b3860e5cac8edf0b7b0776de764392d52160c8531d28a5703c139ac2cf4ed8ec06e8dc0f81a4549290b134a5e67a4c80e38088572fd79f042b718cb9939c28c191e3c5091d64cc3ed80244d16e2ec8f180b04523bb3c6e3f232e69b609e9cf66acb49ac65dfe8823fd252beba85e461692709e8f67d4ce840a8397b01698b727df78a0b79929aa84e76c6adf2ed4d20a6ee0540aac64b477deb212e56f28918735268110ac977962749d131481a8d33c49905dc834be581a430e1c3fae7743d004c092803294cadf2385deeff6c80b23ca603ed03b747e22b2832866ee0ad5666ea1bd706f17881d743718cdc82de7da71b03 true +check_ring_signature f5fe4bc6b950f98ad864f82deb864110f2d395e399b62d9d9b9c89b063c4a535 c94f2b3388a9bdda02f7a2ca5c1254a6d2fb4e3c611681f83464578df932afc7 4 baf7c6e12264853d4ff8376f6cc2e2bcb66aa912577817636b2010f2157d6684 8bfcef9fc057e42fb1944d16e4942afeeb22ae30b5d890e6a14ac6e7c3ecb1a2 2adf439f1b090a3072109c77599834eef4159e2de317ed73c057cd1dbbb4195e f4c410e8bea7072adda30daec2ac239d8e6294d15add6378c5dd53d0e742c39c 1a2ac8f6022e4758f4967d458f0c238706c1c27afbe3bcb26c1ba9accd4d71054488e507250e91ebf819af68b93d464cbf1e436b0c71c46cc0adb39628c84a07d698274b398f915bd5636e980edf2786937fccfd89eaa3b7db1a77a63079490ae715c9903754ae604340fcd0b5ec4c8bfdb5edae1a08dec009e853e2a19179069a22c39a0353d983e60bd808d83ab971e0ccef64ada39fa883245390c3eccb00baa37568870e96eae60a611417db31761612509ed2563975c9fd69260793ff053f7a159e2d79d1d0b521003067cd1e4fc7b625b15f4c91b3c7b1290c1e3edb022ad5f42a16c1be85343cdd63e6b94e818f847548c369d17f300aa48bddd45a0e false +check_ring_signature b80ef40f254ad7f3cb114f717a62252d99eb4f3f7d11fb038eb7b55b3447345c 746199984cd9bae7ae1f8b2656eaf00ed77b81d18aa50db7eb2497c9bc35f9fd 61 c7c32bc2f111768e7c8440cb978c222cdac2688861e7cf72788ea14e4b1b65b9 7e2e88e0fe53922711345bde2954b1bc4ba6215a1fc43c70ba4f2f16ba738c2e 7bba81b6db0bfe3e92fedca1f33e5f08589a817eca505f02580b0668166eced7 f1aad9c1219e053c1b8abcdd7bf7ae385659c41bcd93c49e31df3c963c75cad0 05a14b30272f7fbd0d4c7a48f8315a0a5e88e84f25047780f3784ee995c35973 f6b168301cb8a55e79a9c155a42253fea62e423961c0c4270b752b35acd3561e b61946322038361116edad13dba531e8bd58b7bae05356f1978662df88a02628 1e9fd0212ab067e0295e1ed0e60706545025444e5a10f150cd92ec3a6fb69189 c0f9359d6efc181e4342ef294bd2290acde877083d2ea3cf3389f4aded74a102 3b92df93c46bf5cc42989fe18efc87793ca3c2c3f2ae7805d6c68c3bc403b844 900c982f144d91d9fa17cc4f9c3115c6bb7d0c371f11c89828e11fccddc37b07 8467ad31c1cb09fbe50c41e33f1913d69a7343ccf3020b6a1589e6ab90181ab2 7fbd8d3ba5858c6aba5561aace0a00f6c994333111ca7859e880b1587015070f c177e6b462bcf04e8292e9f2f9573ccefe8b9eacb35797f139d54aa177dd65df c5cceb4b25b8955c7a1aa0329d7c9060559d876a00c6dc26283b29f352032806 c0264b5d88610c3c84e231da1319b339fc416790dced2cb7b366db7a3e77aa29 0646f7b89608aab866cc2f137f13feb22eca22100eaf46e128223f916b750a4b c7a8a170da504f594b6be9a6918f190dedcec0f210384c56cad1cd7e04040d24 27053c0fb3648562700488d117203e1c9989847f699199c1301b857c223cfdad d1fe75d6c54aecd38a11d2a0084c46cd164058fb1c70498ba08bd6f143c89157 1ecce3632a424c8bfb0ebda80d5284784127cbbc3859e35f3379154680c5befa 21a21ebf6f25f4266766f35c6ed5bdb8257dc89d7428e797e1483376a6f4bb8b 50765776c5e806020f29b2fd4c905b1c73e4d9b704b2a9a4e17cd651fecb2905 5cc26a569f320b8cbabc1e08caebdb7438e458df83ee5bc317704f8420e075ed 20d04aa9efaccc337d4f9dab0687d5b9c0638303a7c8f820b7c279496f54f041 817d8b2c65389df7fcc31a7c3a43d2b8a9f90e73437ae71d0da32254f86ae152 6982732d31dd466df304f9417822056c3c3a36bc6ae4fe47f021f3e587678bdf 3ba4af1968a7798cb09296044717af8ba7ad169940ccb275554bb0dbc24c8e7b e21043be77f20c8353696f2d3a72fefec2d78f941e72dd271662bc8f64fdb456 b679a2d1d326d0b2579fc443fcde565e9756b86fb3686cdca84595e47a278699 268f17e4e318fdc3df24e0e97ceced35e02d0c210b21a9eb5e389b557757013a 1ca02ecf8c87b22f572ba4048e9c9d62360354310413637696a2576fd1398ba1 e822b7965f8ba496c8024858d7f3a7f73aacd60daf6fc411ce23a684a96f2359 ed8a6f1f1ceacd48898a54bfdf95814ea97de694730de265728048c5dc1e86fb aa88dd95d2ab57819457971035163b5118074e937e92577c89959d33896fb14c d36b82c998c68823313b24d59b711058036802e531d0ccf25dcf0a52285581d9 31e2d24ac393c770f17905b5838bbfc9a8913fcce839410abc308ab71c2424a9 10f7fbf5a4d8448acf59f21877ad0c9791cc6e213ca70d035da5388ff75faa16 5cfbd8d39b9c103f6063742ef58bcc7d5d78b4962cbd24899d61c339219b4dde 17aaca71b97181a88f55ad9f09fb56d37d75b0aa05ea3b17a7ff2e08d352aa42 4ad233cf58fd47692f14a4c255bfee3ed7717700c93ab5224e82a761fb5b41b1 278f67d5012eca5d81423b52c930773bc65b1bfe97b93fd74ea255af4acc5b06 cef9f3cf7837451e09472e5b8d2c300b065f1529ffd2d0b58723787bbe8068b0 7a3f4cc0064f5bb47e0fdd6a49da9dc8e9f287fe5b8b3d4a085449fbb5237aba f030657c0aa9ab4569845e9622c0a7137475b07bebfc76820ce2cb0432cca680 9a6c273948af2333791ad5052cc7c9c6e6ae6a529d8bceb20a7ae5d187c372f7 ac152f435a0693fc11077fa5b4fa21b8ed1c4bb5d006668413ea5ae023e5baf7 580e009c4b9369b2051ecbb2324c0e06a5b828d9e839f1e21291366e802f901b 461566afb2c234839f7edcbe82c80510af94a93bed7be23d56b3ddce3d6dc4d0 b339d6946f06e3ff6633bd9dfd9e833024b3d8cd23ff2a2f5c0d99178641f3cc 0c38a35333d5bd74b17001a48502bfaa9878e78ed0ee3fe8011fb41f7f8ca541 b99fbc02bda3ce2e7fb13cb1cd4e7a86cd40d2c9b96b14fdad3e139b66759d8f 2f1d6851bb84b81257478bd7c440af0986f3308dd8908e90b375cd433aac43f2 66efdff5beebe3e655eaf31bedb13f1977f0122f474f0cf6a1d19d7bca0b7c01 4583273083587cf6f5e37f0eb3844ff3c2b4c3bddbd1687c46f37a8c15ac2451 34d9c15135f4a32dc7b765053ca51e56f2d8937769ccb19bb80b45e09aef9dbb e38cac5d778c035e32defbc643e15957c9a9aa8405c10e93a4703bfb8df28335 4d4be05c01990d2c89a4c91e6127ea4b997a40407cf2545c05df5e305bc8d7be 4b36fee013c9b90acb9cc90942d43050f8ddfa4b2d911937b2fb32e14ea9762e efffdebcd4774fdab34f75fbce0ecb1b9d9dc082e4b1830b2f313e783c48cb55 6ab226de79828b6d70228df21c6294fb0f036802e3d6179d6c31eb6f4f40915c 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 false +check_ring_signature d3b4ce61d1061b137622806d7ba34406d4d75cd6d702023b878cf10bb3aea421 392dbaaf211db262c97b32021f697cab9bab473db991f8190ad80c26f5c3efda 17 c8c25f89f40c962f49c05bb99227fe0cb3fa7ff7e640bd29be0e64472e5d0395 1867460d6092b97737c5e0893bab2d65fd388d7e8898518f0b84d404471504bc 1146a8716bb6bc9d47074dd2748207d399b8e80c533149c01e38603fde6d0b8b 6fdc7b40b3df790d61128e84128ea289a6c84ad88497831529654919f4dae1aa f5672c94bf6bab41933f6f4174f363a28ca2b258fd2a237e3ff97aea9ef375e7 bb80d6c294560e3dd9d525bf61320255cd7dc69ff163bd3462db8655a160c97a 91a80e7932cfb632a98a5cc76995e515fdf483d62821f4380475005dd4ec220a f9f62e73a1f66ab81ddb5deed2a487a32b557d8ed025f7948db2afd4c893ba48 e9d213c96ee00b3b915597b7cd5c6e7ca8bcf09aa4effff3063b47b6343f3c28 1c21c3b2e507a0c9ff7f3bf48e72855d3a9af8abd7c08c003f8c617b851c84d6 bb8ae623a42223dc1463c2657e7874dbbbd652ef207755baa2e799a3de8a0883 6266eca73b6ffe2bed366dc1affdd10e35a72fd1d6e96dfc0780dfe31ddfe26f 6ad423dbe191662b7fce99f0e7a7f1035a4945eb286801f4fc1561ee41640742 7be36751a3c74e601f7666a8111eb8c9c9aef52f650488857800022a862928db 5f45254cba8cd88bbda16bb49684e118c6a474e40e7755012f3f7588325503db 812d15185506cfad953d2456e914502022c84ae02794451a8177503f8ee47f51 f1b66bb1985b20b66f4093b2b12aaf9eaacb95c00c58dbfb71e1e43ea24efd72 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 true +check_ring_signature 3d84e70b66afe2ceaef00ae914c6dce42cb216905ed3dd8380b7b855d682b0e9 65986f2e9e6c279f71de26152659cde58cf5dc2b9d8b573806b57024277bd9a5 28 4eb1c0093a9e4f488397c680e4824fa89a191c7a2b8feb883437e209fb78791c cfea05fe0abe49061e7eef62bff017a08e30d626ae0aa24e161e7cb35cb0e09f 789b786e0ae915c684e445a445f32b3aa696ad199f1ba352ab6e4fc28517ceeb fee8bcb98edf795b9e24a2b813ff97561a8f19945ad2c34981fef5986382b0e9 995a90ac133ff2701641b21591f6ff3aec49829f05aba658f0c02dfa5a544e17 2caef8554958aa5106c261eab9567c8a0c389a6892eb5543077508d9fb88c55b 3186d1c8149584b21eb9bfdbd4960f93b9537d028db5b07153634180c79e7039 00c400053c0835898b346ece998de23706a75f8446dde6abb428f69011c3254e 8d8e8c5444afd059f8a21fe2e34df1d2ea6aaa9ca3e91d6c27d8849779094f11 7fd1303606cea1a99af2f3c02056f755ff3803e192cf441c468a5d58e2c4da8d 4a5c9d649820dcc21bf95554db033bdaafa303fbbbb926431bf658e5ac6e90cc f97f76e75f2fec1dbdccf96579e874ccd59b037a277d3a42fb3fe4a14370ab95 71b4164127e90bf8cc9cb949f6ddbb5f0eba7a7ab9736e7a1dbc3618f258a13e 9d44d99e9e967214f763a388e23c63684d72182578e64342231ee16ac701ca29 9ce1a9e6b0a155e97213f38dbf201f21bf0f875baccd680e230fe76672b56ab0 14c29b5c86c8620ec1f5467493589010daaee2258b72a1d2183a826cd764dba6 4f02dfb923a82d1cac98f64e5b9c2705955786a6766049af5133dcb5bbd49fc8 d94b304555c984a8c835d9a400fa360ef605d30053dc394189a2ec68d43b930a 17a4ddde943e487597a2fb0b6367529d470f0bb7f4d68f6b2f1b3da46389abc2 d94a4afbf28dcf0796bc3e44c630097f5d689a325c4e38c550baa0ea23afc269 af263504ad6d9ebb5a2a0cca4064a8de1f377c28d374610225b192845f08d12e 94ac3427e93ba33565900400417425e57968716abd9243761547bba0f1aa66b1 e02769e98bc9ad4917f590f6bb53a3c6f707bb89bb7319fdf096ab083fb5f61b 0249192bfc1985c0c6859bcc850c3d80f9fad169c29dd74c98830085f5c8f3c1 e79918b2b7fd6ecb0e2b4957eafd113fc966e57c59e6d8298a2e405781121ad2 b472f7d4b5135074a9b359885ce58be1cfd2097dec293f96e7937d8d19eed28e 474f5a0327a8c07cf74add072c2e3b3b4fa1384b719f3d7bb1adb15e7f18c001 07152a40b2e33406302b966ecc7573d69e259b1077561cec1eb7bfd594e6c58e e53a2f9fb5760d305326f87954283fd700476df30f4d0d71dccd623bbe4ea508544b5fa2cfd937e7bded7708fde625159c7da0ec1467295c76f2896d1f3cc70afd079ec56c3dff8b44e813a31721c56e2991b3e3f8c32c55fce7f94aec1f0404c7305ab0a1ae025ae8e904f9785bdb64337ba8cfde7cab35ea62a30390547e0cb2bdf28902f9ce20747d0d757d8a5b9eeb511ad673f88a41a54055f2dd490903384f2eac963f5f4682a7a7b8074d8e9559801455ef6ca72c6d2cbc032dec72045c4cfaee35fe4fc233df449e434c7df0af26196c2c65e3e6ea174dd6117ac90ab7bdcc2129bed2ab6c718f61bce2bd7e90c7bf1807868318b4b082ed41ad9e0a468b448145dabccc0beb443a37ac4f750a852d0d501e0b4d8d93aaa683e65c0ad808f6464082ec9f1c5802c25a4a702a42a79d10c4930a3855107f227e27c808b1be84495c46bead28e6615da0c1c08b0a34c81885d6c5a5e5b6a9697873ec036112386a1aae51febdb9156d5e9469126259ed935c9eaadbcdcbbb4662b5af01820cb8668a5a5db4accc8763e03f9e3c778659519931bce02e08ebd88e807302c5b29c39f324aea0fffbf95e339a51b99aa08b5fa7bb8aa1316ba85e99ab87018d65e64c3ae38a66c736a633ea665ec1c32ca85be302a39cb822d83dd3c40e0faa2b22bb5d0f4db412c24c2a1b728429a590328f5b038620ccdd676cef05ca00540848025ec7651e9795592958ae4c5d9d130a7bd672694143c5cd4ec21ae304126a698d945a55d1f9a9f060af354187d43c5c386fb7344d320b377e09cc8d0c0bc0124e0dead2ab40146ffc336d72f3c2f3aa2b76fe5564329a15507f44ad082cd0218b2e1f7c242bc9e06b916400fd0afaea4daed690dd1ce7ad44fc5de80a1d4f06c2e5fab46319685764273929da38441e3bb69e38b49dd71299fe272d0c5399e5a77c2db727bf756e7782fa5c223bf3accc4194f819d9349d23f03ae801ae9c05bd664ec9de7e5b8f9a0916be6762897c5ea924ad9dd55161ed89d6f806b62bcfe8dfd6e2d5d3eae5c70628472f03ce361f6067e3e7e3515592d306260c84594996f571ad459408cfef7e5c16c50ff1af425f0524358c82677dbe81fd0a1aebee3f3b2a89da6786142e216dcc2dad8a969a7e9cd833e8e610dd2eebed007e50969f0f52cdc435eace3c4f1e6cd3d390d2cac24291196faa95ebc593bd0a26bda9a9384d7b18332786bda7bc7aa4324409436f894f8b806534cd00406f07f4a324bd3f75049a2f6510afa475766e7f64d2bf7744e9e1ca18a5ac06dfd103b7f22b54f75784928d337bcb4cb5bc1fd8a8accc067ee9b9c3924f54ce7e9504d84e140031cc73303c3fc2de486b66088deecfcfeeb79ccbe00a38b72201160a1c792561e6a98fdd1210b57820209819c0d0046077f01e3d4e38622c2da8b40bdce4b36fe17ad9983a7f571dddb2e380b92072497fad05eafc9ca4f90249f608ab9314942ae6a6f7ff64945cb1d24e1fc227454b20553d7aaf5a3e7077046a0e3216076eff94e3f6aaf72b9f6f114f2f1503ebdcaae0238f23cf546019caad026f560c96ab037aeb530bb6a0c8d657a24c15b699eaaad5353b0b725cdde0380bb74dea1d8dce5ffbe34ca558c7327fa8222074b3225525faff38a7469c4e4002314dc27f26ccfd56c33191d1c34a263ac10d257f3646e70983a24aed25e8d306813c9ab95ad55865da41d9e794e6ad6603f82074e4921bcf7c1aa97cf768d00d923f8f0c918c8cd739801b65467bb38d46878ed6dcf47977127536780fa9a50a7b92b194acffbed7efdbc8dbe786ebfd90a2177fdcdc7fa0868ec6d08d5889025e12cf5065303171d5d0c227d89015b3ccba92f0ea5ea6b047ac31f3ba7dc406cc022e44eb15981aa8e965afaa78d8537666befe028f49e037718c7fe298790f42b78df09a8e7dd745e1859ce2806cf07510ec523e4f1023bff5eea1e4ba3802553f6267a1ec063e42650108782b600970366024a706aabda08a5cbae73c940c3da082e102f20cc04fe8acf37547b44f0ee9d4e14240f7521a77e5f19348230ed2e1d9714225fab07ebf0b41f1451937da42c4a237e5dbf2951325d0683fd7009fcd36445b46764557c9253b73ed69e4a706b8396eabb9e9ab2534a9b9ef78025414a8fa62188786abb52c19c3460767130b0bf6a5294b779091f8b433d55f07b9ff4e018346bc20e6639c5940a1af69e72a09b9e94b6dbcf6a9c52e097603d3377b189118beff3fc366d6427edc3a190976f4416c86fb52c9bb9adc5c4b960175cae5adea8e6265a20cc5cff11b1f1eafbc94fc9b8dc53317a33a385c3c6b07654b551ce08856615b251d229b2595a70e67f7e3bd19a4341cbfba66f1e5f10a0f0b0e5cc93b391dc3fa51866651841ccd40e8fc432549bfe49518e9d8f40908a4241c91357dfd5b71c61a338f1d7a733303bf3cca4b11ee1d0230df01f70d06043b2f3e487ee11dbd3431d1d0cdd53dfeabf547c71133c2c620566a4294a508 false +check_ring_signature 08c3034a183b46f4dcfb0ca9cc01964ed00da66c9a99c9e58f9a00b3a59bae84 7b414e2641ce7571f8df8261bdbc97b207a9d70d8c2984c1e67cac599206c164 1 b2023f5267932cb9342897eb00bd45bf0ccd2959f0f2c060d1aedf4896145220 dfc52e7fc24562e530eb58723d885da9bc384e17906abcfc951965f48f937007010695eda725ee9edea80b04dd1d6b859efe01ab0bce013ae16782486ce50101 true +check_ring_signature 79d032a81d8f72f9df365acc75e30afc58949af86ad68b02541a66ad2f57eee6 ac4df8a6083a18d538b4f33ed7ee54e453e5f211afb266b6b360e69a0eb34477 2 0903fbfe755718f87cd159e809f6fb601ea4ed3dc21a70caad4d9ac186bcc92c f53afc0fbef7ed3596262051e1f92f79f38763b5985b52649273de9349cf2ba8 591d840180b104702d8a1418eb6933d33b9575aee3bfc34830fb60f78bd1e20825defadd3ac9c5fc3908a7448efc50f488d7aff3ffa7c3e9819b3cb3e2f7650441786a21dbd981aa209ec2256d654c25a876ac265a9e3cc4ddb75efdaf898b05e2135b8ab8484a7b947d7a8068257e77638b06c604f7e4a8495bac22395ef402 false +check_ring_signature 3c2fc62f28061446811cba44addbe3d9c9722bc0084bf494118a77155e73738b 85d15048e9cd5f3b160dbd3fc46cfeea482c5f6a3487c456292d94bb74c0cbc1 4 2bfe328b72b6c30ff7db8208215abee2979e04f891ffe43a425be12b854d8161 b6cdf64a94678b5e4e55d027df4400ebc5e03ec983bfa05f240a18422585a9cd b03b99572f79db5fdd03fdd639d606fee50332cfe16ec9423b03d04641c677a8 6690c7a7000ddb6fc52ba68ed6f66b82e6d184408de7c7e11e395a9231589202 a3e69b6c912a3a0bba2b2433b798630fd921077760bad66e0d57e843b3238ca267420bf0113567bd43722815433dd7e6be7415b43f3d0623f52f9d534237890b576bffa17a6a1949f6285cfff86b2592b8f3d2a148e5d4c9258337a741449a0a6f5a232e6f3d220074bea49127423da8ed4eb38d0b563ed449af824d3daba25c51c77e603aec730a52ce791cfcdf3b834dcde6eea949a767f4a28de9243390078a8e0ab20bc7138c9f44f172d27dcb6b9d8da4491d98217201d0381e4f3a7e0f090ffc1a116849bb464e61eb4324e6daa9f380ee33ca6ff0b1c19992eaaad50c33062f0dd79817713836d9f2a435032c61e82b25aa06aa01171c6650f087f308 false +check_ring_signature c04c40c151f5bd520c088ad6c2b606f9600c0e3244cdfe7de9a689df202115e4 d3a4cdda6b6408bcbc7580b72754f5f87c6ea7320c9a720a7547dc0ae0992a2b 1 667a8c67cbffff6e8456ac87f5ecf55f4ee23ecd83bddacf2c87189cb62159c6 5d016dbb72c72c547b6d08a5085a4816525933940a7a491164c842864b567301db541f6ba77d672c614f4f970eaf1280e382d3246acdc4e4c7310dfcad19b203 true +check_ring_signature 931c052fbff22b5010803fea822d241fa357b3259198521fab11e92fe33cf130 49a241d1e285cafea97fd7000fee4eff3f860843e6bcb06eac43afa148dea0c7 90 cf0790aa9d6f961fe5c2be693d2401a98bdea1bf8fd7d9398c41e0140fbce108 dc4eae456e3162e1d67252aa87b95deb833e7c64019068517f5ab9cfc0b4a2d9 de09225fc45e92ede9a5b827cd4dfa4bbe36b2f9113d61f4a3f2b131bab34a3b 8711201c02a6b27757eb7cec862fd802a3490e61f3adc33d1791d8d72c29738c 12089d0fe83a065f6acb15ca82aa326d18af3925283820da691d642c23ed6b4c f6c841c5da9b90396c7c06e020cc3b178dfb530c4e41b223dc17d336a84e4ce7 a86fb6adac343d055e4fee06dd498567a1215f42495f2382bf60dd508ba0cb02 ceb788da42c10a06748d46f4a1dfab4c3e9528a67d982987f92ddc576c214fce d80f90ec40eba00c271c664f1a3f953d8a2dccdbe374a6f0a0abc86a709777ad 20d8ca29df1a2f8d3f0520f7a218208e6356b201cefaa3780db4ac662b7b2bd8 67430e33ce11afc5ab46f8982741cd09dd2e5c2092dbca82c74bc2b8231e6c44 a25e153b464f68a89f4b23abcd5c6ee0078ab7f7534ee77775f50c50704ccc27 d23315a90419c0f73259ab4d93fc188a54a78c273fb929c527ad3cfc5c818088 869860f5f192ca0b26e218ea01720cd58d9bb80fef77e1869178dfb06548bd13 8c2d5217e96159b89d0cfa4d00cc681311c1e3449b510d877ba151cf38bd8886 5a428e84f0fef98ffa37fdd7cd676784b42712aad02f3f42a8c26550f9c1cf11 01eceb0c7a2859cfec504406c7871b802cd2d860979f04221fb29291e200a4e8 e0be51d62988c2784880769473aeb9e26cfe5a8dcdbd5158435b7b62523ee652 3c00417628bbb15b706bb5259507b6507c1f3355b3a7e53728520a16901831c6 cd1a6ca7f29e64c6063bb1e05e604f4cc3dc6871382dc490a3f404cc5cbdaeb9 87aa2a4e96b6e876f36d53bc6142470ea4a3c566ef5841c6f02054bd0a6ece9b 3be50e8ecf24a94e63134567c247df7ccfd84e54d9ad94408e5a91de53e756d3 53bc75694293cb044b2502aff8b44e335aee7047d8baac8c3aecb65dfbb777dc 9d47bd776da86942111de6ff484e047d3eec1d1b4ecc8158ed51dd1fe0677e42 e62334758acaad1d206117556c62e969128d87438fbacfb08bc66cd93e6a4f58 c43aa664d81f2a3bd3ccb5b376390864d29a65d43ddb1ac19538284d77748a78 86ca182b731f8fc77cd2891ec59c66a283a39760b89518fc96b2bd158176d170 27bc6b81d3e29fa17f660eef03fcf65bcc7dd562bdb8adf7e999892811ce9ff0 ffe00ecbf9f4e33f00c0356513e9acf9a2a7c00d554fe1a7a10f1062c5602fd2 29921ade957f663a7e947c0ba9d7a3d7f36522366aad00498a120ba69fb30585 c64be59f562f3678c24b9a703eaeeb8048f1e83b07d3ec3d600bd351ae75aca1 20920534bdc9354e13e95e6c28dfe69384ec1e1b5e029d80654cd4dbd7f2a5de 2899ff71f37a71e1a81494cd6b0e304df7ad40071be32e65be161ecc80e0ad0a c9c4e7e8d38f585a1731dca862f610e2d2abb32c3b44e4272445ea9e713e529c a46184f6367201558b70d1a7fa91f6b8292e3cc53465430d61f825067763d108 d26138df4bcb235869900b5e0d2c09452cd123ca31589e3f9eb786baf5efcf21 d469c9d62e347e77b1028da7a0d6ca79c471bf9d5122de7acbb25d19526530ba aa1f27c21ff21425b1450de9434eb7749834ef0e6c382397a46de21c8ec5f058 b0df141768f813bdc87ce1366e378dd35d9a3e41b4e300a51fc035ded3d632aa bc752d158b36a4ba83599bff0df53247f0749403e7ae46a7dc11044f958c8f93 9507d00143b32e8c0598213e6306a8c942ca7b681c7ed1b03eac55869d724038 636de4a11d694e536c5b33583fa434c1f5fee41950e781332480d745ffb205e0 21e5c287981169b0e4f00bb3e3b90e7d70b3b376049560494d18660124eac02f 1d1eec6b0de3def433ca245a67622c8fa2218907d7405a6c237b98aa643b7e6e 900550d51669c658ea7c0f9981282d5fbf6b6b59e4fcbc2f133ff07ae1ea068a f8554500cae14f97c93b639b3e301c0630766a371293ecb37c7da88c8bb817c7 d7e795cc5ca4c7786785e91f1d89b9fec619522b0b2c4983a881464f8738af4c 8b712447ca587048735d7433eded09b98d7a4a58484e0dfdbdea2e60959cdcf0 8748e9538862ea097ca51838536020a38bd2a0baf904041b19792ddd870a8f88 46ad4e63dbe9f2a6f5019a6f77028b6f54eead8b03f1a77082c9c96e4633f6b8 5c03c02756c75998c5d55c4fcf5ca96162fb95efb4bc5fe4d7acc213cdb9a529 e5134246adb83ab9c81ed599108a023471126ae9dc01d1642618c1d4d1eb6208 b62d14a038d0404bb63242059effd4185cefa86ca5e279aa304ca83f179d7557 de129675d869422b77709bf465e5534cbfe0759c0db2255dcc1f6b5e138c6639 e4bd33e5b44abd778377abf1019dec0082573a0403f1828221471535ddce2356 6888f5eff99b4850a77ec7be3f1d72a705b97b4c17e04af7d06e7bfdfe62a4ad ed06ca4de249eaa8b9918ea7b0d8a3d625bd9a5b6a3abd4b29dbf407d0e28cb7 da1983012f813adb6a8417d15ae078fa4302966409911b91018eeb21f357b801 c75ffc6f396bfa80eee0702bc43811a6227c3d7f6984baeef3e0e0098a89f5d4 adfd8cd4f5d20b5853f6ae06b1a24bb5c4ec0225b7e6609afef2fd469cc97a3b 1eb1348908c8c77ff10d7f5706e46c9ba2a3fee27d2a33e287461ee0e2f5a27b ab589915dc0e71d54c9d4286fa40ac4e6c3a89f78f24cad92fdd8b1ff1cfb60b b059149f4b7a579832275f7dc8cd4aac198bb8c878232cf02ca0c8f5c99d7715 d982417b819d2f77bd5a1ca7cd9ac8e086efd1e136eea0ebf3916b6d6bdca721 f57dc14bdd1e6c897c799d96bc5380139fbf34042e209b7a458007fc51f36aa8 88221ce3deef25360a442ae37512a88ac191a1907c27e3421890448f38a4947a d954e7c0e2a0d8f58878626d214443c2d016088f095ae43c6ade7e7493ab7c3e 92f7bc7e22dd03d85d99be04e9c704e7c35e946f13d05b1f734e25a53bf97145 08bd2a4efc9f666149349c780cf3a340b38c60afe2ec459c83ff8edcdd1ebb66 56080f2b11ef509eef3b4ea6361a91f11c38cd49c49c9854d96f4eea828c1d54 4e0a0b965182ffb6007fd2241cbf2d9f5c431ed2668a340f0091855d76588e5b c3f45ffe647d790dd59e43421083df3dc7cbbfaf7aa67182d7439b9ef00b48d7 cce9dfb0fff3ea3a2ff72c4071d69c8a3d76b63267ec62440bfc977e5fe68111 123268aff7ab5ce18e5a99eafc7b3a88068d2c9d0dd00e91423f5784b3ab35d2 1dec4f492a04931a67f4432a0179be213d3ca3e06bf162035d732dbc495e4bf3 b8b55d3d6eb76b33e8856f46ec66e8a2f5b162dc4d82cc22fa1712f195d788dc a4386dc8c91364623c7f6e17cf701b0d02d1570519c2bd71a85870c5642ef50b c2eb7af926569eaa71686f7065513c14b4189ef0a12154bf2e02d794b3f49e25 7f3ebf513658f22a7e76993ca504495bd6a4e398251992bab432f91af67312a3 b9e08d5f6d6cf2f2ce819878a5a65f9794c4c74813c95506eafa6911d947f77d 9186a68dc408b10f693f3a4a1582252ba04c46eb447104e05dcbb70d0a985666 f07f4354594beea06329ae4968f93f615ce2218f00e2d826f471f20a1069d2fe 9a30ab5b48614262b1d1b9b1cfeba865465950af7e9bee97828a31f8fc59c5c5 184bad0c4e766e6b5986f5f18aa726da2fddd6ef0e3062904f96719588e79577 fff8d4c3e4f9a9601712dfec169c550b3c3a9df0701b007a143d12d4d151e7a9 8106bc82c5c68ed27cb7bf4bece95a711057b7c81438e57aa349efca203edf31 9a02faa795062d4ff1d5a67507add937c15341a7a03b9c9937c44229966d1ac1 c94608aef4bd15e35a483c27d127773d31002e0b6321420ec81413b6c0d878b7 456a264756a969730273c08bf16dadc27f67a3a71a9cf83984fca36234d7b771 e802a65ca32bd3437bd16887e41fb66ed23c9d2e8faf78fa823726b7f1c73f8f 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 true +check_ring_signature 63b5a192deb37348d777b8a3ef8d6b93967df800837dd2de304c069c984e19c0 8ff2401124f3bb74abf476f06e57b06d80be06e9e4d60e2d5beff72fe00f04b0 10 25c7e13f4a05d88643771a82f34b182adbb12370ab47e63ca324761f69460995 ab2ab944a46b71e3013b21a8f917b6f5fa9a546f80d6fa7eeb322e6dc1454500 3cc0234031d7a101672c4eb7ab456d50f592f46870226f617f78ec6e65b94d00 bb93ee2fade9dd6cdb34d222b26dabdd6e5612d79bb0c98eb5a39bfe05c97d86 bb099e39714f7b582942af992ccbf72f6935fd55fa07136092bfc8d5d3c83fe3 d8adfd4146244ad3888313ffd65d3ab929c58c15cb824414ae64a0378e9412f6 9ddf6ea5ca7ef25cd11f0c2317a9aa9bc485f67edd49f31f23ba2dc6f0f87782 0e52030960b6e155c91378705af739028f90777adf7a5672f8194c8f6f689ffa 0cb27f9c2b22b9851a540e7d723b653cda4313cb1be99486970fd762feefebf4 60341124cae1ac2ba8288aa407c0f780a3f01e5f7fc61e4f64badeab5bf9f018 b9b761b3fc03f009b7254da7fb0e764ca5d6f8f16ad308c284f80bb8a7863b084594817dd3f3f5b6145c51710224a378a1cbe4ca35acbd5f8f2e6a8a7d8e8307bce2eb7f8134258b22d906b12b9c6729822d458ac1b043b42184e6738583a50a548849fa903fb32519090d52b3ba8ee9b2274527421b0cfc91ecf17413d88d00b1f3ee62d1c918fe6a9aa3ba564ef830b18d3950e5e66ac387e7b30f84c3d10f039666530ba91e6f05a117e7118d8da40da34049b45da03c9cd6c37552925106e306a76b65731d037b29ceeb54fd28b0a1e39f86680774857a7995c1a7dc990acf0861030973a8511fd64ebb939be8e77aad5d0b14e5560631d8e6b5784fb0068c8437428c447998dfa56132223c96c417d014c0998ed7e824f3d6d497eff70ce435b07ca9fd53c5d8059015f5f6bfac9c47e28c4544632a9c4162c9529fc70940595ae101236b279791429657371b752b0098a889dbbd229273c9763c4d070b48491e8d7f06eb60b348481c16accba3f1813bc84347d06d6487fe0f784acd0cfadff508dfaf46d29de153c90af4791b3eafdf302ab03e4566b71aba0d936308ef9779ef4841f7bf4535339cf208b0952b6a6cf8d020bd3adb77281f3a0cb40be7828d8a37498517332c95cd67531d9f7d3b3a6c9128d4d5287e114e24b3b001031836a533ae5a97b5259fa9d1ea3c48fe824b85de6c2e1b13af67789965f80906c1219272828faced5fead4adedeef39db823e31bef356978dab9255cd5430e50ae2f690abcd6b4647c6032210c348b119920cf4d88398fb8bc4ae6d74e200d0fee1a26fb3c34dda3f5a53f1e52aab9d63a4e72268f936b32d97512e941fc05d2ad8fb86bfb6eb56ca6753d94116f2f4b48c2993c4e23f42fdd0e330af9d909 true +check_ring_signature 3705b6431cf37fd18547047bc95658c6ed541498df6618a0cda1e9659c0be4d0 dde1da7becaf592f8ffa898352b1c93875f1e67715e374a0f71fd33c16da7c2b 5 8f4880cbaad6efada33483e378b4fb1319b03a3ccb7b7148ab1bf5fce57c86f4 5eda0af9ae30bb55a577d948c2249f5a7734bc7b9b4424dd044f58d820920e85 6cc2cde74802dda8090b949249def45b27e4c6ff5035ead4fdb30219b314aa80 7b1ed0c415f70a1b71b24907df87f796f4763fcd753e3893e34da681e21452a0 9ef52733055c3f52029cee466b17501579afd394f8d4ab225f799a2b9981a727 1dcf17c1f18b248f99f98c3278709c4a6f95ee3e865606fe4547da46aba8250ca05e19b7964aff285d96f8aca76c8dedfd0a4458993807bdf593223e1c2bfb06fd684bd94ee7d491922931005f2b3b0272b9d8ace28402e40d7dbeca71f76d0847a42852405dea5d1fa243fbaec4bae781ab50d9ba6bf8f8e6e423ee1d40a4f476757f5df819b34c1e0de6be1369c59bed1cd31784101623743e4b493e29aa08b12c93cb1b91996b0e15301a1147832567a567b531ae9ce1bac3be07c7ae440a1a189e63423127510447f8a31645f71fb9155af4f9bea759ddaae96c57cc8a208c424195465eddb71be1ae298522ec78f60ad6e146149eb4b27cce23d3f3050c5248854e9d53484044bf30825d9f5700e5b9a9ed0f2aff5d4dac5e6e30cc52038777a4742604b1e3245f7dd6fe54ca0a1c83a175a99d5c61ec8937fd2275830f false +check_ring_signature 2b454e9b99e05d7a5dbb904bd42b7c69dec3e2c5e1691aa356029e420e5544ec 33ab95e5437805a6444c0447b521f390ecfe86c03bed4ab6f36c51e6561251a9 36 814fbb5245c8e83c453b013b11532dba4ca450a5c3ff2473373bb6380152e4e9 f65fc6d68b0dc087a64351e24c45cb64ff9895c60595a99c9c485456b3257ce6 ff72f7a04c0c786bdf9375fb1a369bccacb2fd198ae8a04702f99ec62978e9da 8f7b06a9f77ae9cf618044ba5ea9f4aef1d737b695f0a702cd760431ceee31c9 2fce51d40a292218ead0c666bb66543bba2c88598e94448ec747696044557da3 98e513921ef8eec2be3bcec21ca1c1d969c476cb8cc8e978341fcc1dc6875b9e 6a56836fb82b6f48800c3d8fede2c99bfd2ce611d9deadb27ce734a63da2eb7a d25cb90e5d6d22b10f0f735029e1f0a6a80a9ec76b7d7d99c860901dbc79ae8c 7aaf4f6d45f13d514941d9876e28f21e3dbc073d8168525e36c3329baf6e35d0 8fa72204554d40ff301e8994d19d0d7febaf5be92dd370677f580ad6b7403e41 e2137334ff4b6af2a8bc163a293eb4472f90fa84c0a59126874df4490b38a64c 9b741efd276027c129a82b184674d18ba60bbc0f5e047f568aaf24bdb74f187d a6747c5d92ea19b08c3e83bfceb3382ef02c2c5aaab2ac49fb838c82188f4510 afe152bc1c801b49c6e5a9e0cf529ae78a7de2970e6d30c027216b789f736e6b 3a365eaa29232dd2fb98e7314e8a86162736f085d6ed40e2200c16deba11719a 3f20a651357abcac2e252127cfd00ef14929e38737701e2c5cabba239c72e236 23377e8cdfa9055665aed49fe4ba6a9c9739f8d3278e93f7de31b2028415c204 354760aec0cbb8dabf12720c0d932fd1caebf6cf658cbf0ed7cec7c3352dd704 00cdcade4d8716a89ebcacb1fdf869a01466b54109430d7e3dae5ebe5f1d9722 5e3c34c7ac202608bc29f59e967fa6cf29096185552acb3f61627177b29a4e2a 432d8b4ca4086e3130fadb83c0682963c4359f51578f9565d5b361a97399f64d 31d1e11222ba6bb224898901ab74ccd9bcfa8f9d03fe0d4a6acc63c8d76b42c5 ece1c905470a9a448640cdf61cd0f301adf684c1d4d96ee57f6bd3da53ba15f8 a1482bdbc2ca0cb99e4517ef3fdf8b413f8b97761311392cc7b62313a229edd5 bae4c5499eeb446f7c2891f3009144b659153e55bcd5bb7d0a811c148c4cc445 cfd52d8ed057fae10c6431499361d446a6f6c1da65da9b1d075a8ae39f359f1c 0bf226d3e1df97eabbd310b8f85201cde4fe7433787baf28666fcbbaceccac60 b90c7108a5ae304db3f4ad748ceba02d4b1b8d661b41535a303d1ac0da2403cc 5b0e4b5eabfe175f1903c4cfbec11ee5362a53b301d0fb8842b1023aaf7e942d c7009ef36c88dc69d7bf598b5356f0636792f200b515811ec2f497ac4251b983 0a698c78253415b8d4916854ec98b84603300eef7c42c88fd421ef95e89a1446 8efe9dbdf376be70a7edc156b073a58f09d2dd29153cd3318f7bc0736cf606b0 d448cc4e76713a1297a303d9eea0eab3706818e82d2a22d4391817515d52502a b01f789e528145773c1ff9bdb924ded15168557e8d066227414813e1bba596df 60d9232a18e3bc3fbcf7aa9d8d686ff9af0cd13c9b455b07f85559157de63a50 bfaccbe0e16d2724aa258e5fca5694fbb39127d30a315c62f8afc32655e5b6f1 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 true +check_ring_signature 54ed6f6ab93249e8a6c9a32c2843f97096222f509158eef6cbeb34e72a431d19 2b00386524f32416a29660e40b775f189a449cffa2a14c398caeeac5e7779411 1 b6a505cb6bc3d4b0ec2da3cc887df7da7ada7fd4d57974a97fce0ca33787e6d2 2ece9e456eb627cb12cad4d389ec21f76e634053ff1af4a03eac76cff0ce910ad75f1b887fd1eab65ef9ba3f4d765463538dec15b934c0019be0a40eff5ed20f false +check_ring_signature a91a6d596e51ce9b64202403e5abd4efd31ea3d6a4f558f7d01d10a7e77699d8 e0f655993b8a96d76482382831431ac63c26a2e3310cd4ac1a7636927bc9438a 1 3e757220248a96857f81b1563451ffa7be41ebca5d1544e3ce38a27bdc3580bf 7fe91c661632fefe503c697af59ac61b6e4f31ede654335c79bc43183714b70168d860d36d0fbac5899fcbee5cc02cbac9c2dc64f2ab53580bf5c782ae6d190d true +check_ring_signature 1403ccb9336734ffadec14f131dd081c40d9932dbda084b39d1933178c2cdd65 50a0b166eb80d4abd890d52af621e491a1a7a4306470cd1ef9b24c336e079df5 16 83ba747b15c5022c7650c22c94e6aeb4f0960b89e88ac682861d1830e5e4d466 02bf063d186384191a1eb8d5d520d5555f4b6da4398930f6ebeeef9573e39198 7e96b0a15e865d48fa142fa75f4e358c106d68c6db8ed355e21aef737572ccdb 2197953a7076860ead8ae483093fbf8aff212b4c29ace2eb1d806bea7fa91ad5 3b572cbc150091dab0e71163baff519820b508e78b9958a7af07ed1bfd5d0ace 9c3186a37a22fdd99eedec7de5c43133cc3f9dcb6830676c9073fb2be9fe33f8 151013c9accfb3b110aa73162d75da6a3e3fedfbe95eab9b4ee93f0fd037c224 027659389c25eb6a1263893b9c300cd657463b728d2a7be1714de28e9e14ef8f 72029a254a0d7a364a9ff74c34540bf76967c3dfcddff002c1b3d91bd557e632 90222af85aeb20562d1e9bb89ff958e22c9cd302ec7db957690a1cd9e7037449 8653d73300a9c5e44a50b9a11509a7bf3a861485d3f255f430342f09f1ac8a87 6213b10f88d73e4c888d5f38c139aa9f281e2020d36e33b18d2814e912a5e7c2 796f8770ac384b5369eadee2fe83ec56445d5185ce7956022015a7d5abddd64b 60f52b1a6b5c83df278a2c1b178d6bbeaf69cfdc80e403923b593d7c7a767ebd a5a2738981ce432c5361a339bf135230b9070c104136339997bcd667f154cd49 8d11919d8481f00eec2d9af985a5747d22c854567b4b5bd5ef1f8c0ca0d5b84a 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 true +check_ring_signature ab396da5fef5ab6406157774ae993ff9573807ac1fbe58ac9068e25f5eec2e99 3593c2e7c1dbbc208ab9c5debd66727e2be11b61a777fce4665ca60fe41d5f3c 4 3341ba4e894c6fe88ff1a2244725e9172b6663c4b95808ec827eeb3b760033f5 0ab64b720218ba936b7ce7a20afd68d892fbc3ee26201414e8f1680efeaa5dd0 dea3e16e62bc42e524d4b59f04ab911a26ff19a9714ab96cad8e397aeeb785fe 7e3385ec5dcbe6dfa19a3b0c2e97005cdfb71e020aa633312465e4f6c08207ca 03abd9f2490b9726e7be5827b29582a2b31456838d53d6e7e415199dcdd778010cfd02419ec3c2123062d6b09c92cc1a2bdd983a555729a637ca4efc50a8340fde4487c39469996b7109a87ec5b401fa6660cc779c18607ade2dbebc991d5500424bb9e7f9cc55a5c1a2fdcac7524476d4e6b0a30836b89c4907dac9ab70f700d01e58c76c11a251842619b0464a78d19ce0f7213c85e9683d8c0530c6841d07d57e27ab0495249a681e2f9adc89ead729547e0f46594755b8ce89424380a65848cadad581010a3def5d040fa054e96990a0f76aa9d50b0cb92eb3bd2cc41a0fc59091c9520d470ac3b1f8e0f8e0dd46468a88efd9832687dbec103523080c01 false +check_ring_signature 3b4f1d5ec75affecb419325c2d37fb3a0888f9e68916fafdfb86af3e38b750be 24802af2aff5aaace116c0646c1d6980f995db6e1104ca0805c2ea711bbc8e63 3 b1405b617e7243635c3edba2c0c6ce9fb63a1d8875238bef868f584250ec6c58 26c4407f35d8374f0469ea0a85e2a55dce67c7f7516e7673358fd1914cc412dc 8c8deb1f91f5958680be9b17c71854b6ebf5ed92f7cd0e68027f46aecd89c75b 93a0e812e8db1f183f7a7c4773d0f719218c877d1d4a4e934b5892f90bfa310985204b3e6b7d4d4bd5d97322d9f394a1dd699f770e44dc18fab64e0ad2ee680c5fa08407b9adb578133560b67824b142b4ab35eade7de1484320df0a55046502716a495d279230fe4dedf8776fdb24031b7b7985e39279bf681250af13969e0d956cb8b69ae599824e1f32b79224c9c4a54081908913498147f0555efa7edc0377547465228c414fd0ccc76119b2d2ea89ba88baefb2238f0b8d6c372739830e true +check_ring_signature 0e58a1dae60b0958b65a5d24bcff32454664f3af541790b0a7aad821ce3a9b45 8ebd3d61a6e4a8c1d0d186b8b5dc9b9991660dfbb322f5cda7199bb5dd80abb3 64 c0b55fe81fab1975f0c7a6b28d09ac926f81c3f94a1031a0f2c731407573e259 4afca75cf9b3173bf8fc1766d5cb6e417dbd9836e882e656ba0e0d0a485af6dd 2e0273bf427ee7dfe5b59e477b9f6bde5d8417ca90648cd5f84b07dec25d906b 8e3033b7f506bac463cf1940639ed8162e2beca0f5f01cd4dccee0298ead57d6 cef2255dbfcb2cdfd354c2f2f84d578851a776e56973f190b0e716526454e621 69f052160b5bb061d62db4e8b0671b79620b0ad60138826c254f618a9970c018 b94317e92a1fbc84bde21b288b59c725c4f467b9c0463846a7377e2bc057e53b 4015810a46117c3a1304e29411ccb0ecbdb7d0041819473addb83a5719d80ca2 a68757d9d5af2ff1d795c6b7a57b8f352112457c19b21483d9ca47067049dbb1 d14ef297bdc73c661014c898dc601d0a857aab477837a887327b7026ff8cc490 173201230f111fa0bd3eeb8ff2ce5dc84700c71154ffd4c79c745ba080326006 99c4aece12477bde003e316f1d63d21bd5defd7e675b3f426b1cd4bfdf4c6d1c 77f2eb895cbad34f5d66d28978236c98d48733236fb79dac5080f661a77e3fae 62c9ef9c9b181658653a9a72179356ec76729d59f48ee9bf02ab42f39c38d504 d862faf98153aed5df6961c87d07e87b69286482efba51781c72a218dc1fa38a 116ecd32bace20d2ab2737c059b0ae407cde4418e51f7799dd99ac5e19250d55 75660dca7637164234d1b8938b793badbb7dfefd752d71458076cdd25ee956e9 08c76ff16e2dec437cf9d3d95d3dcc4d8958f5b7e9330d60188729d7aa1c17fb 42efa80dc099ad86322e29c174242f2f205d7d4c5365aeabaa18917915f23daa 3ece4ef87348800f616edd0ffc1ed42523152e5c55d54254171d0ebe0ade491e 5c8da075cd30f3f51464d2dadbca9883fd15e69873580b6b039dd72476a2e4f8 954f62e4e2961d99907acc65cf3806b8e3bca18be33d97542439582eb17a9d91 1141685a388aabcc09822de3d2c0cce37621b0a002d99d4abc330e8c99e18e96 bd12f93391afad10aa7014509fa648d8b19c3c1243832e8cc1b8c9c40cb1d855 d41a2c0d98f0874b273416dabda1569e91c00b9d417d9521e123e348ffef3c52 0d44e60656396de6c3c31f5334f9e3d6f2af0e71d3890dcb7d61e07e4f44eb36 2ceb2511f01b5f120b50b8db118fc2c7081155347215d7b046012ed1ffaca018 97f803c8ba429b7de76fe4f3c569e9b9eafb64c7d8fa1dbbd6c709a9c466050a f8f0a9ea9a5a870851e7ec92984da77529404535c17c340f2b53f8d154797c9f 170b1300bb4a6450c9af5b8c61743fdcf324568ae4d11317301574a6be80ea5a 54883e44dacb182a009aa1aee3cc6a66db0ee6ff38feb64295134658f9915272 73da11f9e2488c17fc09e4766745bff1fbf4983465f4d96084878c738b06b2cd bfb7aa92ff0178f740489bc6558b82460d61f30cdc25c4468b337ce80b825c3a 231632fab530ca8a9b8f3d99530eb3280fec1d10d3b298735fc31ec6f616fc87 477cd97150d6519558e442df3e0300e245a0a269ec95d4d26920254155211caa d291b8939788813884961e2b21e86a4f11084e1e9abd8a039710cda949415675 615555c2d90d5c85c4b430175d42871f5101d6fe9cf27ab3361d210460ec1da6 bc64fe638fe719bacd2ab5eac7f73c723aee2c47bcd5ada2b7dca7569ed6d0bf f5cd7ef6a9d4bbf5793990654ec6f7fb77bee475096f544d60ace19b0c63dcc1 62424c4e6d41e81966979f5b9464976e82cc6bc8b06ecf1b3d99f5aa67dc3526 6c040416ed9d72f7b80ad751cd3feff5ece30a2d7a67fbd527949d63f2240a84 cd23225a4ab5cfb9839e28e210f13f46771770399aee90a59f1fee3eb4967d49 81caae034cebf87516fd25fdc7fac1552d02e0dc97620d1f25e04f52fe4612ee af8a43ae765ec50bc2a803e13f9687fc87194257553c047dbcad1f20eb79405c 3aa3c8f66df8c566d1cf0650190ebaadf45d0a3e0d6fdd74d1032a3e962f0dc8 ed07b007dfc03bb045c8a84c9562b2f27e084fa372aba7fe3edbd1fe1c3804c3 bafc42df978d31f50773ded5597709b6d4a250dec59e22c11b50f1578bdb29ec 4e7d190fde1914a9f5a9a93b38acf37d85f373f795ac94cfc38ad079d95b08d3 8fe1fbbd8a70b01a970f4afa6f87bb4e002a7f0b074fd82ce3c7bf0844f63ad5 c201ddfb7d46f9d7561c86b63728f41e204b1706a52f644b17305155cb287223 1592bfda59fc101a9cc971d8617edbbaed9263a6dd41a83b4d7c170aed926550 21ef61033b9ffe7029659f09cfe11a7370ab614bb1bd71ef61109c697924c31f f58874f5ec733b2ed7487e5b0a08625c121e9de654d7507139b390a27a24460c 7c867a73b4e76becc1c6293b8bf5c41de91b3e5ed58511da015380aeaf24940d 5a6af521f85f63781735481058f7b6b38a3e7b7bc24d67c1c67f30086f0075c0 f3d7583906522329ef17fe7069638101e465758c4e47313b9f57cc72d97c16fa 2c57add91eae939f39d5f402b73dcc3d456424a1106202c5db6f45ee7ba33eff 635458c35478f3683e380698c878f44ae9816cd94688616503da2c9cfa62bf4e 6691af77c7fab4d8afb20cabd97809f3242bbbd835bec9c0da8ce1a675d45885 910cdf3a80fa0b4250f6666478da66e5e34c33db68e0bcf792349b65e60ff50e 060ee23f790139a620e28644f1f25d68127ba97fd904910b9d1eef91907b086a b3050ac72f9dfe8ac55193ab8fef0898722a390eda36b29ed609894f3f2d0b3d b79cde6b77791587af70a5f619910356368cea86eaa09d2fff7282e012d1b400 f64be348dfcc802d1caf6dddd41bcdb3d2492c095d8c6a0010665b67ec71e944 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 false +check_ring_signature 01da08a30567d6ecdba828b75a0ed70ea55534a036a1b0ddec8f6fd353ae5279 b511fa7900c291f6d22061d530b656ac81b822e8543c44503f45cb623894c472 7 6071f5d947fc4c0da9a959d99bf86cc856d0f32772d7680adaabebf5bc761e3f 8abd29aac1520cd41691383b8c0fc721d7995d3669513226922f4d33f7607879 e290667ca6f4b840fe6a42d34cba4990a7d8c68fed8557d1b03b528f2e767462 98773baa374d7897b4cce59d01fced1f5b30ef05fc453f2d9e21cbd969000388 5e2702ab0abf228beaf0adcea36e7c6f725f5426267f8f7dcf7e4c407214c156 e1a745b7b1bd7401324639794e3c0e18f38463bc2424f0ef5cafa8cdc6194272 8f2837995422c834cf9927757ed3163bedf649149515ead9d1002eb355bb1a5e aa66ca8733718ec685d8818cd6ae0cf41ba79301fe8ed830e9646d526a760204077f7d031b36ec636b41b05f2a3b3becc770e4605a5f752b379d97d7e86a190b99e1a6594ad73e48ce57a79a3b90109ed7c0230e23cbe321f4aeee982095dc0e8b54c3e03c9bc680ed616d00bcedf8f557b496f99015488e6593ff13c0dcfb0a846585a1fa03ee67a4a0fc57e2e26fa26ba850bb13e612173e40dc897eb20301bdea9fe62fa11ceb9c604bcebdbf176ac414db2075ef7e1d5ed8283c7402560b4fa71cae6a93ca18f99414b12c47989a3e5d98716e74ff3c78c46f662f912a025768c14f989835c12ecec116d875f2ff941bd8895ec1adf476e0149518de590f2a818e87d312c00a2e42cf20949d6cb45d3f720e6d17b23f06209b7952afa0084faed07bc5040b841a1dc99a0bbaf14ec06662e2c3f3d0130382afa6a57641087a2c1f98730c547ca67cc03aba7f91676fa704771cb963ab74c68ec0356aca06e852462bf007d0802c60bf71c41a35311af20b7212ee4eac1c6b78a664810e09a9ef015107bfbf0becaf1a1abdcdc112458d47bbf37e0f1e671ec57921ebac0b3c43411fc23416bde0b9b57665803806d3b72c550e2d1893df629eec292c100c false +check_ring_signature 94f729667d6e6063bd223a5d78f085edd8d6deab8e5bc4fd52eeab3a696c1929 f67f198163eaa5d4913395119b12a4efafc4e019f7be9a27f89b7d0b34c09e56 1 c94ae4c840cb95833a69ce4626448713466433e6df81196217639c54263b42e3 bc7fea307918dc4436261e9d4bc546d4f1e7a3d0156d61beb75d4639b6d8b5dec543c7e019fd92f51de5c6a03005a3fdada39e3797ab9c968db6242b753f7100 false +check_ring_signature 49cb0ccca07b5ddc062be0f909fde2e808bb0a1dec07c15f0c6218d4233fe451 9db95bef2e2f1df15221f811c41df004bc73ad611528d0c7b1e3a459dd3e666f 51 205238d0211623437a07e316cb658f41eba7f57382d5b764899677b4326553dc 73b9eb65369b646227aa3e70f0c2357ad0ab2843df4fd18da1d9427fd21afb33 87d0653c5d729dd89ebb0502b97b7648016683865a360abb7224ebeff76446d7 b2645fbe446e2e760e1011950cb0f1f8502c01e7a7c107d16ca9060c9b558ea6 e20e50ab0afaaa3dfe596a44fe2382e51a673545f3462f6cc2b3015edd7fa59e 787d70562900a31aad4353e14b8b0e904a697b5bcbcb4499b9571576ad9c97e1 e0116bc6fffafc870550f14a2456bc7a4f440f8b2a251408680316ba457dd6c7 6c478a9bd4bd198b8f6433aad4f3e628bf90600012ea377990365e59c4615675 2fb8cb8788d6b69fcb5c893398e4842da34be2ead5143c89a33524bcdb98e81e 8d0ac82f5c21a0817998a23b4a3c17a7772b54267f7f70bf122abe1f24722912 c797ba58cb324ab46de627efaaedb253d8c6aac72231471a4568ce61ba58c9d1 878cc25a26676df88b37b5e257e4f923350ce8148391c498e57e18e84c6f0a4f 628e016bc577227dea78cb96ae2b95dadb35611450fc9a4829ddec9bde68196c c7804b8da739b79c53eeb0a3c1891ed2b0f95f8ff00774c16ed76b8cae2b6c79 0ce3a22e8c9973cf8eeec3bff3eb7914b3e4318c79d26722da0d7e17201da97e b9b43b14197ec1b448f012bde49903e2d4f6f74680a2fb90144fda09e1caee43 44ae0d9d516f3ca64ab47ffbcdca7602f7a69047bd0072d75802cd2b0da0b42f 48e5badc8822eae549f3bf414c7560a798211a02d1f97512dc47262d82807d75 9490d09126b4c59a62fbe92111fd0632f5025d43084c19e7aeda849a62500c8f 8836736fa154f1ba4934d50b4798b26550c33b70c9f87feffe455df75811e6b2 e42dbf1a903bd73f3fe591dcfb1eea91516c0e94c37ab79f923854e94b50ec28 2184c75255459e2b6aab1ac73308ed492433468be30284d7da724583d42f5cba 727c4322a3878410677ff4da8857a2d6d212c0fd9f62ac13cf4467252d911b7b f5958398c277c4ae8fe909bd40735e3183dd6340d7072ccad9f052d429a72107 9ac7f2d9d06a2c9c8212dc8f37856c7cb1c2d475d0f18e11566d0cc516e68120 d9209571776f6d1746efda863e0e031f4c11446e94543bc23fe113ea60f88795 c4294834884e64df8e75d4b87e644bcb6dea9dccaebdfd30899cdcefbfe221e8 49f29f8addde705d9064e0cb8d2cea1de4f99f72ffa46499d4eb09da47e7dffa c3c22bd945636b256ac0e9b68f66b7602d6a61d6bf59610a624d923afb1ddde5 583f1cd8d1d7310a23ddb92de07f455ed5ea6ed26d4abb4ca2ab3920bf3acc50 218aa49b74ec5df02870a3cad8ac935da5e1f70deb4bed3d454ecabe07e873c5 dbbfb9157259838621f2dcfeaf4addb215467ba4c5cee02a01b21a6de7cc08c0 007997b2367ccc32ba6a2364ee36e0e8eb5de1344230c6d76a3c7325eaf0ec8c 67d711493194189a2dcf0017633e5fe6a8cc3c299771f1738f716565dbfeaeec ff7e6f3eb64b0c5b3cc3187975e6443fed7479304aa7b106049784fcc208a624 a516c2abc15c5cef5d80f0905f29b6f5f05dda28f17c4c850ade0558225fa9e8 57e337dcf66f53decd6bf4645851fb3d16f7f79a84ac28b9fa77f6ae482c318a 9dc1cd8c0f8ab4e3af3db17378dae604da59ee576931c2699b933a5133958692 6fda7123d3d203cd1aff58b234566f6b1ff953c66e84c6487dad3ea5fd26bf88 439f2efbf32d70dce3911604a704f3b95573efb001b7758e3b48fb3562566791 34ea1f27476386ef2f9b35918c8252f1a053fb8d8f33ea96ad7df4a10c264d27 c9c298a0254302df24425b07eda8477c18e4801ff7396475bf1cf99e0b8b23f9 7e07cc88bd1205d54fa157d105c676cdbbde931a8bb82d735eebb2d8595f3706 d612d4d376155d248f8fee97d4d14f8e1efd1e26b9a3618722f5c742f75b93b2 fb31ebb01a12e6760d0c2d7c2fa9aa7867d83a43dd13185b0a9dfdbd7044bedb 12d1e61047b71ebe737cfa9214c0391f7d762badad108b8220be73137b9a9232 758ffc63594b595c7586738be6bd74968237affddd94864791c97cffc474c58a 4ad946dcd4f59bbbb889ab58b54b99cddf7a71ddf4c84cd44407111d3fdaf27b ff27be7b0cec641a134236b75548af1afac67ff3db58c460586df2c6a39b4537 7bcd8dbabe815bc778b13c0be4bff41f1b7415e34921e863e939de61513fc9da f452a49033505494b4ff528b87ad19a2dcc644c8936e61018d3628a47f9a9ef6 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 false +check_ring_signature c05f3c24bde66da6cba56739b7e994d13f4d5f484a0b464209090528110951b3 a38b3116fce718396a5feb383fb81ac6de74e38cbdd5a40b565ce6db1ebfb789 1 329427ba240eca464cac0c73350ca9df52a5478e540f9cdd9426ecfea7449248 b2b8c69edc2200915217f6c51162aa546f089385a82f93ce12f08c5e51c1fdf2f41edbb4a72f8f978d7f28bf00a057e3e34bdc0e21178961530ca1f6582f7d0a false +check_ring_signature 4be9094694f2dc8dbf6633deef679286dbd459f80e312a71fef849d5c55d453d 53decc83c09258445e164009a719826fbaa9ef8efab0b674fb4a4f804e44a103 1 5f095675c445a4d074c68467f6d74d9d1177f06b649274500d248bea0125fce6 3420c6415d320aba95e7e389ac51a593da67039f295848606a411743d2c9c1075aebf02ff7d2b404a6920a2b02adc07c13a3b360987f388927b3307a4bbdb107 true +check_ring_signature 8ec9b2be52ce8e67b2266ce7e69fe3c0e252758f301f1c1e868c4941431fcaa4 a5b5541675c1c717600ef5556a1b8b71813448cea72146be63e354aff4ba7854 7 4516af0c95309ddc08236f640c39a9da42b0eeb7632a95c69229f45b56035570 2a7c7ec2ffe294f0973366cb4d7efbeceab4de126b7abbd622b09323258913f7 08908d93d5a8ce574ee2cd1366fbc5b31bd9ea3c73b821d6fcf53671de2a0e95 8b07bccd91ce15e5157ba6bed24bf199c52e082e142c1d1e2d033315a9541272 e9ab69776267e723d42163187f540d4ec0e3dbf63a8deae4edce7e49e3ad1c1b 94dcd133179345528d30af01382d3b13d54a034eb128c203668f4c0087c1b27b 56bdb26b916e02a27ea7e7d053d7f9413eee31180562dbeb772a5d9669998a1b 5fdc466abbaafc5c08fd72399f543d5930c589f185781f9a3d67a6a0f6f52308e6518210544b15967677bd82e20b942ba365a17377706761ace051d0a918d3cedbae2cb219c1a973df39f13595c363a1176b27d477f46ae0f84fe766243b4506aa9f74d868797cb6a4f167d9793e4f9eafbfc176b333a820b93cd8eb1dfbe101792584731879a037e3206573af81b694a3c3c4d4a86cd441dab98a2bac50c0ae6797f771d4ae3bbc3c4b95503443a14df33678da9be66bc6b3d6bdc8995207020657b313d123b3bf7a45c39f81c63160ada34f2def245f6128d068ea8ad1520c49d6dc463e4f5f474649d2d63605021b5d47f1d68d11714af6c2c9d372ce450b93aed6ff4110fbf89155a6be66cbd1f61796551190847763c41b9fb6b07d29016b13cdd9a07cd6e1c91dacc68bf6286f672c647268503f80602b7970dc879e04e3eb4fc73c531f13504831d24acaa7f010d3051b9372c4233ae36e54e6341e04fd208ae3eafd6b3cac0588556829364f9b22e7edf7e4b03aa86afae5ffbeae02efd3e72b5a2cbdec4a98e0fa14934cf2fe01a894a82e5047c25bf35107cec7ae82b8d5ba8005aa5714dea3633cc347fd5f8bf43c950634791054565fcc1e800e false +check_ring_signature 148083cb1f9ea73600160d5a3d471fcba9e8264ea2073a69d4127e2ca7a9d9ff e4fb152b0cff5e5bd70319089443fcc7915eb7ffae81050b03fe9090eea3e6b8 31 5293c8807040bd7b31ed56fee74f968e4e1c2a79f45abc9e32c59c9d9734f32e 130d5f75ce9a96fc5966a071a19ef14fb07b6ec90ea1079a02b5a97627bb2034 42806138fba1cf220d5acb8fc5094fed14908ab4363001e14f3d498613c46eda 2380b651953ee12c29869a0607f5a70fe5c130703618e279dba704c5979fbf87 ca20d5e72cfb56f1ed874f39a439d7e635ae83a645312e26aee7592f484f4bac 0393c98aa2eb3feaf4ed0d46d53604480da157396b03843172a2e54851e3f93b 7b8fb71bd7de61b6676560d19583069a828d97c16ae040cfc68e6ba32aaab002 4accd30a210904f1df173d63820662f7768a6dde1c34d2baff76044bd7cc5e6b 7d28a93019976f0f6a7b85f273985f0073cbb98e1be7bc83d331b1b444cc4059 6cd39ce28eb4ec8ddc820eaf73b674de648318749b86aac9230197f1a2edde0e 4557f1b548461861e7f1cabfaba8820f7ae1eac3c348bfd1c1b4f17c8c05eac1 7b7890c04da52a33a915f392f7d1443ea4ea2298e4c6184aeb258c3abe260e02 a349edb224392df00497afe7be4570b57b7b774d9ec9fe0bdd7d29e4fdb70a7f fbd27ae97f24cf1170440c220aec71c276d8633a856cb76cd5a223b661b7cd9a d7ffab6170eb15a7beb8829bdc47a25985551c9569bbb5c2ae6495b345e92c07 814518c6a93a6176d625bbcf73cd86c9a17ab4f8dcf053af939cb2db1e230c19 40ed6780d8b3da1c141b6d04b88c32e01aa4aec039d5558cff397f51e471e804 09b31878da71e3de219c8b6572a4d7c7c11df1d2fcc9230854c6512d4a9061ab 855beeea70a28f34a8f038517af0a9681b8980a73ee9db296b049c535af8aaae 5aa08a67dcef8acc8a43ebe9c14546167c212e50ee82a3968c1789aa96f231d8 066dd0a5a9380ec35a3e94c58c5e71def606368d782557312fe891750f524fb1 19ed33d6c0ac1a22478c2b8b0264934a4892a5107c6e392e0690ae351163b130 477bccfebead71c4903d41cd10944ea8133aeed2e9751e946f67f2e5cb46d543 4613bbe851819a8c536ac24d32feea03725be40c24a87b3803d94e715ddd7615 3074d696a39b8516a3b6155e44944693b9a1b34999c3d6266953b69bc47d9fbc 5d7b93ddf6f242598cb32b1986b0da41274bdeab676b2196e6c48c0acad8b275 074a3ed981b08a7306e3cc76e0cee04ea4fe8f5bd7402754a9070c6e0a50bccf 3aac04b90f676e335583944ebc6136618cb714aae4a57c20a0215cd6d4ea57d5 c1104a75b25167bda2a0da91f2a26e9dc4d1a163a2aa6a65c19d1a1b02204a94 db68ef979f8be6aa8d233d1ff8cab25b74792be57d32e25fda7da91e199f7df9 f327e1c37edc573453bcf7d21496f67b4276e4fe638f0f015fa30ecfd3e4ee74 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 false +check_ring_signature e7eb7ca60a9e2a60c47e84e8bedb776d0e8a6df0974136137d32cdea8746274e 9df67fdce070245082ac3cc491e142bf1bd60a353204d07e38383df0639a87ba 2 c416d87a918629623e3fe6bf22d82ddd726f5be080017f503475c9b32fbd3d51 db5bfdfdb3945ac22b56264c0a0111c872dc318fdf545a9599bb19cfc3df0e03 ca74a7dbc17beb5ece865612e54ea3a4b992eeb0913973586bb40ac827e4730666ef46388491d7ce50294ab77585df90fb44737cb88ae2577aa838096078c4e9d03d78d1b81091414d67c51cada76d6c53173d86bfb80e7dfdbee9d79efac9c806d0b6ae0e07cde4e3fdf671890d0aad8954807b740f9d89c97e140ed97aff04 false +check_ring_signature 3a46eac6533dafee94513ab3f3d2aade010ada6d24b9929a944974844bab0e0d d1cf334eb356fb9821c19c996c7398ee504e4189e81e4118d10d5ae10ebe2d27 10 7dc2a9bf61e9fa2446ef5d2119cd4d00f19a1a060bb9bf40d31de49b4da1d2cd 7f40bc166c771b9232b731c7700f7fa77a088b98729057af1c9a9048d2cbeb8d 25c9a38ba7c46671b1172b6c4d71c8ef203aeed6c44f2961b731afac25b8b054 0b119a80b0e76255dff73bc64a169485e6b8da332786378a5d9cdd4c94aaaf91 71dd44deae7e44859cd0b8cb713383de17aafe4dc0119b3ae3d3b3699abc5438 0a5c44eb355da1c076fe9ed4cabf0de8ff09d9997d642218ad161adbb04a0498 0c8a4b2f1cb404819f5e34cdf56648a304079ea4c4f26152493430cf4bc8a14a f6a81e90b260f63a999bd9000255f84f5e7e802df6d7a182c11e9fcbea334632 dbd4365c398af43ff8ca8165d203836cd860e6e88a834557701e9642bd4e65f8 f5ba92129233865c1431ad1b369a4876b9dc39e6d3aaea2caf378f2af8ff96c5 123a84142e243798f171e72a008cde5bb3e808c839745eeef41c1711dd840602a7d138bc5c77a49f4e5ca0a2ccc2ec92f8bb717f937b5b35977bac8b90262b05675a96bebb0dd05f347fdc7e1c510b340c265162545a979438fa63d78b6e0202551090462613859a184420925dccae384f4cff5a5e490d6172f798fe5c7fbe0faedd22a99d76388f755ee0ae051a7c39c2ce10320c1a296161b2c1444e2aa308ef00df0f5a6f3c108bed67be4fc87c3b24d4b0bdd436707626dfa89115d79d0180707756be9abae02951a8189544d4e782bb8d5f891ebe248ebbbd099c379807e078dbfa1bc43dbea505ecdcd61ff763318b97df2f58362aeabbe6dacc94ed0dc4e6165e1b5a90c0325f379e2e9d711e4bcec5d34eb2c375f30db8eeb9ae6101fca6adfce04a4b057514c0eb5baa4985d1acb4be088e37b318ebd4e49aa2a20aa9bbfe3992e6d826a2a3f9154bc4f652ab06b3cb0be643e04fa2df67f032c604485d7ad810aac57ec596af072a0825de496b704a15c914b1dc1ddd9ccc0f000104cfd46cd424f5169fc691cb532ef6405b1e19f8352f9e3085b8e5e42a022e09d84d869a006a3637a080bfbb297899b0e6596b93830d27d0d85d5bfdd220bf0c72cffaeb09b078f6aa5c999a6ec8ff3f144e49289733002dcd8f684bd2843c0213fe92870d6b2d40410d24c55f2f86a022ca1305c5563f3935e544ce9fe6660ea4648d38f033b5b568edf46c604de4246b0629826c471a2bb0fa4b747a3e5d0b3a01a7e68ac51382cab313160b76c09c4bb8bfe6c7bc12f5b9726f890668d30740f1a401aea627093662fbd9870296be774b6426daa035725cfe993dba62b807d8c15fd2b54faa94aadff0e12b8143256a5324db1f4263a6b293d8798b646d0a false +check_ring_signature feb03f9d8137a50909e9128ba247ff7991168059dac7935d619cf984179142a6 4a8b504d92f63af1bb28697b80be761b815ac3c6f73b131c4fa369311326a104 11 860e4ae88ff305c838fe82379cf26e9207f2f9947b62839c0232ec1ec6a72426 b068a919788ff61d27809990116fe68a1c70a4123c7a7f2c7a1bf3c16261c691 646aecb09db8878fa3bf85967f4eba6b8afa04bc13a54c34a8e4811cd14b1ccf 9f4093520e0550264ab72bf792a68248dc1158f828a151fed7b8ab3b70c86920 fa347cec2f4cb5596c03caed2d3a939fa75324bdd7de394b51b1da537b209fa0 6da159080ddbf59d167eb2c69a7c3a2a0e22080b9d079da15eebb8194df368f6 4f9116d28d17805e56636c20905c2985bf746c2838a3919e3fe588332dc49ebf b1bba668a79b83ea96e9b50ee0e8385a9288e488c261aacb2a3da3e5bd671ed9 74e286ea8f46f327cbdf1c93c4a3c702e5babb27b6c05ee9331ae15154ba8d6b e5d5007d06f7587a18812993dfddf40d83a30da0dea8d9e536b45f23db60a80b 3cd909a59e588bc161537851e7226b4cfe571bdddd19da93fd2f268d8c69954f 068bb176744621f938434ef994f5c65f04182ae292f4bc2f9cf8bab31dcd1802e9c84256a2e51bb393815d212a7f1f0378a328418a5f41059dd9d92714a492037ac7643a8c644c35f23c63f2bb250bb28efade9d6c33878f930ed4739a2171996e1ba62690b522d974e0660bd192bf0a53936a4e5878216dd74bc47514d8aa039fdd509cc13592fccf91aca5a83b5c8e9906a9c74268f7cc9ae01a6dd19242040b320eb1bcee09cd845c17e4724740f76030e5fef120aa4444bdcb40cd2a140678089171fb6e7855d62cf6734ea0ba9d591a3a3833ec8422fe1f4f3a1a270208df50ca3a552ee92cc750f9b6a2755f14f4229bc758fd58f12dc165d3a517550cd195b952e415517516dd198bb3b5332a669b71929044d2180105e5aca9d46302f0d3714674a9826d4a91ddd2a7a32dd21bafe7e8cdcc0734d84fa6599b878e09caacc90ee8a5c22884444fd5ed2cd5638285e8bee9e2d86893cd196afff1bf0bb476479b1657d6fc60dcbc62218ac17b83c971c454b4772bc5f6767dd9df9c0c014548f139af2e7733f39ce67f21970c84a1004aebe7000e6060a6072d84310fdbeb73517aab60a152eb28e7281b3bd6d87116137d02b5c7cb913ba89918fc09bfa2c9ae9cde539483c6e5185ce21da7adb5af0d7d989febe3d8654240b0349792589bf8b5cbb2260c499d2f666d67669e74988e187986477486983377a1030c3de2e7c9a633f97cf3cecf5afc2e2c61a78a537827b46006afcfe8695fdc160d78f143e792cc180c3a2716e0ee2e13ab9373834274b876d022fb41940f685d0ffcceb9a918c6c68428530a2fead1329f9e15e519c79cd3cdadb4cec7209a1c02860854929bff674b98385bc8b7f9434f870963320669b6f53eb31485c3f86b05317b4ef550d7c1918577d44dbae8c39396cb02541ae01bec7512838a2709890de102348e4ded460fcba37ea0b321f1aba1b861889ecbd4009a9266e9dd1bbe0c false +check_ring_signature 5cd7872f8041b2f30ff643dfbe40442b1669f37bd83b72ee7a2a769ea9d70850 23dee20054d97ece465cc4d57e4245376ebf47b68fbf611a867b10cf89283a90 1 9bb4517a572d3c3fa7b31f564849c1cade44b248ec6fde81e54633be0fbe5feb 95e1c570aca991e4eb414953de078fa3e4b0193c0b08a5844e6b474f00c3d5009ff0483ccb0639108acb4c2163c38c96f34a66bea624b36e33d4f2513ef1811d false +check_ring_signature 4d36ae51ce768413ea906505a39f939009e3c2b718412dbc02f6854866be0113 0bf77c5c8bfd5c41bc73eed6fe6578296fdf3c86488a589c774515b02e2dd13a 1 c7fb196383fbbf6013fbf94c1e5e87ca6e7514f7d06e1d6e248b82d53040a490 aa5afb0872a8e378ae463a230e455d279b56cb6ea024f80e1127e7049b515d04fb12720ee2ff283e0a7f901af99af09e167be8bfe9ae779353768068f23ca102 false +check_ring_signature 0f71cb3d425ceccae4f9448dfaacc11c89bda536e75b68f95d22888b7210c004 4d5291a288e5df379ecebc182dadaf35b0e1e81fe40bf8c3f5f941dcbd85e695 1 88dbaba577c93003c7799cfff085a6f032c3475867ec342a307f513e29792913 12c9c9cdb15c965925d92c476045ac82e54839d30e18c4b469851c9aa6b64f052f682bec37cc82e7d287cb1559b8a7e53293afc8da1612501d1c9bf64c7a6608 true +check_ring_signature 034b95eff880dd2b657093f53ba15958952b560f0a6597b2dc64b1855ac2d857 70e89067b0cf34bd26cde64f4f0d9dd16e9b5b0602ae269ddb17e4ed2a69e332 26 b49afd99f12f1a47948ef49195a9b97a85096b9e9ee2cd6cb4d05075d796986d 2ea22924ff067753fbe253741ce8bfa8eabe23cb6cb035c5cff816f3cae1879a 9381229b18a29ab809c431719ecf8e57f37a1ef3d62beb744d2eb811c6e12a3d 2f4ad8e6d8aae6edf489a0bcf35ed7fab19ce4f5cb88d7033f71fd67e8f27e51 d3165f46ec3c32887a10e4a952e921b5d8878f7dfe230f9509f642fd1b811768 4a25587cd54e09d3cd7db28d579698964ca2e673b0eb989baad207640f09996d acd8f181dd689fdb0a6604723d177f6fd2078b81df4923a2e0808fdccc9c6151 2d826b291eb467cb1d583056b25c31e79c94ed677579936bdfb02b8229b8ed17 801fedbbcd52175f6154591c145476a732b520b3efaa146c40deddca430220c8 047dd5a647fdde8d81fee0c727617454e109921199d4ca3320a43b1045acd875 dd252f1bfc0b00626efab7f8829ba9096cd8e99d4f79b3b693c20eb46a3dc354 7c15f6191d4930701d01ab7905a98cb40acf3ed9909745a871a3b5770d21f497 c31e881a3b360ace0313908c8cbbe7247e151d47e24be47c4316fb74d2a43a13 cd24da3830245e81f0c02b402a849c4a9e57d40e5e201330b471bc25b9904881 42af514f35f7906ab8b13d8d4129c72cf917bce00dfb830e80ed98ee6399a777 9049d9c9c64f9fef9cd93284babab470ab9b2ed021d3d15454173355ed20bf84 bdd27c063da95c7f16ecc3aceec1dd94bd7a991d1229e118112e3df13d7816f0 0749637a72fabccfcd4b9055b440d1f6e9d4e5941585d68c60c9000a40a8db90 f2c8341477880aec487afffc285425ccad0d3e8b2942ed159af6e9c1e68dbe9b e197f758fbbc2c7109ce556632a5a9daa7e0d99823889124dbae109c0f1a6fda ee1130e9a9f486cb266e67376b6dcfdffd8324fd8f392a1a4b393830ec222c36 4d83b7e77add3adfbe16357a80532e946eb27fe5a2730d4c141b8ce5f50c82c9 5bd1e1129e68555a6e094197ee1441b23185b346543e703bdb8753400d5b353f 76207f65654f12f6a5fddd01ff35e2407f157d0d9c894b434b7f7e32b1b60c1e 353d97b8862d4e3d5695f3caf0c5499aabbbaea30456e8004b489eea892024f6 671bb1cfbffe365f2813f9fdef0eedb4761e9e107ee7d03b4e4438703835756c 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 false +check_ring_signature f13f96893ee5eca557eb0cdc6fa2d27ee3d2c127837c124a91c6728d972e6437 5cc32cfa72a73b73a5e3f63c098d8b34e5669b26d852b1d68cbdbbde8f0a949f 23 4fb58b14f063f9243d16739fecc01e306d455b3fec24439962ed8718eb90ef0b 521859446e1e2022ca29783b62953bd6f8c42297bd066b45335b4d89f0a2b6f6 a1a4057f88403ff8e07498c6e250cf65d939dae022084bb30bf44687813858f3 b78ca05734705d39298b0bcb2382dc8ec22e6423919d1fa8d5b81bc1c6acee53 457d6d7b2ea8be06cf8e0f4c471098507deb1f2678cacfddeffd5ac1f77b1aae c19a0411a650168c04dcd042414d2cfa0204e34bf625144c8c3759e1974c7047 61a1a1fdd6b0ee52293186bb3ceb0640aa0707152f43aee49bb3d692b9fb7b7c c969732c51b9df1146cb4aa2d68bf5a9205b687fe6736a7740bee7ca0261dcbd 17d26b8f63632ddacbf5ad849a31343508045261fcd4248da9f33bca1bb78b58 d87de1c964cfc91d3ab5508e4317a7a9554918faeaf5fd3770f9b3a69ac4bb88 febe66f904c18692fb647a5c9a7b58831f6c15081e8612d29acc209bef5e5c02 fbf54795d2ef464c464bfe70971563a9f1ba951164b4aad015593ea1f62c2920 f70e92eb541baeb41063fa5644249ff7ec57d57be082ae7d066ae3fc5fefeff7 facb7e293d2d099ea65858e6f75822b455824fe22a170b5001f8828122fd8369 9a71305751bcfc5617bd33aa13379085e6d6663c30ff20236e36493eafc6a7d3 893268df518c452bf28f13a73649d93870dcc7837405c75ba4eabc444b2f3b79 a929a6f4613bc49dae063c0565e3cbc79034bcd7be10018b7e9b1343c5a62e98 0c628ac13ede3f3eb0aaba0116c7f2baf1c999b193347d1cbb00efb5f77a9f70 3f4cb8571b371213d7679db805de07acf419e37c0a783a36f8dc7921201417a8 49087659265798b73f20e15604744945149eb11fc67d7ef0e1c83366ce274b9f f678829cb6403d33a14192b1814b4ae6be26cddc4ff96a374c144651811a11f9 50e77dc1e5089d4ff8d1a13f7eb34e24fe697dbca23f917fd7b054dc3a5ac548 8a5ca58182e6d9f31d4588ee592ff11620623a7211fd3a46cd05e5cdcd0f9ec1 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 false +check_ring_signature 976d490dac6cb62f3414608193e6e47789e895a987568789e8a249448b65741c 45d9c0a426cab6878e3a57d6c08c6c3146449ce18bc2fbced760aed19aacc80d 1 47a923ce3520e8f5b954eb65492f4ac2cbb094c228bc0dc35901fb1a05e87dae 98eda5b352fd24578a5e9b184dd47f6a26bc103a3239bac4497bdea79bb4a40650b7b9c68e258e66d61a7c2cbce528cd02ab5b653f2211acc7d29a2cc77f91b4 false +check_ring_signature 001df89f5418d2741c22268e5405b2b1b68625aff1c75e3060f53db0fa71aa59 e26183ab4f2935e178b830ef91801f71ded2052fad100d11a8f48dbdfc47781a 16 8db3fd7345ab15941b74feca1b2e0854b70dbd2869d474d9f8c8e12246e5abc3 93f55835b1af1cfa8cf45ca01dc4c1c7d4d87c653868359151ffd95e504cd48a a6f692eaab89bfaf352df33b9344bba01b5b2e163317daac8af7c6485a6753a7 0fb6b84bd9125175d2050032ba9f04245276c5243db630cacef7eb6e260e81bb 582f9375baaa1fecea77fc1581d907c63029cdafa7aebb31cb1ab474b59c51e6 e228f42a717f9cc706e745255b0d60f332de7f2fffc2c4102885173e8864cfc0 d2d28b88c25914e8ac99213e1463f47f866fe3424ac7b718b7cbbf596864dd74 62a19cd03288622cf871d1e6427c924e1d20046471f1e071d8a333fc1a0b6403 9e017a4582cb4b32d4b703e4bf01d555dd27640655cd59fcaa50d8d46d1c405b 351d9b56fc548581cc0b3b6834110e08b805185c0af0ae930934c32d875a7bd9 b19f93572ebd644fde3cd723ff1f7a6f32bba8f9e4a686ca1a9e86cfe36ade28 6bbe1b41e8d573b0c9e5507ff0757124b6a944e59f66f7a2f1ea2f5fbc9e5e38 e5ca8fd2ef9a3f1ffec741139c004cf0ffa719ad4ec8810b614ee595cacf15ab e89aceeaf55d13a8b12e5c4b0342eff05861cc6b66909e04b66af5d121dfe5d8 147be67364bde26678522ed932871377ad3a1c458c9e6cab7d8ae92a0005c01c 882f548c044c5a30ccb9dc038324f4b95b5ffa6fd6c2f594eab1a46ff9d58745 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 false +check_ring_signature e2b53aedb8c4601ca095d85dba5fef7b047a68cab81e16595b2a613612e56e1f 29f4b55c2ede8ee4f5b28dedb5c941bc936182c3e2ec5ec74f01361e3cf0a305 28 23ff8e0fb86740e90b2d49be9f5e31cf3a3c8383529940965b8d5e84e459dd30 4979a2f898e3b00b3be2ff6cc8244e0c474e72a63451b1bbf22f63136349fff1 b6e4678fd8983c820c89a3c7428132c95a9a847c3d23c988356d7595645b1e08 24f7ffd02d488118a34851cc6b3c17fccb7243040a4db36fa3fd2b959f9aa4b4 344074065f63995e3c412e31b2743e0c65bf24f78f1d84c0895bb9f704968e0f 64d6f0d1bbdca9264d66ceeb112bb462c4c8eef4f53a0f54f34d67ece1ff70ab f3469f265e2b997072535ae50f3331fbd58fabb98a9b81d009041c6001bd6646 48c4abc7ed29afe7cfd4fc271cee57ac391ac58c098001a3a39541ba5bf08ba8 2fa92fab4c787d696b91da005b5809ab3c539e39920aa07adc4b66b0bb678900 3b6fe6c10c0885eecbaa5a99e21f07e3cd5c1ae52b906c828f98d342e4ac1228 4cf0e12130a0fda36c0645ecaba3368d86dc4ecf92b331a425ad1202fd8331cf 066ad2373ef78a05dad948acf864125caf7e9f4502e282d2e83dbe243838a2b2 9ba1673116f0eb5572678bec67da439aa51d8583e704f3e8253c40409719c75e 69f8ec8eab0d8279d7808f771a7d808a522d2bd280b4d9da09c32e13276e9348 fcca9b146ddbe3ce9b9c13b64ae75e781a4ddba699fca802d517125ed2ee0fb1 bd28b66475cad81db738d1ec702ad3c93d6cf8a4de9122968ef8974f5e4031a6 f5e05b1d3de5119d3923f2c875977f01d4ca0ce78e50061acbc6cc0075b4b6ea 5427d830e98586d58423881cf1924d3dd4a8c6bccb67f7473f0fadc993aed9b4 a0cff5f82ff3510021e6ef6a82b3566d5c3c796ecfd70ad7f4f195769c0d1d2c 14c13f20a0d96963ff5f62aab18fbd016bc10794f8069d860b0c78e445171a5a 5749e9c791a339a1d1ec037cf6317d8a47774feddb8953a7162cc8c7839b6bc0 21e586d319ab184e5005322e443ca8b6270cc45fa0b9c22c441a85201db0d7b9 58e8145a3f88e381964e628789442eeb535a57cef14427f9ee3481f2714ee3ff 986b6c573a23810c26c4e3ee4f93fb3d7c76422ad2ef2481c1f587e531c412d4 2e4d2843e6271143b06ffc2f1ecd0de50abfd3fd2a1359ea068001bcde716cfe 48b05209a4e52912e8d7a7da2649f0f9179d6153304966fba3a0204d0bd07a5c ff894c636ec6ce9a0b6d0845990857642ac5e353e62a68f8a306b425002e25ef 5d16a78e2583bf3f9b6e3eb93222b1f5cd2ae8b8f634fc2447f50a3cf9a38f65 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 false +check_ring_signature 792c50b20ab782522dac38a12d8bb3fff02b5129902cc79a2a60e9cc918f9581 65e5bc89155fe0b0470b5e2e1f1410fb18a56263ce6cd2966237e41937ff3d93 6 38f6d2e2bb69479479e06f350bd455bef176cf8429323a05c5c05e28d393aa3b 8d77661ea5deb6eaa17dd24610f30375b6896c9ecf1dc350e85a7c3a6f91662b 114f1e15947184ad86841d4b0b7ebbce93fc79c75ba3792458d7196e26074a29 6542f6c20f3e8910f33ed00f4b03868454f4c33fc405042c038d965f3b0ea834 60552a0f65b66b05425361b6a171deaa6bd12b762bdd26afe8b48c959335a931 e658995c3bcf5313cff74a507d3f1440edbfb603fae544cc04bf88d3b562b0a4 02c77f5c8789418d7cd1b868c06c244c7cb8fd22f328fe10697f881fff40680a98a6a3e8c913a5a4277dd891110d423e15e854601353c22fa2db16e26d87a50239f99a7aea85201d68cd819ec3235353ef0af7fb4d181b9c7fee9640f975ef0a6b131ef551695c313a67517cdd82a7dd78da974b23f4c1feb867d8cb19fcd7ff57f44c9fa919229f6cf23791720489b72677d296a4da676c97655edb91560e0f42a92acf8c9023b9a78604a7f98ce6b077277bbc1e0b7de4e7b30ef51526b501b6a11e0222479a15db7664829490722ece05681a3d67639a4bdd1e31e8aa0c0ef924e673b358ade02a2b375719376a35b7b03ccd481c1dd0516223c4c38683024ec153497cb09cd7d2a3e519246182d2420ef0ede3206744beff0511c7f04606a9c50899f8f1147c4551cc9aced3f6cdce87c55861ad8a76a583bba8ca632e0ab80c69a66bd95e367f76eba556df9561602362af8c2780a4d2e3697beb78c30772a9aaf3cfe5d7c6d90e0c1b99294e9dde275696b7045eac8d7662ff394313ed false +check_ring_signature c5f6019d48351a26af3c2dc327d8e3f24141475e15e170829fa38255fa626642 24816943693021a21ad53ca2b19e00fb1c1a00fcd6f23e288d94b23e2aab395c 3 8c4f70ec908cc13f6fb6fae436eb8f66c2fb84c2dc44aad5b148a1e7b909daab 1b0a44872f41f7b107d7cc1f8fe237b20f56f17edd3e3c3e0795a07e3a25c9b3 686767d65cbb27a5bf383ec8384e3028f119a4d5cffe0b145ddec48b0307574a 67050e7f644a05e9f9778137cf51101bf52840bc38fb3b240e1f496765f20306a9ec714de1341ba9f4f54e2cbfea6299357636103bdc6f0f324682f4fce4199c16630f9b0fc82063da259835c1636ebc0deb4f2c299aa82f59f38bf129c6ca90386e9f0dcd9c863398900a137d47d104dc818f442b3928fbe0d41d4ebd7d220771eb2dcac77c1f7f1f90dfa09f7cc12a02932b1be51b4334d4354cd241e80a02f388af252f91d107575f414c6df3c9ca83443a2b7d4149a2eb220ce83ddd1607 false +check_ring_signature 15da77d946cce37b1b1f75a35e5ee1f9f07ae1c1e80b86eb7925382f1f5e52a3 6c999c81073e5efffb98d7e90044e390c260bca1af17914cbeebcc60f037e8fe 16 72c2f2b9919b168521ff61132c823b3bfc66eba79e443aaec9b99b988d767daa b117df035df9217c3abf066540b6633633bf4d552307017563afc89cd63e2a4b f0356db11536f66b6836d54e67acb5970146585f3b80a465a29669bb4063fe56 e7af2e32fe6fc5e882db4a8efede6692b00e340b0e8378d218189ecc1d20ec9d 3149f86306aadb0ae0cf3e8b6c889f4cb884848e30b1f57cf003430a4588e566 b7e79f41ef196abdd446e1691557720387e9db2b947330b97cb464370b2f48f6 2e736de81995ec523c9129384f6488176ef156e072f655275674bac737ecafea f43fd26f1ee5dadb1c60b42223d3d5c6f2af474a2626712b5a01e01ab1b01bd9 3ba3a0de7f8c68eb74886100fe160b8d1d719a0324dfbf080e105fcc28afe290 632bad66cd5d3c1264aff0aee7cca12b738d50f05f55c7525a75c51cde69d8e5 a81b306c1e5502552ef52d0b0bb4e8d94db6741a37e21765046df5b254c2fa6f 4a0154655065e7b144846fe963c712f4f4b250eba9114645b5f1bf3d2acc37ea c183d4d33a895659b96e20eef8c232d16fe98c7fda62763e0c90ed29e66c51ca 08605accd4e48a12b5b2ccc40b2ec6cacab46fbd54c5ce8d29586e0f7e384fcf cae3d97fdf734a99be31eb915dc13cdf16ec4a79a10a7a8399c1ff5e844aa327 1071af5adf5f126063fbf4273b72094ce397daf42623a44ad05150e093a79822 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 false +check_ring_signature 3e209b2f03ab4cd599bfb09b74438dcce9533bdfb1f5709a0faef08a30511432 7b2a1e4af67f2b0b15b9254fbbc55c5b01a71ee7cf4447812224c37a85df5b0a 2 fd5ffd706ac4ff0694ea9988cf197416f6948bcb5a6b3dc40e72b9c3c64f6be1 68bed3050749b8c4f96a0fc41541f95701215e51724afe60e39f318b765e4be5 6ec7ca5a19e3c72b79fdb436ec8f0144f21f1e263e35547b5ba1fb75e9f2d5008fb50fcebab3f4f99bef7013e4187696bc1679f18eaf627ad64625717670f6c2968832ea9dc5544e20037ad116df9556b155651fc2118970ff35f25458c94b04f9a504e6dc8661f740e6934a2d2382fd098fbd6c2b7faf532715b45afc7d8b01 false +check_ring_signature 19e8947debc57401e507657ecafb8b283081ab3c0b727b596af8f7bd6ee1a6e4 5816ddca6ea7cdb2cc7892b4584341f30be5c23bd3e7f7352fd68e3cf62f8660 1 08aaad567c250016d7706c479d2ab9818d4fc2025efca32fd0b2d2ff7f36090c 43154b38fe9084a0b36eddb933be8981ce3172d37ec029162b0798d6f1dba30def70b9099a839f4f8500312701aec4db3934e5297fdbb3c881afc7de55cf010e false +check_ring_signature 2fec0f06d0f8f2c31923c06fb2f6517f400f659be18d8bedf2bf1c19dbc8b864 12fbb734d4fc88a384ed544e1a2243df8faa34c3a235445bcf792d20c708bb6d 114 ef6c864532e1e9f3b157397b4399853b89f72bf7bc1002b49fd9b8585be4f57f 658c34922256d5939a547fec36810c3dd963d30a397423d1dd52e1104e9b96fc d361393b0e853611820b70d69d661cf6d70ddf1402f5963e9c0921f5615babee d2b11c306cbccb3451b7c8365db933d2d30ae17cbbebf39a6f38a1045f7c849f 751503e1a6e4d76487b1f5420bad393cb6136a467bbd77c30c4fa9168fd6c058 5a7e1b382ddaaf6717c9e42075dc5db8b7b320a04bac8b1ea129a9f00ccbc3b9 2f56587ae745adb39bbc2ca535162f5d979312a2021c1e7b01e0db252bd56d91 83ed7b733d606eaea547e8502abe5c5d1d5b73d50d3aaf30b2fc004a001f84c0 eb7755c076273a0840ce79f0687382afbabdd37b8c3dc014cf354d2aa8b5a774 4ffcac78da47b89426d6bdc0e5c034c2efcb65447af79371003782b6ad171ef5 f0abf010bd1594c7bb005b31df04967c9fabb4a4f64258865539bd6af70ba4f7 84dc7a5950d22357d3d87ec177aa7baddda970ea7f8764ee5722fbc4a594e9a3 57b662e0e38f6cc50aa69ba917a1f60438b1031f487865e03ee45e667387a94c 797f7d1d4cd69086c5144b2de9ccb5d44a50d1dcf0098f480ae0c04e2852696a 7d25e55d240ea5c7bd6a82d614ed48d38f7f4be238cd8fc01e4a646071ea570b 94824a694a88954bd8278bf32eca82877c2523593e223576545701e8ba820d6d 25cd8d0a3e14935a6e8f910a0ed0b96842956eec2245b7cb6de7465ee0623b19 d1b917a39dffd6a14d4cece46d7b25c81bf9cab723c82ee81ddb64d673d68f4f e829a85adb66a8b52a1b0f05f0863b75e00dc5a49d65a1e9c21d2c0f03a9db4c b29648f400d783813f3070c97aed95f824e5d544339e68b7c64427e8fe0539d9 5d927582683552891fed19e065bd896e22c7ece1f1427cec0b471f0bd4fff7d0 a6fcd336a973576c3d8b675f186b99bdd8eca6a774dbf5ad3e9555ada27858f5 23876115bf1a2381ef0f86e95255029e965b8436f45e4cc8948434cf86e17ab3 18e72ba0afe2e820d107c897d70bd7d440f5efb8929fa979c095992801d28c28 97cc2da18b9f13604e46f09c1628a3cea24d808e33a4609d2a346cd725272971 1c601a0384ef8777c9da7a7ea3481a3413c195fd8b4353c79613f817149e222e d866114b6ea854fcf016a6eaf5587f61fc522b3d57949b7caef0528c5794cc18 4b7c0f1bf211b9c908ff1f7b3e5728fc1a73616a8b3f969bb1ae18a83e93b492 883b7f9377aaef9a9f13fe4bdee794a88d6250b1ada6f671c8f864a6fc05c186 44d8447cc648cdd8df1479af36dc353c7c1c5a638f9bd13ff11426125b282182 a1dc4761786466177a994e7a668e468f9ed90becc099c9823757a582a2afabe5 b1033a4fdda4c1b086219669868bab3b20b650415d85dfc4acaa7c98db11a37b 157fdfbb3689ae7dce9e72d7f1d5f4cf88fd12525c2cd00da0394d2067378b70 c97472a213e666452ad573b39fbbe6116408ddbfdc070df8fe10b35202e9f989 2d6a760b47c777ad57552fb7ab79fadd5cea404a5db9e0ec57fc39ff44bd6544 63ca4daf58c40f4b1ae8d75a998c4a407a1012cd3470850b3704b17ba2ad0242 279901ed531b8a5dbfffa2d5de8eafacc768799f49a99c1fb20c5ada4ccb7f2a 8c476218259cd5ff956e5dd26c0de28b4e50f327b93c68a924470345eb35341a d707e2f242e2f07c83f5450fca0599e4cb5957bd5175b0cbaa36596371bb8a03 25700f50ba9d940df441ceb802a813c99796925048238d313ee1906534d7117a 30fadda11809557dd2758eefcdea440ddc0b33257c81d07dda9bc8430c835bba 0dc17e8215d5642ad3f1025767bee4f17a5a59351aecf284367464b3d2050fd7 9bc80b864519816687e5b3737b6680986b7b657088ba1d07eeeeb536a4b4740e 6aabe83b05254c34dcdff75239fe4043cdab46381d62792dfe018c943d7b5e05 9ac3ec7dd66680e56df132ada12f75381797e8ffa9353cf6763c6af5bc5d3ff7 bcab08b44c97c0c20133425cdabe31df4c63b23ee1aac312ef113a3f011caf9c 9c70d1924d426ea460e645c670b5b660b32b55cc831040bd3681a85abe242ab7 a32b67be672840b59d3e039080cf49cadf212b150c46d4a02ecad5e1b4d95d33 f590c5366939238adc81c563b14c69b4e9c30e3487edbc0f4253aa4086184881 0c46ad61fa3d771b888b562df344a5c251225b3d2cbf990d8c359a2bd6797fb7 f5a22c2138bf04957b01538a2ec56a0c163b2ff93dd5e703f8bc3d7572b607b8 8dc91760d232fba0f1226ccef6272680b47524b9e1762a8852d60ac93d8b635f 044d2bdfa43389df485e379c434d09d2976df9db94b00ea133a158d4ad863a86 d62ce11aa507b85541b71b19ae167d0757f4cc0de0bf3363395297123e3df447 74ae5420a3eabcc16d6603de1d247d2c74456d18a542522ad5252bc257fa6b8e 1458489b3bb1601f461ad5ce5b63ac57f2193f091606db9ac2efd7bfaafa3a4d 4b373099516147418f2be140cb724db946cf69951527cb96864f88ba26d3b888 26f118754d8661d52f17fdf452797a9b5f63759c31820454ef0f221ceb95c51f 8e5948a37843c2d1762eb67583b07316ab82f1b01ed78e4868186c6335dc0008 0fa095f510cd633cbe7d78d47f7c06ad8d20b4489a67b4c8813866961472ecdb f574b9ad2daf337b92cb8d556ad4d21659432d80c7a79589c44c1ddec445aa6b 897497f2a855f98d4d5cab7a6187773a14498245f68727ea3e904e7f5f013a09 5f987df92a489259214307aa6cd34638fce7922743216742355f6bbba347f2cf 19d59ae8f8bf914382f49065b6d8891f0cd001d710c801b7a73f7cb2a49c2826 53b0f8ac113567f8961af8b7ded2cfca87c7945bb27b1930bf9e092238af3491 81f606dfd6a8b4a06412c6f90411814c1c17a747cd6f4ff0f44d50ab749a0dd8 eecd809abd04ab8e1397c2e38a1c5d73cd977441112c670e6a9f7c854ba58b1a ba924cbe67e8d45756ef61f1e5520a2fc0b911c1d6bb69630c6d126cc7d0e4aa e6f28856bf6efc3173d431bab65f60b71bebd511ee30edd5dc5f606e034f352b 5b1c49f574a97616ddb9e143c7084f62f2d7e1f467f81bad49119029606bbac0 0a79397dd9eab8d94e0a13b242e8498317ac1417475fae4003f53d944bab027c 6b865abc0d443c6972ddddde967a0d5f65a45d7aeae9364037bff4fa4175d4a2 2cccf465cd1fb8386abea4bf12f407835498d0660e36e2bfeb5cd0a7c0ae1413 70c08ab3824aebe5221bf8326004a351341eb201d09a7f01507e30d49f644d9b d03aa2ad73a46d2083bf7dd745b809ffb13bf36c7240f0ee1568b2567c1bdf23 60eb0601cba3f88f4caae92a6bfaac054d9c9b4793ec36b8e9b5e4946f4bc7ed 11f16f5cd49bbdc71ce81a04dfbf852390d7b81c9fc8620f6b794cef5c51b2b1 88e0a8628f1a844a2b71268dce106c8e2f1e8a38d69819babe2075e00680033a c1d7e44251824317c55f2454bcbf2a5954a7afed61b1d8abf4a7e091acde857f b31dc3de84cd229427369782f3f910130bccef61679ce0b1655bec13de335362 885dda27bf4070df88440245281e12104278d1f8f04daff49fff928f28f77545 39d139e3231e711937636360c6978fe0870659c78f781870ab73ed7952cbeb82 e45a4219664e05995a66e45b098ad1a3fd5c279af6bb713c6759280d8ba0f876 6b3c8896fa7118034f71647baa812a2337bcd4a68594fa058e548ddc9104f23e 7e120eae7b4b9e6df0f950f182482b5baed0980efb8fa644689d67eb14e09682 5216104ab9fc5dd09af6c7423205f1562997dd6452be286412eafaea92697c7a a5c74db8c3d1dcd79a47a4e1e1758d48c227a20d191813f50913aa2dc28e6545 996800634f9b7bc1d6d50f7b9929d55eba505f4238b9844edb890089905cc411 da53fc60c4a3ed49e12a666bb0f1504961641da6928ba1009330f312f313ef64 4a0efd2f39b4766254cf2892a16d423909b53bdf248668baf3daed738ea0d774 8b415a19a25f4645b6e1279a8b933e66f472b62497572aacbaf1b6aefb58136b 912891a2bb2b837614818eb447fd687e116382ad06afb2e4456c6fc84d4221c4 f4e3885a01f8907758cf05da486130599fe79f4cc2aed929247556980af22ee2 3771ebe9d7509b68065e3261e0723a736e85af95dc20298b768e507c2fc98e15 b43b2c0a031363c645f5d871d6299fde3bc08cc6508ddbe4704c14d30026dc42 0adfb821ad38f973b3970ad8f910de84f42ee637223b6153c192298334b7f030 80d1f77c3405d0d1d25d69da584933526cd0834fbd297dd7330f3e6cb04ce685 7a17952d193083c5ba6f0d63a29776526433778e7fbc35ebda50f79cf2ea05ee 94cfcfc42ab2dfa6a1bc5cc2c838398ede63e6c92f8891e19c1f479a0b3c9d27 f1abeeaa380e36a65437937f45f3ec9895ea10ad9021830de7c625eefc49459d 35b13a6b67a35f791d9ee1d2af6fec91b9abfcde72c5ecddece4f0fd648f4f90 31b870fa205fb5bc8905157601babfc4562e67ddc1d8e8397c9d46058ede9f25 2da02afdb5eeaa96cbfc1f1e05ff2efd0eefc9997e6077b0e550b57e7351f27f c661398ef9ac8dd5ad8cca1af5257d5d3b92d4766cb0aab1439ee02e4ef10474 e09e742b01847e8fd95921c8219e6f576225e374bd7aa3fef840208968b964fd 1ae397d30cfa8d549006cdfea353f0d1ee5052b157f7fb07d7b148a799899d20 e2c1f1eb4d70993967c8608085e40a28f3ae15f2281eeee49410ac0251a0304c 7d9b98be076a659c8f6a70fa23db0a609e30fff720b48b99cd8074d2cd01804d af1313f136b85bf5a1387b4ae45a3c9945755d9ed2d5af6bf8b7aebd1d7c86d2 2162b5c96dee7dd54881ef8c4fc9112e3263690b986f296b751d6b8e0adbec6c 46248fa8a74d015ac872943ff9ac835fd53b2fbc5a3a531632b9c54982ae2148 47cff10780d49801b9001dfaac8cab06959e744949b7303ba8a0bddbc1a737fc 1ad189a090d3fb9488a9346046aba06679cc20068a82d217b56975ec2864f6c1 f594e3ef54bd2a9fcd361d318c1d250febcf0e511f79749a289316e1468821bc 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 true +check_ring_signature a7e88fe18670ec5584deb2a49e8ea586a2e0654a2028d7937f1ba1033a526768 571ac1524f5a4b0780c359c815f903d6a44bba8b28a43207cf32c62ab14de18d 1 dad051029c46b8bdfe89c3f27dfd419bcd7374101f957c9d3a813c1571df39d4 c3a6baea1e08493324a6db2329f505ab1def3eb802ac2f02e6f8814dc789c40c794987b14cf0fa642eec63e3fe41777cddcf1aefbb24130303c5afaef7886200 true +check_ring_signature 3993efaf856464dca73fa5bd7294be05d34a3ce8532ccf3862adf3ba9fc00575 eef681545047b99af0f5f948b58f599b3f27ddb19fa2c220511eca8c46140193 1 e627302f8f1d0c8cc096f4b4241036761c356f3ef5ebac210c476bed5d8173c7 14cae9d3e8ea4243bc696e86cb236b1ecaf253cbb4dacb9d07b08868c474470a17f252318e07e43cb4ed5e1ec725efd2f3d02f53b9dad5bf0d26ad5269416d0e true +check_ring_signature 63f9c0725f18ddcb419e629fcdc87f9aa9e96bdf855c1f9063e1acea7f92f243 039b4fecc6ac7ee5d80f250acb9f129b1149f7ca81fe8156743a9879e3571fe8 2 28c73050e79d9b179277e78ef247ef816a3014bc63f9d24950de9a35a8247b7b c521224c343b4e3cef3126f3b26deb9f609ee56869cf49c6de800b431eb16f78 cd12f09df0bb3011d259b22b3097224162ae43565c5beea152ea378b14ea9d0bded0be5fe06d5248fada88cf0c8e3e705685463b1b90659460bad91727521707bc3eb2996a0e80ac67f176873f0524d3137f98365631df87430bff2fe7a7e802467cca47ef6cc1a113bfd71ca3ef59a59d9ed945b5209c5f3e63d75742370609 true +check_ring_signature b897767654e402d36bfb92bd4a5024822499baacad99e1c6934eb12b00735c38 63739be1477b05549d493d149c537221912d2505ee92730bae6362e256621eaf 186 1a79aa5bb9b5d76935b0909473fab601c496e5b0ec6a312bf11c29a49b7b428c fd74c80b6a46b45cf4f54a6b0a17504a2215c5d373a4744a41fa5ed74c34cd0a 330349a5d7bd565c2be161b897423f91fab0bd096523df3fd24ed14a8398bd8e b5427104f63296ab47979dc8eb71d69dd4f75e47a55fb8b2a7b5af1da8381968 f6c21c589c70fdb7ecf4cd1cba14ec6962bdeb64e2b0c13a8720fe0a2c2af4ba f46e7b056eaeaee5221ae3221c13feaefe2ab624dcf001f4257457757cc8dc3a eacdc10863612f79acccc2b9908366eb8ede603106907d86090ade9f469fab63 95ad3bc0ab7d295430f085b60ed935bb63a95b606ada15c1ddc244048ff56e25 f334d615d88c75a2accac99f0ce5c86f74dbf7f4c1c4f7543007e5346670aaee fadeeb84d8570dfd6e91896ec5fc927203118cfa0b3e0b438e8807f98424a6bc 97ec454512a8ada399e0778baf76d27e9b006294ad2b261bb7b248044403d4e5 acd7d383ac7ca753e34608fed714f4c1d72060211273c87bf47735f78ea9f9e5 8fdb5d10f35f167c67729693d6ed6fe0cfc36eb5289e78cd46d6d3068f59ecfb 9851962775d26943fab5bd296aac2410cb44af5ec2641787ce441d68e2a4f88d 1aff5da3b277b2ca9969b767ea4ab361a727f645f43d23af5c65e391b27599f0 e27e232ffabdf33448b42466afabf43b200b0511231974dcbc484825219a133a 3aeacee3f85c090c7692ae62e5de661226635abed852b654687c0b5f7db4b1eb 52b7702ca00eaa228f8643dc98536573ca77e50db250d55019bfea5204298dc1 179220df8feb6be738e1a0f47179da5f824bb72417565e8417f986da74a2fa7c ba50ef608673df31c35583c67cba7bdea0850cc4327d57779c96ea79668ae52b c0ca7693034da412df0485d0ce10e615643df970e09a462c78b7a1f9e01adc16 1ea4ede63de5781959691ebe5538e620759709ad0e3c1a6d15c7b0eb94c99d7f 5c850a274bf91d06b0938923cc7dfc3cf255188a55c7d92f1d723a6b57621754 de26829a5c1e8488e057d4e88f14f8d9a0214e4572e8fe45a45c9a6f4db3a3da 4913f53eeb07f199de41d9e8a41c3ad3c21c79cd2bc5650059e68b23260f0df6 bff67767c564f385e033066b9ddd21b7c7d30ed2d1c0f90a38f55d87b60e36d2 258be5f0f18da69701edd9b1ac70bfb3cdd566682a178c7bd7624d305d0c7c16 9b6819a416f0b1465e0cdb2fbfd92a0604a82866e27d8ace30b1dd4c9e7056e4 7b4507c98e60f49be498796668b8020b8f2c24ffbd23964af33ff2d906c4bd8e 386f3f84bbb07121ebefb8ce9ac9b4c477421c68ca5bc713188035fa243b9fa6 9710aa51bfb86603fb86bb40d6f758b082348a2097ccb885a83c7952528cb3ff ac5b187457f8e4f8cd973fee418475defe6d42d7541e26748fa439a2f359f993 123fb72ee54c1367948c395a7194a83750f5aeaaca316b5f72d9432e2d3dd879 69c4d592ffa35cae32a993756825b2914d3073ea66924eff0a7035390bf8628b 09ede1e77ba4be3d59ab335773ccee2bd492a12e1156865d68d8bf3fb3d42fd4 85947a6ffd4a281ea43e1cb8a8a78d1697b0a18fc040a05c0534a93f7b71d0c4 d8ed7f79fe33f86eb35c64568b0aa54ac5cb6ee6fdaf35b719a4e1f5e81ad4ef 2bae6b20b99f79b728eedbbe672c398a81e8bdbea52c6da0b3659f14564ef828 c03f8d752555b2c80723bc1c0d03bc7a5b6479ba8e2f0a4ebb7a78777b4312f1 f1052599aef15f66de51cecd9ffdd7bd7823d8e1d74a3e5c1b30a449155dc801 985439e737aee8f7f8375d33790652df88b86fd7d4365775579b7c8520914626 2d3ec074ddb1857a81fc24b08615937a48237155293897ae88900626199f01a7 eec80f893f943d84bd773eb0d94cf1baeda04fc9d335cd5a7282cf2670a4e925 b1c25dc18d96b03b033d47d062204437c9f841d44276128ecef79befdb4cbd3a f7e176ea4ef50435c3845fdd77234c1888f9fc2aea79d2339356a053f3179b85 5bcf8b0cd2b220a1b88f47d7819eab0acd261241d5e24210c970182de913898e 640a78ec9c74829fea70d12a9120f1ec31db051e6c1929ecd43d392595e56d32 466d729b35b915b824a71675a1bff232836e5005f69f1f716ac383b9c38be319 4f49530cab4332f48aaec658a1cc56c50fed688ea9b2f726ffc41c2305bad5e0 573d50adc070cee415362aa716c3f9c9a0a17bad3addae7d4d04527139eca75f ef0bc94289c6c3ff08142d096d3e917e611112a8aa2849a907b10b7c4cc88157 d328829f3e93ed8ecc2c0c20743e7f04a1a2e6a2a188e26e7088ce115918b6f6 5aea963b4171cc6ddc261f1f6a9222ea7370715e35d4c9a78a8d53fac40ae7e8 f5c8556784de5d69a8217ca8305a47d5e53ac4cff395ae5b7df60fab39a19e76 399af49225cc56d85b9c47a0adc3962ba124b0cb0b512942f571ccfa0d1ac8d1 04f868bac8ca59f85d83a8e7d45b59be73f56c77e5368d87507b2ed19a405d9c 5499276c6336160577249a63273918b4874b1ad55f529dbebbaaf1d0b638f039 407f2a24c7365339dc90e2ef9b7bf39d4c769749fabb5a57b3aa125bbf63aaad f20911d2be82de9ef516b30c645dc2c8ec32bcabdd12969e61f46c14e7abcb61 1b8eabdeb21a3220ec8c675a036653e62b8679e64a097d28e49db52e493774ad bb85ed8f3c8e8d8093313a61f472a3d648d59d9b03dea6375ce5850028f9a2b4 4611787f9e48e03bf6f60a40d460e4d3222e97db263083e825a954c4db565b6a a5a67439a7fe7eaf1d0bdf536f9deccf00533a04f0cd032392ddb8d54b2dea2b 08b7367d71370e081823c7164c544b6d42a49ed79593f472adddee2f4b29679b 94ccb2072796f1c01066bdcb8afd8c128c22f68cd7ae690033834f068bfe53a9 b9d49a1f7199a4b47b7ec951fefab189481974c7b276ac902be3222f6fc6bcab 7247f13e1c507e6d841bbede828e0aa3de06a94dd17656fa2c55196ebbda8d04 814645a0944d49b9d8f783d10ed4cf23b70dbc519e286e4e97433e5b32c3eb6b df1d7c600dde21b6a7691f1e3c0534d672d356962ff719b6f585be9017e43173 df16c6d7a80fc047c96cb84f1f15cc51b0263e91f7250b45cd0a8066279dbc99 aa2e391470970784c64f8641a27829e3674826c598e2963fed94fcb58d6917c3 13dd46a165c99601e9ceb40b3ac5a6f5a562e7b20af4517f297020ba1785feb7 e68e03f673104e67a16d42c213b3ff2faa1ef96dbcd3dc6d77935baeda0b3b92 662465b2a35d3ce5e2fc59198122ac424958fe051e31479f5818c870c3c81d65 16744a5ef59f7371a05a3e2947ec28009dc4cd2410bd6953f8ea86296000167f c26f23b8fe6a358438ba9b231eaae73fe8325576e06381378c97f4aa1927da71 8321e307e1e7b4aca16690681207e27f8ad5df56738496e9d3fcad081367d041 576d346e2be7d2e15cfa6097a4331024c939c0f7861fbc2a159caf615f3d44d5 a62d8ebf3e23068a7bf42d666fd1a817dfc2d33617eaddecd66d5bbd5ebedf1b 0f31a23014e3bd133c353b6215c576eaf002cd36a1575a2311bb9d72ee594e8d e19035cf9d67787b373a35b02b6dcd1cf31e3728de09c33c3283c3940be24eb4 f17c801a680aada318fdb88fa5c2fc676c5452442a7beb6c9540f6afdb80f41c 3f37f831cdaaae3d2dfe81a324c805ff17047c5e3950853c03faf661a2da7d94 a325e652e9c828236e6d0a326110d50731d98eb2767d8b21b15b8522b31d7609 d82977407eb7adbc022373d3203d324112ba02e10adfc636c81fa3f5a2ec0b71 fbff791dcb9c0b80b74f09746eb197b1db7e657949672f6c19dad1b410402ae5 af7d7c2f1bad11ad20af1b4e9273589f1807ba8acb53c328b9147dec5392212a edd066f3702a4b0e506e8ef211e72b8d95818f2f663245b2c4016e20aabce456 c7fc407ab5256a99366067a505a65f9dc1f58bda9c5f5feb4b0bd052022c773e 90235b8d42f83a7b66c8b958f1384e2470748c9559273d685f2a8f72d3990753 0da3b7dcc21a44e402c275b78b460831c817d56aac6906af4192e12626b195fd 3873f0f7f360079249f26cb0e652d2d2557bb95b7771fd20cbff179aec23c187 8fd3a01d531d907d1e5cecab7885019c95e31465a94a295249ef2be6c6fa82d6 4896d6e311fcb4041526d7f639ee18294d18461851f8c2339f4161c3ea1a78d0 d6d3bf08a0734cc12106d46a083ec88cc4b0e254c01f3e72c303273968599d48 99e750fe22751e8188b786eb8d74d637d42d783330c3927cc8a5710a84570dc9 b08f7d4bf5e508f2dbee1581c3690d40faeca0e21018621ed2e708fa148b8f39 81530f6e79c0fc5607f7a13e53cb23e1d50dc7b593595eebb19f3646c1a35737 5a190f5e79f1c5d4a59e5c034bf904e72c868d11d3d08eb57b21f5f5f7316127 9bcab9b9d13ba7df19a9a830d12549826aa34e23c6fdb324544cbaff3a711aa3 13e58afc69b0d4a4fcafe2f28a7602ae24c2ca35f61c458b8c4a692162d13ded 1a208a321bf537fc051d613ffc961df6a84f306df68049a827dae1bf46b46ce1 57091502d9392300bb8ac7456b4710a3c6356234281ac88a30c3229eb5f952ff 8e740931017e220122620b480673823420140f569c6a036a128cfd583e46b189 a86e919e84759fbb73f22cd61261bbf2281a06e0a7af8684f1b52ce6ec5b0337 a220ca4eb5d46ca7322826dfaf96d522731cc213c06e78ba90d76f72aa76094d ef5eb8a547ea07e22c2bf54d9b789faad6cdf5ab6bad6695e03832eef9db272b 5d26b8ac238ecdbfe075d52d5c6e88e0e657bc25eca89e7d893b17d6aae5de85 bacaf10d2e60b846273baf1e76ae51bd0f4821c2db73ad684969495be86334d0 705a765bb668805b7a2a71bf183d39962129d96c8ece24ef00db44955a2728cb 98dc2fcbe9689c7962c3e24453814c89ac29ca7e022f6e176293617ba77e0db5 bd81e9ae7773f58fa361a9ad94a50820526205b41281aa922ca66a17e852e01f 799a789df72be3721cf6a27648729a25f84d70efccffb4d8db6e4ee882f15ba5 ae42687d3f3554318e40084523f560689b7941f56fd6d585cddbe0b461bf6e58 d1208e5d8babe670831ce83832026575907c5161418c3d0b62113e54da413d20 63f4796e17c737841e6d19bc403421c5b9bbe348f23ef52455cef54ed0b7e002 57ed93e77098ac871cf6fc09f72797d3745fee4dee0c84597b6e5e61399ff91b 46d6deb7fcbf75bacc9a15abcb63938102f97a75bb72addf57f5999c8b2d59c9 3a477b19a09f1cc6c08cd9345eb4b959d32054f4111d198b3a7cab8e792b0976 4001f108107edf654de6eca0f09783a683a95b2919707de246a85e351585286b 76b703f61156df1a0889bef90dad914e50d23e9ba49d19a9618f7f88c5c0dda1 fa4eef2b73bc062733feb043361db8a4ab906b7dbacc8f3770d9270b43d928e4 0e5ed9eb248aad6cdc71ecddc97e9aa00b8b57ce14990c847ff50e44464e4439 52b16374c390e6e59ef2b7ca7666c2d5d1014cde5f7bca905623240a70691c0c e542d03b6326c024860d860b277bb4ac4d7f0183715861cd60fa5c0c77c810a5 200f846219ec5482811f333bfa23f3f9d6faac875f1ed4ea0d7218567c9cfa8b 937780a4f5aed2a12ea6de17f3e0e4e73c0f53c9bfec7fe28f643374ffd6c7b7 50c95c95572c028afaa86baf2b441936c67223ffa17d3e2f506ab9753a19c8aa db5d2fc106fe7d29aebd8222e59d1c243a427956a7496ff8c5b93dc9b35db404 870dfbb6ef6934af689b265a67f077a33fb33556cb0317757a3975158a8492e9 7973bb064e8d75fac393a8ac08af82cce6b0545f7b49362f07549e7c67d0ddbe b63192a55f916438e8b5218653e07a124a7eff2e92a372f52fa5aa3e1e6083fd dbafd49af42e4ae7a48bea12a7f5985374e22b6f7ca70011370ffdbf95647e1a bd20e005b5fec09e635743d69ae2beb362150175db4a270052ab0ae41b1d344a 482026fbe47895638db9f2970f95425ee0744bee9f097af623b7a27b792eabcc eebb05ef6a1a7e5ae1b02ff2b9d75c042e164bd54b5f0d2b05a509e1bcd8fc57 96e0423b00d21da991da6797465961ab6171b105a8ddc544041a15ba4861afd5 148d0622d401c1e6d90ea4ea91c5ba183f8f27f37266a11e8ea03e0b9cd89657 8b26559157b9d46bf4eda311ec8e2e83832266d4b4784e6be50b794371a3eebb 5c7dfdd897c5056f8ff3e02fb839220671b9bc9808766ba1e31111dc2fbf22fd 2d493ada754b5fdbb91145f1c2a540ef019bd665bd22a2602906d9091e77f421 5a39aa2150ff881f4b4d851d917912051f9bb8f5b605f7a0d285acde2b4ffa79 4d063bde7f1a0d4281d27f600aec0439f3ed057f0f7ca46ce5a134389b1c0e3c 93957509d60310436ebe0ada6b7e5d30b99944c7bd2271c1f234fe35e3c7f53a c147f15325b185f5849e92288e5839081e8e7d66c99f034dd42d8f802fb82c79 759d2b0a8233372fefcf49795f76d5ab50daa9298648dfbaf490af4863eb8827 d85d058942e2af2259dc3e733dc3f25ebeef85f83321fc1d70e44c79ab57125c a090ceb71ed51c955b57faefcd3d60c0996048584a8adbd74c82a5cacc2c7357 e9e7263fbcd1d44e6dbe29c682310796161dcc115d050ed636eeee28cf4de045 1117e5c8a046f2bdca767f25d4c89964e9401a2ec6bc9e9dd297fdadaa16dd8e 4ecdabd58d037e8e863c41bd632df9bb23237405a200b401641c6ea4755db66e 72e57adc7a9b29ae6007b12b9110973232cbf87e61df335fc3cee47e112137b5 fa5e9b399e027b598333d2daef7fd5b1400df5313034148e5c4988f9fcd87f03 46ea0bd4f125f58cfb80bd126c65788abd3d64632259045317567053f73d773f 16c0d2954f29b4ad141da6c70b9bf7c71cfcb51f1074ad2a891ae6a7d6356969 9e38dbfaa8cd1bc33be3b339a7957ab0aa934d2b7074bf034bd01fce75cde720 26c3df8a57a9a48570e44573acae6ba86a14b48ae1d25fce03aa74e66dd57aa3 bdda7d9d7fb5b5203649ec9d2e303f186cdc9ea9a474b341eb00461aea2e0dd1 39031119b493d11e82960e0e9db35df083933f289f620e66af5bcf60651a9e0b 1c68285322e930848e2cd874a1722f1a96395e3ef5eb8e27f4364b2679ea9f55 0cf96fff7dc647a3d78daf25cd124ca20cc826e7e43873a8afca9b604aba573f 3763ad52c0c9a8d6b4a65cf48f4c0d5250b1a8c673fa59914364787e327fa619 bcfa950621408abc21e6773fbf69a05890a31af27b06e3e26aac05e994a915bd 9b651684644b284a2573b46fca31b27642d6c453f512d323cd1cf5339eafa494 e0447f73d8c4b390e97d87a91e040eafdd4d0fd4bb14366e2406b236779733f6 e8e889ed77d150a424d236f29d760a1bb97d4bc58b1975fdd887438215a3e6c9 1a8abb0cf29816d77d3d0163aae1ecf26ff52a2fc0bd26118b517b2dffc1f68b c0f6bcc07c4ebc2d3af73e8947654d0c14084ff6780376f591019f706b94f68b 91f176bb2e2c8d69960cdf18a8352dfb59092dd5aa2078836ccd7d75be60222c a150f517ede6a5fa27a6f37860e509c4a427d567e2a706429332f7bcb4f69e33 a410a2c480bfe5d3b283eb361b0024607fbd2e6eb93db0ea36e8b385f1175740 4b73205d86eca8f160d5da6f88276f25608c208520abc7aa95a332438730522b 5d5c4e98d64ea1e0404c1972f175fee65e0bf6faf02859b4dbea8731e6fac0fb e0b3b911e225a963e914fd944f1060d744a7fef49dcddb4cf9a388b8b089539f 842b9eb3d83768b0d087e17dc3c763327670bcc4023f6c4d5e32bd863ac35116 bf6c7c82f7e2736ae1ff35a83a7588092268b85ad9beeabfe57b787686a2ee9a 288ea695a3ead9ecd54a9b16ef7f4693cfd4f639eab006efbc56066fa356366f c02b0262463c152414a4f2f2cd452c65ea5627d1aeb0d7e85c51cf5d9617fb44 e9f7a3cad81665098f6c9fe5dd49ec43fc758afeca8556c8711edfe9b156b13b b265b7cae8cd40d34079a8a3c6b3ebae18cb80321e02a8c306f041826222fb7b f7076b33dff0140c3f35509b0a1ca04e49277660028492a21d6e027e1fa6e28c bff28429cef6cc90cf0fdde40bd4254fe33eab16d91ac23c29e218a115ef4527 e5680b4dde7ff78015ccd99cd30257ad7a89d90f402aae036800fc51270ba97a fc9e2c64a2b88bb1e83a1f424e14c4556f006cf3cf375e8a06c41265488fb36e c16b4fc9ca7292fcc62546301fea6fc6326a33f3ef7e6729b28efea7aa9f3ae7 9e129ffd6d6a66022469cfe7ad9b251c47c11103aa1ac5c196c10961cf5d1baa 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 false +check_ring_signature d99b28a019e26c4fea8cbe5816996a1cdbc1530791db96d5f13e96e50830e6a5 cac2ecfe87f7c6fcc289dcce538af6d74c17f2622844ccec37b0a1a62564f6e2 24 b24e7293466dd993090c964c5a527b1bc515943f5c3159d8a69099b731d77c57 d66e326f8921dbcddef4819dcccd7ef56ccbcf93ab870365f2ef2154bd9e1829 127e4c1a0408c2c2a170c195df5185c9439c23c973e0e0dc7fab2733f820eab3 3ad74d594ad0844f2cb4cd53d997f858090e61a79775c10785db64faba5ba499 91b28c834b198c915cbcfb82ccb0edc868b88bffd07b6b7fb3977246b6f51a60 70c560a2c4125a485e7198e3b02876d4123cad9c3786cb17a763eec5cd393a5a 587482447516730101a81c415e5bd191d8db1c10c86795b6c311a2b5b05f25d0 82b4f2af0c9f2640cbfb36263da446dfc522601e1b8b6284cf49057af295f999 bae98b5902f4a08786788d741873992d463f6cb4ab8b67ad054af7211dc5882d 0ab7b87aff8da6869a591eb83ff2a9920e43a82db8a5f08156019314fc9f45f4 cc76c939b802a521970fc8cec46e800b4e55a594911178411fb07d644f4465f0 6ae7785c4b57f2cdf68f153da0c02e25423e5bb4484ca3f3f44d6bf22671276d b81b90a5ca21f0da5315c063ada32bd256b2c6c2f2258e697b69c128f6c58cc1 dec0106f65df18cb37004f6dcc65bf5646280befa6e022f1e73008efa4606574 148e096c434165570b839a256bd8e2cd0984c48238b4693dfed73bf2c34f9b69 bd7511213a8f79bee74c6c3fc5ed8d2f891bbc945b1408fec9b5c4a7bfb25475 afac1eaabd1f356275f7cc35cce27ddc6f568a794a8c465367d264db2b02e6d1 dee7a747ff67be9a0ff2edfc9c1629d6ee136f2c6c1d109c0f6434b386526895 39bf7a8866685a7438912b0f2fc6979794e0dd4d8236c2f0fa9bbbb285151d2b 09f44a423fa54787f3da5e898f07611410c15b170dd80d19968ffcc5cdeaac0e 11359b7b1b5f7176ff1086aad363af727dbb72f742884d659bcd25c8ca95f442 d94aaa70f0b3c263966c4a6cf7e0e8b0b045b852633fe6a1f74cadc6bf54acbc 79da878336f0743d0f4ee4be53a7b028bfc94761e55632f0152e0245542bdbe6 eca4ff2f3c2d02319960e6734e9fa0925af03eec383f8ecf8f4a2b01d3bff2eb 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 false +check_ring_signature a1984ef87b407201bff12ad8fd34d6411bdb556f02d4e3f453a8bcb54d5f07a8 b89922253f3a94e5a37305c3450ff7ed94ad9ce33483f33fd5ffa41255fb0146 2 36da1167286f1998fa15706c5d9da5a29df75448e36ee87e259d828c01901bfd a66b4a43875c8dde2f2e9b4dfa68f605657f2061e58df21760e65f32412a5254 4a724665db8a09ea5720cab1c798006f1c9f30312b3b002592942662c375a209f12b2275981c4dc370088949af3ef94a66521a11b2502743e23092800a44570a6e84a388aeed513c03929fad18df416f9ae80e8ad88a3576022a768566ce5f070dfc379aa8f5018767c8247ab341d53808afcf9a9510b19123c5b71bd71e4f0d true +check_ring_signature 86b5e6d9837438c1dc58094bb91443e169e5110681d69a0d895f78ef23d56edf 186835a194d80c80a7d4d66b680a56b2194c46c9668d1791b20ef7fda8366224 10 b2e495a39b17035cdab120ba14ce5bf37039d5348f812863cc9cd60ef6df5ce3 f9d21a8ef5c035f1f2947e48323f94ae9a07161e2474192dd20aeb0088380115 bf34d23728580a631ba89b9e3e09121ad0533413db878a9d80d27330c6e0dfd7 5de721dd574e065c6b6656d0c53e60335d8e2c5f0fb7216ebfdc63fde7412a6e a809d77d133995d35294d281194b74061d19708570c0c71915bbf464e8fc0a66 2119a3a0ca7bd9507911282a4238fb653c5705170f420a179b86772205bf4982 23f11c4eb1cf292ea4e3990af2f3c3d3cd9f954fd9016feb0370d55ff814620c 0d4ca9e3507bf3af7849a0cb980cb00b4004bcc1923054f9751d0b724cc86846 37b1976f3baeec64c62c64c7560d739d2fdfec6335cc456c0c3b64650ee94cec 39c49b4b7e477e31988f3f5cd942ec2c1b25f4ca891eee35456aa6b6e2e5d5d0 b5f6a0dfbbcbc40f9910e2b9132790aad382d0d84dc37a3b90a4aeee5cdc200bcac1e194bb1363c7552b30c0afeddbb7c6999348e4e460cf36089bf8109d8603c8806b458e06ed1013c4dcdf1f633c762d06038ac6e3f4c27d166241e653ba04926ae3ec69a4ca0a8dc34ab9cf9e4554633360e22f69b2f578b17a9f323f5805d93b82de66d6597ca30e2707cfae615375951dfaf63419c3a45b4ddedc2cfc0235b42daf547625ac9199389e617037853afcd0fef5879bb5fc15d715440b4d053f2d754690b062b093882964f85a2f97aab2474700616d994cca6f3e9cd6cd075f2f2d1c9361f10eb8329d4d7dae72efec42695fab60c39a1cd8682094ac3309e4fc1b2d67e85b018f67c39a89beec485c624b160c6540a52be9c7d2ef87180cbd7beb09cfe213a796c7103c2677f33678a540fd7166e8254a9e751f7f46260a5edd7562717bc964d93fa5e6329aaacbf1e150cb6ed7668264a145d209cc100ce38e88ebcb6f5fa0ad30b3042609fdad702392e56fd964da89196b0de7299e01e2edcd2c71e4c5b861896faec1eacfce03eccecef7a3ff5d69e8bffe37b6a20e171a11db9d40e70b0fd718eab444f72f6fb800b1324428b3d7870c083e195703980d2a81988699496470cafb896596f64ed6b959c733d9437426f0287ade3d087e5c2d3eab069e0f98b5d47d8652304503b2462cce0a319e4da5800f121969090cbaf2beb4c0adab9a5efc2ea0d4baa826204c61cb7579bb0f57df272cffe70deef23adb239cad66ffb0c1dcfe35f3da685e991a9c1fdf3d7d4649bb5072e5029a6b44d3bdfa5ed033f84874117ecb0fb8fa22f0d95afd2a1de7aeb359dc23044059700e7e90db9fdc728f014edca9c9d3c50ec49f92b7271cea063925ebbc05 false +check_ring_signature bbf328773f78d38afe35716f1a9d0392867d76336b3f0218a5d2e301243daff4 45cac4bf38eafc267338d9d3f77403e1021bc172570a77a468ca24334519a5cc 12 203047f08984333521933bf9d830920069967a60d0efe62f4478c6d0744783b2 6e92352a6f6561ac7661dd649d761ccc43393dcc8c3c1b09ee95800cb6cacfc7 610e39d65aaab7dcdc16c3b1bc5b47d10431e5f46a46a3626a12055df5bc2d01 87bf6b9fad05d19351d3626f38dffffebbef49684c807751d0aa192241dcd558 ab798e40aa7899834f9a212380d88eeb751a81931a59c1deaed34c2e82f418a8 ddbce0387af9a0b22b5cddbb91e6ba6a752cb57c1e7373178f3b695a48cb6be6 dcdd05d17aa2ecc2dd281ac1a9d0b940cfed02252445dc1604b920896cc67c63 4beb945b0d429faf2cece6d3b21740280141a4296f1c380743ea4fbad46da525 14ce64846e2e70a46be4d3633dc524a415afff2e5130fc282c32e0f080f871e2 42d8eb6c3ed9c4c383bcaf16588ef2820ed07778e4e8be2654652aa12509d076 1cc8c8590e13519fe0d11e5258a04b9ddfdb709c2384b6d9642aa74dc9541669 ca7c9ada257d03d65c7c77ff3a98374e5808c7340a01e4bd57281a6ee048b582 36cd047b9edc5b4188a3ea0fd6469e2dd797f22c2c062d10a9ed10d720e3c806faa91d182bb582f703938e7264162f39bc696b622d32a0b11356656e1823d998e61897266b276624312d1193f124c9e8d5c07da7a8700d54265d17f1855f2d046d0549931bcb300bceb4577bde8ef167d86fc0d5ccb843af3e9369c677f1d40bc3ce04867f9317184202b30f986f1694da94e2384f5d50f2e3a4b5c7c8cd9b087d6678f05de07e0e368a13f83442630bcf14c08f30784c4cee9f9bdc4f1c920c64278d792141e8816dcaf483797da23ad924a1be5ccd6fb81199384d3bc31a039ff542cb9f15fc1e683a970f15b1a684c215060567352fbec3c9aae15839aa0fce7eaf2d56b470f51a7c8869b41af16920b51216de444b3afec7ccd91253cf0db76cfc671528a874e54f54e0bd3ec48ff043df9871159ea7f33fe6f874c4ae0e0c5310936f12725ac83577ed6afe48807ed37be902f3a4e218295fb6b5c26c07b13f1dc3a78345e4d3bdbb11ffb055a29d28e5dbd9fb86148764be28a988e7030d2ed956b41b79ff6e6f52bd343d608ecdd820ceafeebc8a52b8b5076b61600c383e96701a806f50fc936c52777ff9d248770466f0e6e56745adfe7733bab60b5fa798f8b09efc53e003535dd12ef5f6f3ab091c86db4094036aa28d207b8700fd82931d7fd2b26e0615bf5514337b5cb0cade43bc1719b7dfe14f3f8327870226f9ea9f28b531b81056d38806fdf172c69677d06b0177bc9aac59251029570b575563c686c5386a12602f862591fd765ece8e9329364fd084246a183164df0e1dea963d8a4220040dcbb022de4a6e03192d02b8521bdf1e95553f6acc5cf60a63f4f2d1a8a5404dbd8aff397c77e1425f879803274cfba5c414f10cb4fc6f0bf4bd3ebb560bd4c9255b41da0b11640944c1fa87f22b4734d02ceae590ec970188d1f8d44109691b564c74d8ace3ed330a9594a9db572b0c105a5183a5bfd10d40afb61451a461bec03e0152cad503f907c2cfd41c35bbfbcb32a069a0eeeb092ba094ac7b16c9500d5a548c5131f2e0b9ff1856cb846b99a49b1919ddacb607 false +check_ring_signature ecbc4bfd954a0035d0ff12bc4d0001c7cde112fe218acd5a5ec88986bb3707c7 969b28252666e17c623ccc4c25a92926ac54d4ca83c0860650bdd77ac77686d8 88 87e3c3adb8b3375a0bb2e8f8606ae6af035c302ffcd931d8ac632fdfc9dead21 aa2a0fc9c035053f72d4dd5949cafc7ccb644a4d57dabc6d6f1718c2e74c2608 820ab16f187de021b3fa2a3c3c7046ba669c18b9d9d3a08ebc0fef3c86d5b683 dff3b582f806f51577051dcb23648da8a690669e03ba07739827fbed92789f2e b1881266aef38fc31e48518067518e6226bba2921182ed82ca1a5bf13978af74 10009c0f4d431c97a9888b6d12e7174ae4546b5e16f8a727ed7801fbdec40248 827c9edf4e317cd3e41a2fd306b77f2de6755679711538ef3c0628f225f91c1a e15bc82d148f436a618e91697c94e253253731afb9e1a938a10ade31be4ea50b a6824beb2f9c70eccd06f730a0c76b681f173ccc16b9342e4097d3cae58425d8 53ff0429df05db495a88d1b5e37ae26c4a6fca28864960c9e52442711f8d1bd8 cf6bc4dbba483dea1e3c2812981e0c8fc17181fe76782314e120ecfeb1bc81b6 cc1a48e8e22da0c0d8dc5f1c2ead8c977fceb952742384b7e9382876469d8800 64ce4fe4b46ae1e38f00af93612f7743a7804bfbfd700c9a107507f4c5cd2989 83237aeb4c97fc4b05cd7b31899d753689281d0887c94e8010c497058f62d4a7 afb817ce2525afd1ebd774e03b8281784c446fb657bd2f745e2debfd1ebe88c2 a99d786052a94bdccfebfc5c67863a228110551c91d507698cd9166b1ef92642 fcad3a54cf685e4b9bc9f4882fae1257e14e12a09738a4e8b9f1eeea6f744589 37f7a73f07e41bdba8ac422a2d10348c6bcdfa79af81e437eca168a00632c51f 1b7d3ed887c7fb6c302fe8e1e094c63b76e32c107fe9cc16cb8238dca689570f 7e8ae40f8625fdc9f99e12e8e501612f84916a1e006aa01ec4abf8eaf43585de 94478af7a64d6a8cc31c35394959ee4bf05e8ba661956a688d33ca81979df25a 8b6b6fbace6258f51c3882b40fdb518f69cf289ed4bfe8b1d19f877dd5eb8851 f23bd4aedf3ae53f73e9523424efc59e12ccdf6971d8020b14625a3e401f37df d510074454ecde3e396b9be69055094699bbaad1d75becdb762b82368b4b3c06 26ed01698bf4dcccf8c4faf797a9f9acbae9a5377d439bf2250e0d6b668ed888 54311509b513ea111d808fe0d97fb215be4217ac680aad3d552d61ec66cf61a1 c9a350a83f39804d25643ab9909c792025db8c7ec09001a30039a37353b32615 7af97097ac4a9a6cb852d59e55999a67ad0a4339da4cc9caced75470219a5a21 475a9a9024738cfcee39701e7cebc27b278410aaa86c1a5dfb9d067562b9f7c1 4083ea686e0e8759835f6104c08ab909db876e90f2b088fc44712b0a98ea77d9 dbf45ef941a36e089ab83482a1eb18b690cab0373065b7ffd5688dd7614bbe00 1d6c895b503588dbb44d354c6a5368e5cbf7c7ee7300ca5c1baacb25ead2fc58 815b9e187cc089733c44fb863a82b463bd58c4269ec23a0abd94e60a27544c82 7aafb8c9bbcd9b9ebac5601975c2f0002c132a63ec0a67ad28fcd54269c2bb3d 33889c388cbf4269e27608a1b726d40dd54ac2dc9d663ee4cd7c00b8e164258b f9f41ea7645a7754ceb8f38a0810d569f32daf3ccdc599e85617c916a0804c78 cd5b7befc47ff7ec2cc63ba917680c9ba55251da0c59442f2efab919fbd25f7b 201298788a448e008d140d0bf7581343a511139095a4c0e750fe1f14bede6eeb 5eb2171d684a544d8feb4549096f43e97d62759943e69b1f6c4a0c76541386c2 98082375ce9aa7ae49f0d91c01af935c5aef3ddbc042e400b1209fa5cb3fbcc4 657be3e60188d305ec04d0a0c5d79a2704aa1043d721e2cd50566d2fb66eede8 57c48bda7ebf83b8f9a473bd9e3474a534240996268b024213f2896c588863cd 7a5df4c61287a78ce7448bf83e945edff44be3128472ba4623c7046559f364b2 e9cde63742115e1c3b409b54dcfee88d0dda19721c9bc2ebb0daf9fcb9384d73 e5fe5e9d5eeb13ea6e9b0b02a2b99db4dc79ca7e1d59c8554ffe3ec43350c482 6e88fa40e1c7e0d9d7c403266362c6b1507bd5bc87b6222788a4647fafe274a8 b6087e68664dbdd13995edef94cd99f6243b18fe05de48ad77da87d8f054710c c8f7134eefd7ac02019f4bae9fcbac728d3a39dcb0d966d335b39e5bc025ac0c fb9f59ed24dcf1d7d484bb9bf71cb36acda0416e28def0e03aa1666277d324e9 d30cc6611137fa39abb162dd2c29984f56fce916056bebc031529f8970a5f000 4a7108121db86c82e74b6d081788b2f98e0294b9348e9707d40300fa0a994e90 755872e92a8fdd50a4b20928766773847edf0e3d1e7a3d522d7c94cf65d8ee02 935a610e9d80c56facb2d7253cf265a268e20c61d9cf3b38721df98f78dfa50a 7b45b16d15e25b96710b8a48ef9b63939aa54ea945dd3a3eae7f09bafb1e693c 3f8e70fc908973b0ccca561363e441ce585021ce2d24778a8c8ac1e9cef0957e 1985d7edf2f382a637936d83ff24350b283765188b2f994349db7b59d0c09c1f d7a13084753555e464511355d4c6f9397080f40004e61e4ee48f30795262af33 91d8b5eefd860c37859a2f011003cbfba8ff1f6e1fa31937f15794a35571a8c2 f4573c66277a2cb5beb1a20cdddd9212e56b30264d675e8f3e66c48733d317ad 02fffb490c2b7547a04196f1bdb176d30ce2ea5d4c2b4d6c93f0b60ab781911b 54fcd6cfaa2c2682cb76c0d776bee971eda01989aa72e1478de58952a9a40fdb 3f796c91c3460245ef373d198635dea353656d9d13c0b0e447632c8cba2907a2 3bf1a4204c28794bb4ed569101520668ae7d635216760194733d47b283007a7c 611d9397d1378b93b842dc70df0542d6945bd9a852d4236d7efbd4e285a5a510 6070941db89999df2d6921e087a2d035385207f6fcd23115624a4fed6b945eb1 32f01dfca2e777836ea60dce7bcd594f0883024a04734d2badb7f8d542a8c0b4 d6e19eb3338da496f7ed866a7039d264c6f2dd77e050e74dc4346b3c0c2293a2 57a06fd19a97f06557d79b14b73d31f5353a8df29bf001ce0f40d7e8145da77f 1f9b516a1797fd6f9d154e941dd1a52819a092d7d90f798fdb0c2988e533a659 e8d70bcbcb9f00cd0b7b63ee6c6c464ed9cca7fd9547df9bfc29a6d9fc3c6653 97280267a28ff5d9ef5554f92f078afe41e43a70328822a80e96f69b5b45edd5 5361680bb40c7845ba30b190a4ca7475e72bb8ee3f420841cb0e98b58525589f 9b02834736255b7fc8270ca6c88a95b6c4475214974c3b467cf0dd97eac582fe 8585ad47ab77a341faa32bbe71615d189c66cf483fd65372bd52b92521ef4842 469539777dc7cc1a0cbdd7667d3b78126e902a960bdd68da75d8fbab3640c441 166c5215b58f88c131e206824543d991738a997fac505b505f7b1f77d4f54e76 137a227b1e28766e46e20ab9f3af211d01e720c92eb9dedce2f9ad5aa263c67f 9d1cde6b645610af29b09e69b0ffddb389cac35e542bb9404cf3fcaadb8d2610 94fb1e10cab42fdab4a4803bd9467d5f64273129f3bdbe4d1f949cb1672a7a6e 3068e9dd4e93d517a16e41582f0513066a36446980e63338b5ffc510197e54c7 58e1711e22d0eac9648f2bf9414b3b8f1ba3381dc662914097aef2603045f770 a28f55d095b90091ee16feb79c1eb9febe7ba5cb169a99feb89bf4b70edcecb5 6be627aee55dbb93ab1faf37c38fac23d977febcac6bd7986fda40835a97ceb6 4a36dd3cddb74a81976b81717ed43148d5ac1bc0802dd786b546f6622b996732 d2b73bc8fa1da4362cd9e30fc132fdb0d7e4f50ec61dae74cc8e928a257deb78 6adb05f3e535a45a113bbfd5da55cf408dc66241bfda8ba11f6372c9a1cbd675 8217d3d977f8d231e1bbfee259a9fc3aa4702e6d28b5c2062fd6fd3ad9aea0c0 a55ef554d8748c6c6c1b8785cad90e02f7a09a143e4fe8339c312b133b5d3125 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 false +check_ring_signature 990197794563243b0800b219f98c5b494ba36cb15efd9148e44e8bc59cf8dc0c f45f812e2dc7f4e21327ee99b4f30dda3c93d52008933c782d1ac601b171a47d 4 49064be657986db8d5d5e805557187084b0f263261946b3885903b360b282265 40deabaa16ce7dafc086c8176a1fbabf4b285260e4492a2414ae8be2dca7480b 08f548aba548c423346080e002ad65d0ce8fab62647174ea960ae70cf7720a36 623c4e66767d71ccd3db36b0c821e50f0d8fd75e58fd0d0526a2e96b08266090 949ae399d6b84f166586df649e3b7d7fd378d3424138979339654bf379d8e4070ed3c0755baafb15959c76834d022e82d1c1d2293ad64eb7282064bdaf8724057305e1634d4f2083bab5cc3a7fe699aacc308038eae460a0fab562188eae910075cd3fa72fa6a221e14fc9bd1512ffaf2529f41fa6d5c17911da013a1c0d53064fc006ef1d1c933affaf4ffabbf40ae135970e0b86be4f60fa05c2e14f132e052af7888755051236dce0641343e99de4ce4d9e61da0363522ccb4a6296fa8c017a90fbc89ab96fb7d3bff386dfb0929787aeddc3fb1e8b5b6be806f6f9557c0b0dfd823e9932d29ccb4e2378eff942fe223b3b4418d25535eb23749c80ba6304 true +check_ring_signature e947bc7c9a18d27883471cf208d4c9ef763c66f3dbb5a8b53b9f10373f549a08 7487ab39c94a1b545fdf665df0081a2c4daf7da0b8200e49c393cd230963a7e8 81 b4e698eef665aea057edc42010b5b073cf599309c63ba5c2b2d959f4fbb7954b 6a7c7b77bbdb964123ad7595ba276f9b121b745542493b2e134d57d6dfb89707 0d68bedf91748d058f114b8bc81639f2afb59974e3e4d6e38ff914c873059198 d9506a686ad59cb5a5903d2e6a3d09843426e619e957146d4b1bd626718f5b5e 48c88d8f510f8971298db47354ea23b7984e11c60c23c30b727365942a5a61cf e227f0ce10f573f79232f37bb4a7a066488c7ddad6230aadc09f028481332eeb 4d37128ac54d8feeaee5d95a359269b7bf508e5366d89a2a16e4866d3ba25c2d bd8c4f5659100c8878f3920f5f7032c1549dc0a701e39af42bf13b93a8a0d272 d6e528ef666132754a225fb578d7819a7267c0c37dfc46bca3114625f3586f50 f28df9d876eb45f150b1f1dca114588e233e5902caa01206db3175fc1a3db268 8fe9330dc87e92d23b2865adbc519404190cfa8c134babc2b087293ca16df773 a183c9e497d4d058bd0388425b747e8d9eecb3965281c699134ea346deecf510 0f6b381e333223c28515b08cd07c5b2093def3c528c8ffe2fad6d20da0c63e48 f2b1054ea9fb4e6c21269333b3a4db7e244e4b9042d3e961d1adfb963da6dd67 37eb97951965a7ca9734b072586a43bde45404cfd78b62d0b6e11ef3ea36f614 1949de7f0c12195bab8baa1f09d4e712f49d5f543656f6e749e75acd8b2d7900 d41627db7013347a2886ed7f5884906ffdd7c697f490c9841c5a7b04f18fdcf2 be3b7ced14cb6ae1ebaa6fc3b6a44210ca0d6eff6911bf532cca246c36f65f50 7d1239a33b75cad6f96fe0cf5d57ee00105c458f969cef03606ceaa105d115ca 78b81005c9ecbe8ae67542a3a67b1b8de3fccdd96ac793376b09344bafa2bc3c 0c866b5b5271bc4a317c0350255dec4f0f8a2bbf7ad19fec56025dc3b1b781e1 b6b8524ec884df2ca3d976c76b8ff4aa2b6c2b15885b15135f6371d2e6caf8e3 51d230390582cf4246c472a8f42f7169a000b0e77ba23435190c11dbdfc4d0e9 a7e50511d05d17cf67fbe326f30346600290fe7391bce4f707b7afb6802123a8 2bfc0662e4f7cd8fa77c920adab277871d914c6d49c94c0cdcad97e35286d33d 39802c5f24c2ac6dfdf82cd29e94f157bca99872190f3c42904a4ef7cf2b928e 8c7856eba11457a89868bcea983d3b770e95a618379134770ccba10f5b51b100 66f67b0d6f7afa5eecb736796bca37ac266507e91812634598c71e0c8375ad6c 1ba6f3fd8c91bcfbb0b81b2fe51385eb19f0e906a12b43d83273c4561748b8a1 2faca7f4af6895ee2a9ee7fa9f58a0867eed1c6d577e30e9a268727da5652333 971c2881b7d4984b9279c81dd71a38fce174349780ac67e373c43dd19a81cd2f 8e2e6436961bfe69a65014c0c714a14e4b46ce0ddf11f098e6e488c938ec0102 3f9578204ea1d42ad4ff9f4e4d73f9454a22eb7ea63126a30746879807a0739d d49fbc1c9d9c95fd2de91d81c2069b2a24f75946c764e45cc55e05fe15bed66d ff97451524d50a72ad9127a30c59a20b6810ce5331c084b36da14b7c8231f26d a9ef558fe261ea7b3288dcf136138e00e052f98cb42f20d4f0fa3c8d60f23de4 2960036a817c985d6bf4c9f16a5705868a83d4ca20f540bdbea8b6e450dbd0ba de4fddd1457c967984806bd4f768d6f315bb1a0d81ef175a4f679d9eec408be8 22f684b833687446694e6a8ec03b664919077cb71b0cc4bcaeda8ac43d2547c9 fa06fa5ddb638807f34eb42a44769bc766a0263b2ebf9c5cb3c4c7d526efa68f 3418173d00f4746740c51129ec14c240101efb26d9fe6a93e1445a7d9ce2435c ac8c9695e89406525a4c4ae2927c6bbd7941e1c087450350c9f3f4b4e77392db 2a772666deb8b96b03d92ec3a2b26e8de07b53cbc2d2f3de53b9bcfda011971b a9bb438a55d4f10fc0ff7b8395fc9b9f1f1a7130aa34548607b7529596f2841c 68f6821d13000de9ea710936e5f4dd0cebc7778d4c9db4472ce76eb07ea9aeca 330873b66c9e6cd0f298890450ce8c9576ffc26345d602a78598e5992b339596 dff018e7209aa6519f12259277dda9cf474c44ac2a320f929533128a110d0338 023715820bae561daf3f40f7b334c79cb4e85b58d829929b4766ca5d48230a87 11beecde4a48542b4a333950529251280075704e5d174349e0be9da86c3b811a 51db69590dafb11be0e8dd9f23f4a78b2a8047899bded6ed474c39769dc25d3d 60fe9a16f2d3e8184c42c4800b99830abf16e7adc9d739c501259b3cee8508b3 e685b0c3e0837990edd283f0babba29ac4856aa6e640b7b2be17bdbecb638d9a c8ec2bb13f0abc699102d3086874d491bc1a19c12f195e59c6025200d77f4c80 4698a3b74dbfcd952a43c32c1cd9ff349851314ae0e7b9ffd3df08f185df14d3 8ffc0019dc69c659a78ff2e7fbd53248f31a27597e471b0637185c13735d2a42 b32ca29a5585afeabef4d7a4cf24791684faf03d9e8125e29103acd9ab106ebd 5e086e9f345e9228310084996a02bb099cd4fae2e5855877779c2545545c9f7c 4d9c59a7474cdccdcca9a3c63fcf67074e80ba0ad45630673863e531a9559b3c 0938e25ff40b34c87c244d97d8dda7e37de7c9c71f073c0f1dd3c0dfb6a2a105 cd1892dd29a859b17febb4bc39db40f39263d7abf3a63a4e5001082185215843 f073fb1abfcd2810df1dcea6b1b1ed99fffabf31145834424f8ab380e6ca35b6 863dcf4bc294a84c814f24ce0d62b4aedbb222ccbdf894522b84b5984c3cfba0 483cd48781f0634af0c09460d9cbed14508d2c35ad667cf3e911de1526492922 88c8ab287793e112333bc7c92b33b51c7d5deba45291b2a111dfac7998e548a4 08e7ab9715555c7635bc6bef4ceeda470bfdb2b3c3567d6830f7e0766fb7e778 c0ef7a09a39f5dec65370f9db83b7daa77b06febd442705d6427d50e787f75e5 bfc2ff04ddb999bf39ef5c9b29df989c50a28ec92d2a911fbc0f015f0e6d8806 788befad4e8eab98c83aedde6a618ad61bcd325938b647b83d4585e58ac2e334 580edd4079acc73b7501688e05898cd4b8e4e553967ba3db82cdee550bf46607 fa0cbb8369c97a09eefd47f540268f835f4dc129ecc3cc5829cab023d22779d7 b4c9d6bffe138f8d114846180215f117e586d2d66a013379a409b2d2b8956c6f 170b765745a4101f450fdab534fa95f1eb42e355d4cd59f16e6fc620cf49be3f bbaf7867c81fb2f8e2a97b353e5b8a3b44b7d3f7b595acd04534bd6a9fbfaa1a 4bc0d1c99f33a51ba0224349bbd88cf2a1ae6e7c761a5035da78574147034002 20268612a833a0c26a63241a1f9d069848dbfdf082ea9f3c639d25e57e4dab32 c45563776c27a57544b4e26ef8470651acc647e7f1b786e778a68ce8dbf85d0a c1dc110486c720eb920e348c8275fe54f0c5b2af669a493d4dac9e66ed8905cc cbb7e4885b65e6dd4aafc4b73d3095a75c6a75640a20d0a6dadd3507032a3d2d c3eeaa729119d6fb212d97c65f58a74e99749df9faa0c29903485c73d18053c6 a902be1f03be2cbad6a4edbec96a3ee6a0a1810847cf63fbcb10045a106307db 5ad959d250f34305a897bbf944a9b60c13a7a770d6d473c9ab73d9dbb0750708 992bc04f0ecabd31d50d3f3bf794ec4a9b545b967f35b717710fc99445cf7a0b15c67641f0763cb2c4e7f2be29c1629e4a364ffac4164fe3190163c1fde623190f087c5a937c5106d02e6c0489daab73e9f71d45fbe30f36f3b2860d3a078f08ecbf6037025bf49cda6e6d90a52062b3b07883fa20814aa3ebef0d2196ae5d9e2dac115d8d201341da9c7a850dc595d78d530924e296195305f988bd04a0bf09619785b889424b0399641a3f5532fe5f672ebc4e916b726ca3924a85da78d4084d6ed91e4b6afefe4bbc4edae8119a5c46e0c2345eba565a63a5c6b36b559e0bc09e161b85a604c331da96775f070fcd34b0db1e9379cbf1f4b4ab0938e2ce08821ca76f35709536f9c14b6fd2cb58bbc064c28db07579250fef3b53fffb3f0b192ea91a35a9b8212e364bc5d5f7a3015821a32cfb11f3bc47e5a990dbd8840745b84ef121386c073d383efdfa83f5d5fa5100cdf6be8af9faac8ccc38f5d601c4d48781036050cd5f7c030584f5c425a0987a7e86cdf76987d52f696c01900577564daa9c4fc01ac42e4971f99ebeefafee466f9684f8446a86f3e3a5baf30c6e914dd35c874cce7240add3f71a95c52ac5ae2fedaaeb284d4ca7b43298ed0fe69b3ee348a416a536c9d35daf1f9b36a436e52b8a983edae978216712d1eb01b96457a0968b23837ebab2a2d1d9696e8e22f030826af8a292b6bd0c49e6970dbc3ecb64858d17014957239c306b8323d510d86d22157ce791292f458cb89906bd00b262348c84c5daf2994e94ddb88afe380056f4c1ab518c780b894ee47a06cbccce5d29ac88b9c7141506101c24a41d7eafa2673b1204104dc18cc5f8f30060e1470ec2bf4ae30185cdd10e76568db8bd48be175f8074a50142cae84705067ff2531b5659f210aec726521782283ea536e60e5f3e9d1ca9290b3df24ef30b28f45fa2b7411cdee94206e97782d19a3312c39c1d503dcd00923c959720b903a4336313a7c5840fbeadff46526a3237ea51ec188af1b067513e732a44544d07144801acdf971983a6a90d93f0f42e89c058fd2937e0cb0234745cfed0da5006abcdb5973fba939a229a6b2e6d154b199b58b1e8e600111f6371ec4715a85703a1cbe65497d38c6f5b1aba3c2bb871300ca75df6b1b3b36614079c8c8b20390a65f939007b10b87301994d9f7fa25da3dbbb1da30cad9441060cd80dc938010f4ea4f64db25195570838fa4b7deccf80493ea66578a5eff03629643d3afb1d0328dde2631a20ef3ffe5e8d1fb201e23dae93e641a7f99ad886fdcdff547ab704b7eff22662cc16208cdf0d90317758fd80a5de2149528c68d8c81e56bdb899035d137e5bc998ec55e0d433ef4088a5bcaf22cda7f61ea1ea92ddd7dc2e411600bc1c4aa940c248501b5c96440766d79c7a7006d3b1be3ed3ace23d4031651c0eb0bdc9288470a6f9be72b7e85fbd6e47bf0eab8cae6f70eafe82633d8be957041fa46f8d58b8df6c9a0e29ba094508b1bbe3896656d5221205027ed0e6390b0f80ba02731cadab4877908dceddc69f5442a7c5bc59a78412a9ac6d058cd5090412017cbab5362951dfd9397fc5d24b5823f6ee075fc2dbe0345489d9ae059b05cceda946981702b27b5ddadf01ae354cb69016e123d28fb88806fdaa3091d2072e9195370a2023b9f3304e0eeb588678da6b61f3fc8fa1d14a5eb052541fd1013a9ae89642aa9e70a52fa7fa6750047d38f88d1d12f5ffbae726ad481d8abb00df0ae6adeace886ab5add0a65fd1dbae220068105849afdc82e681a06f7212082a916a8e27005e0beb6c5555e3eb0c64b7fe6242bfbe04372258ae0ab6eb94031f12129b2284a51f981ed7e671eba34eda7f70b431464d91260bfb164e69980c5207db9c6757c26c051deb7e79bd7abc8b48abf1a7c772b7fcfa15596d4fa90e571cece3e9b83488562c84a6e1a0d7f10b247f423e307f391c93645c1347e20b725ff5b2b4f6a7dfbc76dcecda12c2ad9898d07143fd9081e8c60dc19d5a790a34837b65b5046f9407328fddc0517422600fa2ded64453e2fee19e8035c7e205402a29dbf1300a857ee6862d19a7046d397a696409ceeeff208a01344dc9350d4b47efe2e5b9383e09a3df07cf12a79865348f22647f8b7407e6e3ca4c55690caba195310dd80b3810aaa32cce4f6bc7ed7067b2407c890dc58f11ec6943c20c20c1202ef92f38630fcfe1fc501bf67dafdb40ad9721bdfc215a8595470b240c263683d076cfc6124b6710ebb2c579aad840431101d9b5f43181b494bcc4bf0f8573c6f69bb7fbb3a2a86f475221af708fcc6ee7d64e2e6e9fee6402fba5c402de10a634148e9db88df4be2fc18394bdc7e3be606f8d437e78a7549f0a5fba04ea73bcbebef1121fa2cb8e18f3f476db42353ee11c83022a98810494c27aab036895ad8374dbefb1ab9886ad4607b47658c92112233d021f2efa1d5f6d0a1c0b8bdcb23cb1447b4f038491ae300ab7928bed5d4c93bee4335829ae824c073a08a3ad10fb9ec8da5e277cb041099f5d6bfc69efdebdbb104c49a1b68c384c7f082d7e99c2e15320d12ab87eec66b7997d1f01844b26539f71b59d8c4433c33004bcfbf73aabf4c6e6c60c17231fe96c4d5d0dba6721a3c2c8eb62f5d7dff06d0917eb3719704ff13b06dd1bd4115b0fb8bc53bc12c92229cb5968bc15faccea0ede38471a24e667c12ed659cef6993183fca81898041a8d0cdb4c1d6cf6446803e45dae026353ae1a5427e2bacb3cd45a6da67c9c187b2ea6eb6b5a4e38d3e5061b0b5b97d6faaffaf03be52ab41dcc750f898a8b33897535ea13b179697d750404475736359b673773d1462aa19cd50ed3653db0779a0c330c1991d965dda40b48441e0dee8354844f146b0aec1b88712987d02862df367685a8edde1b93970041f965733ccee7579810f16d41178147733158c24ef6194380755c67b2399a02398b6eb0ab51d818b892271bdd133620db09ad16993296bebdecf78016a630096ec60c1a64d56ac6b0b27e4f9a3ef6065523eebbed7e2fa9605b7019c0931a0b9e02dfd85c20a19143db2b47f73ccda7cfbbf7bbd799bb07f4a531178f367b07f6efa45095720af7156bb461f566de0b802c34aaaa810ea3e6b22e3ef724710ac1ea58bbb5a3996f01e2ddc19aa380991602362b3b4d4fb9bff9bf5a7a1ffd0ab675117e55768f0a3103bcf749d5047c919849a3739288e5d1ec9dd9002b500fefcae1736dff8b89128bedef2866d2ca63ec93ddd50dfc9170772814dcc8b70d279f37c630209e7a84db56fad079cd2923b3419920d0ca5c904ad67e62039308974c45946417283a62aece8eaf4e59385b4a3e293843a415bfa98bb9a89f1304096ad29a6ea988e41102779994b7fbf14c9db084633b1d452ac97669f280720d2f109381bbd5477c098b6eb80a35aa96a752b00f39829c03e655f293367e880477b25be3134e224c0013caf3deb4d0b528f615802cf0d6d25565de6146396f05fbe47f172e2bce6ec862db46224b0a200a432906eda42cc5f7ceee52ad72b90cb76299c82e40310895efb89d2e29db4366c23c0bb83ae6faa85c87ac6322870f1093b67c41da87efff0f9588df3e84d8b3e7b59de97d19ad8ef1aa1c751e9208e583f2a7aa0b2db3709c7b7d6d92441e8492373770936fbfbf062099b990b805e7947250231a2c5fec7c82a249eb310c2f4c0bf7bfadacf08c24d5aacc668a06f826e8523fa5ed0d82648849932ed89f994e8d91252e0247fa33511b620e4d046ab5f78735292cdc3870eac25631a6da33db60bc9cece5df18856cb7f88c190fc519ba0a5df53ac4ac95d63738bdd5f99560d3f095fd2086e4a3db98ee567a024125cc458b6166f16b924459382a83db7f0d6e4c51a7b04bbbd58ac9164d8d064a9b354e975a43cb2b0dbf002a17ab56a99f900a97a1f85cb98f6da9e714d20beea0fb76456679991fb8318e663227dfff88d4bb1599d32ac8f311b5050b9e0a4351275b2d50ffc484a908e53fac131f8a20bb835e3cace7acbbc68b0c19a608c6ace45f26d0796601273096f06f1d99c9536fc88f3f5c11a7f24a08776df106039765814286c87f2097e2f129eef95998917a31af35ae6c9b0a83e105632e01953866d64f023f15312e314a35d573f4101d0aa3edd40b91e8cba090b6e0650bb0d0b796afc4b0f55db75e68e7e0810896a244edc29228042e13b081d443d607e5321493d58e4995a1b5daa9a8ba5c1d94dede2600ee022c1805e98428847a05694fcda00f230e6ac3d1d0b5909ae1928e5ed84fcb4fd8fc8402a1d8ea5c400dba0ffa06c0b7f2c593f46b659dfa3cb00d1538ceabfd2c9a547d15d8de257a0c8c50b85e5c5c570af2c3b6fae82745926b9b035a4fbee4fc39fb5192b033b70cbf4553acb003bb45c3e2cb0b49059f4d3d318dee3fe9ebd1eea12c33469ffb06f581e3ae8105ed7ccc7b91430b07343c97b8ff5e8668bac4ed70919e551b6909df84ee413334a6d72938dd76fbc6dbc5c51444b900c40723a8dcee97f831480e1eb4bf372a5f548b28e32253693d5f7e81e9cecd4b455435c18e6daafe67390c8f4b26d34c19625f95566e2c3d2e4091b38d78d3f879999e8e90943ccd57020ccbfa63395d4fe293257374c79242f84fb991e7d689e2d31f73fa9d400682970df1d664c9688ffbabfefe3cd26a6b6a0899898a34495c5b26f465929dd64bf208951dbc6a6add39e7a1ebc74a78f49f055a772d86ddb2e2ba3f20acd121f0b6029fbecaf5f6735b0b0f9d3493a2c69dd803070c90a1edc2e38a10f5063b1dc30675115a97ea419bf9829884f382414bd6f89d240f8a75e75c052b008ed26f9c075cb3d5a7c94882ed798c18b806cf5f5a45f964dbac1f4f1dbea6c5eb5722770dfd5aeaef4e10f73855958624de0fab118da8d9aa7f5ac936dd9ef4ff347c5e0a10ba6e0cb31bdce587f10ca24e001a83c4f99dca386e4d2011b657a15adb980c0de3845ea8b583869954a56178a491eefe8ed0d4fec9832cf3754fd9bd3c860da83ab4ace99ee2fd4e28bfe1869c79afe456381b4d281f104226b2c87217f70260b82444b22cd13ae5c2cb55a35787dc6e5dddf8ee69b10e4b0f3307213d440afe152df7d573f94d906d11f7fac01251f90fd9a82317b3bdff86e237346b7a027f320d18b9ad6ee46d91b1c581db9148e263a96aa6892ae1a78d4fa3b818b8080cb6dca8828bf35fa9c43afb9a9c5c624b8b98faaa71bf695426038804a02604555ee9037d5dbaa356b31e5dace85d0729d52db390cb9268727cd2de3b8cdf019092ba7b95aa98143112691c9faa219c43a32c602502d682e7d524c8f086630796b7c66deab008fe7339a796b3577f35219c9ccd3b90fd0da687dc7ff1e3da04a069d50747cb1d6224cc4998d044768d6732da202e392d5666a06b1f5d710c08d950b323eda4b0f04ca0f7324e582a1027d0ae1a4f26cc505ae4f1f87576a70a37d68e2f2541a76606393217f2062fa8230a4d54777f636e143506519bbfe6091dbdf40e83b7186a29e4f44c83f3f011cfa544e94c3dd08aa30a957f13f8180f6158041520bf4143f80723ec66277efdfb7d46387372f98a29c1a15bd13b91085b62626bef6fa279cc9dab4c6bca3d39e18df2b8b0fc9ec629ba17a5f11d670bfb364f6527e021fce31831a6ff7abb520126deb61db6c4818bb1ef4f7180d4067e215aea0e10b8da0a21c6bb33cc3b1aa93397bbb9f7bceb21d081d6053f230bcc7f40b0050edc05331705c96e1f7ed188a5c9dc09c698d5d980c89cce00320a0c62e9f0fa9d2a47400c15ee1486c7aad8272c05166b31576e48a94234276f01511c3c1059dfb95256520678b8f814126acfa8dcd80d93f251c3e7349f4e8401cd0a0c384cbb75353c06219aca6b16e56853fc925ea18cee0c397b9c435c9e0bb394e6c24529638c3fd338f799b2e51bdbaec74864f83372a2d5e42f9a306503e23cb0025c2b12fb92818052472cf071eda9acd1c117abb246b2200fb3068c0576789dbea900e4d67c237145a5f5d9d0ebd362ccd41e31a146b544f0bffa1c0cd8a285414f570e4eb8221d6b45c16cb21ff0a3dd904097ee8085a48f496b3d0f110b4d811a1c0f032b9673da1ad2d1e1ed165ca23bf74a895ac0228caed620016051b20f394933a0c46e2a54678c43e782152b88336b837eeb9800d86e42c402063aae7bb44574af1dfe271bdaa21e05c11404cfc3c5e3be813f6f6a2ddf500b21f35166f1dd67241f9fe1c0083d634a0f56330f782e779fbb9b372c6e473904f689da2c8d32c6e49d08c363c77369547b97e68ef88d8277555872b71494b40277b80d4a283ecd99b02dc4e3bc7c2099839eea7f0a214c8f997f4ef195a9d90884b0e8ac2b03010cbe444dbe60e34ad158fe6a3fd8e66048ffd5109c711f5d07bb2da9d0d3e274c211a73c6f78992bd39d445a44560f88c2122647534ca2610b10abe71e2cdec52cf8ba6d5489246ec1a6568325c5003a5d733309789497a20c220019d8ed2ab2e60e9d7595cf1dd716b8432f3c2849bd7496400a2fff397600f0a314c7522f4a4da2d66abb746f3b38412b5c229c754c4dd1c01278fa5d8f091ad6635b0246cb7fecbe6849a8182e0a8bdd2d91430ebb6959f7e297644c660664d4e57d5ec342c45fcbb8255c6c084e483cc9de8e4f883062df62fef55f53046e318e2950af95686ab5535731cb0e9e06c21215dda124e9cd15674e658a400ce3187642487eea2403e4edc377868776190a5f0fea0e56d4899fd0c9b0a23d0be273d9db7192af8e2af2dcbe1b4fe6409c2046a58359b4f9125e0728dd4455053062a0578a3d78892a2f462ae6c3f3fc75138345975b8802e15fe345c4d69104d35ef7b1f5a8dae2fa94457ad1174723d5df8725b26c335a00e61f5415faac07d6405b247f072bb3858255143bd649f6cf6638d1a616d455257e249ab663df02337322f31b1afba50b4124c822707182a0c9c2066d2f7ae0055ce1b500ec9f0263f4bea988a07a941a4794b08e78048d061ffe4155a3d013f121ca820fdcdb0a3808457034285a6f6e863ab83ec7f0cebd636a49a0d5fd4f6cf2ee1baa4f32059c0991c78f2ede0ddefcf160ec5394295985d6c6620a31bd4643173d271e8802127bd9f14260885384d51ef37db5fe91724cc23d9462ba695016d975937ec4010bfa500324d58d313ef59d2b5091ee8e84cb29470787d36100e137016931820b30b7eb895dc9dcd0c327f1587e483d77d9cee95b811ae7b4ef18f7ed1b7eb606 false +check_ring_signature ec8ced9e7a5c2c8036248559b66458653c192f40de6ca74a727252366d225328 6afe31fa803bb07abe6ba1f80d1e35dd324b620e256647160e1177d5e3d41f45 1 7c81f2a7e5f6720b405d48cd718ed3d7978b8693638855dfaf6213bce5968d78 2f88c14a0f24650e5bb108fa61c5f8a53889640d866a6138e2af7442c5d2d804e539bf97560bfa4c3fd177d66b5fe193066510a3230bc6b85eb9a68d61ff8248 false +check_ring_signature 8c6951b93758c90e9ce9035011d13f97dd248de014eb876de0ca202d060c5ec6 24b2e62e1502e4e42f6d9a0c53e1bef2df3c16533b034c24013b9735f4637469 4 6f190ff6b57ff81b6dd027a9d80ec9dcef5eea1ad6e19013966ceb68ca044eba c43059d017dfdb72c2b4b7c699c2cb893bf0067c1fc2ba1525fa8ce7d21fa2ff fe387116e25635f7887bc65a3a40e35e974b101d2c2015d22cfb3595d27f827d 6a7d7d4cd6259c26bae7dcfa16fac377bc1f4552e138daec764731f11e03a7a9 9f9f329ff76dcec91b160414598c8c49aba58d410db81995afcd59af74b673099cef082e9ef80d37da97e8a23dfd01e050d358c4997876359bae68c2aa1eaa0249ba832c62c8d66ae4cac8fccb1a864df83abb9c5f6b7f1c2a6258084f3f5b07a92da45f0496c823cd99527ff92f00a1a895d18c63428a374f99b35928b8a80f4b3bc04cccf37cbc0cb6e283b3050feed2a3685daa69ebeaa2c3dec6d4f7490f13bfe97cd19bfd94115ccb81d2fc4f8b30da4ef529e651c405160738c9e489086b3df601a84656eef3b0d546d84a09eb84d87572c2c95b19c195a72c3571bd086eb1da4e07120f463f106b9c9583850c437c9975618c57c0f33cb5062eb08a01 false +check_ring_signature eaec95168f2bfc46cb01a12e04ed268c078814bf780001318ec48531ec068f6f 0fe919302c0e47e623caf684a22a2019846be2f8885de7d50c1e60812dbbb399 2 9ad347b1e04841e411d30390f19cc662e09ab71b378d8f933c6610a9b3ba6720 673c9aa20f1343816c719f42590610343e6d0a60c5b1135d1a106a9a7d1d527b f6194797761c353548b772294c54434cdb30eed8cdba1f79462f1a8dd93cb10887299c87f323ed1d5b4610044ac2189dc54a7b7bcaeccc6d189094983eb87c0c60d4cf33c3c1c35d7df8e77fdb06dd8f928630656c27e65595d5d775267000043aa9bef26acca6c4355087ffb6a5ac42b72a8eaabd34d789819e93bdd0d5730c true +check_ring_signature 79bcc31f71bfaf32fb9b108a2745bbc71fa22f555a9498744305c8db864ff0c1 0297aae6b9c6c9158e4cfdd64dd425023aa609129be9553ee1f111b1b441a5ce 7 375d7983243befbabf1a15f45390d5b589a6c998e3251c42af4de49f4a6238c3 9fb8c714f1bcd317844ef061c35e17479d841971de4fbddd4dcf2f4d03703dc3 ff591f422df98554055d0c27d425ccd09dfa568eb07f6ff4a50ee9d35f85692e 49507769ae1cc97b77997d26cb2bc72049a3eefb2b4c20459a9a8f694f349e14 7d7a11d904a203c51e6611547e86a5ea58de741af5b4368949508694d5086d7c ad339c71ae053178736326531e7723ddb6f3b85667e902495fa176b50d6c0b94 9281be5103837066b86d5ae5ffcd7bc41ea28a0d4192a75781e4aaf5fa9c2b24 1dfb4db13556436589714378d0101e46f65e4cde69075fc0f01763b9e0ac7203f42e5c6efdfb84ea20629890b06dcc4c02a277748a5e834050e8d95724a5370a836a8fbd8f7d3a2ec614453249f6b39bd0068aec782a95ede12dd5ba4dbe8c0091c278fb8cf53d852847eb3b852119aa84b59252dd36ec63e4714fa7b3da2b063a016320dd848cd2c4f68763a1296df3b9b71f1c7300cd85030ecc42cdd3da0951203feca16cf44e78f3b3b6eb832db2192475061d796f770c1106b20178ae0f80c80bddb8100be65d1ab1855ce210b70dc68a11d2419a288abb022c804d530f5572cba6b313fbd21a886c286195cd967b9e4a9dfe808b1cdb9fd3a5b1caec0e69cdb25b41e1cc1444accb60e1144dd2d327305453bc305f08a700039e2bb00b46e154bd460632d3b10c5c2780bea1459aa48055cb08f4006116b9af48c13806acb2e0b550c58240e896f0cb3487afb237944612c6c707f712f2f566a4559e0117afc3eacf2ca871773cd118bc4537ae342bb5266fb95f22fb635913035ff3040393e4b246db806541794ac4de29a7cbc3c751da55b16866cc41d74bde70c90810c3d4bd6146641c627e4536aa8d534b745ff38c6148df007a5b509937162d09 true +check_ring_signature 4925813e58adf23b66d992cc12c560f321e410c2d4c620bade8ab3e4dcedee2a 52cd06939e119460206d0039b19c661bc7f1ea1497ad9c0516fa08d2c4358c9d 223 2ae2349f1e8f371dd09808ce5db8bfbf2cb82ef8aad61141ff99eff7704ea1b5 8377be0c0bfe6aa093eac00359e9de7d342c67e9158cd4872a2d9cdc65d673d0 9eb857ad6b0d0565ddcd05a7c006819c09a873334c4b9e3bba89dc1c931782b1 7e54714f26789c64f1609f46a36fdea9224d34442af2e6cb70d433ae11d47e77 6f98b4ab55c1bbe3e1e530f4f53e76157011611b46e24811a356ec78bd9a0e9c 1a1d3b9915528a17b80256d1d5487a4dffaa147209a2af8ad888829491f19f9a 36c5072bf32b37d4a39cbd5caf515eda517e43c700ae001b564d978bcf6f0076 37b97740d94b6d6e9dc82ba884f1beecc1442ec37d617142a03f4202ce99d8e1 b57ac08b9d7665ab50fc0478ee58870acfb41a0cb999cbcac26d5481f926d6e0 86ba2aa1c627415861624208cd01b223228dfe6eff7825a034da165b114c13c0 40a2ec1775d577c1f2e810be43447221ec5717736e10c14c828e8fdadfa42a6e ee126a049207991ccd52dd24e3cf392794f3a560dee89e14f92f750078307768 b3058ef5033d87419fa84e44d9b84c6377a7eac75c7caf40a50c8569956762ad 3f69a2012b760d59ef754f2bb518cd2da91df49139ebc7bbd6f56475c6c7218f 7e7cd43c57198e7aa82647e26c707aa3ef2db5faf8a10c531943191b4ff26755 6ddaadd83bf81231f160b140b43b4d6d1a6eee4dbba5d34c84ef5b80bbc01118 e021e6b40b7f8e49f044a55e663f93d44d913a1af7d22c70368a011bdc336a56 728f70e4cf1b3585f987a7acc938ee7409c80bd5607ca09a9407f2ff5a3741a7 e2be9002acedd68ef355c5fee2f0e32763b5189b7a5d215e81fbe9ea4e640d3e 7e53f374f4033868c5aee94f7e2675b3721a9b0b0da81343aac02217c65590a1 3d734c62337d33dd09a4cf7e452d45f505bb6c553868713289c10b9c43d17323 d7fd0275afa71f0d7288b701e453f19a85865ec2fb06fd94e69a59a70f1ca1ca a196f505865b10d17eb3bfd88cc499102213f41ec85c8c5b520657a461f6cbe6 dcaebfa61499f7b0d5062fd7308e2837e4951479f44e5cc709c88a6f6d2086af 7992f050138c07da939ec7565cfd9f5ebac782e02d483397fabccb4517174f8e 10efbf8b1ed8b47556da3d0265c964380920cb8a04104b70344ef24ccb578c3d a44f9b9685654081a28ed49caa5cc7473a841d2ef62ff276c83de2872baf73fb 0c393162e62df7eb7ace99851b74c2cdb71122a95c725a13349bfa6ef3c5109b 043e98f793f4f2bb9daeade066b8bb9537bc3f21fecb2d71e0f847f4cf455cf7 e111759d772173f926078980e8ba46ba0ba3f6096c17c89e4d491348baab90ca e7de1ee94adbcae1e06dd9c5a8b84a14f96e93eabdcdcf2936ccaee0e6f63d68 97ccf7d148ea84aec57f512790a8690d06b3bdf4cc1bdc0c5a9166b17a4ebe34 2eff2058c3a9a685ddf1f1b69f886eea59e93e613620059454b2c1d23c4c1db9 6a09e3e688ea5124cec1222b331eefa0414fb7c64a1325737df41edddfdf4545 236a54154260db96d60ae4329d2339561dadabfba1b5442f58ca017deee834b8 61ba2112867932fbf5379225a495a10073a9440c9b084226009af2729306564d 358bb3d135215f13c139f2f186018af095f2653d5ec845d2b9917b6129e7abac b54acd8cacfbfedbbd99b3727aef8065b96ad7425400792eeb7f28d1d5c435ee bb3d6c1fbe927a4ea43c5228246399e35ab5013a8c838240a1dca59b75c58cc1 d9fc6040911806588ad5ace9bd5789391022a6a6bb9064cd1bc1d28812f8b02b f26ddeb62faf300b5b28d7d99e55195a4425dcbbf4c662bee216cfc6570f5756 ca57a4075c516254a5a3e10b233470cc87662636431a6c4d09a5e5c28f2912dc 39e73a5534983feac36778cd38dc96dc25a792b3d7971fc11e713fed6f244972 99f43f0ac981a747c2fea8b0cdb368ab3c133a7cfca2cc260c90bf451c4ffa2b 57d6b318e0b3166ac0c26a439f7e36c5520e259b2aec342fdfdb1c9dedd21d7b 1ede43d20fac37f9ce0e2c769fd7cbb4fe36d59c577524e5eac08fd1617b032a 9d4be187e2c1fafe63e5506100794af2fb67798213769fe123ee17fbdb3ab31c 1c2a83c074c120bcefa8f6847ddee70ddee80a61a558f35fb9b182f879ea8bbc cf72fc436b24dcd8f523256da0ce07bf00546bbd537fa83662a18ed852359865 d43248f73d9a6751aee68a9bdf284c39e926ea7e1c8c1f4fc23ed4606aaefba0 7816ab836ae9b03d6cda73ad339e123664e9a05b6f0275fb89309df0385284d0 fe677f401d776066099489815f2c0fc84fa6b615984e7bb9d59ba0cbc4149c3b dfb4d0dd4304d0d85fc4dbc1d0d23663f07d38733ec8a55e825f091483e68249 536f1bf58fa5d98fac1f6c8ddf16eb491bd03ec2d816de7505e861250cd9bc62 2aa1668d65348389d0bd7337f73223bb9ca04f0156832d59b81f7be1ec026acc 19f2020c0dd9fc6720c987177662c8d10cb524c385af41da5e9a8e14bd6633fa a886a6b2d34759ccda0c51bb802724782eb4c41ac2ca2abb799c5ac24b441e62 caffa3567ba2c79d422ed640c77dedb516cfb28e03a427c44354dce64233740a 56fded4f4fe9daecf67f1634fbaaa518c48408d8116dbc46c52075a03c46669e 297e4aec2f6cfb949e4010f23e851f5eb6c1f053c6f727e67526dde593b6edd4 5032ef548a8aa318a3c3dddb231756559da3e675347457b72adf29f389c9c352 e377bb8b5dc5b709b5756406ce4fc901edceb93739ea2459625bd83246d5ef45 1b023170c98ab00c2227fdbb69f88888dd2d1d3355483f31a6b9fb51d5aeff16 bf138e0b9f3eaa97cf0a634871dd8d763ba9907f1b56da397a8e753c63fdc56f 7b7ddc7b8b0319e4fb9cdd9e76d1e9e062b7624c4e5897692f24b968ee6db833 65711c05b3436c22e252c2c656de627915e372f7383f3dc72348a891d3d9b536 4ad145c6d742ff07f55d06770b86d1f5bf6645c7b1da87ad07e93a9b5d199a0e 43c8de46329b2d5fdf076476cc82247b1bf886e61f8daafc02bf754fa0b5a8b2 f2cd625da66a244ce94e95a6401c6a0192923c5290ded031eae4730708f21b8d 0835211a0ce0da370fc0019c160c11f59c5572d79d880259d6935197062b5812 24e6b3ccc232e97d3f8b14c4b43885111c6fe0053a121fd560ac054e5eed9dc1 c7a29ad1892f54b3409a3db17507027bcb407f1b47478233a18b0b7951ed8b4b da606fee35f1adb86cd387e38a409a75b010458e12433c6590ae1070f70eb758 0963d20b2589eae63e2905f06afe95408a020e01f8107abc4b424473ebf159db aa6a834f577d43d012d0b9add3bf5dd804f0f3a10e929169006f3707f24af39e 19c442fc9e4b868c112665a1f842545dcec023d76cffbdfde83afe77151550f9 966a7154bb887741e0f26f877453412827138b5fef595b79cc1555f3a58bbc29 1fc3bd3958b9f8387550119690738b2e54c006ce553ee8495c14faed6b72ee56 076ea415369aef990c1fa820bd1c07c2aecf534f90c748e81c7f2f73c588ff54 a0e63501eced2c9a65c1efb9052d0a99a4c93cd388d1731091a1102c9e34d0d9 d040542dc1b485f5ae5f8089e4d922fe1d68db7a1504c49d355cc4730159c6b5 326c94eac57fed1059d7be8251536074252066ad68dfa30970fac1e57b21805d ac8d374d14ef7f844d70b19287c8b3eb2647ae886c6e226081ab47c766798efb 5a1500e825995899a4c8e7e7a096a70f848fd179a57d4bd87f744c9d53be5c11 88134e9f29f58ba0d1e0038be5070032406c727edf7c87f4ee7e39ac32975bb1 1c840347fd8ee4f5de266e13ccffac3ffb83747ac369233d7ea216b17635b87a 99d5fc60c57a599830b2a8aebc850eeba0780831ab3de550ce8c7a1654345938 efcb8855b214096ca03635ee1457a4c731fc75a63684edba39cefe07da84f33e 9a15ee8172afe6141dcf316aeda37f26811279d01b0709a6d40deb124c571b1a 223ed097d97b048e3fc2ba3870e01f1187b1111dd07333591f88b56fac9a0988 4a71c763e741ad7c515a75077ce8b93f568c3575fcb6c8c0de9672156d753cba e7dbff8abe0593217c68bad73f1522d98b9945309906ccf00895008840eb6274 99e4523e782cbc85495d2cfe2d5ff91d52e1a97650906db3f2bb633fa356036f e9e0e949cbafaf0245a060a968022cc05d95144f77dbf305d834b4864333cf48 9a400d59c7e2046df39b1297a4af16355e9d0a0983d7aa1daca39cb983dda9a0 95460e203aae91421efb9fbfb74be4fc2b2520b33f9f441b0edb966758f188c4 6d995ab6bfbe2ca268f709246791bc7b3fc487c4fb6034e391de71bbebc8b6d1 b970986d229711bbd8ddddda16059f1e5ba2b99a64f9f24ee7e60c66e10a6f27 330b53652b394612c23a339e9eb2b7abaa340a8f86a9d4806882625ffce3654d 983dcb6bfd59e0ce69a96df9cbf02d2737a965f609566cf98a8e5ebdd606b836 5f9c4fee3523c486bba533c77ad7769e5b5d508691ae7c366b7cc34da030bad6 e932af65bde971fad3ed0769e00502a10025daae4d162465607dc77a98741515 a28c638da3fa656819556be0a4b49ca5f26a4393aec1859f6b1540f52ed24142 a30fb73106c9e07e881858ebc7e4e0104f626da8580c2cc4fcf69d3c4c78f704 6cfbd0a904dc955d0e7ac6a37f2d10cde76c3a8b5e792f088ac5edff28bc1a04 2c308bd9005547e722fb2e4f7b5c580df3578285dd47e4ad23fade2e614d92f5 2a7eb873a7b428e507b00a97e576ec58be62802aef21ea3c511837b64662532b e1d8e813d7f9ca0241afd84797bfbca16de95d1dd3620dea63cd803bd23e2c85 9db661599fae25bc3d516bf86af80d2baeb21b1122df6347dadc8ce1d963ccc5 1314e87c099e0af697ce547ca60edb9b148f52e305c678ba3974a76845608b79 cca918f2ba22b6cf71644be6f5b383c411b4bb94457978d2c51517804dc67bc1 272ed04b547fba0bf1017caebb525847e31bb6aab4327815830c8d91ea99f495 88c1792efaba0b3620822a1bd9e34d759c74c32442ec74a88ed7e6a8b0d93e69 dc613e6ae4df2068eba2da52aca51e0ed65f15450b32568afdb2d2eb1666a63b 7282e9a3f7ed63d80133908341e57b94863f079229b7e2241af839f55ef987a7 7c51cb827e610d52117ac38fbe884d07fc3bdd7f765edc1d19c204733bd7e68f ac43dd024457c739370439483ebe067dd4743047f9a2626d3a45969c0d09e4bc b089165e69aac5c20f4cffa27abc37199b2539a1e22e4ea950803879019d9f95 9b1583e11af3e97f85e5bbe9a3b2685ac424d259dfcdad36895635f620d7a879 87c469be9027a14e1e5c99ff210ecb8277d98cc1b83f613c70a2f45127cf2797 6762a1b09d224c31aab631f59e91c0f0f363817aafe6af13c3b34f678e6b8b7a abda8b9ad0c3a239f964dbe03756f8f7a1c918566cb6661727df60688ed05c06 72ba5a4f54f66aa8c79d77626728b4783d93943753ec14bfac8b0da337c32d6c 80b6b67f8b610d58abc67b2e45f4d428952a0fb81afd53839ebaf51fddb0acce 74164914fed99e09197ea6a4672ca5cd57dd24aaee78cedcd73fc340dc102747 09b969d05354f0412cdb458d3e298f100bf64feac0a1c16c35b1e4ce2fc585f2 7bf2422ae3881ac818e8eeb06e5a130f5384bddcba21adf5995c0cc7a806b83b 550e4bd8be7a08cd31d666ca683b4b11f35878cd9b014230a788156b717783f0 abc2d8c55184cca7c8af6611e675e225ba8335d63272a1cc82cd8a2d1f25c879 ff2c749fd4da08fdbaf0cea2e3322d2d0a2b3aeda0fd873e929d7c917198799b 194b32c697046199150f524fd972f8d7b47de389b632355fa7027060f27f952d a41fac2c6e6d8c1ea5b2c1c57e05f4e440d9cbe126473fd366af4cfe6d1cc8b4 75071502a7a3570fa3f7c3e0208dd8fe0fc697267bb6f3ee4a8a56e3ca45aea4 c9116b665cd7d4d466a857286e9db1ceca064cf933f13a6f7e02be2283cc96a2 54d09f623b3371f524f75e0486bef47354434a74b94620f1cc47ad856b73f067 895e8e65ac2dad8d1d64bd9eb90cf7165fd882a2d8c395d8a777a6e26f2c352f ee470b87ff43451b2360ca01a23cab0ad890132a24853a401e4eff70d3d49e4c 37785535b1c5966c748aa2df6d5060ab776d88999a20acfa3150692e2554a2aa 496198930a1423c58b4c11959ffc118edb7eab3fcf9b5351217f5f19825c9a05 50d3ed17dc8ed223086f1cd9a37e1b89a3acffa528a98ee31cc12c1a35e2c6ef d534a5c30ea86f05ec2b2c07c6dafe2ff20086e5e550fe62aa7d35218bfe68eb aec93dda5b1bdf14131976e5a97a808a8802b68e40588f3723f5d9bcf9b889f3 c41cdfe43a52039cb24cbac6fe1e86489a637e39586f604134d57c64037f1136 a446e2da2fe056043ad71ef5e17a4c3bdde0e533a170a3449a293354424b4a72 c469814eea2158326c1a98451475d1df741a7a28c49ea1be2dfc8683f436dd18 e35ca754c8c4c2d4d7c4846f9d3222e50620028c168375ed4ad9f77678aada98 5e186e80ba56fb5f62c9755e1461f45ef46ba0ee8d4db59845c8876466a05355 9feffdc11c880871b4506f84a5fcd9c8cf84012bd2671f14cf34e26732edca0f 7864819c00fae356784b4bad8bab79e1d0544ea8dbdf7c588da150190da6d118 e18f578a9e56bcdc8f0886cdf06da000e4319e3fc4fd78243b9f6d384591b1f5 79923d8b5674bb5e33325bd2168a6deabe1451e81abea48d6431595d101344b9 73cb2de48607767835b4e70df88008a0f8c0ea6deabf9507ac6cce6e1fe11647 9da1ef4774b0b9ba1d6e2c93654f4fd811dc6e025de1d3e69c839b377846f01b ac076bdcf318d0f2e5cabc8b405c399010d1de5929fab7e1c43588d859d47819 6705355320b63252f8fd22a5cf1536c13c57f4690d24b8594fd1c1dd94ec92a9 f169c24022cb8492672c090b3019b18d66aaa623f60584360bcb201bdaf38ccc d0a41379c2031a89fde2c1e22dd4798d11c9b3744671b0006fb22c4bf533ee6e efd563590b7c48f1ef61dc398288225d8d87b091cd23b6315ecb9ad46ee3eed0 017e3324e1be05cb6bc3ffb6d021d0ae025a1ba34918d346c4690bddda65ebbf 8afb72183e28a105756a665edeba8a2b1efebd800605b365852e5254594419c5 27da7c07fb5cd331e785a03184a8aa2f6bb5e082a10072afc3c0d990c99c292a 1a6df3070fe83c3e0130b686b9c7af64fb08bff33b067e80aaf228d21f8e9e8d 28a01d55b2aec1d5c24d4ba05861925fff3f11e75c6e02303797af14df752145 857055d79792a281c125747b1593c98860793200ec2f193d1ebb332066515947 cd40303673936c9311085ff8100241d9f24bb52adf1bcbe67fac3f303da5f1c8 ff046082abe3af7790e17967627c0255bcb39440c4431a080b7bb318bcc8eae8 56de252d31bbdd0871c97ac046e755ef71f632206f329aaaf39039b24085dedb 48ba0f66a4ac1678dda036704b160ea6598831d00402851b9db7a4b2bdd270bf afb69a03d6608ce9d7041a3c053ecd5e22e12114a94059f7676c6cbc5c5d5143 66576252e688547af4fc340c8a5353a482c82531b9b54ea13c39a4e8e4dbab0b 84d7a36383253410a41ab0ed97ea387ba746bd711d776f16054db1e02ddcb9e9 2025c34b2a3c40ade46142403db4c61dd657275d28ab789ebf2073e7074cda0b 735805b1b92d6fedabec7237731ff9e5023809e575c32efccd07082bd7f91598 94b0908113889cd58df4e39f78d2e87ebdc2b48b2d022f5905986546d6cdc1e8 9a4f0d3d81bde0dc6ae96146a5fb9f1783c934222d6a9b7cd5096ecb5e640421 61257098404ce32b3bf3885bb17efaa4fecf42958c3c9ff2d9f41a166645f749 cb8c5d1c7a276270b94f6d81cf85e2776cdac1fc911ae7fa234959b1dfb5c02a 9de4f554edffff9287dc84e5de01299281865b00f46c3614f402e1ee83dad884 35f79d30bc8a5617170f96dd704385f91af0967175df231a749473e752477300 4cee2706e566d86595446ae7bb0d47286cee19d00be2b8e8e29c3322fcb7c379 f8636608dc16a5c0c27937bb1c88de8e03e322b0e70233b8a442ec07ba5b1f2f 18c3a1bebfc7fc350d4bb08f189b7c5c3d16109083fd6f0e80b2327b2223f2a7 46c61cbf074fb09fc6fab281550b5ecc628efe859240fb7513565c9d6f1a79d9 1f89f57ae54b17d0d00a46e87a521e9d0a2f6fd35d4e0cb845fa90a5482c7264 11b0a065a5ebdf30162e034625000c7f534893a8fc365d78b1065137489e52e8 c3dca1c5dd70d5832d7599844fd4a5d0aeb0efb52666064724aff12edd3bd783 43ee809371d337102afbb539da5ac83b0023619da4a079935e385c9f81f39b49 a0b979ad514defe78d3dee63917a1b063fe2d0fdaa15a5161ef7a6962afafbf3 d5f6445884ed55b72f17eaadee864746a17df29bf16ea32a4606b5829511b80c 1a862a47f2002c41f5978a4fab517a4424e02a1f54ff988227f9f8e20c57cdac 0bae20d26a4285c2c5fdbf37627fbf1b033daaf9513fac9c31b1a33b95dbc2a4 85a1450071d78fdfa8d79dd593298eea7606496fe350291163800ae167778f24 1a5e5379fe4c621c21d43de42799ee8483d5a8433e317e2634de268388eee063 ddb017b08ad40ed5dab8d58f241de56973732cddf0ed5c8ca521e2ba0572a9e5 e1b750a7775d93b261506e89eaa0e0edaecd154ca92b0a874e2a2d5b8bd80d05 55b481c2b99c415e4ef662fe8226e2b82cfd16c0c3d29121515cc4f54096f996 8753432dd68b0a4a4cd048b7bb04b97bf0ec5004af010881126667eeb97b155d 1de90455d397177d8cf8af79b82e90c692826ca2704756a35edf3d2a9e856a0b 6f4bf7025e80db4fb13aeca40a7bf5b98903d734cb62fbfa080bff159413e849 ad0d333ae8f03e77ab00b82199dd3ea3362957c1b4c9e8f8c55465b92a8e4c5f a62f0cebdbb2bbfa3457a919b2af1f8cbdcc47006e32fabbc58c33647bb60052 64544482523a490a0c186ad68759d7a4f81f5a34e3867a8ab01e97161856ddd2 bb7b4351d626a310842a98db927c78756c7e3528d6ead47dd0a53e9b3cb5608a 8511c77c47b9c8236f301f42b755d86058fe027013c89d953b59629f9cbeb657 d4573b1523ccc8055c3f52e1682b20c5249ef8b3c95ecbb5b9cb5998ed436c0c b90b09fbb21e59fefd27502caf1c252f5857d08b896fa718f536038f259747f0 423d81f2a66d9c80435c78ed7139b2e29de138772b466e6821cc7b53c9332af3 8f23932a147965a329b9fb612d87da528aa3547892797221a97c67d71ade0235 5d6b1941e5806b0e22a5e757def5c851e1929961ab0a95e442af653991387721 4710f9eaa13b2fb146942ac301b35ab39b459ffda925acc8837f2818d47037a2 15640c1c67985fa7745bef3e6e5cb49797b4ad3a7b9c1bd450ab6b5f9a6ed0bf 44ac379618a6cca7ae90fec328161fd89c322ad819032b904d1108f27fd037fa e0836cfbea800eea1091e19248853a5af4762f7cdb43bb51d18e4e815eda18be 7efa686291aa701031a5fbb76bf012278f0d0eef4f071909693f257cff52903d 8b8b33fe249adc3835a749f584a15f0731075570442dec515930f9e7f4c48d65 bf0889044e9819ab02976b71ab8cbf7b6c1df9a3afad53c3a2a12220ffd7157e 902b0b45e02db09ea2cfbec810b6eaed44bcbb0ba1cb0f2c925ede90ee5c9210 0ad9f5d544421badc1eb602f5cbcb19309a877a25977afa8bd64d9cd5ec42274 3276d8979e4ebd1a1c199d169a05c9bd911b4ac260821855d8ce7e8fae1065b9 2b5f5d8aecfa7a13cf7c49dd3698fb150c7ecacb1cf023a5385c8ec345547248 87b6ceaef5aee5bd6c1eaf534c09ffab957e7014ec9b54239ef23ce9c23aed48 8af9eaffb025d7d2b555240c869bfc9a854d0a260d5aa0686ba075029296600e ae4a7a3ac36a5159e14807c0aa486da94dceddb2fc79a3a15e6c131130190e79 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 false +check_ring_signature a7cc78fa4282c040d0a2dbfb57226ce23068b613d7406e348fc8ec2cadb74313 70ac45ebefaaa3328bc0f6e38520c89ebe7b41393705be8bf6de064f6cc59c08 6 219440969ad536be75a8d8637f411cc5ed0f0533db103a91511a669b4a17dd16 80fb0abf12712d12b6be6ec7206a6c7c360be2a1558f01ebc13ba50f00a491e5 e2addfa521a313a0ae3ba294a4b941b60de51350b1c913cd8bae3075e8ba037c 832bd63cab00523e5c835efe508b2030af9ec9352c4f1a0cd0a76d5b3f35fd76 666f17937b6c312b0890bb2f6245a1f45954601c2b4c285e9836abc8957076c9 b0aae005d403a490ab4e7268981cb90cfa6177f3463435564e39f01ea545d941 76a743747681736855ad78102b88f29d38cae409223b1fb7266995a9ebcf1b0421e7b9babd3ce5f7c35eca29a1bb7aae21d599ad6d997e5350b2e85f62f37fef354a8969c49c2baac2bf577b438e516f6ff563a25e6c59bf5683978370f4c208b2e7e6c6be92959122570a10e5367524370f1047f79aeead58a729a18d5bef088ae5811b3f04f82abdd1b62d977cb8b557071067edce6ea19e79335136faf4028799be54f90a89f260c3ec63f2743b10782de0d48115a9b8330235a54cbe230a86ff9de09bc954f7ec26c3a0388dfa0e458abc0b8e32a88e5ea33c0cf2c15502c65a129d26818ca49a345a05ffcfa5a00e0b63a580cafdecb07085415646bb07146b43488384fdeee84af641723aee7249d1bd82b37d32cbd4a5b23a0992a200d969a0c21686c9417a85a2dba5fee995d8b58f4f006cdd4ab111ee8d18a2af0233d04ddfc2b0a1b4bd18f16f634eda78fc29b934d56da457190a3d929dc34d086d4a8f687ee63030244151f82edbebb2eac8c7aacfd53dc2b9600ea895276e09 false +check_ring_signature 2aaf43339bbe646ac5905fa6ab64b672a3409dfcaac13f665ef361747c67c6ea 4f352329ebfb0750d34da3512a56678959d04ddf6ab4ab1259516e648df37f8b 19 8d5bec4d9b72eba1bbe9971865b203c4eb89032f92c556be2382c21eb881175b 6b512b3c7c3e5201718a22de9e011fd783d0a893f4c39aa8b752190adfce447d 39596139574df631c05238af4ac3d26b92c24100f47e3ef084c8f2cd945e3cdd d134b455b53f0a7687ea11a208556b78ddc67038a04b445cce3bf2675a48f745 41da3b5175a51235010a87eda15b7a840bb1abcf663bd652716a3d210d014858 2957dca81e25fec2d8da0df056bfb7c093b1949cf54e576ffbfb114c6d451b03 16e6030b57c6695879d1a199d65c0423c2ceddb03e59461b60ce3a1938b11eec 89d47f7777ec8ef8c8b578bf435b14b748167074d0e292843fc44b5d855377cd 62facb477d9b7c2c00cc6720304dd56bd9d779b3b549cc88bf80998bfc3e2000 4556bd9a5a0be94f01521be7a5abad168a30331e6f8ce747f0701a17ce9009a1 45891c971a48d07a1b744420fb0d5c28682846e577f436e2e6d7bc77315f231d a5a17acb6ca6457e24e00b52e93d9a58d2d0f2352ad036e87cd7cba39f6de386 0a22f334dc54b21cf1486d20e725dd1f9e139b9d926037321cae4dee82bece7e 07fea04e460d16735b14fcdcbb9283289e75926be09d89d8d6164e00fe7e0a4a b593e54fdc9cc3cc543a7fc41661d5d5cbc31e3ab2677b59ae3d32efa09ec54a 50d2a2f0749b50715268bbdc12c196ac9f051cf9f892198703081e7e6451203f 88dfb15eb0507fbf44f9a65e215f32233cd9a8fcf0b60978973fa9a41e79a311 18e34f29ff036df567f2ec239709fb6361d56c221433cf2aab96347e60659367 0814f2e6dfb4be046c4c5658e7b778cb36ccda0b35866f30ba37edc10c3e6c6d 9c7b2de40bde1efa7832264e0613bc21deb29ecf4aa5a8b54bf5317214468b02eec35dedef2e6473b0c7871bc877a40d1ac6a6a28828286e242037b7cf3aff063bb6276f57da079b5f5b5f875a909dc4ac6ad5d41be5943c54b317825f301601555a1bfe25211e76550df138191b5a8acd18256647944446ea1ecbc476bcd50fa6238895e56845950dcd4e1e5cea4cca4161bba7081d396654ae55d6ee5e33043a70943f155f8370218284949481ec13e7f7ccbb74da4c4928b43c90f612f50f5b23ddb37adba1cc48fbfe07bc8900a518cfe9360d001cbfd367bf2f8dc4ce0d07941478c280eb4faf34724b3ca17060261e77bb91922b50450f5c32b0285f0a77480a03f242ef5271723a2eeeffc6c620bd1e8e173415923e6a1a1c0dbb8d096c480a571ae721fd0a301f979d987d94b93bd5c9ae6f2f90568547e1190665028419ab68c238b61ae1dd89898ca6d6321eabee83e9f7a6298e5576f8d6544f01b704ecc1f1960c08938b1675bbf7efbe5fd194fb593b01f0a58da47030e91c02f516a4a761c3aa210ab1379caa932e41cc39625bada8b8c784cf371772831c0d67e5b0bc2706a4ddca53c0da0c0b5a25dbd13625bb2a2ea52ee41a5b35b88b0eee84fc4db4509762507d2b92a677b6a0b3600393afa93bc396cfdf9517505d0f033a78a3ce48264224c1c5b29c81b389b76a669f6aa51fed2345a23633f3a00c001d06c0cfb238c0edc0e15de725afc1aeab5818ee105e0126561ad446b02e08008ce722b9227e89aecf682109cdf772254b8dbe29aa8b608032fa19954a49061289b3d8f8708e81350afc6be70084bf44273e3241b28a86f141c1d648a73d05a0bf4f2d6795624c6b8c4d346464968bcfd1eb8f775229ee06e308842621cd0daba825d3eeb142199bdc91422541ee7d6caddd749fdad60f7500794fbae224018ce70cde4460f01f95708424266978a096e1dfe490dab5dc6557638ac9648106ecd32ebe11006a2d4b99b2045b9307995268835e81eb0fb09bb3e66075e8590e4445a6d77ae6f6de6bef8aa1244a725604d63b672c9a96a0c37b2537726cee0ae722acad4501a3c4704a5e0860c360ed7a8205336f6520e7e49909b61b254f027d327d876623c81dd82c21f9d839eab9f3170cf5f32fd0f39aa147744cd273053c08055b9db83b2743443e0ed8ea31da061661bad3e09fd75752f7f2b77e950a0fae4dd12a4805b0ac692f86484b056f17f291d7b9f75f5b0eed70f419e3ef02b69f258235cb93e03f3fa078eae8d9032d6cbf7eef766eff5102d80da5006d0720f8491ced979fe26236e0dc96791ace0aab62d0ae65171a166ba184875b91039fe51391b9883337a6170eda6dd565b63ed9ac8a1f01f5be828caff07b9d1c00ef579a31e4770d6386ef100b92c331c13334c08136f60b89fc40d927a4b85e02392c2712ff813ce00aefa5cae1f7b57206a4a493488ac792b69ac0ed8a2dcf04c05173a6a73e63ff4d83e897291583ebf36869c33620fc1faf93de4f32e8f30a90cc216dab618482113d4f1188a15edb611a0e12d87d535e100741104d081c09641fe9df5598dd8de7a87f9644703391b8c2a6eb6a04a268748ee7af72745b029b4dd9be9b12d7ea6d40f741e379655524a7f0d9b0c0aaab242a7bcf400651031f979991442e26d82e7a31c77ab9224065446fad06b15d11f5c9a20ccdf5ac0e true +check_ring_signature 4434b232e684f1f4f9bd1b6cd2901d594394f0d790ef6ef9016cda47e95199c8 4e4f8cb063f3dd92c10a7a389707ee9a0772f6f51daf3fc2e047545ef8a13b93 7 61ef95daa628eb82c2ac04a63af84af01272d33c5aeca2656c2044c622a754e6 6e69ba8de7c50530e076eeb400146325eafa376f30990baee93f2d8bb094c030 96e30c430805eb2af8ff4db76a9122d5ba489028edcef2ede897ff58d0a613bd 7067b5c4ed4e100905580c61cf0b41fb80fe70086dce7b421806ab2fa2ecb2b7 bd1fb3844be91852b99acd0706317f55f01532a66d0205abf8d5fe2a9482a25f 6426f4daa3e7edbcfc8bab4304829f9e406ffeb21c41498001f2c68345f9c996 1c4426740d533c005a51d72d7e32f8a4b0f3cb48cf72e4fee9b34a40d1fe9450 d4fff1ef2f43b36fb459b060a069308dd8e19bce8fad0906f80b39ec27f8290fc48b961c53b6592d3e2580510330c5af6125a1f345a5fec3f184276dee6ca90c57e271f986ae1a71f9db7a2e4ed4b81919f1616345614a7f14341bde68c07b005d7f6c9013a0d73c57233953203f8ecc078ea91c695fdc5860af4118677d6b02ca25bfd3112608f6a200601bd5538edd37cae8632b279e0124c9c39d8394c507a8a83df5fcb3033b1219eec73459e2b0508b5dfd65c344f1b566ae94763ab7078e4f5e0439e1e626be4ef6ece29d07da305f32fa5bf23e7f44e4427eb2d3ce0edc635e62f47d126617d1250b5f02e2efdcdd565c33938667d5d0d7772dafed0b801f2818af6c57d44b7ffdbe48466d29870c43e76dabee297b7b6c77624fd405d39db44817de3ca8659a6deec934b64c017874bd9bd48943ddb969ebbd80c309f56ed67e8fe7c03116246ae74a25ad7b2d5d8c1ec1918fd73b899fa280a7be091c89c7ed660d9e58bf3703775bd69add62ce071377399525875990a626bf5a0465275f8e47b78f6a1143e7a71f9e8ce464d7d523dcbb3c40bb4fabdc79305306509357208465f7c6682afd34561ec98e28ea139f62059bead6869e243ff29300 false +check_ring_signature 41b06964198374fdcb809d0f8ac649f881fca048d8ee804b19986cbdc86f5bac 7b0dd38dfe85e21c01f22f9a831868d484c70281ece045d1ac00d8e749968e49 3 074db09f9169870f2819778c146756ca3b17cc112b068ba711cd6e549b9eb2e7 3ae201490ffb3d5640f6136cf93bf1029a50d080365530f41825c320136557cf 3dccea3b2fea49c2ca0f078d228f2c595c745af515cf46fd921e1b220ad58ccd e00c073c229654d8db0ca690b8d906529ab2f0bbb78ebb59e2104aba8c1e690867aa9b5afa3a9b8d953bfe050c169dde85d828944de4167cf87596aa98273708d4406bfc6ff8a843efeeb96cabe6023acf0094c181b9dbce62701cbcb868b6041cb6717fdda9365cc1bfd4937b7cf5ab0c26d5b69054d681142426b04a98190f200df5cce8e82569b13d0885dd1e6a0616ffdb7324ad1df2509265f449c97f0c4fbd27d5232b2482c80806d94e1ce5a4089093513ae321bcd5a363bcf6b4160b false +check_ring_signature 6ab5deccb70627d1d56749fe409d1ae6b06a94c36b4cb90d047883c07c035db3 820298cb23aff8136a4c3110d4a62ffbb26c405828671822d8783d394faf953f 1 d37cc0d63e33df200ddff7a452ef303c3d89da65aeb9ff6204bcbc952389c7f9 46cf85e3c436f122dd465f9bd767f4d4c622cf6c41ff7c6a532b5b4d9a83450bcb85820e3ad988c1045bb5b8550788214447889787135d9221e0fd635bb9b229 false +check_ring_signature 5689749ed97379fff416c74c6d4ac519b8e18bb7360b2fe2b9c3631622c7c444 7750dbcbf1fee5b6fb383c7b8216474a473c21e765e96bbc90b198f75bc257f6 2 6be314d485b966669f73e5b90f014df04f9cad69a872cbaf0cb9575ac7a2ab65 918b061d98967514409d7bdee17647b48c234f75f33dcd2b95f320a594077619 7d64011154d8cf2296a489d648979563b49c900e3f73bb8b80ba8ceaa0d7ee0ef744c1cee7df1878eacd0cb863bb092e135490cb30099c903a09e26289c31903f7effb8b811c224008761535e7beb547917ad6337f78a47a4dbb648d07bce90b689bc3e5cf88e8b031c6d415af56a4b918b26b19a57ef49d491529a5ac968b98 false +check_ring_signature 2143db363ec5a298f506af5f945ea58979dbdd42b0312c5c7a81d0812ef22be8 5c58619c065b9f0f6b8f54d978a7089941518741c33028fa5bdfba74cf0289c9 29 aa1ce7a9be065a281e30085f2a9912b0909e94c19cdd3e7b2bee65b2b0e52fd7 2734d284343d304d1d6b96d8e589aac1296a210851de3752d0bc7736896848c8 830ac8ca4b3c04512cc7494e1cf596acbab0303adc731376ebd4ee2ed29bc9de 639aefa7494759afe2f08aad2036fe98006940e6128a449aa1cfe1b342e656a6 ef71a1c6a8f2c1cd57dfec1bef4cb4dcbd78f3bd34889e51e0a71ecdcf23987d 62c18984ed2feaf1c41e8114fdacac75e7b1492e02f05b67f8ec641a304dbe62 8b4f82243529083d2a2e4afefc97ea415ccbd9fe7ccedd8d5f32b99ef79b506d ebe1a6525deb8cb44476b240371675a97cfd7442f9926107ee2cc11b9b1e94e2 59e3126418d2e34ea0fbdf1d1b3bca4d01b06de3f173aa36302e6d34f4805d4c fe5b8c872a3ed043ce2687bba0d0a5c1dc2859a1a9910d58276e4702468e57bc a29f317ced05e19c8f596a71f4c56a19224bd7749de22a69795e1cb3289e7b32 a9472cacc2fc78dc73bf92553352be8ab7d5b327039f1ef8b262027ae4e7832e edd0fea1ebac323b7b18f03a3b207f63e1e5d51d6744719c0e213ec794c5308b b1362d6cd74b1e49775edce8eaf71172f89699fa1f0ba18012cc008441169a9c 75de0d63e031fe6c61f592f705298a67477fe05f5aa6d86bd03f58d3a12ab613 97a36b4e3e8ae9cd542304f5f22fbdf0047b0c77852d327057a9ad06d873eb9c 96ec04e16cf7d73def9fbb695a23384a962fdcd9d780d87f79af58d24f6c3c96 0d2c2929d7751211cfb02f0301c9f0fec6400aad7750310955ed1c90f509bb1d 76c933b5ebaf0db69414c5ec30095a76bd4748417aec2ad22ea8f78f95a204b3 043113e729104841bd96b7476086a7a72d78a4ac47a0ee07be914192c9e1fcfc abf99d7dcf897e46e733360166857e8bf0e04db2cfe6970a3281addc53c46f1c 8c1619387e696be38e59c120b71e937d40558c9afad9924ae3ec370a17fd4fa2 ef5ec4b4c1f16874f215e20fca33cd15fd240e9812243c1c5715b4485f2690d4 41dacd7d5440dae2cd455c9e115e7a0e7c3c85730b698990d5c5c33eb28c9774 2439db0e11d5699ecad4c49e4c2ab86212d643d05777170611d8853f4e56900b e542734c9229873c176e0d399415f09f4a8ecd2d65ac2a175647dfffbf422e84 04bf6b40b130a630b8ea7d41d414f2978d83796c2f2dd2394864f1cec625cda8 46e7d21d166de0347c04a02ee12b3dc2dc924bd2459190e4beab6f7b0f409335 6043242708cd2b81b274fdb6a4ce975faf8ee5eee984842e77418b47929faca5 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 false +check_ring_signature db30eca5ea00bc3539146a87594f37843c3adad86fb0b46f29c5ba470d14ac30 a18b401dc49b7f85afc2268f85908257dafef6b14a80818b54005d13244deb06 166 a67085106b1d0500cec03b3073d4c219c11c40a3d8afda2e11e709da3dca4b6e b65ba10d827c282f3040c3f50413bea2e6fef3e64effb251679fc520b7f3ff03 c188fd1af0137dce6146913f9ea675f52f591f1986aa6fe257e29edc01ffcfef 8a28ad8a5c0b323edca81e51c9193d3890dfed9cf9a98179f1161bba4ee74c44 2420b9b7e9d7bc0ddfac00d97e0b3a695a2bcac98969991ac3977ed757cde839 75fdc41c785cc3233905292c35d0062d4c4a3dbaf4f7059a74a9d9bcd422883b b6f14c14ee6bf14425007bfe1356ce6a7ac526fd499ec72114df34543a43ee85 88d4ff189bc5f9547cba0f975c69d3b577b4f5a7f75f3b18c15b765c6af61a31 78fefcb419549f17925545a8d69b56e65afe1cfede60473dfd1a2e28a873eec4 36d95bbd9f0a263a735ab21883def96f46142f0aa7c07563db31e23e4585214e 72f908836a12625afa4f0794970bc0ab2d47a62cb7529581228e51cd8ed9010a 5575f5bf07e1cfc28b61a31b3bcab157593947888a4277d3eb92a24eb1eb6481 80d6edd48220b40945807720f7422f8ae9e20714ec9ca3b75fce78c03e970922 b2d8ee8d7a9c1dee51734abfa1cd581ff54afff8a83ce3cda40e6ff81551547a 990a20310a97440727c7255c585d61fa43b9f2ea375f107c2f96c3e9d00988ec 35c2814b52736f05d2a92a0434cc9840796609a1b049ec222bf95581ac48dcc7 f039034ab869b5d10e304a105ac8e5d2332846baa3f9ec87b16c78407f40b1c9 4df051c6140a755d27fadd9e01ea95eb251542fcaad42a1999e6512f6fab9051 009abb71aab637fc2735032915b98e7bc75461fa162d68821d7328f9d9f35a18 712bf1bab4c9b05e19dfc73928958b73b6267426a1a50702a78872e0113e526d b7a82115e63b2a5910eb7c78ca783e5c53e66e6d1be8dbc1b8566cc34a86ea18 bfe6f456cf79a07720f99d29c3203fe6eee64911745f81aad26e58c4495869f3 3e4cdc12ada7fd36d4d9b01e25fdb2c6a09a2d7c8f5cae43138ec5eac060ad1a 255c3c28d635edfe952245fa6528aefde8c61fbc5524eaed90a649d83e20345c e053a61c0438927e1e3de65cf4c34d6adb843237f667bcbd15a0e1c3741d1e35 902ff3521d6a240deca5ffa7393eab9de423f76f2bb6c2a943a62356fefc46d2 1bef01cdc0e086135f73877685e38ef29ca75b5a22c49cad063845b083aca87c a0b060bd49fbf582e9d8fde88ff9a31a3a99ec06987d46e3341ada8a4197d207 d424703c8aaf2742a9bcdffa696e66506f096f7d954e0c9daa44456432da5147 d96d15ce6110c63a835c51b36339b38c2e7796b607ee7fcde4586946356ac285 e097735c3f016c051979d502a2798dfe53b07ad4ddda6952c9e9a8f9a6d20442 ace0c235bb52fb8f05d173a9d2fa6391d6b90406772a6b9b7f49bfeece6e3f69 37696bf75f59caae537822b9f3e7032941881a8b8da963c9e1792c73c28624f8 90199a5d4131c8231a7c2dc8d6b04d4658feee367fb9c557bdc3855df2f6671f 47b9f55c734f06b97e6fc43d60db61abd440cc8f8034568a0639dc035e9c5e50 7149ccf00b341b72f521aba18106454638954727336e332257ea659035393980 281ac386fb4379a25449a0f8414a8a878cab5f715b95f93d8d93714c17c2df68 3e18b852bb6c97e9bb2eb43669f817d245067734b8c255ca5720fce9d91d2e19 b13ebcf6b9c2eda5aedeb8b416428bf80479728f6f0ce79b4cbe3baf4001f887 0455a7e089e82062f2d0aba322c6084de4eac9ae800ae3c45b86911ce72109f3 3a756fc2d5d54eedf96ec52ed9eded5f644efb64ca05d15d9b8a299cdcf63328 f0231a4d9b6caf4fe946e177d2cba1be1690cd2d5cf33ea959448670ad37be13 978c1471468d780eddc3d5936da2532cfbe9162cab3edbd1b76ebe7927ec38d2 9eaddae19d7131d298887815d7909d782a8e9834117395bd99e7b6dce9e69790 00bc800711f3ee4761f80e9c3d6c345be7232d243182b42a2f22180b0faaccea 794c2fef788fea6c7440e174c5faa1948bf06ac7e94824c920b7c875c515c279 b71a827dee1ea4e2051d9d545ca1a7064f888b6d7a7195d11ec854580caeeb0c 652bb9abc9f85405925a10efb6a5b8377ea8e8d6986312f1ea107ffcd464602c 414256bfd335cb0041156b3a6070a2707657a684b02eccbc9067422890f46c39 2ffb297359d244ca41cfe14b806877f875fb3adf7f731176cbcc7a4460359d8f c72fd1d12e5d04550ed678234f6afb1d521b02d3bfe4a8fcbd8ed1de991bc8c2 a607ece31100a140e9e0f4b63953a2f8221869a0299ead7c2a39b812a8321a3a 043e9d4173d20a21c5e59561916fe3fc2ba729b1d7bf4d57c5fa1391215d02fa 72deb014b8b250db90fd02030124b203d5aa6eb235eb42ef04c194ebbf05aa86 c8303399cf24fac2187e2c6408277a9173a894d2cb80e39af5093607b2846520 002050c149c4e7b6ce5f83549e446d9da03ad1738db8dca8c6ab3b3832158c24 db6b96b788b40d53f8d85f4a7dfb9bfeea6d55dcff6438fc644113a0a893f6f7 3e9dfc980ad7056da966d32e186ca449d62e890b1c4c31d2e66c37704e1840f4 854b3992a1e8afc40abd61227d4e321fbd99ae17dfceb4a3c1ada0a72fa09c0e 6deedfef7e20a06837ef4885d95d3c453b82dc2674041806dc8299ce2308e9b2 30e5757df447add32a6d8516a5510b6c58c1a53ef62111b1a3c0561eb9603954 ddc40ef5332ae78a9bdeac2bc20f2fc479c4becc490616cd629537381b1c3dd3 c9a62d12e53d78b49f339cf76394d0c0b1c48e977f8a34c6f8f1921b9c2d6c5d ea25b076dcfa16128b32d19eda9c2c3ca898347f301324e53871bed11d65c057 6358a3e7b14b13f9d845173eac8bdbb1f90615a2df46bbc734f75158bd1e8e5f 93e34fbe0c1ce510d289a808493d7fed8d9737a29bf8b908ecd811650609084e 8072b3427256daaa81b352793585d2ceac81254463adf2d6257fe4ad089e7dbe ea753015e00281309587f9baeda452e168b561289726a154ff0c0e01704326b9 e20f3102ae0dab9a60291ee43d90764b57857743cc269bd31befc9057815be21 28d01f1d3090e122e16736368a7a1159ab8e74d6c930ad21e59058914132e25e 923004f7ace870bf830e31999bfde81cddeb079cc4a0a0f6b73f955386b1d7f3 061777b1d92986db1260e9466c9ce32dd8ce09cc3797ef4afe8563f4813109f2 44947b6a652d9ae536938be4c46e7c46d8d7c96025316fd8a263166c21662a22 422d624de3d44ffe4cdd2cc12ab65358b8f3c7a6049bd2254f5766db1a1d98bc fa80717fe19119954f0a11b66c9e58c922f055639544daeb626646e2ff0c803f bb1c33fab4c88cecd9360a19f1fc2edb94e42c6ef24fb53ab30f010924aed0da cd98a8dbe67e54f9cb65dc06dc2b4f0513c85bf9011943637026182ae7243c59 740a659ccf48e7dd901b18215582366be37e9bce054dbcc39c0cc731f82eaa6b 8e0cad9583af9d3479671badd2e710f5477cdad7cc73e2cb861aa67a097c3790 d16933ea6756815179e44caef3a6930e15cbef789a0c79ac9b80fa224037c37f fc588b85e7b5c55cc5cb794a768c946f1583812973a29df5d06856108b482136 ac7e853c28a733671e231bd3f682d785ea17b2de9f8131ee6355e0e13096a276 021a2a1450e4c6bd1f6df084f432b8802f52a85d853ee8843a13ff4eeff28dfb b2ce7b4554da818d78c502f53a9b9693efadf1ee853d1d0cd3b6f742997a2094 d6633a248d421192ae77c3630ff8f7d9875857afd2725ad97c688b3c41a729fc e13d3d1705ed264a1e2f9d2f026b14a89412161be5f0fba403d9edd279e52c80 050857517be24cb822dec716a7ba07b8ff47dc67e6233ab96ad97464922536ee 5b0caf896a6c4ffbbc012265186a91cfdfd431d60242a8b976dd46b62db5171d 0e15dcb8263ef6f065255860a3ac97d1c50e47f9ae5d74d9ac365e1855d22db4 8ed8a94e2fbd76a1d07e3f65a18b6725ca088cabcaa19f014aa2e512aa1098e8 d02d3140405f2fe1bc49db02cbc8eec8eca3d1b9691ac56e8fed6f66e3fbf1fd 8f76f7c7f07d4ffc00f4ec436c43f51456e4b76d644ca565db3107017d05b721 47a80a45dc3a13be6c56f70b96bcb87ef339d56acb7c54578188104332a1472a 0827f722301d2ace25c856ab6d2f6dd33f54aed9d7451906bb62f6d94510d224 3ae25a4e44087f8b0e3912ea07d62997921edbbe565ee23bf4724823e399cde4 b330ee798eb4ea44a2cce609de7085f5d579de3081a144699c26b57122963ff9 5c50781b088f444ad71eae555a36b465b48dd59baebc1b2553ef7dc1525151d9 97d166a5e16096f37931fde632b863a0f67285cb2c2c5cd2a9e539b042f58a78 e072e20f34827509d54e4060f72c0b8ec26bf1697c86e04181155ae4a4f7773d d26681df96bdd78b4e73dafe5ca9b1847ac4ae6e76d8f7b46b24f9bfa7dfa7b5 eaf92e9656c5352e6da72db252005b096083b92129bb629dca0b98a8af824eac 29058d750be173fcf059631accfc8448095dbf1e074f7ae2d23c1069fe2b8bef f713b750cae8bf74ce2c7086b324ffe53c96b16a1089fa81130ed229b9e2949a 5bb21a234d1f04947b8b4d2189b62a7f10861a76309ee104f646ae0edf0cb5ba e7d3e55943e22c4ebfaceaeea48cba4e3cbaf3d065997d1acc40d3224c5004f3 40306a28b315a4dc419b89d43c503a85c0506b17953bea6bd1234b5aecacf821 33b21fc99cb2d650961fdd1d99e40a9a5ae75ac9323cda707c296afd41137730 f8c9e6e2a5ab7a4670aaf83f3c3accc699efd82b0be5926a5a2a1cdf6f4503f4 6752a646352b82baf6d1151e9ef4ccc3b3b7d71ec7e9b4c5592d0ca1de6ea60e f8333bc49c4e9a44fc7c3e6226aee0b9b0055bcba4da377a2dfc9c285e5893e0 6c2fe7af0567bd5a21824fdf55b67e50b6a8b8beed005ec195d2af30ed59776d 4ca297ede9d6a215074ece4e5c2a5cfa78ab9dc625f8f254b6f7b4f407e4faa0 3e12a675e89cbd338f470df9b9faab924f75d5f3519f69f5ab1206401d9adb66 024f2ebee048bedc88620801f9cc4910c46b1cf206c6a09e0245562230f6713a 3f06a7ff1ac9fdfa4853dabfafd312a6429fda926c9e5b55476ae78277883140 30d7452184f19f68497f3801978bb1c2b89f901411343c3019df0d242f8defb0 73aa7f0b2a670434ce7b2c91fb44555a64a23065741e2747cb61de3284701945 dd76f5748e213900b27854c04e94f784db8784e1c76fc2ea0d25e4e48c0f7588 387c999bfde79ccf3a9608fc74b97e482fbe122869b739e6f61d172fa4b090d0 cfac09708ab1652147076727e9aef0a0ee4e52048434c899f04d7d43e1428ec0 e04cc4fd67617aea39827cfbe42d17fa152b290a864d0d2af12a710c13e2d764 29a2bf70178240f42a1de4063224569c0baf8ffb121e7c0b146177bcb0baf7e8 bfde37f805a16cea0147e6e9bea9f30b17c66020de2b77bf1b17363ff2b4578d 920022cd555d3cc3108b39f71f486e20c8204cb77a47ac5804cf4520769d3fdb 7d25497654dbc7318e928e8cc7547968aa341d05f51815c5f27634b0397dd551 b21ccc6c992488edc81495ca7a010b01e6930597c19772d29931a9d172147749 e52df8a52de147ced2419d825204cb20651e218602ee1ec96e2a5c4248f8d8cd 8bd0e96ce6bfcb7128034d7e28dad17de220c406c213dbb5aefd6add69d8374c 89c086d334046c3f26780950a7950f46f7b30304eed8af9bef985ed8ae53c4f4 ac545c0c6822b6ce70ac5e0d9fab17fd8228196082e80a791929ed9c4c0f3c0c 8e64571effd742a3cc31b3467bf5caa7d248471ce1ea1c13a49501c1c9de6453 bd60439d7abfd8960f13e08858d5964b16b24394d8e921fe28a8930140f7caa0 3f7bf90da997cf57eca63e3a186ac9f5a4410ba010904ad57e322b783dc5e2e3 637b534d3c6e8f1bc417a4189cacb043012ced26bdde7217913df9e00c265489 558b4ccd96f48de001dfe66c959ad0ec7cc98c328b453451dc0e434ba1964dba f3ead097199decd0fac6d81435f04b7bee298145500567328109711147632e50 750005e0b7a46e1b3f74b9547dc3bb0200166a7f51090aeb3b191885e872e55c 67fb2410ba480398576ea1bbbb2bd16c39815f0ed1bc158d1023a4912021a7e8 e2dd6bac6bae8618acb3ea4fd532e9f39c5f6e0bb4e2b92f5df60f6d760c0f78 70738b912eed117f1d7fa033f22fee050931e08baefb7bd3b7769efdb3137bb1 d7465a58b479f1bbe07ff1b8c269190ea66f9ff3376cbbc9abaf0fe723395fb4 e7773fe8ec345ef0f0993c4f161773e72ff7b5c360b16f1537d82cfc02539055 d79164312d8e2cf1416650296303c06486f4e59bd0f5805eda4fdf23ca8c7ee0 95356ec5fa9484cedbdd235bbdcba7a786cc8fe16f2af63be8dfd8ab448d53a7 2b3231d3d9c15a9ab6b6c7973fdaea2003231040ca57d59f4364815e3b073852 487288dfafb742bcee521fbfbc2a5818a95ae40e8bb22d96a0f874a39c40b1da ee1de30e4bd10e76de5c13c69dcf9c1748c4a3eb2ced0e30789a1faeb1fee9f4 3c46119aad33602a7190feab3cfa7af06d69d52268e5b0cafe8265140f50a6bf 6ff7b008ddd1d1221e13170280df29563d026b6646126eddeefac426ec9264d3 ecbcb72e38f7622eaccef30b0ce3c0830722d9dc73c0a8c43efe879b2a0fea6c 5956b8c777125841a1865d79de843bc345d234f7617ca6589ab5440907bb0686 0bb9ef294c9298846693aa219d18b44f81ba5636bf1cfc24055e0f41ac4b184b 5b1e2d3547ea63bb59e80989e5b205ac965ea08b97bf2edcfb980262f2a55a56 ae02a5c2094928593ea4834cfd5b800a082ea68a84d59c8fc9c12f02daf43a43 d9ce40c47650b39584c6c2ce9d058581cc3ac12dee43591dc38c041d528e886d 68bb661d0c1b1afc0578a09cac237bbb2b1959b73d32b233455d7143728d4c78 1f40efd1cbeab6e67245e3483604dcb84b02e3f5dc602bf4e5c18094ea0f9ecd 94cd5758b0c2ce29222f2213a7f64be0a8adc3e8deb9171028f2a2d6e0b555c7 5d0847175a30965052c67bc24fb532d088da8c308b072e623b2e3f7a875db59d ab9ab4492aa7d3b55ba7d436cfa320bdae3e4ed611c18424c6c13746b16f362d 511d31a002e6042837488304cf238ebf11b0789681a2e6d333e03097e85b4b8b 075e17f5dede4d55af57c573a542f30d973ab0c1e679f991912de209f1f23a7a 5840b087585584be1308ad19077db42eb6e109c5d6988474887044d4110f5fa1 e91d6bb4d4f8c476f4ae15511c38d09b2e91a69e2908f2fcd5114a92d0932abe f356f5c583aca308223ed6d932bb8ce105715c7d5dc5d6900437f8436610fa90 9d89aabb82ed8cbfe6855533076fa2bd4aedb5d4caf2c32084e6727028bb1589 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 true +check_ring_signature 7871239e77c22024352e29bf8ca806daa871f94fbcd1d0dbb895ccac20885113 fee442b996fc6abfc36fed87e14cf15c0b1a5282681b9842d4959a6186443c18 35 097ee5596d50914a88d7e057ab331e4fdbe00c02c1b32ba94d8ea63867f1d060 14d001b8d1773bfe0514b94690d2eacf3cd961e735fcaf5190421fd236783997 fdc75d44f498a731741e2f383b1c93a1b99720a91cb2c7b7800fd0c6eb5d6f32 a51e4f33a03bad44d941225e3af9aebf1ea8b18ebacc8f602e859551ba6e8c96 59c4cc41ddd92b02ed017bbc84edeeb435383bea321c544b62d414de6a872b17 c02ee00e75ec6e3e89920e49e8e7d39ee29e2f0a145fdb955367fcab47167bc9 e06c6daedc49e94d0a1abe45717d0f29a5b353fd6471fbc1645c10f7be1a88ac 89615760889222c9698c86da2117fb56fd05a40d08c6fc6bb55e7fd1ae39d364 d82c5041cd4082f0cc6e9d481bc7f83e869d9b3d53a9e36887a041eee25a31fe a475b9dc32a82ce4d71195aa2e62bc02a482a14df3cebbd9cc4f87355cdd3351 69bcc2fb715fa45951d15bebb216d90049211f3b380c176c7f071333b1aea415 b1b799f40b8074cb0d38ba83bed52b8eb7d2f65737e8b38b487f30da78f94c12 1995c132afd6eb9a5517a522c540e3d0d6d2cdb8306cdb847e7012b11d4ac06b 306ee41116d41166afb665912a624066d56d670e7bab015214afb3b086131d59 e12b90021631083e9c18c8b1f44936eea590421cd069bc97b9eb151c656bb061 512ffca190bf52c55a9f4b16f4122df4433930ac7c9e7ef1a99eeefdf914881d ab03dd9fa1083214738e799ede12707ef7dd20d59353e5efb0bd8f1581406b27 264e9fefa787ecac1eb124814e42875f3dcb30c9808efb0b5cdae76b08cd353e 2c24eb34db98abef3c2753e95cf56f66dd948e67d9b2297373668bdca270959a 85b2ba793b34080fad970054737ae998dff01441900344986f782b6c07d5c51f a11b878582ef80b562549d0f6b98c4dc1a3c6dc0ce2e59fd1c351419d8d6ad24 ad95144a93ae44a1082ce51f9ffe803ec9f53cfab87fc2a6503336cd41d402d3 00ff9e7b994d159cc61e4712eded4d19ce8ebbc040e1183e1b66719a409adede f2c24072c829bcb92a279924b6b158385bdb187838df985a0a25717c8d162fd0 61bda32f2dfc021490cf52f80d545dab95f71805a7b7964ab4c4adc96996d513 880dd455eae7b8b3900b97d758f9cf71d234dc1a80b62081f0746adecbfc9336 5d80ecdb557c4d58703d97807959137ce73f3bb5c4006517a96a808f10233331 dce29e9450526853691d0d9387a18d6b1036596b0d0f848fcc23c66965886163 4857b82a094be63d9ed4121ffd64f2e3594a08e5b52c17dcc95f0d0a895be3ea 7dbcdb8f2ce3cdf376252a77c0830735cdb9f50162760c24b5cea122ebca517c 10fc2ecbfa8bae0e0a02f868d4125da61133653a4bbba8316bc81091163a5fd0 c007e3ab85ed28a50fe55f0b31960f82f83e5d2526b18de25825be4004148828 5aaf1362388e43d398f79df7446e27d34ae8cbb387d2443367362ffe7205d943 ad738e1dcfaa47df88c551df3594d33f2a0dc4d8c6b69d0f8018ec670322bdeb 51ae47866b1e36a828876fa65808567f67e891cb7075976e6f8b5aad25eea7a7 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 true +check_ring_signature f11cf1153c8f29ac492642f58bb63b07ac63c960fb5d296658d9d6bf549e510b 71588604aac03e02eaa35e87658b6b4f71e0594efe7ed0ebfaf4f1155fb6d9e9 1 2313c6cedc391719015f705d13bf83a870f369a005a0ddc62172d55f0a9cf2ca fda6cf89d9c29b8cc564a5d8cad10e2dd933d7725eab14debd0fffcea6d367f81e3cdb03085a9a886142165e78f6104dac9b6bad06b2bfa0fbc00dd0ff99c505 false +check_ring_signature 89f5095ef674c7261ca4310b9e3392ff4c95f5632fa88e28cf280ecf132a897e 8ef5b67637340e1df2b8c697eea6827147c58667069fb5babf16aeeaeb960b74 67 840fbae8d33d992827bb9fbd7809c8ad244f555fae2add549db027edc5e003d6 c5234f9a664cb3ee6f6a3c1ba9822ca50eac60c4dbba17b8e40a93512dac5813 20e5d6e367930d3e652bd18e0ee34995324d6074e68ee3ca10c1c525c84c0069 201274fd52e10a0d7a7067c5b0fe4d1793cbb68c604a702412886f62cef71a5a 836a05487f36eaf5fd399bce705208b484a5c74905108477bc71cc8604538657 53f29df5d204cbd28f3f96000af4c84436701467309c727ed7a7d46fab3cffb0 6eef33e15bc031c710ef658fda5a70720d12d84b0fbe5657f1dd40459f356a4e 5281a235542d9d6078f4318b539b08e520d3bf4d57d9bc27d9a30c904fa32256 0c1d28a2b6634cc538b98c3528840d41f0d764ccb31bfb530d5d54d6a9fccbd0 197acb11b88a16d9221e2a9d335891fd0d18a020801c58daa6a6875a1a089d74 2dc009f4c14ac1c6e10de361aaae3cbafacca0a9f59d4e8e771292fbe22082c7 0f7ccdb0c714c9a94f3cf057753ea47cf83745a0c7094599cc18fc0fbe8f9ec8 53e2ba89e04eb8b20398354e5d4f93fd7843c444cb70f0617980db70949a4e05 465102f9665b7ce0608c7035474ff568bf257da8332e281e47747da030284e26 7fa9ea02535178e7d0597d2a5a4862afdf84f52fe25d7f9663d48d16193ca5a8 770a82f9487f170cbe99cf73ab4b01eba11fdfd382d112b8cb752562830b726a 6d521cd3d4e5af7298004dedf402ea4cded069a955c254614452f198b0c2aab3 882ca4b551bdf4f81d8b0a5754748d34f0ce4cd4692b87fab9e10de42dc1a4dc 267c1d615da8d9298814f5147f3dc17e142625ca4b0e7658e9605b369c3fbb5b a5991a138467cf7b038c3e6f47296a861b790c457669a797a2245e94a18c7d95 7fc8f2b473d834699fbe6497d2c0444f8a56f92f872f4b4ec26ebadfa0bd2509 d4c328042a7c74d0c25b80e01e3b82ffc5b5bca0dd83a3fc5bd158372c52812d 11e1e0d784461e15c8d22c6f4f031f35d2069dbc2c69b06b6cf64aeb5fd84138 ec1e9be896cf45fd57c92ea70c1d077bd28fc032a98c4394e983ede3741225c7 f4ae4c01470045b26a97b2ed5d0a67b548e5c4a54d8a8025333eeadce37d7dad 9c421cc2dfe01eeaa536acc781ec182848ebf6b223c7fe68cd813d25876bc81f 7016d344ba91f899be3873ee093acfef9e60f960a6588abf6a68e43ecd4f48fe e53161724ed99d4ab897a7f96bfff00b60067c4401b64f438988fb51adc533ee 73bd60e766b02a40803d9b137247e4c8420a9c770c3bdc26f00e5672c5495034 8aa23f41871809f8c41f1495fa5ec59d797d0a4ef25636ab154766ac1490d92b cd7d8dcada79db10b50575f3fa6c565ba0cac966a967db6ec6592c7f234b8398 ed4c9022c99de916f18f02e28e54b8809fc8c1832be01a85544c62f8c2f19bcb 8652e7a027a2c2249a5edafbbfbe9e2edeaf79fa14d1205617f00e5e85b2edfa 8c00328b235b8eb6a79c645de2127c63274b056acc177a031e02c193bb92ec97 1a0afd1e9ac101f5d467dcb7ba788cc7e1ff453794498823b97083e9481fc9ba 6f671f997ffda94ac75990371d55e3e4bee2d8e2441a59cf4abf7a2078167d71 f9bff09ce4f59a37d218a574e2e3641ce25e14472038132b9aa7cc32e7db8759 0ec75fd15fa09e57d58a519d3a90d5374b87c02dc147bf87e6da099168b2100e 28c11260cc67b265bd88228898945ffc74ca5fb2a73f466d69a7524890f79044 b70e1f2dbb612a7d30bcc6c9503d628a61df7b4322d856e827709b46f154a888 2245d22df03dede9d73a4f4cbf60c6c106fb60c675a7a3638ad0a11d7746c81d df73543772382cf3e83accf3d25bc3f84f736c285c8fa768eabe8decdacafd56 a9ca4120fa41088a06e41768cb5a19f6d732dee692854bae91ac9905681640b6 9653d855d1404341258f0627ba5acaaf8d8337737e35099fda3d18b52cf6f00e d4e5dbd30f57a7af35ed5878585291344100f7d8b8965ebf8b706a8246240035 5c2685a89611f08658c86edcae7503a8f8b6bfc66b2c4b2501cfb4542d34edb9 7b6cfcfa1bbdad57d97fbb478576c31a5ed3040f038b4b922ce23a5041483401 73f0de280b5ffc466c0b207d769f68fe6fe9b1ada59837039746c8bb560b5aaf aad8c684815b77a53f668dccaf97b3f7acd8565d5015272f474218f17627404a 46ad714d929b965bdabdfc29f91bc96fa005af7d2c4671a2296bcb412752dafc 262d04d2db36c3f3af903582c6696fa71c4142f6b83c0165ac4b552709ac7d0c 2bab7b1f03d8e99f417645119d109ddc044bbff187b22143c68cf0d2b3035934 f02e64c34b007463748e1ae402c321b2f4652318e0614d4e98d91f7c9003865c 17b921f9ccdeceaf04788726d3da8f7795a76dfb199f8ea10423339a3070efe7 ba78f1cae118ab264f1ad712be3bc19a47612c9fa98ff7ceeed9cd53a0988e4f 7aabb4527e05a1e0e763297f8065c871c3139b16c2b0855b8d2919e0c846b4f0 5894d3986241bd16f8b2a04be100cc914a73937025ff496521c43a9cbd7216ba ff60902a5040f0eb572d7ebbdc351cabff608f36cd15188740fe13b6d75eabe7 f46923f940e61af0bb319ce55bfda1e8e2bb465c47811af068c212209f55b0e8 61524d54bcb145db2dd705f1572022ab875f079a0f224dcf0ffd600ec68c9433 c3f9657ddceb1167249b429c54a0d57e8b70671ca0d9c5904816b004c9f8760d a4117b6472f6cfde5bab2a93fdb5434d866c843232dc32687b8ec974345e342d 71cc5eb98f5e4b0d7477d5209ba9483c53c24f93f9bea5f0a9bdb7c2323722f4 8debd1e4ed34c67945e5dbbf607dfff86867a63b7ed80f08624ee3b4d21d7dee 319da0f1ea08b44df16d754bff6b215d9f21ee207a5b69e6e664e4244ab22ff7 a22dcafd432b829e8aa5a4b95991a2a782f10704e6d785be97e14208fbb7e458 0c0ec18c4b8f3f74f56637d537505ae598c8c805c6daed2ad3f4562ae805bc12 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 false +check_ring_signature 9bf6d903237c85f14e1ae11b6f558814bc33fb9d72ecfa56b85b2446ad808f41 99e9eb4c68c3971d2ea83aeada53b63207955fe55b21c0e11f4088dfbe1eb5c8 5 17c2acce4b5b62477196021dda2fc521789d8c61b905a8081df960dca75f1b21 ff4882ac3fb6f79ccf178eaccb93d4ec44bca0f338369128d66d234793d4e481 98549319076f7c7a4200dc8ed586a32e2ae656eaed0f63e4a5ed2e7add582ac6 d847539fcc0b60541355873ccfe2e597610eec58475e565b5dcdc12bf5981d08 a92958eb74138b39b534ba4a53bffac98464badf9c349eac6d0a233b7e761c16 4414ca2c4a0f8f6d72578def45a1c3e11e9a0ecd70646199dc51ecca60aea704d852af8dba0fdd8622523adb3533fb8e10973428ac3c8083a0eac5d2003905025062a94656b58152406a4f8212c3ca2ae1df38272bd763f5fa3e6b0034f22c0b30a6a4caa1e5967e3eea6307d62f8ad73e66311b036873bb168b4d61bd97ba00ede4c003985ee11b76168971efbfe342f4e269f6fb20018fc59dcb43fa930f6f69afae8cf60d041a09c1b81ce5330aeb4d65436758364e569950d70a84654c099c64ef7641a594dc7df5d81c3f43a5e1467ab49f377769a637a24ecbb7de320fdbc1eb58ea626580b5d2641e275c798a2514fa7979482a43dc9190050272b20be03acbfca0487a1c3a94efb7b0c2c3a627684f03689bd982f5a55fd772d006098afa9609a1cbe2061f79c105291af2e72393b57bc2a1bab7d985e9e9f38b9b08 false +check_ring_signature a81e1426c18b575096fb6f80fca662bd7a03b94ea208f57fa4dd2e4875af8764 ee7d0c58edd0a38d3057f08e19688741b7f0455ebf61100ff074030c8896df02 1 0e12b53c4578baa41175bbb866bd4068964edf29179813b7c8468ca714c2be7b 588348837369d9f0028109f46e6b58b4fc61f3dfe55f6433f6e1a4630af83c0c368cf5ab33c2921c56ee6b1ef3dbdaef1a06df1d4f11fabf70ebbbc2aa05dd08 true +check_ring_signature 31d874473578d02b1bc2730cdf92ff784c3ebe0e0e95bb31705e6ad46e3bf5a8 ca7d83a9c6c7c7238e23216aa6b1278034b0714a9c85e61e49ceb00d9c6e12f2 122 0a4e7dd550437c331f6882a0c5b3ecebfd259c0d162fe14308847cd1b999c238 b76afedd0568882006c4d976f684dfa3752171f09e5985063c717bd954e022ce 1d14cbaf375f654e25c37d04449e8ab33a6d5133eb20d8cbffd482b660c6ecc6 f00f5c3fb7c0d8063000b7e28415f18bd6e81e5460f94bb0976838668a73c9b9 6d7c47c61533d93c7f697f13d7d438f75dfcad4a6c9a64dbcc68dc9c8476dcf5 aad422228918331ba9ad6318270cf8c45be404760e3651b91107c79648d83099 cf219db62011772a5add339dba6f83d72218247cba367a3676c3b1854992e0fd d007306ab04ae6ac956e90d4a2dc3bbd9244999d81c73439772b81b9753663e7 d107002ab6808ca751183122722d0dc00019b357558a7468ea105f63893f336e 9c30b41152bfc264a53ae23fc29ff2ffc91c2dfec4c9dea1ffba245c784f135c b7ad12d5e40a2caee6bc0372648031d3ed2a93621f110bf64f8d51e65dda7610 e79b8a66c90cacb9384dda84b30f926a50150dcbfc881bc2c428ecbe8b07101c e6bb5259281d990bf62810847b01f98aac2ee6bb3d4ad9be328523198abdcab6 3bcc7fd286a96e6f7c1f2d5315ebb252c42ef53d153cb1b0ea37abbf926d12e6 c716505419fd08b9b4cde15bf820b1adb515239b8740352d7fe159ce3dbc3726 0166eeffe9ca26598c413f8da6f33c02e25907a7bf7bd6252632eb21bb8e05d2 d5b3e40bae77e6276a0b6cd26c3993cb2afa7229292b5d02fa4d995c033aebe3 eeabf733a6f403bccfe8abd9ce1c29d1f31496e5d2b60e6aefb1a70600a3fb10 3d38583459c134550ad933b109a04ee8ce438c7e0995c7e6cd9e98fbd6c33f57 da239b0fc9280f4b4388ce6a0550758a245f5307180884cfb0d32b6fa6c0364f 92a0c7eefacf93fa7bc3bcfbc6c37dd9a33b28120fc1a80cdbf9e4e6c4c326b4 0bef7b2c6618d9ab943125c99ff6d7b7927de741ff842222951b89878b7e6caf e06a4618dcf7f90cff3d568b4a3b3ee73848b826f9c5d1f4bd394549176bbf88 b7dde4be5b8dd4e9dc9c9485d95a16b5a94088a3b7c8e63a6bb11e50c6f539a3 cbda769a917b3dc34f41a59c576811200f508730192b0c960657becc4c7dbacd 4b39b7c6738a49fedfcec0f0d5203a6ead1421f6e88c669c1238ebc4656dfb36 9c1e0ccde57a25dbd3b71270b6f4c9eedf527bc06cf0e81ad72554c4b23ff94b e4a1c908d98ddab0b2e2b5021b9ce7d6b6cffd42e6716bdecf692776aaa44d50 53d9bda331070cfa630f9ba35397fa3403f030909927d0a6e9074891820741c0 19070996696ec52a85c728d59913a41ad33ad1fda03232ceeef2c8d0f5d9e496 4aeec6952ee3b0d663bd2aa72adac73df0ac9352c251fd98a42bcec15a154045 a7c0d3353687750c02b44cae8c98d35d6a7779b656a13593d2ae601d96498987 bc1198bba5880f84a6b1de76713198e9438f99f4ba5bfee2b9dc090181f8e56b 6eb3dfd4bd582683d9072012505764043be2cea7aaf5f20a54fc5849b3951bc5 b2eb6908178ced73acc6005f3954ccb9a859828ef0a59c5033679792df14c6e8 637e7a26281aca0914e9ac1e98a4ef0339697c74558db09bac5c18a04d160cc6 5ec198e3c1a276c924ea1d3fddcc88184f07ef0367b0a934f2a009f1b1039267 cd7f1c7a65a72d7f75778ce5b0c7bda541f0880204709f82cdbee5f0e0149f02 c04135181d0c0e020318dade33cd42a6abbf318f2f710459a90558ccb14ad130 5f7ee2a4f29ddc36d5d190e9f8733fdc19c2a7bf8ba3410303631d378bb19beb efbfef1621e6cd3850a86517f45bdf97b12a8acf581da72f930a3849eccb4592 284fafca904ff869f62f46690b0ce31b8049020340c9c0d577cebc346a66431a c2821e9622ef6dab79294bb656d691d66ba336b554e4ab1a9966aee26fb7e780 e2f8a15bdd6bed90a95c1fa4fcb7ac5ffa6909ff2a31dbe0a8c6808ce1001337 17a3b5f7eeebc8dde2f1190e132e71941f704be0f3d4e347cd1958ca2982ff94 5ea5dc14e027ab4af1d909b51be873969e91cf62b1583affbfb0aeda238be5dd b2bbd4c34f481c83a7ef19cf7f4b6891c9b5a0a9dc5411f65ef12ea3d4929236 5afd18c895549086f982c74466e05ac817b7281ae965776ce6c5947e5119a654 562a261db5f4495e8638b8c7d3c478e85ee520b83452cdd898f1189216c9f2f2 b7c84f184d8b6f4af0cc3426d9e27be868fe503e8f49f649b42453ccf95eb23e b11eaa318f56c27bc8b7fce76eec964135dcea175521f774754ea4e587b5a80f 2113056e0f4a314524d87cb93e0cd455010e6f687bc035faa62b50723d5ba513 d38106a906a21ef567a6dd9758bdc42977107d20e1b928bf638598bd5bc4296b 04844b5cbb0b53bfaddb2f047447edc0edf7f11ced25ef9ce140406aa8e0f706 aec52f538263360b215f6c04fdf7fc56dcca0f0c5b5ccda010640fa028b1a3a2 6c31b7d4ab9e55b1d770f484e0978107ededde23f9b4d26effa6940911998b11 63f4f6c67292dfe18a4e4334ad9d8de947d2860ff61cc39f0d210be939e35c2f d15013d3625598a3a7278f9395d7e5c631fbadd1f4cfccf4555624886660a6a7 d8618a081f91c0906f5a90b3390c1554d06e152a3895cd988b69addadce1f3d1 c4b5cb137c3ebec3e47379686303623287589bc086f9d0c20ff0eab9558ffafa 236b1e8a9e15c30aa39816b105ee24cd2318f1768711633ce01bb58998f9201c 27938c0bfe9f5822b836cffcbf23e5682c0695899f9759200f720ca8cfbc1c4c 08eaeca3b2a6f9dfa10e8e66a69f3193a74b5f4b353d8a33fb91de68f53b2adc 5a7eb7dc3a7bb0738a336dae9ecdc01b4ae2576ba5aa7fa032053fbf5f8604de a68f2553397a6c1ccb283a2871d83d61cbe9e6479a84e5eed496b82f70e58246 d99c5b41c9bdc21938fb6c3918b499cb3962fe6ad3248963229fe303265df683 2322baf38db70ae6d5511d710cb718ad4d31d2d5c26cc5e9de3aa64bdc8f6c97 790c7c2f98fb2df2a8f329207b4d8a5f9e115ebf48645021380468c9345f1095 66b933de06a6423f1bc52dc2511202579d9533e23e6f6c37bc4da1f6279c3cfa b39f20db5ba767e54c4d2381ca1d2dd313d6de022a6aac8124d9157e536e4f7d 30f49141446a93aeaaba124430152761971820cc33cfe062c3c75d864cc4b717 93177a29342d85c97bd260974f64c511d0843feb6e56866903e6c0486155777e 58b8f8010d483a99318374432306a67c573677752f7ae13a385e6c09672502f0 4ae2134720c16c2fb18a75153c3b70c1c3263dc77fa79b7391a900b61e171b92 0d0c9ac21c7b14aedfba167b722ee571a4d9e9510c2a4f062f30090e31f8be46 bdba3495ed5a98dd08bacf1e9af7f2e00aa187441b921ea0c6c2504b78f89775 778dfeb0a54a7c9c476c882c13a17cbfe6e1bc01d1d50b606c5817e93987c7cc c04ae96f1b7b3cab34d652855d00173b887c0f6f0964fa260b7d6fbba526d3b8 beee7612e27bd65ca298a0ace16a57475a7947753ee346534a52f2bca35f7868 6b3630f2f3a737b30e8aafab506151420c592b68fa8226345ab8a28ac794056b 5a5f32b50baaddb463be85b98a7d8c77c7c39b9680604167d0da8ac054624357 35306dba6e6accce28d5c8d67ccda4941a260038070c5b89a70ea05dd228ed7f 769bfd8b9825b991f5d61f35051ffec2c7ab19c146bc3b02106ed2be0535d89c 1307e3fd51c0ea5bdd32a0fc9ac621558f7c6a90f2c1685f6601147362dc95a0 695c214c3804d2cabfc50b5fe597600032bd10194cdc2dc3d024151dc80861dd f436def367f87502f989fc49606a3380f05ef404a29b194bbec3a25be78885a3 d3810363a1fdb9dd2c18ad4b16ae059215ca35e21ea59b8c8134f0de095fd923 8dd8a7549e730c0089453905952048fc02adc03f91adf11150312c484c9940d4 4b5abf9a050ac8e0d09d8c3c01f9f513a92c3bfa24d763f13afc98856e6695a8 3c36235bf26424ad9b065cd8988753d67c3d62b22562bcb484360df874ab1f27 3def829f6a0e300ae6f93675a841986611e9f12938028b4233e991584ea9c919 c0b260eb7ad604d4998ae8f5b3d1c243de07f83e412a7d0d322776433494608d e50c15dc22e227ff0080d0f4f240b03ba2436bd8d14cc31346bb494d6a8c1957 9dfac700d658cdef3813bc4ca0c079faf62b2368c55373f85578105540e67bef c60e856571bb145a3cc08e640ccc20aa018f41e47ff2b440da89aab7d2da4753 b299ad6e7385b71b717eb1374bda2f36b27f469472c715ca9cb19515e3588075 9f00b9408fddf9889cd212c4731974a1590f06f70278d8e3f8fcfa6a6f58a77f 19a1a15e3f1cc9812689ec9f77b208ba679386910a047dea7a67d5958af436fc ae5cbe69b8284d1460edca2e88cc5b5d3c80bd22d70f305ad73332d4f80ab9e3 573adadc1798fc182cdd5103651148ca4ab255c8085886ea243fbdd67d5cfae8 ffc0a867e5d05b6438767534c6a211e11f876275fe41b86dc54ec7fc8a539d45 51b33c47eab8783ec616aec18fe60359abef3b2b3acefcb940b66b165fd5b085 43fe55e5271740caf98fea194ad31062e1da3a4e71aba0ca0f5a5c1401a4fb27 525859c1c71a2897aca0ef614baa57339c306114679b5134d91b256c07ce8ffd 831929a2dff9c7668a1f0bb24f9ad9385a937ac606b9c88c2d2b79d2a3a86867 a967adeb0d3622afe98b7e1a95eaa29c1a3fbf52c83d66051ab32637c6c81b62 ac66c355f80c0acc36e6d3bc0addf7bda973b60a582cb3f56ec569d460a6c09e 57827ad5fcd81c348392bf9a0334fce083d5bc5138134f5ae05397d37479874f 3ee12b19a2a74fa52068381c7caeef582b26361ad79d28bc6d130050e0555109 49be86a4e541edc5b4140a637f452973e4c6e6c81f1a77637a214dd1c530036a 8994f99edbe3a832a2b4114cf6bc587797b0c615998b9033510861ea31ad612b 865a3d8f99b2ec9dcb49c78f6d0e81dff7b089cc567ed0e0b9b49f4d5edd7fd3 50a161fd2bff9f954e06a73f5d8daeac26846a43ca374914646743b2dbe7411a cda669e63308b13a0161e50e5022dae89ef5b83e6c5c8abe838d11673e292904 ba53e514ff496bca3a0bfdadc35f9fd8ef7b9ec722a8468e11610228f9fbae33 c6cc839456d9bc983de43328d225ab1710acc289499928984443b635ea82d48c 9c5f0fb7a07c2bc7af365c2ed9538c3806d7966f762329a8c4f961119267e328 dc0817436926f9ed3ac1cf1bd33ab2d4964935047042e3daadff1a41b7957479 78d7aee8cd5f5ba88b8db88cad25b35418ae6358aa1dc6f155ff570feaeecad6 df1dabe00d1991d9bcf6a3cc3ace521594a6e996d652a088e781632c4dc4ed5a 6f3df33072e6e9b9c95638b8f3e771b36031f8a69318962b988c77bb44b6ac11 ca6ad9680eea27b61139bf227ca81396758c096579e611bf9950fa245063a17d 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 false +check_ring_signature e6bdfab925c5e583faf23a24df20248c7b449accc8153facf889e88581b55f4d bcba89a72ae610d05853fed0b3cab80634bb48074c22ea0c669745ec926c5224 1 eceec6b87b71a86fae9115bf0d0df62975ab461930e6f639bc6f4a821db97ebe d838e8b15efc48e6ee9697c06db73bfb6aef78cb82200037994d71d00d08571dc43d264efb0d663fe068d7f5caa8a900fb219ea774a7dc5d92fd5d459e5ed603 false +check_ring_signature e06ecf114506e80968990d2401e17fe87ff080c1e01c05ecf9d4c4bcae331862 975d648eda499b5f91a00a7c67802bbe470edefcaa2998136901aba7bfc36fe3 4 9307317b83241da5dff9320f84af9cfd6445152587aa76f426fed904d63c19ee f5d7f1d81c1bf36b260f9ef7e401575b1170000918683d707166261be7f4c354 125efed9aa969a705c84b1ac738b0bba013494009925931f2ebe4652cc24fe6e 1d02754fc953a175fef24ec47e39924b292c74dba650ecb9de8133bce07c44bb 95e99cb5d7b7ca78f72acb366ae6fff8c493300b8654a283511933c38e58e90550a53cd1c3c8ec8e5cb96eb96aed4146a2cd6df2824e278b9fe0a0f852f7b80b4b6ff5e62f04e57564cd05ca250baf21e703b0f5285007a3ae2e6614426465096541f5fb8170fbb282a287f60c6b545b918e6069f92f7c9e4e30b0a75309de0d3227de3cc2a2a17f79620b0e20bb39ecdd0aacc7359a41c8d745d8b0e87be003750acbd2b3201b24e32226d913ccfe87befa191c74e4e3e4aa7574a3c3350807dcc2ac60561a48da20e7e97e8e89d0f2d71fbe991c729bfa048224dfe9adee0d07f791ac90e1b23032c706334fe5f1c48509e77eba756e4556cc0e2185ef9002 true +check_ring_signature f9b1a298df495a8adcba5c744f485372ce30794069f3985a6d2500507819b3a9 3b828c4c3ea66fa067a722148a05f559aa942066d6cc017d432357af9e9b022f 6 5026c4cca05f4ee9dda95fe8d1727cccb764a55c48fdcd8d7f83147c6e8db8e5 da7cf86310dfa7d07ff8f268a3bf935d74d2f07d1f80ac28f00eef50f4e1a81c 208a4850eab9a83c7ba558cca232eb748b9e85078309d27b2ab76e85b6a41a12 99d716fb54595f18fed531aacb28264bcddbaa85fd7ef48b377739d96b5dcf4b f28fc96f3d459bbad6725bf515bce2ffee6eaca0dfa4f7dadd5e806b79da05dc e92496efe2edbffd9d7fbfb83b5e2344aeaaadd999c775d1a30f1cf28fb63ebe 809b57967c0e88dab33dba49ed889383d78dec5eb82e91812fb93525652233cc1471a318e7cf00f04a07ad98c2015cc268c9990590073c829e7de28587492400ad2a8b3fc5b9b09ef141f3862c82bee545e5e3ecad4493d9e9e09589a546020e3c814490064c111b65679023f3d9dcf9ce74cb5a12693a6a93782e69e9c351073d87e2443853affac0a19fb18732c4b065731f51e64231a7a5cedf3ceff03201504743893cdc8fba2cb5639e690f80c740c92730c787248a829fc2c0beee7b0ed557744069e36a1d3b34f224350c7a0baf6b6b3f551215b58e2b7c8160ceab0dcbab841f95c2289bf5b254a3ba6ff147f46b20fcab6e64993a1e5ba90dc40801ffe84818368ed36ff7f532896c345e7b8143bf7395761144978c8bac0646630e7db4437b10c2364ddd13b7a0aa5751be937223917786f1ec4f403b6b7f85c5b13ba49384edd5d2f72827c6d412993ca6ed539c2281b4681491dd1288492e7104d1b605a8796d0a62ea9d4e7e8cbaef0fbe0ff4660146fcc35742475df16df20e false +check_ring_signature c6df5540ae3bd6f9462da251ee85cc6cb02176cf9520308ddb1d01fcac6a4f9d f333067841c471f5cbf0a7e903630f61207254a956f1fec474a3c628add12054 26 53c6960f9b9ac03034b32e14d91bd5f278fe4677debea670a1e36bf75cb2a850 0f933cf60b2ac54426aa4a4dac92c325249da28a08834572a245add70ba4b1c3 e25bb46b0b3d327f9a4d8da4886fa3c4c403cb665232a6e2c5a25533f309e7c5 d044fa407d495cf7e559f08a68ed352ec8ae91c614cffbc01ed1bb2f5845eaf9 18606fb82be75ba387a1068b54235f0e5ec83de188e77d3e84b4e9f7a137a737 211c43cd5d8722acd75fb5268b62621100732efdf7395bb6e219bd6c7f7e4782 d90ec36bc9b7bdd6f589711cb3678926fab06f21639bddad3f92de76e70c873f 2cfe8a043c5c9650f60727b7e754db0af8525ad2d5ff2ced68f1b9d85cbe2211 e1d7d1ca2875d2e6507cc0cb7a549987a5f1df3532aef73b76cbb92ec16bb031 9ce67370db9a1e4acb9bb77b1439d387f73b28065d37a8987e6f6ace999a7b05 7cb9e5607fb564d12cd63db2510d3800ba12999907edb58477bc13b51747c6d4 89ed936996b82409bbcd82c7e4c905f6feb90767b1bd2cc3bea6bf73367079de b4b0126fd2840c3df65f95d482bd793c9ee7d7918807e8e4caf73d4aaa808de2 4046166e2f7783b3764390a4fcd3040d2a1cc1393e0d75a4425ce2a3bc0b34c0 998e978455551a707051ebc6639968680a15b0ecbccd5ee1dbad5b0889bdb39f e4194494d30e2246c4e8eae99a7cf38deac4aeb1b4ea798230692ca8650a5fb1 fad69a810924521ee4bf709c716af9f6a78cdd86378aabadbe7d8086838ec1f7 bd7668b2100e6282568f303fc3258d5e22d9116e03965b4cb18cff078bb17b4b a0c15c331d476876d0ff6f515c8c90a8fafafef4cd04c080b9ce1093bfc80f46 84cbbd84e55c7234ccf57ddfdd3814de997143f087008d514223637335e700dd a76d4a8f182741ac67987676ba84d90498cb563ca5603396cee4833de43dbaf2 ff0cc85bc4dbb6952015a333901f1f2fdf3f68c3b626277edc0d081c01d08496 b234349eedaea56ba921289c783de16c374b21cce19a351cfddd891f64d0cdf1 5bcc37ac994ce29564fba9fb07e3d7814bdc27b1093ae35105ce87907ccd2263 21b32f3b48d517ef1265dc3dda184bae72362bc6217dacc587ebabb1600ee4cc 308a9bfaab1e5149bd03b3df8ae20a341ee00fc8d6e6be1c55c198c0572f0b31 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 true +check_ring_signature cd36644f74572581e19100992ad3ba7bb28cf1c040e2d8f6ae1d88847dc8499a 2a589a7e609333b325e8f5021fe1dbd154230de7b4c243c4a10789d587eefd57 2 972a045939c649f1eeb344cf8439596f2af7cda40e4481678368dd9304465697 2c919c31ab58090bc379da42c8172c1567fbacd63fb023004624811f19fb313e 3761950f17639be0446419e8da6d35074bf6c91610aafc41a4083efeada3560a924233145cfbfed7c3431db41cf005aa2e009a7285b465131e2d0b53e392c309635f66595f4aa8bac86153a5a4975e7dc169c8b3b3f52328b5b5fb03ef6b460fe23b6aaea855ed77a8e34c425e4c4cc348fc3fe6c56920b5daa5994495434309 false +check_ring_signature 9e3e79475eb428b6fcb03f45199b9a0e910e78d5813925aa28d162e175115733 545bd0cd2e6be0997b6d0169832eaaf5d40b4ed932035b9aaf284f934bfffc12 8 98c5db66cb40763b8586d73282a9fd1446e9270f89774686e745dc5d12f2e6ac 45674f472f16dda38bb8ae3066c947ca62a063a30be0ba4e38ab78e43aca7d17 62b47c407cb6c325e8db12711d0ada0fa30f693d189929eb82472c7dd28b3eda d85cee02af27c6813dab6372c2e5a2e3a977083287a4f79372199f934d9e2a7a b52411ebf7818d6aacbb39fdbd8c4097b1f34ca0edf9d2021d8d636807252f88 47605e1ecdf98d13dd1094090d7435ca9cd25c0ad4e553e16088b0d4215d44cc 2c96b10bb3dfe0c960d43084a508104c8c2f3ddd4bbf84864136cadf8431f4b7 0c3ec8c36f7b05fa405ac840341324fca2c536eb00cb4da5c5ddcaf95d394b28 6dd3547b934371a36a3e8e41c3f7c619a84bd66a9ffb8068c8a8735dac77970e70fdfa81abc6209c8c20c1b5e540e90a94d19fd958d0ca2f732435b32e051a049eb3710e340d57563ca0e1eb914ade545ac71e5924214a189d06a4c452c6170d58744c62f78c34cf0d2b660266a89a297c6e9e537b9df71758a2c23085c291051a77ab8bf352d226b3bfe93151e36560be2622a802a674d6844e4c211e115e0910148b6924bc26a8fa43484e461141863b1a862ba993ebbf791af07edd08af0d91d8f5384b35e6fc14e2fc554b329f49612052398d80c04744418ad495300c02d310b03fce6152c184a62aa025aa5879412c41b28cb866546d6b48f3885e3b06bfc26b1aa8023e7d79f99f734bb8d657da38dfee7b5b176ba919bd95bccebf015ab57121410cc12492b365d74310a1752c3231939ae7ab6635e1c10a6f28690599be488076ae57da0f469503daf9a7c32467d6b29e0b394ea4dce250ffd4b60becd30f561201ad46634eddebec9e34a6152b36509ab4ea01a70cc1c47109330044b5939f2744603611fa38817afcae25f28eeb1e4da94eadb3f1d9b84891e20c618be085bc87a97cdb2a9f1f6c8bd692964590a842ce85cd5dd5913a840e0804ec71004f6eae6bac24caf00ed895106bc16492608592c08278938637f442c20de7485fbb698862f8dcb454d60f9ad08bfbe273cbd5273ee7a4edfc22e4ec2304 true +check_ring_signature 51b537b08f61bb939e18d65622c9439f4bbb1fad724355abbde6178baf25f3c1 8dba861a9599caf9169ab884b0330f40f78a43d089ac449b1753678b550b2e13 4 1e068402551ed83437eb35c676481322e48ccec4099a3b5a0554afb978f5fbdf 29910916633db4ab34104826c92319c7f7473149e6f1cbc048818d4f29d90a2f 0ed78f901cc7eaaf5c53101e613ddfb2ed38c806868e79c4d1bc3db73542c9c8 ff489acd1ca0e4ef793d3345fa6a2a37614d65451740410a62590b038c46fdf3 694eb973047606f3a3f507218ac39ac96abc940d6659f4b68d56677b938aa909457bcfa32af7dbb0bbd20a1d86d89e0c39da0f2b59b18c9dd6580d4128fa620105111fb194f9ed5479cefd13fa84d4e8166ac417b4dd94fa14cc2fc57efe05016c2862f4ce84f24d5d8e8e5c01d8589d543d685bba2536c30b20a6f2e11a1800e56ca616f1c82dafc2df036e8e9a9725253223306b0d01735c9045f6953ed6064ae950a5df09c3e6b912f2f3d81a4f660659ec2a6f79abfb6b551a4915d0160444cee0e5e4c3c7e6715b120fac1493c9a364c071006ee16d474134f31a6352017fa7f2457166b6344397542998211e7c317a745626dc2ccd861278188e9ad101 true +check_ring_signature fe6190cd5005ad3a53bc0cd9bea6fb3c169fbf944ccfc0a5500c2e6d8a6dd5d6 5eaaf36499c0d99024ed40783d1fbc677703d3563c1ef6c95962bf4e18990314 235 58c03a6de82caf1170fb3ba7dd4486fbaa12c0a8432d532cfa4c9407553b175b 8f1661f867e7120144be47af26903d138acabcd1feb04789dbc92a695c48dcca 25a74e7ef8b3d18f14b1ffa30ce481dc65dadad53802eba42b5b379bf22cb65b 3743954aabc8cd46459d326adccf3d685aa7248f4aad6757dc757af768322ef1 c36ae5826cf085020d50ec27fdbd88b6a0f836054607d4901a10353226732b46 b132171e7ba94b81cfdc1735274df964dcc0205f6fc9a9d555cb5fd3350d0136 b7bf451f5982eebd4d7df8febe0ea0ec7677e91d71c3383a6300b8a83ef4899e e32fa2366e3f5ded0e34917df0e4ab9820390e4715d9d2f474af6215af8add98 a6c51cc56f4a66ad372eec2834d83a84af6b26ead4aee7fd546e939ec0953619 6c996ab284157eb426788cbc5e3fe5645a541decae2c9e0c3dcf0802b81041d3 cdeadf1a43628e1737ac44015c09ced4af75611fd1a70d9607bfb15613e82f71 4c007df2939309230a0483e5af0be4231a1b27d027b9ccb1259ed408d58eac88 c986513fc32367e66a36753ee897ef990a405134cf06ab697ba69c5eaf2f4dbc 53ec1bde0c500638d7b25835a2b23b61184b6eb0ad5c3b8799659c622efa2c48 bcefb56cd2f240746b072c6fb8ce3d89e443b8ea91a5d037ef29495be5fd7e5e c5a8c8946f3727f5bab289542d53bdd2ee02a3bfbf16e6eb37e2111dca75b938 fe3a9cbe2cbe7372086af102ae415ac7f055818e31c48e929d5af20980b594ca 230bd71bf4cf7d0b581fdcf2499dc8a345156bddd9f81443b5a217e2d2662975 362312dfee581fb963b1fbc426848079a0ce4fc7c90ea0530a18820a5b5c7a8e 30dc67c3fd47eeb21861f4edb35db8d630cb15ac63ee6436a4bcab02b84a31d8 25a1551e138250688185f659c232c14c6acc18e6bb7eefb2fdb6e98ad3832760 4071c4277c80be69ba32b288156383a75cd1a36c1a243849096acdfcab7323ae 7c85a7d571d436185068217051813d46bf40b654720f8816ce426ddb4a13517e e00ae7053957c1d730a11f3cc78a57081f76d4b11dbc92b4879c9ddfc75005f9 8a3617821aa051a3f953f9af5923e48361702553e966f09ff71d3585e06336ed abc8fdd18f3379000fd9a6254a6b25314f33bdfbd82f7b82f2ab79be8e89664a 45c66f18e63f0a9f30375f1474e10f4c81306f6195221d54ad732d7892a11142 498f42dc2f029d40cef9d98f60e87cfc7dd557af01d4f4da0db05980046e3615 7146c5da52f6d26e44991a6c0e0b270e3bdb87c7c9f695e67ec7391e11fb7d4e d2277549ec8f86a3e768ba2619750e74e9471f9e5cf652dc9078cf3878623b87 c2d00d51970ed9e37da93993c3a9c2b3312653e8d0a97fe1760d346fb94526f8 0a84b569df1c0eadf8bea968c1e5714000539e3d5e6a9e6a30b3d7cfb10d995a 81a3bef9ea0fd1abc7429048aa660268900b47fea1506dee2957a92623e23dd3 5cd1237a96796f02e01cb15cc9a51f1d2eb5da9fdb8ed06c177a11a8a969b14d 131fe75a96822bae5c81e33c5d2c90e15c36421036f322ace7545d290a8256a8 dcf2f4dad58ed2be577e317b83250a4f00f7a5a7385daf455e3cd9cf8506e5c0 76b0fbda33c7ec6a839c4fd0f94109a760dc4650781bbc660f9e8df173a517c8 b8e2feb9a7d48a41f41b2198b2d714a935986340dd4add0c4a2c7ca36d529494 4bd9b8f8763e3f23cf87d475e37e4722887bf9c65933904adfe0f273d36755c4 8ae35e528c9da555bed8afc840c020aabfb6d9a8829f8b504a60d8327d612592 0c8fd19272fa78e9ead26ac233153e26dbe57a2286d8b39bd4f31cb823b5391f 4f07eb49e613536b3d3addf6a2884114c1b7f302e5084ea4454c449e746a3030 fa58d3f8c4fc85850f04847504d010d8f36d347ceaaa7ff2bc973fb975abeb41 dd0099b993f4e22e16d2c03d334d47160c1fc46aeac368af8187cd5aef15f9d1 daafd8134df9516d9f6671ac106b95992279ed8cfa56c3a6b3105dd1bd029874 073b9d59b7b10d9a656d4484776129c9d1a373e2f0c3ce44b14d042b7ab0b8ac 33d512d5139cbd825ff3cc22cd82911ecb25143865f8eb2f5d1fee361acee4d7 7cd81e368f3368d18f25cbf5b49aeeea7b76e8ffb98c8c6cae537ad526f5adcb 691a22a42757feb18d22278a122cafa93fc6be3769a84a766fface5b9db37fed 69fc504ec572b933093782f762ba307b01c7fdb70d29b25dbb632fec98426c5b b4649e33b634dd362156284325edc990efdc9cb226923ca5c0ef6d30a811a319 4a7c0dfc26c11682bbe869273de4a30a2a0da4b6653b94ab363a55a53d146dd8 9aa1ac993c358db18326ec40f3411429f17483222b5a61c9ad0309da69d759ee 5ad6d32bd57731a708f3e2d02d36f5ad0578635720c3b6743f9601a77539c476 0a5b0a8a526c6552dd88e3296455c54984c9b924bae4807e30bf03d2cda84c02 ca56f9cb36b770b39dc6d6b7972a504734845885e7218997e4108fa3714010a0 f3e1c93c3c0edfaf8765d0050b2646906bf1c51ed91f5204f9cea88d2d821079 9a66fbe7ab69a1f955de83c42cd827de420b45786a510d9a8a087e9eebaf40f7 fc38dc6a527a2fa17ef6177b2e4cce70da3c5a8385474642787fb697130861d0 83bdba424a39e29039666c4475e23a5745835344b5df800153c29cc0ddfc481a e43a52b88cab65d6474406d1d00949eb48e4a252e093e43ee00ac913a0af79dc 1f1e0af8fdd2a191c571733639680dd529de7ee10915a68571e36736af578dc7 3283f9f53c53a3e34bb04b2fb42722d402894fa04b6df920bee95d934c59e3ab 0676b5515ef689700c4af35d48e4b80005de449cecd4a703c2c1ede737ab02a9 1b29410a792de492b2d6dd0f87dc9fa4aeb27786706f92e771b3feffa48d29ad 565d58811525d0ca9e29de854f693171f00eeffe191f62726c214a9709d2e013 28a0731c9fc8335f35d00813b08982d6e2a749e89e6818cc602d2dcf10c4c0b4 91df292d4da13148d1630712b22bb83faa671476d47721aa468a07f73eab0efa 84391714db94651aed603b26b4aba8948c01e8298c78c7d3f9a7c6e8116bca2b f8b9eee5c87b30aa7dda535b98f48445f89a581c7ff75a2cdf317f7e727b4523 3791ad0d0d42900211e535699978e95721b6cecee11a8e9b2132efd4310b7e4a 28f40a821c09ec04bbb428321a0a5fe1fb683fa26d22924b17c32bcc34c7e4b3 79a66bb2981976a06d3b039688a20c2c5de1ac5618a08083895c48b0bcbd60e9 41cc0d9b89c7b2432b6cb4b0054413e3a2cc2c4a1cebd29616b16c1059ea44c5 10b7327f135aae25c4e5b14c15dea76cf08780bc4b77440c30532a8c53eef45b 1ce8c1d6be2f6e2137fc02c960e88e831db248472c29ceb2cf1c9a0e0eb0fc8c 26b47a39a137c6f36dd29d42512fef9c739d4b3c41ff0f2d2050b9315ca097e5 c391bffb85b2c5a31764c686549ae86a3c82cb87b2fc207edb429005bd657567 f1978d606a388454fc812e702677c9c4eea3f6854173b952b70e07e84d264c9b 5d8102fdeca171a9db207badac2b58619573723185cb6af8264fa201d745bbc4 d9cb19d1fa3e5e2206364520d2249c7a0344dbb2cd6981c59c3b27e86ed01345 2afc72277cf8dde363d4292761d9eaa20b69285081ed8bf868aae9326479057f 1c203c7f77d2f5ef6aa130450adb0bace5757e9241b3babae0b8a752c3eb9ef0 4a59a5649d6196a0b1faf9f3ea96b190dd9bac8b154eac16cd6e8ed399c7d17b 5bf1368bfb231fbd86d6b9c92df03700a27e9aab80cf882286d984f2ca003b58 22cdfd67aa65b6f5327aa1a07ec26b2f4c33ba68387a50518ba1472d1d2767e5 0659428ecdaa0309d5ce53bb8ab493a8d027bbf913e5ddbe10856d7fe2e27987 7c4ffa87191d3499b94b623db64c282c80eaac9bab97ad25206ec6a05bcca112 6352a4aa0e7e31247350b4eee9de11ad28182104e624e4ec7b24383b1749bf17 a554c9a1e20f71ebc25d721e0fddfb345dd79d46854c2c85660f29ecf1768209 06abe6c8329c336de6db128fb557a77b0e6fb26730aa80e2376d8a2e57336489 befc23f89e0819e724da3d8b6b6a23d572ce4b88d676aacaa75f3d38e44e5b5b 8ef5d4b54a259f2d1309f3f4ccf63cf427d6eb3f3aa8cbb521bcd7465553afb9 6a17e28b1bbd7bdea1afb5b6ecc9176556c9734aa106145d57cb55149b789e69 b9869746a879b6e7aa6cb0d5b7fce651b9d284fbfd5ce627008582e0ea76ec55 1056848166a618fd0be3deacfc7ac8d19980c146332b387cb740f187227edcb2 8294a2eca15026ab1b35244eefbba978361f961124dd9134e2554e1fa3a80215 a126e19fa2570ce541190089974e5b3306407a2a2a7f9ccf07ce65fb79d86434 390aa7d119c4e742d7e5103dd901504d2218bd768235020568c2c6d152b1ac26 c7fc667b7ad11032bf29c3db8fdea132ce7fd9c83e2c9e24e30af147e9e51f00 2e7029f243cdd314adc4579ce4e1b883c6c54b75f12b34da7a522c099ec7ff63 a9d16111b75343a108edc4dd9b840a5d0a485b1ac24e0268957e063f905a22d0 7a4772b3b4add0bbe9db7d92f955b173712d9428104ecade7088a9a59f8cc376 9cb0d0f5f9d711c4645a801bfc6f7345bb1b7cba31d5a4d33f5ded8620453b63 7c02a003ab39defbbd24c1380a473d2018a0ea22cdad419912334a79eefcd49c 226e795ca1ff57946ad3599c4097ae709e83a79985e5baa9b586247e4b77633c bfd572015f0cf97d4b45215ee7737839653e4d28e454b4a9459a65b29b36ef6e cc6223a3fba465ce9512c76cd408c267e4c2e93c73753ff3d41d8b2f02674f55 d072362cb97b8c1f33eb24fc33484edeeef947ae86336c73a7944117e8cdf4d4 324d2e0797cb4466affe3ed44d10a06586e02d6ae9c6648521b453794622ae34 3483cb30749184a978ae8df901377003d88ceb099b223873d1ab9a57437a76f7 82b796293932cf54d5e1cf5ec16b22b9ee69a9fbe0b73ec2fae819ac8de65a16 b60dff86788c240a2253931dd1bfe6f6ae203ca4e6c3128c0e72959e11746706 6b50739594944244ea398bd063e50e93ef0397420388537aa2eea76d35385af0 e9e92342db01174760df085e233f41789f27c54ac52add384c58e2b54178ff5b 2bc0f97610cc221c2494cb5e33be47316c9bffa795593acc32783aa988a668d4 803ec23a9fa952861f06e50f610fb02bccb394c7ac84d83f90e2d03da96e1b77 711bb1edd7a1e96edc9d9ac580fed74d4657ecec5ead9fdb844170043752e5b5 8d977d51a943fa3d708d3bffbbc0c43b12034a4053fbc63136f86ca869def190 9430b26dd888eff36137cee3f7c526cc7d321fa60006cf870875cbed3ab6c11b e330b404e8e21dc75bd561079856c39b7dc598827db4606d1157778afb8c4acf 8ca2178cd32a86f4ab5b02089f717c546c3bb6449956f1ff025e7e1cd5e22822 6efccfa7fcdad8f4611ec176e08d7911fef3688c32320242421fd70672b792fb 258cfba638cecac1b328963c9d3a2f7fb0af7b4c63fefafdf598cfa07a9aaf5c ad0713c745e8b2f166eb8dc02eb52057afd9155870de2a57af8e8e09567aaf82 09bdbe7df42b20c3d792ef454414a1fcfa87d23e4100184690a54bc6a20faed8 cbdae18d453d4298c7a30faf9d821afbf859ad7fcd442c8ef3cf2e3513eb6e6d d8da45b42cc1ee535abbe7b106f0bd5dce79be491914b5fd466b27c03c3087dd 7754ba7ce1056280fe2900084157280ab1c4b282bd35bcf581eec02ded2fc717 c2d3f6527cdaa4f57b9dc678741731443f2cee5294a290ae51843665bea2ac16 df53e1b9f723fb4b6ca72b509a7639bee3294e322a9c3c102c23b1b8f96a9401 ed2d8aba0bb91e05a147bc742e2a93a6641973f90dde35f4a3db0da708e3f296 b56c06a106819c281d11eed71ce02d79bc90db77a4c61e4e460ce69fc78340f0 b24845f90c734718cad0f2f7615ddaf9695c628526b8e250039a46096ad422a9 3ea9c0b1a87c0c8ed5c582057fe3ec41d85edbd78cdfa69260054c4ffaf2cabf 61dbe4432bcfea579bd9c0ed2133f8828d5817ac095c91aece413f5649cc82af 3618a114a7838af95c99e1816ded4055167d37eed172567020eea0bd14710c98 9b651d719305d0168e6eb1693c118227b60f143791a03289c5c29162eb8c10f2 38a9b96117a4ad251bd44fc5a4bef42aaf9e3bd7ca98bcc41f05c2960e50b434 e964fa3d8e32c5cff950d09e81b2ad3a8773e0cc1745410f84f5b498a3fba85f d373ff4e6253aa46208016272a1050762eaade074369dc2237e5f511ee11a9a9 227ecb8601ba1efc57480b5cd3f4ef58b3b0da79907b902b2693656cfa56b63f 06afc6bd694904d8a4c1fe0bf71800de773ea5f101f6979c79a70c08dbdfc7d8 2787e6251e3e289c24a0ce77f361d44d086ffc6a68a915d9c7c832171150ad68 3b2a65a510f0e13bf3e1237328ef3d307f722512cd46ec0c84d9123f3ef88a7c 056f9eef8ac9cfb4a070cb38c8d5a091cdcf7da25612b1c7253d20b9c7a35ffb 373e3798f38440f5375b08ec65c8f5fab55d66f019733bc9269d70cc897ecce1 b6a8e8ba03e88591381a0b5daa854bfd0fafb1a6286dac73ee83eecfa253819d e587f863b52c4d7b0448bf14e8f00bc7f1d341a6dff69922ba93771e0a706687 d0a8f67af03efb1a8e336eb4ef81bdaee8f3bdadb38ac9e0e609aff3469bc4e7 bb099d9d42be4032acf4d2683f81b8ba45f16feed967af69e67ce9a232cfaba0 c5411f841fd1ea51a68fc7d76f6abc432b17d82bda5616ca92e50204ee1916c8 a81bb28834db72f270f933e7309960ff363a5457e0ed3148ce1d87323cf13852 147a17af4e35c259e0f48bbc3931eca980b63db68c0a5735efc03d2a2abea84c 87c80db1953751446db9de993efce65269fad4aa3710c7ce6d8be7efb5c78d0e afc167b27fc3682e132b7c801288746c91df8bc4fb8b13b94a23dcceca0e876f faf0fc8ba299d75f2825f041c599bba1b1335209aa605857bb8445a82007b6e4 9113268c30e728ec593db4224e7991f728f80720e5d2a155613b9d551637156d b9c7d2de03f5c2026ffdc125bd1ec059645e2dafb9a31ef1c9b788b0e650c953 75733465e9d041e21018a4ad6252b214c198e77276675707b6e25be6c7b06d75 2cae7c3f96c4adb475f463f3a97f06db119363b26b54d58bd82c3a7eac5abebc 463c4d6734648ff78ee38f8e84a912c3246aec4ed4332695e22fbdb5c8180c10 830f81d76a53ed4f25f6d970fe796c13fd7392752e1f607dcecfbd964826dcaa fc5ee79b57bfe5088db67e08f4842c6a6c298bd1bb0d4c59352ea7a538820d3a 735e5d93a15d0b5245d16d3f215bbe5e0803e0509fbd26b3f58c0161093ab553 5f1fe4e4b9b0a80a1b3300f7ee59dab7695b176dcc26efe6d7c7bf911b6336e2 1cccf50645341e56b69457aaa46c112de194d1e942661d75f691a7149e4623c9 0514960a760109891e68341dafb008796b55ae51029f9cafe2822c769493907c 81b38df6cd550b3e668db5d31159d2d9fca1ff1e6d44320e0f43d868c1355288 30d1350568ec02a62dc11518f7b1db974e93fc97ed51e8a69343b027b411d1a5 a39f68f2674c62108c2bc0b75775e810f5efc09e224af870086a4be789ce70d7 5a26c736de1301dbfccb8224544f8c9e0fecf7730047925f75854b626e6461ad 5cb8acb0a68ba861d759147da02785341f293ec5f2b9edcb4adc26b8bd9078b0 f44111a669fb25089cca63baf48eea28d16575d61c76a113f5e8fa173cd4acca 5e064407b8ff54248d977f9203bdb1dddbb933062a6bfa3b023c3ba5c7f42f01 e05232fd2b0fbad94b7c4746563f4d35860a190863db8070f281ebae9741d607 a2df3961690402b46133d2868a67dc264c5147121fa44d82ca4bafb5965740a6 109da6b3744c66645215fec9aed9c5ffbb10a3e70258672cd91d6e478e265e4a e839ad76fe7b561193fa1c1ef4f2083de45b42c670444668b4deed4d2e9da0ba 4457d7124b01d0a8bd07028e678fd23a6a6ca1ee5c413e0cf2c3576fe08a0abe a84f7fa6b704e9fb8c098f56e4d152b90e6952484c4d4098ed0df3cc08bf5cb0 e5ec2cace05c7cff704de3735a947e4c8d3cb6cf654582795cce515791d9037b bfd9f24bd540f1ca988be5a1ec5270ee400f69cf8a276451433249ff889e9c41 5f92227fa78eaf428356c80c577afb57209e9e322cc51ca1e9b08b58c1ded459 708bc3edca544e220fa21cdf699c02be3bbbe8d88762f9fb0c8cb652a8766333 889766535fc6a2f3c61e401f737c476739aa81a4ac9078b9d8bfdfdef55471ec be631414b8080e62aa03c8af9a2bc41de31a8029ba89695a1d03bfd671079401 93aeb81773fe1b1e97e13f34cfbaf23fe2b2acb6150be1406b9574f988c6dcdf 8d9c0d4ef1c848dceb8770d14bb5d2435c3b0d09cc5ece0d8d734c0ffb50eea5 5d316d6537bab76e9a04316d364142b40b545a2935e533637b2504e25b6f17c7 685080a37cfdbd9f8e71ec3a8e7903cae357559e166c8b089485eaca8a29400a fa6ec260f58fa3163b1a0cb2825f64252f47fb22662f2e5f0acf65e78441bc02 513136bb071eeb9e5b0d5a6a6ea32a3de437bcc7ba71bd7ad4ffcc4207363100 9a80a172c93e82ccd11d904a1be8bf14e59a096bde4cdb63d593f29efe877d13 ffb831a31a2239f20bd8a56d552a93d8385083d8d0832ddcc3c17b0fd5bdfa73 20f4b91b7e98fa52f15d707c6426725bb928ff3a1f30a9b175da8857ac03a280 148f55b8baf0ee30cad2985cd1f65fac9a2b888c0c8277d30e9983ef935b083b 6cd46d1e52b8e21c731aed4c1fe624a50e72143efdbba62acad10210e714b3af 8dd27e3c2ce2aa473e351a75f33334b18d313fdf04b33873676ccfe0a0192be6 4f0a1598aab63406e1128cd6d69fec163e28d4925fc01df8da44b4a21fb43323 abbf0c6077d3acb5ac399113d643637faffe2af76d100e36193a68f9b668bfd2 298a838b954f7a6ebea7ea436c3aa2e5f6a46bb76b3284b4218ee4a3aaec94ef ad68bcc997513802d5d32febec94bd480b7c0a2506b12959daf26dc3c434fc4f 197cfc3c972f13c96d90bc075c109972d24150a8fad71bf5b12a883ff4d6e3dd 1839880329f78c5f04d824986eb217ba26881465221f6fa6df35fdb5a4f89ae3 df438cee0d3e5f4b55807182b68d3b02187db6dca50862872726ff3536f7fac4 8d2f392ed75599f94563c74b27f52e73e16d508ee2ab7a6ee5b5024c8a9ca36f 1a008f869455e551704a462b6cf8f5f9e2ff5b835ac1e56e305ab259b71d59e7 671a05b5c7c2c596a306d8e8637137b737fd7a60194b48a65720acfad684d644 1450b1a4b64b6e1770cdbdcfc323c9bfe17fe591fe22df0f82ea09b945aa944b f1321676fd703fd31c1cc2f57568ed1089affa76b86563ac3b8c62388a74c1d7 5d225d5b686b78307148b76569fe25d8d40ba65906012504e793a78b4a78072b f821629da8acfca9aa46d35a701c4b3fc3f9bdf1a4d6f5f283d83b680f365b8f 720f46ff1ef8a745b712b45ff59522613f662541f237fbba0d363345e94a39dd a9953ff55095f3e025f98fe89c70448ef8a0dfce98a840d2a6d7d7b8f7931b93 0f590a33710792e7c7e3b95f91292d2e89a85b2c95daebe8471af5718d244a0b 741e7a1b0681c735dd1f869c5b13b47c15f2e923392ecf227cf2705b6c3a1c05 3f8b8ab99e04547b1b167293a04ee6372b953f5197ece1c00c56a4688d207257 369785e785011a69b74deda74fdc8224397e920aa028e4f0fc15505dea73238e 6d8d1dd1c396cac14cdcd5f1993bddda32d5f425a5d8bce9af11a78e4d083bb5 80ea9f7a6a51a7937527a0d33a9aabeac456da51a2b122322abda57b99f8f334 368042a150049dc9f1bf55059497b0943d41542a80390f0006d826325d80fe6d 3d62b286c69e9374d3f08a6edce5871e57a40acbbbaa133f4d4782a2273824a2 6b4be625c2f8f5cae61413507486dcdb6391d258ebd6b318bccf67f61b6131a3 f5fe28859a20c253f08bdbbd2f7881e5d7df3d654c71248ff46bd555400e8990 bc7eac3d644184b4d24900f71e0305647a622f555851c0cfc62111cf9677f67c 86c8bf3322ee8bd3bd8073408a6b6868414b939619603d935c2e348a3e15f5ee a9376635f9ea95face899ff8eedb28c5b2aa27d85f184e1bb789181b7746cb1c 8f2025d1af3f58dc4bfb1fba15b7cf55967b0673b14331e306d1b20597730abb d145d1ebea4631fdf8d422cacb2faac25ecfab118c25d5fb683624791a621189 25404d422b37235242b30f9fdc1906cd4b12ee8429e714ed6c38eccc697495df b5b12c0dde77d013b19d2601b9326b08ea4dd87f2c732df4d2058eb6d20ae890 414cf828db333acc02e65f0c91ee10b1a0511ba5168f501f796cf6e87f24865a 590aab5db0d58113fb5e6c9bbb2e859d09507590111e779e16457ab42cd48fdf 4338299a9292166cf5ad4330f66a1eb80d0a2e7c54a1513788582a4fc9d56380 374447c6d6ca03c31a1be4316bfc55f9d0c9982e291b65349158f4dc250608087b689134cfee04278e8efe131f521d38bd2449dfedd943e4daf081482bd9c305bb9a9ece96386b7ac94efafa5548b6e164db7f1d6eb12498eda8fff356cb62035ed79e5a0e14ae1519b689fe0571de932593e5362415aa942c2ede5282b11e0e910fc4e826f2cdd52dde6479e19a4aecf04da9bdda4e800fbb2398f95a13450f15a62e8bba8af17ba67e905c0ea8f9690eccf7080b66a036d3e764ea3e50ae0e940a8908354d3663ce452bcfdd3abb2eb731a4e9752bc57cb29ba0018e23250e95db531b60311a238e83bb9b6417c46f244c03b387f7d755f2bd6a3c5899390ba29256511c4060a4b1af0bcb2c0eb7a81cb7c7b8692253dc31d7b0398ee64000f71cf43502eafd848da4267cb97d1a312c0d0d5cec4c1d7ad6cc6bdf9787b80bac103abdb63eb8986bedc79ec428b43bcf76a67ae085962f4de6e7b392572006f2fca94d821a9dc03a43dd91979095a112a4c7d7112a1bdabc869a20b665dd0289db461f87ec0c7748b0fad2cbb8489ac9896a9d390c55222243f4c7841cff010b0c767c378073a66355c7c5ce0e7396196d5c0e1caec1e9ed6ffbb028f4700422c9cdf5997f2672353bb91c450377c80dac17143e8173b1d2a38b8da7cd600904f04cce2c31ca88a414ffdd0d7c6b7cd43d56733c21856ab3e7417aeb1ebe0420cd2c36e9af614df0d02c2fd9ef377f3b76947b9a56f89aa6e0743efac0570238c3776a45ebc503b568f90c2ec31507829cdce1d462f2075050817e061616029df6680d654113699ec1f94b26bd2a05649dea06888d7a42f9b00239c2ea010ee57c43fa26d20b8bb4d3854723d637bfbea03fd86e7049a64ea5481ef6d92d0ec5648f7e4a295a1f5344b513c92eb8ebf555d638104325abfb8a54fa066274017fffa73ab982d83aa7f11f7fd3aa985989c9f3798e9c7ffef35b4c8c74177a0d40ab16ef1d7c65151cc763fb28d330303a5ad7ebbc563cca1dd623fcfd4c030372a4f0b3b14e311c5b092bdd7c389f0840c201188741b0a32731db4872e83c0c02f56d959fd74ffb2a19c3c2fc4c24c9ed72b420994c4de7a5e49b970c3dc50c8ce8497969ab56d38ce2767204e84f5254c22ac771f8e832751b42b1988e48061e10b0d40952488566a4cf758a313fd123bec4f2f3967eb40f561c4aa267c4061b37c2642b509b405d6c90420d9aa7273381f54b73227ef3c6884b45ce32dd0c11e309f87c2d32d961a6684849f47ab3893d0f7739e2a8306206bb4a460a6100a66c518d3dbbeff0b5d109ac5c31edbdafb1dd35facbc9003b7577114320a4048417057b00961015853a387385579072b9a90718918168151f5108e324143a029ac60fec6ff77c560f785dc0007ac1bd91906e545776ac13804adb5a6164a906cea23ed0fcae8be6148458bd81098e7d733650a593df79269ef48f7989b32509c29d6bebd347fc56752ac60586b9bf9e8873f934b6a9855298f3286fec0f8a00680aa0decf2d735960db27dba29b013a622985f6ccf149871c69eaec4612240676375a9f046e0f5b40e250fa07b28ee84493760006fd2a89ae150bc0b4fb4605e7bb721d69e87d0b4919ca3ca21cbe17ed6cc4b44ee3bb6068dfb534b727c80cf1814612822b49f933dea9b088613cc3a55cb3f76a022586c8af05241429350c42cdb65384c61a8f029b48e9fdd627321b7e620d15a74b0dead20269c77cad0e9d8ce02952357e78e17c5b295b6ea67be7804e91aa22ddc92c35c41596e5130ce2c781462368f159c1d8b0254f52152ec3fd26c16cc562f6a95e588ca9e4200e8d2cb3ad37ee46e5e648e6ad2cae494c1e139e1adc2491a58b4ff24f57ecea007c09510198f2bc269b320ec6091be69c31330ee2a79b12994e5b3a95f0e14800b532d2ec17f35b0c71c90e496f5ac8e091e4bdb8e4735dc24b1a650ce83de80f51e5a99b513c4df8b4afa359eac5023062d02fc5a368af263ff68c820bc4a3069eb590698fb209cfafbc996fc8bb190eab275af6672f4e30ff435829dfe82700e7fc80fa96e35d51a1125102cac169ede8a610b6982e29eb2bf4446a70e84d025ec3c0c2273636887790ebf0556bcd314695abed14229a139c5367a7db772d02cd1fd78ecb4a9263487d1a63355b1df93670057aa2f09b0b6b757ba204bbfc082468494a178ed5b4e26cfd735b8728e327e124af7ca246320c365e63c0c5010b6b191dbd66d4e304734d6aec77b97853ff6cb7dd2183a0035ff5c2be7fc54009b19f48fdf1ad80ec57b435d0aa719987dc194afd7b688aa67fcc1a61ff64840dcf535eb9a73ed8800c0affb552800cc4d37ab8232a3c8e22411496166de72808a51d94360097062af69923234ce9ea64342e8bff64f8a05588f8476b325424094607a60ba596a9248e9f1dfb5bb477ed63601e479b80c980480a4e9a15399d09720bcb648b6551af3915f1a92a7c0942fb1cbd5212c730a06315841c6b087a0f038f19d6a6b7a51862a38fff37e4a474e65f97fa4f5abdc44133b81d909421025482c2dfb8c1092a49034de15e56f0687905d3872151aba59ec193b6c2eb1c0522322ed1ff5b6a6da095e4a26dc713f2ad0378def7085e75d4d276aeae61ed04811b1051ec66d618d68820e90be1a6f3b0809f93ad28d825cd256fb13e4ef506fdea32dd18e07c4689718c7712ca8ab5239a6ccf0fd455fd9480e7349856850ecefd4bb0c9efd094384d93cc62f523007c1cb39cebf4d5ce4ac3477dc836f208f324c9dd30a96f2c97977f4995508ef7cd7a248c81a2bb19aa6e6dcf213772088fddd56ad7113936b8acc04c4d90a5a5069bfbc0e31d2da002dc3e5863039d0649644776e30b476f8be51be5248e57442a4e587e423f01a9d3637786810608096ebf9d753cb9a2ef3ba6502e2c6883cf81f29da2d418243d958f4b868fd7660dd3b9fec23126ebbff301939cd76df77ab908aae0f4253825a32a0864fc17550cbc6bc054b6970d30123178d6101dd9c0cc4d9c5b7ab07273b50a628d1f787300e9ecf99a8e04a33c11fb1d23e527f97e9f9980125ab11730aeee537fbb6b3d025c5e770c9524683c7c7d3b1df4741cb3df94af46913f8351c3350923400eaf00ffc0014ea1d67d852fdbfbd9b8849c5237edf1265506bd4ddf33d2fca708de00789c7e472ca0ee7264d153d9d8ca7624b7825050068c1a5df61064f9102ec90121ce2ca17fea90ea0c057c2fe2c04671860e4046f11ab781fc2e131b787ed20584548172fe4ad21f0a0dbe787012143d65a5be7415d119fce412dc3e4a3b9d0d1ceb4b06b72d3ce54953ece2bef8f070d5bb0f017c9cd26444f19db3db72700bdc7e9247ea47578271b8fce23c7fbb4755dab07bb83bb8cb22cfe8133454fc0304abb7621baf526e87a3a49e857d58a0c4eee554837825cd6ea3fd6dcb58df0cdf438db51bb4d88f3d50a08eacea1a6c4d9a0272b3c10821d3bbebb8c6c845095113a157aa5058d0938887b9ace1de0713979e3000c9bc6e62a240171ce0e101eb74e86b28146244aec09b3e597c22c68b52ab2e05f03c8067b9b3e87a92b00279f460fe6f523929c97b61238ddee46a1d5fa1b089729d58f942e69d701da30e910aa06f2c9593241b963ae0bc2c0166576b28c30852d8b047a3e0e4c599900fc616fe346aa72ced504df31807167ac41668be54b63e185245f80b089a5fe9016d0b94918a3f9c55ef4bc89585641a317cc7d545dc8366a8419286046340bd0a1b67628343049bc4e3e27a613fba6ccd73c51312109353b7287d699adf408808aae9d7f36d90a10778a3ea0896b968a21da83ab1aa4f8e109630600572c83b093b17d41c58edc96add4be78da0959bc8dea6345771e58e5e790f746cc1f5730011e61d0d2247aae3ce8c40445b9240d88575519b4e7b837cca65ae2fa0e479005408fc95616ffeae777a79108694a6fc20495aaaad713fbf4222d1be6f3c810a472e4bbafaa60155e7a71392d56147467ece54a305c6b383308c6413f8750d091cde03f3afd0bc6867d7775816dd1b9223265ffecb76eabf2253e12c7802be0b89531b2582eeb8c6b412a361eaf5285f57a11c741a27f5ac2b94a7300dfe510f6f60332d2242648508db99c6311d404191b764bceb715241683f846ef313fd0f885c2db4b71d993da7e7df53e0ccdae9fca6e15d3c2dcbe5aff81e6a4d0e060659820da2214c4e8ac7a41ed1a717231d839ad943e4b9572df21976ac74a1d10c91a5a1122f34893d5c70d48a14b0e56dead833ae0f275813e1e45888ca3f55069c3956bca87ca7f39beccebe4abeb115f2b1e03697c214361a5eda13db05a003f95b706789b8c2a09fe95279c6ce2ac34b9547ed2bd660e1bfde639b994dc20900722d10de13d7636d50e2b55f15a47c78fbeaf14e9172cc22f7034c80db2b018148879bb4512885771c9b97167cc8704c34ff0bf14711b2cc9e0d1a199ae10408fd10cec76a3fd5089f62a1d5bcf1c7200f55d89ed1bde230053927c436870e3ce558ff287d8d272ca07fcea28271e5082b5b71c3bfa7e56775a38ba5d292037093cb7c12265e32403e4a65fb85ce98ad687ce4b78444db759ade045ee285074e85b2f9ca760d7b7b4ef9d13637f74e8c89ecc902e4e48841ad9af805408807167a0ac2584742bbd133cb6d477a8d8968ee3c5818bf1191347dc4fa910ed403049c5c44ed0314b03f3e38fc02927b037723f9685848e90b6ff628580341c8092742bf6d9ce24dcd490115f99f847e08e5d4d27ddf00625ff863f61770dc5008a3728097199c682f168ebd593219cf6ed5668b7fc0c5af3de78f96197686e70a00315a5c6f522631ea69f430c2f95d86658620bcf6d3cd4eb134a05ff86e370cd07f2155f8d9f7844e7f7c3b7c5632880719f62154888f78133e81ab0e16ac02fdf86f55bd75ee3027a572970cd385b933aa58602b35536722dcd1a3b4a5b20295400305d4ca5b2e9b2a07adbaf79381027235798b03f2b0cd2a12dbfa2d970bd5cb6c4690e41eaf079a60e6891f231d4d803ab9915877a39ed1dbf04b3e4101aba146b694995602b4066bb446a0146cdff8015ea1e765d217f0b686455c820dffcc3c46a5ce3bd81c199f468dc49b9905c5d48948ab8e9f162b9f6deea31e0feb5aa273ba4bd1bfc62a353a3e5f6439512fb49ee091e77f3f14697bcf0a000570f60d262d053e688b0a38862c35ceb06c064a01a18a08641022dde95a623d06f7de118f37187ffa0fdcce83b5a5883b2b7cd60b4a0894f87dbcbde6846df303dd66f252c895b9dd6d390aa291fe712d05979dc5d633ec16661a1c6c0e1deb073ecbb168bd92bff652470624008bb39e7cdfe00b740cfc805d861a6e9237a50ef8ffc0b9662e5bf99512a4568a8493c92862bbb58f46eba41147946bd5bbc0020adb7688186ec3b673ee540caa52422a83b89883f7152883b3d5a9914a43280d4fbe1ddc8b8f09a16dd77276be826cfcfcb50fa4e5ad9009fca53b51899f76001e2fc1dac9d25a67669aff3f503dc3fefa58c420e4b22ed9bf7d51cc15489a0b6050e777019e10fb25d1c5d77bb9b684d246eb66cce83eb611d984c12bf1730a1327b3bd93c8ccbc417773e922d678438b65c1cf3d570bc43ab93968ecaafc0cd38b21a588063abaf4a9cbd7b0e6691d6e6d4ae170936228d4e6dcedda247d0f97873907fd7ac5d97b8f81aba018d80b2ac30655de7926b3b33fd7bd1b7a070654466fbff0798405e2adb0b96a1676b930cb7a9c8b2a46ad7305690756d27902c91ee6e8bbe240801c5b1cc629246d08b8d8a806e1858144f131bd4fe533140d15f105e49c0445d8d50648dd57c53d08dadc678478d9890826d1ea5883018903e42e1523d5995c20eb4ceefd983c6fd7f6bf1d701e83adeef59eab63d81ece0327515e049ca5e5c3a8c46bd0b2d3fd913173cc5196a40d6577ec07a81b515107ab08aaa163faa40b03eab5b565dc508d35b40367795b4e6e436e4ec0a7c6620e22a9533a9f72ecbccf0c2ef9a06a12ceb6dc9eba893fc77f8e64c4058761c20286e6b24a149532f8a7bc6695a2fd24c5e6d29aafcfbd6097aad32847e4dd9900818c6959f18a2b3eafe2a30dc53ebe9265248128aa6b0ae4bbe2f2cc96d9090751eee8f20519ee0d7e11b7b914e4c0ead26d43db885a06d8d778c737c1a709098cc6c30329dacf32c0688bed4d59c60ad5a55662462a534ac11b96d03a252d0ba62d1a51fa7ed723549431c1dee36a698de82e997324155cd128f604ccc3340d9464e98196f35991f5f820b20103286e186079c99b4ed12c4655b1f07fc16a09ed44d342fbf5a755c3cff177708343bc5ee1d548411510dc92546a1f61780406388c0cc39f844eebba635c20c2a10eadfb29b84203c54a30b0a13ac03d0100057301fd1015e1e56e247276bfa04741a4710e8e8f324240e74ebf49d3e37acc0fe9bc6ddf2843786ea7285bbbc9e03361957d9aec1c47638097960153804d540a8b258444eaefb3fe21571a75cd129e6659deea80def5f2b7a27b9544f89ea20ad03f777f949d4bc0de1af88f57453f38c7bc75764fac6c571387cf2aa3ef0d09b6b527e50956b1c234e2488eeb9f7e935d2fe683b3d562bdeacfa058f1e50f0a17d8ad9ba7ef65a393c503c3fb63d802da916f019dbdab5beda55da802146909c90d38c46880d57a41ab9c9284a065106ea5850ff1ffb85cfbf6cae2ac14bd0cfc28c21f3a6005c472354bc59f04df0eb84825de7e2e086fd3bb7a3fb7424a0edcd729bc064b8ee4ee42c05d6015da5888abccaf2ec2c2e1c7ce6147d82fb300f00c9cee13aaa8d98a9bf2fd110b5a8057f1d572315d5fdc4e6d20ab622e50048376834bbb218e4ed41eedd00fafec5d373625c38abd77a969d9be79b9ca0203f1db293b453c57f5610e4862ea439b4f3197328e475fa7f0ca1b38995da3ce067d432ddae6aaf99ec8c3f496befe6b47de7950c84ede6cfb6b2696438732150a151ba7bb5f8395539a75ad892c6c059ad3007d0944aa8d19b2041d0056702e0e3e11dd72199bab60f63737712bb504a220e3b96eab71caee13614ff43709450dd08a83a596c6517de9181477af29d8d4c0a53982cafe810cb70833d2807b090a1f3313cfd4a9f6215760e11f4f3ebacd1caf41dead55d09de1dde73f12d7970d467f9ef3ed4c59eb1a5bd16bc0710a3623ed552975070d69217d4cbd9408f401553817e59c17d749a2d2e1aea28098b14841cdee8af9d0d69c07f45a791c0e0cc87f22728c5cc385eab3c6f671e411e542a304ad6d356a3ec958ed12627d720da363c704ece9d71a592993390359a0bc5ed09dc201c072bab62c9bd28f3ad90edf21ad2ff2d29bfa4d89ea6ff151eff68829efa6e47f5ffc83dab90194f7110050b73ad5e9c6213079a763c1d700492826e805c0f1d917e33208004aa2b9c50adc650bcb0ebca63c49cab9e48cac257a58e066374e769c76e38916e65a14650f97f691b823e6306f8241f1ad8270929c7c88ff227cd2c14576f2b7263329ff0c48b871eb19d8dea4b81a5a6ee87e7035de2162499b14cc3e0e8e9a5929446c096e769c42f220779b7cef61d3069c6f9a7019aa7421c005d488b9181997d0700fcfc2d3fcb82219e18d2769ac227f8bc60350a70855a1a25ba738f13ef0ad0e03a65332777f25b906fb47561d24d33ab70c589211111a9f46237b430c27c6920afaca95a2600179e6c995988cb2c90116bdce2ceae46dac5f65a06f845fceca02dd343fdad28ab97b56b60d77dc34caba2ac1648dcf7ae973507e7df3c602830426c53722feee6099fd5eeabf19f8fb2c8b36812162150373a44da942e2a029051004ed728d3391d9b12383f6dac98907e424857cb1503ddd45d3f7e93f458700d0ef34e4bec749d5624ec09ddc106d4841f4159b156ffce89d98e19b6a26a80c217957daf3d15e803be58d6a48805d7789fb8cca047b7ca780189639f7f88c05e4c7b6ab1ebfb37089d9c4203ff36f1b741fc9715fcb7edcf1db3d1d2da0ba0fa78eacb6311d77e38b8aa3b62d927dc0c16adc5a982b47b424a5b2a67ab0e801c85346d9c831ccd5104f26354c21d7477f347b6972a6b0fce889575d5aba220734610b40567b89a247fa1bddb57a85a8753247d1f50af44bc76bef8ec904f70c68d4dc9458752ed25eceeeb26b16666138192a349786decc349d1f12c8ff4c012cb518ffdde36b717ad8a186e95b896fc3e4207dcd355b30f031a919a18e7c0f5a6d3086be027c12d852cf6c6d07923a0bacce8baee61fbd66b2a8bdd088840e8b53f976779871dd58e57a5e0a70ca6bbe2d1c9c8b20f9dcbdf92926e2ed1c07562247b9d9fa7e4bf1b52b1df1a5acf48984cca814ac034c5afda7182d5f45010b6f296519193f0750f0db07deb40ceb37518c2b888ce9bdc59f006e278fa80378aa24c6b25d7f2522376ec67ec20f076f74bec26a0ae3bf50791d0971f4490a7b7f7adef2ffcb482a3c92dba61823a270686fab4e07fe19265950d310911909343ee59b1db30f21835162fd0760dcd7f24b8ce79d8d654e3f29a906101b2403f29aa641b978f8b6d7cd22b071cf8b0a141be1873a2769110f1463455876cb0e61e383b1dc04c461daf6de60e1237ec233f8198f85cb30e53a629fc561c28c015c8e7a22ce8b64fae641d1629fe284af7dfd2965546dab81c630e5bc5f2fd208aab5e1624883b725e57f43549754d578c1a1e2b6f9fbee07902fc9b442bd1c015a7dc092b54d381e94e8cfc71e08177dddc0bc30ba9b7cf05048cee0b9800e0adfdcc0f75d1a3d42cb031d4db00deb844bb135be503e52b12bc7b31529ae0302e0feb8add585bf08e1b9bbccef453232313560cad3146487feffb69c35556608bc752c3124c3ccdc5616f783bf7e01b583f986d195ebfc259f27a804e06d2e01ca40be178baa62c15586b2e8389d1613916754bf0cd704dcc8959f0775c1920c8e75baa403dc9f85cec8fb26ee5427d3f266c236cd9188aff2b36022c4a1750b0c838670aca6c175251cf9f19a673b8e7c564a7a97a89d46fe545a8c29cdce04e4392e27be3ae1545f2b6ae8d17602ee1d131215f1dce0bb4e1e2f5218ed9201cd3d9d4b53f6505bacafe9fa33132661a1c7b08492f58ae24ebef01d11333a08d02f68fc28d75072fce9750d71838dfc60143fc46ed375036ae4f8f6de54d0032544871dd6f15114e80a6301c0e0e5f843e5e1f1773d31cd3f38bb77b4ec9e0fa1921923291b64ad473bbb8467e56ab23f18cd3102fda4d38d2421c6026b470598d2eef13da83115385b56645d479dab7fed6816e6c18da077b14d8ba358d90e635cce99998d1fadf1bf2462a6672eae29d57c8af5ca61a7a7dddd39630d350d80a9eb7891aa3895b09cf299b6ebe47a557a4aad3c16cded5ea59180d15f8f004a93c8aaa307aa61b12090adb573e2044fa05f3f1c26a6b0ffa8392c5a8d1c063277404fe01c5746dcfe6b8b74b1ef53f5b24dbee44d9368279827183202120af9471c7ff288794e956d15222ab18980fcd0b459ae2b52311594784696a5c30f332862d8ba626410f156c2dd0e1df76c413ef189ff930fe84b8d28c2b666ae023e98a10b9b219c8fa86a589ada72ed209d325183325feefffdef959492f12007a0a64dc6118fb55e5e85d16b107bf244b9d6f056b7be11eb3d610aaa4b2c6e0f373abcbd35aaf545302b585556c0e5deacfae593bcaeee0c62bbfd9201195d022ae5ea81a8c97b9918719e279e54903914c1ca5a73a6ac247e4d6d3ca37f5804db63af09e050a488c8a882f54bab3982f3c15409aa48c9c2142428cf4d53600b8128cb7613afa66c3a774180d3ca90b2abb8968b57f3ee240be29d1bd5bffa0b1ff0549a2060d2c8f63b93cf088225dfc071426029bb01ff38361cbcaab4ef009a0b7a14f3900f87b1c91003f4d8e4ab3b556eedd9809939c7e326aa71962901ddc9e281f4f3da4eb522d70e2636adefe3737b3aeb8c9f0a71a038121f1e5c030c8ad8f6d35ca5d654eeb1eded4542d96b9b0a5e0b0c4e46c1a8908c2bccbb0cb120db2dc5a32978ae979072ea5be48de15c9d841fcc15395f00142a13ef3a0e40eb0c91d75b20e637517028cb42eabf91db7c2e129a0fea1053f98ba3e8c9017496f8b73bac805b3da60198aff7efac6378887109a9468b2e3e11c7ecfbcd0f774c26cca98faa862a97d360bd7ded0ed6624fca3c7957c3de26d40c4972720119e3d1bcf9c57d1ea54d9b319266ce61ea5bd5e49c5131812096d7dc4b75900dc6f426ecd7ed679c9ab3c936fc3d97e94282361df18aa1a45556c4ddd23eaf07681dfd3a37d1441b583da4c5c8a398b6749a50f22512f8fd7fa7451256a684004ab4c7267ca8837280d7742218e10e67741d2e7979c78bf598d5ebf560c2b60b831970c127b47f8735e8109c12c802a112c1f8c11378defca341ee16970cc10c4ed80189eb7ac1ef18a6af6c4dd4ae98f3a868bafe24236aea16bf0beac076032d4f006cabad35f4beb6864ab65c81ec278aa89fdb8e1c27ae7cc18d8fb8f809f89121b6ce60a9cab89d8f6f413fa75b0544e283d605c4267ee18d8b476b9a00af0613a0ce0e34e4f8271d85499ad170ce4a6a87c234c3e09ed5774b5421c0053da6bd3a7fcfd15bf500056399e458ab6bf2e342ef52d1553dd00bea16bc0b0c308d0836f494d8b7c7e8bcb3fddd37e8b52200689c3da91803a5ac9399c98f0af02e01cdff8626d75bec537f8466d82a24d460c3418fbf8e753643c4501dd40441c87d0e9866fe3104d77cbdb7219efb48e8b753abad2342681b754698f28b0f01af9c43fac46d76d5b0af7838f04899f7743bb60c23f9bbb133cba3b5b2af056fc57971a9819d52ddffcd724784839332558912d51fc5cc9d3669fe7c884d0bb3db30f8e9b4fabeffef903a9f176adcbf6c1f95733718926c929ff772ecf505470b30b1486ebff9d124d4bf9c8ba021bbee6872715f1d401335e6044641f201eb5011fac26b27dc79134d7adec5eecf16366a8ef8e9849d8cf977e35bfbe90a12d82b64d984d873f8727a9e046c0994f2142461e80832bc388c3f22f379770b80beccb066bd7f3500d9a46fc8764b6ea14dcc9a3e6ae7530795448e30a4ae0076ffcf2f76479b2edce443d25392e59d2832d0329d0fcb9254f957468189d307d28ef66679456e5c786771ea4a2706b3d4e0bf9d9eb962434d939f474d70060ce5af907983f8732d9df7b9cfacaa97b71143b3a1ea129561f90d8069eb7e340ca96bd83b8d334805f329bfd18ef66596df8cae4de38ef1f96db77e42d06fe80f86b638e3c511ca8b6920a268372b8431d563224a8b4cb33f3bff801d3ea0280297c8c151e5e95ed08a629f1cbf9472b88ef9c3b67aa57e2e1a271b62ac212a0209a349f08dd2e56b46572a2af8845ad188516dfd30564f6956ea3b212859d4093d1bd77937ff8db66127be123e24e383bcbcbcadf0ae3705bcf316af549e730bdc780226bafad2080eb2f25fdea149fc4efd13c65790305467da5496bff1e20c8a8a440fc6ef5e1364e53d639732773bf42e24c10aab4190ffedaa9d37c3260678098806a58f242cb4269a0a1480de663af682a34b2363f0a7c363724b109b0ed156b71c54320cca5c6b7f2b60857849a5dc27c18c89e07f2168c3436f5fe80baeb4d6bcfa7c3611bed452e08655fd7c10ea2bd5c595995f1837e939656c000c70b3ebb1468a5c515f3480f817985230a8ede1ee5b5e18ac9b3fa3d16694a20eb4a24b8fde3369c28671bcadf2aeff5013b671217d65e6295a0c0c024daf890b5e989fc2b9051c4fe786ee00e7e51b278bc1dc07dd997c2cebd235d9389cea0ed8f51b0291db5bbeb60b0b261dd847c572609910d36633c6b01005722f0d24067031adc84764c5e6dc947c3d15b66be43554d350433b71c188d889a8c2f6fb032cbdafbdae8dd4f2142f5ae490d8991cadd0bc9ca4255adc70720b8334527e0c416a32f62f197834c67c6cc7b318d6ced346a4e644f46fdce8a98524bf36f20d0bf930a5d4dac18cc43d8536fe159a50da8483081b6536815f76e21a21765c0e988c3425eb8f4ebab4da0665b2b9cebabc3db1802042cf61c8de4be71a2fa8048e11e3692eacca76ec553ec2b89e14259b4085aab1be64d64ea62307d9989d07ca029920fe6f02ccbd4a2b71b3d028d00430ed91cb33a789464eefaee4c4d50483339f5668aad84309aebf7ab32afa1198db9f398a19ea1fad639e93dbad870432d6dd008dce634eceb0d3beffbca404626e6eaca51229472769268d44e4c4079437115856643280519c866e11351c50a367f50d921a7b191c08b8a239350c07877ba4133d0416a52a5fd282b3f68bf562b53c662eaaec0d749e627078ce1400a92d5418f19f8877afe1c1d192f61adaecca3efdd17c821a9c269eae74ca6f05dd216b5753f11db2c63cfe3c83fbbb5f71ff1e412b347affe6c9cda68c50c80b0140d27da72d4758358843f4b35fb9925e4080ced9347c43dc13e07938b3b804fcc6b3bc5d3d5733df81095804afcc504f4d1e6a7c91acc8d5a21487db5d8a0d766db42f0bc7de3e8d3b04d5ab67b75630daf7dc352df1305c6d72e1380210004f16f22566de66c7ad6ada8be2b4b46cebf4dd0bed9b38e2e6859ceaa134c80cf2891dd31ee72fff7e12050144701f245b1bbfb16a9f1fd2d29db3dde87ef40804ba4ed6181746a536a4e47a2f608e2595dfd86a60dc37313877212c2d304f0434413ab6836ddeddec8a31b0690cfff1b0356b72a1df75755920d3ef4d447a0aabd8970880f92120479996a9d5a368c51d2567c55ca1420c199604ad9cf8650b94ebe9aef605c7d738d357698e9a135de5b3229dcb3847aa9ea021615432da06ea242e4b947a8d0c64c33b27f12e65f8e9dee206e21916360bb0f12453fc2f0e5069610977b34cd0a70d5c25fb62d9f22459af22839fdce97d74ce40108de30027a8010f7c1660b9061697cf8034c9488a175af4c4585cf86ecacaf2d917aa034a6e5c006997fcbacf530837c3fc7daa58e6af2a6d5069b706766d254079b30b1a85291b2c6bbde8f41a9201a891a5fde09a46e06fbfc1c4c4457134e2f2b1084313fbe60fff8a81347c9e698e538f6c95f5cc6916d9d47cf5a170783cf6010d22bd4411c16941759364b89890fd58cc21010bce61383b03beeb399006026007fe9e2fc6773cb0a26469f06888724a8532e6ac2ff78b812d0d210ed0be36570535433279f2ea61450aeaee3e873443c798a21a95d1eb503fe354fac7aab3300a1f0c2398dd7f6f32a660fb18d4d3bc55c401421ce0381e2e27b037d0b5a70807d396c8b1ae9cff6647deac464d269583a77d2daf7aff05e35d8528de7aa9f804ac0e55dc3f629371cdceb7fad4f0a27e3f5cf2babb3c7be0ab2801af78944c067ee05c6e9d437d67c8e1e3826c2288dbdf9c6888b18f29642f6ba9ccdb9b210e0066b5374874c48b59bf16bbb912fb03b59f452876eaf07c94eb31af369fbe04d0cba3e0de8037f0d006a4886206b6676b5e988efeac4dde3e9beb8887710f02f8cae13acf425b7cb62465ff098073ea3b0daee8570dce9ef666a89d0514c40d2f180ec8b57ef56d30ef28b0efc922abd41b96bd8d0369b9c72a00d2b63f7f016a3291f94dedcfa68abccacbadb3f85cbdc7d6921fa65d5fbdc4df026c42eb0c6397fecd6de242c4dd58dc20d0520ded9fea7766cf66c24d97f435fb6145e90595325997a01b34fcff5779d9090e13b647fac559e9a629419cf019df8cfc4b02020302aa3bb92e363e3c4c82ecb0cd478e235377112ca4d78ce0fa677779710f6cdbac0377377fc649945616518834d9677eb8cb1ab5590c3c4157e947f6090b5e14afa6a10d328e5fe205b619825260522c2041ac24658bcfc5a528be23150bbc23c7f269e97fdcbbb871a4d98dc52badac8ee756ca7ce18940b86a395e1a0881f771758c7a985b3fffbc4c4cc26d18b770d032aeeacf62048ae5b5698c6507987c747fd2cec2db4d49d937dbbab1c76a873a7942124200abf972b260098d0ae3815bacd44dd5f75cf9d8388407c20285c0d1f1804aa59150b2f88bbdfb8e0b3ef9f06997c0cdf879d32c1e995ee5c84756cbd1823a3f18d11f249c7c4ea206dec7300260b39d884f71fb68f20bd5b2ef5ac77e95ca0418a5a3d3b425a0d10ae329f41e1076e8e1e8e49852137d5be3dd189365a12bfc41729d78c7b6c7b60a401ee11ce85c9316b8df686353c45f36bf79df58612f6f2bd23883e369b9cf0474a8eb261b1cf34c2c0ff3df637f406b6d73285793ff92c0b1c429c5fd3eb40450de437fcbc5daf84194bb813b3e7917a294f898619b16ea7007d5423f5ee8045e844f6305e89768e1010c5becd9bb53a8174a2856c12c22bc141afcb2e2320c3525cb593294094420df4e7bee3d1d9edb73e2431c21c0c544b243cf64bb8400cbb2e7e862a6cea606ed04145a56871d23d1643c1ec9f518fd3dbbc9332167000542b73cf57cc8879d683485314783b72f76ca6aa100e8c1c95f8f0fa46e1e050826677c48328532e1789f09420bdb98bd69047e3af08c96e2dd72d241bd3a0ecd8b574eb3d04a288c2d5be0f6df787629919d3845d57155309deeb214baeb08b79971e9c4ffdac689c657d7894ca2672afff4260d22e4b924bb92fdc5194a01f7fedaa86ae5dba8d516526de6c37a6d86f6593de06dac371f2b43410a8f7803d2aca7ddf9c5e74d5c138a2f770f3941b6e61aee48eeee9996421138d082f505cbd44d286b0c160ec3efbc7b9a03952f27da6aaa867d27d64464ae6cba91cb07079cd9337c2cefa83767dceb573770b012e8b1d2c3134974aa386c52f3d195097496441896177a74d11ef3ea3450c3cc836850084a883b194096eef438405608bf7cc8e4ecc76829dc12bccd13706c78d041efd3fa325f3a3c9dab565e2db4096ea0bd2dc2a1cbee3b58ba8f592034e4fe16b0aca2b5489f09a3b1341cb0a40ec57534829178f8af82fad3f127144c72f694c36c9b758b452ebdd493ef53a50417164a5d92285592376c46eb9bffe2cef65a26ba8f7a54239fe70d61cf238d081572a44a7c74a1461f41b7c3980c660354678b8850c69f4a2f205d20c7160401200176ec262c053347dd8aadb51799f9fa944baeed7bccf0a316f9b645bb210d37e5a079da7dae1103d33731472b4ee4df4d9bdc582ce157e3f286ebeecfe904da64ceaeb2c529470abb4e70c37570a81761719bfd7e50825c69b4174690f40717623d829c8672dc335882e672e726f90956143f2e4a1ca38f5ca4f0ace9cb05fa322b3c725c94a18a1df66f6515f247e75937e0916c6ae4c5dcb5e6df47060e280bc21e869df5d21591cc0409e8d56c4f590e2a4172a3ea45845393b1714e0410eb0f7140786e8b849b04fa2822780904a9116ff1b86306f98645d14b8aae079bcb0d4da3d665da0c9823f4391a4e0eb35496ceb2b845def50f2c49bdb54e071f8912995421af23185bf2e42709f7bf80803be7173f164c2f789a28fa2e0500b70b92de351d7f9ff10ed5b18f292ff294e9ba8d818722da6e71635476b086027a9a209285c332df1da80c6bf841dc98c98ba923a43a5c749e0e17a9f75dbc084c9e7d4b62cc109e03f0874ef39f217076de39ea8cd09b0a79e9e02d8d5b7a0e3fda416f6ed3be6768405cfc392f51e0a4d1974b0fbc970a59113037bb80e10d4c747f76fd39fc9316f3630b4a6e5d0559983a1845c8e3d1b5d1101259a7950993b9a399d411135733c8539e0c839b4fb8ca8dbe9e218e6dd938dee8a583510d6bded80b90991ee610566ebd13a3d8bde542c1972e5348af19fee7b29f84a60ffae6f1f18c2a6a2bb659c6b445296e8af47349b3db10ced45c7c70794e92fd036b3c95b9b66f130cb395db0f7598796843cb9cae717cd4d9a525b683657f560aa312add35106d5fcdc60a2293d3cf609d7d611a3b218c95a70fb0205c4fd1b061abe7ce03bade12c86274e56f1de4836586ac41599286fe3ce232121042de80efb400aad6516dce397c6d33e1e0cee529e002b75e076a95a957913505e54ac0b07241b6c298d635890058455a16e74de60776b6c1e4a47a67e8209a5d0c85900eaf292a7a5313f5c7ca3d6a7c4ad43887e04a08510333439327c34ad007dc10e0be94484233c1ef04971a4bc54be2f04e9a34c13c460853707f69bda81a8b30e472a4f8228dc121df51dd30bf45625a1b1c1351bc63b043a295134cee7b33d071b01837c8f90f508095b0748748b0670ab8e8c25b60a956569934a1fdb3b560954e81e574a1445dc94f9af613dec909dd0380e5bf6b2ce09c8fa300390792e08769ebc46a6f4e83c65070cd11fefa32de81426aec3340040fc1113ee98672709f4049f723b62119651cd35a6c4bc608a896b538ced1cc57f1fa123a2257c0c025c8d2fbffef9b555107cb5624d517917be394f964a946f7419cdc2ab57433c054e4ead088a2191ac206d1c0255b1dbf87c33361d7a077b1075a6b1a9b8e9bb0dc790f871c08d7ec0d78c9a16226ee211316b3759b4c21473011756217299d400f4f4f1734dd1f67044cbd5c96a22fb033f29996f8237b6fa9e1e6ba475b47507af321a47cc0400e5a2fc44f4037f2ace7c6b8de3478e44812811cb87bff40a09aa88bd5ccd6892896fb396b1b8e328bd934f0bc3b96b563c876ea0f10ee7a5021498c19dc17229cadd947f64a1d35eeccae5aa093c51120506232bc55c5dc8035d12028ff0fdd71857f19e62e1e525d4514388f9b7ca6f14f74a4780ca626a023079c475604e35f626933b05226abc07419b3edb68c0302afe3013173730340fd1bb8b8e566b895b4efbf9b63fb94d1b6cbe1d1d5bd30c54f508e42d2c0d59024dd9d46946c0f433c09c394bd318040da120dc4b846d5a566ba617f56bbf8a072c54f8a1275c091df36f9616eeefb3a0fe51bfb0556d74dfda9a1976f3336903bdba3e20793502d06b2414640a31190eaa4c2e175ae4e48f54fb360fd234700cbdde350a69d6b078fc6fab292ba7e3c9694c5707b79ee25a53110e70ff39f4016c2dffbaf236143232c4c891be98791c5b868b953eb1fedf877dbae047558802b9d20aa1cc665915974dbf686f31d1af079bad1f7e4b1290e5d4fca83b6cc20b8a9aa1b41f3e372711e98104048f4a02129d7367045fee8f19e209fe5ae9a70105f4abed16c8eda2352cd28bdcbb5b82e75dc7f7bd0ed981c1b39a5c5cd608039f1fb26a20b1b6cd1585be460cb5d1aaf5fc59c93e7a934d596c63abab23e3060e90a7b97ee69b23a9c4801eefe377269357db8ede4741974e26eaaf3b8da40637a5d2d0439793e95e65fad1c514d9cc96e3363b6595295551b19fe2cffc8501f1f0e69770910b0907b387c485d81c61218a3a95ad74205c8cc7c13f81fa500133362cf88b605d2f5185f2f952767a3d3de77b840e00b80cde72727149846506461c8a38d7c06abd75f712a6ddfd1bfa7503df3c5d4f7a08a5964ba1e1dac905a6856839a8d61dfc729af74dae73bf7b322ebee871e53c15fd9b14ec28ac8a05a5221c9734eddf5dc30f3b997ee8cc6ad3805280a6b9622821df1bc9397ebe0e03662397bf072973095261ef362faa593c01c27f7e7f6dc6fe90852a9dec0903fcbf2070f6baf1c7288364c9be18b438edda25a3e7e06e1ae6b5c3060a89410356e555845494651c4e36208a27b0ca5f5f70ecfe90baa6032eb9ae537acef301103abed2b98aa4d8367e3b492edb9520bc79a745765aa789aae51cbc3e48c00285191ca6d0ffc7510ad0b7299c9344bd37997a608d8ded99e2bf428c1e54050fa9c113bf57049510022b4094c95acfea1267b0783a4a23b2dd3247824bf930078a797fc13cb6cbd2ff4ca88f0f38afc17fc0dcf05f8eeede24b138404843d30c5e1da58ea6c4cefd29818d2ba068d229082c6f08176f1620587d279ff2cef7098d07c711e6539e0139ef445214c837838dec2f1162c186f645b2728484b11f0735fda4cd935cce928323d06777964ee76c2d62ffc37eb73726b8bce5b5f1b102534581a5b443351b0f1968f9b690188481e4767cc98d5e5da80ec4fa5082ca0d2b8303ab330819df7241d3f691e7c75ffe62c8922545914433fab35ac243be09572d7d3be726a887626330970c44a7b8d8bb6a45b2e13d747898ae21b4b04d0c07ce44b332c29ebf00e832d5b371f287c03e8b1e60a81c68a07da76a9d60d403f465de13e74a0f90383a53995c2f12971fb9f4bfc58d6b8f66510a525bfb2108c5cc8abf4d2c9a962c43237a9c65df9823b7334b69bcfe29cb5a41b344621c02ced3f849cfc08ca5c09e6033eedf2919439e1ed524765adc0af0fb57e998220203f71be8bf1f734bb2ce0b5645df3b546b228194bd98f72cec85dc88b7cc8e0890607a111245c6fb1b373600697950bdd2a46ecc7cc116b1ca22e42a7ba3f30c92aca81c417cbe13b445b90ff7603fc3e09508bb46ec4cdb8ad515a472ead60fbca3bc9d302ecb27be9ed413f2b2b34a8b715702de2c2c27296c4d611d96ef072abff8d8bfb29b0abb20c1f7fe94d457d1b2f8777580091619b5e3bfb632f00798a8bf286b899447db6f62909b5b4ab2d097f5066bf763e0ed6c40c552cbc60ac0da8b2045d5c734aad026ab83aa1fb76fe0790e314c27a323b5fdaf239e830c7aa4be30947ee5500dd5fa6d1b582f533be4fc571d06794ff8b55a7b6e007a0e4e8cc95738131007b304bbeb7089bbc6bd2ecb6fbe1bf5e347e7d03ef245e604c72b9b37d235078b25777fbc7290b6aed51fa44bf4786587cfb9435ffcdea009fc4749e58ff9891aa4bf6d474ac1351c927abbd27df47d8e203f29d24ee74a06e97b6573e3da3a491a594b7db1a0b623d9445c05e54b0cf98c330911d243390653a8f7f66efbf399b06d6887ed2ec37c94657786ade0f58448293cc4c646990864cd325b939de47517bd8e51c8dde64312ee7c67447151de5b2f419932b1d00efea788c899bfe2fce771edd7d062e04906870e999966a6a6e2bc1855fe32800ccef03e5dfb00ed18412fc98db841d5cb8ad853f073e7a6478dbea01701ad290b99ff08b407b8e8e10941815c026bf8eecf929d12e9bedb641703c46219d8d307f6f8163afabc1b7da45a44086813ddbcf2af633016349b3612ed33aef30fef0dc0be93dfc2e2651f35ed62c173c3a3aaaaabee0d2d77cf979eb63de9994d4f0f77ac53d1e1ba0a0df8b8e36d442f46ce63fbc3c3fe409e353e43e768646da2088a6e607dfdf88910342c84af91691506a1fc047265c20275d6de52bfbbccd00386d5526ac8f94ca13cee4f5ca32a7d91c373f9a6b81a830b6606c38a4cb3850f422a5d0a523a005ab64ca58ee01a1149e65766db443b5b83d1ff803854671207289f281fe63fe0e4e56ef6af42e2a806e6967ab084664f27cea52ac1d90dc30b5941f25bdcce605547789817430e71a053698b59adb573373e6339cd34d0fe0a42b1cc36ddf5b6072aebe931c8ad3e82e1a7b8b5aaabda8bbd7c4ae91563e7016d409b7e1badb9d91780b255f5da505c48adaaa909d8dd329420df0352449205d4a1ff5d1bbb1b72c2298a23c04c287849cf79dfca7c4549b5642379f64e9705fc6872f3a10342e55f3a753a8d694db90910fb5b68e03074071d64cb8df99d03358ca0d692127a38085a74351d93a4f82bcb2d2d8eb381ad9256306941931201c45510158bdfa710b1033f1265ac9d414e7f113199e9b68da0bf0df691a2610ec274a69afb537a9e3b220fe0142c79779395a32b810a6d578882e3b4ba28b50b9de31dcd286726c9f5c3610f38d6dc5265e2cace74712d57f4d9fb591e79990a8a112b74dbfa731f22a01fe14112bc9acc00c88b909cbd6229aaabdc5efec403916295be7866861ad2b729291ee430af4a891ff6e9f1597b5b2041cf60b398054713baf2aafe51e847353002f270ff3cda7760e4c429b5465d046c6e1e26e90a40512733fe15bb8cdbea4a59eb602ce7bf0d3813e59bf3720fb8e04085c73f0f83c9b1e1fcb8aaf35eaa28b5cb4d3ff316cb6ec4677fc045e74be0ff38b6b40e86b30d907ea5c7256a33a76d85ae203b1c1e8c087bbc76e1225c0f1e723acf0fe8d88c3dd45c967eb2b98e30f4c59595c497ba8ac6cad220220ca08a14d6c50eb742bab4e2a4bd518121301bae6a85baabd98c628e8ec9e73eadc1dd51ced909e1d195dc4f8dcaea5f094ee51ba67544b98e0a073096a16413118fb01b82af0f473284d56f14cdcfa82460cf02059f72d71dc32ff9c917254964fc01f680e50d18f4c75319305fa41af223c745b4a7b508b73a6e6c002f895029a285f12c050826ebbb95d0caa4b088dbe35aa8e13c0314c027234313f7d90f2e0dbddfcc2b0791873aad6de0188a5cef28961ed3782221e78b838f1cac2319f13ccb746cf00655c2cc4e5be20772082b97dc4a8b97527396ff766d2b1e1cd9a5fa2ec7b67c00f46f160880103ac268451ab54c8138a6819f7370412568f3f8954ae51ff5c5066ef3f7dcab8c1d66f75251d9b1c9b5aa44fb0f444d09710f14492b167f27870b74746b4eabe2cdd0bdbc27179d8b6e3859eaee97743fda58ac4cfbf11e954d0eb532aeb3647d7b65c96d4a8af89b8b30bcbdf66d0097708f31a38af1dc7c0b02d27d6bf3cc46eeddd74aaa66f95e3cac635a2d276d74735119e75c2049239c0e631f4f4d937a8904533a0ade74027d3503f2e2463939c227dfb28a93ab62fe054dd48451513484ed225b4884c51509e8624f5a7b8a462304551e6de7a115d50035edd3d81207ae470376434475b0c49e50fdf7e1a08e5ab6c20b421f37e7ca0344c710e1463f41264a03e75b407460e12ac842fe65b8d8ca0698df40fe04e40192a41fe0b8bb1834d9e66d75151292aeada01232f4c5de138ab6c5349c02af08efe6c34597ddce010e62d88427625669bb1c87436f08cf920b002e70de0c380bb8f725b47579542049a2238815fa77be9014129cff57d607dbe3742d8cfe9d0f4b99c7b33eb0c580b1b2cee77fe0869642f2b40a50f2cd4114390920ef7197035a4db92e5265943036912b4e3b2cc79e2accc2be007a1b0897ca33f771d4c201 false +check_ring_signature aefd97da646b183a051a4a479ae020d0cd79ad88d2fce7aea4b18742fc5ce5fd 6f01f25b7e6d3b6c8bd3e92eef1aa4c11fb8dbbd70b63bd4e33e08e5922740b5 163 14c9add369f7c9330cd40611f40d7f5ba4532e724f663bbcba342ad627b21854 cf49bdfd30e5e3646b32f760666ae93a35e9853917fa844cd2cf2bb867f1d362 a0c0c94fadafc272c4c06bf405e9247a528320189dee2b360b29e1ecba6541d2 0ed647bc7dbd2e91b6ac7ad513f3a61a652678990913cff9f50209f12b11635a 9689b8a34172de25eebbf531db16b9f700789abf923aa4ddcfd6d0ef1c654805 d8d58a097bef8e06264635237814f4287480316e2c385ebd8138208e461d6f64 e635277846412f6cba54fcf47fdda41eed8837cb215b8cc9b56949353d3161f2 179e30acba43e319a0437c17f392534c21c452f15603082d0c43e85b76c9ae0b 9558cd4488f4b035bb68dde2c92f3fe3f7bdeec59414803d994e969dded25641 8626a318a53a1e83283f132afc8bd815642b1ba5d36e4a32e29900681f90c9ef 3fb7e226b5c0321e57457f1031b230940ecfaf087fc50250b2a326b6b0c0843a 8f18db7b5d86e65fe12af0bc529b9d5ad849c5934a869fa9a04a6ee3f9961bb3 84b2ccfc9c00fc66aa4356205478df69dbc9f6a77bd3b34fc10f985cfab20693 d2315ac80dc2b0f801019b3cad9fad82f2ba01f1b662c742096fe949440d5da7 733c8190dd45f6a450a7921101b608c490f45401ada8bdee9dc85acfd2f4716a 0e04168aa43caf21852f02e321e9562ace64042e1ef7a3df221eb4721394d2c6 09f94e8c38fa012ea5d54d651f10da0c3cd9effcfde37e2e8a8f9b92f0ce8128 a8890380895620396b5b6b2a7092c5891d143dd606f2a6960fdba37696b5ba2d 5c20f81995f435fa6edab827d75ce7d4c7f78775194fb83e51d6d2d35fd4c8ab 4fdc964710ced1663b348e85b9287163afcac5947a409cc1482253f28a34724a 2aae334bc894a4c0777460e9c8236ee32dac450e6cbd743e68d8c283d3fcdf53 c5953532ac352a38a36759d0a4e829bcc8a99ebf07a8f07e68e18d888aeae323 c4f49c654816d6007d07e50bd503b3891e43349f851ab15c3c1ddb644b42ec37 239a6a06228253e2debffc32d99574f35efe9e481057075a5db2c0827e57ea66 0d925eb7db80bcf4836cf8de3ac4d23ebb3d80e7fbdbfdc16bb18c5b5b77a43d e55649fd34af842cea16a3b082158936256a79cb30c93cf42fd694d83f12c986 d440be6e29bec2f6b546cb63cb1e69bd5b50f41fcddec5ba4aa9acad445a7dac 33ff4315cc65b6b9a65ae7097aa662f67f5f559ffdf5c1eee238f36231b4d191 976a1339cc331618f1aecfb7a89b0ae6f5870f4f72b7c69c717c0d3b0a07bd05 7a2c57bbf78ec0c50ffed1fc0a910f82c56009e2e3c7a64e6bf65150c2d11a76 0d4395b019aea3084f04969e3ca40267f332e0a7d1a4ce5844a9e12abcfbcdd2 403f1fbc0a709cbb65d5dfa7570bd27e0c5c6fc8303052dc53aee6c0c5316e71 8b02d274bd7b5a7e36dd9441f327f2bc1564391787671d6e7c62f9bbdffd087c 5e6b78d142387dc7cf27a658f9c3ade07dd22b12dc391017227834e49e129efb af9b2545fac3b2524d53f6834f5595b05448a3e63b38be83b032102c7e9ca3a2 e60e9ab972fbd0fadf26617988c816ba666e082db1d613b88994b15d2ced5f99 c77df10542851763f9c4425d9eb67304dc420e7f860d384d0b7cdefdeced86a3 c2652e787ed400b7425f0fb4557a22d41079a5c66e95caa5fd864ee86750b735 4276068d3d8ae87952a674aa3cf9783e0cc2853b5692bb7aa85d3a6264444e24 a3b95d16e42ea7abb09c2258d6b1d59e65a9ed7eee188bbfd36f6320ccf3c9c1 44e0bc663e5795e9a7176157d070138b9bb80a6cadb3dd6e0db071c1a439f4b2 0f2601da3f88e7ed57c611a4dcd9681b13eaa7d3ebf1dc5b007d757ed7535a27 ac42c6dbc49b5282e3b1aa9c0abf3620d3422d5efa020cdd68bfa6d81018d9f6 b28538e3824b43efc4588b80d2a08cc7c56fb31b846a80199f2c85cbcd96b3ea 4455458279aab1d9730e3fa466eb18644af4a287cee684972695142e751a4dfe 82cbbb35a98288a390aff161c9289444e597b516371160d1480ec1e25291c9a5 9648740aaefe15c5108a0be314821e495b3ab0785d5976346431584f8943956a 4c7e351d834472644a6183fdf68879db3baade82dd03c8dcb19cb40e8e694605 bd00775efaefb699182e381b46a3bb26264c142da6020247a0e85a01c3177d0d b2bb3cb76433c1e0fc90cfe04f429bf7a7f4e009033a60e272dc384d7027f1aa 8549c5d43102b547da24b7ddb838c644723d77bcec9b4a6d3b3ffe7d3f515678 16acc80367fffbd752f8bb8e761d8a095df1553d5da88164e840ee8ba6c1005a a4a55f33f380bb3ecbd3ed42fd792bca6074e72306b1be21659c60ce6077f102 320ce9b680783d22c092a25fe04be4ceb5e75c7eca49ebb9db8e2d5aa99c6274 0b93ff899fbe95b43015790f8b33fad694c4516b785d48da015bd00c0dc45c76 3d66328059c4cb4c3ef11401a5d568626e55c60bf1ba266f45e1f88fd5ad0ed3 fa53cc4e468c2868351d1cc57793ba56bc17227de2bd8b0460a127dab22d8682 0251918ee19c40613dd2abddf6e12cb026956cd5bab49a2afd41e57fafa9e067 46191b4cd721d37b5d48d8a2e15a24f09f700f6c1c49489db902f514c68b1c32 4ea8839ce3c777ad05db0750bba64e9fc69fb4a69f9080c8ad8f32f81854b920 865177eb4ae0e388a433f568b8c92642cc2592d69a11972b18631acdeffee021 0538fdf2c4a275d7461953f43b2bd7477d6d92a81c5b435dca2747b6ccc53ff6 a749f3ddb91f682ff74cec8aa852d7e3a03934dfa7aea02bb0b5a2267e1e04f0 1c0f1a67590acc0ff6995c0e7c1e1e2b14ab053de5daa52a4c1d3538f83ae85f 035c6e5f82e9e76ee289683065790f5aad05d5a82cb670a3cabf44dda1fe4549 e161723aac5149f4b9b42c6f92b89d723bb57d830bbe1ab392d52db1e1cac414 5122321cdfc976d19506cb7013d92d8e1870468994949a76c25df19da6b1cd01 8f97b7ba637623a53129f3513aba1165b90d9f42291e0e51df18737b2a249b7c a1e6497fa3d494e423cfbe52a4ce2bda2168706feeca491c0a73ab6238d333c5 411cb181224185eb23d1554f200c3aeb9354ea6f555d95ccc00ed4057041b01f c64a13b0645d72165155c85a05b324648f0fe41d4d1d74089837924c8b41dfdf 7284442e2625b0e56433907b90fb7c3bcae3358fbcd4ca41165b1fcd2d6e1693 20c18bca3645c2242b9d89a49dceb35e6b47b257816444c3e50bf88117089fcd 2ededb23ab8da3e472d001c09d5583fab53069351eb45b9a5ab2e68a60f4a7ca d2e058d949678bb20ae8cf6be890346d149090bd7a7ef292bf6a321c721f8a96 17108a2d040fadba140160b5e4ff0c6e1560706d67b93c1c24b2181b6019e9aa 14db5de366c8441be09b6e118b73f25163e0666b729586f48a2e8db1993f3a3e 3d348e2b27da715a96a0640f85bcd89e791e5bd69c0ea511c5851919acee18c7 8f3d8469c39d3de1b6b7b7e2dc735b0408242e7e84745430d9d281de6c090f64 4ff71f464348ecbbe3721a576e15abb530b2be9b74d8ae1183aadf2d90d100bc 6ca8480169da517448620e16e70cf45f1ffed06f09653246db7f51c491558827 022c9a9191c89d7dd2d862e740ce7d728598e9cc1ccfb8e2acec2020a35e4d80 6fd1ab9ec050236815319a5faad59d13d6bdc085efa4f894252bef706dfaec2a 2687052620351d0df4f5b07ed908526db33e000308dab46e2fab9f2b80b5b66e 1749d64df10b2e4fc3492f6d3963d42b23eebc00581bd7b171b84ba94332dc6a b2f4dcee63b59d7a60360d44daba8f57f60f9703c401bf7ba500767aa7857546 3fe6bb103fc2c72cae21d34f8d4aa18106666c291dd78ab2377e77b435296a7c 99ff4ec94a88d960493ff46aa0a92f61a6501c4dbc6d94b6d6ca2e348f1ce77f cb89bbb338915c66f30e1932b3ed6efcd7dca9267233278587f041bb4ecb4372 d09da425c8b86252ba56baee9384250375965e24070b8e1dd5299ac190b1fc56 115704913180787db249dab55a7186849f4f82fc1503195e8acb7101b57b4ffb d438c0cb6c282166ce6931058eb3441322a50be4a34c480d2df788fbcd099953 ede0a6f6c352b5637ff88cf2a2dea2d41f601557e00b4665e7945be367105053 31b997f7c5a295dbf71afd78107c7c2a2bbda15f06ed59c3bfafe8241561ac93 011f7c7371b8b5c5320e08b88a3391bed0ec973601bacd24fdbbb0394ddb3c9a d0be91cd0b7ec1f457ed39cc20ce2ce61a8bbe0bbcc89f7828f16586c3ebaa92 b0e0f72d9e9a565e25412432c820ac37d1d5c2ed439bf126a46c057dd1ab1fd6 0304ed035d3547417bab9bc4de4a8d32a3fa0551ca493e9a24ff5b9f61b658cd f9b54f3e715711c35510d232113c90ed7ed973731c068aa2545df51779ace710 5bfab4b4471757fb8200591c80d84c62affbbe4121cb333c7368cf5aa75e47cb 6fe6088e3cec0dadf1b784a3088367c1ee12512d2e654ffb80b225ff3e461ad8 c5607f07090c7fcc268479cb17ae290adb2be5556cdad41c46d71a5c6a94d157 32f05923924c6c2575e99d0bfecfa8b2ab6fcfa7307764f0e90aa50bdf4a51f3 d6b7cade04983f9bf779f8acbef9b28332b9138f12dc70287f85b5a9dc8a6ccd 89304767ef2f5a77c73991b90e7b3f4bc82d7c1a3c6afe07319da4987f530f8e 57e914908e934f36d87b2d9f5467203408d634afdd79aaab89c7689ebe363a68 a0b7ddc82b80c7adc198b51a32e4032d124de1f87cc98e5823c63d34a381d0db 8966153fb21f2ff409f5ce64ce13ddbb1d5b751f0eb9e0cc6a89c0c459a183ac 052936fdad2b3f5286e0b2edd86beb73b56e0b885ec702007aeb1fd3cdc91cf8 f21a9860a50f73cbe3cca07d08a90659fdfd24df0fd672a8df1f0aa98016d614 647636db8de0de3fc4203fde46e0056f33f99f5a505aaa8ccd852f174d2f4791 3ac29252cefc2cb43944a430c90620e6121954a23b514a0952a155ae3f99d0e6 6908947507727060415b3956eff4bed57a10183b71c83d88ec281bcf39df3942 25d980eacdaac12a753eb00751d82149293654efd5d32dc69fc814d32d0774f9 94b9aaa4e3d803e84bc3180c9753b93c3a8e10befa268b5de19a3e05cf2cf48c 6e5af04799bd80a3065905d66e85ad9b05cd7d00bfd60700c93609803185e882 875c62ff7489a19bdfe97a408ee9ef930cf43e998b14e084aa3d0228aa12c91a 9ea43baef31a8ac2f7c93b26dd338fbb23e56ccf1f259cf48ec1166fa2bcba07 5c5c0f8444d3880a8f64222ce2e28ea2c5ad3441fa4a7acece38dc9cb94ea72b 3ba9102a0419583ea63821074712ba649b6ae220a2ce5f5ae665e01e6801e684 6d3da3c336ab7cc150381922d83ddf090a37d0387a2411943247ee08f0c55e79 ba4a47f7753ebf1f48a530b13426145389e35c350d4509ad2aa1852364a7c89f 7e70582d95278ff1a223a98a925493d4eeca84812d8321f8d575a4f440c75ca5 c3ab19864907a0a5382357a8d4df48147b1b6a38b48648c6457a26231e313b07 21c87ca57d493a4d0c0f715b114d66302db3afb01bdddcbf9f1d27e870cb6922 be5956523ad3709fce6f856d2b4d7ad546eec1d3c06968c49ae539c9b8fedf65 ff21e41bc6faf2e2a7596536c1bdd740dbc1b312d8cd7792842a617dd6ed2d07 177d95cda80e0e52d657aa1467f257c550d4ca94229936840d485dc407ea3056 a1c4e039b2483fbf59674b6daf52c051d6dedcd8359734fb4cfd393080a33dea 97d5497795b46e19ee5024486eea64ad98d6b04c0a0e6ddb4e0214715ed7b749 d4e06dba5959036dd8f1b1484a3356b93888da3a5a939d793387d2c5d7940099 17cd626ce5d0a00c923fe2c2492fdb88513d2373bac14e21fcd93e4282c4ccae dee89ce91bc827787aaa6e7ceae1e1b888e7f53ec3053d7079beda2e3a1b1fc8 2c05f436566d5c51f8e6e73309996e7b0c78a829e2021463289bafaf9742d6c8 b55675212309a06de77cdd51df8829a126dea34d2c27bcff75eabe1cc14d467c f61dc8c206b5dad027b76dec41ea3ddb9eccfa393f327cdb82c9d51b12126f32 a0daae39f4b1cb814589f44537d954d1b31928cabf503485c47efc2521a64c46 b1eabc46f19e310678fd74121e33f19793346026ed81aee7c34aa609437e9368 e1afc04d062b7b45c0d852cbe539d88b6cf7730618b09a965d4d814ffcd7d71b 446b1ef51e59b392d009b6b81029fbc0c4edaa43a8706fd57c03b549e4858b8c 6aa63b7c58a3ea968691b5f90e85956063dbc39402bc1f64781746e7aa83ee86 7820c17ce855aaf1d81b5bb613a12859d850a8e190b3b68510c8cdd865930df0 bddcecef1a234699feb11cb2d7ec821f27815425ae8c6c91a764072f8c2a0ac1 de50c8c22532ae87f5efddaf579178072299e11fbbec26efd5fd324c2d14f34b aee971019a20520672111e093a9d689196f8b3d2a9fdfc46ab49574f7dad3c9f ffe5516bebf791609ec534313758c7984918343d92a57b175a8eba1c2c6ae853 6ba497c6c01e9e87e05c44b9c61d816ca4b457a7620fc6801e9dc9ffe656bad7 5c708e09c3ac95e10d1938d450b3989a9646d6954dc7d28a9516c26f1a56382a 4ae80dc0c5909b59800d2e541d29aee2ba22372a4105b2e0e0dc9d44cd77b8d6 6c8dcf6e40073c51e7fb6a68630a89d239db6c8513fbeba4c45817961dbe93a6 9eec171e19192ee3b0c6541921706f7ef6f4430da84789068a1270bb04d54f88 dfa841e9ff3eae7bbbdb0eb1b95739b514299609042e3c6a5404da054ce1fa5b f1198c078614b11025348cb70fb359670bb6081c7f965269c3fcdc4135bea53b bc391e6a8292e0559f1b847ec067bb0acf1c502879c81770931ad4716b2920a6 124b93225bb6486ae3c071f1fed3dafb8e2a9d8023003fccbe224654001d4957 8c470e78842d0d41b7632ab06fd5fe1475fe91909e17916e6bb5a27168ee2bf8 2eece7c52c3a677e0db1751b837ae8272730f046bc9e6ffa8f183ebacd362eaa 6fe4e22c59dc40c11412b3881d58707a5ea9f8debfa916b201a9254e1ba637df 3936e8badd3c07ac3078eae2570e9094312392de5381a08b09ce4033491f2841 ccdf951f871f4396f9eac4b27ab3883e22393f4b3302e8da13e277bfeb271fd2 a9cd71cc013d651991fa33fdef34857895a6d32229936dc7b10cfb112bb8e24d 918776c6057122f827fbf5525ad856e36ea11be8a4854289b52bd478eaef5b6a a891071c5dae8c00345aa95b174973e6252530380ddb96ec16f94c717a56f3a5 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 false +check_ring_signature 066ba7506b50d3f83cddeeaf1549fcefbca918eb7896acf591d3e16729e05019 4b72389472bda3fa935c375f4da6324423dc400cf4a4b1fab03974720d64c4d5 1 b0db587ed4eab58b8149e2dbf6965ddaa156dd9fe7b4401ec18419210bda1f92 2093b2e5ea045d6a8742505769d60b7b9fe55f50541c39d57c86fee3b2843007db3db8351b01245f8b1bc4928d6df0d0b2d43f1826bd5aa26beb1cbd0d758b02 false +check_ring_signature 0697ab1f801e6d94bc307e8779c44845152e0063c9977391cb844b5803b149b7 ac0f0359ecdd8e6e60ef345fa0dda041f005c374ef19e9b2db17da5cfe1fd5ff 6 e293e8d481e88898b31bdeed14158ec8c48bf9d61342d9fb44e255fa0c807834 2dea559d7919b9d4b0dc9c119c34f0372373d548fa3953d6663194e347e97d9b 17e6daefd4566390209fa22b2f316a699a2615b8680f0c293ae2c565a68ace6b d85e16ad874b01a11ae2d979ec8e508cf13b06057838a72df181a75e03b3bb88 808c4c323784554fd93be95e2d89ebe23ce868a8ef7ac48c9e620a8798500a2c 9ff208d44a24f384032527f3f987e4d9b14ec7d009f3f0ad755a1e26c092c216 ac5e2d20ca1a128965a18e90939f56ba608da6c3c38a2c5d0dddb84dca0b5005ee4e949d7534fccfad10257e3118bab37b4d740813c4f4a3d7e51180e593ca0c3332a7617c567211b72ce278ed7ec2814eb0b21ee88e382676a0d67756c66b05a653a4a141febdfb79d5a6ea84eac0ac32912ffd1e5f9b3b1ee6b91c147bd203fe5e9cd0a8bc69cc99af718d1dc93f050bc15fe2bf523ad2e2eb85c74d29e401f45e60a6011dc0185843aadc0d618b37a554c3c6ae2e94fe361e770b0f504702ca834c26fc93f00d3fc8cfb83173286f9eda71be61eed9b74fd8b842d172d70570151375ee9d14874aef6676cc2bbc1b1a1cb567c785773caacb138fb231eb0640773cbfc68c9a3fee7a242b36fe94f9f555caa85f55a3aab40499970a9a7a0b26e2c497db6afbead811cf4af01f9b44a8ea4314b218008feb19d07195f96e091f9e84b92fb3bc89024cda5f3748aaf4901b78ade5dba23d574cea88b199e00fcf11af70afaaf931beddde189c4e26ad7a75199ca4e99d1926e152f700fcbe0d true +check_ring_signature dccea384ccc954032ff52cb92bfd3bd6c2c167b940be1ffad34fbe738f98fff4 2cc0be94edaaf0d9292b0026738301c6d2628d960c867af356ee00261313a656 52 470f96608f0cc5bd50b141300247c68d87fc1e3366661e65e327fa0f9957b8eb 2ea4e8f386b003017f5eb897b532066b98089dd676eb9c9222cce1aad192005b 5e0b2ee5a1db104b142b5d3c529ea05e40d9edc6e44994cd43942103e0e17826 644bd55e14f1c46fb701fe7f9f1398cbd018ecb7d65c455432f5b8632f6c1f16 d84899c86a9c5878a0cc29fe1719b0e37aa4c58bbdf9117374597dca002760ee 95160aa1d247f96e04e09845366e95308362342efd400cf2aabb45712578461f 177685e035c5d5c773e5d10c409f6261803280664b323c8d8bd14a2271e3b8e4 3893f4a4f61bb5ed79dabc68d5287c8a62cdc2ad0b7cb0aa352467fd6c7803eb b9d5c72c6d70aa66a926247c4fc5a29aa227b98f0e4e9ecf08234ffc9faef20c a034bbc1013e313ba5a6ef8afd45908fa4e737b5be05ec7fd95fa9dcdc9d6714 9cfd707de09f12444e8d47b4f1b3fc5e1b7030ca4c0a6e237ce758425f794571 e5d716752ce7f0370db334ef0c5920c64946146805e3a08c41da89b2bce6acbc 62e647848fdee156fd6bd98e9baac81612b5bbf8b73472c78deb87abad2eda5a 6395c6d6262da23c880dda1f28783b7bcdfbdd6e8af6f3cb1eefe6b362b20dfe 8e5bd6ed2cf87ff6e95e3415b5455f43c7711ad7c4d7f005fcb2ddb98e30810f e324c28fdf5eb4ee38a8fc8ce25d4c076fb1d6868d0d1cab67d5ab4688df7d02 4c0c240e581f42e6f9c39a375312e664e036a5c203e2b7eb2e266de8f5c37ac4 5cc7a204cc28a70c8aa749aa5620dbb9f39fd70b5611f2baaafc03455a66faf1 03ce6be69fe9dd7b680e702e1d6180b8b17081739befcfb0c2721de5c2478369 d02dd66a20a69f877120c9e70be2f7c93d3098c73179bf7d7da6f7addc89adf9 49de98fe19dda022b9166a71bca72d4c219e519dfb8508750ed274326b603c6b a4b99f04f6928e0894e9d91add64730b6d1895a4cd0ce10905c04ef6b1433f03 42f1eaf47646646fa0af1e6bc4ab3b94c0219e55488ef5c06c71d3cd4fb8e0b7 705b621ad9bfb05871f08ee0723e5c9c7655dcf9a8eeb5cfb6020347b1dc40aa e68e045fd189223d5ff46f2261fd5a756a9a5c4d24f0af9e793a69ed2055e622 dd057abee1fb70387ca34271a2efd3231171fe248e59ffbbfc51ae0cc4f111b2 556cf3f0891d387c05a40de1f6af2173d8f16395611f67cfe098593e043dc1ae 97b3f91d12c3d4e2eff132ac851f2edfedb457252a3ece217999de0abf5023c0 d1eb464a6064227dee3fd35730c70460b8d1ce482fd0ac4278c3a6c7ea11d988 63514749815c11c6cbec472572460c189ff8f253bc3c60c9b81abc61e419c953 05a025397495581185989957b4bdfd8fada3976bc6dcbdb97f9d6518e2cbec15 c1df73f9a9966cf1e59c2901801ffdf141a8876492129d5379e9614529a6bc03 9f757a3383765773dd73c20270d98752423dcd539b8573d7421de265d51998ea 74200bc5152852b2a491109d8f1748f84166dd0e3438b43de65cacc8e481b139 f1510d23f980360a1440bc4d1bd34d747e61ab94a22d60166ca014c45abb36fe 8b9cdda1bedeb8d492042f9555b937e1dfbf53b3ff36898efb9c4298cd1e1b4d 95e795e310082904da6df7207a7359f1dac00031900545873599692c388cc575 bc3d46d3ce77e0057fef8c0f99a7c87b40a37224f6e9fda35233bfb10e66509a 17342e687ec64cff3a3400aec4667c79d6b22d6b85cbcdb472e00cfa3c46e709 25d9145e5b165217466870fb83e1a31d0b09087653a3d9675b93116afe46c1fb 6489fc8af846f6e701cb4ebd1f4d298f2c8af4b1c2a51114f4e5fe485468e0c7 5b06151cecab180d4c9099af228522a9e2c22200b1c5d64e5c7f08f268f9b4be 8e68fe35b25da927421b1eb7f09ab011197a2c2eaace7376f0312f82b2ecd084 262c096e80f703641067cd782554634d7f131810c2c42ceb374be8c340877f6b 5befeba756852d69695c25e2b95194c49f15f25b938da753d681301475266519 fc0c933747fa5a133e092c329c9b8370e2893ee399e1eb8fa30e646b3433ecd1 007e6f140c490c7d3568b47b29d92dc606a7bac736f75be16df7ab7fd3dd7144 741befd96569c24e7840baff1d2b105da24f574673b6adfda842306a8f151788 1ae5f640bac0b2e16381b2034aef1dc9aa3fc97bd192e3d12f171c345345b001 d5bffd4a17fcefb701d5f5ab532427c9ffcb81539f4db1b1f9d01c0716147113 c52cafc082ad829305d321e9835036190791e73e1c9a883ad9284c00ab4de0de b5341dc4278afe1483e58bbfa83d1316cb5d54dbdd1e36d566a1c3d92b1ddfc8 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 false +check_ring_signature 5054b8df396d9bcf5e25db96935839d07714f5b8a5d1aa2d362e30977640ae71 f5bcd0d3e8771372db40825b766cc002055bff109ef8586e09f4e5723b2d0b2a 5 573fdef1b58b1193527df35e5260e954ec0ae4045ace1d23f380caaf32d98789 f4a5f71a4d822ee551fb94415a7d10f8eaf6879de3a859bb2c974fda1f39212d a152e79d55cfbee8500d354a2efb7e30fe9495f8d255bea8c7842077f485ec19 5a08e85d5fe98ac97e2bc5a51fbdb6d145ec3d389714fb131a01b04877c85da6 b170588c14bb4cc5c9e9d56cb689d7667fc3464419c17bd2bd693082f2fe9280 fa09aa9579e5e4a44db30e730b22264b4effe960d5df4289684cce954dfad609d08f9f4db8b529c3a89ae9554e5647b8f068398d969ad9f82a25661f2045e503be92143f14cbf583f128e076f88f3e986320e8a1d9bbe0763dec43a1be04110c94982fb99bd7ca221444ce9f52e0c0e8ef2279a9566398655fd09e38e3b0fbe5923a1677ff3b443e2f8940c069e795cc4e62a65731866ab5be8daf68d0dcc7034d159cc7beeac355a611cf0fcbd4ed8ad6d07680b47c8f90d9d6c3af7f08270755bb58958a39fd301224aaa098ced181a5ea9170b94cd2054c69f93c897c636526aeff49e1c1fdfc389b06da504154e21be757d7ad42cbcbf2d35314d721ae06faed71bfaf7f6a883e95f584cd70234ae6327d38ce949d2637148d77f90c7c011a7b29b29dd5fdc60e19ca80976204df0c3196348a064ce51495846b70a13108 false +check_ring_signature f6ecaceff222290a853ce2ad4b7ce73b33eac0d1ee52fab652feed0311c6eed1 b47df97cac3ee781d3694b0cb36f86f5b585c3a8a5f136c91f1363b878722ed4 4 1eaf114b5bb9f49e7d28ba6ba6c7302ed9c551016809aa58df517d9548a44790 db92e994edded82d7a841eed3c9e3ac97a018bc10fe5944e90e8d1e63cd46cce 529a9f98af6c16e7dd881d32895a4777b37f44d8cfbddb76a8dac92753602a84 a91543ebdab5ef5435c85f3389c415fd3d71972a0e29798e7d7c10f4438a8f1d 7b33661dc28a0332d3cc835195288bbada8b429e7adb76ab64e6ca25786b1d071eb3940ca7560b3fa52b9e96b7dcb00f1a5b894d8d7c0d9ec4ed81525ccef007db57a1a4f234efd225488aa2b2e45a1e64fd4b296838bd6e18e276a9f0ec0507c101285df92faa796bdab9de15625ae9ae899c4d4c4dd93c21b9380ad226900f624f8408f149fbee9f71d9baec4d740b967c173a478572e53a821465727ddf009a6c95b5939ecdaad283d80174329b3b8f5951cbacf1b3a0ddd4727fc6042d0f1d24bfd4a8f04913270e52fe23a0f785d5ec80f430cc724a13f6ac77ded1370c2bfc6c82aca676b84deebbc93684e8c63081ce506bd02378143b74c03704be0c false +check_ring_signature f58ef9f5c694c2c7a6ba3a2c8491baa46dfbca0df40c348ea6331386a3e2b93e 00b86d41859f948a6fa7cfbe6a209c71939941c60ea92682b91cebb56bfc89b2 1 59471f3bddb8e8447a3c396123475bf96a5eba62e8b8eb7ad1985ac52345f38e 7188ff44e715121ff041a95f1a6b8fee957bdca69296eeb00ae9edaf9d5656048f06711b75f58d6132c31835e82567990b6284b47fa3ca55ad8ee067fb480a0d true +check_ring_signature b927ed1c13d7084b24d46e078b41aeddc4cc23b62fe8037d874d1a29ba5c4282 098fa2ca0e9243ee14a6530b75f2246435fed467a48d1ec420ce8d9f5ccfe4c2 5 b0feaca3dcc8d74ff79b32238eb88d1547fc3679f980d821f15607b27dc5f02e 6f42bd84577215f7b9049cecebe032d6bab923b1c500358ae229a93528b943f5 d09b198cce802144305371443765e176887b147c74e8d637e9745dfa5a1f7b6b 0670289a464ce28e4cca5774d9d4212ffd3b7940d38c920b61a811bd61c5e7b8 e3abec9819b96e9fac76efe0ba7d743274955d8e4807fd1c51d6153a6fd51bf6 0e7093c5121a3ff78fc901a00c715ba51e4540d7eea8e6624b5beadb4aa36b0ac4bacf55ac2e648b70c499702f53b7aa164ea4c41017bbaf44d0ac2726a88e0032ab784cd0f8a3931987d9a0ea518e80d5cbd36c6f160f0a6448b7a4f6f6ec079839b087a81e058d3670f2e5f6c40fb806c6d6ecc8ecb73de126a634b097070f0f56ee80e22be9b2d6869950502c65fd830d1d812f8e83df32e13556af60a90b9962d80187bf2071cc5e67d19d574d1278e9fd27fb7ca8b518736ac34e7f4d0e42cd8ed3cef3da3f74dbfd534f571a522f9577fcf38d114d9d3199dc1430de0e4e943fa9d07e3286a941b0cef125cfe9bc124c28f9a6a36467cea840dc7b5f053ea461476173a8f3189e6142e06906254ddc3571d443effb1d15db5709b73a03e1ac3b61566bc09c75b434790beccbd956e5fa9b06abea14b252fc6ae1f3c603 false +check_ring_signature 041bdea077a377e6b569f8ba901161d38ebbb8dc21701a7ef7523d71cae8fc78 ce6458321730646bfb610bfae96ee7b042a8d3e337e58484ca71c34fb7c98baa 53 ed78d9a2e57e8cdaf0dcd08d4c9e759f340035d1ab469a413cc450c5e31190ee ee044da946da19ba161439b869f24abe11fbd67b5243a68c1a918315354c4e4c aaedde3f2fab04b8ce4d58cc6101c1b59178b44e66ab18cf145aaf3180df7e5e 089fe514c7c182f6f6f38200c0fcd81fbe01a107f0ef5ca25cda92459652d1c3 6555ca1daab5fcdc0c75acb05d26b5199a166cabad794db094fe5cbc62812953 3580640df0f77d72ab32c07d768221d8b9fda1645ecb377eb9e8dd7a094e5fd6 b1ff716cdb9cc92dddca7e9e712cb43ca958c71e363e3afdf8ffb8e7c34e88ef 94ff525f3c3292fad1f602d6763c9b3a81a60ad7225e26d6807f1ffd9b9c8eb0 b735cd14dfff9c05194f63fae07affe20a8b2547cedcc5496c0cf408720af2c5 e0e9bbad0df776d68c5c62910dd9de6822a86f5fb81843bf9de0a0aa9c404314 ab092260416eda1396a1f5689c212820de2ba4df55efd3bf6f3f045ff78858cd 094fca2776f31d2033a00c9010e1e61eff415e34ee2e8a5e1b1061dd0330cc56 6a7bb62d753469792d28558188e6e42e2507587cff55754b6738a04c21f44105 69404e4025213a0c3a78e315f454959d5ca8f1feed2d2e81c737ec66dccc9f87 3084aadad0ac52475007059aea855b06ee9096c30fc231f7e8fab382a45edc80 bbb88a0bbf7ad7d638b03b4710d9a5a27b42258d42ae3e16f103c23cdf8f629c 6e55d4ca980c788cb60b91551910d579286a10c04a4e1f73e7fd03202f32dc4a cbb2748cad5a4c80005e4c85d11d9bf8cc24b063a040cfcf1ae3cdc98398e7d1 b582285097a9abac81d95d836753c02c3a8d2bf496af75e3eb06c09c76f39bfb ab9247662a5863ae82ac932b90d3682bef49b7ce554bb121448600173b22828b 6076ff69d5921c5db8c9e9cee7fc078efc49417f6525ca10eb6739a3fa19d419 298310ab2e4098cf67ea1cdb8718e3f2bb4d9494210edd6d43ea98fb6e574625 dc87946e44f64c3c993e94d2938b46ddcf43025798d11a77894a08faccf59e85 9b56e9a99bde2b9e93cdae892fdfde852cf75efe3e549b7c7f819a67cb457408 e66ff89251db3528b9c9c85a8e065a0b9dfff81d9de36e4e092eb16eaa298ae1 52a8187330d8b3552e6f298deed7647acca1c24d4a63fb65391842ba7f115f70 83ad328328c81ac1e1d9ce82805dbe444af939e6c40a7febcf86b65da0bdcd60 151a50b0c806834441c48b8d3f2b53b264290f872f10a914449b090b4f5d3682 0df3b0e31b682f8292cf7d6ddb5e1f0c6b02fa9881ba3e3a91dacde5b4abc762 1bc15092a2026de9309c9cc8ed46546bbc528f2ec99f0140d13c2dccf9e01186 4089892a9fc143445e0c432af3b5addee5fea7bdb51e5456aa8cd1eba824a4b7 faab82599aeeade55af68f1778158511b8e4df28cc8f55c2fcec2cd60c1007b5 81e381908eb5cd9d497d5340a820bbb4f750140e4e01c896759e8a308e607c44 dbda89b2abfddb998befd97b97368d3e5be0b5b4f6388b6a273357dd91722de3 2d298506e1f443eabd7be7d78a37504d16f05732be2cfa7730bf9396a48a2f95 cc716b45a4d06f9986377853d134fe341cf17e0363faba15781e3020824cc675 0f946bd182ebc031394737629f0e7a267cf6897cc7c647bb9f4870a1ed40b087 1533fe6002aced8ccc2a03883be59b8c61c5df638a81eed7ca5c141a4ce56f6c 17002c47d92bb0e6a917ce59e7bdbf30931079daa6501c0ce620f66fedc9789d 559f97ca21852ddd607cd7b23105ebb3f02f5d94e8a983964f5e36e30ec2a568 3eecd495412d44c9f109ea6c4976f99c2b7a5f4a0e7a344f6799a17fd73db7a3 76caab548a1137a3644dc4dd60cf580c6e244b9c0756ac8db233aac6f16307bd 0a547f7f8cdb19e5f7f94a4d204bf08bf989d975f1a7f59e7898568bf2987d9d 8106bb858ec2c5568d1f4f375585ead8410a68eba11ffb91081b7e58190d68c9 c18fe5b4e50a8fe9ce1fd475da89d0c9e89d1ac042c289dbde7b1b7cdf8021b5 b1d554fb39754c1a6e0f8231f2d53160cd94e78faecdb1a0fbc67b0db46c4382 35330b441f1276a4fb1d75523c15907ba2a4b728664e5b923e8bb70c2d5e50aa 7352f803a37a93c78a8fd894e89f207245ba65c1f4ed8695d57d46041f7f56f1 d27c2c96999f7cdc95595714e3d13515f53ae0df9b637570f8714350d1697d7b ad198f8467144c25db302ab30a80e019b7adae0a40410d1aff515acb2591cddb c6d454d5093eae5b3c4ec5f8c911bdd6eb2e218278b4b201a3a19607b8196607 304a739ca4817e364976f42d2783b56dd9a53fa36cbe1c323c3d7e8763a5c442 888ea08caa7c00982563bb2266cd780ad0e963f3fc99120adc2da4a2bcf96b55 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 false +check_ring_signature 442938fca51f9eb0b2e004adf4a44b765d7bae468b9dbebb41e1fab94e668c77 f78416cf7697fc9a7cc12cacdab618e7c7b3828b43f402c4b961ee4dbbaf1cd5 3 c39512232626bb2ef03f49c906626c71a1c82592dcdfe52d8bdebf58a6eea242 9ae9d9573a311bac645f4477453b7c3df42ad9c759a6269c9b250f39e7bf0101 2966ba0a63a1d014f71dbb17e13cfd24087380c9d0ae088cf698b412a46c50a4 f024d21cec72ad38d52371bae17193dbc0a8a96f6a6a8b3bf68a7c3e5aa18500d23446e716c14e2437f31a0da31119b052fe9d6fcfaeff8cd35dae6a8b66af09404eb945192a0dddc69363c5d3f01798e9239b4cecc6b7a364b0ddd5b958c3032aa74161c7967f9dbd36b1003d6a7fa821e7a514e0730fa342133d4aaa9f0d0719fe649947c2325331af854caec49be193f352a54d5271ba9fc9c957ff6e7706af001dc3d65dd1064d7cf582b9d69b81ce1ec70427611940e2cfff25466d790c false +check_ring_signature 377bdcba1f66268b83729a327bc9eb15b342c28c7b8d19c35de3bd2f5ac4496f 2308a71ab42fc81bea11393545322f3b01f0646857d88bf5cc1472b354252ed8 7 8fd0f48dafb35b7272d51945106f58bfc5e48de600c8d046e473148d479f9fdf 1fbc2a356a82d914ed17fad16a9f58249651ef50f10fcb43e60e297e0ee4eb08 015f4f927cf8e4206414276268924297eb4ab63efeddc57d43cc7fca05bc4983 90799c7b6f26713482de018aafca65538e574023d1501c198f61dce712130dac 413b7f384087bfd6ba820360859898a176c1e2bdb409995e1e88bb4684578f1d eb36d8696c86e748b7ac51c7bb6500ab0dbdb8e87e2f8d2e64cd1136e7fc9238 a0f4724f5030c9a1a98f9dd733ccc93d0dee9f8549c1c629dbb2eb2020d17c65 a931a8a5ab4bc0c54bb549017c426409908d9ea7671cc4e6b2381c1110127405c019442e738eb37f12b13b7b7e1478098c80c299f642abb01ba4b3d94307c60c70bec5d1b44ec4bb22d4b47034f2a9e9a6d31e8bc156d026d610a8ba381e5708a335204b97d51d286cb364585e8c95b9ef4f65150f5f394e1fbaba02d6ee040c3881af7298992774b78e38f9c1264e9cd3866a0559323f9605bba2b946f71501dc10f2b2f49808cc055d26da0fd018fe5dec68dd7fe84b59c3fc7fa719d8dd0740b39e78099e7d4943ced4050c6e45ba30ac835602dab11e5f30ceed478bca0ee1653fca4f4bbd5a70523c6c6247e13069b6763bea6adf81d8af8c9a81f8e206d154d0e61c4d1f56be2b26e7f29b6113ddbdc6f2f13e1c617deeb2792facdb08401814c113bb8259924ff4f315a56b171aec1a92269f329fe5230a9f2246ce009a664ce717ea04e57c15b7faf4a594384cea06b29c05deb06df800379d087d04c6841c9fb85d66c9a92e779708e6fae86542ac111b023c995eaafb3962a08603e82bf13f0e2638c7597d0d620d7f2c05c0871ea0caa45e2b95c3d14beb082b034c9f8c34bad639119515641b5c571c853a6b8d556897e6bde2aad0fcf6f50e08 true +check_ring_signature ccebb8ae7f687130b93916a7d7afea292ba266eb377390455ec3ab18b55e0b38 050d0d6e0052176bc5e6d4fb8e489c43e22eac722fb69cd56d32e3648ef6bd3e 9 492bc87efaec907ab81c01026b8707ff5cd7015a725b38dda09edbfd1ef1a18a 4ff0344fd1c52d3aec9f30c09e41fd83dc1a23d27b9a3162b089898eb487a988 303b25e2efc0b2d56e26eb1e71a346e4a49d6e840744a7fb35eafccc6054d8af f7ea060beb5015aeb8450c26e811fbb0de478d07743f5a6adb7c72fe4fb5dae2 bc2d71a422173b07fa41b95a2b2ce851824c130900bc6d42894efdf46add8d0f 96eefe953c0d2f632c7f2500f932153d81078d376a83748edf2fb081df4d8532 d6faecc3696e62597f72bd9a694216f6bcb5ba98230e3f4fc01c892868b133e5 8696a43bcde94485b68852f605049661a2edb6511413889b828a10393bb842e9 6560b9f769564f9e88ec2b293fc485cbbb8b266d70ce4c6339320db7d3ad46f4 34e905faf04b2d52d50f454649af13e3b7b4dc65ddae9de903ae8cca948e0d05953670fd7e3c17bf47b693ce26e9358711c8ee6e7f7e23c90c13c10a583ed50be1b4634e992afb64091b81f194b3eb79395891686867b55275c0264f7a2baa065940d9e8756641e9941dbdbcdbf3b86e875a5f41eafb0430207355c6733f8001f661310bb1a3316f7346d669d56447beac086b58661779b94b97826f413d26056288833ea8e7a1ac92cb7c9b6b75fbfd8f1f780a10ae25cbd094729e8fc5040d6d78259346c52ae6e78c404515b254770c3dfc8245ef6074ff6b717ab142ec04d24aa8aa5a8afcb190349fcbb6ae14744bbc05af765a6664090ad118bf63ff067a75cd612ef1f701c505503bb06fbab22fbbed6484a1be3863566184e2432101ce27432e54dcb8b00e8e374ae8ef1295cd50b22dead79bcb9d93e2aeb0b4d40d1437bc71176ccd19d7141b06ce550ea1e7a488d952e7803905e0949f238cd0036590469becad77d34e4c765f602ca42a6d827bdc948ca0894334da10a890b3043393b3f8f1060bd8b8617409384a6a6274076847602873e1b8620dbc4f8bc50eb14ccecccfcace4a252bd57330fe477d08e309bad9d3a1ac46035447ba3ed40a45f56f069c0aba1c77df6e9120c8542085d811400d2554bd8703afcbb3f6a809efc7e8fbaab2c26a85788fb4c36cc9d86f88aba1dd2ec0ac4714e3995b918a0735cab6ec295e9099132ba91b7e196b44f7d39af46f1da35398caece72a55ef0ffe53f8545d186ee42297808b145687fb6d3c620b9207a2ae8562a282623aac06 true +check_ring_signature 484d3d9be8d4e8a838c00a87036b6227f28d49083bcea49f46caa425b78ba9e2 f3d9618ad1c54698a644d292057fe01e1554b2f803d41eb214e2b178d6a3b5b5 163 0dee3ae8a833788ec12c2ebff271bf499715cc4a3827cf7230870dff767491a8 97b85e7a50e86acf2d925b860fa82cedafeb032121569bff1c811f66c758b466 f9db32b5813debae2992743e116679ebeaacf5362f1cb9ad7a749c92261dab06 d3e6eba95eae01f0522327919548523ab092dee9bb2a2717714f6d6e4fc56429 db44c817db288c6be3d93326b43df0bea36e3605731ded0f8512a6dd7de3d06e edd7a166977d7ec45fe7a676128becf587d61ab6321d2b50edca7955093eb398 20f605bc5ee1855b1aef3e467faecaa81323c29b6d67abd64241490078c09c31 26ca0d84fd512314da2849766a7adddaeb5d106ccc13d9496281349597207993 a287c960b2a0253047ac19978ed4f8df09100b68bd5152244caa2d0e6cb90d4f 2ef6b1a26301690a2d4fbcbb0045ab6990d2c18b7bd8635bde13d64624c9f5c8 1b42b7c78afe45b80d6a57f5440bf674ccf684a1a8574c8add7eadaf1df77956 dd12f1b9285ca10987ccc5a1bc53406bce9cc5f646548e11fb5a144d8e524ff3 e062523ff91964ea860d08ed0c0e571337a9af49f3aa72d2f06c582de7397156 15b31902c003749f9a61e20fefd60730c8f07f8fbbfb6c29bb36ba003fe41273 2f265b3ffeb4ff87e25072281a61cb23a89fcae7aa563fe7c2636b93476a3a11 2e11d0180b17597c1b97b77553652dee668fb5b3ea2305b1ed58d029fc7aa10b d81a547366834a8c8d3d65cc1192f7d74dd7065848267b88ac709ee7ef834a0e 7cb44d2992433ccf9dacc0708909cc9fc66f19527ef3db2bbd47c64cd7ecc06e ed6da27c7b8e394bdd7042602d734267b115d8f76ebe5278de2e4325ab677911 bee9d04176576f8dc8ab020bcc79e965646e08ffaf1e1593b7888a14b33b2d75 328446230a26b6d1ee45085382a752dc8b721d8dee4ed55ef7ee62c540146d3f 81685cc1393a98dba9a094025ffe672b18c9e21cbc0bbd93ccb85ac08b4312bb 0506e5be05e6678cf84de018f101e3182fcc77be0344799a7ed2bbca0ae3f8c3 61c1e0745e78f5e662a9e4bfefa502fa926132c736f8d51c7774d76be3037315 19c44a1a6794e8cc1ee62ee6a32c970c4bb742247216aaf0d0ab29b330c1b483 5c42d03c5e4239a6271600971ab4939032d95b76a5b73ab11a7acf74c2c48a2c aff182b73b6285a43897204c1d69a571988daf542192299f41a34c06c29022a1 de2e920850f97e677db9541d2ba487e0bb55cedf76f92a4290855bc71760909a c274148d1d16dec0882fb3491d8e3ec677edd19061f099482a696a0be842883b 5064f168117df50f475a6e3eea8d73b436d1e3c222364fc5d82268e6652a7195 ee4f36025347f2adf95f98b4f3c568a8df7dacade70f96dee631a1461ce0355b 7d217fc52f05907b7ff3df6b146052970c3eb6edef4ff6049468a921c5a73c1b f5c70c58c1e72883cd05f60db323d139341244e011f91b6e9b9954ad1f702223 3ec251143a8d6192827e514e2fc1e5d77c09b49b5e0b6116ce61d771ed037a8f 8a6335fcc57e6c0d32d33bac820eda6e133d8dcc503982093bdc6d28269a47d8 5ad88f5e03b73b1decaa86b3fd3dc78b471c489a2b1d148b15ba786bdc38ea7f fd5f9aa198b918315239da92733d65d432517eca1e742e3dca5c26899116e41c baebbc743efd3c7713a513a70a361955f4641b71cbf5de8b5ee27d531f905a8c e0d039e4a9829fcf4ea5ce7a473efcee37149b378633dcd7f3bc994c585579ad 73ae3dae84faacd2d07ec835fc4c7bfe02aa7513339785e04e5fbc8c2b83d676 3fa6125f7485ffef8d130e7fdd2c5d6710e7a1d11dad64a052d21c1eaeb07aae e66919c7c06583aff9d18035521ffa96feb8ea91a64fbd7923131fa56045e47a 532a21e7c5ce7fe4df004e2e5df436aa751c004e3744599f91610e33d64ae310 b09a56741ff482ea7a98a565f2e91bf0feb42dbb9e7d948c31a54a9fab8b312d 566c2934082b03d9fd345f5dbad1d3fa3794f1709468fa1b54f981feffe69e73 ebfebd7807c1fb74e0c8fc3ffbfb82e62b741ce03364ed314a72855099a17b26 7f762471267aa5d29d0224747b7bf580a49e1df4a4b6918ab85800c23d6eea96 1474238b78afc5fec3147f19475cb54aeaa4f888a4e328e38dc90fc56e767639 0026ca733271c42f09e9492523435026afe3e048e25a6ec32fadaf02f9ef618e eb127fbfb17ed11e6c4e41af485f58320a23ee69cc57432902fe43acdefbd839 f4ffcb9bd1d4ad93c109b178485b9b28d4bd5908afb3dee0604f7471e281bfda da37bd291fc64bd8a4c9a512e769c8fe4974980a69ff69cd2142dd203d1713ea 4fc04319ff03526151d3fea645930ab54c80189a139db211e2ebbb16862de974 40143f037593c1efd354f37fba79a58431068c96d9160b34c7dac40d3560de59 465a14376037afb184b720b36bcc850c4af0301901632ca0c7a96a9b92e26d9d 0e80f71109e577f4561edb6195021c25d30a976de88e587efd158d2305591b71 9fe2eadfd4d26b2f000738d6d67775c7953fa74816d87a9791df36f4897194dd ffaf1f1cde8d42568a5c4d6a2364bab67cc7eccbe169ee23c2b5b2168f2e91a2 fcad8435c5bdc82ffa3ad71b578d45ce266b3374ea199dd7ce2c4d10c7aa3dbc d2dd31bc49355daa82d6b24ecf1e3b41f7d2e052b34d833c90bad26cd2dc7fd9 923505121361c025d69ac947a5ea0fdedceb0f234c3d406ba97c81337cfb0003 f1469a1293a45f44a1c688efb029311fc43fae2083da50615b6cfefa49a00277 51c89cb696f19b9ceb2a265eb10cf8e3894b3f72bb2ce20d2b06c486043e4a36 440b8389768927dce7029163af8e855871386ee3b6b222dddfa28c16007dae63 5a3cb1bf8d69dceb2b690558672633dd2b934d088521b99d4dd7a0589b597556 61fd0727cdec203121b0c9453ebbbcba29f37dcf64848d2a220dd477f23ebc9e e5de68d241160ceeb64061ca6cf56085b2383ffcbad023dd18e380a34e66920d d67cbb39a625d631a1b8f9d924fc424a9710566e63a64dfa78ac906eee423dd5 41c5af8d80cbe6f783a8a3431a1b69c17afb9f2dbb611f908970a1494dfd38e3 7d94df49364789109c25f198eedbf218c44ec06468225ead0d0e60e9fcfaa3bd e0f51a70a68184c2232b19709e48d9c4ff6b8c66a2efad8ca25c97358fac0a8e 9870b08d01e0bef3e743ff1770a96f6091203aad69e6806edd0a596e630f5fd7 be735cf1833b2a0469b98673d5e31d7ed4eef5b363e5040b1a778bb3ef178a9b ffd0795e10932d94e33b0c8bb98fd4d0e6cff1d8a3cd7676a398ff64b21a0ffd 86dda7f63d5236bb70aee143adbd33a41d2bd3e4eeb208b79bb8f1c7ab63d01e 079bbc5044d751808a3d3039b7929d9ca1121e9fe181635ce1562a35d05c5cf2 0d7c75025a09691f682b4d40944b2e8d4186e9fc7240d13550f9761e4d1c5b0e 4d579a44dfbc200356d7df4539ee64b4e7c31ed7b40978dcbd4455e0c154c789 8316d67a8218f29148f6dcb98951b35a911ba16f44d105a71a96034f9a0c984f e74a9c9856aa851a562d28377b067cfd9511176c197a04d419c944944e886fa0 7f78e150fbb10c215ae4e819c754198ca9b14a1bca1dffb947641363b784e139 542a3ad3c62fbaeb551a758025c24299f6286ac01744c5ecdbe694c796b20458 702f7f2fda9ae3a96b1b70da766bb0c464dde084b757a71deb26584e11d845d4 2ff1982b9850d36b29e948ffe2ecb91aff4a23b7803a4d12895b34507457a1cf 161d3fbf059cf9cda0cffa271904dc47e1acc891ec92df0f8cf40f63555d06e4 0d77ca222f74cf35b63d9ed7a3688a30a8ba5091642ad49953f5656303acac51 6bf6605f3ad27bbfbf8d33b9466e09d831348a6a756194271283d1f364904d9c 2ffcd2bcaa4c40543340c62edf5860f53c44c1a10e96a743f177d2f12f738cb4 44e690cdb7103bff0a049e0e0f75e2b86542e09690cb4904d294ad59e6e42519 15113ff262b32ceacc03ae2cbdd2e70344c46486f0803c19283a4aa5a48a2ae5 cb040c1014f39ab34876e74a0c888172d8422363cb62d138195f2493f7270455 b10705b64738d2be2b8efe7300a09b7dadf17bfc8f64f59cc93209ffaaaa4d37 b11db3377afc709e634ede70c57f09d670a7152c2ac832d71ae0d6039bc59c6e 0e13551fcc6c8670972577603271e25a19f2b33b60c661f8dde85a3c878df6d7 7bf793e308240262e8232c32835cacc6f011eeefad421baa7f84132e19c302fe 6c79b7913fc97c16ff18ef3fabd89c191b2380188d70a1d085c6895eb8dca3a4 67b769c272a79b045b1b38339ae334a0fa49a452f5b5c2ab2117afd6ad7bf67f fafc5040cd549f716eb00c470ee9e82fe229d5e44625636a827268962a6f34a4 218d32728173545d0d367a8d4313888f7da6edfbac9bbc615254b7d6c0984058 c0e26a2fe45e870c7ea5c2c33a6543e845570ba795eb71040d82c4b0bace9d34 f2b83a1deb8276d4f79384a35a7d92881fbca613977d3726d56709b4e55a93c8 2c007b706af49ae4cdd2f98ee75d615af32da7f60eb48c2116265065e873446e c0b84883bbd21b79c269bd78aa07d37050a4b317f56edb99523a7f77d02d9914 fc00bbccb9f7945dccb1d50440427af139657e0fa0fad7a15f954c96123618db 70c1fafaad27935ee7d630c564ec053d62bd7220d19442ccd33d2e3546810950 df430f53d291d0b62fe79097e3af506b36882bcbc5d0d0e6d1723dfa959dc6b8 7d0709e0e8851853d91565da0b3311e039a673771efee69c8b83c58df6bac51e 0b50e77f0ba77bb25e48dc41b32851e3822fe5fc5b9ac47a3b1e98320b20cdb3 b2f76982ff91be2e93aed336f051259191767a19bafb87b931b409b15a65b328 3c126d1d80b416ce26103bd6dcac3e99a3022d250203a58fe8b502ac4cc61437 11e860f8aa45fcd03bd5e7ffef3849c9a8750cd2626fded2e43d2aba617176f0 16059483d38a526125d190dcb9abdca581b83a1afdb72526434a4aec18978bdd 703de81ed15ed9a3983505eb5d2983a3bd2b20a4195084e4e816bd2721fecd9e b3553fd712ffddbeb5e6709cd2de3f85438b0aed3d47d572134647889d73971c 3ee087fb6b2fe653894d9b723515ee84fc3faa09dfc405924af1f6900426adb8 1968c58ff0d69021765c12f990092140a93b0663787b3bcff2940ae3473deee7 58049f46fffd51f2b42833fe58f282f747aff14bce7b4295702418c2f9fd6062 f635b3be39833b2f1f4208a8d15250249c82bdeb119e83744c4520136b018f38 8382176544a602062723f40986376705f91f9cd3c302b5f6ef3f5e3545df21ba 3878dc819939327bca4eb7d9ecb996a88a1f14c3a2be2aaa44a59d6bdc40224e 50dd62ef02d735ea29366d3249e740e15391c35d320c209677d67b60b4dc4c2c 22d4befc6647f08c85d0b50923b41f20251aac6fd6469e7f5c79c527c8ce464e df5e80654325b3051cd2a80cc1c71be5c25b5e1de2cc980003b05e9b0007f26b e0241c843a0876416d0ad5666afdd402ad98331affb3e360a6b7602bd9d8d0cd cab4ee6ec8224e54d12307e7b901ebc77381501c48b851696c79424cc2d153ed f8c83929f561b9a7daa8ac881d03c555ffd37a0bb68a7a63b1d5090f2b45163f 8ff704bb89441f33268f5229f720e6aba421ee1a41f1798692ad011ceaf42f14 c0c38e8a6150edae09d5fd128390ca17cea5e257f6c3c1223453515f4f00c02a 583ca0f37b1087e2837117abdcf0bbb5d1dbcb7652f9e7dcd22c10950cbbbe88 6fa5e58b0efff67e0c9ff75520a4a3ce831d03cb6f29ce15bc561d5ba5713bad 481b3477763db6950579b18aa2b184a19dc865cacd6114b732688d7507d5cb10 0f8a9061339489ca44bc84af246ae24f82056e7c72ae570160d27fa9a24eabb4 fa0c04c1c1cad5335ae0d88987f0ba7a1183377d81f46b6f1311fa9234273e84 726826352bd5fe8e1355955cdff4f7e3aaff39bb32dd9fd1dffc5302f61bdae0 b56fd96b011a4dcc2293e3f4a4bf7a52dd4791b946dba09b8fed0d78bee2b3ef a77c58f729f0609c6e0399e203857d689260ce0e9c860d490dfef8ca32470f03 26677e69b7885b2a6025faf9c9f1a9bfce31e39bc93ca86eedd690b6f013cc24 aa4a735a806a0915ee1efb7a88aa83296d76b09439eca97aaf6a172b1623d7bc 04d15e070afe1bd9d8e02180a6e074bdc88b74c234968efd492da61a9a70e84c 30d1322dddb9ae25c25455a50de1c3cb2177a62835de317da1a9d7152d478472 7c2b8290855607fefa2a61f595fb58fac96f82a2d39516367b82bdb33d4fab0c 1900f939004df9fb0de385631b7b87e06dce3ee019b807870a72c0b80dfc4cf3 a1f16cf8d2a6d486be9bb326457009ff0b9878e1d88d2850ad3079325f81c843 492a0dbb97d77165432076062780e846a03ce34fdc57c9634208ad8b651e1f3a 7d01212b47a7495aae1a0409d84d92db632b33550e806221b0eac33490b2cf5b ca7a28a5e4c77a57a670bc3d9802035739924b2e230b266b267d72124660bbca 5a5fc123184865164954da37c1547c460e92cad2d8583a9e60a640539973322c 831dbbc5b7ad3597fe67e6665d19ff15b171a9c6ed6d96c04533680cc4eb8e10 49e0e5ddd78f41d683556aaf1ad1b1af5c8582ee6c47634954910eb69d011b2a 780e6fc90bcd4d13fe9c213f7337f855c0dcd16f50b4541f93e3b9f0c6a96a78 4ef385428df91e947dce8dc2219fa417f01f3d36b30f5b28dffe3784d3d6205c 532ac88efce553fcdcad28dab4df6e2a4793508156ef86518da378d8b7c79ad1 d53f5922035267d4350261216270bc765da4613ea331049f4c90b99c7c6ed5bb fc0fac1a2dbf2b1b44620c988571d1a9c75fad56f6f76863dc09d9b660a2aa13 449335842454bf243d631239ec30a253f10747f8f99f79708084a4a063a10a37 b199c43c2cadb5815077a24e949c695ad86a96e345d3795636cec3509f81db31 d762a28668ef889d689fd0c1932755f7387fc09560fb7c0435bf3465aa60af08 dd8fc3c3dba9bdc0bab86bcf3f26585444c6347d2a9a94dc15997d9b56b172db 4ef02043ec6575248340fa51a12f37fa87581730b39ee93fd060ae6dcb53de49 8ca05d585ab3ffa56e8b11f4360a251b9f0de659f4641e52ad3feff55c6abfbd 92dc666158bb8173ad3802a4a231c410d72cdb29d406aaaf626c74abb2507783 9a7d552d680a0a5c395887526fca9447737db9aed6309fa21b4b28f9bb0b0f3c cbc9e3a7111f732dff9106a54eca28efc91cc2bc30e04652f657e98cdbf13e19 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 false +check_ring_signature 8c97e6516f8523df6d78a7d2781adaa4cf2126e8d10475b094c139221d3887ae 37b1fafd9baa73bfe9956144d89e7afeaf4e67d0594e337ec9e5a050baa8fd07 3 fdd7974aac8468519e4dfe1a1284729a41a7ffbd3dc84c8cdaf1416853f023ac 3f5e2748c13e12f62cf7e5f3de36ccaf23f90cea4912e17db189941fd684a269 ff4a19fbd5f19007c9c9d02901571aae3207fe3f50d97e839b085835622285ff 6f802131d4704a85cd67bdbf503f96c451971a6094962698354b51c8b4634e0da173e6733952fda0d5ce1d49817ccac7ad9c07e5ee1d65621228bbee26ebbe0684ebe821349658279fafc94ba93103b84a8a6e6b1a321612790c606725be060fa336042faaae8bcbb3954638c1ae799a34f8a509897be40d768bc4780af2cf03c550d8929d95b1a2c527ba72d12c61ef477b93daa5857b483384299152d5330e11e23c26e9f4fa7840cc53a949a9328d78c04d85985b125253574c2ba9b11a0c true +check_ring_signature c047bddf7088fd681a86a5c7146ea387b4fb285687009ecea16859f7c61691a4 94229a0d2fc423f54dc99cf3d6a72a27c8344f03f10769734dc1e16c497091e2 32 b51e57a4e9147a3ef97900624525cf4fedde385427ae98c89ffef03643d1a78a 9c7120f012e67b541fc7561d64c6046e87e8b5e5d025570ef53fb82259ea0580 d382fb84f49a30f6e7c2ce6d5c1cfcf4aba400530744e2fdf739900e51a7a3cb 839df2e2353fabcd448985210a86900b110a2c2d14db4dc7564e5747ccac7646 ac6f4425071c69f99bb47c589a426a5537a4931a78f8817f36fc1bb5955f7d6e 46a2f68ff4f63040b8b96ba348cc4ced3b236507b6debab78fcee6c7ef6837f1 4503f1e1dabbf876ec131d2de9ae00f8eedf8a9ed996ae68ec0e54562c05962d d9caa53a4668cf8ee0af38c301993c0cacefc1ba9a63b9d91dceae602047eb80 c309bd5f2b59ecda43eb1118fb9b774c419e5bfbc25ee2dfa3cbc4e252b3baf2 53d83d1b18b82b19cb5d1f68bc80c708c367546841848b4e5f13ef5fb0f412fa 583ccaba2cb29b10702aa5cb2e41a51d443c741fbf8e71e9b6f3aaafab0fb649 97b137535b2f62e61df21012a879e506ea4ef85fc5be7d2b0c58985695ca5b06 aeddd5b5d14abc5ab8d69d744d6303660b55c96ac82ff8d4ecafc5db594ec34a f79ccfc3d7c1e9e32ebb7db1924918696aca5cf52ec8602894bd4941352a8301 d39c4b465b2829b8843f45e32c498015836e46eeed3f7f49faa2d7f193803925 e2cc70d19f6715f0e2bb84863f06b48938ef541f159a39de5ff2c8d0a82b0dff c2c57cbdc6f175adc4c894afb289ec44f0a510e63530975b543cd7087bfdd891 aa25f38761c14dde59212c6d591fbb42d63ebc758c0b2adcefc46490d2804ddb c63debcbd0ac7e35db5a56e79440c6743cb40ec3c8fc4956378e89e6e3a57a95 c985b016bb06595888177605dbc9a18bf3fcae51c9eb747248d994957790bf15 5c93f501a7b17b1ffed1d97a547d549bef879770e649ed3ee3d15fe41cc1ea97 7b1f26bce7649d3cb3e99dd91c1d940c2449b3255b4213f2545ed8c63862f11a 0103f880dcb1d21874c4d83b304bf2b6a7eba351c99ac1eed759a4d6e26ec6d9 088ba7cc1d2d19737a3fc0334dd39575422f74b8404c362e14b348225000e447 16e66fbdc2e9805c80ab6cd60194da62c757969d0e908dfcf77f81fc6bf79182 50756c315c3002d8a1424e862c7e73f7a372ad1e44fe4b2448ae2e422a20a5ef 981fd13de564d5cbde90286e01d0e292fd4674b466e83817abb5e4fff8a5e6a6 0e463033782d4fa9776601a3bdb0e3ba52718648e2be587e98921cb73817fa17 2254fda96b579c0c370630e0ff108f14ab3d9670929594f609c89265a5492f4e bec4bed318e90c85e2ecad8764cdf0bc6fa18f106e760ff56f5f73eae93e05ed cd6a489d3d88a233e2a212e3d63bae8c3033e4e0224a364364d869b4ea6ad8ac 92eda3d8b53a8c1cf8f9c43ad3e1f4a6a85759093110dda34bf17296d4a6d2f5 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 false +check_ring_signature 0e41905f9f05fb2e7aadb14b35f48463bfdde21c47086a01af0799292fe5244a 547f5594a664f60c08394e044faf475f2faec65d9d91ac57646ef26bc46aff94 115 ba0ca321e092baad389c9af1f7f5a7e74f7ed95409dd438e2ed2871207e7abd6 a89f6d9c97ee1336328287da0faec4181a7d78d87be885715fbe0f7bdc1876bb ac86a62fe497bf517ac0b00ee1bb76a6f6659b347b8693b01682cef465ebf137 9f696821719a0965dc18bd2e72969be2484078defedaa95511699a741afb71f4 c30def0a99199dff69171a8866968adaf261f4e0ff0462e055b39a08224e6b87 934efc0644612c98940ea8d4edf8c5f023de18688154f507b920f511f25fe25f 2fb46b296a8ea768f97980515b58a79ece6b57211fd71c3cfd1d420d6c6d81b6 68792a5c82d6ac441da1e2389aaab5fe28606cc1b607edc80251bcb91877dc13 9e945432e9da97ffc5c79da3c6c056612dec71a45c3f17fd604ed8239d1f9680 c924bc6244d933fce29fbed0c8a72c0027379c65ea530197afe26f678f0826d5 c5f95b669be58312ccbf628c9b945f72c10604898b2a6e30eb0d189294a9230e a423d6bdb86ab6368d248b36c948fde83ec8a31d2ae8b0c77e9da3e46fa5fdf1 a905ab6244508c369dbd063a490a7b402e33701da1d15b30aae5e1ee0fabfdc1 0693e8f162acaae307c0ca68273df68834be6fe1d4f0db6fd8198c134fb5ca08 1f1a78be2a61e6c25bbc0036c2579393acda2b6eafc177409ddfdc7699d78891 e99d355c1ce08a6f82fadd3ebef02f71656029d974f2a8242be37b6c989ff6e1 d7bb2d5aaa839bdd80961f31bb56799c7066a8a1c9f3771dcac3b3f2327fc2ec 1514a826439ce6d6e8f8d7228c69a045b631a13ece053954a768afdd1ae0cd7d 0a2073bb6b771a44a4c754be9ba28a65523d8d94bf14a29611227612554a0a93 4101d963bdf5a7c5c27ebdec38c4557c1f5a9c27d048b8e9780628bd339cf35a 94a4f2135352319b490375608cbee961dc91606df2d729a914cd847334b5f42f 4929045beb2d9512276d457003e3ace663a14760195ea9822c1d6a626316b4e6 0845ec975a7a7e495146f9f7dd53c6ba3f8fa5941870452aef64ab442db45ba7 dfa8ebf2874da851e2f621331a845dcadb668175f0de8762066420fa2e394c71 79e1db7e12ec6f70207d7bc2269fc39d5326ad1453fa7e9ec71c655fac118b9c 5dc842004991a2d7850014938b47dfe56446d770851987b95bd61e4e1b20df73 972ea0a0d4a1d3f1830dcd607369c354a013b77483db5166df91aaf53590fdfd e4385fef1ca2495404bbed6c932473fd6acd57d65b10daf0d18515f759286a09 ce7cb08938a2e08e39635d4ba2d393bbbda6b8046dae9b9bcea06f88661af3a5 2d8200a95797eb629bfc17bd1febc2f751315fb976ddd47d699997915df3691e 33dfcba11c47b695d4668d6662ae6772bb4cc10c2531ef42655ef50154140706 d0075a25a48c6e55a235b964e8fe3b06fb6e8fbda2b83c37b6a527bffa0ef86c 477180934602ebe9cbf2e079577e18f2ee0f50446d2b2e2a80dce5f9cd24adad e3b2f734400c96f77f3eff92f97fcaa723b592a30e48c1527c734fb2e84a9965 894c9fa24f4d23caa0fdd74d566d68f5c222563b63a77b1a2ebb417c83e2e4a3 964627625c11f84956ad4882e66b0acc9a267c0bd49bd36125416164c57460f9 7badd7980c0525864a32e50bfd31b6262f164d3d8c320464ec732946656bbe8b 37da588a20f0a9d4f77752ec3241c3438e4f0592bb49a5984c41120046e9b468 d65b36d46dcd5f46b94933ae02c75d222ae54e97565a8096c1f4c2941954daa7 42b5f9046f9d263d8a84f5d7d490614fc4c2cd57cc7209f1049daeabdbad062d bb071efa6bdd7229ead8682bded6396746685c971db85c649be5c5ae9bbef757 4163a07596038be17dccd60d5790fd71b097c277ec4356563fa7a26082fbe032 9a684758b767f17f0aa0a5f7f32786b45843d2df254756794dcb7c5a8089c302 c17c41c11a29828fe06d02ed0cb9f81de247be5872b53cae1be8995b8d61901d 8b23deae38fe82aa3d74aedabbe0c827b9b788c8c41fcf45c83c4bc08bc9b235 b0c08b7bd23667f4e07a980a0d587ff193661d1284839cfb582994e75844ef13 44a9401e04cada5893e2918df9145437caeba12a0b4207c93fe378e6ba5a12eb 529736ce904421b33143dd5553dc8f96266cb34653d5317c012458c87ac04312 c38034b154bf783f2b88f8e7c60afcd274851eb73c58f398f2c475fda56bab2a e9c03947e98df37b25ccbbae19a92828251dca01a77dfb3abd80cc2b35a77d00 b62a33c1e99da69f9d8e8297b9bee7fd40fb59d56a6e4207486438b44c89ab51 0793556789e196574cdbe2343b1c324b3e6265f5dbc4363827e1f0cf9c40be03 8e4232f2b32ac629d69eacfbe75e54559013241ee649ba3f203c7e8e75943702 dc508c48c68f878c82acaccdab3c60cfd19a2be8e7180c8e13b1b05901dda2e4 899295bb9a618c44318e03ec4369943890ebecfeb4abff1c7c280f730078a85f 64b11ff4399944978917546e6c6c6e02d9e907248cd8bf09c247db7ab21c11e1 4e6aa7e33d261c75e2d222674d7e33f74566d4735fae8a67a21629d3f60c9f09 ed3297133485ab7be94e19474691c80ddee1a2923cd1d88f192e772cac7061aa ff3df133baa88ea9432c7304cc4c6f636646c6cf5835baa5975dcabef8b4e753 4d32a353799f02762947edc4950c232b1009ffd6d43766bdb5929daae8106613 5aedd6d6d9f662b0ce591582fd4c651b4cd07214b56eae27ec02acb0747860d8 b15283474ab7e096ef37aab887dae89dd38b030771aca2638c6c5c5132f84a82 3bc238bbe8643eaf25a9281fdaefde939143c2a8ba1604248ae6d75e01e41a94 5d276a992c695aa7cb86b48dab10df199e41fe52a4a9451efcc9998f880ffa67 3cdf928f1aa0252246567db17457e3b9d57f547fc2b58c63f0100ca6bc4aa45b f3d7f31c662cd52692188d746894e2ee7a5d32b3d370f396412f9bebceb776e0 b3b2995b735692dba04c0a953a22e850b64f55048063f7217143a3b6d1897fa1 b7d235fc950d30d24f1f178644dca077c90f3c029571991dbcf1957c97b628dd 9be084547c58371f5475c13694438a43833192e043dfab92cc988b21ad9bebd1 e528e25a687a0da85426d3b404901cd6af73339b46e8eefe99bdcbdbceb8d048 94ce4c9baac5d8786f97403b8083004e4cff8f9005c34f15e908a9dd5c1c72aa 0d4535fe03fec7084c35a0f9bc12bde5b3bddb08afb15051832042b32329582e efc106fbc52700ffa96a2510dde25f76f32bbf3b9e61aba18cc753b795697a61 71398c2f10b9c93f4fa61252bd6e65167c6f3fb1b0be1794da9c1280fff67efb a587faf299024b25f1e14309ed0dc5194832e3e82b5d86617281021a5dc23727 c1f4cc548184289124bd99b4604f375020f3327737d85c17e5b5248792817626 a596c11426c2658768cb7be3e2941471021be703635e4947dcce631850981ca5 a795fe3a977c2b296be158b329c93efe040ce841ffb9fb94a2307c0201e8cbb0 321d4a61dc4cc4881227e641f01ae56499156e3e0e64f4524c0c0bfadfdfbb99 22deb923f01bd7d1ed5fd847cdbdb316191805cb886a52cf955a616fb13220c5 0410f572c873547e86a6fda4fb27af9c25938620c50e4707e7ec58fa3ab1ac85 7ba558120932ed176c3ec3eacd8d69bdb74ceeb38414df2ee2bd5bf909108284 f40ae3b70338e881dd919afba3c219f4ef1c2c07a0e6c9aa829d866fb87e3328 dc135a8fd03668a5b0ebe25dc7f0ce9ee5dc876c15ef5d7a1052d1463f1f2078 ec399bbcb3a024be6c0c876ed2551131735533db43775097dbcdfd060c18f5a9 68be827b1bfd23f2cad58da0ce4a9fad1aeb01abfd4b79325ba821bf036e51ab 5a7bdac68ac90864d14c438b1875e56ed5aff100ac7bd0d08b4b80bc0b96b976 aa1efe9eb3f4f4f83a9c845a13ca6f0f39ec86ac3c3e22fae2addf5b00be72a0 cd501ae31f17a4602f826ae1986f0bc7a9992c28137f85f33f8e80c0a2910c9c b78922e9b4d0688ce2e44309e47475d8e2970d652ba631d6b31a069312bedfb3 a7f7f14bcff65c40f57420ca9b904fb8bdcdb9927977b629b6cf5125fc5d1b5d 7673d5baf7c5f4b646e6423a9071abf9c7166fc2deae39d4f2cb5512bbb27ae1 02249e386dd1952f7dfd491684306943aeeeb999b055c3c29f33ad40e4555327 23b9f09a78f20441fcccc4e933b6e18b8f60f2d52cf1472db8164ea8875ea9d9 d01091124504f2af5435d4dfdc433f614403f4cfb8bbdd2a9b3687dfa4d62258 55af1ff4445e352b9918a30e919373a9689e4a0472f3c86f224439be0ab2e8d2 19ea0600268611c166a9d45a4519ecb23028f84bae555ea1b9e3ccb7a4a9ad38 7b58b9f421863252b6852f510b27a3af4832e68f326b517f3de67e55d2a6c71c ed5db97417d89a7306f2264ec160b75cbc7020172836a1098a11a487fecb68a1 545a79deb11876ec78913ed2089af0d964e864f8ae091ac2837ffae712586bc4 075041de2bea4ce363b23f66887bf112f10df6692dbeb5e9462cc29ae657e257 c0486cd39b395d33fec0dc8824bd29b6c576a8fd472e8b03d4da39731c72cf7f fb88faac56fb263da5034062726d4d5cfb8acf5e59954942bd29f10b97e2d36f 5aac94fc82735034ad1a372a6faa25b6e7416d225132a938027a1300f460ef9e 0a10c778910cea22d929ea8d6f9c816905ab65b155b0fa6ff81c9bdcf5782dba 5013e5ae35beca79e3ec6a9ebbbaa31f6d66f853951c77e263533019b703ed7d cd04891dfca466890afb3a1a6c55b4ceac826f55af6ee99dbe7d8e9298c87a86 e95f5f320fc05e035ff2b5fc9a34038c7a235d2a07f8a22e077fe6520f9e7fe6 7cd3042f2133681cc22f4b6781d90fd76571b5e6a87c6089641ee862f92ed36f f4ee768da83625f280c6731872a2364b79885f6e6e64fbcf2e44ea30cd28b006 58552333713a1584c2708d47eed32beb13f366d5d46ab4b66166020aca7b6011 4f377393b5d2def5c7aceb9bd784267d085dd60970722434b12001aa6d173d2f e660a03723bddc8a0bb445fc0e615a0a70ad77f8a9f363ce47fcc1f70c1dfddc 8ffca5b58a48a9b384bdb77ed096d6353ec3a01706679eaa7ffc907ffd05b629 a99a8facf8c995dc7a3b9b31184c280cd06987d0c39db9fc35144f074fee99fd 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 false +check_ring_signature 85f70340b32baec9875a12bf6f31cfd7ec5d55ba6237cba083ebbc42e2f69a5f 63bb777d231e415c66188f7c5764c0933391b5b14875be90f799a84efcc66d73 23 1744e7d9df32c21e03ed82c87e7c727f86b89e7ccee38ea199dfe2050e373746 884c63be4670bc133dcfa7d61acf996c04173332e9ca9ea14d23323dbd31eff3 cc60c70c8082ab3c52bc706437670b97480c14f14cf9b3c0c313ec044b8fc93e 069673ad3b8e35639b59e8458fdb12c519258796198f24afb2cc563b87b8e8d3 c17c9b114995d18894a3b2e83ba6c78b37e24e48045b54f7d27c94102f28053e 09cc12a86e45bab0e6aded0f5b8c1aa83a1a2940d396b3b59efcdc0b90875f8d 804aa2cba46c8514b6223275b25d48d5ddaa6da34acea2dd94820e610001b7cd f2ea8364d890ba2cc78583602ca6be716e4011f38db99bf12a4d66b58662cc2f af6411b2a9f9ae6afa1bcf21545dc6666a43026cead9818d8fd85e72e87a7b9a a227de8d685a0255e60ce0952d0387f6c966f3e2d0424ccc6b32a13b0baeb171 c88128bddfebc048715ae4e15b1ec20909d665937f72123678c52045599da20d 4e7d8735dd827fc44c83aaee9bfa702c2e20e8c4a69d657457bf3800d7c069cd 95ffdd0afb599ef94a94be26f95219d2c78487aa24bfbd658039dee1434341d7 77eb3f07100b593afeb6875d70319bdb411a0c40631d70fb335802b4144d5b9f c419a82130fa11a12931f4e60123f5b193c893205d95f165d411e11823e0b9a9 52ea9a07b550952b9a74bb339e74be307fca33821263f5f547968cecd264a7b2 c12e213880efccbd4ebc3308f894cb348a6a01bd9d3f3dfdb8bb4936f6360844 75769920cd9f96eb68f1fac538bbf86d88ba87eb281b288d3c1f7e9fd0380426 fc0abf89e762e385fdbc321389b9aa57eb48fbf32e2ed023bc547081f901a0b1 83a947ecbb61283b8a46aa72a48f9cc34ee9de9f54a6484166db3a9cebda1e28 ab316122d46b97686e5b5cf864027fceb6f9a8971898cd4ae125c98ccf3dad42 a2b941f8c6b1bd3a227cddefc4b0095801b0a2e0453dc9e402203fe5115848fc 2d076f4236e6666f2fe6f9593235f1bda50cde35fc1e20393f2fb2cc22c5b99b 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 false +check_ring_signature dec64228de78ddb98b08269e1032d9ced99caf6c18f5739e516d46434c515eb2 91ed717fb52629182d8bcebad7c4af93392449032768d706456141998fc2d5b0 4 f7d550cc5ff8f9e09460b9c4da9b683fcfd88e08124e13b3d63a2eef6d7ac1fc c9466047742865abb0bd18cfd3093c079d58fde63f74eb338fd95a70a3555645 122602fbe04c4e1ed7e5560c72c7473fa3a0070dfbb9baa06500db1fd317ed8c d07247275fe85ac7de1e72c8fe00208bf116797890fe050c8ddf68a77d0583c9 51d53f82247286682619edb64a6f3f6d5aa66e13ec44b8978872e24fe154c504fc02aa33da1c6bab642370af9965e658c6659e7b61fa0195567b09d18d1238074a7426a5487822e917ba9085134e481f73e6ca3e8490232985464d8c31a38b023980b2ebbcb6bced8788b6feef025f639bd8b61de532190bc2f8187f6204720da7451567eac3c130e802a148323db62fba5bbaa400796776dcd25935b8ebb607741529500302d20304cc37e8e11b5aaeee963b0b08cae002b50933577cf06b083dbddc1297f69b88f0106893ec53a542d8f7f4c1c50c00b8e4bf42e094d5a900a498ceba2b2e27598d0893bdab7f63f64d42e3292a0221c9335903a8f218ef0d true +check_ring_signature e96b6ffe89cb7fa8989b93e892d2435dd49abe5462416ca38068977e3922a86e 4ff21b9657dd09d98ddb1f0cd9a329bcc44572b98ff45007dbf07172dc55a7d7 2 d38a3ef05acc0fb0cc04d02fbd557f7654e549a4eef100c6dea15e5410b78770 83f6f8f2c55907c130d26bd9f25eeb4516f5e7fb6b405b902d3d59bcb80d1490 c22971c3badb85d54a5a1c34dee528429f0e96e6efec86c5a2349aa71a3bec0f0f4701fe79ef04d14f41faa120c49bf14aaac037b29366b625f9ca87de534805190012670dfa2494822a98c3627d30b36bca5efb8f93ddcb24c406581265ca0232c30b3188a2b8098202e432e0301a9640a1b42400253964b8ba6cca4568740a false +check_ring_signature 6746bbd3b121d924bb6b72b5dbc2af59f67c656f6edd09ddca4bcaff115a4f99 256596bb6027811b5d6f630ebd489b337a42ff16540ff43539d8a1dfdadd14d2 22 72bcba5bc321c27e2fd2c1991eba7b7ab5f69f900db030a667dbba1cb66cf9b3 94f5a8ea048b0965fd1d35615706a78e690a8caab42a2b3e0ac388212aaab592 c49166a2152b0249109048060592728a73a0376eaa8cf92f6d6a56637c3f1381 df674285bb6c56018f38ddac7370260c4c8644377fe3c594caeff22c7f2481aa 6d8977ed46b1fc446fbb010654f2bc47f7c6aae73c65e2e406822030cb6a329a be83caaf9d1124555ea2e58791b3e1675a6e8309174dd084a86ea14c963d1075 ad74a78a35740f8ea0caf5ba3cc6134a598bfa192822658f88b5009944f3ea1e b2bbec5079ac8c618ec608c82e536b07d39dada0c0c2f74dfd2ea88f9221a69e c522623a02b6e5bb695eb638c6adc806309233cec56abb83c4e3db899c89107e e3748402252fbf31de87774abb2c09bbe0630b6add42171ff52948847a6f13f9 1387230337e61b4e047a2f0c93a9e7bb7b2250536a0a192399adaf3e3b49e343 2d632ee65bf5466352fada6e97708c576d70d99c872deff1fb3ca51f51f2f72c 3e55a856ebb0b0c95aa4b8a5f1983f040e81aa2853221a7a79600d94454ffd2d c29df508c3a8e2864e85b97400ad9e60b15fccb5384b8085e8fa5cdd85f3d58f fb67ceb994dda59db670b2c5d518c683abdacb23629f02be4039a036e1e6a94d 9b3dc0c09d9f459d0a4e8987a168848f384c1113a925005470c0119dba298a50 10b1660a1df0c4ee8a8765b511a19305392c40385cff6354a2723b9f2820617e 49741e8251c6ba1d30884c1440131c6663d297f05c97a87268d8ce280038bb34 130cfac41dcab383a2052d407a7a3c9074a420edc5162c5af599c5e7b750fb39 a2d0b5b0f1265d6402a8092c31dec5e48de1f6fb12db9f2db41520f641cd7ef1 8ce7bb26cfe77806084b861d58e1a737bc7d0d47b9d51a7b1d32c49ad120c29e 14e00bc08072a0ee425e94e860a68428a0fad48614d4aa4ecf3e9a5971bed184 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 false +check_ring_signature c98991070f7718fedbdcf92c1ddc8f33cb98ab6497de3dc5055aba558c21682d 702fc4fe6235679566ff59e97bfb34391c2ca4f851f70b19710effe8b562eff2 58 763caaa87cf235adb7c41df8facb167d7752e0168d2cf86e4142395444db85cc a3a71a09180284746cce08f73971d4df033c000aa8601f0e97a07f8386b89118 a0e6bf1068246c4a37fd7bb00cf9371cfc4d5c406ca9eec328b010c50fd20684 7ea74d08c67c459cb5b636e48559720c132acd225f3ee4648e4d4d18238b7323 91ab955c9a45e81fd9ef5089db0a3822718054dcf789b4bf4a5fb5edd79ac797 122ac214cf32ab27817e1a39c4fc3faf4975a53269ad62c688d5eada9bdfbe73 653b3af115c5980d7b5012abdef6d9cf28490b751ddab6aeec7dacab2c07c05a 2528464c127058178ec4888191f7e3dc691710e25eb5a8962ba59845ed5e4db3 5cc66eafaf7b13fb560dd82e4c900733c59d45b206e864733950786b453d46be e2429fa50dfc9f94d80127e5bd03fa8d366cffb9daf3c934f0cedce304d04990 7089a0cbc2b57b8646ebf966747955c1492f0d9a155c183098d077b9df62e2c1 89e756879914a97312f72a191f9f3e7bc671cdb2c75ebced2fc9d237a967d08b 12fa575316ffc42c096342c06392b77445a96dcfcac2575d81fd62eae6743788 8842539447c1d3481346a5056db3413f065e78656f1ad0b82d2b6630cd82a232 04941d2e833d2e56d0e3eb465a7008a488e41d34724c22358cd89441606150ab 9c1bc86a36d2f28e1bfd824d332ddf3f84f1feb2c629ab29af1180dacd1a7c5d 18c7e1cc765d5cd9b7e61643ec4bc524fded0890ea95e8e464b93199f49b311c da6d3c514a68b22eaeca42df37c69040f70bb76a0ec4dcff44240f784bea1f58 a0597779133bcf4e1075328bacb8bcb92b51ec5f4d229196694697c49dc75d02 058f04a8bd45f723a1e14a0c9a72a910d95b199845ab12605d2e300336c378dc ae407fe66c3753bfbf542fcb94a02f515a06f0c2cdbfa004b0e870a4b2a84248 743985b1d0d8f2a13230c882b73e3082f76428790b3d349f33ff8ca1179c2924 115380fa4577d71042488463964a765e538111b50647ca13841759947fc21c41 0defd50f2eb955dd288a8135169f793f44a05a1c7c3669d83ee68e6a7b1cdc1c 9d8f26efad9d62a2cec1cf7e5ee32c3c6399e3bfb78b05c7bf80a9763a7c6633 a6319da23715062f79ce7e3eb10316613991c80ff3ebec4b2fe1177501459410 e84be37e11b463f979fde5cc83068365c007f7371d52c238b2ca70a65abba62d aecc487e0e40ede4d2fa5a6ed40b5736349234fd27db421b05eab6030f1cc223 32fcbd287a51eb1eaa8df5894a92958d773a6966e8959551c94df4209325ce8e 184ed38839285a1a8d7fd0dc9dd755509f595e9a6ccb6cacdf9e593e2e12a888 61b27ee07ffc5595ad1126112a4cc3cdea58c3de92393edc59bea0423981c7ce e99825ef483904aea08e02dbf78418417476fc4c2a0e6403eaa760d638ec2f92 bdb3c6fb4b29610e9b1e074171e5d89aca18960dd71a03ae9d9657ef3b962cd1 4d733f246e04c64dcea379bf12a35ba15789f52015f882a51267e464ec5c5726 2a4e5f3f5d1b952fb9e7fb9b8fcabfc82a384aac2ebd242fb918726fb6002ec7 f41c95ddc6fcf66a6778d2ef81450f54bdd2b51fecc1e01b4ecabba96a129779 73b79acb81fa3af8aa34c5602072c3e4a7de40fdb48247f9adbaaabf1656899e fd8e96071b10987e629afc37b5af2cf2c6b655d3629af38bc8854042c79ba9e1 cbba9e85b89811a8bae726e8bb7fdbe800eee3236bcceeba71ffa4c017f9f934 8b64b3d94859cf2f527e49dd8b07f8ad009f6403fea88fe7d5e84c0e5f6b6359 c09734574e1251f554c503a89293a7681c91451fac06487b22065e1d1d622ded d4c9fb113cd328b3296ebdb140d1d56775ee36230c8770373df4f24c57d1676e cf00460946a706231cade157da2d2550d6c9683c49b9b7dbe49bf92d01ef9554 43b6e8c5b0db9b61d7bcc14491ad536400fc94796d9fb6f11f2bef3d6bf4b97f 44583a7cbf0ccc6fec3c13e8dc1d1848d50cb4e729db60dc33826ae4f8111e78 89c156e693e9baf507f76854dcbd8835733080ffd2dbf757eb6b6803947f1a0b dc0731647d7aeeda00281826b2ba80b389f194470df668fce4f20c0c8b52250c de93f0e3bfe158e18614394e23aead62bd87527d8b1d2e4c19398092e084f1e2 72225f90ba68331eb446ebafa279dc8fd84743cd1b8350d4ecfd8d863567e0a1 af38cc58a9ac38fbba5eb3e07cde4d3fda27875ad9b44ad7530546a0806f3ca9 8a17571ef3f4bed2321227c5013070177d19a0c63c556e607fcc9f3726728a61 1edb83c5fa7d25ffe84e0c262fa965a4be1e6f111c2ebfa7136c25748395b2ad 5c95c65ce85b0ebd19061c5689b1a5124c85c91a3e9964c0ae9ddaaa19f1f27f f382cefbb2d4a2440badf8bd877b57af7f113758e7a1bf8c9a32f4b7ac296663 d78b93d6622b464322ffb1f6b3ad914907f2dde20875be47c1ca26798ad669f7 0862eea45e013e22d5cafa4ae93a4ef7e13a46126e751f0be6a6dbdfcae07d36 9f0285b8eb5aec8891d0d501fc3611f93167fbe03f4ded977e36045e9496e655 ee682de5999a941c8cd9f13844a6a2f9ccafacdec06159455679587ca8523ffc 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 false +check_ring_signature 489247b9547df8eb525489a2bf02b95a1333a45f433fccc36b9308d8013d4d6f cc1b5a296409e1f8d4a1fa451b910f02d2af2a85ec3328b0474c83aca51e0a42 30 a87e12463559d85d1286ec641905f116829947e383cd51aa675311ec031aec93 e0abef28019dd5dbcf0be06c2df2fabccffaf9287869f1211549c4864d94e887 8bb6433499babe82142b6a5d60d27dd85a7b45c97c8acd26c5a15b343a80a89e 7c662fe57e2db6eb5a2d553cd05320d72faa724960ee4ef904a0700873c69848 49325ce67214c968800cefbcf7d27b8da0b885dbb16a1b8cc2040f6ed6239483 555dbe57a04f051114e631bf9a2a2074bd285faf9fcb9bb826476538f4a8f86c f770ef15d1dcdbb78ff7be3a383805a6a60beadafb9e14bef34c5e3fc006ab2c aad703c25d91cdf187d06fe87237876e21cdb313f8ea7c8a2faa231127802f12 9e5c9332ba303622a8b56f33e958e6904f77a51942db1073d4f746a0521076af 5805ebd03f7b394177e3a373ec5cae875eca50b213f3c530f6e0d392b71b3317 5904f80b509b57f761563dee334aeac78d72e5a5c8cb4f9b75b2dfc261a0076e 775454547225604ec06f6f4520875034c1e7970e1baf1a16c494453dd1764913 c884c363c88cf6680d206e2f18635466f746a0fcf96ca761f171d3db2a9a6f32 d015be1b75c691c4eef30c5dc0bbf50fcbcdaca52496496445ae3e40ebf6e952 295d319edc580c466c1b81e05d6fee3dbe9b31e061457fd4b8ee7559426bc35d 01fe31e204d1c0d36914bc21a3a03398b57c1d83ff9551d1deb043ec101a1334 0837d391549c42281e284b531270bf072b52da003a717186685af18b6332c6c5 0b1acb5cca730605924bf607482e83e5d95ba4aab5809ca482f55c1769c8ed94 56a4c70c620c8674391e6f1015b0363421517319ea517324121f4355b0f5cfe9 2f9a5fde9817ea20b2516592c7d7cc0572031d810bd75b9e1e972f3b8c3c0fe4 fc9053debc360b2d643ba4a2a37048dfc9406defeba136cc5f26f774416adeaa 4cd44491ad2c097f15b86e1038c0c05cf8e12d063b0206569ae4d457c60114ef dab22ed8544cf380b1f03ea10204cdb25c958b7a6cb5e4ab8221bb5609a0566e ebfb55cd1f03ace054156f2288621efe454c45ebf3ff2131850c636f7e5ad0c9 95159f2afdfc623ea8fb06079fd2c19299a71f04314b592a0366fa39431ad097 0a67b17ec14c9d2ae912e62ba6fec1b0cb2cbfe08e9c689251e3d16c2b245d54 416f14cf89df663414ae273a0859a25df615cfba69579225330a74676e9c5ba3 16007d8e1b5028e80605a06b4dbdb15864c69f519111e31e4e76efcd25ca3580 71741915a336460d9f2d5e870b6c0768ed4b548af48345a446633f3cbccc5924 be6657a5e86fc05d6f043e108662cfdd0bd282d3c0835711415873755852f804 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 true +check_ring_signature a8cd013daed093f3806b1ba54476a44a6468fbcbe9f537b1db70aaa0e7e03270 782c481c352ef41250b69427a76c6cc5fbe1f830a74ca841bfb90cc14a5783ad 2 7df3c07af233a2cf998edb804881dfa39550e79b8829956f8824b639479e9cab d80653745adb9c79a38905f05525d3ee2aba23ebe613f8018829caaf15d2dd95 8cf753eca51f03290b2ebc61e8f4a08b29d66a8d590c23cc525f9c3aa227d70f2eb989199eeecee24ccccd73b9ae463b8ec1f353ed136477123c4bfad98e500ee86e93cc0dffb3e06cff2f07aead461bcc29440d60e4195985485e8f65ba6107e87fa57a8a2e1b84677cee7251ff3f5938e80e16c8baa62e1d6c897a80c2390e false +check_ring_signature d94cfd5f2d96b845dcca8d7a9a17f8d5efe1dd04b1ece130a7858e05f02e52ba afca7601feffeb674b6a5096d6b39e0c7e4af12cf9b2f3f9ff430794e9d88834 1 152dd267a6449f2c0b82f0d5752c9dfc496e07f58120bdb569f6e4af27eeb996 b0d207008df81e39f9536ca40b82179b3b36346af17da578ef904bf973683008a52aab1b60b253b9ab02d512d67056290776997a6d06455712590caa10143508 true +check_ring_signature b3df5d44812f1e65ecc52cc6a46162623f33033b54a7723013b2c2d48de6e726 4da006cef181367794195906110cbd05060042c0c0ea9a4af6f7699ab3a26a20 1 891c1cecd072053b603d42b8805c1caa66dfaed70d26add8c022f8d4f3a58349 b205f02fbaf90d06f2dc1b38ca319be0dc712d4f613fef993ec651ac03aa1f0db08c0c9ec7e51a8a6d92544d68526f60d7b0c02aadeb2526b0662f84b70dd70e false +check_ring_signature d9308773eaf40413b35c63ec5925ace8b4a05ddf9353f25b3b895adb6459f1fe 5e4557acb135134441b8e9d39ec561e995e8ad24eb9dd05440b05c0f376526ba 145 d447cf62e7383bfc1f0a46488ef4bfddcbe6ead67e0151495fba2d5402799bbe 16a306395827d1c1a5b0901c67e69e1e387fe5899b90550278f4a6c2e03075c3 39a50d6ff8338be05c498d95705617563a9fa81e4474453e89290e118216e75d 301e6c1c0a8cc20112034058df038c1c8e663990d8a6e8f8fdfe249abe7be550 b85cc046d96614eeb4f2a9cf422420a9a9224404b8503ca8028f87cd9339bc2e 80ad9c5007c4f7a574eec8f693f084f5f0a2fc996644bd05dd8dac328e968f4e ab8a631586a27b18c80dc44e01ff53eb05e03d0844da9469d4d943b1c3fad7ab 515b5bafdee33e0f9a85d5ea99c22d6802591f6bfd2e13ed5daf72bde5b92e1b 188c2faeaaaa2ee4d0b843cac3c0f40e3a9c50e0481beae2effa049c45acec49 bf98253b4b155b5c2c93769bdbd2bf360f3c240536a5a0a9044f25a61a2af73f 58674608d4ab37f45e5c1aba28eda3847411120f73caccc98c5da7fd29d0347c 19a5ecc35e06217ae9ec5ceaa644f67992c7e94bb47d1d0e15fc3b80f8d27526 b5a1e68a02bd02d9cb709a1263afe8d1a6517e8a32846923cbcb6d5ff972dbef 0ca66e8bd8e6376087acee7a945587eaae0bc6e4a5f6bf44cf7785b050cb53ef bf19dd1f74011c3617876ecf46bc560f075ee31e0ae359e6101c680cfa5a3ccb b72d8a606dc911d79281cec3b444b160a1bff37a2b506370533ae87a34b7b4a5 c3c5d3fbd8e4098bf1f228af1b0eeab925d7ee61ff1a331244578af7af72d2b7 a914251a5b97ec2a8cd3bcf5771663adf6fc8bcd203d60ed95d10115a3f710c7 08886a0a1113b21bb6b53478caf04c2433b1d22b3f0fc3b9fd446c539957c058 038286bdd844e02c21807db75d12d56ef12f1e787611f64826dcabe813562dca beb2465eb66334bbf64a6f4ca4bdc44208ca27f69ccdd299851e427e912d2899 79debe73e5750dddfbdc7cad82696079a6a2356c2fb131746412ed3bc9974802 e5f3c173ebf0a83e3a0d167f581aea31128923c3bffb5717c0b3ab4fceb48b4c d7f24f6258b6910c769e1b0572fe30a56fa81260eb719a092c7f208bdf69de6e a17fa7f7e991d169e5b01b496fe26355ea03b5acce5ab8060fc958a1b8fea050 433879b49de7e7d0dfa47bfe0e8bb303e21f7e75e046c4023d5dd13cd081f693 fb85d159be2f852327c400b805edc25f43b14efe1d7cd47f4af2e30744631220 0d65ec6103774c05181b41193a71fcd429ee1004194b73584105fc1c118f0db1 75874900e799b3d155052111d8d9f9565b0e4dc2ecd41009d51180e273477eba b14acb3f2bcdac63ba93b5854aa5a517ea03e15da540d767a9ac2b51708a47af 328010c642817bd9a3609523f5475806dfc103ca40083ea1a2e34bc83da8068a a5cd7e33854ab280f97f57923f6ff1d570d961156ca6a181a6808b0b6ab018eb 11a2ba73f3d609d6358694adc4081035878cd02fd50a6ad2ac4e6d8e8352c2e9 8de33594bd75d281dc86227cf47f984c58c868ce43853a20701f5ee5277ca01b 09136cecba5fdaf43652cd9519e6c1227b93b1def94be830570d6786e3159835 591e20e7c3c64f3399f175ef867771a58e244cda30e8c2167b19c915fe71eda4 f135de01975338fb3efcaee3fe01829cae34b8e1490b537969e266b330bc254f 2b0b1471545cfdd28c9b7a218ce46c0bb90e4ee6a5a97086624fae9821a95288 8c260f5039ba5a4969de38615355fc8b51f08230aeaf3081427096a0bfed327f f56a339ef6532110d5e37c83fb1b184c6f6c8e175453eb3ba30a62f40af331c6 5ff4eddbf68d83c20bbbc8006a26d396d6276b6b42f39c895ab94b403290f785 00bf3bc71c24c510263267e8e437c1f2c0a423532f15db0b96ca7a5a0f64e21c 8fceacd3704c030e1e20bef22d2cdd4c2d696d1ed06a68ddf7799126fed6ed45 e47c6726fe22facf8e90ec4f5cf77e2785253209b62518482600cc54aef0fc65 c48038dc99dd9c2d087dc7bc2df1916aa62618378b1fd0ae63a7282fb3c861c8 068adc9aa1f46c0f990f3a8620e1e7c1a3fde6f0126cbadea7aa14d471f70102 b745d86936327fe5fa82875b6fa59c43780f8a90a26eca6cf63a38f0d84730da c832f277b433f2b20a7d6801eb8c7710e0b68d4cbe073f20e210094c4d5cf278 e5e038f6bf70fb7ada2a8a3add4d64ac573e62d6f0176c11a45c273d294d6fc6 57b9d2c9dd0ff3f1ca6201e7703098794dc90b8046ea852fa0f6998a6974254c 23f3cec4a274dafcf4151d3c7e905b5746265623e2ff5a1caf8d7ca6434d0dce 6c4611e89ea4ef06cea599d5622bede1660c8747188ab44974fe9dcc5dabaaa0 8b6aa5ba1c7b2f05e2c557c00deac1a2a67d610a5d83eb4dd8150c583bd37041 6e72d8e860569822d9def64378b83f4c58447fe1b73d6780db48b4bd8a1fad29 6404c21f95bd03f7369da9250b9548cb3439ff17387e4ed02178bb15ce6ebdb3 fe9d737963e783c0fbd918269e6def09352d85fca55becae8a5d716977a6ebeb f0600105fb4ca792cb4848b408aa7417421ab370f4e789e3ff7fa321f4e4400c fcb84529817c699739434533ba2ac896f0c7268df412204e9c717c1e6f2d21cb 3ae4e33effbe971d1fe84e95d1074fb03e1dd0da186847b21ac07622f9ffd84c b46bf0ffc9f05f91199d725321892b007137f260039e82e3b1ab3cf7daf3cfe8 989a674aad7ad12f2da8caa5dda3b72746118ddc817864073dbf17019e845984 7dc01ad2ef7a34714ed8ddfc3dee1d459c3e4c2475001f69550d765b80ca0574 c71ae284a47b9d596b898933bc9a2ab5d13e6bdb6f29ed9f36bf16833b5e3aac d764820335c71cb3461f4eff77d92fb9372cd496d3f190b16de1820bcd8d0030 64cc5b3a6601533d64d1354de5733ea25fdde809d35ce65b00bb5b4b4fcd12ec a44f991b81117f6e776e58c8c84231da1c5c204a707d4124521b23a8630ba282 e6e9a7580708aafecd0e24f44c843680164c32689d1a2ad7ee4fa501f59ce384 b33fd3ad6b576f1549250e05c487e479799df14bb031b55a77385c9d498c0c4c 38e36b1c744f73278732a21164ba8634bbca4d0df8a6f06caac4367b2b262c7f 534f6e9f78c28bf6d6dae82d890e7445fe83f8ea4f43755bde776ff4aa1bf7ee 993ccc85e20000aec71ca4b2114d9305bea4af5a6792bf4a489b6f4b4f0bf67f daa9119d2306d5631146be9fe95b74f6a28b086e56c46effc33958aced9c6359 2c89136fd87a36844cd3accb0cdaec2d5875b24bac16bc1e0391caa0d385f258 aff60f6f8c5dbb3b3ba23c1fdda6c8d662a960dd90752cc087d2099e99778661 3a7a863bdbcf57e41fb74b8cb7d021be9f1887ab8f51c83c74c24a4560c417f0 8d1c2c3a755aa119743c8864e03122a5225bb410cd8099e126f0019e529780fe fab15193df8e040e4e956194c7fea847e2021443f659d2a1e3b3fd0bce0d564c 88da6284176afc9c1550ba7c3299d5efc141b2460201ac6011decc3ed77bd2d7 5104f33f20287eb4010412d108933d9c9814a8ae35c33871e870ff164f503bf9 6b7dbf9bc9ed060f909c5df128ac4178d874148661f69c15e7eaed8bd4f6dfe9 c726b3dc479ab8df8086b0f0588d17d949048072f617bf175a8147e43e186e7e 8582cd98f4a04e0bb6a0eb020d4d2da1c9e7bc59268e981a3ac0849c214bad7c 56b7c1f4e4497367ed1f8cb24b6a44acedb61e67e4ef49ee19c5c59c929ed37a 44c9a8fd4cfda9b8eeba1efeb6a5e4d4a86b1236a6be4300266c10c1f54625fe c2f2d44b3b9b14eb2cd727b23a9b89f319c53dc0a22735acd265007f413091c0 4f4d49cf3d2fbe2c652d22d1d99368f2c5faf1b16468a815d5f3fadf377f030d 790b1adf98727964f1349ecff285d4f52677e962d48431b0a116693c2c6a3e51 428fa7efb7f529edafa4f435725f652451c35b11c1c50a155d1be8c4b5474cf4 77bcc409b198b863449bc23d222a1101d36823d8fe8c352b6d97f8bf1a80aaad 6de98fb17560e654ff07abf8557e90a94644e36fd3c2eb6d0671dfb4d0b4ddb6 d6ac74101f9f46e548c2c4f10de3f5b76025a1ec9a4e8da8c451639dbc951c66 7883cdc318387157b471a852a09376717ec864e6246015a199e0d60ccabb20d8 868f23b48c7011d377560b4a2dc07c2b7c73aab2eceba22ccbeddc1a6ce58af9 7c00a223919f82f34feba66faf9a2c54d917ee577f135a2b2d038d668c580c77 7f15327ebadcdaf23c82d9829065e61c5b1f4104846a5e87618dae4d3e1feb06 b7f7985eaef9e31bff17512ac14d992274fabadbb23d8fb095644d240e0aff1c 242d3d76c337114ab1778776a41b4ccf7fb06a6b73a9ac36b88700569f06d1ce ad6a09fb4fc9c13559524d3516028c17c6496983718d55a5924e98ac3b8329e8 8eb88f7a7469810df9b6f77afb10be5f6a4e5b11b648cb75f8b1842d863ec974 0eb90c610c49ded0ee3ae0727a8718a2c1dbbc4e6b53061f3a89688eba7ad535 7cff27f204a12ec941668dac31d092bc21ba20aa4df929dd9ec14a3f4700c780 13decaa28c3687d25b958199d8fe3c4189d768f476df53ab783e18c103fe8e2c a8d46b0861ae6182c299b19d1985cc128dfbd22fca0ed6c63dc1c5a677ace24a 958a70e4fccca15243aca16243e1b6e2e70c694e81915408fa9ee8bb676bdc85 7992bbdcfbbea8ec5c6d8da919754252e18ea803178ca83fbcef11fcfd47560f e95d124f6f66ab25c3692b39bc984fbe393bbdf1a67e695ba92c62c1ed6b5788 cc63cd4771e95fc2e0d3747b5a083029233d2c2cdb671c02449f515050da81c4 896772c1e0a5854d4d5a87ee2829e354bd9417d33b4d0eb519f0a9062b5d2140 76697679a88bd5189197ae7c5fe289fff2375fd1aed9b302691bf258417aadf4 c8b28f1d14a987351fdc3bf1bb6db12e0150dd68e38ed891295e4aaf5bcb758c cd703f55c20d80f0873bb9e8ad67f3d92990910fb3d3f59e124b572d2e840b37 416e90662a101947d7aeeb85a3b5fe66dd0ef49be65898b06ee62d7cbdcac3a3 747f75156de70a00d18abca2e8481380adb1b1f9ad4a91dcad281e096f63bdc1 561cf0e1671f44cc5cc2b3e2a24889dc4ffd1cb29315f797742d619f54944d8a 8e2840d42cf07958bd071a41ee642e81cdccbb2867f7869a1bdb77113510b27d 3acb12c33d6313ad1e01f923c268b7dba0721db9dda256718846beff5ec4a720 23bc2ff740e63dd8f642a03a2725028522299839147192812525aa1d95a72ca4 0253f4babc4333e6e4d6e3560368be6853964a96c4e5ffcfd763284e8695c4af 0a9ac8027a014d2d87bf0801621f66cec08ef21ed742f87ed7380e7c11b8565e dc9da5183a8d51d963cfebea0161a5b5a81e62fc2df682ce835c3b6d51db1b9e 5123adc4da56eba9a57e150b4a1bb8a78c1806a7e10e7299dc2658c94403ef5c 4b109a0228ce630be9cbec09352f8e5f48a7c517f6e6d9f6b73b9d0d0ffb7fa1 9bd4476f9e69dcda85b6e5fa18484198a969abbc720295fb7719adbbb75801cb 2e2c17ba3b251292f76fe09652b4ae61fd5a8df352f9222694068e719eda82fc e071f63cef7c9c56245d31624b9550a1ee06a5c60a927bc6a8ffa8772514cc0b 8b727989d33022fa2f009b750bc1e0c7a3e4d3b6abcefaec66a747e6af60f836 391c722b7d2bba71428bdc71d80b622d36c861016fe1de52ee764786c86ccd78 f8e323864fb0af95c41470afccf4070bab1c758ec413615fd3c08c48eeb069c5 6400e2820178bab8c814c48132640e9cc78d0b12fe20d0329edce01eadb32a84 56f1ddac063f285d44a9dbc6d0abf1a04d6974986e240623e25ea8d33ab10e16 20f79f2df269a29780300a5004637dac5088cb12c2513e73b287a82a11ec4780 c4bb932a48df79c436f95963d53b56051313bd7084a0c34f4f48311e1393cf6f 7e1ebc5374984f7a5d27bcdc7408b6855c5f49ac7ac649d8e416578a31c6fef6 93c6575f616961496a33de6d597ccc320617d5c87ed0fa56c447c2fa5f620cc6 6712eccca1d08955db7c2bbbf9704816847403334d133c35faed9d19d961f310 dbb519e629f67857c72eea89a938aa271668c6c4d8b465d38a6971374793a7cf 5dddb032714f01ef11695a727e2a57b291aedab49b00f44c75e13ce5593c63a0 711735f4fa145bf81375ab0512da5e79ccfcb7f424b84a4cce67925571e9b10c bf45b35154e5bf558fcc87227bedb1d02ed679cdb04a140348758977bd587f03 ffd793992dc707f414f86afd3f427059adede5e4868270f230a2ab7af3ceec65 0880e873a5fab86372eb4d68b30fc660cd8746297f5063981089977f9f64ec48 4a747fb953b9b65e4c3fa85d4075b994c85c8c6ee2044227655791c6a4840ecf 11376c19d7d14091bc99038da7602601a00775c1bd13dd93f9bcaecc958bdee5 ce6165172ae0363268314debc1d89ef85331e07a05a41236a5258c834b80b452 48a34de60a9117416ca4a4f73e84abf5be2ad57e7e6ffa3c309f8c169c2531dd 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 false +check_ring_signature 29cb1acec1b78ad5d1db686a433f8eb0d6415ca78fce6320ec6cf82fa2e04404 26eda6ed4cb114532ea1989e445c02d82432437131d3ddcb6bf12c43c33556a8 30 dad9a4d8c15541acfb2506075834c5986214eb912c3b39aee1e1c2371884a9d3 d948ed2db9633a77ae0ef3ebdbbce7639bc9b8fb2e0f1c005669a28171285ef2 2e7896540f91111bc199f14d71637e9600a1b897ac6d95d614fd182f9818ecbf 889ab04ce71b8ef48f32f9a40a4df7cac799e47db524cce4241fb059a3816d1e a852ad60f2ff338c21addcc02d0f99c434d55c792eb46a9b1cb515dc5d7e89f9 a218dc5e9d8adeb68ce33eb2e1d3c891e01d98d1b5811086d55b11c3deaa404a 1dda149ca044dd9ba75e65f356a13a590318ea7528957f87924aa1d10d366ea4 5f810355f195f8af32401bc54aa82d6ffceb547fcdd4c2692848cf388f5bce12 db71d3d368fb5ce149992077a4d303028d9bbf3a436fff35dc687bfb21c0ede6 3c3e08b456673baa09575693b51f1143c93ba99776ed5a0129fceee748214e03 3b61079d6475ef1a48d77591aef7880806485c7d995a85664d18bd1e2a8e60dc 8f3b44b68aab274207093b9d7e93e28d30a2acace5c857095fdc0e84c373b975 ce7523fb61d77be6fa5949c02de41d5ec47d686b449827f54a3bfedbc2f9f50a 9d30b8c893fb0a7a8431345625ebfc0ff024192b057a29f89045242f999ffa90 a31690b436ada1a9ae73e7aef9bb8b5e9536dddf9a59ef6b4e9494b8be47ac89 ffe6f589b46e573771a44eafacab3cb43c93aef2f7363b1fddbf54722672f229 5515a4592dc3d49c961e48312413ebe4390a9154ea714230a05da2f9ac74b0ab bfd6b23b44741a608db142b89485467c8ead49c6049d0900e8880e9da0a25488 167e42e9b99a14df7e74eb7d1d6b3ba8c1d617946b8a6877974ce08cbd2edb18 f62150db082d70d10457ff579988018efaa6bf0d3cc9b3fb58e359a9a7f61156 6f15730b3d00368af6e1d23a0dc6ce8d1a8da13420e10435812a2ba6e10a2d14 7dbd69b941c5925caf8ed23d44c9226b18826014eb61ae86b227c7618f6643eb e1bb50fe921749a50bdb6e5d3b59789ca4f474f5884b868e494f1050b5ac3932 f2c9fa0cf429e9fc7762adbd496f91016782b137cd2b23ebf797e28263cdf02e 2ad905aa76c0b4247559f3725886c70c6e82fb0ff999ed028649ed94f9d73213 124009bf1707451e7cf4843e4291ff267554ca985a29d8e3fed50be540da40f8 f5a6827344dbb6aea000b088e5935ac46945f22871b16f0f6efdde0dfa93061e 5256ca0944b5e7eceace952cac1305a80d0b36c5fb5afb88bbf425cbae1eb177 727bda6e244b57291ced3e6eba7431255404f3f394bece0b0e46b0fa2d379a03 7ddc533b97d6fa86ea591a918bd830e6e090426e91ba55453cb57c604d796917 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 false +check_ring_signature be99c0fe0eec7cecfde67bc8f305f76b039cb4e6492bf127e07abd393e843f61 aeaa8f2827927ce293100d29a7d8e86607ceffa0fce5e0fd78e7edebf5934f8c 10 0a34e4a65305244a961661934aef8f894cccbad274fd94b5c790246f89d131d3 24c78ae753d122dffcbf763d5616bbc3dc7d433a497b6a0277d33b05e33ff753 c4c912015eb815fb598ceb3fe369c322c7bcdece98f5d632aca309ceaaddff89 35452f5bd7f04e04f6515c2d81e0ec9fb6d3fa48ff55c75bf4e81a35bfdaaa06 33baca075025b52aa8802f23e59374b7373fc8c36f35702adc0f3c64c39186b5 31d38f8689cd037edd55ec3d6cd48c19ab741005755a00f41638b4acae331c7c ab9ef86fdae256ea7aec3158f4edb73df76d23344f247ac6d0361ad97bfd47a2 67990ccdb25d579ec84dedc871265ca5491fdf58a07f4a526dbdf543b4f67740 77bbd9d3a9c46ff7e7578214c5aac666da53907cbe25d98aae030ab26336a262 dcbd8f9708847dd79a936c337717f1ec214ff2c3c010880d00a6f9f62d7b0e2e 1f7687c9113fcbcc52fc86d01a8570814bccad6b4ba4960c35c8321cdc5e710227fb3a66d1096546034006dc2d5d7150b7fe778d85e5ee917e0bb531e6bc780f525fd6b113e957504d830899084e97758e762a559911c36e1d00fc6c943944060b737b197a397d50aed03158c3e171773a788b967ea16a72dc1d8fb2122d380b4f19914e898f516095bcaaba4f8ed8da12682891d23b4ff4d3bd2442eab3f10b53d570e2f0dd8d5ccaa6d7ded45307cdcb02b3b70bef9f8dafa561c14448b80fdec6d188a556e5afcda6a1edb8c08ee313c9a7a37c1598e1fa371f0ef650540fc4acc3b7e9dcd9d0f7a7a428fc2a4a77eaa1a994461ed9d04ac8d5d46ce6910ff67207bdf29d5a6bd83e517b88264ee6b3086edf13a00f8eadff7c3f12f36e075f1ce6b8726d0ad6ae0f924617a415c90711437282b1d82c371faf40ca5c1e0718187ce2dc1b2fc8871cbdb8269d0deb4a82704371a4b07688f1e1be6ede89049d5cc4a3f82beaaa0873aae47a5362c04bf548da0006bb8916477ae30fa7d603bf7c4869b55420d9cd8ee4d13443af5ba517ad418afe1f8d4d917cdb0fd0070f4663dc6cf753b1fd704a115a707ad0666881607b87d2d0ffc664a80a077d330fb2a448c0a9bd1411a8d620fea89a3007f371fc49ff4caf317de92723070fce0ef5aa6416996723a3f67ef87a06a4ddc76c54a9fc7bd02f007393254aa15f960f9fef7d7a0c892198ed3df984719a4ce684bd68cca39dc1b021411a2853a2340f104338fe7b53c5f85148a2007c625ee7aa54483f8d5a575185fc9615744b8800edbb194fbe1c27c93d7af095919fbd940a84feedd04b6128c67bec33b38ab50b6cf54a18373ff62c2d730327701813adde909cbcc48de116b03113db1ddf3e04 false +check_ring_signature f716fb47a15374c921e2f578be610a91b5f6c7b404513cbc502ea7ecd01051d3 f6e1b030c9ad59297684bee42e6ebbcbf5536916eeb24c80117926e0cfdf2a4b 6 801fd7de390e6031c9af22d1050220bc154010766e3ab26e748530d604c756fc 9b4d58d7814c40f26e7be24f092d4965de2a2ed5bd43f7cde716bce31b2ac3ab b8fd21ba72bae2e2f5c7c7038ffa73b5ececb18b458f90f8d7ff295fc06046b6 20fbe543be5b2d37f9c6af7b1ef0c6422a07253fd6a361f8008dfb43c14abd47 2f4a6166e85ff967309fc016beb16f6dffe6dfc20b20a7e5c4d47d0213ace99b d55387ae3f366bfacaf6cf6d10c089d5829bbb1fb73bf9ba2b3b9b3451e621ef b4de0a8baa4b02a96190342b387902180635dda31ae3b57a255a2e58007c8a06988d918faaebcd90acaf58494a48470044215ea3fc6e96d59e32e98d4d73500c761f6b824d69ee4dfe61ee9298bf56c41c5ef4aea19310387bb30f7a92ecf60fde16093790ee6d8bc8a5656f481d4315c20ebeaa7ae104ddaf345606ec69bc00da6c2eea98fb7de7e6fc45f3b4e76a286bd912d4dac83bc2501c3c0d8413570f6f34782350aff48101f72dd2c1fc8543bcbdd9d1ebc627c9c54da5b13cd41d9f92b2fee63a26af637f0acb324b941494cf6239ff8290c2bb1adf05b69062830afa0581a20866d8cfbb6157d9ecdf2af304e4fd591fd2a30d6081cdce4df03804fc13886209d6e46b8051954091e83b16af80e95ebbda3e0607c8f25f34caab01abbc105093bbcf5b3d06960f3036658862360e9867e2e4d8edb2f56c228a2d0ca98ebb516821c154b90174dbb414298977cc1565b7132f1745f49ed0654c0b090b102a4cce3f657ee497db696bb0eb164de747d24c1e3dcc8ca7e39355abe7a7 false +check_ring_signature e183ff3ca131a4ccfe319d6df93452151265c41ed1c2c30ea12d17639d7bde7b f96fad598701777c7d98a806430b542fbd6a35d24a3b9a013e2dc0ba93c4299a 2 2eb61a76b321a3695292fda7109755f49d25dc294408ea491ed7c13d5fa1c46d 5b7f06b7a12d72df6f2956a82928bbf139acccb72102e40344bdf63d377b9ce1 eada62ab9dd2798906f6142f9c31f94d236b70aecbd4f04558b24da10b2ab10b187404b5508777b8588d10500f938f331fbce8ce65a3d5be79e75bebfcc6160e6a2dcee31df66dc9af5fd1727e7708a7d7265ca0ab26cb4c81c5b70f67425e59c9df3a4a637701212416bea1004e0de0a410a266d71c9a43eaa4ef1777083a03 false +check_ring_signature cb283182808f49d2d0da49558a9fc64d9d6cee1886c982b5cbf3ed0f54ad965d 00de308dae52737a01140bf6a63b420be4281ecbfeed788af1a4fc30afc7429a 61 eee658549f2c2b8e1fe5de4cc8ebb67a0ab5cc2132873d93c3bbf756fbd615f6 95102da66ce8d5f62667e8b17a9c1d8774b479a3fc96b2fa0dda029f210a0559 bd41d813b6f68c8430c8e4bdcc6c7e820274ff99fdae972803c770bd7dccd5a9 5b2e2015e04e7c042d75e5cf1dbd243107eb1b473bcb54705dbf461d33ea6040 bf2f2a6d476d27cdbb9f1c82702858a73a91e5048818185ef85ad073332ed710 a4ea413567d857447d0d6630f1f37db39a03d3c0f24a3e3f7476b23efab4499e 53e5d780cbcc9f23e2cdfccd0ac0d0490c869bcf908a3083938c814e9ab35171 e89ac69f9b6cc93c7ee732d5aaac33b5b65a367e31553817057ad84f6caefdeb 4e4522a41f739496177489e4b90418e143ccd2f0b0a5d8d244ae79fb3e9d2163 7bef8e6e2ffb6c2fe458cf2edf30b77b5d8878d116e2b9b903c8c0a582e98524 5593a3515893e77f1f6c764af932781ff95290bb8fa665adc1227e9dfcdb0214 df13ccb8b33e24a7df19e28d78418ce69b26d13bf6967c3c8c7e378f80301fe4 23e81f529394e60e690ce5b07ca28ce1465d818f79391542783f412e3fede527 ea04923d98a5f143330b093c98dc8fb8504dcedd20713055bfa7f3798056202f f65b5065fc8fda3a117f28eb61a34d9124ac546c01bb82764ba0a50bba02b945 bd758462243b3e3b534db06a1811847e7abb89e7d9d2e286602043e31c5b6729 b5388eae0b362e024bdab7d3d0b4f2ef243789595155502e93f425f143de6fc1 21e074e80cc15b1f2dc58c4c8a356b09ae301c78bc830f3d81ebf605c4b39f17 fc7db01677badc255e4d6c0b447f65ab41149e3ae176681b914183ddd954037c 353d46641b2a4eec8bbad875d9744fae1f38169a4d9e57631f2de6fbbfd61a82 567e34110b106d3846820e6df4f437c352052a10db1d9eb39228929fad9338ab 174d262b188d9eeb665e9281c9d93adf6d849fd9ee269aed2eb1124e039f8db5 5a7fb9cbf73c87c17e7bfbbf1a5b53fdc5bc19ead3012dbdd75b41c0a5901723 1ef48ab6a97aaf2f62d1b6d36aa853007d724ffbf0cf208fa4b162f6ebc984b9 67bf526ea584a7813543121f73d022efa6d2b2f173407d4d47c4109b90b5a2b7 7edeac31cbaf454fa84f2db32750e3f6ada89c1b177405c6522cfa75cd2fc100 dc43a11ee4c01b3d44e78972f2ccd1c94bb24a5bd398d12ecd81c81a12f7d785 96c4ba6834d50881e4453dc1415d14e2e3f7efde3ce2dd617682981445c8016d 2535d5388efd8e8f391f448c601cd3c29f59492c23e626dbf2d06529af26dc33 587a0f1b1118992e1f20e76f58165ea39fddf34fbe796089c4be781ea754a5bd cae61af859ce2a0c3770659341563e04adc1b70f79debdba1417ea9e76642edc 86c6a3d132ac33216693a1acde9863cec06d654b8b79f5a4f614ce61407d3d6d 0af557cdf5d70a74c3af02ed35797bf6079c659fec53a8e33cd48bef99a3bb2e 4f912c6150091d7ada34101112d5b5499444c3ac5e98daa214638d388899c27a 6135115419863725a019353106d43171e4e1424908f96c39db504188abba2d67 c9402d88074b575ed2b985eeb74308b58328101814faced3f759ae05f7285a92 c98a77ff41b99ac3ac47e1c3e1435761d53d62327c9e5597e494edd5bdada626 875d2f47dc7cad47b30899c237f5e064038cef6f52175b8c548517015119f546 095423aeb0600404c3cb47ed7d60ef286e3155d29aaf446a6be9c2d2f31ebad9 6141857287b3a717dd7c9f87abeefb60309508954eb49d6e0f786c1fc8e0409b 75a0de8cb29c4455fa83ac80770455a88819e0d9493cda3cfac91ec547b384a4 63b8cac61184eb74ea7e9482791826628bfda7144a7ab6eda7d97fdd52595086 f6bcac6fae20666e646e34e941104863fa38c3d42335bfef1827cd033108eec4 d75336caa5e776e527bd85291bc314e53582407c9ce13134ce006eb3ba07570f 12ed777206c5056d9ee718da2711a6bb578bfc8cfbfd688b243a2fb4c25fe341 a437cc6c5a23751dc4546de26085c386152e189d33b3cbf4a90e604289b40c51 e44c771a92f6abb3278f23b7396c6d0cde83127ca724e146f670c7b47271c86e 25f3f2bd85693e57668062b806675ca5b6cdcbc2b263b39791135fc479f25f49 7510b09c4709c8150351e4bfe77616508fba74006a20263f995742b98dd47c5e 52274efc6fa364b7136e7cfa27a3794f3364afea69f79628144bdd543924f0c5 3236652405e157b7fc85010be9a1806d03556f845038c47360a685935a68dddf 6c45b2102ac58a8707d5fd40f75c993d90f6e173b350aa4ce351296a85e3814d d6baf743ad2d0fe8e67e589b76dea72d3ea2977d3c3fff324f3165ad083d6283 6b98799a1073f70debb91ae7566540b9857ca9ec70277f60f2c0e99c97a6369a ab4297416429a468b4a283f1c9ab55240aaccd177c2f551536ad9197561c2b82 99629c2c4dfbef9203d3355c5a6fb0608960386e54cda88f28a4855e9125660d 7f48ee2ac193904c71f7bba02a8c31b6f02167d7bf5dba703f9d88cdc729aed2 e72db28479098e55caf95e1e91ddc922e95c5bbd478eff5f7651e15d082388c3 141c140b5306509bc12f8adcbb34e923834411608fdcddcb3a69e475e8371b2c 016cd4459ba5465b31b999870ae974db6ac87d579e9441c81f41cfd10e34d9dd 066852206dedaca5c70aa69b0d334bc88d5eec72b3b1805c164d9680675f8147 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 false +check_ring_signature 872613d74ebbc9ee2297d2cb56b4df70d2f5b95743b8d6272cc2f74d024b1df8 482c9c9216ca57367a8efb5f77f4c23cc27e3c9bc4a15df3f4ed4114eb1926ec 60 a2be4cdebf7ccf62e1c247e1ac8cf96b5a1537fef0964482aa4f328bdd8e31b5 5b9fc44b1705c099ca095e95d9988c1d8d7672e2a5583517b1cd9b4af25c35e9 06ad83efa44c9e142667badef2fb69de4182e80290913e392960dc9550017d41 072a28762fce80db566300d61489309630ea004ad0a8c7314d93fa9ca1524a2c eb5848e0f1c02f03c9912e80fd2b0a4e968bffb405f8b0a195a463ba76e8ed1f b213b167a57106faf2985568cbb18b16845a5312dc3980fdc94688d9a845d756 e8dd6cca9fca588f9f0b6dadb66c3c173a82db9f93b6fb2766ae136ca257cffb 8887147c86b31042b15a18ae8a5eeda84481c6cba3fe9f8fcb5e9ead1ad2aefc 5341af8141b332ed4a9e6c3c9e4fdffdf858bae472887df4dd6afded02dc529f 271afcda1b0c8bc231bb06e4e7539a3ac3690bba8cfa500eb245f8c560854e39 ab7eaa80d21b02a5314c1c4cd13f4e18eeaada9f5a0ce588f0ee52a7fa191b6a c97bba2f84ccfa6bb3563c82cceed0624fb33674fbd301e29b952849854ace68 1e3a7a2fd8c0417d787f1a1c1516c6cf785f1724f9a697402246d39cfe79e076 ef81836704ea6700b02352ddb9b377f1f840c940230d485f0910c1edcf9f1ec4 b6c77e87a6ff260957657d20f7bda35ffe3b770c60a36fbbccb05212e8b1b857 95a293455d62962a26e8e53f82f73673968b5ca9720a2b419cc601261040aada d179b063b52a043a237c2b0cfd58b7fd26db67427a2452e0d0fa472c3b1beeb8 7ac9e3af2cf32adea8df3fa5bf3c718e1df25d5f5ac25391ba34438a7368da84 66fb26fc996486077c3e74d0966f52381ff65a222fa42d8a2250cee10bf8d93e 1310129d7bd99a4849883d95cc99770896cc92d172f55d58cef2e8119aac8b65 e0502d700825f828987b3bb93e7534810ec3253334f0cfcd12d31c3a6a6ddd6f d68f874a8849a14d624cb8d41f30855bf16f32397ed119713e0038a1eb010de4 f29a92026ca2e53f297307b94213af24cc5b95eac41dfbfcfa201bd0352f58f2 bd75b99f3a319c67951d96e9766e03ccf7883969affa42ff5748cfa68c0515f0 10a62309f8b721f7532c9a8ec52ada05e3e939c160ff9a3803293b7b8a2d97c2 c2db2d4a9cdbf6a7c8b8d74f1360f16da50c9eb061ca6ae745732ebbb16969c4 378be9227ab7f811babd66988aed462ffe207e872cc50026b6d56fa13d946098 69209d10f38dd7ed82f67e5c53bc102201216581e320b983e7e68dbec2edf55b 2beaf59d59032e07ef1920bf69cfb2489cd4db9cc2e12ee3348fa7e6e4af342c 45c08db2286d19f098e70aa235dc2c4684a608e0b10137b668708ef34124357b a1a54c4a658814841d037f8e0fa38c767519cf7014cd775e5815806e632b4538 875f7c02a2c41250528178228c1313cd9e0ebacaccdd4dd33a8f4d2fd839d476 98ee4a1487769108b72689a1be7a91ddda423b954613d4ed61e3d3855e386b3a 99fb68a965b5b4bf705e76706efe49c63d84c8c2824bd7715476f0a59d7c9ff7 466f7ac4ac26188ff93ea2abc9141769e1749fe1616e686f5f35714dae14c4ad 595ce1f47af28df284ed124c25155256e5709d4a9ef3ece82c7eb00ea99a2a34 0a8311258bf69309f826c1b5050571cbfa7b5bd75005d7cafedd9d95c6686502 4d1f6232d02b3a30c7f024b940ef33139a2589fb3304208ffd0da5d3fbcb6178 29a4e0abe87a4337debe1cfc81ba7c15528fcb4c177b64081662906f315dd2c3 17fab0ba2ab41d7196e9da9c890fe10a830c5a04889cba9ef713739a52913afc cf554e67645fb22e8d3f6c37c5f4016fa116e93efec2b8bf723c5f240606f11d 189269699a60e7a21147780f5e6dae400afe2e72d6a614f44fbbbee844d9b72d 7b6381aceef772863d55f329c4a483a155c0fd2e0408538f6811e1f2c640929a 6379adf10c374cb824f9fae2b991bda515bcb5f6bc971ecddd395dd9397f39ef 7e7b71e64f57b57304d39e7c626637ac24e1863dd8c483c5a7af12a8f290d2fe 2058f74f6e0d3f106622f7ac328d39a2c3385bfeb819bd27bd75cd1c2d90d15b e193989a2304f9a74596469f862ff683e9eda4666905e9e817d51f78f2ccac0d 497500aacd78bfaf55c048b2fc4d11c1896008b8bbea7d024a17565d03106a54 eb9d6b65b9cbc45db45ef5edfa7143c5dc4f2c4a2322bb11cc1591df5268d932 9ebc1c00b909a25a8df0aa03f6df6af7d40766f401f247f81aa0ad039fb18ac9 d82030f4000ee25eb51be43e7c2275db45578d69b53b5384cda2ddd02225f11d f381932d0b1087f5380effa1bcee0290ede2170af0d6c89737915547875a4e04 e84d297313e6488b24e418f86171bb48d9906d4ce69831ddc19849347b9b93a2 c67524419947083405178f51b107cd090e1714738a06a9ec4d29e9359fe7d28a 1d1ed14e16e14309e5d4b46d09381ae8f5603de7bb9a9b2379a375c6c5ac15b9 180d15421cf340de6ed8cd962a1cb6f1096e64b28b11fee282d81d6c47a644cc 9b35f4794deae56a5d73330fdfa85480b0a758bd6b705dc95fd3a24bd2a3d1fc 38dd78b325086e72e99c6d82433005125a589922de85455b1f8b8c2f9580e5fa 5e33aaa77fd2fd4bfd652be21b2cdc885f588e1c623d216009808da15d3e1bf9 0a0fa4d0e1e020688bdd64616db1720b1f8d14f3c265ea8c2d6ba3541ff1f3aa 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 false +check_ring_signature 57d97713d1cb289efe6b5dac84993442a5f1f398dfaa5de1ce588ac190f9807b a1be5859dc7043cef50796684d5943cfaac12e40cbdd3793fdcde80b7ed16b4d 9 b93ef39000773155f38f13aa2ab0deb1c67efdc0aa1e81dbb14077f54e6adab5 8c01cf7fc10ffcd9e1f2f095619d51150b5bf996c488cfaeb7e6b6e74b955dce 1900b6170ebc08873e2651e071444cfc9f5ffb0ec49b78bbebc5618e5e0b2d2a b78c32a56b4d63a4bcb4d8e932a80046debb84a8fd39316391ab5922ec115727 56abad6869b707a276d33f501d303f165b2112e97831fd83fdb583c975e2f66c 7600055222a08ab2600d21d464105060543d2a5478015cefcd7c8417ac3f00df c44ce221f8d8543935212cdbe0936b5e754a2bde7bd7e43b1644c6b19c299e30 fc34c181ad10637918186522ac9951fc8b06c8407c594f35eb8f43e62aaf6c68 ad253e44155d4782b343b0613606b3aaffbf5dfc425d41358a4a945f4dcc53a8 edc7c6662529eeec56af36eef13dad4df291fed7c5ebd790b1f779fcf6abd50dcb297db20956101e3fa0fd705b19e24495e3a751c86b871117cd2415623776000ea5772bf4827d47697094fe1f421530fb44cd43457b990d0d2c490bb217010156207566957c8beb279496119cbfc90ebe44ae74dec1547dc2e294b06ecb9b03108aad78262e0f3fe7962e3c980d04fac5e940ea1bc920291aecf34540186b050359a8c3793c540aaaec28db568f82cb24ed2519a2d19808005594bfdffc060939cb4a32ffb12b9731213ee2b9c7821d6a09e09891dfaf3e16ea7c05ecca5407e11c186906ed3484851bca5ba930fcb59c7a269eb48442edf153408bfd232608576fc90be2c38fa17725f78f3ab0f3f8a6c29e4d18922715f82256f63c71b001111d70d2771b3e8b2017ac6c943e02d5499d4fb7dbf32b462b8062a63a62d50a1e13e270b8f9d1808e6836e7eb54a7ea43a34f2c98d22a0d867ec01df2f4060a24b017086f0e4908687fff3e2cea6f0675355379f25094eb4183690fdc3753d53529f3827f4d8372b034d4b35a45aa98f66969d7290c3f9e7762801792d6a20ebc4fffedb09f736bb6a6c3c3a36982df567848f4a42c3af337b11a7879ac2d092d8880287f1f6e290abdbcd171cfac926b2c430d96ca59e7cea5255c155dfd0eeb11d19049e824e6fa1fa72f3fe930c072033aa99e3fb932cace720f83e86e024d095b2770f17b2366e7fbc8cc9c51100ced92ba99245844b8712b61086157e3061e628e78d61c0e77f3cc74f8fb88120ceeee94714e1de8ad4b3543219be10e false +check_ring_signature 578e72f8e8684dbcfef3c4863fe2fef1ea5b3edd1f89d3665b04e4360902203f f9ecbab29c28e22c8466db7610d61c975d50e8d3c3065aadb1e7902be98162a0 1 5cdd933574bbefac4e9122c9ab462841886eea92d3b5eee8e4cf2b56a3969b9b ff9533fcededac41eb156ca206945da7d432b1809ead83e5042be10e4d8667abd8d8a9a5b27e1908d3ac76dd76d3103ea51c1867c72ac32ba64da4deeaf6640a false +check_ring_signature 53ebb7b5843b08c0c6274984a323b9137448005d5814b2c0de1e8b22cbb257dc b2194dcf6caa6a63143fa9b283e0108d9422e2092f9963282623f88f3fffa0ff 8 7d2113632912234bb62bcc1f5c31c9a687b041cda1cfd4f5ed88ab9edf8d7d17 17165bd7615e087d2b24c54e1e65195116916bd4df15dcb2c0eafb8f41cf2d35 f08cde49f8606246d191eed0ee4b48bb83b1486cbafdfd15d3368532c19a1344 7c515354b3041c1dcc724ad2170687b0c8830e0d86abf71c8f7ccfdd88ed5d7e 164a35cd423c236098dd7f7c7d16c72a2382e2050f2724bdf0ac9fba5c1234c4 d312cea612fe4c4781f4f64d648c4210278d3e6683e57018839a06114a2c3edc e1df0b93ae30d9af4d472a990df5f8821d1ce3738b2e092ee407618c544a7ca9 f452d07d483d1e1d87a2b4f2c4c4788e5ec8627252941098475e30c8781fe99d 8e6bc5895ea2c11179656bee621c0c459530f2b22b87aca91be8dd2b103016043a72cfbc64b729b30f164f5118032d788ff41a3b3502086862e73db3ee5d5509e59b0a8ca311ad4125b5a779301d8c05e42cfa5ee4ab67327cf144d1b2c4ca04cac647ea4daee018a1b108cbd5e454abfe02c051a8e955b9646c130d39311c01021ddcb7e9085bddefcc9857ff9182e83c8b651e20287a643f58e0ab2e7691098b2840e2a3a97a861fdc750a24ce50935836c9cfeb2b73dd533e195769b12b04d629855256f4f7e02dc25d7880b5a1eebc25c3efc87ee1efa91117a3bcfc0509599d97db40e7394e758e91c0b5cec45cc9b6f3741bde4c7968cda83b45099607c03a3d2a9f49fd9e18daa42250a44d9c7ee68d63f9be46d7c56c3fdd4f6a4c08429cbac35c5b29de1f9960842c685c618e279c8f7facd9d90cb50965cc1a73053b60c8421ae5d23a0ce0df9fd09745c26b46dcf3ec6d9f5452ceb7c53a390402a9bf84b52e7214afea9706cc1ce090a02c55dcfc544b83e8e1b884167f5e9f0a396542cc427cf1dce6ec530880009b0e3c3f4e38e41b78c5ae16f0e51ea3c8072e2012c2102d525e39d0dacdbc6166b5875efd4525b7a11cb5f3af246028553562705e183b5fc88092a4a5cf018f7fcc25a68261b7967456cd8f613a1ce32a03be5a10af2ab8ddfebcb54c211b76a6d3761514650cbdfc541a10b588a031b904 false +check_ring_signature e15d9c1b89c954ecc128d13a06694a52dd173adcf93efa0c3fd1c316fdff8780 1b1de762751d7046a9516ae6e80988527eb00aee5bcb4c0c8ae6b8339178fb51 1 91dfdc7ba06d805c7e02f2264a75ec9b62fd00bcfa8ed6370cfbf3e793213cbf e84a942896419bc74ec70ff40339fb53c633d5f9ef16f87cdf6e756aac86af067707f26124a573b9b7d69d2ffc62caa019d7137b18d5454bb185c6a57f14110f false +check_ring_signature a54d715940e0dd0e4b1e902f6cecc88565e03d86d5f7ecde05da763554cdfb5f 8da3c07c28e404468d605cac07b70f091786aaca4f19eb847e0b58133d8f9915 2 30cedbe07b4bf8eaf74d7bc71bf660fb13af94b865be9bce31d35eceb260cab8 ad11076881c82446706a08f5d7adb1301b199c23a53edc9cc4bf03860f832622 d2027c550d821d0229dd0e63b7b4e83f92a6e74a8e7a28dff39cee9294deb60f0e7a66eb748c12eb914d60a452fe1b03e15d5d0640a55aa556e00371ede5d70430ca0070f678bdef5e1ff09a6155d0bd9d709ea9b151631266e680072dcacb0efcbc172f5c30d900800d2b1801c5ee0fb2a7603a4f6c7156bbfc63cb44364c0e true +check_ring_signature 5bb677a3fb94e593203b6b1fefba2e0e82fdb4fbb151288526ebe0271b1a03c7 58fbc3a4432f4c1cb5d17174ecd4eabe1443159ba18e14179f6bee7cfe1eef85 1 3cddba06724498ddbffb8752a589ba250143e1cb874214767a8daa43a7c83ee9 2a8a3535efbad122791c2334c48a56ade4b2a88726e2435e00825f5fd03dff0b792f84cae935e7b0cea7ed72a27b369918be5a23c739b4670e4f984a6b11f103 true +check_ring_signature 9453a44b6629c090ef565896790ebe3aa281f0daef72c9f8f7ac6661df5cb798 9ae6c1490e956bcb2b1053da7959b8473f2d644045a88d6ece03616f6316e045 1 cddbe11395106dc27ed87e782282ea6b8b71495f8030f928a4278940daf3ac68 41ed26c7bf8fde24a7137ad95ee8bd411b0580a502278d7771147b9ba466fc04d360cb30f80b6fe6756a41562756ed0929d918b8689f6a754b65328c2b4e1409 false +check_ring_signature 92fa07cc8f74621d4329af17f9176088f86d91e68fbc8193fc23d2d3434f9067 c0254334385f3146e2fd284780704d863b6feec3b55734eb30ae32698bf037da 6 cb4bde311c6393b2a35246a56db1e718b585ed366cd859a91fc8b05619dc2290 7dbc1a7eda07ba7a59b12f7a4ade42057d5c998175f7389cfc91057b531a7940 108fda4440c9f06c2fdcda6682777f5bdfde5e68e7a401fc55d82c6725a5861a fd00aff6f43f896cd96eaba8207f674dfe4ab9ea835e1cb14c6b680c2a0917a5 f4356f6f43b60c589f7d39cbc075d25f019462e42f9077b9f1136a6f85d874f1 ee7ab80665f10c89f6fd66fd586a2fc5dd177d966ddc3ca2b7c196f34d73f522 5a71c6b16161a317e9bedabb2da4df7e9fcf50d18b0a833c7c4a166df1520f01b79b6913ced6ff8c2cad52654b23d0a1ef4c2d49d76559601f5c3de8465819252d9ea456ad6e296d866d77b316a3df7aedabcb3f2f6193f9627ab6a8d8d53207508a8cdca5538b8b5ae9f504f7915e360b3653cf09c83718ff076b4c3b362c09bc43a78ba3f0ccc0079b0985e0f5a4baf3401346db6a17e635019facaeb6250c914096678332bb208b6cb58ae492ff2e6078f94f11d02d22ef601af5ebd196019df78a645e31d73dc977d1580cb8083257ce7121f7f05dff98715889007fe80c84c845f3df8617515effd4e9aa24cec5228daebf10afb85e7991ccb7fa0ff20f8af7d08206aa9fc0075209804ac5104caa0b2bcbaaab8c33337128230d1e9700faba2cfee512970becbd2b599b2654476435b8b613f5184fe56699702e971e0e65f65d63f4be15cdf3b855064e38b2752cba6c236ff6286cdfd43d7352cdcf093a575167b8a433162d90f0d114bb7b3b5924ae24fad61c1ff5a31de2f6a83202 false +check_ring_signature 5279cc5e5a594e95a988321d766948e1e4f873953597606bad1b190b1abf91ee e8e0b3a9f5e494b506923261c4b3db91f028ea75f96af56694744c917131e5ad 1 56ba23668db4bbe2d9e5503676c9478b6a2f6c8cdf983ea652041524abb2f453 996180b3b95fce23d6b7b37f7ff39f9bd85079049f8d2e2e0d9ef526fcc50409fc072b102ba4fcf68cc60cc3b8da1cb9f3fe9e39e9952a1ec0a4a867d7e6af01 false +check_ring_signature 28c09fcc17f92aff0e0359ac63630e9b105e8e99307251a83678abb0a7bcee0a 99f50eb937ad2757d9770e5172223505daf7593cea069c4da0821f090af6a146 45 5dfc99f3a0d8b91b7309dd1248327e1054aca4b93afbdcd177260a945cadc7ad 771760ce7364e15b70c5857379f8d0f622a4ff0eb6874d1ae1e65629c503081b 670305323c00ad92bb0f3e6b7e8acc3aa3fb465d42a6b6f5542fee6b981cbf48 72489679239fa9d2a09f219bb8441b87365323a0ef23e7ff0b948cc4d5b449fd 6220989b720c79ef0355ce234fd61738444d4810b7d81b85eecc711b022a1790 30982597c81771eb0a29b4239317ebc8e43f808914998b08bc4eee6651f79d78 40f0370d47209aba4175c640e6a80d64686a9f08bf27c1f7773bd71d2cf0bcbb f556f652c47390b882a646d8ed77a75c82cdc5865ba92a493032681b89694f92 c8055744fabfa614121ffdb7ece93c03f2751a36d83f9b1373d133db2af4f123 732678e11802b78a32b26133b6726f1dcf56df2c008ffae517c2c4f7036d776f f3bc3e7ece44a7ca6666eaa164322709572f35154f6f7b299ffc5a3ea3ea8e1a ae5b67a8952c5322508d891d94c9557bea602ffd99567e43e636fd084ed39721 b33406a6a2331d6c1e00dc7fc9fddf7eccbfb7acc9d237e10460626b8b2e7679 94eeec69e06ba1508ddcedd6f99438d6bc9c52f486bf10a7b50c9f7e2b014523 12585c5bb9e0418994e0b7d4da99a9654ff72a3ff5c46633feb084c15d091fe9 584ccf32157dbd9ee171c7044cc01fc6189f7e13ba1ff946eb0373ed331f52f9 246412013b9675085b847c5896d481d27689ff69a0d0c13112f7445ee30ba8cf 78ce4b0ce6607a1edfc138065e3004c419b01d4cf5939ca21ce38f8e94e3f034 ff12a6ca353fa1109aff2aaec1845e95f77d222eafa2e1462ca40e05d9c91686 3e59512089ab4788a35b3228a57f7351085afb8e874223968c551fb54f512d9b 04923ad027f22dadebe0f438cb35b0fa66338317d39d2dd71c3c58531e2d40d7 89e8e5498397402fd203089ae8822b161a7c405fbb0d805526431ff5743afbbb 93f1858e308be5a3d64c29b8008189d0158f5a1d0e23809fa807e0e38f651224 dcbcf739e1320447de615138e785d098cf97917e081fc7115fa34d02ea0cbdb1 79830f9fdef0153a2f0cd90957524c250699675232a7f7d878a9fc7968cd1a99 5eb62d0226553b4ba909d22c77005bfcc22c7015d4e97d7c548834c4b4aa97d9 5266a7c86895fa0481da2dbe17f860dabcf8680519d4b28ce4e07abb54e89657 571a8b098fe03f620f80bbf8d5ef4a4af9cac427041df2f6407fed49d6e640c2 1ce91b290f8b11aec0f8619af1396c9f2c77f8149cf6a5c3c29a1b41089b2424 be77e01a7c4694d89a9c630b922eaeb218152c4435da709f60bf08f256e62999 fd6df929361353b961c0b825b3ca30469fb6f3195bf01ddd4d9a096485ecf053 386fa3e531ec24e53b40045f43bb9b590ca98d355d4620ca2e345cbf815ae9eb f604e03662d328785ed97cb9e9899b441e64d65c8c988487fa9388f242df75d1 d7273fe723a926a88b409e1d5c565ae48e1da3a2bcc5574a1ac5a8573b998171 76cb708ed9c64046915307900e90d7b27d0f3db6ec1f5147d886c720ecb8711b 62848005b92090c30a1949186b7cb57042e367b5b0a2a3fcd5fe51e2281943c1 8f0ca27341e95cbf2c781dd0d4dfe444008042c334c1c4d24b35c8030a67040f ca8553e384a174fe7052a0f2741f19b986524b84d9de2c6b3cd3d5932ba2ccdc 68e2e64ae4e81f697463c08051e97f3191cc68573421ce81650f14321fe88c48 a81438908146a4a8128e7e260a12418db521446f257c55d853d1403ed85f34f9 98c187772e3187a715dc99dca449775497c0dddec48e7080c06115bd7162e5fc e434625df824863632150ee9780623b9567fad66ff22deee9b1a2177c4e0b528 3adbde52e407e105073a2834b0441029224f4ef6fa6145e0d4a20ea279b4842b 4a44b0a957247a9e1df8a82b9cad83ebd14c7cfb4fcc955ea462e6cde03ec702 1fc195a1f2bd1f7ff3269da544bdfc3eb9bca2cff2a23526fac8e0b07fbab300 5967cb2494517654b97535cf5aa8fd0c6f0ad74091fc72e543006da4be59b307cbdfe416e72444f1dafa04daba1cddcc72519feb03da196392de75264dfd41076d0b3794ebecb8f86ddb0a7ff54d7a6f8f1a0630b5357c1cb48b1eceba176f0045418c0b0a5a96eed534fdff063e7814169ec5e6824ec14084811a4841a44907604c8eadaaa1ad45566a398bfe1e989d1c9ec41f3d52eb1ac14f97ca7d9ac7040dada5aaabb96789fa469639104c0428b5ed7ebcbbcbe16d1d4f965d0a27010495e1561d5135c2ca22329b0c911d8be8a97e7cf3063c03a5ada2fe021ca8450e0cd0b6dd41409b80a06835203c501c75912ea655647bf9849c9aaa8c903c170c2f5f092484e3218373e9966e70c50ccf4ab53c0455cf3b40018e1e4b1e7bcf051719eacd42229bbc6a19a395bd55ebd3f8cdb4d978fb2d2eced3548e3ba2d1064cf1343d85d475a1e6e6ca9ef64ec27388e3588b8cce27e67c26bf1dce57d505d135dd070ce0596e8190b30ec002c161c7522bb256765d50a67ad5f6b171bc07def6ad15f004199c2c0acfcadfcf1a5da1e7425e32ab9587e0adcab30274de0cefe72256ca59ac0de44a3e47512f6c84b4d177099fa9fc555298e7fabf4f8201fecd6b7084922d71c0fca7c38a7d305cf322e0ea4238eacf93b25be9dd073303932df2f1181f10a590518ce21908caf1547adf448d6f2b3977a69b45cd13c50b4dbf4d9c23b26a57a9831d3adcc7b7b34f1df2b868e5596c0afeab81bc9fed0df44b84c350be4b4600bbdcff44767103f41e9e2b01f8a4fbd99fa2a290c516039f0e356531c0d25125f6ab988086726ead7d7f0b806a6df05527a8ac9636fe0eda36e5b0d71a22a5ddb350e46c00f2a4dbb9a1a2b37c4af3bd1173c1db8e9702e40f78a5f785c067e262fb4fdcbc7fa09271d66d1a683188fca8f2982f7d0302004198fe7deaef550941ba88a65b85ef32d77cf3425db784aed29866f848510447223f1069d076508bf711cb00634473ef68f9f6d346f72a77cad31e7e2ef50ea40573c7c2d9b6964c9983d45c26f4758b5c3769cb4b1bb35071d1eb4e1ba6067f75bb5713071dc5c6b0f0cb39027b1e72e588d58a7b059bf37a530784d88503553e1ab5999dcbc9ec3c11f33d4b5e0997ef81246dc97d360f2f2f48c039be0128fa4d110846671f7c0ddc89a81263330946105a1467e0e3153ddb613c24b10739c6d1762181f736ee310d6a49d51d0fc5c38080ef9fab5af2f55e37a317a10fb555c9b75cbb6608b212ec843455d32b5b62d235f05f8483a4856f7f65293f0fd66c57284b0ec0633cd15a47d19d95da6fa21bd4e9587b808697c5e2fc2e79080d45344b6f9d42c64c8d0222db65a85ae5312610e872660cf7aa05436041cb05d4da5c482a586ac3d5699d77e267965ed845c9e7c79f4dcec700444e80b0370a6ea550fc5a1508ca339037e3e77027e28ddba6e051efd13d0ee713948b1c34060004828ec1584282b9b221569f0c01438b0480d554f511dbc36ef003ba850f079dc78bcc7358690e1b25e6c735bedd0ee7aff67dc14fe81e94db1a1292c9f006de789d9adad64331bf0475f74fc5f953f09295b7bfdaae763bed02cfac94050c14418bde61098d54c195af19ea026433edd2c5342ab1f4a817a4340edae7ac06593cf9b2b0cf4bfbd873c870844c571e70fb8a28105729fa53077b946d536c06e900de61e6aff1860437b4c3c7ada9b7ae223535ee974b74a83ae032a150720c37da6645b652ea7e4b3c12cf17309ca3169e3ece3d0856dc9c0e73a3630d960695f70a6669358425b62d4d18c56e636a43ab458de3fb6ac9f82bf5de53bda5020ce26d83548d3f6d67e513a07fa669826adb1e87b6d9705315b4cea93a9c4f07495abf04909ea9c0a50a7673b2dbc7dc6b725f5a41d6d3fde970f553b6786c06f62e4c5aa74f79de067af7ae42b0b5341a625e79ec3f72778d7e7db204f0c5046d2bf92456e7b1739ab0475799c56f846047517dc8fecc1c75d82b608a13db03b6b2f0f0acf8f762a954c0a7552b49d5fdb99f714ca11da33ddd11e0acd6fa095dc62915031c1a1d9918c365831f01f14252fda68eadabcc0db2bda4fbaf0a05f14f34f35edb472a8e430df5e6efadf75bcf73d7c029fb5cd79d26b401971b036af5c46e582ebf6667f7ea2e8ff18c02f8a385ab5a2d06980d56da990d494d09bbc6499f89765c2c500aaa1c3667dfe86401d81652e122148738bd6f0a3c1f0863a47004a129f4d2a0345204046d698bf5411b9ac642cd01e6cb757b93e39d04e03d1a8934d3cedea80a221182127697e7540bab51a273ea5bc7a7f38fefc90f95c981e900cede124f80fad17e34da93f6035010114290506be37c1e0a87290f2d958747852870db8b28e7d47ca151043d7e9b6859b8342a17f17bf875b5920d54d1455de8809b8347e7857125bb92459ea2bfd3bae8fef3de72127c969d42099b6f6212335053676f441bf1b804810d9e539f867caa2d0558ae54ca83da2b3503e002597783e32dee99897979adb29339d0d748b063c6d725aaaa9cc747bd0269a9bf258dc016c9b3d518225f36ff086b362c11baad9230862662d664135408bb9a4adc1f41f8aa23e1b9ae8835b903247a3f1d4a357e49e388d9afc76ad20ee49a5b6d15a0e4e625c6986b0885f5eeb13eb0b4f2d494d52dbb3ce60af9490c19b49e03954d0acf49edca64c4c7993e772ae0882bef1aba94f29628df34310b03d7e3584c0ffe1784cd74bd2d65dbefcae6e35554c3675d20ebcf4acddcbd0350716e383028942fcbf624d1ef2d9f7025c76b67b0250266d80c66e21465bf0bd9ec734133e2a11830a5f41a50715f95e0e321a30b4cd22f57f9b4513bf011075173d6f74ae31912258a98cdee54ae2d4a435c630ab1e67019069b344f94c80c2141e343d74212bbb86e9d9ded5045893c7b4eca115283bfec00da6cd7d56000b9a2cb24a3737ba0802a179ebf5959755ac13995f9a3997007be4a1b22690e0ed079525831e4573b8a16f13371d4fc7ea5830a26f25a069369e7ca67f984610183661a14f2327a9047c871b5065e2e940f23fd3aa4e7424026da1ea5e717c203503aeb52ec6ba0b9674bd49a06e2fcac93a6a0eaf3654c3b0338856b10f62d0b1c872c1e6d4607e79598b16e64703ef5c5162ef746d9f168c1d112ba13adda07d0de7bde998766c46ece5159fb557e33b4a3e4b85c83a054ecf13d03ab67400487ed94608662d049e0f2ea02f87702e4c387680b351a09cb60743bed9f639e07ab6b6e0b9b4a56c9ec982093f8181d60f84fde79209d4a1a3654a6de0bb3760f1fd745d9eff20bf7c748a46264b4c63e0889d3950500654b6942487175e3e10e909f78a6dc5e35521bea01b5e9bcea15d8f67f00f2857528540c2545ef9beb04999b43227bfc8c1b676474d38adffc3b481d6b18277e0529a17e121a1d61bb0828ff5a40623bdf6c440a3ecebbf860a1f1b9e044e6dc02165ed86d8eea433f0c3be61fbb372cf2a32c940ab41cbb1c31474084002acb3f75048a56013ecfe70eebec2f0e0b10a3607a1d53b4d2118977f3e2832b288cac553f1a3017516aa30d4ffb28061d70b13d7be20e0874959293392b2e657202d0e1284e393a6869f4074517f3bd6ab255d37ef54721c1cc9e65124b8af16542f1fa7a872dafc2a5a40c3b944751f20179f0b2b405f4db74a4563fa9e89aa257955d0ea9245728e19607efac3c3306f268674ce82a2c595f1998a0c1f24a315bfa9e09678abee0b9a006b052390b30a1ab1a23e5346b6864175c70adee27c42e5440750ce21a75afad07a0ff7cf53e8ff761ceca3f047d96e96af120905a2dea81e5c643933adacf6406b1bd8092d8c4bb78eeccc322489bf7781b76f229f9b1948427b18a8f5ce7230cf6cb817873ed5776a9549f26a2b46496066835570db4676b548ee2ef9ffecd02b5fcdc2e42cbbb76a36a4adb5ca33e00c0aa2929b9510b0409516bb0441c790c2544bd3ba373f2649a8799410060aec2f0df4143ec6849a4d7f0f36749fd0800 false +check_ring_signature b6f5491f7add9a234f143af52c0a0396548c3ae39337ba2fde823527ac6d4849 4fade925a0b5d6936868e8f1cf05fb8d3841683755ba24bf72b3a5b40b4f8a1e 18 b35a85c1fe49e5e4f837abfd52974b37e5c30fdb5ba945cf8b387fb51295af59 d69260de89debc52398076fe2161530c281e019be3c0e3d19c0b95d65439b65b 4e6ce6636b53cdbae8ba45fbbf2d48db817c2de73130a06c0f7e9a46c4f861ef 8fe1b372fda44677d947c3ac203a8485196d2a42060e2fe2228a4458070a9988 2a53b6266e8d5d2901ccae1d3489053529f05f3b1379025629ce6099ccc852b2 42944bb15e8eba607b244faabb356b94dd0b6ad6f17a097fa2e5ca7ee6eea30b c36115be76f4407c82586f722e63c1d91729bb34b0726c00b60142021a116ed5 6b06c030f421d51e585f32463c029c48f96e3910e6852c25925cb8d22e3d1f45 e55e84a7a5897f3d87fa5d304cc0e2706e255a1c6e411082572627bba76c1200 fbf9abacaebdd9d5f5646eb03ebb264be0f91f5fd0a45d3380e1727d24558926 89fe7f830c905c2a00990536aa1ff02d3846667192df7ce923efe7091833c6e5 d139f59aaa3c937e2903306e7b9ca8033a7e9e8365ff7559de7785d7dd8a88cf 83bfd590e97c16dc2cd82875794bec2c9ae0d35c95d8e3b0773e3d0ac57fcbb9 13379776821a85fbb2fe4fc265d2b8573db82778edf0b669458e6ebba901c7ef 9e5401fe845dc41033aff2a69cfc22b134541291768021d2b48bce8d8bebcb35 b5b5ebf4be11e58d349edc3b2c70cd7fbfee5cd943e4e13e559d10a618223a57 824f6e5d531793bf681041dc8040fc98973d819da8f778602662948055152975 5fe84eed042c274bcdb59c27960dece3a8ee456ec539c7905555a5e4e92a741b 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 false +check_ring_signature b0f85d059da9391e0c43ec2abe90214d39b683b9ae42643023ec656eccfb42ac c324f0b01b7121324b2ae73269aadc8ff1addd3ef996eca7ac8f08dc4d1bd388 2 ae909302cd7c38c82c96b1a32e30566ca05feeb7585617b1bbd9a4767065c0bb 893d7232a7d81910ac66d10dccbb842392ab4cdd2da2dfbbeb9af881f0844762 21c18e74abb8caf9afd74af2a8da2e9a7cd31472b8e82783b7754b8b2a2591a216f2785a3c80cbf786ae4ea94cc1ff0025268c6e4300df1c7ebb48b2b94f4ba59a65d394c3352aeeb00c70f90d5e67caa56104e7cd12fd77e3e5b5a72733e20c14033709002e7e6ae40c60fa6ab4feecb819ef4433818a2a21281d8dd9529e06 false +check_ring_signature f049df4b6090d539cf01f6782caf0a0b7103c3773434dfa97b60c00dbcb1f317 af8c454bf92c6664aa0ad1f3d82a53efa5747e09a70eaa1be9163b2cf5764e20 24 456052f24a9b9fe69d1a35134dd517b09c88f8b9af053f6d4fde2b11acca0665 30c6129fa0d902e3b208e76377912cdfd3f2a44d7075c7e183f46b73809dee4d 6628ff091396a5271c3e6ada4c9ee415d1e9ae76c1423211c337b36cb68a6183 3e3b166c3f9283fa7fc17d70c6badbfe425ff73e1d80ffdd07c3fefdff5ac688 a0954b58974c92ae24878660e16b9e1470c1e9abfd728c6ae9813cf8875630cc 145ad39c5e4846257482f1079d736c3bb2d8ece032aa231c398b9f381bfeb419 14fb5cd38ac1308f489841ddb02a73b0a769d6afcf9caf4e5ffae7db06da62d9 33a2ae5712019f5b53a6f7026dd24cd355dec66d3cec791930b4e61d8f19cfa1 b85ee0a9b319134168dfd3e6d09fabfcdab0a43031e96ebf40bc0a4b41845d1d c684f05a1b61fbdd87aae9ab7728f6e16c4e681f6f09e1c2b34c01383d167b7c 64dad94af3b4aa20a47f2c7a52c1e364153f3a667e4c123445759984ee32c970 504f14064d9f59b73a307e73abb00ef3fbdd0d7d66ccac703d6e06bc3a9d4e80 e1726b0ae3f9d0753b9d67d223fe62144d0593cebf1491cfd0ea38bd5c93fc5b 730119c5eb5a11a3569ddc7bd6bc553a91550b88a098370e2a072d6024325c8d 501551b41bb99e75ef67ab91384e93be006a0fa6a21566cbe3634136c74c4faf e037c63f2902cc013e8f4994475345dfba371094edb41eb4d79e90a472db44f2 7f48ed2c59ebc4c11318c7bc8f28edb57df9a4c8470356378029396be904e01b 0091f03d0e9c5a087429ab051517b3a5baf4012f08cbd8c5a927cfb948b3b26f 2d17fba0eb0946ed984da6cfc094b1ad9afbba3d35706c7b2f00fbdcf839172a 2fa14420d072b349eaef4208b02ba689fb8ef98abce6743120a28c30d72ca656 45f8bdffa1dd074a18c901a297c0984de07fa7c7753729eb0eec7941aa85349d 2cce874d8ff5bfab08772a58255f525bb6988fb1b3e31136a14083b5371f39e7 05f7bcd57537da0e99c74c323a1357c5ecc6e094e0a528d48907323be868e0c8 17bbc07d00e23b9a81cf294d304676b15ba0f33ce28547b7b9f2812300a31a46 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 false +check_ring_signature 727d0974802e64f27bdb2ecdd1d366d13bdbccec7e0d841eb28d84da86f9a729 10a9192284977c814a624661e4bbb8c0fe3301b0fa94e93af1a73ee19d73aebc 6 e83fcfa53fe4d847ef6ec4a571d19a13fee04ed188385ffe4c0455c2c0fbeb92 8c29ebc72da838905be44db88413c4167c07461c5e1f3acd32628d9d68b37b61 e59cf02b8a170bb4f0853f3a6cdbb22ece8854acc834564f029c577e1e6062aa aebf2335094d0fc7ef7753ecddead43c5796ab813180880574393ff7dc5dd2bf 2b80c0b1872237eced204982af4bc2ca9dd4df13102922f748d975b3ee080935 4ede14d64c622611c771431692bc076f7c3975736f2a51197b32cab4a88a8501 475da2515725ba06aaacd280d542f7382ddb439c03eb2209f7e6f45d3c68df0572748802a0704af7d52da96861ed5192c17f4f11310aa970f3dff235b02b6a0fff677b4638a03fe6a68acfdd5ea1ac1f2c2220ed27a723543b82a9df31205202a8b46759ba807785ecb81633eb410984bd4d3b70ecb6abcdcd12046cbbe3a507d4c221b8bca910b96dd360d628e1d3814cd10b6a7d5539114f7276f3a00bbf0ce64f7d833f4c0f4ebc3de60dc3f17cbd70940a6cf3bed225a018ccad6a84f501e0308315114417c71b2945002a6373fcb662eab174627d4059d6b99597b1c80cba329f14dcffeb1d2781fa6ebf17bd8e7ad62c1967e0bbf5694032ed3ac0e202ab3d4d207278d83c5ee845aee3008974c9fd2c4a4eeb99c7b0aac212d2050a0208204e944603a24c35d8edc163344eb60938c26a8363258668b75a64b88d4313475527caf48ad07e5515202a078f9d9f255725752e6971a16189ccf21d02600b023b727e1f2915aa79034b8b11d08def735caeaf4febad43574a01f782c33402 false +check_ring_signature 8542ff6cab193e5a0012d058094e92445138ee55b5711a32901f48fc993f2642 53895fa6fad1c47cf4c65a89a4b4312bd63504be7815221b246bef1ed9c3f082 2 eb413b1ba74c05d66ecfd7a53d0504478b2bead67b09321f6420b6aa59adac16 c485b1bb0add61dd52863b045cb06cefa528c35a6162cf84d0fc3d3456b713aa 0ca160e15cdc116015e4021a20720ed8b0a3f345e9fa3afa78d08f86ac03150d1f6b588ecf3e41ac759fee6e55660082de3c6d444c22879d0644bda0efcbb80d0470c7d70fe587fa35429dc0c96d1fafa2faf18d0e66ad3e10edb6c7abb247008b3019c45614f7dc6f50b6b20bc7e9441ed3d239feae9b8e0014185422b097af false +check_ring_signature 43f91b6f2ce9f7945b0f12f8b37423546973308c8a17e9db8edc6b39e96764c3 f5b455774c597160510594ccca3bf9cdc1a56003d5302c29c584ef6b21d4031a 28 3700bd709393fb62082e87d58c923de84ffcefbdb68c2e4f1d150221fd8f4e5a 54a07e0c6b65bda278d0c0a256804358a87e25bd26eeab50be955cf08db6ad28 6692fedefb10aa662c891e92470a1b0efc4cb8e0c66e7270fcb9546546b479e9 279d06ea0c9d0c3ac1bbbf2e743d5ab4566e93691a0273090a7e499ebc025542 71005f1c5ab1759b64531e73a18ed7a741b644791a58b11a0024b44a3c846c7b 3bd251e8830f6ce441452cc5dad94d889f0283e3401fb272189a09d735ed45b6 b1239fecb3f2697e4409c73745088752da6642c680d9497c9a6a5813d47597f7 bff26beb49c5dc8c2960cf754b73e34d966cf8bd55407dc1bacba64989fef275 f34b184982b68fb8bb126acc05f481d8ee2151b02a8a98a3f7a60b31e2f77e52 a7f4f98ba5635a4545c83366729586d1991012fa58a86e8c034d3f5ddb8ee1e0 fc9e7c44a1acd0aa3b3596324d45bc8a0e9c908f4549edd1e361a0f0db66ffbb e6a754636e8f1757a6735ceb42b52f9d8743c0bdfcea5a2f3b80bcb390a352ff 06b849d8f19233ca165cd7ea16a75120d037d5b31673833f6eb9458de9b67cb6 8916dacc894247452627b5b86716809a3d853cadabc9809bdae3ef6d31a6d01e fab7f5f75404d95f75d3613d3866e982a9add9eb936ebe3621e5e460b3dd206b 65c2c30e885a58bd7bdbce755b3e8b31ec5f4ef1fa6602594f744c6b6d4854ed e4cdc42035b6bf34ad06fbecf7a7b718d8f815272d5f50459fa57526ff5d40ac 4bc75a792116d1846d440a644c65d30343e04a5f705b40764d1a3e975c20313b 49cedca7237a5b5b9ad27d05dcaa58ba8176d6dfd1825e33f27eab28686b76a0 c1ef52a0be8fd9bbe4974083a0d5c091de1e89f178253ca81871828ab0623426 3c27a091ecebc56e0e71fac634bee55aa6d838938eb3286b8c6a304713b58fe3 6a650d35ed7df60c3d91c3671e61bb2b3c841c6d2e50e27181fef5c86ee65f43 27d7c92d7bf8fec47e4ba058e2db3fee8748c764922c3e91b1e4059a659b3f50 721d70ebf89715e052b35d753ea0185f2dcdf37d40b7a5c3db810e6355aa8851 63efb7c3cc5a3393300bedc36e31554182fa1213d47eac06f2f00dc442d13a08 d66d22e1fa73196ee82155a30fd7f58a48f65f53e6cf1720ffd6088e2edfe0ea 4b5166e02bc35b65e1cc88d2aeac2fad0d924295ea82057ea20d89defb547342 a3bc6858ad30ac40ef10c6054a73c5c367b20e5383a8ee6e643989985942be90 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 false +check_ring_signature 2ba180dc783b70ea06595cda1c83238f25c695433d01ca442d64d883ce1febb0 2fc26e0b31bcf61338df1630166a6401b3846b803fcf25f2f4eeb54c2d3b3439 11 f607c8e37663b3d2c0e7523820e0333f0e281069c1ba3e34abbdf68f50e46ab3 ff731032d33b8d287699d66e2606150dc32a975cdce08ae5bd2f6fa519d9a217 3240f0af408a19729f9d0994d04f8770d7f2e9a1bc6fab9a9633aa951f6d41ae 2919ba129f0b45f4da890d92e4087b5d24be96b35ad368e36d46cf30d64b123b 64fdd6a6478c06a4e18dedd2d0b30e2b3393994c94879d244785c642f72506de f4e416b89d369fcc5f904597b40e4bfdb4ce6d3957baebefb3723e3944bdf787 f19aef95cc941506cda8fd26ee46aef010b8131e092616961e6238fad1d32b2c 8b31dc684a9c1e18df17471188e237ba34d728c34b3cb96fc6a1bf54ab9faf84 4103c2534da5c9afdd4b24459bcd84e3bcf7c1e318e0fe007dd313b026a0a48b ddf31737e72a28f8d99b6df88728b0a5245b222dbf64901daab4919e755ac484 b85fb6bd14ed86b7b7b01285cf40bf855339edb31c5b3c297bfd1de1de80aa5c c6f5d98634fe0f8b5883f6b4a8d2037792fa80c79fc12e2171eb964297e90d0d20a8982ee65fdeb984381a7ce84a34bf03b9784523883e8a924d7af85c832c0f655b13b7a4bb870bb437508e1b6018ada89a63aaf6a5b2312af15425a68a6504c99831c55c0f56f2f52a16e1403f6b11fb0756cd46db45b588d3f271d93aee04defbb0ed9241ca97783c760662bc943d434378493d9c7d5609c1ea3fab9c970247343b44dfce48617404cdf06f0a0dc605922ebc7a64b282c39f9138dd07a50277dba6a83937d2a2f26eec92b224b7eb0ac58ac2ad981e336e6f707c34f7a9053fe58bdda2ab7f7b89fbe7382d682a2db466b41968f5187d622095e2febb3d076182ba6d4ce18000bf4e083c4086283773555675d8933cdf23a5c07bdc8f6907c10d6c2278408c9b1aaf59bf6619d0c825843f5ec28851e66642c64d10e21d000cfde90af921f4c3c14cbb05de8e66ec02b247509bbc946813a0c98be0e9fe079a1564e53801ce4013b00523be44522e6593a65bd6feea2b053588162fd1110f0d5802a5d6fe36157a99f800dad0932bc0571f0362d9cb318b025055ca61200341dd60c89e80d2682c7d4af0498106d81e9de3bc04953be26fac2ed8684b2b0a9c18a23c995a0da0e490e7c7d8f63149e121a1f00284495eef72afadf3f8cd0cff605b25900233d64dfe669ec5a28bb5123ab61373aabea479115c0a98fb590ef433e568c72cd8c39a0736779053cb4497a51dedb6811a7544440742ad14c009110279fcc4d07c9eee0f422e723634e6d86fd9601aba169f012f7b29938fe10509e2b551c1a16b55c37f38831ba7857949244a71d8c1ac67073f11a957921805d368fc17bbb829291b1fce5d251f9c666183b7d0704983fafb6b8e2251b7740ba367299cc71f728e9c4adf57d73f7a46d0f27e4e1056dc41f785c43953e5c8042ee3892f8d4eb1d31ad80c6fa2a8465ad4c620e0886200710fbe61a985963c09 true +check_ring_signature b7f592da0bdad848b36653034e5431c42e752ec724e959b912a473b67ec9098d ee3802a350bce56526d81847e5210aab90297407d69096e5bd07eb9a8a2f0648 84 54f4ac4b767811d2047ba65360a62f723f37bfa2df1cc33a509cc703a19d95c8 e6c091bcd079d4a6afeeabdc05f696e7040d1d4d7465dc442ff085b3833f9b6f 49dda6263258347f07bc27f3cd743933181b5c58410dd8f35f45a039b5cceb19 76f82680c64f8f4136ec9912a1ceeb97dd3edcb6e2fc29275680ee4f38b789d4 eb8ca1e9e061e89e72a1a690119b0a3e8167490b1f4d692846dcbdb416635e69 d42a5143b4d4eb08ff481c9bd001deaa6253dfb71073dc11ede1b5ae786e2704 e9c28e4b40e6ca30a2a4fabb84c1d4283582863e6c067b800b56e10cef677779 6d647ac52b0b2e5907d513304030a81eb2186b73751e361bfd352253e97b06d5 beef501f38d49bf6b03b06b22da0ccfa4d88644102cbb0756df49856a0cf35cb 36f0b02431d32dfe54240b2f9fffccf5ae51d9b75699c955ce13abdd209791e5 5741e1d0a5f9ea5c02753997a39a04b2983e9ca142b903d4b11c9f8104f9f320 e1a16ce155c69212a94c6cb89d7d64a1d46250984fa6c5896697e3594c143fe8 80ec6e66fdca259b2c5471a5b1bfbdd85b716e70205e74e5af9d715fe3688969 a68f1a73dbde9e32c7ed5202da3b96ab0c7143674d64d447b848a96a4b23c6d7 72415ea5eb3460aa3ceebaf97c44f9c731c497d1c3388c6fafcd28adb963cb10 c91387154c0328610f33878d10be83387f7695101bc3a18da8ee42dbbc038ff3 eec10f7a82c93f2897964f1af4e640af9f81b377a91b238aa0b43163f0049291 7afe49c9627b09fa57db794352a4778924e2802a34fb92b2a9174d98086e4b52 effca901edcef670fb9a9fdd6fd30f418344692378b3519e9d36afd3b2beb7a5 ce72a73ddd20cfb7748202a425bbafc9ccdbd158cc46db832c857d10e7714b5c 41fb47b205f3d257507ea6d628ff4735fee53bdb906be1919a44bf4cef10e7bd 2af9e42c56734ac49cc51d2b563d1b90126024bdd34abc03d429804c62f7f1d2 9d7752874f84d1fd41ebd8d028f0f855888a30fef31de6775b72ea9c28e5ac06 9667f8f437c250f4a0c4eb56677bbad141de57f81221947e149f96f70d80a747 a00a8d38583268b911bc8a19a5449378ead3141f46194e3cf6780a01c6015435 7cab2940020e834ccd715aaa1b742f2032713b899f0cac39b600e04e9c7c200c 1a7ff6974dd93363f5ecfcd2749714d0a62df55f0735ad5ec8b05fe87dbdf375 aa17e16ac700415db0c6b8d3d9bcd63b9c4733e4fadbf21c56f2172af3816951 32483eb4391d1be507d4733cccce1a0087cb6243f5306168be44d58578267761 94d4545c555da779d72efc58aa338ac97e5a71d31fa62fe9795e53553894ee7b ea749931329490a3d4b321869ff418a40c3ff4caceb180d0191ef2f98ca3ea3f aea12a2148954795e32bbcf142f912d6f4f30181848e71c10afb16c0ae02da99 ea7f012f332ec6ba5e41eb4c1efa2d64affbf66f49a5e55fb8ee91a97375980b 9402f29ccc05be19039f539e73ebe8392d1d27372d6a6a04b82d254bae9255fc e61e8a30bf50c60ed16396fd97603c3d7694cc0b50ef79fdd22d1e48c1e13085 0bc1554dee7122c07b1f1703ab13ddcb2cc81859cd74cee65b3227c34ba3cc2c 5c547cbd582ca6c3cb356a99b1f40859d2b04c5ce49af4ba435ddaa833fc07aa b87325c2f3df9a9a9584cfe91e8c33a8bca31658e4ed025856fc61505b853be7 c4eb807c1cc0815683e7641172421f9f56d9c00054b1110be25aa833313b64f6 4e307d119717a1f0f673a4a5eb3df16f2b97f8a44aa3aa7efc98849d022322c2 48ce219114b077b87de61ab253f20fde670e03777cc230f7f2a3f8befe83221b f2c30fe243e70dd986f3738240d147850bb07095aa53a60b13600d0688c20282 e3e16a8a38332f53f545feb53414d6671cfb5a967e256412772617365efdc8d5 ac23d4b907dd961914a0faa98b4619f86d1e70f5b6c453e361625525d4307e87 b5acd7ed79c54106d0815ec6f9e17c195c20fcc25fa18ca5e8ce48b201148c17 bf54a1dbc59a00eea85dc8c3be319ef64579a4fdd8b7cc20742cdf11b3ea66c9 702c374e5d81e01c17d8fbffa2ea340506e3ce2f2eb54f1cc533ef83858e45cd 3b8bb3b4e0689cf3a28d122e4d20583432f77300c717ffe6e680cd7a3109a25a a8067a9d07ede35e3e374ad0f5981f66dd521f7a0dc8974fdc23bb3724f62c8e 434de12c8e0d096f29eb315912eedd2a50b7b05abb33ffb5b4c7ba0c08152dbd 4795de0c5f0c4f773f9c8a79e0e277e7e7ecf71a84640d016ec9ec8793a05002 9dcb9288a3cd8ccbb47951ac2ea2188ed7e91ebbdfb8f9b6d65f54806d2477aa cfcde4ac4ab6ae6e44d22f6c0ef085ae765e9edec3c8d4045d3128e89f681a28 d1970dcf3260cd072d550c9fb48fbf5e1b9922c1760d089d78ce20cee69d9d22 c60dd2bce50ee8e581883d0f1f3bb867898e5ffcf803a2d0ce35466f27782a2d 8f65127fb7fc1820759799b565474a6bf84d7a95c5271a4e1c71af53f7d3db45 04806d609ba69c83c5a6f0720127b8f4990acab98d692155cff4c2c757a3f3b0 1ab0254e339cc1b7e0871c8d17aa1c75f09f3f2e2790c22a1aae4c8fe1dc5949 103ad7286e26ea34d5af6dd6a94478488e22132330833ce131d1c601ffb744d9 7e85951de2d5f53be02c4b105347d859c44dcef7bcb96c5617e48ce69e4c3b65 384f8cdf5c35fcf2df56c38b9b250d5916ee5ca00f12a3745fb8a0a40ba1193b 6359aa76f59617370df695de9d2d37753dd70f23da119db097aadc21f426ce71 09f981398b830f1bddfb5756beb874d70473314788d59e2d206946b458aa4899 d9a41c9c629b95f3d00fac53da3534952583f21f45045b3464849031f3607e19 a427356faef3d124e77c6d1167a67049023ba8bb7f6de03084cc5387ed712489 79c7226cbce82036e49aa093ef9e22a7e4763be1df0db9406b07ec9bbc3ea8e3 d161c6ddc1bdfcd93fa8900e06193c085244ac688d90fb1c125a6a654ea2c653 0831c60692337128ceb1122a32c871e417319054a6e24c290de33a42e0d78802 e5287fdd8811fefb817713020b29e8c3e0ba70b6790d9f6e663fa546a0cfeb68 5c7a116f27dfa01f8107d40ce912417a5a55261f7c745069db5527cea6a5aaf2 b7125835e5d7c702f6fa6e57f00504b2b49aff72e2f06c1c6c817234bc85d657 176b983c17f1576679d618a7a95396a1b976be0b030e692d22e23b527918a9ed 7fce838bd26586b7093faa5dfbde8417fd4d914c01a416155067509ffe69545e a631bdd4b5e4056a50e1637552c0d53874901f14054fe07c2445257bf0ab8f4f f76d25380f5de7cf6885ffd74bef1192ad679c9b76521ce326a596d0c83d5cd3 1270d41e160f5c30c057866f317b4a280b9825fcbbee07f9f8fda2c540eeb084 6a718e1f74385a9f559b4f53905b2ee2056965ceb0e709411ba28f3632ef9374 0f995727ebf7c0a575afa7995e79016132abf080b28ab0c94845709e13bff75c e43b08d900a11c695697590a78269694682021f498747b0afd08177ea05f6a03 5d7f370408e7f6e9d15ca1b1245e13e4847b8d2891d3a5b792bdbf6805df0dde 44f4893d5ac36c9cea76611b4ee6705d3cd299acdea1175054115f5d927d67af fba46422377d57c37f7607e0e6b4c909459b5550916571c67a2400215ef3c32b 826752eb6d977d370bcba68b9d4a5c2d9e7e5375b36e039bb443f2efc0dc5e45 40894b257c81807763a748bb0de69e3327ccda32a812bd5f71edf4b8a1684784 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 false +check_ring_signature 1e0817d42c76cb1ea3778b660b6ad9da317f34e59f3361ad65a75330d49ead35 0795cb472d5c5ab690e4d5f3c46f29c68fb83f8d7c01db27e49ee672cd0ffb7f 1 9a014d6ac535f7bafb27d0d3e58f1486ff3a8daaa415d3509a1ee02c205a85d0 53499d53745b9776ee8e74355adece4aae3e10bf269aa9425511b6914c746c0473efcacf3551e99517fbcfccd89c2fd72def122456c6185a044f0025653c240d false +check_ring_signature 99722d5e5bb10f6c40f41afdcb958af76fdb08fab0fdd1d3f42937eb9061db66 76cc4bc878fb0c172c54d052ee70fc7eeafe94e4f4e676270f9ee9aa9f3e9479 1 b67d72fab4c3087a287bb3b0e643c2f67a7e322269e2251b29b68bf3c198b7ab e63bebc00a715aec12a17a43a781cea5550c4f4c4e1382a9d1b5c20eb3ad08077d671dfbe025565d68fce9dbc6f36273e6101101aa012334aebdd230d6dfb304 false +check_ring_signature 249e52934f966c8acd9998ba6851cb4b76fe6371c916920a89769be0ea1fae0a a3806839e271b19b271f6d6e479c6fcff5781e6bdd216b7b815b2efa1b754447 13 0c107aabc441343a98704488b295ca4605d8c38f9b1707bf48a828ff5410f09c 20f42a502e7302412f7f4dc2e2e4e583e4ccc2856dc96ed2237bb2d1384c96a0 702d478fe9cd4ce27d4413d9b6c66037061adfe14d90664bb3f903fa0150900a 32edb0a3c2c550bbaf8b3e95949d2ed2087498f7756b7aadc9c4b5eea39f7661 1be9c2faba29374a370a7bdada516dfd825e1966eed5c4294671989d551a35d6 22ad6b5306f07ea0a3d5e407ad161068c4040ebc448d0739be4ed42c36cfcbf0 54d7798cf5ecead8b0879d49fea3617b63c3e99b15e004e49b739bf1ce90d38f 9910b83ecb710715c74aeb180e9f080f4900fa97ebaad6676cf6b68d1fc472f9 74168ae4d8635647f857e800759632424ddf5d455b7319330e1d6a5ecc50fd83 20114a7dc38034aaeee17cd13773d94dd3a2029c1c5a56b7d273a7f68462736a 0c4f42f290a9b824c864ab4719b5a0e3a8a48beda8bb00f98c838bf2b29245e7 6709f023875f5d1c3fbe2146e68f2355e8b54018fc1a76c91a3c720cd2436a33 de16d2b08f884a4064f321c4374d122098d1c6a57ea7b128e9017366dc9e031e 319a3e7e7f0a013f0734ed0becdb5b2d03c2eb54378ccacf5eba0541d7f10002bab4e8161afec2220b74afbe772282605dc4dc874dbbc50495e095a83644030c0bc92feabdcd198d61d91bbafe3559dd5d99925f640757530010f122e53f8d05070e748f6e8f63303c3e30f25a19db51b34ec61022b2ffb9fd864d94cf3d1d08ce27b71d402644d3ec15cc552002184916b10c0c1fefef016cc27bd9c6ccbb06d893b656f314fbcddcb218ee740f0bd586087e1432385c65331c4fa89b1ed80aebabb0aad0e0330d0134668523e909bf686a6bf7126e14465e70402ab405850c683092858b245f0b9bd2da4f7048dba4ff4344f73772d75e267e1e633ca0d109f3703a44e982912e7a23c2f5c7d66551e23229eb74d4ae562639b91dbe08dd061cfd16081eff4d65aec69d2774a5ce924db311bfbaca84cf4a46f0cbfcf0b40ee52bf69daa51126a9997dd02ebf3172be41f9cc06becf8af1e2742951ec077008a38bf53902c8967526e77b8af9711dd8f3c3c83e44f68da3a63140d6baf650e194c106cd921fef175bd4455063718b01f9f7fb5cc077c20ca644bc6353f9b05de5217293fa1648b0860df82eb6fad55309c02b25c13eb191b45f718cfc204028015718c7679e812be6ea324d5b7082f8b7ff00913e27df5902dc9de3f18c901441930186adefabd465d26a1b9dfdc07bddaf68655123c1c2204876e5345430af21e423a765edd801df0114d238431665ecd24ca03bd17fde27a64aa9b625e97b57f7476d4c14974d8aa590ce83599d790afcc7629c8b8141272ffa8593235089f9d4ac48f0460de8e3e5d0e7ea58971bcaf5726f7b6cf06783dfe313223400b083dad3338a78b4ec804fcddb73da541dd4921e012e198834eb4df09b608a7020c13085a2e97f4cfcac831d57e45b7c923eb6f97f4614b2c69ec5b0f78521403c602eb153a2a22c74c5f487279867c4d3fac9d09fb6624fc23d075426ba40e019991664946213a894e6ac16715255825be42010fb64c5e1d97de74fc3a55310341280ffa920ec2c01c9da2d149bbf2e39d602dca36a83b68d9c2adb0944e13037e0a896b8ebe6ea892f6d4820a868473defcb9821165b2e746500810678acd0b643c36f9130b4c83edb5669ffd24647647e508b1174a8bbd863e7a5b918e610b false +check_ring_signature d1651c4d1286ae9a291d8b002fe540f1302b93099313de3dc725ea219fe5c49b dda2f4450bdcc0f3ba4289984a2a94cd274c55fa22cee04bfc937ef81cfd53ec 2 a986791c58a93f6aef6080d5829023fbc0fd80b43baa56e1909990d6aef67162 70ea3dcb5b1e5d31761b6ce9031a65aba48f42d5be0fd9ef00c0c7c5f198bace 41abb5871dcde2bd629962120010ee1181e32dc9374e13fabfff809d05144db5b436cd1be3eae39544eabfa81f59e0af7def6e9c69119403caad3dd8b61dd50719ffdae1d719d0704acdf5991276c1f69eaee94d3f5a1b4bcda45dc5418116c7b18f18514db994051cbd9a66a3f86b98a42da1d69e0f4c03e1e1b3d051e8340f false +check_ring_signature 09220cabd5c6caa15cdfaa9b980c575655ab5cf5722debdab348baaa2c3b21fe aa1dadd86ce230fe79574f13f348a7810aa20523f92d9051028c440a2fe4bd04 1 531dbc2eea802cc19794bf63df8ce02cbbc7292f69023f5dc7a531c65ea18bd1 ca39c30116486f7fd10797f6614f092a3353c4aeb1b43a6133d822bba993cc07b5324f7f96363d6fe1ee7f7092cb38d210950770848f28874852d25614183302 false +check_ring_signature 3670752e7ec554b1db2ef2ec9617b6b6bdef1e01a9d2f4143cefc6ea7d8623d1 de2902695bd17eac1dd42dffb3636d5f67b8473ae0a39c2b3512486b6fd37043 9 9143cc828e9767d81e158fb378a8bdf1822e82225d4defe55098297a2504d80e 0ec7e153f881de39f4bd08a0e0b1098a2099e0c6cdecb400646ea13b921a7c19 d52be1d3a3709b29c93eaf9d0ee020c6a0017af478ce9e36a646de297a7962db 8e1f827abbc614bc9f0ca07c9e677b1d5ca327f2450304294087d453d97ee6e0 12f5b368279d93726c9b5b555b6fe6bdd96de53717d437cd1a64348c4f95e8f0 66954fd8db581f04acfd5addb3574b6c3f1283a69a9e3b1ccb8b3815b4730d36 e6da9c342501d5f6f6c35fa07ed85d4cb58a854d07b339fa4055a84428511330 567ce1644368f7b47293ba5f9d5e1eb07c44ebf32bca21f3b949ff3a8a7d631c c43af1a25ed92750bad5571637fdbba4648a69c14873112e56ff570f21530a10 472774c3f0da4fb0a0a95eaaeecb0ae1733ff42c0fb0513a04ac10ab8e22950f99dfce3f6388f08a33e3a0f423911a1580aa43af37558196ec43021185a3290a5de131c9d7b7732ae58f18dac320764ac9f6579791141a45d55e3d96eab41303a4822d828b18cc6cd5192db52d489e4264c6db5fb48eac8394604232f81216053c3328f1901665483f9103f97f30e168ec0b996b5ad3fae7a95b03633438780af93d0a1cdaece2661daf8026eff97c664efccc55fa42d1e7c0d681079cd9eb039ac30f0fe5cff2b3806046b9521c8c6d2acef28525579b23625e313c3dd6df0801e1d1b62339b6da48d57f70ef8aca0e42aa0e41cc64717493c14fdddc1cbd0ae70e29e3414d22a6a3fdcd9b0ea9c3589443384e18cc9ba85cc337817e09d802226564cdf44056048f6f5bb77ba4c1fb7652d04165822d8fcdac2da9e4f20306aa5ca62d4c72eb89ca8191e04ac910c27ea45515575b5422716e3952b6eb4f03749c4087d632457749f095f3989fe3610c4a2d7c6a73b2e489f0a105cf01f5068b5896e8d17b70a5f6fa7cd472a297b27c15a7f60ad21aeed96be11c44fb540f34b1fd4c03d6f24e38bb2fbc0d35fe0b9799b891a21f342334eecad2636b110c1d39793d6932b93d8c763f97711e1a970afa16e068eb1d920ff8a92f09d887096be095cb953d323568f6ba924555a61daca5ee0f3d8895ac201fed52baad21055b3036d7f0b2bdc0b45459110c54ca17ba1d8baa5c1fb39f94bfa141c127cd07e793b19f73359052ae6bec5b29775caf6a3a75ffd8ab4f0ed2b02e26e742480a true +check_ring_signature 79b2df23eba0adfa4b15356a7c6faa568e3b53097225f2f576a6cbf157f4c847 6a7424b7d1885a6de7b0fdf105e9b67138327b97ef26c8c68ca137dce2834513 1 405e6526758325ed00e38b0811d1ee60d5d1b947efb41b56abcf2f20cba56f09 a786726df15550cbbe4f6a434c035badf3db5b9198ed15005084dd5d44443e61c95a2269d2b7bdc843856c91f334af5444d83432c723382d653415ef731eca47 false +check_ring_signature aecce1bb75d81ce568445a4acbb97187aaad19502061e7e8e310ca0efc7b9d95 aa71d20cebb776afcc0456dc3082dedc47a583781a825cfc966b3dbc43beecb2 1 3603681780013e1ed672a942ef0a0b509e3a6786ffbadb4b3bd096bc329d3a67 8dc11ee37981561bb1dd080e206bd6609cf1106bd2179f4a73fdebcaffc24f0aea18a82002d6a83eb4e7794f12532a95cb9990975ed3d4b9bb34889cd7724e0b false +check_ring_signature 0939e5ef6cb19ca9da1db49046c31d813988b6dbc2d7c9cc44f7d0f93ba14910 ce289a1f979a1fe8452a95b02de54c4eec44409328a0b487821ce79616fb7315 22 9c026c412468f4777fbaab8d44c414404f170cf2bfd92136a5fac3e702034606 6e8803177bcec1db0270219537cd08b0c0ff852ac61ffe1af8db328ce7f53dee cef4edc883677925d9715631bd2d7547b863d040d56b2fe48a2918d360421678 acc1ff52a832844dff536739bc38e47e1ad3b27f5c420a8712e0e5a13bed5913 3d733100551a8cd044d0f0ea7f32f4a7265db4b7591ac6034f3ec475b6761f62 cec1ca8541c19a3edd0895a6b0bdf2a9c2a98add2f587b0803e6a12896816094 e7328b4eb6926d15e882b8244e95623950777d3cb3ee84c470843f8f896e5c3b 42b5205052ed4c44afbafe2c6b45cf6bf2536f5c9fa5a6bf0a80f07dbb98c04d f01b0e3251518bdada0b7038b08fcce8376bb914b6d914e1c5ebec46ecac47d9 38eb94034d679d5d5b74a8fd3530e58ebced10ff0d1b214745ce211409f9b7ed 8205eeadc3cfdd242efab5875f4c7f944d76bc924727ff51162c46d91c82ed39 0dde6889ae492ebde4d0981ba6f1f9923d11966d5e70405e03450cf1d4510129 b600cf0cfdef8fc71ed5eab65a10f6d910c9b94b45d3a3f021373cf988f41b60 6539d48447e63ac6dfbff24317444d7cdcac2de05bc5e7fc2a849dd34a4ac968 18f22ebc5cacb8e4dc4ce4c7fa788be0d8756d953b882511388220db05006710 9cffb89332b816a224bc8c9f0e06fd3745fb05c5e7ec566d9d72b2205758c343 4388ad22fd8b1ccd970a8da5771531badc8f5c528b051b20c6034814af45540d 4443877b150926abb0d1c08f1e23f4319089dcf48c0ad7db989a71f83d7c4622 ff4d5511da776173ac3c72bb529c41b9a295bc102ac2ab324197acc669ee5ad7 2ad9dc8aa69ec012070e3770e612fb76ab5676c034827a39ccbda3f07a67cc8c 2758484a9d787220ed7d419c309a80271cf72a9b1ce32bedb2a535640e4fa34d e72351985b4e4f1e47202c6833dd1da9035db3c4f7aa52bf60025498e08ae766 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 false +check_ring_signature f29fa3fe95ac76fc260dcb9dc42b95f24f85e2b8dda584add132539c45ff1be2 fa1cb42626d8cdbfbb23e79e97d62baaec39190823742998fca20038e4b927b5 2 dfe02ce213a7baa79e2f45f96acc15234df8364c389e6406b42fdf72687333cd 9d1b3bd0973b08237849f07da4d74836516e106abd0dbc7115664b9c699aec0d be2c7c3bdd5cb24af801f9c63dcc49ef8449d40c540531eb254642daedf8a6007948f63b930f155add09bf256d31d4cbedd7ad1587ab2e836ddb2d50afd54a02b9894e81d485df9b2ed342b552f939d008cb514d7f686c926706740b1b5e590858f4ddd7948b3c85626fc8b09b9879ee098ff3e33acb0caa75291339fcfe9c0b false +check_ring_signature 3c2ae7faf5b854b22df3c30ec71cf2de2fb04777ac8710fa45efebf69a0af269 8787761327bc2a7f8e582557ce1b88690dc4d87a6625e39fdf874ce17fe287ae 1 221b5059e1395e2ea57bcf8b0e232874b086a4df748e72d6baaf6b720ce9ee52 b367bc659e5cde3ecd63be88e0ac9ff894df001f9e6de8a6172a2b8ed0819106abfc5d049e9b3d57d00b0140c41baa2a9dbd9306ce1a13c86560a2d37e2a5a0f false +check_ring_signature 8cf0ec916e387c32a716c98b5e1fb42af31f0beeaf9465cfc026ad7962c269b7 847dbb3f10d592479c2c8dc560650d0a8f2e818ea2a5f1435c7f9414a0d965a0 6 f99726559f0f3d5165dcddafc55da7d9a16ab26d944f453eae3b14d8f1a89078 1edf07871b2c5c906de4b71180d197328245c1a730fedeb93836654f53516695 73a2f06dfe636061ee8f5bf8ba41909c4d1fcd2d2d0e6cb11bcc0042161dba8e 675cd59701c131f0c3709ef01fe7188b97dd49e7b3497836bf14faf73c0e9da6 51e7499c6efb88523bf285858cd3000e75ee8f09030fc9894220247fbdc51793 ab6ef9dee93e2a1047c754ef042cd59212550f0ce1b88841e013e42937d133fe 9f178f94ff9d267743c87134d92946b0ee1dbad1998f71fb0e158e016e324c08f8e3cafd36c144cf41f3639a949494324925e43dad6dfb7c9adc0e58a1306f0f1e69bf263f2097b4871c63e9cb8b00916fb4a575d0281afb318c8e04c3845f075250afb84370fa63278b59468cdfbe99a777d9cadf79729de9101aaebb95620977a30f727c0ee808ea405248c5568a71e159733ed23ed5140414576137d12704c694561af1b4dd3bb4b8e0e7d10ff074749770bcefac9dc262c2cce47a171c01fc027ab7b9f347ce5646b32d70275549c82a8b91f4306d234a7ca066a6cd520efbb6df63341f211a2db8a543c6bc3f9a42cabe8ca021dbff8bbd3c52a0b2600549012188247bbaacc3178c20d2371685016e1985f2f83305dde4270cd96dfd00b6471ae82c2836086385eace8444c36c4ada4f129e7f726a928f49dda3785b35b6bd01e3f3918774bff0fc04188c31483e02563b050590ec15ab8194b51b94098b17f2436c55b968068df24c60fbbd411cf156646738728f55e7e4d4ecc0fb02 false +check_ring_signature a14c8c140b27c7c7c3cacf90b8b5366ad86cde0cdbce36bab7914d130c25152f ec6538b8c838aee6a492c1b8324c4a79e73fb593fdf8dc26efa3c77133491f3b 4 c8f8215f9fe281f822a260d9a7cd9afa6453348a3d353dea62124261d905fa91 928898b6851bd8e630758cf0d54bac7e42b547d2add3400200b9db5a0e3324ab 63cc0d08490a6f0c10fe2daf3593541b5ce2d95195a8ae56ebe8b8db5f44d943 c49490d23b741bf9c9c016b43b7ba0a8f0038e447a7b90ed8dcce435f851b682 a9128e31df69514a7339620bfc025fc38f11c420af7ac5862b8f8dc2ac06780e3cefc2bde165068f513f273fce0a14c1ed56aaef1dd6188dc199eab5a9cb93449e1791fd46df3e1c6fc59cfc45eed32f7d7dfef0a7e6a646db1cec6ce9320e07544010b0163a3b9022bd56bc2ae32461a0366f6effddf69edb29622b0dfee206790e5b6d2b278359bfa5700088328cf7c865c0587cdbfb324bd35c75f4786a0a7d8f08c58759a97c10eb0ca74762ec5af85571260ded1a493bdc74d5edb3260ebd95c4cd3b0211b0c81dc1a8301da5b9f644e044e1fa0a613bd93d5d91669f8ff2448d11df7ff7f0dd078ba9642769be191b56271b8d6240b56142a70c119703 false +check_ring_signature 54b5c45d102d7473e187e8d9747f7c2098064c8baea427828959de0c728f7b25 63ab43aaab68d15d76b97153f4223f1a752d19822eac6c6137a5172985be1a67 20 aa3d592002debe9a2de484951da4eec887bcc68f4a1758558787b17e3d4269d6 052f2ec5fde688bbc5dfb74fc77c5427c02d4676153c844472a05d5c62907fb0 128fea9cc11785bb8df19f73e16cddf60ebc2acc1be0c896443d07d066020c4f a070e6e6873d0484e2e6792459c932575383410f8f41707445374405605576c5 35ce7d101b2325141cb60297cbe7eb3b210f8fec23c2f86270d425eebdc7723b aa2d7e9898e3098a0af43d958ed901cd662a85878b41bb302e24bed82424304e 8f0dd5a553cc2c2d51ceda1d42215aa87ce1b7ad36c9ea03aa521615ef9c15e3 e20250c52300ee3b527279940e6a022ca1bf5050fa1afe5007eb16480c73dce1 5c340059d0396108fc850658a6dd8e708a1d87c97e4106c633089dc65e3fc2d3 f31b8227cdf2a29e2c677342731de9dd038c7a5c1c5112726f85d760dd770dcb 021a6169270e0f51538f4c5f678c5a636df7b15588f10f1004c5c24a8da5ea32 3e4359a4cccd5165381d2c579cd3be2cd4a8d7ff57c8bb813d86de6cf5346cc6 3d3fea598225c100a120c7f813c67ef4d507e01497b532f1b9a6c39c1f989cba a743a9f03795d2b35af52fe910f6ce34583cdafea479f8b86f29a4e99087499d 95f11efc39c0cd7f0a3c60d54913938e3e481c9c7248558f1258fdd9681436c6 fa04a89553e4917c4fa52bbd6fe67a3b30e6f1a36cefe2ec961f5cd778d599e1 fa869abaa58f35afd8af74d39e0aefde20dfb1500039c95fb5440485643d56e3 395fb18b2eacea79e799a48be509d27197c9d18b820a6234c01ecaa963ba0734 07e3621e8646d9307f25ea85db9a64f690e6698d876c27b9b0fb63576b5ed3a2 59b937359ba1176e7c655075c676a2030eff57bf41a637d56f034afa71f9598a d704990de95c7343ce99b826a7583c86ef852cfe1e77a26075cdd0534279cf0247cd4b4fe3988d3e75dd0b3f93be925f686c1dbf4b8def67e6da5a2a464b3902ef5cf21c626d127a3c25de89b056df4a69301fc44444799a1eae3d9349601c05f655f763e095ce791b1118bcfad5176c499168b4ebb07e7e5aae7ea14a59ab06b89d652dd7997268f7f9ec4afc32c9a56f593d9d00adf7f379208a28af541602ac62ebab5b2be4958b948c8a52cec30bce322d306cc6b203be1da72906bcc7043c5d820e328a88fb1b841c45db948597d7f241b847c859e216c2235334a808050daa9a3ba822a26b8061555ad6afc2e27dafa0ee56a554db49c25e445f75890b142d7565355957da3ce96b5e9fd21c41e688e2a584713e00c899072e2495d1096bbd3537662f944f50ffd17cc249c8750a4ec6071e6a20b54217961fbeea8b070f93bfba72e63333a625e45ab1ccb322ac074e8a917f2cd494b3abbedc057d086136bd45dbf3679352fab61572757743327270cdc484836c7790abcaca409205e0c522ae6f1b12e30c4eaef495e59cea99d0fd93fddcd724b6587e4e7d3e1e0e4f282fd58e625c450530d3bcf9dc437b91966f2c5a0c799b02adaae3c1c1610f3badf3f5954b077c02188a3e9ebcd7b4c1e3d1ca8a7919516be1530a056f850984cf7baf75286b0d775d588c5b8b4881580c18a2f75c596051c27bf95e4a730226d09f292fb5f074e509bbff92c16d557c184e2f247343e733c8b162ea6c8e03105f0e2de95d9f376e3d0c6b276b68dc0a978e5c5c1a3b59a12e680a9544fc0f86912d752618f1984974da4a9144aaccc113148509773537fe57e6db2baa7408cf705eacd3faf0e331b4a65bf96d14364614c0e74de092c5fb258bee2919ef043d13c7ef37137cb9241c04c9ffedc1e884e0dcc43081ba04bba5c274f40fef0ff2bb8e72343f431a723dd9cb2fc2b554ab0ad8a302a6e072096bbc788b95b5071d91d949f09d0fafbca6b1769710c508b2e82aadb72fb99a145cda92b84c2a0f06e5c7bdafa91b8c913107d8347a89ccf591b16825baf9da2cbd8513ad6e040438f3270c7b45b542897d688f75f277f560376fb2170db1038efea956d495410a3137a8628cb7639b018ffcf98c8bee683caae2970b7c9e96e22cf3edb007650fe16ae4d6db37abcdffe7449c15ac8d909c858842c8da2911fb287e5f78a70f0d426516f6d2c52f164f8f88b59194bdf8a00b4e2d8457044c057df10f133b7807be54e02c722f404dccb403f27b01fa216a0030bf0d430d9b68b6b89d3bb6190c1105ae8a37fa80a3d0989240d454088ccf3cd98807749ddab9e26532b473ba0d4d2cd17c3829f79a3d3a9f95b8aa5d17ce7670eced1083aa06f17d949093f7051453699f957508bd6fe0bd28212b8082eba2269cd9e0e7f90644a1cfb3d27c0fc429bc99e026a54b794d7639bc03c6597af62756bcd2a61bd8fa4ba609858e0be4042d3edcb6d6abd675c0f5ff96413461d675dd1ba230fdbdc18ce9f36034070d87bed5f499354481687d1bb4271fac34fe4182775c839c0655c518135e7e089f9f5250bc76db50ea57800682e32808ab735c83c07c39544e63f09d2b3628077a8f99de890a7b797d269edac574bc0e842051c50123cc9899f60bd0c7d1cd05a7077e296d6c943f0075c13231db9328f79ad5264a65d156b962257692018f06c9ffa149a5a5a36181c5987bd44814c0743a7da41ae481cb854ad75dcc589b028ea56199daea7813387a29a18106a68a82dbf0e2921a05d1f711c6b8630d6306 true +check_ring_signature a563fadb663bdb1fc7b5a95891d6df21d0857224adbbaa182248c28cf6ebddb7 3ae3112acafb165e9c3cf4dad6dfad842f789b2e607f56ea19fe8697f0ed2e2f 6 e8517ab255aadda9e2dba728481efc6da4de3cfe0a3c3415d0324e259589749d 90f0f8260dedbeb9acd0dc37863e9337af29bac6bf3918f71e91eef93590e2fc 838d9929cd5af56d4933f955f01122763adcec5fb1dc068eb0210fda57f116c7 4b12cb9f90e4fb2171a56cafa8c711f0657e1199701f80d92a412a8f3cd40207 910c8b45e5275557dcee85d9827f68afe73bfcaf262c55b1c5154d08adf6f79d 7a6f4ccd28fe78cc7fa682093d7de3a0af9cb4273204ee0c1adc16fcac19893b 07913b10b2f6886bfdf4c74efc0b0081c0282736f45c191ff59f3a0e8b8f67f1c2d6bc798d8506ee0a62d6aecc1b68f43e0d60585405dd912072ebc31d85ec0d50589976f95e6bd5cf797c676d4c8af5add088f4a607d91d43d3301fa016850130d5ba6f639074c0f67530e72b0c9c77feefa05baae15ccce131916cd726690f2bc3ecef96a564f52b6b1703df6cdf6075a296d98b962d8c80b3facd7682370f8bb2919f0de70681320b5c819e8b832cca33870d69cf6b7fd2213e157c68d50256641b554d2c475bd5bdd42ce2a0b3955ddd01646ed21f96a31b2462c158890fb7efe88bfd176616fb82a9171965a143e282d320dec6fc0ae4dbf69255857f006faf11a30d8c18d1a0e82168cdbc60206411c90bc129465734705a528f476409e01a52d839e95cf862497b3940c8250d883ae3feace0b98309b1e88b2c79a203dcf447b809dad81d40fd6110412876f5d67742ad44718be5b265c41c2575ba00ac470a2dc0e9188deb6a2c3015a710df318a2cfe996c74ed705564e6bb017502 false +check_ring_signature 492b1a8986dc1a8f04ec434f11e331f3850e7b7b7e7ba7abf31e91095a28820b 472fcb37bc5a082930d8393e6881aa9f5b1cbed4bf95d4b417ff765a07835467 21 0179312deb47757797109ec5c8ff79756e9532a8eb581b36b90cc87401bf8a46 6120a0e06d597403c41e6955e28a2c9bf9450e829c8ab90b4526b1d668adc6d0 6316be06dc04030a9bbfff6ea319282e3b05eab51c75abdc2ae490ab4df4ed2b 2860e20d963fc4439fd1f466704e484d12e5898746ec7d15524b86e05f3c6f5c 96c641e00901085d4436c2ceee06633f97511b2679b49a707e472f74258b339c 23c8bf451d55e0a60f1197f40c2c4fae7d3525d127984a9c037da52393163638 0e328652f226f4e6529e14a6d5da832b8c1df1e699fef3ba01fd61de556866f3 4c8cb77cd74b7d32a8edbd2b05f6b26ae03c203f6b03c2745b711208c6a6b6aa 8b61671282f987461f384d4965c561e62089310e1cda437706acb126c8bbb4b7 0045082967c359f0620bd458f9c0932528e9e1a22477cf05863dbbb272340691 ff713ffe2a1c0c311dceb70daa6a28e95ed7594c676a47c82195eb77d0c11723 e161fc9f0b2ce31a82a183d6751b54b65ed49273b52f4b68079eafbc3c3fa36a 6447fbec0f4ecd8525580e54653c75744c2da36d8829a091d65c20cff160c5c7 b885c6718791c11658133d2672ad901745f20ebe7f384f36bc9f9ecb68ad53a2 171332261895aa6bf4901e9e4930dcd1590f494229691f93ed3fe9cee855ba6a 7669c2c7ff999dfd9a76e8c6ee20404ac6e138a8ba135cce5da3cf1e4f9ec0f3 19e7e40fbabcde1b677ed97ed201c953e2e408fbe197140b25281f32640d2cc1 c3b82ce7def5a47d256fb5350d9f3c8de49ab9ea81a4817558fe0dcc5ade2988 bb2d9c43c0ff8a6e313f29be75e73dcf83d6bfe9d76f2583089e33499f186fa2 1765bc4494dbdac4ab84587effcc1f98f62cfa05319a4fed74012a9cca8c5198 87a9eb5188645badb8490c8a34fa1106cfdfaf84cceef457011b10687d3342e8 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 true +check_ring_signature bfffbc8a8f0210caf8cbf1b206aae28b197fa63e2bb803ec1aca6df446c9c72d f671e9a6b13370f0f5086b2af342842d8768cef2b68b7618c909b7c52893bde2 138 6836071c0c57f9abca490ff690a1c5353031b5581a1ea312ccfa61ecebbb07fc 4393d7d0625b227ea588979e1d3b75353e20e4dd08fa610e37c3509f1329761a edf37a42c26adf7186c67b2f6d6174a5a8b30a29ed17af57a9859f81ee3ac43c ddb63c76035844e8f5338c6d02d4618b5d94c30ee6238ca06485bbc7695d0622 80dc4e7e55bf1783098ae02a2dfc2e0309345fc79ad1cce1de87c22a5db79c8a 3b4bb9659786fc26795a0e4277926139bdb5a4e04f199947e3f59a5967648e08 2d8b7ed15ff8fc042f9ce6e58810866ffe2c38fe4280108c6d2c809ec3afd687 9f186cc6557ce6ae607d4f6f2d86a1c0c4366243234038f4207f09fe44168957 bd9cb62795bea49231df8a15a5d0e9e2fa15fe98c4197800493b09febb00c383 28836e2a2ceabdb9865e21377859af36a0e3352f0479ece41ed7d27aabf9ab69 3af6b297abf3bfcad45bda7da3b596a980417eaedd9a8c789b212b9f5546ce5f 81750241afd54a00605776b347622bfb1e2bd92391ff70f5b77cd2fdb2b62033 dec00c081b1f5efe3f61faa38fa548468d2a05caac0de5b571bb0ffff5f34d3c 226239843e11af4355a10ad37dbae49187a474f77ae038b1a8fc3631c17c3d7c 187f1a2b4704d8594bf5bc5b6b9913658840de04fd93ee7fd7e6d24b82f0000b 08fcc7a773c1faee957228b57e7ac95b9114ecf0d092bd5b0928274a5b321521 e8364e7855cd101063bd89cc40fbaf84ddf58745561aff0bc1a6060f8a6b7777 f7f1f39efce6dc2dfef4ed7a937628973584649f4aa9cd912825a458d7c25f42 2f167630e29e03ed810781da67afc1a3e9b814d13686875958a681a8af09ab8e bec0f8429c85fde34b4dca46223a17f88e7dfb025b44b17a3767952ac789cf62 263c9ea44bea8ee4fd109c9065e752933a9b6454a7504d2d2cee2acaa7a7dcc6 b2628d8d0be67cf31c244855fd002bda9f51dd88c57901e9fd643cf6b10d30c9 59e36485655973551754fc8e40e587b3bec732e438bdcae2931993447289cf3b 06e061fb4a3224cdf0c589259cbd7bddd0a74f0e592813f5b883a8d6b2e79f75 7e0ce27e87e7b47dceaece751c7255d3abf2d363c426ad4a1daa8314ac93a7d3 84a504c740306e648104d06f6e320f57cfbac4e8faf3d3bd48d7aba41a700c4d 1314d3d97e264dc24d6d0b8cf683349c02a7ed6a75206c13386c9462911d773b daf059e58325b36e32db97d98b787ab5d16275a64ede3f617ed255b9307e2fa5 bcb16be8aefd59940c3f179f1b0bde28584e5b3c11cb3d849845e7c995e626f9 ef5e2b0d7539b717fb5878eff2b6bfc4a004c73b243cf7fe942174fb6ef7aebb 11086a8d6cd586a8567c749f66103e0f066c57649e36ba5fc60e4818bec2f3b8 d161cf20ab37b16fa52050567f4f6bc47217b0539acf8b2bcb6ecfbf371e9d92 9a48211f3ed1a27d6a6c98e77f9b2653c8a33db08442c2babd5c4e2aee0f5c65 558cd0a9e417df88c7d6772b850b4167f1c8b93275c271e4eba6e28ef249703d ec7a475fe531cfde0985839815ad34c8b81bf63586f23e71db0e8a7fd2b4896e 7d3a32ce20b31fc254346b0866ca5390cba3960b4c90e2782f3b7df16790a1c7 5bc756299ae1c5f0a76fe4cf5f9f305484f8d8d2c9f543a43f7e371b01765d14 1a54f22aca20ec9ae02b5db7e36f913f9070a86879433cdee7e1d4fcdfbeb43b 6fef5fea36c21a3e4837f098d4466e22a690804163bcf080040358f110b6a7db 0dfd6af495c13629ba583a805af3dab867ff3709f88612e33ca114fff4017814 459634be7fafa0325e429e9b090fbd9f6a98f40c5e5bb6ce95fd4cc9c2ab458b 8ba0e5aa7b70a4ec6b7b2541d8b7e16565eb558a96873e08dfa99b98de1af371 a2373872285e833d1051cb46ae10189d6903362dc83027e0f9cdf2c33968f692 bb60530451dc2a7648851be75bd958e063b4f1544d64b18ec8f5af0ea3dd61c4 9dd859f46d36134b478114f0eabb33dd1d87e5bed77082fd446bc10ec1d2e38a a2901fdaceb4ea755437d02fa36af83136ffcd30667b4395400ec683980f0a23 69516e76022087e44c3f182f855630e19b471d1ecf9ad89eaa1ef6588cfd2a8a 16e4582d6fe02fa13391786145ee8cbd96bcb05cb90462bbe88b6ed3c24d55b3 52b28c842f437be57959c73e71c00d9e99ee2661fe9bbd543ef70313bbd590a6 d601f35f06274b892fca5dbf095052c52b616eeb31f8dc3b5a05890d8fab6490 de7f348e04b97c0f12b424795346d2354111cd6bd0388afab210bc0ac211282a 29ac0f4e2e639f486cb82069d068651bcd155e14128e0d05ee9c15b9ef38d301 37b56865efc11ede20dd9979684c75d10aa18da78970e2ac265cfa5a20094e0c fb1b229e4eb5246eddcc9f0d68f392a933bfc6461caded4abf1f164bcb0b86c3 f8bc9c384e81ab329f1fe3eac1e1666a4b292fc378876fe4cedbbb200cf09d17 5ea7d24a08faa8b6c1a4695cd8c8c26c987e0c7284f743fd4e2c487d9f5ae7c4 34ca3bdd1c36eec1977f3127d06a39a8082820e4bbfd37883ccc6c0da91ef3dd 73ed081422e61f9baac5fbbdf86855e879978830d4c554701ccf0f50ffe0436d 3872d17415c0b2bfcc5f6981ab490533c1bbed7b513c3a317d1ada6926ae09c1 53d3cfd53370df2247a4f81bff5f82aea3ef7c0cf884c8ddf806da668e876de7 737e019ed430614ac97c050100dec804fe428086808f0af643c858753b8bf491 a43d398b13fd566eb17a7d766d8f3bf8d0c429cde09d6097151419d3274f9214 0a85e8f27caf5b31102dac86ee44e5773a14f7610a87686bb793727e573d1db5 645766ddb1d874637ad04155f050d6a2ed45275a576fae5a0070d8b1c9297220 4a5f5a2a9db1c46c3f13cfdae015a3c657db99524c8d7824a7e6c6b29c70f7fd 07e2532396e40adc4aa6066804c24966f8a0a0d64c1854dc55b7311fc2c40592 3ef15a6054b023fe8fbe73ebd6b0344ec636e07e7a15fc1293fd2f17d3f8647b 63e7b977b778ee6ccecc971eaa15cb6f51bbb9938cb6f0c0166a92eed225048b 48eb9fe7240b21081283e0bb8b36cf5aa0a9155c8eb54de6a35f81576f96f389 c93f85f03e427ddacd3dda9a6cab93a647a7c3749804d216c4ee33d96ff3adf4 cc7fc059f816f79d6000b829a35625ea696a80ff65684b0fc172586523c4dd7f 8019bf3508abf3ec59e481fee8cd7f7c06879460fdf0dadd0a02fd56bf5ca96f 2bfa250063d063c31d551df90540c70a63313bebefadd705f0b01b8b50ba7cc2 a56f86db8de47052764da37573cc6d2405477759195efacbe7181c265c1832f3 e0ca2cfa478b0c4ca7cee3fd416b3af2e77c362f13b5b940e5cb375570db1246 f7dd9ac6665d0f4d5b44f5d352cc029bd9295b63e996423ab092122156705421 2593c102c7596a2fd53c0ae20a8be056369dafaa9c15069bf8541cb8a9cbbbfa 65b5e9076d629751ef69c3b9b5b36316ebcce7f745a1de10cff0011ca558f77b 4ff0154fbe2fa74cf8b73f325bb050cd6bc3eda3ea9ec57bad757eca6761d3c7 e378bdb2abe0e69d51e00379b323fcfd6513863883ffa5acb20c8c4a2b7e8b8c 75790992536a0e9c2b5bfb99228ca1bd2f0dd7ee15609b4dc206970c285d8e40 b5dab53752b9562b0f0cc5d01dc54042f1166c55a279949bab4620c851fda823 e388f5a659615ffef809d70ca92cc17c542f7c423fcd81f49684d7de0d5f6623 a9c06bb26937425dd665e0c87662d4cb147d0db232cd184ed3df5d919c56154e 280bf4c9e227b329ba728870767172091b15fb0c04e4d5606c85670f72d67164 c8e858891dffb2b511cd7e447e6e21eb3cde36b608b67e2c339a3e7f73663b95 c77558ffd2477eb69023a66644d92a941f61677b45b6ffa586b47d9aea5175b4 738a3a521664de6fff11ab8fb91e9b978fe72daffcf9f952a6a382cb8d2f4dc4 046568d4d5ab01eb3549eefafe0f142a6d3a7f5bbd54d3a864cc06b0d8850d20 7aa2b6f178efc24f124f94f5c0630546c72c533871c7463f76ca51d59ae2e708 20b0ba7678a965bdf5f15831645a75306db228acd6a5d1cfa512abd70e769017 2207062c96cdca08dda977ce21be783c042a50352b3081434183cd1242d81adf 747dfbfa76e0b36a8486c792b7056a45a41c4f5c4e0f0cb4104c5b3388a7bf56 420f230ca54fc9074b152b6d2ac01aad98c888e99d77395064f5d3c0850d5a6e 0d2c8c152904f1037e783c6fdf453ef41c238fe2a430c801291a220144489c4e b28be4d0298c22377dedf629ab00e04020272ab892654c107a5b0f284cf05762 b555b40a6de85b6401fe0ad333b0d4012f4ae25259631685d2bdc1f4c795624b 2b43384cf7adc16c3f3e7f7be15f384245b04758f9de239c4882adf2518a893b 1e8aa9fe0602a754a920757bcf856e832045792ca71e10194dbde515336211a9 3e2782d44b53be2e187f60bf9e0f0287f4129d48d92c2c28b93de4918e72d0da 60656a0a754b4c88077cdba08ebb6dbd89a3a19e864046efe12f068e43e48fa7 d1d5e7dd307c3ff7336c71d96c64183c6cc0f413ea3aaef822d967ac8ea9275a fb48fb0b8fca342df1626a4259828a48132abf144ea7173c03e95e7f34a6dabb a7c84e0d44b8e93e89899b2282c52d5016a4df21698eddf521f89db3b869c125 78705c8c97491c8000f738e7859e46a1f15e4e54dfffd40ed6f1a74e99a3a841 12addd863645c495f89cc0bc3cc84cc14ab5be17e298fcb688d2951a739f4ccf b0f3c280a46ad81724c2f35da9e1850855c65505fee51d955c6874331c618cd1 f758c1270198020230cb24d6f3a28a8461edda5cc3fbdec32d9fa4afb0c00d89 4e8573cdaa14e17b09543856953d13421beff8bd4fe03c595709114b400cb0bc 4fb9b3c35a570ee93e03e60949fe9c095f21dfcf6a98ae2aa96504705ec2cdd4 807c1d4948555fff4628fa960e865d8d8ed8f4849223ab9d5e209b1a1a67048c f0e79150293d93286abb446faa308597104deb13e1ec27f363ac48f46f40b963 eb39e1de6df29529a63dc4c3677c58adc337227755e874fce17ffd34037da85e 42afa542103eb7a3e6016c24142765c817182be2c2cb6c806f064629ce284a15 f9a9c1bb6ed7a721182101c8bf2eb0c58ec7426893ec38f43a48a362fd2e8474 68aaf7f50ef4477d38799d21ba175410770dbb97a656ffce79ffffdb5ef3dd00 10674794e8666995a59756aa8e596cc1cb05db3362136fddbdeccd197b02f270 ca309701a327f29015219c6777c526cf05c900c71b6e71b621425ada8daf85fc 3eae8ab644b6f83e571b77c9986bc7477b976be1dc6fa77a48a432ba8c449f80 667e2db39bb3c7e2ed3c5c45a7e3a6954c9f567a74045762984c3ab0e834e536 7ce31fa195af0a47708c49c3a159091702cdd21383a81450ad4c4243cd7d3b29 0eebf97047d60bbcc65d65114b7ad59249e07033b03d61053b844d6743bbffb2 17cc06d25dd66c6073dc76b9ddc3f7153d8538259f8e4604077ef25f45015b32 2f0af208fac5626648a464d4134229d2741ceed05062ccd2b06bd1f6f5ce7904 362070de95930c7619e227a3ffe61a0db7c6e311d11bf2d584852a9e661d4521 cdd469d25422a818cc13cf73c34277f494dadde50b96216798c1d1e8d5c5dad6 1a9461bb1720c0273e19d33597aaf0e4dee52a07ad109070ae248086f9d6e61b 907ccba428a489065d842ce35ab7d9d75d5c2e3b96b0da7755ebe7e45962dcc9 09549cde74cb6aa3626d2948dedd54c19eef59946eba028efa85d225d36bc357 d8776ea3a6a9d5579894a0474b90925fe31cc54267af42e35dfb7b4c6ebfaf71 b75117d3ea21b1e8ed785113693b3ff55d2b571787813a08695c4b06db079ae7 42fe322f48758b6bba5f35ce02747964e4b581cb15cb1f0553437f5cc537d55a 3bd42ff5dbb1ee7c2510fb9f1dc811d8ed58ab2bc41fd0f1e9ea3db9dc2a309a 6a356470f66c5ddd364dbfe4f80accbe1a594b65f7406f1266526928a1dbf73b 95b5b77df664d4f21602ae31a661b49df3061d20cd529894f335906a5763733f c57f5d4cebe77eca47775fd31dfa3b3698026a810e7b313039135e080cac5151 72c011776691b517a448573a7901c5b733d3ad83a0b265147e4da79fa61815bd a929875172f278378790bf0ad61a22b47b6c821a669f2a5089c2a202fb9b1564 9aa44f28af3127ce096bf32108ab7fbad5a16030a1de1f4a34912899d1261a06bad3d7d34cb48224abd4276378970a94cf11dfc3e2622cbc12b5b4d89b83b0024a7c3e0486ad7158c403421722cb75ffcf354c2a242d3a46cc3194ff129c4701c10b997e05a672151a1c8b272152efd3abbb8d8a935011855c39f39eedbf820bf541969d8e3215c36bd778a9d722bb5053b9e0d7b7f0acc3ef485137c47af301f5d11bb731d10daf511babe24876f6aecb48056b4e1dc4e073bfc439683f320b0e601e614458e9e1076c72892c1884919c5d8dc16385e73d53df872e24f2ac0a1daaa40f8d8f4ad4364b859f4f588a108ea89cedd973803f2e34e7e71d3eb00f9e57628356ba9feb29b6f17b881e3522e65bba4fe7e4963fcd64d292f26eaa026d1d0198a816d3d5cf66e5d67af3d55787b8bab0a37dde762a7f80a1f95d460f14e69988f04483f01151a4574ce1b1ab0613240822091292c54d91d62d53f307ca4e414c6be62164ffb9230a7b4c18c22be9cc7234e68160afebc3052caef806c617e33b7ded80c9205e1218223f2dd49bad21bc281d5438ed22d0983449d204b11f6bafc63f10962d995a2560a9d651d0b9decda1db0356c999987aab5d0f037f81d58083905bd5479710b858ed2a0dff2cc72804e91fe262bce642b7c2db082394a8f4bcb0d19245fd84fddf6f7bd6b2566de8c3de1378cd6655a5f15f0d0e25af558d63090bced19b303f23e6e4110b7a01c20b6a6291f51608bfcedd5e08a7839a9296f57075e8c243f1d0b12d7dcd9eb7a35a1a77930cda810a8823e100c138ed3c6a3a06e111144c9be9f49bf95beabb15a95ad752b8eac1d9eef2ca04bf5cb8f2b9efabaa5d4daad53aa0e808a36aac1f35e3a9edd087ce7dbd17b40cd4c74c8915d551c0d9b6bae1a11a63aa90c2b5a49067a14f593ae4568a589902a39162a55b81f9b2d2212a57fb5cd3d8fb1979bf9a3f0b63dd474ac5907758081a93acc3979b74f20ab9994da6fe34ec9460bb70c5c1138352844adf69136c029fbf0cfe7def6a81a863a3e0ded1fe3030f4193fab22b58bcdfcca72ac53af0dd17a7254cd655ef7706e40d2eaee8f974adfaa9ed316d42fbceaa69f68558002642f28ee43821d26ab2937a7018acb5ce0bdc07bfe46001a0213d4f2e95a420745706a0a950973be0a89229e8a2d3a81be409e55cbb2234585eab6f0f491830fc164c69ce4c5bb64e2e0d3d98c9caabd3154dda901e38fc5c25238d2120071014de88589993652f446f7ddc75baca47e51822fec8a75891346c689f6cf2e430a2949d41d55a24ead408fb6eb93efdad3f9849e7b17204b112702742e22e162098bdbb0b6330579e8319e92b423ff01fdf825231537397da4dd99c7074617ac03e39b27d031ced80f10ace7599295bbeaa4fd97aabfefb77e8253a37a6812be0711560611ca1dc543569c4c2a1a33474f79b2a93b8d7e81c59c20b4ac28cd6f0e5078940f429b6b79c53368d2ba1b35533246ce48598907fd4aa5c8fa282d120d2f0b6aed33c1e47ddc3b5326493d893d3c67a310f2c6fdd88ddb852106ac2e0d05d0e2371dd6bffbfc339b8af2b6e4a23326ce74e43f16083b58dc4e9136cc06b7438587ce5ffc37bb3258747a9983988048d00f4daff43253eca37fe8a031051bd95c44a4e5f236a111a0a6f41ee48d65f06799179ce637aed75eeb8b24ca0456091a0091d5ccf273d39977c38d33b30a36514cbe9343841926bd786580e00bcdef64d6764b1e682d731924b81c3c6ed877e3fb717212a3368c15e3f0d71308674db0ff866b27fb297ee55c6eb0baa854857691d61e4532b6a5b316cf1e2b0348be18138282e47317b302700c9932eb7b9a267857ef40364c353d9e500be603bc5a73d58af11326a37996f50fce3219e4da23db8a4b26aa3636beda52dd930ee82b0e6bbb00133d2b7e76083a01a1160d169761d015a67c7cbf9313044a3607211522c59658d1b533f5c59f3c7b4e066891b47d28503d0f80feb08a96835a0cdaf2e4dd5b14143cdf455675ebb3b8ead0d100e7c3bed260421b158d8dddd10b85759d13066887e455adc929cd05718958f38aa35c1276d7f0cca500e33220038d093dbce7714048888b5e2a5bd57e0a7ff1cb58c90b35eb8c7af138fc39590bf99078f68efaa09be444db3a91435174b7ae7282a9190776fa723f2ccf9f98032930a994765e2f28f303c7eccddea2f9d9cf4e868c7bcf7dcacae4a162872800b134f8a99ed1a689871849321898c6593e56449be1c64af94d450a7774543b0acdcd7f909b72009c09d1752bb8e9cda30280e79fdec1d37656b24d37252ad309cdcd7ac221d1bb1170eb725f77f2947210828fa68a3f4b8d1d7d24502bb5e60b184ca113665a5dae33991e260633758d4781dd9db0b89a1e288b210d8c45ba01160ee93eb4df4ee69919700e04738ff91e74e8f244b38d42a370afe1c24d0500437c445f3f796658ff4b1ab10c7e3185382f178944f1aaeb722b59735b3a040438b53b71349494daf9126a29e1d2bb9e053725b4bc5e6b5dbbad8d2cf64f6101534e6bac8872e909d37e8b4417eea3bc563a84ea5f76a54bbfa13ccda044b50be537fa030a162de380a6c162269937374b24fa7764b50da1dade3a89691edb00154d8030d7e2a7ed39e9e3b05830ab747999fbb90a294e52a477e4161d2ce4002334da8f97dcfb3ac2644e079c36ca5fd7acb3f830adbf6f5e260a16fbb27e0e7bcf2747d79d68fdafb2def84e5c514ce32aa0bf317633562922ba58e007a603383f76a821116b52f175ec657c777a865bb7fcf23b532fbbeb5b990b15c9c400d1be9ffd463c70e1cd8d3da163779d1b7607eed5ff809eefc67a12836fd73f06e3c8455105407315a94464763402e0e8d17911d86378560943c65cca336fe902aa77cfe22efaf4ebcb31a4bf7d3e47c5acd1d0654b653641cb663d6206122e0c283c93740a4fc6c7a28ae693d4bbd9943b17069b53d5954a5c634f93548bcb0b22e17ff5f2b1520b7748746717c8248ad42e0454c5d042f86bfe7fcd881d860d76247e95c8f087fb6fcfc9a7c457f33f60082358da5c15eb8b8e53b778a2ae017dffc121c83f9ece8be2af72750370a26f95f6481ff8c824e893bd06011fbf008253a5f81b64e0fe516514019fad8dd63d8a2fb58a7f76250e026d36870043000e55115f6ae68ac9ba1020d92156080ce6554b27eb6438aea7276b2311366b0f9a6123a1e35e16611474d4950869810d554f2609653b34127ad6989cf043920408cb1dfbd1e85709ddcf52f987a616b202ff9ac3bbb16e7d9d4a002945a23c0aa25c53fd5614a4eda8cfaecc585bf486c767be0c0580db150cbd324143054a0a933de88e7e0b0a5a6936896ec6bcc055eef65ee3f16d40b0ad35289f00652e0d4840c586a64cebaa096f390b9a58b3513919314e9914b147768a4658dd52040ddab3ba0d9426a514a3c15dc4c89d5cfbc8868586f0379f109c3c06d50d9d2d0396824510177dbd8eea915d2e05b9649b68f409f66172812f62f833d4b80b4405687e41f11be564b13200298bd5897542076cdca7586669417dd035649739b007141773d8ad4eda982e934cd4a35f40f8654358276723df1f940f06d79618300de0d6421285b15ae70fecd0bd4b31bf2ee05d6a7a3886728d38201eb39d84170044004e9d3877154c3cb43f72d9da74e8e7a7971e2da41a3ed070de1bcb546709f977df7fdb4eb56ebf77d28e2705c0982627827bbd06f29c13a286dd560e0702ffff304e637cbc375031e819a8b9a07401ebf18d212e324374788e44a6382a0deeee7447ecb9b90710718039e0a2872bce44ec0f1a112faa3e1e3975475334094c82111a49bfc179f67f96f74603383664c578a97d54678a5d32a6f7173a61024d8214ad543ecf7f855b1f3d4ca6c3b0c131fb8dbc28c3d899f5d5afbc2f4204ceff5141570d95155efcc4f039fca28d4baa3a0ee5e2706357b20b292037b50f8ed8724ae92920528c963246087ab98bfcb2a6f2f4e90bcb7c1186b8ab44000cb1d266395845dc0f2ad7464a9567514d9f4ec889a9de05b0db9eaa92630f600aedd7a12b7df63faede525559e89117b4514faba40474117e38eb0fe3cf242f0a250a4354b22eb4779302ecbfc661bf185b191a19d320c9844bcf49906331e30d1bfe9e5e6a7ce0eaa41ee7afcc1d8e8ad618699b477325935724f5c4764605063cb7b81448872d71fee2bd93d70f84324775c71430d423532543cbc7f4f3c900d9b69bad858c1faf2e33d1d050d6d95f9b96a16b16d82eee8fdf5e9e44f76e0b6601887b2a55d2a756730d136f3a68b2835d4705f130ab34fcc6513dcb589903c97b0448b8f6a9c308d2bbaea67cb01d601cc59068c93b88beac42653dea6a07df3a2f408015eced5d43978d97f7865e8ee44ed093cdf95d39724ef6ee36bb09d3b396ea3418396105730058af821ca5b16aebfee0ea21b35743c77ff049460a913c997ed7fa285af0eab71372c95551ee1926a91b0a61a1271c5113438e9f0d652f3e05ded77fcb952df51a8b66f9345f1f110a83b9f04771312146a1090006e407b6b3491cb5a4708c1138c68b62966aafeacf8d94da7ce96a963db7c4f309cf46404f65fbe82d746bb598e69a73d11355fab29c02d5a4db3b66b819d58f0645c9ed677de944baf08f602bcbf8e0a1c6a92949b0f192cc3c8f25c859e06b06bbe53cd2084db4d5a8b4f1c9ec62682ff4d7feec32d05eaf8d8b7441ee1bd90d8dd766ed1cd7e93e696959839e389189a07f39504f831a4c4d94b33d5c03b4047a36fc7425353948f9e0b2de020ae7b5531ca4088be9d91c0ea584cc2fc46e0c1788e4dcb71e42c0219393ee4836ab533db85a02c0613ca1da60001bd3274a00bb09eb147abfdce95bc861448648142d12b042060fe777f127818f87167428018a92bbc65ea11589de30bb1e645cf7944642fa5aade8ddad0aa0fa806fb7940f047c825c44ceb58be016fc930a3b96135e73cb70f298371995e1d3be19fb72076ec5f16109bdc84824dc5fcf45c7d57ecb017a3b20b4035aaa83dc60fe8d810b5cdfd793807bac6d3d40f26f74c626ac51389a0d9b73bed010f56c4e0705f007ed92ca444cb0c73d6451ed93cb516fde28eac0ced3a7ad2d8622f3e9061651081c9705f6bcaeddd80dec50d2b6d873c1290f23864e9db06e47e171a40403490a19ccb909a9c9349834869df4bba641b3cefbfeee509ef28b6e3f9e4021c60b0ca749cc227352da45c7d43daf678a95cbeb9d5b7982e560636929e298d7fe0800e3fb9d570722273b9a6288b1712b07d55fa00cc10b734b6993e53c51e793740fab439feed7ab145bd2a71f95806d24d0e8f37418f0332ba7382f8e88564a4807e993b24b4571bd3f3d82824de4fd5d0bf0a7b013b58a6a81301490f4555f7108828f701e6dcf84fdfff32eee8d93a06b9d29d9586d17e37308878fa258dcbf0db8b4464a3ff6db70d8b2c2b6168ba3f290671007c83b00f6e51d3f7b27eb8f0de50be9f4d8bb9149c6a9c4d8e6e4d4ce79970bad2299bf41174bfbebeb46750a512cc3dd11b9991133d50ba48e10aa95a06caf3918317ff498c1aebc3ae5a204918d8ed0eb6f1cb53848e85cd257ad74e2282d21b4fbcea35ee5bdc511a4ea024de0c84aaeed204a935c715d11e6494c3487306c00107cb14ffe57e2d316700b12239bde683f5bcc39ebf8efa5e49d027ba4065ba62733a6331430d20393d70ec54e0fe00f30a5471e01a2adb0d4b3635dd20d539f634f91f50b45c7ddd9c902d113e75353d5fd6cc34d5a8859ebbbd120e027be48949453c56b0d0155e9080ec8f721290ea3981e39a5d1d35a3c6a2e7ddd0c7430505ef3153e70f33894d301f463ba27203694d78ff58768bf30ed1885d1396ec5adb161b4407e3e88c990062e49bf19614da65e5201e42cbf6bae651e45376785b7e19c0db85636f13afc04d56f3f351bedd7f484ee03c3a7d5b22e6a2f05fd9620e789e429bda83f648f022be314a1259b6bc1d48b2761b2797bfe72dc7a9fd14bc1b87edda11e9192540177819147d6644a32cb4bf879c081e09c2acf5e5d7bc19cb77e84b6abc7c6940b8aec2ca3611ed0605afab4cc631ab1b182bd10ccf8b3e1517c3a7647e2e4720b71873bb6920a1e9b232b3ecce0ba091132d67bc31567abc0bd5d2e508080bd0b1f20fa621820ec786a815dfd9eba554b9606f4d58722cf868fbf28a37835e307fa0de5d23aff8ccccb216b43b93f72eac54b7f4254c4048bcf2291dbeeb6e50fcf846ce6369eebb444adca7aca016d4178a4ef143c99cd3f523e74834f257d031fdae3eaab9d72078e1ead3800baffd886b8132c5d2ba0f09afb9c293ffdd00b53506af750f312096c75bd31addd11a7fa221fb28583cd0109821bf927af990cda79bfb423ff07ecd9e421e1063572789872535265b818253da3066e152e92048e4bc411a369c9dc6dc3832e38ddb04751cd4c177c0f3b49c867c1473d7fb90cfb4aa30100dc2bdf5838221daa3a6f955f21cb25cc0d40ab9dee603ab167b60ed2d028dfa30e62a400881fe7ea32c64393023f75b203de1de7dfe5c2e5c92402e70c8be8c162d43e91b9180d6b36650d64ba111838e8e2ab381d2baf0eef740aec4036c6fe490da504a075d9b9a60cda5186806749e0b9b82d7d048a44168b0a784697c211a350de03f9cdb95516ba5441076faea5eacf9fe5f0e8eec041f90b7f796b9b9cead92f72552a2a0af0fb5e969d56e74d0e9619dd82cba98134190c1869efeb69a79258de938a2e468c1032f05b971c23f3087de2dbfafe4030fa0fbeb9b637656b93c8cc16269c8876db9a853cb81714ddb07b92c8f4c3a114280bcee34ea776b6074f5d5686354b7917f4c3abd3b2080e3f72b6d6017641218308bd8e60837b3d0e997dd6c243193c074911f2b2c4dae6dc141133204ca27a4008518a521d188549110707927e7c4b803b66163892dc9ab7346d72f5df2f7c2a04c49c4a571d7aaa7f4e6d7a414ee95fbe03d480bb028ae4431182c3b97b356306185865d1cb3afd289a4e03eca8ab7ddb5365fd2e8778fe1aa940343b9579220b65f136f02eee2e62d99eda79121d540ca5f31fa97c65724e90ef8082109b03016f684f7903c673c22ed800d107f21ffd3a104f0fd5e6cf4856229a61f0f1d40b4219fa76cfa55df9a6f66c97c3e51f23b5e60a3e4afc2d904cb9c83891dbb802bbd91b3ff1c81b2b596ec2aabaccfb7e73616824dc871a06a3a870d40e628507e6032c5d6257cb1bafb60a133e8a9bc4b1bac8c82f8314a91f8ccd21cb8b5308b0297a9be0330c2b9ec88f21d6610d5a48f827b477ac1ffb508499fdb6ab550170ba8cc51ea16c06ae96474778307de2cf6703e5623ff3d9aecdc3dcec7157011b94d6988f2b00d64a6993cceb81643398c78a277aaafdcda1faa97b4355b70bd40932cce0c9a3a7d43932041b488786491e94e15392d2790db050414e5bc80621070623c9d65cb18589e51b849d40cb1b561a206b60b475955e0d9e207c040e4f2f100a677b90dace6746343a438fe30f2538a9c8d235c293e747b539d4d504ffc12c24a6fa1a289298a1a1c88596cb01726128f24928d109a9aa92e02f690ff7f54869dc09e0b59292ab84911f5bc4fbe9befb7d3289319094dfec09bef100156f0f9a4a91f92f0f9a5ee384c834dc152704b72fe4c5b99bccac3cdb07ac07a3b2e8f6be737930d951e07cb5d659a0c806c8407b434f739c82a40252cc0407fbd896664c1439821f42a54b6092a2d912bc8c97efa6704a314af61c0b2dbc0e99d32349d0ac6c917768273345298c2b042f81c8764695a8e3e8b9d07fe86c01ab8260cfddd3df6e36a3737ecb815f0a601394c27ad7c4c3c1cd5b017b2f320b4ac3096de7c07e399d54972e7e1e0828704d68ff134c2c1ac41dda183329850080f22bf6c9b58d2aa8ea92cf4092d01d48a352a82afeea09d90ce99245e0f70ad85a831f179336c802580987484b78ca32a50f3790bb56c34ae84f2970e59309679272f759f8e69da1c6b3a557667fba2155b2d7d5aa1faa481821c1cbe6000a42d549422c819d8a043c87f793984205da1ac774f0f9b9aca9a36e41774d91010c3ba97a0ee158ec2874d0c0b080ffb8e70bd17ddb18abf51d672dd1503ec503ab2ea3285b1d57be09394ac97fb10a22528da15c3c46833cd0c9c52c0a41a10ef327609c27d18991d2f0852e7da316f773fa1ab646e1cba53daec880d6c5d20c86e177aabde941077879c24c90f6bcff998edc31b6cba9a38bc5aa3e5583a10bc3d79c773b690b9d59770b6eeabb438f72c867819f7b29ae396ea259cd45cf0f7f70fa1ecf69feabc05d52f1f4caa45312cec7b507f602c29233c3b5fe28000cc70e761e6fffb9693182cce6704994d5b24c2e9bfa0b376c5a8d220871c7c10284901c81bf6b32f133f4b200607454a515a7324e7ec8a2760e8b087f2fd4ad025f933146d81650395d9e03a42774f53845e6bb07cdef39aa4de99068b73dc9093f15276c7e6dbdd3acca7db0847f044f560362e6c4d1ba34b42c1157de63f30b55aaaa0dcef77ca435b49b6efe3446a68932aa3e35bf26da93290136d62c0a0b57380a33490fdcaff7ae62f030476da0915a2676f793b765ebd43f34ee2cea011ab7709739cd70ab883e4f8bebcd8ed02b58a8344de1d087d7e6ecb5c38ed80479e57e207e1e26eaed7c7aa400c4cf2d0a7693cc667205ce87ada89fdb2bf20da3e973481e69d77652959dce88c27dbaf2a754adf73faff115714de61cd28000524efe0c72ff2583c993328e130be2385311a26d859a72878005e7ebd5993005250c3034dffbce2bdc0fceb082d4efc874a4274fab4437846ecc85e1239d490279b561a7966ee9fbd50fac39047f79213818ae57593957c1f05c14d0f7b7bb0779043999e3df6ff2556e16ab2083b085c8093f3f917ee87dbcfea4df95381f03cbf56f69eb9448cfd8f6ee76d6c549fb1f624b7828dd91254419f5d55c5eda01942b96e071105f9a3d9a680308ba7e9d030008220d5c85d96f2e45ccaedb2905767a1e2dd7a5672283c16ebc3464381a409eae4152b5dfd3b58b654ecfe9a204643b78a19daf175efe95a171429e3ac97bc5c78e10a00a8082aea36ad1acab09ea0813f36c088b90474a6f7e9ac0f113ac1d76b69851a5b57c76b9a2264fd60a503d398fd8281db00f2c0f0611322c40c163190558c8675c595a4f20655a750ff3928bb8d4d71dbcd352db5ad183eab13494c4ca4e3d2bc1362a642989f6bf0df6f5bf80339e42749d808d6cbe156648fa4e34baefb73cf2b8a7bd36bd48330f3a9beca132ae4cb23de1ae12cd0a80cd5e5c4a5f0ac9b5f7f967edbe5aaebb03502cb7122550d93c2c5f858c4a65f3ce49eb5626ad0902032164e31c6ad2920f1df5f78ece4bb673ec30943ca87f3d5ce59d77faf4f0d380411d90d27bcb0c05339518e0ba0fe2a24dced08cbe138baba1cb916035d209e3bf93eb1598765a061c60c74576c6e4fc6a7a941e7971a906d7711314af34dd17fb84feb9565a5209c1877649429275f77f7d7f31ce2908af35da7a25da96383e35699c32d80c7808221e7e748f5452123f835e9f86adc60fbb15b2941564929bc621fcc630cda60b98360c7dc9d6098804004988d111f385749aefce1d4e456800d93ee7e0f2a10fc62bfd991132f54fe3c8e2c14a631d7d93e960628756eb43ba506c83049abf01a135a99bae53dd8a03237d8e1e5ecfd12d84c06623a905018a8bca74f5522b0080249a2ae424f39bb269725791ae9f1dc3a4f2b391709265ef62d9b36e8db30d443ad4006c7f18e2dba1a5275559a68f9b638eb3ebfaeb287589f034be2ae80d4c618988df4c40e5b16cd8516b6d1df38fe590a7cc881bc0e232231b63d80f04101ff0a0ebe9490fdab6f4ebb3d1bc976030656649b9b506ed7ae22842186807e809616f0b4b1094813da644aa40627096edff6ca6773d052b973a41fecba30381083efd0de0ca8dac31817e05e90f12c93bf631e8e6e27ec9fd12862847bf0d50f1ad4b71f98f364ebc43ed1456096b682a571201d7434442daf3081e1ac108d6620e8c1c8e3287730e2e31447bfcb6ad555ece7ac53d414fb2832e43c74f03a4047b682166a4dd642521ca22f2b2feeccda9d1dba731852478d96fca964a00967424e2fe298df4b70e1a414b566edf43391e2ba47f7cae2ccf3210eebbe60ad8c45f24053415e8b2bf5326a97e9d00664928393b3747d310ed76c04243eb0e1b2a9f64965ec8d565c319d5bc62189b9a807a547abbb44a2704519af38455019eedae1b26fd90f2d716aff20d9c305b9d839dd6dca7cade399fcfcbd0434109a85a4315ea018ac532ca7b9dca3aaacd5520ca82acc95789bfef18f848e62619a6f6eacaa04784fd63ee6210fa66e58b19e97bd62ff84ee593baa345da79830832bfbe31efccd8ee96db4d1d3c2e664943626f22e7bc85deea1b1765e85a0302286c6322e2f76bba5c94de0e4ee7e14607e355a0e32efc5021918d9d0e162a0ac0aab3b9b87379e8952db70b9f3bd6ab1f6da97b1c2b38e2c469e594f2d9e00474a8daec5898397ceb38d4e5abd0f03188f2ae9f9ed69dbf5b7ee7925cb5c20ab4ebd238a1ef14538a3278272b358f99b36c9e334158eb0de5ad019793b97905c8c8eaeb088c882293abbfa6ea94af4b6539bc2e445a31236a82caaf8dee4b0720d1df59d7a3d631ed905078964ad91c76a177fb5f666550f110b9671649a100e87fc7c8d5429a0ecd2b88f7b441ad467feb043eda681a39742dda370697d2007a320d906c0796619a69c5454dd795f42faca55cd8479298a1e00c907275eec58f8afd71880ebba6c7831b5e275d978aabeb41f48f32cd5215cbc0bef600a5031725c20224454537e5e96770e99a323d7e5fee9813d05e02a04aecff835ddf0a2dc63e4018a6ea4944ae18a2c51cf11eadb0157a77c1f696fd6a9f22df91980c5828ff490d42ceff700bbe181432ad707e0f64693c857eeb647f7e8d9d812906997075583efe51a722820d9f8f457e8ca7678d4de6efe3ae61ca84a0c679710893ea4dc2004e94eceec8f609929348533fda12d04e32bad8a2dc8e46c186fe0370d2a9a0f44977e93fedb2661d5ec16bfd7e483a13e96a4aee10cee422339109400bdf7a2649581bdb41369dcf5c68ded214fbac1eb8ba3de6e79d44594946025780bbb227a38e67fe08d980a50ec2b5378b6ec04ce4c0143efd679eda5ae10d77f95cc5ecc5ac6092ef9ca992386424d9f43e1e288a43f1fa06ace472a9270e9bfc112558fff7652df23dbdf3c608d69548589555b8ea99080ef364c2d6820e4c4ec1e1253c86deb1c7754f7ebe7231c2e5597ce44aa7c077737e1582671e05ce9df94a47751e2fe362d1675a947b79b35065992a9760d3726166e33cfe9c06800b1a732d5a233d15f2300bdbc03db8e227b24fae18a829ca3defedef0b7b0357863ad3354d7b048df4e2469589c5e307edcad237470889714b43b0c1d5750158379f6618f159922b98974ca382af88083ee359dcefaa818d709817e22ca800505ca109148c3fb0e11e3461eaf696cf8148b915c6373f2d21cedfdc30f2fd0bf5d101fd6a5fbab74618e8c0934973f9e90fe0677b309080e1e01813ee0b060e8c88e4a5a3db824ee17723a2d00e7794cdff3349f9afc7c0dc27e19ca06bee0ed83cf8053e4b9e89ef013cb1a6fdb2f1219495f7e44bae917f7f0400610e800e2113d1020d8d491898bbda7c37915981071ddd31afe0cb2dd5be6838ce79f007a17e939864fd2332819a7cfe20c5a81e42a789dc596cc8b7b7ba255d8e734706bcb9e3e236d981d3aa618452777c413f1031bdbfeb39df2132f86b1d405eed08a685f1dba59a30b6e2534fc3df83dfd3deda412a181180dde1ac4f7838b85c0ebbea9dbf9485e583a377682a4393b7228adc7e5d6fbca798d42d7b7f99a7d10aff0786b0ea419a16f22a5c43d3b449a0bff8d9e62ffd3569badbd74531e5360d7d44791eac20b28f9aa858a58ac15e9e4aee0b4955f57b0c98ce7952a534570b033e3023f57f6771eb67e28e9683f490398900cbe6134e523a6e747f2528c6082f32181946df5f92b81f31abea002c39cb6acc9b1dd0d49bcfb3d524a4c7fe0ff49d84826b5b3d537b71152cbbf7feea5a2d475c8ed0f56003be7201d269f609ff8718ae2d182ad80b7ea798d91210dcbaae99549d2b4ca025e9085b9395ad0330671f791dacf3b0c6e6a621404c680c8ee5fec1197312fe0e72367416d91904e11abbec4643a001ffc2da22f77012f0a5bfaa2623de2037f72be1df8a389409c33b0613bbc2318c9c2b449cbcac9247fb9aaf6b354bb87054750a01555cc004 false +check_ring_signature 545219d0c68d651af80088d02ac62e873637a78e6f8708116225af2334029243 6fd28c557a10651b3bc14ab85804f37b12664a8375e21907bec0aebc37d957ae 14 844a93cb099d1c10fcef404c7599bb65553917247bb7d210d282bab09871fced a671f572bb3c840b723b37500b6d43fbfc592b0c5551951ce496d80659e9bd56 91c5b0f30cab457d5e605720ede636be0f3c762ba9a796c8f6b71f7dc231d835 8bd6c3fa9cc4560d8a4d624a83944db195ca03238082cb885e7cf204785a22db ea0d206a0bee20e96a8537c74036929b973f025e2052ffec58ca88f47f60ca5c 96dbb90a6add884f299f315fe5d4936135a99fc0112f32d8508f7c762d81c678 9517db2276363dbfdbf71fda57fbd24c88c248b7ae00dbd2882e3ce2e36a27ce cb24079fcce599179f226527221331985e9f12a6a2e8252179fc70988ddf1b42 132712be6f3a8620b8c3dd175bbe2cd605574756969e2ba10e42741501b26c36 33d4248399966145ad00b3019491df8cd4abe76d0630bdf3b38f3313b0623bc2 bd7a23c67bddbce38f3a21d61647a6d714d5c15507502861bd1eb51ca1b5f5df fa3acc640801905876d1fd09da80668150de7870698db8798ef86a2a7855b1a7 5aed7e9f711d31401f1c29726e2636be928a6811ae1eb867b02235b9519f7ef8 7e0eef2a09ae92ffe2b8fea3c1e5e209a10776d2aea1a1683814327090936371 d5c50e236f505b97587b46e342653ffedcffb47832b306249a90bcb3c31bf102fc01471e2a04c759f28fb9aed9b8923c847564329beb5b65fb50e22ffbff080a0bdf0aaa78691a95785f36142b6b492e6d5287979d8a09539359a4ee2667d80a2f7374d81ab4f803c27854efd71d2ff92de27695d78511e51166433f51b33d07c407525d0d0ac58af149b1faa9737bc428bae26b2089f9215797b91e9f618f0d94f642dd8e3dd471271e42e360a933265221a981d60e16ad1920e19bea2cc903ac2a8e2f728c4bf9bb4d2c05fa559d267460e5f7660ed782987839316d094e00110ece9f32a67dbbb3a6c64229947a2cfab0d70824ed403f0d94a09c2ae65c0d8972fd343dea20eb624863bc21517d0f405b38e48fa81e03d50b2c713683a60bc6e5a889a4dc68f674086a4174267c2bf52626c63a972f4a8aa8b461d668f90567e580d6c65c7b2780e96dba35c2bca515b801c97bb83077c8618a08ada7e40349d0dcd483f66401a4bfcbb6ac72dcb216c4b8e86f31f8412182d121103fa308f834c05a581ccae7c28f638d0615d1255d2da90926905de960384980844bda01357949e0c75cb4ca314bb3b891a7a4fdbdfb921fa7ff800e602b4a4982839907368ec712775b99354bece5feb4c85d880234e38d4f6c63937f60a2da51ae970e93f72d3eac1ea23ce49e9a06edb9d404b8666c6a69c57c0183485cc3cb3b1b0cae257249c275649ce622785cb3761d9ed40ac14df14847a477a698eeab32be0df5336cdb399cb4d1b81e6e2d1facba70254a89bf18fe99c2deb4dd6dc141f90dbff3b6fc51408a293c11e8ac01ce34fb73cc0b27ce0ee33f76fa2e15df36340a6e5de7b37682ce8bb8f8388a343ca3c1081f784765f45549a643e9c828c5840ea9a78043c0a9c1f3b4a2df30810ef47c6194f35c8ade263ea03f34c71d992e0cbaaed0365176276a6a263053053038b2506aff201c5a56921bfec5709c5f5d0d3e6011787cb18f8d072fa8ccbee794ade87330d79df58e0c161de56cb29d7f031ec5376a8fc213772da33436ca09c9048d8910fd71ccca6890a1ec6c25d21c0874d93febe7375b2e4f5e6b659a9ac8f766e0a1194eb72d7d8d061138e126d3032b3a9c8180e884026651b529484cbaa49adb385037934cac12b99ec8eb1f6404f07fa14f5ec214b7cae8361b135f38d6b4d6b8e4defaaec60d798962d36f420b079862320652bc0359acc1ed7f2d2e388a8343f37231d689c6e612b347830009 true +check_ring_signature e67339d0d8bc7565dd6c3048229adb6e57744120d461e31a3bdb1c7bd18f8224 50d28889a61d97a1dc8eb0e454a250171484017cb911b54485f38732775cabf8 5 4335fe62f1284dcca60fbb2f003d1bddd1db1e48fb83c01e5c7eb4ef59941c68 c1ff9130073a08d6c2dad1a16f27d1d3fea1f9fe17294b722b85e136664f1857 f221f15acc0f9d250f0665c6ab14df83d74b99d2377aa206dd5f86f2f794fe3f 65799e40da674629148aae4f494543d177ba2edc7f1e2ecd17b4a42780e8f332 e56658729412b38f96c69555159c39e942251608edcd73f5ca550cb55a34df7a f1bf509737584a29d4f30e589ac601123e66d3ba132b2e74e918eeec019bae0ca2dabc8211af101a1603014b640b0d0dd05f98e62aba027b8e6c680f62c9e4016dfad8fe19b1a5bf4d4559c777cf2646f79c82b22c52c7df5905448c1bc4150cb0e5020320fa83a812520be9f50b2dff2b868a00bf33324c86e7740743cd32082577c39e39aea2d7dabec174722040cab675a21da16e4ee4d05d29eefb5a900bd6ea942cc75483f9550846f3f2a8b48b4f2f753b0606976d36485c22c1c0a50a9f277b0c81d676ff63a8a40dadd660ce8026486d0fb69158aecaae29f890940b05267545277668205b5759b48a46c6a1c9646cf30e28db0dedf73e136a785a0d2c9fe257d6df53cbfb84e806035accdddcb00f22e410ff630f5417325ccae50835a18f64cdb28e07d58a89e42b01d0591dd207fc6efe455e750f031f3be47208 true +check_ring_signature 0c94358ca3d10eca60e65db3109b81655cf9d92f462881803e04c1deeae318cf ff8581b5972bc075dab40132cc6ac15496543f8b3f622693b1bb6c17bac87a4d 69 31909a1b71c9f5794ed4fe1a112ce645c12e2973e6e6184fbed34f77c9c00100 db4af36f6c9eccb8faf62a2591c605fd87e330f04c9e954f6ed73bdff108c6df 5ef9b4744dd990c8bf408f1dd6122e14a32efca7b64c4f98636a620512e76b95 e59929eb918fc2a3d2c2b51934c19acff55652f0567a1f84933f59703c8d0826 ff1777b824b1c80e6f309166673c917114aebaa769992e71d38c19fbc13ae017 ed450c4bb03eb811927bc9c0c567b72a56a642f7d07b1a66864eca04b3251c18 efcbb2631c90e69c58eb5170a8c8d50c0c710849b5c3ba7de19d45f5c64d299e 95379b033f835081b8c533de8b9e73b60c245382b1443c8e184a9e3f18357746 2f164bec2ecb15e26d5173516926a8dccf35472b7ebdb77a70d0787f7117b6ed ec58042570c9f20310eae82f3d059cef322c9fb4ad49fae6b6e887c9cc6caa69 629fef988b779e1b872665c14d8dff4e2b4515df70d5f223140eb28e46150220 50cadb9071e09db699ff13032bde1f94b392920bb0e107b425aa0848b08582cc 50f04b5e17754a5543f912c1bd1e2e21fbd3194050e043f34f1ae93f8d1462c8 f2778f8a2f2eb0572f44e1023b836934b6e012dee0386b4bbcc64e6049a542ed 258de5dac4ecf47422ee72c940ee0d1f74d343d6802b4e03ea19a1c0596d184c 65fd0a4fc2529ee06da3dd4818338d15db70b37b3f0a777b25a9fa2902bd2374 0913cbee2f6b9362b11c8d4931e01e0f0d1a3423f6f981b717b95f96cc24c31a 87d1975f8eee648a35849280fe5b53667dc76a4f565f861930d20ddb3f9ccb8e 02e9bbc02c96c9e879258a68a37019e5788bac4a13eb600d47052293fce44319 2d67513f7bb121878175ecfbe613f73c8ad2d709d1a637a7c71f6f748c77f48f cdd60870f756ac9585ff4ea6c002beccaea1aa08b795bec7d101f0ae2196d1c7 88dff1f0a2f3fe5f8688ad5b006005ae03d32e692d3352839c8834fa9fc4e8c4 befa632685a305570a04f6e1d2ce164706bcd6ba0a82894e82eed2685a327457 038ddce92cc99d0fc2e085a6354e9e105156a55870d579ec80535916af3bd16e 590d484b474fa9ea8b3a1657f39da64385cb9cd54f5e64d8c7bcb48649ef463f b54e6cc23c29a2d884e7070babd89693ef6856eb80b49ebfc9fc1470664c63cb 48491ab9cc7ca0996deae2b8c96ed2c4485fd7cb95e213815d7cd6aebbcf5622 a056738b1646475aa77b9d26a3f3f166e1de86d5171909d3c526e5d38aa61f58 299be0db3d84924e003071ea5ef782920365e664cd2929871fedd5a7435cd5a0 52c5116ae8d7d6dfe24d8aa951be524000043cf494583c4b488031df76183f21 4cd0716c13e64f2cdf64dc70b7861581c73ea5a32f9e746a0f5d8284f0386002 b53dc32ece76e23e5373e9b56566fe6afa3835e5db495b7106ecaf01cab9699f 67e4b28542296c3ba458b1acb388e6a02b245c1dbe271ec18c9fc410992e3590 5983153a5a088964c44572690a9f5769614d8fa8c9e5df385a4ccfde0c1f579a bc2654881d7b19bfe8bb74b9c77563de6c019f5ec346386a57f169fff3033637 efb237c870ee0248ddef5b4a332ff5064bb0fa9d99ff584c3d82b22dd2d1f419 8273daaa8413410da179bb68412d03244fc11bd60d19ce58403f6c375249d21b d91819ec0668dfae01dfd1b5e32e71f90a675e780f69981882b0cc8a1d5ac04e 6da9d37bf380b17705280776974f70077b8ad99aee587b41643dc58753526cb8 2756947df9911492bc11439d69edccd841a343c99b10cd973d46bc82bb152353 bb4db2da9ffce317e396877c8eaf1a50300caf82ff39bdfe57ba58a0fbac3893 ba837f07319727546f33cad97622f6aa35c3baaf267544bc300d1a17d0d5eac5 d0496280bb45d6df56504ae8efd3d4887a8d22fe21af9108f579aff4bb22be40 b347f23959769a944a908fa6ece787f5aa6b9e3ebf1d3945d49125a86a41c3d8 51783e8220240e150b79e26de70a875b0b8e7a8181d2ad12afbc0bfc5823de56 205f04c414fba66d16098a47a334e2104feda92c02f04f8b26e2e6e4f22299aa e98150f5ccc879349553572cc65ac165a90b4ef87d53afee4b182b4df769ddc1 252ca5a40da23f550303c8aac223ba42bf2d272e2dfe47479c640f8662bfdd06 365d809f9fc50d90ff1b3c2eeb120e58a6f68d1505a581d288c44dab00d7a3b1 4b1a437f0a636a510236fae78303bb7885f2fbf1f465a606ab9b697502748132 401ad80ad0eed631a3ba2b63feaa030eb719aa1884cc4fab5c7bf69694e4cef1 31c8c5a07a8adb25a2950896c0f5c902d783cb520b4fb00d3af8bea7af627881 18525f55a014c2c9e3e675d35ad694fc961420c43fe046b9c315528c462ca6c2 f966643b224950f51ef29210813f30411e54d95402f86cde15ef27234f086b0c 3b6cb7bf9cecc9ead1017b3da3654a575e536f52760d8250e3171b96464a7919 64efd0f6a3de198ce1bc366a5ace0c864e289ba81c449cb1c61e74c7080bf9c8 f8fc9db523cecee4c37f214568e03070bd0a55f617ee209c5934e9a51a2e8927 12b80cb2050a04bab27674e607f321dd1c61c0dba3cb473955b87a5ef834a9b3 38b8a90dca8be962d974c45cba51a56fd858628a475fc26236aaa4bb7407bed7 28d800c2c12a138db89ebf397c60ed129f6387bf0166bb023196aadbb1b40ea2 bf9986f12f2abfc4e4f8f985a7e661712eba466b978d1e0e88a83bff74a4926b 36a3622c7e4bb43b5045963877e5b996b4271c0149d39c017ba08f9ec73569c4 97ba39de9ccd31172ee2cc868cba5a4f1f6060c1d3fa53d1bc71f2561ed5061d 5445f7d57b1b235612b7985ff0713243e1c0c3999825521d1633a0ebb101339b 45e034d403f731f9ffa3ab78517074f22f19ffc0690f634a3a033003d6945a5a 72a7bb215bc848990a4e92a5abfb79cda2dc92ea1985fa031672a4cd2b546dc0 1bbacb8af85fbf864204e175cf85bb54b52e11a1d13ec2361d5ac98b0577606e 83399f34f3034795a8d6b0f7b6de1f3a8289305ea5a219385bb0c2c94852770d b24d324ae954c55808201a8ac4051e33c6fb0ce5cb4f61af47e71b9b7e69209b 6889dac9a153cbca3e8ac693bf458e339a45150613270a231feb4833afd4e709176df5760c0ee8fef7c7967ff6e519b86428ce955b34ffaeb37355d6c90a9403afbd7c7c757871f2414bcb3e82218239d365364a48ed0007fd8e6463a10f250c9a1307d40da9bda121807022003a299d6379603b3afac763652118d33065940df9d83dd2bdffbaac90875d5847a721bc0969787a004b6d4ae661ea28ab59e00b6ff32603583a3e786e7e9b0b7c88b0c638d9db5902ca8ddfc0a60ab10e9b8106c499f1ad03580bda9956daf27f3ed3e1dc592fd2883f1ea4256b53ae285deb0ddaeded56110766dc8d5240d5e1b31b1baa870555f18b89f586dc3e710a08130cb2a9030eec9538ec79b38b63bb427e44458d6113c5a0314b6f0790b94173100568c0c3a36a2d9e0f7f3e2b44c8c9ec75fafa7a961bc34fe445017174f3aabb0460ecb1952ad0d3ce9b929077b11c20624c112bb1293713953418508c140097053f40c143df72789a5f68b669068c4bfaa63dbb7988635387454a8978e74ca30a9a094599cba91606f67978bd9f4406092ecceba36f1bb24be0602261bfbecc0dd5a8cbaa3a9929e4ccf46d4cecdfefcda094662373b9c4adeda647799f7ce102ab664f51e7a21ffee3eff304cb135ad3b4ff30772d9fc77a5f6c27efe016de093e8c04b20b14b0379abc52c334905aa5f606738ecea9c3810db538fefc2f8d068cc6a94330ab26565a67c92cb1efb4f8972b78c44e511775c3b12b596d60940d05c03f2b4598325d05ce1c00ccf9d71b3abb02ad2d3d84639f02e37fd3fc9a098ac0f9e5d4faf477ad1902e0db7e191e844fae8b500925d61a28411a21f8020160ae39ba10d5ea7d98e2fc6bc483a63779f1409ec95f652d71c6024f2974f003f391c87a1f3148a6c3de2129c2b41a3554b66f075cf29615451f0f0df4a96d06666a43a4cf1573adcdce72278a887e6121722835e51463f1764c26aed8095e050d25f69643990db253a871252dcc79cac498dd8888cae7c78561bc46cf504406eb0fd08db173fbb68bf4ab09edf2835742433a167adeacc48b438e412ffd710467854c7fd36ebdadf3c1696dbea333f412a39100a123ae2f3d1006e015c8370089d3475497c51937c903049e12578d12a674c66653f02049c6bf487e08a6fb094bb940bb055e1e457ad1c6ecd0d8f3b284c1337de379088fa4e3dd6450f8cd002152e3518310e61db62fa29ba1f07788a2366a52a47f824c4f2412548258810c03d0dd464701d0805b3d609eb735bb6014ce374b8ba6234cf30073ebf4db5a0af945df0f5b3a39f6593621f94c3cbf6196349986baa7e50e60f67cb8465a7e0978c958d6edf0109c7466b1c937d884c9000d9e296bb6451bfacf2f2a1e762d05e1d523a68bf3fece5d453191310f721fa937502ec41ac452f376bb599e06f90c04f05b5104ab5447f68699b424ddefb9de2480defaa181419ec79c14362e9702477078d5b108922927e6778f2e1c681b441830eecd61642ecd31d54e4dbb1f0a6e16126048f6b482b258900ea36457f31e351bf5da1766d2b6f87299c922e20d00954308922671b4c1b8dc8601604d3e822ed6910fb7b97929976f29445b5f067e45fc8cc05210e9754b5323feae933b2990b1847acbdf253ab7ccf38b8076052c75afd746bc6d1ba51ad637dafa6b808e3fcffbf52c195658dc528d5ebf450c6b2149036af555e9de7e48c1736dd7266abae4821b7c189a76ddbd135168b307725cdb81c464b7959a333b5248f0f70ad4279dc7ffe073d819882c90fb5ff3047f64940080bd0f37f7079570b0982c027e538615eedd8a2da527a62ed18cb00642468567889fe4da2645f60e39e94bf71edca5ca26760d731d0e3fdb9f0caa07f81c1572a7146415118c1c937c0f8b69b64c8d484d49333686ad248465e7c303845374a3eea39c58e729144cdd04f9a13b4f43a24ad722ff8b83163f2af5750843a599f44e3d608cfb2c32e779a65e8e37154c2705c80cdd5ea009e2bb0e810102bbb2ed9c019fb0ae789ccd7ce0c71b2ec1e9bf0187c4f156fa123a6dfc510c6b4490e1feee628073c30f525cb689735d1ee99c9e18e4f92318adb91aad510ff99c57098506af189fea1b8036aa126d87000e9442990237037b782b4d0cf207c6470bcf40b0f37fde3da91401b53e94ec7bd65e3e5e5abd9225ce414703f60de54e742ab266b07c59a02a1b3f19a3d91467cc3e1e2950326dd7ea4bcd006d04fddef54cca11c03beb434d51b938b38a2573477e9688143b4a1d7dcc13ced005caf6aa273e0cd2658052e09b936ad0a576be98d8bc8a4aed37e15965adb88b08e73e4b2a61f1f5575c17f11004529faef897855d5f62f14d42c717200649b705a99234f3fcb87520f491cda1e684a5d1c54328c793bd542cf90a6901f3c77100e94ce2a6a298e9dfebb4f26b48599925aef4d3a9a69e149838f0215aaf0af503756218546d585a6be0eaa5e96231668f6bcbaa10d3f9217f90982a8f0e879909158b161715b0ab2ec6f62178eece677ebad0e1c512f4d1945405424d446fc2091325a260a3ef6b7c2cb0d9e6c2e5f4c77f21753bca5ce23e1f371a62d80a8c04732c5192426aad8e304d74d0ecb47039c2666487546ea8726f97903619114e0701ef144dc7a615f20b3e5cd3b499eae269e17f06c16194b90b22a54bfa1a9b0099631218ed3bd0877fd8d3b9d23ef1bb82fe526f541c6ff80c29ea0d885048071864998c1f7595b04b2c52ae9cb5010e654c0f0281eeb8e6493aaf1a5ad1a90d2521d1e3d02e64cbf57058525b039c923d66123699132372c1c92f7dbbfa130a19d50e67fa7170a369c31fd41b93c58802c838c31376b8e17cbc197c61a66806234e6b2ec42bc4598fa429ee4123af54b4539e5f7f59cc9133bf5d58fd90850785f7c41df458f69ae0c90a7548ec63a750ffb8a14ccab080a8aa4e40cbb68004734b05a1625086cd129b0baff004f5414ce4cfbc310914871589de960baf7703fb5c2931c5de9153ad1c6a0fa292c55ec09a42591ca70d2ec96fbfa8f4ead30198fe5fa011f94faf3f13a371f9b8a92a0f7dcc0c236a154f6706d93fa7409f0b6f601b081d3be0af9761f8b22c1305544037ac28b6548b5150c08283fad1e70c89876630a6ecf77e4330f9aeecd7d85ce35fb2534a663151e138750f7b91810cf03004ea2d24ae0c26d7cbd21865b48127a1a8149c24d93e386a1e7a38749f0b275bad38fab7ac4c53ceed6914778c169cfbb45bff7ba985ba4c7151c884ee01ebe4a4030e8e2bcc8eeba9c5f4d0298f286f4719419193cff92707617112fb0ec9290e214c88bf229b1efe80ec2003e28caeeb28c090b6754ed50e31aaee8309724ea9c37283284d9c81d5b5ed0dedc3ddd632da9e6e3667841ca4f91e436f0c936e8f5f0701c6336a10232723a5d5ab270856959d409aba3a90a13012768305a0e93d2f3c6a36265fc466c55acc69b1adb1e5573b8196b1ca34bcbd50177c07277d5e2f4992f1ddbf641f5935801e2b36cba0a5786db858a73b160ebc88ed05d6a0664015b8a817d1573e578a41ea825091e540fd7e61bf0e2aabe1de49880a88797aa96f446684003c5370f20fedcd9d842c0d9d17381db9ef1b5717944b070cf2764029568391c806b1152d1f8f6fdb85bb48122e5d49f62fb8bc38614d01208b3f459ca47a73172d70dca5f8f8a22421e7569a2481239ef4eee4931f260ba45fec4dae9b9511b4d61e30a31a7093c40294bb1f7e5ae8eb33535f6aa33e0e3bc359f451a38af80453508a4ce48e853f2b13e1b7f80eafb978e49f56d4aa0147d50e79f5483d13309b29aa41cf9f30af4995b5ad469a8042f0444fb85127048efe60fedefd4fb89f02bcc07d5899932410dfecac1d3d0fc305d5bb298a780d873e66c6d82ea9fb30616a5090ab6a1e85470b5d76cd4a89e33484c0ec59290c7a9aa0bffb74f0a08bdb9f104849b7a97c572ac58bdfb80063cb61eeca7b19024bf6dec2379f9713463f90ec9e865f5a0ea7270480c527c9f708242c628dbc09c0e9adb244f4b0d41c580222e8bb857f41c991c729c63c616c9ac78950a33f0becdb5427f265907b9b022acc3e3a0b77d9fd715731781722edb804b749a64b07e5a74358225d1ebb24dee3feb7ce1ad0ad330c35dcdc5384c25d04e89cf9320be1f667a3608625e635ad4473b9e5680b085d4f149b773285ffa22ff23395d90501429e60be4bd08d7a8278255f6456e01a1ebd6ca42ac467f83143cb74aedf0563056b7366ccfa4fe92aaadf1737d1a5d1c5e02b220d2b7a94fa027150fb020efea850f7d4c1c1920e5000c4d0d4f3b778a64c60e013b3aa082d1fd05d4f9002a7e298d0e493aeb43a98581ddc9b3f874330b55b59e635b16b1ba07b839f5c0fa865302780d6e8edf08c5e358b290c48c67f42454e2ec073cea8070c7539fd0a070db72ee884d7144a0fd7ee9eb85af01282640ebd3e23615cde1a9920580b09102c4933501bea54d462c820f499e7136a6bd0b7b1694e4ef36cc4061db1960ba1b720e262e7ee88823c89555e82a728cedb7ed3088ad9e7f7a1405f36df680826bcb2818c10344ee09a34a859b84d300c7e1a5311f8f35312609a31ae56e908aa1f847235ac2ad4e4ed093a392d2e201216f220471d3bdc10fbae1b497f5701d9f0379cce41f9a19ec9559be99199d1620bdf5999efd4c442604a1ed648490362180e83c2b276c4b2f1f3eff8ff920348dde3443c4bc7a43ac9980dca0b210bea7489a4e7dedcc352d8ef1f2277d5ff904c43502bdd209829f2a58dbc0f5f0e6a6287a31109a7097bd0b4ba9eff96473123c2569bf32bb834c718ff308ec90f567c11673c05fe6c3818e58d6622638da7477342ae92722c8a9f1c88363ecd0dba038fbced1ed73a9bc573853197067509a51c715181039337bcb381559a2e07857528813128936098ad7338065e359ce964438945d65351a34096d4bba2cd0260ffa61668a3306545f11e062d99ae7e87a1045595e33a0ed1cef83a89303e02664248c3130d284a120907bae41b40ce3d8a8af91bfd74b3d59207ba1220650145b6feb5133bdab66ba69e5e6f3bfdb67a199a04898ead8aa459b0f5070e030293007c984d69ed518e97854c13cbd5cbc122e135063576918a52e0d903f6d301269bf47b896ec2b51a1c9bf79d8a5745f6712b2d3b1a5331060522f1110d7102ad8dce08c2b1927b7c3f49dfaaeb7636ccc404c4fa9e580123d50e0d72bb0c0e44f2e80e9d9cb959b860eadfa120839dd1e6137f75e22eebddeff721fc0e95061f40afc45e91865f3483550f4ce6d5c678bfc045d76bc6bd8b5334174fe4310598409e1389844de0757a6a3d082a717f48bd575a6d89e952ab41a0a90e2ca90692b09ca0a61d8f6de743b32b9d89446cd87f1c8321ee015258631c8bc63b1f01a69861e2e57ab3c368f4ca26ee33a756ac226c23b3df50864f99f196413cc70a230289e1e9d5e41ee3adb38f0bf6972accb43f7afe5c71923cebd9d677d79103f48fc203d89adc663a14fb545a8e6537dbf0eb860c5db681dcb44a88bbafc5017dd9e3abc8de988ca94543d3c629e9fb489cb304dd84c7517b21301764cc71072cef61ecf0f335e43b830266160bff2cf84de01774a779b1905e6c1a291adc0b9c7dec9eecc7aad182de5d8e4adb3f681964f1bff67cd35aea364acc5395270195421468d7911f15001a28bf15648d3534d846d61269ef363b15b5d57d2e3f0286096e80e1496180b87326db38f5d0458d2a86bcd8cdbe8309a378f3ab6a750b64c6224a3a859653f0331f6404bda558fe15e3d6e12139b14de2e38532bc270a042afbc8df634457b3bff70d09a2683dcb9787376b6bfb0a95444b2d316eab0f5dd9eda291033531bdc9ca7c8f7ea2f19fde5d8a2b815ca94ba4595a9d2273039cc7423057f3c560afda043fd793acd7fd8721ee404094c0f1836e4f2993e507b37c8b076947613ecb22a6c2ca51fbc493495802540f692c92509ad0c6a3f00574bb15cfd1acc4e5c63515282b1b8df99e3a44921c8a031df1ea64378595bc09bf63a01a00985e459decdbe9313dc0acf919e02aa14af9fe2d88228fa81b39084cabe688d6fd02db819ad96a695e9c3df74ef46e45a7ff21bc7f86e1c8dc23084aae968319c7ec19688d52b1e4902a123af3c34c2407f8ad0174dbf2d63c8e07 true +check_ring_signature d4c105f170c412c9c3ec6b320eedb4256d27f13abd0c0959a6409c33a7b0b40c 8e5033d3955f38db3a9ad3d6b53020fd8df3912adc71ce0bdf4991bf38d9933f 1 5552b27f86e6086af2a8ed5ce91502b6571c8c3d037f4c5f8e4b1e1bc14c9b55 1f1073f937b2a87fdadf26851dfef2e850bbc32bb4c02234863a22290507f10081b698c6a5de5a06a4df724ee51e1ceb988d866a23eac72cffaf545c1db76c0a false +check_ring_signature 5e94da9239059270bd630435f0596bdc5da149f10989a1a118995072decbeb45 c953fbdd349f940efb64f02a57951eec23e8e9373398b62c11bb08ec230a6a88 10 63a22a0943feab372699eeebdc78a4430d15dec44556c075271c3eba0e1a9b92 a1b30a81ac3fabee6cc6714da7a7aa0e112914af3c0daeaf1dfe26a438d50f7c 630557e0a456cf1ef08c05b2ee197ad20c92f895a60709793c28039ba7a1eee4 966ffd6594b9583a93dd49d29c4bb761cc9a8ed2a7d85f38afecfd4d132366f7 8e9ccf4464cbbe4f96b9a5ef1618456f4480db8969e48b222d7f1e2e86c7fbaf bc7fa9c79d4cc0b548e8fed6fd0221fd49619bcacbc98385ae28b9f1d845a73d dd03bde038480bd98f78c7ac6e9088aa5bda88a046c8cd4103a306c9b3b3e46e a5d8013b35ffc7ae8faf4552bce5f06c8759aa608f68e89f4234b0b7a60a3a63 00e8593968a453bf3893e138cd6ae02459e1ae63f755cdb9ed74ac21871cf531 97f9db47b9fe1d4261839f6e92b28dd17919680f3503cca32b34e410bd49be95 7481474be7ba98a9e5e08a05e25906dba20c8b612918955158f1814b17a5950ea9f29bb0454052c23ba37f5d36e096cd8be5491e0be77ca88d1bb8567479a200ea5899cf47f71ab77c738afd582d75bc1abd63ca630ba49d86ecc99bd824d60867c4fb9468fc3387fcf1e4287aa12e508ea546ac4d5fd2baac4844438d708e024d4773698576fd000ebe88bdc4a8f600e8bf1d052ee5f9aefcc8f6c31fc9490a94dc4c877c2d44860ad5fe89c5eaf05f29eee1794ff6fef496222163d307810a062413d06d3af2b0fb4ad221a14cb5094ecedcd346a616210908a6dbe00bf009069049421981bf4ccddab3e3b7e09773304d287147dc1aea6cd440bbd2156d030a1ed4342ff476cae038916973bb3b5e0a6ad097bffbd867839c8d74efcb941e1ed394b89e72139c2fd7ff5a0e3fb256a7fcc2bf6b02edfe46106b53588e9f039c2bbd0ec12c5d9924694a7af9493f82d8c4e6ec193cc923ce5adae3e214ec028d69268f702bd049de4599eb8540cd7e4c898ecb1c1a473a27b7838795a9710c62f1c67e72086f34376986cc1087d07676d9692ce0a63a71f3509fca8961c501c1b74d3f1e5d21e2fcdf7f689cec3b45e63457f79ce96f12eb34d3c60beebf095150e76a685dd4bba14457ec6a1f860d8dd2f54f4c285eb56c94cc7a51f57d064c39cc8601147c1aa365a9b507cc0a55393a86746831ce28c6566fb322d46b02fe9573b6a86adc87d6234d68f62b2dc312beee25e1a705b30b3f1121b39f390573e18f152b2113d87c8f91b9e348908d410a06f38d2f42ae33dafeadf75fabe04944faed928d7d604e4c15526941d3b9d394e5e42d01d4826ef5138b4a67750c18e3065e3b08d32eac332f87e0ea07750c6881a4575f0a2eab352ca429777609 false +check_ring_signature cf22a4288841fdffb276b922f58c233686ca687e3ae1bfda9aefd0e4af13b95b b8a445d383a010bb0262b8bb401405bbdab6865213a2d64274e31921fa7e9007 7 e1dda32a98fb9f61f725ae516454ed0c7a5d1a5d05a21d3c7c112088e4209a60 b5c66e11c355df89a7193863a33d6e00a6a74f23a8f27b1f7b2e0b0a4122ddac 521d216ffebd12e170cb6d6ce7ba88f2623a51298fc9cbc4edbb385f80ac5d7e 90d4ba532fa63dc4056fc5ef07d8e973b5e8a6c1dd562f77206a706ef9ed261d 15152c5b8cef870aa155303a40d85d9c2210abf697f60ed6ac18aa1c197c2c18 41350b0d410accba7675be08907b060e7b2db826d87a8449dc69ac122ed83757 e8ec2496623d5c2bdafe53b98a174c35269029ab71347bd42832593d0f69c5e9 f8238d5df39c9980f0fffbe1c0793f93324ed10328409cd4b0b65f4eb0f2ea0cb35dc98ac70a484d6c944e414e5c5313fd5e776c43e5e4f6b62fd9633aa39001b7e6ad3e4ca0b233ae43659105b330db474051e1ab00351f687c1de39674a8006bfceca4a552a810efd6380b9698db349b708ab1d596541177bb612d8f4c0f06cc9bc85ea4ac83c6baf9213c12f97a494cb4bc25056fad298d94d829c2f2880ab095a61ca92124789ada76dfb89f9023a919a35b9708fbaf6eabc719e49fd00c929830225d798638bc1fa799e978230529b4a5e66cffc9bed7b5972d373b7d0eaf710ef8f2dac3ade2e2fd37c9b6ed350211ec125e5d834e91c97af85ad5d402fb392db75849d692e1fcaef0b30710983a8226675ec76e42dd31a54b98dd120a1a854f6ec3ac95229b8a8fb8904481c4558c6102c3d23cafa6ca96cc1a77c309142a4e8bfe9f595419449cc22fcfd5f23cbc9d9f2c7def4aa66e43537e650503a984edac138c7088e8c2dfb45c4523b08b84fea7bc2c184ec34dcbada530ed081f7443144bae074b1be4ed3ad98a81458f3b90db5eb7c9d18f8fc87bc5120f0acba393df32c090c49138787612232a1014b9223ca0f79a6caba04b9952853b0f true +check_ring_signature c2e25fe2cc6bc53e5719f7b129e0c174a325181cc0a4324aeb0b2432b17fa777 e1875647b29aea6a6e532a74058e7baa1a3b3f085ce5177a0ef38dab25189b6a 3 21fb774312481ccca02fd73be76ed07941f00dba4b8faa3f79e573591bddb03a 44b7e0a142bd4d39b9be4abdb11eed4f8083fdc1d490312afda6c27715b7ec12 c0ac47cbf428543762456e4bd6f983ce490f9d748f2711c73457175556e01ac2 ac7c11a5dd43361c815e02f442a0d916c7ee97687e4315abcd3150676c08a50756a842593a730dade54837fbb0001511818ca6a9bbc1677562f5fa280a0b0c0b2903167d517291655e26e5bfe4e87b0839e3055b8a6b149b32c27c20e4f08e0bf4e99373a31550c13975a5f850624f093a97103e4f599cfe9ef2f3c6ba288907b3ee8f11a0c0bf9df8d46dd66806411e27036c8d3484c5ad3279f3ecac363205331db2c8510f068fdfe255e98dde575e68ec253d5c545b621d4aa55b22e0ae0b false +check_ring_signature 9a9f29d9764601a1976ed690e4daad16d6bab01d1ffefe6d2227919c830da905 10788c097b8b7b2692bb23b60cfce638aeee3ced44b2d51354640825b73a26ae 6 c496d4f5e7f48caabf2d51c13825e6b6bf81a31800a5ce2166a0584e4f63773c e8cd9b00f9291e0f4af694f44b363bdd60619d7fb2117231fcabc968419b7f5b 8cd801caa74e30b906dc7e4bf75b45e5a64ddffeee14e7012404c5d08a2d71bc 4b7e8bd6c83e7814c220412a20d21820d7709156c100dff39842235823ca5c7a b5fd230fbb6419b4b4eb04a94f7a8ac706c82be88931a4081c4d193731bf0b01 51693d056db8e10da648a946eb5810aaf0a33336c69d08d43992332e31a15d63 c163b579ab5cb3fe6aaecf387981d552e44adcd95faedcbc24be9e0bd856790d0e73e6e3d209503c0d723e44d446d486a35ba9ff6f45d1d7b85e8c500d770808f76215c08fd42f65b69b150c8ef5f21de2f7e1167bd35ea0f8588de361a6830a4e776156e0797dec6532b7bd748a9842f0e4c0fb03d4b25aaf77a9fa943e2a07f78e421a141406001f7eba479b0b219cfba5a860cfed46b54f1121ea4cd35e7fe0b5fdc8a5ac97409cb57bc59152488b9f3918c8ee4862de96547d4e52b78a08fb7bb4c6f10c54dc48c664dd2b95590984b7d2b721b8efee84412b50312205004d4e8534280808c876d87a4360dfc4c7ae8ea4c0922324c932a1868544a1cf022f51aa440ab8edb7e86e61ee71efb3e83c198f15d4a08d5ab88fd2b92badb20845958e5b3182fb1d7c844112be0acc563c236e34bffbdabf1a4bc5e2f0d14a07ec6be045d67ee0f40a14eccebb4277c1fd1809748c9b2f9850350d95d07c88ee69fbaaf6749a7607363db840a33ac0df13f10e50d541c1a5143ea69de0c3280a false +check_ring_signature 86d39d08934de5275d5937a8da8a9aa1023297da33369c97e42af3c70a5de38b ae3566f4f027faea2d4f60e5b505c0f51d40ff36578f7f347090513772a3d789 125 cb601b0d8add3193d35116d916983337a393519a2d9f3e3ae68865d69dcdadcd d8745433ac42fe6d636e16cc59b460f915678b02cec4b1ec96dd2dd4b93da13b 218658b3d516ae9c1ef04a7cc82b088935b97f894dc1a633053decf6cbb01e07 4f922039120657fe5077ffb8350c60349bdf1ab4c25e95fe9674e13cd0648284 f2c80e7832e3215d4c8a235c248e51a9ff2be54a278b33466ea054bb59b60b78 de2996d3b54c0785b00b7e9dfd659b2dc12ce0f447f8023f2fa4d219d4873c9c 8f324e0902028e58e102cb92dbc6d11d4125bb1099d87773f22a2d570c81ef9d f6a3f95a8e12dc1c2bbf6607365c4799414f60b4678bf03ff9803e4a3096a06a 254aac8d0da8118425791f1bbb1ebe58dcc6f7f066bb6e714f5287a17da52480 50172afa359110f7b953bed8e7fdf789c5ef1ada5fad0b19759c80e2a529cae9 15531f51fb9703c67ac3e28bc0b688262ead1d39c17f10f4eb019c6db17a0182 4b8467f0b016a72b7ecc1b3177433377652eb6afef059365111ec891087db320 76fb6a71fc511b8333c42558ae3a044460b7796cc8d79b1c8b630fe259671149 32c4cc3ed43553ea6ab4170a9e29dec0bf296cd9533e46e5c5b6a7b2c61e5e6b a9e77dd87a6d4632803c7408f59eaabf77dff137e39e5d2c35fb79ad242ed105 8f69307cbff1e3e7465dbf8562343cde20d0edf25621c625ce792c1fbc5a4774 a9d9c193e4c2a8acaa2edd0370c9e451ddbc73d739b23f4dd2c065a5c7538aca f4e911f99b8922d629cdb72093a17ebb32e819085c51c9f1bd73bd8d986859a3 844e0639c3013e5a84bb0e13e5f49c8dd259166103010a5fe1d1b1ecde3d748c fd5edb2deaf9f8661b4c585fb3ab965df32536abf06152a7c57810409bdc8925 7c8ffb049e5bba75fbc22f80bf29d7cf767d73b991f2a7f670399b1398aeac9a 44329b99509a2707421bd6e597c932d02b110453a1b8bdc8142bd57d2d695b5c d977b073517895b12575a2b51449b427768c3ff9dab0a9f2cf8d4f0f23d5bf43 922e0bd12f3b7ee6b5793cfc621a64f4e6370d976195926ccccca4d647e64fc8 e135a5fc74f884e82b3f8eed01042a0ffe05e6a9aaaba475fd0f36ff513e2d49 9fe7a762681ca74ce54f50f04befe9dc88ecf373fd964fff1b29006ec19c1b88 22519b20c58bd46963c13cc3c29b3d43c9505456fe8942706fb58261fa9e736a 34742b31d2fe802acc12da22fd5eee6fd877a344848dcd0e9cf4e31982a4c280 444957069ad6b21985cf5638384402e2ad353e6bb5551ce080a0e25c46b1151e 89b4966ff5f3fb8c8229b4f7667ee83de6b0308a6487d4f2bd994fec42e44b7f 7cbd6d0937aba071fc158a1b88f27ad58aa17be5a7e10a5dc2e0041611d07175 5a48fb6dbcc4ffcc34500b6f8f2c75e85d6588c4085ff22717e7fcd3f2b8ac42 e632a527359b47f67562496e6bd6f33f2145e820f017b27da63314e5489c2005 7a5a1be41339b0a12a99f2e133f9197d23166dcc84422b96af0fd56150ab5ab6 2b7ccd34ab05313b2af444288c2431fd7303b7c8ea89d82173234b9890a3e7cc 5cdb4b528c9532c3f00f0484038f5da79945826977616dd4012ea095b6148dbd e27caf8012dac3e74c43cbe63fece20fb3dc1af26ad95a7b53100904b665fcd6 ae9af46c1d4105d34afc4192921f762c350fdf2f876d0a4e30cf9dbb69026d91 ac810eaeb3eac90614fd1a2234f16586df1d53b736cbb01a80d759b2fe38c5e0 01a98923a751ab3b696cba42724d7918095d35e7225681b30465a8f5d345aa75 aa4687b953759d7a020e53db210257eeedb2c6e9fda3b4dbdb03afbdc764c982 945c43d4409f669c5a64e5bb6cd70bb2f6289cd92eadef862765c73cbbbf194b 13def0d7c91a59647f3a7271bab60a8ca48b8d79db09e6d585633e6c518d4040 d16b28d8eb859c5943c1232e1f0e25bc9b638cd52a1e91158e903bacce77e8cb e61ba298da201a2c065f87f04af4c1fdc9610efc88cf134e0b1da911efb3095b 3dab3e8113eb194ae122c2c33a0c6ae2e94de71bc774a7ecb49cd24b30476ea8 3350ac6d721fccc4c7f1612ebccbd5a760a2eabd13185a4d4afe82ea7dfbdca0 2ea7d347844882ff332712fae23bc18b5529c73ade0c41b8298c9c6610541dc8 be28673a110af8f203c038f59816236911586490d58998921f89335427693393 eaec0368105cda8d59573576876792f3f045e489d56e003b879d91a5d5c48092 290bffb5b72b8eaee4874c866f5d44b701190a40ba3d8af8fde24b48116395e6 29d3e8d621ec5efbf576a0c02199e82d450437ebadb2178e306c0ca550ed00a0 74b291b89703fe61ee1b20827804ee17b7a97f06562eaf08a4568485ca2fa2b7 7abba5eae297db81f56b60d8986d91461a94fd13dfdabf91e98c72e1c052fdd2 b8d9193b4e6b3c1583fbcc418a69240880150c5899cdd96f87677e824ba7b07d 00f4d39cd430ae2fc8a07c97d8a514afb4f80fc98852df2e0f1b6eb1018bd251 a75001e93d0776cad0ebdd9d560339ab5aae11d7e80e7812eda1a88bfafeb964 6a392f139d13913692b39ac83ea1899639530b296624aecaf4f6452fd67a7b56 93aa2fe7007e976453a89b96b5ca4cb363b7161c8df30510025163ba238dc715 64e08aa7902cc3841a9a6d53708008370dad987d0e0c9340644f3bd64c5c31ae 94d5dcb86c67e4c9feb7f0b121010c502dc3325c77782e94a9bfe0ceb46be527 5c40d37ffb070b9f3472b24a5c2a4db994cee82a7829b8b6d53342ab92823a2c 3c750623235aea0713d5349e1371e2877d1dadac31b123dd38350738eb62a703 5cad4ffc7091d79ed9f80afe9519c95ef97bce1df22cc715b40e9ba31882cb80 bb2716cb6d53e18659805685faf712ee344d78eb9f82b26a1069d3ee95d8ed3c ec0356d2328f905d029740b18a65239b2546d7ee66c513a1a87ce53e4b64929d a46ca9c90e22e3d067e068c4fd8e5be6baf9450b01878e2a066eaf5b76f16522 04301f4975e71879f3e03e7e1125ebd347928f9d4d8cb87d186f49cab793fe97 d8a2755c1a25fe73981c65a72b29181be89e5e931596a196cab152ab21b8249f 6a887e8c7f570772f5dc0555d821a2a357dde392a559ee4a54ac57b2edd60108 07e389f307076a2f3803fed2b0ddee27ffe2986d4f852758716827f373863ea5 5b145fa86b5a4d2490ed4371bd46b5cdebdf8b737a1252a185b4381eaff2ae82 b8be6a5e9d5e89509aef165c05e69e544e02c5994e5517dc9c694402d9ff18f1 c1210a28e0c1080bcd66ac4521d88477c90e426cfe8df5d47d896cace7880afb fd85e671f1d33aad1732cd095cc33b39bc911c1166d5dff2a28d8f27ceab5617 6e1067e1522a590b5b5d68b0c9b55693163339c2d3f8280dbc3bcd8a8611b9fb 5173a45dc19f0d6f1605da31b618390134be837eb9e5efcf51a143aa5a09225f 6bd6e7b151464209baf8f5a8a9628ec5f0175a5fb0e918a7a945949ef78a6531 333183787db0732dad6219bbd3a04d7d827ac5b8bbc7325c572b5072120ff98e c9f824f6d3396fc3f8a1755e0261c50b835a5866ee967aa80579d24b5b4ca2d0 58a4998ccff845f2101b60b9f2f6bbaf67aa06e56b2545bb987d6f781c5b3371 9d3ab9210e91c0fc16433641ee84703b535af88a0fc5688ff238aa5cee3be6ed 2b2b08dc7e17b2ff25a96d8a04df519ea0daf9a7cca9e0bf0b643ea409f4e8a2 a6c2aa7c2c3c68ab08ad4fb6f7b222a408c4d6836328bb42fc77d2258cb500fe f9a4989c61fcc3aa0cb95cd9ca2708a95914a9d2e74ee00d335b1fbf31bcd9d8 0b28d7a6a6a44f59dbf33c890029c747cf0fc971e3146d7f48e1b0c4a45c637f 2b64cbc9fb5dbd49d6be1039455bb04863964dbad68c68a01cc0832743b2a747 0574b167a5af294387c3b4923d4bf33e586af8723f3dc455ab5f5bd8a732aac8 290f6d4404e533de44ff960137181b8f322f5142dd0e786235f7b813ae9af323 9a25df56c36e5652ac15dbc18cae691400959d457d2945b9bb7822c2e1df25cb d493273f99165820c5af9aa459395e104a58cf09fa99e8a60bf7bb07246182fa 7c8d3a6bea445d9e2d5915f945f15166835736f908095d1a3adee29af7cc5eb8 ac2b376462f70189f2483f2be558972da528928a4c3ad6992259cddea93b8537 1652f1182aecf43e1ddeecc93512c7f3427ca97168ad5002ba39b2c05873df26 5d950fdfb4502c404637b7588367c350a352fecc984c8c96f41cda872a0f55a4 a63db6715456005c1a4be308b80314be19425e78b1d1b56d013ea9139c4bd044 e60b16d04da04a098a029cac31be04bbaf97ede8ea9d6282d2c428f8fd324acc fa1a99b145fcf7ab4124437759d2fcb6ee2302bbf0d05de0d2cc9cefe5f3c1a7 ea23f77ef73f9c4961c13597420e9a59b02dac0534e7ce698d190bf243512d5b f152fc39322ae2f1f8ac6d23830bd373d39b4e53fba499fb4d82a61c88fa5f3b b77a6b7fe80a8363c8c6d20eca298a4801061aabe1368c8360a333ef22e780a4 1942f15096d00144430e4c0946846acbfedec54bbcba5d36472653d6798e89e8 7f74c386c3ca74f4213e085be7ba323a8ad9713c0b46c2185bb20dbf8e88b3ac aadddef8032ffb8bfd9be2ba44311319c94cf7ba3c1bc14b6f8c32731801ece8 657c8bd709e306f5290bfbe78b6129b57cadf32ed0edc699282314d6f06d34eb 6220f93597ca15efb3728a31a34b36c9986f97de311293f521bb02870ef4ce5a f1ea004b5d5cc9bdbc7241a094c6ddd003753bfef014d9dbb78c533bccecd733 9c3428e7f0c880e8c1816ee42b1a775d28f1c7e1dfaf95e3ac935cb56b19bc2a 5a5381f96cdb48d1197ffb884922f1c6160cfcc67edb88168bbd340e6766cd4f 92e43f64046f3fd38e5696d8198dba26c3665d9bdabdc5c95dc97f6e167929fa e2451a25e6cf25ed9c5f000c9ce0456a04b256a8dff2249d6b7eec51746b67c5 2fdf03f129f0c607488d99c6387dc9348bc2576ce78c8017a43d83c4944e46b6 c52ee6f5c7d25f90d3d50f575766d150cd3bfe449f9ab46fbbcdd90a50176d20 b6d92e5c807b4c73414b91e56d5404e4bbfe795000c0497741299b0fa6defde6 d12dd3324c30ec3c88a00fced434bd47826f6a70ef50828e0cd6672c65358ebf 41249ae693a8e503762bc1754f2cfbfc9f61fb26ac15afca0e699437d94e97c6 7b3c1bce2f93b6b7a4d2498d1720d6514a377f4d9f861e939dfffe441f5d3f4d a5aea003fdb9805f07621d57d31dd33d33486a6a41e99cf5bc22e3afa1bb31c2 fbc788c102753d651f5e0abda6985e8494074dd7f087f97e5c46893ec793becd 1ca99530fe832197b63bf18b517147599c0d05ef52c87c5903bd684c6f994c76 458e391baa68ba002d0f981ebcd760623fa15f7231d2e3d40d042d71edd91207 24c8cbe827bbdf732b6d8e0c6910f243560b73e44c3afebd115d2ac4a2a851e0 dd0437f6558b6c1fd99b80c0e286839bbe3a95dbc342abe4d441b728a8038eba f691313bedad5d87339ea5b149d1df20774d044e40b6fca00d700cf7073bb92a ffb4986677121530ae9605237087ac8458d1735327dba33be045ad931247237c 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 true +check_ring_signature 9748649bdc06bdda34cb99cdd2fb934ae20cf8067d774fe7ee859430ee0b1465 e3ee7cc2d1887e202939e44bedb65350bd0c3363e56aa037bdd2f9ed3b0ea3c0 2 9e651a7358b06c531058b5968e1c44393a636198a08d5f4e0ff6a096f038a3f7 bf0718b0ce43d709c306bb8cf63b6740fc25dd2c6d2403083ddcaf81b31171c2 e96e691ba5d8acf14d0f89fe238c990c1f04fc159f8038a33bd37fc9a4fdd20eaf1fafd1e214ced98c6949c11f3077787ebdbdd53c5a861921eeca8ff1dd6205acd8a039180863ca987caa9d745d147f1e037f389396cf8ef42f6b32e943f100abcef7c7eb59afbcbe421bdd566222813fff7872b1f823816cdf6d7cdac43c04 false +check_ring_signature 7e38496288fdf3052d2eda465c396ef41a6fcc25092f51e0c5731cf1e0bd31dc 7829d434f5ed9b554fa8c445e283d3f08e0f04b844f5ddc3e60733eac16da6b0 2 0d590772243a35c34de913a5d41e7554f517fb3d6974889841b23c2ba1d695fb 6dff98e7d47656577f95c1cbb7819a8621c034eb3135a149a4b05862dc8fecc3 8e5c3fa03b10dbdc80e51b04376b9efd6b1d7d8e0d49db43146898013b1faf012fbe359a829971e44f11e92361afe127be68e259f159f90dad637b7acc578a03220400f6bdbbdb8681bb1a1538bea56153bf9677503e25bc719d9486908ca004fb89922a05d3fb2e6ced41905aa03b3e645d2c350dcadd3897d3b4abb15ff604 true +check_ring_signature 8a628fb172a7519fb2f0735b2ad1271c4f9e0d37a69bc30f87a6d25527b1cdcd 47571573a7de7ab06ea1902bdf231aff0f3f79948e50c476beb724be56f71ffe 2 f8267eec7777c81d2ca6889c85ec972b827e8d4140bb1cf7bb90c4f571a6e0f6 6ab09226cacb36b3856fe4c23b49ffdce13058231bcc48814ef26470f101ec75 58d71fddc0dffa74c0ea4193830388d959143f72d0c1ffcc7686a3b8782e5f04ac0e7a32612e2f0e710d2d7f03d0794d68094c35de781e9e2d7840c7ffb8c406e08c26af54a0ab47ed0cc808dbbf9480753369c06a9060a8860ee9c69834850ba32299a308c35db2d8a3bf26078c7ac43fcb1624146b6d5ffb5d580cb823310f false +check_ring_signature 037bf00d757c77751af74433830465f72d2fc4ff738df0df64b3700cbd55bc65 00f5e1a220ec7e4ebfa0337b682d88ce8898b725c7ba80c296092dfcfdac297b 21 6d875ad407903175520a2d4be18d41269329373f6bf5145de6e7ae867676f0fa e2d80fcbc5c97267c64079dafc234f59ffcb221eac810a32d63e2c38421d523b 8b28f71153af6867b8ce23cd48ae3549f05adce12e0a0beb45b96284a73a2dc6 7db0233f3012d9bce45724bd5d1161b2b4a2ded4801839ab4470ae9b49452e62 57301947789e3419e14ed90ca77487863c3d8da3af48721c73a9c17fe9f5fae4 e52d910af1cc36076c9aa2f8f153b2610606c334385ca9587b63469237e13c46 b45e173073678c66c11324ef518e7d7c8c41d44e4731132311446091cee9a665 408efc68392c263e48376c832d6bb56835a439c729fb0ec3697d14c7b8f107df abc7b9d4bc70eee4f14f0159819d035cb65ea254d86763e39c4e6d5af4552d70 33c95a04af506f2fd72c3a757b3b9ada3f3de8cc5720c38d61b576878fc834af 0753e0d1224ab2125cbf53ff269d3833d2b22ef59d4477e974fdf566d07e7ba5 b15fb699a24add8b04e29664b5e1e450a98f8ee4b847048d9324d464caaec34e bf948391a8680744a5c0e12688854625e1ac686649c6969b99c04492a4f7e505 9fb4e43907acbfd0e545956608e89fa1d7bb9e797640747edac8bab088271199 4fda0cd3825d3d9de6d65287d14ce8e42d292e03a6e7be37ca300409eb2e6e0f 0a9ddaaa766257d0a1e831d166755081c0f8900ba8d28034fbc6cfec56dff36a ff0a97cb7e09cfbe37d8fce796e947f2d7ba7678015544299446c76ea8971dc2 75d7d8a4ea0baaf46fbd1279961ef096c64752278f49d3ce790c83f42b6bf36c 53b7a1992b27c262d924d806e3ef14b0f46b5b71e81f8d5ba5e41567cb56b2ce b81a1510ee2d974f496ab74dfa2ed356a9c26d526d6121d8c27929b4274ce333 ee09fcd3c709c6d884169665f0c17365c9c39ed4b48d9c72724318d80fea78d4 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 true +check_ring_signature 2b069eb451b00255b9b9317e0a36172c724bf84a87bf82dd9694f54dffe08e37 7741887964d63bd756b02086239c21fd3d5883ceb637c64521f8e161769aba92 2 a630a52ef7ed98dbb5995474fbeec3ff6942d40cd3a4793d5d2abb863c1841d2 be0b47fac9dca267e049fcbe5797358e31d44f9121a6f3b2a4de457f1932db9a 6e83ad4aba62d3eb10d69abd4136fefabafa589eec4aa7ef2fbb8969c7342d0d7b442f2f6ffeefc36badf05ac95af09a7a5990f8f12436655a3d9a81e38f9a0da24adbd390f7ec4d2b58dd62d9df9a03226326efcaf3e81a404181bd84658b0e0e380ec24951a602c54f8539ff1b841509d952c91a825eff67ddc0b37fc7b708 false +check_ring_signature 15c7f74bfdaeb388bee3e8118b6968ac84c4936e0dbf0c501de13290b1735ea4 5214c527981e7d304f088d3ed37ef7dbc975ea3b31f979011920596765469633 2 a2683ca083295ac4f4d7c3bfc5f0e460b229874b77501689f6631d3384bd41d6 238cc72c3e58bf4a37202a82bf9d5a3e78f117d5904808852e7507d4754d6225 a69dacbd40119819f4bfc519e2b68a06dbe719225e9a58005a561151ed5b880f99dc55a1c7e3807309d517d1a7255d322cc915abb09c23f739ad08d53d5d330783c386beffc1eb933b729b6868e728a63e896fd91b8e8a02e1a6396a0f2f4701566666f96960966fe423d5f1e07d84617317b6b0e8f521d5ad2b5fa33e1b5909 true +check_ring_signature ca45f298d4926005ba26367cf1773176f54fd1cfab65c7055ad577bef9d56f23 4a032e40669c0bed596a060a6b7313523ae161f5ebdc18b44f2ac3ab04e69f98 31 42db1c9fce36ff07682d3a837a9a1bf5ee7d997e10d4304f6488963dc4d663b1 9f77cdbefeee162ad63610f3a8afee5579bb5fb3c052342fd0adc19391e558bf 5854612db94426d8154ddd8d3606a8202cc415456f413c732c01067c15b2cc33 b3378704df6d8352f5348fc06f66f1a05612a315758f7bb2fb23ae50dd625be5 8135e04c3ac441a84eb4016f5cb159c93d5d755c33e5a03bdef43ce1867aad73 50bae002c867b1a104f5fd8fc1c746feb91af5ca18cc5ce4c6e75363485656d5 f866f014efaeaea45c4a1363cf5d8632cafd72e8afe2eefe1fc91af519c3ab50 490043f1315b845aad8f857a62228e6c333d9701ad833c2de0b76d7ada308498 72e851b7a435f2f12594e8ad1e4e76c604ad88c97b9ebe035867ef407a32daad 35786700a1469238cb6b1d64ed1b0ee4e9fa9ac65bc932863d7f4aa8d77bbac7 adff41177daab13d09d23d34c673fd541f12d5e60b8c765af7cdbe52ff1125fb aba4fc2c08a9f9081399ba001bf3445bd44375682f2a7c5d1aabe7d0a6b8b026 6ad0dbb447debf713a8b4adcdd37cb1268f2076797d790bbfb31f1c9238525b5 0725554b3b054b77c1d18f786926c5166244e5028e5fbedd2c8cc12e666afc25 64b44b1aa4c5a7762a6d3057f7727c8b538d36a0378c1596d6a44a23c8f7d93a 9129f403c21f581b8b3cd24378bbc0e18c79f37b5d8954706332ff6bf013e010 21108f0d511ebd2b37471988b685437710d28aafed73f76e4486b704a0e1c936 747b308367da3f0b1cff293e262ae4ec7987bb9d387b0d8788db96acd21d0051 a0c44fb43c408483067a5bfb1ffb4c2de524e81f02b3674b57d7e1ab0a4045dd 3a478e4629827bafc22eb4f6a7076d751e87e42885b17dd0d973a5fd26fa30e8 f9a3938ff955bb176c26d7303a8e71f203c907365115778323f3175f83870cb1 3d5937ca9c0f70f4225acc3538eed56e000bb0f9c99f0caf812e6cd4b829e23a e3274b199aaf8e7f6c2678f23e62c4b739cb6250e431652d962bd45b88e0ca5d 6019e99d5b2445f0d7108cdd983cff810b53b449aba145fe0852aed5e8ba33a3 60c730b994f15889c6475698c465f81f7e1a138b6f87a67c382d947143b5b0a0 a5a3468691ce2ec4fbb440491a1eb92cecea5ac1ae8d7d2df33771cbe1787719 633e40db347d50106b6aa9c525fde63619b072f98e32587cf89cc100855e309c a197bd6faa7d935fc3baab507daf98892591a24aae3a3ee0abd8ef62396b6df8 e2b317a5b5b4e52c476a6b7267c1e667004ba4285a7a6e8c7adae969f269519a a7b85bff8549a8c6e93fe459c4bd1b93c8cdb8835dca2adb07f67c502caa4c07 f9317e776ef4f404a796af337086474a6af23de4b9bc3c52008a243b1cdd3a60 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 false +check_ring_signature 27e042a1a4379b9d13601778acbbdf791b11d7ca0443f006c80012291921529f ce460b45648fba7bcbb2cb7a70838dbac0fc781cc26b1c05ff7d790bcfb7c8d7 12 2e2d0b17253e428a0f445f465129ec4cabd9367cb381e2572b870227881cbd7f 0b2eda04180be96ca0fcee00e750cf4aa4311ff4aceb0afecf58bf8cc1eb55af 9ab0c3b3d50fc76916abe4c232592d996f44915374893f9d16e2e1e9ab2a520e c1898b1a1ad791012403feeae85d7386aeacf4f956444273ac2f5b9c1d0c31c4 31ff05057d32fcd935d94e8d268ac701e4d2ca9f5a14d1165519128617fe420f 720ccce1583b06903a56d75a278fe34679beb1e773b3f80b00a0bd43cfbb74db ee9a22fe2fe55a582ffcf7632157c8797e7b64cb39d5b8415269fa91def68756 475a61de05fe1c5e7c08e280e466174ac7233c6a734db33a669d757d0c0c723b 14f722ce060af3d73fc167f189394301df31b93aa21cb1fbc268fccac1f7b030 e78997ea882cb8aacf9377fb3081a590ad3e84d3d5ba2f6957e2c8c50234da00 19b0551506734bc62b8516ae743d876cc6c6861450b2a600f6debd3fb54dbd38 0f509c1ce4513d91c9c63c92a19683290939bde4989fef8f692178f51d348299 d7e69a6f5073506bf05e3039631f4cf190271b88cf6b4d4bb4c642e593b5150d67acc94e7fbb70bd589762dd338310cef250e15581a4c5d63782b67b7237a501af8453d9dbee9e8c50f8ec8e947d4314204fde23b3cebf54e5f54643226bac045a9fed5d83214123ef362ad0a4571f4bc54cf86d58b5d99538e214b8ec98b50f454a77ff9e6f84670b6116523f6ed27e810d851d640a98629895f13308088307da28f412bceebbea7eef91cd4faccad586ef55b82d5c3977004573c60046ad053069c4ebfd91ad0a9453b2319fcc9061917341d106e339d44241e16dc59e3a0e43114eec55f028b2fc0e8dec629d8b51cb07a34d5ed787279804dd30e80d000d2ac1ea92139800e466996c1793a756663cd168226b30ef0019f8dc460b1a3907712f722e66319b18d06534bdd6d58008de2723f1136d63ed05f68bd34e46670748a46e637865221de1d4c53650cc577938588cb34e3f6a12cd056aba3c7cea09aa530ad5135b6e5021d346464e9120a2dec9262215bdad714a77fb8cd5ce3d075d6f13a42971fffa15612a538c12dbc5cd62dd2b18cfe66e8696c40c7650d4009f84dc3ccbfb2d9feb58253bd239fae92d7cdf5991d1416f7dd4a7b7b8328f000af93dee85efef36ca6fff37b41ae84709774c5fe2c141979dd0346a3f381a0378515bc608b0427968e71898756203846922712add1bfe294a2084e7e9dd1f09bd6603d9283ee357eda529938d2c6f218dec19028129ba7cf3c7b62849bdad0a669c9ff51dff775ed5aa0b362c802567e2291d924914cc6e72b9dcf6baffca0c19420c2cac3606eeff9628e2101a0a8129c993f2cc49f43828e8396827860d05d0f1cb9c4dd3d33ab93dc8e0468cfb665fa24762ce636347145943d3dc7ae60f327692daf39089caf86c1f7d51bcef01c478c81bb9bba6a76b7f8f6d3ac7450861f26f7eca3b68b3c7360f7c79d3cc2dd8637eaf152055961e12dd23144c610fa6c8cde895414d30fdf78a3e462510faafcffebc8143dfc6c13b51e08e448a076429cc0bc21e305c4d5470722fff07d97a85906d1f73b925c70bce7f66532602 true +check_ring_signature af81ed502e0cb82f846a9608b4a27dc204cc7ccce277607137ba71053eac8c34 8bd46ad85b910d53065063f8cb26d74977eac62fcaac37c1a9d59e1af88fdaa7 1 1ffa8871528b515bf5bdcf13a9f628b3ea1c0b0001796f9b7ff21794833ad73b af3a59a90f64042486781fcd1f7c1e45c7cdefaddd6a90f02d0c0e24ee98a10916375ad7f20c5430dcce32fa3bc47d8041657122fcb651956e1ffcafc65f9c09 false +check_ring_signature 8dd65c024807aa0ac55e08bc6a571cfc32f4b9cdc0232e7c50ac5931fc9395c3 fe37484ede51cf63a465ba87a2f0a5c39294967c8e89e36f3479ec5461d8981c 6 a5855f45cb4472eb373f82cc3ab483e369f4670ed1ee29113e9107301528bcfc 9aa23d891edce5faab0769741f31add0cdf5790b599608d56450d52434862791 5338c9df44e9c2c00e7e1d45e17b21a512203f7ca7701dc6b5e64a9f83f35f4b 715d53b7a60cc673fb14a994d1757eea9094dd5a7b8904978a8354368b52d970 05f94b6027f656149c318d96d67dff26ec1dc651608aad2237146a70a32d9ecb 3a0f77fcecd51871b41da11e652b251fbaa39335c5e3a5bdbb0c50302a36cf86 d98de43da08c2bb004472df48aad77ff7c5f7a157d42ee997cfc1e2e02fd7d01b3cd0bd2f9b74f204e4ac87cdcfeccfe4f030cf6dc12d5a3788b3b900a7c4407604a271f3ec7ec0298c086d68852ff30d42a28c86e3b32fa63086833cd985f09d2d65a009819dc6b7d0cc634a2a2265b43cc7aa0c663f80ccd4abc46ba6adf065f72810fcdcc54d8df94de643c672bdaa3d103a79f3de2c822bb502258468401a7f6333ed2642a4f2c77c32bd702bdc59a14143def655926e30735947b2b770550077f87eed853a12dd98d68005dce40430a39b3dbdb12fecb9717ec7dbbe50574134c524985ef6065c0451ecbe30679f7e00b375ff5105f21f46d6f1f38c00f0e0ec50d805b6727fd8515c1169b2ac03be0f399d8e39bc6ee271caf1b11f70be969d42692711c20f46d2198331fa001d93c55f366eed4e4d69865793d394908dd937461f21a056e4d6cb51d040a78b254bb8c363680e1381c80f7b12e178d0d17b3e7cc0bc86006b16b376980f483bf68e815c428050380637f8a9f679f4e03 false +check_ring_signature d0566b2bb7e09f4a227736bc3c55ab77bd8fd2252a6e7159463fa177e8eeb7f2 5b6fa9d42a69cd0b3579360eb79d9f81b8f0b2c5c015653c38d62dd246bdf18c 3 e51a17824833a5d67080e4b016391fa66fbf6837de255473d1b0d364fdda9904 351949fc168eae6076dd78cdc1db283649f50abbf76ed7aa120d55f4c0aa7def b224ee3e5c0ff61724bd85394605122dd90b012a0c315ca4511ff98b4842322b 177af74be7dd0bdf417e3f20d8b3da7fe62a7c0fd671e40d2175954505d33d075d5be12010ec4bcfb34eaa70d66b06a4fef6b9c005487ea623246498fed7c003f28b8b72e15b272ef7ba8d099a55862dcaad0f5e2b007453b20e76c07c27a60b2f489250d462d8c02b7fea886250024b70dbe78b2e78f8fd23fbe0b75e3e1c0c6a5c533443bb483999b96e1166fd98fe7ddf7adc1b7c711bade3e471cb0e7b08c6969361ed498654808d50c369be8855721b13817a36c12061ab750a2b36e505 false +check_ring_signature c8d8a6a8a6f4d9891df2d4c2ade986a89c3a16b66d6db6b129bc6b7bbcd09425 c27a1aa68930250cfa26f8514dc36ed969ada3e990b4bd10de9623af488d71f9 16 9ac82ac664b96df659522792d3e3f868b229a8d8a91446a14a210108e8df0eea 778724f26a88933e2eb92b71df9520e5b0c7e52e4bf36c1ac397900c7e59365c 72f01870b257fc310f117a8e5ac7221898325cd87754909e85ecb8596f4be3a8 356fa5a5b5c97256c4da227dc1882e1430410cfdf71d07fe9f35665a71f073ab 09f8e355f6fbc9f57257719a6bf0cd6bc6c73a43980b97393bd2f9ac0b0dde0e d1e58bf0b36eccc03d1c7b847ae14eebf68bdb4b742372f845ea2371994d2366 f1bba06ccbab68a30c67ddaee75916299ef030d136ca662862d69439ab7b507c e357465796ab4178252d5a396c38cc71009739e81102a74bd2b76c8e983714e5 e088727b9aaf98fff111eece48077c6123695e0748a22df3a3b7409a40da2060 3d2b002fe6048ec11a65b92c92f64f0dd5abb02cf7690739bfc56cbb3bbec5db 84eae0dd04659a5cb2e24e8d3ec464687b92c45a1362a8e9416ef7e1539ad5f3 8feb36b820e675e438a432298fc54fafe71e580c250d792a2d3adc5c20c7adc5 8127d388a00f3879845e7c6b35446f66196f9b74266055b98d301d790230110d 15275b67c91d390846b67ef568ebce0c3cd37a242334a0fd4f15fc73b46c1721 bc0a834786b1b9bd37c4d7a4ab6053f82041f130b98453a90ad1608dd72ca884 84737fe118d5d352a955bf87e77e9fe0a8d7d5c7f65699503c3f437505eb061c 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 false +check_ring_signature f4e967491f41eae534dd4c00511387ed6062937698fe1cd948816dd6242ea638 93f91110d4a294af82dc14b401882d8109b6dde3aead57c23425df8661592bbc 1 9d244cc9e49092352ce5b2bfc323177498acad0444019f9ef3035e47354e86c1 907ce805ff2639fc455260210fc6fae8b088d92a35c439eed1303acff65a640fa87d48b2a2330cf8dddd61624110d04a4f323504128a79847666aaf8a067d507 true +check_ring_signature 40954bd53f43360d23fe8fef527c61f7dbda22b318deaaa96e29d3453696aead 3e0acf9784fa5d133a19c53cb2f08f3f93e3472b0b2ea915ed55c914480e92ff 21 d7980b95d5705f77af5bbfdb04f438a1730ab17ff0336995147593c4796d5c02 d7607e635db14b146a10a78601b39d8fad53a1951c4139483d3cf445cfaad41d 010b5edabdf37b63888446d4a84c6643d9c9b86d38f0c7b51d2f1fb495e02a21 105f215155af80cc578bae9d87e134dfd7e075dfc7f9311ae152a6c013dc6891 507164715fea223368847856130e68cc9aa843c385f41f0eaeecc8169a199d17 98965121e9709dcb69dabcd96b0c27789b7a22db5dc24d79f2138f649f1bc9ce 6f570f7aa591cf8744acdb01fdad78c464fc2a1f920f39e90eee0b98c24bfc2f 9d9b22a8f437d4ba2c46f34b4f0da2d99b34262417fac8486cabf774c8902bd4 83ba6fc300221390ea83b60fb645ebecff42e09f986b5a521f9f05f5906af72b f17296be0175612de96e9cae382848873430257593fecc412fba1006dd93c61b 0ac6b2d849501623ad431520b74075db4cb952027986f06e9e39af799833f020 790ec13a166da35c6cca66de23b4b95a8887b1b2c001079d717a1d51d40bc847 4907aa1e46d173ede36d079db068d623f00f49fae7202290119c73ffb1fd2724 8b38205ed063945aca02dfeaa4e268134859e1ed69908c05551f63648e7be2dd 0a9928a0b948712ae095c7ed12f501c19dc51e88654bfdf8aac227f48b6e9cde a1b59addfd12676ce893881bfa43f30b0e5a85b811f8a9ae1e0634b606f3a252 7d7250cfc21e1541612d3f7855f144b0a0207e1e72d8df677b65190cf02e7ddf 5574114cf814016d0f7ad980a9e9b8685095cfc5260b99811f180a864cc3f9e9 ad3121f14e781a125ad7d5b572e6ca53b15cc05f930d7d78a5abd5829fb8c45f 4932d1c99917b6ebdd624ddc327fa93859880c46e618de70f317bc13249d9d10 8de48011bc78ad45174ad35ffae35d5346aca70444e3c4e68bc4e15e684e81c0 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 false +check_ring_signature 310d6ae3c782043415f4b085bcc6e1bee6981da96a213fcac6658012112d8c38 4655f5072925f41d3ea72bf8485e8d0ad76bcc78a77797d7218cbc2eb9242d19 116 7807eaad662177a554d4203b800354f4bc3c8de88d359405b25ec6d01bf6acb8 243f963d2dbb7c90b2a482c3f50c64087612f1f6443888636c023cbbbd459ee0 75f3bac208e7e39e469115bd252522f0b51f79b815087fc5af3ac690b055fa10 3b440105b596a27f7f68e96372c4f23328321bba50f2b7ca8cf4f0f5f1573b65 426681962a10f5935bd863e9fa34d8cebaae83293282aabe0806a9ea891fabd6 2661411a67598906942a954f9d32314080a4ec8cff37d0747638209301e83f26 abdb73c4e6a14617ad25d8415ce6e85ba7a71f51809f005f38158e3b061018e7 0aa5045422b3eaa124bc0d1a5b2012097cecbe326de83ea10aee2ae88247e5a9 cf4a278c316a49dd8d725196420d8927c9127d946ef809d4e39639ff67fc7ffa 307ec0a8ca3988b3b4c19482de24f4f0c3ed306d9306e82446bd5bbab333e3f3 9b79060b6ad43fbe1aa1657c88e13528252b5483d52ba70a37c46075c1287a11 0ba5b1e5ed5efe1a38dd018ab70783efb16f8793105e77891b60a4ab5a8db11e 18c8de65a46d3d5787da3e24d6d1b3a08c3ac20dbfd725e60600ba509d57d15e b0e2a872213d7b5c988c76985384005c8350a6a5cffab786cb96a749dced5484 b0c69e8eef215af47d30263d683ebb1d5fb6a82bc2fb17c4e66cdc3b8d68dcbb 5f233d4312b43419693e83b49fc61c1e636437e5111d31c46523929c301ceb3e 88b4b7b34251b862c667575b8500261452c7ae2e3616500ffad9e28167fa8a3e 32b99a72e85973f02e42a86612266c844ec7d951190dca6109a134895a83560c ea79cab8e63834915f956676de6a6ee86e1a5aa54b4653c450b550342a31185b 6f7034b28634582c35e8eb78d023d701e07686499fd7992be02061624a81b41b dfff99a3046b052ee995b1fe204ff4f5848326fdfcf8c6cb621eddb52a576f26 fb50ecd29ff719550f2f7a8b361d1ea28b294c31718ca7e5568625bc217382f2 a1b967b74e9d0cccf61efecd2f7fcf031f497147ebe199b9ea9829bb6441da86 bba22d2526ff859190422ab652894ba8e01bbe7ea73ec0e05ed8193a3e282781 7e26df47de96672d968f523bb25f70c0529c71692d61936754834d8f3e805bde 196720d41c9b03b0bcaf3c4aa22575c92c9d96d9efa675ec9dc9204af95c7ff8 7c89452f01964e095a42fb57a6e984db6505f467941500b872198ff5443bbaf5 afca79a03977da951bcee8d0d1e352274394960f6467c9f36c6222474f86c24b 6499818b9a821095bd69a9a2a558563564bb8c7ae60fabdad58b492b20a2fe66 28eeadcfe2593a31f515623dda2d99b9b13c7152b1f03fc335529f9732a84062 d6483f0cc625144b6daefc9174b0deecc4b8defceef2676db19ca6e0a4e71fa6 2a3b68eaf64024e87c7a517da3d53e629c5d52e186f07bf71c0b5c0ca4ee3ac6 d0efe0979ba88efafcac1574b450c67287df9678013b9954235134f20a0991e8 b1ac8d5fdc7349d3256f9608e2ad44434e1518a4e029fb9835c8e96785ef1699 f23c61bf170b59f8226180aacd909d7f980bcfa82b7105ed8602cea24461c971 cab2fb00e4fd79f106d6f0691af0f4d6b366fcf0c43e7c13cdfd88a057c324d2 c1dbab0191310d3a2049d6811caebad3aedb0b03bf115a29397cbf257d9732ea 2cf4d6eeb523b8e50e39491a60d4aa1604014407418e69da6c89ef020650583c a73090ebe177943f78099836245426fefbdadfa897d0f16bccaf6a0c655db4ae aa68658636f6e9490744ab6d437bcacc8e341c3de4a637ce1711664f3230df5c b1dca726508f79e19eca642b16c45d91e5cc243a9da5699eaed5ce033f2e5bbc 064dce1f4218673c2dc870f68686d7edb2a4c2d1ac5653152fa0a4a8e4663439 dc04842faff17e231790b3e620e13cc7a8b9e9357a172a0ef313b541dbbcc8b8 88ff4293253d34d283c614a759ca0db49c49116be293aed9bd61c6c3791dfa50 144ad40d237041c33ec46697b71169fe7ecab10eb64b2f9e95295a3dd08da974 90fdfa1d1cbee0226380d54a42052d953b4d298b62200d10730cf5c1fdbe416d 3f4a39088e9eacba197cd2b04e7f256aac404d03932308d18272f157c9bd3e04 0099c85d8895d6d6f7862ee3a3e7aa347980c06c638f429ab1627729c7114d37 e02a9a6003077e2d27a1be9637a08e4326fc3c09fd1042f31b726bb85a399f34 b41f513bda48137483a891867bbe4a8b4ff7755d5a832b957aff7b53a4bcbd1e 52e94e34a84f923e1c64e4f9f59d28e40df1bd3de5ef9feb96f9630d446d3848 6f2e18e1bf048efe6fa42784616797a52df0ee8ef874f66b9dc22df70c7a8a48 9afadfb6c3891074a70c109008357405aab0246e17566bd719f5c3e28302e69c 7a37f7f5d26f1e0e2fb4737be23313434c0f8f38c3042c4c5bc513c2c9878457 fa19ff7448533b7cbc70328d1d4bc60f8a8e35e6b8e4262e63ced4881aefe307 2376d71eb07f42b6b43a14081d964b522b6a315cd42022c6b2a543e2af0880aa 5d6abf4d43a5e3cd12326e5138186ad88bfdf075cd875a0dc29aea2070c50af5 b5443d7f7944637ef8024751646ac3b245dbe0763f11ca3d985ff1b2119cf212 34aef0b5e69898f3e6befe6c1c478dfe0561b3192353dfc690475f3ead9aeecc d90b7c619b39df1778520430bbbd7de726d60349dbb8b168a07fbe3f30868a56 38b2e86d0d615080b457ae7e53688aecf57979af0d7f43d7b1f08600ceb8519b 8a5198b3e06abdc3ae23b6ab1ae6f124d1f482f7ccf5748ea08a383de008ec52 bb6db9c2ecf463a01ab6944f7564dfc59b5ff4926e5adfe2d61c796d6e1840be 8c0bdb356e786dafaad32e9ab1c9584637177ea339429a3eb0d54fc998a5a8d3 ea7b49409158cfe86ef7a25865fd690a2602b9834a401f654dabdfb725261a0a ab2f6f10735d3a88aae9bc15f86a2aa672d6998f7f44df84d3847910e8832fa2 7a2b36fce6aa5a36c597c04233dc1747ecd2b4a7eb821aae6364f95e49d21dfc af3b5d5721057979fd3fa0b8c7bf05a9f4bcde1d16b8bbb42d6fefc29297b296 8ce37871c5819daf2ac91d6110e85a2021d344d8749988c529a97b9efbe62461 60d6f0d40c7fdcce050bb9d243ac49108b51a77a692921981873811dc758401f 379e3960b1794be13fdde889a47bf76bce7d46b147e95e7169854e72282366b3 4ff8aaaeab595a10e0d64cee1c7c683b87996be35ef9d618929edc7a0f147e2f d53185e8d7fa7fbd8095e05bdc9e920678785d53c9a555a747eeddc4f17479ad f0a9a8e29a825e469180d85f1ad9fab70abb8eb2e3233f3d0b8338dcbae089c9 f64caa6ecdf7121b098a84782c67e17bba07873f33dc349ffa402f5c8d3cf5a8 cd1d783c1b3757c5fdebac0ecec5b658013b5ca5650273d697624241719ee73e 1f9f87a86a0a443e4b04c85df47de3d3667e0e310ba273f2e104c95de0240126 373359034e8df608e1c2d607df4038df5e200548c0eb1ac2e4839a7764c6b316 ddc74b8108db902ea7157a251d1f91082a5bc6d3d883bf6ce85bd7dc959c7df3 bb0909401335e0a0a323658b2291b713c2c5a1183400e926f632f1ff00dc8956 2e3d07dbcbd48a85e0a6b6eb26ac98c8f094c29b6ab4a1618edd72caf66a076c 4faa125f4afeb30bd7c8f5f124b9ab393c9290a572e7f2e4b8c3ec3bc0dbebc2 090f95fe51b6c80a830d645752ea65f93496d08a44baeb72abffa633d8f6bbed c5d01ae2b6e8e01d4bce71696c7177b2685abd5a29c5884ec7d049494cc3a963 5d80301404837b090ce9b13868b8cd9f15e741104d08e9bdfc62abb16c250391 8e729deb0c68f60ee34c08bd209f031a8505f939264bb50818b4b8f50cc3c7e0 bb871ea3855ea09edd134ed241ffcdbee7a5aef8625ed6ac3f0de23cea07ec1c de7afee7982ec30b0a54a105aa9e96e736e92a0b9db9ef6b5615d15ee975bb3d b37aca0b6fc23749908ed86d6a38833765d7ee741e6ed2177b507ec4e89a491c 1c46917bb4d35609485905b332053c34e2587a374640f48180581239c64e462f 4814d2b538a9f657c76e3223542fbeeed714054ff83d66339e2a674e471d60bb fff3d13262a472102c092d648e2bab278a6f6b1f337bf03d2929a005521cc1c8 dce34021cba4d96695699a962c02c861645877936ddd77445cc7314322f3db65 39922b7a3cf9921d3942567e98244be13d8883831f928ef4b8732cf1d1c7c7aa efc52e8d2734c19b3b592e47575cdbb2875c2ffd188ed8530bbd8b7892e1d6ea b2b8fde10a89a646596261c90b1591d895d2dbf38d7c9f1fb3c633107ad8090d 78070fd850d00f74cc4466ac6770ed783ed0357bce8d43c4296dfcab58aa3c11 c6037036aaa75a2074afddc9b8fb582cf2da23e68f26aa9feeed6f2cecd87cc8 32af5cdbe471cb2be8b9da434fd7b18f07a49385c25cd2e9f6ad8e09a33b6339 03204b77ed926205e2e5e63442a618b6fb009d6d73274a40ae69bb5efa760954 5b9375d7494ff5b1419c523a8d9650a80945d7be9c9b718ccbda6c4d4b506b92 555b6c2c1066f4fee1e7e49696bca4767e12ded606c41d0a80e6b04c1cb450c0 f6b5fb999795bfa7e11ce874dea099bde7f5e7dbbb00e3e9bac9c840e6f5e7be 11b69160c91fa243f82d80f47334352bb93a6b656ee7c12d2f3b53efa172c439 65f0da19b7c34afb952aa61249b1237dd4b7922623bc1ed9291cc04879981864 1a0b49e5fde43996062eb5aaf2689b6e34e90d9d70e99b7261e3ea79c4d1dbf4 a93716c541db323ba60066b9ab4b6b88aa874c7ce9486205da161046e02969d0 6e4541ce6762b2679ece8b983f278d6368343a8472afd197c2dec79436357edc e7894f77563b3259028de5a7fd38ffb888f8d19e87c2f400d53b737413bc6241 4e229b28f42ec0c1aba8d69401610ee13f2abd51bab8c8ecc6ce30b69beba5bb 187eabf0032d9a5d656a5ee1a853b8ee7d5775a2b406bf6950920ba6770a7498 d6ca4fe3dbb37e0b63ed5a1051e863697005560dd650afdfb0ee4a149a04af67 714a1d186fbae02fd71f45ca2dfda9c1b9d1c3981f8f6c3107dfc382564afc2d 91ef61ad2bdfe75385597e803b2aefed3b1131739364dfa4cc4c1aa3fb571ed4 2e6cd6e9491b1fcd10e8276706d342bd0c1f7ab2e1ab16402ebd10342ae46b2b 5417c80b1642b1a3b77a101636d314c82ea2f0a2375b275282e3d785c9001264 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 true +check_ring_signature 1bee2307cbae0d70deb765ea6585a98f2360ac5f2312d53b30160896d22d7e69 dfc10e8ef7e54df0abcbf2e37d6e5240242831051debd943f2c97a44f18822a6 22 c45d485befe03df7c8073e4fa034cdd6a3b5d40adfb67840f3f919796a681a78 1b8c4973a61cb07fe9599d95c82476b9aa4578b620ef20d7b0777ec52b3af0b2 35c6fb1384be87a117d29795a707d311db29a4acd23f5ed91944a7906ef3f2f7 eddb7b2b8e8de4bde4042b028915489ab990646eb09ba7efdc6a10eea9a45416 5ebd85c8babff784c1ae931bffc2de28676f0a017cd94159afce10b9814ddd9c ef816b04ef9307d5b6778731b69dd6d466bd0be4f8de1f2bc1802fd54ceaf60c aaabeeb56e0af61da30ffe24674d808726a77e5dbf1378019f998b196e1ef95a 0c54d3a2c1d24bd9a1731a44bcab632e51b6daa5dced8302f636c5fa1613123d 471192b5ce65856383a16f4dd5f459ab3702a005c1500906034f46dc5abb7bd0 7940d0a9f9db9adc473486273108fe5485e933466a50b239fda165e100311b2d 3ff46e21277f805db51d846787280d617d00dca1e6053c000b789bc46acaf9be 5feb804d9bb8ee880e3ece47943d1ed5230a0240bd8212dbd51801c14ec7306b 3a0b1c8bd722d56a98dbbee40e741b857825457cf2bf5caa9a8e418be24c999c e3b7344146e4f945b1d37260bfee459535adc472c6fd30aa13804ad0b0e6770a 4fbaa8d028d7eb59312a4b03932d4ba627be85d55ddda546d050c708456a60cb f3d51d875c3248b571964b92e73ee660fc43f943eea989e261708d49abed67d4 c18a3f55e81463b0aa274eb57130f9b72c71de4f9faab6d3b1a1bf664904fe8c 93a8aea6a911b402292f8c0475f314da1da8a2ffdc7fd3e8bb3e6096bcf25401 9597f623fba19d46f1c10cf99eb53fe57ed666a11847cd2ad4b708d8b9d58cbf ff3bd3417c922c47f72603ff5bbe698562707fa2d53d15b5dc72d490bbafec33 dbbda6f78f7b1a3db04a220d35a817de3589df0f52b38af3c7c0b67f5d7ba501 8708cfdc241c15b8f906f54ac943d64a6519197f0016cf65b8c06668059f5e3b b56186156ddd66c41fd56b168075915603dc79a3506fe7515da93db2ff49cb0a6f1cf84d1c273f4083d9b01288057bd98e298936c62c365382681c700f258c0919caec23a5472552e3b8f30c70665929b875b5dd63e82ccb31d9d8596d992b03d22557852fc8823f66a3c77c0a1e0bfe22fbf52beb359e89a63d9c1f8c91120096e6b7aab41b779b7556d540517558386b80581f0f205bfaf0fce6c7300036038d87ad67f74a58757de877d91a968e070b772e74c15325680d4288efe650df02c08bbfdb2035b8dc2a43be7b3f725bab5253bddc23acdcc61f7b063183c7ee0b7da40bc2bff5fb29594967c2187f21a22972eb3c56139d3ae1333c383adda403cedaad74e36281f046878424e23b43fa32327fce3be3b561ead37d9c43627b05453100c42a00e5f68e92f7101d47d49cdffd6ac9681d4beac4d4f57d91a3220ba3872ed6a5487c6d8b6323503967db43d3d64673adcaacaa4a643f292adbed071f17bacfbade56afe027ca6e68a974d397e6663f4c5ae459da3d661814d5ae022b87077e44e1328bf175c6e3e47190a0f2d50d0d24a4e7a7ee7623b434d92508fec9add44c626e2f71be8589570009d7a75dd3062bd4642f30ca0977f5951207e0eac4972d949358f7a800f572b2c007aad666806f1e62467d9e667783a4e503a60097aeced8df2cd966f1c8de1e69ee2f316d9ec6d25014367daaff02c1c80b8bb7785017ddfc53aa92ecba114ec305585428a27e7117c7c0ccddf7b7ac5203adf82c0f0ed2c9e01dad05a8ceb523bcfdf4907d8a46079b0ba7f6ac2422b2797004ab75a0bccb322d861805d73d905d7dc4ba6f7775e833a7389727a928ce05e38ba96a2d388883de471bb3dce75b350bd6fc1efd316192719939cbeaa6d001f425dccb7d81401ca27c7e03681dfce38b07ec8b32e333f776717d9c1c16af02a466ef51da0a09bbbf2e8090596629978e81cdfca698d174b8efebd941df880d84951275f1d6b4c5acdd018f5bd49611314613a3d8f787b8e989b5d45e503d030ca8b2c253603eaec69e0d03f8a07b0a08cc0c8be03b4f48de90c32fe8d22a0c863aea524d14f4d8c491530ce8b672bac014086b29af1ca984f8fe1cab93800c5cb42a164371410f053988fcf484c50570c80d92b9715fc3fcd887151945f503b519876e0c7e4bdb7e4f0dc1bb534ff4a1155f15068423a79ccc294029fbaa086a8286f8765703f7f39e885678278c3cfc3c293dc98ced06e434bb87832c5303b7daa81625a7ef6f28b0a4123d23ee6b437416a0b17e6c8eb770b034e63d16035ea357ef9ee54770f292400f1a8e8ef83af638772802846d5cb851e83143ec072387b6da9368458a44a431891ccaf5e706cd3a05c29aaec6a6e0bbb91bc7180380ae57fbdea2fa0bfded11f97866bb78b09f474f28473007bdcde7cc19b075045f278cb3fc87d292090c5ea6f8dd198803accf963a6611a03f8b62703b6ebe0517165083c438125597a5fb5e6cb322276d746591a06d3d3f063c2a8e0927890b243084a39109752a50df29a32530d5ddeab48f962c3d7243c22afa89ea14f30864d48541aef11add3aa02b7b5297de4341c9a0d03b8916d5f2f6dba731dbe500c0ca5bb9c31a4374e5887f6511b0a14ef96d90c3071a9cb019a1341a01ce710eb2f5e1dfd060705b445f328c9090ebec09ee03d084c38c7d34bdebb8b0bef70503e932302e3b757d9c9ba8a9508923ddaf16843e0bc37b9004053ea541b29d0acaca4ef0a6cb558509006939753bf8c873e8cf894793d7c650d108f3aaddd40ec069723b3ca6fe894bfe6a020c54c23a12f9e5373ce4241f8c7f8700918c3b09c85ccea5a50477c7833b7c3f535e01edb8c45b3e8289158ffc5197aacedae50c3e3e91808f46f1bf61bc6c2924cb3dbcc31dbf44ff3ec6143316b74f8145570a5f834e4485bca12df1acdfc352e2f6b347fed182d7f34d9df49b33d2a49cde02 false +check_ring_signature 21895cc59133ebf0004c36193e05c4fc127cb5bd555dc63d621eaffed8be71d3 ecbafb4b0edf27dcd8eee2990eb7c9818e2d41972fbec6c351a6f0bc43b0c85b 5 37d69e45e5f7e7a1bfaf81415204da2a813010f1156bcf423aa2d643e73cabe4 78a4d36d922388db274b312324ae0237ec22a97abe3e0005864a99eca591d767 569eaf9aa27c1a44e00771277742c802f4756f5d2d251e410010bea0f3c793bd 9c3aba914a25e1d8c60415f6bbd5cb8da1f87ee96f0d66a0eb728e5ff2465fdb f135aed402f9675036a6c57487a49bc82b8867971b154c58c688c7dec5327107 e1684019448b2717d4560115ef905501d9cb996cdaf5183f8474428d7dd7640ae8036d6694a1dc8360f0d5e95247c0b255774482caf3ee158649a786dd34b80974c4549639a7c496cf134559af29020eb5f86f199bed4956e8005294851c83082e29da64449099f459a9b4cb41ebc4fe641d4b88873fa99ff127121446874703f8f6becac5ac81433b2e797e8c06c5695988597368fb7cbe25a45afe883fb402c520730927e3789fc3315a88c77b5b1f527eed371ad35c248f1c748cedcadd4d6b2e8cd1a683105b3d3e96c3cca4b5eb7722a7313e5e52b37ef294a7749a260f5a58496fb0d255a44e9b878a13a7df801c4ca633435c2c0ebcfe5b8fc2de0704205cb65f55485cbc2ee4acde551dc9e6d63f06e9ae76ad204239b96e78685700c0bd5749607b69522cee9b440e1ecd90286afef5de1a978ededf91a951994500 false +check_ring_signature a1ceb1e28cf7539702f29124201902f89c576a9dedc08b532b6f32f4714bb5f1 9215affded4f3464d39c3468da2170b92573ff25f49754b8a276c783cabc0fef 7 4592c2b238b2d62b85575544b2537548b7ac136856aa3a4fb8c61fad355e6856 8062de0f6e58bf5735f731930b04c87f0f972b40575b37ee13df8c6bfe3d3f34 212e3537eb76779f2d59cb95a9128d98bede8ac721381434ff6721c973f91d76 9296843a003ed00eb5f0a4c38894adf0d573d6eec2894d455293c8da2e6af29f 49120cf0c3575650e3c1ed19cfecd85bce34a9bdc21698f073495a9cd495243b a6c3dc919da447bd3fbb1ef1bf398d64f40a158d669a65d47857cb20635bdcb8 b219b7ea9550fc7deeac250df0d713975074116921ed26d6f2c2af0dd72def7b 8bc3428f3c8c9d8e812e0bcddae48876e0efc696d9ebc39d0c688166748f72022c99772a8fd69ea904af3905637e78ef69dcea09ebacb9d241672cb6145640072fca8e6e28dc4678168953dbda6f0f69d32f779c4d744ffd2973e4d88053040c49b2643e60b0517922ef84312250ca2650dd85174582ffbdc22b057c243e5b01881090479c92dc88075651a3e0b2bef743d37cf9f4469b27fd3f4f698886730f9bf90de572444ac2ddfa169eb32e357fef5a286afe0ddcc4c14251453dc6c80ef21fea6df568479345218bc235c41689460ee06803755b7da4ecfc0e63309a067478ac2bb001bf2b3b58e9e087c4d9e8475b0d0d61074c9ff005b3e70724180e81050c52f2e5a4a39b7e63b4727cb8cb6af33683938f8331d2c59631acd2e503eb566339f6575e034371281ef3e27cbdefa09cbbfd8100d57ebd5b41f68fbd09cd316728038f6b59e837513f93be96082db6d59200e84a643f5e004f310ea45b4611f12e15a95f519222865dc3b557ef0c9e94a21920291b11e5e3c6ff64bb02836ce612993dc48fd652f7bf64e3f0c215fbeb15a5d34ac45b9e87531ab2900fd3b2d970942f61ec3e0db7feb4b21e3caedb7d98833f0cef00affbab7175300c false +check_ring_signature 91c96196c234c8360a561f05e5da2dd0df8a985f551e177598543c330597b9f5 9c121c8fe41c45ba3ec374109c7ee8bb3ae2f16b9cee0458300dcba0ef2f151c 193 e161862a99dae815c0a5217b0a675d985d24cb1b234af8c5bcdb7c1b5b4fdc77 7121da185c9e7f255d80df00d815f6d05190465dc1291e28b2d88a09fa79e91f 868b93a12a9876467229b1ae65866de4010fa91597df8e5dd76a051bef3e4fad d1ac8e9547501523ee84dabadcd54fb4e28e16a8152d558634df32dee382e378 67122106e6c1cb08b9efc15aef3ed942d1c901b1553d0e2ae350e82768176cfa 2515245e7b7d2b38ccaa8806b8de0a08671618682db8a7a93b3b2c457fa43365 94e9f5fb2ef1fbbf74385bfa5beecc2cd38dae1b68963214c6c77a995102563d 46e220cd8a58d8cbe0db7c1dd5b8115d5775abc484426b8ad197badd0534bcc2 1996fb0da456a5e4f58ca01db9bb03e6e1fab0671fcac965621a556f4770acab a4225350f4e0e9f647289db0370949b64a0aeadca3efc27764ba846c8d3ffdf0 718b5e839de4a375afe2c75eb856e8927dd409f76ceadddfa3ca530fe493a01c f8bbd8593204be709d2bbe893a8db100040ce0eef159c98ebeeb6eea9f7221ca 3bafcfa2817b887b77ffdf7c24b058bf0017167fca57e1357fb110758fa1fa20 08cca9f73cc1ad943b1566e7790bfeb62f67b282f5dfc7191a41eb8d08bb121b b70fa8af1494810e3b3dd725691660e72f04bfaf358fa68dbdc4c219459124cd dd82ef68116ce09705bacd369b3ea9158ce5c6c804915e788a7f13563447fa37 b8524e8293c7d7b22d25bc99dc14feb769f2bb7beb75ae2274fa49d95d0d7774 d3850c2305837f933d2277238418b208421d1493141d1ab756e056fa7d41cf6a e8db854c01dfd1726886758dba64cf0d153f272a63338924a838613c9a06832d 16e8ba39570340f24524cfaf101027387bab6bf60326e4d7bc4be72dc904cf79 a5293e175287fd7a10a0f8bc0121df46380e9efa8e80ab9644a6d1a220e9472f 8588de4a93aca11147879b5332e5a634fa8d8ec0a0573550ffcbaded51bdfa66 b4779f8ded424940af83a6841b7e9b894ac5759a7af25258311f52c98e3dd509 12890b61c8ceeaba6046f19e1090731c72a25c4563438e8d185c874407f65256 fbd1fdbd9fae56a72df8d02a89144f374d1ec2345fe6d87a7ba9717437ba7b19 5809a152e2a50d71d056d27262687d28502fc287c5e5477a43f07995c7754451 d055af4076b2ceeef2e7359950fcbefeb63fd39eb233a004aba976fc4ea0e77b e82b74da77ddc12765f219815f89b9b67417515b26ba0682cee0142c9895d1c2 b7fe388bbc75eb37da2c4336bb300db8e56c7d60d43e38c117c4a66d57b7c78e 3f9bb068b366b1b8a3f91dd4a2d9efe76a3c42c5b59239e1e804a761605d10c7 d8c61f4abe890c25e7b564c2b119e033f86bce9237334953be942a9cabb599d9 407dc82419c3ec2d8eef6dc0b30d48bf3e52e1a60c094f1f704f19154c5f39b9 9d76fa5bbb8c6915177b98cadc434fccebd7504dfb78ae7c193f480f2a6de9a5 651f507857a6873ca14dfd136efe28db29fb7cddf1914cd98b4f12354f7771c1 4654f0e017bba46280efb2379af5a4671ac096faee347479f1fb177c06392d0a b4f29d1eafe89f4433b18ad6ac9b99203d6c331c86db324601d9765327d9c4ba e74ff089967086c994f648369ebcb39fe3fa6753eff2cc6553a1a84186c701bf 41f12df6c52d96c7ae5b58b9e334b98a4e39db6f89459ba39569d1192bf664f5 e8d1a2b82fc477d08f92272630c88253f3a630b6f125fb93652363577bced915 b41554744802375e2c0da4a46d8b63200dbdf80db23e11025348bda3419aa1c8 af44db4b23b67edad57731a85371b057caa7dc9fdb1cbc5c882cddb6eea3cbd5 3ee37268715f4b2e7959d1fd9d0060f194c289e1560ce9dc49cee3f0d3230a3c 2381e1415f6888dea57bbb3235dc75bc33e425d29e5610079724a9ae62875ad2 6ee002dce5a8e5d0d52c24b1d24dcb600847917cdf31152ea3a2361b4e300205 23ae7949734cd7a92206e7e3526a0aefd0c57942370b5d9e5d2a0efc04ffe832 a3d13d67723c4ed153d6e80c00f68481d78e804c75ca62c08e1ffb21199712e3 493be63139ee40c22b0b4cd78b20ebffd5f1e33c4feb8c1c8bfb6415d9b74745 e9359b412f4bc3ac21eb1095f50efb9f37e9f8ffae075459e6fb3fc9c0cc0dec 17b1930073d4d52366076e94a841577fb2bfdd0b946f7e37d32f9a657e17fd46 7f17f005bd7866df24cc4931283d94ffd0ce6be0d8ad6ede768ac472204cc05a c41cce248f29ea63f7dda29c5647b3a26536c73d298e31d63cd99fe8b50eddb1 296122c8c5f534080b20f361a7e845ca954bfe3a7927c318ad4e6b83c07dd1d7 5b3df5b707756b3c833d74a0c25648a5d130e30530280e7f3df53b09cd6eb716 d96da542b5da7a0c227eeddd2499e5e754d96df6d02085ec2bb486d1e5a42163 7be9c67253d69b68ec8f647fafcd269d4eb0abf6b54b564553e0a6fcd6ec93af 34027dcf2aaf47fb96bf715bfc1c5c5882442a136d4d9ee613c922edccd5a953 d05765857c4fbae6f8dd06f73b76299f95fe6b4fcfa3a70ca9bbc91a49a9de0c 1e72257db52cace73bc7979f06addce710a5ce34ac62c46f4e3543ba4024b4e7 a51ca9ad9b001063a07de8deab3eb0e10e8acf78628687fe26718f90a19ad05c 7e501131246a3567ccc0d7ca21741d55a54411379695c188d7036358db8077ac 2cf9fb0483a55f8d7bd2586b4e9471f319f259d453a776cbbc3f5445ea09ede8 e48913dd6cef97282dbd49f901e1a9cd6fc0c87f08a8d4bebd1f40595ae1cfab 1a2d07d4b426a69052a4976a63387356140394570159a51d6f52fcc64694d8d0 c74799705b1b3a25759dd5d6ad7cbc3a2e52f9f5d329fd3e2abd43d202db2412 0e191d363505d184aa67da6c5f16599c2120daa59b5bc328f3a24f513fbed87e 85022f199b2c5063a9c1deed15d761c837d51252f7beabcd93e2c9e9ebb067f6 4fac2d2d8e55a6244730a2ac6b642faf27f20b7a8f59dd21e4fd8e4ea9a0cc9f 4cf8659e5f7c920f10b7f027215aa50d75377cdcb2316b89ae88c8ebdc9983a2 f3fb3eac0a57ebe0531d1cd506905a7faaccc3ceca80c19cdad326df6525892e 46f413c203785cbce8db7924f75f5d90907c56a6cc67c89be04245a651d95fe9 f6621310288256e3e799793220a9b1c9a90a1435ccfea0be7d06d2cf385b827b 9b4bd622b52628480455d694b9f218c927e710921be5f01362458b34b3251aee a214ccce02e0da7ff54638697185d5dc61c4480ad55f260c8cde16114eab948e 2d3c7f5c6d45c4655902ec442430ebd92336f03b272c5e927b51093b7f91a973 ab67cbbc528fdb606eccdba9f5ea8271ff61a938e9a43055a6d25bf8dbaec37f eba5ab398362838fa05fbcc1847834d5af81df74100a33f058b2664a511cdd5f 696f0ac7c74f9972ecb84b4e3b35e15845ce6a3c1c7d6829b9eeb670b1d01f2f 7acfe1dd35a458a98a76015bc9569267b33b3b2d775343dd7ea02cf50887b256 2705f7156b4caeadaadc47fd02e3732bb728640ed61b9c1870afff0eaef034e2 8aa19a27e43d8dd0990ac65e8a51b1ef11ef2f40eb83281ebe61cc81c2874489 a6bf939c5c529abec874124b71d24ac6347f77b1c01f82b5f11dc76c9c0ccf4e ddbd80ffa8967c400794b5d91cc874abd847d52263238582c2752ace236f9241 fa64d0830fd00bcdb2023fda400ababebf39af7c59e94c2d9c3e4c18d1bedd64 f65ef60b181b161d7e602a01d839019010b259e4eb7ef359e6d5b538d0665740 b38f94c5dbc53de06f0048be4c475caca4003507cf648377ead7d34b577f19d7 e15dfd5a89f20a6d36d165102bb959ea024541b29f56dc2d49c919d7516d1170 c5fc2a9ed79c26099659754e3ca1b80315ca57892f843a578340ae7fa73d3634 6f5091724ad56abb7972390808f6fe142e650c5f9ba0de8756472c8e5f51be61 2648c79d0339a2f60aeb263b45ec55f2bec8a30bce8f1a330e55e31cd283dfcf c8fa210fce5b69a82e9dcadcde20d7b91eca89c7103d0178bfbf88c11d11ec49 33141beaf3621ffefb22797eb08d9ce9551424b1632f825fadda731d73c4d51a ef4e9c88061d7cd88a2380de59a674a1c691d187b0d992b28820465fcac67f99 e4f20cacf1c9e8f05ccdce34af65344b4e5cae9bb9b36984e2d8f861d2670890 958c2698e83219646f07560f3f205f3c49fc1f4f79eb8bfc4525b64beb9821ca 0d78f83e62808774279f5dd6e02e53389468028fba4eca15a1cdc460410a225a 0c674704d18814852e547a7cec5a67d3170638355641be3a48f8e5d00045cef4 1ea41e2b9aabe377a04a49f199dea7e61d0b9778d3540fae356d329d9052c5c3 dea86385c770f40a531abaa73015bbbf7c150ec44f01c74e53c11c5645a90a34 4c73127881b53641bc501ec13f8bdcfd85af76fc33ad6abe46b54da5cd492dc8 4d1fe371995472084ab0059e5d11188b223c17282fc89df118ccd8a702973f81 75ce45819d1a62b6f619c30ef1e1255754438a2fe7f76fd4480ef997ab50a554 5b984b640e4b9cba7d4e9b40002421051ed8679c0cd0240c614025768b551cab 82332c7f72e3d98872b06714203483af929fb06067bbd3458f6d8b75b0d550d3 4c29590b25aa2457c8de88dc45efa6d55800e0ab5a233c02ad26d19b5bedffc2 29bcb5493c220fa2f1e4db2ea4d022f2130c4fca2fad45fa5e151e376b5b9daf 8d662e8554f94a61520522dceeda02c8da2d56d682380437bb7e7e7000337c0e 012f84568e6de3bbab05be822f2dcd3e0019d873c5110d2c8a8329c44f56da33 621286d6ccf00e35785e59cfc589b81946359f82fb6195b5fc5199edac11586b efb019c49b35c135c095c13863dcfd0e8ee4eeaa4ffbc0a2dffcd24ae72fb266 978bb9d5405f956463ae75b382e997450ba089a8136ce95ac1bf2f07c86f40b0 db3b3ac107629e8993f38de924439c672f66b4f4626aca460e86ce4d1b05a9b8 78dd68c749d267a8230a6688b4356bc8e7192e67afce456b4966f38e268580c5 1869040fe2e6372ef82a8d4cda43a49bbb5f8b29bd7075122d25aceca048a7d0 6a7399db2ade2a40bf94c2c3e28a9ac8972e18f237a77364242ad7ff808111d9 1ccfa9cf961e12a0b8e220eabee2166e1d5e03b1b2ff6acbb9342c3e61f943e7 e3861f895559d30b28af8730bfa776c6127e0a98d5c378833dc0846cae1b5f54 c13516250905ba3760eb3d9cec410a37edefe952d97f6fe9bfceee544029ccd8 ae7449e1fd0bb6b4ef3941ca74caf6d710e5b8bc0654a8b740bdee26ad2649b5 d8e59f284cd7abd2d20f9652bc54a6dd6f725795f19f3701ffa4845d613129cb b22bf5a0c5fe152380c50e6f155b68b0971d707baba2bd53e995d2700facf3d6 d3f477858df1a9ac4d44227ac73e38bb6a318d29ee4653014c696108d05713ef 7dbacfc64f214324d135adb0ad7e20fe63aa8959c8502c34784635adcf672b4f 6dfbc709bfc859ce5d662cb3c284c86fe4cd2bbb9df777e55cf20503d3eff1c3 66ebcc577c3de8c45b31ece1ccfcb6d1411c40a27859797f3b5ad0a70b2e6081 b63f90395ed317237d5833d424abd1628a7c799c0911847576e65944249e8670 604cad976aa6284c18fa49fdb84d5d8d80a54c4740896b1c979ad4c44cd059f3 b1b85202902801287f67b5890bb1ced239d97e2311ff8b523cd51b6ff11dee46 32a7caba85a3cb2f442687465fba4b99402a2211bcc60fcf3011e093e0d603de 2652ee4ae8d9444d103e92a138e85737c707169280ae21f2efcf86a889c44576 7b1ca852eac13aff8342de958d6eb66841a432ba45e4e0c0546fcc25076363a6 63d964103c6680369a99ec33309b7a4b28e3168b2c0d14dd6ad0e047d8a98ac1 300da9fa3bd62dd3317c034e5d382134f295cf52f5a3a15f9b7149a085ab140a 7a2abe067810f916735f11fc3eafcae30c7cc466e6c2d3132ecdfd86fef2071c ea4c30ce57f207ae4fc18dfbdf32e515ef8aea1c28b9dc3984ee0cc9ec45f41d 981cc22979a6ee32d9d052209197d819caed76a573c0d98d95af997d1a31603f 3ff6934795ff1bda0af9a6b89cb70e4c0ce34462534cc9e41f86956a62f35029 93044f44329b2f80bc79788e8d216e1b6547a36c6675ea32157ac9712d83e078 f9630497226ce1f3e1f19f5a00482a46637c1f0741766170649eb4ca50d1a6c5 9bd9a86894275e31205158cdae4ebee1ba90ba2b84a0b2b7fd6fc2adc014b651 68b487bd1b15792da5b7bd1855b780013733ec2f46c72b8d259286df38f45472 4baf89810b049b2207a2e33df2131dd7089c161d61dec454bf29d207f7890afa c63216014b78c4c2582f14105fa45a3fc2b44cccd5006e717d77f4dc1fc16cdd 2f88b590b978261c9c1f9d3145bbe8010acea2b5736425610dc29816900bf917 5f8e13f81295adeedbef8f8d611df75d9c3d607524d3a2d48395072e559f9867 9be16bc0147b509002ac9961c8092298ff930f3055d68bcc9dfd54c703470043 478f7af7f6646765e498b9324b0223882c0c050c36068257f59e9d69c61ba60d e875b111f7254650a6a0d58c2bbaf062451d9274ea48e2e9497d35aa72aeb76b f57b9b8f3c4d8d9c03f992695bbc410d1f66cd94ff1d9926871f7413ee767525 1024ced84e85c932c83ff6d58076ffb76355fa4624aeae93ee92dae866c89c0c a74744d6178daee546654b5204bbd3733fe4227eabb4295784090288db2bea03 6a80bb76ba087cf97cf40364284534495f5fc65de38acd2d537d0c3fc99ce46c 334ba343a14bdc95cce0a72d8dbadbcc5f59beb2d9b0a777f4ff64ae0d4294f6 a225481439a23811489e99068287ef24a0bc8c91aafc39fe06d5511b9521fb4a 04ef78c6aa557b0a7b0c7419b59d8c0f3844d563bff6e7a210882216a358359f ea624d34206592e2c45f7c9ee7d74de718f051f3b4a48a61abd85e0d0c290d98 a8820dba71d62b35e4717aa8c4bc42ceb16e32a2dc856dd5ba3bd72870de7abf 7e9b06dac3b7bb9eb053858010e3a18e77fd8c0fff6f0395bd5b8452c59d0c18 d742ba47c5ee6dd0dfc960258a90f4daa7faa91809baaef005c30e543674b8c9 da6963ff7c64cdc58fadd4636ca45f431bceab8694618c823cee20f7e188c254 ddf4bd50ee7b3d5caefe27ef54a3f4b732333c558f4e7c5b4aa874849ac50944 e647071ea38ae99b53087edf06156ff85a420d35455d5cb68dfce219975d0db4 e90c1ea0a57ff79857e003528dba4eab4ad98450617d6f75bb257ba71169de62 2a4a02456239a17fe7f12434629832d8139e3a883dcaafb7c82d14883fbde442 179f62b40c704c509046e5425dd9823f677018eba18766621192cd3787f956e1 be99fa9b0ee10d5d16b01419372dd8b27ffc59ed268fb916fb62c007bc03c4bc 8a5700c4b06c4cbbe778cb573b954546b7bd50f9ed0bf68edaeb1c62c7144621 afa2806c478f8eb525c3f6c10dedb57463e266a7bb74fcf4a398242cdb373645 dc065f497840d0e64bcc10ad55d537c1c0063b543be94bd194b19c04370d6ed7 22fceb6e94eac5560cf080b5d4cab3ec7629e44faf999dab219910755f65fc90 3630889f01d6053111e6b6b81f5322d48e3cf802653271918afda028fd610dbf 7e0590a0b6591103b696d6191cdbd734c9a298ec806e445520e138766a79a6fb 95c795a0c79207d607c18f9b4878801b51c0343121d2d88572d854373ff0f4c2 acc301102d1ca017efd7ff48d1e89d5798e2c0316a1c8a2426b725f7a32422f6 512fe979cb4ab14e86e38ee7e91ce314bf41bc8545b8fc9abf50f243ddfcec17 3fe18f13a44ff9057dfa3a8d991c1da262c70c85d83f6494323edb2a0ef115fa 4fff7ca8ad7a8da147c26075da5a612b7cd9889b2ec89b2698ea4cbce420ba09 50a505cdf0dd91f3436777d41a6ec954356309a339b230b7dd2884ed3e5c6ac9 59c78ae9f94a520bc32525c70c4ac5856057dd470435dd7dc306163f8ffe2a45 4feedca1721e8ab967a9a811d3a54d8d87702b7191e7806ccead4f28b63746c8 d90248f2402560e288d52118ee92e9d25c62ee37b71a254472089bc9f3d556bb 47cff9595acb876c63dd28faf929ec0dcb4611e1e178c3ad77c3db1cd10535e1 28372fe85facaec13ffc1dd7cba6184e3bc33bcc7f47ce8b45dddb0fea398172 07a524d12dc6c779874953230dc4959586b3af0bebf5fe35414e0b1103c127a4 11db38c2d48746d3ecf43c84254a3cd0ec3734c3b3788c5814ec34edf209977c b258e81d902b876b749d4710296188f2140a5ffa7502595fe84193f060d6e60e bcc5dbc52d34ef550fa4460ed0084f68643e7d53124e24bd84f4a2df86211cbb 27bc7aed7ea316ddf5011f4e888183956c78674d2c81aaf4097cc1126d3b2f0b 673ac5265aea52c4ef3bb9f183930e274b9f6a85158089199bb1d6359ad7b946 3d918c37bb71d96f2cd7994b0e374b3bc5d1bd8c37dc4da0dae37fa03cf0286e 190e5082988924eddc9b7b521248d098ca4eaa5e3bcff3061d0a489923f4cc3f 755acdc3f0b93afb5a0a328a9dc292f241ae42385b921e487649df858513f58f 4aea64a5c881de6f7ee664733f109b4c0e3e0eac0cf3015c733b477f29bff980 5ed467f8b37afac922919bb3b756736a6e6b68369a12e5b3becc1da98a9f0cf9 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 false +check_ring_signature 5a9a0a48720a3d2e72605becdd28686fa12dd934bf895f45b7344a9a2872a00c 9ee8a069c362287ae2d0d99807ecf3b575dbc1a80a71e50724a0784ebb74804f 46 e191c54b27b199ae24ef52dfb588542ce2298d4292f38ce789a13057ec07c95d b7f9e81e7da0611deb90cfa9992ec3e2192d97abbf3e1ca7b04e0fe0e81fdce2 55faee4b1a535e7edfc58f4a8f4623a71fc941969a5f57a9435dc2d0514814c3 4302d297996d35d929270ab7cc615d54559d8553adfd63e61d1d3975502b0801 fce7078d786ee0d8a6b42f2d2836ed5e9da2de251dc5127884eb508818724009 24b5e7e4a276f71d904edaac4151a653292ef81727580ab128ca49fea65d511a 64b0b6b0fbf7b33a2d86f5e52db7710381450aff22693aa637471a7420481e21 2d7a4fc11d17b27c99d6ab8eccbbe97fdaa4b88e00b027fa772ecca0f784d1a2 a9a8073648391840aa216176561638f58e8ef039bd8c536850a7cd918552ba9d 5840e8b047e890b2cf6ef1185198d0efa96b620e12e116a46089d7d3539ac4bd c34b311182eaba6866aea210db26bcdc07fcd1a850273e8bc075768ffb4752ee df4bce9dd5971a685086e11cde6a01b265aeebd54a0a8b9ab220c509b66535b3 4cfd8a5c10b69c27cf0de3517d51fad60c1550c271fa59e6fb7be3449a294387 be8ce8d10ae6231f06299cf96bebcf85e1094a4243fec4e2be1851c45e4c4f1d 19e1063f0d942044e371b16e5c7cbf5c7ba2124fa381ac3933dc40d0a6c4c198 6cc8b55601d126ebf71492b960d99af01699eb8a8f0171ff8be9618971c129b4 35e7648c9904a45de453046db0047491d3aa38671784710a47713dfddce5f7af 0b98d48d90173910755b1b699af582c208ccdda64908c4d77d69d0fd388a3fd8 c6dc380c33073fc2515f47e71c33ec0dbec961444edecbf5024e9554c6d24e3c 51ad43f81689cbea9607157c790491523b19ea896c2249f12ad39251cda4b9e3 3b3b52ed5b6b0c8aa9a3496f85a1509770838c42a66e3731ccec97a32e8254b3 60f655f6aaaec6becbbad2b8fbfe8bb41f69eee2be8d4449a5abf4a868b631fa 0870c0f0bdc83c42ff58892295e7718e39f8fc3e3229051f1a23300f9cf3c609 eb7c3f1a0eeb55cb8389daad37a70bbe084c27c5e80fa4dfcd32c46b519edfaa d80cedbdbead4e1e8ad72de6a17475f966009401b5194217b358e608fea02ca1 f3a8a945806a2714a7e44fbd9b336b9e0530c170710b7dce23c68735c1c4c525 a5cec0e8362f73f90706dd56686275c3778d568c4a674091c66c92b13a7983a5 54214a593baaba174d53ab1fe1ab7132e957f7bc81241a48c4eeffb273f26ca1 cb46a71f3573454f7072209d9aa8789805a5e9900ba2c04fce736b265d1e45bb 71b5be3253f51fd8b7483b21c7ec68d83948b34ddd4cdd39a5b6cf1dd935a524 49c06b6d54925233ecc9ed4ab13710874c71efc2598beb2594911ac6551bf4d5 c3df0055c8b7a91abcff238adeee052770b1fd34ab63c57f09cee7ca9c5bf4d3 4fc65e2a08ea70938e940df321d9f6b98eed474e6313266b455c9e8e77063ed7 c3817908c2cf85ee69efc46929c189a9973976bd215c52dc2ade3e1dce43cc00 fddbe2e8eab1ac4ce8feeebb91ce5b5c2eb4606dac749f6635c662bfd8721f57 c50d812a5ac2f86cb9cbb7bef853b6bb437243596b50f0a1c63cab4163f5857f ae446a653dcb5eb2be63c364f267189b780656032690a917cbad02418dc40532 b5b7e2bd1e7854c56c6bc085a52a659a13487384267f914ae748b0666816fc4f 4bfd340325d37f48f8ae1d35f3fe97f01cc378ed878c7f601be1d52c220f8c04 319d51fc4b07ab3dba74c6d4d2e820a67fa0db49fc1452012db179a21a0b4e32 906d040b6a4e314010a938de210d87f2b2f5f8e0c3d99a60fb8f26b98ed9928d f1f8cc100063a3355eab12bf7389674151dcac1d354e5ea6e908ccaf58567917 49d3aeba4df28ba63917ab193322564f21e7772a0b1fd00ffa1469641d839575 95699fea13d1c3b2bd5057bd37f46e62f4ef1315e05e7bdb670d03d9247ec1d1 42c2205718f098fe99b4a976b345080279263bbcd08598116d21360664d64863 eb35107b6148d1e72f565a28640e95cdc3124828d5f95bc15e88086da6ea0ac1 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 false +check_ring_signature 3f51c0c3e2a19e5c4495bb9a8ba10d07665251c6af8d4821e752945a1b924f68 bea45901c7148d2352714a21e22fb6d74f0e0e1d74a3ec0ec792165ed4aaa13b 27 0b66089349bc93fdad94df770db0810b1c42a85f843603a966978ef5d7c751f9 a91e7d8de911502d381c017dfbc5be5996bc6e20762660e0e03e49b3cf60aeb5 0324c56f6a20a2c77a7a03d1d76299ceb0e83f53ae4939a39bfa5af55d594ffe c92fc42aedab370c1ac20aa57e70ca96f12be72a5c8ea47a69b8de207fd7349a c58b0dfc4c3b9f542a410fdf83242ec812b5c9e0ef33123577f5c14577d7b2f4 7fc16a62fbe81c4027736d1c274639701d82e3de50e34cfcf1ab1c885aaf71d2 ff1ef5245821826c3ce0e2c761d3e5385d5e5e02307b207e693fd04d7e35e2e4 2b93126ebe7a2745531e783ac6658b771aabd1e756c2d15afa44dfeacc902e1e 1faa2b100319d0abdf8bc95c43d868cc5f9c5cfaf4c11f9fe38fd12632c36372 c081af545b974e10cd0a720f72f5baf26dbc1afc1a070a446c1b5f8ee53cfa46 1973496732de9785350ce24780c5c200b0555ae2ec5207a2e999e4072129a693 38bd06472413a3370a378d95e2fb0a0ccabe9a8f17e34508417e0cb9c262246a 8f28ddc65c47f7eac6da6f780141ffd3a80c79ce10bb2c1a170e871f9f6c0e75 6e9b0409cef5cf79bddde9f2b51d0c60b4c05a97227f94cf9bbc2c3a10eb4f9f 920b00a5ee68780ecfc1f1737722c35a6bfbc5d5ec249db2134c017e9bdb4ad5 d1a15a43f2c26520fb99377494cf9bf54a2e4c369dfaba64c1785ddc77c734e8 4e7f14c182611ba5358508ec4e0473be4e044f5fd69be31037ddaff252a6721d 549ee2f3ea9a5cbb52a503062d90a027714f53c831ac805dbd879b3f57da9c4d 43c3b9dc78bb98541d32d29104f158d76d0d3e16a665a4b48a69a5f482a8d5e6 a742c68c6ce9fd698772f50e849f23366c6ce950992944e5ca46887a958cbcf9 59d5d44bd3dfe72a7a6712464becc21a448f0d13385e29a709dfbddaa0f2d9cb 53c26a66ac8f551982394a74cbc52e957d19f1cfabfed804c4a4748e30365b2b 327e1bb4677b5e6e39d868f52ba7ff7b054fdd9d3bcb5f3ea4546187062c8fbe 28b4ef87b509f00c668a2be04229787000c2d986b75667e0d0d106435561bf47 07753924e47205179e015a135b56703f1f97c87951d093217eecf82721232019 7a876162b93e9967d49984f9f6db9a9e2b5198455dab011cf882b73ac7fb656b 2b3423a7f4cdb8bc3128211821f153bca1d67fbae5e6067e3f689bf92c01e9c6 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 false +check_ring_signature 52667215c9bd75812f50a500509dd705259732ad1e27bd9933178a102f8f3607 93181d2d806106c51ca5a586dffeb00cc5242185d8a06edcb32bb385eae56aee 4 21640f1cda5d2f968ab1900d5598dbbef51d60341d330e42279300c0fed8f06b a903a97927c14462469cc6fad84db9f0536fd79b3b12e4c73751476c4396507c 132ea488f37618c7e0ae4e1ca4d4a7abe756bd26e3b7bdef7b0495ea6f22fb88 816d3c0b5989d7a7249a9d2fc5e0faee5314aaebacbe7691dccc3aa36303e805 5f7ae473fc8becf5641786892243f7d7fc146bcf0876e8297ec3953b74fb6b09e2e4f5a34ca41674c68b1d465274678769baac18fec4f162bcf12e4362080464e2542e79d0dc8d51761517515459d547a92bb62c6a51d68545d85bf8520620031696b9a2c192168fa716a28d0792ed7ed21bac4facdd10b14e22bcacb13ec901e99ef7443d773a4d02b972026c399195a566aec4e592e59d1e51e110632be6082408bc96a67b6205ff144d6b149490d7016bc8850c74be6677833e8db62b7106fb630fc8e4eb829eea7028f891ca944e1ab0bc58583ee053107c7e5f9fd3320e81d958a8643b04a4e3018655959a7a5d98468a7b332eb2c298b8c1d478b1990c false +check_ring_signature 99fdee0994a83f97b0049e52e5d39dc642abc174ee98315ace76fe8a04c98744 20fad0a05d50e22f191b156d9988d26c39ece02a1c68f8e11a56ea63c9d0354b 38 c361d426ec07b493323b2e7456a05b133f5782735a53d5f9f94c406d863ccf8f 4f2de3914f6f7e65c1bfa6f3db5ba8ec3849afbd44744761c7f11f44e113647c d3c8beced620da1b1dc8a829d168e8bbffc3aa229a17b9028b6381e8b781c863 0435dc4613ead371d90e1ca9e595957690c9e87722f701ad754445f637acbaae a28b7a602dae9a1a8329ad3cd5fe2d2892a0025d1a62b79e72eb8ee2a4272d21 16de1e4ca841a2b3d5ba1c347918073da9975c6149c8502b583331790ffa93d5 c07aa37378e3c65857aded57940a1e1625281e44634e46f59c70f0d8cf270c92 5440322d2a524b84a9a12292d45ab15d5ed4a1530030fc6c3b490ca4fd4c1e28 04616337882a2e2bee5cbd55faa5e8f168680b5bc941fc6bf0ed35103f077df1 37c56ca499a995a1f7c09003b000c9f8acaa4519aa043eeb05d40427714e6264 1def03c93316778d4a7034204331e7a80143adb69242f3a08719d440ab190bbb b7b123ca15ada8e30616c0a7be14812179e7bdcf4ed8c6794fd1bc5856488b4a 57db4a44f5ff9f0478a12989bf3c8909abfe4af003a5ee44fd84a99d1c939e48 9d45a7f952ab6a190df2b9298258560fae0ac1d82a5303e8d845e125026dd01d b1d58afc977fe0cb940c39ad689d02eca06c1b499930bb2b1b3a33f11051ee3f d9bedda75ca7024bbbd14169c0b5cee39a41167c900812b029ebb6bf863d80c5 9ab780540dfb2619e7631c7073b035403cfbe8d61fc5d276feb08499800b9806 32648f12a4e6b1603d0c70a57633de72a9dc81720936d0d22a7cabbadceb6405 6dedead1134d597e93e1825243fbface6277280a3e36a788c2d6c774185a60b7 f30066d6ef1dbfa313a9f7f60a2344d121e1340f1fe132a528b68a2acc7cedd0 a0ffbeb081f02a292b10cf86d5e1e3b0206e98bc4b14542164168c000e9adf3c 7f591248bd15e2c4ed506a14d5aa27eca75bd8bc21d4cfe5dc13f71a013549f9 8d6ec64a58d9fc3157b389b9a4c47dfadc76b58ef8f9705762309fa922c36edb c56a8a50ec9b1b1780adffc03e4fc7efa61c18f1086d0113253d307d584b0e3f f8ad79bb15590646acf7c43a3e1845eb1130666e0c5d2f12d253c91b8e37f1d2 e3aa24c3eb3f8c542a79991694df14435abac147a163c70025c438c72a44ac37 8000426e481dce9d2b564570f752e40f41346220ebb34910668bf29d85884d1b 8797d1a67e57125793370273fbb150501a12103d6af52816a374823c2b5c0dbe 625e20bf3722a467edab661eeeb5136ab3b21ccaa8957acad335d8e3ecd624a3 9cf09748488c03ebf1aae49de7a8cf0607189a31e8209e54f6a94c22b5779e9f 0f2ece87f028e6c703c7d5fb6816f76954e77a08705ccaed72ec9bc9df739849 42d5eff368e018e457477bc2d4e3ff2261e18583fe768161c48da3c9b28e18ba 44f9923c7d09c85f5e47ecba184fd7ff98ff0339b1ac6ee97a3acc944da8b7ed b8b8ea91ea94ba8a09f14afd29e4e93b968b462e8dd8b5a94051d8fe800c9781 9fbf118f96fb0cdd5ad6431fece8f093bc35fc9e1c0ceb766a949a76ae2bc388 a60aba980165328c8c67a8829a631f379c84b93762a44b71a713cd1adb6d2257 978e82b8520d147be8d4059c7daf257b055d0aac7123ad2a2bc7574e21415896 baba23eb0db04dcba5ff18ddde563b8e8ba6be8b3bbb357dab13ed8edf06d539 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 true +check_ring_signature b61687f92ce6c59a327c7e68f91a755ade0f1faeb1e2bb06e0e472afd68c8216 91ca0826388bbdf3787ee6b2d72798056c9522265d80ed79d48701c361c8221e 69 90d60e339026b0fbc324ee91acb9ebe38f38a764b38d9ef681ade8bdb7b4a4dc 6e12c634a48219d3745786ce49f0aca2c5de8f05f2caf1774b8897c37e0e9411 bff2f388c0657028b9b8bc36ecdc4033e4ef1bd22ebb81f39f492fc6f1ebe242 0ac8722d191ec083afcc058e0f65a1926d7ca2f01017561efe5ceb626b19d012 546b577f8053f05bfa048bd92871b1d50269f065803f5a8e2680e6bc0ca69666 46057ccc2670119e763183bde857f4bce57fe45a9a0dccc72aa4251396fc783c 77e08e8f6cae445a844d8eb6a878b1c95b6cc60b846099eaa82447bcc14a3bf0 74d1aa319af0a3ef6e5d7bd30984b307567f5e80a89379beba7947800bf4e5e3 f042b2d7fe50deafbec24e546250ed889c46b4fafa8791a1ae223ffa58424950 a243058dd09b1a1ffc5c8f2cb4ca4c74d22b39d2d4fbe8e6ddf8fdf396a2e62b 275a9e03fbe5304c7448cc2d85ee1cc263e16b2d52ae66bbda11b66bdc1f9c01 4509db6239122690697616078fe49557f395b09f49dc55b2d12af6a2f0b42365 ef75cbc7a1033e331360721112aab5d401a70429bc7d6145305fedfce45ea24a e6feef4041bc0af6769f2b809502467cd79cda5429e403034a32502166e48911 d4d873a9de76ecc3a7a089092dbdc27af53300290b4fb48c0a9443fb15f2fca8 6e82f2d3141faf5adfffe980dcc3add4ccf7dad9beb5ee677c0af6c7341f4551 031c21e6e8bff0d7e0db972da1f3104949affa0c43f92849d93dd28664945d3e 3ab10bafc977b3d6817a44850399ee683549bd0056e8b76b5dea0a2c21d83ad4 33823d1fdca8c8390f2eba3d92c5cc90841282aceef56ab98b7a505ada09667d fae13f3c9ac9fa86bfe52760719a66ce5f18415696c3ed037a7aa348f561e902 ca90848f7e78ec78287633dc62c4781d518dd14bca81d14d60ea576387c6ab9f 59c95524f4cd7e75e774fcade7250b041d80b34354b79cf7c562e5441688fe30 7fcd466f6f7800d2890b7a631b493488652f93be2f610d7247c33acaea725cba cecd44ceae11fa9de46f3b2dfe0e8bcab441df53936eff38323077ddbbb39e11 2d52765a3f9dde57810bcdfbbf20502409c6d1680d7de3e335795b523605e1b9 1db9d4860ccaad2d4d60f12d6df243c14069add11c3518ae66454c61da947db2 535a251acecf53228b0921bfb98ce9230201caa7a331c7beef3a755e5fe9b8b5 676d0074fb22b135bd05214d81741741f0cf2219fa81950f0703515c8046958d 3a623df4413093d8cebb6b37314be5a72ea21c79b34552c2f587f298c0e2614c 7bc29cb02f9c24f63c55ccc93b269de25ff5a9256a7d43f69d8975aca97779ea f087114c6983d71affe58552b0b2466df2dc2a61b73fc75155a73365452172ff 54cde206c4eecea2a66ec803c8621b357752033c7983ebaeb222b2fc613507fd 5573aa57614733422c3cb87ec4ce3687ece903cbb0c3f3af7003f37ded1e58d6 fa4144ee149e4a6704c1db05d3d12ecaa4789aa771e690a094baa84cb66c574d 0f7217da70bdcbfe26c68da0efe95c7f3a928d94a0664997659800ec5f41aad1 cfcf9efe186e903e68f967e024eba4dee33e36176b69496b5252220f50cdee72 5936a9100da43b9d61601ff4bc61722a192e237be1aa826189258a10f28cca72 9614ece1e13fac50ac7e0913179a12a7c3b8f6a09e504b6e52361704c7d3a713 40506bf1f7196349213a3e63e06b14d62dc66acff64f0367d80079b0616bd325 f2a447b0f38cb1817b4526a565e0af83bbb36452e704fc8c83ebaec140b0111a cd9c8995d57ae746e7074b4ff2a27cabf685a68ba7c87e6b6ef88f4bb574fe48 07a212e4745d04e14d86ddfc0ef5b0e73859fc1de911e66551ecab0bcb8feab5 ef7563f94a82e40c6e97feb72592e8df7726c4438e9bf949adfc1091d463034b c53d747f4e13df1e1ddd2dd2f7dfcb4bc7d6316351786a66310fe07a6f7e96cc e6ff84567de7e6d8b9c27b2efbc7704250db78cf3853d2ea48a4ab6953ac4880 f358e0206f2533e5a33bb95c007632849a627976d3941607f4f1c34789b51f9d 191257837de3908b2465c3192b59fbf3e366190a8e57872a9af63bc02d8cf2b2 c8fca8fa1845cd897c4389b589b2bc69f090877b9cbc17273efa23f3f0e486e9 46424c2e90a8fdecc2af795170c9857f2327614d478ae8d53acbae29ff2488ed a276d8bc462f494707275d27aa2f3f670d3ba9f69587bc71da5f6edd40504ce5 90fde19867bf8c3c95ab679a2284953b2297c4c07fc68c0b586c4816c39bba70 faef31cfeea36c9002253c07bdafa522e9eb4839a213935be4177b88a8070dae 9e159ea361d21d08b07aa3fb056405d4e5f76190fce9db93c62341a8608fdb8e f6c77ccb860892ef72139069405c8c2d7365dcbc521dcb1c1713d8debacc3a74 f82e777840e620b09cc5741541b058188e33236d12e79685186b93208f5b65cd 8b01a56b2e89ea5acaa7f45fa1c56cf06f18a07e35eacffb6b0076aedeeddb2d 183fd8b0b23ef6716993295962982bb502e4430005eacf7dd82427e0bed16852 ec7f7e98c7f33b7e99e194404843371fa3921a2dadbe15ad09061432641f696f 37a86b4336064b3ca40b4f801412c64747116868422dc3a7a9d000839afb3bcf 15d66e0a24c89e3617d26f654220a6c91ecf071e8062c0f55c15b68c562463b1 7177db0093dc8c7d8588044fcbfd1a650b4f0a4e51006d0b7f1f39b248b3d7ce 8e8979141016f4150f4e152f78762f0b6c7443afbeaeb6ee6e5b2f6cbff8e843 2a6470f7ee419356f798ecb1afe9a34830d328ee107d4c07f78d3c70adc75570 a37d64486789aecff731b7417308b468941a5a6287e39454c07d6bf4f1721e0c 86b124a6b3237c44562aed1b76bc88dc20d38091c3bab50fe9ec045bc2ff416f 4fcda4516870b870f82971dd1793709c729a17d8ad1cbaf88655cbe5bb85e2d0 06cd54e4326adf2207de87e54e49842f36432544d74c5728397122568187b56e 6bcf55e23b73f5a96ea76b6d22d71d2c70dc201cfb2b1f0e6b25ff1ed80c116a 90dda674f801bfe083acd7751d1b5fa9d4ab25874a3d254138cec31572776ca1 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 false +check_ring_signature abae92b9deabcf9c9ad0c538a34a35c43dfdc5531b826d2b5510a15fb39add20 6b1c0fb3c76c3ab6918b276246fa331fdb5bbdfa8a2c97838c5edbd9f7bf7157 62 dbde5d3aa4e5e8cbae98f33bbaceb09a22f80d4eaffe2e7153fb3a376079e159 d344270406a91177c42a3fe3b5e3993fc689cd253ff9ad2f031672f44a8db0eb 52aa4f714bb2da31d5dc72e12cee735af4d093d2e566a9d914f2b20c5b34f98c e4924d7103dd523312d9f146059d2370715b3eecc6782394049fa9d22998b061 67d7fab36b42124b91660fc5e2d6646681b647a48368f9727910afa5198dcbab 2cf70fa5854e316ff7c7ce96e9fbf60861cce81ea352577c01dda78715fe7e97 105d3ba37c8c405c38d7ec5b30a464c5d6ca322dbcdafda67c6d9c4c7a0073fe f0e7424623c84e6131d639ad1f517604861e0425ff902b1714c3ba43235a1464 e1f5e5fe0e31d66974d0a402d0e2508616ee301e8fbaa3d405a720d39a9adf84 e865ecd0012544a48025327317b98ff02192d9cf34349837d736a1584b2d649a 19b5249672c76521323f316f480d2fe34fab6fbc4033201a1c1d133f93b9e90c 5917f0963a62fc79156905cd92ba26d0077e92eccf7cfe07fa6dae6f7ca42971 225ff849c2fd5f831d17a307e620b33842d0840456bf05a74523477ea016f1ff 976263551f073bc9a1062685aec332942ba032c0c0eb70bb197a232267bdd20c 8ed5c7b1e050867657cb091434de6cc61d04ed3773520ebc57bac5ec769c6714 7ba0538856b958d05f45d16e2317bf501a5e1fba0981f3900edae7132be01997 10569c3a23e51f1cbd5fd68c5fe6f944f7aea6a62bf34a70036d5ab907c2a0d6 2ebd21d6eb144f6afd94ad7e3f9a7db12db7908d2755814bbd6e96554706ea28 d4cbc8eb9da8798c6e519d82c462a7b74f334a67e8824f53b5920db9ff3d0d0a 7ed6dd9191b9757b5afc38a390f6be01dbb8135ea296820d101b4db73a8641da 28e455b046a476cd739bffc50fd9cffb2a4a39b2d9eaf9d893e3385bf59f3360 ad1456e0231eb24151d9e2c4624067ef0bc723d281b948a314c897a6b0293600 cb9373ea96f4e77c5209ff9ab0261aa49370d3495125dececf97baf429bbd69c 959b24cf76bfec065d3d877c5ae8dad80131a2920ea3c4de6daf86f1e288cb25 b530eb28a4e7838527969674b5694e3d1dbd104aff7a1be9e1240d3be6841ba4 09aeae1ec8a35c6365a1ec5fd06e43ad09c492de7faab73ad52a1f14160b9245 8047eb93b05b8840c76b4aa35094ff6924e35503e7b5af8626a06afd2d10d79c aa4d12a7348d9ab21bb1d99650ff32e768d214c98c10d6e71d8dcd36a9e1c645 e53c3ae7cf8fe93d89f876693f4d6566b3d8a7e6d07bf957d7c402523436b2b7 3710c39480a59d9432d96d510b8fae023c2e8a283ff7dfbe8d38440ea3ca54fc f1b6083826ec26deb63f18e7c11aec1f1516353fc74935871492d29680afca6a 05aedfcd1955fd95d9c35d7ab07ad8b05e4464c0576c4349ca594fa8b93d2f5b 4ea324305211b80ee314141f81c44165bafdb01d4177b4e457c1b2112ea9b0fd 0004ee32f7a134739f5b09c944e5936169208ae277b3018c212a14c5e1fa8173 5de96137070551122ff57fbc7ec5f914bc66a2699215ab6693c7d6940937402a f3a005c6d5a4f74a99fc330c821e3bb0e4f9deda9d41878aad037ee4dc70c5ad 89626ddf42788858059105c29decaf4fb68d792ec5383ad170c4c9edbc932dfb 33db5abbb95ee5b0d31eb91ab7692f4eb96ec156597c206c735f5da841e7e301 5358bfe38b6bd60c9b88e4cea68f3e020627754732d98dec81b888bc91bd4a03 62c2935751ca3dc996f14fd83bae3f5076ee9697a133e0b0ee42581b6bb232ba 4e45b42fd1e12471929c9ebe13c393912e14cd0e491de7f8d3bb22ba93a9fc60 32971932f9910d1e987806f54e38201969a1c2aea5d755f4e53d10ff12b2054f ab662029a39bc228f4631d2e35da2eaf64ed34eaf7dec5c05eeb47b56ca46646 899c92e3ac949b170446030cc3fc62df4e19e77a3deb8757b939c7cd5fbecc05 ff33406bfbd7682375e3487facca942199e83236a37bbf3da42136b604c21d7b 2cb43248603798a208635c5c7ead853ce58b92994c318f6c909f49395b4eb97f 4ed7fcd9dbd4ccd9c1838d0786cd9afbba37fe28e74549dc1bc68bb04755a186 0ee56adc6d2f608ae7ffba79dc5e40f4230eb9acc57f062b6213496074091a16 5aece29e9f58b264c24478c4f8c92b487f457facdbe752c9d62f24ef438ccd61 a2774e11195d704a4eb2dd19476082c00e71014f470465752479ba7c0b74d3ab eb93418a7029eab3cf817801aaa0e7c5d259895a00642f8b69b316d1bce44ff2 d8220debf4611042d340a2f4a170651cc9c465c4109e9254e9b67aa4b7720362 feb9c2b0f22bd033b8f379d3c9f705dcf0b1a18109c8bb3eb7f08bdbaec39af6 2f41f85602e388053a2b643e068478b1221c0bf00ea2140862fffc411bf4f0b2 46205287fd4671cb8dbbab6c7a8fea2cb47401d8c257da48ea18afef67c45ee5 18e5e4d429cd5c3f6549281a9d89f306a08745611e47a636a58c6af6951bab5e e4a08903ccc06db6628b6cece8e92ceca0f82e83bb1b8d37095610d1a71ec6c9 886b51323967c3b4f7eab34b41aaded9c8165fcddc6bc7e71f37630f926007a9 5e549fb764984e264b8f91df5363a02567d161cdaafa768fc5a5e0f033ecd0fb 06f79b7d1884c5fba6a910921f80759a17fb4d68f90e8ee6e9919402e3cfe880 71fd7f6ca99dbaab3428667c84988f7d37337eb3e5314a71a649d755530336c5 4b7a38dd32209c6bc0caf330b04e1c5e1e481655b8ab9e1b5cd87cc6e4278b30 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 false +check_ring_signature 4537e57175718d31f4dc31e8af5f0660a5f92de8f0a3c2ed11624e66809e6ab7 dcca4a6f011ccfe6fb40329bac50d1b3e336f45502ce1373ddcc5e396693da5f 12 576736965be8ba5ac09f0fd2ea4636b36bd6bf242e430587d66cdf708ba72817 39cc8557623a98897579807ac32fe82f35a5ef3fcfdb3c8794a8d5383594d9af fa6ea9add4b352db55100fdd6ffb386ddb44b42a1724a39cbfbabb20d17cdd63 7eb493e2a6584e4e8cf4366b70d0a9ecbdbab2cdbb56e5272243235323c52e24 a03318a1711a42293470b812df90b1c9835fa548939884c25444f9da74415f15 066b8e9febc929cc21abba169b5f9669a0f0949ae9c6be8f2c5cc56fcf177e30 1c60101b48532e9c1c3d4bffa5c8d485c265062bddbabfae4ba13a68fce1ba98 ea6d56ba0bc919f6924e162c8e264846aa6bd46235881999628791e2919e9f6a e22515c6134013b5c5c9b1eaa2df476441baab9d88957fda02eefeae745375db 6cd55ee16324b28b634f3a90fd8604559faa61291a38b1f2b3ec088ee7bf9387 850274ab729e20b995c2354bbc636ce9067d05847c5351baa8b08e00f1a02937 d2c591ba3cbf3c998632f0a08bacb67787562ab8f285e8dafaa7370503b5a4df a595249669dac3f9952c2a3432b595b08f45106547a393f34f3c428eb1fa8c0767acfaa43e0e075a038e413a816a7ca535d398cea2774a63c6ca8f8b4ae901095d0732f0f17627cf5f2e4ce5ceb6db0b4566f060a64e8d40b4f67e5a0dbd6f03e7a522156d411229625338f862343eddcd97d851ed5c8112d681d634feea28017eaaa1205462a6182807dc6a3cc7cde6d4efa8a82576307da426f9fe2e61da09278ee8d3b5f4fa6d5404a765a38a4b83acd929574406889d7ac0ab32676c6f04f93e5fc93d1db453f0c35e2c550f89f0fcc2b15a57f01b8fa58a4260cee8020a804162050d8c782002aa7c52a66fef4893823464a8c5d91e2b0a6530a3da1f07f37156eb0ee26d6ffc897d116ceded66f11504e0578442630a952490f945e80ff16ce46eeb7757c924440350c9c6dd4ce1ce1b09dff8ad91b72dbd6d48807a05136917bf66610b4cee97619e0ab16d31958649dd30316060ea8026e09da298e1f8b0c5c87a833c199cae20fce341142b47b60b11f415661c1fc6ccad1522540d57e09ad617cbaf292cd7f656450790b78f30e7724fff4311967a3b4fa7b6860a6177b567b47b5193ea727fb2b507d6a244c2467b6458a5be570c317b0447e80ee6744e013ca63d2a64d1c3210c73057b148f4d9b1b6e6655b4d43586988a6a0d7ae99395633a14500f2d43eec0ee8bd72e6f5ba8254edb232207b954cda8bd0cef186d51afc0b59773bd5aa0593c7e0787e799141d170c79487246cc6c2531078d75eca61fb31f2a5f90e6b7468008a47d20635574b97e0232a81c2f8272850a7bf0f4ccc0bdbf277a8abfaeb07636182d224f2be22e9a9852918f0a8ecfbb03592ca8a321a7b8aec4a06264f875feb5a31d0139941409e75da36b2f4206550845302a57cf3c02a9bd862855086f9d34897c8d054e014d0ccb67dd82a1f0bb03b666eb62c885873b2195f04d182639ce7e584db657b359c8778d4be7cd0c05054ac24ad225c86201db30d401409fcdabb3d12c810595d42ed157974d9cc61a0ba8f8020151b44ae0866d85964ebb66efe74ebb04a6c9945dbdfa9033b6c9aa02 false +check_ring_signature 2062fca5a14910aab22a80334e11657e74405b573b746788fd44d19e13fec058 8319eb95f8540b413448ecd7c54edb812af1489902a139c8cfa2bd816b02c9e2 16 1b3dde359628ccfbf0e74e107b14cfaa4e26daff66910070a93174dedae699ad 802a47ca25fc2644b50ade8d0038e002e0dbdf0601133e37c651df65a5cf7438 357bc9f3779ceb69872e54c110962ceadb5fdd500f21634fb7a5a807a12c44a3 a893d74e746e22cb0e5798030020211c94e58f586299f4e11956f1e5d8711d9d 813f3e85351bba4f4d47e93fbc3d9a3196f3f16f243a478b757b926fa8e00b7a dc337acd576846a4954dd1222e18194db5f868c4a1c1d9b4cf31b71a61b85b42 1863e774228dfa42befc01ce48be6f1f75ed4590c2edd4f0891dca6dbb788b4a 2989a1e0f64ad4b42bc63b9ce28e1ad084490094903aaf3876a5e7ac89467d3e 18a842af997ae4ee6fbd4373fec079f2db19ec3b52b96a8d204f39c151d141c8 445e6a9219ee61f63aa02ad0a52551793df67ff05c6a47161d4d3dd6105a5f9f 9cae0f899be60e0e427754a0bc7c53588f7211900c01cedcc364095679903377 9d98a898267b937aa5864ecfa6dec33e9df8b5cbbd1241598718fe66014c5ab7 015934c00a849ecd11c253169387e31a90f27b6ea12a27b2eded3e9114fcd7e6 464e9f58b273060007ca05c34781be9bcbba836b11953aa2984d09da3fe7d6b4 493c1e5f335c095bd81b133b225ec92b346518b83c4bc98e36476a61a3544340 6b06ed736d556be2f86b505f4b5f0fa104c5e5ed7acbc47058dcad41a77412b1 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 false +check_ring_signature 1da524200980e7d7b76890bbe8c5b9e5eb43ccb0404e7c6435c8bd18f1c683b1 16b7cfea47c73ad358a3bc7099b4a7da8a6b29d48c089787cc8e8e70d12f8cc3 9 57fc878136a61eba33c3802397ca1412242f2bf0503a5928d85cbfdc38ec839d e2bb31d6519faf4b486013d266d6c03a69bedeea30bc87e9737c7fd963f4143b 2d13caa62ac77ddba0e2996c642a269684d8dc94bf275a980328e23df1c60999 057cf72846f4bc4bd1f194756f99efac503fa774bc4167562a6431f592309630 4d7838c8f1c0a4762daeb07df30fca724ccae80b51b59185bd74ac4892c86158 8a3167bb8354a9f1ed0d2257c512a5d1dd6bee5bc63e51c55cd89f77541cd2c9 9d67c3d2cc607ca9f2d6c79dbf605564a6d4289136618bc363fc0f4190233ab1 73151ee7c015fe711e41fa2dae46d6e136461c2199c70fd3e872db87466708f8 896dd833a60d213d3836c0a9e7cdf0b7c95fc3b731506cd897ff51e5b55c547f 31668675d514702d52244a0c8f588cce3fee8f6b1b4f8894c8b20bf0dcf96e0352f69ceb2e1ae16f830ad9e14c70b5b0a68ad5b27c7a25fc4d268155dcc24a05b34a0e96fdfa4b84bd4275de3300cc8df463dffcca435d962b330ec492279008687666c834c8dc8824cc3a4f42708ef66c267641247963f67f1e092c59d7fc0962a8c174858d8db73d4e471e0264de4c4921bbcc9e19822b81e44260a416f90116beef56aec2df9f6173aeeda7d15461bc54bd2420b3d3cedf8ab42ef1edb602ac958c4d826a5fa9fa1c0b17c855a7897450825f92cc36b402c11a5988bd740a5a3e4d35b5e639ce6287d89f2e20a46363a19b6c09f4135b0109ca8325518a052d4247829e067b7e2969ba1968141fb6947b2cc5c3a27cdd7c1061c33abc6a07a2ae71bb4cc3625fcbdb0ce128bf45e2da5c1e99dc423336bc8e058d0595dc0a48c2561dd7c814f9cc8f6bd2b652ceabd35b5d690936ba37c421084492c13509df98dbf889177ee3c3071dda63d45bcec304b99e2d61363bcf2e835d2d1cfe0026dea0aa7aa9b3917f2ece0f2a4ec6a03939b1ecc10b681aea5fe3df0898590ffdbd86ea11df21069eaaf578ec7b440291df512403932525ac4f1d75bd0b3103558661c966cb0d216b602247561393a920537b2160c8aac195b34edd95cef000554d1ad29381682f1429be47302283ab23aff8fe418f7e4ab86c964a021961042db7e7c915a42524d5f987b0b7ccb85dd1426a09651aee70b6e7b46f405cd94322b25e31e344fc7559ef37c5ef3fecc883d4cf02079ffa427af26340931a220e false +check_ring_signature 1bd8aec3aad87ebdf5c20abf1f65c075543dfdaa1dffc2bbe011ddef00dc129d d5a1d3bccd137a2194da8d98c813694d4856940bbc9c99c37518793876275871 4 816713218edb08244e7acfd3eb334a0bf8c8dcb61081d728c229c5c7d0e5952a 91f3bde11959f8cadf56b493528874a271ccc44f87172085de3a83004c5624a3 8dca1af0d78ba9a3ea8765bc90a2809d8c0c4f4491252b818e8e9096f1f188e6 94ec6d06acba2a13873b54f59f96b63c7bed5c5993d2ce424a10820036b10169 bfcba5d569f82d8c31741fcd2123bc700e79680ef8fdb1e46b0202e290f5b60037501bb4317c856a6dd378c1f256e3ebe87b5a16ab1d69dfb401195e2e48f200b0177eafc5142ce8f260aed50baea6f558f90bc8d3bf8d46415b813fd4a4fb0a807083461dbec3563e54d6b6eed245336da2b935b67a14e451f8093aa4dca20c75abefae5b291d48cb71e9d0b50357af94743892c718a1e0759598229aa3fa084922a4ab2186a48f4cd8868eb41461b81fd4d1cb6dfc2c18398e1f4666563007efd6499ebfd824c0f4430f17111057e8fd7836666d27bb738743b7b39a80050e982249e9493266848f2184860ccb99d3fe491e063b2f32201784af6d88d7f50f false +check_ring_signature 386b42fe55cdb8f63b43ec15d2a83bfb40ab0476a3990f876c5b8fffb9c4c290 b2c54387fb25612f16ab3230d01ed54a26ca067bf47915f72c06a5fc4dec3a08 1 065ecf56c7ca0607ccd8844a12807fca2d7bbdc4f7eb3592812e4cc499e9df06 5d9be95ef4ee331453a7d2a01c5471570a9a45ddb75f417793403924386e2f03db9889200cd7fa90c4abb8db3e4b72987c362da517bc1bf5f0bff2a20b098b00 true +check_ring_signature 7b0ee27833bad6cb7613dc6a4e05d3cd682c040fe7caa0c5cf74ecd68f3bbf00 d0ba68ff8c0b2cdba66486110a3a87de28b3078f0daf077900903f18db17dbbd 210 e9bc0eb334e8056885af67b0c1a85f9e3fac640295b3de3ede158bd3d236f304 024fe16abb8670153af3d2dacc2d6011a9dbfd30a6fe6751a3600f3c5a58a358 2934ebe587a693d0f41735df709a4e8777fd48dc2e819bd1bd4cd65d12238cd7 66453945d1e1039508739947f574635853817a8f441228ae5c121c4ea58995eb 1ef584303dc31475dddde3d85baa586c67d055906d4fe9654e00b0a205670daa b6ed8c90756d345512db4eb25add05ecc5ebee2b259044af656ca4f76e743ab6 d77fb59cb3f15707ffcc1abd7a65f9e503edbabb6bb12fd6a66b45e760961574 e9e0bf24923407f95fb85aa57540e99d95cbbdb21395a662b6a60a19f8aff650 e32bf49a6066a13dbf0fda9c34f474de5e29aef575f55447532280c794f85288 5397abaa4a037c7de18cb766cd26d1f9bbfe80ad0d3d2300abcb28ad61575483 3a26dcf5ab0fc4008a02c20e9c9f99831d423ce97da7667a0f20fe3a51e94352 bfe6615b9a16b47997665a77d5b7340025506f6084336ad7c7cced5cd17a91ba e5332191d688ee1ad580c8c0668aaeb48c3b628776125e720c5af09cbc98de2d 2a61d68dc1c84c4429ed58bd9d890e4d9334a3368119f27706b7206123e6a4e0 f8c1c6cbeb6836823cbab09e1cf26bca193a2b5693095ba272a28cf38c08b4ce f1623ee6c79f4cf2f66c2ea9a2b8ddaf073628e95904185d5e9564d100eaf252 c102000caf4a1b02edec86a1cf58940419b913a9a463aa8651b0652046df7229 90011eb484aef7810133b5028afeb918eeceb26d9cf2c7ca92d1b2e704b954a4 ab358cee22aff06b08417baecc30884e6a8dd003d16ba649943db054a5f07282 06e4e45ae4750771122b89fb79a5a67b805d672b2bdd4e5e90735024db2b3b83 8149aeb28918a187c75a6ad220f87b76c13ea865b2b821402e5d30fee45ef35d c07408559a17ca3042222e5defc63e5f7eeb51e1ab4786d71e0eda5d3c44613c 657bb71a98040b9d7f959cac993ac053ea6342c258a4fd85408e69e1ff92c285 5bcba48cc3f17fd9c71950c6f373ba887eb734dc1116b58ccc2ec68f3716c4cd 2baf67bfe3b11f6e75dfb40d3c86c0357e8be9490f6d4a8ae3204d83059cdcd9 a0f885fc5da8375ebdb767e20260fdea5fc0bef9907c4fc84335cf6c50dda67a 63ec203a17b9122bacbaa7a62e68c0b12b84db1c64ad261ef99fbb3dcde2f8f5 d88e4a3b6364d6d58722eefc79dd2b5a067f1877d88c7b78ba6c8ecb4d63ec81 18d229a0beff938b1c4f96dbd423c39de4a6f7f1b97fa02dd477268e380468c4 c94302aba0e7767870df5961fc6b2bebd5c3aaac911b242d8af878b4befa7556 d69ac826e72aa36b2d71831ced27203e38b227baa43decf8fe4d52e054ffa5bd d248d33d08e93ff3e3d1e98eb4dfeb12b73c08548b7188654834d3e6c064782c 468e411d6f41336f13aa3638293e4ed8c10f022571bd0a8ef24879e7c2798de4 3564e81d622dc204c4252ece78fec1efdf423b03f8e76d4904c1fd1d9c46ab9c 7e1aec912d86d9fdf26a9beeb1ccd84c8580f49aefd5428e48187377cc647f2d 7aed60450c85040a802fc08ca9d440323fbf8847f94bf1ead7863dd3730eb312 8598fcc7ba4f96e5b0780256674deada9b999a629c754de8d4c69a76cc18eba0 d0fa8f5fac94e4128754897ed0b2122a44a0008d09f018f9ba077dd2dd31b49c 801b4e68887849c1076965c3b77334f40adea11e4681c1f6bd0307cdb06f885a a5fb4b06f05544936a6ac489e9d40874da754a7403b0297831fa9cc97c7fc083 bd89a7aebe98f9d288ab020b563cdb96088000ac09dfacbc3b11b3bb96a3240e e5b154085504331ccedff125e6afe0ad41997e28046114e714d940f70b76d90d 498478965ac05aa067947bd3d9357308537f60cd0782f8e19727301a9a6a0913 3a53f4ecec7965e055e5c531b9e06cfe7c661402fb3a064ee0a60840d298b6f3 561390a93bc62e3afcffaa1b5421b438ceae5dc5f65e58a91346a3ea18adc661 c5253a7a475a6ee49070e716574195d47372355d7e3a03965589a1af90f48cdb 56a000f72b88b1c67098a7fd03860a33cd4355791c304af10f74f0d4995f25ec 87047e6db174450b6f7c62608c61ec1a6a5858d2ca3426361d14f94e3bb9126e 158f4180ea2ff2ebf3a78020f8d71b9187b3ed652066f49412abcc872f3e95bf b7fa74c4abeb8f01627e288527f681dbcb1308d671ed9b752e8dccd3713dc65e db938b24b32a0bff2f4c97cd2598330978cdabcb7167df3aacc16ff922dee85b c90b69d9e3708a1217824dcf316d76bbb8ee02c6dcf1619a64befd05319eb7a2 624d9b8b5b7b2b072ebf06c4ef0898d4cb7d01aef748282a8dda1c7a4a90b713 917d6f5a29a1aa35de303600cad06680a2f0baa045b1f0f8beb28338fdc3ec53 6ea1a902d73b295252e7cc5619bf1ffc7cc73e252112bee8971edce5f05ff273 316d357c3e3ee4c36221b5d240027ed44b1e000a27129286a1924a5a544f19c7 296f586066d7c0cc65de46b02dd855b8a42f4f9a7b354e401e19a33998f68c0b 6efac760e366cfbf15f97cab7eea2f67b97cc7a7b6bb06d816ff22db4b2e193e 3fec8daabfda6baf49bfacbbce45a307fbd82365911dc25506265fb0a973e2d9 7dbfdc93afa7003031f31396465b038ff72a31ba109a38bb788f85172620d897 7414184c47378f4979631c8b35fe5c9eb58a9d3c4443eeb8eefbc97643bb292c 562210d38b79cbc704e1bc3917579cccbbfb0e3f29c962b3b861f12982bdb694 7ccd875d07f577787e2e23aa448ab9a7fbc0ea8adb42ac915d7e0ad01ed20bd0 ae4197774107fc3fbcec53e08fcc4b55355a15e8f8278678d9cc77f78fee56c6 6d8970e8e76082d4d7e8239ed99f470072d3dfc466de40ccad83549795216c7f e1be985f501a4c1e76f1adc93f239fab36dc2e289efe4ab8bfa9806c3dba764e da127b1ff9a50114e80d0c28eeb20aa1bf6a2dc37aeec86566ad3f8b874e1dda dbfb70324a348ec36f2b91ea7ed5d637b7102085a9536f03c3880532039f74b0 17d98e7509d41b497bde2e2ba15ebc56764b6d234420de44d2740df1c937dc48 41a210efa0ffab41e587e2482e50f7a19623633326761a3d177fde7485ec5b02 530f9dbf6b2c18c7008c85121b44195c078ab87a5a734bbd3e0bf29fc443baa8 b65db0883b6a5168b59e62fe482cd19727896249ee9e49079ccb897e76f2bcc7 0543618ff15bf7a2c793f98c2d491e301a7eb86e392c39aac3af2c8c45deeaa4 eabe90cb2f71c70dd9f41f06247f7bc24544e29d1e044c8029919c7a668afe7c 357e3aaa231aa43b54dd806b317c744ad1ce55108b1723db145c5a018ae910c1 155bbcefeb47b97235b46c7553f5d79687aa6609a1191729d026ebc81ffd3370 46246a57a1ec18aaf8b8ebb1228a21ff3b1335c6b0a69d5dd71fce57124dad59 106a538d1596e6764b8bc9c055dba69a2755e4599a8d4d7d6b7eab6eb36df4b4 fc0f76564f7ccffec6e72dcc53f010350a6b7b4c058544cf4a135e6aefc57b47 5c2d99c6c2a206428a2a21e67435fceda3b276fb8981767cdce618de709c1e17 9a1fd96724b81c7d2b6f343c33b296b240251b21da9ed15b6a3eabdb7f2f045b c9592d3d38878c573826ddaed6ecacef1e9b8e2013af74acb427f931d5e85056 1ecd06d05ecebe2845070dd4612dc811862e3c4e0e1229f58d1565e6ac0eac31 61790b505b632e52d5f763db6f4a4f30e1a67f783f814efc99ef6434e4271eb4 7bb1a4481ce5898164e6f6452453f59e34a06ca8bbf7cc9a3a4a300e1b132b2e 2f1e0ca738a22773129ce792d59d274de05d0bbd4615effb41bfeced0bc7aed3 a54fdde178992c49b84a35a66beb26ac9ca9703e8a57cfc7d60c695ca3ae8368 7af137709ab78dc935692cd50d6f45f35ae4f5cfb569830363f71a9d14e9da60 6067655fad35bfae5e3b56777728bdd9e9c955505f36cf800280c75aff818a43 1bcc5ac047c2089af880ec0c2cf6fdbbd833bd46f4c1157eca3453684af5c062 1fd08b9f0b03e68d3c8fe7c5454af615f5e1b82481250a977efa7db78c90b8c5 7ee46e67622fa5aa0f24b8df4be7a810ddf8a61385ed470bd60d129afd391f23 cff979748b86229c6d4b7f3f6a67a334c02a43fd9d55ffd8f14b92d7ab056ddb eea9ca7133ca4036ab7c14b09804dc4391c15c25543f72919dd5ff58d5434783 b87b10fec882c35cd92cdf07b97b2aeffa51157cc87a2bb284f23b37bd9b4922 cd63b5be0acc158d100924bea6d05f7c337ea8024f87af5c30452d72a72a6d37 c3919c539347795df5495e3cade4806226db9ec5100dcf78998664519a739e54 d2242ada68c4f016e6d99a956a502f3ca8c713d47201a2c079aad3c2829fc5a2 7376021ead8d1841b84be9711ae96dc81076e1337b3ea97f8e01329800c7b011 9ffbef1eabca56be0a186e1ec76cacef074b0099b991abc49f2697f304410cd8 567a122128904ef41cb5c019ec0d3ffd4325f3d658999233314a2093e50fbde0 1d263273f9a04b4b4fcf6918bea504a85bfcd1f96f7da53790d4e6b258dd1580 bb76db05b85379a6ff9a2769639338094b35a411128f1cf70a76a4f616aa2c48 04e66bb222362cfc9b50abf6cdcc6e4c00a78a856153601b983d0e8067ae1dac d04c4dc3b4f41e7cbafe488c604c8bd5b1f7f456ad274c788ca5a0156f34beec 2520abaa447c04da732082d3a898c651360a20ad7cbe7ab3f555513aa817a6f3 74031a84b1c0121543b98052e5ef0a7211b757eef456b5371566e80cf829a593 f11c33817f6e6594773bfd7e2e164e708f7b5113c76a862b60e1377f4d2d375d 8d24d2ee6cf732fd01e369a67183ebb13b841baaa3ead331b6d86549bea78e21 c691d1f09d2d4fa4dea54798ceaf5e480842c7a9a1d07494d40e8a7cc62f7a0c fe2c3561bb783f978453234457f58552355be2524f4dba90425d94cc225a3c9d 480ef07dfcb700a6ed90eab0efd7de26f377582e0586c9de3a2f8f680fdc0e65 802f31982225754711d898beb5732ebdb94486d8b2da14f907a874c45cd7de3c c3c2062e9e8c30772c6a172026b52aac1fb3f341e7fb417b53f6e2393c3fa5c3 05c841499513e0b38b440257ce03c96279a6f7d548cfb6a7d1597e7badaec48b 95bcc541d049d59688861067dc280d99330d229efca907cc6e5ed86c12785285 31fee95e8805f3692d405a19980d10a912b130e716accf6afe51a2b4672014ad df1d2eafbe75d32c8cce57de9333b68068e491601a7fa12afe3011d60a1c5f53 0366695ac8bb45382d65400701cade641efb611a0e9f2f2fdf5fd7f98bc31603 20436fbc696b6bbaa73128a46902cbafa937b4696cb6eb1c70cb6724f48fd1d2 34377ce4cb5d2022ec3c92d92a364f647788354d8a718da73d04cc829660f989 93be8ca380764fb5da6539ca5f27d2fda1daa4b977abd6e55c43ea284ceed5af 8e870b9a801104880a1ea33dbad13d28552b640649755ee583fa6d6aebfdd41e c681a5cbb404a3f661fa8ea218467e228e0d5decc6fb91d750e5920af1fdc25f d0c3917964e9b03531336991d8eb204a3eafae2d401be2198da3b0b1c148e0f5 937faddaa75a2c658c74703decc2e6a324c147e62e2d0469915162d5347cc2d7 37b18a96fca31250b2b77a7e5a9f725933187da6e6fe94a98c26db003f921660 b8a4ae8f588d8415b59fdbc191d687f34f097476fd1ac08ec51b43c8cd7cb178 8d25c44014cddc48ae976e4cc799abfb121aa94ddbc660389555e383b6630bda 3d9f9a05085f4462bb6fc6deb5db632ae43b46f4d10fdb508930bef7b803e065 7e63ca58dac095281718b89ac6b82272625cae747838b8b3b64c9a67f3fb6d7c 44ad1ebf60a22a8e28814f57f9b4c8fbf4c95e1951a33e0e5c5dc7c2b9288705 d09c5ee1e670a0829612cee563af57b4a025843df0b7a1c6120fedc499533b23 2534dba6818190dba3b556e77058af3fcc1efc63a9f57d2f3799d576e8a07355 cbf07e1db37f0d93c5de4dee5d56fdb5a8aefc97ce2f1de298c66d75b542f73d bf312c63c512f94d7453d6ba9e2d247e2d411b5ad37c9677324582046015fcd4 a10a7aff2e5283713933083c1dc363ce2b9d83a45f004b9d018d48bdfe1b8cf7 bec9932d0003a8c44f4223a0b6b11cf11e3ef59aa690acfd73790a72fd1fdcdc 4c9243295e9a45aa0800a493b28256e2f611c6d752e2f18d9546e90333b9aceb f400c393844ea95986b290df95f129f0bb75f592520f41db36e95c83f86fc24c 5d19d1520f7fe735e08b9e6d31220e34a797345354b52172292547164b206a40 f90efe6445abbb732ef8dcb3b7f31cefee83b7705f39a241de6ef8a7cb883fad d6f1e5e09ff40d8c90ed3a4e37d273558ee1125c275f76fc7c7fd5d0b50f9fdf 369754017598ca0c32d6c2add2078629e1636f959234a6775b3c76ace16bd1b5 7f74717310ad6ae831b24274b20f70ac90e55ddd87562ce7fe47ee77df319809 f154fc2a0eda09d5a573fe2be39ba60b3a8d54c0544f7f06e27a8bb6820b6699 3916e2e6bb5083d8366fb85fc5a351bf371f5392c5b208eb7c322843aa6b256d b31a7215ed782ece007c436d581f3d6544262428be933d3189448a37999af19a 0fcd1f82ca1e100a4acc1df499bfc879b66f6db18bbd5f8b529c65dcb09de5f6 edcb90519c26d246b6bde9d5b3d24b59706bfef2d81761e85f83ff063176017c a44210ffd299a097c448f0d421556adaef1dbcdb5fae733edb927d8c732dc5bc f0f7067f91f511875a871bf11e5c2eec8e1d8a7468165e176a87c534f01a9595 96029f544547863868c315d253a89cab2d7102b64124a7a6d38ce95ee182f85e 0c02cd944e71cb0a7deeaf52f6a0523883a6df82e3df2556bf9e3cff97a90de7 ac0bef70b63000c158c60cb13cb0de919614dc66e0f1fa2e063fd53244dda335 1ad578441d785d320761c5f318d33ea4811241a0af9628fb992535693cffe907 2883d6448c7020d527c025e8bc9f8601fad249b67491fca9b933656fbc2a8a84 2fb242ca9725c160a49ebfac181219ab08da76d0f521dbd4c26edab1be22ac4b 4bba56affb22ff1e98aef344bea8c574a814ea5c90c9a528bf6677f1007cf75f d101d6e37b50d825c7793e6781adb36dab3aceead27bc555beb180c0b69aece7 308b9bbea27377cd4bcbf64a56eb582364e28fc21885f6bbb5f5c5a4c7184990 a7058ce3c2e286a737cc0fd6dff64623e94d4f25c43b2c107559e03ebdc777ac 7511c0edcead4d22f64d325d37d1ff977a190c511a02e25a4c8f3216d86b09e9 1a29c84e3ecdd292e5ad36ecfd8fa2e723d3bd1519d8a0cfa0bafb51cb31bc35 0f03429e804c0d9fe07567655cfa3953e02cb42e8552c8505034961da5299468 f321075efb2d9a64a1a806831acfeb5ed19435f845257021b9df8aa8d21da827 eb5bf8ff77a4b3df45b42f2e17461947053af8df8a1158b667c016bf9bb55533 f30c64d57797a3d7f82ce7b3268c9cc74856c3d66b267eef1fa61ab9d66e85b1 390b96f45c64211cd52284edabdd4e0b466c0464f4839176301bd04e231e43f9 cd19f8fce2878178260bfe88b201e0632751f088173eace3834adad568dc7f4a 164fe14ab557f3be29ad40f22dd6a1952c0dee6881a99415b7143bd5d51e5e3d d4b7ce11e7498ccf0737e1583a45315e461555757c7b0d0f9634110da095ea9d e374972991b3d69f8cd3104dea0b0192c21ba11f2dfbd562a8de2b50f2389375 cc829eaf4e0e4c60c4bfb1762867edaaffd9665d8eaec016bdc8a5beae130ffa 73e95c1d1b895edcb15547cbd3d7d7fc967386ab7c10d500c9c5ae2d7e020a2d 69d4c241ffc2a6866b6bde4e8774355121bb87bfe95d2bdc21fb01b9e9a4d033 7c265b9d580b041d52077127a719adaa0e014d35c50234c75d0e5f0dad8e732c c86116f2e46da59b8976fc42644c5fed9c2e428f12ff072847d6eed0f3cc3e19 a8bd975d96ab2b4f6e2b519d676be113a2df0384f7b707a0e7dd893c8bcee836 a54bab2b3b8f2ac6f7477712afa26af2046f919f8756178ee936ca868b4bd76a 1d07b0d3d25884ec8f3fc1f0a7c79b7edc88732043b672907342d0d3863d142d 370c90271989511a4eb28e5d9e87300a5354e7cb7b4710eb737096ee2e61bc2b cc2d221a614de911f45874f9ee5db12fb55ff06bc2c48f05a2e42da9fdb31275 0ad8e2db05abce7baddedb7a4a68da67075945788709b8c6f7b9116e3be370d8 2ff6ad3751749b5c393955a845f692b34c2490336e50d3e42dfdecaa714fdadb 2525712c27dfaf4c23baa666446f85ccc77c563281fcaf634f5737579fc3a62d 3b4a5a835c83ec6fc8f6bfb42712f4364650389bb3529e73917a8daa405b4a78 addd9f640232c7ee5bbbcedc98a62180de0fcc89eeb91c155c30b4d95b69244f d12827f603327e930417cb060837b51e40940b687e63fa59b4205650173532d2 5c67f213592f92223ca45490089e54bb63a31b7b21a906cca463a97889c7186e ced315ef1e3122f79f0bb2fe037c8730ff9a74f82785caea84bafb054bbc6c60 f895036eb8552502857e06f206f52c8925fce570058f416e832a2480d458d785 6f49faaec09b6ca4cd8d5d18fe979d5e3c989bd5b5525a1d2932f8fcae0c202a 4db4908f51873a1fe0ce8dc67cddadd609c4950ea9d1f54d6529083f6ae0fd07 fd0767f51f9f0af15d47f0a04f802ae06337088c149ede2f04fff3ba168dd907 68db263f78daa2b3657f2413c4d6e4ff1940773d1d04c0e7327f5dbc062d4b52 a7ca464dbccbf9146b49c582205513957121c6764e89b5c3515d39bc400cf740 3e3e477137644a7619b7cbb2aac065c63713ecc27fbead6154a859344834e6bd 539de1834907d44c325c8c16590d04ceda709aa5d0d2531c1f33d08ea937423b afc9caad0c0c542ff7c75acd6e26a426c1575af68085c4078c4fccb411fcbff4 c47484cc270e53608b31a221e7ab6138be080f01d28e5a3569da9e6029696536 cd17752a67d06646d93210d10cdf69d31a3ffc053af196f6c43bd9158a6ebd6a 1350355d29ea897fdb8f34702bf8371a9bfd61174270fcca971d6a7309706aaf b26e1549bbd535ce3ee485fa190bf836fa6a79cc493e94277e4048321bc2e28f 0467797e02441aae71089ec651738c121cec92eed2e71bb31439cba92fafb6bc cdff1c2f5185a0e8d8d141f054f02aca42a0b206974de6fa12527e35e1aa9f68 d30e1f843b9c1408658b2ad560acf450ff2805d86d532397fd451ff646635d36 bf74bcaf3be844d3e9fdba2afbc43d346aec5911f2e4f46e1f49f8ae9cc34c99 dc6d76183dcd3a7b356fa8b248f337243f2fe4516684131f1c94ce90332252f0 455b4f65caa4ebf4b3c5614d1787f1f327307b179dff307bec456646ac9c4b0e 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 false +check_ring_signature 818af8dec37ffbf033ca5032bb63a1c2ad935b21488695955fd4f2bbaea74ecf aff3a960f9cb6ab8f70959be051b7e11c6474a175719121cbe65d7d9037beb59 231 a19b161d0f05da8c083f111087e40d487ed3592c7739c873dceb2efa8a01ecd4 7f79c25597327a7b0545be7284f4b461514b1e1047e260ec41c8fd8cc81361c9 c9b647cdeb3ca54632797f890002300f970b505b66dff0f55d34dd26fed6efb7 efe4a553eebbc66218e82a72677dc15be6a6454c19d432eb3f76c1dfc535f2d3 d60163344be2394cc5766dfbda22c5199615a3c9c7381eadcc3f93aed8f757f0 5d4ed338cbb52f964ec8249529d8cbc5a8d0842a8a03955e7de31e9b0b004d60 7ded60c5860255cd945c598deec6ecdda82be93824bb4a8d90f0594603066978 0e50547fe9b90061465ffcaadfcba935df1f9d256966869ebefd3336f9cc3009 06cfbdd3e6992aff52be7c974b9de998c1652bf36b1d18b7e8866055d7b9a17a c3c3dae8d8fbd6eb3449c4314488c7b3d9e9a8280fb8cd82d1c384cef1397bbb 864c5c8bc3ecc453a6b09790e1aca943e3f9730d70df21d0ddd8323d1ac9fc3c a5bd99216a2d423e1e2e741aeb8570e47c85f525a8550b8b48d235f25604d07b 50cc321da9457d81744b16be757edf3be7416531ee23988d661b6fdd684cb704 85a225770e74d49cddb2442a85a0201497d70cb7d748bf14b1eb9695a524ea86 607f10537afe6aeb6b3aabafa8e1c308fff5186fc9ecadbbe1b47711ca46c5a4 ac13b1a7b4c8cc71233eb6ed5af661e539fcbcd3ba862b7eecf8da6af7db5f1f fdda909dae411573a527f7f4a75dd13d974e1bd08740eb007893969099b0c5e3 8964505c74c9358ceaa2cd323a72400c5b37a6199eac1eb2fb2e732dedb7b091 b76dd1ff7feebb7abe0ad402defd01bcca140ba133d1deecc970e3eccc2cab61 a1618ce6d9fb818dc0fcd1af44ae8bb807d8e0d580f1eecdbf27ab997af2da22 adf430f7e9080c139cdbf8d03b7f86f074228079637dcbc89a42cd4cb7c79d18 7395ec944b93b2a5d4fc515471a248bef0c5d2df023e77d4ff86dea3e135456a 5ccfbbd5d4ffeadc69f9d64231a58bc034c69c812d6563659f0621e7c700753e 12cf573ed3da56e63be4efd4a8b6dadeedbf6855e6fa5ecdd1e2dc1e3080a175 a73f33f76c954ee3e108c83b3ac761df55c05a6a38ddaff571522e8a3f696b08 e348b47a1620eb5285e4b1de082eb09fda4585667259c35630c06510ae7e31ad 629ec730ddd4a00b55e5fdbd374c968eeeeef299e960e9399c4680d21fba0391 88b97643050f0533cd35aec6f1e2de27659840fd0de43fe3fa5c758da8250778 86a0d070d33adb3eb07167d3af82283df1db7c9ee3c952969f7183c307f33d73 82289bda2c7a01927ee941887fd256f646caf14c7c7d682d0617d0a345a07cfe e7fef4939ba6b0e92ed087551d3a49387ed72eaad4584d2dd0489db898491529 dbf4278550d8b32510fe242f3795bf7d2ba336d97f37443e4efb2204f376d781 08f90019b5f3b814aca496a8ca7e7d6a2912e327ec43a8b1ea60f73363e5c80a dbedf10eb9931850e9e74a9973dd46de5275631580947061550f845989feb0b6 8e8f464e85031a6ebbfb9ad215e1055595f27c45b759ac4b82bff8a8da8b2fe8 99fd098b9e500b39aa0118243bbb73c59b577f01840eac76da5081682bd1307e 3f78f60020d2e56fb5595707d7b5f06d266672820c87c2496cd03d971a4ec721 d0868971500f9abcf808a38a0cae68aec44d2f5a77f823217ae1589ec9cfd4d1 201388868119f18c6686e530000e95d0e652bb7f05772ba794edc4e0a9702bdc d140445c6d63873dc6fa0a0443484559e2240a3133de6f8e44bb92d25aa8246f 19cc9787696f3c14af5f3e3b9a1eb8976dda4a375fa558b8370c9aae2e7fe772 ed47d23acbf3378a452dad54caea1ec7636bfc634091254894e15f98d6823a45 bc389a0c7e8c7adf6d1f741060d06318ef78518ca2fc0e6e19c44967d41b5d77 40b7f92b93be10f137f58685b30964003638710b5854015bc1eba5db23e56bfb a7f21a03c9716b2ff1f73e46be4412d465932e76a18ae0a6da1b5ebdaafc3793 16de1cac521b481345a93e4be14e4d65a1f4ae697f2549b9cab15158b63680be 0e58ac7d4f11498ffaf516e5deb5da16c67cb0e0902f182d0b49bc359258ff06 349bb01b3ef0f38df0d90a2af9d077a991d30ccc131f73818178383445d17ec0 01b45315a2e9c2d81368a2392f6771d91b8be0999609d64d4b36eafd52b9da2c 6fa3707ea0da66811960122db1108baa655f1982e0f01c9b9d6d4718a06f76ce 0dc50a69d9d593ff0f0782e0ba7291ab65ea5612f098a3a72195eefd1711165a 21ce28f26e027d418843c67ea892feee83e76ec1c24be9c1d22886f0e48a77e1 4683144bf224c07c8aa3812b7cccc0ba08f559cfbd26d3487ff7e1e72d87c861 95cde94ba5eb31c1d230e92d6f296f338e745cc4833fb7ff2d6b360ce382ff91 50ec408aa6581325b40c5ce3834ac3c4cda7b562820f97ee703ba205a23d5fc5 5db9d50bb56998b85a3cd4f776019aadccf5d89ac06fccbcfbd82d44869ff7df e30b5b32507c79d72a750de45e4e035ecc58abcdef0419bfa36f85b7c730cfad b79aec5b13267b074692c8948e737b979006e9c54034bd7e1d345e15dd875e3f cb5f3646cfc94de51463f951482a3ef3fd5b857f166d49cc7e930b32a1ce11b2 45a70492404066e9023e831229b334466b71826fe43497ab6b93ce7f79d5692b 7570abb82ae09e285754d1e4fb45d2236e1b3d4847e66987823ac0924c013546 669e1a0fdac417a01db5f9ae9f89a10b921464c1b3cb587cc8ead8eb566d1d67 87947f3082401e3667adbff2fa1022c8eca6aa8fe9c38459c42a9723a27816d0 c425e6c5de6edf4d6561795b1297b8e20e3fad26a0b812582f1d457440d9d196 450ad0832e11df9b7c1a846ecaaad6f3f3590cd83c2116bc2c9a67a8303ca1c9 e9b862c8722be2dd34b385a86f96909909d8ef5782ee7f597938152daefd7442 46628b6ec6184dc5b95c1bed1383b3cc81f696f9395c5f15afb4f9474d34bf8f 652a73c2519cf5c1cd5fc08e3fd0d58c599fc2839b5f85a2d111736c27a14d13 1e2a9dd26a93e03573fba21a780746226e81a15a895a46d0fca109a413701aa8 98f9ec64e9f48fbe24d7331b7889436c838c89ef0fba1e9ebec4bfecf76a9c6b 4de82e3b4d6b9569ea1d7a7451a88c33c115dc8c19e37b279ab433eef9edaf8c d9e45f02811caf631e842c546fc479e20aa56eb608c84790fa551908c1549a47 e818846748f347f8e7dfe3f25af580bf57a72bb37f6de975a137c3218026d5b4 c197ac12d5726e6e8a7c53d33d52a15cc54e8e48f4bff504486a20330946e74a faab7a9f81680fba4ce14c49a532042188e4ba8cda3bb73de357f4c6faa6458b 40662f3fea716ec7af85f95352527c6cf419e83aa4c25ecd7df8db2b104acfe5 d2482477c9307cbede2bf845eeeba9b39ad45ca9653fe840bb9c36f839a38073 147b1889771a975d6833c3bc391561a4297e04a4c319d90e24a93b65e06c3c68 b9d07c49c1becaa3f41bc351a125cd9853659d684b33318dbbe3a8d1b082e9b6 d843dab7d0816ae53b6fa84bd001fc78a50b8b753ade522d9bf51172da494cf3 fe735a81f3a09c51cbfec726a68fd34ab8d3498f0b4bed94a293cdae1d9f7374 6dc97f386ed6f1ed6dc50a60a89e51703fd26ba921d2765b625c286eb4383465 07f72e37af3aff67a1c7c1aefa4693468be753faeca1c8f9e2a69c3b3b67a7d8 728ee8e9889406e5b023c22b7ec0334078709b3999ade3dc126d60e87af82a26 df5e3bfcd53de215d5b3231d067a01814f0a0368ebf77819f84cd8567257fe62 cba092e1706407a6600bb0e78fc955a18ce26021bde790b6cb551dafe9253e2c 3528aaaed5ec99cf00c8bd8df9f0575d05f78820bee11da63be7982af3990dbe fb22ee89ef3f00209ba3d261ef756c7a383e494782c812d2529509e43092c65f 9d990166cea66ad52ce9f2c89ef53fd7f7b160c337c63411733c9d629ec46f2b a847d86266e95aa562d076439134791058aaf5ede749b32460249516585d3b0c 79132e4cfb98846a34c6cf3f39e3bdcca69fcda272cbb74ba0b746410367c5e1 7f27f9f16d5b2c3af85df59c0c20354ccc3fcee978cb94c8d96f0ebc88c3ce7f b6bc263c88764c2c43e511709dabc8e5e6f316c391919bb9bfaa9483dc62ae91 6288a7e6dfdfb97e5fb323c1b107945823aaf1b47424335bda79f3d89ebf11f5 5b8743f4fb13107cb090c9d642bcb041d3b0b421934a9afb30bcd896a32e7e93 e7edd3b1e9be4920ae3fd9236505aa85c3de95a36ea25a12dfdc311c565902b2 8cad9c3d5b7a14705d2b266dbfa22af1205d8cae0defbbc7741fa6e85ca1574f 3fb4125765edc2366948b47b3be000432493d8bca535c620ce54b07a1b456c1e 6d57d80077d0a80a08013d43c4a0bb7cf5411cfa35092518b50050947c8d4ebb 94a766689789ecaf11d9d83aab0ba8b6cdb1148bfe558937f00f50dcbb316184 6d1f52828badaa45386820f1cbe928061bcf556b2232132ad4b82101e9b5bc43 46a9bf98c6b043cfd712ce486f3524def622e03cde7b0d4a9ec41012be10920e 3c6e307b4bfbe7baf82db3e83ac3c4e2a83c800ee619c3dfafacf880a14f6286 36542e461ea20d712458727bbd8ea9aee3f971f82d54d91562f8c4d6316fd5d4 ba5dd64b8665b6f063589c07c8e17c7a5a7b459f786b9c765b66c96517f34022 6c4f56c0d4ca4051220899333f9f6bc995f5a684e02be7ac6172d2b5265263b7 a9ccfae851530ff4266d7d443dc91e39fb17cf4fa4b20ab4130d5a3ffc65cbf3 86200041bd1644dc0a93b19bd4790a58158f7a65f8fb462da0d265452191431f f793cf05a413cde43c6273c39518994718dd6c395352d0805b52f81d3b4527e2 112f3ae81a2d9ca7a151fe12f458283caaa79de83ad4a8674e045580b02b752c 3d4252613028032bd51ff5e7869c1e1d459deff6ba841635fc09eefa9e2364b9 eafe4c5c0f16504723344a76ecbcd72e988385b340c3b67948dd09e67fcf7504 6294e7b7860e05a779db87247773d132425a4981ae09b139c787ce58f39073c0 dff8ad717eb8156a7909c29b662c95d979fe19b028dab8332f989b9f1d405438 f55199aeaebead8abf70b817224d28e463358e5ba91a0008c9e509f0f1b0dd47 736af03e41a6b911f6f813cdc4fc26ee992390e961d3744a712497f9ccaeef3f 2a4627f23ac4bebbb8f01f2d68541d0541fa13d4b385719dd0a2a7c545e7da8a 6f9ddcc56c1b7325f083c56a5054c0c0c38f6b6839575ece7cafd66643fcb58b 361c4b575fc323212f8df77e0de63e6dd272c9442c8614cef3768baf6db7f040 af7b121e04acbaed3363b237002725eac77cdcd635e8bfb31862b3e8c897c0eb 078069303cbb61b9c92ee422255765f79dcbdf5ad5e6e4484fe6bfea57c2dc76 5d2c0afb171b76f9f93f60bd2403a406facb3542ccd3ed1987f269918855c4ba 1d18855490d10ec582a4a08e24ae5f75024410259f93949266ed9e14f1a77fbf 37e07f7f9ce95405918c4bd599c3a0ad0d0aa6aaafe979e63045bb96940431b2 8b173b6e806f43590a15ceb537160725cf2a929777504da58e8caaafeee75de4 c6b1086ad92ce2f6d37d0255ae57915389b2b7ed73928b855ba127bb98f29b56 2af3c2024f664f268242175db52d64684827a27b0bf3f5d9793c2929fe8199f4 ae657f459819d64eb516d136eb198cc810a02c8da1ddb04c14af7d703da40683 df5a0f4eb58adc10aaf6cc2bfca2327ba654d9015087e2cf892d1f72e2e6b54b b6dacb0b93362a49e63be1faa9370279a249d1ad3b3af2a719773ecd583749b8 9196f4703d629fdfa47c0a32bd61b58a87e6f3df5c9103396cb36b913a8a504d c2bf6da9288e45ac7a80f9c1054772b0996140c1b8ff44fc737545c977948fd9 aa4eccfac43c1cb85a40f050ed09f66a6b9b741232dbbeee726a81bfb5b385eb c42f212f51c95cab7732310e79de189b601f8cbc0714aaf412de0abf0351ea44 97412b75a6e731afbd5314531914d8945222d62c426fa3fc9ba8eb0a5c32c29e 7482633d27a2b9a9f55986730b814404fb3a2ba4e8a82a43eab3d84726a33af5 361645052d8dccb379eea95c5b2e58dbac30fc1fa7493ee2e9ae2b9083c04361 9db9d9dc17f977bfd942a3c4e190162780778fbffb8426565f25d2bdb6ce339c 643e8e8981e9921cb1147d4ee9199de42e2744cec16b8acfb1121d73754f67e1 89d8946c6ab51a1912a075c9fb0d30c70c4d5514b28400fe9a0d432f583e44bd 11cb3dac28da0371b76937d322ff5db2607d719c385953e68156f615b8c7b178 fbac9ee7d58838d660c33c4cb9fc153a24316157e23387dc2857aafb99dcbfe2 139f358b80242d940fb88d8fedd324e7ec84cd4786cb560c704cc2e577c1f1a1 fdcd65d762099974ce1247156627e9be8c6eefeef4e2115eb74996beb58239ad 19d300fdc7220f571736908ea6d6816a56997f88d9e79bfc7eaa4b94107d56d1 f3690241c8737c09f83cf77050fd1518c30030d2d070c5bea6b0f5b0d9c225ae b8090b2bce8dcae7e79ff05fec5f3ca1ef0c558e156d9396d99a88379bb26d3c a90fe55b478943970baf5a46d93323cfb0f9617fd7df55724a4cfa0dbe188724 ff3fb8c9070a9380599c1f149e2b94cfaab747e52ae4a4d07f51ac8e43fa2f3d ee44460df1d40ac16eb25bf2c5b91ec49199ceb7e1d7b9da8c7e945fc98a55bd 2b06fba082668d623922ba7f49f3780cfab30de2c439b363a53198207a76a477 c13566b8f89fa4b4a40b8dc58142cc74d22ad399c9c6b4c29c087518ba09d180 d2aaa083639bf656fdcd96dc834c80f3b30163c9abfbeac01fd4d91cd9637326 c10885dcafbf53c746eb31129787436d4a44807247d951ffebde5bd66f5a4e71 fe7626a260f03d5c255499abe39b377b8bc712d9a8c22a16ddd52bbc407a6cb9 5ca819318727d2329303d4d0582f174b5850d400b18216579899112ecc5cd90b 22cf3ce7314e14d59886b09d9a198a6ba286da5284474260bad6ef5b3603a4ce f26bacbf3eff8765c2b2d478dea0f37127fc7c38e7183f9fa60eda4dad954de9 5592d9f564a0a398e4c781d66781558f1ae8e5a99513a380c208a4a96e408428 1f66d98d67ad5271467675949ddee86518a2bb44465f09db3c18b5ceb83dde11 ed83f2a222563eb8133b57e0a40632d7feb8e9f75298625ee3cde346d5790628 d368aae656edbfa3b0f60cf62caea14846e7145585178acdac566d714921844f eca00d7488c35779b0b3842439598a6c0378577e0669182cf548b3c24d5dd900 aee7744d280c7016cbfc545925d707f7437340fb46f6fcb818421efb5ca54c03 ca7c77831ce42c2e9f934d8aa4a7f229e2d026c3bed3ec1e5a408fdfa6811639 8f6e6ef043e2a295a47fa898c67c5606f47685fff108606082606a58567206de e86fffbc0aa461a3aec5729c7abbe1dd8dfec9dfa873f87c9438915ff0d46436 d4cde197b930ef3b90817bfd8d3d74cfbed536be6df26884490d5b55a31df875 8b3da1981b21f58ae74ca68faaa4df9df0efef78cafa2c6aa2a2417010a29cd3 84acba6fb1fcc70a24ca3ca03f42e188d542a14003d6c0df640e582705dbb857 1687864a5025f40c11d072806f81254a38ba757bf245eb74f8d9dd1fe362061f e23dedfc5ae8683328577c286d7682e9052f65b79beef3b384abbb6a2feeccbe 8763cd2a179778acbdc629393f07930609f79256b41e980c2e2d010446554d99 399e455761ca85ad6b378cbc3f21219da25002ce94793c4f164eaca255d7198e 72b67a025b22ab3f7e82f0228069c5a7583e1f63ffb2c8323249482d2dcddd07 36497f2bbc07add59013f65e5053701e7caf130433653a7607b3f6599d6e84a7 3cdc5bceaae7243efd761f0fc417888f1b141111564807908ea897117be22cbb c622f1c5e5d8740d4f6c7fc94816cd98e6653e9fe322e7810243e309b2ea13d9 9e2d0334e13d1343abc8261aa3528b6521910152ea70cc6686a12c55b11dc4c6 dd449d46bbc9d2d05467a768dcefd1a44d3a2f2d60feb10a58124a9ef83814f7 32cd8ff28e06a6b78a3e4397731b9936962bdc869b38d2df09b0f7ce0c55a956 a46fd79d5a573ff6ce20c699d8acc8c452f65f6a34552c96c916c7d32bad76da fa17e81a5824558222afd6a8fdead0b84b970cb3370a246f023ca1069f46dc6b e44da975c1afbdc35daf9bd912b3064be8a7061f58218244141661582e510be0 77621a08e9b3d4cf95b81037d9ac0116c6ba97545d5d5dcf1f6991e4e4a6303b 49ac6a84ba22d0d36b05fe2a84cb42cf14a4750c246bdffa1bd6a12bed7bae69 c1b97a0a64d034bca4a052b1484a950bacbef316966d3209d2e8f1878f174c0f b2da0ef2c20dd11c266a496baa1ced40e39d51670c122e7bba13f214543220de c67ff49e056f7cab7a71d5e9efa014cb400fe2a7fa9302896949ff987e88fbd0 6800a836294b6e5819d2ab0ac88aa71e2efc8706f3c97595e3670e947a0dfd2c eb20ea4fa0744e9d52dfc44a3de362f474b65e9a97f671add66628814d8b1bc3 9f180ff2994f30e315ec7d1d87e6c8c3e242dc8f5fd88ec5851079498b83ebc0 3bc1a2029983c554e6ef133e3a221ca6bac5993acbcec5763ae38d86fd65c615 003c1f659ca049b85814e6a49e8c8ec8c5d6d2f0f39123e5c69aa8de9f18c543 9ec4be595cf0db8d8355604b14507054624eac921b95db0cd6e337effb0320a3 ca3a7389806ac815044bbd93ca91958cccbbc966a129b87b0b19c76ec6920cf5 a2fb3d5e0fce299bd0d17fd7307ff192ccfc565cb06438b5cf04e23710430894 fda81fc0e8a8a7e2a0c503f155e21239f6a963c987c38157e51388a6d09ca0dd 4c7eaff2370dc39bd856766fd314e8604411435b64c2090002ec5a412768b59e d4d5b169ed37a59012d077522c6f32a2916c57f77679119421050e0809df7a24 029fb040dacf93a705fd9bf3ff05cc960349b02e402f3400aa782a5f9ad81bc1 724a3de3427160ad16611b0dd6bf2197ec45ce4b0d16b2f9038a8b56ea024cc3 3bd46ce89b4e816348451a94ab9f867f30174c31efceb89631c1cfab45476812 0589b6aab992e0af67ac53b8f24f33c89f9af11dd97d8362cf9612da6bc77a54 5884fe36f8c38f1921046e099a7f1b9866c5ff2fd1ac861826f21fb436bc1181 5bc678ec8817b5ad4d83ee9357647565413458283f5e11837e65b03118df7e89 45b23663b601ce5399ae2cefc8269ae85da3eabc86ce6db2b1f2edb475bddbab 1a181164d49282091a94049f8cd46c1d859b8ac13face7acca2714182b9de66a 23fc47297853ad2ecd1ce2d044804d326f4c4461d57c51b04020164b8f69f074 c928abee1d4fe14f7b7a642582aa7328387beff2e6eaf62f6cc6543c67ed0eb4 fa28ffe6ec9b21eef27347be24f557ce9412bb1b86238f747d54776868c1373d 1b181f519d36b6b88b22c5de74a2db453cd476b5ff73f3d453c26b3cd824f50c be33b63a03c1e0dc098fcaa9f986f1c526d9435a5a8ddf2d99a89a6c2baa2ae4 8f4d6871a4471375b017591677f358070dedd8c6773b5fd5b8a462dee14f32b8 533a0cb7d1c73c042a42129fb44709e337582d30b8c351b570b7484478c20d58 0bc5dd0658246cc4b20b3845da2aa4a00dc1e1fb1c3351f5d86be63dd84b9d41 4165622cbe11257ae5652c0e40b477401eacea233eab9b41bcc5000b740fed45 55c6048ff65f45944f8585a304e43ed0344d07baaf6d4e0a6a41da2218e0bf45 1ea21dc9eb94a35b84703f0231df0588e001a10c054d32365a6be44ff7707f79 5f68523716f44e16bb7f2c1f25447a81c83d5420ae75793b8dd89d5039a231d4 cf43394a14378c275aae9d325ccfdc4e672eb8219ca62f09a595f24336ba481b 5b86b884754e55419aa3acf35660b1945b3495799fba131125f79aad0338fcd0 41ef305fb3d6e330dc888a901843110e99418f18bf91179e5442ffc3c602a08e ae7e5bcea37ecd12c914e806f323cfb80ee982d24f0b70e9393e9f4087a93368 4766c139636368b66970c988a87e48357b3f620646852d68c30ef6647f8ce628 c20f72cb8f563f0f61da312fecfc3a7e969c93ae522104191f6855391caafdb7 4a373809f432a55434b71ad52a80a09812278dcc712c6ebfd28e770749b55600 ff96e01afed08f9e0d3ff01ee6ba291d3fbee3898290a3ec45a5d1b93bfa7d9d 55ebfd1fbbfa6bcec2603d133fe59c18131d745c12a7145cbe3e31fb3783de05 850a4a31fc60803199e3487d762cc2414b1654ffe84d86662d4be4bdd6df8987 6e6356a791d546bafbda86ca061644ef20e579c1b704f44a55f42cc59887d9c5 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 false +check_ring_signature 1cae308e14c147235025c6e90c69226229971e126ac0464e83ca62facc4e943b f94baf2c43e53c9793e78b4ead812cd6ad8c9983ee103517da31bf56e9e8a834 32 6c4056dc671d75a2bd1f8e1ab37d6f697db56386cf8d1410844972942de3dd92 20cb16582ddfa3882aa734c88ef1635b1100281d096a9a30db2462aaf9b6818f a71ca9b06a33de99f4148871fa1f3591fa9a1ca4683cb6a1fe1e6408812f7e92 749dcaf1bf424ea43d7998767a6390cd08766f7ad7e781f395938e50117cf4a7 7329d3ba1afa598e541915155b127afd318e9bde2bb55fd168254dcf25bf192b ea4b657d5ed6fd7a9692cb5bdf16bff1a08e86172db4fc7ae9e0e1d012db6d5f 6453b861c007cdc3c8901f44ebcf72cb995bc67d57009a8dae9397ddbfc60e45 f3987ee2b934877a35a7a8ec9beae047a16994ad4d1b5196f4f00a90d791ddf8 42dfde55ea15175c3a59e2f9c8f2a6ed864626dfeeae36ed87b5f8bc5c5b42ff a6e888cb8f414681ef219f342357011dcb5f476a794884abf7212e97d9e39fe2 6d27e1b551d17caaca3054bea64b0e2171e2518c092b40779f31b434033fcf21 321642615cf3c5efbf667d3660aa9027a5c7930122ec81e77081d8a918dfe070 1c84fb1d4dd4d8d44a386520002eeacfe717506f303ffefab57eb0636522b980 f64d987a4c258bf680282c02969baf9cf46aee640a1cf1a6d18e998fa43be1f6 7f94b17e66f06d46ca4f4518559b3e30c6bf2130e0c3e9b118e5c0c721847c9c 85103b152141e6cff147a41dd75c7fd1bfe0404f75211f8e248b7020e71ac34e eaf6f83ed94268a7b37d6a8863617281b71835258e117da1a53c11e5d93fad57 7d63f61b4635911e9cb4081ac680fd838f01bbbbed26f05dac7c1e1e01710885 8b080766c9d587c580fd6176560e84fdd9b46b76a4b7fca6aba8ab26d8306778 546b94134dcaf0ab9a039a536b7a2c849eff6cb4ac42ef0c65193b8ce80fe642 36e4b5a48f16f5015702301b7141d6b7a40ae8e5a22735558e5ca0b2325aa917 0f08bfb9fd36998fd1a17649664e523c8ced7cd6dc09496c9e45465e79cf6c6c e706d9cb4b99b9cb6e5a79f9c8020ab56c15df0f11b90bd46cee288d317d46b8 589daf1ec465ca138099a0e3b31e21f3f4e3b9345a8da51fd40e22ad75d55392 6ce807b75338bd9a3d3d747155c99846c8e2991e4b3a02a9a314ea4c6d86c211 17d61cacef31d561193b7e792d4a249e35ed7e883863ef473a72ad8a26ae80a6 5ca01d8c31e0f72c1a757295922280d0e9d0cbcbee8adc4f93e392a997a1f843 6b7502549be684edb684a5f5a27b6abb6bfea3669a4ee428f5e140613a9dfc2d 3156b50e1b7c190dd0703d6a0bfe73fcf56618a76c8a48ebb4af900eae914942 c044c7c8b368dd336d9c43d6e280b8b13ba2b28269bcc79f3c9584af2e5a496a 8581760756fe045259b8559c06b9ae3b0cc33e1847ef159f4413bd4c1133d130 1ba2aab7847c9fa854b31a778113af5216b4ca696f4c8af11fdd313fb8bf3761 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 false +check_ring_signature 8f4ca926185b1644b02ef5d58669fa6667928e053d4fe59daaac50f016dad0fc 397dbe9cece430e5d6160077fc5cb55175ef6e6633c47c869f820293eb33f447 205 faa07bed8eb843f93a9aeb874fb06f3f925dee40af63bd2aea383979571febc4 e0f664f6db22f243bc156feea5f4a509f76e947dec323533abd0aca3176630af ffbcbcd4a93dfb46283a63cac30782d5225db55f329ee2c43a7eb8959562f94d bbef41ce4241cfe6fc93b90250980da02740fa5ec6f9722f5b3fc65bf141e744 ec1f4ffcdcb99c4c52a7926fa586776f348484a6674761beaba643108d2881c3 9096525d83ca25a890b63b0775973ff2a5ceca9ef75902ed86764211f7c6506e 448f7d2afb8705570f693a70394cf7422775eaa2120d589e43ca5b21b095f8fd f76893b206b26e4abf34125eb364d03dff44d394dc95b19514833d44cba5d3ad f79550e340c723c6158568446652952a459ceb2f9cdd64772247334a42712a21 d1b7fa86470db365156fbdef611de59499ba4e431fff9f3cf430ca9b9717fab7 cc914bce3af3841d81c14385bfcf4eb4f0cc566724194e2a07f805f00e0fc4eb 74805cb24f2bc22bf1d1c5a907b92eb319968ff4ff5041cbb9c138a2934f59b6 accac956f776ee1670ff93bbbcdcbf54029972c78e8568759a49acadd22f8f7d 46c845ee8cdfd7efa0faeda2425b0dfaf84610a9d13055066f0aacaed816a647 7da0312e698d2e4f0ba1082f436749407ad78ef67247ee630ab4890e9f8fc9c5 9c195cd417997221b03b17e362e834f5f4bc7f21753c44757b464d1ea22b8478 035de79b3225ae044d7c0f18f276dfa02e9cc8dcbf6f7dc2df624d32b3ae722a ea35759d09029404d104e31096d1f245e0b9d61a36e9f1b9276ef004bc3d404a a0229505f6f48feda9ff9490792224e1f890a1e6841364825d28b5dfa319de0e 56885d3349de823338403d7d644f1187162c7b31d7ffbf3de9501d35e134baa0 369a8987a49f09b72228533dcf08ecaaab326b7a22f148edd7746cc3ac7a47eb 546bb271df47deb4cf8bc7fbc883ebe43089182205350c7bbfbda13b41847f3e 89027a513788c727c60243e6f7e21be84687d76c01340266f5cfbf29ae5579aa 6138b48b4bee9fb49c464483a616cd41c73a9934d25b6ffbdd86748994d3d4a2 1296ba248c06d04ef912e39214f5bfea42f23d828073d5e264ac62fb8503e522 f315fad27d544ebd10241af57c705dbc61142223fbea54a297e9f968322d727c 501032172c56e4ba8a9b42f40aa763089d4b594d04243a0819063732c63591ab 52ec92613585ae0ac683ea5461e7cfea14bd2a32e05895de9ce9b06bc8b0fd70 2b2723710a617a8874c9358a54f1f65c21a96635ea6d18e59dafe678c6c18742 5b8a5fe325bfc52076c50bd31e077561b3902ff0d5e3f8621628ebaf481a465a 076267c2befe4fba2a313a6168160bb9853e43ec2bd49c9f6fc121ff8df5351c faa456f7ae817f26bd36c8e2cd4eaf6b8cb1e39dd07abfa4794da73f183dd194 cd51e428452f5a3a5cbc5257e9095397b884d19a0bc267a61ecfffbd5261f709 4ae1c01a499fa70e1b54291d7cc9cbb65415376736c5715c5594443da020493f 0d2a3423eedafe70a55f11533685f96a1961f59c77bca8d6243f7fd1ade1ff42 a4d6c54fffe45ac1009cdbc5bc5c39495f2205b61a0e4bb7c0f9cd9e6a734b1f 87a02fa664a14a808c79e7e86826e7e596c87be85132e6933ee0f921d919161d 3676dfd34f4e3d81577ec10f38c00859ea61a975784090b1f5233501950dc6d7 77d3f5d0b0d827e7b4b986442533f8d13042c439100c97cc23c033a5ffe731ad 6ead2bd64e5b3c28a6657010562d62624a79a7c6c681cd4a234861bf4b7170fa f5637cc3ee2c96a4ecc25d0fcc397fe4c8643089d9ea76a52dd062f1ec0b75a4 7192fd7715a2a24bcce48e3287a2f3e9944dd6eb3ea856f83e10385cffc555d3 f7b48eb464bc49d2ffaa2d00653613f0c13ca4f317805975bb10762aec384f18 db6a711e6a5989811872d4e6de0587194775b8af377ff6c7218f53d43bf21bcb f422568f4d73e96310395fe6c2dc52fcc43a3760a9fefedb447b22b29ff87bfc 544e711d490d8dae23ce40fa5f3230d51913823ecb6847b2d6a3d2a0e7cf73b7 d08d447aaa386b1c14aa3aa93d970ad2c9393e75c8cf1d9407db195fe794486d e4f69760bdbae6876c043d5dff6d07753da50e530830f7c873356556695f7a25 65895861996792c9217d5e450875bbdb7666fcf7e56bde1b9a936c2bf1a829aa 12831887019ac1e81cdd2318cd0848bc0b18e8fb035c1db0025f375f9d254e42 1f57f27a0739adc87c96bf57bc3ecce0d169f58f861d500e429dfbc05bcc70f1 2e6666c909284453ef23d3277fe7fec11e11e3258fc4316e4505e45d3386fe47 6fd5e446be6bc557af86e52713570eff775fce463a707683606b37d80d85562b 634ff668ebd66ea2cc3a0204e67d920f8bd6ce5306613304a1bc596d7f0f7c86 5e18cc34ed35f4dcdac079533b594caefa905f20590b3f753278eb5103b1855e ee6983322cd657736c3c63cf0f135e7af9d216622ffcf74d4e6d5563500e7bdc 1d8304240fb169eef810bd7e347de2a72043477e60edd368117836bce8c6d1ce c0afe08f0d52861390e961a383fcecea9a15ccb53b01e3b152c340176978f3ca 4a01ff39b62c861db28b29527c1f9b7f4441419380c0812145a2f03c4c9004e6 56602b50d850ae7ea0e9a2b86e32057cf59360f1550fd8c49395858392fdeced 697e95def772b3a3e67e99b717d74e10ffec5ff51941996b228d925aeddcca66 c8ae8487e1a3bd97af2ff7d1e3004fb05297f4e87bb62aca14f6dd1059b38940 97e209f01ba6097a2e9cc0ca0946dc6dcd3ae1241e4d97a7009d409324e7c2f1 3fbb9a8e8f0eed259ba62591cc12f6a6c16797cc20d8480d5d6a8ce24d843c64 9daa5edc63223d6093bf5eb08c14f1e39e672a420887123b69f56aea9d07aa58 304c8880348bf315235956d2ba7db69fe1cfd06c6b1f58901e7e201e615df85d dcc5ffb5feeef365489a2110251ee05c731d2853009555b45b5775f36ec2352f eba4a270d3b339771745082d081e93f95c6fd7f4ef784bdc83fd834d545b8593 f06dfe1dd1cc5d2c487b312fd7b05339688f8bbe8105a6810039abbc285cb587 9f9aca63a1894a2e031f8b79361e4d36fcbaefeabb9de3961d589b10dc06312b 02eb86a63ba0b4321b24212333bbca157c61addd5c568f3af3c691b6ecbad8e4 3c3606efb20e016ddbcaaef5deed94ee06d9488078d9b19ecb79e5014268e622 233bdf32cc68794b6d63b60979188c3616eb5ed9b9ba1176d20c2a668f75a5be 6d9c05e534caa5049b1567e726dda3b118bc43f63de6fe7e16fc4b918e63b462 8fc25108e6eb9b1177605d05a2d31106cc38b59dd60bf00b5d2a507aa3e64b1c bbb5b758b007e1a7a829b25aace41c5ac784a1ac06999de72f768be728be7702 9f4d202f5d48361b2f2ace3e6b9d1958e77aacfbaa82baa7e860f67cc1ec66ea 817004f531e4d191f80be7f22440939ea24d3433a7c7acef13d2d74d9cecf96f 5b5786c1e5660e4a0b5429596129abaeec6348ae826005923e2aae48f4073194 07a56005b44db6626b9c968b5929c3e7e4c63effe58cd7b4fc5eafd396856aae 47f65776dba915592cb7e960199b1477fd233c08cc1f54d326795d3834a3dcd1 04fa1b882197fe4f5734b16f14b2a55a5f0fe1b1d4e1f2a57a26b7a4a9865346 c719aee696cf313dd115fdbde78afb0e4a9909b90d747781a4208eb5eceb5f75 7c98cfa038b9b877fff40f3afa27c8daf3cb7e42fb39b0118f2fdae7538ff99f dc29718535eb7b6c439112d0196c200f2798eec6d942c034cb139cacbbd36b6d df6fdfeba803c428bd8964a18f2139d602738510959195bb60c879e04a17bdcb 2361c53342a9bb63dc72f558f65f552edbdcad672f559b177b3de76f713d1efb acbaadb9752c324144ba6ffea9b1594404dd70b297cd6b7ba9745229580ca5ba b7ba03d7efa3fe5be57f3016844ffee2dd24fcf3b97298163707491be05e3c2e f16ac0c32805308da08a445a9b4483c96b2d1002af5c4f0b397321cb901c4aad 02cd4ccca6beff003453cf9ad77ad0f59a465c11d61e2f0715bff97aa23c31fe e42d6a5648f34e9aa35859fd57909ac83fa9d47ca97e8aa9b2f282489b0e1af4 71aafe73d611abdaed1f754ff29e6c730011e858f36500fa601410471af092c7 372ca22e8fb696fdc3f25ebe363944dbb9641b6f783f1e5f45d9129209003962 b9b7d6cd1aec9383351e4f6e197508a94d4581660337b7ea139810ac2c2033d1 af378f89dba19bc0b4482ef94b06553294cf524adddb411840dae2439e3f169a a2461a4e9765b18143deedbaa197cf6780fab5900215904407bf63ca1390553a 97ac22392c4e4bb2d3a1062efc187a99a3c4ce1291b8252fc87d7b1ddd5806be 7103a62e037b1173e76196cc236bd5f9a5c16a4b548ae3aded7f4ea1dcdd95c5 d02eef8b5426b7062982af8b85c5115768b8d7fd50cddfe807f873aa0ef854f5 da606130559f6e9ac70661198d75d454843fa46c2e4abca093aa47389fa95807 9b91b482bb09ecb6439376b6852063ab1c3c33b449d2717907b5130b9e88aa4a 27fbd74ec0705b49bff90fc1c9c86590196d1746558ece62fa38cfd072399095 c5c63e6d23414bc068738e256f993ef55de404a648141f9a1ffa22597a9976e5 745715ef2b3b5ffcd4ced06b5fe53391e7c6694fd01c6f4fb9810a5183276942 d5e0d45574b2c9bb640e27a49a1420661fa2a5f8b9790aa3cf5259ebb9dd1980 50933d9a628fc65d877cb20d00ddf00c879b4af855d5cbc2ff895fb78812f3b0 e2ec0dadfad14ebdfa2596ce3ac49943dac492960581484ffcc05ab063f96aac 5e7ee50f4e8e6f05eb3f8dbcf2e4f4e74e44d877653c70c23871b7748b397813 c6f7f62120d568ad5b8891381c057b8a7ed71061ef6ca87dc3828dfee3754601 a90c899aa7ad86eee47874468c20c6257030aad361aebb5ba4cc56369b25bc3d bd08efed40203ee26b588a08f671bb4946c6b6b5ddf8f12fbf2b28e6864b2b70 330388c19aa2352fd10d6d0bbb9f741840be2a2d7233644bbff322958a0c8bf6 fe3c5c3927f9c66c25f4a712750a193790b3db93a0da01d2bb4417878cf40905 e0ffffe78a502693953aff83b127a676d26b75cfba8f7bd1c04e130bdee21096 feb846d6d7e35213adf617f6f284a6fa796a8559fc845fe3540047d96be77788 218d3dae45cbb42323aa7032a5f028f1153afdf67c56fd3da24c62552a99319d 0e86229e5502e18ac9d9cb0965121eaade739b099ababf67aee9a55214069ff3 cda853523bbe8da8b05e90c2ac32e50dee800d42414df96d6a7d6997f4d9d7e1 4be74b00d77074d611d996112762422a3acd8f54f219e3b2f0de03fe5a31ee85 1d724c063cab9871bc6209a77fcc927527ec4153165c0f6772436adcb6e26b00 57ff591e7ade9f76a77308a65303e0d37478d93264bd03600cf4a1934031a631 93c472b3a4db8bb1f71ddc05076e93012901e93bfd491055f763c65090ef2dfe 464afdd394cf72dab3cbfd0ab48ce6f81505a1ca52b6198f2703af5cd6329330 509559ef0841b6d724fc711b91bda94e8478609368dc46a14bf60b31a400f018 515acbd4bb845bfc232e1d4d861d86e49a881f9c14c241e827b0f6bad616a825 3b4d6fc97a48868f94877328e46c138dc1098ba297825b54ea64e509e2336258 6ac1cd1db8f7179c6ef212c8021b917f0742aac8ff9b34c67eb501e1632ba57e 6f6837f43d31c170814178f65530defccbc72bc83c4580fb5a80e7c868e230ef 58362409f99880081757e9170d01fd783ef59c19d94216e20bb3d1401a7b6974 c794934049c0a06bf25f63e7f6ab566e91d7e072f907b3b112c2254edf819918 90231b9c26075e77b5404521dfad01b223f0155b1bef6ffdd4a153baf1f5a5b2 938e6ee557593843ccd276818704b6d1dc8327c50ee4ffdb86c71a485d92f04b 9d31844ee3cb199ed5da6a2bed0a54f118193328baad46cb2ffc95e7d1c77e2a 4fcd595e0b38374be1471a04c789f674b344d44a5de1eef557c6c103e725c748 26ebe6ddb895515feb9bd4f3d4418c04b69469d5cf1f922d4dee80b7461a5945 1c6889c61827b4bae9267ddd422ac03c63fa3f643a96e0d15da1557ed74eb1e9 55373951a22133183552112b4a537ff459271836b2992a4dc51b92157892c1eb 7b768332f8608d3395e48d17cb003a678434af74b233d848ad2ca3393b2acfa4 f8cd4d94deca9d3d2214095e1ec11cd0d86dccd7837d9beb002621a4224e0c34 74dc7a8276c0b6e3e0787200c109c33ab29e8169f13112f526eaa3adaa9f5af8 97388402970b81fdff1b14f0a8910fee2f936428ffedd26a6ec13c1c00b6ed40 f13b5b3b5017932b26a9532dcc6dd7ef1cfcc40f4b81b6f0b68d9105dfacb54c 955ca46c7f549ad275f758d1b5dcb576806e620f03d71ecdfb6cfd65212ce46c a71150714ea22ca35102643c6d952e6b93e841d933a2c95ffd46d0a79fb8e254 3c54cde5ba11e16393e1c31b61cef7b32107f87ec70739617920192ce715458b dd44e56a5eef6e89414af263fa52a85282038e1dd024d463dcd400085770b1fa c09fa0ab5fc99a12c0568d538b4a2abd04d76b1d37e62fa7fe55289d94ba1576 402f9c89835b14980efc659577c38b3b39d728e7189029d10068585350514c57 7bebd50d97a61bbacb11f732fdc336f9ac6354767e29aa2c8dcf5b06bec21ba1 f12d5b67030048bc00d114439dd47521ca2df4f94cd6071131a053fd00ec0dce c70f143ab0113b872abfdedeacc62d09479bcbd65489dd9e21a737592414b284 3ef3f9aa0196de6c975021b76b367748843315f1e8a07d55fbc45a3055f8b083 683ab3aaf5ffabd90a92aa31d1e956d133215a888f089e5e3cc1cd1d15352251 ef0348d0d0205c9f2f9bdcfd5b2766bb021c86289d9e336a2aee89ce3b2d2877 f3e2d035bda15ffbae710f2b790cc4fd5b945845d068c6c170fbcfc87dd16aee a6b6515dac40cc8cb701bcdc6839d44f0fe74cb38c4ece279ab7444b358fe8cd 42bafff8342e25549956ced18aa09b127edcef71a17d0d7d79352bdccca3c428 b53e28c58701b3f5411f2cab86ed964ece1a5eee5935d64cdbdcbe6b181d48b0 52b92490b4a839e03c92ef058239b5185ba4b386c4fbcf2bea13c08b598b2783 75b5779d59ae1d0feb447dd361ba01e1cf11e5f81aa0c0217404933915a74945 72429bfb42f8e9fe616b28a12ec9fa3c9b9014667caf1f827aee11ab50e293b7 c013bc407782717b7d3b5980e12f6bfcc8b1be08182549606146452ab06802da 8b749afefd0c5a06a0226db76c9a69b7128a2e4a7eeebba8a8e8dc73432d13fc fd38589070f7350da42bc12148bbfe1be9efcf8b4a2775623883c0d7dc5c9a96 3008d0ca9211365917a0792c35e89829bf764777326a84e4916007e047a54768 b58766c04c081baa19cf639259ef6018788b47197583330829b1aa2258e6b2bf f1a466a0070f4f1a14a341f2a3626a4bb1704b3e89a6b03d253468ad924286f3 bb34d48b8c9418b2ccd0cea7099d2b7c74725ce837ab1b1130baf03ec798ed2b 7946d4c43e2b617311c0280d43a9e9c14c8847994748dd260f951174037af844 fb90a9155fc6c040899f752d65a3422e93bc27cd2d7f99c33dc5a4fda16f86f5 45a522fd9adaf96978d997c930f6f6996d81a7dabdc767bac4dc632662244cb8 6add423d4908944112ecd9120d17434d56c0fe911411b3d8de622e57cd58475e 045f51414978afeccd2012f0484ac217b83345e0bd536ba4c1c7e1c7148c81a8 1a45547d5cb18807120e139478ce9e85f4fb06314c715cb751491167d9e91158 27ca976c01a806af9190f4aca2dc6202ec8f46c981eec7c883be04bd9038cede 90ee73e86b8581739eba86e8d362f5a1bd6453d9ee3e146d85890a95f799dd08 7e44b9bd3e559c951e65a54f5606be01ad58c96348a5bca801287addac251cea 471ba8907b6b6212cc4b49e07f83158bfcdbff2dce62b393527635c28f0846dd 9481720a90b41e5a02d38848e0ba06913dff1eae961a473f81cb34a4c8381c31 8cb7245b9f8fad5e08589e8d46bfb9d7d909852ee130e395d5227970d5505aa0 38c9d0c36611612f3cc9f9a5060504230423c9e0baaba5a22989b2a98f783637 d3c1fb2e351f937d4e9dc62842c67dee057d177dc0789610b379b9f9b41c9dde 1a9759b98a7f06786c5d84b5791724e8f97dbddc06a0e893502494c5d421d735 ccd9b28acb1cd780fe7c0f0c38fe1b9818a79587795cf41f07371721b16e00cc be096ca7dad3b8cd2d3a573497e8f62a30ec65eb6760c36aed89b356cb327cce 414b37213a63daef2827bdbbf5715d74782459a0194706eb3b9dbfa50d52da00 42422f3b794bd03dde40a9658c23a523ab03b82b036f7d11bada20c160725090 4bd07dfb275a744fb77385b57aafe1f5f50c53c586087f890eed4679a6a5d39e aae5e924ecb8b6c671583f706c0694aadd742aace486c424b0bca9b6c8abe352 acf08a0cdb4f2a5681688e5133a905ffd0c7a407b85b2b0a5c0576ce132e4a62 4582ee214dd4c731a27fdf1b18b8e00eb3e13dd72c8a5968fdd020fefebca3c9 43922875bd81393ab15ad63b8a19f705052d9f141c8c46240d0f7b1e8690f470 b5fa64e942e037da4d39f484ad8d61da1b212ee28779837bc6f647b7f16733c7 ba387f6d68a9e6c4825e9ed82f7c5b9cc261bb7d50aacad172ae86baf9204ae5 99faa4e9097c6d96aa1cd7f0dced29c03171331a9f9d3feeb5ad8fe349825d89 5e358d1f4be52d75e09404bbdc90e0d2431200060e1a16f37a3889153ea5ed07 0611ad7b124c0d0e6bfdfa49d17307000ddeb7a55528fb7b25f015ca8dd99dd9 fbc5d86a034e97db3165947a3fe18100d099a1694dc4822791e3b4f6f07cd6e9 c4075a0c036bc008a2c23c970da6051d009e0dd71310c7e993ce03b40de50769 4738f893a73fa37a7e7a8aed248816855deb691f14ae4d03bd1484f579a43b2a 049a867b508d450b1168a286d8daf816f76ae0592b7f9ead15b65f88a926c74a de1e1534b99c20d25e5e662ee49ea53bee2670ff3e5425af90f0b0c6f7d89acd 99908815f184fe9a8d8f72fcb040046d7a787e32863111dd56bbd14216ae3a15 99f57341a1d92ac960f03a4eb908440ede4efe5def0628c7ae5c022b632c39ad 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 false +check_ring_signature 34e06ca0229a0fa63c7f2ba73df9c6ad305acfe2f4d441107f8b2ad383013ef4 9e31d96b9a50f3cf6e5f758c8e9a3d3a1e3d63012b2b013366e55eac66b60435 15 7a87bfe1d7b0a61965fdf39f2e961d6f298ad527ccd6575aec83106159c70cb1 b99a52a5a84c11b6aa31e1ed156531cd38a9fddd93fc1a540cf152c90bf15eaa 50607eb914f001827a3e2f04a9833ada4a4d3ef6acac823dc0285cec494d1193 8b1c2513644e959595da5f2e6333b209578af17775196964f7df4d8d56cbc112 b32b848774a7f6c91909e2b1cc8cc3a69cdb56a6c44b7b53f9fdd1ca755ec991 906a7529f6c0b8783f4b4da608b0eeb8e1794bc243f438938f41ec0594945b70 26654bdd00d8faa62e4619c5031e22db925e523943755a51912059dec638070a 43dfff77735e0b8cfe14db1e5b3b307fb87a65ad6a4ce785518ba9f4881ffff2 6bfb5270f0b1d5622a8450e8e84b79e2759c23ef1946f642d6d851ff0a1c4927 4618879d85feff4517a5fb215d8329cd6c2f398f922afb0831a4896df4f09917 773475f91b064c0ed13b434ac68c528fd22d287291c33ecd6cf890558052160c fbe9c0b8f4dc3ea1e0b4884299dd0c2d7cad2f71f98662b1348784214311e3c4 14f2b8ae34944362fa850cd5cf1ff477f52e0d9f721948200a1e9dc471e17cb7 d79391de3c7b51ff8a1da3b38e87e3a58c55d465d6a93d10936b6979999eefc3 b456814e7f6a52dc729ed1dd5baed02199b5e6d9b48adfd2d040284ea9834cf3 cbcd5e87b5b8a74a52d7262839b0a07dbfcb507344ff00a91e3e1caca7ce900f8de8e4b34fe00acada1996e269532c31c586969190aadba2b5c537d4ba2bcb0f1e4bb4b3a8e126671e0d03aeee47bec662141f36a863e924434993c6c439fb057665c4b34b064f7a644b69eaed7e121616b1b79dc43b1962ec219e2827f94e039e971d4994c86106caf1ab26a2efbdae5c864966aea33b625f772e66811cc402a80db89c47b7994e97ace179aba3e80c6b3dae65e517bd957d654b64bddd56074534750460b4b9a1e994464e66484a69c914fd38de8b4528130ae6e6f3370e02698a5cd29ef8ae31ceea564c3b6e4fbc343b0a9c15d09de47de62e8df9eb170840bc968496c321f5e1d4f50e61f6d2d8d69a2b7534db1ac0126303b1082a8f3f49f516e4c32fd01ac3f4e9d62d5fb7cb5ff029d5540a4141e82920e1a62a9b0439de8954784870049bf96cb5e0cfa4e862c8942656a462763ce85dbeb93b2305bf71f960cc22c3f0a2b8bee5d4e60693e6ac7b55d916b8a9c6a0c44089b6ba01b93c02aa28e3193caf09d5aed9dff01d9e554d4083117439eb475ee0528d5e0fdd68c48065dbda370328055f85efeb54fc48bd6623d77cd727b0063eb29bdf00982b452ec3e481ba12b28bfaa5e4c3e0797fa9ca2cfdc56f8ab29ee1df956c065bbd9cdb5e2a9dfaec06d705176007c2952bf0ada97d0d753a947e9b9ed658043696d9b3dd5de305def7af3d78bdffcd02cfd3e1a67b2d9a3736a4577bbd960266e1e0f2b0057980767c05fb4d3d6cc6b06f15729455aea2bf6bf6db8f263f07bd2df6c3b65c8243ce97c4a7f499728ff44ea1b0875359efe239fb29ca77cf0deb4b133c0b397379cf6a2c1a9221ca221fdc0a74c73e92cf3cc572c20e7ab20ecc6e4ec4898edbc261874b505fe7e926df3c9979d334a8cefea4cb6287e4a706dd3e5af58d782b08a04ffaadedcf30aaa9bc0f0a3f3d3ef5c7114be374b7a10edc3805db20e98446fe22a571adef7e048fccd2e8a1f7f6aaaafec5ca7d26730c1bd41eac03aa412de2af7b4629489a88033852bc9372469f28f0faa53f5ec50e6b9dd16c1b64d0a0b180740716f484ca4fd2f601ae7c2064dc06f122e9914704577f578549f7f4dd8e86cf441fe774b89709c18cf04709ca7860f6fdbd6dfd0473cea46d361397b567fadc58055aa4dc93f4d5c999be0a27793302a55784360fd0b018280b79b9445993356f03c4cd77a159d3eca3400cc477688b410a823a0c6cb0a68561431505ebc994e2f702a99eb5fe769794e911e933f5d88b1bdc0505631bfa3377a5b1d3f4e1927369d2f41ff64cddbf944116157522b4836752800b false +check_ring_signature bd9638108b3858b695404789dcec193c8b00569b771f8b0e23b64b292fbb79e4 9c5d1d4c5aa86e0353db69fc8147031e8e6c77131c880ad76b67beac8b28ae23 2 8d91156d1b11c755f14ffbca5a85b11a496e51a17c2e3cfb8a1bab0cc67803f9 547f9c840485da239604f4d72e7a16e804484399ec81824ff62be227cdf74fd2 36e0a87849884c6fa70ce6467df56439ec35f1e63795e97acc2a7f4007c9b60a736eb9629ca0875e88a178446aea232e24052ec3aa342f189bef115ed6fea40fa3b5e04feb3a647633dc41e434be6c21534ea89a05af3ca5fc231118d0d31903022d7481a54547331b1fa174f9f934718577a7cd1668571273ca1b1f3e7b4704 false +check_ring_signature b6839b1f52a7f7f3c8a2e61e59cf28da7cfe853159f43d0dc3e25a48afa27d78 639a7782af9e2cdc4dfb9173fd69d7f5fc7de038665144379c12e9406f981436 63 d2f4f701a7bb5a80a57c9544a60644e5f541d1678588d274eeb2d020a63438fa 4587ec25f723cc8571900525fc3b80c53641a67c5f146b2b2996264400211449 32fecb221e9823ffbd0799d49d734ebd192c6e924e47d991994de840f59c0f9c d6679c6130b1ee5ca9044b281a40a33bd0db707ea704572055e2c48a060b84e1 8081fcb1b2310875b87003ea1dd471062fadb0488f5c3d58f9ee2200812d35d7 f6ac16d527dc92e9c8e260365831500d39296d022822fac0390272f7c84f3e79 32bc1ce30cc1dc7e7a2913ba048ecd529a146d1898c500d74a85c25437372ab8 967a4cc007f48adb24d464d5ca23f999b857de868781c3616cb1623209a37240 61e379701a4c9c1219f694b2acb5f9b26a00999c33907618caeb035bfb78ff84 676740aecfc9e8b3e4fefef736ea80dddfb3f08ec5f49de0092cf1ca0a0c2924 e0fae1866411f51e349150ad84cb8c6f9c5d1f404b848e9fadaf1cf039a8cb51 b429f180d0c06812bd99b2cc47c7337fa54bb13b56d4d1a0bc789524a535a097 35ffdd7885ba494223512104fc0d026906608f3c0bb2f67f82c39aaa4150a5ac 201247c443361ea024408967e5569bb8afa5598fad59b2db8893b2bee576d9b3 a0717e304e10bf03a13be1a6ec4ee319d5901657056727932085a32674d28932 bf8c84766b92684ef4f80e47556bb18d41ab4ff24c8410de07334ba7788880f9 7894d16a55e3f25832deb72f2cb9408f7b49c3c116f96cb729dbf0b54d873fd9 8ffea8570e2d8b0fc11eec7145fa4efddb45c59b5aa5fd7bc52840acf89ca9fb 87c59b4d733192f85cd484772bb406650b4b0c629fd2923743f9524c1a7c2a40 e4e8d4f55fb8c14576da8bcc033c459ac07238fc40fca182d49ad94e264fa5a1 d6b475f39e48e908536000b08283e0ff215dd3983a86dc9b957d59307d56732c f976c2efb1edf41dd257e93caa1eed0eda96ea9722753b946505bb432138e05b 584d4952b50260c698c3c03aec819a6ee399f44bc5e55c4e439be6331cd33d7e d9bfae924f6f92d4969fa1088f3e45e75d4dd3c6696516d79fec15505af475d6 22fe550a3047134382bb32cc6009b27ee32368e908c0a510afda31d8bb56398b 94b9ed1adfddc28da4f896189f6726cf8ae2f192f3d53eb92d158fcf0b900c21 be9c20ef66482626543595ed4cdd9ab9edd348ebd7bfaef2134b2935179ca408 492ac3a29b9d8f1822814644b50d887904943e517babcedec8bae093c948b457 b320e4317d28aeb2c5e8c7c258c8759a3f3d426e86c0eba3c7c81432452bb84d 57993e9c004c7b49a0e24bf53bddec1a505d466e6a824666b0c2c03ca5a7c55c f732d2f4a79caaf7e5dec2882e2edc7f037525aa31a6156616c369c471d83729 d1fc58aadb42aaef12c6ae08e5699321dffedde7c5941a17c1f24d0ac6acf567 c1a353130cbdabd9483e4580d16754f4fa74694d96edafa67e61c45a1547afaf c370db2575ae0afc09b0dc2a212497568918ee1015ef519c33d420515b65128c a92e48313ef41b06b767d24db38c60bfcc3586a407414c09551f46eb35b249ca 74b86c379fedcda0566233d6e2db9d260657fb2f8857e0a14f65e29c60fb6955 20deacef9d9e67c2a90c5d80df51db91b1c8ad2d004fd08c02bc218feb72c230 b51626a915aad86c542c6a01bc19b4ea72a7f0b9b152725a5ae81294b89123af 8680a17c953c896d554f33168375f1e6407fda21dee1f3b33ae0fd8868f1af4a 676ad675da32d17b27289ce7654f61f7ec95a90ea6cc65a36e1a9d5ec235967c ce0f96c9b0c3073fd542e83b724bf5a10470ae8c815c668f67a230050eb403f8 b7cdbbc697db77974ae8183339fcadd455dab07b91171700ec492939efc2bfc6 3ba61cdad92a6ca8507ed4a9844bae6b0d78189029e72679f1197ed424e523d4 8dcd2c9d09b978856cbab8a1ee62ec4e53f15ecdd6044e1c5a68e923b3a3465a f9f14f8603c164991f359ec279265098cfcce23d1c3fdc2dae5722211a48ef37 33bae54bfa42bf112d48e96cee081d50c4ad21657d1804c6496a1575ddc1cf82 3371035ad339ef806e4fad044ff7e290f98a741ee4483f5d0490d5dc142809f5 504006bfa6a809d8387b000c7e241e3e34c0d3037a6000956b6e31dca4f8906a 3b27940b9f4a1995bbc1a49dcdb75c95b2fdc2ca6aa87a5ad680f262d2952fdd 15697ba20e56df46498d11530a518cc709205bfda3a8a859d5690520b1c97c9c fcc77894a9572bdea273dde33ef11a747db280bf259e2a2e10a37e66a4bda306 3617a7f7149580616aed00f770cd6e7ea9bc8d8db6d9cd78dcd688da40b03407 0c8cb907cb03014497693bea85bf30ca6dc7a681452379da7e8cf39a0850694b 966240c88fec6e506bd19c189a74302b8fcb53f6eb483e99b98ab5822cb79cab b55f43fa0509d094dd0f996d6019032ee4a7e48899d8d0d731b8f9fb3aefbd03 33608124ed0617e9a276e94f579a9b7ccad80fea1394ad9b723ef72c6757d2bc 9036f8ec02e242aff41432d68e2d161fd7d7d247fa49e838b4255d7c434a9346 44cc811041d1cde69f7e88ec6014930a44cdc9b406c4d9c0557bad6cd3a55e55 c9617c5e32d51d61cc1918979fc89f0c7798de41f029b53d8ea9648e76dfd945 534b5abfc421262cd4a915604bf2b38baa3019cdd285289b340b88ba5ebe2f67 3677930f7c5742086a484867fd75df40adff6013ef614bd276c2d4fcf20fee09 52509f3815457cb63469e8a4cc5650fff3fd1df1f739536bbe9a7bc34062da68 5cbe054e66426da8acd5a750e12c37444332b3a3e9cbb1a53d671a3c36620f34 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 true +check_ring_signature 5e2a858810da111ae21ab5ce43e837b132a2c06db68a097260c762508376fc6c cd3fbec61a0e294636326e680d1fe1a060a7ff9b64d7eaa1f3f5eaf9ec0f9e40 15 986c82f05d514aa3164e0dcae6803774d55d0a5b8e7dac9ba74042defd3db42e c80ea57c660153fe3cf8067c150bea28cbb39545ceaa094fce2af6be299e55db 82b82ab4be9f53f9637c906a62fd4b962f49cdd70d2c9e81b2b7af5b1843a0f7 5b1e044fba4ec30aa05d460af651b38996f1540e812b073c2e874c75503ce7b6 2782a6f914cc183d1ab5c618a575d85909bfa952668400bb1642664062f1fe71 066da74e2968522dae74f328a4b97d767c636034e9fdac5411390998d6a52f9b 352c3ce4ebd238351acb54c1c79ad46bc93803ef5120734362c867c51783a1d6 6785783b476f6efc907a9db077eb57d220760332a7a685010f5f3fafd613812f 447db2fae2009b8928a12aa4da8e80a6fd3fc7be6bf573faa7f724f5c46be303 97b96575bf0db132b0b0b9ed755140e3ec97ccc6f158fb41efb38652b57eaff3 3982a459867fa63502a50963470befa8d6f7fa2714388d32ce77df54d6338e22 0e9ab7e1a6b7e7c17fdeeadc87f27005980a8c4aacaf206d95ae412c51573c91 b0664ae779685ae89fdcde71c03571edf228bd80a907f1f5fa3589d5f5ead8b1 eb32453cb34af4725d0137effdf92324eee0c2ae623395ae907928bca04f05cf f020aa84316ea283beaa26831ec7b84e57931b191fa2919e237324d18cd5e240 782442779f603b2af95605dd9da130dc9f35ae1f5f3aac0f68175f8b4bed3a09a3693feaa48316dfea28b92744fbc9160ae4c753fde612da4fe02181be7d9c0d7241b3f381fbe3062a774772bb17e54e43a863f3fa06fe917192e7299fda630463197a31deb8a9d26ca2b3ebab6013a43bfee082223d887db9aa690e2763b300540ceae488d601629f393aca17606de8b0a19a7fbdbcbc7dbeff3a579816d6059b4cce3dee62b67320bac04a2ac70f3f14104375e98e2c025fa7ddbe46703b0494ba1eaaf077215cda0738ef3629c4d853dd4433c9ce496d3b24969efa567109bcbf495268e26bcedb015697e451ab7b5ec40d0cb8873f0da6c922a2783c5d02413936a3e42c974705f4f4882ea6e5cc4b403d30bf5214ce49c25bb492a9cf0f0f7378abde15a7e517ddbd73e19f837d6ba8b9a43b8203d235b6508e9a519f095d7e0ce14b71142ec630a77a21035dc6741d25b60d40b4b71bfe78344a7ca9002ed5b894ae09082ed0ecbd7defb0afc54681bd1840bf27febf01d8f523ffda0407759be7e50fa88de9714141d8a71ac94f77f33cd80043c51a9ed1b8481e990e12156ee9ed1c3b7687521e5ab9c044d94eba9b6de457c6cae7521751f049d90965164eb837d44ee409cb05e7f406a3917524a1bc9a9526f5b13f09f5c723620a3bf13f7f4fc90741f1275e5a43cb78a53f93921a67de66dd58a0c9fc9e9cbe0b8191f402e59a66548affde0708c0a58ce2d7dedfb2a6784c3997668b1d1e8206591c0b573c6352a1f8b958e04a264ec4383f071de0444a8d9f365b130931e90a014b81fb48e6a73b92e9ef07542b5fba071d7849016c1ac923b520eae2ebe504af4d1b35dc30aaff2676a25ee40e974bf16a2798aa9398baaecbaa80e613d309d6c6f921eb482c248ae9156195db3f04454948610d912e770eeffea55919bb021cf3cf89c05d93fe005761ccf8691179ddb74289af8ec03381ca7e29b9374d0ba122fe49d34491bf8246ecfcbb1fef599e90ce0409508590d15f3519d34cb7085250b8d9d7436f23a69d66e6176396d1a4a44b4b4390f2eb97b9eb46fa87ee043273b66fae6f6a570671316534f7a0ae263d07cfacb2732d3bc86cc1036a10074f16d4405755c717a9f9efd77c4665ee7dbff725e07dbedf3a5ea6f8e87ad204816302b60fcc8668a683b7fea3026a6f81a3b6e1291aa1f6035b377bfbae6501bf9f1f85a2dd73b91eedc1264dbb2089be3428c6b8932983083d4f97bfc23105249ed60f394334315723a681f5b3825236094449a6a23f987213b37e6e050100f3e7375abe1274096300581d9ad6cd93fa13c264e7590b483d78149729653c08 false +check_ring_signature 1b25810017988ae5601209cd5e45d6b3034c103a18d62ff1aaeb458ee5996e5c 83db2cb516085edfde9079ac05480535058bcb258306367fc741a51bc7ff7888 3 4c86489998ecc0362e631fd12f9599ebd9914e11ab26bcce63b89f375fb55abe cd47462eb2530eb30225a65fcb4391ba2b44a5861d355ccaa9a9f2445e06fa7d 408e29c2b5ffd88e957a5664d09498f4f844495a675fdc2e792d00ecb3fb0593 87c713dd83613ab067221c16012d88081f8629be99c973aa35c5aaad431f8b0a6875e2f57cac488db083f9d6bdd5598d0b90f13d105d42b3f0345dc8f681070438f32eec2f11bb4f1832c11d69180d98b2063f1739a14f202bcb776820021d08d7dcf4260a6d9ab80949d199f9e010d7331e510ae6717693cdec3c074bbbd60028477ba6a3c4ad8023ef3efb9479d0bfbed7be94925f8c7147a3e326a4d23f05d70b34b2c380e2e75bb6cedd8f2ac84cc624a4fe6ba9117397b3077ccef7ff0c false +check_ring_signature 22335027ddf7905b19af303f1d09e6fdcde2fe8da7e8ee1200a2af16e75b3531 8c0f1a6d89877c0939331154890278aac9f45ca4a7a2846f6946fd9ad17bbc22 4 c5452d00cbf96d0e7151d02d54cc44bef4a5b5587fba1b23ed8775a0bf7d5ded 4faebdeb7501a30c484cec1bc1e709a7c34cb67b66cdde6d09a4d51b2dedf9b9 fc8bea233e0492c9d3a3eb422103c3a640b55c36d9908337e46679f5bd631935 710c229c1963460172da6196d6a24c0a1cce422c3df616dc28bcbe3763048130 6c83fa4c4f270170f485140cbe192d95d22f77f9749a197b15051df3c2512a0996c4d841ef1e1ae293403c06f6fbc79188c9bf9a2cb8349b8bbd33f874bdae0cdacae24bb95b73dd3e369f8c5a5ea1be2b6b83c789e0ac5d289f9de7e9a6d40eb6a26e6537d0aff4c09c8684ddf98bb69f53922e1136abcf31e887cd92c6cf04b197f8a72e3443bbbe5513e468ea3df7bea2338f8ebb0ed5b33e27647bf4540f85732bae4ffe8dd6955e9b47a3c31da44de4906a26ce33c2af4a18482855860e166982acc8ba966818a4b6cf3e4126ea6e48b742841a47e47ffcfba2608a6e0800764b84f43667fe4e6d6833645b7cf863ed6c3b63230832fad5ca6b88d29c09 false +check_ring_signature d117a942dc61e07cfd24e1f5376626e6f8dfe163bc73646759cda910a13fcaea 219666ae29bae64cda9eb430d427b5e51d0f269478703510a2dd19e0385a1ac9 6 1d313a594465c94fc51933ede079276c5bd5edc79c18ee96e690a88d44ede793 bd71250c03e0475e7d1ac04539a4aca35def74a88927e4bd7a4e46f2dc5d4f05 fb203c275ac072e341a86841604fcb2938d23ce8b8f92081ccd7546a3e983ca8 00e653e51ae7e8be867bcc83cff8ae9ed4095ac3495ce4cb223d4401eb5f48d6 32bfc3de0074b898bf20291b807ce9f0845de654c566b526f244d30a6f18aa4f 8f8ed3d87c59fbf0f7afa741333051c46876a46a1a395403f94110f01a371758 89aedee24e7a5786ed4ff076134246c30a9301ed7ff6052209632bc30f7ffc07de1e406e9644e37a87be0ffdd5b79307276c06b9d5e7166feae229167b061e0edc9ea366c291fc08e58c82e639fb5a9ec82f37be7cc4008ee51a25ed2683800c65469cc357bfcb8dc4dc604c5ff2739a55d0fc11d77fd450d53bc0135e3fa2026619746f130c6b21cb519874bfcca55fbdcb3fce1e0288f082072eff2c5ad10df1534bb8f2d2f0d179020f8ec18d7fb5b80668f626b5737a0f64924f6ec4e30393efeb831e565650ec22d1b44cd81e5ab67092dc0f8c45e4cdcaa17ff7f9a002e250e3ef124c35af082b68dcc70312e94b592c47a0dc0a5a5d74409fb7318c008246fdd1a877815fd597b02d1d813f0de12800baea16d652f554942215ec5309894bb713e937f64b43526dbc593efce830d2a987533a8ecbf8871171961e2b06b1395a3ff39a2eb1a047f0dd7c0282e1b3bcdbb88f68cc5cda3b3949c24e7a02b467b8ae81eda36abeaed0a5e4b31529a3141f1df8b82edc51c1292e01093407 false +check_ring_signature 89b658e4e4b688c81b04b59b96597ffcb20591d03db8c806bfbc534f2a8c3aaf 8b2ad5e682aa1a14fba182f46c84416e4e8b3eaa7f5a179f977d2a8a09e426c7 1 f6496a8c0d11a5be6ac497ba19dce6445032a17ea404b526a6d2b3beb6953b84 49c9aa923d8f8168d6ed487b1464f75447df5720a444bcf95ba38da62fd4c40c82cd193153ace0f5555a927476ff2d91b17458c00ae03030805c0d3f999fc306 false +check_ring_signature eceeb219426d267cde10835df1e60e1d5778a8d72348eb917712daee9680b1bc 68a2410f6b135ed738fbc02b343d1485a8d3c71eca33f068130ecc475c832a01 12 606defe655a045387958c80031520a74d994adff74aa1937b85d3e3a6418c69b bd2733e6126402cb308fca53411c911d8f8736770e0565ec92db92d1eaab4d69 f1fe14e33415d5ef2624e00dd9d37a9e53b6f436ae4cf30633d825d4544d3a35 7dce1d1750800dfcd4f0c912411a2008b76b8c427e9e987343c066466408571e 7914b16bb0df58225d43a836eef68dae1c02759d37ce1d2664bf16c185b420e6 6f0afb9d986a6ce94b4f8c45e91f939d9dd2e8321e58e15782b524b405ffc242 1f7139e827a9f7c0a7beb996c6c86483d603acca8a6d315d34ac791df5ab66c4 9e1e85157b57fd7dd4ec4317adedb3bcf95f0c54c90cabde57289dbecfd65f03 fcf00118b438cbed0de0ec57c2e7f147ac0f5ab2b92b292591fd57a8899921bb 004be59b560abc3882585299536f3e046e45aab5774f647a2df5d3fa9dbff06e 090e73e7e3d1a6309e93211d8646ff0af5f484907365c0e7ae839d9364ac498e 72b5778473cf32396f99dc711c389f16b8611622f2917dde8b9a91b5aa2e3c03 4aec01a917acd6591ee476c40fd56d848a0959a8bdf9dac0614e318875cc4406489a5629e794a24e7f171b0c7835c0665959bcb8e63527fb42cba1eb7d75e80886bd43b377ace8a17559edb50dbc3c1390a5f3fa5550cdfdc35c85566648900d2ec3d401f5dd6824145057464db898d0d429371e4413d46f910c2bb52b702702c621a60acb5c23f99438d11eb3e067e5ed1f288dec5902b4fe0b0f3f8f3d12010202b5e45a2e20cd312e8da3abdebcab5b537f6418a8bfa6e0e6ae11b267b00c29d937ce86bca0e52d62925fca5bb46bd1e5d1efe22f60038ebaae049591df05abd8df47780a43baf313da2dca65a30b6913952601b4d6ffc8dab2adb137b106dfcd389705f176376cd40cb6a0a4a6b02719ac4d5a9c74236fc763c39ba8890acc0ad200f8b0a9892f092f3fe9b6daeec09aac507dcc84327272facf8098b508ac1815fc93626d3b94485f833545cbdb93445c3b0008f851eecf74950c07be0bb9c38acfcb711d6b412fd043b6a9b1eefff61d6f3248f6a4160af51cbc494301fcad95fd9ad8c99ae7a81f46ad8be07b3030f25b6c04510abd7463cde773650989aff2d133f00c2aa5d029b58033280f40bc9fd4ead2b513cd7bdcbd7497a60ea51c5b3a8628f74ca87a21c3cbfce966098f9dfe898a3baa7caccbb41e08120eb08da12811f16a09d9856fb225d822b05cec5337328e963a49b23a95f1cc0601de5957f97e79f0d9853b0240140d09971d29c9a19cf56bf1dd095940147557023a3df858c1ca7ef98117d485ec2042f4577e6b2c05d00fb9bbc37b69ce42c90f9f4ec3061182d7ce8a512fc3ab4493fcb835580dcecc7e238d839e3d63e9ef0651a09f727a61c2166c4ef77c206fd6f2e80c54e06418130a5dacdba18f04b3088691f590285e00362d4e55da7bd1f6d0a8af9bd1fdc47484a1a766b5439e7a0c161ee33f84e691df6f173eb6620219eec45b97b3f4fe9c95a7995c6b82966602fe5a8f4d59945c533601a89956b19cb1ce141be9499f17813696e93904f7d90304357740afee7dbefbc1874c00fc364a5b175d8c1c319e2cda8c40cb6a5f6f02 false +check_ring_signature cd1f44c4e9c88a3f230a6ffbde170061f70d1d4764da591cf8ad082c72203364 4ce765c5a4ba4ea109033b7d81d5379c562f532f0a0db06f759b9bee92a707ee 7 689161627d2df722562558afc90099627139d2e0e6a3ba49f0f2520b103fb4d4 c30fabce09391a0c6eae748eebb6bc14367752298c347363f4b167107ee4353e aacc5ddbf8781e083b3b17e35dc8324dec0746e2f0a40e77ced8c638be1610d0 928ea4c9d2f7a149b89d59322e7f0fcdd54234a6f92ab503565f78b45bb21db3 1c2ed53ba24d3e027ad5d17a042378cb8279471ef0de431e5a83a4f499becb52 25a7edce76f0c18ee9de5fbe37c49a8b51525dc64d4587c0aa6e8949256b5a92 692a809f4d5c8f8449bb068d46e39c57342a82382b2194134c0a61ccc12cdbf0 7e0f33c9bfd73a8cea15e0364c595d2272edd4860567868cde75bdc222fd330b2b848c7a481241540ea8892c56adac8cf3c4593801aaac9b5ae0877abd241b035639907f5af14c28e6da5bd9c35c5ce6fd008876af20836a8951d8416562160f5792d77a8056c0d2106d3dbeecaedc21257a664e311afc5638ef1c0746378502068974dccfa712e253a4cc6f6390d7d7c7725d34c313ef6f5c5978b91a7f2005638dda4402c536c678dec8393f4cd9af7d212127f6a157739961fdbd006ec2096d1da6f7e907fa5fb6b290094cf9948b31dadc1df6e02967e173900e7cfa310abbbdd6c8097c9c6001b0038a655ac229b68d0f2301ba8cf714cee104ea691b0d3cb0b36a2486b976d511db8577ef07e66c600a7361dd5599a7709bafe4264000e31fb4f9a2a2a58f56decc1f1430f90f0c6b32f8ad23574aa7a8dfc0f2d3710f40f5b4bf65f0d6de08bd3a024d7944aae74f98660abc8e8ab836d698dd6742653daffd60d2f537e5258897c66eb53c542b6a13d128a6291aec52eab365bae303478fc37e6d9352a446d9bbd8b00f6a8f4ba3845c6457d42d06a589ac1b1d49075643c675bd8eefd76e1ea00083d0ba7bce5481e371da8831bfd65ab044fe8705 false +check_ring_signature 0c9b7806661df154019b7958a2af329d0a2131aec8846593c066209dd0492ebd 909e70180cb35865b601669749f7531a44c49cdf04ef740b093e4434a0b89832 126 149e3648252fbda3278e03c992cb823641bea586cac483f7377e647b2a84c20e e1cf0c0b62830e3b364a11e3f8c5394459bc072e7838f4d2bf3106aa3d1dc8d4 cc31efe4d4032c09a4ee88ecbb1662fa053d730f1b38dc5a9d02f085290b31a0 5aeae963d593fff38bb791389281e34ed40c8f658655f814ac4936c5a0f9c18e 85046b6f723bfbd65d7d38f0078f11b253c55ce1a46715913179f73e2dfa24e4 c7134b35ff3345121f70c9a2ff46b678c3379614cc5a33a2bcba7941c2062e1b 988ee641b18cde9a7796681640733b297192211f9797656ec190136fc195321a d4912c85b1ae28bf6454caf6f2143b05e2f6606d5af45573103ced03438b0c90 c22c3a6171d0f4b2080544e24141dd521baa383a0543340cba4435e816034afe 63f9cf6dfdb62f85a347d963d7cad9297c9dbd721c64be9a0650043bd10b6ea4 31be27a70114ff91b988af85475e86e7c8bf1a07e8bdc7f22f4fb3b182598ba9 67f684b2e850891d07aaed392b9959b97b8a15c6d013553c27e474aa2f711616 7fad45220d9c370a3206328da50fd19b9ffcf018a0a85bcaa807bf576cc1186e df1d45a578cde8f1f0eb24fb47af65eb3fb0d96a0c28fbc3a3b66de1bb1769a4 b1a81e42158364fb78ae01c6df70093d63a879419686867807a5f5dd2bf1cf0e 92925321afb0678f2fa092b40cd648a2b80ec40903185f345435bceec6277767 b3d66010fec754d8307182caffb687b7ee7ade0d4c482b3b32017da63753e992 180fa7cbb80ab4c315636d2895d0bd278dd6e5290b498e34156fb85d3de062df 1883bdd457eeaaeb6b9d3cd4c333cf5c3a0498313f07457b3249c85e88dadc58 f114511d8e9652571fd49d3e3f69c4f51c5c1d2753b74b74f64e3162856bcf85 99e0a5cfee1a0661294074fc268234f25ebb5ca5bdd236b88ace8750e0b58d1f bfed1644bd16bc8b9f9390381bb2de8709f66c527029aaa2eb37e7220ed5262e 3d80ee92b909b6861e3ef2b4e62367e77592c0d55168a237fb057c228e3ce49d be9085d2d2bbeed0d2fd154f01d18da594a16833cf9d295565ff11e745bbc721 7cb871e120cfa5f883e923eb1562b27ea1e5d905bc98026563ea3619d4f6e31b 6700d8a97a0df4f88725cee98afa2a25760c6d73476a12d4bdab88b5ccad0422 29ee169e421a5f8c6637837bf6b0c8ae406c92b957899cd11d39ddfa93517c96 53270c8696759feb538e9a0d3558ad32365acb6bf7be5d1bb7052317208a98ba cc140ee06acd3c61d658cf38aa3da5c0bf19d2bda7eda56062b842eaee973b61 bc996a294d1301aaa6c2fe3cce1e3267e0a33b3e4c4bb136bf6bb8f17f2fc162 9cce7442755056a16edd5668b7f2597fa01674c04dc428dc147909614e22e878 61955989972432e7e0c1d462729da70d321e498d637dd2de835a8d73deea9947 7c722cd2ed228efa432747788cc504d648655b43319f45f66205a890a639b3d1 eba0945051b79496eee9a441243505c4d6cd0da40dc8c0b523cf1241ca24d578 13b57339c067043b48f29179efef65c2568f383b1af180f16e6efe7df77cb6c9 22cf900dce346324cfb761ac215ae8d17b95ba9c900fa95e79a0cc5c340d48f2 11529a90a2b0bf5f75746f85eb3021582fb7513062c45de69bc610694dcc2b8b c9597692207c8af4909b380cc73c95fc0bde8f681af9d69eb2d410dad127f4de 9921eec94b8933930e08c5fbc6f986529d2281d5b96c811ae7f697e571e7d443 543f27a994444ef778fd25ea5ec6911f23244d56b89cebc623e3417fb67fd0cd 57306a231a35121c69aab35e570dcda365874d15103e4007c7521a647813ba00 e7bbe5b7bbb14c4bef10c65616ae8e2203bb84ed9fe0c3e3ad2cbee9eb97adaa c2272ccf5c1efc05a73324288a7b3c62839cb6a3e82d39d9c85926e14159b7cd ff579899a93f07db0cd70f3012164bdbfb99f7b8ecb1e8a52ca14005743e7c69 5dafbf20129e03172ab96c418bc1bf97f80aef19f58e4a78c8d18608eca7756d 1b7f3ce38fe1300ae183f79bdbd02bc2ed38c7414571d689657ccd4b26c64763 08e541a1326d27c2a4478e7367c4fe687f1b88b39e15945f81d1c454a7e1722d 5517cbdf73a5bec89a0104c5fc5c52c0483c6739c7647540ee967955a35bece3 0214252efa150473625f08114afe6ab721267e095f98624ea76ba3844fa5b743 f47e3ded9c689f29f8df25c14bda0e5296312e8e489d55c56f2a1c457ef34e95 4aafe2c5ebc57e1e3d386a55302bfa86de8f15dd157859773f249c0084cc5969 7c2f029e97d5cba8eebd0b5933076b06e95ae4077748e2f725d0138ec5be195b bcdc9b0b999d1a523eb9d4b3c3352fa124238ac088591f11d59462134a34ca69 ce1973ebb6f9013d75f794d8640b2044929bb44aebc15d11ca1c2d656561b6a8 b28d90b201fd9a8e8de985cdfac00051954bd4a906a27d85b454bf61c29fa202 f8f682e4fed6d5f5b5fc754db18830afc4d5872e387df96729a75b1828e19c0e d1ed964677101c79bbd827624c7cc09c11e075db6bf413ab46087e8454b4d5ef aa89d42ced0d0d2d65bdd81042d576b5b8c8324b2e34a5ce0c07d022b07327ec f5c6d9ec255672671af7476790a6bca9c62c62b8417919a6661db91302627fcc 09bd2fd0930f86471c20773383330b4f9e146e1e8aaa3a76176b958c87f85b8d adda604c9cd8a692c863ee57264492daa05b2ab05f8ca3c855f54b29b0046ad5 fbf6fedc6fa44f71bf4a83d23b35da89dd49849a32f7d983dd2ac9dd3acb64b8 fa9e74fe5e2c4b8f4d747f5b571e1d86ee8f7ba7c14364835b217f5c056e3cb6 cfa3d6b2e93b23a2d30d1f70f7cc3a53889c444321c56914f40ff486261838fb 7ac33b26f5932e04df1b84f9314e88a78cd323d491535b3b9a0770c58c413651 758adf532995d42fc01d348e92972a92663f542cbd48488ed6ac743f9c6c5478 f32cb5803f48cd834ff6a78d3aa73d6623a6a7554ff1275476fd43ce5e53c239 13e40b5f313c15c674cb01c386b45914d745100c570dfae05e1cec7adce0eb2b 1bd6b40824e8b76f9465c536ec6ea859f381b1afd488f0e766d986ff9519b334 2cab41d15bb6426787d90df633d1f22e5da3522d303296b2d490821539894c25 9a967364c158267d87daf2fe8f86c8286938a40d167b3ca9a2eabf1d959a5647 6a0bae93bef625bc4c33d376a3f9b4d64c048ff031694f5da3ad7071569831d1 b2e03c660f00eb8694173b5f7c22b3d25d0ce6353668406aa8d4134909d6be7f c7cd78e4ef6d90747df283b6628fb6db3b6dd172ab147f6762f75ca903574b69 c0589b1f773976bd711bca5629981575ee2ddab5642274b8b5ae345009be3e65 56d84f473861388e633fd2718a3adebcca1e36bbbac78f2415592b701b13e61d cbb8ac9cbffe150ba69b30bb92d5ce1af48c59f6ee979216fba580c4280e9a5c b5605840a7c1a7f6f00421c2e6cc6cd57974f3c3f2ccecf27f8debd243983a70 e4b11d088ab25758c21681607a7fcb193d2548b263004e762fc83833c76a3ccc fcfb02c56699021cb2fcea6fa1d88cd04c23213316c0772fc475725b675d0a2a 1649d8009e71192350e0be712becfc0a302ce359852dd333db300865b8eabb58 1efaefeadf82050c88cfed7e230d890e235bec7de58c1bb00e114c3dc86b5a60 4eff508dc94d806a0a9a007e301b53256269b02702dd0d9f16d3e0de9d3fd328 cb52dca774300002dd0025791a0e6e1f8a8f502fe7444e181808d36670c56e83 375ff540df88420186e5eade21b24b088d1002ca04f2b381e370c50ddd80635a be8fbedc896add69491714f40196d96757b53a00e5a87b3f433152700081cffa bf0301fa99dd678fb5cc13b0193ca9f45feb5e490b7987eae6583b515a49a494 37c5ab0806f33104d4a225da05c830b3d6a83f58e315f10ef95ffbffa71c7560 7b896bb7428fe3800ad0e9eb8e00b480ebeefc350fb48feacd8331dfe4b9b646 1276d18db76db45bb5519fb7119b549a38dfd72513683ac1ace1a3d6a66b3092 7667ec63d6c373e476dd90ab3049bdaf3d4a28397d41306787e2a9fd9ca97677 f2d2c448e3272f9f81841119c6d1f3e210930119b5c34fcdf4e65a09a12ac3b7 89fb18390df9729265dc0245f3cabf4beb1c98a0a9d00b90a890b7ef949ac467 5622426a8e3c423fc72f8be5b4119788fe50366c2fd223be3a98281bd7e6d184 440a4cec16345bd8ba7fb95377e148a4b17aed729bc280f225a91a063470d213 1233eb2ddd762f6951489be4e180120fdb7b183e71b15b200498763251eea9bb 312bc90b4ef5bcf66333ba7c61df12e370e8c8d608a2e67320a37a6f8000aa26 443bc846fe457fa35441eda4e1309ef887c6ca0f0b4de602a2c3fddfa5071954 83852acc9fc2e053ada4275330a5ffc9aa6e54b7a23293264940b9ba979cb2dd 6832514760061036c8d441136085183bb9406ee3095a482223fdddf479136e1c 8641d342cd16f1723df7aeae0c4875455a85ea587c63a2f68a159da7155958fa 9d5cf51299180f7458a3ad1f8840a02bc8b639b038298487eea4da57ecaf0dc1 ac2bfd5c06667873c87ce08b405daa804fb44e5b166b0cd9c15ebd8423788125 83e15224d1e34f00cb71fa6d5ed463971d181d39c457595de702158bc635f6c1 760a56bd39d9e5bb09a839c707e7a7be7b1ffc3f9641109f7e4e633513fceeed 708a528bda4667729a1d86db0b2db817beadc8caa80a614582996884676c2597 2227708507ed4cbf8b324de2f2010645f201670eef69c3b96eaf9f9c87fb6841 b9c949d7d7cee2b4f0ed9e5fa742e1a8f48d97e4b87f09588e166760720fb8e6 3940372902216ae5fca089391e31ed310de6d139b085183daad170513c6b017a c1349b16e731cddec12177a6efa5ad7b1673a24efe644d3dbd85827752e153a0 f02ee7db428e4d32b95e5dfa493730b101d270e7e86dc4872b648d79f52071a8 36cdaa723e698c5f9d29cd899adac4743140b5d620b6b5d82e3c3df664c69f39 6f16a9dbbf31db146fea8adf63b605495a0e05cb8c67f5bd22447640df8090b7 53f77ca86030f25d4d1b5929e23343fd33d4b9663925feaa03c68ea3bf94280f f3f66ec629568f907efc633817008b7f11244d21fc180721bd9659a56b4025fc 24d984fc44ae33bb93c8a97b93ac96ebbd1998c013af2623abe3ba250e2abd4d ac222b518f140d77a4a42a0b191782fcf3988f4448c93a09f103dd2c2f6213f0 18b3791b0dc5c92c80128cd3148bd553790d5bc1dba5bc967ff800fe43eff567 d67e8037b43a6e3f7a14b818ed2cb03331eae43ead307d6160dadfad47270b07 eb5fdfe847f411914835683d6e1d876c85aced3feaefe15baf9afdf6e817c051 c178dcdfa4f19c920d7a93a5f96e48953328d7e5af746fa9f6da763530eb064e b81f48586f18f651143d605d2e087d4ce44989635a302fa48193f3466a98ac42 ae59228aad954e7742a8557b0fa8da2a3b5d7f4d0bc6c6837cf6095606336824 0235c11713925f150bd97dae776d2199e26fe9b51835c6b6c349273eacf85cdc 5665a87adb27cfa9c58a9318b8a101b9800537a017189eb49c48976865ff9794 f91a4482f07265c376816d2164a0319979c1f568a5a95f9836c59e940670bc3d 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 false +check_ring_signature c354328df3622741342804ba34bb5a45becef8ab62bb85246c0f42146337dae1 5b9093e949b7cf82963dfaf1399aa05ed5d8a3e3a73966d553129af6667dcf78 56 8575d11950109c1348ad540c7bc8c0e2b68cf523949bd66e6616b146c271dcda baf9012bae1bea0a23c97072ace2aaaf10d82c19f143336c0ea36666ffc3d53d ad1f9c433fdaf3f4dd7d383d85c9bb892ec1009d63cc41e9e2e41c5b771b71b8 69d2cacee9ddb629cb8decca5f6f251ba735703e6a7b53a98541399eb98cd118 8ae75d006cac4d42002cb7ef19fd7a2f57e41300b22a3c7b50683c2f8dbc6170 406c1e49a9ae84661fd063cd5b8e09dd2319f1b9b574c56e50ef627be5d80e43 12ec50ee4554f406b6015dc3b7d0c07a0a9179b3ba36e7ddd9b41b652cf7615a e27ac84925e05a6039c26d2de89301980ac073c055122d4ff297c2bcd4bc9eed b7ce6eb4bc7d101d43bc66ea51b4bd1ea4bbb81800c706695ea5fea738bc1284 855313e196c8fcf6f99a41dd07a5812955d2f022b8c33fff6d637cd356f5805e 55cf67b082f6f506363ac6a51f8c1913118d8c0f45b16c3077a2f532fe623ab2 5e569e44cdba748e24b742bb4fccbf5054f66bf9d3467dedc8188621192a9324 83d7ef8d2f96f5c0b5b89951f2de0d513cd6c22bbfce85cbb81a3d2d7213b6a8 d0cfcf13995377b17672d79da382f52e8c1f3f68a675b573b52073d5023b861a 5a4c81d50698a2ab3f40639119543b0c335a7c5896a4adec208d230202f0ad3a 0df622337fb01734b2a8b4b747a24965c344fc1146df2635396a2b1bce906a46 cd69388aa8230adf7e5ce2a90baf8aff63cfd71adfb1f782eb2bf0cd999bea0e b8bf932f218565eab49b22e1d07e659cea51ac9439db124e67a03fa612a7bdeb 1e1c4de0f1a29b24ea6f144a1e9089052d3d4143b4933873fa0f00f555e4def0 da60bc48d41954dae8e5f2f2239d90b229483420862a1b06b088ad76e7969476 538e8518119a6ac8dc19d187a54bb421a5292ce8b63f9bf6cb590980cb68bc47 4378df3c015a752ea6598b74a81cc1c8e21767b7b53ef3398ee9b93497c6bc6b 30ce914527ca9d5d12848404a97bb5d70eb70fe55333f4a895871371fe69fb86 356722ae652b0dc88e1b958d794cd763c4cd2cadd57bc51450fb6640fa2209ba 11fea384a4591d68753f2b22dfa9d50b3cd350c7f3ed7345e82304edaf91f5ad 80adcfe82be138cec5f66a2e70e1835c5ae6f5bd9974fc31e64fc0f058845738 cd579d3444f16498e6a90d9c9b7b450fd2eb6a70636d6b73cbf1b0a311bb059c d25acea3741b5161e8adb101e1003b9b5e2d58090b46616665887acd63c5a9de ed8c62f762b306b85294684dd63b8b6c3f64ad473ec9171088c5f4b27add4a4d d6c3fc2bea48d65f9da404483061a05440fabe010422fe712d7aa0075b7d919e 93c70941a6a4249a45bfa2e398d6565219c4d0adb90843a698c2a07e191f7473 4bdc42584b966a1a6487414bed7d10978d138c3c0fba5a3f25b5fbeb1ca52ccc 9d8a97af15ffe4f6301ba26f894a6bd55c1f6c76b16382544509fad2d8093def 57e486c29bf732d229003a30157b3ed502380530fa3f871888e96038807d3576 97cd0ce33ee281bb410dde98bb012bb809b903e32646c29c99f255b7006c55cf 73f24bb397f551d3d9b24817aa021895868cc40eca29e6ea02ccbf47f56d074a aa48b84a3cfa59f5137596eaba1313388afe808c7cb2a8c3cfb27b753c15bdc0 c5277232c519e83bb50e2ff7a7dc151c11bbad5e27530ec965a86c051f94aad1 e34abd194d6938c0eeda5fccdd00eb8df2cd464eee49ca4c9f4eba06fbc07584 fd3c92f24cf5fa03e0ac7e6fe00afb8b0a87d65acd097dffe3c0e6d9a7fbf915 bd884709004509ec9c9db458fb5e60c2744e19d32e3aaea6a90d3f05013e87ae efe5db4151477b7c3d2aa99f4075c045f93dd7808e80f0b20b2fb362ea5bf8ee 9719e753b526af3cb6cb058e06c6cb3e881fc43c69bc16a4e14eb36a3d86be7f 21a89536b2de9c2a5c40037287dc3fdf280bfcd84ec0a520b49f6fe1bc8b0dcb ad4a6fb566792da5034a183df37675c04f841d42bec1450afa55b882b478825a 60a89723bf6ce07d4544a8bf4e52f1adbd92ec1fde80b7e692e5767de35496d3 2be78b98dbd6240e0e8ecc171561b730d8af53fd3f1a34e60ae80ea64045b419 fc7fa813753b2d6abe9ba4b342a5b16b605336b202fea6675d9d745083420c8e 1bd09bfc09d7003b2b2f39c52de35480df3400ae90501b770afd2479126db84e 434055b60dc8c3d4805da07f02ff72aa63706f5e21ea8a516bfd6c8f884abd69 b48f1ebeff7910ac6949b35ebc257d686afda7491eb051013581f3e8319146f0 874a3c2efa6f219f5376c1ec87c3bfb33827cb9e633fee306b6e2bd6c8da752d 3166156b35fb2ac7e3e521ca1e51ecb032f1043f456f90cf2cc3991fca7e0431 edc4c3d609765e1b1bdda61bd57c8ee4cdbbe98cb7b57d06cf71581179015e51 30906b1a9fcf72af7cee90d6e76196e9be737c28383d1e1f21938f139a2df9b6 cf5d908f99553afd19e004c7f75ff54af9a2736e6a2372e19f91f111c38314ec 55eff74f3033638fdef8218c8ad5cf554630feb4446c98c3cf3794e2db761e085af89ec0c8ab3f69d4569fd5cb1ca70aed18855bb35bde00125c27cd969c890595983e989e63164711a2d039990dd24d72803035cd40738c41ff6609dd19d50a35a250eb8bb2040aaa446b1b4261201d15c223e55d5c5cceebbe5f406ebd0c0d9c8e90ddd857e57d9b66c6f1143546f127583dcaad0fb6360c9b03630d460000527949a741dcefb623c11bc3d54961fb1b43da81cf7e1ef74443762675019af335f7eee8f82438a534322aa39b714e0cb7e237e5931e3a51a872f004ad59950b3299ec12f3392d458c9738efed6d5bea9831f962eacc5a13e731c25ec80a21063f83d5c58569728ff3f654b0f98aba6ac85fa9402df70435a08d39bd761f5d0dd1d5081754410c5b558066399c139a5bd53462ad59793522d4afc0799003c408c45e7a6d92c272c61731d75d99827ee15ab72b92ef8c55ba49c23aebefcb80026b76f1a3544cd6149c1a3718dd037286577bde6533ec31d4788a3ba8b04733086a4320cb78198447bc3f2705db04960cf165dc8ff574375473dc72694c16880ec5bc004e98e7759633c9f7d46999b326c3ec9de351e30a8675d6521c5fee2d0cb8925cb1dffafb9fb10876cbbd94f5e49e58376df2041f85549754740eb87706ceb5918670cc5c155aee6e3d70c0147fac3500f7810af34b24e96da157b4580d78eb7a7bdde6354b078e5f7df7375dd0497027cde4ae4030bc3aa40565ecce0d5bafbb0dce5aaf46c94a4e4d4845013157436a237dcd9189ad5113b3f155c90220ee3ab2174b7855da12ccecdb1ec4c1ded44075c2fe3e5f27c59a5351c9d9060c3a25b82a959af7f6c8d2ad66c11509a7b5221de621b3ddf802368f7e5f7b08a91c4248505209a2848062ea84f19e6ad3f5c3a2fd9cdc4a5f90cf2f3bdf040cc77a907823ba053595c774c3ac15cf46fe7d7e0a4765e0a6c39490b8a55cae0386953960f522780476d00307b7c1a1ba9cee63c72cc69595689b18f6aa5d770546a382f8e33c43828ead7e0087128f18414b94541ab1fd0ee52edb95936b27005f5d686576995777e0471b10c41cdadc6860e9424f551cb161ef7d7840b0e70331f880dafb20632c1de9a80c2024a0beec32909685296a7fa7e774ec8e7eed03ca488c75bc0257b0abd6bc6a40c41286844c7acd90188c003a004a79a1448d02f869235f38d474c241e2a5f9c7c48774e4c5fb546b73b70ad09b9d388215770ffe48cce4ec565f88538d2a7a638538410efd42276be39d704a1b2f84b5a6080ed49b64d39d498830d168ce09ee8be33884d9dcafb5ec2a4e9d131e26359b3f0b49cfd93955e7c766c548e1e091e5704e482c73055c5b200901b7c9e1d6887207be94d392f90cb98d7ee420a61a21331a5bb24b39eb2dd530d8e75a7615b9e50b1e17290a469b51ec805730c88e75b463af9f9fb4cf64bd0008dabaf5d5990509e9acf7b32eb18727b16d5d0b3ff97ea9a2cb57d44cbdbacc86de1d3681918c0e1d22ac05ea9c9afdc1a09284dca55bdc33bfa7c90deb1f07a86bad4258282e04d470df48730050e48102b9d5f3fc82665c2fa2b43dccfc4711fcb1149ffeaf074f04230ca9b3728ee783f702581f1f9cc62f7a212e15bf31ab7d80b390ee190c333dc06bffd26f6a53053384101941d6ac4eaab838a7766dd4a275af5640f109f44d735bb162ea2b9d3479d7cd5f3dc67b4a3cbe678d097a28a56e7131bcff054d7da4d1dfaeacc1545a84be09d5f5ecf682ba2f83a88fd19bd4a8f978e5ce054285b050e74641586bed44d5e7cb6f88e3db808d25e674ed7f2dbc5b75685f09a78e055e87ca38451f315543c923234a508c0be0233d1364dbdad3e087da46001775ed8c3796eb09e7bcaa490791dfdceeb4b0bcfe2c99ebba6a3142c1d10503eb5cac9c925c2dafec09c77baf37710a7a5cd28dd585dee4a79194fb1fafe10b15f8523c7dfe74aa5f65cd7b85f14a71fc6faca331d8a64f1c75165bcd603e0969d9f93e1cb86dd8db31ba9768bb00b12102d2352e58557a5a9e2316bde75203e0ac39affc90f1e37efc86981f74fb0d16f57fb032fc9bf4d1193b6f900ce50cbee8209b5b0f1163ce01475b458809b39d991015cd6b5d67e038ed573b062d02981433d547025f31f840cfb17dc4dd04c8b213d5ea2d4acf8dc407e032908b01d793feae336587a1b4261ad75bbb5539c770818cd87f1db558a61cf6c66489036873e45637ba5413830b50775523fe42506e6a41f03d6ad31a56187667139f00b0d97c56b87f6283ccfa5a30069cdf3da55539d49baa8beff595d31b3f62170a4c4d166772dcfee08b648195dd02496fe7ce8afa0ebae611fadb594c082dc50a8f769881df9e8a78eb5fc2e5c38c7365ab2dfe0509ac7bb2fec54972d86b9a04eb5062382958f6d71b87c56fab372c463aeae9887618e488205eb8b565117e0123622abef8da10ebbeedcd93bb7f9a014bb6f294b37a4cb030e90f367951dd0eeb7944ed3dd315d04babbf57d4e46a2926a2929ad164b9a39ab4710d3aa8ea02dd1f325f7335f8591d8119199e60f3132a3144849660de40bd514443ed492c08acf83abde9134afbd17147a272d04b100937acb1cd6bb3a829f47d9aebde7908f3831e2f32082bd1756cdedc501214471afd3d0cdf72ba55fad56fc1a7966b021b27ecc22c68d9d00a4f36904455085fc9eb05a5daa64dd1fc825f6aa197ce0a1ccdcf397d3053f08a18a181c0cb73d2135f93b50bffdcd95ef4ce90ab8db40c0e1dd99cd5c4a64c4a5376246472d45a92200000542b89e43d6990bf5a29b40b9b3bdf0d6e952fae660a1de6f514679682f81c5a4dd0c3d2b87477499a490a02a17f35480d537551091e63c140bb70d1a17f99f32d03a791e4d209ceccabba007d5eac7f8fbe4fe16152410b38b5e56339bd4b7bd21296c8f8576bcacccdada82239c92c96acfe1147dcf46ed9661a0958ca120a88cac44fac4990c3ed301b0d5ffebb0ab02c1ecbb69d5871e782c0bc39aa6fd12a4dc4ddf7e5b834f58e460d35ec1d3a1052920803a1e58dc8917c3d6f8f5e7c03bf6f6222961e41d71c9b02fa4abadfedc1a4d7ebf951dc62f85b4764ea4f70758b81a82d82e2093cdb5e09d76a30ffe7001d6fa0dd05d8f267cf17537054444e6fb09343712a565dd2cb0105e7784907443746e19ad2094ca1809f6a51716535c4d985c82be8c1a8ae7f0a8c60e6a3417795e6cd667cfb83a1e477de07b046a84fd1ae436c4749379e580ec6874b0964c0c3cac9aac49f8ddd8a12b5a5c35eba562bf723cadb180d0e2408577d0c2bbbf910a1a81354d281ed19194733bdac7d7f01fdd0084144d4ebe308058e9623d9a2721a47da39cb1518138b9ae32d29d592c8a7000cc75ae2604406aa79d2cc0714cf68ad19613112025434b5d9994f156d0a41dc25252c68db2309999f6ffaf9fdc0c37cd24756600b9ca753ce5837d456a31f15416300c9840204d065ab4e93918eadeb98dcc097f3ab1a35f3bf119c398b2e208163c77a7b190baa0d6021e84055da9c577c3482a6157c189f92afb7b188eaf18e4cb84f9fa10dcf13060e7aabdd15ffb932d2a9e3e624ff7ec94eca883b05ff5ad7c8aa4f2503e29f30a3ff82a920f907aa32f8e7e0006b7789a6ae904d9b9c5f15f235102f0728253668a86f32ec6498de348121574537ae2902fb930a1a8b52512182a35d0d5e312f76c20b44134df32dab5ea1fe7978069eee955468ed94425c4070b9110c1ec58069f027358c873400684cc97dcec40b9264b4298d49e9e40c053be0470703afdff2f0e6d843fd1503a317025bc149a22c2d1047042883453b0433daa007f612fb681255d576421cf060acbd558c01605082e66336aec860a4f36a1a69056f11aec586f0c05af18c538cb18d5e964ce594c45aa3e419b31e8afb23a5ca0e31215876096f8e69c2b06767b41c4c5c99f5576e5e8fa9eff814655fb5b9c3084e41ff629e79128582c6fb18def20a6c0021559bdb71cd2f5a0130df8e14e40937eed38354610f085ebf41fe9ebabf2e00d56ac9f8551b1c5fa7524a2626f00e1230a771325c46ac942192c3a07ee4fa67fe3e9392489833d5a429f5fa7fe40e5b5a3930e7c9cef5fb727010c546894de76de32ee13ae35f3ae16d5b4f371600bc649633889f7bde0e4a2798e8c8884dae1db68afd44abe9dcb3a4441464780f62453ba803f9ccdbfe23c939079a6cb7204a278fd690f03154375449cd5a300bec2d0a36d29bd4cca0b4c4ca513a25e0d18768b8c635895bb4ff3d5672713005d435258a7fe58541f9534eef6108e19f98de2476140061cf342ffac9cb19f90060bbfe5b381bf25223b6e27c0ecfc95726796098276f09e4287d3f43f0dbd9036fe95b7b2a5f5229094dc07841b6ccb42fc1b5ca9c44195a9c49286028376c077a8d2e4757d8d6236794d86f17c5c7842c4a83b12b349dd1e00347b33c1b1e0feaa2fb73611b0c5e2892671eead8af3434c9ce6eae288de018532ce21eb8490de80731ced94a1d8670c09452c527221030f6795a8125cd00e42498d62fc77d0ecd510383fdb964f3ee59c00de9f724af5a716801ca3bbff580b39b5c70a5390bf7fdc20af961639e67af3e9efa3dad7314c992bff4325f1bd12f2e15f428aa07341033eeeee520c6d37434fd4b45035d48f9c159b47e1c910687c90becee7e0bd95cc631e6072aacb58edecd7ce4d6946aff4abf014a13dea38390f3807e2e08d601eb74677b8f70dae8869b01c1f6097a214afc9f20ea723e4e80540d8ba101609b5c317317851f8e924d1448b3105abf6de17fb81e85ee1769d1a7c5a8de009e5de0b887f2243b5972fe32820a38c2003800e7aaa348dedbbac855aa97f90cf837ed41715902981762e7b84248a38c7adc3acdd930e90689ed7a73656e3a043d8f5105afafd52637278df925b992803cf18d34541bc379d2810396e7497d056dabcf60c8ad4e60ac6f851795e1c9bc807e5c08ef070bf88a176520c8721d00 false +check_ring_signature 6924656c129111eea1857d576a022ffd0d5a26cb3dedfdbd593cbb6c6ad050e3 18807694f5568834d1483d6252a5fa4f7970fc49310cf2007c2b72b6b38dcac3 34 08ab253a95aa576b7a253304e022a8bb2da57fc1023fa1bb535a44225fd328a2 9960f0744d57c235b87c4fa8e7acb46eb616080f09d39c6fa470c4adb6e0c383 a5c5a29053053afbd18af715dad35846539ab9f011fc3d5d90b045db53a915f7 b5e63d6a6a1cc3ae8c45fe2eb323cb8de8f29297611a4615b9ef5c5849da55cb 08fc0b67e1904d5815f7949dcc79dc1a48d639b18e06b0040d729ecc79f763c4 f091fe7f1f0c31f476b1eb372954edcae60f34092648714fdf23f3ad7b23358a 38080fab19e7e2eccda0b488b8263986b6ea3f5641f1f22e06f597ea1d0212b4 6fd84cb460fe5d1bd291052dfa64e37dcaa58853bd1bde3873d6c92ab41d976a 5cad023c0a3f09a524dfe663e7440dc1c6f3a4a5add3a16d8f877037decd4c4d 592ff8de3aca5929a37bb5f65850561a23a6c866f25e43cf3c81d096c38f615a c6fad3332720cd213abc776d70cf0e7171c615c42fcdff2582ad13ec0f36705c 2a05faf033baf040f5a3a3d0ecdcd58ae808acd857062ce825d8784be5a5b63b 910357f5a554660016115bf7ce601666bf1ff9861459ed863aa127a9380cad2d 5caa3439b42ca996bc545c61c8f5514f148e56f14dfeba3cc8367cc003c03e9f 73a87480e329824040194d38be24407009e4cbac5f0e9f5c260c7fbc7f125346 68f952818bf0004528d2a3994bb286439be3686fdf06f31da1246f74e8e3e13c 4e70147f389a9a785d7cd1aa32a2e2a82e7f6b21a18f2189b705ef9b1ffe8169 a9456c6e1d98d1aff975084458dafa2558d79ab8d91a58ab2250d6e94db05109 909732ea6b1c7a80d8bd82ef292aa907fb798e2339c018a451fd59d021410655 b54009aa9e6da817ea7c2f18191d183c2c4ca64bf98b19a084fc9b7ad5a98415 3a37aaab845c170cf7dcd43789c8ff8415752ea19595910cf32ca12757b05fdd 832f33ed65e9e243b3e9ec6f95e5794735172012eb6228270648b1959cb6cb1e 20036a36b096340d0dfddb8d9fb302586e5e7d0e88774abf81c268e0913de4e9 ce74cad534d5491ad7d47578d265c4d4691bdbe4028e6514545d2c5bd4cbadad c6a2efd5f7564d196655c12efab8333a5fbb4a9ce9bafe23098b5809d5daf4da e4f685916ff929fb707d88a5f4e824d6aa5608cad43e3dbd3f01b1d11521c66d 6c04f365f617c1ab3a144b1a10ade557f10b3b1c1f231f73a6f402e0f35a44d5 1d6c44f1f795c0bfa412a6a7792574b93d52b9cf020c57e1852bcd8e75c1fa95 986e2e44efd4dfcc1059244f069c5910a96459e8e5b8d9071c12b7cdf608eaab ac60c696d287602b93a1534eb84c11be3535c6a6c04e96cc11077d106121bc11 9c71726cd3455d6f705fcd1937f81e51f78202191b2b185151de5bd62f72ed38 55d3598c66237126a9d8a75333a9cc8250a1e035ab6801ea5d0d081198479515 55f6697007191102f474be3a2f7004d6f01c5b350e15f05e1e0ba4440abc07e9 3584afae939a3538d95c9e9b041b56634dc8968cd91a78a7c9d4bdb8de8c2a1c 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 true +check_ring_signature ba5aa790aa88a565641c4f719ff26d2875b198ae13e5f2983d6e7eb28b2b0426 6ef9ab5a35f7a2f2cf6d1325499720a31aabc7d44f973fb0d83cf9279f781619 247 2835ecd665da540618544ea9fdf390dd90731c54063f474267d3be0c822cb4c6 051b66b46fcd592c5c1d5ee0c527696ea18499bd54b3b0c389f01e581d2c30cc 5db2fb6b7fbff81546277a7e46a8026a5e26bd6273bbdd2e19c9d56d8012951b 0189c280d99d6c6e77350f02db952ab0ee1cee6ce880da11bd984762a63713e2 69c6052edd79bef63c3ada57fe3dbaff37389f612c3f0215a9a69e07d4b86e68 834f2a997e46455f4f91490c200dc303b09bb2eb4b464481693fdd1a8fdf5492 2a0764472225e8905b3c585af1838741c19b20bb0cf14c8aebe54eba647ac886 4e2cba381854e71df7807a4e3316acc6789f049934583eb8e346d8189afbce12 48be5eeff2af5d30bb2318864f9ab1e2efb2091378e04f66b215a026ee6e4fdd dc76c20f5a4a27e616fb0bd389674ea82b1c1bb069d5bb53107f36d1e1a9a312 15137608dbb58511189deb76a91bb2fc7f842190cbc9b1a636cf600b2a807438 656a9c48a8b2d4c7c73f03995445042e0ddd2907287dda0a0c060561c115f718 4532b622578fec1dda7389187b3a4a467baaeb2c0fcf53b7762ff1c8547dc77b b88d9095cd9d3b8f6f6a05767a14904f950e2e8a533f8c88845d8502ad872604 674b21a341d6c413896b3ee1067c4871e37cc60475c4814af2349259c33156c1 f862c45cdd6cf271ad6b661c41c13b1a1999550add19ea27777d93421ada8f99 023413f86525b9042cda3bcc0799f16137099991ed4b4c5d55bbbc8cfb5a11b1 52b265e80ddcdc1ea46393e2c8c1cad48e06a75a37973dc908e4d29bc2712ade 60c0042d13f46338b8876fed414b80f8fa6a128c0dd668dccc26d8dc430fd7fa 26e835cf724ee675abfcfa6b7ec012d46aeec65a2e6f944893c58c834397be1a f124c9807d0301b302e8154488b5eff2dc8e06e61d18fb6dd71b361772ff3e1e 9ccb66589556d43b443a06d7ba9cb657bd9507d96073a80ef8bacf2bea4cce5f adededbada94dbc28b1330045af183cfcb68f7c5facfc387314603edceffad1d 05406f6a0de09f4aab01ad91cf7e1e14a1a67d3a53f39a0e58af93953b2825ad 86c900ade43c7ff935dac8a35510f3aad678771183995edc94700e0071d0396a 38054a09e15b194034fb88b01a34771b9ac29661537e939b7badb6cf92c7def5 a88b3f3a860dc0bb873513318b91c1fe0a46670b8621304efbf3620d82534a5f fce8ae0a6d29006dc2ac98043cb0e50282878ae85e131cd83d0f50c6c7cdd0fb f727f4ab94a10ab90d69826289650e06e8edcde782ffa41748dacd76a39da997 646a69958bc844f1333671156fc5c1f4bc5efdab41448d25518e1c2b822eedec e16ad4db13bab98d644594a4a62efbba6753b84fb66b39bff5ec15eef70a3bb3 b60823c5a412efaa0ee5ebb63c75c6f278e7fb80e38e6e9f15c4afc9995fc79d e92111409383e4fb31bbd15e1cd0a9e84ec5307feac24a8e15807ac93423f673 9c0cdfda4c2e4ba4a8512b8021afaa10d22c1aa733626ac21518fad868ddb5df 0a1fba9504594bfb3f43479454f527b277e8dd2dccdb86bb01158b6f41029543 25a336abc19f2aa8b5009373fb6e90eae818f85205b3083e1bc3421075a2cacc 0ec83e8d7270606ddebd330e85de5b0aad51e1e23d2440928fcc39239e9f40a5 4f0059b554be0353aaed1561dcc53ff5eaa9f8bb1ce42fa387afe1c2e59ed2e8 27dd1c40a6514954c4b60d0e376aa4e084b7357b81199daf06dd52e9054ec1c8 f73c68301e8f83a2592dbfb5999953ab29ed8900e638f402b19c4d2b621be42c 242831095d3bb7652473f351c80d8c15b0f3cc5ead5539b264b8d59976ae5499 7932008af18e7adbb7e2d23e175fc65daccd83716d11505874f5e2d80b0421a4 3c5b13a2339f198765d4f73f8044511d0bd4a8a4e039eb17f880d35708d30fa4 2951f9096884b7aaa4b38a2c8c7cb8288b12a493293d75b13f8ec5c9a161df8a 1032d3f8565eeac13fb672d8370f94d4124d6428e401ba2eec53f9be5b210dec 612747333f743e22dcdf96756377fdd18ede1639d9dea7a4e30e699263dffef9 2e94abbce88b025d1f5fda2a70bfec6e2324705d53dac2cdd928703678f8214c 010f2c0f67984029ca12751d89c82dfaab5602872a60d910442313c47b9d0289 14639bf3dabd73fe8cf439447a3c8adeefb92a9372b701939339afe62dcd5cd8 5e2c1c50c661a178c819571a830527ede08abb950053a2a6dc7394df821cc3f4 d408c133e9527a99224b317810a940df7942651ba71276845c4d3c9c8235a323 c5131b6f9bc02abeb221683154f14456f68431f4cee06acc3413f50ca3af10af cadd7618394a9f452f4d2b74e729c98b05c3aef09dbfd49cac4e8e284e91528d a5f9b9fb7e3a5ae9a6ed34859d1c3f3110244e8de9cf7665a265746934b06da6 7b2ddc892fee833af80a384101665505a9530cd289403c296eb574f8c536202b d9947fab4208c028ebf54681e99070ff3de4134fe741d99997fe5c0cbeffba9d c9f719401758f5d01a0b24bd5dfa92279f3a3cbdafbf9711e8da82bedd4621f1 104eeda814000ddeb60a9434ea77565338dd06072cf7391d0eeb3cc106a4aecd db574fcae69e3236facd75d822a3a1462a78b4ac9b8dd7c8e00132abb63915fe 558a2c37e4a9a49b5bc32549eb4f89c8f21e22295921c22f6df1586210e02e42 c446abca27035271e891698b08ba639394d158278190877678069737620fa04d 728c0425f36b17b020e9188a5ec059ee3f609659d4aa1f9c14371999a73b76d0 ebde0bcc2bf514fe24fe44c22b5265b142987cd16c91974043554296c78b24e1 d6ed60539a9291f74298977850e6bf46d7b0e8eba5090698b2a43e69926aa568 fd07e805dc8c8b6babb28110aca4b53562473f5cb41c491035a6ed938d788a31 bca928cf475098c1b2d68685dbfe88b7734b8460b08a7340caa26f4a632c2399 e0a3df653c6c6c8c64d548a1db846821b7eed10d06c82d8e930d67800edebc3f 8b421c652acb72d6be5b116e67c2a38465368de3964b3c6124f422e6139a86d0 9e30caee3a77aef0772e9408162dabec978efc80a4eda7904936371c8b2796a4 b5326c1939f4585b6a5b60ff706d8115574bfba042ce8380422c5d024a886eda 1913bef86a172e6772d5dfaca30760eafdbd9432a72ab107287882859b04e395 374d4a8730af24459758e8904e0d812d69c28ec8afb4465840ca93fb9718c763 1d5ca0580de06b66b4932fc4bca4d91217e04420030cbdb7d86a910fd5ec99fe 480011d4f809c7ef82697b67fccaed8c3f5cf5baa64177d71cfe0f439c46cde0 f8a495becf424a7cdc590507aec8cb9d9a2b659c544df0dad993bec47056dbd4 2ef44c9e3dd3b908ee14b16da36d99ba506b71c19b15e94d0442631c36e566e6 9cdb31bce041e46f211490611cfd65329248f8ab2658cb1cbc91bbea97177a93 1a1987bede55d1692e0f3dd0e3eb1fb353542c56d7490f6d275044f72017b004 2f3bdd54666382b4968093d9c20572b5783376a68a96913e05daae58307e8e1f 71caadb52f9a30b10023842f438861b418aa259a3cfc9c6f49b6722cf6bc771e 258efb47a8039a924e6b5313cdb89003ecdbbdbeeabef8ec770d61bfda3e1c3e 089779592f2449cc461db46ca64300c2055d62f58b09acdc42453c73bd4657b7 d1c80f80ee43cb9074979dac950ef878317853fbdc95c4213b305b660ad1f538 809443b2b5be8647eff6e6713dd65b159603d740101297971480e072109b4a53 6ede77d0cdd3f2c3d60f85d1997665549ca7fc91036c68bb5a3254732610e38d 711f064e362b1f38ef31aeee01c07047690ba57e9b5b413c6b097044912fb89e acdeb5b4a6ee0f2f4edf0b27782a6ad124d7afb00d0b3898c6ee2ba36f44faff 85651f76e9f8b4081103c0777fbc1c2f9af56f8845c9548242aa02dba67f2dbb b2010e5b41e57841ef8700853a15f6cb83eb1d5f984adb82382bf4d09112b3bf b4c79309edc691b4bbb538c0f6a6fd98e4096f2a0e9619c7f125e7f90df590c2 86ec0a063a35a397b7d870242318332b1a0377cf4d2f0a655f00d9a7664e0b37 b061ed88ba21b7118758741f5a0db39c9573da76f8d7c9baaa0ed464d50ccf55 e9df66d2ce466bc30e3e75310629c04c6380a2303b9dbf004c0ed2d1584a0313 c7305e4e0c573af525d8d1f8298eb72a99a84f32b0242b8eb3adf9fb0c9e665f afab03a8dedbc7fb70c6f68115230dfb51117ff55206cdc6bfa56d30c4ea21ca 5829b42704769a6baae67117b4fc1971a2d2b8f9b55a59e6f6c511a731665a4a e23ba42db760f545899c9b5de63db11a70c2410e5a4709e799c5b87738ef7b45 8e5c9f572329d40cafa80d02912b0d2199c6fa584f59bba612b7d7d468f07310 b7dc89ccebf51179c720049a075dab19e6add19bf020a2eb2131413c1c53e25c 1d9482e9195e2903b3ee6ab02fe68ec90bba0702807597b312c23097142c659c e1e84f24577acfdb1317a77d694143767eebf1d7301384147ee52877bb67d22f eb9be4fd831d3712ddf86cd3b03056fa560eba36956cb42b7efad41b6f54c022 a1e4d9b803678009217a64091c444c3f188e964860b407cc7a728bcad6efb3e0 58665316dd5bc1b4e4a85b36e2e48eb94faf63d24dcd941e70bf1d754f64d3f2 940c93364c8f4f36de6d47fa8c2b43d2edcd82c0984d73e717887dec53f02b4a e765fb2c5bd3ab5eeba07dfc505a7a31ab66b4e515ac8beb7054344f215ae0ce 902e0f4be8747332398633d58a01cfea2131eec09e626f3a3b94635a8ba0429b c44b313e522b948bd8a3c9868c7996f3e0403834465a98da5fea21be46a9a5ee 8257a5a1df89fc62cb0eb1c0e5caeecd7771687db7f310e71c2cd16acdd4b3c0 047087a44ab39ef4bec857c855240fcaec5ff2b320e35c1d26bd1b4315759e84 95f317247bcbc0a8732451985aea584d18953295ccd05249e1a2182c269f4457 823eba453895413bb7e0393becf96068fa40cb690fea61fdfbf894f6c8a1dcad 5a97f1997be092594d790c54ce0d42c324990f762ba82153b115e9188ebac432 557a4e69efbf4671897c8eb7513e9f81b969bad3394d45d4616b74edeb495c8f 9ec549d50b3abea31ed7a44ced596fa2414f744c66a157a50a29fcd8049c5a76 8977267b70729ea06ad0e016cd13d66b501bc0073afae1c8a0d487f54eddbf3a b44d6da2bc5ff1e562d8ba9bf04f76c4dd379316a91f67af1a28c74969b655b3 988dec4b95a00058188ed59488de8e9e2a22359b82bc41391145cb6e9463f005 edaece319f491eaffbe0f8bf5ce55728b59f93c52022f410655ddb598b98247b 4817caaec89420e48d3342799125c305db1c51a2661224b7be17cf85f5377935 2638c611c6c5b1a87abe95109ccfa9527acc55d2f7e75d532d0d7d25e31c58b7 32b5dbb2c79bbd4dc5c88c250f3e2b9efc2adc78892b6ded0a9054345c1f765f af98d2efd31b5c955d2142307f19c813dee1a873eb230036d4a132a37c5e38c6 7121a6a4350818e954cbb03034671fd4e4bf863b91bf25b3482b72553c7b9a14 a7af9f043e49c734be80fbf022e71a504ba9832408208e537ea580de5140d724 57cc8fa7de90039172a1930426643c600beb02f836cc0cfc396bc9f0d86facc9 62f9323631a8506b05ad25ac5e9f2561d3546af9012f1fba8dbdb3348da94110 ba538d476315dac3b7b2e139eb2a3a2e78a075278cddc821e1a6f2e955d503a7 feb3141637817d04cf54a6face9cf51a59da24c3a92a0717f268a7b1fef7a091 0993bd85fff2e3cf0b45439c0b537bde2cc1397020710a1c5409f5a91a799504 3f49ae378b3c0d39fe3f186571894fe599a5bd948897035767b769e35b3f8c47 de1162425561d68dc8f055ee387ceffe4a8b795019dfbc764b95cc21c141c708 0a9cf71534728c643ffdf5228d222e32fe1f28742f68e5f4a2e82c713fd77e28 c5897f4e5e563782ee0bde941c13b0a4319820f079d02e5a5ee0ffb8ffa2bfb6 f24e5fb29e7a74a3bef79e485849e607edf010a43715feb4092bbb8db8a80599 66c09bb3e5a24ecb92ac0c27ee04b178555278260fb088f7b9940c264181d39c 70fe379e13d4768553b4e2bd2e3fc1db72d04e73f83916023cc74ccfcbcdde04 5c4a29c9c10618fef2573bebfa02b213b2fd3697ebf9005fcf7e1894d466d62f b09c7439b594162ee9d222a30dbb8450d404a108d891552526a9b72ca3aa77e7 dece6e0e0317e0c2733e2189cdf9f148d22f31ad29f1940922953b88b7ea4733 2b8443b7817a15db574afb9c493d41a97978dcfb0271d88cdaca5e494f2f9e58 da59aceba1bf7d41bc0150b25d353c07f07686cf5a6d45b3ecf0067d61880e75 d462b59f4703e54fe7d227e5b71034c763a4d0486d5d266558497ab9a86d20d7 4b85045d952f27ecf22f3ce6e8254a05f669625f4ba239b1c40fbeba1d132d8b 3218c7b344f98317dca978e92b7a1708845a5afc83e7d7952ae55847244c8132 3cc379bba4bd9ba69fd24f2da16ff8edcb6ee56c0b53215ac1453453ad5e09ac c360f1e979cb0625a5fa903228c390c7186f247a42878fb237289362a7604c0a 7d32b77c2c907d4f6dd858741544be5afc7201f6e4e3dbecf6d0fae21788b344 c2ecf93ff86824988c76d6d8832ddbfc0a080e6739cba3a44c1f68cb1d8429e4 21a51916c45114a183e6c87297092856d2579d8190c02df04eee1ee51f235919 901684b36c1fb32245416bc63af4582f3ec91208fdf5e05dac5d954e2a238ec0 ba9937065455e48f54baf7fb922e941db7fe7ce80628a648440cffc837fca389 878c1475b14281622067220f24c7c0436a7a85e933644f727a2d02c7d400f13e f5cc54c8b146479883fac3c6723570cd2a0265a797f2c3b3d30f8a2d6dfb8df2 e0943bc6339cbe0846f1f3943b3edd38402f05b5124893c36f089b7d77530684 209357162d9da21665e1a02823dcfb8cacc288c8cdbcc02f34610dd0ebb57efb ec502de294b8e97b0fdeb584b5e77912f3a0d38667b2e7a9d7e1f3fba5c6dd56 0942c2074cdec8786b62adbbbfc83f982e6d55b9f24649799daab0380f983064 bde8d14db9c66f3581675125449522a60231894cb306b69c18030ca6f9566480 6d478441781d1883ecc8059d5d96ea5ff2d3514983559c3fa1bd9ccb0164a011 7020c64512771c5efb5dd5b63b195cc5f7f3db57171862795745e14c67cbf39e 38736eb747804ad5b9018584d77ccf176448b1d71a6bd40fde670fddfcc3fffd 8ceca35e9d95c405bca19245e0587fa949697f83121ad279166e5113c11851fe dc4591d5067314f9e712307bc831ca2629b2d2b99090b4a591b3a11a52c5017b d39451138ee61ee986678f5c5f88d0b4aa88e97bff8f6615444e8f3af13ec6cf a7a46f90ad654be0a9e0ab51f8069c6e5d7b757f6dbe1d78620fd532bd5fca3e c090ac1285da99ef9c41e102c0df6d7855c170aec4a66c0c54763d327aa23ef8 0dc257e39d9374280deb9f62a365edfdc512124295c55c2bc058905f3e09f658 16f3e7369d160b0af51bf72447a8e469dadebfa0a2f1d1fb373bf157ae0f2943 d6c3eb4f1f6156dde26ae05236c6e24294c8a2995d14d4300ddcfb3c83621f75 87aa73f8280df9167250bbe4b447e865280796acff69eb60aed6b0fc84fadd4c 424713db09e211a1dfe7d4bb500f723b42d4ba2c80af822d3e7541f2dca1dd5d 60c2f13fca146533878fb27197079c081aef782359b03eadaf0fd058aaa73228 c7d72a9057c8b926fb8dff86a3b5546d49668c15008574c193519f9d36f43ba3 de0ed3affe10ff37e0642b269efdb17e2ccbeb4598bcb736762debf545d98adc 4220e6a1671e2999794cf2600ee5f1ea2809268224a710b25a5ba4afc845d37f 3fcc1692998775c4d1efe0a036f7189b7825125003a8cd210d60b597ea121cf7 4626f83d20089a0dcff965da674264eeb9ab0ea6fab68f2dd9075fdd16ea110e c4354ac2cdebe31cb013f1b43364a6bbdd45d57d1cf20c7a3cb402c67726124d 74480a01b81f60e064a4d39d30e15641f193566d32a4d0a422792a647d05665c 1815ce92ac0fbcd0e9ef5176d1aa6dc1d1e45062a8d4909a7d10f58d5a8c637b 901f36f9147f8d98b5348d70517a35d3b0bcbe5da07c99ef04ccb10af8ac5311 dca792ac4ab8205a890199bc7488f4423617347483c727f8a28da792f011f928 e297b8bc5d3831630b415578e9374268cb0d0070262fec80360e1e34e6a4cbca 2b3f79342cc087e2a953254bad2c73104c1baa1c67b1c9005794fd3f12f406ea 5535157392302edd10c307b98323d3a55a6449fb320e43342a47239064aae552 9c7d80e8a6e337fd054db3ea8b240a799a9bd590f2a70c3d23b57e0a888bb7df cad72e250e2b4608cb27833ffe1d8b8a8e16909f57560f9f44f8c30f64f7ad7e cdc47188c7de8748d70496e6d05daf2a7a67d88ea9a29c997043ad2302f7b5cd 94932267e26ea7827057a5afdce7b41902cc076abb7df6c435e61e230d8df45b ac2448f62adac9eb04aa5adfbf54a38d66817eaaf37b2b508490997401ed202f 41f0df15c35c67fc1ad16b9b48e7c91a7f8aa23268f7fc30d1c4d4c5a7d7256e 6564da7b1315d1ec426e1809f5520eb339c209f37bcbb7b757f8f926e688dc0f 1d89b455a1b82f41468d86c9d3a9c6615fffd772628bc44827b8fa962fce6da1 f725a6c357ef4ab54dacd98347adac9d040a2f99e61751c153ebf230c0c0786a d62b032fc071f23f8a1cde753f0a5d7d6f29352f8d90a64285ede18b9b079644 6bb0cdc27f719db1aa4d69c95e6ac9e799653efe5d76e37e1817552df6393dcb 5d554b8b200253b33c182d6fef9798dd9c63d74b3501aa2d248c2695b1d3ad2a a3cc222e9a208683e5b2295a73c691608a46215f2e1769b82c7c878df51892d7 3072b5c91825a59582209e9e7b75b0d95163a03bff5fd4a53754b181e9fccc87 c6443c5a423ee7a6b09d83a85f3eb196ac328d8ada604edfb705c7008b327529 195580863445070ee3e5ca71657c133ea57316a816c5bb09deb6d74f1ddc44f9 bbdf319e1154fd05d3808da2c10b7de5a0c730d8d05e94c3b701596a5a0ad98c 5676de856d9c0ecedf0f8445222635175b467e540107ad9ab9637d45d22663c6 1bd2125da88fc57b3760eca74db17e86323c62c4c8a7629d42f9135543f06ee6 7f6f8dd39d8a7fe3613a0aa8f485da3ae89bd5f3cad47604ce685b936b6be4ff e795c89ae1f4fe3030dafcd6bc21ea91ed42105fa3e88f9cbd5046dd6cae3fcb dcf23d5249b74064bd25f42b5ab083ffb0322f7b6a67f2f185f253b0ce334a86 bf4b1bf8b009fda1e803375ee70733399b580ddec8191aa7778d2b87a88d27eb a02140ff2535921cf01b14cde72bf35231a537974292ff4de256d201893ce47d 60c02aa9963e480d46e5e7d2839f8372db0828da901383018f44c8a2a52a139d 109637f2abe262f523210054f6cd7b230c3a92e0b5daaa4a4d1dfa4769fd2f31 cd70ac0674c7a2474b341dbea038f426ce3d8c2053e48adedc37b605ccbd4472 5122103dae77c0974eb5bd6a2a6a5fecc0e86ec850c0d72b685149ac68a3a5b7 444e5aca2ad6a0233230f6df38d63f3add2de336363ac3ccfc656d1d6cf1e0aa 36db035754d371343930cfe61a6b1ed6a3be254b6f0845939df1d925c0db4af6 42cafdbc70c3907098d797113302371a539fb127488b73771f2787af119d693b e012ef7d6a4dd51851e3d304fe7465d4682e608dbe23fbd663b7c16133ee2cd0 fac0ed72e1c0edd5b382d8bba2c4144fb2ad51c1f8f27e33eb07b755dc5ce905 664dd6a274b837355ceffa50669b468f90e0d2dd0ca24e1a0a3d0e4051f7b87f 97c5e0d417c4cbe28d4f69cec58af1ca6046e0c2f7833cc55a1875b1ae74ace9 2065057d224f5fca6ae734d867dd0e1710bde567244e3766700ca817e5079e7f 490a4bbf67bd8afb4f47d2c0f343024496232aaf953cb436502a146b3ba862e4 7907cc9d2bcf271dc8255fa1a53fefed1b3a29936775f2886e90df6e83ca9192 58725915509b529e72ed3029ffb730d5e6ab868e787bc921486010ff18c10ee4 d4b3d1e8b00af1a11ad89b2f846904009bd2ba4d1c105f68e57e2ad99276cbe5 e2288531d95d62e4c93f816df12b771d6e8ac68a1dd094896ce1d9db582e937c b9aceaf4d5ab9ccf20d8df1ba1c7361e6936565a5c121fa4c5968bd53bf160ca c4a4d5dcd7a1923a2c8709a7f0a7f30bdac88cfa70f27648a02aa0f4d785de93 9b27f8dc4960c074e97a8eec610546da8bb153aaad089ff105d18c89a42cbf21 6959640403eb49fce511c4c6cf260c591cbf58370cdbd8842d8e655a87fc2f32 270653fbbeb96f95770278faa8d6b517a40ef682f0444c6a6b7eced7a0d06b58 0723daae4f938b3bc7a24ab970670a1dd8289f4dfcc400b9ed03593dcc80f67a a9ad6d359fae941fd588e6e0a3204d06796aa889db30bacc55b8385945e2ac66 acd894c6552b9b3b1d1b6306e83d88d2e390d6aaaaf83d8b241329b66f9a6cb2 f06163b64189c13677dd5f2410fde5e6ac6897c8f9311b33d4c8b689337b98eb 8f191f811b86d4dce9da3b6085b4155216f7bf7d8d49290407fce327beeca5b8 bd7c4aa5a20be0359d4ff9368c40261788a9026023386efc9b174aa9c4e1dd1c bc9d642740d10b85529430efa591c0e3ea915faa8d3fd0b4daf70d8d0311d37c 6179cec5ac37598ae27961bd8e898b24a1f770ce0b98b30877ba199ebbc55fba 8647337fb762e7b1b54ce083b055a6c6af6088edd102bb5f88d7313c8bb8218a 2c0805a08e82b816b946f7e7affb51b05c6ae43260a52dad6e54f1eb8e01f113 f5aa41c40f126d48a29cde7ca39ea558abee54dad5e49b9d723df827f5d0a307 e07fa4cd3a1a503fb03a6867e8bc9471150b2b28dde140b2af9b69ae81bc1f0a f51bacdd2282cba56a0e0c1a0f377efd29d9f85ee353632388e5a8415bad59cf 6bf1f293d1da442409f573e36a0e04b226d5d08c8635fc69064339de84163413 21d99d6217a9feaf86bd70d0804c917ec71ad460feeba4dc48536582298b6a36 04429b3a01832e4217cb974db7d712cdfc1a010d0ecd450305ac03fbbb3c85081f559c6bc31cf21e8bd6749aa7c5c8c1b74ba0cba243e45af1e531ee033cc300391f0b80cd4ec045a25aa6e58b72776687a0f74b6dd55810922b8539b71b9f0ba231d2b3c55ce0f94c4523c8ca57f2a0505181554792a347f507b6de26120500396ca276f53f8c45d6c0bcd772486e94b80f9426dca15d920cc143f1359a66011848981b995b7152afa9fe178bb560c9e6a8afbcfcbd73a4ef26ae76f785110cc141da8eef88aa86c502425920895bc90adfbdcb0345337c9ff0112ebead1400f3a4c1bab126a444ed2585d04c8cd7ed9c1cf4a41c447e258dc037bf953f7503b818c94a20680093fe0873002f179be61f2fa141227795eef350fecd9c5ade09117e20f2a7a22d7e31e34a9b938b67ea4f770e9036481f12b3c50d4511508501ef41c65c542ebd327e4008ee0facb21bef9ce3c986da32afe07db27ba323170d54ac767f29132874b0f435d59f5e8f8fe09dc370be47bbc1b462ef452a03850ebc6016614e63e4a27d54bba255b86aa41b2d8531fd2d8604253ed227f5a4410448979214cf76761b4920bcb078cd90d88fb90318fad076685218ae92784f760235b05b58ac3657707c8709a7a81eb3118d921af0e33e1468b7b6bc44c6a77b0238cd0fe495637113e6b1b959c7d36b3cb207bf099d3b0bfa53b9ec03136ec70a2f8098559794b8701d6127412e5afbf11f666b1a38d0a74806f5f60ff1dd7a0ff3a8b127a683c44a1c8ebc4cdbdc4569203aa29558d1944eaa347b0971c9cf0a96790585ca3aa8198ffcc445586a86e332dc7b6d7b0047fa86295308a171c1061f4dec653346703ebb0bd28f3b85117cd0f549483c6092458f93c83ff630940227448516ced608a84e411b5912806883a4da6306173c81dd5b6a8f36c8a4b70f4e8bfb2bce074136ce3bf12f746e53029f43e54a1a12d1fea2fd72f4cbdc450f9476774bced8fe68b0648b5dee5905d79b1bc4a8c86fe7a558279879ff6bab0a349543592dedb0f1dd97b330d49bd37d9e9e3e327966432b79d314b96ce4cf0334b129b3cad9fd1bbd58e91f8397f41aeee0880fb1e7e5b8cd2e21010abaa90b3d63f0dbe69c4e751b93a9f2fdd0bb3876d1aa26ce25c72462c99d296a87e20fc9206b0e2758e0687d52c6ee7c5706d2da4adcc18af8b9b7c5ca3584b903560cc09bb0bdba08bf9e8ece24efe1d3966541a376438126ae9a669f93d0db0f9c0172f48c2542c1d5c1218d3aca541bf1e148536889c26551aaf18ca182d621780e6014a1f95ad766ff873455557349f5dc2fd237d485471a93f5bd9f99ece3d50c201db39c47bf90de6abd63c0836b244de93227fdfeb8843f9204bd4149675f0085f62b440f1dd496efa924fa4c3733a1a8723b8bef94d30b128e5b928c800d0ecec49134850565a94f9421e1119f9dcd2da6953844537e1b0c893bead8500f0a7493f58cd3a0f5a21fa3907c11d58fc0d37341de97b9f50f03d4f4baf135500c0c81bba774597f8ebc5e17fee3324feaff01519887dfb3b31fed8015e0540209c51b1c44387a4b74d59312c5eac3e00a16309f78a4509fe75931e243d2ff59078bab13fe263c3c6a4ba89915a36f1371447fe177a8528ccfa5ae121c3838c50d6933a3f853d2bf8e51734b474e7985cfe69f4303d411c1f6761587fe1110700d8aae1a560fafaaae0dc9d0df50c1ac259482a21b4e2a0f7526eab30b7a3ee40b9433139920e5f45d1c831e7820e4481ae28df874552652f7819178212b72be0c3b8be3ad55f36b04378f2c475709f7014a7c60eb4e699f6c29607babee4a0a0fda2bebfdd225c7d2d67851e33df78b7e8ecdad2ea08e5d38256e5d7299d7a6081336b136fc9e9c49a66f337f948fcbdab653b3b68da768a86ab7019c0db5ab0e8b76c3619e8d662e78ab3c93879d7b949e5fb7a7587ec152a105d15810b031091c1744c819af54d459702e393c57401af6d76cd686743271f00f2f10f0660903f3c32a200146c93162421312e3861c66520b30df69326b740e5294cb2ec32c014d6f9706d6214daf870a8a018b9456eda97b0ebf88ed02336be58b2e6c88ed021153838597ff3d2d5962620e436ca46a685480d7f3962480aac8187127a7ff05bf5253b0828933451c36b183013ee3a55aee870a2eb0d228e5ed869306345d0401af4680344475f68a49f24f6f635055ed335f373e3759327c86c9801247960e1af27b5a3ff188dc5da9bb7db2fb36296d9f427ddea867c9f3a3ef6820809c0990ca5f7f07870d23d28ceb637b03f8523d0bc91988c94b5a945225c5a3ed0f07db0b01ba8303a89ce058c2d4fc933508ebb99ae1f06822968db3b67a38856d035cb72cc3cbe75065bbfecd704271c207fc72938141d4e0df15970783312a2a07050ebce1648841245d642f1db78abeffa2355851050b8f217aa562481238260a35a81d85e01e4a17197a133f3e2fd6e3ab1e41dd9b357220ebf3874c6a5fd2050b1003e6d773a9db168af804427343470c9cc882f183cbedfa4f208b0650030fc63e74a4251982d5f92e7d42121fb4ff14488a9f3c60060fc66d342d823cd408eed83ef9793c55e697387b06d61ce64470b7c1934553e998c222308e22e3230d291683fceb2c80755d21d0f6db590b35c98f7f9eabfbb18fe94540609faf6b0298b77aaa0d5dd9dd5fe3733c0a2811bba967256fd39652b8c3561fb13877f5029200edef50a47e0af20d688c5a4dab4649e0cf1bf4d64845f4eb9abc5943f902ff90ec29ee159b466410444dba1b608d977424bd63dcab1b115f5530e20604012e9a29b0aebf3ea248c835cf7660791c35333dba6a820c437c45d487155e5702598c93cf1d4c45d69f2c2851aa2d98b01baf7767d90cc37081e93b497cb3470924b628bf834931ffc1fee9b17f5fb463b7c1d6b6284f2c1ae32abd872ff33101d9b98db437f4005caef7875063b3f7b03255b18a11948336f5eed5d1ff8b210b63940eb28d024e5f22e157ed32929188674b63602770800fb77dc09de7117a0b034d231a9dfa1dfb155a67c059de3cb3f4fb40c45609d3ec449b4ac4d16b3d0b41578c36e7aa6002f4d2e1bc1d17ccda1e87866960c7efc1a925d84a1209660161bebbe447007e020c6689216d3e6801e484c00a305baee529af867c404d0407c46d27e7bf7e633976e73e25ec5e95ef019a87cc8de4d602e85b280298c55c001c3ea6ee9602bda3b30797041f28bd166f4fa5b5175a669bf7a8414940a0930967fe6e5054e8f4f75935c3703868c5c20c0ec7db9371a802173805f44690c80f809cd5f3db71ca8da2584db4b79f2d3cb42456b491ce964b2a3d206db28d990d75bd3b080edb683d244f885d1bb6438cd1a8e48ac4212846ffc4a04de02bec06b05a1c05e6aaec8d10db1a0c2d85e22df6457696e0566874eedc69f45d7fcd0e25f127d395faefac9e061eece709b7075f87e6295eee1748d2ec82e8a797c006d08fb632b0d20ebc0738e088fc288dd0c99f156805affa98eebfc5c4de9602086da7cc10143603cd31ecc8c6a6698f51fdc51bcefb2c14c286d52c33bfaa80088643560e2553d269b56ae9ece52f1842ce2ca58a44543c21884d085263eec00b8a189115f67941bf83363079c6b74dbe4ac852d67bcd4252d0c13df5bfc02f02ac7deff3fa754f15d926f30d15c60dc963d102d32630993d44db389f1a3a0b03127c3b91e46190c34fbc4bb89cffce0583deddb78e9b2e38e5c9bbb6a320b809215c378a64018e8478e117c89722c7095be9d436720abb43002e170e3d53170a665542f2102869e27f5e26453cdf915fba9249b6f0670896f9851ee553fc0505a18cbd61b58c0a13d431f50475bb0b5b15ed49b087e3323436aabf3545a5800f3747be9413c6f5f1c740a4178b697ae869e443d8fd2d4260f1d61fedf7fd54003f10741fce5bb02c15e2aea43037ce8c03cbdfca1b18844e2138f3666925bf0fb5fcdb2faf0e84ba2cde4c62184978be0712abf93c623dccf93f072d48d8af06a70466bba91329fcb7d0fb34a521991149210f09a55a2a6bc34439a6e3987e0e1fec0a91b01f5990e6134b418896f3ef879955c16516119a01727ca2bec462024c333e4dd8fd6fc4aeb4c56f584db7031bca1863763661559a14d5d94db9fd0bfc41fb982655781a152e2f2e04ff46361e59aa405a56c56bc987319a70b8aa04fa2a2b62c1a97cc989ef6d6318b37fee22edf5bf220864d7abc36fec9b7d460532e020be7ec6d5072c123ecafce36c01b8ee13da9207043510ad24f39c210b08a93a764cd40e65cefeec14151eb1ed0c055e3ea64aea5a874a21cf66a75a9c0f68210b1e6626e75d09888a5563a4b3cfbe74bbd58f5dbd7e513ae31f20b56b0953d079e20c81defa377bfff144a5dcf7a26df5ebecabb89fa0ff8f496d48c006618c9083317f0cf62cc9ba1cc3e7fd7d49d83106be72f80ddfd88d04fa6eeb0c7714a5e0d3fee611b400d559f05762c725e334c2660de3d249d45414137f6809d03f6b3b32b2baeec6ee9863119d1944dda35e69123555109e6d31f5b056ad0023b4e1f6b594a81544fc6eed606b1359865eb035912549a84622c78535381406c2e7813f5287c32173a2eede51d16eef03981b2fdb7663fe49cba4692949da0522669949ca78afd942a37718da2c1a046b0d4c9b888f8e3bd601f5caf63ba2056ec7d481146d1165df7c4d981f1d22ec8b592ef944a4e6d3ba42eefb63f1ef0832cbcc69d99489d29589225b295e32ecdf842f2a647982505974adf5cdd1ad06d1b3eef0d327f5ef38a1f95e882a1c382d23428a24a6bb3fb2f72b57b4b5bf02a59d4d45c179737ec69988e4682c5dce792caf920ec447fbd417758d7ed1540a4cae43543f7819613718d031d5e419da9ae9356685e51f1c32988b565780d5082b2e8f07c243f027984984c25be391541ca705eca2e921b8461ea8ca31506b0e7539d2d5ebc1ee9a4ce7b8eb6e239916b9dc79884b71c07c0aadc58f75b6540f28cc2b5a649a653e14fe7d70cd0afe6102e1f2ecd848cc25d65f3161ef54080d8e970a19c5c97b00bf47e7be16cbaa1a1c0f6829d81058b0f87caa12406ef0027e4a6855ed3d3df05a2f913d78feefc253b4bea622b46ff41e6b69bb4fe95d068245fd82b3ee9e0a82e541ac4a144a5a1f55c8f4f1aebad54f1041c707742c00886236454ebb409b552fc1fb7b78138b61e4afd7b33e11d53eb82d6b5d5f2208622b12593e63fe60ad3d87378deb6f6e586e3f00503d25bde8af03af93bc47066da6a124fbee9bd23e59b70d0d2e657b67aee1a9fd87d9cda94d40df45a9f7002dfb769d17bc37b059462ced686ea28a4b376b1719c9f67bbfc90607aa1a2e0ce3dc8e668935495584db87b6b35d75cc4ba93e371bde4adee5193323ff82b4012547995210d5ec434ff5cb7863ce6acaf54676481caca588c6c17af9e8fef00318d44f5c278b567cf42a652bfa084c5c4a5abe021f4d7e1d616887f68a6ed400473d1aac62c6e2a79d3383593307f170b1767c2ad48ffe0691370ac74ab8af08af8edf1083a9a80b8f460acc6a5ce1aad7f277e40b3ea4c5cfb49e5b105da608d18e5c567c26cb63f65568dc657b063f23528d2f8e46cc473092367f9e3d7b0fb41226fc5f624680c6b2578d98c36835b75fa13fd8914dd0bd9f50efa35f560b009e1e6f183a9c20c699a95eda6ba13dbdd028b78ccbd5567ed58974323b260e0d92dbe3ed93e1b61414e93362f3282085e09db1f990ea181a58d1bf5cae3a0062aa5a4f4379e8b1e9b4c39e96b09d1dfc030a608ad24aeb49cd0c281a84850a58d04463fd46f22789ce6c2353b5a28f3556c78ad0326e3a3cca81b7a671380a03f7f4cbe844be1d03263b6c966d2af26676edf3fa2491af2804ff476be6da017460363ff163b42ed815c6fb1fb48a2ed4cdb1c6874cd75d62160c4f05190b0454545aa6b650dede0c6a7e10e8c195c52e7556beff7aaf13917fce8c2d0eb102514b5ce2107261a2ce529b52b31ce7d3bf796deb2c90c1b8ffaf650bf664850c25ce97e86fe4f8e988592c5651a1cde95399ff038ab27addc9a59b9380bf3f09d34687d229342935f4462ebb5adbf1b873f59e445bf517b779b5bb50baf8290feab870baf39da03e1815fe78773efc0e634db049c458a96f3d5c45d0750ebf06ebdef7a0ad399b163823db1d7a3968547cef28402a2aab1cc33dec927144420c7206f69d6ee3861303462daedc8347e82d81dbe33e6a3f7f9b1735cb3a2c7f0b41d325e8ead60beaadc48e16572949df349c46b294e4aaf08e1c94ce4f639c0fbea6550af262a0d375d47e15e691edc7da46892373837a9b4bc7b5eaf43e5a0be67d0a7c4410e9af532ec5070107a696f4bdb5f71478bffe596f964d46fc5a031be12f924368ea90b8f9b3d6ae61f668ae9ca4ba2422d888fa79ed3e4527770415725378ebdd6fbe46c761da56a63331578665821964520af0fa5feef33ff90beff27eb1172442a08f21855644724cdd4fc8de70be1b91df02cae13610c93a00cc640935e41a3f31de69f152cbfa1151a8544110a5a66b316478829e4126cd0cb4fd5989c0d51e4d7b8eec0bc002881ba84d423a5304a3a1bfb358a32a528002f8e2ee442ad7a749dad36f28387504eff270421cc9229b2da799b288217c96003415f2724a521ff04449c316078ede3de2a740c4141dd234ef8d4ce09d8db80a84682d69c2951094cdbcd976da65a8352127e649fd78b96599c214bb7dbec7017bfad3df3ae396b2bbbf75ae3b81705456426678aed4d9d4a903901d96e3c60f77b45fb4f6fe5854c1a8cccbd82881df02410c4af89245f3c07eae24e3a2060845c01eaa713522524b6808c3a84e22da3c756821a754b5faa4143675ea34f8006623616c75a9983d344418180676c9a107b488c2a4023ffc2200764605a56900564aa6a16bf1ceff91b151a8e9f789f267f24b36868f534c1bb89de5f9e84b0c13bed8307829f27518f3e55089b01d2c269df2033f363aba80ace27e6995a30d3e30396890b6e7f17828ac676c353651c2e3ca787769813b4f57da9b6dea3d05597bd0458249686ca652cf0c4f2acc96970d2f9f13ba23c780db1689df944e0bdfc2dcbb68b72d033b75571512eaf629e6f01da41b765c22bc3a0d6ef447ea0eb3302e3870586d69d28c96c971f7c50aba4c68ee247d33adfc8b6ba481362a0f56d361b8bd21863df0aa8189d7a4fc4275f887790f5373446b867dfbc3c32b0d58735e42405a30453465a95f1ed54a796248fbec0078c11c9395a64532cbcf0c0a73303ca394612da353c270adf72f537d4dab5b6d05e74722fc7dfe9552f90b45cdcf87f977c9afdc63c38d00dba41fcc25ca17d247865b39be47be4abbfb02c23d2449edf044e6f0909093dae74d6ea72a3bc827758d08bf28e4041cdaab0445ecfc1a1b172f56fa2dd2cbce0e6163bc7933ba90a64c88e07b04491aacfb0c73b60a2be2f02b85ca3a92dc44761808cc1dd259d818f894dac954f112324101e128cd2bacdb699f36459dccf9c3bf0f463892201c6812d50d52ebcbb8f58501880291b699bba350418da905ef344283b9a2876b470d67a7838593254c19ed048940fb060d631ace82cfceb1b28dab324c7efb8803429b57c2fe2396de62aa047519ed916eab98371bc2d3ada1cc223acd07ca4633a044f4c584e3c566f8b30420c861f102377d35b955b37541c323186f751e6ebdd27517340811def08f9a0e2012746c2ce0ea4850a5097806452140ad9f9cc678d7b1606462ea188ae557007266fdda1e1436c7badbc3f567cba9d7858efd005fe32b74e7573d5913a91202ea2380ce2d4c4a99599b7193b6ec7147b6b7db624d570d957094268cbc48e009e109a455ac4474d0f97ab2b5acc95bc26566e702acd6dc3cc6007575d2a2930a878f4d5ff53d8536b50b8d83fa2e4ad7a915bc4a6726d14f3069aa9055289901673a048a2566c30e1b5c94fe10feda3e651fb69508f77f9785768e10eae1b00aeab17ad8d6eb4bd52a82f77065875278197df4abb559612727a2d626670348045a3da98c11b65eb43a16e9b85b447f16562bbb538de1aeee5f8c8d45d1875809933358d72f89788d1cd3043a079e96b2c2d970ecc776c91200cddb66e675860479f5de3f33f6bd3dc68a6da04dd8ff30e267cb6eda5685a050a2101a36f3340a5a4896cc9b8d169f58a477b07f827b083530dae8cd5a39e25a385d342cc105064d2d828be37bf6f9415d83994a2b7849507eccd7caec1bc133a45040c59e100ab3bdded9f16d1669ae9bacdd268fa3de3f08f89b41cdad79683c3abda8bccc0d8af0b2d11ac52ec28e21b5826fc9089adae20c46043c2e910b3cff40a49ccf0a9b580b1ed6494b35b2940dba9d2275ee019f9844b95ce9f6ae1ab951207383047e256e865415c8350030cbf4946579df51f1b2f4203f3f70823419220a5249090243fea78ad2abbec7985af23bcb359c248bbbff5f503a8bb4a984342baae504065fade7c97ed88dae461b3c9474ca4f3d3dadada04ed3589eff748f3d14b10031eabdd0fccb698f726d0076eb5fc424b2a23fccfeb6dc032582f589d3e16a05baecaa7eb7e27e8504a48c2acbf87c3cd7dfeaddabbc192282d98e18341241092faac05740c6f4f9ec79ce60a32eba44d6147642dcee56660ec97f98b5a1970275a6d41f6e89e3ccfbf20b8843f58f210b1cc25f6bc0dc393c27790770f6a50dc8d0a497e37579b02f6c10753cfbc40aaf0d79489523c21ec0464c1621529e04afa505eb82e61a87ad4b7eb41aa6ea571d2180c56f1d4936f414e6c61763de0928f0489055ae9c396c275bbf25cb26a2fe6df8652d91a5e5f72a01210096c008b1eafe1d6955aa6f7e25b739e380f8bb313f39dc4fcc1628783503c802006608fc138e1196c8483917739d31ba8be363befb92eaef4caba108681d5ca6f6060254f9667bcc4c78573789dc71b35be17762746657291862a4e511618db938330a0e050341f23ac0b1bb960d788ea505eab345bc53b14a5169983ed7ec2411c80fd65b43634daa0ae2edff9e2abf94125a458ebdd2baf54a4b8d99b785c11ba40c2eeeec5be1f2142e6242c12cf8aa5de21a4c5879b79987ba2bc50e99988cea01b31f440cad3aaa5edd3fec7d34414997d4713f15c31484205e41b66dd9939a0e1bc397395d1d0413889d16e4292e77b7ebc3d22266111de6372dcd6b833c8a0f136ed57e5832034be42e449449c2c22081f14ce71b6f431947b2796625a8ab034d123aeb28c0b0e2e9ccda66aa1820f73bd0dd255940b0464dc9c1eb5094aa0f41c2a2f9e71c202cbdd49274322de5fe885b0842cfe2f8ed78697029280d2301d4b7adf30690195f205d4a8e195b3d4885703d861da43624486c2e098f0c990e8cbed555405bc297d4b35ba62e931ee7afcb154d1724fcdd4f522178759d8e0aa0faffa4b57b2bf7b14654b98bf47611e07c0fdc2989ffef8b731a8e8a0676019871080f30c7e1aa4ef9fd5bc3fdef13bd54a78d52a86a80d3efcfb0b90f560044076165d07964a084c7464c8566019b050797cdf99440e3ce805a86993cc70f37aed66d2c4a16a337301d85b450c597ef5b7ee73892d1f22bcf65559683dd0a0bcd990a34074fd3989f2be64f178ea3f332c05ea6f2a9484d6f67141d3f620a2b1ba305b07cf3f362080847f6b8cd78f218972ae9968a030bdd205e87f0c1007930c6f8b62667f8b0065626642124304de4556cf37dcfa5f3ae90ed434df4028462adefadf6bf3937f26bf9f53bc2750a4b8b4187a946401f5944ba11fd1a0b8128384fa6a84a35988c9b596760dfe1ee4f988cd87209b86cfe4fc8c3e5fb0ea6544ae7190084298c94dcb4d5af201a1d09e14156d940f290d279f6b95f7000d4e35c2c3183b47a75d43a4beee7df44fb1b7f7eea2d17c99e6987674079bf0da795b73fee0f0fb3b8cd3574044a291dfa32383f9d3d6f4155121cb1223d700bab129fe0bc3fcd4b689607b599b8e9300d4c0412c131112341f2c046cbfdaa020f19cc980ca7b460de773823407da3cbe94328bc9d469164a4ea23dcdb0c590490fabd1af3117efa5a4c2f8a281a9134cefebb7b5f247658ad1114f932a0b10405513dbab0a7b95d7635e1d32d760e79fb1b78584423b1eccead0ec8796b21026671f41874f78f1af4be5a4d6ccd278ed9794578d5fd89fd65623ae9b2f1810ca56624dd8bb42ef2c4da375844ce15ed809995def07a59737d20448e174464071f007f64e8b1915271a1255520407c5b773e327eeeab4054e2562b8f37a6ed008f81a2c36c1de80cb94e112bf77e8ddf8a2af5564ccd52203c2bf9e1a4c3d20658cdf064e2e925efc3d323d53d1d0b537364adf8c9fa0f203d9fa5150122b408edce8ba0b26b5e3f2218c26645e1fbe23bdf6eb1665be66532fd2293f810550ab2caf122f0ca47b69c352626a648f16ff8653a63b259b6159b5d1f3c12f5cc038b71ddaa4897cb55ce8f1a061bd0332ff03f4359efc06209ea40d36217f3ef0b5fdd4f15768bd0beb43e5cb06373adcdf15c4847c90c61cd3b34df497b9ad2093818bbda5389472bcb3243c574e09e75c1166d44eb41b32f61d293fe29262705c8a25601700f09af22b8e2d1f60c8058b2bfc982b43138e05973939446127102d1fef9a4f9709a779732481bebdf2eecca243728cbdf5f1daf9a5f33815b390bc214b989697999829f3d79350971c735bdc9c570498627ef331f8e8e30031a05c0f0aa4f2737347429aad86add2d6c1f468319b1b2b1261cd6263e11c458ac0073784e2a0f997fdfc83b73dac58aefcba9a0bb908a11a512e0b7beec68c7300f2d7e957d52f930717c3ec86875ae0b176a38b51569c2564dc63029d39117dd0a6597b29d05b28c838fd8b1f1b60eba8892b6f08cec268d62d6792a1f4287ac0814151d5684a8c14a5b5a6a52103febc131477f5428b3a8bdc63632c589b30007d48bc293767b5c39dd9c9c11373350841eb6741d68d8adc750bd6f7c23321805a0a5cdfe382d6010c9646a2bf89a0bf0d7c17b0b06b925da2728041223d2f50f907690479c47f2162ea03684fbc0cf0eb7815dc0d214a2b74ac44073bee01707f3faf40a7b9297553f930f6839420dad52f9783aa7b67df9354366ec80c36b09168a38e1902d7a7a20201a611464a5baddb7772eb581d03d2859a151bc6e5e093adbabde1ed83b16b19bbffaf6204b39bf986bc2dac250f41055f0b53bf99800dfe808a6a8f9cb82b4d859a2c50172d28f6931cf120def44082968afe694060cbe07d4d04b7209bf42ddb99b180cc7c4e44559e833603b2ac48b0b7a39293609af6a4083d0e5ab1402bd198d7126bec0ab4404e00ee89f44f84639f687cd670d3e905652fda2cc0d58700129a9790d54cdfc00b09fc60f87a145a80ad24b0c074a332856f7ed4d67ca263edd97339204e419c7760d676d582bd55cbc98c38a0f5b13fea372d333e769819e201e1016e288552c2908098bf507e242dfbf5246019f43db756cc42fc35949572c6ea939b4264e1464e1d9bd8fa2056edc7ac12403511fdc2bfe2cef58577d67e46cc315ecf313e08d39c460f1a94c06eec195530dcadb07b7ef195131d91c169881d5454aef609e9f4696b97b4a89a7efb605160aebdc7da5cb8b4be990b59336ad387a473284b9bf64bbfaf3743bb1f85372ab0dd9985cbd2a7448c3e183db19e817651ba851e6c52e404d1d4bac995f5d54fd089d84c5bb155e9704c6eb974beee7a8a4e3f742eb1ecd3d677ad59e2873ed0300a5d8f1f8437a3f5e3a76de14a8fcd40fd72bea3fb69226f16bf9ccaa7f0f2e00587d78b3c500ed75de037195fed5a4e7c51a3538dbcacb410ad5f053acf64f0e9e8792229117920eebee055657a1fa1f05a0b6bcebb33cbbfeea8f1165c2c80173a39f34bbf96eda5790eb79fb2aeda01ad536a56baf9844c86cc07560e0cd0b09ef6b990de4fcd4762cd7e5728d8f0c51f57472a7881cbbbb11c7b447335a0d2cd70f6415dff6dd7567ba2c09d13dbfa9b6cd6452bb51948b8546ba721fa00351189e733f9a8009bbc3fc330df34cc3dca05e075e312dcc7b96522b8b68b9017975595555d71e69a1716864117f8e647d75f40f46181d04a398333490507904f449fa5282ffc692d711159ab3167ad411a7db2a530b809ccbdc63af71b259059b37685091d835c0765287fded1f1c9f4c8a9a7b3372613bbf587db0ceb94e0e7391af31364b5b2c157be07e17e978a04676d4f82e2d75298928c6a0e9b8a9023167b5569eab244dcbbc7bc43698e95a0568dbdc710555690d46fba64c4984015c52b969a826cb41869acf4fb269c114521e78f6dd88f020b499a04efab5a405cdff137eab692e88d1949a21b2541f3939b9221e7d24a1b15ac0250439d12004c2d33495e34806b61a540bf7ececa76083311c9d2594b421d9aed5fdca9f1e04b34a3ae833cc1a7e9bd2c8acf8761f0f0651f7ed7e0f8b7f4404d41d55d1e50db6084da5864fe3c3469d63efc2953a08ba9bf26bb51530beeb82ece8b2d1f70db02a450edd2c0c8c804b2a7c1f7677834436c45faa4fd18998edd0662890770ad1b71092c00fb8cf48ef0ed3a2dae709d5b3ead6f5bd58b852699145103d39058e543d5f2446b3036064219d8df90a5ae47709aec667e4d5f4162eaf62d89803716890329e914a680b8d57e4db332b1214208d33ad71c4161d6787433583c006b6875d98a86b8a466a95a8865f7f38552b30b7adfbc80b8b323c11d45c2a7e045aab4ab102db4dd13103bcc1c3d49f70392341de531271469700c0eaf4808e099bd4114f75d3da96a213761b532e1d7ed6289b7efd57a74d13ac77946061350d515b47f21bfadcdf74682762bbc36f33a82b939455992fd916ac5fa8f44ce50e866e3e3fb400d2bbf32d02d37caa0536525b787340e60a8e7d6d9f574945950ac37325203b76c923b62acacf2b493d36f1228388b6521811856937106c936003434c10688f2734a4a0ac23823de434903da0e3f6c979c820ec44b0dd99c9200e60c92a602853e1206c489a9ab8846484a783af39a007a3c9c6bd3cae77041803cfd9bcf1b6835f5ef05ec87e8ae9d2ee9630a4e0213524963385960accf5620fa183a82038b2e38a6e2d2a7f8f6ca91b29972c65f0f7774b13dd7a77a13f6e0abb012767ca98c4837a78de52b2d23c48132f4511b7459bf046b725e82fb5b20b3478f6313d396a1e756d3124bb7ac04950ee216da5aa8273b2a23124b3a7020e17752af63c5d01a37e28029e1f42b505e8f00e31b2a3a0dc40323b7f59a9bb0c557203b65ab35a844505fc200904716e855e84b6691fab89a81451434e089e0db1a4f00184320687cefac50fe65736067ac243e7fd6005234492cadc8c46b50654e292811aa1a7bf133fc078ee56d2f6359b71ef6e9ebf18d7cac23533e8c80ed0c51092306c3125fda76a6a7a5abe866f834206cd93a7611ee959338819880320d968b0f654134d5ab9885c475cafbd7d272413a236ea218e85309db7c1da00ef6680db8ada950ca1badffc14bf74e4b3cb5544e531185df2be7a81a3ef2e07d34b7a13afd4f67470ef4cf19d822d260befa8071973ec991b581e02d1b2230b2b578d4d8120f4547bd3d32392f9c528161be688e2230be053caea0ba43a2a032f0728ce8b8b09a6357e1bcc8177b8bf230157677dcc4b3f875649ecb67c320f9f431ca7e50ed4e3b8da11337864a564d9eb004eed843e32869163df63bf3706a57aa13ee105dc426fec974ed20ed812035748c96f1c430e056792fa70bce305dd24008e2947becea471f7f98e49b6c88761f42d2a13678575f3e1cf93603607f9566cde710f0e9bc2af6a5650ff337cb43a1c636fbf338e636880c8146a9d06e9c64accf09174f3edf0841741807bcab477e0379f2d4cfe6061a4ef6e33ed0dd994f3f81bf64ec9209f5bd4dd709f8ee151fae0a7eb9ca062b24521cf50620e67e111b22eca81cece432204c2165de748dcef63379ee2a1a828ca19e4a31e02491b07b263a2014c19abe25aa3f2994a681732d5eaea7096873db0ee862fc605788c85d9a8fcccfe2aeecbd4da6a4a732296c1ce3faf37762c064b29142458073761666f7640b7fe4ad0b01677170237cde50d362466b8e415e942790ad5530592e5d6c6fab373ef26b0716c28838a680d1b43404708a989a72316378a37a9066baba55036d2d0afe65e37214efbe03455c4d81ebf00d39866d547e2aef2530a91d5f5a5e07de2267da29379b89d42c0f7aed454d8176a283da8ae6e06717a006b97b210b8e652e85467f9ead55c711231fe0eb7e15fe52ffaacf111ffa8c9003935f580520442e21421597c381f9ce5961e275d599f6f82983504524718da0b626eaf03a12f61efefc764198ad3d58bad84cc04aa01d87f447b2e46ff229a04964dc55c173754fe4fb7bdfde56e9ec6963729f614f11f4c1cc662d440ccb60252105ae12bb060500344a8b2b862007b46b978c263a04ea1a58facd51293a60780916edc57bcf90031ead665140acb518acd36c538883ef0f542954b56fac50a4e4a77a23f61f8628e14685adc3834201c9e539912d7f03b931ea107e03c600f633985aa901d3d0f471f0f90de5986bc0178dde5a9840f31d9f5ab0d5a4de50f02dd50914096f8c6a4ecfa132cb510e24ad5e40bc43a73f7df623e7380b2c50cddb51ebb0cb836f32bcbb82ad44b7bfdcedf98124d6601a807aebd948aeb7a0b9ef7a36e509dcab6b45fb23bf6a063de51e81922fe8db8a7120e62a04499e20bea17ecc1a842b7c334525ce94ca10d281ea8368af35d68605a4a7875b4d41b0a6dcdfaad998def6fb021563ef0d539aadf42e99387d275e84426546406e20a0e202fd577784c50cec4ba4ead7027ef019bec5c3d01fa83a2fded61950bafcf0bfb0d38fc254dd76e9abae7c596986af74a9edbd531ba8e316b6200b4b1f34b040a1cb1863321470f0d4fb431eb204aa7083a88ee0758b609b463c332d422250c10951dc2b93e33077b2dc7356a4e189147528017fecda2bd0713b19bdabdf806d5dcba47373f6dcb5699e6c27cfa6393fae3c87ac33647c5085fb1f6f66eb603214446580501135a222de42a204985b796fe61708536c088ec6f13c58c06b90d9227f160e13e423e4922b7fe4d6d12d509623bc302cc4642cdc18ac93083f908a4e0c358294a228adecc96c7fca9efc6cdcb2d49f33feb0a47128d12973f3c0e53b13ba9dfdc4749521a6ff840a782eb3d2ee519f2c0dd19ecb5c40659e87705546bff3ccf8a90107eccd3ee3dda149ecb55b4ed7b1623bf99489388004a6204085a1611b0d7850bfc899ecff0ad50c72d72a4fc21c4c427625e6a376838a90e1dff1af84853e4a3ad143c56f53e224b8112d2b719332f39e77b757891a923025d44e201ac1f746cd400c37ddcb7b0b154701643d00ae1d883765e276bc1f20daf2548080f5d8119252a5a920f6477ffbe36948b45d2123c1ee9f95b15f0300131d82eabb31829383fa2f78c033ce83da02e47ccf0d5a2a131d81db1736b9d0962902f849a0f363873b10d31ae4721fb39c33188364f45652d2185983f31740ec1718b57bbe1668cc1cc426e77ccc0888bd3b969600e2ace0828acb09101f809fdbdacb3dc324187ed915512aeedcfdb90842544470a548f79d8917e03d2970df7561092aa399a386bc44ac4426f096ac945ff18a0267402017fe77ce8e79b0591597fbee8e154addd2510640de58d176052cbb85f271a210c52219797930c056712e5ff133afe9c0e8cd14fe8d333f01b656534612ce9c7ae0c14a7f8f8f506471b0be8e432d99ea0d9918321434c6bc0865ca04cc9880d6ac278a631202900413fa6e3ce882c94866655de4e9c83303ebc1f063e644d6d0dba18efb77be706cadc958b561e99e989496e7e9ea10df710a80c2e5062c2683a39547e7306150042aaf85f764a04b93513e493753ce9235aa97e366124c1005e9a99a613b7d700103d9310a0cbc424328816971c3f74be77587b40461f343c15e4a63206e9f50d19ba1915af1ba23bb85e4c4cb7e0b432474e1fa17f5312166eca5478f965df07f0f14cbac333722dbeefc7e04608c983e007fd407caa6eb554aac7ebf4b7ed08a889dd8cb3a852921768dd99743d2dc676aa47ab15ee14038efdd3ed3bc4dd0b2ec0b41f0258165844b6925a2bd40fb3cd8b8e710f2c53e53cb24882d383030925134668383ec4d94d2cf0a81eca84f027c8e8c1109416a0e2c059d6e30a9c04156e405574362c8ecb7bfbe18dce066a6dd9cf0fab10d15dcc00bc82e5d15100c09aa6afddf4fdb053abb3cf3be9ba9d2ff22e427e3a993952dfe56a56991e0ed0822150d63f7193481d74421f0bae4209ead583ff65e0561d7dcc4a4057380981de0f312d43fe1cfc5e70c4bff10ade8f30a1a4ebdd1630ad6bf62d685930079a47155c2ad649c21dbfcefeceb21e836d19185152345ac0a9df6507229e430e3bed8edf615f5d69adbb3901255e4d6262a572e6c6de8eb6878a6c45684da7074855f36401bf2c065396ef8b56203461a9bf897e18ef765298a0dfb5427e75082dcfad26b58e5893abf555af76e6b3fe2ebdc897fbab0dad8bbadb47dbe12f084a8444fb1806587300e9950c1e6c8149d91d6125ee68627292a4f81d84b3180a1ffc58ec2dc316c17cc92bea1fec93fbfd5a494cbcf3d50b4bccabba6709a2055cc2739bb22119dbddef748a5222916e6782a517a900702a1412dbd7662464041a8d4bc9d2dfe24c0e76f42993375dd81f2076046d791a51b492242521dce60869f7306e5e8a4879cdbb19f70ea492fcdbd69cf2b3bd3fe5e84b972ee670d207f94c1b4fe062afcf89cc0575a2c4b0d42eb861046d80d8e5af5ad9481f0acb0a4004deadc80cac69cdb3959881e4e92568f037d38df2aadfa24bc9d9d9338008e07111ebaa0c04c6cf4cd108014b581f1ceded64747f915f3bbc6afcbfac2100b80d6e9ed236072d6104a76b60ee04195fd9ea3a2a3bab914ceb29e656d6bc01ba0548a2971fbc1b87d7f0ca900e1ef7a3a42ea8105f6ca8b4b0f51b0064a50fff938b6ce5ef72d953d9e67aa6802e896dfe94ce09d93bf696304850ab203105b66b200fc570985d1d8451de8f6ee6d63c9c2d4c2895c2449e48cd9a4030dd0ac8df6517db3f160a67a5d996b2a05a94719fe02cfba2ef4401d5249d73cf680147784c5d5c281cde88c4803a47fd8806f54645c255317da8ddae943e4bab3602684a7cb0f3a11817ab50b85968696e894643f4aea7f69c337a64bc586d6dab00e4ae58e8e0db1e3072ed2559744f1395bd3f4e49f88b4589acf8c0c525e2b4067806118f05ce9d46d744fc70d92563861d436ef652bf1a8d5b01ad376416a70f232bff8c8c77099c3bbddc8ac7780e9d9f1f63d84740f50314474887089e830715dd24460a4d196352242a244d32e2b8d3273b11fef23eadc4efb73a27ea720b81fee022d1d042ea19318346f86b91d264aaed6131e1f0a974b18eff45d87806afc882a0c05bbb93e463fe8d75ce58b01e9062bbbe4bf0f27a609ed46977be0cd3e0d79fbf4bbb96ec9feb03885d5294f082e9b736766a6253517bb538233c02571696a978d0534e0322b563739b36abb3d65e22ccecca74c070ef54d4e0920fd5d7227f73d7d269b437a1e3dd12132f9e3093baf02712b6b5bff937109bfc0267bb9043e04259184feb4c41f01edc6f08a73bb8d57114ac45cb4256c6a52f07d41fef0419af299a9f731c3f6da1f49836b7035e727583182ec0b388e8b6770d632d398c7ef3b0ba9604b71c5e8f6e5cb54279d88bb18d09b126c88df60013024f05d2fc8fef33e159d88c85f2f6c95a671bbb7616fefdfd30163a6a1c0047020ceea82317a3a9d0526d9217f20511b09cbf7330637454766656f01f2ae0f40c1e3866505e57e63ec6d8dbdbd49637ed83ccba9539b8f6807d60485f659e5a03375cfa189dc0ac43862d1a0e929baabd9417df83fc26f583a1190d2ec3371c0bc2a8ac184ccd54d7192b208821b9e57e26ca63293e24041f509dc25d6248e00b3cd38c6bc53fa6687e755147c41ad4f899b4e4939cb457d88a02c7fd0d528c0ace67513b578b9c73d20f005e8ecdb6fef4196ac3c4fd5836c95fac90e1e74d038c5b3d854bd919adc219bf1960a92b6955c802bccb738ea18839b8de75095d07634fe71b99bd99353fe4c2afab14faa0bdab725d2d03a0ffe708ed067bd0a906b5f31078d0cf5f0efc02f76a407679e68f9d71b821ec38369841f9bdfc204103f2fcac59748e9e7e50345c413724d55e5e6d4e5382373803bd673e09d5911406cf77f16dde3f51bc38aa52ed96658021b3457a6370df83ef2975234277ac460f89288fb202d527ef20b538ac84cad474135ae0d2ae186cd92e08e204f3966d0373b1c92ad91199ca79f162bd692f32952a4b63586c2f1fe4f7487b09b0b5300cf90c48f722fe9a89d8b258ee0a7b79535b92c44431af543f87653fa719d1fa01ec01f3516f97f28fc6510e6ef37183a0e252837e2cf44623c57475fab14ef7009b9bae776aaeb8955be08178baf91005ccb0fe5a89f1db869db10c894e438605f0f59bd025c1aa5e13cd9051b0026681eeace61b03f5e98618fe0406a42ba900f7a67d80095136ccb56dea80b5295a07a660532a8a93816a1c9f4b03bb54e50c92ec2f97076fba0802b2f67138747dbc6403755704aed02f90b9be03ff9ba3001874bc9728b820ea30401dfba7a28bab2b46bf8322ab598ebbd3213df4feda01a7ee74a931c70babc7121126252bb18e7ccec55b5cbd09fc5cbbe3a9f43a1d026493db5d214092dfa6dc3f40bd1c785239fcde7a406b0b15b6b5446af06d920b831235d8afefff77a24ece5aa0d59a30ff6eaad89303700c0a887ba04b478c07fd50d89089d37bf8ce28ad04bba065a4c315bd0ecf6162d705321daa59bef6056dfea3b6bac248d3031b12e8deacc6255573a483bd30c60566c81a51b526100aa3b1583fa2dfcff1e218551eea7bb46a5731ba5dfe81bf8b748cc1af662c0009539286e657963b6ec6aa544d3296c6a0e145736edbfce45035971633054a1c0be11501fe1fe156421050786818de061343f0dd1114baee5813728eb6be77070be0994de519177bef014e058951c9452cb2a16768c7c596563ebf3f94d304580398acc09885baceb06f6b4e46a7e0e1e1d26a9c534a4e174c2f57ad09db767a0ddb7a2aeb08ff40c25ab57c260822bb3ea521966ffcef95b2fc859d60cccdfd0a226e26962302e5235942d868aa1d3f71bba90b5ad50464229f0b5681367ffe0301d5a2e6edadd8c6ebb2f32970393d3ee0a488d7d63d7260c7bf91472c156f01144f1efc8305dfaaa3594597854e58b5b82db50d1317d3d54ee76c164ed421049779de4b9f5472bdb64b7e229cff90be68f4f44a0ab8ce33a201d194d12a320d1b88423c218c969daa4c28f89d2b34fc7c6b113255ccb96cb59bd2e9ef90a708fa3151e5148782aa4caaad6db716206e59add06d960abe16d0d9f45bd4dd0e01c7b6c13ff95c3a2c243009be5f6cfdf66b8e487f7b80313cfded2b0b10c43b07b39cbd1e9c23a58128a9df1621330e859e93557e063de1e1d3b602e87058a90aed27121ae8a69585e71db79dc7a8480a4c418f5189258b71c7789208e675ca053d0f338be0d7842bfffe34a29fb382599555af2aa9d47f3d90af7724259942048e35c35625370f19e8af84c888efafc4c80fd5311b49a58905c64c4249ff4f011b51b7ff506f49b198bf029d11dccfa03c82c591867a1fc977311fadc371d8016f276572308590477d0aadb1e8a0c46d2b9c85906852bda7a22e3e62903f8b08c61b8f6b532a262c2107e1a69aeabb138965ebcf18f2317563a721bf56d4c8011ff6731ecd3d18c5b087374bbc570ca56bdc39e0e754f15f0bbcf14db9f0530d041e7f278c7d4dc0495f1ccf7a5f2b1f1789a0df6afe67f81d2ad017fe019a062b3f3cebf20ee8e365eb6bfb4e0c13737240563b47c5cdd6c0c2b000cfeb620b29acf850042ad92b94e4f4ce0a02b9af8cbad7c4f8e9808454169b106807fa0c61c6ba485a48f72c4c4ca9fd8fe899590bd53a822cdac461d4dd49ac97c08f0aa7b797c7df3247ad94ea19d5e294bada9db6484ea1691b2bbf268935a3fdb00c28e3c21537cb55d8eb338ebd645dbc6dd90d219909ab84d40578503a8067be04bdadfc60673fa215c255deccf5d62a21c55a5d5409005d6c8861c177194d2709f1949721d852b3f312af4a90df8c836f522ab1a15a1f52e8dd2d5af232ae8b048eaa11aefac655741c1c43e409b056cfb7b57389dbe5757ebb257b1e893d77053d0cc72e57a2f09cffb95d5e5c977916d55fa9bbc0813d0dea461d625944a10790ca5ac444adf7ef5bdd11f80410cd72edd0009edbe8bad937e31bface4dc000615b86ab6ab7166373ee4876e2b3e045c63f3f38f73dcc626ab7d78e8d119009b192268d0bca199fb9e9aa9e79b290ccfe68bab084b3ed650863264b61468a050ed2be1f95d50bb8aef980045de3e890df09bc99d1d5626770909b9bf30ba60ef218db361ce52fe35ce465e1c1bd645c562f4283a34337e66ea59fe8598f080fbafcee3143eb63336bb922444a8c5f01524e5e7ae124b756e269ecf7fef6d005d05d779ec3eeadbcb4271cfedc362751ad1d29184391b781a97e8e13d5dc6c07b6920888e659a4c9d7f21674eb66302f691fceec18db56fcc1ba05244512e309d72d8d9b69c8147060b35a4c37af5c837e803055d39f8771c409ef0c98139603768425e938722205422aecb0ef8ef16dce1db6c7c524f2b1d477d28392a5b2021a4bd0db9ab94ed10e93edc2c35fd9e39920d25af938999a2729fb29a6079e0bc01f83efe3b573b20d36245691448fe42f96db872cdb961330468c5222d1f0063c0649397f7a9df9266428a8bb3bb9f9c7b99903f5c1bcb75744d1a72beca904b95bfef8865133586d57e939fe293ff0296eb33659e21d0d8c1d60aa807c6a09442d621a15a90d72b3ad6bce7ea8583a082b9a334492c1277023aa033979760eeeb0682068e1dc3a88e55c67fcd3420320905b9d11233d60a9acb35c7a24cc04a67ce0516b9755ab98f30317a5cd2e56c96c2fe5253966a69b8629559564450b75dfb1bad2204dc83e31f55f665f0941e2477b995a10c140ecd9fb2352003d02054d21ab5605ada8df8cea8cf02e1830db95134ebdc9e7d856107ea59bb5c306e0071bb5bbc8cd6430c26947b1ed84154ec748db3eac15822fed8e9202ea1806777227649f40b09e729f3d0f8ee42c4876a135e074e13e8a5e3b039f740d030f141eec2ca1ae79a341d55516d182538a239ac49aec267178c77fcb5b3062950a3bf23d4883ee196375c0f930e1899c74dcb59ab89cb7758e66aa15c84a8c1602a7b8101741d8d61958598ff386640cd80cd947c91012f266e038c3ee79e74d0b548772420cc6c5780609fab7dc8216f63f7c23505c46cd34f40f5bb188b6d905aa9809a4937bbec9606e03bae8a870c89f40bde6c739237f281ae1451f75d3075e60148fefce384997e55f12724e73ef42bb4ba1bbbd571c7b4b46121590df0eff1e04550c6d3878de253c37a3324ecb4105bf77742a025f40c74753a6798301803a30bebdc52a3a0403776a79b296effbbcd53a806f30dc0aa8ef49e27f530ce32a2cfe58d96494498222a3883ccfb3ff42fa7a8b890a8c37b72f04df5cea06c13c4c043c4e5702dde83a2cc86504fcad025dab2095d1ec7683b94535ddd807d88a71b806f88ff2291506aed864e8e10fe127f428b0d516a9cee2a479930c046b2148d1ff1e02713557f8f478d63fa821a08779137f19a51b2d44b78f32c609212130630bfcf6de08344a58893bfb6ace834889311872f1777b0ef103688e0c00863dfd0a3996dcbc4a34cf7b4d500ef65ece78c62d32811827f6e1c84fe70c6ded2ea461d20d9b8ad711ba0941036faae6e557e6472d30be26dff423973302e14712c3b7b73c4c6f6c9ea9c402d02ae25e172c626ebb9026cb618917f440009305c1e60d210603cff7f5410217743eb5dd1a105a99b21eb8e9ba58286a5808fd07c9aee216fd0c32686ed4eb080b579f881b535860d8d0cd6361a33234e00f true +check_ring_signature 02e5a0cb838c3e8e672eb2b39d71117ee4d755ab7000ea37f9277dac2881538d ff9da19da8f14014a94c44b66ecedf645fa4b643f688c7ec6307319ee2568535 6 7e10f50fd05e3c1662e225311b9215dbdc6a1adc7f1051649e7209e697a0f6c2 41bd1289442583f2ea327f08e977303bac6d77f36bbfd912fef0962571591d4d 3af331555a34b78dd21f18dced21836eeff48a89caa9f302bb7946918df3db88 ea237c0841397fda972c4962161913f64e42f1c9e4095d98021762ebe849dae5 441436c44135c6c5042154d7f7e74bc84c349432906cd53fd0edb2d4202e93df 1fd964ae0d324b4e7c16e858dccfc8a3e8d03d58e3b572d07eba1f0fb1a8c3df f498ec3a8a12de34e88d78fc9b24469d279a2f9f3e55addc1b653836ff0f740b6e4ef1f79dd27802b511ff62027187d813bead31fdb7c95adbd93cb749eb23088eba964a2127be94c8c0296a4958b31b91a42481ee797859a316fb9e776f5c035f1a9e613dabc70e719471518e8a1e4f8dafa25c08e4471f448e1cf56191760e1e815a3d78b4698df46c4d3b0a2095b7df76e9c30c218db608e1af267797da0d1c03b2df95aaea282d52b6208ea0283bd78b9bec23bc3f182f166eb2be4b1a08bfa4370ab578d1baec0db3204b24eea3054058f7a9ce2ad0a668774a01685b03abc816b1417bde51011019b1ab4e87c4d00499818cd36799f05316ee83fbcd08e5a80990f2431acef7a2ef6f993443cc2df2a34487c4e876d528557d621725080819b40875f7d59453acb77a8445f234bb9875a28fae6c0fc11675ffae5ee30e356c77a3fb265486df610f0c6d589deb71b5e229617b2daa1c9b09865f1f1b0357e4f1af3f1963368f1d794e9d11e0fc48a476b05dfb7d4bd3d033a0a6958a07 true +check_ring_signature 99f5c5074937c09a2a7e4a952fb47d1592f634f0c075fb37f325e691a5e40b5f be84aa7e42a17e2b9b89a8c9803026088ef6cf576a839563f22b4553f4713a63 14 a0943e8f1b94116d49da3256cdd6b063abaee1b3f686122b7bd5b4d67f4ea6dd eec962a2779719236c2351f092d36dd4505821ecacad80b823059d666a2afe9b e9c2210047b9800621e20fb623e146db62a2454c607ae9492ee8ea7b1e975e51 dc00d40fcbc184f480762d6b88d1a47304899b4663ef40490dfc38269ed1f3a1 f0842bed3ed550e02ab44468c6d9d1e7456c5e2d3ba160fa8496d8480eb49e7c f7ff392b77ead34359164bd6afd5452cca49ecdcc8a4f16403d3cbdaba772efc 52e3b551445f8cf1cb509477d3c6449ead2e88d98517e6db80fc50d0fa220781 d9c1116501dd329476a62ce4bf9af836b6682b194601bbc21386a3ce54050eaf 9468a8e9a42c4b19e1e14e3821a5697a81fd22efa0ea293118a547442ffdc1a6 e60ec26f2f740ae3261418b733baedfd1dbd9aa883a48b581dada1bfe8ac0e48 136c87cd493f36cd485c98bd65dea164146b7cdb7dddcebae5bed61cd9e1bddb b8a248fb3143992c26eb1dcfadadf211ae61d62169294d5c6932e8199a568b3c 97e33d0933b6cca933adf8b4d41b3d65e24de7f4bc6b15c0bc86ba62f26b4076 4430932ac184e57332063bf9b38453db595e38a9db8a13d78ce732cc55facc3c 5f07b2225f54d5ddd1e7e1ddc610f7939bafeb7dec92c227feb6743b21b14d0067e10c55042703683e7a5da98eac0605eef989c0dc8754a079ccfd7196cba506d6a553c265f869e3c733c59a45c94dd6816410706d82fd895ea55ce9085d6c012dde5cd9cae968db7707f2c88d7b67863926b10e4203fe2d35c42c18158b5806743d37eac3d9b446187b68a2d1c50a2906eef6b823d795f7695467dd5a14e003ed49e6ca17b2f9ec05240907fbad0b512336793072ec8f2c8dc09ffb0dc76002271aaad2cbbff00809591b023e69b20d10b3b6e313c966e81ad3f43185c4aa39550c56fad5dd6104c4d790228706cf1f65ce0673e51bc1b35761b3d681f61e0ffb094741d01ac53b6692d00f280def26fed45af99b369ed0e31c19e9e8420e0a237b34b627da1d1d3c7b22d7f6abf8b0b5c7cbbdd15b9ca6a166d7cd188a1b05ea6ddf4368f6cb38b50cc3c1e4da2ea904fa2f86f4f5e12b98ddea4bb09ce00ffae177a0cf6d3edd55c06aeb255f614928d0fa4a909bbb038782f8e02dba4903b05bd0cb9da7b97d12e2d23780049946ac24cfea125328003dc57f17af308d024e55b46b7101013c38d895c00adad9caf934b76fae87c6dc1cc73a07a08fb90dd7acf27a30b11a7514cc9c472a5dcf7f5cf1ccd0414541a552b163c6b5899c0967147a99dee20fd998e87610dd470f5ab994ea039dd307fbf57e6fca0f85191f6fb271b6efb041a1ef0f7877c6bf09915acd057b7e8d0ab4578d35e9dbdb8e000db94f02e1ff6ff0d07aba2ece2b72fb9603f5c900b9d2f497709ff4ce87b5e45438dea29f47144fed67f289f798d287e739fcb3f24e2feb4b2e26fa901a9a0145e676c373832841e48984499f95ab6f8daba6349b4ec859f5643eb42aebdf0a1a16a8bc6fa116103e30ac810b0160cc44b8f805e9c77c44c2b76309d17c770d311c0c5aeb9a7800beb89fc27111e0ccdde6fd17420db72a22c0cef3f592dca7523bddfe95781f84c3e6fd6f49113c05a87c0004418f592571b78459de71d909ea0ed55738a5d95e8d30c74ab5bfec6b2b44bad668d711b16e16126f74738f0fbf04022e542cbaa5dff9414798e099e03b052020215708c164dbca882e08080806314e296a2d0b24ba7e82e18eb1207a5e81ab698e4507bed51a70ad590fd6047c6fc21955d8123f15f0d2cf8e0b0fbde05252d53979ad8f403a220ebbe4c8046f840ab3b0ed37258d958caafbd83243bfd6e30d2da58c86b20d4442ad1cff02 false +check_ring_signature 5826388cbd3ad63cd719e455a77324f752680dfb415cb042deec9b8731bbc10e 44320f9d8b68652addc3755dfce78e2410f8a06238cdfb556cced60092e81c7e 1 4b57c4111f38e7b7efd5f083707ea952b51adeb52b9b110cf9288b8b5fd5e54c 52d2a4708fbcda411c998ffab90ddf47db8c4b330324d8db11e40adbf1667905f27c365122055151fe7d34fc519f21d7936c70814eea401c3fdf8e81172b5905 false +check_ring_signature 2b328fa53569d69ce8bcbde6a32d71e226d8e1aa39866a67074808def8f9a345 9824c30c6df2760a4444f9a5dc5ee9738394e72af9f65086272904a1a49e2a6b 1 59e65f9be96ec4eac61be96c876c14b32efc87e02dea8fdb29d015362da319e8 86402bc0c7edb82f13ab74eca869b956d580697c01b19917b1b35438a15fab0491bb7ba75e55828fcef00cbce345e1fba41b940ea442f6d66aa084f6938d6101 true +check_ring_signature 960f0b1bbf1406df89bea926b63315fa2261d4880e4337a877d579e1eb571f65 0f89faac68e644e45a194cfc605d552d383a7bef86045d104f92a70049bf7133 1 bef5e6e714854e7862886af8ba97e2d9030a79855e89f4e09215ba034f3b4d53 ed2bea658e8f1372263c839b7887a046f5b6feee394d16d39c51d7edbea9670af07e487f7719911ac19f7aa9a599fdd7fd385fcb156152d0c60637e80f224007 false +check_ring_signature 37f1ff61130210b49258bd10a06ea2cfc10c5830b7e5eaae386173d01e5fb3fe c6f6d944a4c564abd46a10e6fc98b3ed3bbc1b08403e174996d09644781d6b79 41 7c8cba033f6b10981e0f50b87ae304fb0ac63bccfb15d803f95562e1886293aa a34b0ced9264d84c807b013314544a189b493ae9f16843bbdc31ca28461d78d5 8d26c826e03f5aa49e040c22e8b240787260c33aa761f15e6b626dae7ee26838 e4ed551bb178edb5c7c2697ce0e5180309703a760fcf94403cf53804b6a23efc 9dfd91280a17a1f20ede08c78c78295ba49dccae55b10916c46dd09369a371dd c0a09f95895866ab3fe121a9fd451492f33f4a83bb0e4f21d596f18adf125aaf 0a76b4542b3bd70605e2cd496374971f7f9d30ac5eb6e6a05603873d75aecf38 250b9ef17dbf2247f821b31f64967fa5a4bc97fec91e3d22e5f8cdbe1d96710e 957e3e8dc2fee1980897d56f0d76fc7fc54b622f2af2af0511907eda36a61a3f 63ab2e0d155dfbea0bc4bc918348c4fcd43803e87bd361b7c11fb3b997d9f4ae 35aa7b6c171af253e35abf4873f225303c85835782f6ba3925b1153e27c7b2c4 6a1117340d9c9d772e319d6a25f067adea42563e176834f3c083495870d58521 b6a91c9111c139a8e8d6f4ae2602d694662e2fe3a251f6804526457b6f18f819 9f3d0929b9945c33fb7dc590494dae159d521b1a2b58b1a1afb3b44f7f095386 7502b85ddc669deb82096225bc796bfcdce9385c3226964d3f6ef751edbcd846 d7d12d0ce1a64a401db3d996e946d02d4229a782d9eb4f6f18fea73b22188e90 0b84739030209fd65c99f2a671a692e9602611a79bd4184f88441b29bb3b8490 a688e9f24411f3e240f06d0854fadff7a07e133e3c983f701cdd344b4a0f1618 cef3e77619117c10bc08496eef7c1def70d189bfc2fc1716d3e5439747472050 216a7663842ce845110f3bf02142e909a1571442269d3d9c7eef41dd0700ebd7 5642117dcb92ba1a823edf315194f495c75d1a7cff3f5a0eb58f67ea29fa4487 16fec02d47c71e47937243556f0af5c8a02b5391658efb227f270a7bee5c0b8b 47265c01b2999cc56389ab9ece1eb6476883242207c1c70d7d455eba372d6d31 d9c82520f823627922f2130daf5c89cf8894deb33e8a5df24e30c7b9257c258e c4f64e4f7809064d7ebf78c72c900ee4ad8f38de32741775a7ef88d1851892a2 ba5e06885597f3965751382a74cbfc5724bc2b65762e19c7a428d996e5305e22 6c1a4e817139af52356a3e2d90da1d75a47cb38e575874043adca2c328a5ff0a 5cc6d7d99d5bcd2f98ce140d77f85ac734595510c62f246b06eb415f13251046 e6a9db7dc897a0902ef014a2a58f5de6b401b7d9a7ad2221f7de4fc20df23da4 320cf3b9ea68dde3f9afcaf9d9b0938c78eec3abfc6ab732808ae6e3c20ccd70 a5eb65dba9b7f5fc046aa5343034e269fb0951790f292224583d9394e68744e8 abdc673528f3b000c6dcab43cea12023daacf32a60786ceae74e57a2e273577d 9461fc5c12e6655bde20267ea06fbd7e071d888897a1e8d9ebe0dcc6d7e2a3dc 7a07d57d8d553dab60dc8f8b884b2b61cd44c28570d7686fa26712f13a8e88e6 2161c85add05c551fbc2db04cf8c087f49a91180aa6cc7ae22004c8198468cb0 e3c6149381eb098a8709cafe0d1dd1b89918d04e6fff244ef308b68ffa3f8c0e 2a3848ffe332e10cda3d534339f55892576434f18be9118dfa98b24ee2ba2cd7 c45b958fdff1c882498e4b88bc7c5359473e1d97bb017acda1523b057f07dd4e 456c34cb0693436871d5f0dfa79304b34487b5866278a15c64bd234a4eaa678e 66744702c24638226879614783bfcc369b265a5b4f334f6e030a58e3b3e0214c f5dc70b735b71bafbfba96d5c466a4b463696897e9900c285061260e610c8f54 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 false +check_ring_signature 3944bbecf38169d73f4407bd00f243709ace7401d66efbff27228fb410bfcc9a 0d58900b050d30e20ce7ddce35cf3503ffe33113e3ed6503595118226cd6c17d 85 03a461a63ae96990a55ede19f05ee70e3adccc6e7f79fabab8cb9815b01ef8b0 05d82a7b26eb9424ceae67026371388b209029c0dff89aba74ca31a0d6ab02a5 9ccb91004019b462041721c36c78dda9837074c69b9d6258081dd755f014bd6b b025b8529e25098f63e413c97cd2852decc9a237041a4ddf4e991cc2704a5a07 2b3074d79094f3481d0a2977755f4c614e2a484bc1ca4787b83dbf302fc5a73f 67df945e62ceb6e3b485fa63d8a06b79bbb8e31ed9b027766b2a700c82b89f6b cb18c42f75d07b0b7fae7793bafee3edfa89fca4c39ae7ec8b72bddd9e7a6568 5526bd7d594cb7e6ad4f0762ddd6c27a31bca63799650326d50fb8adb2de2854 aaed7dcfb6c34f906ef7d93544c7ba1cdd7c8f669255593e04643409602e94e9 d97f0eba7faec85626dcee1b557161a4115bfdae884099b4ff75a46278ff8b02 6502a823cc9b40534e29fc754b6a7c463a05f49ed8e0cec0950138050f90639c a56296114bec470c933575b7580e4f85f07e678ab27b7927b36269cf98a7ca56 352528e77f8d4078de54c7a61eb7686b9a794ed59a3c59a1afe21361395494f4 d0ed7ff62cb44439a4327d801a09a334402703fcbc054b3141c8729379898a14 922d4476452f01f2298fad25547be160c7d38377b0fca2bc0ef14e9ec2d31d27 b86ca676e1766d6a86c2ea3c3cd2553fad9763bb14826591c6de5fbd33f0dfac cee6af7e09703bfbf7a8788d444770af20d30f62a4ddd6548be6c4eac7c44539 927ac8f524127b753a21e972d50b43059d34289f68396a0fa710a0b6b0c93255 81211e5100f99d918f6d9317a1bff6aab4b11e5bfd3fa52200eda5932acf2ecf 107bdb16f6a6c7b24268e82aa4f7cbed511e5f9d9ec967c77a9820720707c6fb a211f5360b1df3aae657ab9245db42fcb1f5dc0052c6655bbcc3cf7c2a0e5ee9 765119cee51c092c8ff9789aca24742c5f7453049f913dbfe3907a8e48c14c61 1b4e6f7422d13bd7e2c1ff99e7a9416d3596783d69ad106a48d6191f0e7d2580 b3c242995087b44e6ecaeeff24dbabbd4e3c7f64cf6a8da3a0018bfbb364671b 1d85c55eb4089c73c1d7d091f6acc3c4b57579cf24ab671d676b774b2fd92d47 3f8c52676c482ee1cf4f443fd688789a31b619cd3b30324ee1e65c70b0292efe d6975e89ee4147855c887caf4f53524bd2dd938e4f59ac7d2204448f99a30ef0 491d6b218abced0227165105e43c61ecdf96e1d0071283153b89ace3b2812379 819271bad851e7f86cdfc40e7bec2af465b5bb8a029c098193814c19e1c1d4a6 a81c95c513ad31ee11272817ece878e04e1a7337d7f6f9a65cce81cd887c9b10 066e2050bf39ea974691c64b27d96334f6b04330b0c297fc82740862a31f4e2a 670380121caa95a4df8504478964ddbc66df990e029059e3a6abb0974495d116 0048ebc5194e547b19b22a47b7ae046f9dbd690915f4c22b04c57c941645cbe9 f3bf7d12ce43538a0572a4fad3db2e4a30c58ac7dd53dfb71d77cbd523c3b572 1e6cac73161480c16f6a11ab21d0383a0b55bc431298bd1ba87c65d7e6c39108 75193664479f2dd1ac1a078e0118edfa95f45f033ba68d90aa2e0118b6007fd7 622b931b8f69cf49bbe2adb4d1fbb4832aaa88e5fe1395819b3ae0744dce455b 8d4c56a68cf64d00728bd0ba6aeb0d3f049536bc328bf1d7adb4bfa932f0bbb1 40bbdfabe81658a5cb42d68fca8cbb0e5fd74dacc7b323f96f79c6d8197b1df8 4a464398d11d4e441ee37f949f0e7f389c3f617fd4f126266aa6ef82d44cd9a8 095b77189f780e5549f75bc7f6e31af900b66009a34d40281893748137732af9 514c1f0e4cfb94e339ea4889f63851a6568fe24d16b6e5fda30ffda0eeb9d4e7 c8a7c1eb3b13c4b472629c068df76586cb9346dc2babdc670275372c3a3fe53e 394de0a0054afdb7c78f6dcfeb4c068784c7471c877ffe8e72ef6ef96c978831 db9dc0c745c5b52d137a09425057fe302ff8701b4e308aa7554419a5bd10b7b0 3195eaa3b9af64e6fb2a38aee617ff80dd376ab19c0383dcbf975a6d3bc6f887 a47eb1d0c0b31bf43e82911252ce9f0d0301546f7f8a9508b30e0769acebfa42 405019c040282d00ac22d7d615cb6e876347f2736085c2e1d4380ae3159ea3f5 202372d85f6b22928b905475ae6c228d2e31e62d2cdcdc3173c4d830a39b006d f553bb04d59fb51f6ad05b54777db7705cae627a70c7c9fa63945e07fb1579f4 319b616ac33ff3b33ea2951cd2518ae15856382956a3e6bed9986818393662fb 02a80cc440783d0ebdcc70a5bcae00a6d5a7ea12938436dc9f8df50bc4d04e52 20424fbd796c4d1dfe0f1f4d90d4f9bb81ed93d18006fbcebef2b7f7c3195062 6cb94a2f3cf266527a8dbc04f1b72cdc124874cd25b5289c799f2a8078ab3e46 72d854086a073d89e9489ff5c8e62ea6b7f1b954abdbf6e461b38834399fc341 bee46d0bad0d19f14828f93e87ce268eebac443afb9511f7440bf320addaf7cc efb92896d63fbe7a550c4732098ff31b91ff33d917e24ca6ccae798672e325fc a0a235774550c83050f0c6d07e46f1db9666cd75ce78b16b0383e26297206e3a c561120714696d195e43b4483e9988f03281b1348198666a82eaaabcca2608cf d33367a8f1698e24262396f5d3e829509ccfcf48248de20ee8554a07337eca05 93cb9affdbeb64c76109c70b6afe3f9af8c0bbc672ad3fe693eaf383992bb031 cb9f85e187c729c329645eb58ec82595da32bb9312996452db0d3bbacf21d42a e5afdc0b5ccd4a59f667c21b3af7f8119a506f509e9f805b3b5b820b992f27e0 8b91dd2f3aeaa21730e52a12c38a7bdc34d27e7d080918a31b3eda005dd3b75a 5821a70e5ba67d7b6ccf3e48a80e9c01f6acfb59b0764d98478a84598f158c8b b24529d539934ac8d2aefcfdfa3e7b224b1f1f68d535a3616a44acaf62fbefab fd56c947d33ff54e423d8cf8a97f72991678b8214e24c70d70c97ef4ca8c8640 e64a78b03f5481c2fd891905ae03066bca549bc025687372579e2f572063cd3b 8a2687abca154a67ddc7fc568835b041381a12f291a4b4c4628d929c671e85b3 c0cf24c61ccf6efc4e40bb44871cdbca20ec045b8d1142869818c4eeeace2a70 8dd32fdc73f0340bc5450da6fdb332191a52bf21d411a831d89433a05660fe0b 5b00f4c63be65689a7306dfc077aef31e62982f96340a314b396382c278d7dbd 00dc4ac3ecff6a717691e2e0017e1669de34fad195ab7b051b8ea82f18932817 c2d310dddfa2cc43538f180d5f275ee2cc6e49098e42504a9e41e822c83bbc81 a433ba60c17f3146bdb998ee2e234de0502eff3ca5673f46c3169c3fcd8dffb5 6f14a1a841e0faa8ce5402ea342fa31a8887e2f42993291cceaf61ee29667c62 23715f4a0db2c7ea7b308eddd814fbd2443f89d096bb59a0c33ee42b90f57a36 fd0c1486b6687e043bb733d3f2028fa71ea4440b4d62b9d6d8e5e9222a98b0b8 98154c8251d720ecbd14f260345b458c15afe36194207e9b2e478c6f5753f239 cce49acc97ac309f5618cc8a2853afe2230382a2a4a1ab84a3002b3276627a16 e2d0a2202f1a9f31dcb14951f7f7c517471e60d1f41a55f406d06420369faaae 7ef28138ec1c452f85211f377b646cb784ce6e65f4f56ccfdafbf674ae29615f d9a867e4aa26ba59d9077154195444470aa149708f4155afa7029ecfb2d9b0c6 3dd8a472d38358ff662ee26657482af045e756b52e7aef5d1e19ae87e6fe7d1b f67836db419a7a23fe35bf1f9fd664b48d6c43b3a975e6e169f88f806a224c69 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 false +check_ring_signature 3068613e11299fd1dfe7d30c7d5ba9f368dc71372502a61cb04367a1dd6bc4ba c172eaf1b39ebcd5c0a3903cfed163f30417e87352572596844faa243cd49a94 1 8d07e3b7fb6ae4d152a87e7b670f2e2a43b6832c056705151a1d1a49ddb793ee 3f5907d33dfe023e8fd032bf7be0abfa1163842b65a8f654c202940ecbe5a1082feeadea134a5f083e46610aa940a2a1471d9618bc33d0211ee02c413c34840c true +check_ring_signature c083ef344e985c780fea1d18c2fc363379cb6df3853493f3f56f4c19b6db368a 7b74b28f6f6b4c2129380ae0dfab434e30b0d35860edd4161f7e3b701ceb6bd0 4 4f7f5871e419099e8c4142f173485d36af8a414a2e26bb6bcea436354c1e2261 a7b3a8c485debf09f3c92503facfcf66ff4ba69c178c2e918bd7368dd55aa225 3fdf2f66b40eeb8f26ac4f3a655d3266cd9089106a2a72cd817f1a5aece858d4 369048c0d6c6104e0962d41ce8bb23860e1c2db23824938ad19219e5560c9d69 7ff58f5531f1bc74ed0f82e0294655bebbb363ab4cf49afb774da940828061056d1c662c65ba0f43927d79b66546ef4468603d04626c5760dec71b08e6829502b66f90edb64d32fbae860d40fa1bb10ef583ea6c261ae0ffd2aaa5fe21a2c309d97939a63ed8702178720dca1e625cb45ed405537a3ade9d7a814345a5e4060ecadb3a03c041d1de4ca3a441c173c5197bed63e67b1b88aca14bb66fe497940ff407d3296a4415cf585b26db9d338264cb7d66347aad6623ca0f4756ea90bb0c5ad7395d103bf753c588877dae7e415b3605bfe92c90673481321026f0175b060c6cb754321116b77fed1fbc138e8323f233592a13c8089f92ee4b8255595400 false +check_ring_signature 7c59010ad89e4f7481a0330dcac35fd79a12241acdf477f6b1ded630e4dd6863 aa33cdeddcedee7e4b7174801b08af64ea444c20aed01578284f92ab7a11f155 4 24a510e916741fb2652479932ce7745009d9ef8a2a0c17566cdd4a7b9c1ace9d 8d5560db86fa780645c8547844a7109e99efe8faa35011a0407542ae44a9992d 3e78cd38338aef74aff43880524d3f9a83610b0a8234a848ff4f0997989d1fce d3e41b35b2aab384f3be7b0fb23ea5da3e8a94a3d716dbf1c90c6149fc59fd2b bb9acab3b290f906a000362de9414e4579a7ec968de4ec54c144e72943cf5e098e2292970e052604b46d5051dfdb080fccfcc0f4fb3920131a0291ecc06cbc04933554385e55479544c067f0297bd38bf29200275cb224ddc70b1ae41df3b90161153ee7a498c76ebc2194ef70c84af4802ad9e858606290d995e6962ba71b01810603a9882e9de04900a38ebd5c38c7686b7d64546a8a04e15c877db1f2220ba886fda5d9829a9f67974a083f339c2e7fe4e6cf71383bf74ab52bc761affa0b07e27e6fd8782f4977ed87fcd19a2b1142447ef06c3425e1015d2fd858053a0046c9137911df01f3df6e89b1bb85d8788bf3f4e3f5e6db218b92c0e7d6c23a09 true +check_ring_signature 04fd431ce3869b3d44442ac263fcac60d586479ac06c3c20bccd627cc723dc9c 0c23a3e26945044d1b6c8c0e01f0d90110132bb3bfd1b5c31bba657406a16538 1 1dcd60eb2fde0d9717be8ca958bc01fc064b04ccb189c25158b3fbbdc4fe2907 60800455962c9a577b4e4033e5f807eb65ad5247d7b9e420ec4c7d58d3448d0c1ec2877ea63a22a545a8827f426497ba63e348cadd570dbb6483e03425be8c09 false +check_ring_signature c76a8cbab4cb3c88fd028e141a785df094dc230ed712ad1e1b534a3353c7b248 dbd7b96797317b06c3d4e70d97276177ab48b4289a3d090b61d8bc1f88e1310b 252 4c00225af924d45a0d7dc3f62ff47c953d2396bd3b16e0b9b17a0246937e8867 133cad508c37640c77200207a4677c155bf298942690aa54430abcc01fe31402 ef6673572a28e017ba527ce957820468949bd8b1dd4440f8f6a13726332c4780 555a45b864f939a310d8015bf8e455a99d2cc941de22b343033df41ed33c0682 ae09ced715f4ddd4be7416c578ffbc771c538185b903290fda87ad404ed7e267 7d1d9884495990957228781fb65c93ad2b34d9a7a5f0d66b45aa1f395b26e0aa 40df0c36f0f3b8d0e7160b443c0a2d09466767b49e53f3fafa81240f28895f35 7906b4bf8845b83ab073917fb06b2f02f48e9dda5c14af3d759ec99224330f3a 5d6eb6e4d14cbafa295bcb9166fe484fa6d4af0039030f7b14a1451aea91c37e b0c8717b50727f4f6bc7cdfc91e5c2d2e59ac4da85b73d5f9021bd837435f81c 37af2e98a438bd760e7ac50030621d88128d9cf14cee3e457618f93229295654 1d3ca7e6d3698c7b16194e1a7b559af38c466ce7d18a82f860d0925030143aef 46d2b7b658b7cb98d4969341fc8e6f879e142f44997e11c9837eec5b33995c5a 313250248e4cee97facb518c840656604e65730bc11893e381f43d6d68af4df4 1bd0a3c29565284fc6675b4951180f3d86ae843ebbfcbfada35bae18f2abdbde eb2f1c79ec94907454bae15385207104e87be399193f71e3751e9be3eaebd3ad e6f2d10299f7d290c10427ae4d6eb58a4d783e5404408ff58515e8c191ee9565 f867d65bf391c14af5ca2f6e768d0de3c84c036359cd6615ef58bd52165720fa 8f2be18ed4e96300217151d70674d799030a04f272c3b98812c64fba18491fb2 a5533c1761cbaa18b322a9ce105132a8ae18c8031a938d2394dc0d7968ce2d17 f58084e5b0fd8f54d1a870bb532ef79a300aded4c30c263d9dab8e05b09acb5d cff3df6159a2e4435a2e46437ecafa7ef705180499fe365d4e853d0f37feabc3 e3526ebb127e0b2e19efd463e40448b6d52c6ec05b81047fc8b73db5dfd8cb77 63fc016206d80bbeeb16eba764985176c065662dc36cec3207cc8f9f92bfb162 72f923cdcb3bbf6947f3da7a49e9259ca188157ab56e60374f351a6189c0dd77 fb0fb6686cc51de3228684161fe815884872cb146b0ec40fdef2ed23e739f284 8f3c5f9c7d70c25a1bc32a90e10dee985ee5760acc570a23648375dae24166b2 5899f9e3104101e4563ba60aa7b4351e692b213215376f21e9d9a60d55197225 4c0fffbbff67703d0fd6a5e6a5482d9b989563fcc51d9baeb5aec7beeed61971 f759ee4356cc7c00d0ae25f33a724713e5af525a93222cf8446f795ffcc338cf 2183cae9fb8b6d566312e29f27177e2cc12e1ed02c619eefadeb3c7e2dfa56a0 65a8d4e1edb8f81139ee747c0e0cddd3b7a37f35cde62c1daeea804e6a4c8dbc ba6a9e8ec1228da419e9d9f96d600b74084e5d47dac05d510de480ad2cd6badf 7d4d2107c30f384e684407d235fd61e282b18e9ac67470e57be9f305a649e2b9 06eddda5f877bd4506beb6d9236625cde4df9684d8499219ad0a1c74c248f2ca 8b51306a87f3fea1bdee12eac76de9ad85f0ef46811d95782844a12f245e61e5 2f3b34c9cade1e547f41d14e66068273847da1e71713a74f1b8be6b2ea139ad3 e287a3664f1c49c8878b59b4dd9025aa3444939d554c95f5eb541ae1171590b0 149de0c43cafd6fdc6ebcb6d456afb20dd0dace9ed588a7c21adcf247c92c6ca c238271d900af9cba3f2485450e561d0ce66a599a814d779e21086990c50e5f2 c533f624b1d9915e70d789e743b0919dde3ca712ce8f7ece082319bc3dca8477 b14211220674252bcb6870b72bae7f638b9adfad1537b467ab3a595d6448f13f 2e60fd3351d1fff219233029dd5f4217f58fbd62bfe12329cb49aaf84d624a95 0ea31ee2931113169f83c75a849ee11343e0d052b427b0493985e7d121580267 c1ebe6b825f0c42d8cdf93fed0ce180bb35ea2be26aa028b957b8e11eb4e863b 31d03d78ef547cc52a8cbaba7b6b134b41a5dda09673628a2bd1f82926a64ae3 54295f8944306ff8cc5e1c9549f71b56c5c9892dc85df420da3369dbbe6646ff b0d17be91c52ee3e62844cf13b588d6f7ed7958e1b7d0f637ae3f9896face854 f994748393dd6f3a0aecb7cae69b556cd1b718a5ae0545ef73366d195cbb6d62 6b2e6aeca22c861872f399696b0d0271806adca873b4c98b69decc40bef57b2f 4086712528dba2fd95a4dc9acf3907858a826559809fc464b2fe781d6326a53d 17882d6584d89e80977b0f1e6b6df80083e9da87888d8615ff3e0a2d4774eeb8 2ef26ff68c619ff15728a6d90cf3f6443354af81c06b3e3c3b16f216f1ba4f75 3ccdac9769fe82a58ab40193ba3896569fd249777ffcde0f558999c3dab26c93 a531a62e2d7ff9d0f063ab5d30fe74af8a72ff91611fa49bc344ba94506b507a 97544cad25fea782623a94eba9e704fbff17ee90c829110694d8e5d7e74e9a01 6307e69f672265f5dcdfb0934ce2b90f79641484e4d84b3739cec91d1f754cb4 4be1477d2acf4a691faa75bb97e1857cd4e24d422660cd3ab30a14e74c4f11a7 1c361928cfcbf55bfc96add35c3e3815606125b8ffc320633645de1c50152602 e33403e8f6494bf2c5c607fbaf55f71617b776d70f86c16175cf3436bb88cada 3216402d7662949877295f6a16a5f5ff82f1053d23b6ebb052f3231eab3c41cc c2423fed7a04f4f7a906dedb0e754e77464218abf2ffbba755612fab33147899 85fd728482060b60a57a5775522c89b7628a8c3361122310771530cfefb57fcf 6ba3f44f39db4a39c7a6ef8a5c25a437325b985a742e01d650f3a192b3b552b0 2260d278fa89298436baf04d4e6e09c743f62c6706e0b23887d8d110c93bb16a 242b7505416c9856140cef9241d4bf1d56a02957fbdedf0d78d8906c05712cba b6a6f29b10597f764d713a65ab8ee99bd309aea81ceafc18597c5e497ea72f96 b7b9eb771572937cb131272821965cf87e63b8beae5fe53b91995466ae5a7156 f29c2476fec021d618233124458771f37b1abf55f1ad050a079f9e5365a1779f 65f7754d4d03758091b61e1e7e75e799ba6ea2f905c2f3f6059f7bda879f6fe7 fe1cd9ea1c2acfed52c1e637916c9b49c7ec22e7617e026570b3aaf335ca0348 d1ec52eba0a2d1b7992be14b6cddc71dea59f10b375a7766379ba727aa4f18a9 180b0e6dd3791be28eec158718cf6310ea800f018010a858783c55f8bc717b33 c26924fa360646753c3486bbf14ae1afe5f8f3f6cb7a1cc9bdaacf40d8dfc4b4 5cd672eec0c2172f0d0fdb6ebe9ca71cdbbe06f8d53f6d2166e31f0c3ddf4002 d7420c0fbe130ff78abc3a57e217c326c8de11e7b3847f3d3e09165601dc6f5b 57485089b17f9f895f4911ee8f9f0b3be2f53110c457dc6743579cb851ba5755 79d4c9449822fae9abc4b31e59236647065faba6427382afa20cd0fdd1ce1ebf 8c4b0b26148b5960f95190a2b2bc864d35e6757c31e46e56faccb85318f5e6fa 1c11e3e8c9ec860ff2a5f4c7b70db809790089021fd385d7e397ad47ad982f96 83e744e528e3f49132ebab2e63674e52d590c8664e08777f82db2ebb935fe70b 187e957b9d423395f3098291562b0ca87dddce032e0f8ae600bbb93a45d8ffcb 376bb42f93937e92796ec6fa7ccf3bc524664cc945bc221bc19d3c4556e3d5fb 84d4798e3fd6de516699e40b62b229d797e495b9ca073597b6775ef9badc2480 bf5cd670c72f00a37109bba06c2c5311a8169d3128703909ce23a2ea03adf305 a0957ab0a5816984460edf6aa28e649c31e99339b89c99ca2ff808ddb783a4ff c5e6a15c8d44df9b22d2f4d4bcd6949c0158791dee947308f271ba31eb3ab960 b7162ab62503c9bdeeca05b186e59371e6a4e8b64c781bb3e8088862910ba43c aa8144e0dafa016eef4b774913ce0ce9760d29eb61b31cc4fb18f97ee2be7ef5 79638f3a55b591a1bdeea6053f8dd1bb2a201cc851c4febd92a8d9d796a98f4f 2c630c62421a8b978e3ee7dbf00bdf78bfc3f5bcd2493876f922188b1e92cbfa ffd764c99936a19c2bd0d2bdb139e3c8bb3328ad663cdf874590b51934bf9612 f088137c558366f70dceb0144633637a603a53de272a48fae93149fbfe88d734 ebbd5e73f2ae1cc713241981fee7c313bbd6bfded7a606a61cf2abeb3c525a50 404918036b0b20385938673eee9412bd1b41188bf50f4c15e48a9accc75ac380 14a922dffa7bbd49c33a402faa79144bff8edf738becc3b7fa71ff865b3535ff 787156326d05447240dfdb97f93c7bb5f3b43dc5d85259adafb6584e8d1c5331 28b66ece2698937fcb1737cf3e3696a9c23f55aa46fe46003e2fad697dcc46af ef9149814afea7001dfd1d4a8fa842c34609340e252d7f3da1dd7be812aa1df8 76aca91330a7ddac7ab9ce9cf520685c01f7154dea40b8e090dc379c7f0dc889 de9cd551fb4fb49556bb0743d20383fe69b55dafe9f6977cc034a726f00255ec ebea9629102bfe72e2188771cab8e7b614fa4d0bb857c52c82b565bfa08fa2d2 d6457eb7b9d082e94bdc553ff4a9932f757592f1dc0004bb3ba3a849cd7115f0 ed62418b98688d74c6d236530650abd9da37ccdcea34718025c6ada164d6c3ac 91de7a7e693107cad122f804de277f6bfa6b0e123f58d17d166cd5669dc82b4e 016e2077c6b87ad542dd37540f7204f4e4796d051ceeca0d423e3427debd01c6 c5567b52c9918b501441b397a778df6b6de7cf99bc2c8c5785b692b8b9d2f011 82a046bbe75012bc98473597cb99da6bebbdab2156eac1310f7433daf0d80348 1665010cf6abb1230f7e4d99eeb7b36d4150146b422b404c68228624471a9f8b 1520a4243798e6de141e735ec4b759a0f1a356b465339df8ec797180a1573a1b 0e924c65ea52566b9a8de62dabe4cc7e808ec3de45d0029f7ef0b911c614d6df 2d9009f1148f92797e45a9939cff52308c4a7d736132eba4dde0b2f923d6dea7 57e43a9bbfeab8da7ad496536f9e177e29fe622e28f064941b1741fbfa1cf08e 0657b5f36da4076386705f098a4aa4631f06d4764d7ab4b3059099cf795f89d1 56206a24a34a16fda834b909dd1c5476aaaaa2b977c6d08b601d2fa2bcbf8726 ffe85e7791d0ffdc594b47e0ee42893761bd5743a3e6cb1b05eedd24e7291712 8d34232c145934257dce3f4236a589f39f611af68e429e3f9b640b465c150049 35d809891d2a42a7e7135eee0987e8e3668b50ffeb286e9803a14e6073e0d35f 87c939bc246d42ac2ee83f2b2057a71b0daf3e43f943df6e13f6bc11c7a79edb f594ad639248a3472fdf5ce446aec366dd2d77e9e8b40f44c253b607b3406e82 938300c00b58ac6767395ab99dab26a96c61fe6da21eb9ee7e9b88c5f1b6e43a fe738bf7ef35ad963ad5fef0940ca33a33cc01a1e41e22dfcb397dd121a3225e e676e9cbf04e9183b91c0c6be28a2b7f218408f304b3e0a86988a83e5eed86a0 33eecd0eaf936bed0a8aebd9e04e04e4e4c640ff31b5ccf575bd2a9824c1d573 b4665925f8c214ead93ce0fd617bf0fae1f1a85b09c7d484fe3361ff0240ef49 7e78e4d8aa9a85f1ffa82a74ea905a3382f570ec20ffe258fe6db4a82fa42052 d59c80af0d46de78e2038bb49669229a6ae5a240412e615161ec79c183c88d21 9f906799188c7825b5c3fd15d7dffd2cefa874ffb5c719544f5096d360870afc 5cd23836ae9f6fdac70c594b88d16ea4827ce48aabc45491bab22b519fafdef4 94cbe8035778851eecc0c49c48ea055aafa83582b4a5f00938844a28327f44c8 dc3d71e2c917593b678bb6103f121fa0a7c9e65d896c41adfcc56b9dfdf45a61 a67cb36bcf70798769813096734d1106a91eb6eb40fee5c60bebf46e11ff235d b40e99aa1d67126df0d9cfdd334ded05f1e378bc4fd3502be52aecbfe311dd15 34bdf8e9c47e56c8664dfd9f9c7b336c97232c19f83fcd67573fc694eef97be1 afbcb115e8c53670eaf7216e1bb0cb2c8e19d8578f724305fe104e13963bb7dd f323957e806fe7e5ef3dcd5bb04a2dc4db8ab2f49e2eaa7914d3aaa882196baf d4472bd94e092af3916b46d19268d310238ba904046124d64d6531e1414f168d fffbe794e5a9aabff85422c22c92195b25bf3577f4f13c5d364b374f133706a4 90a2ed35418eff3c7a1266d1db50df54ddeaa1d22657fff3ebe19690f9a78510 c795b664e6eac0e12ad05eb879fc768158ba481101e9360033d048444ceb6723 228f11880b8b02da878635b789ae1788c1ca7b36abddb8acf30a5bd72724081f c3704f97d5a9508bffd5cc41b4cba02e1f2f886ee839f8b628fb55895ea1676d 3c14429e0f125c941057d7564e2968049e93675a2c7e5e58cbc861f063e3c33d 24184f1483fa7e39254c8dbc51b81f6fdbd62d8fd3384ea1e5c46c35d5a58e25 4e7dba475c73bbdfd019bd531cd539122426892d319e6daea10dec2f74fcbe64 8e8fe24480b7e33ba145f198b41a635c6fd33bd15e3a3ac0c49caecb64af77db 944634222c9c4c08318de7c0ffddcb898752e9988592a6acd1120ecc48cd266b 70ed4794dfdc29cdaed20ba988578e227e457ac1fbdb999bf6b6d05481450417 01da4ad41ec5eb3c69af957975a473866dcfb348a0cfc8d022b9c63adeb9f30e 2a0a0fd275d0f18866dca3855687baf51863aa40aa3f8904d72a2e8fa34ad28b ab7a876f66249813444eaee14e57f485b73c79f564f41a5e6ed12806007648f7 a319304f3b5bdabbabf38883bb1a466525cf87bb3581cacb441e230f96fccfd0 5eaefeb89d47441336819f402553d784006623e294ad9db2c84809ce10dcedcb 9db3360b6652070330e2f9a9792456e9d67c759fe9fb9b3d3bdb6c39343ed888 edd323389bf21d64c99ea4111e4e71637dc55c741f9db174a7151dbe0d8ec55c 7830a74b6d312904be9f318985af7eef2f9d9001b5d2186cff7e56f00cf2cac6 6e3610203b4ba6ec590f07e826fe07fb1ac696610f81b984cc110358299f2606 08850fe3d9d31f92ed8d60355f607cb91f33b98921614030827d674bd0666413 c13d00be30cc57aa4d1c1d9ef31432eab612624ed7b8379873bc25d2f765a533 41987ca8ee46b18a376b9860a5491312fb33d93d97b8e3d53ef97444d1370893 a39b47e38dd5edc1d7b94aa3971ee63200cfc3650d65ed5d84b2808ba4f9339d 5f1102411abd91a4354a1fe1c664768370ef28944e693418f2ee75449639b552 8153cf3252e3048e65fd2d0642734426ce76e208c049301ae440bc109457c9ab 7e77f45fbf22831114b6f8f439f4b42c309d0499927e139059fd0b142b36d9a3 733739bc4b8fafd5b263cd8d94471a47c952cff09771c05787e05e8c1e188eba bbb82a0555803aef14e519ee3cc84eec339c4505e7b1d1b38fb91d11b409eabb 14f94b0c52a0b6dfe46f0511c1c41f29e01d651e8d6ef9eadfb94718bf0274c2 08ea1f75445690486bf2ba14fcd22f7bf434c67540c7d882f78b26e2d4c4b9a4 2eac8cc275d24af1535ad3ef855e78f1c016a445585de4afa22424a9628f471d 4161d6a7814f17d4b44615349af82dfc2b38284bcd1166d290fed75259e86285 66a8b43c14db92b92d544543ff7b14a3e4afb54f21718151b73bebbe5d011715 4343285533511c2190e9b1602a03bc4e3dc1ff58a156c7e371f80e39cb89f183 9d82949eb0c5953c0e0f13b69d2be881928249bb77cd77eb09b08692ec6e0b2d 4f0748d934dd497abdaca0cd441a676f969f64844da242a0b52d6bdc0e824c17 90926505b4135091fb9b83234ea193b23d86e8b1b00513fa3d42fd38729615ce ff12a8fa04297bf9e42b8f864ad5cf6ee5a8ef9cf3c8db1a5fa44fa1e1a33261 e24a2b0127781202314eb5180fe3a1e736533215ff3332d03de4d29ecada82c5 7df347289ea082e23c9ad7a160f81e8dcc44eb9ab557d696b6d3025f178e1a33 aa5248f83ca4fe00a408b357898383037818ea8ddbd977f86734477e39a5ab4d 31f910b2394e7b918b6bd3d020d19164546da232b717a1909ac91b8c6cd74bbb 02cccf9de09fe6a54d6e1ce6e825f18e20ef2e0a97f8714096116fd47e487229 8d8c3369912e7c1f08ef81937222f90bda2094f6c69f701d1cb7450c1f6f9967 2ab048f76da05cab15f5946c12b5c0547863afffee0c83c11daf85fc74b6ce4e 0c4006aa7a13238f80ec99ed39c49e6cbf9094d04ac2bb37e45e248803bb47c7 fd827443837bf528aa91e998fada0e482ffe55fe4e3ec6a570e0bcf36a893fa9 c3a6a450f427ad3ea1518a8b79bae7f8b5dc0a750f24f1169f5ea67ed587fa86 af06d54844b292fcb151dc65cb70b127811e1a794e3b5f53cfd13d2c644d6c65 34cd72755a7a43368958169532c2121190ad4b7f2420b59f4d9b9005081d3620 fe4aa3dcdf61680dfb4df3f39311979a5ed644553003212c7c32747693e3f8c6 fd524d67b5a7e1f725d52cffc2cfee6d36b26081b42bf29e652e4d4e83752428 ea2ff33f08188d8451297f18f7578dbd473c70f856b021aab5ee6c68bf12d267 b502b4a270836f0c3660aaa781bc4ea446ae3e6a9d8536322bf6b39ef38e4a8f e135ded12c390494a4e752c5fd66e1879cf95c434c476291e04e601038541804 b483b874f352fbdb8540f1e7cc6f1aff1c2035289e9626f939679d439227011b 5624b92cf65c5928ec138a24d485a1ba38c15ca694492b32a7b6922af96a6e92 5223d75d86e9c2dec001c1ab5b76b07097d95b9ef732a59a866c8bb6e113ff2f 7126285017f355f6e5b345e3b53607d5e0094274cece96aa39cd7d1bcf3b5ae9 05fc638b4a33f66744e1c1eb0fb0fe684b96a5128235bf40c60064e735f62426 0f3172d00eba8c6ce65b0dc1a71f75c89e0eb007adda2ab4f16e39d4188d992e d99d4d675f26eb3f25a8034a8e86e52dbd18c570ac80219f56b37148633a5707 ff7e4303939d326d95673457043652e86263dd640bebc8ed0475e09278ddf562 5eb40f6be964003efb0a7e494a4b2a41505b86adcb45412f9ae651dfee4eadbb c4c3e0a80fbea2107f69a989df27c6f91bf51ea50aa40eaad569e74a3007fe2a 9a3558ade6158f9689d3561b1b8259978bc178c1ec4f9fc5e5a4752cc37f52f3 3114638958f10f177690794287d6a50da3d845b09e30c3a9fb946e127d92ce1a 0c7b2900406842d41154049db23f6dd0225dab4931f801eef62fbed0a175d60a 7da8025b8d4e5a6783106a8e734088d459f660ad232c6b6310323e4e4b49877c 2547e7a9063980222ba7c46d90d1666bb8e14c07b3f24eb7c6ffbb4d781cb2ba c570d93b62b264adaa82708985bad65ca3783cb2cea12851d43bf9c86b77e5d5 b84e08f95d4e4597aa129847c6454762c2942e9d33adfb165eb5e0bda77ff565 52b68d1cb0a5d83efed81cd171397d90e12c3f7164c27304faa3350fc0397e75 8047e5c6e2d5f108469f130c856bba19eb80fc9d32b4e21d07a2cded64dfd6b8 d21d32350ad61466b3af99f72a7e2dab6370a04862c2067c3ce4695d61e09580 dc21c6171f4e3798a0cc44d4768c4dc5fbbf38e0adbecfde135838612926c8c3 df1229c15c293b5ec7ff08fcd76537e87d2b3203d09dc0b8909a9e6bb7a2e3f7 8b8617c91ceea5fabb0da50bc67c8cf75a1e68527a05db559fe48de9a5ec7844 f73a488d5a5ce31166034222bd23a7cc2271f6196365a18085dca6933d9474bb 86cbd861850eb03ad21a27a5600221cb9fb59226d1aaad25e443237bbfb53f3c a707a602f7b21134da10de63d23bf57a4120d69636791fa4ce0d89ebeca4c1bb f71c259fad434cdeaea41c4c70f9baa39c4e45027a5e6df36ada26233ceee4d5 42030c1bc2cec38f16e94773e623a342d534f0468cbaf97d70ae3899e6ba129e a9913dc27d3b96cd9a759752e489c4996a4ea40eba64a1775efd330ea95da24e d3d7d4eb171cba2779514da05d90209eaa1727b52c9b8650cc8b8db57e46897f 0a68b58c79e3ad6391d53d67b471138c26f00bf529327ac2839c755fd96d0658 ebc9495273b4931be7077b276e051fe7e8250ed29d9aeef31373a4b03641c289 3b8badd51c7045dfd57bab5fb9d8db13a0eb7020c290ad1ff47d5370cccbb068 b2f09dba2068bc955d463f076db8b6221e3b7de6275a6eb4ef9a23d82a181544 6e4361b0f7c4f1fbcf76201eca5b30a92a8f722d5cad9a57beea0403b0928df8 3a4a6ae4a131314c10c7384c2a58785a6325f4a00c4706fceeb6a4d6ab30ec6a afad36e990e6e041a6db4f53f880b268ccd72b72261a0c9c048567e1c1e958b0 caa48ebce5899e2da0c7814b0e696b035be952553d062f8829def5bc771e45da 89406d314f4e39c4a033d6a4e4c0037edb7a3a31b37c98eec6c8d720f2c48f01 0b035741c3fe08c2dae982809d9ed7485e734d5547faa8403c1b77a9da609ad4 1a901bc127c3b84152875736adbe0ed69167fae31e181406b1622f6e3bf71df6 a7c09e32c7ca28087797e11804527fc83232aadd2ac4e4c23186f02e99efe7d5 4ef11891656f600a39bcc5f7f7af21e3bb26e453fc2af030a2724a50776c4791 6032204ae2b379496d83b9d2240c7d063d6259ed8f2433747cd105ded18db7b0 a63b0de0182cc0b97de44031c55d6e5c2337d9f6a0c2992c82e3c1aaf10edd22 a790c12d426ff35c0a37180c25ad5b2a929f3c268c5c91b20bd5ee2a202d72e0 95c56ede8f9227c93d02146ed6e57eec055b62af9c43ad2bc5fc81651191b06b 56fcaa83985e5f120c841b50e7f8919c76578e21d247e7badcf03fb8d1eac4ee dec07c7dc8c89bc941c8223d62d94043acdff9b2517602119b0ae9a3a252cb45 c584631705ab126f070fec1dd3e8a48b69b12612d24888901c737231ef93356c 4863cbb3e8cdc1faeea1abad685eaea9fa63284b4328c59ccd1171c115d7f781 729569ad10a1dbc8e54fe0ec19979991b4eb9eda9cf88b2084f0e2ae270e9cbf b66d3ecd02a26407dddc554c689245c2675c055f0d9bf011095dfe5ae82d7554 2a24417557d9aea24b7cbf499f64cf0d68cb5c624a32dd8c5e43b92f9e83d256 e09ab5d4c07215051bdb16b97d2076e10e8d160a7b966bebfd2e0bd7d02ab6f3 9ae1dca3d2405a2c2b1673eea8e08c4fe9b01059bff85c8f4d6daa4c10b59e74 69d2ab5cf7662a005d70270be30dbdd3523e56108712feedd8c1acaf9183edda a8035f625337c31b0ae545c63b7993a65dccc55e4bc17094f44fe45c2ad04867 0ead6f438804330f41a356b1cea31e696b837f1cc839772d2aec226aa942b6b8 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 false +check_ring_signature 4ef3e892bc0c8fded8ff0b4fdf9e3e891642f71fe3b4d2cc9dc3f59737c4591a 6a04e15ee5573dca0c840d6a700ab83de4dc387d978b360360cf9757a7d2c21f 1 976495616de20cf71beeb2e01b23e4b850d7898948157403a7b8cef7cf76023b 2e89fc510442c3a598c51362f4d3bc49458cd6ea5f2e742116685675d346a493d909e610411c2616a9f4bd9dab2fbbfdd26cd57a8a13669d1f622b4c0620df01 false +check_ring_signature 0084b7d78e1174e113f47279e493fe5ad73fb10625d29e40908cb8febbf47f7a 8265c399305824f8c0699628c27aab6e080b896d9475859f0ad253c1dae7b745 105 d9879fc25594e626015962a6f371df7292fe0b4979a8c0115cecc625b1bec458 24ddca57655df91209eb8062c33d0003be77db07d05c7e8b0b9921c893178805 d63cb4b8e219146048aa68aae5f5e8f65f383ead3943b9e28856b3defb1d008f af489c9113d2988e68de68102e4721710a517a047039618916b16e4affc44513 51a95e1943c4fed089548c27aa6d3ffc1eb0fb4009d02b8c4b35244a19ef4da8 6b8cb347432663e2ad0d02e500c717f0d92e1c150291848a5eba36dd4d4af988 f90a266fda80f4a2f048884b95ae95444689c3e2542191bfe1b10c5ce44738c8 61893090f49069689749ecadf5898d21273cacf6664779533a2d664618286987 7b95d0103093c212692dd17fe71cff78854609a88235af63730353b228e6cca6 96808c03966a9e00afc9039a3719383e377961c0ab61ce312a117db82ba83fca 348420e28cd8f8c38418ccdec8d891b43d4ba6fff97bb2b6007ba82fdbe90f2e 62257b7485fe15ac1f2075bc88151f58255a2be5006d23d774d4245bc1371bea ad3fdd9f00e0cad13b1bbee178ce1b64a2c76a37fc9d6c2d1601a51d7c7fda4d 28d2ab2ac2a9aac023c913ad34704b6a2a0a3d1d8a1de78b2adbe9b3b986ebf1 891e293bcfcfe0f8a78b200563e1b58c0ad425ecb3565031127c5bd607a0ac0e d7ee6a13e5bc35b59075b8a6d7322e906f515a37ccab6e63c4b815b2a64e23db 015140932008da064018479a43690ec49e949c3c71376d6bea5cd03fd755102f 73256959c04db44c84f59e50c1f129a4344e902244900f5eca0d34b33408d57d a0bc73505f3ebdb92d657cfc6843a78840250d9aad80397c5721455d55acd812 2fe6e12c10701605dfcb9021ac65bd368ba1da028e1c8df50482db6dc613c0f2 2185320889155d2a0f1802b5d1a6902037aeba534d1188ddf92ea306095300cb 1cf324fe8d45a5586faed246c7b2df27b579578c78e361d1e8e4e61bc2422b02 7608dbd8137272ef35c302391b18d2f573c0a593239a71bd4914af9436acaa9c 217ab41efa04f5f72a7e62ddeacb0850d7a47c952520c1578094be8801689a7d fa01df875bdc8746b669d29b0c1cfd7798cefc8e6e6ec8951872fc7dba857685 5aa952ca3f74482ecbcd33796de831a2302406b4d18cb9d2be3b0826eb0b584f 052ea16d5417e1c90b90faee3fa096f1f82c26abc3abbd2a081523d20707f882 55647a6a53a7a64485f460f7e999c62abc4bc51e084718dd5ff3f03f124491ec 64a6b8bd7bfa0fa5d7ca310fe4fe92caa504f93b42c63eacba824f05f22985a6 973cbb2dd8d713ce5435db6a8e2a8eae41f2131f8f6fe8cbaa2e0426d7f97517 20399da256daada4220beb1b2b4cbb84b9baf2aca1a27c36695f147eb75fef84 3b1a4339f4864dbb4d1ceb67975cb304968c033f0f3a0db8e6ae80d488165c1c b9a21880fc056774737f4e21a0cf99cf43f6513fa95ce1a493547f812e23d013 257c02378718df4115b4f2dc144f88b0226305d09b2d9302ce34f5521595b384 7b13be741eb3f6a043fb77f734c15e6b11b4a45506ea4782909eceb31beb7bc7 400f910b604aebdcd1adecdc6b3be125a5f36f962ea2140152fc6b58b020b14e e4f99960dbbe541d6023278632165ae143571136693c150a368495efbd7d97e3 dcc857a90dfac0741853ab180fb12bbe9115f60fa7038d05ae519f2968d7b376 e80917d45a7d7fc8e2a6454fb31d7a7954a5f1d0a4970cfd0479afa842d6ce4a d3694f72b26053744c18869e5a74db004dff96ca51a6f58934af1da99d375946 851191cc47d8a4689f7322542b687f7f95f46fc1a22efee96e034f9cd6273e07 88025e97325a55df3389181ac066b105e41a7f257da6a551669474ea8b5c0131 8ac44216077b87fd939711a0cd27a1980455230b9670167bc25b4dbbd4387f0e b8c5ac085948095495d882cd7323d4ae899f8d336257bd235c738d083d4c5527 ff322913087bffd551411a743b496f8ac4cbccb4380b439c8bea107433caac72 feec68aa6ebae178d38d333f7ec1467c6af70e46497d16625be9bdd97ac807b2 3d5715276ac3bf474b77a9fb69b6d90e2ab52d3bf3cd50901bf75237cc55ba5a 93a3661c469615ab4d2964277069a464ec58e943336cb3023caca11e3fd1b091 8b829f37664533a2ea009d9616de281f18127da71efdeb31bf3b101bc73a036e 2daf8264ede517e19536c241ad83d86c4fe2f5fd2be768ebfcec9ddf2b0e5f6d 4aefb08ee19a7aeea4c8054b5cf82561765ca4c4b803c7bd8fe8aafa27a53b3d c4f3795c2a3db79f90333c7ca5566b502488eb7f8fed75046094f49726ec98ad 023fe5d2448c454a9cc6880645eaaed62ef7526213f006a477166051588cd91b d45678996cfce0d8ebc1310851c5ebb8eeedc0fb4420b63f79cfc5eeeb689e11 4df30beef1f2b67ea3bf96683ea5e0e4c166e7b566a0f03de9759f89e778a9b4 f28f18c02d0da66b45f50e67762adca5705cbd44c92b1d3aef38d9eb7beb0dfc 37dcadae7dab54a54763a6e316c4750951673eaadf7a5620343c9700f111be23 d553d92bff408cc73394d297bf4033a69c6459dc1708c098402923404904af35 1bb777d8b42c6a7d2777ba89c7e2d5a8def4ca353a1066ea636ac69aa0f95b6b 4b3e3e09de6b9bc90a9fe83a744a557671409b553f05eb3028376411d333608c 8cf76b958db65dda10d1f973c96510acab7f7d985fc7a9a8b51a8de0e2f99d6b 8f16396e0dc2b5abe0b53ab8a91d80285b8a936006459ed75831cf846d839d08 a046fba01bce4b5f6c74395173eb073c9e08bc1e841d59bf44b55c9874738a6b a1229a0051a752041f52b15746694fae56d1f47cae39a10aca3728efe884ede4 9db65a567bfec4593ea4e7d020d694d3c896d80889088263a91f1377c088443c 6ecca18615774e877b09e9a63f20857bf15199495fff92c3189c44934f75eceb af9d5223df070391453de0be80196d845003a194cb11097a6e63795d9b32d524 4b4a7e4c84486eb33ec15b6b7950947d78360a7ba66c827fa4ac2fe09a35fb36 25c35d2258b8a70887e3093dc9b50f663a2cc2d93817cb4d41c666e8d078f486 f3acbd54ff0b37bd2fb55f51c669ab44ae7f05a82c586fb8168d978b52813e56 b57eca012d351704cd7df74b17b9344efd37d455685812901350dd2a70b4c8ff 38eb34b779e421340f87d6f84696a1a984003c94caeb0e9d485e61c84c4fdcb1 3f32ececba58caa7e14c6495ff8ff58e24560e4ad27859848a069f8c4497f364 3ca15b0ff296c5dce691bd3ae86983a681135356971e2f08463c96132e25f46b dfd1196f5f4bc1b538c1f32c233b78e6aeb39e6e2147566ed4ee72c7d47988ac c63a88b29dff3dd7bb275bae19a4bc0116f57b4d63929715582be13eccf5d35d a7f0aa3efe6427e2db8e7920b96a880fcfba81ca477ccfccc524cbf3ea1e2340 f7e646ec7af73e0b9ebe71552c646b4892136083c7d5dc35f927e896b697f038 c0b56759d0b042a1cfef156bbd6aa3067f433d503bb2621e8b091f4b5b3c3e6d 65855f5bb0b74c4f4b694dcf891d9b336186342dcc8387a68684a7570b6758ab d7605ccc1a26ca9dc88ca945d736757b4a480ddb89093d6a479af3248c1fc3b0 3ba5c026835ad44a51f7c9c72199becf34c6bc85093010000d942269cb7d696e 34ccb458b6070b7102078e354a6d6ec123b8248b8ab9f93cf72d559d4845ae5e 53aefdf6bf07039aa295f81edf55d88dd4b9cf3e24521d988546358eee50e746 f9d426847121ed85a011aad271da868b27b327b01f10456001ee7b8d01599329 c2bb5d75068a4240caa3cdcb5b3bd7fc2ef6fcd45f39c69149284421edd1eb53 acdba561ff335f9368bb18bc3498b90c0604a65b6dec9196127904ddb0c2fd6a 508e433dd909a603b6fe691efe88eaa87b5b53b086b4c5c7a95afe6bfe12a2e7 0ad870e8d531dcf397f85067ba45064f2843448692692ff4fca9f7fd8d2f017d 110f4b5759876fb3bcd6f6428d26c7bab86a92606e1e9d8aad0d9d2780c821aa 09affac0695710cd63980ce05f7e5d9b19255c72c477849305346a9217b30dc5 f5f3227ccb1d882c6422d8645196b9ac9a571944bbc0c2fd14578e02c0cd3355 19ec75175973d3fc6a5436abc71f06f59b05bcdb3c3d8ce6929f5c008e309a7b 5c40412bd4df71a14042fe8b6eae30b79a44edec0815a2e1a64e479b597ea8c1 4bb9198cb1e230fb37a7f2992fe042d6e14c8402e2d069e4a35e49490f4fe3d9 18382b090ecb9e6dcb9d75b0d045afcb62335aa6f791d698965b6ca5e8109df5 a850830b7520fafa655e959d8bb8678e91a4665350389ca19c5d1d9bbf04df40 f9cd7472a867660cda68833b4e31475402824ad8bf39bfc12201231c356ba1c9 c8a83329fe61f73dfd4175ddec619ab552217ad46128c94034770b8ff40f6c75 2b1147c4fdd1a25944725bf2ea898e5a04468772fe63cdc9fd5a44b5171dca2a 7fd2cd267f8f2d1e6e05314be1ff2c52689294c4b75b78bc776130b75e203f37 55b499077f9e84a05ad60315c770991187aa9978788c3e01456968ef23c67fa7 5a6ad91e163c0291b38a7fe107f8999ae34c5514b7abe6c1915983d4e6e1eba0 5c584bb0329ec21e029fd1d0321a16960c879e00d9333db11497fb9fc5b6e372 55f93ea227377d1bfdcc22cc5cfde33e01afa311cce5077ea76bb41c2fe5bed9 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 false +check_ring_signature 55466b6e3fdd3c65396695db8cc38bf5b202b9b5250a2d0a036d04b92df36add 17ef635b1b63b0f7d307bf0fae90946fcb187cec48a31930f166cc1bd58d1115 188 174b506211a87b9d4f2387ef6217dd7ab4567e7945ffb571403c11dbf0c3fa27 86bf503b7012699134fd4709e235c6113aaf001ae38235a6ae66eab4fee3a89f 7a26cdd5d01f0565d901554a1a5f4ed954991adff1a735cc2cb8d4827dae5eb5 cbd09d941409d78963ce9b0fbc74356103393c7498be97f9d09a310928f05ad0 999160a57ea074275c2500669ca556f914396d80702a135bae6f94914ff39ae1 4903b24466bc278daf304ff7807fbec3415688ec9182df2ec5004b330452548e 2f5b7db9f6170a0fa2340af6c72177afa4722b20d8f2956342163bd7fc2f8d80 c766f4890af50033f0798354dfd3613c1c7346a9247f69d599728549599a8964 7922f79241513a7a4905ba283c82912a994d44b899030a3fccb7c77d98f9fafe 95322f7ab579a1373dca3fa5a3be4a1cdd9a39996b52d3f987e0e899e1f87bd0 e044563452b45291cdf6ae49c1d844fabfd64739d5965a15cb8ccfd83c85e7aa f44bf598962173bcc57464e0ed3f670e82dd5b8cc03c75de8d34784229332335 91aa528f9ca53d922e70a3334692831d27b5fd28194b12248bc226a625b110a1 161fcfee5b44941f2abf4ed59396ea95bc8fbb6258ec56b20d943b8db0e83028 bc6fef0f7b43b7bd2fefec102129473aead7b7a5a20b51421f47e5b081d09705 e898552d858eddd625876c1944af85dd6581e572d8609d5fe3eca575602d90d3 0f595a52962c9eb0ea4bebc46e4778b787f727709ad2a1f2668a601c37f54f95 4781ad9c9a744230ed76cd614b771f743d0f719081162b97c9029f1c371612bb 2db52b8e93945d728d32e7e3d04605c94c4bd4f63875ea4ea7738c8c57ed84f4 f6a878ff1794ab273ccb31dca8dedffaee7ffefa3ee9f861c46aef082ee81ec2 ab4e06d49475bad348af47ffeb81a34ee6f5cb6245516010769444e469a14f5a 5c47b31250824c9a0ef053345b9e722c0235febebccd8826a5889ecdd24335fa ec3f319e9976aec3ddc16dfbd5bc11df1fa9e8bcbbc54da7f3a22373586d3d0b 187d3b597a4c9b3b2de015118d7e2e6ecf6096c4855ca9c4189f4ab0afb76882 da2660fb8d9d72f8d51a33e792c769e99e959424c5c21b9c3cbfcb5351535cd2 7bd6b3755e476580a7cce369023052382022f934612fb8e48ebd91e5abf446a2 339ea73eea3ea78a9c22ef3e861b04199c0d3dab2f3ee6ed3f77eabaf1b5d111 3ff792be1c8f4cf29bd5666ed029c32638c161d67a6a5b42624ed8a61bd4e021 0bd151a53fa9624e9227cb99fa34c57057d32719c384041cc1037eb200967c0a b7f8de3224a0ca8bb2b6723546869acaa992f0328262006c2790be1c5003f1b4 136839eedc3a0aa45dca0dbddf15472599000956f5f36361c8f2a9dc6bc18a97 ee2de7282fd9763538574f2ad687f0ca4df038a3c266955a0af44358960e2d6b 245ccdf706f758be0d5cb92a14c1032005ddf982999d114699d8392722b2eca5 806a7c3900d847b6951e9dee218705fee7d1b62d11c0ebf7046e06358880be61 8e230db8c161e90bd1ce595d44816d01b39c51f60800271a20c676676cff301d 7ea0b5fa27cd33f642cc08820459cf00e9dacbc2eacf6eb5c46897ebf86ecb1b 9bb7786770bae19b498d39fa3b998909f8bc453c54e3e95e39b3b13eb8af0b69 5b384f243ad88029c080aa66cb1fa5b3f92dd8c65134b49d3d400429c2eb05ba 3e9166120a4707cf42c0ce21b2d6a85329d04aa28dee9cd39fe47e4e4fb4eb80 34b7debf3125f72db2e9d65af52ab80726646fa45df192302d068d11567bca91 89dc2532f4acdc4143fc3b4235e6b9de94b9162f2fe4980f03aef33f3a437325 ec25b69c5811466578cd13627b7d4b998ccf93b476131070d1ccfbe0ef1abd1a 4d24384cf8b2ea7af20c4f968dc36f9b8644c3104016dee0327cf14e2b30ddb3 fc98e78454ca973d94718cb8413a03f70d799158aa16d938376fdf9eab860dbb fb90e3427ff3b12d10af4f4c9e5f9a2dac43adb98e402014af68e18c6832cc44 67f8f1b39770f3732991061c2ec21e5f1baf9afc4ae8ac69a3338296325c269f cfd062e338f3e8220a94e30f08224cdb13a1cd24c7c73c6b85b9de7647cbc0b6 d3f19c729e1579960a7c6015762dcaf38c4ec8e975550dd1db7c13d16955cdeb 03bdf0a54cdc523d8251e0add834c72dd85b504b673903022ed24aeed264e5c7 48e9c940ab6229ef9fd386eee823faf817ba329dfc0cb618588e60440b96cb70 164b2212aafa5c2e7ba74cf37e254e16bc75447fc5207d6cafa4c19da6bc5427 14904460cc3d8a74aee1b2ca116a8cbc24f930c2b75126f9d3e399ff2966d56e 27e7acc31684b4e3c97cfbec21c7287ea3aae7c72133754c8e2237894970f86d 8ba7ced39227f9671d102f7f387d66b3a537871b823446b88cac52f28ece108e 3f32e178c7b6d9faaa3cd0d243e8f0d3d947938ed5d3b73a916eea0b1f3a0dd1 2a573fd4bef527732b42f013015e093006668353a7a361c47fa7762736e6e737 873d64af0599d5824a5f1e74143fd8a19fb171c7455997f67c7a59dd524dfad8 b57632ae5ebeb6bc84993466819bc197c360d17b505467e64a9b23c8afa9bc6a 599034fae26e25bebc68a23b4eeedcc1cb090fc88a2b39a5d7f89b81b2f64af8 24f7283755f8ddc418790257969016a499111f96189269035be3bc9971643569 6fc415136c6aa35b986a3828e30af01b0af118e7d02cd0fb06e6aad1831cddba ffa3733e6c2ed001dcd2e58e3e5f07408220be794a0eca567ef59bcfb509a9a8 b652472ad3fac23e0fb91cf36b5026d0dcc95e81b07ba2f328f6f304126162c2 667091be03799e4ef96406281914cf33d29f7091929f44e7848bd02edb5125fe 8f0f6b1963a8e67b3f9c57dd59cc43a1a2a3c2f51e5a3fa9703416cbf321440e a57dac92763ecce3a19474efa994c1f8830788e758fbccee62028f4126c598f0 c257821d89104ee54896583d8e8c9d8efb8ddb35569d7f3aef4dc0300c5bb846 4982883ac5fbfa6684d5c4b8f72b41e5c233334a29c33939659ca71aa942d080 f67f72115f0fe982b735be82c372d51fc6ba6174da6d2940381cfd50cba05dcd a9da7954e5eb09bb1df9e3f71eb420b3266c2bbe87aacf79784a583cfc81afda 9653503dc689f19db10e92eeafe3895e469adde098158d2fecb76c018d26d6ff 59016d7f6f47176d41655ced5bd75af61e1e972cb16d70c3e03712f85bd73646 d5e78c7c6e694e39f34fcede4899957e2c743e0c0e7d9d5184be823eb89e8951 776cc513e209c90f8ca987228435a89f04a816b30a875824c4f9b89540b13790 179005d1f2391e08f71b5abcf04e93af5731bcd1e1641b8a3470db10f2958735 f82a049ff600bc1633dd96388b778ccd3455758d4eacf4237df9daaba4dfb93f ba6412fd7049b22c10a97cc6593fc66ff39f7d2e3b7b5c4cb935c4e7b81e4545 a6feeb5154053b0e7be4746d21e429fa48616c64734202c0fbe96d0239a5cf17 92a1c8ba615f89e53234897ee3de1173370d4e13dba2ec1566727f60fc1bc913 b1efc2b8b786e2b82ab6055229ad5f391a42e90503fd72d25047a2fef5baf004 d75cad81509bfe86941d9a30461de8e9a9a90a62ea2e578b217332a344cdf3cc 0b4580129f8206a325d17213435ba02462369a554bedb9694367ee9663bd3906 69556063127046f7f5668de50cf50131d5dd690143a9c6db7fff2fb7d7762209 b328edd77aba62acdc7d267bdaa24226a9da7625696e7a0b683c8a5ef6fe66d4 73078f5c2d60db6449bf92455cba3a2937fb08660167ac162e9e784a07c450e3 aaffdcad6a9d529c92e14959bdb286ef37a9663e8dfe2c98d13a4a84fb0defe9 2cf02d99f93845978440aa11f69604aae8cf97a873c8f6d506d1793f7bdd0a42 b0f96cb98002c1d7d8dc4357afe3ab003572a739a2ec63fb66947f0497cbd84d 81aaea97b5a1be300016e9e2113a5cc2c490c6dbcb29b1956d2d9a1251941099 6f80f04510a228615f4ce395394c15096a7ca34002846fb5c88eb83eff627921 b8332dd6d50a481caa662fe8eb9eed08c79aedb48f5bee6acdbf69eb02d465f9 7296aa746e0f9561d9399644ca66e75680d4c6ab0b52b8b6a3f43a39eeacea4b 2b5a065af745f60ddacdc84220ee6c52e39f8dba230650641d45429e8d69dfb8 31e54a5acde78dd853a77810874496d059ebd00c953ef8bb731b79407091243e 3f1e35d0a32534c5c0b8fa95f08377d7561b30c15fbbc7942e0a8e797875bc8e dc4b32d2cda60ae97ba58c57975d623b997003b75d55bdd09602ca1feec220fd 21a8514ca65450eabc9a2a2b90ff790567189fda942d119ec0e105b51921fb2e 43d766263f6f0ac6f4dd3e5cf2b2d69df7aa4ef6bee2d3e0e96509155028ba1a 261bc36890dba5bc9b3eaaa81a900a0b1ca8b1c4850d819ba8a25535ee00dc1c 667c911652cc4e9480860fa004c1201a681f17e2cc1239a1dbc3c03eb0fe6e1c e823a7dc36c4c1dcf39bcfdc74c58de9600cbbd0b019398e93a205376c28ca83 b04fe2c822027fe3ff1b47e9f74b9f0a830434d3dd4499aacb3bed1499fd6ca7 ac8c49c2213421ddf254f1e4750368b191fea7d44fb256d22a74b12f1f00adc5 4cdaada4a4596f384a66aedb1f9c30781a222e3dae7f3aca76f2356603d9e8b1 761fb5fbb8f5d085db4c97f09ddf3b96863d0cf351db4fe07b68c9436c4a78ab aaa429d2f78a78e444a34c5769a10ee1c38fc16c84a099183485f655f1d5898b 91455816fa0b2c8c146ff2150ae599c046d7a0df1f795cca953e20e1609e7aaa 0cc93b55f93d4e502f44b305d9b8b9e499b1688d0edb173a884e06e315ca0bf0 60d5441986f0c5357c9baf133acb3263e5ee6e20e4c62e76f8500bc36d96a540 f4e1ecc0e06f40b8920780aafcf7dbf5a23ce93949f90e213d38007e582cdeeb 390cb6128feaf03937493050f92d0db9d6e93e4cb2910a9233a9251f6f84bfe5 4dd8afad5d8255b49160cd64d33002a711d9b7ae5cc39e54e00fe133e0418304 50910e572c7dfc662272b26fcc626b5b8d2e2233e868fb2366dfe8d49338cb38 d7910da3cde2b9a48a69091e1b92ae698a8736d92e55ea00568e8e76c30f5000 53231652e999d43bc134d2271448d1bb102ffca51cf5bc3933feed57ce917842 2e897dd3f9266ef1073ba51e46afe445366f581b93e183585cafdebd8aef68aa b2c795b820491f3eb3b49a4b82923a2d54a8d55cee3ba0caf63a1827241859f6 3c34114ac444b621f904e1b5b04b2a6a32160406f33f9d80ee9bb144e6f197f2 34f14f1a6b0ee84a49276142652aab903468fba4cb230201626151ea6c6f5e55 d458936b93be498fec6d8cd5d79022247ef21452456199da98dbd3634197656f 43fbfd2adc3ebe535fc10a90bde627a27d1daaf64286b8adedee959f32bd97d4 0da6263936cf07165699360652cbf0dd7967fca72b5dbfd76ebc27e5537fccd0 f7ea2fb7d32a215617e7fbd0d992e8aab08d0bec9d65dad2289ddcd9c29e2d2a 01ee9bffb8c553366988559bf9f0ce64ffebb737b6a42ef369d7a89f5c62a8af f4e58defdcbf5e6d678b0c07f2f07a27f7077709d5b884efd5157553b664320f 50972b3a75c6dca3519567901cb7275592dd384e287fc5c5360f849fc3e7d2aa 69b15a3c565c177f6c99110791e32500a4c907f578ad147ee2377368cc0aece0 a7a153681a133c3ea2ba2788d7306c2c20d17842d82903f658dc2c23bfea7971 4494b0d4cd18c2511243003d9b2085cba56f6b63bb7f094ee385f66388d7b765 3230e6719b39fc3972d77f0b626f6f1601f740d6b5657995ce73a3226dcef889 42a7a66832dd3487a446f5ad2ec98df4b54f5f5d04d9694a1289b8a6d0228bec 38ac3515008b7a3b9a77776a18d0f08848d7c3e7ba620165e3d22df3eccc8f57 c240f5a5602160faf49ae0d5a9eb512883dbc29073fd0a5f782b99a7bd7999df f663b07492d3177426c01c2dc2d6c162562db08aade3f3d5a7f164e56d20929e 32361d593f0a0c5bfaa89f9fa98f8dae32066d8fc9581339b052b5dfccb3f813 0ac729dcc0c8620cb757e2205deafedf0e1e531a00224e1113b715c11d78792c 403506b6c359f000d63ce849d4a172f3875c3e37399e31ca58e4eb9976de0c8d 4237a32ecc75c72766e740b4edb4b6f3c57f2afa0d11768df845748da4db926c dfd42f2ca9d0b520aa32816d207a0cc76d25d41937869e8aeab9bd2fb90e9d89 338fc1d79c279f1bc15eb0d1ee7e2b5f6b4c9971d2eac2856df612f11be968d9 75f140eded0f1ea2ffa0fd4216b709d6b5f607ec2ce71a9448c61c223fce139c c9ce364aeb4cdda00959a439b0b9ea5915875e62fcd87bebab811b5c43a85108 ce3b1c3ddb7dfd7dd93b145b2dc7f28c5f857c99b49327ea85f45ff24378c610 d3c66f0178c9b3c695bcb40c2de892ef1022b06bb7f9d840a364d3471d0c7130 4532d52478c2654d0e562cc963e2e6048f752b2f00a66b5d94525c84d52931d9 2e56f2c2fe45cad4ea997f3629db8042157fa5881d35cd3910a7bae0c902ea01 f644536aa091eeb78b4c68a4321bbb0d59c611e247ea24abb36a3947c3775cd2 ba401aab7ec1aaece35a77cb34e40b7c516271fb2f1c9cdf041a921b5b2cfd08 4468e65c88d1ece78f527f6fb5d3dd2ea69dd913e69b50944b2980df087ee942 7b24d092a4f0153e49a649b7a29d9b83b453cfb3d7c25d6bd316c36d58621445 ae731e806cb13c8e792aabefdf46b6ad1065e7757ae2cacdd94cef1107485e8e fe00bd282de6b12edf84d97162f9d69b6b0c887ae752600e18afa75e42bcb5e3 47bbb7bfb410f452cfd61178818b2a670f901fb3ec2c7a1f5dc84ec83a1d8a75 77229257d5cbf9f8333819672e28d8d710b1e1182e5a869d794b3dd59ce0292f cddf72814456dd5214cd2ac099d0d8a6c25e84cb30ec6c44fe8a3de8d5c98de1 65efa0b5a33391fe8830654687ffef6fa8d8b8c9b2d58e9062bd71b7c64812ae b44027dc3f4a4a7731803ebe252d15183c34ddd1728e602ea0c70e0dc6c86ae9 6ecf9be75e25b8166fbe5288721d3a050eb5c4b50e39358d6b9945718fc55ca3 13a88eb993042a398be573a9a088088b1268e202aa27892dcd9cd54aab190025 6c6265f9781fd8da2fb75c06f032d7276b72c1b868f124263178fe4985c272b1 c54b31812055c3a0f77eb2475f3a6c5bb79d445276e13b9537aeff4f5add8a08 afd4c016f69ae762f920f908a38a4bb6994256b7605227cf2487c452647e891d 3d76678d57fb5ae61df45f4d044989f299bd8dcef3bde0c3cf1edd23b873c33c e9a1d3a6370452a5762d90dfc4388cbb30d06fe33ecb927e528b344fa8848d7e 6828d9bcc542037e64f076135b8098125c595acb72ff27c766aafb0542db2382 a16aa0d0b235ceedfbc1920a1b4801841bbf77cf447a327bbe41029d63cb5f62 876a693845ca46e135988e89aeb6834bee9448e3cac9c77f46a1958e3fde02c7 0b46c3dd1ebf98ce198a3bbb2e78f9615b252179c875a1db9a630feea30855f5 6592a56db22460682896457fdbb0e0fcd73d067ea40f551602c44598d482a38e 971b2220b28ea6344cdb67bbab99082e5c73b20b1813d278c6eb6d56795f22ca 18112f04772bf05445e6669e3acadaf8c1540531f3c37e6db932160eedb45256 695189ccffe55027a0c779e70835427effc45f05d334c34a61fdef75f200cebe be4ae24732784384e7a2ad51313e8a6b2e6f2b937019e2c947b54eaf93d3db78 4887d622ab77cd0ecb5863ec4f87247daa2911fde5e302673d51fa809c2387a0 1d64873f5c135443d3fdcb13609ed7e475957a17c5d307d2013820c738689238 e783978d5e6d59c7bb96557d161dc5150994de3deebcac8f09d8a2932b31432f 767d71e0bdfd6be37cbcd3c0085cf845c13bba954fdf5857be4f777e55a7ffc4 a012d38ac59dff2d16514aa822325b63d82c4a96e5eb7352b44536954cccbf9e 0f161f07bbb5dce120350f6e1f482b9856375a50174a45285a80f72d45b05b8e 287fe259065b6f29541ff1d0e4dd5addc67fc07440fad8b35a0670e0ac4fbe10 b6129e763a8f3a01f52e87f5063713fd8c015f9bd7d0d0cc7897bb1f9c65715f 5bd9eb3501c24083c50baaae91d5f2ba0dc77571d327a977635c7af874a3ef7f d916364c4acf7fdcb6df4533ae2d3b3476be2accdc25c2739f2bdf01dcd8fd33 c465e15b311984c05fd3db54da9521ad72aa417974844ff24a5f3066d0e3c779 9df62c7d7e641a5ef49e1904c639cd9e687e19d80d0c08ce3c0c2699b538fef4 26fc3f27b42426c4219733f08b99bb522bc32aa916f50f3c5a2568c1a7da5302 9aedd058a20732dec1d50a3fe2e8236f9f6b30707f087e6d11795dcb95331f21 6e1ac21e0f5e881ad49d905c8fb1500dd08af2c8a4ad1646a32a72d0242469ba 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 false +check_ring_signature b76c5fa70da5302765f86ad7d0e1540a7459f1a38ee2aaf8280344133d33e76f 3d427c219d5045f4254dcc007657c39828aa3bb85eea35e0c061e3d539e810c9 6 b7c48f046847430188ffeb89adb6595745cc1fa5cbb80e54c99a99018a676942 2ca95f9b982ce0971826b8fbede352733a7838e2a51a1fd4fca7323fff5f5d0b 29fa5b9df05850aea84ebd32a5a886d3f94c96960458c26199425589a15b8ef4 c524e2d466e16fa39859d5710a694b0efdcf09c35d3a2a7a96d86c0b6459252c 44535dcb635ee511469c670ac42e0e3b34e0955033650c4b75423cd554ae8d81 1e5377c2130a2f148bc3c54c52f55ab32f126bb3442f253e72503c7a71e3d275 b11486ebc5560cd93de2fbccaafbda2badb9848c42ec1aa7a366f65a8fe1a6066ad50aab6f28ccb6b1c62492d3dffc7af1e3eb78c1e59614f4af75be3def762c4324424b4798a722d9651bfa5da1cbc3f9b05564c84f2c669551a5e1bebfc604832a27443d14436f755e6fa6cdbbf64ded6660318cdb8dafcbe57048692941009baaf953a1e087aa3db0955de8beb887595c467f972b8b116fea45b4c3de1301ccd94df636990de7564645fbf2cf596f328735147d5e325754a1ebccbdac3e01ea4ef0408148f3515845576a71252ca2662026b94bdf66e3c10d2c7f0c757c0d86ab7fbba8cb74222c46fdd67d13848f8c86e7307b672004f36b11c5ff9fc303c64db3deb1b37892580a9f5fe250d2f345ea2f1c1f4934e0ca5e4ea758e74803ad36804c36fbd7fb95f8912e7bb71b07d4ebebcd516defa968d573815e4d3106fba851575d40e2d2fd1be6031dcef8a905f80f0403a314120b6d25feda6cf70ecba4531d07476a32ddf75cac9fcfc42a7e12287c012c6b56b22001f4a252d10e false +check_ring_signature f66628aa258991283d9cbd2863f6696d51d867dfdaa6dd307215a7ed011f92d0 193b442a24d8a4cd6e8b54ea05679caa6e61b52822a220c6ddb3751d7b66d909 1 cdc92b67421401ddc76050fa294a60467cfaa3662e194c013a7bd8fb3f0bd760 1b0be1f127b683e6752877e64e62a9f45dcc0846f5d7e31defa2d3e19c13920b6c71b42d1a01f746506240bb2e746b31591bd9088904e77f66119f97bf12d906 true +check_ring_signature 0443054ecfc3444c408e653d099a66e01c22591b9af550a1b664f2036974bc64 411b3882dd6cd9e8c7867debe2363bbc8ef05a46bbac2f1768fbe2bb08d1602b 121 55909b067b7acf2438166d88bc8121c7f8948b378c177516b4c41c08ab29a16e 69fddbb86bd2d4adaa648dd49d92e0321c60c04f25db8d1cb9b00b92770dfe90 fcb375f4e7203afd70034accfe1f4769135f57987a1fa6af4b233c8f1d879631 9d64da90d656fce3bda87c522fd5669da36e929f65919ff2a6871b07d09743ae 8709bc33905a62248b80f252efc397f7c6cda0a5c7acf5764ec7410737d94dab 8e384353ebcc6303804ad40aad5a99867da5ebd599ea45670ac4a1f77353dfea 88a487b4fbdde4fcfe1145ab14a8c7cb4c97ba7118c9c4275749cbe40ce24642 735584857c9d7dcfe0119f592e198a6daf21211f53a52eca0da6b779299afda9 eef56b5dd752e8a0a10aac68489948fd07ee351b7c1f516a863c434aec85545f 2381dd0ef6c30ae973f454407be976113d19e7c7f7cb27ea0037efe4da6e513b f819ad5260c14357b9056e19a538ae596ff0c8bb05ff8a1b25362b4bfcc75176 aefe1d7b47fab04811eb604ff64316d3a8e432c8dd381084cca31b4a7fce784b 3be8f078e049fd7b530f9df274d7bfb8c07945fbceee68f36459d019bd447615 e2d67b524bf44504f5a068e354f2916352b66e2b9f7877f4781842455fe41fb6 c81c389b4050d272f1b5bd543d6a270b3b8e8860d66fa3c123293a8cc5efa73c 3b66fac49b004ddfe71172761fb238cea74dcbf3a5ca38ea959dfde2579e9d22 f6af722ce23cb0c5510a073ab7616fbd84d5696dc0747e26bec1b4905019f3f7 d4fb218b9962b1764b05acf3bcb1da382206d71d8fdd546e35b32972952441a2 92d962cdcb95e4f80a25dd35cf85cf4a0baa93354d578131891bfb8271fb98b8 baed46768a9fbacf45d6e3e428698c1b39d1c27512c9ac5b2c33393880fd66a0 b553bc7b380161af1b180faeca126b4fc87e087c68a41edf78bcf5e26beda1f5 31e99b9cb775a586a89b383880b593dfd6a4b4ff8be3da7e70eae30691a34f06 892dd908bd7f30b8446ab998858001e8abf78c0de0eca8761f44e13fa32a6b93 34ed757eeb440082eff2c402caf89494f900e52743d2a28284383c6485bc96ea 03fa9cbc5b21ecbc78d357ad7113bb60d80c5327aea7deb987ef6f8c36bc7881 49ec88cd8fcbd7a1f4491bd0373d00351e2a47491b99a34fa5850fae99f003da 34ab88ec7f9bc8b55fb42abdffcf4764a309094481bdcbc8a3703333386b8df5 840acad5816e6b9f7d15859635b118abe8171f111ca15df84afdc1640035d682 39f69be5e4057f1722b8d1bb22432f55d062872aa774005e26755098780012df d8cd8d438f7367d7f395c1468375a1715d8a23bfe55383062f56e339bec9f9e2 a168c4fcbb643d3d8d7f1f759fda60d22a92767bf59aeb1de1ac56d6fcc7d77a 868299e3a7c0e6b3c009f15f5fa06f25cf2ebf0e8a5c839db6ecfb6533369213 379bad8218076aa09a6176e604ecdde9d6c5590c85655fc7fa90ac077a67d697 9052afa89e0f95427ebc9548235089dac595d0f100bd59e2809bd95ae0a8e803 ea96618fd6647e0c141d0b06eb808960ea2031e44a84ac7c06e3ee1523cccd04 019a3248bb6f6ef81bd33c3ea246c794176aa57c6ee3e3f63819884a6c0cf698 ed50ddf386fd9d34500f8381c4d4b97bc63cf109f4029aa6e7d4b8db28f088a6 9a753434d3c2daf70cf752077493aa01e95fc984a617d32cf72712a95a66ec42 234515869b80731100c180f409604f4cc2c41848ea812fe43fb19cc0dae34a1b 00b7bd3590114474c70707ae3b7fb97df6b9b8fee97667dcab98a7c98af39b70 584a477e30bce655e506c696bb1a06958cf3ece718f4a3dc1a8d3ba99ccbcbda c3f84535b7ceddcce4c44b94994bfa9e98270d40a34928cf044b78851caf8771 047db5f01b8a5ead8558aaeedac32b46c0122005b163a2aa4ae4f33ddfcc2217 7269a29c4d7fe5c86da657561320f4031a5ae8bd24e36ec70b34d5102821d5fd e5a39bfb9956c12df687839477ff5253ea28c23a6038bd180d821c08a2b0e032 479af578ca302de352a5557f30d508dd351c2d7e48aab82fce26b73144de5237 e04f5fccca7b224408bedb13c88dd318514fc8f58ce0b7595b94643ac3c9a04b dd3c26ff0e936824ce0135b9d8fd3ed02a3b23683504b7b604bff55433e39e6b 89caeb3fc4173c72c7b07ba0516a974ac3dd0781d50090518f796e9538a7dbe1 4b76c3096691d3385dd8c47bc659971796a1749b637b5e8b8025db34a8d4e3a5 2e28a9056161566130bca6f930970a9f28bad80f7b31c3c7ceb2251e92e78c0e 4b005a03754f845e66da462cb5a723e9b4a954ddd81cf1870846794c2128cbc9 b47234eef621ab47841ee62590b3ae3df2c27a8f43c24b0fc641f805192ce9a9 fae3ac01b70638850697745ebcc2dedc5e7c50ffccd9e8a0e04f6ee70262877e 4c19a584dddb42a38d0b8e753ff973f86016745e42b135cf1de3da9fd8363536 42e2c474d6cccd703e86874d0aaa078db760bdb302f08af7781cca03be9615bd 9f4dc8d482884f9fcf8b40768d805785e852548f52f646ba892fc9104490b8bf e43adeb094ee08384cf0e81174049339a32ceac5ed2f9965dbc8071d96ff991a 18833a602131f5cc01510eaa0a0c40c338582753fb149158fa9997e403ef7bc6 ced865e82445857ad6f319a9f1807cade1fd2973705add2f4c6b655586a4e0ce e6bbd67c5c8df864f74906f24872a3e6382b7ff5651f48630808a90196db7f8f a7afdca5ee5e0b5df3e21933f636f8ca1b52471aef11ff67af1c69b88ccd4adb 576aed87b372d1a5db55d7404d9b81069c3cfd84bc787b43f4b684c17aa38fc9 3619bec8712e9f227a66ca6e2b6954d4d5d399195e7e086faad091d166e91e04 ccf0b3821acf830a920ba9da89f26db1fc5f9df5ca9ee007d37835ffdd3d31da f1f148ebef60121cfeebb62c6ab9cf4f906601f2f0bc272997a691c5b845f78b d01e44887e833c63b3f8143b3022e73f1721f7ced698bdd7dd4911f827cd504b d9c9a6bdf693a18d9a9f675cdbd46c182717ceb8e84b689032056b191a54f820 8b32eae1d14e50950d2a5fa4059daf51b8a0aaa54e6e8cece229a5451cbdc5f9 2226649d865a3c121060a1f5ae16986ead178b16a03d98f2fd43e7fb8a47eb87 ee369ca4bc00350efc18defe0a45f7b2bbd1e52005c65891078dbdf7bd4242ce bb611d0aee7dd1601047d483a5e752d986395ce4373c1d479e0702ea814ff116 e3c5e2631a648074cfbff9fdd5cb3865877c8ed9740060d8ec19a8c0e68b4a3e 6273542736995bea142d51bdb12fdc67c45b99fb2644cc0af07e7bdc6174fb1a da3d1948dfb719ea86205cff64314bf94862fa8a9fe8a055e28a84a4eff70d1b 18246393725a72d3066bac79ef8782417daba4f968fc082c6b19e16321e31988 b6c5d4c56ab48e109480564ce1f7cb3f3f721289a0f94dd48ecd33ad3d6910b4 3c0881232d6fb4fc8da12f3d0ba6507eea126767395f519d7f1af417d21b24a9 138056d6e4e94273acc9f27245a237315af8f753572a90b919f285312af7a995 dcf76815300a5bd560c7746ed5fb89adbe5bcbaa055768cf704e439ebafa212a 57db39131698ff9661c81df88fbc0126d5ee0669b812f2f8db452c18152a6088 0e80f14c50018a6141dbad54e488ca479900c992236106b2769c2ccc3cf081c9 e31261e6925b1286f5c7a60db74ca8824d9e2ef98d3743d7466d95f412c71716 3edd4dccad4e686c54d2466e512dae283321e3e3c5c4dcaf4ea7e8486d3fff91 ae42a94ba31b98de52927763bc7f1c2bafac4c1a5773e9e5572e9755171bc92d 7333b1ad259d99b567065673deda8f53a4ae1cbbca73268b73428f2486efaaed e21452330c0d9bf1b53754355e167189c9fcbdb299d35811afc7cffc5a094503 d4bf4dbc4834a29a9b5ba78bcdabcf5d4ed9a0de00432e345fefd681b71dc0b8 1a4c78dd129fc9348deb71ce085ba692204d26e49bc97a50d5c12e998b545dc0 cddc5fce2013adc289d033d5783bfeb8e0e0009e9a83abe8d8c84edf965041a0 f17f54b00f88894ec8e9d73a54132de311a8306bd6a18ea0813675f9185645d2 54c6309fe589f7fbdc1d7f18bb9a48e37610f8666488e72d08c8bb84f9cee567 417bdd7eb88aeaf9618a6e8f6cf7928ef3ccc4ef6d2dd552484ecdab72a261cd 1c6188f8146410b8846f29d8077400fdd6935ccbdb5d22d8d1b78f2f676c66da 87b9a5cf1dfe10adaa9ddcb67747bf800c40971b65c55c0c09eb6673ed7ccdb2 1f60291b939348bf72256c78a71b4d21766390af154860ca8d5d4dddfdc4df2f 6d691c1d52a00c455480f90b84541d56cb8b2e7be4d21422089bb7869664027b c6e0e2822bedfda66f858abb102d28d2da1368d4735a27ba20c9c7ddcc5946ec f325483bae78a70ac4ef75c4a96b4cfe4a24499a5f6dec1e12e2fa07922785f8 6d20a655e03890b9937b9f1a15516572ac4bfdeeeaea761e48d8e96a3df9355b 944607ecb31a1f9a43dcb213c5700055eb05b64f5216dfdb568af69a9b1cc749 5fb4676ed875af4f260ec950c7681ec8d40ecca3b0dcdfe56bdb44c856e0b9a2 f49f4cd110cc0afe50523dfcc81f2a532eed97ef2eb741ae3ed10b11d0ccc804 5bdd0bef2b3438519d11d25e21d38ab327b44b172f6233d14a6692491437dc6d a352b6eec19b4387003677c1514d636da8e5f6053f04fbf1c284d04b5ea5e358 45123c1bf10f1ac01a7710105ca46fd5d9dd20a2a0290ee8bf96a9af38b47a16 f34f5fdbeaa68a7c0028d6a7c8ba7fc472ea66f1b3095da63d3f53fa0bb98caf 0e5d7355d6e5c5b73fdcf0ad172a3a566fbb3c71eea510d61c416c199c59426c 0fc5f4d5240fef62c696c0bf8977661e8cab6b2ab47d3439a990e401aac6727e c6385ce937a51c2c7a9045187c81a3cb7fa5f421c83fcc0c1926b08449b36f88 814833b05cc60d512fcb8c68e02213564ca5ebe7ea68c3a22a1a3f105c8ca7d2 b244db6cd9a91184f40a6bd453b0c0a2d52a72b3e11199489679f4b9f536e44b 5be3dc56db7b3b8457a7c12ce583e651d8d20bd665eda32aba4478b44f0d849e ee4e888b54ccd526524894489c8c69725a9b8424b3ed41d93dbfc429a4c975d3 1cf9f35c2463b134af064148d9a1403e017a73408eb68042d31c6a9f3b92e7f4 c171eedf7c328f87c7c9c14f2288fc9869f3818d064d44d5d6ce6c9c42d296dd 039f046ca97fe2b66fb9e186c3094b61c13fe7992dd36d629302a63019d2043d bb51eeb1823442b107d5f033b001d2a4b82753d5137d3b537ba344b7c212ba13 68e700e51227754cae433ac999c70d22571dd24b4c38dd2698856ae736615ea2 18ce4d2bbaec3546769b231cc286a5aea920ba9be1f0d976a66ca4918bcb4323 f7ec7687aec6e134cd27339e061be1b02ac72d173f3076d6a8abdb1a339f9759 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 true +check_ring_signature 6664ddfd62d4db52cc3527630b8e4bd45941542d292cadc745ab27e3b6de6446 a4e16dd06309db9140f560577c1ee7c36e73b774cd028b6f55609bb66a019c73 1 303c4e5b2b8acea9bffb433f117e0b1a754453e9d68cfb98069c40e9bf208bc4 7d6d2450bd9cbf647ac677eabd62194f585098575be0f8df58c5ef9eb687eb05ccb1837d63621815df56ae9c421630ae443cc25c04cef8e129f68a74bf5e7607 false +check_ring_signature 098c228de28779ca4d2fadbd8973385caff9bde06161d192ef86f5351ac99b81 a88a4b0fb7eea101411c6b2b7c9fc235ca8bc8cc5ee740cd4c7123910038d745 40 ba78d8417661a6b9908fbbeb4fb50996042cba2a9b3ba52fb6a71727c3590f8f 24e97d1aa5157f56c5a7a8f5f21369d4453178f878fde12f34898ddbc2440ec0 bbef0068d31ca15ddc3a6238b1ec4cd8b574fb596da5024fa39a4b8d6327b986 57e1d12f326a58c17cc7e764c866ac3a3f074c6c0c884ff151fd1c697455ef6e 6e8a0f2e35c7cd71430694f054c3d64022d009d71095b183caccceab7158d07f 88121de2616c2fff3e5afe6186d345c31438189a94b751d8ec96e641cb72ae92 ed8112f8a0f21f8682274db02b123ea6c9fb26b2d26f3735a22e14c268a7564b 25b02a9d36f890c94d1564af9e5dce2d767d9c72557cd15156ee03332aff07f7 ad4acd68a59869c7bbdb95b1782148221dee4fec095682246627ecebce38579a 5926b6b97d3162d73f29c3dac30ac8cd3695dc71fc9337ec3c85aefb232f2a03 47055f963ca42daa585de3721f746c82ace2e98566b924c2c3203295cdbfbdfd db2cac4cc971d3456bf70a3db302b1f597aa8cb1cdbe02f99ca90c81d1997f45 5e1a9d0c81de1a3e3781b7ffdbf8493a8ab7164f1cbb37bc98b85d6753989724 154abaab36ee0080c8c74a79582b0c0090c3466c056fbf85bf4cc88143caecb4 ffdb6a317432d640e7a6b3cdab48c2830aee129112e0085c822c231fe638d610 3edebd9180be57e9c34645821aa218a8832ba4c7c97c9fdb9b2c9043ddb5f178 1556f39491dbc9a7434954038ed59868ee6e4ad6849cd7e8ef22f842d851b4c2 4698993a4657d61b0e0b4ba2d77d0a403ada31bb55a7db78a8709238ae5c94f1 d424e27d49e1009203aef4143042b49a744f1db406312bb681a26af7b807a3c8 b12a7498aeca083ce29d99c24e349bd35ebd0f3fd6706a04456ac387e5d77275 b493b1e5e8bd5b361f0eba292a81640f59b64409173a4eeecd5353b3c740cec5 707d531de041d91b8f9e4f7ac53aff5c2a25937dc4c1d6010bf531164f46a718 0b687467f5f1bbf5bedc63a70697f341745546bfd5929474b81e96bee8316d88 3d80728181769381c7571c16474c1480513e0fdcbc0908f5e00329cf774259e6 f0fda5cf17bfeadaf49ea83e5ff530d51e798a143ca3e7fdab900e5ea6e17ad1 58ea3a99b04918c0e35297d68297e3f4dfaec7535b704d413fa9bce574773388 ab60ad352f222ee1c4fc02ccd6e1d3bb435580add45cd7165423ec93cdb76aee 089a9ff4f9cd7cc6d9fd6f2e30772b768cf2e116c0270b0829736dadd8a3110c 23179bb6ef5f50f5206ec4b58d9834ad92eed4789a0644137be990019efa9889 2fd13df0f048919ce7d6a03c34b8b11deb5bfb6356770cc97edfad880365e585 75197ecfcbe5139c3699000851b4da93148566e174131cc226d085bf1b4c5f1c 82abce2c958cb869c0134ee849ec75d754fbeed83cb21ff80d9c168edd4eb3ae c0974ca50ccacd1dfeb605fe8de16e6fbd1ca7387191e219386047bc5db76ee2 f13bd645d69ce38fbde559eee64b90872059d11b0dd087f26bd8c89a2d289417 e625973f2e39d092707ee540271655981520a0995f6a702dd8817a8fb99eadd5 f0f6c6bc2d325ebb76a41b0b7d903c315bdb197ff6110ff2969d4987cf5f7bf2 53e52b65b15bccda2bd1f7cd32509a7bca632d5b86c69b508ccb564d7f0beebc 0331f6ca9a79b8dac04937e8d3dc7a27116293da863e6847f1387a4a9efb7c64 6f88d23f8e881b315f4e99a21b2387be15047d65033f26769fdef3109a589389 55114566ca20bb207fd063f144b280fefa7da2d34987eeee3db184e631074eef 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 false +check_ring_signature 5e60c84f90470fdb92feb2993e79db56e496b59414be9c1980b3d94ca80bc03f 8d0628445c5978c8cb25e3255c03d61dbda99374aada6caa125269367af2783c 14 0697078ca6d45936627ddc714c69ab678d05de4c5db5d42f51a0f4b77fa42580 47f4a3e6df3a1828f2be93eedd2275b421370b3edeeb539f3617436d46385a82 f89f4fc8cabd9461333b82862088c36f037fa8c6fe2530c1b1856a03dc0d2347 feacff0fd68a78bb8f407bfdcc42db5096dedc30add97fd1c35f00b350269183 e354b55d368e8c1a32b079f52abab69e4da4ce335a7ea5a05bc7172fbf25301f 2efad00457dbebe5aedf96dce26f41993980dee02b71e33bde6f970741b38c12 14bb7383c4c14d18074e0c6032bdc28e5ae1a9484b0e60ac7967bf55b033656c 40fdc3060d8878604f7ef1496f069feebb6c87f5adc0e148014a9cbf762a23fe 0d05df8eb710336cf486d5a35cf07cbe222ccdcafa10157cf95ebc01b6995d4c 87143e0bfa2412a4452fd19196754c77ff7c4e9e95722b7fd43d374ec96b7f6f 3769a2243ea7ee6f49aa28cb40e60cabcd559297f4f8ecf8388210f60972ada7 8c645e36f59dd5df6e61998562b4b27340f812413085d36ce3eb2b67fcde77ae 800d5321ab658755450fe58eddcf334188ce7a31c3684823d128fb4ce9bcd32e 512b8321a5dd1dc130b79bf77ec14c5083c4b397662bd4892fdf4535ce7fe8dd 493a609624e08f9b7688af5de1198d79e2507eebf09bcb835f70faf9155a7e01b5a10ef5aaa8327fb32d605b76deaf96ceb972db54cfc3bf19ff77611fdee20bf41cf223fb05181fcf1cf72ec3fe0dd32b452458f67d36a84cc5a106d11eab0afd9bfe1b76fbac0b0b0b2afca66af4b9e3edf106a1ecaeacd3ea880b53bb030242a297322520b33f0f1285832ac45ae5217c78d2eff74231fc85d0718ea8530f4937df4c972168dfd657dae8dace2a2bb3e19a071d03ea6c31d61de6531c230b770459d44ac693fe37ef99704ce850cf6c39bc9b0e967d615c6be152a0f80d0d707727d9fa5c9894897bb7eacd80189e2a5c087a754362b7dfd7bd3799ce43017ea29a0f0d1386b782f73a1fe2a45132e0244dac07f73f70bf4a3e0cc949bc004a063b8bf0a6eb5d480340e0cef038a24d1287324b86841edac8eaf7c6985a07d5a463e304bdf819f2f53ca42e400def95e8ba9cbc60723ec568950f1db67b0c4006d5d0f3075a780ffbf38166e9b1edbdd65279c8f4a06b70740eb7f5ed7a0d8e8120987ba6e72a177e2978a2f4ff00ddbe51888a6dec3edeeaf49d338e3d0b409d41fed1dffe31a77a3d3ed9c55a7481e09f0102dded6fe4305f001af5fa0b483260ba2c08307db04ee309f0144b57a169c6b2a3120b89ba5c7f72d5f262011e3ec3e80c8be0960a9df6473f74265bed79b44333e8e0dd241193cbc2bdf0099577a12b4c8dbc2096bea311a80e55bf9bd8428cba22fe9d385e796a93665003f8c8cf90b8685f06b16e56fb75bb5f940f761c6e6e5ab66064e79fdef225a50cc6da6366effe7df6e8595ecc155560feaa14be93876feb20ddf780ba6174f2036598a75139dab1f8ebdcea0853cb81a2fdae7f28c7549bc78d490d9f99c26d0d016b2a4791dce52d4520e0fd788a1d3c74f81fb8c1d2661ed88ab488d501ba04eeba5da4c7d6f0b8d8906404ae7bc9f6d9cc9e51836ed60f7527170689be7d00197d5b883be8a9213731c0424c8082f20a14572262e11c50cfa63d35bcfdea0e3daab6faff77f1ab6c83df5ed3c4b41ebf97f341e77834cc8985b75839df640f8a104fdcc4990e6ae6b12b6f22960b2deefe13ad55ff94fd83a7d4ab0de38c0e9d1098d2da3c2e96eff5a5783caf8ee3065b1524eac2f5126d6d8935938e26006fd28858ca49f4d5cdcdbf10d491093d6c0c0a64bda84ac94cf11e7cbc5cbf0201aa5153704a4bfc27cd3ee454f02d064d4bf0ca27697ec87dd2610c0264b60c true +check_ring_signature 73b51f2fb7f2850bacdf69a71268a87f98703171346b499ef0b416fc0161b104 a042a66c3a5dfb443f6941295faf053319abc79d62feee63a801282035b59b3c 8 951be4743e2aff30bae6578993fcbf40169bad8d768e14bca934c3ebabfbabba f6cd6506367f94d32263c29ff7c55df596260d19ce3681abf7b94e0fd3c87cb7 0bfbce60169d40e9f226302f6da350e66a3909f92cf31ea9a015789ec20993ac 9818891d40019f6c4fa9d60c53418d27f7432e5b3e9051184a6c07a421ca02aa 5d9711d1cead9661ada60219c05ee60b4e0dab9c974cd530ea602c34f53f0016 ea7622f433bf6f1fd6ca5e2fcae08ccd926c323c1b3d8d34d31dfbd05ede2276 429dc689f6786d28d64f5297e8b42f9880df0edeb33c55c91de039b8b89b2652 fe432a71a8bee3e1d8a538d646d61b50679a31aee27281984c9759e20c9c5848 dae85a093c04ca677ad60cb1f558a857319a9013d7a619143c952374dc8adc0b416f21095b5976c1f7a2a822c139dad2bba9765374644d70f8efee77deebe009f6cb9ebd2bab6ace167b5160cbaed9ac00c94f03101b921b101d4635f110a90eff2b661ff4fb508bd7720a4355c98926e81d222dd8cb90142c4fcdb415c9a70bbe3dbb843a0a758f80060eafa842c93c30a01edcc801c64e4253e92a2229aa0960245170b1dbde27dab776a5a190b02168ce53362c4975e3e656377822bed908d9ad99dcd74d4531d49fb071edf666421d82178a15d9b26a4d830c4b9ec2f607ba979ba546393a86258333680419fdba72ef5f6ade937bf352ed05bf678afa0acd76be46b01cb10d9139daa65cc7b43ed5f84e696ce840a328e9854b07c50a084c6c5bdd4866cca3f1d0d7426654db91ecd36093c07efaf9a681c2b4e0d0d90c9f1a485659fca867335956b6347e16d249c3ea0f9aca5b8f7e0f2294d4f68d019f5f1166081032a248b165d3186be59c086d34c8070aef6b257e94897daf3d0f62b171e61a76ee2833bdcca43783f7db14f5853157cc5ae8bb5c8c4dc0dc050094acbd81a4978f66a356567036bc16fff50ea0b5f0532bf57074a9485f61ee0e7663229a90a8bfe0cf52645ed65db0bda9bee7fd9a8cbe4b89e06fa6bb533209d44867063c825c80bb98a06bd79e0180d5d5c09f9353db74995b757c7da348b0 false +check_ring_signature e1e8c636af7726f032d01682787f88057d5aa2b345561899f56ef2406a48aa0c 76d82cd5c5abd87ba15417a57c3e2328f083de06cd75a4ce62397e40a471800d 3 7bdb3545fe8cc8cf61d0d14b7a35c6c6cc2e30a6fa5362f92b84fa7df0275991 e7dc7fde6292256cbde42f1028509856e97d505c08b5cc389cc3ff4cab66c1a4 4a63077291afdf7e31e172855db908c523a5431b5d136769ac786573dabd3fa8 6a6882d5dc7ad5821f37cec0aa4915147d0270c1c6940c5fe7514a482b8df901ec3d3cb484d41f8482b4b4b9cd819812dabe1182d09899ccddccbefa39888e03e835735334c7317a8f56a1dddacc50bfe2afca9a634b3f1ac82d1d9263e0d60deba45b291067a5f0234e25eb412f0e0a060271eef1ae484ac15f95e619614e031b9e8187fe5d9ecf6c9911361bd531a8140d0864ac7b066c6473c9960eb1b90ca11f376d509a6dd3dbf0839f17da669090a1ecab430b4bf91deec17d7267f906 true +check_ring_signature 236bca93cb9c75611c53ab04deab49693de2d33ac7f45daa6bbbd4fd9c5aac3d c9ded5d03811aa4b164d9fb993f602a20ac7b574a4ca3232db3eba9992892fe5 109 21b633511119ee81e124b14882e39dc7e039fa97e7bb015d6cadbc6a135d18fe 53d8132e04ef5b930e5343cf609bf2e2c2d1507ff9363e45574d486c1cb2cf25 c7c820dc97f8fe10c77dfadec249a52297db609261688b454b02ce97718e9ca8 5d798b982252966809c20f6bf0e447e80a04e82333cdb5e3a2c9a3c6cc8c57e4 19c1decbeec68004b1275b009d9be1521264d57761c43b2b40034ef05dd6fd1e d5e76765dde2758c4a13911580cf6eae972823e1224cbf85a60abaf6733d4c69 cc6257761706ddbe1e6dde5b954997d74d34ebae4cf76bc5b317e713119025f1 2a710636d5cd2d05e72acd4427f49069cf12dc3e7273c8242db47697da4ec9f4 67da707db2658509967c733d3bf7646d0ed25d38dd4cac67e1fe49fdd0411cf5 24f6e85647b35b51ca12cb836720e8d0e60fbafb4d2ce4c1be087f3581a80f22 1f7c4d12e307e7b4e13ed01fabf81dc8b09df09982ac490e51c581372d6192b8 5bb4423873a144ed5f47bd5fe9434546705cf8d611ea7ffe43e38ad1c7c5ce54 d6a5a0d9ace410d8c48aad1782b4474392b063866727463b2ab349d83131ccd0 d85a57cd0c6ec21dc3402f8c786fc70adea03c57419dab993c465eaeed23de7c 33c570a29db5ebcdf24759d08a3df691f1f7cad76a01c1c0cc6e24d5d11b22d3 52bd49f1ca331a64edf11548c0a9d5908cbcd177293db415008a83bae273f4ad 99809dda7e4fe2c9a1f0e68499ce813a82ac6b13d346e4518e8124af98a1548d 96171d8846a79c8f9f95b7c09f232f175b99a648e1041cf72f052c4e76025daa c797783bce05e9d56b3b351b361faa64908e8fff8fdb0caf9e398f0afedb710a 6377872f1aac7046d696e57261ba4cd454a91cd3b92485091856ace97e03d2a2 ab8325f22fcc6cf9d9530fa22515b33e317fe86d5c9100b532c212f0ec1b812a 639a9a3a1b5e381038ce852948cee0d91f69ec10dd085a750b23893a39c617d5 48747e760cad1eeeffcd3f528a33e6e9d1ad051625bd05c9b55160c8ffc4df08 ae20b4eb6ebe6d5def7e4c4f4a6af10ccf97f3263080b64286db83c351f54ec9 a083f0a00a027d208ae49c2a64eef903e0d6dad16581900d02d98653f845a720 e3f854e96e4b9091212da568eb84a90c175600b67d721302310b34e0012c2f31 c3318dc9c780b74162815da6f055c0c8206868e443b9a07b9fc9d459e66bdddf a1666df44f6f4d334aa0fad8039fc7350a497fb1837c22b0b92d9e2f65916379 8414b88d6cdca65192af065e48e527d8e88dd8ce2610ac32f9574d18e5366e94 dc09b95c8e75d500f839ab18c608c6820246ecfa7eaac8ae89927143ac16d1ed 30b208870247c3ee3359b800abde386d371ad6731175fa50e924d92cfa72d6ec bb2fd84d0f5f5b56239ca3bd912765e62839e4bdd70391aa1bf9e9ba3ff42132 f24113b34368e89ea491656fb25062b0d71d40670aebc96cb4bd3cc11cf51993 2aeac6a7dd94e20d38bbd05c197483752c1ee21bcac2d7fb8805547cdd5c2ab7 56ed1d81064f9a85a7256799e082fc1cc9fb70506f6d2e2dc53aa04766ee5b9f ac91596d69074da4d24b1e2e6d2fcdb0407f31ae466fca0b315ceadeb01e244a b212f26c1cc2be4b1bbd4348bccf972ef9e1a900f49b2fbf355bf46f3d316ee9 82c86b9104cf1af4f1efb4c46a191fcd94f2b9e1771977f25b59f7b3ff5dea24 33adeee2235fe120e5818eb4ba4d5ff98a811f4c767ccbce1b1bdffdfbcf908d 1ec3cbf49397536b8b44d8fab1733ce08ae9f5c7e2b8fc9106901c0b819cd658 fafd8314ce838b9ed3b33cff096b6242dea00343d9f948a1de5aaf637906b395 5d2e23ff140bf5beed54faf850f15ab2103a567b47984179b8ef8e227dc73c12 b1dcf8bc44be11ad79ea20a6225cb9d0210134a713af34a9cbfcf6ea7c1b87a4 f8fe6927b88cf7cabc75a2bb65cdae2ca21c29f3895c0b610de98c2a033ec03b df2a896c5e4d11aa617f11d4a88a31971f88843fae40fe4d08fbf6a9a2cbdbb6 1425a3bc0ab9517ed05e345e9f7aa2440f0128255372c94cb889ea293ff1d63c e65a104010bb11bf68bfb33639b071e77fb59f600788ceca24bf2f9bb985c285 f22c211b288a1dc3414c161d58ab052b13146771a6c22688fb86315bf72e109a 2feac0a3871b2e165d9e18e768b543fb7f95e4848e9316781d5de7e9c9469f17 d26b37cb0bfe267d73cb39e3d782f029d1d235b5683fae1e06e1bf175b900cda 34d7c7014ee8ec21e480022bdef286979fb410835a4d0ed7386138402999d7cb e2da0a66cfc92cdae96b519c60fffbb0aa9292c216813e486d62d97693fb67be 2968f721f49e8ee29f138f1482a6f8af35a60bfa7669808cc379d6c845ec7899 bbdcb4833d73dae9cadbaf959f798ed222bf07422ffb36709b2fcacbbf660a08 d54f324e69ec32d5ffd58b8c2a98075327e2cbbf29c7fb792c6f404ad5322a59 3f122895f4e3573646b8e3aff5200425aeda593fb485a108f1975e26ec60ff9e 140707baf4982dbef6bfaaabef434b1307e1857919887a8d57a432dbb4f5cd95 d24b9d7f44884c39eecf400c77529d7f6ebfb6ecc7e4731f8d5ff9376b5e1886 f3e4403e3f1e3646ab0373ba93eb0759aa69c5f710011313704ea6c447980232 cf7bbf20466ef7c076db09449952e92aecfb888c647d69036dab97cba77e47c4 30de23a6564e1d89aec3362728fc38f886260017203330d34bea292a707b491b 8e5c56672dc3b7a0f309dfc3d7bceb1e16f1fa32bc43fe0b770655a6d866e7e0 9e40d9911088c28326ae6699ef4ae2f58ff175e96028baab289b13af1f687c00 4d5af321d71289e966ba46f95326563bf4af0876c3c8301978a38fd9b37f691e 57dbe69abcc19bf5d7eb5370e37d04538a54d9f7d73de6b45ca371775814be2e df40cf6594ca6b1d9d9cbfd676eb8c1c8e451fdceeb0f82d291e67a8b5945714 b9f6bd3ba91fbbf31f323d696fe25a7206034603c300aeb1eab79328b86aae2f fe12440886011e93cd34ed78d6a8a163caf2325e3e194da98e9b75ff63c8e71f ce7803e8880eb38de0ae044405129177659303f0a7f02050e24ef4dc17edc16c 922f48ede5f02e1b483aaf70bb0330c65ae0c3ce4d237cbc8fdf054717699962 bb575827e25d6451dab88d0d5d3743d23b3dae08549b28f9ec4792d853044d9c e37d8f08129eb183b9de21a8a1f2a9cf6dc1a88f47981604d6c7b9a2055b41a6 d774972c215d2b71888ceed625a8ffc8896b4eca2eba7bda37e8e54160b69745 5a949eb192c47a82ee29305df440e7eee4fdd948253717527d7238cd4ba370d2 45b08e47d6babdd2c659758ee7c6cd72b6d99777c85231f2c808271c68c6926e 08183fd8009a120e9e2c6518626d8368bfec3ce7621d0be35d9b46668c6b8ef5 0ab20c03582388955393f25eacd2a91973cad437bc6b2eabaa7d307ffc740eed 131e153d4d78069a62f08bb5dcb1195cbc55ad501169fd597e985ad102ba78ff 6e2baf384b4403c3cb1a2bfb955f348a8ab27ecca4b0e6ba171116023696decd 3d6a81aab6f9ef3fae86a1f09a3d8f78adf849d275e06aa19f5fc9d4d21e22db 670931ef4d82607f7ca977d32afdc6833d6024c4552480096e18d7c6297108e8 c0675e7158b35417090a89ee8d369d6f6535da900fddc694d5a7efeb7efd57de da4f6fe4edf2b9d4aef7eaae1aa40f3509614061e1e338c1974e376e11d8862b e20b7500a127a1e03c03f683566c271de536403f67604f0219cd2741c35d8624 780e660c024ae1752a4ba45bf5a570627b9214e1ba4f0d6c6bee99a7fc9d933a 82032bcbaab568cddad0a8d12db0bb8d2e8dcd9607ad2a9afb6de07a260c4347 68fa8a309e58d7a8ee7b38800fc29d03b035bec0fee4ceddb8b4548f145a60c0 1d6217ba9c059d5bd06b15d46d56d148541f0c317c3088f80b378b3cc72d9286 10db2c3fd6ef054cf10bcacec7c8c8f7739be7f9914e83fb792a2cce1371aafa 783eef8fb66112ac85be0697298b0706b5f5506bb91290a54b62ccae33b07d73 a6c13567a396a13f6ae732bff6d40c19686f5037299db6c31736284dd5e02d96 8bb09eb89409158be50147f920006c823ec4a65068d303fcaaf5184923d08c33 af63bba9ee65d34ff4afb24be315ef0ca046108b119688c550e662969e244e5a bed44ceb2fd787304edb9e570b4c52107b5477d72939cb4e671e4d6fbdc569a6 53f1e5304eacdc3774ad07841bf8244ae663b0a7e19ff958bc207b38436638d8 403b14e4ca8ee47dcdc351dc7a568634ef3d2ddefc65a7b30d4ef64b137c413d 1c93abda0c55a2b48ead529851f10b4d16998016a5ff8389c7be5499b2a5044e efb976d59823de16e41fe22c1f22335170d49ddd07008301f18237e523eecf32 04985446cfed21ec59b7539d432c4486218828e5fd67f6c01aca6ac504f25707 23fed667865c3d4024a8703b0e92323cb3827645f60941c5caecb57b9f0b1364 5b5e1a01e87eb5f38476d44434e1f7ac74119adf1c5083873cf222e7e4b3daf9 38887b4f5e94461342cc68ce8dcd96e31f66b1ab0bf1afd34ccdf657539dd2d1 d59146602cb9a3c3978f5fcef49e1432ed8fafcd512f87f69189d95907e6f8c5 4513a01a8d0cee77c4066942092f68907636481d431eaa6751561ca60c51eb79 a26d1efe213eaa8aba5db71fdf0c400b3277fd1110bda912835d8ec35163ce47 1e3a761734ac9981315f72c74ad25dd0daffe4bd58475fd50e612d61e4e2fe8f 03b7c6107a257bb16bc2ac805e692b0d8f15b7bb119b2467899680e747076554 94995f20ae41f8b8903ea05f57f84e6f3107c52b76f7450c793493f02373eab9 2e29b43be0cb1b078c2f9eb58a244f0372691614828f9a82c1b50ce601ec6b15 7235be07c737ec6d197d281e024e4c42941f6b94393284336878330870a46b077699d63bcd522fa161954cce89d17e41519e55b3f57599afb4d0eb6ebcd8150fcaf461890b8668c116c21e78884c27bdaf0158aa84e9b3536ae88c80c1c3bf0512d2502312e3b36ef77865591aafdc2f37fe9e7c7c4835a7aecc867df25ffd0356d904d8666aee245681d59c11c9d81f3add79350d6ce31bc622f92c7eb6850e04fb0726fce591eedd79c44b84680a981deff1d6c5a6cc5cdd49b7d90324c70af3bd2551964627dc90886b881675562548b4bb7961e914fab784fc76a81ecd0a597917974d0bfbd35217978c428f4eae89ffdbe7dab146658691f4278c70320653c103a4a9080579011a927de7a90a01bc2f3a61d04de46da3d882e0c486dd05674c2a31ee1742647056a6d73cb148f413b54e198d3a74a371b1fba2014b390a5094046376db88e52bfbe4e2427823f3773855d964474d27de2e546240b5120f33a0279c6b17a153ef1539b4f0ca9e1b96538d49664bda4629f7d46f4723e60f9a6877a84354cfcc21780671122c85da06569053cb0f1ca44ba09906f38c680f3852e8cc2bfaace66230e5e10d5fbf41ee4ad156139e575a1268638380e7ad0ed13f7f928ed27be47157908c4294257488c37ddbe588ca96d92c2bda69d4cb026244843f860e64dd549d7213b43618d0b5ad25a6e82405894a841a5035fd8e0f94b6114c6887890d7c3a5a072c7cce6fd669510e01b44d3f5b7039e49915ba02edf5e544e70fb6a5d0a994b801b29f8108db8b04e433639e89814fb1f485ac0a4d7542ea8b3dff29965643cac27c1d6764c8facab89087a73530a45c9643c50e25a834d522b83c42276c236a54eed7821e667df5004b178807811c93cb91da07283dccdfeead84a5fb8cbab7994453c896aa386f2fa2c4e07489ac1c7502ac0eaee46f43e4389fb85e05954d56a7bad74dca030ab9174e4c7ac0eee5690dce06fd1061d9b8ee89d3259df65037387d238f6d78aadb249396120ab921df24c90e4a9633bfb1c1a8b8617ee4dca9761821b1d523bc74d00f5cb5a9fcc52289850a5ca66a3a1dc79984303059594c14c1001e50c6976723d0ca67468df9d383e0074bf65bba06eabda28612272c5df9dd76bedffa8f21a4f466ca5e09fd2526100b1da0b7ffe40a066c8fb08605a366cdc2100ae1084e2a0719b3b1ebe2db1473036cb5e4114db273e5aa135a198426723471d492ca2d419515fd04fda810f11500743d7782735f38e0ae13648e3e6448b9ee069fe83a4c676fd00694ea3144dc08472147af0c029007d2a85600b7a6d0307780bd30dffb4e1c4d836faab7bcbe05048eff01f36fd2e7f7159c8c7082d32ae8c2cefd2b2a08008b38a7ba37f8880ac1bbb952335ce5b7c9407856cddee40e9dfd707b5a63b8b8b557c6b93e73d50b220f6be0a3c20da876386ed7b593689583464989497145c33982e2615d0a72095dc53e58694d521a69b1ab49131bf0637ee73cc0491d0b020f4627bf3801d202027cbbefb81407cf03e782d4141445d4a2810329bb578730c6603eba5bec8405f4e7ecd0cef3e79c2f24266643e1d710aaf66bc2f3478aae3ec529ff9dbbee092de2c80fb2927688d0205f50e397ae38987499fee44e3a18d09b5ed367300f00152cb0f913dc3823f1ef429c4bdedb34a0fc745c1d3742cbedf83032c714c30349fc88d5f30abdfc3ee8369c52a14bc865563563c3814bca01f86b87fa17230464ff3d7f3708d1083cf429706f4851855d31236ac2d4aef762efa943a9b9b60e611c8b18aac1ebd2f797bb295690cdab1f3e90770cdbebdfb9965a25bc3d3605b8d5a7bb4dda9e4b1cb3f11338914da02fc4a63567558ad8083f3a08cc90b60f5ae2719a2c007ab50b9e8b101652b8ed498c7100f3ac26927736c3ba715e910549152f5d90125d6815649eb0386eda0ba4431230cc5378ad03919d10fb9dbc0c6f420a7cf6682681f11aac61254cc9c2d46cf63ef32a7709c2886fb46ae3b304691fb9dec8d870e29f973ab2600c0425e21ea70bace4d304f869a0804a3cd305ac5ac86311a6c76eeb50345bc142da44f6f5b20f7f3ae0a397803902d4b1c6003c81f22fd0e1ce75c8353cbabac32a9d1d7ac9a2f63ec3f70c6ed677b771fe0e1fd4802ed7cb9779c4489ffe4fb2661bfc4c0ad0d92c0d79e396c59ab21eef0508fb4f6421aba609416530a238578f8184935af006ef5c2d80c224393efd0f0276a7b7ea9b0961c5eeb3898db43a53ee07f8c222c9c28d851a1f88c0a68c9a0eaefc47c255f09f051785a89f5dfa50fa057a199fb4beffc31865203f56f7200a1aa0e078bbb2ca9f60fc99a1544067a316761c33ef08a62244664ff1fa0a550ca63f2d91ca1089a12be048f02fd0721dda22243671af7012683ddcca6b3112050e9368406823c1126753d91e3f5f1aa6bda03292f9f3c6a9d24e8479c9bf6208c0c8354d217622472783da155c5c433a75dd38e9fbf56d2becbe43ca2638dc07dfc8e3e392f6f4bbf31ff0163e526007ecb1bc6020e23329abd925bec81a4b09cad5e344124b19d8f78c70e9f8b4ce71d6487a387091cc8ff31b9f018bcaf10422e4340d1c368016a735011a4e920197b7a4fb867d78c4229ce48bcc36befa02e4109d754766308379b003c63ed08c30ff72de6d12e81c0b2148cfb2e6828906f06e48afd3082805aa8c9b117eb1669d32b683f347e85cfaac5196eafc465d038194d961a18732420f16068daaf8ca0ec4cf02bdbc1e275ae777efd00c6efb0a6f001c27b4dada5de240a79cad8263b3e79c31e03c131dcd118c4b478efe2808321535923f80f872fac336fcd93eedbb3c1c83279db69ab332e323319fecbe05ffcf86340b583eea793a87cc5bbf5df1dc797b46d3b54ba4905a67052c6d4f011eb248aec4d733bac1750e4e61e1d2fcc398767e4a80f40977b29ea2cbecb3053921caf1067e644d10e9cc951e0d4cfb94cd78b0afb54b605e0c9ebd58ef380a364a889d9f47182ee7b2c06a72a3473ffd34a731c4e127e24bcf971964b4840da83567f821f8615c07d76d1414732b73bc4a6480233c2f3cccc448fc0e0e5b00367aa87400d6694b3c9ee71d6a99cf624973c18bc5cfa3276a355991508eab031a10901a77dd9885e526da5261b0bc882b190f4566eefedc4d06a1f94e561e08927930e269b499973695a15fc1870c08fd352ffd13e3ca398912f0ce781ea2024449292866f273f6c284a8f2a3cb9b3d80279a4add0468460e61d0eaa9387903b11b9de4348fce28406d6249663afd7bfb35d51a46a6d858306ca7a157d99e0a105ce347d65429e9aeea0c85ef0841f722caf485922a8482b8ed80e6071a9f06ae9939c32316a50501991a832288b23d0c99163ffb1309ad2e62cb53c727a80dbbc9bf0622ba4573455c79d7933f21d8e52f510d3aab66103ca350e1e85e110a223e00cdf4800a66685e4644e97bca9969b9faf8ca8975edf87f356f2e0c2a0e71a48dd5d218d5c93ee34ae0e0cf740d7fe1cd71ae7c1c25aec8cba7b2389d019e0848995ac7b97f80516cdefc2d0e43f7e3ba020ae66732b395706b3d8ebf0ba493dbdcf73a6aaaaea515c1a163160b45f8e5edc63a4311befdc82a76b84609d1c46857945b26404cbb510e95eb3980b75e7b5c6c3a8afe4351f9db99cb3b06e38b81969f096ea789c95bf35c08dae9118cde2ce0830b99b2af0f8dc8041b00f2fbb35a851b26c408ab38654299c3a4f33a2bb195af0be8621afffb4bae4a0901a31255f4cc7b535ce27dbe3c7bd6a9dfde2a8c07d10c6fbabffc2f24e38d06d70ad4851dbf7f22c838000899a5ba259e85bd3422d97439e32fba831b8f8009ffed94bb37bc12d3ea04ec139209926798203b8c78a4d18ff6396008d1783d070d98627e63c80e00a726961dec013f9f5714531dbe4380e55bb4b36014f88708b13dd6dd8c0406c14776a934236d8111066364e71bde83491eb835e712550005700c1b15a473d40eb595ed077a43e00138f15c51a81be66024873159c232b00c81c0af8b12e376d40f0d0289727681e57390578398ca97b92beac7b6bd9ee904c6d861b5776db8f85463526a6759b35adba98e342c72de1a5b0df00437b3d109f92194ab88757a23daafa453e1daf37e96496c7b9b9a673bd642647116907b0d21e27a54d72459ff4132c6e6f73a16978b892b9c27e7c5da337df39adb4eb6094a3ab21af2f8a297d814f45bc86c707ce7b894d941809998d8d7c751d2373701e5cb438e68abdc9df7ded644bbc82d7a5139f1f7b2f8b2fc21434d32acca4d0ca2b2045814f692f90eaac5052a17854f4b85325829acaf78512ad9e1534b2805d281d0765f93db714d9af9bb755dda0d5fd0348c7eba38b76693946ead55960f51bee3cdfa8299d2a8f399833a66d9aefa0d5513110b107ab132aec23c36e504b2ebb6616c4e5ef5eecd8ccaee1f946be1244e026ffa22b4a04e45133206980e969e18928030653ad4d4a461e938a07c684af62ad992b0655080e46e9de8d80867e1f415b1b3f410d3d8eef54685d025d8db4b6fd043f6150534065833942305cf16af588b2edf052bd5c1893236ecc688cdfdced8105464f02033fda436ad092d9484a6e4240443fbd19c8ffd39d02d90901588a1afe74cf884e38962993c02bd86bb3f11d6b8f7c88d8275b2321e998915d31179858c19365d490d21d7780c83e98c2ad15b9cfcd060ff0304d63685559a8631f80aa0755ceed225702b300f656061e35e806f63661d62d5b97ceda8a8d30c106c0f207c0da55ca79db9d90a89dc127762b42c15d8d060a0ad1ad660d35a3f40ea9aa6f109fdeba40e71d90a6f524174682e674bbef0d34cc6b5caeb85464d1cd92327f213f613cc48b51e0c090c71e0240c76025426f9973132ff424d0b558aa647c6de2b7d1884fa9d200bc2c18c47db5aad8adb5f30784c682bf805dad97b4859e04510d90dbf24284a06afdd4f1e086c8ae01e2a2e0e6ab32c2f99dec3a7c4b465110e8efe7834da12005bbc970b9ed3e794bf27faad06eacbcd9cab39cd3a443b8af678f9b44e371200f1301a42b9709df07c7a604acbd449435cdd44530561c8c9a7ca1045d666f20c06083e87bc2c0a8a4cd4e77ab13e9a98d7b0bed48eba43cfefd964e2e5a5b60c612826a0e2f2347be44cc78532d139ed185513bc68679cb71602d2c7efcaa80faa019278bb27ceb72469bfbb43f35bfdf87e8a1fd6381a35466ee4ad2986820186a33fa38002c4914885f9d5729cb200aefdbef666caac65a7638b1c0ba43e067db6a4145f8e6db06d2895324681ad9a468d8116ed8bf73e657d6cf44b7f710dcfd1909d2475098701dad3f42b6c831b7ca724453eabfa4da2bd848d3c35f402019ff7a354a3b9974d2582d3b93e078b2d90c6f0772d53420f806f9c3bf7ec0147306456bc9ced08354b129b5719be6bd8f31760d8fe9e40024f4aa444fe0509beaa6ef4b7e586a979a284b8ae982635faefa41b8f2a1078a172ba72fff57e0c6f9452232e3aeb08a9d582cb6113ac1b633e5a79be016cacd71b5b874ad20801d22d2564d2aa7347e3bc4a8d4fc57a37e8f80c96872c47720db5dc3966c84e03190a387f6f5ed4435f57b44bad06db092a1b53b0f2160afd71793125e971ae0a0784bc2d5f38a8d1282a3a5b9d4f3e8d64c18325174a09d24d1c8dbdb7786d0574b63f527f9e6cd1eb154df9a37c8a2be9e6842db981a4c61ebf0f0d7451cc0793d4b24a4bc3c97ad77d5f608dce40989fa2727bc4b689b0e69cdbdbace10803ba64d33acf4e747cef862c55851b86ee4d3af8f97dfdfc682c770201cd7f2d07406538f33ae93ec375d256fb6629f7332b318bcbfe5b33c062adcd96a05e4705b9bee0f9d3828d3c5ad4d6980b3c6fea5a54274ae712ab90a0a4a4f54cc06c05aec225c3f85f16f1dff1a66a7b04a6b242195872df7a3903eeab038f813be308f972e28fac56add2e2b35df415eda1e794ae7c98b8e8145bea50277b41c2600407cc72b3ca1d94709a0188475c9a58cef4a29ed93d768bc02479c8bf1c02ce0de1c07e12006469fd9642effabe484f335f18e82dd78a929ca9ee81b4e9f64a0fdacee1f0b090447cd92ae681500a6a805d13d3b4197013c79878138737019f08bfab5d7e17cf509874012a45842512f9deb6db7286697f638baec0f92464d10cc8a2d8957235c53077f065e172d83ac1123b167ea9e6092d056f0d2f76c3e4098e0841a1e58bb89b7167998c4261692e796a970b56407bfd7162e215e547bc0c0b74266b6f5fc9b2b0283f45621500a38f077edb5b3493bb99979f60ffbfac02295015aa603b55abd452296bad62b67c73953f4375796698b47ed77ce42265075c302974af6db4f642960b4f21eb04c7d3e835874ff376ab1a1ea2803f511f0171db6f072f5702632b114fac604c64a98fa68344a8e8d38ed160a6c818d48501a032bf446b340207f3896af1afc80ae713c15c3cee3b79e8f94ac1fd0622950505f4936eebce896f2f0fa340fbc3cb6c4ac2212fa759127518283d290527a8009822defc76afc302345501039a55b6b8717584225aae488176b53f9f250a830a70e9c970d9fac103c1cda1ac3fc2c1d14ae09d25880d64ad04fd8f1a9ba9980f22b4767afaaae13f966e05c7523358a70e3fe69ed9599dbd3a4d34b66a4f280887ebd69df5d55aacb8bef4c8bfdc02706869484f69f12a445d7383602422d90ca7c524f195ffbca8097a09235f07ad358e66d9f04af49c4b3c54683b9ebc85070e57651d4b9e53c57cdfe3626a3876d18df2e3fdbdb780ac2e46b8a1c186630e66b0d67fa4abf5a7e93d76bd67c1c84dd6d40759e042d464eeac687b23d42c0eaa0585b884e2af4b80714a349c20ea96840042a24c7aae3718375f88e15bb20b3de9855d10d0f037761b98953bf9fa834055282a44f439d1fcad96f048027708338ecf19937466f325ab343b77f3672dca7df9bb1a82f4393790ffdf790cac04529ad0e0db9c9f99bae6a371d01ce0059beaedc0eacc514ad737602ec2b3a40d33cb49b28249cfbfb238acff5e7b25a84e83dce7b77e360a1dccdfb461b5130f0531d22878f5f918e795beee3b3c7f33b8c9ae283c367ce955bfae6f4b7e190524659486e6ec61d542d5e3c2f0b764163415e218d4e1127f21fb7aa3884f930bd1e654c1199af2fa2810ba874fd462fed3ca790bba973b96b208397a8893cc001b7a3714fa03831b011c8494a006b3977b92fedf8b5c77478ccb4f6fd7b34600b78818ad865bd55f0c429e577bce26726b388c9ce43709a8061d055e9c7eb50733eaafe3136605c475dc347c54f27cd521fd9e422d6e99407570a9c38c7af302217988921c684618229e6c4e659853e3b0bed0fe58910b070407653a4714c60c2d0b0f98cba194d34dc2e371ff7a35a20c24e5c2493383da15b9097854c1de05e6e80789228bc6efb1fe6718b1a26e5c947b22a255846b4831a24991d266f40511223bc61c46abcda08c074776234fb246b9e7b52bf3c00dfe7e0b8924da3a0daed2ea5eb0bb2a52c9b0dce4415fff07e083df806ec58ebdba40f6449341780172131da8b1e8eaac3f239a74f8463833b0036b33d119a691c4700209717ad10c52785fc34cf03f69ca47c694f643429792735dfb12fe38845ced331e1f3e9d07dadf524e9e375de455c0178e95ff6b8d6d2d5af75220451a6d19da1d099d4d02cbd4c022441b4e255b3dd131ff607e62595637a0fde3aaf61e1ba9deff6bf3084564a3153721ccec7bf722244ddfef9343f3a6178a4390d3664cec7a6e8b3b0fc9877b4f33219b77562f593dcf36d786cadd8312b313093bb809e19f1c02620a670becc1b26b123c91543772e6bad7aeb39b2bb5cf1e4e6ce629650010fc5c0367d002be3708a941e459efcb5d9e5b3566766973e6cfb510cf73de9d565822083b16ec4d0c96d64d3f1faaa92154049742b49ba4de7051355605335cdfdeec06ce7ba0f43c1424ecaccaec2a0bec9379868b1e85f6e0e46488cfd4ed15e72900b404b4c3f76f0b770a7229b25402602af7a54aee9150e8349e0a02e9be2740056987e73ee41d451bf0fd470df92e3a370f2fbdbb8dd1c2b285627b107e1db905ead02a0faba8524bb87788abb573f967615df801275892afeef2847f4ef46401c993e25e026a2c1731d05fba093a6edd346a7a1105ac0bd61a0ce2b75ce0dd06b93dd8d12d4f8b1eb76426d3f61bec79b3ee7826c2c8a61fd1c7b1bd8c3169066166c39efdd83086699bef9b18e9f61a96da09830fc76ffea8f536c507670f00a1a73d8b23fccb0c455f783eb195728b1d8787f523999b7f056751a319843c00d14944007f56d7772c4029c1f62b1ca7c511b21e1fb0111457bc0f590850b80f469afc6ebcbd5361c1a560702ab0a09e49f4e1e09a853244bf5fbeded0373309c5df2ef5fdf0e170cc68d54d6a400c9bea1812a9bd5f45c954931ec84645820a8aa0dd0487b5c9e7ce2f7901497f9ec02e2bb5b9c2e08fedcbd447153ef0fe0eb7e9a34200bf3f2caeb0f1b56b4197c7d29d43e6886966ac08af301b45e9e30adcdc8ea807f01ac3dcc030c12c1b807c2be15413e9ee4192607de57ad706f50c14717f585a374e8650e6b8abc3dda1a7141b63ef4a866ea9464283380dde5d08d02ea75cdbce782e6f6860f57cffddf782688e36f107aba8248ac7f8edb1a2020f0936d5bee4e65353154ad972d78d8ebadf5e44e549b31d8a2be530614f2306e509ec4793e836343236c4c7cc6befe8e2f4be6296c94db93d35b9d16ab5f900d615e3a505422e2d5ef15ecc7936963dfca00c498c81f722773ecdc82449d50ac0ddde8e99ab02fa04bd8eb2809f2c609b109c8a477c25c90741539635e3b904649427be37c838d8a84c35e64cdd0250e9ffc2aa5f2174b2dd463de273cc8e013c4563623a38bb1b698289e2283f61d862fe555272dfe000635d79920b7e6e0fcddc2df9c9d89c14c9c902e0c4a01a3a0bbc806bb9e195ba0e5fd02798c43c0224e6cad06f7386fa2db9c6e7921cd5e93c30139d091d1b95f9df457bdccfd600c84446e056df906fae17df030a5865c57d250bf817353a4fc612ef2028413b0886faadcc83ff0e0ec4df0662593f8c137cab3286ecdca7f0968e94d7b48c75012ead64efb2a159e6c99e3e7fb4b9e21b5db5083f0c8ea37e4853d83f23aa44096ada44272af4eb3309d729cccde6cd719877cdc62df3a0b8085936bfad30140f628125eb45458a714f5d947c586b0502ca341734b7050c68963b416cb51c770e44e704d774a0a9bb32cd690413babafecae31efd6d02540343360a262a14f20271378bd4db4f101ffad77a6ccbac0901353e5ece6cfff69728ac8306ab05010f372a08d3106bc1b6c0d7e981650411fbf04aa69bdf7f14a1a4504f4917d4d60ac30e737dd9e3a369b45e65c2c8993809eafef292a32310b428526a5da6b62d0588f6d10ac492e0280bc62d38834805eedfc313ee7f356302987ca7bbe23dca0497995d75911c61b4a9a6dae8e7f640e6e6b20f4fa2ddd9120c67da43c8e4a906d374979de3d8c92545d5383d8c21e5d328c51c9a9d23f97283c5115049adba053f02dde89331c76c48b5bc1af676ccbeaa2960bf393ad675a382919815105c05d910811982b59812bc4fa4cb6f8b8cf8c2ec74416fbb0ee65aa8d44544e3eb03e0d3c7905a24f6eff6d7b365c6bd406b49775d9e3cda765b681ccbf83a6430077a6914bc43797012d4a11e36c1acbbb7002d8ad5d46c2ddd0a956e9d691e2b09 true +check_ring_signature 7d4169403946e59e0ef5899549b0b246e22e8f932bedd1b3304ac44cb20483bb fa432be34e3972778a6c12b87d6c7f0b1408a85700ff03df632f401b6ed72981 1 7ac25e0b19c9934df5db43be40192aaecd902f2973b8783d483eeaf53b47ede5 1f38fdd08791a6cff3a671cc250ee9db9cfba1b7eaa7bd6fe2b148860f0c6b0fa285074a3de31624aca04c34a7f79b981c07d1715b242e3d239ba5f13755220a false +check_ring_signature b3e0d4eabf5789c157298e2432126f26ef594b57f6c6e0129f7984bea6ac7bc1 ea6673a762308b0947b9af24987ec65fa9b27f5408ad17ad2ba61573e1d2e124 4 b59d19e1bd087b5e47005f59603f585d59aa782377a52844b1dd8b6fca18d95d 7f995c1d28ddc416443d40d59492e0e98d7f15aea5a0487f026dd97f6b4a9d65 ab51727c9256ac228cce399a7b8ef41cb0b91eee953ea7f2c8b9e875d4529321 1fcb56dbf4380fffaf8dbd6bcc80c0a649825c54e27ac32e865797fb53015a4f 82bc001a933742cbbcc1bd4cfd82b1dbea584a030c29f0f6c2094f41e2463209dae4fc5edabb23d6bd1eb520661dfa3ed0f02c452af03989642b3b6c27896e0ca270dfae10ec07e9dc5e3b02644fad589f318728c69bf86c6e3e8823af5d26063ba68f4c9db008d7e818355d8211fef5f751541db9c2621509c0a1c06c682b0132b022ffbe7da25981248879f0b4b01a481e2a652697bac4e6604b96924aa20c3e8fd598d76360f74f9d66a5592137bc2cc5f5494e8d62d398d6840d7e19570bb940093c451d4d7044e2bde626405bc2f893261538e1f577948c1574d8d18a05a81a5c8d339aa7a6ccc176fe5e9b2ba15295cef25c27204450077c9e6ff4ec09 false +check_ring_signature 0854476fb317fced0b45ed51652b792f05a55846d2c96990bfa325b2393a9406 4dad540eefd57439d00d7c350a1e6f2008ac00b8274b94013321686964a99f11 3 efdc15ba8b040b2da14205161fd088d3aceb6173588dcfa04766b0b92f465906 d7ee3942814f0b5e82f28eba8a358eb47f4be99bcb685b51a7d6c2258acadd64 0a90ca681160f6dff3d9efe62d3ecd7e49cbf8f7f409c86e3e1ec2433d9eaf27 e9d4ddbf8a01487c1161d034f7c843de54a3bb9cc331fb5130dc5a591109cc0e66061116d294bf14424a127831c51fc2789acd74b9fc4bb6e370b5100481130052320559cf812736f75609a044396c776392592431a92de93a38892758dc3d0d31a2833343395eb22b0fe843bac30681dd0e17f445b8b2f0c61db4460963f60d1ea74e5496dc0c87754f4416de14aff0f7b4d45f249e8eaa47b971855821e605b4a78e66373d3564b7fd7d4f831e5a74604c918d982def6d587b1ba1ad17ea01 false +check_ring_signature a8fc9f82570e1f173f9bbcb028005210190a6e5e2ad688c74fbf27ad8f13604a 61d721986c851c37ffe74707450e31861b78b02dbd6da6f9f68b18cc211243af 26 ba06250d12aae879081806f9ef814d572d6b066f94c8061d659ddeb6f00662a2 26bd91a55edbbb1f2b354aa22a9abab185016d281e37553138ed8b1bbf0929ec 9cf4d769a4f1d1a9218240c7fc9b99dcf08a7aef882899ebfaacbd67def3f506 4a3f584bfb239add1cd3f5cb1ec983bbb82952142cf99dc36814ea5cb7fa009b de11a90c64068bda54132de1a0547066fe89d6ce39590fe01529a3bfb21e317a 5763f08cf38cd5d91e3dde1e638f9e47b66004c020cee73ce2b277a3efde649f c9e234d45e47e4d53ecf83cd905851e44ad43f502d2548f6c2bdf40e25288b4e fd353e84e0911b10d0799dde9c9d3ac835c563321f42427cf73b67542c661b0c f9cf029b191a6db87fbdfe9617f323bd3abffa534420d3abc453342886a28b52 dfa6b3f9010da8866f3a7bff5a0340ec9ca33ced410c9b53aad592dd0eaeb9b0 9445f5d745156f5d3c59c690ac8ac1b96af5d1e630f6e3f6f6c42eaa960ca1ba 0125ae4eb7556e745acbacb5fa9ef67c24bddde2a29f98a22728dc7ccd4b5bce bc7587cfe3ccb6d9abbafdfb0e675102f07c632a11b71ce082a8600ef2d3f5ac 54863a1d65a33601281fefb5e19c00407fa85b6efa65373ad10ccb7fa7f96e2a 39906434ae7e63b39e5dce195e63c78ee5cb515992b709626db2947e82f97435 0bf1550be6019056b7538c05b99249747c13ee78c44add2a6ec798ffdad4c881 4dabee2af5a9ae5b3f1ea7e2ca5654a353075b9b89c25712c4ce221d6748942c bc1b7a86607332bb164830a8acbb0ce6cefcdabb6d8c90c7e720ed9d6218a61f 3f93b84033e6146b47cd8f92ca962b965d48b4be0a5710097a95d103394e681e 84e08aa59a70dbc97611112e5564e2fc63954637fcd4fc657c7740acf0317f1d 5fb2eac2b0cfbf46a1a3eb2038cfec86a8a66486d520d4684aa1e68db718c1fa 6d96652d7daf5de2efccfd7c78eab370ae19d1ab482adbcf22f2247a5c84f80c d5ba47004267f9ec2c66d76696a65d1031633e0a32b949b3ccab770cba919bee 4e52431c5ceb7acc739766df3fdb84ebb627f6c4249eaf7b308664d2aa40f12b ba1877262eb61391b36f7a18aacea950a4619ecb5b77c3cc404cae4e01f7135e 3a73ed0b5279ceea3fc13ee51ce6f55cb9e101066009cefbd27653948b655bd6 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 false +check_ring_signature 9ff33245c6d5bc362eca17934c470340dc155cdaebd32d10ee8eeb3c27ecdc3b 13e132c97f3726ff537fafe931c1076db732a2e94a4430d6ac1517fa4249e8c4 19 54fe44f25800661e88bbda1a4e90aa8f16c07a7027c6aec87d5ccea1bb315ffd a3bd87e15012a501eb8a480817996deaec5f59f2d7684fe4f4dc2248f6a4bbef 1e7ffe3e8631bf22c9bb0c75dd613b92e3c37e6ba85abc96e7ceb54a798fd87c 8ab32ab0823bdca6d41ef595b8f27dd6e834389d9f1bb6d20b219240b1b4f517 73f6e7650c67cc2de802ca87ceda955d2ff7e36df2a4d680932cf198240fe29b c7c0284d3e2b6e90b7c5dab2e6742626ff77383f271da709ef685877b5820705 e84097859de34353d1db10c625a0eb41b090517d784d0edaa3c4a2a9a668a2b1 7dc2a363c890d1dad657cb0645634cb38a14161605286b2c11a6f31dded01a01 19fd2133482f4a7cf7a8f263512ae9c3c8dc6908c177d174e865d1310b4bf013 ab4a1f389c52344b3b60b94e8f24e3b6f5f3f8ad35ab975a9a442075d0b8e68a 72db5d7eb86ede9e113638c4dce68983cff6da33f9f90c2896d2c63b95c29a1b d1d65bfc72d92f10b0d7577b7c438e7e2bfb086feafbcbf469f978ed1e211f56 953518290fa37e89e1167dd62bd64133113cc02d9a1706fd76c5be0abf764fa0 0d25fb25999bc9dba9622a46c96cf2e5c1fa7d931b790e7b58ad567659cbe5ec 8196787aab895bbdb262b72a28737c2681971b1c8b6191dc08f55f7024fc71c4 03745b5b79253086a2f4467624f6e3e85f5acab59e4ac48dd6f95bb32088199d adf6ddbc9cc2a2e54109ad405516937adf2caf9f054ece13f518ce74e9453d31 e721339935f210902acde3c483075674ceb8d82de10e9a89ac60fef0b829fc2d 116c814667d9baea940d812c5c4e4694a193086b3a0f29f4c555128beec06c73 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 false +check_ring_signature 6cba43a09396cfe248257b93019a5ce8b630f9ee6f8219495fc3d90191f29817 edc3e17fec64012ff7447990e01a7afaac23c5c01deed20d76790f5097c76810 161 2ef3f9a23eebcf7cc45752c7e112f59c50c1b04bf8d03b31c7de6e8492b17144 305319f524ba9d1ec43ba75d02d0b1904a2b7c0380f442abf7bf9fb55ef5b7a8 50531748a434b225650a4dcd35ddf3930e21c141682dc10d3841858faa786079 ee0a118077b7bd1e0187ca1053256e07b33b1d5d81d1f29472d4969c76ae6821 7b40a4267283a9f0a3ccfa7698e0547984b043b99517e9abe967242a49d813f8 638da1b3106398323fcee0c3316f6097ba311b28b5a99914e27df7505c1ab11a 5ee700f30a17e1bfbf7e65546774e68c3d4fc527f9523fbd0e738c384ef96b00 f8726aca1664d0c68cba2d0803103be0cb040a8ec80e77ee2825c55742cfdff7 78c1b5f74f769b0427c4c29afc3480949cb3249a95ac48e7e3e1d78adadfd4cc e79e9e473037fe992eb21dbe8d31b42e37497effbde37bd672963dafa936e785 bd57383a968e6539182b3647983d499b15e218d9868b0feedd247093f625850e 4ed6885706f584bad95ac0c73708fd8ffa273e68769de4e36dc67b5c51e406bb 76be992a111f32549c555198dbeaba79b5f047bf4848fdd1ac84209ce27faa28 9e07d998b50c0db2a22691f8caf1988d557d7bf820444d0a5b19574cf1cc5aa7 3e2fd07b0caeb0812ce8b483d684814ab79b15af003a26e9651444d97bb4d941 cdc3e8d0684755636d3100cb763f90f5e6f51aa3064a76a0d1499d72d8eac0c3 e213d99492b9ee2d7123598749ceb2d26a8db99fa66c629662e9247512096d33 2f72002cee6e99f5cfd9d01528ee1aa1d25c0d86083ea6330a7ad11f7a32ab55 1fd92bdb4c1d60b87cb7cbd796a3c153c756f15c6733ad45a16d7ded5432e335 3111ea84dedcb6433c5634c621651f5421b1a63708de691f23a1d1ec50aa74e7 8afcff5032edebe0848e836a4b742331be7a5bfaf341962c3050cd7f9798a1a1 0796a484ab3608abde6a2532c0ab688e6fd05394ad8580a1df76cde398ee71d7 ee5c203c8a8e7f1ded65d96b56a978f1b07eae8cd2c43407e05ff29025b8a891 46d6993ce2918ead0ba630bc675f9333735059d22d681526faa82d62e0a4827f 6a25e12a585fbf0469536307b924cc51346d2d9422391141c88893f4595f6a8e 43de62aab4dffa5e188bf276ed7e4ef468bc2569577e77b0453547c3d4dca471 a664c807ec7344aee6a9bd28dc284c1cae7e06d2e1e592787d0eb4e873222b97 7919ffdb59bd4489c47b84396d6149b6619712340cabeb53e8dc4166dfb07b51 3a0035ca5e98b52820aabdb1c2a20d6f47c6a50ef98b10a3aafa545b2b350931 fe687138e45e1477c1c6edcc965762610aafbffcc4c403baf0ed2e8ade8849b2 51c6fccae0ab41163d925f5b9526a6842f5bf33d9f527c20b11cbc9045740014 fca8cdb3950f78bbbcd0568bdadaaee2d228803555fea33a5cb34137dc9267e3 9314c18cd62cc7507863704b057602f1242656e37451c4f3247ab3e5659e5c82 acf0623a4e5afebf83775e5e07f6f421af722c17724099877c79d83b71621c11 b4cd01bf184b7daa008ca37b234e8f26ba133846db80dbef389d948988bd2f7e ac0bb95d53db7af2b86529a9bec39be1898ec99b1c9530d6c3c7ba37983692b0 b9ae9c0f31d91de2080c55f82f17ea0480def8304f98cd2986f6e691384124e5 61874f7d4443cf096fa09bc93ef2f8dbb129ddb31a023cffde4db9d9d57dde07 830e7b866c3554180d979cead5f5a02856bab4e48ba0ebf20e088fc0e607d206 b132c5ba6d985d31a438834e4837d1ebf99cb0aa651464200899d943dac96e7b acda751ac2bf355223c6b7f56ba2917a08c6ecfac95c1738ab22ce46ae8dcc4f f02402e3ab2847cdc6f5b3dfac29d9b45cadd73ce3e35299afc49d140758dfc4 cc7fa5c4a29feede6355b7dad63ff305762b56b720c6830ce9e761e9d2899565 4ebbefbc1d59fe6ac1c28976f805621db55f46f2ab917c66fb57760bbdc92e33 5c3235f57d18617c1042eaf42ca9cacce901b2ab635a772de727c3e83433db0a 408fcfb1f89d0b90d5b7a9119df036b88745162085b53b4412f648d91880d3ea 522cf36cc73b1229610e7e4e2850d3a3fe7121ede3a7d8db64a947ddb4a9135e 7f8b03b7d227d4e6c05502c775361f9ec690a212fd46a42d9c7c70dcaacfd64a 4495b1b61360f442c3364e615bc42c893a58534e30156693049afd780b6e0bc8 641c8f050ba6c304c73854a0ead4bb56fabbd6da3ff5cf57f4fd81ecf4d170c5 9078d953898f8acaf5e4910c3d7321fd0718cc4c767f5babb4cba90243ee56e9 9ff73e726884bf99961d8b0f698edcd4b5e30c116ff0c5080ba5956ec84fc81b df29ea8683abf66a550a16d374c20344c41703d2a127c79f96336f7ca1f9684c 7b8cda818edd0b44ce3882ffbcbcfe995ea0d6a84c437636265ef38bcc3f898b 1fc91c860f9a6c48ad3266fe3b8c8c22a4e4fca839ac2535b354effba347993f 261736fd224f5764170484db4296c999acfd332f9b3fcb4c2ca18f8017c25441 bd0305be085c45f3403b4968a7896cc2cdc5bbfa83ccb966e72afb1d6f6bb961 4d88733a854f7830bb6a59021c3e6b92f4e5bcf782072cc2f16c2b2347a54655 fa3649a1edc94699f326f66dbc883f3f259bb49d54783c116db838be47eeefae 99af9e604e8443535ec191c311231223ff743d723efbe8df95420a8ab1c2e432 8bf695d85831c04a4fec8edb8d4746a6241923792058686684cebc81368b4314 5be41b65f6a3fd319636ab09159f0acc0e566d2f6a129ab273e3b129c153a742 3274ac725f8c392f9b3656c5fa5e0f923ef6ae267f09e4a2d465400991682f9e 1870bb0534fecd6da135ffc8284b69f6ee147c9cfc345fa6f2b99074910d803e 3ac0eee73dc0dcdedd95763d298b0e896ef145d7cc29d1478a8cc7ffc15e931a 2ec0898c98293b69305b2874c369bb309f85ac352f4f83f189dbca81bbbd31b1 39521955eb937ec2c9461169c0a08ae578945685721e9c9b06678a7d5c054d39 367c7538e00728f92f42a36890387d96fcece9f97fec74864ecaa947756b7801 4b6b386a5183fc6680e523b2e3f6d79bbec85017d42293e5e0256b2cdb31913c a8b13eb0fa0452dcce9b60533ee147e8d0c7e7603024cce86d463581a2e7dff1 54a139c2102abd74256df6b513005d1ee115548028f3a2378adccf4b4dca6f0c 484ef2385add1c42999439bf1de2ac7de6afcb10310a1fed671a57744c1d0d12 480552690b013248eb6b5e9ab368820f2d77d377b42045ca96e21b37a67773fa 982e0af0174bc91e16cffe347112d53d2acaf7b5d9c420adf1cbb4db318236f4 c06f00cbcc07a915772d46d27a8d81356777431fa3d20bad4aea6606b6112f8c fd3c40f0ae462ecb7ddd87f51a99f4a419a7ef1852374803b28f5a028ffad306 3c2d1e0e7873533b5df4ae53c3380693ff0ce2107e37ee2812b5e4bc961bfc91 ecae6d1185f01344047b33baa1063af28f7a58f4262ca4d07ebc256453cef506 473367759ac413ea8f467497743c141a00972f674cbaf85d7b0d95c18193e682 bba8659a6cfe6cd1e8dabbf8a56b9805820a0b17a96c680d270ea3685944699d 780d31447a082f3649f0f062f5e03acacbbf3f4dd95d31d7e2f14e663abd272a 5e77d83998b223bd21fa1bad5d43cb0a11d0f7b93aa3003e7b19d6dc9d8728bf 513ec2655cc88fb9ee61d3f1c473fb21420d4f7ba16ffa535dfc9beedbbca86c 26353c541b0efcb7df4fde06330c3a2a9d9cba32e9038a29ac72c7d6b3f0eab7 a78fde441ba9ac150cbfd20b34cc8464a600d279aa2b524194eaec7345a5aeb5 b30a80d3356088c86b37d0c09d4d28932951ad2a1656297dd07bbc96c3edf1bf 1fb1a5ed2d8892ea55b4279c5892e220423c50a8c69b06c57f77cb6809f9d707 d75183552e91c5450603374eb19a027477ed521d44753f767f206718c3dfe551 31ae359d82b2fc59e4969753aa9ebb166226309813bb0b6b711fc0dee9ba75e1 7de34b9ac7a1549f78a3359625b4ddcdce68a2021b7f382efe6fc70c36f753c8 6e764922c2fe879d4f721f4876a5844b5a1dcb2d8dfdd25f9dfa1b3aae7fdd8a c3f0955337ae8f62eb9f58867f84cf20170c40e98c23accb4b24eb68ccc1474f 7055245ed916decce06fe925d9a36e1b17b4236fa76dbaea6675c1b535723f61 7f0ce33214b5083e2d05adc8f4acabb7e265b99b531d7b869d4611da356b6b61 c43faebda7155b821e9fcb01767384826c2a232da4634b9b15f889a31aeeae2b 7f15437387d84adc6a465739ed303448c4c8dfefb63a14e000585f0ab9ce07e9 ab7748644c19d3e90f3301084dccde5ff5719a10490a3580de2e21a36c77df68 355f155e356f1b9f159a50fe34dde13937f7f3fba6263c9af88fe14bf953de22 9ebe425e396064b0e35ccc5682066b6d6e9e96e733800d33090ce7501a1b9f9f a201bea0a7ec2973a820f4b82312e14cb063b3b210edd4de901fe17138c83442 da4d49f103211c84e64dffefadd5cddab3ff9ef977869c69110f92fc856ad277 b11696518406a90dc66a7200a67d8b85df689fb49cf46258a6ba3d3a339c8b74 14d73c7ddf88858501df23a73aeb1277932389d60af03c1556f1708eb0d51782 fbaecaab401ba32dec414d611842430296bec53291e97eada4b12b214b0da0f6 7bd2cf224a2dfe381d17acdeeb6baace6ab2269fbd6124fae3ab951b9afe2f15 886109c9990cc8c6231e8b139e79af3ef8baee02c2b3e459f35b2fd08ea2ca57 949d9d7e74ec4bc6137693d644fb92c1a4ea491bdafed691ab615cb3a3bdabb3 667d194d45767c3a19dc8f5f6ac2125ca3b156365e631b2c42fe54d7903f3019 b91bc099a0189533d7295c16b74a9d7c322bdd6c2c4d82e546bd17fb0e0ebe40 27657ba04389739da89432cc43b7cd774b2c803899724b79747e2c3bffaa06bc 2122e9d361f57f59910dd8ea2000db0ba84a9d504e0f9adc083693321c4fb220 7c1716e716f9579ebf6dec4be869683fdca3d4790a8e77a042a87c922f66efee 3ce33f58cd7fc2338e1c305a08dfcfb51a8a346602591a6a3c6e580994ce8b6d d2f9a2c2cd908ad330e315b0ce28b0864c277d449192979ff833967ba547f73b c509c71ed586e1b7d288dae65cb7bc10a06b185be11f7c31f8ec99c1629fada1 c0077dba543c4caf28aa3db30db40ef3a33201e31d3733cc9c21be1990a7f4dc 96f385385a952bf4692016548b6d1b6387d0bc326a790b8fdd4f9d23704c7c02 f3105ca52412c4ba7f4127596ba2593d6ee5e63899e93e6e2a8db8679fba28cc b03778e3713393dad50467fe5b2d82d9f39ad2705885b41c10bd356a217f09bd a1639bba38ca25ab2bcbe89daf4593cb82e5fd3ea151d951367d4cbc24f6efc1 a17b775caf8802b8eedce721c2146b0b10c9a7c160ae83760c3503eaeb8fd542 3746cccf9d749f3887fb31a6f7f5faa759a002492b1727724173c0ccd00ed7e1 2efa7feae369e424ba9f305141789db09b49311fba618c24af26a4b1c5bc9a87 cfd162c43ef4e0570fdd19ab2b631f5bda782aba0b9dd4bf36f13fcaf4ee9e38 573067638553d946bd27df86f774563212c5b80226c22358cf1e03f530e664f0 7a0a46009627b57d0d646ad5e90242f5243907b6267d43cbd456aff7584e1a10 f9249836f740297545152a6fc17a86192788b9235281e808c75809e7d89ce8e5 489c007f392b1a88bed6efbcb6a76702f2ee7d3de9e371180b4007df380f18ab b00d2632614f2af463b5ced6b10f29df75dee1fe9027d8759ea1838a5552c395 d49cb97b11cd75ec54001471d419d916e7176f428e804baacc167608b38eb59d a697d4c1b768b7c0239ce0db3b9cee5b99c3b6e4e595ef35a9a6b9ffde08fd05 5e01229ec9e9952fb30d75d34f7a30298cad196234d5f2cfd3a7f038fbd9a93d 53d1183895d91fa4f031564f1d42cd66e95c852f53c7120ebec9d8c938f2fe5b a19d66291953165138011ff89f6c4054eaab53de08b3f9c3034edcf2fab8e09c 9dcd6e1f7a2cf7a3c760baf620f2a8d1ba12e8f1849fe7c2e30016feb2f366e7 8541f8f50160b2c0809f056af4148e1f55dd19faf96ecfe0098eb4b60d789b1b f00559ee94731399886cf08981b099aa244c5e2e4d728cb4fb7ebfe569b3747b 77f082c92dccc6cb66edd35220b99e8336080b2af8423421129939a035bae4d6 e66628fca5e4e89ec90e7a373d2e963bf8715d01511474320366b2c5c9a3cd94 684096fcba7c4afcb7dfaa49d922c93e9885847d6f4c85c027488414209246e2 e8fb3e4377a0fd05244dddbdd740c5d23c1ce4c0ec430b9ca47d5a7547da6dbf 833d92362e2499f077b4620c39782bf9c8802423f919038ae4a301044a78d3c9 4802dec1748c0a8738346c409f25badcfa474111b0b304a85924d35d202aaa22 c511f894ef9b87e334e79fbced77e3451d8c1ce8a423d263827ca330d4cf1536 f1c1800500f0889a246f9ca53223c7ea3f10baf8e3564d6b6a8e08161b1a163d d72931b6be829636b0ffa66bfce1f396551f2dfacfd48e16a22d82b8b28cda66 5a405baf6b73014a40e44b5864d5c83b4d9c232b00ca5cd08c3b13e7d181f71c 4735e1583b1cb5d6e7eb995e40cbe9a00cd3a8715209a61a7c444872b1be4128 77420a7566c381e6d5ca1b78ac7e32a55fca3152c8dbd8b690d8868d27d07865 78cd6cf7fac6a94819d3afc71150383e1b3ca75d575f29f4d76f92c25ba63b79 ed9549cc77c95f4c9daee1c38d19e2e0019a76205f3cf1e45c1ed98718ce94be f1fd0c024f29be42424ab43c3fc25fdfe2b4097e166848ad78f26ba469270143 c56065ebd5d79788e21b8c32308ac12a17efc99efa2e296683838953e53cde87 e3871682b7317d3b0e7dfd82a1fecf4d559347107d2a570bcc2a0de3a809e75d c361bb5b6a2e700f1a09c00ba36bb6bb09dfb1c7a7b80a2126bc9fd1407a0166 bb0b55502ea6226457cec9988ad14eecaefcd5f2372cc8e446cad5d632b5f9bf 55c911fb14af5ea27e8e521af5357fc4555035a53330bc4eea6f237e1a330040 b57658f3ae81b2e3f65d7a9bb4ef8e14d12b1a149764c1b7780c3e91612c8502 3396d4c1a025ece5c319d4abba5f03a650828f6bbc1c946bc415f6020ad50fcb 62fa6b134e1e9977fca68025a2ac17b4f9048fe72494c13b14ff104ba1a35ebe e6e4a2657ef29ff6039d713cb5cd1efa6013440fba631b0b7a2ac8312abe0b0f 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 true +check_ring_signature 8331bdab8cd6e412417f5cb610e9bf67615968f36ffbe7b3f38cd958c6c6415a e5a8f24b7efe77431897b0234714fe8a6c96575234213bb56d3ced435e253f2b 7 6bf1dda0d9bf25dfe93ddb183f1600ebf4bb41469166b62225ed7c0be8bcf013 487b281ad9717f97a41e6c50cbc7806eb63718991ddd837582b4728df8d5d201 596978286b670d529adbda4a60c1702ada066a1f1c585a6579f32ea57786c865 062cac95ce6e7942601fa92a54732174db2393bb6e7c37cc616acfb3d767f528 d258988fa95c26d0dc5fe991d311b5cde0263c155e19bdf2aa3129424705c282 6994feda217421744a9365876dca7be5c463e1b723fb885afdaffbdfaebb55d9 bae40345627ed9e2d1cf4349c746329cb5287c6e7bbb8091a6c5485ff06869e3 62de0d5834a15672279e9da2cd7f09914436da832fda46dca8f008ba86feb4c649dfd42603a359035eb5f5c2b1eacac5a5847b7e80bfee1640cbede4615f9d053d57e8be6048b77b41421af0893278d02b0fb831565004316d25f1f8a1a45e020ab4d83a3ee7f9367402bf70c23b3a9c516d66787921fe7fd77d8a2e07f20ecc30503c0c69732d9e4278c0d3c30c71ceb52fbf40f071532dd54cc87878b7000e8d02a60c07ec2a183683d29fa5437afaaa5371ff37b80722f3151d5488cce20897b18429bc96cd8412d7991ef167669d105e03088b4ed09c8098ef6034cb2301f4b719a3875a9c3a1cb2513a7af2439dfab588183584ddbaf59da49588bec007d39c715e8129226799c84c869228a0cb3f1dbbbffe85cda89be3c3d154047e0f93a6db0117d7065b137ca4525dece03815e4c7bda797c98a373dbbdbb962830255184c6562091c474494abe875663e08dafcc5e416d6679462d0cf56b6954d0aa9453ebf1277b934e8604ad25a72612321451919a4db0ce969f660c44ca18f01f291874300793a3c864381cfc6f612a6e899311d19cc00ed05571404063c590758ba3811e5516b7ddf6eae0ae34f6bdcde5c70e1bf899a0ac2202fe2d2bf510d false +check_ring_signature 82e191b543080e19c6413d17d2711dfabb00cae7ac9829646ea3c185d209140c 7b47af00c2b0e0fdbec786bebfa145ee9b585e7f8fb074b1f90a290fb297dabc 4 5bea2e1836f7dca8d63959c9b90e07de78fce1d4196ee540cec6f4e165e50dca 68523ef8337ea587d48fc8a2f46d69bcec7dda8947fb311aaa0917325729ea64 a269b320a3a2063a92aa641e32c9b29fd20a957936df21b14f79b0cfa7851792 367341992ca76035b4a80bc35e72ff0b2ec3b54fefb39496ffda76f8bd871754 8ff9ee8ecdfaabefed6232bfd8c92576009e0977e677601e5a3ea3e4fbddd405fd5bcacc86c0a3b0aeb33af3bd4afcc5e305136ca064f0a0d093a5b357ad8d0978c6fc814dc4c0097b0d10a1e34aeaa7c8ec3ef107fe8b2fddf90d477ca4f600ed84e950ab42a5366a9497c47b8f9ebb80a9584f7e56d0814d1fc5fd082ece063ad61ab57646dd092aa4ed872f08131bc8c6bb5fbc5509d7c6a6eff0008d9203597e40edb519383c0681282df2617ee9126ff8efd9705d600dbe3e35b955f408aee9bfae78f7ccd57b74604715380c14a20955d460f0e89cd3b7083212fca802c5755a09b33cdcd5ee176c970524b5fcb5eb12925844bbe8f78bb9b6ddbbc802 false +check_ring_signature 6c178191fd83e78807d1dc2d4854fdcb2f41ba57f659a2235a83e334e13b5f6c 25756651f2878910328494a669eec382a4a98178fabc16cd0c04d508a33cb892 2 e773fe63490e9584e5ad1cc7386c846844f69a24f2865a7d8b4a9ac0e6587692 53d03db03581a6bdee45fc43d19d0225baf980f462338dc4ff713d78405ca6c8 a67961e889998a4d91e7ce427622495926deb384e1c061843a5505e1cd60570252ee095f7230e39bf7d777962f7c556f99b887ea07590fb5e892f418ba5a9c04727924d1a39723c1430db9e9596534b7cd3129f246e497b4d21edf70a39c4c0c7b0f1c30974937bc98b88e2c7c1092a4a226fc73e8143988b5593e281f258504 false +check_ring_signature 8b9909bab6c7f7c82cb539f4515ba42810970a49602460b432d4f484ca97995c c407c4cc1e19eb76094c841074fc34db0a8166f2411969a844c7753ef7a62ff3 3 2902391d1045f41d38fecbe9456454bb78eae45f35a8902b8ab52fe53d0cbf22 44548ea7a015f0c775a8bb1cba7eaebafe54b01a17bcc8c6cc2e480b8a5957fd d2c49697977f9d9c16323f2accdb2b93dec72411d86c47a65c11e98d8eba57ce 878eaa04afdc6feff8d315d8a73bfee6c9c57dbadb196f23783e5efe1d365c0297a2b7ef3c4368672fc1e923ceeb083399115300640e5306fb591b557294880f1912dc4a69b58f08d76348b9fc4a23a4ac336e935c8fe8f17f4a6a3d9257ab0bf56bff72aee241a1566fa7c89cc88655ffd997bb33b7d6ac1e49d2a91554a009b6db492f274a2fa0936c7229f8415f52376ee88c40d4208db3f5550538df450ec028a84ebb7b0e2e469ad923b06adcc4b814f388656f68d7aebb007e5437830f true +check_ring_signature 3d4227f3d1bed720c65a3b327f123e7041b5edaa5f7f662d6b8ccd8506246a50 ea5f57d6bec54ae0fd03f9c91565d767c092d0e4fb649a705b577b8cef53efc6 3 f36f6be96997f9f1db91d2ccfed4217da9aa09a09d7b78a383a98e6ed94261f6 a3dffb8f8ee36faa35f7c57c79ff8db4847a000efe640cc3c24b1e3f0dcf5145 e097cbf6610ad974b675adb2e547dea3c88639673688a22bc5b6c3e5ac8ef391 3aeaff6428d1e99396cc0d018b864232c642a8da3fca8334178048318f99d20776f37d6e3e1924a26c30dc05ff93121956249ae1fc9d0ffa22a6e5a286f33f0133102d8cfd1874cf64aa478f4fb53eaefc7b1d89e9424ca944a0a9f1dd10bb0fc621042e96cc218e58e2fa1188cfcc4511078222e04a2e2a71ee9fd8d41de001c8c29cd0377eb453baefad75c88607526978545138301c21bc55e413849f580c78cc6c121fabaecf6d725b102592914e21b5efc9575d4718f71468519cec2e05 true +check_ring_signature 0f0f07ad2cdd46f0c6d4f344245875bdbe9dc6bc5eb773eed39ce01f69e409aa d61f6f637187818d91e86e10e14c190a056d257a4f04200072b9adf0b709d353 43 b4bb5e0f004360747f5520a1df3dc47ad73c074f84d4187b19b5002bddc2f4e3 efc3f066d010591f79c8075c195b73a7b96d7da6d8be79f0e8fbfa4c9eb080b8 f7e26ea0ae4ade4748a0edc949d9fb755e3017b281313d347713306e135cf39b 414ce089f936dfc20e78fd7539352cdbf5291f03b013cba7dc7e024f2c8e6a4f 0a4d630c44d2da9fac7b190f8d89a5400ca7607931c2c80136f79e27aeaca003 3240c390b74f21b891d760bf9de518551fed0ab969875b3e4c0cdc4e315f6293 7738f92b6cd1087f8478b031c460ddbef3d43e0af05a4282df8bc162887b319b 3964cee5ebeead138df403b2ebdb34354d1a567dde0c857ddb6f4c9dc286082d 278599fe82ebc0029c4cfe4e8d8e5dee66c7d12117869acf7cd5019a0df490a4 a9f6b82cbbc39b10e26904c0e731eced370b68cf7044f79065ab6cdd1d7e81a4 b4579cc68937c342ff59ea0726ded8307e22a1947b0d0b2c160f74e06b9cc498 d109363578b6d9762d248eb0f49564635982e9f3bd1ff1893236eaf508d9be8f 5d707ad6170230ffc46438d0556fa975b0e1de141b7a36b5a25b4b856a8ee5d6 a414f664ed79453f285353ccd746250c21399779c509300ae7436eae72ca7733 046b163e3da8fe9b9a90fd3148da8eb3bf95ea015d59b1a21741a05121404cc2 bee278ce2610002f004c27763c786e889bb87b4e93c9d069061eb13bd8d3a9ff 2e6d03ca0af5dc41c8a88c9b45dca6544fd3e2366795a7625559c99a3c38a08a 8416e516dcde1588868f1654a7fd2ebf871389fad8c98015aa4c9f8b36eea8e9 3eb70b782afb970a42a87725fa991dea0777e8cd96d0c8b7d142e4f178c6f7a4 33783995b178e2a0acd0745bf5806b11b66fb6c6305f0845df68478417ca7a80 d1431c00f34064c009a1ab7e2d12b843ad6b2d8181a6ea93ab1222c309f3e904 809222cc8b14aed26bfc221abcf6f7dd28f11ae0f385ba83ed5153c9d4dcbd31 7ad782df748efb2b546874a291bd6783e01bdd98693765abd13cf6f992d53e0f feea44fbcefe8413e77d9b4475f9fd3f3f2e0e4fc5758ef4228f5bf87bd28d6e 23f4da01c785da20e9a1245e6b7bb4a5f817ffee464ac8b9e262b378527a6cfd ae5b21d9865d108d4b14ff64d8d8002495473d76ca6fa90c1c05954747f9df44 1964a3d7286b630b663b00a65fcf920fb02f23f1dbb52ee99ac66e8ca074e6ad 34c3c2c2db97653ee0017deb0d928d62eec23c2ad6236419a56edfbb56896dca 000f0f39cc66870ed22bc08b8ca8094d8bcd77c09cf7c6c0a8ab1971c8194382 0fac5a73cf61f8a4939e81b585249d69716e0adbc8cad92a3a4cfe0296893405 b4db6f0bcdb5f77a13dc0dd9b5457f0663da681d2e820daa1e05ed80432c41b5 30b8e6eda8a1931b7bfd96f2821d878a3a688c52bfb9593e13ba9c583f6f6a8a caf2567e2f699e43bee4bf309a596e875b707c6aa8f5916759f3dd68a3cea3dc 24995a90715faeaf2c96cfe13d904f944f28aab8afb03148c29f8f443556837b aaac49d11925782c4dfd3389b339f7d1714ed279e1d3a0157b5d25fea3201e91 9537e2b3cdc76b1a8b9e77d6d4710bb098f35d43bfe2ebfb64a24c03406b9baa 615ff841b129c4c2a406c71dd3fd2a91881c253e95be842062c8dfef084be8a2 d3032df2576010d6d444eb6d8b595d8e2acd7260ef9ce3fde8804396747c77ae cca2b0c3bdbe343fd03a3d44089a9a55e6f61523f0a720dc9049f5ba4ebd9e1e c8a14e3f72ee010f11032b655d687b18f32d42bce556129b2720a8f9bb75d106 2255795a35a372d7daf2c06856e97e5cf1496cef6d546cceac1d73c017548e67 e666de5437f11223a209c9b105504171e8a417f14312dfc2f6bba9051bbd2515 766f58844ddbef42d704639b8f65e9f4f55e97ff70dac35c6f386493c4e0551d 5fe93e2933a5ac95e8c2956cc574963d971f0a46923f5ebeeccef4c39e2a730c21c2c49b164e8339cf35460cae60c8d6dc7168d23f6a560f5080d2186a9323042214bcc8a6882a654bcae74b7b9630dc3e866ac7b6fae2f85f2605b1e85c180154aa69bc7a4de1096facdbcbf99dc554dc293a7e41be61a860537eac0ce0590e26cd59c5625b5449df630eb9dee501215285dd08d07d7470c6b2c6530645ec0500a7126bbb43193cb9f72bd3cd59b8c0c77b0f58605b01ecf107ed2000afbf0bddefe3f6a64dbd734c81d0fce93c86aec27748fdd4ca00c661d20b1c26b6a8073fab212fdf15750e4a0879ae0abff5cbcf80050c376d9fd962eb1413508b150bf6855627378392b484992dba0005fc18852babd256d87c7c75a3915fb1613f0a6e25ad190128d366c7777f4a7363634a4c2336793a51771d162f49177e24be0e99596b84bd49fe7d7d8821cec570725aac0d78738cdc5c5f98d42f09c44d64014ae1a095dc0be01f4eb24cefee3e060b1e923f7c41e05c9faead4f3a4bc1f70cf7f9bbc8f64b66e92f92ee367794ea8801b5c7023930e3df61bed79828cb7d0b1929bb5c6f801f07c2792dfdd297863f2bf1d7b34aaada3eca057c998bbd2b01ddbe03dab2e32991c82c2f7d58d7f57ef0d42f91dbda907ad650b9e0fff60d0a199028c3eb3bcfc64679ccdb54ba740436bc326518a79287b9a526f8b64afa0f132047b42fa161e44bcbab2bba560f2bcea99ee69af69417bf257c49a66e8f0afa262b0394beaaf0a23d5791bbf845961caadfee49957f8df15659c43618965bc5fb07729cf786c6e2f92bd19432d5bc059e4f9b2eddc9e28ba029cdc73c6b032b662044eab8e267f0fd7fe42acd792d53833adf0a7ad0851a6714462ac1e7094928988346bb8ef9ff7d957ce3644f5202aa1ec976188416a8caf093d91c4d0c425be571caae9f5de6636603b0faf78dbf49fe5c2f65a52d0c08e6f6647aeb04d24e797a6cfa39e78e0e074582f204544cf31eca2eb4695c306ef7b043a81100d81f2f9885cacebd8af5536bf0004ff44203d83e7f424bebaf1d4d8a20022a037c5a544c21af98fa561224f9a3e81083c431ac32e09e7486a94e3bd23672cf0ca8e6a1d532e21bd6546fd73d6b5e2c27ba1665f9c6cc2d0282d1b5506c4dc00a71826824ada4c11f93fc192e7c2fa6a563017ed97a3e2d4d7226fbc67b0d580ce99c465d65120764a443d63d81625000d7a637b7cc7e7b709502d260d7d80d0285deebd20fad227136fa4adc459f6b7b33b5e493a0f39196a0c4ba1f002e8d06fe786180542abe37cf1c2872cf875ab3f3227a9acfb96b502e5d1e0766989805f42bcc5f614635d03d62043bcb798025f60d651da506bf3a516d7ec80a8245035ce28b1cacd5d1277d9427fa8ce0839a1ba21f220c4c42f0a8bfcfa3ccea560f9fe972a71ebfc7b64a0032273f4b3325445f4087572829eec82ff9034973750e4c7f8a24a14daf6d95648468a10c3d954609a8b5f09ec8858edc65c2450cc70ba3e334d9d05597f932572f13acbcfc66b0311bc8bd450f22e99044b513a118076e500fbeb5f78a9c0e798bc06e123e2bbe7f175a4657e4b20435d1729815050f3011255ab2b6a260491488d1009d32fd7e134d903efc252ef5fba844a51b030d5ba4cda6cfc10e254f47715c2581a427c422c9e2388f7cbe43f45c3e00913c09c5fe4643b97a2d85993daa05583b74e43e42851a7bbfe42b88f83792ffea5a00b639601d30c240fac23995b4340b08730caceddf597f412cd5ec27ff50b15d01938158a9a5782045b25c1f6340031a90f1baf117e48c15918dda7c779f565f04c61e6a7d1cfbcb1cabb2b53c337ab90092faaed73a4e4cdb2eb6698aa777260f16c1ac9657cea9059abb84683128a90f34a7b7461a7a401847dfdfd8fa362d027f422bcca3358013a37391bb11c951804c3d1575bd99f866ce74d40f36c3da01425f56ee055b6d445b9be8bf3d74956487fd1002b4b72c6c993ac246412acd0534c46ad03eb5f5143d794aa83cbd94f4162ec6c75104bdf008d21ee88e15030c9f035c44553b7396880cedd53e0470178799ac0cf0885eb926e4d249e866bb03712ccc3cf8f159230d45eb50c39ae82b2719e0ef3eca54383f964e40aa2520062aaed073c5319058622feb4a47090b6042b310c5b03d38b39239e2c0f1ecdf0c9275eb13c7bd8449303520e03fbbaef0fa9bd9a1fd349a180765fa2c707177098b7e52a2bd8d8ae978321fb7adca7f9209c0436bb83442d986fa43f8dc0ca50d558db0c528f6f87a973ff7dce72735bbdbde62a6da1f3dce1ee1b245a550a105af7b0c6418903ae00815757697f2ddb1bc9bf8708acf19d21e3e751c021f67073d4ec75d943fbeeb8ea1bf11d23b4629824132e8d04991735b44da0a76d6c602296401dc86cbf9e323ed7d0bf7ab914f847e8ac5c6d5dae83a55c457da3c86022d15c611ff997d830c5d2d36cdc02047f1a62c62675ad3889ef0e31c55374c097f72aa7105b1db7de64e19658ce703a82b185de6f2b06500c2a83196ba729c0c99f75346f715aa0a39a544593f692fff9fb9bc096555cd1937fe266d23f30c0cdde8a2ddeecc2cee5585e85a627fc47d5be794600053d5ad514202102b831c08fe43da7259a4e68da247471381b9691b76cc5c15757a51ac821bff1a5b877a05cc05cc1e2699d014948af84d97fc3145f3105efc67f64ec9ed9a05bb0405380f2974eb7cbd40bdf14cf6073c60bdf41038f7774126bcf4c87455d0b8ba55230574c3b71a31b68981b559070107e1b95ab23df3b9d5c89d0e78b27deeeafe6d004ec29e04413fe3fcf608e54a80ccedfb2266fa5856b9a0061b973d1b43dfa30fbfecddf96377e39e6d7a46f796dee49a936b099626b282b93e59582cc53f060fd2b274f48ccd943ee5c6ad6d4492b6aed270bb786206793a1dd22c47b719250822af1db3bc275f072e8585e2a01e175678941d970b20f3eddbb143996328170a82cc63093f36d970e1f9649de69fb4d560ea095d79828aaeb2ea0c624d66550aaeb24bcb796a19c72ed5558dc4f942ab4c2e27a6d9b0ecdb2cd4eaaf2105300cb3e9c33edf327ac99bc54caed5d5ca5f324c81dd7ce7fd0ffa601856be20890fd8ee0d9a67b8809aa8fe21473ac864480fadc058943590da9e3c6d9c30dc70080ea62236e38338f3a2fcbca750141c711d485c5ffaa0671d0d31e9b5714f9c02ead3eb8987bb52e6b9e61fa761eb31a67debdc9fcda89e6d9d64473d7f234f044622c4f241d394a96732925ed71f51fc13164d5375d57340a6395fae4ab863042c71788559a71aca0d9fb1206d90d56b2bca1c9550dedba5a1fada6478b8980767ccc99e7f6e2546bc48df7a31024144b06fb7659bad5b50f0f3faa38224b80c4ee25595f0b03e17a8ca2a1a05cf9ab39d34cb4b117077a8d7c11d4738def10583b2c6dcab0ad211a9033d21cef028c562666aa1c82b06c6fb266e14b1d9ed0f0838f4a7c99158035b8fcaf1cd2d23433c0d38d42ae034bf425ea4bba76ea20bc86a7563ff8a821ffc5d958b2a66353a918f1eb36f8d8303f4fc45fcf38f830898fe44be224fab6857680a7c82e4c6c994ef198898304ef0d8dcfb913a866b000d887053bfe3d9f53e1ae1b7d65f6f5f24c2c2a3c8dba94bc64483dc49e1a30895b0fdc1382053bbe6b583456b8757af843519a50d71a0e2152d8429689c13000e46f5e8ee3ffdf9850b7a5a9b2f7be1d2e28aa2646cab94328219cecd9ff507189add675d306e53ff9b57497cfd0d33f3db494bfb9214a993add7dfcc2a010e674cfc5210ce378efadc6573b66fb6a072f20f33ce88f8fc23558a216577a300 false +check_ring_signature 965214e5f8d053bfde6334705610e43c484524ec10e2cfb1e54c0988337d5465 c5e817cf1ccec823f7ec7a5fdceb7f4376ec9bf9e40ed58afaf34491a991d82f 240 a65ed8a13c0d887580ee74901b8a19b9955078513361c7d324f014d661c6133c f55383732de4cfec12631ebda55a9bc2618a5cafcae165938efe04dffcbb562d 5fab1c87a4fd8d904a04a8ea78be205fdfe57b3cfe1a1639d97d90567c04db9a ba1db000f4fcc466015fb90bdfb8cca1e0416430ef81b96ed3e4adcca6e2d9d6 b11fa2805daa4a95ca1394d21d52054170a347605fb9531f4dc29468a4776b4a 36442f1a955fa1ac6d1cb59cbceb625d259a2c63dba6e16e7a7734b8b3216f15 b25c91a51913cbc4b99ace299e3c67dbd3cd238c7b25255815523392e18aee13 34cbba61a487d461a562431f0e287ef8d6755879a91d7c01a750cdf34f949563 e4925dd00a423922c85362433808a9bffdb27fc151a429513f7d3f38dd2cb239 c484be7ab08795c486dacb4c61c0a93275811efe2e334d31e540a0b02fefc134 eecdc82aa71e8fc0b528bc2f9af26e6c077da027fd0944f898beff588e659986 3dfd82b8264b29c9d5b166f93d392525eaf3935a0ec70ca8f2bbb7fc5fca1bcc 5586e0f3c099173858abbf32f1991d44c37c58e5b2f44d5ec467f535b2c034a6 c6ce8ed5128e5d7362264a1edabf73ade145089ec17db8d049317eb5074a41e2 6486537de2c0bc63bfebde20f0724f3d3525798096719768ce73699bd547c9ae 2e3cf99a1a25e2f71aee1f0eae4956c266c1ab7c8e402ef34dd24c1dd2945ad6 3f2ee05c3961f22026362d20332b2b26fd544e84bbe486f90ecf8053561ae70e afbc754751983da1ead41e98125ff28cc14f7a57400690aa5e1b5c63837ac610 6d06e406f59116b78e1600fde276086cdaf159affd498f3a340374919bfed753 7ab1c46b74719ac689328e0deefb9e2d48962ca71fae1f602b09d6b1e07c59c3 2032dad0ae3f600b5bd8181b0bf3fc3ca28eef948fcc433e213b95907e9c0718 75754a977d634543ace44ebbf6e6f45f27181715a6539f3c5c39b0319f618116 0c3bcaa41ed343e3e06ac735468372e58125e4bcdb3bcff6d56a8e57288e7bf2 baee8f40a9b0714875a838b75a64d92334a83f67a66af0c70ca31bb5aa85d785 f3c526e12a6c9eaa80f4949d692f96d677fea3c0e52046e57f8cbfd73aa96114 d3e47f51359ba7aefcc3d299377ac15f6f6d11e456d1d63fdb10f07c55510bf2 637975821d29b19f411675d0fa2c6a09b7d6cd4715f095d718b488bda0b7f77d 92bb022ff12bb19de8a1ac45a8d41c852601d300cef4f4ffe71c5bbb8d069999 87fe05c9ca903c4ff3b924ac29c16fcbab4426f0eec6fd272204b3d982270e33 edaa92f6c9639b9b9fce8f9cb14e0272ad43a5a836f345f55e8df07daf18105f 0acc6665ae061cec5cfa01f870d6d9a1e8eb890bedd75e1f61f12878e9e088d8 8649552453538f21dc148aedb85711c68f90624d5df5c237751e6f364e7eb4b6 181de62a00828d8bdb8731c8d66bdaac6c07a77ae03841c001069aca23470924 b4b563299b982d254792011ecd5767c08edfe4565daecd4dd9653b6f1d789390 c8e7f027856c86602d3e7ba2a2dffe107109c35fa0342ab73d8856a046d83871 176e374eaca73847a813201520f7e1d8006c8bbf4156fed26f098ddccc152fbf a135afa0ca2d8e3045ddf682cc1eb1f61ae40fa5c2cd2efb3c2f9e608032578b 77a13ba6ea9bc338b9cdb03dd510cb0b7eb7f54a5e274b7ec48abc85cc595855 1040a823e775bea9c1a8e9fcacb1040781b1f6902a13412c87c3d9a1299cc10b 62c4f838a3c9a38343eb1d26b6369bdae7d3e8fd209cb69d75c80f7f466714c0 7ac961979d392a311c48206f03f3d742321887ba3a5cd74001a470a35107e550 1cddfd37c3618abadd9c60914724312b89b74afe024f9a1f20ff560466b9bfb4 18ac41fa237757c8689f8632adca99fea0f1a307bab5ebcf11369d493fe9e7ab 933fed92a5872fc21a62be10a49abe1a13762d03fc0a566fbcf5594be6b32726 a1b8412cf1adab469a4411aa0af9afe34495748cb28cda9c5da9a9212d73ebb8 c022db0036727f222f050a7c2aa432faf2883d3c6b997e50eacd702a75856c42 2b1ff4362e0dcde0ad93e26b61741a5b1e4244fcf751598385be4a125ed8ab1e aa40e79824e22bb819570b5429a2083bfd9a06ec6636973d45571209544cbde0 8e53802aeeccb6bcd278239921505aed7d5130f8c28f9226d08dbb560f2c1daf eaa68f607a8ff1cdca94bee453b5dee55c6a334784660e92f601c62dc4824586 3febb2d46f492ded355d09d2dec00aac9b9b497a5f5e1b6bf0578b90234a227f 6c5178e59d492efec16de40f801d945cad0095d77238377e61f000e095d42f2d 3d1f6e1cf51155bb69152690709ac88d5f05e808a894069404fa7362dca0aa6d 0b0a83601c87486b2027b205462bc7e97db0ee793d86892ae224549e2689a45e d5d5d2691090871bc9261635092dcc47a2a65b64b59d6ec22bf1c93cace319b9 d05a99e76df502ecd28df4f7aa1dd7be94fd136ff10c749b7711aab4408179a3 b35cf9cda5254262387286f0b45fafb16da1da0797174b862cc636311081a5b5 9dbd3a7aed4cc15f603d7f2875bd720cb050f5fc99bff23702c04141c53cbd15 c8c98779009e2bfea5f3e5991b48f0ad8be6b666ee0ecf03fd702e48319f6f35 02cc598e5e2a3a739ca71e22554285b7f673ae14ffe008129f4447b0711af645 c7b5ed241f6ea031504f4ea6ae217df5e8ef4b5a9490633e229c8e9a89de4b29 a69319a76e4e5494603f5ca58010b432b1e3399442ed2eb06c1df210a7a5e491 0b19df1ca86407de679cb64bb371b7f227c9b2f8ed416677b2f2461f8e0b5d9c 592ceb77c143c61ac51040d251ea4e5f29ca7449f5fe94d9a71487510a53a576 38ca9f77391f2248ab02f3b098c199002011dcd32f9548cef5ed5ad1daef7af3 96b714230a717c3aa96dc98be2f21da3d78ae73f318a240050239a844af47674 bbd02bec7162043cca50b40eec39a4f6f935e3e6522876e335e0b5c0a2b96929 404717feab7d0bfa05b0d8c07520a98beb118d696a8a90638b5a9c7262b353b5 9f273f31e96202dc05e6d0935f45805b67a5a94db43a5272a8e360c49f67147c db61a8747614385b0f8ee99e4a2e475e676c620bda6a65be9b2893cee37edfce ce6daf079ef53c57b46adcef5daa6f85028ddb2b16d4b6080f69178f31043fdf 49643c89cebb65c13e7be575a03d28a1b5d858a38db849186691ae16fb1ba392 1844f20cb6697cc3b2bb5d03b62870a8ea705bcc8b78f5976bbffb3d1aae68e1 556cab7259ef74e293406d1aeb096a5d91ce7f5525d34fe5c3b077b42bbce7a1 9f6d1d663cfaf85877f4d1add9b87da4262ed9080960c35d48bc541edb93ce0b 10d3a87182caeef8afc5f4a1d0e8ceb4f7e658db614e5be575fd6a8fca8f58cc 56ee6c3809788e73f5abd12539f78b794af6314ef768d08086626a87205cc6e7 c5be6288447a3720d9a4599f225fcbd3fab8d790ace5ed14f3515048250fd428 5aceb25d6fbc3d54370246fbf3c0629fb9637c5ac021acfece1dddca6d9831ba 0d078d8956aa952b77fcbdf73ad643fe1ba5f9ba1ada5000f181e3c176e87b45 7098ae431dbceda3332627061ace8f6a28d3344e4f7ea4a40022b6310a93ecd0 6ea8c7b7c3f1bfdd48d6f87bacac9edcc68330a5aa90466deb32a666a4154b18 b4e8760efa45c8dc9918281185452442fd301dbc159a48dc71759934a4f4ac65 780105b46ba20c060b83c59e78e0171ce0d62583ebf278b5625aee31f5a29eba 91683d8142e4d6886bd526b8d308f7c74cfb5a226b2d9f0024860efe776615ca 08933790cc349cf3dc2c85365d010956f9fa42ea3566e5669fca6d6d81fec503 53f0762c283a5fe303c5191c6826825bf4a346ce3e10b7df1051270efff95d9e d71304725e7f098da2005a36193badba5a84df778d69906a0364cd3b8f0b05dc c85659ff8af1bb3b78289d66ef801d7fe63a5d1486268161f08e42d54c03ed62 fd3f6dac720774bcc5a9b93e1bb778246a71a3215a4273e287e1a70bdb524a70 9a0d3f6172807719d2fac69219983a0b47f0f433cf94f8de47888465da364537 ae81419d3f4883e95743fcb0ec1aef5221d08ad39111cdca7033b50f33507301 df9cfdc0a4948f52049b262f26958540a46a8e4afe95967e68512d7dfb04e451 eb9ccda75813672584db202686f3d28a71c5b35ecf1ab0dce501162493ee1239 b3618fc6ad014bf1e1940e0648ed2538f596bbd0f5b6fdb3e8c02d37d4e12f13 322a10a3f2a2ff99f319d6d537cd4ccd5faf0a1654b5f15ccd1067756ae23e61 cb7eca3a1ad40000f81607f5bf6f458d6f0208a7fee78edbbe10c0ae4f99cba3 9d9233c8f3799c22e175a12e11265b18c014224b054233104c01755acce94eb5 3afc849cf26a6d96186753b0c69b3698cc23074b8041a9db338fc9fb2f8cc9da 23142d03938714a2edf569d471ecc55ad8dbfc0837c133ac6674fda285611754 458e40c24591400629efd35d5004edb6faff096d4b030625bcb2279fc65a8a7e 76ea667014475cfe6777af23a81f4ec83a6001ccd2689f4eef42b2a5be75398f c47284d3505e1280b6ebf1d61de96cefe22fd00227b94df8bf0d886deac5aa3a 2133fef93cb95e89c3907d2b56c8ae255d8e4455b148d7a40f3a6f33c16a804e 8ab874ab6ac91ab5f4d2666f68a5d22da311f61f361c306000c7038eff97e9b4 7ee340342a7f6758b6912bb0656b1c297859cbf1fdd84cb24c8ab387e54e79da 54c8d5ebca5108f9efb8d5fc796f35088dc553ed6c7426c221166ae1ce28b4eb 9044349c08b3dc8e78ccd105e8a97117b4a51b7acaf296ddc66b304221659b85 942785c7c2db9bdf90f7a6b6be73ae0670c85075e2bbe5c613e4c182e6f87844 e962211125cd6172e4bdebcd93c9f9209372fa2c19f7a72753df70ffe2e35a1c 1c7ff647dff4fc897c764564f336fb737ac60d90ef0f08ff87caee4f38b3092e de669b6f97ab2df1fc68f134b606d88949bb4d4133c0ac9caec59a215155d380 d1853dcb2e493dc8cdbfd8a362f772f2db4263e14dc0499c3ccdd48fa2f338a0 5c1dee475937dd4b7c0777412babe377d294ae8a4dd22735a43790e6b741c094 f0ae69fe83dfce23f9e52995b89533227a5d8438ca3e50d67ed31a8c0e7f0fd4 bf558b3f03d2d4f08fe97698d042d24004a55a9688fe16b1eb8cb0b6ba5a7567 d321b8d8782f1108e38d1a451eb6d2e75f2a007460baf92ab7d81ab988947f96 ce051eeae59b0590c53471790ba81862030d6d66f712ddd24cd109530d855fba 4a08c6dc74a58bd9ddc9cdc2cccdd684a4aef4e65e6a8574e0f3b5513c7a006b 649342642d558b5c1ddb6d8835141ed99ecfa6b564ee24876642f14b218aadac efa0e9ed412f021524b3c556052b43a0352ec5469be68d40a9ea5460d8079223 26f1a5c1b6303f4aec4d431518d7ed5dbbfb5070341cdbcfbcac03da90d22dbb 525d58c709b0a2d613c23bfd6161584e0632603c58b51ab8f2e827162cbd3972 7fa554d2e6795d245a5e6b030b3b88a0760568c77b8337511584fef6d2715bd9 f00f41d88de12909b4d31f5318fc8cc6aa3ca68ade32852f4e2d130851446b0b 71cea233b10fe02dc5e73681643a59e42ef0f2af9808fef1ea34b1dfd95fc661 fbdb08c886b3b19d879db4e807eb017be6a77c03302f093b0dc3fc93684983ec b8188dc8b0cc3ba4bf15e6a6e9fd03406d220701568f4dc844d1d6145585596a 31e7925606f68add80130ca3e84ab5217884d48367cebcff712f9700d1aeb04f 03cc8cc924576aff89c37bbef4d9bdc951ebe92b1dd8934d48a9df4658435b01 adb59ee0372fea16ba01d142ccfe411ba8ea77a729e17fe0204f47b52d08c4d2 18f6339569f6da35a58b64826e02ae94d9ab244aa3cc5376b6c8f3b6c380daf9 a117ec705660c217631679915709d252109abe4d48f46dc17f9b7391f9005504 6702247c9a584af8cc28c4a058440e6c20687aa8d591aaa4c17cf57992d9dadc b067008932c5e99ceba6dbbbbb7d7595a8eab29f2623f503eeea09d2bc443a4d f00259ada0b69b34ce72112c26c528095a3892b951b3bfe22b96841faef8a4fe 2001bbdbbe24e17c1ddf54ed8fd8e2dbaa08dbed8e04c416b25cddc9ab817e30 83e34ef9b65f7af6a298b0faa03e0618e160afae9fb85a631a4ca0a397762545 beeb675134e3b9d98c4648b2d9b8abe59d080152bce534590f3053d90d21b226 9dcc6977867084e027f7cfc0418021af31f9dccc4f158ed9f5b004ee20caf2dc b3b6a5b444e710ade23b4d888d61207ef62b802573da86f2800a5e6188912b00 526eeef9a7f3196e7f8b986b70de99f4744782261eae99716007b896834372a2 fb82a95ad4ad6b32c2cc29cf0700d9b6110e79559cdba4b6f8ee1af38263af4c 15f5c63ed0ae22fa6804c4d07e1b49a632c7bae10798ee9ad3b4e7c2e562584c d05bc2b87b11eae535c3586a1f4fab116299079964d7fea27adeb2559dd89c5e fbf57ff69979a3d2d3e2835e6b09c14a2f3cbf10601102d67a3ebc2663907ca8 cfe082735dd97467432f90c1ddbde796d7892acf9f74084c293ac720b2876dac ee34f540c19afad546329de5559b7be4c30438976607095e75fbcf03f018c7ee dd4debaf8055a84dc6bfb95be09f5c2eeacc62d62bc39a8d7af54311dd443d22 e1da1a9505064d8ec5352c2df1e97e0b78a9a615064bcadb35652adb77c964f0 5a2fca853add98e2bd6ca39057984ca8c13b562d230cc200879a1d84f3ff7573 00609e89392b69a4f39a29f16245aec74acc38a1e47a28cdc760d1c7b58b81ef f56b92498bf34ca73fa6dd379f4803f185034418df64aab9041d5d28d06b9682 dfd96dad4497e734663e27b886134842e06a5b67c30171eed057ebb45c6d870d 9a80b84a3fa541ff73209415231a21d8cecc5d8b36636b61afab66a2b5a27880 0020c220c583fe635a466272e1354b117a14da2d1b610d725590f53493c75d28 50072c38b115365258af029f8a0d09c364705b277b6e22d4e161cbb5dfd94fb3 27585cae29226daba2ed8b512eaf76792c205309654a9eb803c164f71d558606 1da93a09c90b28ca5223e057f8600efeba1a5e5417f999d764a49f1cf9e130f2 c604b60e77ffb22425339810279836e9d9f727a097017c30f79b11efa1056510 d96c367b6593a27ddfb8bb3203f4f231db999bd3228bfb9ea9af9ffd3512a634 1df35bda04906c2135b283512062eafa20f0582956570ec96e379bfcbe703e0a ec9e17ea6871e8fa875d11e3776ce2c613ea86a535db058031bdb09139b2bdeb 8b7383ee37a79e0f92faaf51bf65bed69e532cdd7438acd4d70ca49ec0bc0462 43cccf7639a6129b8b53aab97303d8220ed24441594e6ad3ebaa6491706da146 81d067c37b21b8e5c04e5e4fd287e2e352e147be1901c0f1773b371dea82472f 6e27039c8ac07602ea10f226052dffd0c6551b2465e175e6b4bef1ea60839236 e48a52f4293bf174c268fce1a6d8d664fe590ed9254f4e4b614f78bf4c8c1ef0 20d55c49ef6df56ff4374bc9ab785f8f74022b38c303d408380206e2449b0a7f a06decefe45c8bb9f6b1cc65071d24de19e56fc9849fbe808b7c4bb3e3e47287 b10cf49ef6ac31c4fb55ac5fa96db2a27e343e33f236bf5ae3678489ffc1d524 f893ed1b6c42468700f2edb147c45278eb07cea8df34782b7b04aad43f4f0b99 e41ca7119b0b34fe55a7574a445e7c8f606e1e387e3da6a2d5cddba5f0c889b8 b3fef6ea6f3e562db5e7e680b680a9e888e6e263a0d6558787d029631e243799 5f4bebcad15517b7c243522c87891d1e931690bddfba243dcc3205a8dc66774c 34164ac8ed888b94cb2d09a3b770026fb83f04a1b383e3b9a1834b61bf3b9f6b e2de4de415b97b51d60e7df29b3574b630961c80a88cfc41a5803eb1a9db2f2c cdb7bc7cffb8a2cbb5d0326fdc033a4ef4d964b3c63988ffc0564d8079fcec0f 3f4e968e9b7f503cced2e4fa148049470e8f7dc00b56a3e240561c5936cdadee ef1e93ff43812c1aa6c3a2ffa065b2d13782489b8dac97f791d04834edc9ca4d 340ac3f0dc455e03f3b3350bcbf32ec5c0a82f9335b2f48b3960cd06cb2aac51 7ef662aac128015512e783c8abf2569778b0bcafc8dcc517f9e2cea1343c7c92 9002f467232d5daa57c3133384529362fa3f11e442878ac04e023064c0c969af d101d3540ac92f45c0830ca63b0854e5a382932dcfe9ed49accc3f5a79a7bc8c d196004e714dbead95e7ca40a672a86f9f7ebe58d2e6b9d549c4394c2ed46748 e6eb386bc04d447b30e0a64bbc1a9b94d75752871067b12ca6a3714786f63f49 261c225c0471f8826fdae9b9b6b1875cf7d1bfafec1098fb248cf705bff94e2b a59e9f38c890b6f70d914fbaceaae1a14a7667741260f615a807c7d8757f7355 a994c743d5074023bebe0b3b5f4aebe8183a67738ddf289dba9a3e6a47d45fd9 daf6f8b83e38a2f6ba070beb531baf76cfd611d93e75a3c324ef8be17a6870ad a54ba31f9262eb99a3303c71f6a837a93353e7bccf5fcd9247458ecdcc2c34a0 47d827a080b2a4e6a1cd473e7044a02b3bb50498a1b50caf5846604cf572861d 1d2d3af66195487d788059ee287ec5386c95e4738511ee1be79ebbdb19ad28fb 0dc1b706f7ea3c2307799528286192dfbe43391412af4fb4b36b70d98e66f0f6 476f71bcac2b5bbf1f796514f0469c39eb3e59281a385be410d76be41fe238fe cbd209101d48c14bd2a3cba74fce06053632f4729007df26caab4a5c99fb4dd1 1097da758650f71c69bfbeb90f3fcede5fef00ea919ed2e5eee2ec65d02b7f31 b3e773205eaee40edeabd7087d31b308224818164c3df2a3edf470fc04a37b91 80f802dbd7258d31efca0941692026354c37c379b9610ef6acfc382c679c956c 3ffe877ae038b1d2d39952573ccd0aa5f0b14effd5541441f680452bd0667b3f 9ae0835f7a2ba39599e13bdfaf9e050adb542c3e0a9ce325ec29b32878355a94 e0f19aee81781d30a690a8a56eb628f53b0f29f1111ac267e1560e671292d7ab a878f9aa1e111d2c2e9e87fda087597f7ecae1508c1020771ec589be42977d0a 36d8d17dded6068c1043819fefa1588ca525ef30857135cc70d6549b6153625e 5e53add36fa3123ea0ac930c2fbc8ff775feb4d1429c4426fc76a0491b158786 704bd11edf49f3b7f65504cfa15619f052b99b043175932221e9da2f4855da61 d35da09b53582e2536b3114fe34f9811a99416559c977fead7fd9f0e17a20a77 956229e0c6642f77da63c40c2480e59505b7b84a504c455947b1540ab6b8c31f 440932fc5c0393fea2d40bc23844765ea66aaa79b4d32426880eb3140cc7af69 1e79c15a4167c5e96bce48740f96fc3ae2ccfc3e354e732b44904468f3ab7cd5 44ac48822662db3a2bad4492743279ed61d51d9f326a82a160ff1ecf3ee1ddee fb74348c6c786c20a403ed927b6fedc32b55e1fdbc9db4b8037ff164e128146b d4d20d6d363bacd5907dccfdaeefd9cb1dce51e8fc76a9307061fed3ad2ad263 e361e3aa3fb72b15bb37e2a61b9bc9992c7eb3eacca73ffc7f3e795f0f253162 beaf959ef7380f6ac4f7609916fe7d52814d567bc8cf5b5fbcc8c88d46d42c38 fab280dd341fb1dbd35a7595a9b77b66f640de7638003e856a17621da6ef6efb d064c96b73266a6e32390efe44201f285b7f1bc330d97383df2c8d5a09f13581 9fb79f04ff6be3f07f347304b528b44ef2178db5832db80cbb2fba520e11f71a 6433bec9ca0a1c7048104b8ce235f3422a248238dc0d6f6e9423d58340c21722 37b6dc7cf42750aa10ec5a3fedd188ec6fe5e85f28370788711e01d044f28267 889f5875d77a0ede9d2b4a71c05affadb96ffbcaf76efa28bf61d812c6c689ce f5c4920edec4eddbda1c86d39ae8435a46ee985da2bbd34621028b1f4614daae 8fede9237a0fb7dabdb884aec30ba9b93383142292978304fc3302b43ee77117 946c4f49a62e590671e1e563d3082cd4c14baf8f4150497d7f5549c0cbdad1af 295d9bf7a739f382685d621cdc9c9dc0f3a337ed5bb097c4d128f6f730e12f01 f494d699e8395ee918c848d962a516a557b67cf6a29dc13a029bc4964c6f3e09 0e2c52fdfb46b0b5a8a858b49e16cedc4bd13df37fe4058fdc93eb51944f1380 fae35e235831124cad198902d96b32679ac9ef99ac93be3aef88b4545c918c27 6dea670dd3a08ddcc5c51a21c33ab061fccc782a26464d159366839442c50490 a0a4643ac369b23920e8285849343a4be79d4520f709baf53695ce03ffbac274 11331dc3da1ec18cea8d9e5f81a2eeaca05096d060aace7b2d95dd1b555fc776 7b1ad5656ea714e0d690013d31d03fde2f9038b9de08896e2c4d2025ff04c314 b4470cb6004c7a6f4153caa77581de809cb33c1f495da70fb0d74ebdd7f685c8 c38b1a155e9ede3c2aebf3a57243a2d73df23525f3062aa96e14200a6c56648c fccc952842eb0241f9e4aae4c1a837261bcc664c6eb971f56be2029425f91664 add6f094c828bc3f794e2677329e59d3b8ef3b48ed19397b0d816a05b4c9bef8 8846f8e58957613d9d9624f256870a19fbda893018eca02396c68445349c34ca 786341d99163d5ad083c36b431b810cb8043d0bab3332aed8783946b48e647c2 0fc0062eed5e991b60b8b7db0bfc32fec48c709e539cd03faa00b1ac370f1d71 06e58bc577c9a11122baa1c2cf0b147e047804c34b19d4688ae1f83b8ac0457a 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 true +check_ring_signature 7f16c58c82c1172f913bdc61e6fffd2e228fc874435ac8394e66425dcefa78cd 243db35d89a40fba0408712511d702a90f58036c0bbcd4167f32a2427da2214c 81 cb22e98ee43137f31fbb3fb66832bbee8691f965122c508b271683c95b90a3c0 fb8f2fba3fae75020683f36e8ee69c80e645f8f81c0e3c254dcb15a8b6cca78b 15cc3d2e83eb5c2f188cea4306b4fa4527d33a49e4ac2ecc564964977c47765b f489789cfcfd7afd51898223fee93bab5ea9ae7381ddbd55cdf7733625757192 77c5584bdcdaecc267828ccb45fdc618109fbea971b070537a29b7651d4b24df fbf4e43f5b0c366842c760d678a49dd04beef3860ce7f4ef4b8268d7140930be 305596408d312f044cddbc8e4fdf7f9759d0ca1f9de73e050a41f60dfa027e43 08b60bac329061040f84360462c296a862392d9d6953936959b9b28033ff3af9 fa9ebdf5e4bf1d5f06aab9ee66218b1aab33a5b8defe98104f00a2e51c44a18d ca665c3428f0d6e761c6cfd9686eb85e96b7e234f02b6abf20d452aefb25c059 63e7c98b378b11fb2d1f52b10a9044ca2aa1f971288a1b8ed5d2bbf5ca3ada33 644e9448b1a646f200672a296597a0e58b8232d6aa482a2fd1930cad74dfffe5 de41be75b46597d7286123b2050a8995e77fd73bf3d43af0a1b0388b0169dc3b 708f38e88765f3cf343752ea0d27c0bbfc738e12267e231d4a5f7cc12bd5baaa cf57667bccba351479597750a9cac9dd71709fcab30dd7e222fe65c162386569 64a8cc3f288e0985d396949f97bcbb205d57c030666d40b6d6654a2ed06a00b0 1c41f072ea27c0f57b4beae3bc1be132f0bc0606b4539a8e501581da0eb3306a a1bf01227754893d5bcb2f573549de34016454bca39df0c732c00173aad1e13a 0002d5247563c39d4dc1e2e3929061667b0c1b6a515ff008a2dd1adb36d51acc 6d919c31ababc034c319367d9f240695888e0c70bd4d3212aaeac851e39b1c36 c51eb4c4ca5145aef3bd789f4c126d7ace6753811100b1f11ad3e8a7f0e0e7c8 8dcd5ec88d717b574a2c3ec16933eb6069d58df7b7ffa5a32cb8fce1f9946670 138a789834438310947780803ff6fcf6dbb70a8c9d3fe03bb3e7a1b3a7f5cfb1 b0742bb3a6037a7c0bdc9f44ed76c418120800450ffd3b4a673fd52904579129 3c9781ba2d2fbeb43ccb5d13e8a768de98dead1cd07741e42f9fd47babd435f0 11b03834672abe1f61a1bafba0f8898841c701d7eaf37646a951a65a4ab34db9 a2396d3901c1dd5e63436832876d8d992fa088fdc6fa97f77dd909bd3f1d30e6 6a82c2cb4575c555a42fbdeed985c1038134ddab73e0264ca5662f7b09514a61 52773f9b0de01bc19fcb3c1141d041a4937089f039ec0889a4638d485d222870 dd312b43009cbf26d5c58b894ae01def85748b38c946613e9f2a46c06797a558 ba49f31bc295b2e4bc466b13701c9001f16189c03b0743655bba73aa30ceb0b0 636b8e1ad447e1d323fa211e73e20e6797d899c1d7a00291f9bfefa2f29fdcab 1b045f16113d2b9d6cd80eae611b042b9e864b5dc6d0baddcff2ad78c92dea63 e74902121539ee5138d79ae6aef0f93bd52f572a1c55fa6262b178fdbdf3e9ac 97a369da0d4c4d0ff4270c68c1798d9857d7eeca4eb5c6421192db92115b935d 1dd1eacf6c6fdc5bf01e7cfd865a5e30fb5202be3dd04ef3d1e6e03d0dcb75f3 41d409c2bb2150030548b02598bc894c8c58310175ff939d742f469de3579334 6d873e2a5b79bc0bd7c17016ff0342dc5eb03e000f0b3b5318cc396246cabdc5 dbf99603999c021889e95ec345ac8c32f61a48840933384327b6e70369d7c05e d3a9ef5dc95f926506a1793719e1ed8fc46774f7806537beaa52e08899d4c72b 83abb3856f242bfa74915a0b68b2d2c85dce6755f93da4967e8d42d76b942119 6e93699e370817329363a3260c221baeffcd8f1f38c49ee4e2b6b0e504db8976 b21ea0eac735c6fca96fa3cc6172271fb639a0c8b814a8a87319fe86bcde5634 9dc7eb28b495bd91f91fc45785b25e20077190a72234f5e66cc2b9fb09763599 4eed8f1efef303787f3a0a05457970efa10030f1d11aa05ff3f53709ad61bd80 7da7d0362cc2a82c2bb02572003431c65ec07904794de1045cebad3ef3b297d1 0f73dd7d58fd95a9d8e6544e4ed4e65d0fe09b1acf3267b111ef26ed125c9e3e 679f6cf72af9cc7159a3531f453f47836d20ed86d13be7156112306dbfe36c55 08776a04c34e984495507bfb255b89529f804302537688e6d6e7a8560dc6e211 95b28c5c544f380ee62ccce9a809680901515861c0d678d80f4bac516eb9586a 012f3e977a746f4b1d7ec351f3254d294edd011008ea977c8b3c4d581b065f0e 5dbccb85e84c86957070cb713a91c378899774ec432dfb9db01ce85fc9fcd486 8706ba1da0316eb41bf7ea0bb44a208b1137556b186a62e9d1c81e4f21016f15 d33c29fca539dc5c6f1f43b3b85a51144a784d1518291a2c2047fc4b55c0d214 a455041265e13313e690e713fac83f952b1baaa69b69f948b29597e4b7a098fb 8fe4c65b96de012768bb1dd99281de38739fb5b686c36c8db6a42dfd773d7d4a b2a0b90ce64a31ea0f95f49b4ee01f88a67828f546a81c26d48cc29541d5a7b3 b49f8ad7f14dc582c88da2944531e28487f7271d83b365c9514eaee8d9199f26 99b5c404dda7feba0b417c6f660127885c0af8019486fe25f33e440f9e42c221 81c3384da70f6d8e3a1f68ea14586c2d137d5f4a4e0a673ec47ff9ce39ef58cd c9a808729a7e8e4ea7d461baaf89a0768c566c6e3f8cc7cf4bbada70818f5e44 163580dca6fd1c7e6e476cbf4aff8a90a95bc41e8f1b16cc519cf128fc23ba26 5b3196e5009478addf6bbf6e8808ae3db997e499a8f26e87f0a97de7c91ada49 a8a3bae1c19fbddd6da2d4a5be0d31bda10e06606c8f763bdd5aa6e2d2018d4d 26688cecddea3228e0462e85362b6ca482cc0eb053ffe80f2fe2f97f199542f6 f3b2a7d5e61de61bfb905b99d2b23aeda0df59d5ccedc70dfeddb66c7b9c92db ca722f1511810cc64c3e36c6619054ae49c754035691149ba09e6e664317e983 77c2d2f39a117b7b06234c7c2e82db801ff26be2fc9deb441d7ffa87f7df491f bdbb8e1c3774cb5d3bbc648bdee6b277350db11e5d3cab4c198467d1c890d701 8f47f1663c348fadd98dbb7d1ec4a6c8dffa2aa0e5ae8cc7edf7ddfe2ae658a7 d7bdec61b1e60b77f7010e72be0869906975c6b2539e742ac9522ad311875015 6036daa8fdfe004f2c158eb8fdf617a9a3904fb5a9b32a37856e37479a89896f 85d4ebdde443b69267f2c95606c52469d2245fd17ce79c00b60b79f0eb6477fe 23898beb5aeaa1db72745f5d7413f64a3495cb859fc6d1221884d85830c53aac d2f1ebee534c570129148db308373497770b11aca8ddd9cc72ec4bd9d3b0129e 9cb3b3745d96d8f722fe64aad1a1f98a4b331a9babdbfbeae143019ad697fec4 a78175f24308c3b354e6dcae604b1808154e42b71414b1183fcc032ca2f8ada4 15b2660ad0f8a65e4b4f032735c75810f415030965f8b3289ba2d86a96229132 21588558bd72ddc8968607ebc0ad2bd37495a96fe072e9f7d570c0ea7134f6cd 2d6128398d8c3810d59c96461fefea5dde555d0eb8149a49c653abdd2fc2524b a6e7dabbf9b571d0d512e95c7c1dad11f2320223dc386c7aba30b4edbbcf8e1f 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 false +check_ring_signature e43161617d7700802e02b35eb44db2eeccdaf8eca1ee4738eeede9b84935dfe2 c131e541d81f218b49e1fe74ba2d4c307dae41ef9583fee30412f58627b35247 64 da30bce8687094d53f5bfaaed2e5b64c18b2b822342034d36dea8e2136d729e5 6035ff4ec737789af54eccc83bebc8d1aefc643ac098de89255654abe06fc8bd b2dcd5382761844418448bf8e637eac4729393d3024b78aeaba087eb287c47ec 09ede82f371a042d888533a24a8bde510e45af926b7e34f32ccd13a36745a7ea 2b0402feab4d0c6c0ed10950f3ddbe2028e5a467463f802492d4a82caf61c80b 7d353de277b6ee3afb0e3819a0fb5c0b194500c5ae31d48b5018e75de0a6dc43 f8eada9217a6250255458e9525a3759f1abbbbe2abe3b91569646ea7d1004634 ff95be8b0387e781839fd2f0dd4c890e8a8939895e97088678e7123b52a58a47 d0741ccb17fca89294ba42e200f2fef07a0de46493e95eda0591656f237d00f0 8f711aeedac6f36741a86f1093f4b00ac4cab6c767ae1166c6dc7f99b1f8f062 508bc523019c1bd91052da2bb2d2daf28dbafa2151520280cd71b2ff0d8efb2f e63dec4deff1c88251f78ede6fb36b83774ce454408c66c599797c4f03148dcb aa321f3466757888c85f87304f9b129a589f9f0290ff7b53431bbfdf6ed684eb 035fbbae7ea650a11a386fa46f83b11ecb821b8eddf812be48c3adf00cf63d34 685d737c6d6b9be4d03117cd7125f2bde475efeee85eb0afe757b17f24308747 39dae9ade2a915f0cadb6570b89ae5cc0d92697de1df277f5ad4a1289f9abbaf 54a9af9490ec2a39ba862f671b3438fe67a913f08e5943523694c6878f79a29e 7ed746a8adbf685da09e7fe63922153160292b072726a4451413b391096a95de b320de473e99b24d987512eccd98366a94023cdcb1fcf11fa8013657cc4f8962 45d6171cc37629958bad5e4bd3e6179c4262ad0172877a451614e175cffcdff5 6495a84c8b2338b2f9cf8ef3f591744abf6f8f61ca583a91fe89240d13d8f3ff 66e61e9038eab3a62f2ec31a8534a9fbcf15c97eaed8d643b26d0965b2ced8f7 86677042ed80f3101230508aa5c00e31f4af4c7db166b89aee9cc39a56acc164 09197165bb14d3fff6d483d4e8139910f5645182f9d9383d1c2c54a12f27a994 d01f1793926597cf2a11c4274467907b52a3224c5d963fa0ac812aee10ca74c7 9234b26c13d4d977e9381615539a2c0004fb9b8fedadd0950b30ac5c6c14786b 291f698f76d754b4e03b5b4283e2ed00ae6272a7922b714538008f6ab53e9c40 1bedbf6037d7798f877dbe78c2fbc7df8b0587b8b045b8e5ba4c99dbd68da93e aef32bcfc8b85d98d1e047328e427008f8f40bc30d7f43128af8e0126322d582 7007bd0212f5a3c5b5596a55f1aa1761e38cf6c02d594bfd9dc7be19a3ecf9bf 412fdcefadd3e9c8c36c344e0ef341f314dfc34e637622c6ddb1b1f07f2d2740 3d6ec45909bfdf5547a4746bc2ed9c9a10f1ebeb4dc818e3572e4973d4969a93 3a56c75e872c6ab84c9564c2924958c9221437a2cf160a604e6ef06c63e24824 0fa9c7575ef79d3b18522e0380536f5a9ec8fa13116b6d4b8c2ced8d2189155c c9bae09b735fad33f31e22525f4de9ed962ce18dab5f6a1bb1b8574b14635755 255f718654075446063062294c08417338fb6c68ecf96f1df8ac28d8577239aa 1f943520d31c1b349f6997d6a2a502215b2431602fe3fbb792873eb294d161a9 6ba0129291eb534855635eff20e12958fd1a4bb424222cba24fd13f76e7d10cd a3b94e736e6f646865c702228e9116b0fbe2c3f1c5dd45e6cd1653ecd7516e86 8aacdb0865134a812fa02baf0b067d19d95ebbe14e3cf0ea8d44e950ad08caa9 1b38e7d9d4b14e77cdc741fdb8e647ef7c741ebce1ba7ffeacc8778e16803304 d9401b09db8c07a30f9a1416bbc205b431f35cac5cbad11f442d7a43461d6574 fd78b37f9a92de10508a7fda368013785e3da8a61c3df9cfd7dea250a840c146 bf02e2a05229d9c3804993d001b058848be5ba09a73e2531320aa73acce0031d 9cf82d81d39aa3f315895bda8c55523aac0d7f3b35fab79b59a244a0ee53e058 1321f2e3fa8a2d28a7361c276ee71db16dbfbfdf35dbb4bc37a6a9aaa14e75c9 53d98c885459ddd06823e10f0dbaa7bfa4ebc922c52aab727894f22eced4f7ef f77a79ce93bf9000035bd42495441cb41ce542da39b769e3bec662143398d536 14b585d9f272e84106cec6a047863e1fa40e09990729a3144f57d93993c02523 fa0e557691c65475dd91cce1a34f0bff451e2fe7e20a4a8af7e19892731d41e0 9c1c3c8184986321cd4ab03b6bcef5b8c9dc4e014445cbbc15a04e9e9ec7a2f4 d6d161a4b42b299f1de974db4ea38bc4d7aba9b448e5d30d7d18b8b256ca8ec2 6dd7508592dbf116285d167dc19c503a9eeafa101743c1939c5e5a1f3c8ac9bd 796d5d354fa72404a9be7e82a20bf89e1ead804f991bc28fb6c9ee48783b8439 6d220ec372dc8f91644483d008244c55402fa1c12048cb5b326ab18acf27880c 08f24e8f84f993ba412f6f4fe993f4ee0bd244788a767ba41d2581ec1b5d5780 e1ca06eed4c256735b8fe5fc13fc79f4ef9c33ec2510534fd17c62f5626cfca1 b93b0b848cd272c7ed37d35f60002e3744081bebd8318c281a8dcaecf32851ac 5b3c3b4194975f5bfb6a7495ffc39d0df63af00072893abfa2616f70d86497ec 30c7b728840724d1b1ab7fb02dd961a6a9224d358d1483a709ca693ed0371d61 51acc725d4652c793aced466d3958f1f6552d3baa2494cf3a4a8efd47c8de90b 9d127f7c859580f547891020efa05b29dc46260d3b0772921431b51923debf80 449403949e054f99387fe0c9805600ec9356b7dc9041b0830f60cfecdd4b858e 74eb94fabf235b37627e67b2e8a7798b64258aaf0133f955d7819ba14ce6ee02 ea8a5f03abd98edf3ad57c5044b5eeec723d10ef127723dd5c85c3f656aa740ae71aaa48ab511a200186dd6f3e0cc44bf03b02c96bed890592c52f274d3919013059b1f0e133dd7ee190b99412632aa170b93d4ff12db0a0bfd91c3e4cedb4099e1c1d55092c80766c85867d0aeea4abf985254a6c37597a3ebf8e9e35e88003549bcf07e37488573bbd90eadd24587d5e942f65b8704d3e830885279d01e804b9748e3d22d5ace9de504f5aa31f06748fe10e5fcf1ae67287c19f7c3c560a0383a9a9c52e413d34430e284f17f818a69dfd2216c6fa0f1070471f8f468cfe0a3dee87e22b7a8bf20644cbf6d3cfb9ed890bf47e9f92dc0122cb903ea9e6930f5488d347dc983fc92d62ebbad5de1b4fc8b47f4e59ed2b5a428237242c9d040ab2c1389ccdfd4b564e063bf1847399029b3505102b610a3a6bc555265cf85506b418e5334e95e5485a40a8f87e74632a1cdc7f57d08ced6f8bf15e739ce65a0e26680fa6b41f90164a1dbad64df4b1e46d60e77cfd4f12c63d72d4db4a0d5b0616d2ea0fe34054839546862f9fd804a9470f33f7168374efe69f0c9a49519b022d0d851cc80ce3623eef1ff9baff7a8909e3980cea5b3508fd1d7d478510a2091b3a8fe2a4fb7986417260dbc8e3cab2ecd0f25367d8df9ad2460b02b2fc010985d3ff9bcbec5e0d8d37950d83e667eb2d0025c5c51bb6271585513f39e19109893c32bca1760b27b267c72e28984649803d29c5182516734e85dc404bd35a01b24f15e94ffe18320d78c0dc509b23f15b01f784d9b1c404c9c99b8faf4d340fac87c1aafd5eb2298af06f86d42763903553ff49baa36799011c62f76b43780ea8d4837c491509d13dc9f559a994e137389da47260e57e4cfda287b079ebe7083e129dcc1a9678f455f83cb293653027880bf8f0cad6d3be4b8bbb74658488053175b605409f4ec22402e2ad88eef8a26a5d77693fd101a926616465d4240004fded25b84070053e1726d19318c03ced3a8bdc3b27c8bbc90830a4fa98db24002c100bd4dff96f5410d1d419d7be0951f904f07ff22983d9483e4f4391c819036e98ca017b505774e473711c407f030b7328f5c8bb698e6ae3ec87b6beee160c3e221fe8402c5bf63312b9e4537435846a49018087e8f8c5e0b214f2a3e1370b5c32902e901028d8b180d929f221aa55b60348f9f626b8b1e28eaac0295fef04748bc3517e183001d302701e64973d420ac17c73234584cd7aca57b566d9ad0f672b2207536132a1abc26d4ade7d5b364f2f8f9eeccfbc8797ff5fbe08f1d109a538346ad91628c1ff5d71aaff475fe6cf969b1a93fd9cd2b4b9286795f67d0b68e020e15f3134a4fafc0ed37c36f51403350c390eeff586262434571ec7830960d72ed29887450c7e0b3fba6fb7334ab1e0ef1cc5dea92bfd5b64d16003aa02916a357832d6a14783c7b6e1c1e9318f7357a674cdb59d94661da7525880ee0ce67d7e00df38a5eac004fd5712bb3eb5c73ad38cb59733bf4055475efc5de30d1f81f4006c4c57dd981a61c456e975debe7dff3e98d174559b2d6d09267f5d0e56df782cedb929986817a66be3318fccff19e3db2f28d6de8f937f2e8d24ab0505cbd5ad36f4c13d3be126bf52b5f2ace52ba39ab819164f8e87aaf14fb7870d2e005e4c0a5a0a465fc68138bb7a097a8b3d95667f181d521e20cc6f5d383c0b4951222abc3998230ce91504a67caa731db4cc89fba24c96d06ad0939519820333c276f97675d68e03f7fcd8267f349715ff1528425eff09f5c6c26bc7f5f4040f5b1fa46d7d88f05f7d95951acd211974480b634574b121bfeb6aa68f26ba0a277cfa178eb230f2eef48d961b5842ce4e4d7edaee4ca5f90236d075e14cfb0897013273126e000d10cff7e619f27ec80de8d1a03652296fffeec316cef72c0753f2bfb02ae66b90d29e9ff3f38b3f728124c26fbfecef4b55131915ee05c50582b3d90d223f9536b0813a314b451065c208ae61d2b8f44864e2293001b7090a9341e9dbb792f649d4e7e303e72c118e3b09108d28437d226edf24372106c20b783fcc958e1c34d6091f3ffe38e1f71ed657d11c8a94fc3c7db09bd25be0f60f464ee5d3e77af81c4e4ce51fe0d43f26395d21dda1f742dd601c20f388629c0eb84d9c0be0fd9a96b9cbd598a4e3fd4618d7578acdbb4857ce1c25dcfaac2b09e0992058c95791ac01d5f2657bddde6741c7d5843abda69d36b9cf351ebadb042ba304739bef0e824a7f50628d59cb1af13e630c0efdb858dd40b4329e76810825b76f99374d2e7169aeeff191320b85ef320f0522e7a25f177fe39dc44e59067b78a3cadc92b6187471c508c74cef58e0bd1566ec71a51438516761b2f3fb0f549ac6699ffa2ab1e84d7688c9bc8a88628848992fdbe4963818dc98b536f40ec34043af8a4deaf14353d06a90b0f9e91af1bdcfa08e69fc8536ad66864cbc059dfacbd07809b9a0508ac64958eef6de7bc3e0540db1428e88396ff86da7d805558f0ceca86ae61be858c2020f71f5866bdb3a3a415eade5017574aab152220b693474d181a5ccf8e375f85c7c2539d87302e34d3c5818534b4ccfdf0ae02408ad419c62921115c83f6063cf4c328e5dbde1f5f4299b94c45e7243bf808d0601012ec3810b118e5ff8354dd62a041b7fdb77964be2277c042c98124c07ab76006cf55134e3afb071c73ec8ad8d862f1ef0dfca01cc128b74408bfa4dc785e00fae1eebcb489a9a6a900f2288e9cd9705d50b594ac7103cff861de9f547e8e70c27262cb47fe91886022b2c3c3580cf9b61ded07d88628ee521812d0c5f5f9406c1f2e974a9b91363e2d578779e5ed34efd557b384ed4099e4a94206d6669490c96c4a12e5646ddba1d139ac9dfc6643b322bd65b7eb007934d741992b3eb1603b87cc012f70781e94b84bb88a7dc6e97a64225c0503568c173ce98b45c1bf60bb2c38c7be96cfed0788efe2ef50c01be633b431413348998f6e945981ffcfe0c36e197c06c7edbe19f935317c39e146c02725ff2c59809140a2ed75faaa5f60d7bc167c930adbfe56ffc85bf51b579af1b9876f2662abd94300470693851550f1e30794f1282025c07810e1f099246b0055d0390d9e343113747e00754149e0c4bd8ad898eb4f89d1a83bced91a330d5cc035ef2744ba127147bfa63eca23606e6ab117da20ad115034aecb8795697bb34cf9b021f1bf07d898b673b5dd0b40f3a9ef77453b7f5e48b719b7f3d598e171f82062835ca826c446db8fd4f8d830f5e7a866c0acb4ffa63e4b6f9b697ef779bac5f60ed62928700bb1f908338e20e3ee0a66fa4e3dec429ea63d1e4c4f85bbca3a83116f47d843955c4f9aff8090be10052af94bca4b003dba9eeacf1df8d14ae1dab896d0c132a35eb1d8223fb08c1970d321ffff80106b93695d4a71a019958ebf70addde7b84352f27d673530e5060c31906671256bdc33bb717fae2c617671a92f15c650ee2fd4c6342d62e08c2636c4892081015ad7a31b52089bf3e6058c29f94df4a27557e0857e591c004255fbd2315c37fb48de00fb475bedf5e4113bfbf52db5327d48d331e29599c05d657bab669df3e15a5a7d96ea5dcb9f21188f5af62f8063cf127d527d93e6703b7eb0f70f527d1e496eb07f085b2fc253275c2060bdfbc3c62d733ae68719c0d8743de89d4e3ee7aa16d06489c0c84883dc54a45f5bad14ad0f1bed97cbb140d39ff5658e86215d90681b5a9970de6159af2076c651e644315e00d0f71eb9d047fcd6ceee61ce9127eccfdffa5824508d2420ec25ccbb05fb513e57a2df04c05f4208948fad7c0e3956d1b254228c3db1f83de662e348ddb6c6cd6aae55a0a0c994cdd1eb8ed4d04a89f8218afdc24731e4dd2c13c6b011701c85fa3d111810992cfb4c97a5e05acbec586710c266785eabbc09d1762d06e961901e0fff2b700a3324bf084409ad6afbd781e4936e4e0a75cef0399f19fd7fc3d28c873eb46035abe4dc922a962fe9c1f460cb3a6adb87554dd90f0b7820f47d641c48b50c406035b8b95d179cf0158640b3ceec418b2dd93f587b35951c9799c39274613d40e0d3d2a4d073627575dbfe116493789eb04bbcf877d56ac96a61c9efbd6edaa0b541861be40bcb8602947806ad46c8aefdd5ae5fd5108e52acd26d7e85d26b00f111b1139b1253d326deae9b0fbaba93b1d5b07784687e7cb2b18ad667ecf220503f00fb993ddb7271d84fca7910b9bb1514df1f0a3088a50c290bc1b22e4ed05560dccd57448eba2a4c3bda34f1592023eb1d0f9c11e16a2a88ce8620019740dba1f765cd9046a85b5e6ed42a96e978df21d0fb3c73627438f4921fc94824e0bd2c81ab29594e86e4209a7eb714b55204a757cbce8e4a7b8a1ad4222820c1c036f2530f769edf122dd9c35265e7464ef592fd7f4b2b03ded1732ad3439507b0d5c0a3bbd59194440f1145abfba31f9837c9808e6e09800650f70fed395151d080a38e523100dc7f70d2d0c6d91302d943702fd25b44c002f1bbe5ad42bf11b0792cef6c84871aa6ef636e5719b0a06540d06d774e67678b126d17b13960e920f730a5688e1d792b76ae979c88f53982a9e0d8e62ed4b0f3818b9f1d0407af7015dccc0ee6691a77e514a00f2e7998ccf30a7525473cd8d2630d4e8576a455f0933ae9e0fdab0df20a78b8f3ede87d33e39383410a17f728e6ae2003c196efa05b420ccb8b71f9b8120bab993e34e6274eace8167dccee49f07d34199e2bb88006a1008251b6ab489526b3a3b8dadab9abf195fc24b413482eb360cb980660808b2479d51d29987238c1ff6739831376bad3bbe7d15c20926e3428984e58cbc0394eae3ee5f011c225fbe3367693de469abf07c1cdc09fd19e7c42e5992c52207323f0d79c2062601c2fc8312fefd5d9994557ca520abb108c2f7c03f3bfc980176bae94361a095faaf7c01d12def4ca7dfff60893bd8968dc418e6203e24c708832cccae73d71bfef7db597d4f19e3ca47900387b2d0151ff8d4c257d038f0031a26ee635ed95cc4f45bff9beb9e31e1e9794a1327657ba58804c80643745309e1a4f5ae606fd8c39cf3bdc60e5d9e796be2b6a7270489c3a177f36b1a1e0f0ce47e07f9ddbc41ddc0d85337c801dee6b588f798e65a92e069827c5ca19d220e9b3f8d7aa63ba135f70cfd0ea4ddf2d788cbe10faad3df8a8398dafd7d18930dbccc19a19c3dccb790e680fb27c3f9a51ee8296ff79a997824259e7ba0b5b202af6f3dcd01c0d8e3a8d2c017282340d164211c8bc8f5d8f412839fd63171d405bf6bf3bbbcbb75437a66310699cddf17ca256f2319f51ecbaf0077e3a613060b950d40746bb931b3edfa7e7eefb7b987961d0725279b26fed6b361572ade090b2482080a52802555b8e73d7ed4cbb25b33e9b522ead1915c3b0d61d18997c4019d564e156c3ebf6202fa10b52f7ca786d4636cfab6faebbeffaa6fafd4d93a09b5d054b0b914f5f09e219ff25c589e35aef095c8c0201580c83d03592744b301533bc34906a8c187b10252c463f331f543459e6431d9981859562f1f5165680ef08fe82c93784e54eb0bb668ea6dcf21387c44d069225978bae8ecf7aec85b0ddd3189f0eefff47aa3f14c1b76cf393553415947631dffb1e9353a3f04802300db2eff1d5959aaec8a77beb000f717150cfcc48275c829de315b4070552e520343d767de0b128f724c9b7459cbb242b18c96b5b74a17ddec76a5dd024093df0a false +check_ring_signature bffd7a8721b2bd567df737466528863af8e20c861e3b69540d36feb86fec4032 13bcf237a83cedb0102a25dbc3368eb01bf5ce1b4a26c93e26efb007021e1b96 217 e4f871039e8fe93bd4eeb24e7cd814b6199cad0e5c6d16786dd072dbdd1d2ae7 cde0686c0237cbe6b811848ed250ebfd4fc8885530ef60ef52c21af4aa184cbf e651fbf27eb8c4f20abda0b22e6e80868cc097611b99f56abe2aafcbac8fab3a 74f66c7de3498a8e85827a4828ca7903f750d995fc138980b9645865d8dcac68 0ef77a84367b57656b1ccec3998bb38e973fe4490a89bc3dffd65f0c9e882c33 290d6e869f449b9cdb5e674d33a9720c3c67246906a98b87f04bb027513cbfda bebe136c702f8a083ac130ae89a158a75257b5b9b5dc3a020d94a1780e8ba863 a5df3de315d91bf27c9ecb057ca14bc60e0af9b1e14b1c548481b6dede1c2aac 2d751de10ba9228282c17a60688aee52b97e10f0fc89849242ff216325088cbc 48b569da16c8a71ba8ea1003b797f1dc77f16a05d086527520e8af441c781885 8b5c0ac4725d94e4fecf9eaafab8ef0b7dcc1bafce47beae96bbcc3beef98b83 894526b723a03608b95d54890967a4ee9384d22377aba09df6a731e02b6d51ed 6a90187ad209ac35433e1e58d4f1c92524cd2c74491ef03fd7e6d0a6697275ff 679411dbc6d7e535cea6739c5a5cba0e94ccbd87e91e9632a157bfff4ce075c8 09f459750540e2f7935807c0d03e78b8dac0c9dd654f6f103a327568c3956f3f 7728d12a7ccb8cef7917b185cd057d365f496ac326cd4524df2da76051d11ff7 9a04c200760ad8b8b5b8a958d7871de21b08b277139ee4cbda9fcf1881efc894 e8184dd8483545841faa4042457d98b6f88b861d82693f21b756fa2c7474418a 7352a59746075cfc53eba8da644559b231cb522a59b904315130053c3084c766 b7f348b905ba047f5efac2683ad97e289862d22e01c24ace85ac0f699b5e09e8 ac51efb9461adc860aab7318cdaec2fc6a50b28a85614d20b6dcc34002278062 6a36b30f2f8ed1d0e72f4701a92a62179cb25ae03aebab716d768704dac4e9be 74be1f7b6f356a061b3cd42b4a0f743e959e63ae544c33da2f3ecb04df4a6a90 0d1bea6caa757e5a77aa4069c383eeb09003f80bd9c948af0e499bfba9cfe35c e2c19539eda333b2d2f4bf231122ba4654a691a2826df6b390dd5837e9e6e286 94b115cba9f1fbac0dce62d2ed827e4b222062cc7d157c80f0c9f4eb4946f350 3c1b4c992699d46be28e286b00640017334d6d19da7e3548166b76370b4747b9 3f14ba403ed3b1c72aff8cdb6f0df1f7a20e319a1b66aea81dcfdb88de3e8bdd 9f3aa78834e4a14d92c560526c48f2e3b2dddc24aee27c968db21d20ba1ac3b5 9fede8de4469cddf0c97b95aeda66750c8d6726119c9efd24778d01284ce1587 224cae06205702e122249aadcdc38ccad1301547aba42c96b5ce791dd3050e55 017523ab11a3b38cbd827e0914fbfb21aeeb2ff6b76f6419b66af9e01068b5f1 dc7c8adcbf6801bb1e52f82929a92431c017109c3b89e05235e3dfae6e98ba3f 37b15fbe15237001e6767e6ec6e22ad092d267bef8a2564b3cbf88b3b2c67931 f8281db261cce40a5c3cba2fd339ec1d6e196b516d20787ff5c7c1361c4e5b3c 1e136db1db94331a0d8cad2cf4f0573172fa00d1a233c92066ad9f6213fee3fc b7f10b670972ab1bb24489c32903bf962ebc430c9598cea3cb8e42f589179636 897eac6bd3d3ac271b3be5edaeabdfbaf1b8c715a02b17fbec5a62525317b6ee a2fc476612692c5de7cd5dff17a5f143a0ff025cfa0945d01130c95e317b0a62 c2d2aceeb7da1dde9d59015441d20af3012948f43d6cefaa1581cfb3449f609a 14b5c1b80270ba76644f90f9fc7605fa1d1ea63eb1676d37f29dd2994af927c1 5da46eb5d2475e1bf03bb9d43d42ced01c11938ed6f25181de4b91744ab95f7c 25bd9acb186e9187ce954fcc127fcb13a725ec16dff4cb8b5543728269fef995 5085d386f2132ec50bad30b0eeed3ec782f7fec4fd84d2cc703793738c061739 42b1ab8ba3c76c2bb7b746e01db108bd9f455edc180254555204397a8989e8a2 94ac54e669262faa4321b1003c7aa4171bac88d2f35446ef62a14a9d381e24af a7c6078c9818938d5e1568ecce63205121be096c60c34cc7f4ac9e9a3ca9fdbd a3b59bf5d5c90885ea4224f34a3cd62db3429200ca23f79c18862af136d8ac63 90317f341a3b6e1b3de390074fc4217dd78240cb67cbd71d8744e0f25f70495d ff8eddffad079903c909d7b6bd27c5d30968713882d450a190bd9eda208ba8ff 4d07dacd4ac9abcffca4c52fda88049fcf316e97fdbf74d8a8a2db2f12283833 8d03de8375ea6dde79747adef5197c46a997e641c2b9124cda67ec7d1fd169b6 17bf80a74f3a1ec338a5809fd05cb159c40efaf261657b30437038845859d269 de64e880401aa8eef7d6686d6d99e9a7c5378bbfe883dfd0c7ec85a1387017f4 be5a81bda03ef69355b05055c9a262f095d0d4b0e3761361dff802d8c911da94 b33a1b2912d1be98a09d084b0278bc406f97ea2a38bfedc40ad929f7769f0363 8c164fe6f7c3896c4b8ebbfb55c4385a83bd2d65af32e8071bc2f9966d4bc0bb e7126e70d27769fd5299985cc6329df599504aa8fcfeae27b5e6d48d9a927b66 7284accd3cfa2dc8cd164e69730fbf61fd0b9e57c5b7758810c7f0470b8b17db 7245900fe1081d5ed57bd7c89d7b0ecb47cb6dc4859a4e6af19036c142b1060c a4248fcb27e291c6423e59f2e84c7fa187e1b785569c8f433d4783962ed0c457 1c372eb030d0eb273efe7fd3a641b37186cd52d20816e6d95f44d604a84d3b8d 38fb69aa0705687f2ddbf20ae01761939ff4621a7f9c4d94ca800277e84a807a 39fa6999db9636a5f4468f1602a42028111e4f61e4914ca36ad2b3993f17c271 12efd3e6de70f74db58194c38bac16daf00309047fb4a21d570d0070fee3a180 be46d2487e2eaa99e900dc7c3e75326b17e8c41832b16f4439e20e3e34de8954 e3079aa5e2c0fd3bfb036613215b2808ff48f05a77241543dfec00dac13e3833 15ae98700c55db4bbc4d1f702ba27c7833c94138cfa874a27777e01c4b1c1842 cf421c08ac3e08e5176f26bde0268635f5c5335918ca0978d3ff05921fbe7fca d2bc6665904d9c6fc03703039e47ad2820c1e66eaf0026d813b6716f14e39a7a 43f564d71a1da94b2a02241702ee6cb64ce4c567fa8f9b30dd50998a8fca60b0 d206166b7b2aee93cecdeb9368c38f8567ff27842b006956f0e0a3b946137bfb 8f6ec5b9d58542494c84dd60983837c9166c2bd4fc1a4da3dfe1313709537b96 0ac9b3beae64fc586c8fdb4f0fc1b5d313662dab7ed300ba9488362b1393e525 31cb1fd1a0df97042f5663d7ad2bef147fd071ccfe2d78eea58b453b955f4f32 9628bdff78b114cdd1fe81737c70f75c2a7edec0848a79bf0d86a0df046d0a8e e815a1e660834f38c05c4edf21ffe962855dd42268b7eb194402193e3065083a 51b641b6423110c09de470cb91fb41a57b5188881cfe6d46a29b8f929f9d7353 7cdb91d00f311661a01412a406bfc3974bd1d9f420b50bcc28d7561dfaffcea4 c178e1b28d234b4f194e40ed47b70143ff57e0180da3a339ff33914c77bf8ab6 3435742a0e4025355bdadf97d7b7c94a59655c8aabd923048e41fba63efd68fa 033725eba529009a260fdea63994c07905e66a172c48f1342e42951a8952c69a 7471b33df8f7ebd3bdf874a8b0bb4d11a9762f25d2fe38236be344dfd11879fd 4657e17f195754481080e4fcb2a94f8ce1ad19e456d101311ca3c4019948968b a601590fdf1da0ff66898d223cc48519a5ba21732e9adcd46168a1b73bc82580 26d84eb6d89d89ed83118802e3ee6d389083316e6213d84c320941b20a35394a 781497d94d44b3a1c2354e89e01e83c2141c01be80c2800d8d022cfed582cee9 96bc56209417d6e591f45f9258567b5d688432289bec280cbd4164a1eaf33b86 695ba82e9b615e9b22cc244bd71c56639d772cd30530e93827e76a678ec0e3b9 07c6d7cdcb5caf6113ac308b1a206ef5e6b76e350940166e11dcb6831ca5b4b0 9f07c2d616e028ed1a55ba2759852a71046c42bea1e3c68ea0e92ff79303f83b fefb63966da84a9b489a23fefc096c5c88e1c5fe3644490e8a5a2445ec6808a1 a4ef9098add84f4c4f5136ab34a1436b7ca9cfdc8e0d31fae0973abfdad2d226 92656753c2e80f63af05cc5d36f52acd241fda134ddc1517dab786216744343d 0176b844a43faa4a207151a1aa1ace69e2379b1ca1059c1680f390ad4c323d07 a7d4bb87f2b3c868f0518662ed78c8fde2fedee76bbfc3bef3dca237a415816d 698d0d608996f33f4081c0406c8020a648cf346bea405d0780f50afbeff6a724 74fcc3adc89def77d59ab30f050414e210bef694d6495e5cbfccb87bc45d7ad7 b91644f2dabbf177c62b831deaefae431d308c7c44426a4defdc4052cd8790f0 0d805c4d6df6a9048b8833c149a8dfea58a1ff64c5ba60d8794fe4b807037c70 13609f0d42387224a5250a5feaee8de5dec0a3bbab5dbe2f1f310666112e7325 cba1e0f41af7e347bf9fae20d412c196f815683ead8123c123144abeb270b7da 30bee60d2e909cea388dbf513b083daac4e4f7e6f39b685dabe4271b0671708f 4bb8b2b2b5ccc04ae2561e6ede503e216c231d0d053b79f3b93bf2fc08c9dfc1 1848a398bc5eeef98b0e619ceac148a672f11910e619ce24bde4c12ee199a8af 58f4bd16b4ac13f27b55b8f28b3172bb1fcfe9ce6604e8c34a16c2b243223877 a2e4e7fee634b9ae6b86eac5e2f1344826df7f31869762797b1044dca8bbd50b a22e5039520c1fffbd86ba3ff5894fc8734f50ddc43bd227ded949fb0b8bf56b 2a712b9afc4f957c7d3eeebd8a2e069f2c845c82cbe8b6128b70c6833a0e5606 4f50de3ad5eb1c115eb567bea7b2b649f60d2146431c51943e07531f279af2f1 0a9f7c13600ec4bf27d7599fe3682e311840d2bbdede043fd36e76ceac06fd55 26539935e5e7896e3d0a3451b92d86b618c97a14f00a08eb77a05e5f180f63f7 dbd26aae8fbd943d6676ae564ad867b20c2304da2197da3ffc247999387ac34b 9c290750d86d64a867500f2783e78c322032be457c50d2e8a8b222a9271f935b c09aa9b8a17b4ad7052ce02871e549ab4b451c9098981609c9878200c2ff5921 461253c31a8d9767a115846078014482f7f5e77590e835935779efa6ff40dc9d 96410bd6b243a6f25f690d40543714295fa23d33ba9c87a04000617d17ff309f ada0837bb14624a57df9627cb989340a5d93f9b3db1f6863e1e5ed7627c40675 ea3a6130048123a993ba76804f50ecc5a91a8429055d39d4062b558b5048e360 b6651469d9e8ad72114615b03ec15bd815bcafbecc17ed58bf04d81ec22efd4d 25450ca2c19b1f9f4950f9945ffb6db8bd3bca786d4700bf48ba0580f85deb6d 8a543df93d7a3cd8e34863a4b55e2f837473503d77331fd3ff76873c0f81bc4e 66b339adcf6ad5952e719f18a6a41e10cdc15f46511a743547dddaf2abaeac7f c4f8d40d3817200fb2d5da1cef2309ded30373738468ee2da3d8eca678a2f0e5 7b1895bcb3a6f48aba6593a70d78dfda60fd2d82f3c97ddf56f423bd62f4e705 cbfa7529854efdb42fcf1481c856dc6e4e5388f448f6a1bfe34f19dcfffc1f27 be6ff45150c24cbb6a2e21ca086806e6afc98222eb5186b7435977fc405f3a81 809587a11538fde30d447067982ff7062c180f1402a89ea0335b7c1452579a8e fae9c26d2e4b877e66e848e2cc8cc5aeb54f61db23c0faed660e22398049b144 16aba82c82ee8f502bc0778428bb2e472c52d11b20419feec06bf5c97eddc943 05fbd05bd6d21f111a599c0e945fe6e7bba4b4389051e86ee1344fe919db59d6 805fdadf64a521442f64826bbfc7cc25f3e5e6ea0aa0313a14cc68da3a6c8e2e b2f51ed78eaaa90e0a156a102059afeacce07213d92209d5c27113a477f24820 a0b4392a50f79bda87539c9171e7bcfe5ce7798be91804133eeb19cf1e26b510 8f7eb71d025b597e983b93e84b906933af703e93018afea682fc22e2b36db2a0 4bb9e5d896366712287393247588c8d017286ad5ba57d9155bdfa977d09ed925 a923bb1b7dda51949e47956bd5a11111d8ff3a99025ce20f59d434958e8d7480 ea001eb6f50725fe183dd11daee5ddb2b3794da823d2198b1e7e473d872b26cf efbcc0729038a43d2202bd5c1eef7d83adc3e2885e59363538e9be6f6e36c4fb 8196cc15405bc5510d4370de2bff2fe0f4ee5e03011fbabb0c1d08943b0d05c8 9087dc9912beff997cb2ef84ff2823350ca667c408a065312aefcfae5214f2be ae65a237ee9f434804928553608c7c7d739dca45c6e35a5069c3224f38f36698 75de0047c22181bc7e014cd51ecc34561b6b9bd3e61eb1d2966893cf76865d22 42cb74696818aa9aaee241bc708fcd072ac307b1d992a3c39e3df27c360a9924 66169e6f1c3a55c5424b0ddf5380781239dc833bb119fea0d26cc1ad2a39f3c5 ee7122657d4c777f61b851696f1ec6f0004582ab6f9338aa4c37a5c38dae287c aaf74e486d38da8226e46a75c32bab9199753783c5c444463b430add9fc421f0 7e3fd6edcaa84f4e53d81d48fcd46e02c629c6dc7fb064518a564ecae0f02b87 6e88e665c4f437c7a4e0cb3b88fac36c1d48901c3a2d8414b92edaf812716067 96d659dd965b852d2258fcc4757a5b52226778580d8c148a9ae723ec3e5a91b1 c88e6c47354fe247f5b6918d51af95a145cda713d2e8bb252a619b9251f4cd4e be344b500a608d0b3415cdd80757caa2a776f26d95c50b716345868e1b7f1371 43f96dc99ea50f3ee98fbbd963b2e9719e821d071e142a788d7401cc906b73e3 1d128d95f26afee9c0a7fa884cd80b37141909f7218835dfcbb83f305f5c6c52 04ddada77e60ae8e529721ca61570b11c3048909b4d7b4e04e98ab4ac772dea1 6f1dfd9b797ac0d28afcdf2bdf353dc5ab28c5e00232b522b4d3da795477038e 35bbc8ca8bea7128f2de50743250c8f415cefd82e4130fc1a38dd7d5485eda08 f41ec9cc6c276273b5df2b88b0215e4a9ff3c0a0ac7cf4d970c5a41d69e49adb 08079eeccb1135d743562a37a745eda2af7e421a7f8c4e6d713b6c4f7a559cd0 6ed238f9476f47fa07ca435a611330857511ffe7c873b2adf946eba5c366a010 4151d657d839daabd6129e4bf08eebf483c269ca6e86f554b6652a0a64a7cc3b ef548c5b55b795545b63925340b460a4751770311f29260481b101279a70d57d 16b5b5275443e0c79ee3910715e03cdacca3a10dfffcf78127a978e954c8d047 52a66e6415e496bb6a76f51183c447402b9b6a22c1221115fbae3682d1c6cabc 15e6a7801665fc7d6cbb49ee27db6fba576e5ce4bbd479d8cdd7f0a39a4ecfec 1a1a79084b5559cbadcd95ec909931ffb39ec44c87b9179414a37135c5a5909c ec3b9018fbe03a86edfa66c39413fb85fd8b4dfd69adbc2b6c5a7e5e001f05b4 c81cea7c368a81f4f177ceb66cdca96067f4f23532d315b089bf5ddac55967d7 6686a192b7ec0696103fe86fed4e0311d4e369f51b11c388e80537cfdbab7d88 234cf988851baf73222e3d060dfb2ce15b496b87f6bc6eb8308f16e38821de0c e258664f9b49d85366cd96f17c99535a7ea33b9cff2e841b567757d7b1aa3869 bdd3898329ec6e0bf78191ce153c0ba7bdbf7a3e91615937053ede75bcef3f10 3c3a0ffcb2d31466b78a0c5b66b73041645e041a83339a24488ab7bdd9a4aa5b 76c912fd50e2fe8dbe09ed03aed7665ce830c23df0234b2213b78cc587dea600 1121433e5dfb3cb9e92d75945c5676eee6f7eef6291477bc62e41f7e8553347d 97131e2fa5d29dcf7cb10d5c19149c1f005e2db666024c257796bbb3964f7011 e978988852907c74a3df0e9ea3f0e9cbd4a7cc0d92e36f2048d54248f91f5930 25a294c2be33751e147a3e67c234420fd9eb09409c4b27b7faa645e5cdfa58b5 c9b5bd23846c614bdd4973b6b92b7a877167f29277a793eb5cf7a72ebca81b24 6ea2f8c08bf47dfd4c8211eb01bb49ec9448de4c692de188aa7d338aadf1b53a 4fafd07d4b0d9368cf15c53aca646e58e305ea8a3b75eb92b4b17144d6a4c8b5 264f55023e445592f1ca37244df347359a4fa4d8b34346a43a54d8001090190c fc58a59a9318fb815f0b34923e4c82edbc28a35de42ee53543f5973d0f576b84 ed114d377bbfc1c69b1eabb41bf835ec032bf987fb5a1e4abdd548670a8ba2e8 3561d59a2b2e57266b87493719346b7afdb23576b54b8bf662048edf6ed6defe 7c30300689f361f3f4fd1cf44fd26655526f3dca98eeda899a1d6dfcb3cad5b7 086ea4ddae80791a7c5f0f74d219968671e8d52724fd6eba1e2074bc0b268a20 7cf79d26e1949d47799beac35a92b1e523d0bda63c61facf7073ab6c9e773f83 2e24e33dd4b41b594124f8b88b358357407c89dde04b6101b5d2e48ac29d9377 97980941bf7372332e3eb99707f2da8910eb289ae567fe25362a9873cefbff0b 8912daa939f4e1adbd7c85f420fb3f85b68b34d14890f309e101a349e61f665b 23c2371b6781f6546647c9270dca71df2814440f0282c9624a304c59fbdc33ad 4f1ce27b41a8d63b507795d7c2cb24444b473606036e725e0b8e8e6041709974 3d2530277cdf2d40de52065cebb452c9a6ebbf0e5667acd8ae36a7dd32f67caa 4f2904649b8c9afc4d81559763b62ce576e355a6e1be73ca2c128bb91d0cba93 b485254a55a526cc697522a86fca1f392deffac730eda6d199918c1a48d52359 f69b4cf090627e6ec62971fc6c5bc36c87a92993f173165a7ba96d20a612ef17 a6fe63fa5162bc31a6c676dd667eb8a5a78dc9e966addf3bce24f1b7095c4c1d 2985a2d6209135638d5859cdb843fa9a8020ab4ffaa207a47838963ba7e630f7 f3a250b01b08291ee496ce9b0cc3c4f227a7814f2595d241aaca979057db9496 a28662c2f85ed8fce0f2b528297fcca460b6c8b651780e7bc60e4c85eca56083 eca0fbd632aa4a241b568b9af2537f12effe104255a13ffc0a36541bc697e414 2c7c5c397ac344df2d48dbaeca0f01b49ea4b5c8ef887311cfce305f2248b7cf e6a4a576eea3aa00498da05e43a129a15ed2eb223e4ebe35f9b7dd4a9fdc919c d05837a052005756d4fb67c490a5914f9333826661130bba6c081c3cfa66ed33 9152af99ccc76b484bde333110b3dc5148adef85a54d6ff0f392c94bd7efa54d b273401d3f49e6ba9c78cf0795bc3181bf1ddafc5275958f3ed95bb6f5ba6b9c 15cf8cac6493ad89c4d188cbd239112a27962ab0f0f6937921e4f17af0c47799 24bd90abdc4fcf1cbaa773a3e77c5bfd1a8af0c41c2e4f4229e42cb637874d75 845e9d170ba6f370af4aa2929d41d897c0d5573463e4ae46bfc637b3ed21d57d c48785ca945132a6834eb918380f2ae8db318211d076ce9006b212bf7c2dc386 a52e0f978972c1b436520cb3764dd0654388d607fd81f3badabdd03e88f7565b 6eb66444f72a040734211d7c80bbbd7b6dc32f4648772e76e1cf7719462e4ee6 e673b6d15e10ac70d2a78097c3cd1a675216c333ad73fb441944970c1e748918 5e8ac899e73c0801de613ed398615ee333273dac00d26c72958b2a7db8e19691 ca5cda4e10aa2e8e435c1345ce7eef337c6f1c738f92a0b5a8be11004ca0f785 bb4f223a27b5044e6e93726ebe4cfd73167a4f80d89e258fb0ff85a89c3c9773 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 true +check_ring_signature db1ba2edade48eb2b00affe18040fea8ef28ddff8cf4a1a45b19f30495c1d00e b01cbe33aa4584415ed2069c6655472af629b15def551b1bc159f222014985d0 2 56c16fb88cb75d2a24bb5f31bd25fc1dcb4daad8a2e6f18308a057406ac96c99 495483757f644b1b9c2bfdaaa9d1f3daf5deb6bb4c86ce9cfae9104716bb6021 5b7c95db3400ac7861f8271203e15fdd88ae408f9037db48855a8a5440e9c50179d6c26cedc7e452fc02e289e574256f7c4542e9e8d2b077443ef88c0fa9290ec4a7134a039eff5eade516128e7ae450c73e23cf1dbc3e2fc076109080519105070c739c422ac6bede44048d40e8fcfb15ecd20a86a9199b5c0f4689d7ef5509 true +check_ring_signature 11b2e27770e170e035112a9822a6e6b2b6853c65a7904711b3fabbdb33ddcf14 284d321057b0f41b923cdee7a1e4d232bdebf401b2d7ce86a26b18be5ec17a41 7 374097478fafcf23273497c500962c4236682a8d330aa55717c1f42dcca98884 28dcc78964380b3c788b5e5086a4a136c4593ee5ce1c079aca825ac2dceb52df faa72d12edf72d29c13d3bac623e31df3609a2e00f70c401d2f6a14d1ec22637 12f87cb4e1d526d54a76a056a25fed43be2e71ff55c7555a3761dbd2ca6691a6 b012e3377e5285f3deda8e20c717dd4375e498d022653a096e085dabdb7bdc52 1a888d58bf23d80dd2b73ee58e891affae96e83d159ef0c8165257086bfb8ecc 092cc10d3d61507299fbc04ddfae647cbf2ec8e512df8277971e352d793cc867 7f37661c278c96f13c3539b822468860c5454b8afee1d655deeb456a587a7500ac8705531ecf48963bbe71b7a25a386f8272e52748c6396cc676e57af847c20360e031031c79c3161d29e06b3953ea2b356cdcb1e9991548574fce9884ae5406d3bada083e7c8d96c3f1820d5186c095eae35d856951a50de1e4c8abfe0878066e4d9bdcb4c0ad59104855b9792ebaf8214aca5b0aa84bf9259dd3d60f18f2052abe3793fe8cb3947405d4a464878887765ded08de0d7782b5292de5c0753a0a561b6bc7f74eabe08e8829fb782bf96a256cdac75ac42cc98b926c0a761bbc032ac36c52f1ad854a51834310b7eb4479080af30e74f20e5b5e841522cede6407259ac56f862dc61b1e9b5f2b1782ec0994aaf4eef0083f4544464da36f374608bfdc53d031b2b66a60e11536db628e43433b351f489603803462a6c29784f508774dddf3e8320d0e5b048353d4fb5823a30a6de94945b42adcc4ccf61acbaf09db3d80a7cdea0fe3ecb77ed0596113ac4185524c1fc229cf0e8c7b428a411504bbeaf1a1337084dcbea36f5f64abafdc43c3526dea212d2ab80229e74d649f0df94129c1e50251bafd1808b7081bd26d35a5d53764e761fb81a0ca9ce659ab00 true +check_ring_signature 7c089d04a1ffab01236bca15250714c0ba7b0f5b307cc69e7d3b0306ead8886c c6e03d1faf0ff638a24b02d423d8b6e0fb405b0c6bdc79c48d80d6f2965d4e9a 3 6eb7342736b3a3f1fbe76e467faeb3e67e1814c1ca6fb9e5e7b135f7678f7e84 37f5b1873a8d839e380624c79b16ba3df8e07e16f4f3675333c641168b7d0387 f71276168a62959ebce53578f7e7f3670a341181f2ae41e23ba565f62ef28e3e 135f6d8640552ae0d2e94e5a47678ef771d2b44bc43ce12b0c36922a42dfed02e31f9ebdb69a0dcf06d997910f83cce92b1cf6720eec5fc70361323e3755e50460e46b09685125625532e5a62fdecb18ba3897f32b8bede60cd065ec1127410d9d9131cee5390ed791fe5c5e3c550d4756a476230f542ccad3ccb9578d6f5502c2db3727cee47eca553223d80ab3fb93d8cc2178d392fd3992925a6b24d5240a84ccde6a1baff2275ac55628d649e62d04eaf0fe168eccfd8fb6e0b648332000 true +check_ring_signature d082767f7435551438ac9d53affae44faead4626ae0d53da6f10754c51160bc9 f7ff6ef72643fed6285a1e8394d2fb2706826a8e09aae9fe58124f13c7514657 6 2ccdf24ff93e70c5f3538bfd907711dc4f13e25780ab67c00b76f4a6d96cbcad 823b7af9a0300baf4ecc40e84f73dd67210a693268fe6e67e5a27de30d5869f9 7edecb7793beedbbb1cf8bbe7c8abc1b6cf21a30b188e903cd491060d725f54b 00507971e990056f95fd00661979dc59adda98f43959bd9c65af496d33145548 2c33d42c34877abb5e0f0d5ff1e6bbffcf59b20fb162be10cd1084d6d02f1472 978f1cf298cb158fa4406922045a423da8037dd2c5add675bf9b54d95de3a0a1 6653153bb1c9ecd1ad37ba8f51bc97abf569d36e728a21ed8716be83b85a7f0f1f093f6a4cf4d18f8ec8d8b518e0942a018d02fc399777e910aea0b2de22d40a429452baa2de1565337bf071c4f8979bd38e6988e8b009d9b45288b5b9961d0d1d4dad28e4b335bb2ec09ffd68b94213a169e5941d65fd0f0e925f2d8efc3c027e307cc2269c24fa0268bc1da5c885cafa13c76cc727ce535649800f02367e0715cd9b4c8f46c605146497c16dd5c469b6c28ed952b345f70ec84bfe85b85b075d0bd6cf34e1912598a9522c9f9869801aeb3aaf7ad04a8f6a21e254d0457709db6c31be01d156faa3fcfb1366c7829a7427da86e71b9591eadfb9942636300552840afa4f72eba3092bbd9aa2f62727bdad0cd50820a384232e2e4d194dc80d8c214dda4b5a651ba602f8ff8e9127e5f83c2abdb60e21f4224045d927b3040c497f2d7b36a6ae2b1dd3e2b4963d2c04be6fe346240b6bf618b0d48dfad17406685966af0710437d0c4cd94f792d5c23a2bb2e026ad3b8051c3c667415d91a00 true +check_ring_signature 80472731aa93cb8039422d09ec93ee05ca0959bc8deeb7a4d342b117827e7f9f 9fc2c23671c274aa0bda03d0ce7959331e9f71f81a1722778d296c16093d1651 191 d665c6a9219cb72f16550ec8f22f8e0c77c8f285a3f7f7cb0fe4df8c0a63956a afd8f2b195a67118c07f18b8769a892e9e66f4b54d9a27ca2349a761861c43db 7c8bee2cc70aeab9b89cc65a29a0fd8945f9aad5a5be48875d9b6880551c8126 f603edbc85d837d562fc5d6887eafb31bde395c06211e9cb278e4b006100c195 1742f4f492e64764f7a1c12bedebcf4dadbb437387925bbef6cff3a6dcb410c0 b48976dbfb436345a10fee9459cefc0594ea68fdf6e6f7176b2d7948442dee5a 59aeb08e6cf6cb89a801808dd58bace42463965371966764f90500fcec5cbbe6 be74efa1974f9628f6ee8dd79900ddcbfee4fb3dd424fa30bc35d2b881eabebd 69b2e1f31993d6d161d44421ba3afafe90457f528a5aed8db2213bf93c9b90ca 545529fd242fd8803fc758725206331610fcd9ac5d82242f3454ac8964231f39 ed396913b2022fc4ce7d9540a73651c8fff4136c4928411abb366f8df5d20643 3e6e954795a5babf2ed9cbc14c0fdafed053ecf7cdf21c28fa96c1cffc6e0c45 a109d525f44459c5390777941113c638ea0e6aa1acca1da85b4f2d1b0e180c15 9db9c444cd00089c81d8d27c1d6492e6e0627dc4cfb927b7267959863b0c008f de573ceab15f70ab0c2d9170ae05dbf6c3cf66308154d3a8ebdfa6a43f9be002 4fa0593048a5f236a81b374fd52cc00ff00beaa36a0a8918befcffd01651abb8 1930497cc33945e85ea276b7044b84c4a2df1a06c2d89080a6ef0c3e113ccc58 64ac2a51bbc73e9c3f5bdcc63a6b486b35100e728f8dbe141d12c458aaf721ac 48f571c07f585c73340054930dd2f256bfec54aa1b1b07a006702a75cc1fdbd2 3d4405c8542a5a0afa9f339dea589eccf46a2080d82881120257ddf204758fc7 2f85798ab9b22e080e44b7f29b996c105a494a8c542ffaeab20f7c7c55086846 851ca8d579ac46faeb2ae5583c0cdfb7c416e79bd9fc62f3c614ad884501f9c4 8ea58ce6b6645621e9cb6789c5b8d152ff424e5f988a95d6d2cefc966a8d5b55 dca6f44fc2745443a1cf7025e2666756cd8aa79133c93464cabc78a9f5db8e08 04f7f9fa22ce2958bce60f64b2bf480b6fe47e8024bbf7ab8adb74102ab546ae ff3c6f25203c13e6e79ef4a783e2a88f0efe18fb1e1e8fdd560f8e73dbd59c95 6074fef964cc16eb063dc68e21e4b68cc05031993d658d237610674ff43f743a bb88d44ae83fb2c7e44f833aebad9e27adde386dbbc7e91e16295298a7657ed6 ad366e1738ace9349b8248ebdc57cd9366249cac83a40f72761285b86b6f3618 9872bf8beed3c7570f280e7a65566577625162431491aa1b06dec63ea406085f f25a4cee387f869eccaac755f925d43935eafddfb18aa1efc8fdeab18c390cda 02bfe510e0eed668070dc4ab3d5a4ab868ae1f7312d067e90a8a02e3f2f50a9b c8e01be7ddbab3161703d28331b5d789f09f6f5859aa7c787d10353a08452823 63419a988d01ccb4163adfbe282ec76813b156fe35da0a5b17daf3669bcb5417 2a62a62f1e7fba4fa085734686812ba100e4cc3f6776fc051ed78548ba172bc5 e35196386a1807c4fc8c748abfe8c0b18eda4ecfd52213e3304b6436c51b09ca 31030cb71958b052a805e98f7debf2a9ec472b21ce754ec7423d809eda384fcd bd29219f375de601f51b42b55f1472dff7e92afb9f7aeb3c56e17509e1f8a8f7 e7a05ce7a25f58840ebb7215cf38f06b4ca586b3750010b69d3dbacf9d11683b b1070c3d5db1d01d01fef6fffec2bfd69ccca80359345afe0d360cd5541452fd 75d97dc9646beae9f4976bf45075be447eeb459da6af71886da9979f4e2d4245 450166e62422399892378f870a4505a4f7e7eef900b60e8878a5f02d36e68a28 efa544c4e125da60fdd40ee27f25b34e2059313f2199025a79e03f627c197bc7 eab535e715ba81e3342b4cf1b690acab29fee902aa7969df3d7b727f58e6ef49 3c5e442848fa4f45074b86884d246dc179dea11b7300d35fcacdfd321c1f4b74 5833daaf319c85de938793bef31c70e0522e2826750ffab8e675cfe6dd89a9db 804cb3a2f9c427b58ffb7094bbc313d9f3742d32b60cd83d87ed00c1cfae6f73 7b0fb7961aaa9ab00d90376fc1c38c9292caa6603ebd49a67eb8aac7b193fa73 de5c3e3600fe36db3bef0501329f67c73a5eac1e19b09439188a7e45bdb7321b ce81846e39a823015e63e57b290c648abded559d4fdc1dd449638a60d91c16f7 1c92f002d19552dfbb2fb1e7fff5346259b393aa1d7f00d7060417b24f50b547 83be7614485f13177d997c15dab82ccd91e729c7d00b5417ac8284b24cac8336 8f13ae75a8ef8a796e5f489138b0ba0b4a9fc2028fb3e328ccb05cbbcb14714b 19fbe69566a8a4a5697f000fc9875fb74c9c4b6420b68a7e2e0af3bb79df869f c49c234323ff5b56a3de61c1c8beeece4d62ac8553d1f772f83a5aaf70b6997e 597bbe9e9a344a0f28699986bac49c324af131b7d6e9beb3581719726f538a1a 7c3c848fc66e8f78b56b7a938cf3ac364f87622cded3de08eae818fe26b70de9 410d20f55af3b5c4b155dc80d278c4b839c671ed38be3b97d7f376a7bbb4d840 8093d1f3f5bfbd7eee8865fa2dcc7dce597c71795241a6cb0f975c259b21b211 1c5080e3c2a536fcb6a8856185b52146f65b38d695210164c53db5a93237389f cf36166fb2c84e4f5931ab90f1e2f02d0d2d9a575e37c2f0c30460aef8181fcd 1824aa474594ce36b8a8d3209a226e78e2620ea077731afeac5e630857467f53 e2d04bdcf5f2fe0fe4c21836361d5d21d633f0110aebb79c384b702fc17bf4ab beed3115a03fd947f3da1c67670bedc09759ac11de754b6bf52b18c53c6d0472 d9d5e0a847a5bcf292d02a2485ac0f496ca92205d16f0d73cf3752ed5e238fa0 34873eb0c773e3960825546d4f8ef4cd74be1c7704c1ef2a486cec39e7e7e049 ac59ce19d910d1426c4ec031f93da6ed388be13362f920e1ab00391f16ce02af 90c03cd2134fbe9e9c3f0f6cf264d4a80f1ec949b2a06e577089447e63d2afbb fd5f2ac956536f77908dae7237157b4844d3525610196db58df7073604318923 917ea920ecd0bfd81b7087ef57d78efbae4ff910bf5aa1b97609f6afd824cb25 374e8a7e730534f10de553ad74384df7938dd031fe38f9376ad247c9fad3324e 30cf4e0088767be728d4f2cdb35366f463924f544d1da6cc84e796c0e410b2db 679f223e222c0a5281931f436428e57961f6ee3f8281ea3b7248d113aa105f74 91d4ef8058489fb0791cc4f4f0c8e9c1f78bed47804b4597f06acb5ae2eb870c 0dd308ae6550d4ed048c55e393bff079c2d7c80ff2b6557b7dc0a5b34d404223 1555fa7c397bdcd878376021c98b18557c27bbfa395cd7a8dd8b750f0d94783c 6bec12e2cf90563dd0d0e4401a079973fae5a9bc81e6976afdf0242d2e46d9f0 d0c4c20cd8f1d422875476e33f71364f38047b4df7436a7c40f4bff7cd0b2fe9 5f6d027194680da3e7b032915c031ed304c528ba45c39eaeba32f49bd8266d5c 9d4bf39ffb952cf696d088bb163e22f9de637e10dd2fe5b5cfad02e5bfe7d9d8 a3c41f3703322fb59a962b76ed577ac2f8a1d1f168628f97f3fb10e051886c83 83bac27850f3ed8698bf1f8d594ba71aec4d0d70356b6c25887be1a071ff151f 934a05b8fea0a47481ba59beef88294fdb8b4e03cbdb843d15202dd4cf4d26ed 21233075b210b8d4bb20dddc5c13a5bfd86f625c506a434bba886c05fe62f082 7f35fbbfc0768c3a6c815a3223c225494b9dbe6b97c40a7fd598552e59b82d42 db8b46f17c1bd8f0a2a6e4df994218bcd0341d6544c9a0099a4e89fcc92f4419 4720a68c0d4ad8d724239c2ade10868254314820c1918ca4f41ee60ac34ff9dd 119a568b3b0bf65174ca2d71a6d475fe86b5e805bff222ca76b8a8b552f2360b f1b341fc87e456cb82542e72d491cd70bfecc18d43cb07625e299ea33e364251 406bdecab9d613af9f27a52b408dd8410bf706682e6473ac1effb9edb243529b db8b21d8ce959d41013f132379422f4c8e000f986e93dc22cc6d7cef1e2082e7 cb08b035911eb95414b42465182ee2baaabb2f2daecc4f51bfc9fa7909f2fd6b 7ab17cedde0df30f6e1585143d2c295ceb7b6e88b189eaff3656e89da845538a 705da5106ffb9955252414b1df9a76bf3e23cdff2afa2362aeda81674f59f744 38300c451d584a46fcde50feb028d235c25fbff83b1fb7786d41433ae2ecf216 a3297d76c3bdbf20267a3308a88c98570208022feee7b16fd03944959ef6f229 a9cc25954f662147ebc883f77e90ceb3b8460d9234b59f6f59369e6b559b9507 f61c632d9811433ba0b07f2a41fdfa1bc540265dcdc018bed7f755e341322c36 486b3e6f823962095fe727532e2d77d5618d696691dadab45f053997fc617311 e47aaea6c7cfc3f8028a80376f06135f3d29c296d226bf57c35bbfded1498d26 60133431894ffa4ab48ed513e58919691c835f2c4e10271b0296db584286c4ec a0d850ad4d9b6738a35b3c63a1d152b4a35f04302f8ce0b0e6675289654b3ac0 543583754a5fc1098bb83031765f1310a0fdfe4763caa27b1d2b6743871414f1 c996958266548c00033d70c9b825e2e16cfb1a8928882e76c2521a44ff912a9d d71cfbcebebd1d7e050dbb5c98486197c046e20509b887302720cd23cf2f349c 17162e040a76c7ca15e3f89d130ddd6f5acc9ab95d94d297328b73671d5e037c b1f2ae198989fa631dd6a3e62bf96c42ed8ed64c6d209da9397e93bc91d81368 9b52368728028ad1c2ced7cd7dcb1cb24c71c70d003872d7c43dfb1c34bd4630 f4c875f42acb4cda8bc4bd7d03f16977754dad82e375911453d94b124c9773a1 f2ab45b0143fc6108516e3c2f246816ce61203b90c83babd490ea55f4574210e dd619fd3354aed48a0ac9b50fc8105a8f4f09d7d261cde11c3144ef50ae6f8c2 6c9b2d4086940b94fa15bfdce53d01e673001b423b0483b3df26e24fb538fbd2 a3dc1f8b0625ed73d54cf93efcf4952d04128095d03211c07c4741544e7b4c6e c52543469d26a352b69443ad1a72ee9ff85908d6dac9019fa3eb565beea1771f da865965463f535265c85410d3ca8c5a650d81586307e2ca03938ac3b6bf2dcb b6e66aa9cec34813064f9a48ef6614439d659b5492afaea2966e787ba23e2f5f 33fa2c3a6556dfdbe76cc93ee51982a60658d9381b790707c9186423ac7bb0c5 da9f87bafba54786e1a45abbfce6f3cc6904e5078ee5a3e4d6ff9369207e2e88 bbd93d8f841f397eca82e55b49ad1a074f36c4f28a61a6198f60866a817a87f2 27065c3f046fa6aa78f7e315952f754d8e6144693359eca219892bd4a33255ff d672cb030c41db84fdc2b85d954345da1bf2d29a9889b99687ec61ab9e770a76 e2dd107039161f98907e568b56e053fd5e2006e67e59c74f846b6f824ec6baa1 23367a754d9339af2bd4f0316f3926b39e9f5846f2d8029cb5d7a3e07fbdec64 71d4eaf71e3766c8750ecb78649397280de74fd20ddab17ab1b11b80a5f282a2 a32728f0c61f94647a52ffca69569e46aa51441e578ef2819b4ca97b5a02a503 660476dcc25444a2dbbcd65e5711a0cd661d54b9899740914bd44119c43fedfa ef18955528c83e6e3dae60b00d03dc84a7721b2010d5dd05f23a9e4f93be65d0 57934bb32dd8caa2eb63b93ccaa9d3154d7284e6640d53f94de0a9251dbe8406 ef022f22489625019078ba99fd90f57d0003eb5fb01222e2b4837ec07c412513 0ac45470370b50e096f41601cd2ff8a1dca18524001419a1abd60365f82fce31 e687502823099a31653f590d27068e42b3dd128d011090864bce445b103dbca3 9b4a2400e0ad570613e597b0cf80a96a3b70306ae54fa493d840cf274bf86b6b fed32e30111ed14feaa69aa0806095d4edc8272f3a081733282d604a1a6c1818 6012f98e2cc3fc92a1af9498e888217ca946c9b76575a0590b801ad34706dc6a ece304c926c2ca80db31ad0ea968004684d881434d45d4a4af8bd4a38f913263 a40267121a1b2da7fbeb441c287b5994262a7169d8d4275d7819b0c6b79dd913 621c4e6cf6956e569131f67d256348eb5b4722c2567c4a2f0e23a67daef7bb64 d547b34756e50dec42de08b285bd3b2bbdb5346a60d4773e2eaaab61ba38e647 14d68e4afcc217a6bd8150633cb4c60fb25a57b32edd9fc4111dcbc61ee8c412 465fa91613b104dc9fb219c450f1348f7fc2dbc1c1c5b97ed63e116fc47fb343 406ee20e1674a41cbf2499a7ed089e77e51cf9d499078e8664ffbf5f5a4311dd 19b9a61806a25395d9a69c99c6faf04960ae67058d16f43a8188c35d6f1c9368 8f9a937b4bb38b57089dd4db58037daeaa4e2e2b3bd7c36db2dfb9eff503737d 94bb4b9cd206c8b610152aee41cf051916cbb9a74d52f6c944878ff23f3a1c32 3e291c8a292831d1c69b218a6c80e9c183f756f97f5ad9c3b6811b190dc890a1 160e8512cdcd83dfb299754295da70d3eeed2c399e7ab0d48f3a6a78dcecce28 d97c08ac33fd9f1ef7ca7cbcc24c1af010386e2d24a2f31b74cffa006a57c8b4 161def7a0a516c4a1f7509461a80600472c4ab12baf7e408109ae952e5d8eac6 c658d76736e98b919f4fe6d0fe4a6bac5947903cfe037c1531d9767f747b6459 cc780cb91713a1ad47c97a92e2368f4fdd15296995e44eac435564a317241253 9160213065a04568c1ea5054a66f118bffab1c50f9f400ee55f2ba104b0b0016 93201da12a1ae17aa7eacca4f717650ea081cb5c2c947595858eab0a08fe4468 05b1869e9098b832c6c2a63a8a64bff9e1a3cc3a7946f9e00a48807ef41c1a10 01c387c1d1934a00981d3f58d8b302c1a334cdb2d0a1fe1a9a10c37f215c42dc 30b911ea1a558b1acddbe29287a4ce2d13680e400f3876a0905b40e7913ba14d cf005decead540b2eb152df4b236604a7b0f323cbf6bb8c5ee983780acdbbd90 ae11fb0cabd979c0db772dd9714f15472897a57bd9bb186ea3ea34c34c83c44a 06f5a61e13de6aa8d19da5a0714b790242b281645b485f831789122e1ed7cb5d 6a0609838fe9b0b1b1bfbba6e79bcbccf2e7ea35ff5de5278b90b7a4cc523acf f1aeadf1fb519077310781b43666534ae5e2041614df3753ea5a2f4079ee91fc 8450e307504f503288519fd25733e411b6d0ef6f96ee61c9f1c34ecfe2173258 821cea818ab6d111fe73128ef6b11bab0967da4b3aa64d952e1cd6642f66541c 4cd38a5291665de8fa9870ced6c131ce41cd6333ea279a9063c415bf0370a42d b821e44895af85e54ab844cc19d1496b8e20daeec387f5bfbb2b01c07a68312d e7578b07927cbd13497ca05c013c19886d8af38755d480026e735560098fd9e4 e0c26645db0ef5481e17b78c5e48869c039fe66933fc1009a5158c6bdb85c7e8 808d55f57bd44c4c545e59142699ff4918266b724300eea059f666e2d15c3673 0af25d0151bd4b054ba9263178c99279c03977fd9401bfd755141e5b3a0e5b80 e64475b3a4d277b0d24627ebfbc5e97e0b39215e9d5283f3c43195302ae1e09a e5d3fbe47151d8db191d2a93318bc30b7ed483002aa0f29bd599c10c4cfed91b d06ddae131d19f25130c7b95385747de41ab8c30945a6fc798cf6109c3f96f37 0c1f5d54edd0fd3216519944764bc1ef803d4886c4593428bbd8487b704a9873 06fbdf0017ca07ef4bcb4369ef8e9c51eb74f598563ce1a155afc78b183cf253 fdb25d652900643c020ddbfad36f86a94d82dd15e87925a6cf857484f778c952 999ef517e0e713bcbef659f85864d0a7f12cd96f0d336a3c64e180f620a965f3 c19ef32cf307317559283496fa329f55024c502a63417524154bc6bb104a4526 96d477bdb6cc18a4e17dd8843b204b29d4327b957b63bc8a9d4c7561c6bf2731 64d0dc7d8f12987a359a1f817a5197d3de07668c5962543498f96aacb6d68eb6 3de230d5feb06eb5ff8fbdb0da15ee619c74e145b42e2c6e2809f2ecc4b10db1 00012ddc9677d35ddbb737869ec0d4d2f6661da5f1fe3ee0fda733aa15ad6607 fa3c57d0c23f9d12cbdea3da74b94faa9d00de84a44cb823f7776b7d8220ca20 cd3eb0cda5ac151471b9af22dacfd4babeb8b0b4bfdd8e526a66595e11ab6b6e 2b0c49be0a7c40d793196ddf73cbadf6426a191a25708de07403f07dd591d8c6 70cc142ffd15c91a57df47cb8739a1b1f0319346253234dc82a09b70be29b57b 53586d9bb5308440ca010b3cd77ad7d28acb93c2a403db77773dcd6cef54a9a2 8ba16bb85cc15f7001109ba5f902a9b17b08bd3d9f2c820d65336aad40e54f45 ae3b7d4c9b574d5aef6941a3b6181a6495321e866b5c81e473ec898d3908de79 ff2029425877e277d178291370c55c4f894e20046fee343166c1f10cb543c973 4e1135c1055d21ef46200e0d8eda13f9a588d375ce1b7657b6c70db9ee89ee3f 5d455535795952e17e0cfd4658608f317433d56d266d09eaa027ff7f55029fef 458b800835c2a15ea19c8b1cfb19281e1cc39468149ffb0ffc16ccc407b6282c 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 true +check_ring_signature 7528542aa7824637547fd7677fa8f4ef4d5e8e128756b98189943d03f5c6be80 af1dd40203f4e8363e0791303fd5e3f0a2885b7c805ef80675e3b7a2cf7e30f2 2 80fb6f95f962e1f75cee05d34639ead6bc0057ebb44fedc53286df90f8727f67 6c325cd3e060cd3e2bff6c2589261bcd58cf50daf27dc352d7b698d0d7d4b3d4 5d440152d7d497980039e79024153b4d9c41f32fd692a9621634644d131d2703a326785d1e2505d0802ede93237607d66bb696edaff4cbbdd8d1116e79900c047cc678b1c6f2347ab28c9ea5d89cbd9d349a461a05f206c4e71cfc412133f408e827ddc49960f114738926d7921d127f71f78c14ce2e033a5c5a5528acaf1a05 true +check_ring_signature 13a94a5f9dcf71665a122be77066e7bddf5d150e74d66f2a516cfa0cd94d712d 181d6219cfc4db3d10adb0768a63575b38b9e5b6f8115d32edb71bf5b3a24f1e 3 d67f6f68c86bffbd4e00d2c416ee56972dff513c6bcf19bc3218e7d1495ab2c1 8ae882ba02301fb18834735e22a6343fb72a69c86d339c249a7ab031920f9ec4 ca26e2e2339cc22de972a1b9367900f64b830a3daf0d83bfd0fe1c2576ebe81a 4c0c0707f2b25808ded8b7239c4e449b9e83fc9c21647ec5b6fa56ce59dbf60f067af6d60192751177a58555da5edb0ad5f691c74076b6844fbfc80b1b63660fa0f94f640c96b9dd7db295fa844df435f3a9a13582c0116ab5c2a92d766ae806f4e0fb20d5dd157727700b77319d010a0974eaadc1d2c4f47136d76c9eb5570c602fc00631405942280c86b38de5da4b7c4b81c06134d0c71e2cf3d3003f5404d1e45491ba005bcc61414c478726504b9ee8ca21b7697b88af9d904a76d1b203 false +check_ring_signature 95ca51a8c2f7a7d8507f350b278034f2f56adeab3825e02fcaaa23686df643ff ceafae2249d93b9d94a2d4736049885905722472637f456ff570fa2777db95b3 219 03eb19c00a3c932be3d55444817b7795d25f1a2ff9734c07b4cd765f92c3943f df2cb1c4b23cb5d1cc05dc6cd01fe597fe695d6060a44d7df94667a8ddd7d0ed 4e3a3e1465381fc7dcd3efedc75e55469a6375b0494304827150f9f41d3ac238 637041c8b379570963a8f0b0486a8d316ba8b1e7fd48bfd6ec08920e0ac2d053 213048b6f466468175793ab8e93128dd8f3a30d7ab3905f6c2c47eadf9b6c7be 0a6640e8d2e2238de9d546089e2dc14cc5b398e69aefe29bd8533805f2de8326 68c16cb7fbe2179c0f6290cee73335c31196788cad91716133870206ab0e3d03 ec3c0d8caa7542a1ee1c815ef90062b13e78337eb17c5633cf4832d69af0fe65 cb0af78a1384be960210e93ca46c2c20427df7a1dacc4096fee9f09130ddfdd1 c9e0dbfdc497a16cb9f67e4b7b21ecb4f5d3652321b5b302a3b6b0cc5817ea70 683cf7837d93ec85f2ff9142d85cada1902591b98b67d29a1e7115d50537f31a 2aa05aa253c495ef70ade53bd94094685c7a82ab41c9e51d8514279ea8280e1a 1f94924a7e4ca36c2c0233c54d8194cf89c7231d54593195e8b753ad0fdc1a55 d0a03b49426e897c2f1444ca0539192b8b2a0c34b88d5e0b68fdab20d1495055 4341d0378b1855fdb9c6e9bc4fe85a2299786cef2565e127350c53d6c8303ab2 ddbf6488fe2de45cdb47426426f60767cc4e808cbf738d327bf2432c64492562 24a23238531412d373452e572ee12f9a0e4f3f5ced2d25a4b657926b46fec246 68e1f4f1c6edb0ed2e25c3a9931a062aad1693010b78a072fc6e2690442da41f a6e670b656e52850686d4ae0c6879e8183156ad58da1373dc1cfb30b522095e7 cd1eae7993d5b2a941eb75e575b124ebd6d977392ab97738e5cb82d3a40a73e2 ada00ddd058453530457b1a5da9a172432989f49cc43c4b354ae72c3cc4c27a0 302ebcd8163eea85179ce8765eae761bc9d2dc1435192064e60d40ae5ac2cba0 0bc23a4eaa22e0a84c86258efb75dbc3cad65a78d90cc290afd3d6caa0d78914 a668384ec6c255f37d5572ce41b9c412e083181a49c66c2a202d5e24f35238ed 56cd48651c4d178a19ee2c78144a11469e8b16acddfd6d85d0dbefdfa414b1cf e25b988551af890918008f17913ac2f6bffe04eb8646a5989a3353c664f17468 8ee2e4c471eea436300c0038251c92db61f9ce6c31a06ad2e90f6c12040b466f bdbb5b04ad19e83ba712e08f5842a41b05f5d76caf4272d833efea78f8e641ab 9d7702a66a60c546a32b2b91715908feca0a03f8e1fb591bbaaa721feaed9f0c a81912dde709db48912ca617716b647c386076374877d06464109eee5ad7fbca 00ba33f7d899b36b252ac7be6142e03cc369739adffe4025db800d133e1caa68 28e0ea5174dba8419cab525308cc1afb6724a32a4cba7208ac42b1adfd69ff33 c395606fd6ac9b66889e65b24d47ea435612529197a40437330f8c15f8d9538d 32df64984ff3b0f4cc10173814062709115ffd6be255d09a6b42a63b31faf6a8 14e70c55d669a18c6128e135b5c4926182986508efe952d39da184e2d47d1432 54bd48b7c386cfa27a807b4f92b8b76407e642c6feb2e77003a2bcf2aa7e83f0 32e949d21b5318f240a411c509f660f99daac32ec3527f6e0fcc095c7d5ee22d 99f1acdff2fb9c293eedf9edb9ec4e5b5ac9621586979b899531649a900a5778 de929eb8a5a0bc25e6436adc23f9f755ceab238d91ef5521c1bf42ca7f65dd10 afa63fde32a434773fdfdff8da439173dc17502b791e05e0b70d1cc909e0e95e a2c4de43d6b260c421bdba67edeb2144b7da44604e713e7834cafb2bf24e2262 c99e3beccc255df375eff9b85586d8a53c9064f8f30c43a14767638e2cfa252a 6ee27c4c81f89a8d81368a031cf90f1a7da150735e5f3ca41fe68d30a518c9c1 98dc00c63fe88c0a88f0628a5772e01e41ac244c2870c0866c2f8eea717d70bf e0afbfb7ecf8f6437997ecb04112c69034a75bd7bd46dc00ca18290f724109e0 f3e4e8ccad0479801df279c4aa07ff5ad535223e1f27f335ab6d3e2fe3320bfe 1ffebcb926b032f601563dd3d77895b06e08474e89d9c88f6c31d66d49e792a3 e675a29f33796a91d6975586b65257bbb0dbb7a7c7be10fb7b1901e362820107 9e1aa70d2a524b94da0558e6e696d05a914cbd14ebb98b807a23cbe6c3387ca8 f8a28f4b8574006c909d56240921eb00331cbb4a1046c9021932f3e80ac81101 30aab1e281939abeaff88b9af95d49a30b84bb0314d2ee4aa647ecce7ce88c0a 363b1114b4dfc7c38b13e6427aef8b690cadfbc3e9a4ff1e2e4ddddfb322a82c 487a5ac1474540102bdef44937bfd8b1e24dfbfbc533d32846be47c975b98496 41cc2d40fbcc7aab975ffe2d5c063442881ab1338cb21d0302dc84783c16f396 73600b333ebfc36416f6479e68aadae46e9f29ce8149a6f73d89762e18408db5 f098fcc85d066c7eab87d5bf78e47f12854d7e4ec839e6a7d8534bf307c2d6ac 85020dbdabf80f5e90860cda0fa2e2828862b24ae74a73b6e1c697987ad2aece f76e7e95bd644c025090183bb394d2c0a07b31f8ffa7c3ce83114ce99b0f4439 2757e5ed33d49531d5d6dcf9a66ac0ef1a66bda73715be3e96179fcc3920a94c f13d4c756575a6e14d20d28385619a0c5ac0e2f93931b4895ec513061ce75be6 4923f01962aa02ade489b9339a533548b028d25d2e60349c2606714ba283366b f54b5099b690206d4bdab5bb308109f332c49d83ee80e37c8e357944631f50b1 b78963bee1df83fc7fc61a4589b0a70738e9161d5c4f01f337a0552203b81fb7 1d85cee2e2e765b60da11e1e1d29c36307eaafc940a62a73ce87fce2a9ae381b 17c7c2a840d3263969429e0dbf54f8d0a75eed30cc13ab033c791814e6cfcb29 b1d05204aed42621d64dde1d15e83af274a6606fb300a0d68fcfe8fe6c1bfeff 3ba7c05c49112d84e3a188a03ece3ca6c71c3987154f833471730d6d5a60d8a8 95f777d7c97daf6943f73542541d2f037ac5900fc27d83d8d0c65b9737427751 baadf7129d0eeb7ea1658d4318ec717a7321af52a334d3c98e1573411924c1b1 dc9ee765b51cf38cbcd329234557f10e12c394bf6c0cd1ae451fa867e61e1fd4 3097fe6944640efc4416df2afa5f17925d4cce8b187386db0d45cf906eafc0a4 21e785f56db22ce09a84dbba30e40ac589689f5fe8641a1586acc61e3fd5120e b1b394c6fe7d3af18ed38d4b4601f32c924796b465f6b4f7a1350717f507ba4d e53ad87496327ca77e71e77302fa8c1885bbc9a9dbe34a7891a2aa1c53bd751c 8408ed2dc04a0f001be4909879ead159943aaee81b77c38d91ed7f05a3b18057 46869db5ff04e021dc7c3a15fe9c88c5edc4936d5d4a330b61aea9408c2f7a74 3335220c3a0c97116b6edac1e77b318495ce9d280eab1d3d102418b3d7fb4b90 470cdefe426398fba392e5834889a4be3b6570aba54ea6f2acd1c67d47570130 70f55ec1ff84ea2519953b2e2f9c34a35d2e052d066be2db038cbb5783ff465e 6dac8b7aeccc9ee3c57ec1abb4d0858ecbd6782a6dd1fde36e4b1492f9f17b2a c6972918fdc92d9197d8c795fb862392cbf942568175ff2242b4fd4c365f0d44 46b3a96137abb2b64f4d305a7527e2fe87fac048123f7989ede4b4bf09cea4b3 09ded486f7616425f6029944ae7507e5ee0319f91dc19eb0901bae46c94cb79d c020f757e8240c0cad34f737b3b317152ea9f7e61ef78b37519a9306df7dce8a 2a85f11e10afdacb1470e85d69c488012617b9ba26ba17ab9a995451c5dae9bc 895a1e62823137808d542d5a1375fb598c3e8d57e734647e553b4b8e453bd7f4 7f9548fb1b908a49c3b155718c1990b0858f9b88d68a8fd96dea1202632d6d14 19bf2cec93ffb4dc3f9f277f79d19f682d04aa8121c59926f30f280dc7a56f12 11374284b8a772a4f84915e0afc191cfbf2c8cb238ec3dcf405e930629b037ab 456cb5d4809fa2f6bd5b81f1b8b8e4236c3fd170c3b132dbf8f2aba7510bf5ef 885a7457048763eb2bcf705ab97b4f4ba33f56e9c4cb97707acb0bf83a1273b1 f7d29212f509e49b2ac9b62ef7e2a92b7331a4cf25dc36f366aebd90343f79c1 7d8ff28f8938a2f0ef6daa57a2e0c0fa1c5f3ad52b8886cdbb14c5350ed555d9 865857f782ff2919624c8110982c9471e5e322c026f31a1f374eff172e1ff34d 39df71ee4922c10317cacad9c73d24ee2cf7e3e5c5884a34324ebb603e94c1ce 820b59a51cc6181bf11588d73dbf5346fced0ce16cb39ba30d2538e89de9c2c9 dbbaaad635f89d33301d5557ab5ed84531f620377cdfb0f578612294d4071b73 7ce2c61dc029c099e50b7fd419d4e9d092df54a005c508a007e9bc5d8f5ee53c c8016c58b5615bfe5be8419a3a5a65308fc2de1aac8e15e8e68305c9c3fe5d21 6f34c89fcbeb1380c754a3f511d98c0043e3250706023c5da756eb57e205f480 e2d2ba29e8b53d97a837305d91cf94f0a7a5a6a83331355cf3dc3621805b09d2 e82e49fd7699b2cd21f2925c8aa9c27d2892d0a32eee8d9c3a019ad14828118d 3950ec75b260e7d0bf7d20cd8ef02b733bea743d46d0a457f368d84b85970a8d 8afde111cbbe8b0e35ae1ba92fe072b625f21cbce2afab22dbbe435843328572 dded27946a7971cdceb4aea0691c359c2cb45dd9e70fd0ccb240f1934e9b0905 f4e501fc7b09111ad194d28f7c5685499e110e3d1efbea6f79c9698851de08ba ba273ff57050787360c331e7449945749cf9a2767ed50f8c3572b3c7dfdc9039 d3014f3f23ab88b1b83dda241f19049bd80ca125f11be9d67cbd5b8c5e777add 75ec0373d85c40a35ad4b2b87ff606284132574ef180c150ef4f9253e6aa1938 709ed35b6dc2947658f57b6434a631ccd73fa3e44ef1d422b84f3158706624b4 c627c60939b2b417f710a73ecc1f64fdf71858e7f15362099525b29ce55b84f4 9458a1284b3aef5efbe954d1efdbbb8d24da3c90098f9563c042e6d162bec7b2 963c48e7a47deb5fa2e1deff27d93f677c6b073d88463bb96c5934b1344e7fe8 3a438da556d7fc45324eb0501131465f9f30ab0be293012aeecbd5835bfae2ff 09c20d8b72f259bc426bfedea0125e6443b66cb98c62653d2fe05be84a5de053 23faaad2d100e81312e3b2ee728edc737aeff37604ec3ade241cac7e29a9cd0f d1ff1eb285561f6c0629e1cec5b2c3650a8f241d79c29407db59d55c24962a34 1c9cfe0aae880aee76281649d84dec6a4bde2984fbe2f5c412774229d7974684 89f82cfb0c8acd7f439fe37b1a669274712df02f95b32974ee2b3ec1a36b241e b3addd1fd263321226625aede3953ba4672aaba600eb745e2ff8652766a9d557 cca17a7bac9a7564be1242b3ff56aca66ee7bfe753464cdee24e34460ac2af4a d700143ecf31e30121d9ed0728ea8b91135c22505c9df10fc180c8f4d02744dd 3d8c3a5610ec6645b8f2b4228cb9c571626ec0ee8516bd844ba5ac2a26d34064 91f469cbfe33b4b448a9028b2e769dd1c6b9ea26b468295ac41c1ca9157a968f 086d215240dbb593eab64889ea7848be2158392a6d6dc7bb5aa4505a35a0d21d 51c5068b1558ce07082e0bf22191d8213bb0d6af9272f3ebc9cd63f46c231478 8bc8f7c023be50b4e08f4a9aecd510be8cf0acb0407ea101c38b1b18be5cae0a 6022aabefe39589799c520c0507885021d99a0be75df22c7e11a6217c8060499 83a167f2590973883011ef4d1707744ea0a7658dbf2a8e39987d0bb22ffbb830 751349eaae8dab1075a803d185080561d470931610703d12824c23cf26b4f0de e42dcdffbc2477cfc5dd7b3164d4195d315fc2c8801958ad99ee4f8de7e3544c 11042002c8105506ab384e2fafae0e0d802621c941cf34340f4a7034f053080e d920842ee6d8d8458e5c0dd97dab75fb454f7b240e3320b4cff3fde7bfac5dbb f603c94ee2073dab38f127d914a757655747d0cb2ac71c2a411f01f2f96affb8 7ab3492481b02f5826d36fa9d74698b0d386c77e9ad8c3924ffb47b4d4066929 4bf4aabb164c2f1e2562d9f17939515f4e7ad896ffc051f37a6b2fb049aafd10 e34c7345b8a3fc0f73acd27914bc855ec820569698c29f55f261659afc5f256c 54f651a46f7d6b6fa9b783f9f488dc77a89b81a222d09146ee454d4f6e1d5088 a15da4d114fc29fb03269edfb174070e4dc0a1c67900c8fbd3e42c054771b2c1 be98c91c95fdec9ca71f21ee39504041b5c0e19d4151e5614a94affb3b22eca4 f251da3e7e51a60dc31a529f529cd84acf2c2c098a7c04b6a1ce78dfc6057a52 5fb19d9e62a587fc436eb173f8b9b48ad4f2f782445fe91bf63b36a0fe3bbe81 5b12daa77f40cd07bf39aeb932cc98fb6f862d0cea8ccfd636d25d111579c916 5da9849c4c5d522884be6e0d7033962bd963bfcfadf12630671d9ac15dc05456 1f2a643fb2578ebc68645d1e33b40460cabb9a4b05dba5c02af2596e9b52b257 5be3486529c36e80168814fc8284d596c22bb30a3b2d0f2c933532a0a557d4d1 e5d3a952a5f3f2a48b57c655b05b1743714ff679508a17a8951013ab22e6a5ff 75bb450728aea098d776fd54b444b1a8ae895795800d8caa5c4a8bf8a878fcae 842dc6e9d7ebdb06f23e8b6dea7526094a417cb88ae6a3f676f8065b5e47a484 05943fe4cf943630833310680bb4559f09b3da461a18363496a73b32c96568c4 32c9aa7fd6376c0a54aeb243ce86e450a0afad4d9f0902635ae688de1bf765a0 10b2678fe887952ae6217207990fc57d0cf848d16809c842d38f54d6d4068b57 1e3ec341863600457cd1754e3bbf55365082d01162bcd5eafe30a94aad484063 9ca0ce25d38d5e8c864fda98af161b331ee7e726805adc37fed5a09e712515ee ec535d8f19dd2ad5da907d62b4e027ebc8ae2562022c5ad66054139535de25c3 13d117598797092604eb2486a00423dde8cd92e9940fbb8a602e3aedc7835be7 56dfb9a590dc5b90c19f0a008f7b70d5db9f74aef1e70a3c512d17a3b4612185 47307b00a7de3bf85ca83a694ee119586cd37d02c0def54f9fc1b49c9c8681e5 3f62be9cb66a1c2a3019d6f2b7fd9b33c73bad04e5da97cf9a037552b6cd5309 44aa640b56afb7aa75a5858c0468c45a59ae23942b205a6a687144d206153b99 8a5a92934d4865f153b2094072dd5e81be18f4455fdb0ccf3c735b1993c78116 bf290616588493f58dd66272f60110fd8f6f026a7754986eefd5018a993d0bf1 5247cf73cc126d2942169872d9229cecb00aa74db3ac0831270fd3533324d86e 7a5505223bc16fb01b99055ac918f9c3a44edeaa5db7ce9f4fb06891ad0213db a4958dac8e7b8be9e109eb75bbdfb0605ae7c88f56213d9d2643c748168b00cd 90f6c3b11e9ce6d7ecfabf6c731b231cc14ea5f798e0179c7af29a244795d0cc 5510aa566e3522b877170c053ac70316f1fd5fa5279388c12419966a91a0a05a 41fddb78a63e5a0dc9cf962880dfce34d47b830ae876230bda2420ccf8198733 4b4f25d2c0f0edf95ea1d735fbb0ced451ce544a37199ec662c302c7ed5a00fe 1fe62404f79a38e5e5afdd768cb937387e88eba91be8cb6e3dc8921541eaf7b8 6dcd67fcbc2ea11297d4194c280d82c88ba7f639952e395808e0d71138b23faa 352c42035527381e7d60ae2c6796e8a45c35bee328231c4e46e172bb35f0de88 4e38dd2a4b15ff26b6d4723ada304a408bfe5d4ead563a76f572055792be6ff1 caba8ed1d4203efe406577148edd7c1d0e5be72fc2bbdc6c38c3aebd1a2d4af3 732987a9350d9a36b3afa79c53b9396a09eb307ed158cbce3b69384947ed6ee3 a9fabb52435b4c087acf3ecf1383448063b295ee2693089ab2bc2d91729c85f3 45c9899c70db52043c14d263a222657b9fd7bbef5ca85242c8ddc67448b715fd 22d5553e285760591f035fe34c15d6d5c5290287bab8ac292ac9c709890d1221 d71e71669629150d2180c09536356e793d5806d717d9c5d098f070747bd2414b 14efebfe4fea2d2b88deebb976710e03c7bd2720c17595a273f788c1597e96ff 05cb3cd6187c3a0d3900cf6a645c8fafcef3e9387b23e81564548184719c2c67 823b4ad3029a8102a6697106f318b7375ad05660d108b7ae233bc2dbf737f467 fd2df33217a23847167000be4ff8872aa97b3289456893bf6b101fa138ca6115 1ecdd78c0bd2e9e7770f4879c67db2d5d9b4161bacfb28911ffe5face0881e7c bf93da2df96c9d400c59eabf127de18e8704d96633c99bf4835fe5179a65efa6 00e9898a9a4e891f6ae2532b73a17bbbec9c2605a5e6eaf2c983ddb060bc6964 df3a9df04de5842077e8870d37a7604ba939d61338f68260a7163f8e4b2cc51e 84156db72eebeb1247a3c88407c3274a2b9b960fed88597addc85ed3790bd62a 9a4431f3c571883f89cd3b2a9313679b1f306b03a0fe7abe59b88bf698756a09 f81f594397eda1bd7264daba576182c45d3bfca139decc85e533bc230e7fc62f f0a4b4e8b96d49a68132976e804fb58303cca84814054a9b3391ea661047d36e a2f8d5a5097f1b43c787cf591823e0695ada9296d541070559a3ea88a9c5376a 82382ad13257b3edfebee63420abf8fc74517bddaf63f9b7bcc0aee851f9a138 12af1d69eb72023624af1f1738258a5307ca6267cbe6e3fe5e851f80f77faf9b d769ca9df5e6830ec8ad88c4d728796c6a6a702cd803c48cb96bf892f16787a6 5be0f9d1144327e53c64efc559f4752dce19c54d8157094bd2a4f66565c05bb2 e6fd04cba17970e55be92339a0a72a9a711f591e1fdfceca609ed3cd7069551f c1d955ee0723d55ee486e634bd2cf3893e0ec78f2cadd77d0e1d95eb133ba697 b40614f28b1de4720bac79078550655412b53eb33a5d23544dee39a59fec04a0 bb99fd768da20c7e1a4587e3926ca390c8186443c9ff0b2dcaddce9c28c1c670 8dd4b85633b0e9c65c861d3913eda5a9f43c9b2d1e6920930013e1a83f66f04e e49f99bf794f1db122109606d1c4b0c250078fa5611eb1f9882a733119cf6bb9 2263b7813ce892d76bad7d82c4ad12eaa07128b438d239737a36526f0dc7bc0a 6b2e8beec380bd9b3835fc87f072080cf68f83bb5d1da0049edbafc633639f7b 4fc4f5e9b254e044a0e032c2398d7ba334f0c2a88f4d2b44b27c3eaeaccd1b98 9d0d4224ff08751ec15935406b2b22c2539ee8f3126394b86c32e332ca92de37 c5bec5ce6acae2e9c32949517e79f61e3584d76b4ff58dc99fb0ac671ca23610 1fdc3daecf4575949b34a72d89a8288eb95dd8e5c3ec403f9566ad75f2b1804d 18e99baa8fec0e0fbe782bfa3794996d029cd97b61268a2c5037bfd010fac6fa b2886c6266f8995749bcee50e8ad9c068695533c4437aa9366924cb43d8ae82e 838cd1d6ac6f78408b8e69a0c4ab7aee4de1961d42d43898c71824e80901239e 512013c2021dab3547c483d8329c6c9f6d8e13ea8c26bd8b22062041cfdbf09f 04642b7512f9bc83574643a8264283c0d5babd2268d0cfc0dde2a0e9cf485810 73f1d238488bed3dbb6dd2b17cc2729c37a856c4480c7659df73ba720e06af66 dc689ddcd35537242d54bcc1d9c8702fa7052a3225bbcc6099c630846b86eaa4 d940524a347587f8aac7c625a5f2e9c09964a81b3bd23d9935581f481410c435 c13db87926100d59333503014d9fa86cb571fdd8f06ebd18c49ed81dbbdb35d7 fd6d7b3cc4beb0b35320193c2321e5a701c102859bcefc03b59c04771c9e7dc3 41aca81c3610c710d6b4d50ef7ddb6a16e5a1070f947b6b992aef2154aa6116d 2a335f036f2be190d619200a4494d11377274225660ea2051270925f39b0800b5fbbea24f42e23ef20318a301169fa0b33150787bcb774c0e7165f6b645da1028ed153ca63fce2e30767784ae65bf1aaee2dc3d58f1b596542ef0eb6fa205a0e064630ce3dfc724c35c55e6c5c06cbc5406e2ea2b53061bf4644fc580a444a0b3a14ef1c0c63b97862c41154f9088dd9e5a048ff579abf70201498d3530df708d18ac9803499cd4f73275322f075dff5066ad323dbc284a070eb6db42675f4087d9bc848224e9d30e921c77658aa3a4c239deec9720bc725dcebc761ac54a8026fd3cd07416422d76cb224a10ab654b7167172cbd41cb3df8af5f144209f3707e9dc0ead60442637e9d21d03bb086ebb6d4ff6fffb122ac09f867569bb136900e46267b36a4c7dca7f81500142b43ebcdbf3819013f107a93aa36c699d505e0c7e9d4f521eca9032cd00285df847b44e72384038e3bd23e808fc6cd422dadb0f7f9bc5f7492e806e72fdf074a059fb5144bb3e41fe63b3d98f9d5df0e01ad40175183127d227cc86154dad8229a34ab6eef7feae6f409d6eb85d076d0483b60513d97d59629c8c88d1bc5e13632d62f5474912fcd64ba1c27e4de4a3320747072dd84807d658d3586e6cd234c16bd7f4d6f719549082d6b9fc3bb05cfe7a7f0bfbf5045a7dae4be973b311bb147be460248d34cce6497695904618aa33853c0b8d43ea60341896abf3f005ab92497e89ae7665187c7024a537b4c35c9f56660f4c9e558d5b5bfdaf5ca3dadc97991bc7164799cbbe76d114f148407817969c0ce8c80a05f8bcc5a17df6dae0b9e5c6a531d5cd395dde2d211736bf9d8da4620e535b3338e11b1ac5f1a37d57f8d68b35fc9525bece15d7e01eb3ea1e57bc2a0d81a06f7a75e60c9b3c335a8be836390f76c02ade53bb997a0d7f90718a355406aa7a6b0b2c5673870c6d95a243800e745d9a7a0590562bdbc16695120a93e6032037f6e0bde5ff33545170f7fef30c724ab3eb29f6db4f05018d37637c6c1202a82cd85269eefe5192e40d69a67c9e39391d52903c3faa9e7007bf6b32e90e0128c62f3ab9455948b64c9d9388af948596ae93d02c3afa4aba4fd1358755bf0d62b22e7ab9a24085be55b01d137e64f177a13e43824ebfc94704b1220a59290afa1eff4838d7ef7c79b57417381e851194e054747cc5f86ae114ca556cc1320b38867d99eb1d16866402dbb905c3a4dc7078d0954041a1f58f6c47c6a87892069ba900f3ba48d15b8e7513f51631eea50ac21c9f34e7c8766f1641236a9fe0033a0b279fd87257ba76585b94cdd451371d7d0b3e77e02bc2aacf766b8b478502b95010df95517847065a2948e4b40ceefe3e326f7617a7087184b52e2c63ad05dc9bfb2d9002d8de57dd0d91ba69ff6a340bb5ac54d93caa139709f68786140397f839057b958e5006e9c1fe00226e3c7aec189dfda28ff922926d985d542505db2d9ca114cabc9c6ac195110e3eae7ff9e4eb0efb35baa73c335ea866b98504b2cdc86964735ad6922c0f7feeba09007cd0508527c205492a981efcd8a3b40f9b78af08baf09c68c090a8da033cb5438f68b5154209f7d27c0e3b2e1829370a00c84d53389f0965eb18de9fa0c00936ccfee8bacb76ef718dff2353797f270f0990ad0536210ea0facdbc7aebdee3eb9a5e5b5923ff361d4dcd5de43dfb60062e59a6957c53afbbe6b56827cd90801a2096740f423e23082b8471944d12390e7bc960bd28e910d0f74f274c5b4202df2c11bcad4349126a5e49dac744becb0c6fba072df9ac78a0077ef0381f644318da4ef5374567ae9c90ffa0972b38ae0586009823f626e5238b503c97d2061e725de7baa7b00b15c922452a8a4bf7950b1cb548254d44ccbe0a24f9ff9432e37489e1cd525b328813fd43555847d71907f8f86b3e3ced92016974b14ed7acc5c05507d9e49d1c4d0e22bb3356c2a4bd04e798fd10308fbf9f22505dcbeeb2c42691c9a7501cf725489a4d71713626830b619b3f745f30df274a1f38dc7bf467b2a84a7b9fd674ebf4f95ee2eae97b820894cdf5e135895ca3e0a350d84502e1f6d11f64df299371c0a4e5643a2c248106fd338bae8da3a376b12b39abe7d4e4f78b1d8906f30ec239423c193c649d5b0107da4c0ed19fc6c072fd998ab621e3ff521971a5a423a8ceef3a774fc5012b0f4d198f1fc69c53107a00412b3ea1367dddb8bb134544a2ef23dffe356d22cd0945c059f635d9c2ebce160c09d98db5bc80be2e38bf2c8adcdc60cbfdbd6eef087e9857f1dd4905b0b89e4c7d594bbceb64c5a1529988f709e89cd600e42a4c0b5515a6f8b17216c6640a10c1f1cfad00737c90712aa54d40f21e2d3d3700720a54b92eea66d396dc1597277804e311096513548a1865497678e0f15ba96bae0b3414914e7afee8c5f54efdf808a391e122a8fc6c882e5e0295873b684032660addd4f32187c75a28b9e384c4b038124b9194ff7300cc505a005339a6033db6085a472ff1b6dc5b6485c126eaa7c85d1ec1f9f12064fbd7d5ad12ac2bc9ef000cabc81c1b2fd8096a4e743c59239501552208b6e22049e8afea8caa72e87a8e00497f1dfc06fe44c3ef04a5625bdfea778a8c09e66039a5b5bbb4c7b49c95be0905eb9cc2a0d3fc333767a92de2acc4318394a7860113af34a52f6aaecf75910e2b443e2b87aaad3d005312aa33a1cd97d0a291b3c407732fd82f7d275740060a3d23c8b73b83d429124a2904308c6304954e15f24b7ba7b1bf163c8a6fd08609dd265752eca76b93243998ac133965f4048c2b773dbb503d0a104a3e477ecc072aaa0b7fc4a55cba9408559208e53e78c9bf618f853a08c11149d922aae5f20b76c7b279be5288c1c997ecffef90e513460d93188ff40bc4e886a63ed70a34016e3805f588e11c648651a3b16e248c1191fe8743e1a03174b570cc89304a390b24a875cfc57736f2fa2d46cf338003920e8de51e1f239f506ae76ca2e435e20da030d1bf38057d1f5775d257f26f3b5303a0de95e6bb968911e7787492c30f0dc020453eee525424e1a7c6043008bb1d979649e6341d76362f03fad4dcbc03008de0206a80f1a9c7e69362aab1ddb8950cd1ccbc7f7b9192b8c94a88db33fc06f815c889b7ff92a2115abd94fd986ac74c69c766a313807ed95b06f1d5e66709eb2ebcaa6543e3fd1b7d5c4cb42666e33ab98eb21c5b3722ecbf32342e7287068cfb3efcdef165cb516729934f9ef1b75805c611a14489ef46ad4d43eb59f1072b59228fe36b0bb1b624458d0aaeea20ac86d4525684f22b8bd894ef9d6acb02a9f6e53b34e3b42d35ece111ec7cef9516fe1c7a2e6fec6f86722ff9fac15503e360b091d8725cfcc63a9c9eed615f7a43dce612efa288209e77e1a74d1e850d744112794ca06b0cfc2eedca2edf3d6dd99b95d97e4ec93fd6ff91b0021cef01e02d560d928a5eb3bbb0ab28e89bdb74526de6b8b484cf677a6ff9ac687877077cffe04cea0b612964b138029c9f1e91ea71e018ba72f1ca95970e65a1c9940ae5ac64adbcee155d08fb7236aa58eb5e0719f2b811b5a529ddac91dbfb963c0d4d3527491e105df430b74ed807ee7f4b7dee4d874c6f45390e71a5b14ca3e10bd49b75d425960a7561d14bc26620ce5e98df164091b9e89816c9581cd0b9e8055ce4acae9b50a1c0efa0fa695cda1246bb79681431b3a2a96efdc4068f07af0630abd0892c54073af0d0b433e82acd10059927034122a56e38235e9b33e7bb08d661831d65c688ad76b617607c0c8c8ff8e7740f9eb2769b962a804c9a0f540ba8138c522a4e86ce8034778ab9fa8f5d7c699d9d5ff8dd63c718ca100a5fb804d130dc23d5f9ef170eb93d7a10ed78d4228ede2955a5318022b4c39063c0b10b76673d3b17cea406be90244db2ded76840a0d2a5128a6d251bea852d76dadd0c25e5e1a3197f8c409877629e6ad6241320ee5c933d18c5fc78dc66e66a15660105614b11e3142ddff30f6eeee0f8f75566aed9f292aa43484a7ed6a1c20ec00a58d9a53c5e490c8b9d37667cdf2439e860fefc761a6f798c4f91ee88b004b30029d21d6997b376c30ba706812a8fcc003da5e2d1477c15e9f3d9137711ab050910c1976235c66e90be1cd046556922bc383dbcbe5d217637541cc4c881cc2a0f3519e922d7130724059fe7715dc20b96d69f113c4abb39653b3b48bbfd4d9b00280605e4d2aaf15bdf69f9c18e5079d15291a5916e43b397dbbea9f7bbadf507a4d4e869aeddd4f90c1c8a34b6cb9047c0b26368288e4904369e3ba5784d6605ad302e908e5e6aabf38f9127a4fc41c5bc267fde7fe12425a833da7494d5ce0973ddeae92c90f32b2e1389bbc1d567e70e574d1b28254c12a496c8a25c6ef90a33b4e003b9728ebe342588641792eb5facf6f0256259f5d4a2132b8cab605f0c5750a837d09050428c1b37a1b87936eb7cf180a4865f45eedc93dc460476180e8b5fec7a64a3555330d4e674f8295ce3d61de110d1a366d92fcee0229664710c9cee99d17b648a5653c1d1d07584797ae9e5098cda6598f4c1793105e6319b055f635d5fe25210fb62dcd172583058c039fac4a2686e371766f11069df02c90063b045e2c6b538c2aa26aa822eb328e592badc98ec93d64efe4f0e3d7212440095114e45c9f654b4230e8a42480d90c7233c20552467a69c5a2d61bee36c9803624b75a97ba189414001564991006464dc2f9e383d2cdb3cccca02a88b834600c0f8ac272f26ae222488d2e59cf057494bc0d1f3999c9fe1e21275240a7da10e884b53fdbb72685d6ed656b08bb215fdef0fffcd6941bb061f2b5a638c02d90ecd3a82b5c862a344bc93932cf4ae3e50ee57ecad6dc8a70eceb97f5ebe4ec10cdd2129e0a554f23ab2515264ed04eb21e84dbb5344aaa5336895ceb8a9ee870860f5e75c470551776c4d847c1568ca94b2d75fb26942d7fdfaa57f73e3a2f7068fec6f796e53a5d177543ccbfde2fc22032f19257cbc6b0b038cc1c525f5680b59f7ae36367d28d3c1b583fa84891d8b67a1aa9f1e95e35929908e73597c0a0f022e99201d203ba51559cb25df383b524b20fcc06eaa33e686c0e47188504b04c3d3414360a427ba39fc1a850725f80d4bc4ac95cb2498cae4727ed63aad0808a42bbe1e44f1243b7debc221b29bf10cd91d4daab93fe5aaec2f0ddd4364f300c039ff270866c6245fafb7aec5677d060868b13be3ee5a7c1205a071fc309b0106015ee785bcb9483ec6ec82e66f85edef89dfcd45f3bdbe26b8009f4ac73302cf43b4e1545cb6cce0cf9431e18f28f4be84201a289f75d68d0adb306766740bb889c0154d4c23a0db8fc49c979f5ab7f52543c53237dfa6c93c500c2bb88b07e0472ff1702818d8f972a30c63e13c03865183dd302b46fc5cb97627caed8b06f1a3c86b129afb61d7ad56452f22810f59338f82889ef8ac1505aec68fea0b0268ea0a60d45086118db97349ada12698399fe82237d88dd98219cc813d5aa30497caf3ccb33b158c96c164ccd0cb3b6979e1e0e141373d11bc358231167dfc0bbd98499432bacdccdde810534d04071c52274811012121885435adee3146880ab74b0b8bb43aa8269422bcb4b0439ba5794a4f12a0804f1dfddd577065a74909290e3692d5e18cc41076367e673c7efd2209afee628e23c382d179d497c3760673e427e5807a9564a4c2b927b01b3efbf6bd55e1adc7e04b55da5be246415105782eb9ab7aefefab4ef8b8fc70a06380de48f988f195578d325dc2345946d90ffca3f97d2f055fab395965a98e8d7b5cc280917c4f7041f9a4ff4f0690471c04efc75da21c5e7e781709dd89e21bdea635618e6345485c0b67a221f01c251a0f3c0a14ccb19c532607ce740c0a39c1e6125f540d6683ea5912f5e7b06100a40ee51c81355f28be47d3592e2d81bfd0042b1c3cad0bbf48e73b6d5b801c23f609cfeaa2d827ff5e97ab8fabdbc1dc0c61cdd924495afd5f4178a7463ca963fa0934f02dbb12047fd87f3b687130991abe7d206a0d58c7c2ae8965087e519a650d4ea6b05ad65456476083631af06997eb13e7cd4fe01e0dcacf084a2de64fe20ab4a4711dffcc77bbc438a28931be276d52974eccdcbc03ec4706db5b9441450edeebb175a863b14c47b84c7399613d2323ee1cc73692ecdc040bdb3095233b056a2f57423cc8526b10eb03bbdd97c07124d4ab90deba1c266d29eecbb3efda0b481988863b1b3a24098c82da2f4d4b8f89951499c5801dbaa1bbe77dcab05502017ab14fbd61459bd7d2f1c7bcbeb3fd786656a69f19f6c010e3b31f230f18016220e1e40a6d38558de756bb4474fbeba56863bb3e27b8d76ada1645bea5f605a850ddce746f5f838c2bc34e599f7459176578a4419fae32bc693515d6091707a22d7c56bf3bb24774a75c6352e9ee0459ac9d5fbe6e078021e0b05b908eca079b483d805477ab7541ddac564da4a04c404d558bec38b3c4691083ca94222109461ed0387f663db7ea43092598e8a76cd05c87a7023437d7084259d44dbec00235d97b04de11da33d6c8624ec8e260cb2b8b1844fe72bfb8327257056b0cc902f923705492e0f8eaa90f6737a61f7fdff0405f151a86de0a13e8fd65b84145054409f5b81bee368ebeebf4a8073bafe34ff62cc21126e6282a9979e5c702f8006635afaf34c1b0c65c98cab197d1f8d0dc7971595e897736a7152a095cfc530ca53772c753d7cb33b0ee4081cce0ce12612bb38d03980cb1dee53d2a5755f00c7d286d89ab79b8871c98c1f9de07278777bf48ae897da6c4a8574762136ab40a07a316e5bccfc5ca4b0989b4da08819c038f037b3fe573c8c9d5543948703a0937d34598841b8ffbaa3c5363bbb7b81f00d94789312bf6c8ad5dfc58cf5e4e029b1b480ead30d42e60ad4b2c79cf41adaadf5297c3f96e9f848aa7320087540aef660edff5612418dda465113ed9c7636778a8e0800457d1aa8df8c975622c0810869b9342a6d399a19278dbb3ef9c45e33162fc0999104ef578603269fcfd0165129923422d5d3243aeb4ff499f548d8bb1447bf814e56990b8f6f5f7b57b07cf5366afcb81f2b77c2327bc16d8dbb294960633864af4c3743bd99c67b8f40abe5cd5c82bbc387eb4e5bb3d919789bc9dc188f3a2906d64b4a412540d58a90afa6095ffaa3bb818c558064f071ebea84cc27b17876fffabd4648d51a273140b7dbc1132753bcbc8f38d6686804a9a6ea9bd7980d73ad16a77be19ee77503702743dbe6305def508d5e69fa377e6d07a9bbcbe316b9028b8d4b7ac8f043e9803f7957b016274eba6fa07a49ac5bf31c14dba2ecf8ad264d6cb5e5d48a86e6c00351dd4d64b7b0a0b09bb0e3a648cf1d5a16b4087ecdf454b44fb7d67dd83dc0762fc24cfad8db745e61551e3702780e6079025f1120f16e67c8c92c1500ced08701dbc914bde6e44e820c86ddd72f7fac04cc0248115e9d55c7e495cb20ad80e083c26aad6117a5470d4f056a52e84ea2499e6591858425dda36631f9a91290ad343f75ee789737f86a3d088839bdaecfadfafb1b4485135c07b886cde4ed901c3a9ad0f72ad721544c38818d6fd6ecf673a61ff9ccd97eac3badaa7106fa30482f865cd3bff47c3d800f5e72d6ed96468cba56a78da6e1fe25ccd74b10b2c0462fa46a1d9593371817bb571bc18beef3677beefac7a719bfeeccfc8f8e43f05ad97dfa8aabd3251875d442d65e06c819234f42d7ba703ac47870714a79628070e9ada8f5c66d9dd44dcf9cf5d034cb86f1e5128fa8611a28ea3fe3b3f79cb03e41bf9bb7f14f5231bcf15979c57606428aaa0589e616bf81f840edcdf2130071a3bf313ecad9b7c8329a4f1e69bfd36779a12ae6aef5f5e3fa558fcf745e9042599f966cf359c6d17485a2016b00ebae667f28e26afe51025df7abe4f479c05d179fbd280af76e4d41975730d24cee294e97c9111b84c871700e546a67d21088047ad41afbc66a502cfc6f10154cc2741b758aafa2e9c25b47886b0cfc9390ae683acd083fca78d821cd5314b545dc8e4ac2a9cc4b836de9e8f5c411b260703890aae79ed26105dcb704d894e355a83be34aa7911512f35147d17b387f0ad0d1feb186440147127e289cac7110d49a24bda2fa72dbc38b02d8f5b94a034dd0dd10a4c81e537055243f9a29d312458450d705c459b3d9a9b8d84eb21606e3d0eb5cbd038e24ea1a2dc684e0327656e59e157d0f823386a89d58508d5018c140269c978248c4df0c41aef47c18a89e01086b1ce7ff1e892b47e2633581adc530fcfbff066fb3b829effa850dfe9edadc36271b6d7ac54f76e90092485b7fa640094384bec23d7abd16aacbfbd47121463da806c3d38b98ac2d28fc934cc79950578201cdc43afe23eb9ad6ceea23e0d2991c32d28d38905f07147b5186e607c0f5386f80111ef27abad6ca4357cf4c3b1978d984101372e4a68d4c81d3372c205313382e8247d00e7d3e314153cb2d44bf3440988521a60bc0743a0d67b58270205901f8c2c340e9ba2c88db57892c7f110d3d63c0fda3a5e80666be66e44ab0ccd6c2f576cf691bfcf9071778ac7e4a72e13ca773f8df8c3ee6546557cc5ae0171ba84883cecb53b5dc4fcd0c4099b94eaf83c275185a2d82a9c33dd445a390b14d044ff9bd8b13dbc509ae2f0b98a0e73ace0d71281bc4f8b4ed25d5e2e060672e67362e5f96a81c344e8abcce4a83e5e17fb093e342aad9ae57927d29b7908870b53b8ddd13accffc1f0b89d22ffc4adde9d0db48500d08cd0f8da4ffa0f04b996a023d7d570f794f664aef9325535e03b17712132d5d6d00e3c0c0f88620e899aa8ba7217a04a7586fc160c3799dc6af770338a824442f6ef6cd041fcd601876e167f93457813b27429e3a82b741f3cee87960f30b8555d0d8edfb57926078cc8a3a43968c33c3bcbddd3d6dee065fc0fbb704d29fd3bb27e748922fd830e9f2c05ae3bbb7aa0213d332881b4482740810dc220cb3cae5e5bf7e17b42010ddd277aa9cede86abd5af5c5c744d11c9a5ba66b9f34684b695b59a4fdf6050038ef117163d86babd879c9d48495988a413948a12197bb25040820b37a01ee40ffbbff516dcf7e8b5d052497c554fc088cc2472b27aef31419f8de04e24f3b7041ffc4d3c2ef6ed5f4d06e962a55ef7508a4fffbf56ef7ed478b384d4502acf067cad8d859ad4a63d84f79e7decfbff329298c5daf130170f4e3051f8ce01f60cbf826a0a3cbd298872800ca9fef8ee4a88993224add09bcec759abdbea365709caed3e66d5f83b3e3ce9e5f3ace1cd426df280e813a9550de32654f6821d690764cab9e2c5612f2a47db4abe1c8a13d7151cc7dd1225f72a1d9821dec8b0c90cd78097bbc7e40f8c42ba4430abf88d048d0d8d92ddbe77025f161515b4a2f80a6b1659f923c624210597ab7f5f8c6627431d8ea0b69de931d5ecab18a687790d03128506700f0f23fdeea72b65f31b79ea2e5a7e887773317093a1638ab99606605de55b6e971befe94bb84f2e05e94be4e58fff3fd847437df2685d1f22d003d3f263c72ac9030deac0a8821d30c43149383e4a15a22be981e8763db5669b0f8293be9288719d90bdb33710534902507f66f34f23060fbcc9ff9d0f0064f808323028b1511e06744a5a797b6b2d6608f08c56b221dcf135ae5918550131830497a1cf37951333be23633dc38869273628b8790663301891c8cb0a8e32fdce06bf6343137705d7784efaddc7ccf98a04af777d530bbb1550a5ac9e34d0b37003c8956f1e7552e2b9c0f3477b692538d6e483411753e7da58cba54c3f154aa507069ec170922c85bd8e18d4ca3caf16b0143d7a6a352a3a9349753c742f7e3a07d69326ac5a967a63ba12de5abca9565967da68c607a62e77bf711dbec2bfb4049bdf785f309ba388f71f96091cdebebf5bc81babb464489be0f0f705ffb2420e1a6577c1ee870a09c398f39c683d594547325def2bf05f9f6633b13957673102f5e04ca468589b948fa046a13df21143020134c4e25d285e5443abe64310e40a1558fe1bb0141927da7dbf9a7c0b274901a880b6865925196be881d1408a3f0e90f59f8d135d21cf8ae57246e6962980e7642f47a9983ed396f92feed94fbf0a02853c2729155dd6516191cd3fa6f7bdf64ca73c927f2dfc1feba43b985a86024f82bd354795ae5c54f0dd552f3f9aac1afe621808d19c7fcfa9ccb60a0f380b0c6c597f5603cabdb8f9d49d1534654c943a54a02f12b8a51c694c388119080e3aa13dd5fd06c1537ad293060f9b9a9e01e90764151ee08751a11ebab18eae068b019b18c921f9759e0b1ddd87b440896039e7205fd8df7016d615f736e49e0d32ded6a349da2610241619fb7ef2cca4deef10861c9eecee9c94fb630c8ab8011b4898e006586d8414288a1610249c90cf2cadd7f996a0cf901ae869f444a30a114b049926f04a38d9c842fdee70ae9a41d3ef44cacc18fafdcc7917191955084febcd2e1c66561d57af3fbcf530bb3e46411295a1df5234868b2490d9b74d04e0731257f8bc1aaa555da277e9ad3d436e0f61316b9f8a3418af7668b41f460fc2575551a6946b56f84b6b19e51c6b12bae86aa459692cd44a913c5240eb0a0a9844215a72187a263f1ca4e6e2f309ccb505b8e1225d6da94ed603d02d680c031e7e55ff1f5037c02c2aed19fd56ba7fddce9f50f8e891deb47e13c2d5b11f031e75cbcc96a6822483178cf561aa7f29d6bdcaabf8d1c1c2a7f0901f8f4fae079673846dfa93bc4015908e271d95075f49b2d271e87e9db2725514400ce3b906e118d7085847e9979deae0fc8307eeddc39c0815bfe35af6702789788d60d005462ab6a71bea038cec0a7e1e0d7bce5e1581639e4e32595a25686acccc12d20a162266098e3bfb494c2887c5e1d46fcc6584166001491bffa3f7d707adc90b0be4df56d8b6446a1fac3b71dfc0e23c97cd0808c0253d4e935f4205ac367c2407cf890fbf63d4f479af7e2438552a2ae1870f4d322729693b669b72d37e5f560db1395dfa6cf74b6536753e26af3b4c5407733e22391b79553c2b2ba7468859089085429ed052728b131d8e7b0362fcbb8dfa4400c9b5ac6ef1bbcaf4ad0b0507699af26bd7230b5052c44651337225c3e7cce47ba713a4a9a75cf7f27ba65207d09c9855584d523269f4faa390c3bfa0db547bd135a85c08e57d5b4b8ed1620bf6725d4bd7f3bc7d90076c28b7cbc5e605fd4748b04e0c1531284675fc717b072abe1b8f3f03f11ea0440a29469a10c5ec8a5f214c58b823ada8ead9bb7bba01db45d4ab3a7fd493af49b25f641a34d3cdc8f69c992c4531351837f2bcc43d024055642929c063e9b1d0887e246979387180f9457e8b05eebd0be68d6c2f2002d27fb36a8d1d061f584d5e001d04e36b067b1368a1201edeb805d86d38a2f20c8b49028460bc803add96d20ac5871ac15114d6830c3ffe76ad1050929be8ef0bbcc963250e6ab0feb9969a9be58a7fb510fb4ac835c2ea63c139e3f705f3480590db91b58882a7debed82a3940c682c731cf1a43a5b9784ed5d4007753f24e0578e1686e207d64b0ccf725aaba7c8d9da8b3df0ac7a7cca8f74269dd04e28e0e1be586cc8563f6df2d8b9e04cd18b24e919244a850d83179e5ce8492bc82b302a23485df07f9673e3d2b25e60f8c3f3f7757e0b7309d06b67d1ab67718869705bfad11e6a69b9d4cd9cd04cb7c6e1011c79a89f0ecd256c4a781cc8ee3b1d30e706418e2ac2da2d827658d9c7eaf41cdd40bcc4aefd1c77f0526a18d6f8ea20ef613ad81fcd9cf30a1459a2ad7ac2b8403327beac5d76d25a0682672319db4097cc7cb3be3c7f7ef7ac3a5e4be0464d17f7fa3fd66f04832d5b08912b7303708ef6fcbce95da340c152e49ae70a7ab397b4a31ab61f542037aa7bbf41cbc8c0a5efa075043d445ec6220775be2649d1a849cc7de9fd5f34ac7d29ca529af480ac0b5668b3bffd05a851ca2564c896814d2dea840df19b9189346661eb197560380770b4a8aa89846b22d1e25f71e1245ec04df5d381210ffcc0f5a840707af0f8707cba4f3d08bc2a449b130ca2a09a95f2873f57c74ad1b100da90de605ba04ed9e154c3baf6ab8a1be5344232429c171da41833469c8ae588aad802e2d0b03aacaccd125ccc3132abdd4bcf97f055adba4d11d10d406cea9240fadfd6fc70299830d32620eb150c5dcb06322a97c06e04d1555e0612b9c8b403873a9e5a1050f27a9740228817e860d5a000e2e2d802b95d3e82d80ab81956a067414f8fe0aa3ced87edab7bab21c7198bbc37c12477ef31b0dbac0e89d0d71a8996664ab08e4622077ac3a24ff4292d9299c948fd8b211f7a80ef291394eff117cfc848409fa4f6c786388efb188f92caf1305b015f496727572ef175fb70cb0b51d12ed0d7435f312757c73afa803ad105429211bb6ea5f1516718a2d8975d47b9972410464d8222e084af99b7aefc578df944c8f057fbd2986a0300eedcb08f3dc12930dba22a862bd6597c9905a4d372f63e2d05512df34fd7eb5b513bd292900868802112f46464bd62eb589ca56bd9fb0679164eec2b6acb15a81941685bdeb9c480e9491f0f4a353b4d67d80704e4baccc2df8a888e50a4293fa4e74f8f9ca4d4d047c1f92f975121a10febde5c3221349a08017ce19d8231763f23fc15b7e89f102a091b14776a0d04293bb2de5821e10d71a2d21371ff98c52e17276458dfccc0123e391898138293e8119962b34e5df1c80ed7c05fbcffad24e4b325f981b880b893d67133cbb6d651145516a1804a3be21966e2f82a270da96e96e9000f0b305b44489d78f66726a83e5e615d08a0d23a6bc3c278b824d69087285b3474f0b09169478a2e60fc59332e9d337a9db4fc97d379f5c2112415aa8800f76d6cff00ddb5f2bf8cfde2d321be7a973d619668f27b07928cdef218d6eb728a5f648660d081f8a6b0541b053b3996d6a0e7abb6031c6cd81ab9fecd0675a3d8fb10ebe01fc4c47b67b11ea8045a84b1ee127888850971117816f6ba2b29e8c18bc61970888b4c3d07679d88da0d4affb6ccfe11dab598043a007b0cb431057050f5eaa0dbf6e1bb7a8bcba1d6f37453d8d568172d59e1041cb2bb7067d631ea11ac04407fb12e0653d84d1de9b94d0ecc762b9371b82675f15656e7bf9be483ef2de2d0c425facc27d87046c07734f95fd647fd806e5188c6326bad5352ac27cd08e44031cca3712d5841fc6e98ef185e40c8a615332ba53530e25b6dc9d969fdfc6b70c0a857b9f6107d22a82f7151a9b7efe7eddea9bfa0e48117720ba8bbb335d52023841697744004941dfe1692bb0f76f3db2508fef4967d334cc95178e6c8e1e06e8bc2764b02e5df9f8107b54eceaf6631425774801a68ee3c45d84cafab3ed0223887a54089023a6032fe5850e578556617bbd22d9d4b8cf36c63cd4cebea508f4fa86cb958fcb541f2dd4df4c8646cf05472abc00f56478905270e83279e100f166097416be1ed0bf4c725715be7d01144a028bcaffe9799e57274c5bd71f07618e7b1f5b4201e5de22499180145b1ef61077668a5bf5662060ae1354fc330650cbb76d481eabd7a0e954820e63380504ecf8a0a469e9e3289290e84e719e0b8917599af33a1568506538e8489fe1a7e279d3dfa08c93de19242047e00f240a9561d2211fbb19a682089c9d24128f7abb98470b2b9721d45c64861855002c05404ba14d13bd95da31c0cab7af3c7688f6d5e6af120f77099a7d7bbb79f5770c5d86b2afdcb922ec6a7d2fab2da4bca2d9bd20e1ce2136171944dfc824908a043da47098c6782acf9288c1ef1a084afe7f67b816f451918b16fe7458e3ed220b28519544f09c973d306ae8b45fae8cfca8f3826cd41ad85415537ba9932fd501d170e1d4d250388e9a145232903cb7f9173d1016e15468564841a3ed9d55360b05d84e7df75a7841c498e8861d045d95f5c05403ec096ec7bd4c8e0160c5660bd439a739b2b339055a71aee1947c7f71822ec54d86dbeb01fc95af6be5b5860c5a5cd069d0338e4efa5e49cdee40c34286af5391bbdb75b101cd77925dfdb309275fa85817c9869cb4dce20ebc4be0d49394bc81233247ee3f2732e43feb0508cd3aea0ac322ef058c361f08504bee8d10477b150b94cdf44ca342aa597acb003dcbb573820f5fda1b8b96f0057bc443f6980739dcd1dcb89c716906bf4540035b02ed2124b9329d07d10306f5b3f2fb7046250767c4dc3698c34f01e52d0a03bf573b73ffc6c0b78545fa217f01951ee69e6798d655f141d73854cfe049750099f800a37bdbacb00b2d3b3ee7600871eadfbde05e4b3cdd2f78816898758e01130b6efacf13ae6b949358769b54edd860583fc3183fded718d8897f8c90060648d65e536994e1c57a20f84649b37cb635d200ae67682b7359ea0575a590280e3c4125dde720ff6a58de4f0caad8e468f8fa60be725fa562c0466139d530b10a0881c3e0f9860b3f62b58705f0b1aaf0d974b12988f581cc5a3a869646b6f6065827cd3b905cf614414a259e2d597d30c370bb73f7a0e9098f6703c5b74a190b3e60a66def6603320a417ac39ba6410646b2c1ca3ad435a2888abe234bf7cd0ca53265bda5af0ef11562d5358e2dd1cb833abafa40d9db440fbdf3b026196407bafddfd7fdc5fc4428c7b94c56dc1da49d13b2684ce61065ef7859522813c1059aa24c2d68e6fdb5369b06d39ede5285cbfe23c55da6f1531709e6283efd4c062d633bd81e21aa3f88e6fa99b207ab949e329c0e58183bfc4a7d6e54ac16b70bae841713b1e915ac99de428ecc1bcee266666deddeaf7b39e91242b5543b13084859e565247aa8ab8e41df6eddb27fa65fb48202f01481418f5042e1aad90d002cafd1da38eb3eccb76970352a38141093efe408e3ac3983af1e09d9de50ec06a98abf12a19238eae558589a15d1e2b74ff04c910910d018842c57eed191ff0d82521131a5373b26cb8a7f149d42b7a90cd10d2ff27d4675709ae16d8ce2920f83d077ed6bd1e49fbca4a24fe3d2ab8cb96b6be45c573696f463bd0e8ce91103a5f0cb5de73dd895af9eb6ed3daea13cd735053a0b768718019f97de37e24a02c71e36f2f8e550a1e2107d3b421f0442244a0db798ff64a023fd05e8ded31508415f3ac08ca3d0fc61ff62e3ab587456b194bababc51b61ae74915ce6a0d3109fbb0dd6e564a106089bd1c8edaccc48eb8ba0f230b0974636c6d568e19211204b54a55d5405b658b1829929b70a42eb2d170fc3988970b23ecaa6ed3e13afc0289e097ee3fbf672bff426cdaa9abfb549a0a5af15ea322b74792b8bd62db6209a79871c57655aa67a20fec71c3e799dfaf0322a9059c29b10b196641dddc090d91abfae17a717f3839662e9e7efaa3bcc8a28debb3c8a42daa21941fa7482101ad9c3a11a0c8a7a4904447b73e9c25005c507598e6b742a5af1f14dc6951fd006582026626ea0c7aec01a0548d8ca7678fa6de3bc10f6661b288b31a9b95260034ee9858544358424507ede32735b33e5c1103bac72885e74a7f07fcc8abec00d0c2fecd5a655eed69fa2c8ee12d3416024091cc31873c063ddb9900f66d38021d4cdce3a886edd488d134947e31889dd52ef342ddf7f050fbc41a1ccd1ddb05774cef49ba87c67ec4fce84412e9fc63e6290a58d4c4fd28171d1fd86de1f5041e19d1f9f43dd79eb7f24b716eee0f80bba6e0a8f9d26466bf3d7ed2beb41d0eb61919f543aa5cae5b47ca783da7f760259b1062ce8512e36671e15cc0d4a20d83307d8a737bfc66db61cd3973718df141a4f083cb5f05827d803889911e210cde133a113c10d2fc8c85794a21291d8203f70cd8ed691084063bdb28d6f0d4037fe2a8123c506eb3e1f4749d1824500aad69816fb07fc8a2eb4fc25791f31c0faa4087b97daa76c5d00f2b8921cd5602b18f3ffedcb8d0980a5b28e5503ac10fff83c98ec0223d27f265cf5a3a451804db549303deba248f17ef0d4cc116ec024b48e0032a2771409f07713aa6bec578ac0933c0cf9d8ecd726018d36b409b066cfd1d2e25655c2110ae4c9349ed63eaeb84252e56fef1ca4bb61e57cac8b807c42fca6d81b71e0c0dfb8ce2439efff90e3d3880d94451e53a94cb74c867bf0b14d7ec03997dcf61cb213adaf4f5f768b7d995e694df8b210a3d9baad348a7089a719d0a90d6c23d16f5d5702f85b26d03d89304c6588477aa75894f28cb690e61b0cb88856613252c2b4c3e6f6c476044d002213eaccfa9bea99f1ca55bfa01a8dbb42c38562fd2ae7dc0ee80eb9e2304647ec34f89c4b99af58b8e06b3be0c32fcff2f3d6c32ea44e7f6549c821ad9c8fdbbf2143f14d5c838fd710311e8031e469d6077915247acd904380debff6a093f0528604117957f2e20cf8df6ff0aaac2a6a617a746c88a4940638255c008acb9eb09cffc8dcab398935436bc6b0a6f6bebb95b81ec3900d9e199cb77e8160e45b555f94a718386e8aef7259c0d0c3db31a9d98039131687c2639fed47ac892cbd2e9641b973107c6fc1a95bf8b01767c7b20fae87b10cc7c336f4293e7a1c8605030eb419a9cd5183bc20749c60907156187206e3bdc573f7b88dd6276b5cb9525d5a2bf516e85e05ea187b91c0e96663b2eda12702681051f2fbdbec6908c438c4f7f6d407a97d78c2b9a1187041746ec665dec810b5e2ccb4af6c40830447ecbfd7433610f63933e2bc21df1007cdd094f34d2828bf1cb31a8bc96df40c8bac7d904c2b756f4222acbaedb400cbd30a432ec441dca560b049b912fc4848f9b04eb58ac1e2755ce20a176d2a7091a3c05c7fc63cb37b34811a6080616cb9e9b1ef674ec70e37bce031112f8da0336970a72c57cc387fc80440a48750a4ae2dacf4657a620dcd5de1cfe16fa20073999da168ed2854d488fa4a46bf7f57c21615bbe3ade7daea00f482c9431a10298cf928659a2647199f8ebf7dfaf5d24b10b769802bd9e9b6e9600aa26b4b90b5c5f3a403fce89ee823d44fae8e2c68258255bfdb6820292b9ba11669e2ca10479a7d177ebd0c13078711a3bed023b25222a7c1c67a52aa77d13d440ae392406f03712389fce3fda327c06164871b281b0da6667ab55ea28b02e137e5ab41b08e5fe2b589c3e9d6c97110387111487ea36faa58a1dd49d93ff18680349c62c043f1e340d85123b96ce80ae82c240845c2f9284e84e2ef2e67ff7dc0d048a91093e76da12ae1d196f974701cd36828160524333b65249dfac1fc2ab0129538902cf42f2cf30eaf0163ac26ba48eca5f57620f9695def5b28f12cf9afa8cfc80070c701e2a86d80491c42e4a55a13d59722c54b74d2ddca7005acd0fd894819206597ae8af857b38c0b44264672ee3b37a6851e2df9b0a731f3dda20c52d1d580eed3edb609ff00c5d8d7a3f82e297fabe7b8b4dc48d413073f7ce2dc5fa5e110d967a6bdd747f14364e8e9cef0486c231a50ee694f73b3c65f87999cf5777ae0d038c64c6e18591a153c87ffc6a4175fa300649f4e035e0dac88e63bfc4ae05066d7a7164b8981485711b8df62a0d49522d58ba271ce69df139dab055ea9f76022b7c8c969208a1e7bf1c21bcc0b9fffcec623df040060f5beb18ce5a6772070a0db76aa56d1cc616d61e1970b71458b4f583032b751d1f0bc93cd7043b065307cb1710a1dcfdeb7b23403058f369a8101e716b862a182ebc69916eca1466210ae57d07c2e2e1fd99da10262e83d0d1130d1394ae66302101a711616549bd0301a8155f4de32de9e3dd34d75b70e9c9d386f1fe777f776a0d3b8df20f1e25d903795d00d699994ab2632b181ab8e641b0fe25c1f0659dc09a35fbbee9c795860e31a73fbe6f298c4f159a7289bb3df1b00ce312760f37d7d2e622abc82ff2e20c0445d673f2c9826058be314c10e9762fe85210d9543ad008346a8df29179980e7e43b1da497efa91b557317f76ece3933ccf9416aabe6e345d3dbc4faa989f02eae4a4502a9e8daf09a1a35aff15872de9fcc89728c02f56614f96c640134b06f5e552b87b1094ae79e4dbd92c6851a9edeb7fef58836824d9bdcc36b35f5306f8e3aa38be18b7f49853fc2fd0612316162d514971fe6704b81f2bd2af8eff09c73294726c30dbcbf00534e0041205823226c85a3a3c4563d91b7ac5503ae00c389971d41b39d4b2a711fb0065e8653ca930d1ebf4bdcdf70f8275f712634a0a1b8a2c80d2d90e9ecd8d21b631a466736223599d542bc848a3856414c18bd90c567f56373845caab5d6c8a3d8145e83bbecf01c104113ac1d32f9f1233e4340fb3ee9b7554b936000cacca52f90a4e8a2aafeeb9ac5f5e04d16964869887af09eb5aa94d859db1d7245537a2fad4c7eb4d00d70a61e520b1324c33045bee90016e95a3c70b3e021ba08e423dd2aafd7dc1e52379a35fa4802f3d30f5a020980dd06ace6c7317d06b8adb231a7ed38dc3420f4ee3b4d9d234cb2af5ffe7d24f0a8fe4e55e40992fabea9a2f78408a0c26c5d78f2ea9053031cbe217dd5e7ec10d5b920a9e7a455dda8b0fd4e8296f611e41e133fcaff086a716df3a02436d9c0257246628fcc6bade19f6ac57034fb939e67694876d3d67908bee4e5a102b3b0ce384a30c7800af240d1326d57c6e8501972540e96b7cd6fbe78be647a1f4eb0bef82045c634ba0cf2d3b29d9f25a4c4f9170e261b3bc83e58905cef757b04603b0967ffffd477c3177b6091202744b1b07cf33fa744bd9ac4ae523578aa9040b4431576bd6a1b56c216cce92fcd6f3e05090ea9dd8016352468c640bdc67b60989bc0a9412a2aff478560130b853e4b61ce9c95cefeb3ba02aabf587123b640741eeff5b5f1879d947559ba19311b147f8afb6b109238966ae683fa63b86430b4469aed09a98c097fa5bee486538841e412028020206f5237227589ae3dc900734ecaf17cb35ca98831ff1c5d79f0cd93c8a89a9e83968c4255e8f946637f80a81c760214715ade81e67b81cb9d4d68fd19d7da826a7acace095ecc89c272f02c8a7e4d505037c39d44469b222d64cf12e96c51571593cf003aed681e4422e01b28c986fff1522200f430a8c5da813c08f9d89bb760b503bb6aa6914855358099694d613d5ef0cdf891515d65748c11e3c6bf60b1608392a6c2edb8b11a8970f8a9e2375ecc16f9cca94977f95fe0e3a6681b2b400e2860c4e3806734245b30709c6f8b923ced1e8edd6e9f9fb2dc2dc8223c01585192fc61226fb67967c430851d59de5129ecaab4ca98044be558c08d90b7bc3765c5c64ea5d5ff06ae6f50fa9dc8d807713d85a07b2877d3252ddf5eb5c91d7f584bfba001c5c9059e3c10fa12ea02230c6d7c156b4c35add61d7f5683b4e0baa786ad4d519cc8714bea002918d966ad37691b20e61553c91b4f1462a4a09275f06112ee434a057d7d03a015ae19e2a62843f4c7ab0d1f54111942a5b369250afea5974dd85089180175f00ab1974cf9a1d7dc2061a8291cf24cdd936dab618c36213cb56fe7130c218af0b1f9491e9fe68cf3de81436b36b0e6b59a276d8d43b41cf0e1d401fc51f0f2a0e8a8f4eda4863b178f85f159420f1f880645aa63700068f430b7289afcafadd017d229e85662ebbc257acaea5f98e4ab9869426c7af0c63932b8bb048db8b4a05 true +check_ring_signature 648561d2c483bc13e325bc7099359ee35a7ddcb77097d94f8ae2fd422e4a6b10 4f3f19a00ab276ff7a30288b31d85f7804efa0674d483fdd5a097f6b3eb49f4b 66 d1fd42a5c5fd6c6f913d215f90268962b394533d457be3b3d7032ba1aacf89d4 31c87365534f2cd641bbd8f0efbcc2bc261a4a7e61751f3194b1dfc76f945e4f 2ac2827347635cdab44135c21383a5f7a27190ed36bd0ec16b63dffeaa91983c 7df36d43b3d16a216cdf0f6a1db6c37b9393d92de72a4a9f6ec6c0105a5f2fbd 64053c5ecdaf4795d7ce12aec31b1d75618726769b73687c2c3942311d6dd7dd aabf4764787d59f4ccd72ee9f7bde31956beb01d613923bfd470099940a70576 89da0768bac765bc7a97f149e6593e16808017e73a3f6f2564ca23e03f9efbdd e8e3d18de7c40a92b23e85a28a412ac97a19becd85e2d17c4ff0df148844e5c1 9b154e0df88590c549b81ec2ebfe987433f27ea52003d3aeaf34229a3550f892 1e188016fc7bd03277b7c25a2647a8f5e40d57312f5a5704dbc5f5acb2ee2328 afa0940e0498049620cce150f2232b52424b36198f76d7f3f6511cd3735acd50 253acbb9a37a9076253afe7b2db8a80ac3da35a71edc9d6fa745fc18cc267777 62584d2aeab4b0ca46aaf9216c36d509d330b5aa1424eaccb2992947c551f491 c2e30b6dbd19352aa2b450b6f50c1db0c8b56a3cdec4eda58e45e78a305af908 b746f824bfa6dfe9671510f5c3ca70fefabd47f3cff9eb04c950bd8ceb52f997 4a724949f3458faab51d3d91d007f4a501d5d2595a22a024d762c7a5ded3956f 0cd9fabde2b0698f8c1e2b018ff5d3158b16a85a54123bba1b25e5910d4f0943 b8e64d56513eed54c5355fdbed73b995fc4f6dfe1ee9891aec65a68f54dff491 dea90f1d3e491d4fd631517062c0daf84f9d6d52cfa14b6db3566eaf93c0c694 b6f0bd9de7eb8b3e4a0736c9bba7cb6fa15c17c78b0759947e05bee305baf877 c4982756db341a24537f817b00767249abbb2c3e68b45ab75b81a2d5b0a3b132 b968c40f04a9759304ff2a4fac36674971019ba7e3b625c7439443b57e5d8c29 11e2b1360fac4da5dd7f60776bd19fd4dd8976c7e43e927b23be6f1936fe6a83 d8de4eae1903b19dfa984b3218184999b7daa85aeed37ac61b8a53bb201b6fde be71cfdfbaa5e51513437bc9a3bc2a3f0c30f68d52ffc728feb4e9774407fe63 f3e14d3a90ff1df9bdb56cdb09a83868405ac36571aec83cf35320849989784b f46d9b3fb03ccb8b0ab9dcd2e3c5b4ad0cd16c33c8522fe83ecf1c357f0fc50f 843b2134413e021cc98a5864e7cfe973123d2e126ac7039d14c4bd4cb7122df5 5a4ff16ab2e0618382d0b89331fd07f9288ae6eb6dae1dbb900305ed2fe777b5 a6e9103cb652ccf1ed1ed0a85c76a0cae9f5a20677bbb61a21aaca416e2caea7 6aa41d317695de74640f6a4e1572901817f55cbed26f69d31e7c825b72e1c4b4 586c48cb50adbbbae13df932051686cf54482dffcef75a1d3470e58cdce62cc7 de799886065ddb026a97a929883f2257a639b0a4d110f61df9661443fb62705c 740a4de28cee0c77909ded5eb711ba74c6c6576e7c7a5918e733f47d11124318 3a651856c4f8edb1c6d358af8e83e780552dac14e9b987fff689255d48297d3a 2f77dae23a227c0e861ef15e5f06418c94ceb903b4fddc3c1099c596911dd582 b5dc799a72152546a0a5b355e0b445e88f761bc675cbb6b7f46c4f7ba87a6f6a 449f9c155b41fc102d9110ed5ed00ae461bd0330aa529313015902afe68f8ea9 3739cbf06bed5d90f5d4ccbdd732d1253bdbb0f2c0056da659728f36b8e8dfe6 c82c15656a7e779bf0639a4e065b2492043833e3b64c46d26abe7d07099ff547 25ce07dd285814299a25dc863fbae981f69ed22fbc474cf32a7cd6c5c50c8777 5df9bf9bc122294775dfc15c3aceddbebbc1df7ded0912d261b788345d42c573 415c3ad229e801f03c0d29976f2ade06a177da3dbd66dc695995273c1dd8e571 ebc3ba1644ab323e79a41dff8c19f8e4c59287313b7586add29e413de1b62605 a98326feab4d89e77922d4d7ac90d7661f295aa12c4f62ce1679c418058adbf4 1d6cb3557e406416492d7a5326a59f3d9499cff8c1d6ec57dbe931d67df28f99 c25a8a0fb9c7ff4a25ec5810f1fb2517da8f68e92d724f2447cf9e18369d00cf 061dd9238ff579691fd93951257ecc9ae8b763d08c2df2c2b15024fb94fddeb5 baaa01f92f32d8216d9c68f18da6592118f1014f58f2964678c07ada8e15a655 8c0c7b049a770a669aa5de93d2ec10a26929e2559fea5c99d183c1674f8ddcaf bdf32157c483f1c16ac29247f1a7c1ef9332356c17e6c30a8e057b7f6df924bd 699fa2508079f6d6db58db3a97bfe91123968e0805338b8166e4144d6f5ae014 bf3fed9f7de28e1eda911b53752ee8875e9afa7deb5ee57f7cc3262981cc3aa7 30e6e498d253cbba9384ba1dbc86bb899d19c953520b64c7dc6cbc302c73d350 0d98f277ccd6f453e7564281b06542261cba05ee79483f81561ae737a9b416d8 807840a1625e553e4b6a819ba4ea149debd16dc6079972d177079ab879efe39f 976bc0d0ff33b308dfd3396254d38490f4e2762a79f11c06968fe24d8ea1902e 11970efee92dc6cffd4cec140b4e55f9ff6b9e5760e95a5c036d2b450762040f abaac248f8fe2137adee85ab86b369a847252cb3bead74ed306094513aafcf3e a86ba0a9f48955677d6dacb77ac1468ec39ce85d5026beb6bddb08a90b17e5b6 dad6d4be8ac3ca5a8d03fc1bb66e1fe09007335a6e83ed3dea592e61c0750319 a5c7536f5c784256a75cb279fe8fcb865719a7614d80bec33702777e8fb1ea70 4f5a03868c15d9414d42970c99af5c339ffeacf39e3172ee69c936d5f99d97de 26d337602a6b5220cabacc0c00c40843634e67d5c880b00c6b5748b638bcaed7 e82b7d2a9f1bbce940979ffa61f353ee2f6d2d68efcd45b31a9eece2ae46ea5a 619a2ad5bb7607e5dda36ee4f07c1c0c93fbac6bbf960b099f3b70d5a3ffba18 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 false +check_ring_signature f2da8044b10b359b22acf1d611da4af60d01460b65833b5225c2b8fbd90d3a6d d588ab399c6e3dbfc8fe421f75f45550d53092471fe576925bc983ca1162d29f 2 d86b1f333815de17f671ed6aa0cc78d506a5d7dc92319cd361acbd353f5ffb03 aa61c4a64c8e8eac110b9dcb5cc46d8683653920fc6593548c0e439570ffc1ca 3a888311aa8a4d91549391f5b010f94eabdd649af04419483f8b6390b6d9442991ab49941bfc6685a278f3cc057d21c73a85ded4ba67088fca9a6e618ccb230bae0abd5d10ffb3c0922cceaf184c909a927972d14514f5d55d4d2835b0d961e12388767cb806e449f626c7e39c48e145704c3ec64db249d81c3605e059406f06 false +check_ring_signature 61e9a6e7a98ba764934b8399cef2fbf94b3173c3e4c3eb62cf74e9c210fb4c96 50ea28051aba901a2135cf18792892a7bc0dd606b1e058903bed6f51cdfe5fcc 1 3ea5c349b575d446e67d984002246a9ee55b24ab07584406989da8b8b7a555a9 791bfe228d9c1c1788a0238dfce844b5e19f5526c57f4aae397035960a45330ad8d015332928b70bb262237eecf084f01dda4994784c765d82c0347e60b9d306 true +check_ring_signature a0a97627648517e970c16bbd591b86ff23ffd0d1a71875f1d324a28e9082e347 164f3db29d1aa6cd1ea2922f6d00859ea956e9fedef923659eaa78681ab790b7 1 50ffb118b12e06973cb31ceac937d27cf69ad09bea847cefb282bc4882290a21 51ea086d3e05e4a26a6b5087d74799fad7adfd4b75757d541192bce555742407faa638674254c581eab6fc82c7aab12cc53b3373be31de1aa04fea36db56f2bd false +check_ring_signature 4cf0c99bc452401e7c603eb0e250336bdfcf0997d6213149a46082966dea7db1 c3a9853339e9c6cbd69316753c3962aa5a75fe19f97c09fe06ec869d67845331 29 9ad95ab7fcf01df1aed19be7984c8018a4e84027ea88194bbe777dc2347e2d82 295e82ba2130f7617d73cc5fba37573b2d373a93d4827cde441f423c7d7f90f4 b8b4fe67525037df45c9f85f270b7af06526a53ccf1cae660026f90022484f01 5002749ca5a1037d97eccec8b9bb3c533461dfade026058ea14f4253040f7854 579b0b38d3ae03c92da4f24c2f19f08ea445b604d0e22027cd1d2dab858ff6f6 6eb8a98196f36bf8f96dacde853403d65172aab3a2c44696a072541fa7e5af65 f7021076b63283cad883c6a696f560a88b4717caf7962a8707cee6d376b5036b c05eb133546dba2e5a43ba829280ab7cdb9c55f49e152ce133cde13e4fe4d17e 93f836add31dca6bfa300aa8a26b89e3e56ae3ee83748dac14c4f0f84723dd8e c73018bfae23fe9b4f4d54d4469478d1f3a29365a3c133f18d26fcaaef9195b8 7372698561e081813bd62f8fca191ce366790e6665735ac1105125f6f96aa522 b87e49bcaaf0f7a2b28ad9ed4b8eef53573c573581b11830a614e5bf51ba6ee8 39dd823cec91c075bd2b92695dd904cbfe49f5c0b51ad4f48c9513fb7326cb82 84c2f527802283ffc137affe3c5c48610f4f99d88cade23b4613db688b51993b bad137477d4df1f72da02b9d0364806c2259a8ceffe97095c41acdb4e1a2d542 9906d7400a687266d7dd2137cba7dd266806f451faa5a42bf4ab6e39a41403e2 f4d853fbd1def92ade9a5421e54c5a59a10efc13c3aea9b4ca74bc05a640c485 e3dbe3c3406e56c2e902b78728dd7f7361cfc041aa3e2e26c48379f6e93014e5 a9b9c6964ede91b8f0943d12e58daec5ee21214dec337968c8385d0a6f97158e 8060d2c7c86533f520f2fd55eb2914233b4eefaae7957ad9c848c21f9b497432 3833bb634070b6c1186ebac255e7ab46948220cd81a949c5bd4794ea1bff61f2 28e43258f12c81e6fa40507846a4f719a818fbca77d734216a7026a9d01e2a71 08ca66aabdd438c388f32036afa75ef9408ae371d3d55486d0d3c7c7e4331eb0 890e1aff6c5a3c8d6c775f915f40e24f7dd236094a9311414afa21a9bb4d920c 509e0d37042dd94fa727f203fccfa6d2191d255583fedd747081b023f631e7bb 2321667da374f109773b0cb7b7adf2bcdf6a85d2c4618461e86d34389a8ced9f b4eb2d4bd1d0e2856920de2ca2bb7abebed662f9f270129e61d627d07274ed14 0c1784b8d2db95226afc89eebd52dae9f24dee66a2dc34d07ec469c8c3485442 1661eb4ae1bb2dc9a5847905e4bc4702d4a32edc3cf27c8b562b662e23721679 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 true +check_ring_signature 17f59fce217e716e3a57008af350699440e1a7d23e5d0ebb74c692afc5e27b7b 26a89af1bbeacba12158a75eab8d35cfc524633ddd39fe8074c2a2066d8519ae 236 c26bf72b3cd043d4c2f6ac33a008caf00d1220434cbeb4f4386c454184290fc3 50d846793e4ac9c27f5276c5e562136936d3f19045cdd4e9033ce3633a53281f 5a7dcbebf400a7ccf3b2974f7539dfde6c83afa14559e534499a87d1f71972d1 17f38e7e7adcd3d62f7ad9057bfb02170a354e14be1b4a4bb3ce0b84c59a2cd5 1273e2a98a53d7fee045d17f86fbfad1726fbef93b3534d11e26a72654320500 7eb35aabd9ee1c1063a361342d24782694369e219e510a01f4b63d0cc1ee34c2 9eedf28353794eb2bf4cf5bb440972db8b48e5b92e2e7d7f5b625bc775f3220a 9c5f391abcd3dc79839987175680e4f29d7a5ded0494717c3fdc120ba187aa79 1cd9bc35347bdf651c66abcd3c82330ed51e5bfe256e39144ad17e32cde1c152 11a7086d1450daaf7ab65fe1f13e8e1a88e4bdab1cbd3b13a0b9c92349d284cd ddf36402ac554377aec0f9293fc7bc758b418b0cd5bdb26595ee38a4610c59d4 128b15ecd305b0c8496289a1f4f8e1924b559d82862c7d588bb69c1797f3d702 9bc0a1836486f0713de60eafce113471135d833d2d327ffb240b97575126c34e 655f45e719da74b0662305113a02440c8136721c7413b7cb459af3aec438aa02 178c661d446b2fb20632ba57561ed25eb67d8ade978378243824311e84ffda7e 2f92654ebbc4789a8259ec20b12c344c9fbba4fc7343fc6854d788349732a904 0989caba3533b57efc5cb30fd53500cd245e18d8039f9b5ab156ed7810e2bbc5 cb1fa92e4e0d5a38bac9c4f877f68639af5bb3bca674fab4cd2ce96c04545a2e 92baed360fb6d6a0b939ce8843cfe220786e8d1c0636d6bb71b09a721d834fb7 6a4b16fbb6b963cbbadcdb500956122999ab4f03235af133bf58abcb0600903e 5cd62dd626b2349021dcf9d0d1f06862d004e95ff2685ce931e630029a211435 c5a9e2c77b27df422ee2838f4c1a8a8030f28f02cca90b3bcc88dae125f531e2 99d207d9d8ec8622ac499882888b7f8b61ec6cfdfa06be6869a16d225086788f a7175b482bc651f78c47730498c9bc754d2d74b8bc8e1420a65471c9ef7449e5 5f0c0de71aec604416cb521de667b86c7ba56fdf868c46bfa06c570da7fd4e62 24bb8bfe55d8403b8cfe7ac4b8b98ea3c86b1d1c2db80f9567c55f967e514c6c 25bffc4dd0fc374cc25a65ca226f0955716f05e00b5d6cec5612c997d52f258c 1ac4b81e222658de8e4c47381f1a8fda2b46cb6eb850abd38542192cc075c154 129a5e76c20c087baabb50c8b82822d3ab8621704fc6a103aa8220ae71f28766 e39efcb41f8daed0eb96269eaa10c65d2435197e9b07a7b1caa11ef20fa162d5 204de019824e1d549e304e954af7fa7dcbea8d8042323cb4dd163aa007ee73d5 29321a2f59a2a065aad0af295a93985157078efcdc960c75f37ff4cdb7df501b df00e9790e479f697bf835869018373afd4db4cfdabc07f000c3e4115957301a 9d8b3a4e321b69f289b4dff34dcd78e0c23fc111b5a7c3ba5aef05de5c6cb1d2 872e2caf8ff566fe6813a5f54dc9d402f5fef01f7ff1da22a8eae40ea16d088c 540989394ac401eea584b9fa49b9535f843d7fd952873e6d9e98438e5418e670 4c59b2250c3dda5db3b54912e29837f77320b412e1b97835dbf8dde4bb21c399 499cb5090011c871b6b65c8367493ca95c8a7a1317abcd8aa1d9b7d1ec61cc9d efdee07d6cb6d0e892fc4134cd0fca595e1d0e8742c71abc58adaf667b61ce18 b28f6d9fd3b58ea5858ec1d44e64af846b01e7438e1e2cbdcd6722f51e6653e9 ecaae8479ddf0253b59223c6ab8e7749d422fc0ba1298ea0f1e3a3240bec43f7 7488dd8a7c58fc18415d3119538d9ffb7b48563fa73016058326bc70c7e37a00 e603a9c4813483f159f2514ef7f29ab943419fd2807b3121d884a0f2c297e7bc ab65edd3d0528a7f9b08bf5cbd9df2b37edba3d1aca6d8bbd558b9250090aa88 0f03ad9e6eb665e0c6c3bf719e3ca517428cb6ff3b89a914c21877bdfc4e101a a86401b71dd6962f78c68b5892c8fff7f4b80b8c090a4395547bbb1c894bb0a5 aececc1b2cb3de5da54e6c9db12a47296ce034d5af6650ef71c02876d4e5e335 eda3d5a421d210e07abed55df0d6ead78d9384401cfb31f566995dd1af863259 563290f621a402545df8590a5eaa78992fcb9128d34290b1848c9ff4f7adfe21 f9e9198a5f87803734b9a20f3320fd3c51323488169d3457f8ca7f35fcb4df93 9c49550269394bbb6fce18402e2d2cbe94fa8a655bcbb70337fa3a51466c23fc ff10d0ec73e47505e284c799847fd2a4ee0cd4a7cc5badeb85d5712bbd8925b9 5886a60ed41643a2a35e28c895db7ed20095cf6d1c6962d22002b437edff89f5 e9dae1aa4505475e2ab9134b176db99898bea2ba80fcc5407229e8bfc9d33890 f31e8f66b06ac72ddabaddbe883c554a1dca063e53a3e3c7794d2585fe126f1e 8dec335fe7ece73094b6b8d845f25b9ba45c78ec94f419e212bb7c13fc35544e 6fed01f26957cffee7277d2404ff472ef9e55f80919adf8017ff1307d58dc6ca ae139f15dbd62518bb0450418d41e8b154ddc903511d102b5d03e9e790f83938 60237d0937188ffe77a38bf864aa85aca7839f31ae148ae99578d0de45584396 c1a8feb7dce1f76965d38af983e05ab5b4b879675fd28f49c20237eb4f16028e 8b35d4b0415560d72e5bffdbe562cbcab5c5d9b0c99388222d111835eed2ea3f a5b1558661d96b76d989b93fc0d469082cf43a93ed8794f868f01faf636a3582 d7ef112a2d496efcce0b7793f1d285a78ddecce9ffd997fc3ae66eca3e898426 d9283d173057f2f74eb01e71fad2ad1134edd4cb523fd9aad10ab429e3a60464 2479e4b555e7d4524ae9fb36f19fbbfb9e8d17c5c796a0fed49ab9fd2f9470d3 00eb085416ea4961466ded3f35e04d715a1227f512f84b831ffabf0c2e3d39b7 c5f843545d6a2a985065b7d82a9c08f0d049dcdcebc2f978efecb858fa295023 c7fff2b921c3e1f2b588fc6ba6c9a252fe035bd0be9d96911c7b197dda7e44a1 6d30f43e71dcc335d09732a32392528d45ff74b34936df17504fae342bf8bfb8 3c958a36eb41d50dcfc40ed4130d372c4b5cfaae552de786e93e12ac616abfca 49bccdff6fa1515f85937b6041a9046d7cb6eb28b4b94bff013278578ea1e526 b5e13dc9b6682abd8bd49d5e12f7d6f434782c750f19582466acb996d4695e8e bfbf1b80e0635eed3caef5e724a1a85b6bd965c90d8862e3e382d64001fdd330 f7207be8974ff94e45616d04b7a4a9ad98fd81def0798840134f57b92642fe1e 2748dbdb6103876904d30fdbc286de22c376fd809923921c251b82a611b3595f e86eef5601cd8818b34bebe94912d93fb055323cc340991a6cb89f842bfcdcf5 dbeda139cafed4d9353b12279de380e6e71d36cb0e533467410f4f4d5aa16fc8 df1741773870e35d8b79259feab3a00f73fc5398900bc61c87a85c81ffc4a1b5 eeef12f2faebdbc07865e0678a10bca4f992d77e0db93ac6537b6c9dd6943d73 a3d71da627fd56a6cd73ad86d3eb4b3af0695fc2f101e67feda1653029f23e1f 95637575e6bd1de8a80c35e0913e032ac99ffc04ee744688aff151bf8e742744 c62ef74759ebd7f959e91985f2cab2a7e85878c58a3c11eb02eb8aba8e0878ae 321e69afda88d06e067b924a618dcc579327e5e7dedcb1a7d81b1e1c8b6ae2da 0d220eb8bfd081ded5c564ea6446d4b0cd7d4e0202cb7c72785b5066896aed9b 2195bfa14aa4f84cf82b4be9f85e1e143d7bd2b39a91510cf1de7af907d8dc3d 35e80115388b5645ab2a09d9c5539c86bb330927c2f449f177d521cf02e53825 fee07daefb71f119d8186699f0db1db2db34f658dca3ebc6135e9276594afdda 039e7e92b7272424ad45a09b9a17e4823d17c857cb2d1a1aa6a06ee593554923 d992aaf55e9fdee8c74e98d4e34c196a7df9b4c43b8d5ff5dce00c7f2c84f048 389d5d195ff16d2fa36d5f484294146bcc117f5765f0422267e6a0072330ba33 1292d20ba92e2e428ae4794e1373c9e0c711dd2ab01db16ebf229b27f064f7ee c7de9ba7193d199cb6f25f7fe7c731503d68203f6a4cbd28035f8468178a0bd5 05341cbe320419814205dbe2d2cc24146cfef0e15c498d4bf57960fd7f6e6efc 52ecee5b7440cb95ff9efc63086a64ccb476b49869546d87d5c61d929d0230a0 7066228371dfef97ad160f4dc4281a9360e9c53245e97be4e22d8bd42010faf0 50c37f9734c97af7a624beaeab588a4949ae2d7a5834f72f3a00e6e6b519ab31 8fc41c0e6fa6cd26ad14dc612f9a0f223dab3201708d4e6ed2d2d1249e9db44e 70da3574bff9f340f1de1cdd4dca001aecf8be954bff72d0a9c476f8886b6119 db436ccd70c423f55985bc5dd559045fdc581afb909c5f0e2ea82bca960009cf ddc1eb44e4a3b7a8ba2dd899feb8308bc5fc763f081c12988da1bf64376cd1ee 48e61240c21abc236dc7335c52493c54dd90aa81dd031d024a79ff8566ca6997 cf9d3c201c2418dee409fb5c5e9b6a5f6e85587ddd1d2b831c44ba58d63a2c6b 8095d9390c38ed062ecb4e78435d86392e607a53b9bd8c97775197a29bf8867f 608678ae7eedd0b9fbb6c9645b8c25fbf7d89022ce92ce6ca78d4ff48a17484e 42f201fe879f08f939ba9d5bffbcd0632152a5bdb4212ea4b0189b305e611961 246e4e7a2f295b801dd47b3de65f4c1fb10c3267c6b33219df4780698a953a9e 8844b51cf869733817c9fd03736c7b2a6a91aceafb8a1519bc0144c82ec94540 aac56ae7f85b7d429ce0becaec5e98c553777f35bd6bffc6cb3e06758fc27314 187969e2fd34f1941fa1d668e5b1cf7a7fa207896bed1d49f2fd8b8bca26ed38 83bdac9b1118b4a891a2ce6cd2946f9275c6ad6f72fac14357d1ed948a98c183 2a1c40f0ba1a797eded1fefe0bb536c13495fd7f423b49a3ac160790a66b985b 6d8341464570eb6b83ce2c5ac2c0e9992d4f03f21b83c5a54cf96124df7a8374 bf3e1754675624b5fae634700c0be3ab5738a274890517d15c240e762d339af7 aa045cd1b2603bb9e223bd11b6e86a5bbd8e0bdcf878193fb726170e5cfa2757 5364e2048195dd8ec36040a5430678d74fb055d2e3b1d612d6d9f6fc49614a3d bf4227f83d9d6437a41adb847bb61a22211d62dc2d8ba3430727e33b7cea5c02 1ff62151d170a85b60bede52dff337b6250abc293c12ed2c026f7919bb622f5d 78bd54a63b69b38af18644c0c5b8249543fc5d054361fcae629ee5b10e995bb5 6d175bc085473874f057d0a3e55cec3eb2ac6bdfd969d474b9aa5f1fdf4cc7f3 b38c126d5b28be60f0b7a432109a8f99a4ef4fb525e3ffe1f8cf7825342cb460 fbd1755dfb05979264348d79edd417a040e19ec1b7a0e402b5e9189341250567 fea8073e8a77c2333195513b91242c113ba0247b49081afed10b11f8f2c136a7 4b0f7d10209e8328a32d9f158c8cc3856ea0e25880a0cada992add9300a7c993 279ded90d5e960248648f7baf61cfe77a2ec776039b30063f626e34ca283bca2 1c6ff526d920b690b59981bdf28b1cc5dea3093e3f60e2acd660c92cc171a358 18b487185a5c8c255a580a6900af4650d8e3fc7c441bf422c36c68092183ac2a 261ccefa0257a1f4f0fd264274518dd26d59ac2906bd0c7e6eb36602e9e7e666 aad4d260ae4e5f057ce0706312ea44acd7d8a482cc01bdd7af62fddf0c70ca83 532baba94a857fbe458484d8297c3a5be76e6ef37ab596d5663ae25fdc1c52b7 2260cef29241b664b873f06a6c927a442e4ce8585510b8a395c911b15433ef5e 4f5f944c97c75306a893f4ca7b10e4b4bcde40dad5ae50e410e4f2514d5c8e4d d35475482284722f7e53093978f8bd430484a51776cd18a4ea2e6e81f4a34807 6c555fa9a971e8d01d7ae94c98a2bde0193bcc7936d728ccfe69fe1fc5256648 6c8d8dfb6244251bf9170fbc99bba7cde16e65635eaf6e4806119bc792c794f1 ea7652bdb2565f6865ae9a844dc7d2e22f95bcc0a3ae6d51b0dc7e6b90c785b5 43579311e84e8e8e7ccf726d67d4c1e54cca70eb15692b58e472c1c464f3f116 9338deb5f3d49897bafd1c644c5a7c82b070b5e7c5ec083c6f62d821f81dbfb0 8ee55ab54d37c15d041f734998093b8235fd1ab8bd7942edbc08a97d2b69bc02 53136deb88d3ea0899851ff1011eaa5c572510f987c2547b91b332aa4d0461ce a3b5afef324e7fe91bf72d8002335f1878c06617cb593d2c7ebaba6758988046 dd07368579e7d8b0afcd1e2a674352baa79f0d01861bd433d883d51dedc8c977 2348a11548282df88195ae8e384cd05efc2c933f65405b0a1059df6f2c4d0a94 8b45db3148d9678abf4085dc6d86b55f1f7a611e1884b5aaf695bb8afffcd4aa a6d6ee2186d210cb78dc92ecacbd03e500c6f68c7b6687131189cd399f710e49 55d58ba41c5384f8a5b5be3b8eac70fd963592d4b9117f6b04b567dc6670ea79 fef2fa9520a3663deb72f57f94f76a06700ef553b8251772a50e6e2a2bf8307d da7481792b5dfb4305c4394089143e9f81220de2ff5911355b2ceda5acd130f1 621767354bf336a83ed2e117fb9f0f3c40302a254d842efd9b018d6dd7119f44 8840a6bf330089a73657e9d0c4bedfc25a361949eb858817d8d7347637daf698 8a176c35749310adc330dbaadc352b0724a3eeb2ed85ff62617981ad1418bc4a df95ce444278a2df82823455ff03aeaac0cb76f508eff966d74ee34c95e78fe7 317e5d4fed435cd5b69a268f486109b5fafb87615eafa2c4427f5ab3f9a3d481 010d34d627e7e327871591e89c2df2b583f941dba9ed8faed7ee7264315f275b 681b4d9c5516fb78760f0e9dc1fcdf7a516dbd2819501a5e6789bbe4801c9b7c b2344db72bdc5e86e75d3a607fe81eba98bcbe1f31ede4f8ae03cf0a09f9a325 b71f4b941ca4cb8fdee169336d9419179e07e79039df7d31f6ea154e279e5e1e 098d3c0b6d30465cc8fc396c10b39abc313ef7262ed8e7cb237daf20068600cc c9907f129caedf5b9f3c03c1769c848e24e030eee7387445c27240773c41aeb2 8d4d72eaba9fe1767f60edcd4f00056c0c76473d95cab4f9cb7acf5f6e23e4e7 cf68f70fc59790eae1f2c76f7c68c0e8029da784a572575628e68b749ef44810 4ade9a306a2858f694e7409548045a7e8208186176b5899bacdcc14556a8e82e 1b4bb65b113221c289e979351cd73128c1557c73065cdc0bacaea6e24f75a60e c3ebbd6894d73b454e60ef0742c276ee62b74d9b91aebeaf5d6cf51faa634f0a a45eeab6b5cd0776936cddae0bc0a248b98ac061f4f8dd4847f6a725e13a50d4 23aae9b4adf8a0d294565bcc72ce63fa20e0313c5fe8c2d1b6cf68f7d15d3b2f 7d612c222336ba7fa4233adcd213b226754cd58fc57760603ce1b5e744d42d45 84f7d5cf37395201c2617cae523bcf3abca78e25854d2c8b8f238ee7c7bcf848 c265704695234f07394253ffe2f4f2a6392c1a232385ee7127d4aa914b984b32 ccf1abd2d4317410ec8bfc5fb142b1f65ce71cfdc22652618a12d46259db0a6f 13967758190ca91bbdb9b549d5e62e9c04cfad479c69365e360bbfd5969f2c4d 86138507f1c368fea31daf0025a20f291e39f5fac9c54ac3461bdd0d9e7b0ecd e54ba7e16358f2df1119f7d01a139bdf4a850e2bddf2a69315c63db8b44ca377 53c7017b1677f9962a3260bd6253d8ff1930de3822cdebb007d1de8e68213174 e7c029a6cbcd3eca90a73f2d0283fed8ad0bc23a3de25eb815dcca1bb7e5e37b 842f04911b40570b700992e625c75bea98751c71af81c15d8b65d950fcb55a4d 7232c69c55c457715063a2b50e5fb42960e5aa120e5d54d9ff9bd379296ec7d6 226668ec8a842e17ccbb129e31fdf1181f2f271425489a43d400aed9c5779908 c445101b3ea11b76e0799ebec351cdd3af64b435301d427c9048322984675b76 b4a4656cbfee2145adaa377aa4285e28e42817875c215c4340ed93e181be1c10 73e3773b17ef3ec8086cb5faae7992da315fd9e6e86bdc9173184d964636cef4 072dd4a741743af84c6b1461f153488064a79271d281f6fbfb85c8c2bee771a5 083423f0732a5de1ab7993d7f5eae7576288c47091913bc7224a95b8995b72b9 8d74e51a876899a93ae35b8ed6063e8499811d261d7e0c18c236ba7b5c01b9a4 cf363af0c90abafa18fabc477273d3d891c1970e4c0803393581e9312e964383 12972c0b0764930dacdd37ec6eeb1a287a96129f1cf30f9c5a4e85b550c89764 e9376b08129e26fd07fb765620f871f0e76bb74419f741727f44e742a8b016dd c16a2843feb8e50e713e717acea0be19a9a267f7352b6c361986f0532621bc13 3d597cebae93b398e9ca5a0c15b58a58337f1508edc7e989e4dcde57be120d19 7709dbe0f11bf4753f8ddcc37b7c1a19d7c29a100f2b56b75aed111923d0770a 81f1b56d5468909958ac27f543087517753574f1784f208762f485c533df3709 f4d93de8b273202900fc95be9674bea33a6316a0ed5e1d7bd1ee2424be46ca81 8ba4ef8b2d7d6800f2e914acca320c7830f3e033860162354c8700c6a0bcd0c8 b0fb71a96bde0a4b5ab8ac70d11bd754a52aaef5e0f9085850c8c56bb467e3db a37f7bf9b65a984628d7a41ce8aefed693db5175d54f2ffedef2f24363c8938c 22d0df23c29fa0e005e8bcd9fbc58fb253cb04fdbe910492b029815c75d89610 6c13f520035545f6a3d81010118414769bbee5132be903fc568ab834dbe69941 1199a00f48fe98c386bfb8fe65af4f28258c01721babeea589a678d0e4a09502 4ba30b153d0d673fb299c01d640916b416970f94767cb2deba393dc0b4ea984b 2ec57a7936a1cdce8abb31478fd34ee350f92faf73d28e2f83aef86c9233ccb5 18a77d429dfbdf144049fa04a120cea013c75da21f186aabd1cca5cf7b8df2b2 65bf0973d8890b04e06b0c6360bf99c6acce2e9f204872c6278eb187349dc570 f3dbb86729e866ab00b5aa295f3a2983a14bb50922e4134c1d1522c1fb2e9e13 4493cdc49b4960c6f2e6b6e30c3267b285a9370ece29641e1cf7b0b1e1a5a7f0 3292cf1537c9e6494e5c2ab4f2d3384450a0a3f1352b6fa8ad3bce95f78c4d0f aa418134472d775ee36844440ae5d8a276fa4b53b4661a24faa921bf4782073f 2d4ecf315762c2a34ec11d82a7e29c83587b4c8f3749c729b707124c1e005e26 eb9c9e3d0360d3326ea76fe39549e81252d1bc160d45c5def12dbd414d4f6cb0 36291d8646b27f58399f87b332d225316eea47b3b68ccbfe2dc3a645ecb5ba0a 1a85497741893b439d281c41feeb9de023758161aca54f57ec9fa40a01ca4bea 33fe8bad016efc7012e56e69850094c1bb13887e77f5a9a12e497b660a4adb8d 89a7c45f2689b33212dddc75c6fa34dbe343bd31a86dc3688995049ca7978da8 ca97326c3b186af36e71ad54395997370355d340c7b21599269178ff57850a04 d8ae78c83fb24c8dd6a5c6eb0a46096e69602ae0882491082bce22b12473443e e02de02b87f16ab79e790028ecee6043bb1033d4c34b2c474e64c837419ec0af 7951566a83b26a87fefbf716550509354b47ac889049719c0d57d5604e7bb93d db457a8590b2fca0b2700a13beb331df7a58f3789a6b7a4c80eb02aa4ed778c6 661369f8792416b51a2df9bef8e1fe05e489e3f3d98c5ae38b28f379fa6dee20 fa6f58d64a135b815c653d1726bf441ffc298b09c650558854c3f4ba7d94bc01 87641c1cf1206b410c9c27b4283cf19873e06377cc70e7aeb2de50ee9764188a cb541ed79a5eea469f1b374c18e0a8b12ccc800cdbd364bce3daf43c7fbf6846 e3d53844579d83c2b9c78b79169b2f6911d7b125b94f89ce4c98f1343e255295 05aef36fdd1e3a6e17875173faae4c9a2456b77c9e78afb4681c31c66784f590 8ff43e7d4d6c82b8c91758dc3e292af3e9344dd621aa18e97a3b3682e3467e52 2682b3e2c08992a8f0f7d982a6c6364277e9ec213de325537fb2d827be702556 83f6723c2f4d443f5b4b308d3c8095da6f20647d95930a8b5ad765efd049614c 438124b602a4805cb0b44782dee63394d9a8442fb62318313807bf030fb2103c aec608be9ba863aabf78544b1b2ec725ae83ac16cd15dbd76d8cd8207ee2a1fd cd5598039f1b650120294184eb5c17438847ebf8f9eb50b8f45dbde84c4eb19c 0bb7409ce09441d4bd60aee5385d2181bc34e98c919d689b4dd65cb47bec6610 89d54eebb2e5a8c5ecaaffc2cf70b255aa2ed8314a30aa767c9c1a60bf80a158 07f968701b8d9309e659c671d18f856d243959c06cca1e0b2b3852c4eaf146a5 878f353f0454d048cb77552ece25bc542904341943d2adba5ec5b04e5cefce91 d96a16c6bff9ea54cd8fd81344ba0014fcb194a497b838215c2a1815e02c25c7 da40eab1d4369c130f1901a9dc3e1c23d77b0dd4b1204748c222f58a6fc475ca 12ee66ade2fb782e68a0cb499d464c3a7b7f3cba757d653c0791ee9579ce1f92 b5e14255b92b4a964c0de98cf1644543363cf07eaf66caab5f60cd52ec373ef2 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 false +check_ring_signature 5ad397d2e525bc572c0d4fe3d6cf60a7b0185cea4bde180b69ca1218986b0957 c150fc926b8b54fe7e06052ffb74fef16fcf918948a4dda7d7a8f4ff5c584342 78 16c6ccfe049e992fba67e0833eb42b7355c97b0a565783f9256d7820f18bb387 9f472351b5d2ee50eb1b395260908c8e439679ead4043c89fb76f7ba130af641 3eff5e23c1421fb4651ba50ec773d9d254afc6fa89ae689384bc884bef49e18e 50dbe73508fc3324190ebae2b975e67c0c01e6036bcb88f9c6774b77f17b71fa 767ccc68acb146793635f963608ee9dca3e817beb2ae8162eac1e8f26c45c0ca 344a3520d03f1014cec4fbd91ce90add58392af7a2e17b81280ea7eb2dc44482 a2fc3addc38b5d6bdf54c8720e010b7111742aafd4169ff3bcb2c867838c612e f5d67f1fb3ff03d04b9196141a7a3d1e316284010868cc6631a78eaaf6a636fb ef04c150cb399ba04fa3ea76382fac5506cb8646317e6390c7ba56f1412b9881 199a9d4db6bc26f84018411053c8cdd26233a3c852a46bca28be8d2ec95d0932 aab2cb540476808feab0f4955bbeb494c49b3756c10ac4c4890a631309dd70d8 b5b7bce7da7eb519e17c6cd5a4b7a0430dd16f6e360353e800a4b85e8707dd0a c5d1ad0ca3f1e7c692c985afc192dcaf4a0ed8d8cddd3173e38595ab570f0349 130978d57332674619ce8ce2696850ad35dcdc4592c7b72b77b02bef992a6025 f79c2f033e4f8de6c9d81823282ae5263bc1923a15b14fd56b09d7a38d2791e4 ccc67a8fd26abd69cf7099c3ba1b4c43e589391c4363ca323283da5a41027c5c a186ee7b0290f3dbb78d2645b2bdb4ea3f5a5182645f0d0d8eac220161271d43 72729822590715857fc7d8c917eda3ca519e216947265f1b2f16826d2efae6a7 111f3e68394a5fb87220bea0660d89cd0a5d2cd743cde4d751fe550eabe2aef5 d92885d7fa7d4878759ca684beaa5a1597cfe15adcd7691fca68d2672de727c7 d98f0c6110649b6ad85ffa267c8384ecae3ed90d65397758f8163bcd21c9e3f0 31ec4bb2de4734c4656dd8a1882f71fb46bc9274d0e2ee3fb0017b1bc4608927 70e8a3a1794ec59acad71d0310e628379e0207f8bbf2b4421263e79c2d4190a0 ca92dfde69fd579d2b1ede20533607535b5dc3c4ebc65fab3f5816093b904312 64f919c775d46ec5d4fbf21bbcaa7a01e164ca11e6ae1556a5c37ea3fc5522a5 48a36026ae1a43f0d093ab803ef0e4ec2e5651549a8e85df43a968368ba94965 d2b17a632f30f460b800bf5c8d7d7b4981b5a4d19bd3552b216ae47a09f353dd 47f7693ac45edded95a8f60ecc2d78b3124be0dfc71eed8ea4378af1b1e41664 488aa8989d96fad99449e0072265cffd6d6954a301912075e2e750f9d02f4a28 2df6fbfaf5cb2279fb308c8081e0ffc4a31af8f9efe8def7e5ba4a74022e4f29 adf2a736f444f9da6f58e6ea50f97d9e5ec9a54c827a0353960f5b71334a1bc3 ae331ed30ffef2ff4a9b0be7ba16fc2a6771a6a2b0a9f615e6dfa2b2dada26b7 fea897f78f28f6847950c7e9bad087bda90e2f1b60c4a0a8fd52e0476c27c723 52138ddb9b1b40c6ae900abb970c43683a4f7f446d2db5e8e9d648583e14b27d f4df8f97d2b31d3d8a7b0450aef3b02e242d0bbcbf18c2f051192f4b8961748e de2407075f74f1e0a784eaf0e28ecb75512b1b90a4676164cac22858159684fa cf84c877a4f04f14791b3f5dc615f09d879de2bdb21f5f5f8028daf334f8318a da2959de85316c3bf2bf18c12394c1a939bfa0334e12c46bc39bf02748b06b5a 3e4cbab5765fc5d2e34d511ed7d85a8ed607317a889b56925d853070187aded1 26bf44cc24ea42c0d200f0bbd30f80a4c62c67175063d752b090859a25605f09 13c45543aefeb712effba0754b835c91bfc5a2d48a01df9b4d6bb7e4f86f28ec 4463bbfc4ea38db4a4550604002079ce3a47f3b333bd6d2a9dd0a58871edc146 f93645eac685236ef13e56e25c6039a7e2959d4b955f95ed62af4fa99803a4f1 f4ee329e2b8c8a64c9a4f02ed14d248add98eb45c322a6bf5d9d233d952ae42e 1656b513820e15afc82278d8918c7d4562842ac7bb14c6e6e7817090c3fdbf28 3e3854ab0edef3aea098441f6aeb6839a1cb8733b3d28ba6ece56cde65d25e67 0cb51f6e3ca13694983e362c9292dae7749f4d322c0968c3750d0efd397d476a 1925b56dbbd4f33c2998b42ab1fc4d6e6b24ff649071548d0ad99a1a6a703f76 891f54c487b39f1a4f519a8ef65ac249ab8b5107b2229b6bfcebf6e4e62e05c5 cc8d344cb262c368825b948778b1f98b6c50d40e4ea8fda0270030f58cbc3e21 a7ea7e4ed95be5dca5753af9a8a85b1871f981392329c023e82d0b9d0a3c53fa c8a5b573893d9a257c62e010224791a3dbc52552b9fd54c2a88ccb338ac27fda 9f431124b1fbbb70602398b0d0af7b44e6f1b9d7c59b6e01641b3be3c9e2630b ca15b6af5fbe14f21bad06cf4e0a16f4c71180a95263cda4928583c18b1bccf8 81318e527a277d0e82cea396d1173232d0c2c33a0f6fba31fdcb21831533bdf4 5fdcacbb8788fa950236ad0eca32b51d5d6d369bcf4afe82314ac636ededcddc b9b917ee218753bc02b5d7d80800046543a057ea74a898fd0481b758023b9a5b 0d91888f3c4a7b5e00b4b7b3553d5ec5d114e85206535ade5ea911b17e035421 0db929f38c04b8d8fa04086ffd787c983cc5a7fcc6f7c09274add50bef7fa0a7 77a9c149ef218636597989ead52be021eca71255767c1479d76182ce7fb726a8 03f959e87ffa3190b36c563d7c0cbb79c84c665032d62ba65fffeb8146da98d0 0cb8e52fe9ebd66e95d048de89da566e91bdb2935cebd6215704095b35dbd2bb 8bf544a37b3def46fe0536e359abd5d4c2a1eee572c8ecc9c9c4d8399937bb54 01a00be9eaeff23ad4f3ed10b331c91693769b37c4da635fefc815e05f883ee0 e7b8b6ab9839f9011df5585288380c6f0c6f4e7eaa7b239c3566b0fdf50e2bf6 d876d750b84a7101b525f2245aca51ad0389c4f09977b63765ef0f74ed92a6a5 f6791da7c59c61513bb1334375bcf9405d872e1341052afc525b592ba666a89a 4c22db6c874ac7199b693eae44bbed96d5f759da0a63119a9b7dc937c994d341 3fcf6028a920361aa6e8df0b280cc3c1a3b22768874bc521f4e1ddda6f6cb2d2 744070c6842d5a88707d6a9e6bea4b0ef6a3f2a049ac74beb1142203fd23bd10 40ce9e5cf18ca8478661a2837a09b477a1218c30793d0899a3abb45a1e2739d5 c0248c521b474b074ab0e3f8bc6bf31f72afbc98feb695f96a23caeec2d8c7a2 479f53579328b78eeeacc32f0487a6c8d6147a3e2066958b62a3c70472fa017d 64dc1766281439647f63d12a83786f2fe5fefd4861abdf3d3c313575a6954c51 2681d60a093e3fe80c5cafb9932c364fe4992e746f86f99f74c4a8fa879e342a 15d896679cafbd3646e9be6df7f7af41d8fb6658bda209a3838787682fb263bc f09859fd5b818ea756cda3cd7cbb7231f192b4ba4f468eff69d09d57f1819952 0949e826cd2421ee332bb599ef5c350f8a2a2774e66ac6df5791180c3f569b04 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 true +check_ring_signature bd948a9d20dd526ed0c7ea99e07879c9eacfeec8bdc5e011724238f165fdd361 8508ff8b97fde2f91e25d20c5f044071dacba8616ba923dd37ea2128291c9d1a 32 3f22c789dd3a17dcbdc5ea87c47ac99b0f58df20a851c190f1d37a4911fa01b0 fb670ad0d35ba957245f2728e0ab855160be192642c467db55aa9c64b056c8c5 83e48cd84de97c51f2e10205785617297a95270dcb7eb323b7d15bb7fba936f2 132519dbd43b978288e709ce2eb8b730b94b3b2e785ff1acce134a66da7f3dca fcb418887fefec11119e2f3df1f7dcd6f5d213454163a21a3fe3abf45d7b8d61 3137c98abf4dc5fd7035002703373db6245a1d22b4bce1c2936045d50c68567d 7e457e83bdc0495db118cf215777017471e853cef8f22a04454ea5cb6bb188b4 524f5bd1e5220b90fdeef5768023e7d002672133da0346a22db67c79e5ef06ad b0afe2aba41edcf2a3836504ae9a000c2c8908128d94dbd0891e84df8c86127f d4acdaaf564f48b45a0fdb41bab36fd283003e5dd87aea6a29146d1835bff615 5207edf25efc74ce533012ec1178628cb479593708fa8291acd886239577a6ec d3a5fc9cf03a1b821bdb8da26b0d88cbc2e48a32961d7d3bf0cb6198db522396 e9c0fcd91a34971663f17cfa32d66f45c95678c5ecc36a865766f7e407a3a9f1 03715dfa15447de32e6cf72201768ce40835120f351406e2d2480114a5e1b94b 59ff5bb2101efd0a5dcb62f97ec45c0050152010c932b98dfee23c2fb9d70e1b 6d08c992f46be3426d909b2cab64cc6d7e8781938b497941b167f543a6bf0c9c e94325c2feb3a4ecb626979f322d88db46ac973056a95c92d3f52e4e0547813c d6759babe45c75a13392205f898999b668529aa78baee1949267fbcd8cf86108 d865e11b2383c4fa3ec0f19f8e74e1df4bf73bc6d5e72707293a6fc390ef7987 227320a2984a0602d62b9366272b8284099d5d4c9824e7f727aaee7f78a1adbf 8d27a661995d9587717c61355dfac1cd7a5cbb447b3ec7e7979a2310bc887e9c 60c6e289b17b4ddfee3e1709d382689148a03193ac62f1fcd84eafeba1ee07a9 84ce866585f0d49a6d63e62579230222f3e3dfca50a01a717ab5805c5be05459 5ac03aa1757a819556b01011e17c87793ae5da1257c72475f510322d1806c80e ea58bff2c511b8db09b8e311cb351e36f0c24ceb13e1eab5c95bcb180c0a0ac7 f9bed539ba49ab6233c6f43c2cdb54c6d4158b99a49a7eb8c24dfa5fb3f9dab0 78a3eacf398f449fc3ec00647475af44143a5beb2e2786f58dad7b4d5da1cc04 dc34c01eb6504e4f1c72326f2376ae9bd687d726e19b1f988ae368a32115b5ec 0e620e7244f7e8abca5c54d82ec661104fe93331384b44e7a8d965cf83bd0c2a f1e301092a2075cb8df09fa10e2b1bb626890987cc933759cfa71aa81b1daeae f729e7e5c22421497c3d077743360dd09db79b70f3a1633e7325dc7a36aefc07 9fab0dc213aab71dcc7f3085a39e0c6c5c162387af7f76bf04bfa5cd38b7bb8e 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 false +check_ring_signature ab0f1abba5d701f163059cfa007d2f676442f89b742227fe7798e93e99250c09 caef420ff7162211134bb3547c2128c7339c9796b695fd158eb5b22d70f2aae0 1 f0bd15af29a5787e0c79c39f0892d27669b8e39c763183f6fa39cb32639de157 c7afd11d17f6c72033100a8b133d656c30c4ac4cbf756c751587152450f5f00c08636d06ddb035dca3220a4f5e5990b51155f6fb0ad921ddce290fd51ab4b60b false +check_ring_signature 65e5aa463309a8bbd4e460b71cfb1ab0d54ab443e1deb0e9038cfe5ddbada757 64639318fdc5cb264112439ee7543cb4b64483abbb29636ce383a5b5bc61ae90 2 11a083f2a26ee4fd1048de35de6e139807702010fac8ce24634a9b391e1e8eb7 f705cbdfda93d825c4401d0d43b0f64b824f34d3ac312c2bafb8ff94202c080b ca1f7b3efc72d962f5d48004262dfe6dc0b0fdb0e7fd0289ff78465b7ce18a019a94aaf30f605ebe5bdf7ebd08ada5938eaf49b7145b0db8eb514f33f61821023dbbe35c60d50e05e57fcc4a3a7e191a07ae599d6ae4d81462a4fa851d4a590f5dc73cffdfa7dbdc82f6f7faa6d9a45936b6472e4e0dfcde607c8c8e1488680e false +check_ring_signature 1156b75df99fd4ac4170ab157c11cb2df4e2a51ff244ce90624269a303ca25ee 26abeb8aa7ac77602ce3a1f20a360d4323dc2f8e8a4a1f724f6aeca5a0b130c4 28 9717f2cd42d77006900aa7367072ff3cf34376713831e98774a2095b5d94c1ad d4133416ecf439c544550cfc5b056d8d04ad811eceec6fe7818dd8a1228258b6 e6b92e5ffa48c0320f24f1f00a603d626933a9505f52f0b1140bd46c69e38ac4 a513f684b9adefa20d58211d36effafb5a5f6313ed0d3ccc910d2ebf167dbfb1 88e181511ccf04e185be0854c9c7ba6fb43b20beae4b82fac6eaf172a870b750 78adc822c26e1e2d717a074b78ce98226f2575e5db2c56220032916d8b93e426 daf9293694d9ae5dd143e667dd6c2c069536a1f5e666da84d36be345287d8922 8ad1eea19d46c7c17cba367b2cb50dae28a1bd41148398158554d741b6a45652 51c399372de807d8990d514138504aa24a066d8946cf094ecb47081e3c10f80c af54e68f6898b15989332e6bd91f5146f3976cb0fed8114acaad9608bc730c2d 79ce03b01c0dc4f257a9f49dc9ddc76c42dab109c1cb1dcc81a7befdb965f40d cdd9dc55a91a853c7d40e77e8d0304f5968c4d38033e8026b436f1710cfaf747 e9a048c7a95486876a9ddff5f3178e84f6fdb5b0c4b10ffe40fdfd14acf33316 08edecdf21ef4cbf3e2a4ed111951dc2d1f81731e6a0545d92c27a8dfbcfac0d 5dd9b2ecda3546b0468dd419c586420d22cf7b705ec8fac16f05233076631c69 eda2a5d1e26d3881c07574183f14c1b08fb01cdc5f393ecb9e243db17013a1b3 05d32b84d13454f3fa2dfd43ef126ab7a3c2b0ff8c56a137d15caae28f7a5866 d69d401e2dc000b7e8bc22731be86d8f9f0ee7c280bde8623b0bda5d30495d32 9cc22974d155e78d0ad514f77aeb402a117fbc8b8e704e686ec6e54c3b754ae8 86e44ed6dda7684b2584466ed17efd185d3e53ce8f46ba69a935c9ded49d4868 ce2cc8dfdc4f6e2ff04c372ec1dbe647c7b58a91e98579b9685e57fa45575cb2 645d271f98183226d233d9dd75e177619dd9546d6bb0885e460a00fd3c049640 43f14ad7f620fde181a8497f68ae5ad0451301a9c95cfeb578918ad40b99d8f7 30452c91184b04b5342329b15ae1f326eaa3674dc02a04c6e15ccb6d2359dade 02d002433955ef8510fba4c7be861caf79a40948d3e1b2305ae6268d7eecbc13 747ef7532232fc1fbf525b9b1b497ad9bcbdb277d7d05037a999557b7e1268b3 980d736a5c0ba71150c12b68af368c15b755b789416977c7731c368dc5ada5f2 9efec0c98805714e00f2b254233a45b9465964a7046f00b078c668e5d000a521 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 false +check_ring_signature bbccde968680defedd1a38e09239b01a28400747a33151c8af793fa26d9e49fc e56cf2894f0f963359a6eea781cb564a13f0fb5ace5c9a709c88a5f1fdf61905 29 6c3a1e98b66cda3b94123ee766a704cb061108b7fe3b5e1684f0d5e5355b8a82 7f7af7fcf67c0fc2e0eefd6bbb1c017a218a7eb44667dfbcc9becc838ccf2e10 52b1a946f3571c6d4866790062a12e400f51fe8acbdb9ec64b306160d713bf03 00f91d12d73515d1d773a49f3dd85bf27e74935b8745fe0e50b37337644ea3de 5102beeb52cad0627c5e5396ed740e24fe8d5a0d27c105d58b4b9f254f87d99c ceeff99a3ff66dae3db324893296724c34e593ccb83231588d5d9de16a62dd8e 682ed0febdce3c65e24da2bbe4972e3a9bbc683052b79155165cfdf9bcd10c66 c7594bbd4e607aeede309137966003f08698034502124f56928965218e5b3e5b d52b7ae361817ba351b32a331637d4e56422a53e8a5d02300f2bc21d52170327 4b9707c2db7c6764ec95ee09815ce19da0c9980efcb60a03cc69c05f286ebfcc f6313e7f55ea429b9263c91d69ab56c449b03666282ec633d613b90b051a3fe0 a757b95d7b64a784e15b06a3414d525a2c29ab532c5bf3af0e661defc3927651 6f305dffa9bfeb7eaaf1b6881a385e0dd24d3d5164ae8845e56cb299e9406f42 3cd50aa95ca7b00f2b917773d52e9dc72a8bdcc8f5d838e25c4f126705625f02 bccdf0224db3550a0e93041f5123aab17c9d54d36179732cc1728094455e9e46 fe99f6da8965dd7b2a5dff15f148d1444394711b76b97af69ab90b070459c388 f5ad15892a3ae4f2ddfe3566fba5646674aa13cb26ab97d6e1048bda83679c98 4b7d9550efe912fe700f396cac3ac095f0af00b2b128d307ba431cb16dde605b 41c802ccc33dca90859c743f0b6b80b363ea832e2a4077c1c3b8c18f45ec1805 2a48606542a30e291094cd0156d84ea5f1a73bd003ed3727782413df2f977a36 d6bad3fc8b9f3797f814603ac400c50632d88637c7d767b8c99a5a28276b7dcb 4065396dcde866b2b68fbcb9a4937a26160a960970b2912a259c5e0ea7727b4d cb5898b278930c5f1f2f3539aceaf5641c21de3a418b1cf5524d31adbfd78fc8 0280afa93331c63b9609e831a2514d1a95778d281f5e8bd4b5ec84f014ec0fa6 1d896267db20219e7443266c57ed011e62adf2ec8b6348489a94526e53b9ee7c 6cc442a6f99838cb432dfebdb8e9213d38d324a8b55c23955cb84fc00df95d57 9f7315c162439eb4a89389aea62b85c7ef4e3ba5ef6cb268f36f79240aa01475 31dfde1a5324f6031312c46e00e7d29aed00db9937374a0f11bb1082394c5985 ece31f1d0489d87331efb90a58a093bb6e15494403320a52c9a622b410e65cf9 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 false +check_ring_signature 8ab32a90447cc4a37bf016de7c2b496ee12cfa5d4ff74deb833e8fa8144e3ccc c5a057e865122b716c4f9697fedf3d5d4d67ef1cbf19acda12ff685c9dd85b88 1 81cd61615f31e4e0627331bf8e82f17f8352e2ae2d37072cf6e0a01c6f35d4af faf26518970b107a472020b9cdbab711ddbcd406fab010385faa3be0cb090e0c6a58e8578d7575c59badfcd02425ab6aac85221d52bf0b4cb88e71d11106150c false +check_ring_signature 79e8c22bac02d73d3ec2f316f16ddfdb818ecf3d4293106f5128f30f46414cc9 e6dbeed65e82c32e44237e0e3f723369675aa3b021a4ec0e2b943ab4fcbf15c8 1 c9df6753038e697e22dd8bcb6e6303342cf2170a3198c085316bbeefb05045bb 360d06daeff4c03d4c6d4c046e5e9dcf561c398b7e89bb3f466ed48a895afa07ff20406035884a68a6972259bdb1c31e69ceddbad5f76b6ea9a05da2cfbe07a5 false +check_ring_signature 7312bbb57b14e0575e3f45f074f9922f4eaea507914a46a96236c14ce2066e29 4e77c876b674f994e33b535ab5fc6937fa101a67070158e876538e846243016e 17 cd1ff7a0b99aa597f3fbd09ec6bb8fc5a2e7aa0bbe80e37b243d4bd31827f239 1365813ea00faca92b392f94d003c84a8e1adfef165ed94cbbe3a25ae5c7074b e05bfb18f1142b18d478fee3f64882800d0dac92081aa1c96cabc28f7f2abf6f 26015a34d7c459f6549673e23e2f66743fab72b81f2bf34e0c0610ae5cd5e649 ebf804dda844a1c2c43b552b16e56fe41711e378925edf33a173fdcde7e3d1f3 e5427bc500f7567d039eb09b1486bf8e6ea14dcfaf68290bf85fc589c3b515aa 29d2630416e8b836f83380c860e383e2498d5f2fc3c3d9e8d5f69e07d18af76b e62d99191501370e7d54f4b08ce7ef1f4d9ea19fa0e102fac2500af126d87145 4319a9305e1edbb90c30446134ce637b47ac68cacd921a96486afbb5ed70baee 045214c8d3b4c0162c5149fe029935f856dd89f1dba77c8618247ee945a8addb b8b273fac86f4ff05dca36726e7ef70804a2c4671186c25912561fe358362cf1 ba11fcb0f480874d8f4c39639423a5354ed543858e2fabc7f420365a4be99f1b cd898de668a1bd005c9aac9173c1fe5dd9b107587fa9c97b1cf728300bf63371 3c659dd10ec5aba9963fda964507c9f288141465262e7e91b621d94ee685a4e0 48d4273b9a08d5ff9e755b4dc5a38225bda570ab7e41fb2315fcfdfc1ac791ea 39e5ce532fda90ecf644ef912601249d250c763defd7c71babd06fcf56ca1d5d 2039a513bfafaed4812e2af0bf8a1b68922127303ff8af8d3c2694c425cb9f31 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 false +check_ring_signature 03c335cd40f3f01ee9f5d52837b97a6a2d035a71ceff74db426584c385910433 d374c9a8d3ceac52c743650c4970c6111d112d5fa2deb9bdc7712e80b77a5865 4 cfbfca2d8461e60a2288860695db810695e19588a5a62f98b4cb580e78324286 074ace7f5432b2aaaefc42e55c44a4d38503678c839b354d8bff4eba3790696a 3a5b1933b1d0a638faf4b2a57fce389dab79dfc9223946b75bc2aa9e6b8fb16a ca23be8c75c67b91b29cbc289ccc25bddf19fe69b3fbdd3aeb7c5d65258485e1 523e0e0d6cf6895443910d753ec5e7b6962ec582393aa6334677956fd3e59a08500d6f9c9425c2c9c44b2087baf781a13df016bd1e7bfcd51a91148f3b59f10bbbe242659ece4355a3c71195a5c663a7a3d2ca17ff9375ed9f045d15fd1f7f0093221a6ec5f73fd42cc3aeada210c9ab045874fde07ba56f221819a9a279760c7d08ea8148f0fa6e92715d4dc15bb886c52ad4f42ca5ad13c9e52dfa7113150ed9db3b58e3a286c519f3d401c223dbd28b7a17bb1e9cc7a3ebc5da0497ed9d0647685c758d72c159e0ab8ed4f0728061c62c11644ea78fb141369102d43e66097229081360ced1adec54a3651d7b17fa8afccb4fcde8a2bfa4d6da4cf318fc02 false +check_ring_signature db4a0f96a2359f3ceae83ff0b5ccd8cd9097ce88d500e711da71ac438b397a3a 0a8d9347257599e365c73cc27fea8d206c62f27257a5caf31a01d2f76dc7cbe0 2 1457bb22ab84c4d827c39ebe80e5716257687d06d4606b03eecb7033d678bd51 84810725a97fb349f82669b5fcd55d3873f481295c210c1bee7e73feedc96c72 677b6e0f359dc37f43401ad49cc480d3c7b8276066d830e05e640800ece4e30f57203761e0ea1bf99a0b3b3aeaf378eb3618423d556ad36edab4c129a719030bc62cbfda9749518bb908fb525e11818ef760176cded200c08108efbe2595f0075e8f7d5e0d261411997ed435c046a0edf81fdde9510095f945122e06f4e3b90e false +check_ring_signature 9bf10f9126cbed6daedbf2295e13a753c4e3074bcc08fe29ff1b1e048254e1fc 6a64ca0b38418e1b46f3c3ea34a6600d0ff39db88359cbaa2784bb0c3cac03a7 1 3a0c366c6a5cdab282bccc028766df2c8f5d6363c3936c2f434dd8986fe1370a 50d934983b99cc10bae18ab53d2b3232b9cb9f46adf567853a2ddfb920d279053cfe2d8a260737fccb8b7240e41331a459921dcbfa4a95ae718cf0a7a724e102 true +check_ring_signature 6f35614f772a40a61a2cda4d352549a403f2f0db107a3522918e7aa39e649b00 f373b134b898be7f9c74b127ebdd2ea9dda553cb2b61f8c8511c5529ad26d333 4 b2b3a03c417c4dc514a246c950ec9fe7cf744ae77180a0f4de74a6909cf9bf8d a5c71f3b6b1f509d615ca44943d59bd2d39db6aad67da5f9e9b5ef0a6bcc79b9 3106109ce483792c58f577e85f69f690ab310970cce89bb49e8e677a0da07d4d 69ad71bf7237ba32907d38431d72bf93a12040e56361e2ac3b266efb2dcdfa11 d48c8a32893c3809a39dfc12f52bc36ae79d431ac30467df4bb5d024c2a0f2044cbeae25174092b5027183f336c9a097dc13b0305d867a7daa15a2d0e5925c088361ccc42471db0a0beec5f1e63672d28279ea87c762d6ad854a18187d9bc00496b8caae63eeaa103d0e2f1f21c885ac128f2564bf47d4723ba9d5b7a3aacc04a286615172bd4075a45458b970c49037d665f0097161ef83fcfe2149701dbd050f5ad8cc0721f61e70853345eedf7e51d67b814ba8d41cbbbbf425a0a0570001ed78a832d416d034641431d4c391d3c4ce1b4d6e0dcebbf0169cfab7520fb00d5ea5c255df525b52d7437c8328b62dda47f3178771259ddf1f4e6ab484eee00e false +check_ring_signature 5d60a5000c53ab9194b018b7f90b02c04f6425d4efcc430297e3bf721267c7a7 3a832001fa0e0e587f1de65a0415a708dca22d9eb9cd74f4c4817275dbaf2dbd 1 bfceedbeda871939c014dda66989eb5180f7bd3c0cce3a078d0242e2ac579a65 b82e5fb7644cb97b05494e5c03db1e7d2584b5426cc6ceca76cd0c867a55ac079495d9bbc11562486d4a595e2f86ba234d4229af66f169bf375a896d91131103 true +check_ring_signature 6b53b70801555bb0b8da7b6689030cab4d0b02f1e8ae94bd595b6afe3f83d858 b32f3f6e77da382d2a41aaaa37a27a478b37cf9a6eb0b920d9160ef3b4e13ee0 4 13798cf4142ac1fb7edf0d8840ff9f3b78a66f28d1cbe6e39ff02c320fe12f3b 49b0b60715cc939d875573842b86e39fa5a517b02d49bad650a7860fd046d59b 9eb7f33a19112fd2dbffc5a9b6c7ba27f18a832eebc4feab1d5013ce9fd143c8 7d9e3457cb8eca2040e62254d15d9783f79da56b6c3c959f4bfb6f93acbe5442 5082fc3e1f43df60b37bd54848ffdb202e9a50381f4ad1fc14ab4589b11d140bc90362d4bfd8c69a87eeed249005e42574c3062e8751f936ce0165b0c8897e025376613b4abfae77d8aa8336cc77e3ac0885bd9a8a79fb08a20a766183b23106161ec8b53f42a8d5ba0588e18be29a5914fc853e2187b6edcad2dfdc194dfd0c89917eb98eeb4956a4a8999a6755fb97cc5d009464d47a876dd8779564c3630c1ba19a2738296fec90a812110af1edfd319040a804f0296c709b47aaa498e400c3e1338431efcafd9cfc192509a296cc301244a732d7ec595d622948900a6e099e6f28e3d5ed6cb0d5f5a5979d27a00dfd774702035482850fb42b8d67f3410c false +check_ring_signature b99fef68da0aa182b938d7719a0b02bec0b02fe1a0b7da2c81782d842ed1d5b2 ed93e28f23b17f4bf08fb85747d2d6fd31be103fe0d1b9329ad497d83eef0822 11 f7b1c556c0b04cc83f7d9c820dea9b18bef29b941c970355f50279d6805e4cce c7487356162db734a4af342baf99edf0ddff27d628f49df90a8ce34b9d6a6a73 d587a056b91c5df38f3bfbe1f9c0795c2508ac01b743efd0f268888d6b933c94 4b43a886083d34f849b35e27da0aeb4696d3ed52e97fedbf3f5710c5d70e0792 8e243ac9ed7d0bcdf276b103927f9504ca9ef69ec54ea70f60a0f6b1f759a0e7 8f87c43d67de6f77f02ce3cab0485fc7c8bb6a1b7160e372593c29934345e239 ea31632976168c0a5bf679cdb4b1810c740bf4f8985a49635f1d78cf6df64553 f8577933f10dd5f0457a52984d6ea7cef9a6962f2142425e77c42c9c741f0c3f 2626b9dde8d92b6118f4498339bb7fb611abb93dd0e4a931c620f5725317bd71 663c76d6788f85d26b4c6e42eac2c92d833b5f24a508daea38943f99825a7dfd 2d57e4ecd39bebd20e9d2bdd6a142eed54f19c472943da665f06478935716d8b 363b5e99948f01a42637b9b9aa145fa972dac3913ecc54341ec9b999b8419f0fe16bf1d1a7acfb6cb0a5c66ea6df67c55be7500fa847e19f1239e25491ecbf0763cdbcb8926eae3271a983c20e263a8a7b452801bf13031c8371b94f6e477d9589f8fc10bd0d589c3122288c4ba89f3904fc9ae94c26308d292dc1c36c24b50cef42c521818a7642a335bb21672e867ef7a5d24f79e748226e95d0f8087b4b07ef6f310c3952a32643d9a28664a4d2ada3f03fd858aa753e9476019cd4c4ce007435e609e9218f2866531dcd4f7f15ac049ca3ed4edc0c482529f79d93cfb0021b20a756e33b0ac1de7eeade591894241df91335bf5e514955206b279495c703ee53f0c6c8def78ea4f2fede3eafc24f210fd823936b512f7424256b1bcec60b584811335543f04db89c8ea6cef4c8ee26a377341bd6cb3c8706c1b6235a59080f53edbe1adac641853aab4d91338a18e17acd9f3961de51eafa340f9a18fd091a76aee31e8f5153ee925183722a6a960366ec1d964d8c66d4fe559b21b68802e56e71bb390b3e9ce157eb22364fbbd7a44e128420819d128c86f25c92cb7f05c754cd8d96c86f27627c201c15e3250f3120ff4835dbd54af191cd82be82f80f6fc32d3a6021ca3d05f33a705cc2659d5b5aa50fcc1636243b5466af3b183d06f1e0654d01d0fcc6f7917872fdebb2068af6c1266d4fe3e5ad297efd21687f083dae1a4079db7b648b31efd59656aecd960c60adfe5337aed8d761a52710450901037069f05caff680cc3c4bd674ba163dee57c27b55b663be721d6ab7c4a75a2a74252cba857e44f37e28be23b2631bb8410a7e708540600385877bbe0cfa05188c5242b4b11fa6b9b5bc4dcb02e0fa63a11b3c88dcd5f9eb331481f77199517438b878a5eb94eca1ee18726efda59756e2d9e336fc8704a3213286dc54d80cee22b1e23cb22afbd710259b562d456417941a5abcc5febc9978dbaabadd2a03 false +check_ring_signature 4aec06172eee22edd6cebf13875433afca3184b8f038efac6541a6d9228d1d12 edb7ee3ed2e3b949ec92fdffe0ad1fd7d2a01104e092710c8863aa1bbe53ebef 1 8d0a8e24eeab26b6772db88d67bea3a3d0b624a41e3639c9a0edf1ebeb6b8bdc d470837dc519be3879db286b906d13d22b9068ccd67c64a472778bc0d06d030eff5e1e3429f37f3f1bf1c341c16cece63237e0e7882e74d5f8544dd511721002 false +check_ring_signature 8ed9da44d94cf0c52f8a4ba4cfd16da7115f080a14e3284284b0e58f7b262f09 c6846557c0918d28161c456bea1a748c8ebe809860fa8dc4ae7d277eb575dd38 25 cb4adf5d744930469ced223e7fff5213acaa5f2928b6997d723f84b900094c4b f19347ed5e8cae62ff112df41bb118ed21a0b772cdce31cd5390260b4ec49cc9 3dde300c1ce11643f13a600e0748f133658a9afd9327c4002655e5fc8535a017 d21c9727ab84ec8b12274dd0efda5ef3c33dbc851d499324cad547edbc93dbca c992c25ae570d8b3ba89fbdef5b8d4c6d33f24257f14a9eb8205a04ec3b0c2dd f739e62b4df00409e3275d4da086a22ec6e4bfcedaec89a748013c8c68f721f4 a09d23b98e6382c2def107863ab731ab4f25fd6add8ad072c815c26d330430c1 3affcd4c25ee4e06ec0851ba42e7073c087bf5f5ee93fa38e37d7898db47c402 ab9b4a3913ab4efa8c2670b5c76d913e04fdf68c804add58c54615bb165461ec 235b151e47b211dbbed4e706c03124a59e4c8ec5d5457ce63abb25b33cbd4d9f f2d8d0bdeedadcb436aafc39bceb308307eeba41cd1a4097323aef0b532d378c 6de970da09b4499fd861ebd07023e17ba519045428759cfa6804b1a1e5b3f4be 01aa9a6f8023f2e87e7f88ebb7a0acfea6916797613f7ac39a348b3ab181f7d8 1f58e06c625e3562441e33d8086eabcde7a7d38f71946b3a89ef98dc2ca62bfb fccfa6cbac626142faf939ce5bc9c230c401254451ad4b17abe721adf9cb0d4c dcf8315b93fe2edae6fea6b017f040039491c08318304e5216ffbfa37b69d33b 7ff7849ef67cea2171702c58f4bd3a758e0fd3920d6a9546ddd2588632a1cc60 2d2ff4592be837bf6452c33aedf7339df5fbbecc1884fe95428d9e3489f5d332 3c8a14c06546f75662519f7e5ad565a4c214900f56ec68807ea5da161d129628 97f39ce6e909f35261e00b033d144595332e2416ef2965d7be459a4be3b58ca1 40bcaf1ed57e8479f950c5686ca2fe562fbc896cba4b7798134bb345c061bdaf 5c955d764ad5bc5c68670c7dd11ab98b4f8270b98a80230ca89c55c8a4c5ddfa 183ac859023ef8fe3c290217eff14c11183d8d87561d3ae730160e0dae6317dd 5df3e896aeffc4bd88d2870ec096823c0bcd8b2486d94c1ffdea135883ba51f7 18d4710cf4edc28dd0b362ce859ac12804c21c4412562d51608f61a649b8356e 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 false +check_ring_signature d52f8d8772eaa8b4daec5506511bbbdb35bc49cd263a54a05d6c98d1d5ece913 20b1b3e3380a9adf5208655595cbb4c632412d48e79bde5ff982a3fd8682e522 1 c3b5cfbebfd83e85136ecd21690bc57e19cc93ff6383c3a35318b7d20c15323d bee5fe6e8b92918d6fcd86c526a5e9651c403c0a89bc07919c897d2e5b59780da548d2103e33f89ccf0a3c100eafb2e788e1c2d69fe00d5b84ebd67a28b4f50a true +check_ring_signature 9c5f45dca925ad73c1c2fcdc69f96d4ebfa4139d744b4760a5b652cef036a5b8 6bcbb97a072956dc87ccd860f2d5130b00160976532c640e8ec3ff2a8e4c7c73 7 cb0a62143a2c9fdcef1c1c0d4ab4be7b642f7b7395abdf2f77f0211df4995e5d 01fd170d9005c990dfffb230a2c4b41d5fcb0f5500487790ede9f02e45149ecc 53d26b5206ed8d61d12036e7eae508d6fd28fc7bd14c2395767b9b6d58b564ae 709b82fbe2c13d281b817f34855547c0a2097225dd2ad41e5a26aaf5fe0d78e0 1d79c221451514debbe0952ad1bdc57a6629c962575725bd885dbf887aaaaa3f c6e50ceb7df4193d57e5f9362f57510a8617e7cfa8e89c19c4487828e0828af7 afeb621e79c2846f5a33cb466040a40b7466d477320fe70d99d6bf934b117381 c13685da54da6b88a4302950154a4a048ee5c7a3f4fc0b2c7b5dbdf16e8a6904767bff0f8f0ddf90a3fc9d82af7f49785e20a49b51f7eae35ed2b73d94820c0a7014219da8bfbd4993d52f2135c53860e18974d35e4a4bd98e0cdfffd431a9053baf3670fd2d57ce81b260c937d6f6eef9e6e9413fab257b0fb87ed95fafe70550e1c01f2cb52023553a7fca8a52b3c7398911184bcd37750a7ce7ff22e2720c34c5da76b32ba7d811e9991873f16dbf3393020b7195af306bb0067080971a01b707b06a3cdd1b89c5f2ad0e6913e7fe28fdb144b1229bd69527a64bee72e4099cc9e66872c326f1b3714f377f5a971d7896c982d868c48a227cae89095bb70c28a43ad7bb442160aefa361b2b291ed5ad4e0367b1818faa28c6e02b744d136e6f99613027fc37df66783e23eefef1ff9430cc16f25c918257754cb8447f5e0195f3af4943ec08d22036b495a5db7e44210f9661071f59afb0a633c9d18be96ebb79306b144fb930b2ed58e1c6980f27bbcad10a571dc128270dc8158b61cd0c5f98a6d6a266782a59ba945c5a159294f76ec17ec8d7efb672775f902cdf1e06f4d243b0dc1db7ce7204223c5df1fed7020951d879daf43e87195b5545aa8b0b false +check_ring_signature f0818b26c587e033beb3d9142c4f7077626973b19c11eb31e9cd6b7dd2b03ae2 be4fa0cdc45eca12d703ade7c2a8cf9e8000dd7cec54877f54f7baeb28da24f3 8 783a9c452f8160b7a8bdf7aa9f532313b3682d9c14283d3ed50c1b27e56e33ff f87d0ffcc5efae82c56a3387bb78260c7db099bb7cae81f32d85ced9da5bc8c0 7aadff2b5e5a3dc9958a40ee876690353344d6ea8cd953f7dcfe426bd38bfc00 b8a01a73d4e28d6434b5e92be61801f59193c077dcbaefee79d5883738d34d28 c8870df21fd49948f70e1dcce3952f60ce7221935cfb6b79f8f252e28d6ec1ed 25d9988f684455a3d7bbcf3f62637a9365b072b2b17ab99b4ea6d57950cdb07b 0764980a39c4ea9658e8f31d78a332914b7753fa249179843c8c220772e8ac24 7db988bcd217c16f72c509aa8ad9180e5f36961e8c3ee90b3b596ce1a6a099f9 d6ba0d6b129e819450411947203054322c2aae57049aa130771289fe22af9205491efd73be9860026bf231639273f2357499a4fc95ebfa42c9d93fdb9e3b529beba0da16578e49060c7dea0a8fa23d7c42cb25c6ef7c577f29c2a6eb049c850035e45d98186e49ab06016afee60e5a3d9c9ed8c2ed30de4349a24e9d7284a1024342cb3f18caf70f293258ccc3d86072e04c4a91ff83908a4790f5df3b564804b97a7ae0a1371286822bae46a34b6f1b934e3f738cb4e214048961ca4f589d091dfe0dba5422a6540f03f060f133190844c82aecfd365f890d9e9451101be30090f009f8dd4e55acd202ff750ed8258ec4440cf1b5299c07605ebce292754f0d4a6eb984c7df3d08a423657f8296c43e56c24fcd4624a8b2786245d7a682a9016684ec5bf5307e4f0532654ecfc3ae80926fe05cf452c1bf4869e8d96f0ccaf41ce534f2afc9500bfe5e2fe294344ef8cb00d5661891f9509f9f25c7a644830760830ffb33c320f2e5c7ac2f577682b4fe45a7894234d54597ad845e84112a0c1cb931e3717eeaf4ce78cc2ee945a55453561f7511c53c8bf203bb5abe86420a177976738f4ac80eef48aaa284d0caf8478b7430a7b7ebb6fecea9d8dca2070726be50c55d009fe7da125aadee69a0f9aa5829bfdbf01ce34a77fc6a7b13350bad95bdc90911b378991292e2ffdb3fef6001123edc1c4a53c6179f96f2bd8b0b false +check_ring_signature 7c7cc1cec69d0952b0d7bd1047b5b5f07451620cbd7ac42c5948e124af8f848c db9a7e3278128b2907bbd68444e8b56ca3da61a782c63b83547d7f3e693c5f3b 72 c6c8923bd0b67c5ed79b6b658327dfcba579cb6a567d40f21d5bf164a91a1046 19dc45e178aa70b4a5b6ecf5dbfb76671cc09f202235a8625873f37835840763 a61d82a5ea3b45760e5a042455a32341d3b3f05d8087548ea703b881762cad80 d5f64bb5ad26ac91c13c24900ab8dec0065dce6f41501e45a113b4f2f2302207 94587506e42b5396789d9f5c765d7e46009a7ce7d8920d3d3d2fcf3aa979e95d 0f472688511c3d5930396881fbe73ef432f9870ca8c5d4302c6b5bd6722be6d3 aa44c9d7a57472af16d487821afed31270ccad07574e14318b69d0a1fa11bb29 34746a4f8711db1be5710c0a143292d7f224a49c78d523319695ee0d8e697a86 0e8dd73d28eed6aa3879c28388fa7a96574ac5d7aeb05bb360f8e8e836da2428 3950cf6d2588b3c21829e06427ea97b25f8d4fe595e248f5f8f8292812671ad8 261b1fe65bf4302bd915d0dc4cfdb4ea71eeac0b670bf21d920054528673e7fa c34d7a26c2c6350651b665df1734619eb9f8af4577fb61f7f75fc022f75b3fc9 642dad95850edcc50a6e731f54494340b6d340d727af7b4b088eb30662d5f73f f55af920f3b87b91eb0bb5ebfa4f9418a5dfb50d99d85ec3c414ef33bace7382 53e933ed4341a2bd750686537eb716857b5efc957c1d17333c8ac01c65df037d af74afa51541aa02afcee9fe3d5de2aefaa9953a04e2a3772f1b6a78df7a1c9f a5f6b158ac72b38f725b1b094c274574a8070f525e54d641ce915e9e0e26a425 41f6bdec3d4849eafd97739b4ae2706a2044df48e328b3dba7d7252f64693c49 91cc8b2516bdb9adedc30104b03b034611daaa712e15bf0d707b2e483c4619f9 6a1f5155c474e19bf083ed3b619b2037b1401bc91eb76a40a7c85f9db53193e3 b2abc92439b9aa123cf1ddff9d2b85bdadf140f04d775140237ad7d9a74df599 40dd66f9d7eca9b19700874d735736b63d8414bbdeed5a1b1b2ad764be947a7b 8b4f379bc71e1527c0c90871d7d4fb438bd841fa6bfc0794a42a2a8aca25c55a 7a68b2e01a8c1d9617a00ca46442721cb02bcfebab5035f9f3de0a073eaeaea0 8e1957ecf4a93637aded8bde672824608da8b21b54e8793d51b0e558720c78ae 28a633ea017d915b3f9261cdfbde2ec0ef7cc2c9ff457a082b5e2c847fa23bf1 0fdbd40b1d1b26653917a1c4d362e3e28a584a04d54869b66eb8cf0b28052529 f9ec01a2830c675e64e6d0f0136d92800d0f4bab5c0da5f3edc27b4cd9073665 c5461db05236cc985b8918971fa02e4c8380cfa290c5e493caa1bd14bf5a0791 fc2e0b72908437528918e676b6b113fcdaf71625bd82b3da2fe092ec7556ce95 a85c99ed0950c165fdb5c6f4fe614a2622112e3d04fcf47edf35ee24085a79db 5a89ce615e7162f4a946c3f122de49d3a464ef0aa33e352d13e634ab4f5b54c9 6145dd206512c091820ea144af0e5f7fc387ad7e85b06cbd5edc5bb05cc61c92 c3e5ec8e248f72bf964421860d9a61d9e40c1445b7f1bb667a45e0b68aa25d1b e6d79e7c79c352aac08756c73e5fb08e261e05b1eb47c4e8c7c12133ba074b23 3c52e39c2674794d39cfa5c60bc96b3536b8eb1d71a927b84ce67b8221dfea97 4bf556ed08393b0b32322494f522183ce498d7076427be06605b155432f8ecf3 5d293d673bd1b769c0631f8104e3f8255251a8d75fb1fa5f14a21bd3354d6ed8 8b4f2aea800f896f1853e497a593060d572e9467299019f6d3b751ab05ab4a7c f66ccaa3bf183895805bf6a5c61d239a2724ea9e670f717b4ea0a3a4b275b498 eeb023753455ba11424e08a05d8382f27b74fa21cb6cd88a08002ee379dff08b 5a58a130b9f9c6be64996269b89eeccee83acf3620b085621b8cc7ccaf8e4cce b429441a8bc0ff1929e711ecfa5d37323469826385405c72f2ff656c8f215b80 43f622e81691f56dd6d4099ce6bb890ee2bcfe0ef42946694ea57019e81736fd b8ce003b781d04a2dc998e30776d6ae4dfc8a3c6946f22d3eda52dbe41874c60 88212bab9ded363d1939d7c29ed81750a0d069f62d1fa4f509583ea2e4225598 113dc9149ef1e28bcc3a30972d1be033cb6da15bab06e1d07b921a84693a5847 d9e2680bde0ae1c99583771a21f377b6f01b29d9543a2f82a10346cf9928eef2 eb040119cbba9fccb0154d8d5f5ef187b7e6e357fbba61290b85c9135c37c6bc 7614b35bc7f9872593d9e610587da82a4a921dfada297c565a641f3a6f73deab e872bc4934a1f816a4c88714f2e3515d82819d6395e720799e7b0f8ae1269184 533f3adc5a866dfb52901a9c0bb7b38f87b48d3b71ffc8ef407448ee9f99b7b4 4d1fa07d1a791aa9a6309bc810d9873add2ec6718b842badbb30f30c5842acc8 0261478f479afd7ab55bdc29a996f12131dbd9ced4358ce00d784c314ddfe679 992b917d12579099c8aa80b7751d61f5a3f5d90eff11a441a502a32deaacfe74 10cbeb715421ff98ec2180cea68bf95811221a8dfffa5e9a99da16d8d242b5b1 221c3713c7f9326288822ad2bff837b89170632454d67f3eb8b90b700871ca84 abc04212d7d1975a651496a7dbe8509970ca15fde7031744e5cd2bba6eade540 0ae99a74fc051ec18e20b580cdf8d9333dc5080e5df07fbe0ea0d658d75bd6a4 e2a7ef8e626680c9ce2cf6789097570f0546fcf8cb6cd0f8c19e2300691b455a 76318f168052ebe25c061791f7d0ae09a31885dd35bc56c19484ac3c3be29795 1572b656ca6cd0340f2f81df7755ea12b81945c77cd301334e6dee6736185d9b ac072066e889fa47dd884dcf061aa20e11076e1c5a489fef6c9462d4ec8e044c 3689ebccc5d64ff54771d3881c1d708031980beeb865b153c40debf16ce24944 ae65fb67f073dd23ec9263bfc2fa8212371f5a486c8e80eb949d0dd49c6b64ab 1c2c2f224533efc51701cbdd991d56387da658399dcd225210cb88c33ae6a4c1 46f68a06998ac773c7ea23d2de3155c1a77dbead1f49261cd1b18866ca7d8100 304b7436dfadb22f4cdf4a2fc62ebb006c5d84945c3fb5ab7a55e381325a8506 9ca5daf4626e18fb83d3f61b7c191637203e21c602478c3510c3ab3d0f76fca1 7aff21674e2b22bcfb6de4ff3a6052fe7bb6d95666b2a8bae8629dade3d0175b e060fce3f1a5ffe49538a1b09dca4df06517f53f06b5676b9d62cbbc95ea51c6 8f03aacb2be2efe0cecf7524963a0255d57117dc8bbd3cf6fd2f171138c8be32 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 false +check_ring_signature f54c74a1b290d237a96d3e1a1b2ef03459700152786588d74e4ee0abf4918f52 094d30b9d3c751020ba36844e893fa9aba008ce28e51b371b73fa64e2905f5e1 126 5769b5fffd6551633318a4fb918d5aab6d281288286186eb80c9ecdfb05b7784 6d853b4ee0249c02645d0aad0e6e90e2493dbf2375c04b7e73a9811c10c00792 0fb98170e0d9cdabc2b62a5e737bc7cb2b235ec88102c55b7c71cf3ec2f28d90 49b86a784130338aa20a624f127512147ce9c767269f84f9f232a5970bf47e15 45ce203041b0124accca4a5eddcea2871105570f2c02ba087be8870a77bdabc8 3e51f9bd7ec2cdce795a130c63a76ae8ff6e3263e4fbce5ee4c9fe0ad80a3161 14910797a28104b8dce365f5e557a737d05310dc9e9f9040953746898e229e4c 517d16ce210ccbc14666a2169063a4c450dccfa8474a8cb505463a92c6ef07ea 88e45917d7c6b8f25941236bded31296045c7f24bb3eb1d2fb3f9b537f45986d e0af619a0967c5c279fb5147dff26e49c0361c1fa3a321dd4429974870850bd9 803d3bcb732bfb3195ff1c40247b877e90554a4c09bd2e759f537875c4033e75 3c64eb0d86185d12ce9db45f0e12696b1bd5aac80880b2c66eb0ec5961596499 e965a6015280b51041744252d9275abdd07dcde83813286a18c871a11069392d 552e5a473c459329377f894207a2eb316ae9f78604eee2b946ea5f64937ca416 3df1e8646a575b02503d8dd028e8a3be36235242552bcd7f69b934203020365c aed65afbb9cb32ae61a0aab0399c5469d5fa2c1f901cd33425052bc3cbf95f84 216ce093e405ae119c49a527205a64438e7a2c8bbb74525be4cf845d7851e705 7947b535d40fe3a0e1405f8ce2571618f8d857d69d79d6d4eb618b992f749ed5 79dc34e3909b966c0f6096914722a3943b8b8f5f6dc753f441f441c339ff5b17 36c0b7b41a808b876d95fb67eefed9368b7450abb577f1576e577391e41f5193 096c59672058d80658740b0ef1d9df3938d902b2306a31585f9b4729f8bb1550 3a751930bd7812666e31460d6221970e6d492a9aedc33e168784a9375e554d87 2e56a99957890b44ea3d845fe0830eec6161f7a8c56e6eee27e79a109455a91c 85b8fc7c0260f3726c8ae0bd90125f4d123d8aca6a3973adbaf68159d8f3e3cb 7f9ff848d788312eab291b8237899a035025149227c48bae984db75124e78bfb 9f966710a62788e90f4665ffd7503f61680c4e3e7979210096105b850b21bfb8 fe7f1b171f76b0054685cab0659968267a3ed7ebfbde16f629a051fac044c113 0193a84984559ca018b6d8bba29b44837282e90c6b4a590a31d9a6b44cba4ca4 9231d70dfb7a63cea0e7ea4efd3066d7cafd04d07f81f012cf3085aebf65f190 97ddeac0192d7283230f98471e81ce248b0d520787f150f4fe09b5bdfc936bdc 824d137f48591eaf3dce28d49706f3dc557c520dac1cf6d09c8f294f123d63e1 3a3516b776c7c1ea22fd6069e95bf485bdb4ced3103c446ed527ed954e669f17 faddffabaa1d5343c594662141d14bb990d75a31cc7be55c8a74c03061851c5a 12dacf412800bfe8bd68e738222d5f895c73f6a5f035f6115a9916368516962b 4f0015dd0dd0127d7ff0abc3390f9ac275cbb351d54a487ab58812e08f8c168f 74183e47218ec6839a82522c4b1916f9dc01697418056158553ca0ed65c172be abb9d06682094027813e093b59400807e266cde47f96a485633a71245c8705dd b72d3a3950f08b0bf29c9d91fee65c8f4264f0fd70a61903fa620e400f76412f c90da1d7ded1c5e6b748f2b27776da5d9d49bdbce32fdec81571de1126637692 0ad4461c5b310f56b7fe9a5eea062462b89c7e8666d09c14145276d7a682bb3f 2cd1982dbbad36c9ca254f52c925873396079622b29f583647799a89932a8e61 c5bc56e732b7637b7b9c36d405405a6271eaa7c9a0e8eba4820e2b87e0bde3bb b8ffa781552f2afa4db5e090ac41107d06ff0c8eeec34d968b2d99dece884e13 64e8e315d7b5b4dcd525dfbb320a1b38688c8bcf188a587d04f8ef18f89f8f84 f7bcbec4acb7e22856efb1ae71bd4819942c72dc43bc87cda1eed3aee9d141e8 cf29942ef2923cd99ce64a6c1c1a046692fbcc59a8c80654ace885a997ee772d e095af7ea8c1171684cd55782b9c9c4978de07a897faf31d0b36bf4f94e0e4b6 0a708bdb344aa4bb956c31a0a4157e3dd6c56506e1f851c2ede1945c2b9fe827 640d3f91fcac0f693d9c4d7c887aa80f5edf7d26e4840d39050373f0f0f11403 00a51c09ed8625bef53cb19e2eaa02a9941d5ffb27a043e25cea959569e5f2ff c45f5f357aa1df0fb4a74c4ee853357b8263f17e0bf06913d213e23e174ac401 c09b32c82666528018a1f0739c59819ef7654fca55ca521c1e7e374b4bb7977e 72c46974712caa69c3dda10e747fb0830f822d7be2457fe8da330bd78f984a57 1187ec9fe284424426fc7795ce1adf8f65a148ed744fc03648a01194abe3a0b4 1592710a21e831965c96d94f20f457ab75c12c8015a7e41df298132821aec935 ae8b29c92ff80416d1c4cac01c3dee5e116e439c33f9b6136cd592cdf26ea2c7 ba5376b3ee253983ca358566c209d0d2eca4d30cb6588d6bd036cd72512ee24e efc22f64986084115f90b37cbcdd3126babb921fb4c3e555b9535307b45c6395 327e04534a4b70a2e51d290c02e5e2fe5ce6b586dfcf811dd7ada4b2634c7c44 43b61af2f0368c174f790916de6e6660790544d324b9dcb4dd89fa455ac9290c 5cb68429ddd7c39f666d792f547a8c89caec4a8050333af36289cc52adf45ef5 7f9280fddbd04b4be1d8e838737e3b1ffd63db49ec72a0b5728d63b0875a25fb 0523c68a6e203eb84ddb0b795877cc35fddea756bb8340fcb62133990ac48409 2db939e93ba67085c26ff3ad67fbdead69395619001182b8eac8d21285f9ff22 695b7cd1124bdd03dd39249c96554a9e5b409dd10cea6a7504e842bebf752e42 eeb81ea3b7f1f2ad83acba8d770eedf000a4fa80987b9ebc5842f862897a5dfc db5c93d8f04141b1543f8adf2e3f3645a6298cb4f1e4450a95fafdfa2cdb2fa8 9a2fed37260f704e5a4981e5e4b430b1d53a2f5c448c847700c8c7528c02c7b3 7c71d944702ed31c8b0534e893e64baf6174b482c896bd704208076ccad033fe 18788212ccc7cce95cc1b6ccc616af9c3623da2920682c6b2cefa8140136716c 5e34b12e624a41451e9aff2847850ef0995f7385e4dabf5f4cea6e2f088f90c0 25381c2db026c0d2e388833619e3012b4196e2dc3d7321931919b047d44af7dd 317725845ecef0b20f100d37469fac5fd301eedbf4070b2a828fcaaeb2791a51 c0521e6193df91764cb3fa659acc34c18c1140fee6d8ed242e3de54d55e80836 de917a054122d75036b935bef5a365d2fa5d4a724dd6ea1d9eeb57b6d8be9d71 961e6459560affad3bdfa35cc24ceefbe475e62f5f837698e3824f223888c332 4ff41120c6a03f59daf612421a66317057c15f9b2599da3261c4f4a42c53edd1 9ee764c35a5eaeb4861672cdd7874ed7ca1b8fa9606ad8676b7aac374cd7a2e0 2ed2a7e0a5aaa9278674796f007ff1c30ac57b17582b97a3394dffc466670725 577e59d003ab5c21d26f4c85e54f0cc64cbecd21a7a48d2df6f95eedbbbd16f4 6b4c69b2a3cabd6d896de2375a6f0e0e952e3cf1f6bd0172f742e64321e5c0de e276b466a8fb44daac7027aacabd065334a6360a43e3eca45a69968efe18ffd4 1bf260d638f2bb19308a8ed4a7e85df7b48eb937451067448d784dc573251618 8afe7b7856057dbc4b201e9eecde616617f1c8207a36985013712f082642ed22 88cc5534ddd7a58bf2770067f788f44771f6552f27824b12d94189a314b5fb98 29f958909ae2d5607b37b6cbce2a7e93477d27b1f51c11327034e2a416ae57d9 355eab89b3e5e525dd2fa48e6b95eea735063e665cb773ad352884fd269017a8 ee7281639e6c372db2b818d11be887c3558c29d3028531be9cc9ea736ceff2a4 de7eaf374e8198bac046e6b3dc3e54601b8047fc29878b57f694d3692346676e 5fec45641c2d2cf36c72b0ab4294f3c16de029062dcf37441d81348dd586a2ba 3eb7cb81c9d72b10c4f6dd070e5070f0d3a364f6367433197b67cd9d4bd3e1e3 72e59b96f3e5598bbe67a6ef5b70860e613f08e70bc29c1b2ca7cdf1fc49b6b2 4ea7a8ea454f0a8614e94baefb9438ef4e770ef020029349e57e48571dbb28a7 c7f24d87ff5f70bed9663a2a069c41c9c5d137d883c50704c6751d8311acb02e 765dece2716c33c4fa80fe2467f2299baa1620e6d0a187517fe0c2a5f46750b7 1899305d0cd7503ceedc309506be46d35b7507994fb50acf7870229c0c435c94 580d5177d0847dd6ec0a6126005d7299e00fc7467616c6090bf1c21aa8755378 326d44a6ced9d9bb2239eacd6169b2556ea0eda0ddf676812f23b91ea6abccb0 fcd9afc8a4c73c140d466043961ca16a958daffb2de01a7d387f7ebc23d32b40 b5bcd74a9fb4b20bea62123313e74b400d17a0776ee15067c88b2c932b89b500 de001fe84c71eafdb501bab097cf33edce62e5acadd512b2cd40581f2af23039 9b29e584fbde607fa3f4d3c5185ef8a070fefe49bdffb49bf29381f28c25fe5c ba03d52039cd2e064b5e30b00a607968583402c7be92f2eead5eeffd647f48bb 9aa9571d3848d8fa2dcc961403493af3efaefaa093ecccad408a320139a1a94c 26f2886a3d69b0f67b77c4df16a72022809afd6e7ccf08d5d0b3f3c99391828b d47098a0589861105edfd3daafe06165dfe7d8ce58699c8e4ba81986d1f3ebbb 691d04cb909e3cf02d120124dab66fe0949935aff2dc7e5182d1cf96e5b52c88 3470c5a6ab542b6ce08a0f776bb7b145bb34623b6a3040c267b780703a79a374 c41a32d9ace811cd8361273fcd7a36bf922b3927a1308c9d65ab03bb9e1b6e78 aa16c090449c5eaabe4ccb131dd1d03d71a6eb774ab1bf7883cc42e317d73575 ca8666a802d30ff59d924693cf7293cd5dabea3a7ad914b54fa6b96c7e9b1a8e f4afcc9321781beb69fa6817bc0268d3914bef1e7ff6ae7cd4b0f8d482d8e5b3 e3e707d1a2fff224720a50508e514f70ba4611177e34bcd663be29df00f0490b bfd5f5414cc9f04507b3605c62346b5fef9eb5975882583148ac824a8d4e38af 34335fd1acfbeb5382489e4bb05a20446470c697ae86f31b4e46cecba7de8b8f 3ef32c37ce1f00baea84db8f231620770f7e2c2ff8ed7fb90b6eaf96fee4f9f2 07cb3db191dcfa1c3680ef45fae82b3ac0d8774392bfd3f426d203385f6d55ff c2ad63c1f25d83fcb272b123644ac7978362bb42e6e0c86efe8ecd0093d0fa98 74582c13639ebb893a80a13a1b423c8461b681b8ac57d1caaa79078ae83c0947 0f266cf0e11a0499d2989e91d07d4abeecfd9e20d699472b4f1d5fe4e5f6a267 d5eb5770a16d07a9b35f51be65d47ab958d982fc6227d1cec7902c2eb42a6479 7cac3c05872d9561333942a11fb1308c22568fa864ac77b05392a8ad228d4b4b 811794ceb2f3bb18a921dae1b90c8c4a8b2d884c5b7c7996ff73f44263bef6d6 9e203781ab070dfcd119e3bde2db056db1e6226bc37388f3f9694011d2297cf8 96fd0d54ee56c7c18efa76476703ae3298b48173406b4713f4441308fc77f183 7e83d1954e7ec37febd4a1340c73e333b075ce100ab8c1e89f7ff32cfc4084c9 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 false +check_ring_signature 4edc4c2c6231dffdfa88d45a1f4e5c272f8012f34b8f052692a52fad33c452e7 a97680bffac0b7b23c52fd7f432306f0b6ffc7aedd047745da29d6276854e37a 2 b52f614dcea8b216eabac634fc5c5f6696c21bc5d6da9cd67bf7478fa5b816fc 3d8f5ee46492ea34a33b658d132d7008dc57471aca1ac901df88febf6afccd5f 231970a2b566e17e6f70d3cb99436fbee7199385f2a542c41553f89786fbbf004bbe9c9834cb95753cfb7703bf7df10c1a9a14fd6e0851eca630f1f9153d4708336bc26032ebaef3aad1ca1e1a469006e51b0750ff69ed846678e18c001bdb41bfa935372541cb76b9d429c75adbcf1a4eac94547c0b950699bd9deee5c1aa06 false +check_ring_signature 702f8a4fee10582bf097f3adc99e3742af12ddcde9da66560e5b365aecb7fe99 f2056a5d8f94925888346372a50f0c6547bd00e3222a0b39ffa15dea61fdb263 22 dacbefdff2881edca0d0126415bae6c6f4c9940ce6a49f0487705ea7ef3f9f4a d7b720a7fff223b64f7357625dfde92a4aeba14b8e153d141a96406cd71b95a5 c815d746f1400d64caf61c68ef9b7f8519d2738a3b843256c2f7c79e8991a69d aa750f7dd67e1b84d0984b57971ba19455e8665aed6f2b48ec9a0f482825d789 53cc3dd46ca56fc1f2a265293be2c518df76d19c013fe589240a193dc0408689 581e24bb5a1b593b573b3765d49a31921fb535207bd6ebe04e3caaa1739642fe e828a705c3439283ae9efc90b09658afdeb756b5da2bcd91d1c2ccab871d0633 2315823c99c74f8fcc38ed4ea5a4a35d32d12c1ff204ea1a9a30f25b15e19e8c 637496e33cfdeba11fec907014502901880e6429a60499c3264480da94432045 09d67bb83e7b130c75116fb5196c0109c3e2d9f5c0f90c468ef6571638c63340 752c48799b55d570ff2b8816fd971da49f5a76035c5c6e6c5cf196bf9aded4af 39097ce876c9c689221eb2ebad4f0831e25196605a6bf2a27cf76ddadff05c0a a8fd3b8087da9639379bd4af595db91cf6f6e10040b7e2d9bbe746659723d454 3f0ae66b30d3352874933a1913c730967912fd14b7abed34fb69bce60550f974 4f5d5d79b38910392678ce15268f1ea958957b86f1aaa074d063b06e6f44ae43 0095d60fedbbd5861cd33ccbf6c7fc04c84de0d54d628f71ffb33b0b3e4dc975 0c86790f436593f847503246df91b161d16b03323a8bb8df4185558866c4580a 46fa015321171b500efb9cfaab17c8a5b9b485fb7b9c140cee3f928793359426 5ae8b3697f0e4ce3ec7c5df97174c4de70efb13d2c1cafeb991b248463607070 5f49c03305e1c37a5a149fe39c7781c871f2cdae6ec97f02da625bae987c15b9 057cee88cb8b42ea620c81e5e7803a443d505af7ebb69de14eee5bd2ed360c55 bd7de6b145d7bee1dbdb231a854ab99f89ed58f3cc64a62bcc74c5d96fcb84d4 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 true +check_ring_signature d863bb299f1ab2b669938cb35c4450ed88a944ea1b963ec80dabc92ffd549839 88ff6d8416e78a6a5548466a3cf9b0eab9e12e99856276a1b740eef4180529aa 2 b46e6f6d46ed024c7ae1380b40491d60a270dbcf167cfdf14a6b3336069b94c1 a3d0ee7e5a24cbe8bc6c59b2d60df052446d131dab724e4850c660bee16f7f36 cc4710b4ee2ffbf0db386216f19716185aebba90359cca4a8c8a0ba54a4286584b894c0e10578c2a045cc196a2dd8fe72905fe01baf6bad60fbdf0b6dc245d0dbb92ec46ce12ccf4f3c1efcd85646942cf49e9ceb99c39fd59269ae4f92a5809859746ba1255cc39e8a2e49b7e5a3416d716e9181cc14cd4a7dde94786255a5b false +check_ring_signature 030b2b6564471a725e0b74243b9eba679b5eed22a6bdb2a9371aeb35be377764 9420229dedb5016306a5834e8ca1f410fb4f75be6419f70f9055c4d1bb667d04 49 04dd6531c275eca5f173e1506fdf13487ab66dda691fe2952790a95eda1dc24a 1e06594f064cdd7bb6f70a71d9c4555f2cd2508b1fe271340b5a6a65af074d2c a221c774c6901346db1acec3eee5dd5c5d64fb7f38ed931f99b01e73fb4239ec f5b7a76296b99ba4011aa2e2da0885e12e11f836272ab1513c2895108f92a962 50fe03d93328819cd7ecafdfcdde85cc9bc5b3561e9e0c2d8745ff866a317356 9fe5dbddfd681579d0484e3b503f9eae8c5adadc3544d58218f72909e1218dae 5df6553184b988c01288075aa3262d78fef4d46e4ef344823f55c9d49ee3e8b2 cc1815edee397e3ffebf5094c8b827af3a7144d1993d8ea94e74c726e2f7fc82 ef02720ef8ee65b8673e5e3b9772daf21712784a4807790a75d8fe4308d73771 4e2431cf396f29df2f3b5875e68888dcc2cce60861cc09c3407a4fce7afe7c5e cbfd211e02cf3c99ebad6bff7d2441df21c0d2af33251b1fffbc4ff8ec1d8cc4 c7c479bb33798b35175c0af51704133f7c6199c466beb901aa24b24536b83532 4894bb9fc879fc134472f5c060a0898dcdef4643b042d5ab5ad9a6e03964ad49 cea59ffbcbea026278cd2d28ee48ae35a031eacf33be287ef250666e262c080f 87ceb730719ddf038e9e7bc33db71ee291e62886183c3434c40eebd52ef62bad c832ab8a99c1ca09cd9c4643758f6dfa043080dfa8e91b9ffe3bc83b44db0ae2 3f771f0c4f6fd7ea1fd7deb748683b56c7229cce9f4e9f8311223e546234d687 d87fbbad52eac1787ecac97e84b15cb80c62b63cfddc0d6467fc437a71901fa8 b38fc40e4657178a72845b595c84b70f9a1ba90b94ab8c907f5ec5fd0e32754f e8a122c570690f710b1b1f47e4a8c4bda9c508f8c6968a17ef7315ec97af0f1e 83edc6be6706ef2980f6fde52643e16ef6827dc6477b69687c32ef43b1bef0cb 039b64c5418aa75be354b8ea9eccc082ce1d1f25dd1c589dfba8f3bb3515e246 e0f576edb14989b9113de26a44fa50d0d878f80bf97d9e3fbf6d373c3e24902d 4621a9b4a8b8b7ec594df8980bf7e61d46583b9ea5c1a116fb082fb091e8bbf7 dea17c68c9ef284293db1322db657b5c8f8130e566b5c722ccfa34529fa742d4 3b4918f8b60e44df3ed99afdf38f4446cd1abf200373c960da7c3a959bb38da8 5d22d1f49e2e46b67dd5a30ac3b60c62a9f3db99fae8df8916fa28f83c06cc63 64025043c0fe3d0c6d8fa278b9fa976cefbbf5e3581a668dfc303ed79e76ba07 de2a6d91071d1df1121ca7256610c5b44e6ec4ad010f922e2573f317c471f09f 6d346ee5e1a5d6f9fecca57d5ad5c70755ea7efc00637af093ff392cb516f80e 6a29b584f1086f5cb955d0ac4e84817c9d3e9a946e457abba10cb9298ec3c6a1 64f0e346f69648d5ecfa40be1a4e4a239ae91a14b00578e58feeaf7fcc6605e0 8b16176f86fc9b515b2b89e90cfc9c80d9d03f27092832a2bcae46bad39ca7e3 b6c083d2bfb4033d18f110401fe44b68a3c20acf6989f2493fcc393dad38187b 3bb9281b72be663ff424c88c83f7729dd6edf6da0626299daa8f476d8f72b30f 20f72d2a59078473ceba85d1d49f7108f2d1e7189e4e660a35eedbf8a4fda690 d23fd090ec48dd013d52e780f0072c2a6c107e37de7efd28ae1e79065643815f b0ca8bb65efeb6e806f53ea7f173399a14bf49bb826859a0132cd2092fa3c164 bab9bdd9c0e244477a3c60c6b2fa254e21802815948ce84bcd2f3743b5466571 cd1de044167a82c80b536b89e7aa4b3ed0cb917b25b1fefcf56050fc9a21ff69 0f5a2b5e121f8bebd1da0b972ed70e6b0b5c715752a71e4380d6895bd0887da8 c61cbc42da256417e88b0c74401e52f0e67bb97f3e8622c136aab1db24276097 10a724e86798ed26d4d0b38f9f04f538a90c586e9247855e59e8925cb6ac7af3 463630e484e0293532f461673e2497d5c2bb80016d02e8b5e1980aef289cb6c3 17ab44865c2c75a4ce72a2f663af0798298748564a5c6c3ba309665f9138764c 066b392fb244d19d45c44754001c272e4039df676094c5d7209f725024e6e991 d6380834846fe02ec511f2f8331eb30761c7bbf48f7fd2f662b9629827d73f95 152f23afbabdd731939e5e3b375a575cbab2dbe782f7b2ef0250a0945c6ec73d 99722fa2cd028f92d01c6a574e1c6170a6fffe2d63a57711a5cf9146007d9bda 171b3c4046465cddb51022eee9a0d9268d79e806d5c6870a4a027da1b9b7420d81779c66155d4b1b4611943eeff665fe1271a697df9df0b45cc821bbc63f750076c37320e730d135fdf98fcc0a93f8c77e3890b98158d0872c9dae00de23c90f3e3008302ff47cee823b13324e30755725956bea9bd9f0b4a142be7e4b8dd20aa846dbbe9894d1a9bc45639232951f8f29192217b58592d7f22a65a2e9888808ec1188f26b4514ec75bd6a3968d2a48f60db82961e4c28e770c3095ed1ffef03e46ded14792b21da161e1b41862200c026a48b4965ed59b3bb9c6d6eda9e3403d601c910d5f8b30bbb4f6a40b6843bafc15a0b043015a772f74d69c353d41f0cfd1773c794692c38d5d73a58512e82aa7b013cbd976da21b02dc815954194308ca596661983b67b3f555d3de4bcc024e2026c35c258bc113b5b453902211d105109da76ad1c59b2ba97f75e27ea62be7b7d220ef6e8b0ab804ecea416936ef07dd5d8757748cb244963e6c60f7a19aa32599013c7b40b50fc8a4dc96e79d7800e390a1962080b58b865af39e5b779a0d3dd53501a44c2b31c97d74960b231401d8212935e0405d4c1e1d971e6229f2825a654cdb26648ca5e1ef5a557459230b30633bd8d2eea62d39cdc0043ed779f9ef0e8381578b91665a0abdc2dd0ec10e930701df2587674bda4154d6a91c3a5515f649724d6b4b3c682b69e0aaea3e0ade1a5753ed053bdb396d23cd93a7d6703a95212083f9ef76d2842616632a650f3c69fea386a81f4adb82338625cec24db84387174e12a9f52999083447571205d4ccbce614dc1c6c79d48486cd2cafdc68a28e1d6ad5497183795aaaaa89d100d913695bcbd882e867642836dcf19b7280fd27dc55985bb35039ac0c0464ce0958f5b3ae6e016e3089f30a4acb54bee6f8022d9f2463c27e0014d13f4526740fa5ced9f659ee78bc6e708aa67f44c7c1e32e4d24fafef214900eef0435806800dca2101c56a972d99c834ce0f6548b58cae2c41cb535ab81b542eb8e25397b0fa9352717902c99dd7f47ad2bdad2e37fb66fd1cb0759debb3b9cf1bd2e68780113401b7962ad4cdaf0610dd269f8e09286fab7bc4e7be15f24786c2e8339e00041bd0ff6f726f1607bc518445248eb2ff40879530aedc9fcbc25422407789f0f7c07ec3beca58724db54e78b52e27eb5a0090cf132c2f86661c6ae26fd27460507d5130b8ba55171993ad3bcea40eb06e53ec31aa461585b60e39d89788c3b0a248625ea5b92ffd61007834f4acd549cdb00fdf93358e1faad8a88c3fc2eea0b83c2ed5200b0ea37b819ca4fcc18e5ac6deab7cd9921d65795ff2c8416e9e20d82fe7aec6c88dbd57f35f8978150a4358d620a9723f93c9f2b698eb4814fb30229a797fab4332bb4034fa9de892fa5f10865946a0aa55ce557db40920cc38d03883e0acafca3dd8d56e799c2d10caca8a0716a4319b70997bb9045354c08700f2087dea18e60d69c0857bd1544a469ed9b4b9585cda8e8e7501f6918560fbe079aca54a68c44864c6f161b69f3fd94782deed7fd9e59513ee0a0eb4518115c05b9c18909174ec91d69b5f802795646674593ed14b2f714cef2ef721e85381a0c3222840311cab79a2775b1fcd3268185a19feb70c8a52b7ff564fe06a50a9d0dabdf231154c4fc66a294d64d256f95d7241394d7359222e50e78b3176b5a4201c417693f8720b7749b88ff612fe66517011a3bd6c1b73defca9b8fa5c977820a7406d00b7c21a634d3840b2e3361da7afd354e2cb67faac05da409eff22ee408027dc97bb6a95ca0c8949bfb9d6adbbac5b278e50dceb10a4c6f6ac05f5e4307b3706e806b8de1a14056c8612816ab57a85c051ebeae2f7e142f4c5fde361c09056a2c19a9cf960208bb1332feaa5a57dcd262b9e62e6b292b1fde9ea4489f0d6d974377aeeeadd4b81b4118407f2bb896ed22307700b88d22c87806a6492e0e5870d265ccaeeaff538ada4edd76153e7cfdd0add2206586c5730d6206536804fb0f80c4075c1742ea1abbd31d7335b1114c47f0feacf10ec314d7eeb76f5701a9d67c15d6cb1c313b4ee4e181d3d129c46a235081aa383bdb22309668b4e10928b55743e842a1a7213ea80d3c1a8e7e09165ed91e9064cf2dc417d9de41800321af74368fcf81f5b813d6a9e8d36594a87390c3cfef18dac1ed5151e3bdac0e20d23833cd5273074efe0b9f8e25e2503ee7e3a0a5fe4dec1f2b6c282b778104174d69f6ecd9877fb14f273056b4f21521af6c0bfcef82ae08250e37f0cd350cbb014a1eedde2366b1e36fefe8af88de11b9593e26787558794d0b93853411075d66dee405f5825559b7601b67c41d0397d811026f6e05095ca2a7ae5764bf0a6a1a66d60499c400b0a787db2cfed0651b2c7caee339f48338e61469cbdb66087c775c2331d4e74c6c8588ee35f29e8a3581a122271fe7cbca8c07ce36d4050b9561b149d78f27e6802329b516a641efb9cbc03a4ce21fc82cd534a177fd230e694674a21daf5d77745c3df9785fc70baad27dad98cab34a3c5db47a6c6fe70406da3dbcb3848ae3cb0c5333c18b6187dd7ec85c5e7ccc95a8b846b408994408dc688d3298b5857577bd57b6c72a8766118c35fa502e2a352081a025b938d806b3d3a083b3b256825266dd26732a7cb72dbfaa1740633a0c65a14b9eac456300c228fd396be2071de60bbe207a87e62645516866b11e9cea171c5ff642574507def7765f255ed666322727b1b68d0fe72a7f16db370cfdcbc70d1287b86493077e6c245bd1b44e89c2023118361f96697b084188c9aa813d067107199f38b9072543ead26d55314ed71eb7bc018bdef3a38d5e0174ca08c96ca9a34311176b0081a8ac5d4a56aaaf8fe64d4553b33f15c0c3c9d477c73a49925cf003ab32ec0b33a731336c28c2122df8f8fb0b05500fa088b536f794bc42219bb6c7bd267d074c2ee5fada4deebcf72b7fe8c30a40b474b533c138dae63886cc28d8656f2a0c08d538ca0e47749b6a059ad73e639b8fb67b126ef08ce220ddb810eb88fcd3076640c979b6d62db832ed694509686ee01353cd1641fd953fb85b9a31ce0bc207ca7823ad28871040f419bae64e8102603b64b97a79078cba36b929791d625004ba1b224c223c38b18a94ebcd2c0bae8254dcf62208f74513fe101042a2570307ce2adb70dafe91f2b8c5c1a99a1beb6b7ae716b07e6af6172a3253fe392abb0a07cda88651d77f467a69668ceeda81d8c39225923d9afb652b78ccbdc444700433592c029c34c11ee0687f84fcd40ce65d525919097b66c7e866c582f01fe303d7cde820d30dff81d46397a0ea8d8c593a080b28a3ec3abfc51684e8e4f9ba0192b060f324e24284ddf6879440092d1812c51c76329c76ca114ddfbecbc4f008c2831a521e0cabf3bb0cc30b38185b38710ea3083f599a4575e36b9c15ebdb0833f6b6db41b61103fbd46ca2252ade72f17a86e44f34e8d9283ecf7dcd4b010e99fbbe77b2c7bc99ba8be81f4c7f1d751e3aadec085b855c0b11d61a3202800cda9e0de2a89e2519a1a14af2126a03eecaf9836578fe3d0605ff6488f261690f16a68132ec3f2e068b9742a74cf501d78df97bda8068fb502dfcc2333bd14a0423f6f2bc3eb77374ede411c7883062ebbc80d07337577057b88662f4525771056055092b117924823bddac1a9e554b7348569f3ddcb6f45df6f098668230d40b324953c4709335c0eb3da412c947c18f9e2382d352c3ad933b203fbc7dcf3309cff3ae4dc011e29deb8d6105b16a4727d9b37e482c27abeaca1cbed4a6f49c0ebd5b90b68e0189cdad0636757f4996dd150a9a165382eb0ab0fff9b1ad52d10e67f462f247dd7bfde87adb7bbc4b47a33f46d3d187566086737e00ac533bef0baa9609ee88adf2d242af0daa1082f0e60495c5b6661d5903128bd6beb535950f6aada22202f80a974cbe0fdb1a56b214f2bdf123e2cd1c8b759ea6efd3e1290f447a658e6899481812a0d6c9df8c81090e92eba08eddb84e4360705a4651a9060dee8085457190d6b183e0efd1411bab612a59b1620c7c2a104dd5bbad23580316a434f16b01c478bec38a1fbd113eb23f32b6f1b799a165c9b25fb01b2b8305af5d88c9f562aee45c1c8a606edbb96476f6f4df03beb7d5e7b9442c093c03013b67b54a94aa1e5014d428dd2360bfb8d812dc9b7140b646b4f4919b2a4ad50fd8f8809ed7a240ae0d0fccb134c173022c8e95fc55d3ef2b27b6b021a028b006c2ef39f5f059acbd3feeda15bb3a905cddb2c3460f38854641589e24be07250286f9e2c93667dbb498475dc113b6723e20b9ceec8c599206c9089cadd7e32108cda12ee59c61bc1eb36c6e868682be6041f10e253dcb2390d612d97ceb62bb07 true +check_ring_signature 885394a6f0f87f772da0fbdf57f6195532c267c5ded6ba9e9744d6682f7bf003 e23aa1871c81926d13688bf566048796e255f412872f0b22881cb8025edbd2bb 205 c1b38708978a43ec5710b08de2db059e7d1c64e9420314d74681af7d5669770b 8423f66d61fc4ba7100ee8bd8492a412f007687b36276ec28560fe1984a7ecca 9dd4484221af2d78947bd3144d8b4546a2261adc8c97dbb3a6652bd27dd7fcbf d5fa8b112b71ce82bd90d99827e2e54af14e5cf3b4ee7b13be691fc1704f9210 c2cee640157a2126a81b0065a7100f98cb8bb9e7854891c7e649b9cc5c79660f 0a5b76ee956606015b7abfb1ba4f0ee941f52664145578251857b9c51a327b76 6d8e90fe2b662a39b1dd9d79f33ab2627dbd87912da9cb0b57f98b2b09788003 655985b16414aee22eb87c76b890306c010f47d6481e92fe322c3a459f5673f5 f0b3c6716787ab712f9e59f53be475fa5f2a436a9e3a5713b3bb47ef868c2ba7 fdde49494410a4a654393dc67787095bf7576e877061a417d85be571cb395eeb 47f7507867aa188635bae1ed06059bee8636ef8bbca5d3732b57079c1982e4f1 6c576efdcb493945fd22a58e78b10d2e88a2589265fd8a0934ffd2f22fb7ef52 6db988e4faafe56b529c45bf427cc25743a5b9d46fb7fd79141b610f57524c5c 578473698051505e58cdbfb33d6a819a9577ff366d9d9856258f8a99a9b7866e 59018d3a720a37ade549623e62bd4d9ff7d0a361aa887568f704f38273aac81a 05da33d653b87b1b13d1502b6b3cfc1080b016ad2fac9672828e4ebfdc4969dc 27800758c200cebb06358ec2cc3efdfe591e68788d90400898584438f7a7046c 3d4fc3c3e96abdfc2d48f47186e094eba0fad679605076f88f4c980f69a8ca48 9f35ce315b99fed5804d039ba7bc154332812a752f765e51d52d82ce174b75e9 2eb6dd95df0eae2bc145ed6a27b0a54ecad53982a3709a8d0bd10b57c6873a37 9f7c9a997a3e99865a2e04c029cdfbf1e6329e10df6d465c7a0dc6fca327997b 2174e066600e299c28c39d333d642cb33f37b1f3d3f74ffc5a7cae4fd4dc3cfd 22613d5f011bdf9f484029c05205063d5b5186945d119152086ed0a221e8e0d7 f9f9def2897277cec312a40f0d67262a768a02640998647b0508f4ec445af0ba a3fbd80a6567bcc16ec680d45d04a16f81b5705bfabda152ef0e1864de14d977 310a5df64de71e145d916ca7edd53cf05acb030b29988002e03170ba0e99adc6 06cc610d07abba4a7de6d904d7cdfc6c7bce505b54526ff166eefc8948915fa0 065603fa985763f749717b6e0d6c783780dde109f7097a0818d088dc47148c85 77bc9cd2f3964d9d0b78008a77eb1bfb8be075950f5b90d366456e7666833e7c bbd9f6ae3c5843f6388e04d13404796952f1a0e3f993b36c3829b22af62130dc 088897084aac026f63e031a3f38c571b127b204acd93bd37948f8f645ebd071f 463f78c0093b7e592662cfcd080d2f7efdbc1a59bd85decbc4bf2c7665a3e1f7 d3a7e701679b76684e10221333c18ee4d1d12541ce4db6b3cb4bb5e578ccb0dc a24c9cc6c088916f7f73d21d3a7da6d0161247f73c34b6a40c4e7f29e1e501a2 41ce11b673d15da2b951162916e6b29e42086228d4eff251f97cc8ff92910423 9db5bb0193339b03e41b597083b0df1142f5cf0f705698cbedb1e29c40266fe0 7bfd9f79e20a44e4986b548c54567136f074efcfb06b5622bae94e36627602e7 1732a7c717d5aedba07f10c93fd0a16a7e575dcd859c78155dc5f631118d532a 3ab460cbbbde136bc06ec29b88bf6d36dc439891cee08d3a2970cc75ce8740f7 816b0f3e8216406f8974d99f399d41cbc7a80a2cecb84e14fcad6ce2e0149501 139eaa7beef87f2c2f1be65ccbdda3c00d5b0e48baacc5a20abb862a9e918051 e267b03ce387e5fe6677a20ae2f9574c8ab37f7a7646d718987775f3d3eb9d26 56bfc31a90f2a7688bf8df17d1fec4a19db97236797835af6a204c89b603703b 55bdd2cb8bb93f27c09dc3aebe9e561976e6101d07695401cfd337291cfb4317 60fbe0b3d3c5cf90dbcd211e5d605ac56aa143d3565f93f173609cf3a7c06c14 2df32d12721c75c67dd53c6505d576dae956ba1fead6a8ace62464287f655fc1 e430eca66f393df81f35c9ba1a9db10bd1dd7f547129cf99d0590c535fdeba9c f67d413b5dd435d69206d4349e26333a288366cd62d28180e15b1300d5d3ba65 ffdba4e55219be22d6887fc12d2bf9cdbfe3912c8c58c61c6b7f19e0200b11c8 fdcd4a4d768effd2bc3c9bb314a2d80a9067f7c9b17123beb835f422a28e5535 429dee08eb2ab684b31fea248c155f5494a6e615478c8e3e1f4cd8eb67ded47b 14f77be99745961fc26b5a102839f593733912fb36a47afc9c2605e83ee2905d b46d0925238e286b3773ec60af83bb4ba92f816180e9a360be7a5e1302cc4a04 f26b8431b8f839926fc1d538e975b542d529a6789d8e25cb177d5226a69f3dd9 3837c0454f6e2a5ad86c6dbb12fe4386344328359fb2dc9fe68feb3e496df527 671f188197ae5356cdc91770fea5b951ef33a0d56a4b31259ad587cab052d7e8 56e2727a5b08504a58624b4d7f97aa7249f46bdede78907f95e1c317b15dcc51 931630783d2b420752ccaf951c75d3f3aff9581f94815a3ca59289c13f9b9197 37aada10e9f5cb7d901e9aff9c8ad0dd6fdf17e37b5f02f26869d728534747c4 d9a07702b8ac1db3d8ad8467308fcbf33ae9253e347e74b378bff533b52b85e6 9a50c740bc5d7d1c52af0a35e7015d77fcf1de7cfea2fd05808ed784df095c11 75fde23b3d62bb015bdc99ee591a522cc7a635f55d4110cf018f3a1e3cb2579d 6ac4aae22967b70608f9ddae86265188cfe96d4913b21cb073b24549bf2d55a9 2641af07c7a62ad477e294b2f63c9a626dc988fb6f4857571ef90f95ba5475bc e6b01d28363725d39102b0f183d78f32a51653959b076e36fbe8c16aecb5df82 f041f9bc4df73e30d0674f054b53613141f2d8a0d1329326b376cd1c2e19708d 2472c7ea28dbcd872defbfa2eab191316fe39166352e2ca4e5af04f09f52e0d0 75b1fc4ce8ad69cc6db043825cfb8d2eb57ec2c2033955277dc86ea9590f9f68 2e41702a5719d8a445f3ce3ffe75bef438c0578a07219a63e72620f66b142e8c 997813412f1f6a2ca963c6a904dab748154a2d6061ed80abff35d30ad80331b8 e69103b2cbb852b735e7fa1cf421448a4ff9a3b98d4ab503c68747599e844cd0 0610315e4b4306f8b7e0606bc3ba6a0b60fa03c2f4d19176eac3c3ffac6ef2a9 a98c80bc04e3f13676174096c1004794e9a4ae539db2d29976bffd0cfee7abb0 cf9173d31cdef6d1f68fe89262415f20abdf049c95f58733422d4f0f311cb977 f6dcb55c0c8ec5a625be1451d57fab3fca5b78a2596b5193f2347dfdc346693d 7d0e17aa413fca78dcd44e94e159a24c6a823f6c83d7f099db80b977a7406f02 eca4bae7096db33bcf6c9ce9e3653d595f4e8301e3f0cc29abc0b1a419314467 5c53d341128d5aa8b2dbe99a29f5dfb8f84bac0a97b4558399b36bd586fe133f 6f895ca5e7dce029a7520dfddc8fbfeff944b36e44cfbd0586228b1855e9197f 227d256cae3a3f849361b2bd28211a433d9afd48205750f3d7db13a9697fe375 698cb77217e36aceb9849d8259413668a10a38961323f6ccec6a6ecce9ecace8 22266c458ba0ec63b6333e5c7dd905d7a04faf48914a80a59ffff7e4224b485c bdcb47e9f3bf9cbaa9c6226ffc5169357690406fbfe09ca3ef942264979c8b3d 0762cf86f438e733320a3dd46d7a455a18638ad54e0abe45386cfe4d1436f17e 26632ad5a5431c2e1648e7770cfe98329588348cc1798d9e0352ac53e8626d4f 3c57145b07624782fd4905501a39dc0d0de7bae5083bf32312fa78b87a50eeb9 02759939335304dabea672d3aefa008939ea40269eeac5e489f5bf9f1da1b60c e41370b9b9fe0ab9696c1cc427516c4f0d3d300dff02f92cbc15dcc9d2652b5c 0acff6ea59483690c7921d67d3f08f1b06f9f28215085b320523dd67313671ce a6aeed789ab1cc022d702bb01765a6cb2544bbbb47fefe140939abfc70f6d99d c57fbaae4aea1002e3091f9e2c20f6a000fb4a35cf64edb821266fa10eff3c5c d45ae49e03d0fbe2181ebe4ed2526f26bccdd184c56d9493ee8be344f095c06f 91db6353ca8ce60a88b1361cb8cf8ca90d71678bc5a75732fd7731efc70b81dd 3699c43fea7272d836594eb45cdafb77c486aa75fc2ebb112f3bde19452acc69 ad04147db17bef15cc3939a33ef7cb64c3c9a87ce055ab0e1edc301d6e365292 7cf6f5237820962dab491a507d46aa41ce8428ee26fc959c7d81945f96cb0e0d b61922a383f6befdd486f4302e6ce81457e7dfdf704302aa2469a1707122d477 c7842979df59dbf86dc7d8c02bb00e75217d0c72e24108b5d09396926862140a d9eeece164e8b517be3ee4ea2d5d5f16704ed315b13c70db3d939e73848b11ee 3066b2789936ff937b46991415e97fa9924e8df4073b31afec027910731af8be 27fce5d25fbb36b8fcadc9b7eda789d42679c109bf835c0abe9234b61d1a0091 bbe72208adea6d98521f8d439e7fe7cc7928e0c4bfa2d69eca93a342c7c1c9fd 3e20cf13e06781d23fe01472760dd26d283ba748417c3acf135211c34df17c9f 018a6bef14d80e37e264fb1e1cb7c39bcc0c51b8059dc66a26a36a441863230c e4a5aebcc9c9e4af21327579faa45f4ae601e1ee0917fbd7c9b082460d9a1307 3decb9452455281f105261cccdc3eb413755ed795adb4173569d207e471c5c03 f15f99f38a0af4d6cf787b64a403f7c4041aab9463322719ed57622ce8492f0f 0fe0d166d46667efe2834edd71e730254c7fed65a49705dec913fec76d637465 42ac5240b5284f114e9d30a13a83f5c84aac3624de331f0f792ee9a8163387db 596adea92f40e6aa2ed7c7e56dc5c40e021ebe2fa23e8e28bfa3c8cdc94ec140 a2364752d00b4ce57c1e6a078aeaae3361e52e9e40ce485406b657a1ec49c03d 1d32995da6bf1f9a2df18e17bd2260b6b69fd596cd8a9e16a4868e68f3273093 d9d73376374fc24a096f2aa92d738d074ba44b46853e381ff7c96e063622376c 0adaf76dc8ac5982a088fe9d4af593a3f961ba989a74e54ec626ea7cc5811397 50e9ae79fdf350a9c733bc0e0aae7fff8c45490d67b17ce353362e26f7e8cdb4 dd6775c8f7ec1a0f87099c9bba47545db72ec375996846fcc5ad19fcd68766b2 44de67b83d9c516066523e6768cc10e907fca1ab5ee3e561db0d00785c712dbe 4e40a23af4c67b1c21bff54285c32bef33a7d877555d4dfb83b9be6b5c223e59 68fe7a63f815ff04cac04daf5a0ea46024e47c721a4201669d4fc6873ea55191 258f0e64d0e754cb582387f9c1fe1c7f7c1e75d5fa06db4c1a7ed67424c11ee2 962321559af4f56a7839c4eb9af408cb2332db6a1fe86057f33bbf5bdf5837a2 f4ae7b1b8633646860cab6168d02e313279b898c8e1677a4d0346fdc295c98e0 89717b5e1999d53d36dc353be45136e9209c3ca46a7c07cb84526ba5c52cdba2 7c78a41cdb31087df5b8c5ac893a73c6fc278dbdd7ca849c8ffc538bb809e9b5 bd9b2ee21a29710bdce5fd874c20ff12290fdbe71eb8e74deaf7541db9a58043 ff5eda8928f32ecd3c992b5685dae650c66ec0aae7b272d468d7dfb81248eec6 e450cdc5d534b1f29ce74fd4a4986378ef0f592930b2c4b480905284e292b5de 46dfe811e3670c8c79b0ef2d2b4ae6fff481170a69fcdb9f8012eef180f233a6 2f64c44873d68fe2639144eafbee4dd813bb5193f628f99a16f3a466fd9a8e04 6174bf2f0eb2062c58a6e90a95fd3eb23d4144f76bc9beed31c75dc584e1475c a5b54bd56567942654fc544d113c508f4e4bdb8167a896c72837726f76aafeb1 a136ebd6115c471242b22ba9d7079457109c463cfc651f1e6ec3999e0a282a13 680b43225fadf89e2d4e8ea302651645607a88e7754202f9d7286fce21b2a69d c53cf817307016cd10cfdb3ff1a134f8b9159b941c79194be16d8abe8cd051ef 949cd5e23c083696c72d0c88cd3bd5a1123bc7e2bb71f83f2fa64c556d05e2c6 e2031c971c0b2d8809bccf69893bdc53237af890efa1879ac2fc3de7a5403490 9b105bc2fe21f8aaf5e862b4b4724505ba33f67278e12d7a25df63517d2f8613 be49ef18545ffa40c5faec59ad5348ac6bc4c5ab34391b184e098e0781fa8c59 d51030e8f80c10bbd438ef8b6e6b008d3f85d9795623fbfe6ad0e3eebb945031 d3a786e182375f7cc03c7e2c4c020cafa0fa0b5efbe51ccc17e6e4c8406018f4 aa5f7e6ee560a3df8bd230772135ecb5010751f50db40e6d634fece9dadee428 0d008d04b30810958bad4765ef7850075d2fc8f3b62d7891881b19fe5ce15072 ca145fa1bc31f9f6b6fe95a18b6fd40020b11391e14f47c2ef8b3a834d30105f e7b7f58fcc8c6fb29c5559dfcb6ef07cd6668d24a7c2e6453d201d83471def32 840aada207b0aa8b2f30284ac2e1e599012a82fb1186961c5332809b8435f16c 17e515c87edb38e0dad476facb270a26804f2e1b9c98d9d4bc925fc756670f93 a324c73603604ca64daab387e9dbc852b4db6116b6d0a8d2efa593cb83fbeab2 76765ae2e71b361549dbc54a655d5889bd6cb4ede01f1ff594e7cfb8c7de7242 8e2f4c491bb077eafe2da3945272de0a5a9433b115062cd4c6429123040f9e88 9250476660850697611bf59c7db85fc479565ad9d72241765e7333a80da94a7e 8e2af8bfa5320dae2f1a424810dbb7d02993ca3ece10d09d360d42b56e6f600c e6aeb16d8a69a3d43b1267f14de50fa571edc6c581aa1edac9991317cc54d3a5 b461c0b75c804e4c13a3184f0257d9f0f4a72a4b11d1ef71f448ae0710774f64 bab9c83004c5e492c942bf28f87d0389d473b00a0fb32300ffbc1e3ee8a119ee 468623388bf989e8434a4942576badd33eab31f0a20e2b706a10280568dacd3a 9f3250d27090139eeb0243c57c48d49754132110fd2269b1354897600d90be0b f5aa553060da53b54904755b657f667a920b23d1f12eccccb7cd795bdb82db22 d7c07e090efcfe3962d837e27f142f9bcd9a982f5718d4bc8331bfd24f1d9109 9d49c7f8e6b100d97a9e762b684667c7cedcd155148318bca3b4b36612872b4d 8ff2787aef988246bfd1417254277062f86b40e1210e48c9c22a5b6cdbe89d83 795e1a857f678c10ccd10f94040142874bf10e1207aa89b11458a5cacdb953b7 97ca777e778df1316ad09c601593c6fbc2851d9b06120032b9de5ec1c08b8b43 6bbdabb94c9bfd0f69a6fba0f6becf3187cccd68a6d53dba70bf874561ce6c8d 5812c2765aee384e130cebd229ceb43a7c9c9f53b153941774200b2960997d28 e1e71c90945f5e3f561ef9df85fccd31c99901bd9a5607ed31bfce23208d8135 4983b06bedc968c937b789c4fec597eb3be0be79bc3fdc6d164d1cd5d4af25ea 1f80f11b8cdf2fe77e9a6dedd5fc7ac134f38245fbbd0d357c6b9a2ced011714 e10e7467a7089a73ba66bf0b4bfe21d9808f4b3540b39fec4571cb815275b82b 43848fdf5a969570bfa2ff24c26a5f1cd16545cd7a099b8b13f2fef4de3c5682 3214bb86d2360f3ab64a986d849b3c3e8dd27143c09029a15ef8d748d6f52dc6 123e2e68618475a84240a44059389de50d407517ff22341da8dd2244a26fd37b 8b8bdfb743ec6859c2ba7e1776d600bb6d5e77a507029fbd4e2a67ccd9f51af6 54af94bf86bb8c36d43f171ce2e1a5f24f572a6d1fbafb8ddb331f443f2fefa5 b025b63bd71296e1e8b441ac2de1a1f6f286a49d0c88b20e14b0122882157177 8730211fe8b9a2ba08be2fe4a7ee90fd63366fa3505745aec0106b344b1f341e e5ea07695a2746f0d628cc6241918a5e3f2dc28d315a28d7f2751e2fdfa6962d 76a5bf82e8fe910540e9152bd1e740b5d7cb7da545ccb07da614cad9df66ed31 4e17d2e0f1bd87703d4d54b1e6f2164670600bc94d6347e02e539007227d8536 371472ed08a679342b969d6144f0d1a18e702156ed642734eb8181291b762637 52730d99452c3532063ef45183f0348ba0ab6270eaa4c504e88c3a295c30ce79 ac80b9510b7ab050f9f0e149a3ee7a26fb94f283cae2289f3a80dd0b9bbf6fe9 51bff3c3c35a177d2cfa93edb8fbd51cf1978ed3ff111362544732ea616495b8 0c9c1fb8b3b5a851c35a1a96b1cc50f962ddbaee3761c0a31e8326d5de6b6f45 5b68935b5f93ae0477f49b195b68f452a945840ad57de3d9022c70679eae3bc6 d3c03cd2d471c307cbf0bc2a6fdf4f58289e28ce46a5d147418546915f0f4de4 aad821dd080b7035fbf544d25e952172dc87cf15c3dcb0dff277724ca21fc5da 97bf66fd42019614fc56bd3e05bef66f7d611e3612d0a41ac21c18cd743d8928 42ce3ca9281d2ffa200e6a0392c9de1ef5636612d20f718c3e102c75d5a6e2af 36dfb35b52980bd3d78084bdb6f5bfcc554c8db2db888d01c3eafe684692b238 88aaab52a970cf68e66a1de224bd3803bdf9412f100daf3bfd9faf0337af0939 5e6a545b0a1fc210e2638f4758e333f72f7b5baf39308b2c449e03730d25d93c 68c66d757e44714a9c5c9670fa97637ed363790553f01b91a67dfd1dbb703af4 b63b08ca19a3fdcdcd391bfcc93a2cf754addb463b805123841d4fb77992cfd1 c304570fd39ac0bcbb5ad8631dc6e92b8ebd911249f02d6b994f914ac8a90fa4 5d75f11ceb412f1b08408fb51ea897287416fbe0f7ea086728d3735d0b3cf643 8207286e1435978572a8a371b2295269c0bc951e78cef44c2d0d7b1364074d7e 36442db76b1a7ea41f004f7ba17ad0be9117bde1438e850e0d30b03f1dfd7386 4dfa95d173eb8e5976b8104e168b6dd720f6361e7ebe05f46f0042cf5d7aee52 abaa9dcbdbf3680ff7459d93aa56a15c5b0b6fb3c2cb4b0f08448fac69ff5f51 96a6677f967fb20dc0de159264fe42ba55424a54b660c96fc205fe25ed9c303d e29fd915a4fcdbf9a542bf0c834b4ced98a22178c1d75bc1c101ac29f01979cf 760a8217bd7811ffe6ba6a435f9d9f337e47c537318b77e855eb4a40905ca2e0 c44c00af393cde170188a29a002ccdb96a845d2a0011375d8c81eb8c71d92b6f 5f384b8ad4abb2539bda86a471633d9bc3f05170dc254d7772f4a548e3102685 a3fe15a5109ac321a5a800bd945ea341a3d6e8771da5464e8191f5ed31a369fc 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 false +check_ring_signature cc3cdc034369c01e11ae4312fe56b13d1d5ca1a7f143a9ef104ec79bb2dd6280 915c932b2e4a5a7390b7e75d54704a1919e6a7a4509ae6edff385c6f23ff9a0c 1 6d6ceac113e039efe698f993c6b397531c5a684afc530b45c7f68cc5973fbafa 11003e2c2bd9a4f96a1261c33c98ae56c374ec505d4cabb47de7176e8bc350030c9bbc77bdcdd7c271e7ce6545218487f078fbb5327b73ebdd7b9fffde7bcc0f true +check_ring_signature a9014b62583ae54abb4930758fde197249d88a95418bf34e95602d165ddc6738 b38204bd1b876405f8559b9dc592f464448a7daacd446f50314c08ad912f4655 7 3cbccee9100e7928ab09eb4d8fdfcd5b2f6fe5b42010b805a39be21ea71cf03d c91e96b6cf52e1ea441a2606605978f79459203ca6e2c32def43264e29c1cefd 8cfae39403d7e2408c52a1e617e068a27cae7a180cc062b499211892a01e5f48 9ab9e18bd924676716a3cbdd0105d98bce1a081430fbff332ac74e9fcddbb1a0 43f5ed7e0f4737a2f70d7b46b2a33c62ff9797fbb3bbd9fedb4efc79751104e7 1a8b33c30886e67b7266107bcf1c74dfb66a3318296787c1f6f3503adbaf08e4 45a42e920932104286b51a08b89d667278fce09db9d4a362ee0042d1905f9705 94621edd1e3d44bbe0759d1bbfa376b24638faff033092b3163196f729455d05a9402cd6da7c4284e8ab4bab1b6f887bf1d466c6ba71e71141c4698d74132d064f158509daef5d97170b7535a9a3fcf0f61cb41406f010ee645778c39ce77209b527b03848f6c2eb9e17c807c21d94c4f32f5fe250d46074b033a9d757733f0e6a81af51210a6aa045cc8c98cb6e23d8b0e9f18dab36f5eab11f8f731d0263064e5221b32de0d571a9835b5f8e7487759a655a78b30d9ab4736fa8d28c78ec0cc1f4a4d08a209f09a4de1244c6590cddb37660d6197cb62cbda781142b07270c40194ab3a3d3d1fd3f771a7b21aff43962a6d8a46fa96e75c0d6ae1e821895035c8da1daf116d6388abfbc61f94fe7d78ee2ebec51a5e81605bdb5dc217ec10462f99772ace9d3e6e8ab17a7dcab8495ba9162d24b43dfc088ae39fc3e9e7f0e38f2834a21fc17ee05a3aa09c100e2157cf6d74dbe76bd9ee8b2807132778800b1696dae2a56788a7e5c78884d9190dc91d89a28c9143fb0de09e3b84bd0db0fd5363de5959f08605fcdeaeb2fca2d2e840ef075a6aeb0acaf40b11335851402443190644810465a6b18df279addcad5f664ad38fe70170d77f2a1def390760f false +check_ring_signature 2a908f3fdc60318076ed93f18c1286981d6beafbc5743706a371a354618f29ee 779253c369f819ac211c31490bd4558f9ad58776a40c32b6377cc09056ffae47 4 3225b973394c15b9004228c77463067d0067614522371a35a8b99005c9b211d5 90a776c6ecb3d52810ce4d97a7697074d954e05f1d4b73525358036f72323610 450e0a81539217b77218d479660e8cf46d458099cff8f33bcbcfc3196a3f244b cfff9beb02ab13977cebf3eef2003df4f179b78e6cc8e4db0e83a63f2fa94b6f fea0b2017901409d9c526c06f7b31cab33f02562de3e028ffe69f997122ee907a8da3699afa492c618bd45e1226989f9434bd0f87f76fa3e650001c32843360f687d2d4489de20e5ee8017aad4b9b5567c39e37d60092e388ece1a4c22d4ec0c65105343c7f606796ef54b799e4d72f942d94417195d38184b419d192b405109ee87327e8720262c91985302f73f8a3f13ef1be6d4511b63a85c81a536117a9a4eebdaf32a9af522bdb018034c91835c021e6770c065f182f3559351c63cb50b325035a5fd225029f415beeee972308a505421ed94ce8c76829ab6691c9b99078240a432499884a8e75a9f7cb25ba933424f5dd8b918d57a53d82d5e9a9b2f03 false +check_ring_signature 1b2fc1ff75b5f21907b9991dedf3dcf8e7420321be7ae628494a105764ce2e97 a001d4897e2bf0c880da98f8f6fcac026d8b63adca63eec5de7f1192c118bbb4 1 d9b8cd59c9061a8d1e61a0424914509660358d40c29a3f1dcc9c6ecfc6c71403 3a46a08e90295426683f137614e6725835a124db3a40b734ddede088014f0704e8283e35c3b07cda873585b6a651e90b4c96def3833f97a35de8c7f1cfb53712 false +check_ring_signature 934f62799b243006bb7f5a806e559c76d3864a9024330ce7f4e800397b886243 b73909dc3be452f5d9425d0ad3c8b98dd224b1635ff34f30a3e5c8f0af7dc5db 26 37fac6cdb0ce1b7886a52d33ac3524f3e0180e13f7d5161e02ce3fe80bff05e4 4d732ea37159547be5ab6053b56e4a06c2c9ea79115d97c510d603d6b6fdd820 a4b6f3032941ddd24f6aa9163fcf25dc4cfb9bb87459fb0243d232a45cc4d45e 09f82a701571138095ae00e4e5eeaac7c4eb5ac0d1f1a8af0ed1ad195d3eec87 5a54ed0b13fa76bab4ebc6ac57529eaf23920cecd28e0c23702b1a8fd888a825 e85333dca504c4cd004ee5f81784210d94cfc0ddea0aeab845c453158b035a2c e64527b380477e0e75c67f7fbf7fb918e19418e05fa73e32f9ea04f33c21e3a0 39615f3f5d70223b02038ae0bfb66b6a5b229194a56bfc4ba9330dbc72a2c95a 1bfe92426c61606d706b64c7796c834a3a7bc9779e83771f1aef4fb5b920f2e1 745c23e29159dc3aaa988209ac3aa5f08e2688a8fbd48dc008d53cd9382ad212 9de9af082a7ab10cf5bdcd7577b4118667efefcafd098a4f3f2ba99958178eef 3587c9f93fa14f4187dd44e54a0813acd6770c435ee709064922686d94fc6308 95ec5abcd04fec9d4eeb912da1fe513d3a814dc734895757c32930858d92f182 d69831155848e06db179a0518c3e42819e6b7a41046309147be2eca597ebaa7b 32ad77cb3d16b544dfea57994b43445cfb11657b8c6e26e881efc61c61505184 16b8a7edcafa1be617730c64955592ebec8b6d84731c64a821e986a48d9a6859 6814a13231ff3dbd4d677213ae28207ce03b81db814e844929ee2b588da3d116 8cf8af9d0417e32cf3f04bc51cb006859d443e6a1f2c67a4652d59d65eb3021f 222ea8aa7078f40eedc3c36648b94e1ca57cf6caa0f19e76c64cc508ceca39d0 eed67e78d19d4d253f8473c19a1c01a44fa18a0b438fd77d4c210f55cdbd96e9 f2f08b9148cba186fc03c0b513a41826565ca98549b96baeaf9061c1c1301449 b97fa8541f500afe103e00485074b883ec3f49f7b5e30cd9f049800c31bfc687 a7914c41cee0494ccc1ec1b3ead1cbd3adb66844f09151de758879de35fe5a29 3313e23607ea7aedc191fad6f111b12ebf9bda6ee19930c2123464941869ffde 3586e837afd375c5608f099f6305f399b441597ef9c33f1980bc27465f9793c3 7ea2ba01f74b2c8877185093f7438f804d7ff748f7093a51888ca20199eeb8e0 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 false +check_ring_signature 87e729205e9c5a0bc54a08e91e401ae7b99d4302ee42af4800c12ba2bfc21abe ca54987dd236b170284d9c1a1b44b92f40296ea88ad9c60b656ca65c07844b67 2 93eb88599d4c8021c37329f69b9089147e3d733748b8779adbdeed4ef3fe9923 972cb49183ac96d78b9f7afc8e1f1d0c3538a5d6fe48549043171b23d3d45aaa efef7b0e93e76934c0254b32653831a4d45025a638f8f50cfd995d9e66d3e20f774ffbb34be0225cfe604a13071fb10f01607ffd586610365df9ba87325579032b5abbf0b66293c87bc059d6a0253674ed93427a32e69f66e0648d5d92b2470c8b3dc77ef3febc26bd30ca50584fdd21dec69a424cb250c238b9250d948f5f07 false +check_ring_signature a6c51cbce5951677eecd398091af0c1de2dc03b3334101517a975c0cd0c8e52a e0dd29335a889e8f3de70be7ff0e85d96579d95c658d65f16bd21fe7e8480ebd 47 8569e3bb8ddac52b9685ffcfee50682c55f0d5ef627b5346c72d1815abeea97e f063362a44c799fdb91ccc6e7a9f19975c250db25b74e62a30324af182ef31ff 568f81157b408968b20ac24fa15ad497f23575a7df6d14942361fa7fa927d14f 69b8b97688da1c07158834f81c8b8d1a13cb6c5522e41714826b9c87e09980d3 dd13e5b5ae64ace790306b65dc3d47c9213989ede90b17ff17ba030c7e85da01 27169a7b6b658ced99b5198893bbbe9f478e285cb03547013ddca7932c7675d6 73665dc4f9bc293b7526c40f4a344e03269c2f4204d748abbd370560eb34cf63 c69ac4939e0cd5158a2b4108b01c723a065b8d15455001021d146523b46e4245 ae85868db6b4e57780d42d6afb8d9138874746facfaba07d50a479842039d3c3 193f394b7f48d0c1f3535423a056536b1378386aeb84d7a4da62b3fdda0576d4 5dca30d9d6c76cfa4e018bb0bd9b9a24f7620dc572a8d82f6ae2b31831312667 012b8c4b77677ba67c822cb2ba37f04766e1ea6e7e9cfb4e49fc936778515cc9 1947f66d7069aa3ca4992d2cd046fdcabde1c301b8190accac0e9f76fcf2a510 329878c13bf86e05c45feb28e0795e485efe54265e19d39aa48aecb8c9142dc2 43ab62b7e66cb88527b78b0af796bf9fea487c27c111d5dd4ce205a3c4bb557a 308472b0156204356a36a755e55b8747b87cb1a0d2fdd5e0755c0c75eff26437 8e93e7705bc065b066a628fa22a21750ab4b29bd716fdc65a40e0e09a001008c 59bb252a5dcb517d20eb10a261fcc113eace978be33b8b7d1d0e1030e8b11116 f217ede3a3a4bc7c92e0555859d2c8605f08c461b26f95f80b4232ed7b2130fe 39f7218cfbb11f0b4e3439e8324861071b8b4a5aac9c5d760c334944447f0e56 e7c448a304b7bc6fe0f5e892ffb90642a0b68bd730845d77f4ba4dd8129288ad b280951d49f5e55c541b173a09424e6b12d9def2212a8f2f1b5348a177c18f96 06ba0818206e8582f6bcd670ef2e3dc4b57f074f5da1ed6189182eb686370092 af8206a2b3b665c75e46dd2602ed7b8a958f748df969ee0e8d8bb701e30e1539 75313c7d8ef7563be24f0c546641f3ca67613562f5509800fb9822cb9ccfb7b5 2b8d02edeab6ef5dfff5d77a05e914f44862d280691dba73070ca7f59d9feb48 088a68c866b340d8073051dccab2d9c3e07f224c0ae617fe1d53c982cb58ffae 5877ecd59370b4b65d90a0f7f5b24a1afa4f6c692fbc4d033b143bbade505a8c c83be95d27f2b432e7bded5a4bc7c9af63ee0be79d2024f42101b1e1afc2e189 ef15d7ecdbfc6a377726863f692d3592bd2dd4d1f1ac8a4b47e008607a316d40 b0aabe91b85e0eb8323745fad1404ac348058da141b69e7fddffd035d3160439 0e3487169681b8e2f0b7c62fbcec4b94311fab417f077058e6640e805f90422b 1fd97e547f86517bc41011078a1bcfc2f61887f020bd2fde28a20e95119937cb 47a1172505d0551634a49989b99af3dc5d57dd37be260910f8c61efeffc22c20 cf2a134080760e98d5bcec1d8f4ae1417ea8c9fcad052569a4c721a1be803bbe 17efa91ef5b630b529c28ef7f79b33907521b6d4987fb6ccc0b7182adf8d7be1 a00fd907d2800bad5b7832a0b5296d012c9beb5682c4f1c036149b1552c59046 b953cc42217d53510ae69eecb6a2f7c8edfc22e1d605abfc301a7934de2b13b7 c0c584fe4ebb110fc0150eab647e5a0bca85cd1f360c92e587742b6c8c9a8323 a457fcf681929475fd0ff96e359183ea5c95753c3642f617c5ad1f4411807abb d80ed6697970d83a75f481734affe8632ab0f65e49c043ae9d7f65f889ce278e 334af62282c7424660d68aa7e63d2b4f2f690a214c709bc47300f7c16350a0e5 3d249a159f6c89aa520cf1012d082210f4c0ce43eed8f3635f85385e406366bf 3f2e4391ecccb2b543b12e12e3d3206e676a41d63d5c18317ba68fe66541f197 265cc776f2d3725122f35f3133d48acabc1e4c631cda5f4dafd5abe0bfda0b87 5e9b2efd0aa805719284e04e8e46d7abbbafc402f9de171ca7652a75b9e346f6 bf3bfc3342af917dec0edb33c858d3d2114f21a8647d302d4d8af180c5b78417 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 true +check_ring_signature 04b787991bc8021a59d56e444ccf29f7f9f123904ddc56c034e119ae492b7efe 9adb03bc64daac48e1e77cf1ba0f1d81ca1fd92a939e966434a5671677a7d0be 3 648d5861edad5312b5dfbfad13dafbc4ab28d24b240a232ccc1ceb37c924b555 a6c4a63bbd07cc4c08d2f20068ebc11a03c2b7d94a085af732cbc034af1906a5 33de8d260d6fb249d5355b3cff91b10dac5429ebbc1e19727a90c6d37e48ea63 d3432992bde1499d48b1528bb5ae2e29fb411ccb0986db29f213a8272310df01c858a6d05392901c24f8094b85b179783b13f4efdc59d87fc836ac8c0c52c9024f229c0d2638de0cf91983683360acd87517d4156a014a547b622f8df4a3feb20e527a0800fc54406165474297540e44dd7fa0391f8c816909cd8fb0910da50398c4405194c3089a59a0c2cc150a099380a78ab56fcbc4f5b8a04d215e37780dc827b35539f1b4b1e0b159e826cc3bcba5aa4dab2d7e07bfeb4fcb93c4ef0206 false +check_ring_signature 9b45bcb602d21b21ffca8dddd55ee725cc37c0185beb5956b75c28b4885eec8d 3c61e6c7b52b59c24dba8404d69fd5844538dc1624c8ff5314e875e35e75c4b5 1 106234baed705041bafd2205b7fbf911359a15ede31b4aa2eb74cb75f90ec5da 5949ac73cb7e04a8c424185bf1524c7436fb63b9af2613fa824da4163da5b709e2c817d2e06f5a9ae142cf2caacf105574eef4632e4519489ec601a5da1b030b true +check_ring_signature 975eaad62d2cb9d17f03e9c02de7f5f53b756e4a3d33e1ab0d746a10a784a1b3 f763487eb94a474ee62305effb15e8e9a2ae4e96d982ef8fc85e1b60a996ae10 14 bb080838c13a858823df76fd684d087e2d4b3f8e1c3f0289ef12e907a2f86b78 910359f0a0260e9cddc0d9739afb4a901f4a9a4503111451b9d5466af32c8a43 4b4d674588256bcf9c56cd536fdfb3272bde2e533e9ad5b4801b5054c7d1c4d4 ef2a81053f5479e8f09dc57fa8a7b648149573f7ede061f3b1904a1b8a40d457 ba0deb2c763972f7c92568605e85cac9eebfa22d759e937bc7fdb68a8456bd8a 08d7c3eef62a06b0b7c1120a91120bf2a8db6756a0b4110f20bf3f6cf7147284 d8298ce820783eafc01abbe0eb8d992ee074334b43cb25b37847ffb6773699b3 097aea15c1758cd52fa38ff7345bc5e02a5fdfdd570e2d9d6e7bcd2ffa3f9c9b c2c35841d29657d304ab3ca80bb9c5e486a2db461c0079b638babb1d73447f38 cba2d41a7a987c4d1dc770b354983f5cbbca47538e5b093ee557db75787f2de2 e5bd35f57870d046c233f4e07ae0d7e20dd1e6d24634734c4145a2b1e80c205f 957a7635de0f1d047793a299e5dc2c142afd0c46394b32e4d5a49feab205b09f b8ec2c752e916b4c5367d1b8a4ff79e948f861d656ad9a09752213c0a0795e03 2d2f8199aaa3a7f4aa5c782a244c1488b6577af1229376ca9719bd51e5c2455e 7659867eab16aaba884590ad1a26ba01a4864ba8116251b5ee54aefc497bff05bdbb0cc69dd78e89fbf100ee07c40284d791fa362c98b3b12b69c612e64d2b07d854428655c037154c221db56700d22955d63a509baeca0d9dc175c399a3f5078c4c9b60882db507fe51cfb676705f6db2f8b297d013f58b3117b5a0dd64930b2465cc563f31e5744981dfc1a70c7508e4978227a9592d603bd9f57e66050d0857975d7d78dddce61a843f95b65c0bf7f858411041f22eca2960f4e74775ec063e0dfd635c5fc54246cd176556b496edb83e12f73bf4b40251bd6cd6266dcb086776d6889b90473289d8f455faefc4384c53ff40dfe7053de5dfd695363f3f06569655c570eb6dae6fe58a7578e2c9e43ab00e5ad8564f5d60f88bbdbf894409b35176279e36d4ea85244381b7888262da2fa455c1539b3e0063f4e4f9b2bb0dec13990320fce6330691ca7304cf76adb7ddcd1aed312c511114363ff869510e4935640819cba899c8904b505f2276b09af8bab87785f61c0e2a972277288602848614ac580fee8d9c01251ac72c5b75e924794295d1f710fede9e41a27a9d03f04c7650a932c16ba497c7f02c95566f668e8e5dcdfd56ad8704f2fde798baf88b6959ce6fa6d1beb34902eb7045b693d9b1e59ce32d3eeae82a7e3fe3a36c07ab558f4bc0d645736740100fd4eda9026719b7c2d55119ee7cc5922deee31d00831a50f4aab17331532edac4ba430412aba4e33a2579b9608716943ab1d25f088420c62fea4b23784ea38d67fc48576c1691fee91904f3be91cf3b1c23a35308c4b60f2b9056fcb85d36371426a3fe804516b1194d0f68faabf4867b2f006c07926081eb77a391bcc89c4fd2724083d072325cadabf0e09e83556d57c8b238002b961d6b44b9197c20854b7ffa1d57a36859383abaffc885b9d1ca715cdb130359718d230f205f4ffcd2b478c7a1aa5f242e6b04aaa6f3eaff9b6017194f9e039bef69b473098034638406cbc7d1954a9d025ab82665e5a61ddfac7486aca809129b826c360d577278403166d48a4b6a770a2bd1bc965497301c40ccff6aa9056da15757e62a7526100f1175857136598fbe0cbdfd518d1bd925d2e7e29d4db2627f586b85f984b48f573fd05abc2360a73c15bb520481a1658440c2202f300345c31af19d9e00bd5daf64ab4d4aa6ce9ff00dd9556a5a66b0960034f5a697052baf9af97f3baef519608ce3a11ba4328989eb16e2ced64208e2c0691dfeaa05 false +check_ring_signature 3e267796bc50007faafb36a8ee7780eda5bf4f7e412fa0457dc67aa13f71dbc0 4e331942925910ad379ca62579d5f319bdf43dc6100fc6ebb59bec22421a56cb 16 ed26502f0b479b288d603648f920108d1fc8812949ce0d4ebc2a20dc792ceb6a 99a3d93bc5d93639b9ae2256f41f9c25c89dd2c2881d637349b135b8e010c470 9c647f823a3c2d9e8c6926cbe887813e2f99ee0234f1cb976476f527527386b5 60d3bdd16cf539f9a2070f525215d00dd75f243730f15fb06f6fc6bca41cb167 3df24627e57414457bab1eebb5bc340086e07f85a340173efb60e3a619108e8c 04bbf2d8a5f791650f753243fa634033c311289ab0b549302f2297e7a97ede8e dc17a26d6fdc9c8329222c46e090e03a472ea237c38c0b594e9282f96789473a 02829136d31d1a0ad7e2e9ae2f065b7baf7bb7122fa2bf3e6d2c7d9b4f997beb e223534308c844fe8a2ae4fdf5720104e3bf31b4bc42a8f58ea4f49d76ddc66c 5628fd2faba6894b3e22144fae271aa3a15ea3ed2adf400c40f8b0fdcb7a0240 dd995c83aa9b8d80c7d298204ed83abc98013c0d4a5d43e8460c6951f6edf211 d4a71fbeeb5c8b4954e0bb61ccf545fe4b01b757ad8584a2e117e662c60b8496 0c1b95ee43e98ae38a6ee8d171617f991ee28bd031371ba469581b2b442a0848 733f0390cdf0f9bafe70278797d682965336509485deea7402df25f1bdd5ffd2 bc162adabc7075ad3673511115c978dbf31a4929b9bb3be5fdae2857adfb51b1 f302d17a9d4daabc93d785b3ecbd542b34c9b3f35fd7ee73cb97be787de4f862 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 false +check_ring_signature 6ee05c303241e5f2efe1b18e4d177ca34b7848e6a7e5d6844b2a91bf10e2053f 13a21cfabae60384fb3960ae6c776e3db5d535eeab229620d105c4d0cdf5fa6b 1 b4b080d2704a0cac7da8043ba02cba7c46c3de51946a4611af11cb6170ac5f25 001dadf87345c77ec33a58f232db160fcf17bbb6da8d72f36de0b6d28d31a6099aab8e4bdd4fd6c5b144372585039956763ceb9b3551ad4f4997f8be4df9a907 false +check_ring_signature be2100645ebc642409d63bfe78a46afd8d384869fe1608db11a21f76dc7dc6f9 640b83e305f7024acf4f3d7cea9de72015485a0b3c24eec488280ccbdb5d03e1 46 3d65b23be2f31d7fdc04cebee591aa9f93450b0a55d0890306cf53998da06f11 72ed7300f8fd118fe0be9cafe8a86dfc3a203c1ef51fa6135fdc205e53d3cf2e 9a9f24d0468eb90a6cd90d74cba92bf80da3553a66e01b23aa4f033fdf6d0dd5 982614069b49daba62b8402cab7cc66b92b50135cd3f0d20b6e2ce6c21b58fd4 b9c34228225155d733372d281df7c06ae4bcfafb16dd82c87c06e7d8065914e8 2c97a02c1a7ae307967a89922219d5f2425175d5ecc18e964c9c149fcc8aecb0 22b817d741bd49a0e126b646c7e1363df19931192531faabe60010a784ececba fdde45ad1a9faddccfda09f9e126946e9fd8ccb6ba39bbe14eef749d30db3c7a 4e7d8fa7591e855a450cd151b01189b57bed961a4165c73536d6e52e87a64392 833b917a977bb47f449e623ddd9982862823331c772476af5facc30cef4a446a 4251b0a6be427ad89d834f63e733f846038dbdf8acf7368d599dd9fb727b9975 a1ad484f5eeed848094f6bb24f81f701437e07abd8d4f857d818b770f875175d deeabe52039ccaac3f1c7af4b8285920fd96c3a5a670b3799cd52c23a4e46e3c 3a95fb3011d9a1495e2dbde8b3654041a3c1b74ad62b918091b24840dcf34ed5 146ce12649dd120d64ac1c7d26ebce5be33333f57e51adb62c65cbd084609e62 3017eb6f4c5a6de973dd22157ab2090701737726a668b4d8fc7fa557a8c5dfa9 9c0da5ddab5802cb3b15d9084428ab5f7bd36c3cbdff258bb9198dd9d24aca89 a0c6ef15d03b9fabae63f4cf810ecb7b01a67c0f20a3f6702e4ae528b82bba4c 9eae46dfb8edf0a56bdfcc88bf5336403c4e6837bbef952721185955890a5bdd b97f01ee06a9bb1982f93eca1a96648f8979e77f3b1627fc1a3a280eacf171e4 3f5950398b97d08f1d8380d41991e33d8d44d9536c581e961ed5d35654744931 35c393fc22b7b0c1f70c7421d6f37c8061ceadc37c8989fbd8d73eb978bf1bd5 b5eaa32914d74b81d8cfa9b958fae7c40835b7102cbfd210750fd880d2a9964e 77becd6828df0b290c6e5a11385224b4852b3b5a97dfb79012ce785c634250cb 9f212717199d89641c8f9be79c30a126b2d6f76f246feada54866ae21f7b7644 3eef86201d8398bb4f45d93ccd21d392663620efedad59f90cf9ad892547da8a 2f75f0f0a05bfa58c7cdbbba9ba5473efd7237eda5c128c6d0f971b23ceaf355 c7a25cf5cd9269ab3dc3865062bd5bb2479220b00206f6cb7386df534df0822b c6fa7598f0bc54a6c896fdc47e38b05dd60329722e448b038a2f0b1bba89bb5e cc8ee814144e520365444868fd9e5612eeefc22fd1d69c9b1cc417d7ccfcf79b 8918c969ef151a783cd10c5b4d6394743bf3d33255adbcdabfb878cd6078a9f1 b670731180bd25c8e8f4edfaf380139891d16bd69ad7e02098ab67370a268d4b 9cc3d5d532221ac8aa683d1f1261a3193d22d25193fc794bbb5d3163cae55580 471d913eb9ba56cfaeb5e2b1586d27d61c805604383eb1f40eb0c44f6448f456 5f6de603c371697e4de713a2e8282e063f3dc338d82dede935b27d09751414cd bc3bd2a5701ec97a46e562be50a337914dbe3d138675d362f7811a579cbcf420 d0bc3471c34141b5c07887534d5b5233a5b93c4737885af419664d0d7f9b873d 90e65b27b17aec4424971b34e75c5d9d4efb53aaa88dccae52b25eef92cd7cff d5d8f0ed76fbfcf1c6b82d372e2c50c1c48ec1899abec3aa0bd5d75fa0749758 18d3164e6a3e5fa5a4d84f8724707b31d6f3ad974ed88e417835362150248c65 36fa2a8c47ad1ecca09914da30b1299fc4604df0d66e8b5a432c573d8ca74c5c 73318b797db8bf374de2208fca346931800f066cc61b85a9d314365b16591f0e 6ab2888721b0410ff16a926c86bedc1dbfc6a629d83a91a37c9be0fd29001668 fc0ec36830621e009574a33ab1513e0200797326410cc289c13defc474df1c7d 78e958b4a79ba80bb30c7424dc89d6385615014a09f8ad3e2e408c7e0579bb83 e531e20d5503d07dec2ac945e8872b6a50ae2f567e5632085e9dc030c1b1942c 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 false +check_ring_signature 67ca8409c161a5fa1f71ab91a6643ec1c9abe6a8cec18946576fdfb3ee9dcfa8 c6953e0be151d955c9a8f17514b9e2593cfd0194635cb7240dc457ff14256555 27 7426dd96dc314fe08ea7e82f8ab7818a4af3c75d9752276b789af035ffa3ebf0 19230427a745345393a1d6f022567e51b988427ae3d21669051e90c8a8ed0c6f 634b5523b72f739a48595e839122c0dca46d6500ce380a52675a64ad9f6fa955 d9d1dd89347f74611b328894bc7a4e8beb425c0dcf0b4b9801de914f241fd08e 83fb2aa4a0a00bfc9c5be7194d096e2290e3d57582cc8aae3b1bc64016abc8e8 5759e9c1aebcfc83a1454fd18310758b1dd3fd0b52bdb486207526d2561b7e1a 028b2d40ac793dd548b4a2d1cae6b6aae09d8acb45e39b0bd9364426ec570c60 1fee6fe54a01af6cb7ffcf4b685f3c5349a60bb4e73084794b758085f079170c 868394880792e2f30542ada768ec1efb9422ea214be68fa5906e587d79e199cc d41d5f7be3675c74c21e063a09714522b2528b83473ced1c19fe658729f9dae8 22f3c72599a2257c28663a982350bd0c4987f0042b5d2e3c8e6c1d703e400837 9aee674b9bd82107e9345fb94d85201a85689cd5288797683637d12d925d6819 07a8727ac12d0ae75695e856ea76ca2deb5aa487b7f99f9e5a2e85b4a8c4ffe0 00d7abe3a5ac37a635b94576cb516964a1ca5e17a25a405943b70ac6a8a505f9 d9375925718df1999aff3c2eeb292c1a955448323a2d46ecf29e778d741650df 55d20d2bf831f90fda7bc290d0e6cfe1e2447ec47e7b4a7b646f681a8e8ac933 f9c94cc6e8aae342c47a2e4eead6b5cfe97811c2d9024a5328a766937ff236b5 ecc5bc0d79b9340d816854ecc9eec48e4bb33196c03dfa6c871763e154a205a8 a98f564c6b8e3fc3bdf089c1280d1c91f2645b6efeb0bd877bd152b3b920c674 368d0f3be0052d9cf8deafb328191971e8819ede070b8694c990c881846b55a4 3b8a9ff69578d44efa038e49ec25d86567b00661bec3e86890e82c8ccb52edf1 849d7e2a9cce53517617b750ce54c04841c06c660f2112ae860043370a11f1c7 8599c2f30c4f36d2424c572d34ac876a363889eb06504bdac6ec0d96bd479114 4f928e7ecb606c63ec4e1610e41ba3d9e776da083d526667106f99ec197c0f7c 736e3da2a76beae397b622c6618473b34684e7e941a9134f06fe9316487c9f72 308d3e9049f0c03d0fdeb722a8133004e5e25afc76091cdeca84b95091f047ac 2de58a98042e89e77e5c1006eed230503fabc81f69ac043aa85b42c6cf96fed7 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 true +check_ring_signature b4a464b75842fe8cad865901e9481dbf72085fb56085bd62734993f6b8f35f4f 3ac686b317575f986506e1a09a529a0ddb506bb981aadd9d8aa0737c1ff484e3 17 582ad9475df0a198c4087efc6f75d10bfae7074977bba75cca19e9cf6b5c6d60 2fc7e44a3a4edacd89a857c98060aea5afa8d152c8043ce2ea814cd0b5974dcc 7b38ede5a8c117cd87cedbca018f7f3394f8a50d03869850537bd464fa50447e 0ab968ccb81d774b7ff44015af007a989629fb67b4d5ea12192ddf958ca926a7 4a02fcb39507f649fc53ff19f9af2e6537c5f20c3ceac93b917e0f46da520f27 9c35f2942bd8b28b11dd5804730d5949227932c5d7cf62eb95dac5ce231af524 864a401a8e188543517059e48c6ae0b2a82f2eec1e418255e3cc55a33e19c441 8d00130b88513ce7df2584a6a7a1f47cf2f8e3c7003b3d0ea273e01e80af93cc 3f2efddaab7944e603cdf6758fb90f74e3ef35adb98e1c49ff868b6014314eb6 7165cc7b0ef414054beb9c72c0e59c569d4f3599d3561288ee39a05ee6538d77 93145a1966fc97af27774d47eeb428f84851d3b4f7f6b5f61bfe9b364028c8f4 7e90414c89543bf6b3bb9632042252a28e7f52b95109a67fccaaa66adddcf4b8 274fbcb306c551179ce8bdd2d338f372b3d92d016a2679fe393eb983501d67c7 4d0b1fc75b5020ce5e396f34cc0c0e67c050b05b827592da6119296720a08a89 3bc5703a86aeb8b69cd2696b35afe235d196ceddd7d35934a92e85367a8b2764 44b27ea1e3034a1d1743c7f46c85c6d0baaf63fd87923016cc20dfdb88460b40 e74219e13d6b7aff93961d426f690923e10a0520271e9f605a92e14458b41bec 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 true +check_ring_signature 923f26c6a7cdfd806795b4522af5ec0deb7aab52b97c2cf7daf9ea525fa71fb7 bf7746fe0aab45f9efa7948caaf3a36a05ced27475fa87f11b13ae75e3c10a8e 6 3def33768a1437279846e16a71bd5f81c4f8e17b1fdcfe1f09b17e0d1065e033 790a3999fb4e9d69b251a388cad7a0441008b9c7c2eb52162a6e3a4964d392f8 232a63298fc24c52c90bfb7877991f53a77079c31e370646d52e05a0b4528832 255f1545c8c1fe601a864b158025e2120363c090609bbb0b33f95792907b2b72 c3a386f02904f7b6a24b00c2f5fd56052a0776889baa1ba182b8457418db80f0 815fb0aa8537797459579d2d2bdfa879b8afd64429faee10b2ca5b0f0bfa7bb3 4f3eacaaab3552896947409edbc44a7ef4674cff54085189457586434c88b1049aa183586c85e80992106b7dcc8d273fb8ac6d38ec299f763b865d816bf7f303679e8ab0a74aaf083b1851a0342565c7d7ea81f4412ae060ace096f5c44c600fd438d951b7b2ab1553314a78b7b42e89c36e8ee49057acaca183977b6c1a7e00a8ea76a200a6c98ec402e7a8dce7b435514fb23c992e279d4db62e93464a420a840ead6936e54aeab9911a871d7e658dce1770a090b670be546084dfbdb1ae07b94879a98c174909487d7f57d36d3e8c1c97376453e5e55142fb211590bda300637ef4b7a4315e26eb8ad5dfde374369a85a540aa4f3832f1b2e5c0c4ac5960f047800b0b6fcd2088c95d7b6b49afaa602bd07e1f0feb1a315a926a7efbc280d69d0c91bc131473c9ef9e439a5d2763684531f7f2426867575fde03641077da04536319223196078aeb2d8924ec0c1b0c3d23a84ae6d1a52632bbb21f6f4a40296cb5bce19d9157f0e63c6f49499c627cafb26751d26fc88f4aa9dbc499dd10a false +check_ring_signature 9643b9170aa3c8b8265f603ff487443a084f219e6d69ed7cdd02186ade78a563 a47f07db2b84a44f6489f02a5c0ba225a6bf80483b343e5b5f575d210eb07580 1 7ac7920e31be92605735dd5915de211bbec0f084b4e4a84a69205e86f72ddcdd 4f4703bb61a884895c6f73ba14ca4930f0b5c241326d8a5b876637d55c68e208eb6d87c8d7351ca8fe59012346eb921a423accde763b8e82f685b60cfbed2d0d false +check_ring_signature 74a1e669688598bcf8cef3aba417985c3141a65ab7005ecc4634e4245be2b050 e37557a20cda2990455e1af2895866b800be131486b157ed5b06d63f82948564 1 ecf497908dccff4adc3f914dd11199a12ca9b378003cbfaba86495e9976be1fe a4c50cbe2ee8d0664a7200ff609f6a9fabce000715f974148499aba4a6a2ec038735cbe6864e6f7d17d2e17db1ebd385ad5813389e41ee48dd888df6bb2e3903 true +check_ring_signature 09eb68a943358d3da4ba0ca34503b64a7e917ea968c5d7b79c974f855142f518 08162384fd803e66fc431ca3e1c96fd60f25ee6933436c6d0eb9e0877a5053ac 8 43ed8f944b02f477e82631db4e7e070bf4b4bdb86dcdda96d5ca1660af060606 cf02c64168489819f3f4ceaeced75848c309b3879c367dd7690c85942dfd59cb ba0619b21cf4dc5f617fc6704e2ea68dfd678b71864621a96b80f6a4b6efcb2c 0075d4a46ca8c3d42b606f9a3b87288d0b9132728fec66f052dec8d220acd8ed 8d7b48dce019e558d58f8a22bd3fdc0747653aa231abed26d4205d15e44b8fa7 dacc2604c0ab5aa3cb2c8a67e08cfb3cb93ecb51bccc5cbe1b7cf737aaa30b43 ff72be9128280df116cdae50e47956b65e3d67aa33af1c860ab0195f958c3684 ba02222b617d1f1d540fe1a3b1cc60da5beedadd7ea9e99765caf04ce1e431ae 6fb3b79f132fccdad270d5239378d371154a73263f75ce8f712feb1da0d6b10fb29721373e5b2a3144ad24658bd72c28097781b49eb7c9c75062f30c8c37c00aceb4d10081972ad884f111f505aa426ac085d2998067502790c0d36c21952205a4d54cd61544943b583b06ec663bbc841dec5b74ab3df238ec2b9aa71580340ba2687f11f421c99058cc7c611442ac5400358ba5ec0ae0230ed89ff25875cb0ddb43b97170f206279ae554a8b62714ba20753d0fcd9473c924c3f11e87ece706f917c0e33d3186d3d7a9df6b3a378fa6120608b6486a9713816a83322c455801a5b55abab338c9c4e945cf0a29ff01dde891fa38d9d525cd2d3f24cb661126057e7b31ce4a00f68b8a71e1907b8ebf972910503e7c822b838411dce70a4049074c9b1f15589b0670cba4568e57709a27ccefbbcbed4e1acf914acc3aadd7580a88092e9285dc10d27759c83d0cd293917366ef124fe26720b5dd95d241d47007d39997d68b2a091cde5bf8e32d4d055a67451de13359e3c608f6c1a74bc4cf0d78edf0251ebd36a60ed65ff370a59e0575011f0ded6b526fbc8b16a241dab10804d1e4289e24cc12e9fb6c9983c4697a6ea0e892bb95f3d4211d99e909be260fcdd633fc53d6ff7c0cb1c3bc7e5a6ccdbba9131613d7352e7e26dabee7e1be044e84a849852796b8f5ba31b8448cc148271c617f63a00974c04e6bd35e4fd80d true +check_ring_signature a578518cc07aadde1ea688180b5bff313070568c139cabad7d675abea3fa7a3f 9fcb186bac81d4bdc70101171db3e8724467eaf39557f156aceec39b90ec552a 51 42739b76a28aa61cccd4112165bbc2a56e93f8a9f5f102f3ae38370415a1ab6d 66e58bfad42ec3ded560a433b859408c4dc61187d7251cba026890b3b555cb1c 5f123053d666d8fb771e340f43f43c984f5de2107d514cccce10d985f6a2ebac 174085f2c190a81aa294fa290602a73797ae4d8441190231e2e660e0dad4e75f 4296a9dfee0865371dc618a769f98d47379c2c86b1f9fdb9b528b83dfaec4f55 6839553191c8271aec28f5075a0340cd05f6cdf46586a56d5862ec0c553ff40b 96306335673d7d50714430cdad59ddfb899c57b628395f0f76ac8fdc9a7c1a88 98903c6cff76228a83b2e425dbd1e7115428bd8a5d31e21cf5a4a7042b098308 f77a53c8624f4cec80902d31a3be969f5ab4cbab15e9ca5b531ca6a985d4715a 6a49cdd7f60f181da5f25374dd008c7bae5b17c3f4694a6913c26e3af05e25b7 95a22d1193ebc84e78f16e1fca06df908ca5ed009adb9772d2d548b3da86b10b f994c9ee41c73cedd60635748e4dc950adc699196b73ec381e92d7c7a2497d3d 46ddd53f88db214b8c2cca702f9b31f3e9ba4a52ed25d6b3dd08aa7836ac1428 99a1d5fd90439962657d1995ad803b475c5e3286dca34bcd98903bef103580d4 b2ae120acf919892e23f32d5f65730d0d7b1b792f41163c84c466bd664ad9ef3 fe6cd104f670b62f3f23865d2ef49907bb5a33fc11281d03b869fefc3cf4b04c 816085cafd2fddb82ffad7be6b7b4a3ff4a1ea379c78895a18f5f3c5f4b86484 c104971371a1e2e90e8770a01b01493eec256e3f4c723a54bcc9f234795d8240 5b2c24cba318abf50750cccecbead77879fb5d7d32fc69f89a7749891d7a60aa e5b5fa8dd4b83a1e9f5cc539472255bd4550cd5e1498f819d6c71f49c9635e83 1ecf1d06ff9168d0e79860aca757444abc6ba43a3bb7bc4855df82c80a906d91 14d1ee80d734415924f19f19027d3be8f1a5d35ebac15d2660365b4a1e3449b6 71de01ad2197fcaf83aa0a88f070f956b3fa272680ba7b2d5a5d147188968088 e5f318c9ba0cde83cacab7524ab432a083dc938425b2680cf252968826ba7b19 8bd68d8059afd927ea752de14bee958dbbae739989c5ce4262c0efb82d6190a4 724d4495c2606a928303c21f8aac5e6c01cefe642c67d02e95fcbbb76455b273 f90796a050821d8d371b44f64e83fb084e562930bffd93ce3bfe3660ce51758e bd4b0ca0e0700527d2ce7e0009947ed6d6d8cf695448c789195eb39afa6e6823 fa0ff056771cf173146e3c215f9f653f28eb8fe0e940a2cb2634687e43044f1c bc07232af720d67ee2bd81bd535d568482b8daafd7060873f376e6814f1bb41b b495986db2e7b09ef7ca8c8dd66955e30bb3c7d4cafbdadc34106c21a633d26c 6d46a74464fa65fc4af8154986a73e3e0ffe847cca6a41c01dbbce7d09c9acc5 742da1943e472cd24e091f5903436617bede5519e601860833892a6eb4ee87b4 a27bd3b822cee7dcaa87f9d7f409b52ef9daa8a798d3dabddcab5d6607373213 e7ef890043b3fe57a294ec11b702fcf7ba026090dce5902195b8e31e5eeda99d 4d5bb0347ca29621fe7ec9e94a18355a1f61d0c37673b7c97a9bc653b052e8cb 8d4425c9670d1f814de43595ffc11fcde60ffd35e9911a912de9c5e26e71d704 8db3f74080255f33366f64bd3674d33da8a656cbfd410ca1d9da607794bca91a a8c0f7700c416e1d633a1dbbbcd83c61b1bc08de319ffdaf7a48d250fe99d3c4 42d5ca0dc8ea39938ccf0b2c814c4644fd2e4e4eb2ea71759dd20c1263562941 5f6883f3c6e0f2619c1dca76bbcf9c594e1927dd29a7bd22fb0aa1899e51d21d 6da6f36f85bbef6710b113626127b0d01c80842b79546e0728fa9f9593e586dc 50119ec286c11b617730939e3c5a89ef52854598499ec28981a78a4e6862700e 45181ff9e7e1c066f1e81d2d469767ab33e461d902591f5415819e864c5d7970 09fd71d3c54382accd9ace15c5deb68f67a76980b0725b31f3fc231817bf9a77 e3f753b40b72bdb96abf10c51787a6abb9b064a813ef80ef015d90f8de9ee79c 98e8853ca82ee6a8ded0d8bc5e7d75e6f12e723919a9982129ab20044064920b 7ccec3bbcecc3134ecd68706ad4d15d2367c2a2bd094026f27efb8e2bbeca5fd 0d81ae79db68f7db1e14bdb3c808fb13ec7db13e6db189f7c1479b7e599c4fe5 9e70dbb77d06ea3ff2b14f078b68b6413539f6e1365aaaf3127b2c439a338673 56b03519d53bdd7ff774d2cb158de33af0360a3a3c789a9eba545d10fd21baf4 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 false +check_ring_signature 87ab27cc6a980cbf4a374d79cf3482c0bbcb5dc6c9cef726f45e4629235f9864 b2e6042391020dbad70e5cc1e30735d06b53556e5ddeb478cf8821dcd67cbbbe 22 d17219bbd50d2e5178587101a3a94b32ab5a225aa73d54bb1819bb6bf307d80b dba3f40dba7252bd3886407df65e5d18c7d8f09144fffca8ce2a295c2902ac19 1809395b73b6aff3d92971e00beae032dd98eede419a28236d855f62771017f0 ca7120708735d2955f0631c48d45ed3ef8e5df57a95fd1bdf1077d32d3d718bd 9a97104912d7f5c0bf8d6eb85b4991dc138469be6a5abc395359097574c9fae6 8ebc2dd55bc9c22d3a6a353fb94a8252e4314ebc2a4c268e122169ac9216a44d 8b61e7ebb548c0af4e4e2f3ddd48090d96cf231aef578b93960c28f25311514b f59ec8f25b1950bdec64c7454896519dd0c892ac793b2a3d2ceb8c06974307b3 52ff00cf1ef6ca072a857cfc45a7c5f9d93c03a6d653885d062c7627b08d2d31 39861b9c8c707e498f11e3c8ff94793ceca7ec876b3a40a18326681f2c23c927 3dea66e978dfcaf0cf8a5a70fde33297955e88a750ca39a16696ca79ff6fbecd 3b9943b9ebf3e4b05a8f18d4d80b06acdc30f263c335795c71dad6d40f384f35 111944ab6457d73bff5247f2932f0c13299763b694cd3c597c86472beef2e644 e6a9fab5f2b9fae476b97413f7027dd0bf22ad487febc1186812913d4e484d5a e3544bf48792023abe59cc893e1890945e5359c1b37f9c2d0b4955022dcee99d 2b3fb7e7627aba1af6b8375d3363d32e70091831bdb680e18f8a3b25a1c2fa3e de8675d2523de939efbd52e9be3dc0d8d1fd8fd2c468ecd6611336aec8d1dd30 454f343069e7ca860e37673f0713a06488a1695e0034573fc6d2d1ca6037010c 7f90105d4544caa4d2365e7659e0dae3ec70cb13ca696e9bc508c93a1f0defa0 700dd5caa800cd7ac323edda07ede082991946964d31ddf07f6d1989436fd349 7bf17a9f0942395bdd58a3653e1fd07ee4bb733d1a6934be01291954cc7ebdbc 2668efb01418655c7e372fe72d174b253049989719df7683d66ba7a4e9ef8d11 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 false +check_ring_signature ceac4a97a872aa49b148ac94878b237f2995b52e421c140cba8df756e799f648 d39348a73281ba8011cbdfa13dee780b243ae79c8227ef6cfd92e2e8483f1009 204 f604342599f3e0ee59d65eaa3c5f67ec87d5bfb55ce578fccc4ebd0d4728a53b 4ebd4b915c31e0ef3d8b9732f2e28906e57c3db6f20e6289c39ac97609de5bb7 3637857321a9c77e729e8dee946678e80fea9c8161219a56abd55fa0d7dbf0f0 91bbff988fb8a5819bafbfaf6979c54bddcd0ee3a8d14e1179bf8036fcacfcc0 ddc534212fc4e4c05ff55779b5eb3701ace527cd002e818edb24a298814459e3 61669f64a804ab1cfd29f5d7759647379a26f60ae33368eaf94256147b270b6a dc114a86fadcedf8ae6d212497dbb3e5b656af5da4eb84e179abee2ed6d44dba 02c790dd9dfb4f572f6ba38999c0331f896e0390129b4dcea7f56d2fe7a8ec79 8cda6e03e427bd835112648732a46fa884cdd6d6d414d440d245e7c75a81b3ae ade002dfd78b0e1ce46471fc9cc6db6f69ca273499bba1c7653c0311083b1186 07c62518d5e099b59b0ea235fb4b7ab174298cc1ca4dae1cc60f917210e8c7c8 cad1d546c54719c81710b0273bc5fd343e02b8fd5e4d1d8bcdea8b51a8967813 60fea69d0fff6048fde8eb2492e2f0eb375662e7d647e3bdf4fe66e26204392c d6bb38d8c0a67f76004707189a982c1dd558e9523daff93bb5680018f121312f 665bb16d688303424f02656f46912ad1f744ffc180a28d54ba6c479ecf2ad058 1585570bf5b4510af914ae2a8f89e71488bae39bec0b01d77e37e7da932b57cc e5535c5d89c1a2cafaee58d0692d2b4cda063821e2434e28691cdea973a89652 0d709707eeaab999a424909a48314161d6b23341cfb9165b10856489d45236af add7127dffff6dc2f8731c8c6b1e8f439844970dd179161ebeed7d5adca7081b 7c60480b2e18c94960f4b43a04a3d1f3d839519520f24c0100733e76f6be8011 b63d258af3f2927178e9c3426c696a5a8d13d9d6b3b8500306ee7c9036c7f312 0f5cc49648b7b5c5b4195db5d6fd20fe3185e3c980937a3b6b2af5fc38ee14d0 3ac1502e969a529d6a96f2954566722c90ccfd3c72304edb4f31070ec99af149 fa7651b7a656f70e9eb4ce348b09bcb7b49c96baf8cbb84a7c6844272a13078c cbe3ddd0d78136c99a7d26eeab1fd26732f0d211dc2870a0d5a151f95076b4d2 abb43e59419d092cb266a71a3223707dfc5e85ae18dedfce817e1c4c26f148f1 1e7b523d840c1bc15624c4d9cfa7a07cc3fa5b53e48f5b73bef887943a997332 bfa7ce577ec67e2e4e97d9d30dc98257de842dc1835bf33cc9adbd5715ac255c 193d65c79f25285ebdb48e8f492944ab7bd572119c857970916a09a1c9b79e1a fb36c2cadb81144c959fb390329ff8b3b0ceeea5bb53b8fba07f305f3fd33b08 62859c282f23c7539ec47122eec7581e2e8455ecc89d3aea8c5644da9c45cc63 cd41f0bdfac6dc3885193bceebc49cb017c2b4f1a033e498f0b4275f3270430e eb8a3fcbf458c00a053475791d29af19b8f4c4faa0c2f2bd392a24eb3f185271 c01f7d31d9cc7224c4d18e8029e17394fcc9623ee5a2dde3587d87d0150df7b1 50a6ca93734a03cbdddb998bfa7961ce3db46947e3773d0cb0d8f7431b4dd523 fcb98edf8a89e31a5802c6527ac5a0fc68c59436a4e08632fb367b2f56146730 de432c1cd3a3be7b594ca81a4994d60b49c8c6d69be3dd46f5eb039a06e72373 6bf8062432d12a6aaea4ac66c6e5a245cfd412f443c521011b917597b207e015 41096aea8310358c3a97fe9fb7fbc31d86d0e4c0d9206b9f439aed2166c3dd80 acc1707a25297db78134d81a7aca14069d9f1b436cfa12501014a035b946fc71 8024c19f8b8b0870f9d06aeddfbece561cc8a8caec7d95f931cb7a35f494dbbd e95288b6fb90b07dd66c2eb51621b2385be55fd1d894d36b45a1b0ff5c9efcfe 752c432c3e235bd43df35a279d15ba97a4061f01128e207c3db5b3dd9724f47a 033af94490a358b571d49c6f55ea34d842b2f6d8fad6fd0105c5246ab5880b09 248f78e913e62f31c23203043e696b1b538d241b9ae9c683dd6a6b934e6f7ea4 dc3f5c1e8ddf18eb41630b7aa979174022a82edf6cf2988ffafa078e08352a00 06c925caf0677422d09190198b17295e9243750e6ddf87657df3d6212a67f358 ecd5c998bfaadd6469c599a98c3419c7549391d2e1aae567f1af7464209c811c bbbb3240136065ee552ed093a2d331cff08c469a7911b94c88613ea1a5147201 da9ebe67eea9d972d36a9a5a67fe9b0639d36f778d790817b69bbbb49dad3869 d0f5fbe613e18f4529c4455d09412f91a58e098f7e8c26265d1da644a498f101 221f0a971515d5d518fd08e70820caa6810db1b2e8e67bca86fa45458f9cf6d9 cde433dfe5b87676a81584a01619c9de70ada418e17ee884427aa3a1b726af3d 2464c630f6f06c679fe04eb102e46c8a0319439e31f98099d8c178e6299227a4 4403f38f36bfcd864a738daabe408ecf2f7d4075c9257ce27cdbcf7bd1a0016f 17c19487c46ab6e5f362ead0bd00aca736e12cd7191dc4450c1eb4d07f5ce613 bf3d54a179175de1158ec55e9818c0913a89cf1979d21448906ef6086ac38e21 dc04a58105728c2c34af78062664862e47f348fa0070ad9000a2435a27ce1588 9236c89bd6ea81c7520f3c9880c8fd7511f71f91764978d4a9075491c730309c ac9f87cc839c79a9f875139e664cf136643c735b6336284f432c41897a13415b 0ef714847fc67bbe8c58b1b29b96f5a3cb93eb19249bc222a569a3fcd824709b d8a563982a1ba85941a5121cf2afba8c589ab988260e4ac1e8a88b2cb6954f0c 71ba2c4919f404bc54cc1f95b93500e25462664b4ac1194b7f7c1d08f6d1398a 193271ac4c4c3402ac438d5413ec76856f16b7a0371724faffb1f9d9758b90a9 2e314af8f828ecb7dbadf56b15343bfd72b02331bff02936473ffeb01b6b5e1a 003a50abf77a8b6e089a507d4b10202789eb2c29dc7c88689978d4ca512356c2 b9d57c1d47fbf98ae63a510d77dd3e40c45156007e09f3f367d2d62e58f47261 b51e0174abde7122719f0f798f61630ca1f2e942bae5f56db2d049724135eed0 eaddeed669421bfda0f26e6e720ee62eea7ad2384ef83749b653bb8cb04e5948 29faedabd93a5c2418bea1610aabb26fdc9d2b50f29912715900abdd98952831 a59d1cc09f3710175792f8bc1e4786c5964c4fec3a38e3d95b2850988f480ae6 bc822e1ec4c55e38d56a5459819c2b8e1126f2bcb404bb8256aa49ac8d17cadf 70f2f77ce57d5928f14eaeb64ed1e9c5093a680a4ffabc615e28232e2ad56c81 9fbffd77186320b64c6202e2a3a29632005221c56733be61c87296e3d3ca7640 8914fd6ccd6e060dedba76e50c8652d6bebfb08089bebf1e547379564c62b027 9fdc384549744d0081fdb4a8471c91a878c4b70218e169cb5fbf6bace619733d 3835f26f2db998249972219f9a1b6562e86f84ea702fba24bb4b45e953235e99 41973abfae111a90e905dd96ca0216dbc582cd2d8597e87507ad8586ea9d9b57 1ddef820025fa78a4c27755101612852bef0f52fa1e35cc69910d3d0cf79a89a 6d7b814ca12542f6d10cc559013d21bcabff34204ed62ba40c4d648a99661a25 ef9251853872ad2808a7926f5721e6be2842668d7a0acd55c8b9fac4b3517b68 63cd4fe73a3e2162b6cbebb47965852adaa1622010725cdb1ec42408ac72c008 361e14835719025ca9d7f31ebd66717dfb16fbfe17878b52cb02749e03a144af 34a4011ce5d3748c716c93776a723062dc0998bf25d3f995cadfbaf50228dd62 0c81859f11b253b190999baffc0d3536fb7642994727170a941e2efc6e06e57b ac07d71bf6ac2888df2bc5f2d50e808ac7f66f1f4b8ce8719a7d367e05b69f22 b238422861e3916a442ea07e25f18b6f426863b2f4d3fada33114cfadc4983aa 361ba6c5ab2ef9dc4c2bb26f71bc19fa277bf311e256a5cea71f56839c6bc055 ffd5309c39bf603cd929b79689141fec2c840b83168eaa29b591633825951e7c aae000760cf008c01adb7bd23b1ea4491b51aaff5b1d5c8718e39e1761b51971 3bd88d32ad2daf65ad26cdd25033c3f5ef5494d0e0fe9eb5f7e0fb4c1c85e1c8 3771c310e4dbb161f0e99565268cbe237eb8beb48e685e83cd679e5a21f2bbb5 15f9a7be56b6a0c18ac9775cf2c19247afb3018d52325f9eb19d65716d5f8992 e921437112f677dc3283e55ca6ebb5de50d4987efbd0698c790f531c5aa03ec1 7c31955ebfc97dd6ef1ef509d4318a69ad828ca72e413aab0229c0c01dd475be e275f2630ab553c494ce7c1c5d64e2ddf2d4d90697616ece48f45e022cbe3ff8 d602471c1abd175eeb55c6cff99f3e4c632e86f953be6cec1d7ccc5842c42cca 63a12a6bf9a1dc58f20a71d18785d99f75eafcd938533c0b2fe6d2c1e5ce80f9 0948dcf0d912f0ced46ec4ed70cda3596eef6347ac48ce5545d7a7f46b07cdc0 1a4f1025d613c2caeff8f552d108cfba3425a42750f991ee649324e59b0c6fbf a34a1169544e6e079664cc1d1f2ecf6f3c97d423d88f584a5360648e930eeccf 50c8aa0aad97e27dc4a97d512577959755267eef3ab499efab679d9e240f4716 747c2d6185c237f5ba12cb77ea33da0f5c3779ba478e7a13dafe635a87bea761 be07f3f90a5e693d1c63b8f4a58530ae0b624292fe19c39029971f3fea463999 f7087a760318d4e2b8793efa39196ed0d11f67b34839fc29a523ec57d88b0218 554799e79b3cab6f66c094a85e14e7d43a9465ad8bc693881b06462a21a15da2 a444503ae2097ff626709df3ca7d14a8e5dd00e314ba997df5b4743148fb5e85 47f9d3e28ec206b4d4276401005d01f0698174dfc5e0308b712f0a6389f39e44 8f05b118940cf436421cc518d33d802e92c80c5cdfb7e61517c24aafa9807092 c259a00bc88d9583957545e026935ae9731a41c626ed31a681341804a12eb8a2 9c9bab624dac55eccb97d691d06c117e2f22a64fe2e861b3d422456a68b2670a acaaacfd17399b4a89ca19c0b371676a81b9a17b75a2faae8c0771e7d8af9307 59c43566f174ea96296d6f345af8aca00a152e9a8964621c6d48d8a389d8b9c9 c825e21052d083923b3f3eafdcec959fd92717dfd6cf79d883a4c1b2d55e703c a30ff15cf24eb21f1c910d6461bbab58e8d136361addd8ed619967ec55639fca 64489b197067b176ca4aeb6eacac2fa048eef9e891580982402d270c4cf0abed 5d8bf115de3849d0bd74b203650449f0ed8294d07743b4542f27f2be67fea0ab 3a543503e366952cd81502b356038bab89ec19222e101351899dbf324e1720a4 28cd580d43c881a267153a17b997680e306ac7209e99ae38d10346a2a8f00959 527ff468c67400a33527cfde146c27cc61a6bb0a5398b0b28dc0640afc636495 c1986d84fbce4b1c13def01e8ef230f4bea6ed55eaca5e70159e5063cd7fc096 2679afe926e81cd3bf8fa02c4b950b0018c7c373ef7216702e374c16a3b84440 88d82d5e5fdc1da061de8baaa2bbfc85334db5ca29737b668b9c743a27062505 ffe72c5a559099fc7857afab7497cc93017497bad377cf4ac53933411c710d6f 5e3dcd96fd8b817f5991b5d7ec2174ccb0c14311dfd70e07eb1e8a9be2378ed4 b2bf4c1733342eb04af501aaaa994bc1b0d572dc85199c0981c323c0f6f5deed 82c14a622068cf54888d02cb54835c668886045246647ebc07fb090a0cd8a39b a7ae49ca6ebd7824b9a7e9ef64ee4c27b644b8684a7b15f93c102400014f6058 b85a0236e00f36f54c8c1e2df4d46d768547678524351b1afadfb444964b6f28 eabfc33d2dd339fddbb1008f20901b0e86397d2095d0201e9651c95ee83a08d2 2637662741ae3c79417e9d0353eccdedff8e7f77c8306218f9133f71b1295d9d 01d5b967c47fc58bbc7d94f0d444404c4b8b947d40a0a29f9cafbfb62e307d7d 34849c4fa735be27ccddcbe46d0ce12e14cd711665c5415c7dccc78a9b3af7f2 f890fa4702ee235929f5049734972847afd562b5163efc3415a8d1cfcf537ede d634752c52939e2acced35013e8e4f68263ba92814aee7059c568a017dae280e de9363b46f284d8510f660d4c86264881a6fdd2497cdb61312a4d337c37480f1 779c007da7cbbe1f37779a6770c64f3cbf7c2db04d880a944ef3cc47a11e7fa2 afc549dd7ea15e8e7bd948e3e3109f3075b323ba5b77e325b3d2368439e3ee13 acc7ba62cba93d196604234839c590ec2a9f44e8ea2d4ccc95edb0e5e6c6ef60 ffbc311563634702e4fe3ecdcf8cfe791e44bfa842c5344ac82807dca08adbce c93d9183bcabdfc758dc761ffefc01e5ae931b861a2a92f17eeb12e305656d03 73b87ee6f37448beb5e548855154ef20da56ed2efbb7eeee430bf907c85f82ff ddab3ace06fcf167151317820d28a4e9d9d63de8ea2880f1a245a07e03de0da5 73d5408ea0e11495e204004feacde20e321785227f0810b756d228caff21b728 2527e1dade4535df9a42e7d271fb4e12d897cd5fa266032f1c46b0dabd2b0d67 b53b3c81d0d39c349db741ab2b9f8db3dd3b598d01e4ff038851d6a1a3ef26c7 fd939c0031505d05841721fdb677cff7a27efcb0753f28db71bf15b16274c390 63cea22c4ed719c54ad9800b79055b5916399dfff194568f139ba662cc9d4f15 b227c5219ddc580d6a09ac24812adb648f943d682b6044a77049e60d41e53aea a307fceaf1f2def6a822cea0987902d7caa1c5057ea145cee4cbe29d3ef678a6 ea72172b3ea097c8c2be7f922bbf0e0d59deb725040b73cd13250c828755cd93 bf7e46168d9f0bdc4d88d04bcd8d5decb16427bc768a0ecb86cb7c3a31efca0a 0e2020e31c6515ddb61b20bb4679163d8b4f1c168b3879116c3fd8037ce3d25f fc9f7b31c573e56da4a1576c97574bb4b08dcb98323f0c868e4c96949555d0c3 a69836b2bdf06fd14f72dfbfa243f3efa4e2ad7c886c800e845db2bb9313ea35 fb66cb548dad9bf5cb457ec32c1403dccb6e4c8a4b1f0cf5d4e3034a4af89402 ec604c9247d419174a6006ae148caa0ff2771f11bceac32264e14df5f9f49411 49a10bb097cdffa2b0e685bf690f713391bc322b186a1293590c13cb224481e8 cd7309e3c00dee6238bd0829db7f3d2272904119b896d6802851063aef0b6648 e4bc932e9f634977cc1acd7bcd65f879bc979bb5dc63fe913d0e2d23eed7ee3a 25b8382714dd2822cf6f2f63144a1d952779435875b9702787e442fab2edcf36 68d03048d1b1244ba2ecddc01c2848e50328ebb9f1bfbc8b5ff6465f786fcd63 2e20cece8a0c8c4022e17ff7882f7c3b61620c5bef2d7b3604c139f5684eedd0 97944ac6849b8af31cf8e460abaabf1019fa33e91af74af06326c32161f1f714 572290f9937ff4205dd7698675bf57866acb27163bee85b4d53662a7b3321adc 4eb698b8d66de693151907d57906379ba89971be1df4c3a0f756fe945f1375a8 473ea7544aacf320b6aa901661bca8bd8d9e4eae717e4ed75ecb919be738ce5c 8892b696d88c8af8a511fb227850201ec63a19c5263b7611cb98bc6a6e770ab5 63e9890151fc06371dd475b709056eeefc5451cdfd820fb976423731d77a471b 78f6d6b3789a652bc79719872aad8faa67241d69cad65364d8736f6e09816bec b92e5f160b7076a4a29d244a425efca86284c927f62cf72ba8080674d9c65f14 401171856440df887038b5128bfaece79ff618802b50d8492f3973c31d8f33a3 c1f266b46bd303d8f5a1833790a10c03b0794372f3312827a05f2447fc49ec05 26aa894565f85b408f34391b587f58873253e11f78aaf2be6d13666081a9041e 634659d439c506cbd982a6a0bbbf5aeac827252e1e356f474c5a572b4a64e20d ec350d00e67f78fb1b0d74cb130bcabc8709e1b9a405f092c8741680c0713396 fbe60943aa6bb5b0a1cf250c85b5c00da93a358e98c7dc97728a59c61cb3332e 78f0e33104b3de6ee8501273e14c52be68d68dfeba07508c4327bd96393c36d0 d51d70f3ef3dbe53def97ef36bc06512713981dbbe3ea13a22bdcf7038650e0e b8bd5faa9177b93f898f2769f31fe6afe544a7dc5debba6280437a56f26ad541 0aece4d1123524e280db6af5e033f7c5e0bb39cf2097d477cd2f6261ba29c73f ebfa4f6af74d1774fef336c5c5be623b043f066322c9eaa075a675f03c97762e bf7f416a637a803de9c2ec68c7113f4b3d0ef66cdffebabb1a7aaad68fe4143c ac49b3701e94cd6dc27d0224afe0fc0b3dc7ad9b18b21a45fe99f9b113623962 856db3fb4e19bb2c58088b3478133fde5a7c6cafb59c2d7f39ad88d1a3548562 16f3815c4b711d85aa00442075751c9a474d220476be7aa0f2c91333b54bcaeb 046b30140d57e61f0af2ea577881ca1e1dc4a98124bf9ee5eb6b067268f6af21 f8f7a43c9d9063386bf878fd2e56f914b1a63025ba85e1bed833aa363954ff10 3e8422f1e04c6386c777e37a8895306070a0e908e8efde096c96b437893f2b3f 1d6f4b9dbccec8fbc0637a9a90e10e60d3ff01088a4b1179fcab53b6384a001a b8b518dddc9f38e8491ffee38437d3ed896a821933ee364b53a0159e957d04b4 41c5b82014df1ae54a9aedac095df2be4fb068f3f09eb66edff7b723a2c63f0e 5c036958a90b8d7cd054c04861668a13e049a1561764a46800e37258d62a980e 365f94bb8b1a39dca3e4b2980328c9cd733d6c7bf6d26653950f5f5ce357e9b0 40a49a70d051d614b7b95a717bed58edd8ade4de3557ed367e88c517464a1a5e 97487382def088cf216462c0ccd9032adaefbfa358478d7731ae5231593c1ae9 0964d84c40f97c29bbc1a1c65cf2f21076b207f101618ab7fe4de907b4b39ebf cb845e0ef05c29af57c147076311b2da2e120fc2a5fa77f861273bbc6d2736ed 2e6abd048c1691f7e8e8b3c01e06ff94112401fbe3e0cb02e56f27ae3c76654b d78424ae1b71c5a67e15a4427060b8da7354108494e14654b9c6b8c9f97e15d3 bdd2ef0a3172617bd43ac1554f1f7715675e6d3025dcc82b8f98a65925e89154 a8dbdbeeb13352af5d8a62c086046ee4c6725a17ba7b8151e876a01375ce1bf8 28abba0b2121fecd55134017f75dc321eac7e654bdeafc2ee6987689a89f7a0b c8252977c64027240943430a38b6811e774b76ffb6aa1248a10803992e931136 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 false +check_ring_signature ff8c9ce9506f05ad58ce636b972aa3da201d8c673ddfe83f012742c52f85f70e 930ff5f225e005ef7a4b292c3364fc74a5ff1edab9f8a4a62dcb6f86b0f108c2 74 693b8f08056be66ad8b325f94b1ddf939863fb297913069b568bf9f2812c7e8b 64e0ee1a9fded86ba515586caaa7f9bf91a203dee9be86c4983b591e3770d7ef 193d73fbc615b46e2b2c5a8ce5af36ee111779c3bbbd4bdc4a64b4ea17881294 6c5d8cd4ac56576c9d0cd56762bda9e7df021106bd7fd561b8f93b96d17ee5f4 6e7826bb6c875505b98c00cb2da08d4eaa57a546dd86c0368ea6533b329b3398 904198591e8d043ba0b7e3cba74492912432c2904daeca0812ac5e646e266d98 19e10ab3500e835c24cdf3d4463eb78a63938feea605ccd716ea038f4d9fd491 589d097cbafa02a928049d159c635160d65e736bb85ff3d94ad8dc3cb38bc927 8ad1c032fdf435dec7fe5cf08b531e862447794f575cc1bca18a37aadfb56609 ba682e6a6d690c195afc2b34dc56c50385796cfa0a8730979568639d86ea9bb9 ac84e262c1d16cb20f98b8ae10b6420db77964715d90e165e5a17e4d1cead1f7 f8e4d908d3c37a1983886c79c48c2521a14806108a2cc0b2e8945319eded7871 8d844d91c6474ee8e862ec0dba4cee3890baff0cd8757e475cedb1f7a8bb8624 921456162a5942162c97006d8c6e83e094d3df90cfc3372de5f7fe7feee90cd0 05c4d10220710851dbd97feb365f9cfcb62fb6efd220c0808fc4a382cc1bac93 ea9d1281775a95f14c98e9bb5ba236137a8a8bf3e624fe5f19838ca56a9034fb e8bca275bba7d598ff6c88afbaa918e3623a871f83729350ac8956b03709b34c 1fd158d3740ee1eefc10155cb36b786b211135c9f4d0859b2006fa4fdffaf703 8ff5603f83b5ef67b91ede27e7e0e4b19dc729149ad682ccb5968c521129294f 63043b26a2569231a7ad54a3406e433f9f094f6e20a3deee4b9d86d3697eaf19 031b553f77b0e1a7fedc5a8feb5ecf7d94d98829660efa54f51b1c9f5095f208 dcb8417d6213d05cc79ed0b7ebfd33c2d2e9631640962e4d0e0820757034c004 698d929036b9c90a566f021a6f5c49c56d268a21c3c9be5c6f8b6d4f684c6a0b 82f7c0cec87e03f977d593d1a44efc531e57f72782c5960374b757caae9188dd fb0eb9ab27dae8b20196cffbd43218199ffad5f872d4bf3e69ec7f736565d2af 28cd0565036dfc2c43d1747d8cef1392fbc595519ca410fc3d7f97d74fcfbb13 4f36701e9d3f2b55442f312e63b2c305a4de22d7d12fa9783df1c5cb1b22facf 4f57c5f1b7bc7c8964fd8b5d8b94780ee6db1377861ab20aef9c761471832b35 ef7f3d4e38455cdeb6b800ae74373efd916f8f69a6150a605a9591469300f817 3e83a787d708cfe83f6755c59212d86f615b2ff042447ffb22d9d91f01953ae4 d75f767cb56b50b7c8fb84fedbdc68c28fd03a97fbf25b8d670f72b1f9f19a0b ff81fc3b97ac03fcbc2b4f2a60c03eb3cbd8fde52148e48a7ffe845ad3d3da3d 7ced3f046c76069a9cfd132e46753a27f39b22ac3b83b56952ddad9934c1148b 693fabdeb97e21349445eea7406f3f97c3a397edd77cbaf1777f7de890d037b6 f069074ed2cc1dcc7d09d889f9724c1d965f051a061052f841a0f9c21572a1cf f372bd3f6807cef7496bf21f447ac64de28635ba0dc8c1a9fdd67d5b012dd20e df8ea5a6cce5fbaab2325a24d4e994f83d7aaa844d8e81d2cbef21733b0d15cc 6959cc0abb27d11198627bb52c98ed9b102afc1b7ad12e336b0fa0684dd3c212 6e613d3f83f554185f4ec7d947e7f296b4dedabdf2216b5efbe2a423ce539e81 4d1073cc1e84d9e9bacd38c26ffa61a42d60523817c36895c597964de6679850 706c1a2c9d73c202386e32bba07d686b9be1c344543c30cfb3aa093ecb244ead 26dd162d71d134c1ed040c7d1d9e515fd095c8b0ada1aaa5a20ac8ffa1b65010 4eae16fcdc565b4ae48f8473db7f12332ae09021ccbd14c2d505e069c25c10ad 62de42b89e9c38a0884275dc653796d9ac9f24defbc894859ad2dc970e819fb4 ff90c6271da497c0418b970921119dbb834e939677a0a8ba920ae5d2bd589885 165029c549a731782b53fe1fdb7779adce43dfcb00137ed059ca11da92e3d215 f1b6929c23beab5ca67481b912179706a8c8b9f5283c115547d724f29f45ba43 b18cd9d3f8c9b2293c166dafc9c8a6f05164e64643ada8bf9e601619803e6145 5179fdf9ababf31d3daaaa62edf78d8f7dd79a2b60c083f9cb0341873599749d 0f8ff6e100fa5ee43cfa442c598010518520cfdb8d80c41d864f03f00633e324 f80df27448a68b4943eff3289fb9f6b236a61c89c6a89a0ca0509d34246904f1 6c6fcc3fab22079b459c5f891d82a0dd8f7a34a312d210c5de32a3d8603359bf dae084758c1ee7a2d9435e2e399476d47d9615665d5b538f452e0fb778bfa4d9 7628f20e56e5a20f8047b954f814d0271d4f14e1b02792cd15dd2601a774e06a 3bbc6a4ce4ce778c83af389e4876d8d6054569f515dea8b7947bd01a88ea336e 67dba0420586c0515909993d712b4137842cb5c10f9e584ca7e64ae8e133a65a 0c3af95b2542cb683da3933aef6b354abde16b6dd1fe10b4e952d5fc7781b468 8ff8c830d8ffac06728642ed2e4dbe2c13a3fd340552cbf21cc7a066923f0e75 3670e6dc5d576149fc9140aeabd775d3bd9d7ea43fc0d48a2b8f4b88b664b55c a36ef15f4f2f39650b2d9e41cc2748b6cea32fc56d1bc0658380340acdd1526a b1c2e3741a452fc334bbcac3e2c653d2613126f65f1a0e15e6c2298928585a1b 9c6f323eb272ed28207bb2ef3a7a973e622e20df8705e110acd1a034059c1d52 ff7f41f3d6e7b9a556440ab1d389bd17da53520c6770cd8913961deed7328476 b21b4c7540c3fbad7bf79043db3f2f9560cfba0afec55d4e9a12dd145705544f 6b0910d6bcb5266de6afb593c0b357827f459f7d735e666ac67654d3f035d843 ec13ea37ad3d4c77826beaa10d169dffcb560e34a96fe3dcc7e295ad19a0af51 d13fbf837dd79a15afc14c105aea2d636caab90a9be779b491ed99d7f7aa2a15 90842183e0e2781f8c07ccb012e4460c647853f71d0de6a3da333fb03d60ebd4 24637f4416bf0733148e44dbf1836902b080e8b06337dd09324b9e3f9259fa02 afce7377a3f91ee03ac2e1e20b3c4e22eb2f4493f22934017267994dd9e08d40 91632fbe502efd187f3d91fe0e546dece87bbb6f81bb9693221f1808a58370ad f62d9af46381af2b88942ada0cb9f6c0fc633b416e4de28d1ea116d2ffa1fa77 78cd29b14b39042917893a461da1d8e70e6f3907fdd521a34ffa5f00f6b01453 49ea0f76e74c57dd404f675e4cb1f4928752de23896d0940d1c5e5286b00dc01 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 true +check_ring_signature 599d4cda4c1a6fa8cd33178158178fef06c7fe1b3c3fce08d3006ba5aec1bd8c fac133f07ca120763a0a12eb89dd4c5245f5b99ebf143fd9d11c8cd5e9e505d9 58 994e57106f3b142ebfbc4eb85a8015d5f8b58988b92b52dca04905d02c0d1af1 d2a809469d95d8229794b09eb5585768f1ad6994cac08700c0d59451f4fe3804 12d262e5259aa7ab1866b7a8cda4475db99e5eb541695a6a7f41ce25ac9db18f bef6a1a1a371526ec2ef3caa1e797bf553901270c0d6f32c05adb778d20d0b99 47a2c221accda0fbc148e95fabd41b6ee5df9fad68846c5e7214ba0ea996ddfc 6abad1804c374782d88b70cbbdfb5615556c5c0d953b96eb1835c20238467b8f 57a6d498e6419ea0da5f696194787b80b6e0965d584a33062426fd086dde04aa dc6c363e82fbad93d737fd03bca1d76214cb10d9cdccf1c0312fc09c1a63fa0f 157a0ee5bb4aabdd35013617a76ea2be6dd623f02d52031071b5b9ab0fa9b6e3 950482f3805331c2cc5f30f2379884ea7c3cf26adcec34f38b00531727224300 689ecdb10bf811c469673c9fea9ceeec159e9e16e289400e774139ca98f45b5a 52e05ea5707c0a01adf313e933b48113e3528db65b06a5b6d0567a08f2cc4ff0 319cabd699fd667e515ea25278487cea8b42eea022f7b546015c5b29d601957d c06ae284399a48897b88d654a5d5e3ed3436d7bdf0be50553bcbd37773553628 74d452ed9b6842dd350ab6012b20bbf9ae4ca8439db1dcd4ca647d693f39d1e3 05bf57684d083f3ebeebb5a64f94d0d07b12ce24c3a3a5deffbbe94a2f64e4ce df703721974bc7ea84b97e355609601e681ad73a0951c37314d7675e5e6f95fd 28293cabb44d1baa014a2fefa4c2a5f8632b58bbc58635fbc4654dedfa6b2ca8 a749ee5e7e921ae783157fe871b3fc4c2ec7ee65bdaede2f348215ff3120e7ac 539270565645b9182f09bca6ab53c7d6b3a4bd5ceb7dcd5309df9dbc58cf31a7 befb3a88b0177f1b1eac68b010a7d41ba7d8c09009a080c5c1d84d9c822920df f09c82cf0050d149144ed83fc1518b0a1796958a39afcbdfe14ca3c5bf543332 a6d5ad9a5b02f23ed84b22bd121f089f3add29038ace47ca0b9f7baf25b89b0d 44aff964ee7debbce83beb75714d6dba6b3bb61aa1b52100691a9905c24a54e6 e652c9737181c1284114198d2e055b4e5bbe839346e80bec22e3a52cefee968d c4e9e5d14727bf8d264f11af850b85142031a24bab4d3f67cd00aa237730822d ad0b8d3833e39181c2459fa5b3234c48ae990b580348eb0fd8b9d77f5424d863 d828fa967bf11cfa7ac3bf89af4fa922be23657a58d0e22d639e610ce43a0b81 c19d1b88f32a86147f0f01c14466f077c6ded5acbf320636d3a23f2c2b2aeeb6 122a85a6a48d729f27f1bdab9924100f8bc994de37f6d3ff7ed2f0bb82c4df6c e2fe10f65d3a29f9beca51269a6d19a5f973e5aad59f82ebb2e5aa950fa248f1 3e479ca8494b0d421ce6efa2a37b9638b7b200ffac8de9e8a024dad86dd1152f 6e7dd056dfd2801d8e663a290358afae51eb99cc2ec123d2a299bc79371d6b4c 464ece86efea596ad44102673768134cfbbb60e64137a747f08fc5f9d35b2513 4958f7a748483730bf560495c85aec3f9103953950c1be92a16a2f7c77139837 636f317450b81c764332e69ceb027162521228fbbef45ed5827db51689ded936 4e5d8d21a92dc6f299def9a7895f73c7e0cd3f3ea471b5b6eaf9f7a5589c08c1 5f7fea2aedd5470504b8af64e27a3186808de0e131af321446823bf88c1ae7c4 71a773237f61786444eb213d0832afeee098dda67ab8202144a171dfa81bbe5e de98dc0b11a4633b22dc62874d76a023e0112dbbe3e201bd3f29b6eac5ed8abe 57348d46c604f69d63ed51d2484932d70b3ca722a7cfa2e61f552073fbe1eb18 151e3925eba4cd784842a241875ee2cb1e4a982519ee60f7d96d7ec6d2d4883f 8402791ef568564c4b6e2ae17094b725314f86385a5425d5dc21bad547987a0c c022191eae2cae4e15be7478640d5484998f9a563de5505cbf6dc2f9bd0c8de7 0fd38964c0a8458120e50a6ac05a45bd6656942d1e8a7eeeb259837e8f5a3743 9a8b52a52920fedd14c0c9b5555931cdb8caab168f1527028dae3a90e17a939f dbc695f70090942a6c71a2e79820bb01a8f9297ea966735633b2da3532c9efb7 310de280ea20ce89cb8c8f69d1132710e85e2ad20fa94a7eda73776c11370d1f 39bdef0c203b4e14cafb58d29c27b7ca13e29d81549ee5c5abc34a0258de2404 91c5df19c4df3a1a275258b8924257ab771a4487cfe224571a8a2acec86a1743 95b0df6a08ad5df5ce19c38e241167803eb871366f905a2a527f736051d72cfd c819c1ae8b5cfcd5b84bbbbdb685adf141d1e7492a9648266a77a43d59ba334e 8f7f619e179a0c9c6be12d2482aee9abc8fdd8f972bec9ad2da6018a2e51bdd2 fdf8c171e8d7b189e8801018a29f38eede1db1e559d20d3c1930b8cd485a1439 a47a62111cea775e4d2a82f8b200dc61db8fd1c5f3d8103adbcdf006dd270928 f740fe2262c2b40391fa78b46f34e56751e34d7ea4cdf2aeb8410392f5499fd2 ebe96581af8d070926e9415f8989568a30f48efb18df87fbdb924028b0feb7d2 a8ffa7b49d39a6b23af9bf1f62132256f17f91d1aa2c483d67fba4346437e684 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 true +check_ring_signature 024953219a3a2b2229d2529ad02d7f5ed75d7f539e4c8182aa9f6b171dfcf4f8 ee4ea67f3c17d59ff6073d80186b26629a3bcacb82311d6e4ff95fa7bbcdbfa7 1 a3bc0f9eb5af5cb10fd1deaa04c51641a1fa954f0d11f1b6bd7c9d4c2fdd2145 75d7e32908dd6db2c4d6633eb9d7281cb389f0849e8878b8d60cac8d9652c60c6b823d91bbd308f171f648485da9f33641b6e868803392b19404d64339db2900 true +check_ring_signature 52d646bb1e40148c96fc24dff5c0ee95f76d314838f3dce0b4bf24aa38666ee4 69ea6e362f81b59bc9f0046f38add1767acf16d908b9ee52f8e16e322b9beb8d 3 91512a0f32094da2d97cbb3206da15e2b0fafa6ce089bf21381b336630f4e378 ae24f67c39234a92d6d12619b901b08f0d7a0b6f95ac3f9a5c287fa852ba3e44 3e74237215b2408a64b1480af48fa4aa5a7e84b1280600975fedd22f90288e45 c26cc89748b18f49e60359ae330f890a2d62b2890794535c2503ed1fea0e16032797a0d2cdbdee959a861f1e59ffdfc260cdbba3b75f827c3312c24c71073e09e45da2ac0573e2959d4eab0ac804a3c934c7b216b3ec40d825483c12ae4df9068548d02588c772980780b14cc03c0f9b587264c5276532c090bae61dcb5284ed0495b9097a11d87b2ce8aa1da022e211e087ff66057bedb39843db0c83844f0d43e55e54975218b3347137db90cfe85802b1aa80e631f78c3f856cf7112ca409 false +check_ring_signature 3f8e402199590b46561e2a7a39e18f1421ab5e02b88b365353bde802a597bed7 b057765038ba36b0198acbf95b68dac7b51220c780662ac5fdcb6258b97f458d 91 a7594e9b734b10658a385673d71032aff7b5e91beb0d019e543bc24c786b25de 10d5891698e40a23d7c0039b5a22dcd0963528154d9b1c7fa22de16d01da55dd 47e69779e66485fcb7ad8de05ba1c82024afac488ad08730567df6fe879ac770 6ee458d5f32094e2d98109faa7daf07f65cd8fc76a13b1d93586df0343cdcf37 f6eba3f5708a3b00bd7b588086ce80f47518edd8dbee9496fede6799a94e7e9b a339d4e18d2f0c979102196503925a814912e37e7ebd4dbb1522ed3610a672ac 928b7970e6bfdebb06047a5ade56f2802d1629e0147b09de352c3750eb06d324 17bfab12364ba832de03f7c39d428b0dd10aa9b56750f8a1ab2e14e9c26114cc 97f28205c41e2ebef30fd5131c464bb3e7b902f0f406479294fad6b9fad0eeb8 302681689b5d505258fd892efc7fb544b900751b172ebb76327274e1582ebbab 4cc447f130836662cd6025aa9af2a4b5abf2a3bf5c6e1143a5064f1b331f60e6 80cc990dd81ca2c26e34057b4d7d37a84db73255f57c803218dca0d2acebb116 375f59218a1e45d0bb7e8e13401a5df8cd4131a30c03eb9f7fbef02da6ced4ae 048ca7ee14f4f9aac2f3cac1c58e5656d03b5dbda78786c419f5e7b3faa7959e 8c1dbd37b320f1852867b69bb4197f1bbf0a3a93bfc2bf2e139e4ac5c4f602d6 1f5ed16b38425117909597ac31397bcf4b7a0ea5d145b667fd88df032419390f 930f7c77300140a0cdcee985ba43ad9a6e5058cad453a9d733604b01bbab3664 ce0fc9fb3a5c55a8d010b20a433ac669e250b87f766ecfad4557da99e3d8696c cc5b872315b870caa6c55d8e8b1db5e4a0757cb627ba63f2e8767fe666651c1b e8b7eacaedaed1f94d8dec138395d204ee4be9d7eaee010ef24e72073e40e71c 39ec7f84c4ed6296c13615115efcf3894824885d148320337e0bd234f48efdbe e642e760e60951d5298d5cff1391c3e9a3436cd662e0c3835d530fd598166ba5 1f51d9b4daf1816947933730e2e5dc24cb188e617e5bb8050775b347bd32a979 260ae6d3a1df5029dbbabb1d11fdd1a69fe392d712be410603bc2e2799386f3a ac0365f427d9fa9a136fa3f952e3e5664416b3abd36eaa2e8c75c276f4b5b380 f8de31f19e5754b703616ad82989abc34c6abf5e32a776c377c1933e1899717e b40865394119f8e20dee131c1e3550af5c4dfb197335b6af6ad44634e17db4dd 5d5cda50574030a962dd2ccfff374ef9cc1d95aae7740f89784555e9781d858b 3aaea439976302999c7ffa9a7affe92fa13b1ee140c14a73ddc77850a0a1e38d 8adc6ce9dddb6196afd4bb8f9d7c3f83903589f49e6983585a59a8fc41cdf1f2 cd0990c1f3e24a07659508357f645fce47c50585099a49260d3aeb9771c55614 663a20ad11778e9b14147172f22484a67555d2d3e9602b39cb7b6d869a9f2855 d0fbad9bde99f9c74dd6585f655adbc339b69f2d7172f7c79d13b0d0f3471677 bec39362fa58672e05fdef1d918f1f49ac665e5a7b2de792fe606af1d682b3f6 1e7918b696db817aa49fb7d7200bacd0858950254f81dd07cf4293a75f11b240 ac0a06023b5861dbdd46ce271ac04f9c7568483848fea2592a29b12ba8e311e4 6308db943953b3aec572a8cffbbd140233d5954b0e122a68e85c4b0407deb6e3 3d4515cbd260dd391e5431a476a6f4302cb8c783cb604e049c4f2c4d84a12fb5 e4fe139b768703d92c29172c6e78b4e99f59fcae6587b7040b3e84119a12a2d5 e0f1d57eeba7c3eeaaa131bff8f9c2868fe6fd1bca4934ba0948e6fa57ca1955 f21fd66c08d56920d108205d22a3aa1bf8cb009ca397c8e7749562a08b016599 ab2ee77ee71914b9cfd93e7c9580840c841a408c6ee9fee41722360e30f5304c 34208dafe5453435a11ff089463dfb1b7751325375f3b7588e54f6e57a2c3ce4 38af9cc160e6f880c3d1ab2f9f66f78a7538a700b37e148526e97bfbd6ebb5db 03a04fe7d4c39a1b08e0bee4ddf7f072428b3c8829dc33f8bd2a7b589414b75e 29e329fa814567b4e58802fba885c63d6bb3a281ac4cb8a3ba138d17f213f421 5244e7e6b576bc47fa509c9c2cd1bada32b4f5e947fad45893cee389e69152ce f23668da1ed3be15c1dc9470766643bebffbf61837a406e3d64918d5205c099e d538b21df4ae67d5a554f863fafeac323b2ef27292338cb3e0836867e4e58e10 e37ae14c93dc8d8b797418caa83463e29c1ce958ba08116147dfb053e2f78507 fa1f93d8a1dce32c9206c3f5253721aeb97fbeb5c4088f5b865cc96a1076d3e2 71f5d1479fa61832be28f05cda728a644e5fecf07636cce4c22caf6d7f9c5dd1 dbd923b83425d694ab0d0397e273359d7193ba770f6ae62250d8aeed59c60d4d eeab083505c06de1aa7a504b7e3fb59c47dbbb6abc54bf80651698ab105b4dfc 74f142c3a30e46af996d3e25ed9d7475b0424e5889c648296c06b54b8b604033 aaf62b4204fba5c131fb423e034cdafaaaa7c10d2d9bd0e00f2b12c4b24c3d91 9e2daccd4b1454ec0264f0d133513f0bc99238372f43090808e8a35a373271fc 1c8e32fe8a8f741ae412b4b9e2cca0f3ccebe7c9f04925b5f9143d2c0588a99b 0d5c9d18034951d01d9b792d6d72c5c84125c50d334d99cfd26979cab6faba37 a458e5da5f317f533eaea85dd57cd7cc94a33103d2bef5a36ec1a942e8716cd8 c0f7c7f912bb692b839b9257bf132a667b93a1c264dbf0cb60032990df3e6fad e8f301d352c45cd2890336fe8116ae58f0baf016471a3e90b0e0f0fac5406c0e 5466cc7711c1b35ce886c54334511d9cb73b085bc45fe9b14d1829137d9a769a 6ff9322dd56d3d6ce6bcec1ddacaf93af393fcb7b6e057b5a851bcb081005144 818ed9f9fcc6d2d86fc8f45db7050794104043153c50a55d0fce32d21e89fd1c 125f6ac514046fb58b9cfd53fe9693e6fe5b2dbc86c4627b64f9b3f8966d274c ec3dcf577d4f45ed8c671d507c4ef109ffd7ede383f0975a66f138958de7d61e 576e4adc73b9513497239a1a3fd487ade4677bdd32dc9f600dc91b6e60163a27 05a6f58914a21e618cfe39dc8ac15f938db36cf851e44cedd1b9ce014a2beb50 45feba0e98ebb395393d665e2e4b84d92b266bfe1766c942e942f5e8da551233 ac0c37b128f6eed6a0f538ca565f850f21b1dfce3738d719c25f51009a93c83d e5a7ef9f2ff4108887f752a95fff4dbc53c1d9fb2833c8946b2628338bd855a3 835fa61fa0b3e237959e26e2ba8b1d9e55ba82fea72225c269ceeb3cb2c7f938 81d73888ecb0c862f0af49a8bb684554fbe7f289032b5bc0a018ff3dcb39f94a 7309f929ea7caf60badbbbd02fb76dcf0b37011067a145d266616f80fc6989ed 92e624c6520b6ed1b87c352d4d53d57533af5249c038a9410eef32f1800a820c e6772481161db18f3dab52b3046c5df0bb5d69ceb5f5bb7aae721b0c1964ef01 52cf3adfc54aba6b77714a64373927c25f78e7a538ccd132b4273ffbc3ff7c17 1aaeddd3e22725b010b57b5646c57da87521c81a75ff011ae8d607e647d2a5c3 1c9dfda1364dc614a35059de152f837a7f521ad1c17bb8bef407fd1983a6f2bf a510135fa8e1b8f0937c7ef5babfc893861d905ceb52ea21a5a3cee216cedb2f f99a4efe6a8191ef50098b74586a4fa162e585e903cfb05d1dd3a30116082c14 579c217dbb8ba20e777a30676323f255fc3f7c6d2f13417edfd21cf5f9aa6aed 3526c1c4ec84f1a449ccc077459568053034c46f7f0afd49a939f969d45c54b8 6c8bd9d6d8e3b2e5cd3cbe944c7f3ed376e403c44e9e0adf2ae647bfcc09babe 8e34ec451db882ba39df63986e9b387ee63b7f41a0e81fd5dd31d092635fdc04 3c7f38b8c627ed60f387e758933fb234be63b9bdcb0bb701d58edb46bd4bc5e8 cce8f99608580ee8932ff3a2e1cdca7b22b310936d5a3186b8655c3ac15a4f8b 1cabe2a5f7a743a972afa05254c012ce99482b4d0aaef9d35df72bcc2a5c2ab2 682e2b6f01d1cefe180b6292b0142de39715212656057c17cf482661bccb7d13 d96c44cac82b4ae9a0048bd82b14df41f48dd620c10cc34ca2b2e4f6dc152b64 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 false +check_ring_signature efc23321d402d681a593b615558ee79aabd10f424eb2928297832eb8eadf465c 521c39cc482d3839926487a9ac2de16100561e0a640d1539300f1d7b1b091d54 15 a88d6c7f793aaa8df1a98a9eb427443c0b72127a9b85439b2a1ca76508e96243 a1479ac8ae799cd98998c746ee0caf0149f8ca9146d750765e67c1fe4a5ad8a7 daf185ba5d3ec95749444a1b49c1412b23f1534f48383779237596258a3fea24 472e21894ada260d538b23726cd82d3e97f649ac582cee0b61e2c4ae0e253ff4 52dfaf7e346d79c90bc29c4cf97ab9f809f41f24e9a005507f1253252b67039f 720973eca1ab26a57b2205bbf4ae4db83e52b8ff3f3e51ff4eec5712236a823c b3a32f06786c9c0f7e854cf81a9621a0e573b0720b51bbaee28e26de1b28c119 8a9540cec5a26c2888636c39cec4f86db2932b00b56749d7d09c9e7d9290e3ab 1a92693ac75b4c88fd8adfad31cdf1af11fbba8f1f62202b69de5ddc2ab51ccc 83e7901d623a7031dd4300355954c6faec082d85a2e5dd8b100005ca02bd44c8 d647345a9e5b1ac6ac46a5f1e50435b0302d4fc990c2005e4ae54187e5b6152a a3440fa5d1e0d16aa9b7ab6680a1a0c9eebf8863b3ac7ce4e260d57388599c88 5d496bb629fe035fdacd7111df28442949448f4a5e775230f3d278f3c32b06ad 36bf63139af419c7cd13de434383ba81d019a76a382b273e3de40b12cfd29a62 9b76403a1067abd581e80b18ec900e029be84a6a5d89c5c2ed3cd4d8f548c94e 149ae6e64b9592d9650b7266697ec9103f970c4aae99c0d5b58a3fef4a8c0c0b6329956d5811f782910089463c776d941685c1132d47d4b24b79570facf9330a7d6001a500d7111e34011d176335b32bbccbaadf7f1f18574517e793c82c67055bcc2b0449a41bc6c4f88e876e2136fd358a9d387b162bef34c7f509474aaf0aae293ddb5e5ad993eb236ed9212d537806bcfcf0206c20c09392126f03837a0d533ab891c1124d8d4b35eff51b1678c0ef73e8454fc02a3eab0f065073afc30a6d69d0a238fd9a24b9750dc7476eb5c68d37f06632e3a6d5753db28318c1ad0e3de5b8f3ead0b422fbfb901d229832baf1bb67ff3568d6ee9cd7dcaa7bac1e0581a18b260fa7a7978725b6f61a0627a5587067d45a16bf8e841480bb071e17068492a5bde9d0627fdaf7307119d1625bf164fb4d79ec059ec3a2f2a4effa7b0498e3a657060fb37705047cb36935f6cf35eca0c294212bdb582371eae8552a0b4f6d48163ff0501ec828e5b332ee91fe900a15b4ec4f0ad91be8e905e6c6192f0ab1bd9d23cbe21fec81cc81ca34168dd3e24e2b10a3d8729eccfbdc2000a20d89fea2626e3f9d026faec5a863a9e180df3275ae18b9f172aab8a1e5ecdcaf05fa3906c3aa0f6fc649f6b677806d421cf367ef6ff4f9b2f9b0b967380a8a1a0a1d0af8f375ad1b98d2aea187307fbc1671eb5b8c00efa5d45e531fe437b7820f2dd58ae4a113d62199e7247dac206ce2a9084c732c4509cedfa32771ae6c110063bca5f8bc004a87a715fcdda099b8ab13785be8a3522d66d12c0dc9a04e4b02012da7e24caf364c5e25062285e7da5fabd2af4c6d50d4099e9ad689098c9506e1dd093b7be1925582b61ce357aa6fb56a6f179d07c25ede839f20c192503f0317c2042e6cb9ce35d09e98229b2ad89bc0e8523d90309f368ed2fc4642a59f093f143197f63a66d3f34af36908367c7cb56c20fd5b5c400071a16a2403d8a80db029833696975b4f1278afcc2fec0cedc847236d9621c8822622dc6a223b7c013435fd6c28f9e9731ffa5ad2c26cf0d03d94fc17f9cc7c9724d7b67234a56d073efc9b910f2b9f04372401ae73e23c7cf6f6812907a625a0f9b1040529bef50af691ca963ff0fa0ad5657dfc61f33cb08561088972e7d46d0cceac2e12bb9f064f44b16e07d7dd981df75988a7d7b444358a41dde44956291f148a058317f00ec3d138b6b3b25c358a1644d73b00ca3f9aee63a8728862dcce3dc79d796c0b09c25f76b141804935cf9ed864603234f69b49844b11c9b191dd7e96d561090a0f295c7fdc4dd3f07e5e34e8b021f422a31880be079cc111e6ec0132c93625590c false +check_ring_signature 9c798ae38730f6b0e69a34fd86909cc07498ff73b80e84ec4ce541733c7a3996 ae3324223dd5096f1fcd8cbf68c1fa8049fde8b8168cfa8543790124e56c64c1 1 5d3610082ca0066caa822943f43f38214ae1302b4296e0a3464c86891adfd056 1e76379c3cfb42bb4e0d9d5704126ce61e97c7954af13c004b68dd33c4d50c00a8847bdc6ee3e892b42a51144663910eae384f63a05c1f9726c264d2b8fe470a false +check_ring_signature 5e1cdc84ded1e9a394b86b5efcef545eb098fe6555d677bb913aa33277d73bac 8a6239734f4d7ebab80fcfc75f33f8de82ce59208e9b278e88ed0fec4b66e7a9 2 49cdb0ab26bb8a508db83368bf0437e4d3d038470dca012fb6d3658b7742c58c 6d637bd91395c22ad4021f99c496425666b6a4aea0bb00aa6e18af74e81728ec da611f2c8366a5d90a4dd4441a977ed19e582492a29eee1cdce54f68179284065dba9572d29f86860bf70e6b24409e937dfcb0c34353605b2dc5f4ace952db0d13c7d6451150d0adb7612a6501c216cff6e24fbaf16ca24df94c375beda5dc07e8b0e2a7acf8881da5060c94410ee77af0ee390365a2afa5b51e60ad2fbe190e false +check_ring_signature bc7aa7ddf204dd9ec8e7f5e541d68e416e4cf4f034d0a4631544ca14c43d9b52 1f9ad835a17d23395645f6068a3c8f11d286b34f65ffd52aa46103a5070c40be 4 98171d0334fea8b400ea54f8802bb3d1d259e239fccd69f25e8a8a897a03b0d8 f17130b3b3304d6840d7a6d2f9500c9323f5b420ebff26ae56fad48625d0caf0 900b20e43c629247bf4adc3211b58e5220fc518908af4af2b0da487dfbfd1b9b ebf9dee7b3e2ae7911db222f5461ed062e6e6e3094bc5ef0c1cedc955787fc79 7196de11e78ea67d80d465b7a6b6eb6494d85ccb40641a88f19ed1c36bba770f8e432c1eaf3587b8841e370a2f9bc26f2b23132bf343df6008b544d0e80de8021142609e8b4752a8ee871f01c18ddb6f3c4b23b780d059096cc3b1211f3f900c47087e2310f31cf7b60c39b2e9cf17ef012ea7a2b3dcd1db6d18813436549b098ca6ad8a0129381dc85071e2458ce6cec62b1a137430d3395bd8625e0d652684d2a4bcfe680fe68d73c6a45011cc3b41fe9b61f1c49ee27851ccd29d60fa600f7a1f06fc94f8e7b9d6d7c5bca3816f7bbc220c8954686c5f2ce79ccd4e05a80a65a1d50f8dd1d70ef10a97a266e2afb6074e94bb0c050b8ec3cc9ffa56a47f0a false +check_ring_signature 89fdadd0e2b21f312c09e5cae0830e482cd49180e560fc5a7db6a76602027cb0 b60efde0f5a33cd80ad73b660d7bfaf1fb9cf96e3bf6ce8d5ccb2ac2c77b16de 6 23205683359f492cfd023ac88715346b07ee474cfcea657f7009b3b14ec5ff8d db87401ae2c68ebb01b1a10a67a1678b8064d54cadb5e0ac90e971ec812558a2 9d6344135ba7757ed760df15d9de15d374fea45f356be445edff6a5364258120 be2025ba8853a57ab5ba8c57eac9463bd70e36bfbde07c742976753d40ec06bf 870640ddfe037c4132a9a194567fee1f8df8ee305adcc47aa98450a94958e966 e23f29c3f3bd232a40ea413ff01e8618d4373b24cd8a5bb8dae0b5b7f0523cab 78958b81eff706031c2aa46b8cb4dbba9a656bdcd8357a9fa2ed2cdaaab3530c75d1eebee6629da55d965cfab52361b179fa2ce334817a2d5cfd29c1bd46d706e614af2f417c74892cce3ec81ed59f47242eafe1196d600f06755bec9620790ffc575d036f2921cfad9425fcf6a2deddace03d059752852b9e42fb5db5a3d607b269540a7c27ee99bce2b98e8261c8ff4a838c15299b66ca0f07fe45e57352e1a4bd4425166a0a99f80f6bfebb9e51d7d9c3afcdf98e6b1224fdc6e910690e0281c93778bb7a1d8af9e87d87397399ac404d6e832f3ca67ecf85333dc77c54094c23d943cf50115e595baaab6711bd77a35e5036c4a4c5d172ecafa4e48936007d1b72aa03af83fb30b4cb42820969bdea47376e1cabc5997daf086f54b46504fe6e008cbd4668955e1976ef8940183efc4bf8b2ba70eb9044a7f5f8f0a91e004231ee9b3e7930bcee10d91ffd0717c70dd7b67e58a6c2cafd83c7a9d4a528cf8b8781b10ad41b3606f60b47eff439de6b6c0e1e01af8e22b1c06bb17c4c9c00 false +check_ring_signature a13b1af866cde8ecb1b4b3ff9b8f87668edc2ecd53ce772e6f24e6d0ce80163c 3efbf5a2e3fe069fdc4243ac9414d9bce6ffd72c4979fe77e2354576039a1362 2 c6b695b5176d4f31475349c4173da74cdb747c84042488809f041b6228b46e4e db1708ebe9bd5288ff22ba3a79bab641c618966bf11e53aca9a8ba90a11b0650 533f8cbd7f7505fd41e160c989f138ca36fcfc75a001a528fa754382a665150a7dabd43d0e59e355a1af976680eaee728d940c1d1115828c44f1c7d58fda230ce3a7f350eb378099b911406329e351c4b3386f9ca39ec726539007d0b832fbb42cea5092a1b893ad8883670cad3e432c841737053a6cc6ab1b4d8465703aa505 false +check_ring_signature f323bee9182019b40d53701788a3a831850708ad0163d34aee6be350a8e57f07 3c503daf1ea5805291ad1fd04e4213227d1b24305c08ae095113bd3ef9be9b7c 5 829aac225b64bd8da46e97197de39982ddf03d9c8c5c4f48c826728efe3e9671 6439f695a168fde0fe695cfe49dcce30438670a65e1b1c5a4bab224ac6f479d0 4b56b056d707423ac8b5a4ab172cc75f045b334299f6e0f245cf8ea038849251 57584b1489d74d654c4c16f209db64ac8d7c9e9304d8e21f9fba6eea491c2adc 5c1a08913b3ab0d57c1ece42230c3a2fc48c979861572fc96a6964a2665b984c f4f793b0d36585bc37da71a937208caa999d67ee23b7cb325c3a54c49b8f8008be1e8f2af7a6adeb346dbdfd2d5058220dee83330ce94c1257a55b2bd6e6d407dd814a58f469955b19d22b2bb5a9a7b76dcea510d6871c81639abf98ec04a101c2448b103015d07ef53c170e4f9951a4db697a0f07c46508fdce7cbb1320d70a84af9521a79f778916ac37e395dd5b002baca1a6d22a7f7088232a01a175f506309bc6c017a0ccdc9e2547ffbdba900d938dba258c6641f1c63fe187c16b9706109ea19e5079c53a36aad39107fdb1faf12655a38a07d7116348b03ff91a02045b7a1c53a5aa8e323f8fd78633ba0a69109ff093d949c8f2b0cfab289039cf09acbaf25b3978c0de4ce05ad7459485eb939f03ecda41397657df412b7a119501c98d8ae03dd3798315837adf0c728e188e53a0078a7a63dfd77c9e7cce120402 true +check_ring_signature ae88e7fd56902c1d2e4e1a69520548b2a3dcd53dfb72a77a43ef8a06b5141468 2d65efbaf85986b9088e0bec23538aa2cf1f34a8adc7024a94305ddcfc29eaa2 10 92ee4635dbf0746b56a2b1655af77b9b9f1ce8cfaa4ed3f7b02e2a6ad5b55da9 b8d6a16c88fd84d58497c88b4b405208cf8ffac8382f2dc5d06044a56c99ac69 f2967c168cbab8b12ed4904d99680fce3807d9689bc2ccca7d31970de540ecb4 c4a58f615947ad1b91d9d33ef476036db5eeebddb46cd780f6211b2d8ba5d662 c96f1e64247d395e2a2a5774116a180027f581676a97e826c02043e92fb77c71 bb77ee5ca127e9d1bc7768c67a61b9ab995a71b63857f95bdbe5b45451bbe2c4 5d4fa36ad317143b0d76a38dc70fd545dd23d82fe3fd9c6279c7c4b83bdfd916 51d36207c3d676e8c33fa13212b6270fe6bedf66b229ab27688d9719554aeab0 d2f9745f99c898dac06315d84804a80d4c39b144843d5ba53a3da52c409b6392 ea3610de0457d48d7a4e1aee5664ff3b080fcd706fc09e9510ba0f96f4319f94 f858b678d8b4e93595770720f321c16c66e8636fb6de11c67a265a4902c77d9928eeb5a137ab3955fd9968a67f2163c86155549b55fc06f5a3c3e02f6aecb90d6b04c264187c76ce9f85af4fa589ea49c08039efd398ef763fc7a937b2746e756eeec1d72d85b64bc22329464cc2044b17c017fadfd00d0746c4a0d7538a540e86bf97ab6fbe534b2f573d296305d61ed3162d206c8aaefa96fa28dca3149406c176e2180857418973defd2c493ca4ad202598680618259b5939df61ac287a0ef298631bd143aecb52c4c19b21c8e2fe02651cff7415366fe214385add7b0c0967e194d48213db3bb64095094b14d656a4a9d9502e0f194546522c09f77231077be294b6f87875bccb0c8dccc674230f78f49ddbc9acae60c4673a50596f82018398cebf21f53fac040044bbe7846d60f85e0e13f3a946d18b761938f6f81207eda799bd80924617866e3b2f34198eed8bb5c16dac7bc0c61551e7d5b634b504e9f8527c9b1f49d9efcfa5d97eae897fc14e3d1ea1926357dc01a3f9cd047e0000b820ced0c97c140b2f6c13dffd89d106a4a47fc4debb383dd774773bc96b041265b0ae34d274f474a90ad650975a10e73d8a2fe48117317e43229ca9719e079705aa0ee1922a92970341493f843dd749567cbf416d7c6b9f643172bda7d20b749578fa12ca13f84467bfbd6c80766955c27752b28a1f8f656d83450aa3ff0594052c0249f1690e32c83a422a171f08eab01fa94ff3c47b8abc1004f5fdb400cb89a1bc67638a17f0e521ae088877e7fa790392ca445524c84fe76723b7c404f718df7cba35d358cbfbaabb197a2d5eaa516d4b9fc0ccb30557819fd7232b0b4c90bb3bdd9f5ed64737ee8262de6fc04e3125193907816653f2f6b076c9d001 false +check_ring_signature a221e0ad83d0ebdfe783b9dc40defb7cadc34b30fa06659fa272247465feddb1 a6c99a37608b77e4b8899407973d6a0133834927691c263cb6c2e11c515200ca 21 e286d6a00aa0e2c62b24c1b34d4422bf763f7c5ada3f046ba765c7425976f3ca 29dddcbd0e44582a9711ad83351cb6a0833f8270b59d6c3f15b97e4a9a3901f8 8ee0641e2f41d7f495d456355f69eebaea1c85127e6ab2751d896c5e4bd1681f 9718d0c464c96030677a42ac7fbc6cc71c07a8a5535205dc436072fecaaaa59f 00d357e3e9c0c4b7fad497dd97507d8cda22ee5c32c8a4ea587038ce22d6d41f 570714dd122c75bb75a8f4ff0aff54fe2b105b805436c73843dbb867fccff5f6 e514609c028073caa08f3373cb9ccd94ae266510eff2b2a60e56ed15fe4615e1 32fcc9807e73c509228f7a523022f7d05eab58bfc4502d967c22e55e920ceb98 dce65edbc6c63bbd300cd063d30c0d97b3cf4e44608826d8e5bf1a0e5c3eb13a 768b56883c5a39b7ea2b950696c6c0772840f43ea0c19a28a0d06c1894ad68b8 589bbf2b0c1d595829ccde3a5d6acc2a7e83e1f16e6d06f4aa7823b9f4f89a02 09f920c0123ff52e7e39ea120c7e01acff728ff577ff16c826fdb311fd10fddf 75867f5a2896f837e612c07855ae5287814eb13998878252cc89abd354ed62bf 8805bd8b4352a08944ca908f03e6cfab6399b67a1a8a9f268ea8ba02c092bd50 eab050c255680c8031bd15416018c30238b1537f177546e2b5c09797d5d891b0 96c888299022c60e493a1ea450b56116c835cd057abf3db815e24fd51dd85b54 116c807645d5d9ffde3532072d550cfd7f244aefd219ffa1591d962d8d51f326 d8c2d4ddb0ad0b8311937cf0dc82208a01a40e25eff7a2227614edba15e91239 7726d4572d5733a12eb2ca36764da64457e80712e397c82d3b357bf59a779ea7 3da0336e2ded4c5b51b3c5876bb43afbddb81f7a57dc75bc31e1ea9de42fed29 8e56857b1afea5f97b52fc87c88b5bf12369b0afeda0d2b195032daa7592c674 c2d51da8265fa3a6bf60e0396777e6e3faf8762398f64a78469d7ced7b1a6504ec8a7ff6454505efd7268c58dc1e4c2bf095f5f1e9576830cd99b3fff443c30bc0d52b380cb355dd1b8cf31f8168d10f11907f95d986673250dacd8843bdc10d1f0a08980d7f004ce7997b0067306fc7f850183d84e377270933a1820fb1430ca73bb61408c373a2b5431ab83c1e71afc106ac8cfabe373b7faf1c0db2004b08526d2de41ba275833c26aad68d0fcc15f186f67fcd635891f6c534b53296a607eab5c51d2ce313585a00f9ff9f425befb7dfe0fcf7e6e366d70c0477f24b7a0135c4fb7d0631756999ab857cfa137d3d530967e7ba4fe75cdd8214d0280be200b405fd19b2cc0e1daa923ffd56e5019cb9445e8f0335dbc5ca64eb3cb737cd0e3573b8b65f3b38b9a476136fa60a7bed5af8c8fb9cbbf974d703a38e7b223c0e94d26abacbf16c2bc8f5a219b03119b23dd47f5a24c2562ab3c6884662fdea0b8afc727a671218733e5b36b45ac85d386ce8e4029763ae1ef910c804ed074e051ba189e790602268cf8ac0fe3e5fcca6729482e2f44e656906e51ffb28ebc1001205af2d8fbcb8fdefdd8e412d8f3524ccb4b59cf9cac3ffecae361a077cf3076d18d591785396da849c68677a0fc3b47e2f569ca18343f122250d984b15b20e1d4fbc5ecf8c1cce3c8407b8a6d87a3ce5a3227c4c22190002c8da0f2de6eb01ea83ded5cb1c733b9e02d11bd1887f3590b4b61df818c4ae70ca1f26478a42001d4ee00e920735466a2c7640c6bf7dc155f1c55fed5f3a4e31a01a80b57f5e018486aae12662a1cb48237ac3945b60e4e40bb4041244587c7d519eb325c24904ab3943286e6bccb0e8ae55681c6a7dddf4a67f33caa5816fd0290269d4197c0b175d4108d18659c0db6775fea36472930301cb2325877bc02d827fe6bdcb2c068c3d37e507a5ef7fcb239eaa83f433db9b1c7a05dc775a7b0e52ccc3575b8a0b97b1b01f299eba82c0d54786856b04c4d48c7e88075ded5cacad70ec7071910cc2491cf02c8b44a738d6d350afb81c7bfa37219e650c39dc571a1c129c88930d332b1ab9dc6c658654571ad83e4cf067ef5e812ae502c10ed64a1614a1fbac0516696885f692086d197c362a5aa1499bbc05857b33cfe9893fd734bd70db3f07dce5afca9140cae8e2b79e0429031782f643242081c20eb130ce4bd10f3cf707640afa709658dadf9001adce45cbd702acf60715340f7fbe899e512f63ecf106e6827a9225870bdd9db7632480366aeb5c7a24f0fd3a24ac96685c4a3617870af6fb16fb6be9aac4b2f30028fe9b72c3b066429b4d96712017b335fd39ad9f58f4a59ce061a4be650f15f6df29bd88414867e16cc5fd01d6384d6db35509aa0f18c3af205480cf31bef57e34e35994d8b485a92d245c934679fd11c4acb335035713904b8e1604a1c25c4a739ea97ae423aa5e6d56d7049ff89bc7dcf515b70989c347e47e6f2583c31432d4364428924644516b864996fb8cc9db7bc61fa40a219ec47486969ccd985983596e30b39c7beaeb457b821ce7fc83f009dcf1f8019851bbe7454bad26b1f1c8a08af6b07335e0a50b7dd498141b1fb6a12852cf05dc9755062f23c8d7516870185577b7861a16ab49c46cf54240e57e6814f9f9053135327fca73b41fe500a9070eef523b6d9649970ae371989e43d40067baab0961a257e0eddeb88f1c6bd9e78e0bcc4931c23074c901080be9bb07d5a3d8c8074f11df16b37df02f57f4e2dda2135dbc77a99a963decf4ffbbc2a94b0f22c504cc0d4430a85d1cf8bc7a5562accf7975877fdfa82e274e5005005a6bd439750f1fb2e878692394d0a931a29e444397bf6009a23463f7c914ac2f56cfca040b0b false +check_ring_signature ebda99526e477f3e5c3516bd0f4ea7ee3b1fccf363b63f011e07344a51cfd35f d7047675daff65d9451b0a3ba56a97b4cb1c01b4f3292f3c99147dc3c5428640 4 13e4b1ba2ef976a7cd8aaba35299fcc96b112b8d365d83b6e49a872a861e2dcc 43fc9ddf541739d1d73655420b88e38437e883cb2d228bc445895801ebc7f762 7ce35dba8815ad70420d9eeab7296deac970d29dc21a24a3dca6b982a25e902e e3aaa73cf77b0ecd4d34d796fc2d6dc29876ae51fddfb7d97f4aaf5ef82e8342 a7e01910f187fda01f64f1b02cf9032573192cb6d8a2158297d3465147f8000ea20b7232826fd702086a1a5afaf4c9b4545740c40d28c50fa8d76a9dcd5fddc9db7ab3daf674ac953fa2d6ffb00a739d5445b2d25335400c5321818feabef001ad04c18b9f66ab6f9b0d7b82aba6d981b834b1bf1ef6d535b53ca6c2c15aeb0a4fdaac355e7f896824074bca5c87ff8fd04a06ae30a1aa89256d03b1affc1109819dfdf525ae64e6fa2cbc4fac386252b1f0ee03f791c2db40e9bbde5de66834c97ab2e35fd58abc838492c6e3ca562d3e571c8af6cf4a0f983f939b4481b3009f0a10e01c6f64bc45d87c4640ae0f4d3ab3e488a4f76ab005d77fddc621750e false +check_ring_signature f20d406b967053824be9024eb33d062316ed5790216f9cfd6c07d3e12c82d160 48b31a97a55ca38f4444ed4cbf27533417562f7f5784b6abeac0771ff2e5eea8 8 c62c84b9c8e283b480e3e38f6066cd29e65c47dd6be3a964b71f00e1a51d42b4 c007f3857ddf04614bc9be4652b487588bf4346eda7650e6dc5270661a1f573e 0c43d340c6a44ac33db3ada762ffbbee19506b6e5f11d92f3ed624f8d8b862fb de37d6f5c9c6dae4d42d68cef075371181a43593fc2ea5475038f50ad057bc5d 447633ece4f67451957fa681337a9e83812514a4189291435c2382bba116de5f c0ce0a5b09ee5d1d33b2a0cce64baa1ee84ed766d9c2f20917bd658619c19f87 bca8bd95be5013fd16fb86f1d86022610aaa24371cb21676f241c65bb7927ffc a19ed0e794db404a7d92512083cb81958e2177aad0c8e3645ce7b3b69e378191 f7551bc211683690778a1cb59cc84c8a2d2f0ed0779632fe15c0f8100ca74e01e7b5b836060bf41c383207ce0422b42219ceae2245d742fc8011717b154da607fa69982661f4dd5f64b8efd1d323ac61f0a4551b78a415848b2e04e3da43c2088d05e55f259f7d23c7a0634d199076e01e5504764f1fee4ceb0c58fe7e1ce00c977ddae688dee3192a3232318afc4bcadff55412315220e4f2a6b1c575deb70bbb432518ae865c714282ce54dfda8580c795b931c560fbf83f8af6a092b4ea080e5073244656cfc5aa86c01cca98982115a1d8b99539c7382ffbea1cf56db206338cbc2e9a0797cb9f6eeee144e99ea3448603b9098e94d32cde0632bfe7890119a69a70b98984ac041f8b01a463901f04a00884fe43b6664e0861cfaf8b3b0ced0a1b9305c148d86a10e4394013e626c047cdf2ccdf02cb07f083eedbacc4068d92072fd6377803d61677d65d8cffb2f2d264027cdc49fb5712c432dd0aee0bbdf7fed6387caeef8bffef903b4e307593fcc55bd2e913e9227663457e3852035d02b5b55c5032c7351528633680a8542c05f4fb1a008e11af97298ec1196d093b4a878d96626cfc4a5534a2a56a8ef8b4082ed49aae3310043ca5acd400e608e04d8eaa99666994416d727e743fb22f0e9c643be11c19e821f1716be7257409ee5838c6ed86121b9750152b2525ee4829ae8a2ac565d48701e1ebecd71e8709 false +check_ring_signature ac0fd4862ba8a3f3011ce22123febd85cff730402e3421946b3746cdfbf7d066 998751f951b8f8dc0fc267469777e31b417fb90b89a57fe0f2595c8534c99909 42 31cbd18eff019fea28e940ce5c1ee248b5f049d2bc6657a8a44c6eabaae75935 0ac30f403cd9a83bdc85232c7a4f4f9293ba838312701ffa8214397f87073fc3 b556d5006dbc1ac9767ab88ae26b6f4758f848dc36479b4e1e25fc8a8aefb9a3 10cc5add1b90e0a8768a93698d341d130068dda1115662bbbba877c9630b1bb8 a2c4021117e689c1b1a7428571cc872c899d42dfb074ca5e2473cb033140f285 c0dba0103a8ad12aaa08a5390bf40cda0cfb8b88a7d8464cebfb8fa64d280ef0 829ee237923ccad532c97fdc65c7d906f97fe110426a5feef9c1c4b0d446c846 3fedd3b7b454e5cdc935d0bb0e1ec5d7cbff43c5468fb86de05418ac81fa21e3 e32b6993139d4aac97e85f725a46e4eaaf0ca144c522e8dd5e45aabbeb95af37 395cb6b59c1d264ffce2d70934537cfd635c18e3a7bd791fe22bdda993d598e3 c499402122437eeb0ff197ba81ec38a97fbe41031020880a69fd421009c8fa53 51f21c96886699cdea5e08b2b025bd871b46d2d60d86dcd6802e2d9323a721ae d5bae357827fcdd8f0661d7c6848a070a9ff42ab2f2a164bf88d816573a36998 7e596424dd67a7fcbc13f4eec99d05542b6f1df735cb48accdc15c0b395bdd94 ebf2f607c3fc67caced0ed88b110004837a742e365ee8d7b00f5e71e6796ffe4 e4e3bfe489233758666e60c50a2f9bc844fb2d6331fda742d0628e97bab3f409 0f9183e2d281770827463e18633ddc368529bc1f0d1dd7fcd334a5f45813261b 90f0cd6a4b26441d23fbbd337fb7b2707b15365c328347561f7200a96f0e771b de1c63f873e9d7a1f62b1270baa06451be4edf2b1ace8337176ac2fec7b9d148 d3bf4d5949093e32d1cba703b16e8f1f1daa204ab27fd130d2e50d28c899472c 299da7256fafc4b1640316f76bf69eda75e3054ef95817c7ed9ecdb3aebec9f3 704d9f9a27dfb21bc93e75a3b3093c32724af58b50974f2d71fd9069bef9b9f9 443ea97a212e01f14bb03d665fec7cbf222a7f3b0594f5a0a05249c10ef89b1b fa8653d7887363288c1ce55db795490a1854dac68fad9b1c2b99590466907085 c004ecdd82e48b55d1b3bf26b80f21e516635e741683f1d396811399fbc342f2 bf09040af0d5ea8b10953565fdd2dcd2d2205cf0d343b9393d8944ad561f2166 66ffc36934fe9862bf004bf45ae5ff15294f80f0f4ea6d5931b9e00aa34c777d f13400b4d738d82261f1fbe10df0f7b8ce93ff3f72aa4c006eb82f9e04f575e9 d6f780eb6e255cd92407222fc9baa91a2721dc89e31c70ae8df3f73429d31e97 a42cab70d7cf4f676f01f5ec06c0487aa70b8aa37ed21309a62b5f2d18004ffd 4f579c38db00572bdab3aa32ea9e3881ccb9ba4ad3bd52e8247fa8c0d7fb6e44 7183f4f7ffcc89087a9998202ac9e8b4a1c20c91b5322cc507ee3ff7bd8bd772 57eb4653222d1dcf3fbb5600a6ec34087b720d8998a611d7943ab54e3096e94f a436656b470f80874fe23f527569647d6d7a2ea1684fc0fc795465878edf0454 f02923f143accfa8272658aaca05191e16e30d6144921ad7b3f391c553a252c2 8d2a5ad5d26c872f5e02bf4937889d30a85b2b7256eab505e3544eb83ee0069e d97dc8fdeb10dc83848d9c6d3dcc32fa68e1672a9d0c304f2890a02434c4237e ba51a44bd9b5b06cda5a6930f32bfa61ca0c97a363a1e23795f6fc26ba5ee801 01475ada70046369679d05bb74092a11c8a7154a9f9c43191e2c63d4c2e2de3f 19a533e2f496cad94b6fd0edf8575d7ed57e665cf2b8cfad1591289bc9fd2d29 39070ee178e56bced65f0e6b86941faed5e45faea8f7af14ffe0054260082712 e307b00b94c497afc4495f0220cb1b84fd4c728f7f0a9ba223110386c7320185 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 false +check_ring_signature 7195eb80d52bfe06f5fc28e569af63be098b4147b47827871a8d2f93191c9e06 ffc818748715fbb4f726673bb5ab15abadf5767d7c7b2706807998a73415c332 4 0fcc11bd9ddd5f541f3e0751ba2aa12e6f3a7215c40c0f4d33f450f80a97ea57 11e164fdd98e2571d58aace3e4b7952b9fd5a9a35fbf27e563aba243bed29abd d5a046708c68638e74f534b37b9f1c9200663942e895c714064625966a1575da db5b9a4f56cb2c1e86376bc0e161e4badbce82dd14504c781db7e60afce7a434 ec586da91ec965997441823e4ad06ed3167b63303267de3f04b583a733f5a00c6a9f587797968f548ff29294c7744e166eab5d80518c77c408e599a515920b0fddaafac329dacf3a9c192e855e43b9424e5b96f4cd3ea8773702c1821317020be7d6a7799fdba25a3e72ad6ca6d59b80c736afc9060e8ae0381a3a9dca412804554a6857e3f9866a1095743467e00be5804fb6b860fa2872d7ffee4608a97690230fce89e5d53d54b9923cdd8a4920f3a70c8d49d4ea8a4712de1c639a71195cc39c7bc33f13955bf3d0d99a885313976b0fab31f45f1005bfc260069103fc045fda606ff7f351a06fb6b95de939924ee78d54a22fffe9fdfd13ba40dc9cead6 false +check_ring_signature 64910fd34b038cfcec5c0390def630744418efbbf9848702abe5e32f135be843 b1a6a53d66a564905360693494b093cf884ed01c48e9716b83c96f9b2a0175bd 2 239cf6d62878ea9d75efbf2ddb08ff6f4b2c0de6e117743a4efb1a57c1041c4c e9098725ce90d0f0cc949b71af7074fd35fcd2dce1bbb7b9f21bda62e9cce9e5 f391b274a2f5eb9e4f53892706fa08487d98ea5de8015dd4d0f3ab1036ce2405083a5219abe733b4fc0358fc5f49a7180f83e054417327989df5ef6a5d5cc2099d1ba209ce94773279df65d740956744f2c3c56adecf653f5eb9371d91fc1f048339f26725b6b7d6bd3f8c22434f1c3234ffbbb78f157c645220781f6e480b6d false +check_ring_signature 64298f4b123c62cbbd708b9a8df8295c14819aa9df1ceb9c765e66e2cb0585c5 3e23b3a096c33c20ceaa881917caa2af3e1b462d7cf9800c7feac9eab834d0cc 5 e46e6d3c1e0eae35e27f2cc51ba1601a7d68470046dd97af98cc2c8f582a18ff 826e44b0626f0a29208a6063b9eb6022c853c8b1bb578ed514edb52bb0e33111 8baac94840eaacdea77964dea424df751daa5b975e027575900ccb4211597c97 5eeba3828edc84d129be0de987bd9d5b59b9d697a9f4febe0e82c99536d69da2 3ec09273c1e61dcecb7876faaeefdbe6cc5d3337d21587d8b202b323b93354e5 e330b767b0be87d4c5371464e5adf0c4d46f127ed62d4b09ac29b544df73890f9fe7c11286c144b48d1ca43616ea99820609ef9a16ff9ccd863ab0e107972c0b7b58cde63d44367a40ed7720d55f088d046aca3c1586baecc2a96fb5f92d3401a2f8095b0f18fb68baa51a2604e0b18b1a43df4ec28e5eacfb99ec3aaaa4b90ab8566368dd5f15b9c0a9322bb4ead71a1ed73e292184b6514a51c1116557020fc8f85f75100c7b2a2bb9a3e6fa89c5373757419ba710cb074ae931463a58660ce9cc89227ddceb3fd6c961e6322edc1308eeba2eff3ea02ebb906b98f376a7051a1beae25769dbe1a6fe58686e6e1f8c55bc891ed3905f608b3e329f53b3a30f89957fbb2d5cd68735811c81f3701ea6fb277e3b62dc007c4a371aee19059a0b670bcfba828c0097ba56f898de3a2cb1d447e1df28d248873b3470e86157df0d false +check_ring_signature 1b703fcd3e5df33f898494a059998c0dc095ee37a3137be4f628cc4569d88c61 686d12b8e95507113dbb228fbf2bebc6cd36e3452fb89b1f580991ade98a499b 5 e49ee0d1d72fc102bcba65a0fa312a6bc6ff74506d7487b8417f5343abc9241e 3ee8973b36c21744953549763d0f4d4106d37dede93afad199d1b4b9d6f3002b 140a85508c00fb3618fc15ae7e8ceaa02e5feec62fc30ed1b2514dbd87986030 d2e9bb41142765f549d96dc618ac0078a0dcb89497b889dfab151cceb7766505 d5ae0750a2819db3566bb1e28ee7139e017c135a81ed079c9fa7d69152786196 ffe51ace44c36926ca59aad4c3a4d480ebe3ddca72b361753548ac1412d0fc0645af56939b2cb045ed0a3883b4d5380044acab32c8d720c781e54d85c1c92201e297d11de5f6280aa52b2e044e0e96fac98df15db458442120eb67565ac63801f49c4169bbbe3446493820190ac0994e79eb2b321a4b2bebbf20a6562c4ace00fe39940af4d257b723c09f7ceff768164f4af8cce927646b1e6b83197942be02873bdcb323b798a99cfcdde79b2c3a6d0c250c4e44ea436c7a440962565a0d0f1450a7873473fcaea42088ae4fcd5e9974cae8280ea2776255bdc57f0eac6a0abe7fcbe8b1cf1cd98db78ebc12046e3bd7a9f92b06bcb5d445111c486440170ae754ebc5873818e5c90e3fef1f7d99bc6a6b8ac9af7c8bc4ce3dd4f4b703af0dae208359005098ef51d9268bbf410a6d334a5706a28ed90710d266ec121d7503 false +check_ring_signature 999b1af1f6cf37af876c8ba98f30f671c4034827160b48b57599b8ea39930283 b8cab1f61fdc9d06acbdbb4f7929442c2fa07471d66cb75475b66ea994769877 13 48a8c8f7ce616f7a8e46db00110614059794c1b2843fb537dd06a7908cd6d080 9999aeb65b66efbe5b4089061db33f58c93b02723fda738ab00a75bb4ef45c84 66cf29b096f209b50b6fc7f0ec550701651eaa12e7ee06dbbee2b2838730e6d5 e7822fe5ca81d4006bb6fafc824333391c458c0045da9cd5c4305ee169a26078 a7e89e90a6dda954ba4f6437138aa822158207363c1de0fe7c91797c66a0c760 867fe5a55d0da7f65ebb3cfa705ca629b55d4d764b2f94401e831416738ec5fc 601acedbdcddc41887582872a7f7ff17b3b9e25fed792ab941dfd657e331b182 72ae21dbc86f08a314aa7b8b6deb3f02bfcd253411c375d618dbaa5a4e8a1012 a876a2281b1c85770e7bf45ca9e054e2949bf735093a0fd54fcf03b67591f916 9280e987160c702d5b95040a91a6b5d19b9803ed0f0a9140082d04c9441a6956 a8fa2853eac886d5d02dd8c8319140452db61a86381e2e9e563c4dd8c2f511ee 260881a621da869218d252120e8dc43d7756720d10e2299b39f280dadfb2ecc3 684d4315a1985c1292c40bd951ce72a385e644f1d5334f1d0fadb88683a9dc31 dca867fde9b5b5a33d5378a6fb0f69ca96f4012fa8a34a908b81fcab406ba809f56121bcc7aeb32e3b84b602a6061c63c2a12633958c0f7c4061c9c127740a0f771a58d518e737513ebd525a85f43a978f04a1eefb7a0e565a59f5683b4a7903926ffe9f8f0c1963c73bc35bc690fc54bc412c0b8bc0ceabe8ad2aa682797a088153fc5a35fe351a9a030db37e8e193e252ab065e92684eb9fad69122219370f0bd0d282a3b9a6a978196d3535aacab8fb77122f79c855963812c4fded007f0d496f9343271b027def9e64d7af00621d622ca236546f2169cbcac90eb5ba0b053b72d91ef4465aa5f742a62579b1143f58f1bbc2f2efa5f6ae673418cfacc80113ff376a2f5af34d806d9de2c7f3195503abb94cc01c66d4fe6f5336cf5e3502a0fb44e7f4da9cc4387b84d9035b67556a954bb2a727320a20d079930249d4020f5d50dd9422f55ba58bc60497361333c14ba955eab69d71bbba857c882d2e0e695135ceca226d9b8115092d0360a635768a55375cf65c998b855eab3013160251410b784e7501eaf46ed656b82294e8f3bb96aea8b600ced33237f507561d02e40e7f13f3ed72394707fa033be5dd36acc03347feb3d123c62b04e5e09fe80339ec1cd79f5d0a14a26ac92dfd73a4117addd52ad937f22442320bee6ac4980637b889913540fa8000aae0a7dbbfdf6380b3b21f8e7119cbd573a3ac9452930dca5427987d0d22deb5b0d22559c02ae9195ad40967d98648552a0c3c0164ea07dd348fd6abe37c5238ecaea9f03ff5834bc437fa391f7c75fe88dbdd7ea4700160b3f14bba7b5df6651ac163025b6166122228daebe3f7564c91ae21dbf73f02a315cae010e2a34b53a3d46b703781a1ec15516e84799350282a1423cecd050871e12f65ebbe28146974ca5acb7618f86b9ad7a2ce868be09859acc6b40859038c02f411ad4ab9398138eb543768f7cfd1ef8fbf45ccc19181b14fd7928e440e689814670b9ab15e4f4e91fef74d210caa05bdca1ef18a57147318d654b8320be60f311cf800114b7b84de73a31540285dc8696b1b5582ca75e058ddae42c607bb950cde6d8f91a5408083c11ab5a2fe698f8ee34f2a59b569a0d35c64ceaa0e2b6d02c1210f5ee8c87826e63605da6bd042af4590c9f03a122435a2d457840f false +check_ring_signature 00c166fde991964e6e575f55c9c1f95ba5f078b333cb4e948538cf513dddf5e0 13888fc028e6cd14c7cb7be665ab410324f35468023082d06d282482ad74f168 27 4b6e81a6031fdefb39283f9d78817244917097bc497a8a8f363a711714d78646 ae185bb0d945a69f1c2e8b2d0a3a6b9e04f9d8b60c5e01742f28a99f1ad5fbf1 af086439278da8ed42f173efa5b3a15dbb00313221606985be0dfea4b986211a 4f53a201c9c97ae232789ac7db45b3d41e87a3e15987b3131c8048e2a599c272 aebbe28176c63787358cabd4dbfa37aa2b60cf13167cdcb1ebf4b26e774a49dc 08464d00e98b902b07837bd5a83e675816e3f043242f9361d0b42f15eb8ed10e 2cf1c814076db692e2e44a7c41a433792bd6255f4fbb96ae18a93a391463d12d 9249badc730c279ac6701667b550d196fba9d10854355e960cb2107f733dd5a5 d6e3e41861a1e46388f3bd80b94696a3a01c9d8986753a221b7da69f2101da58 d54402d560ff303de78618d55fa06d1371126078f5203b78e12c3e19778d8bb7 f45178a19bc02d467fdc361d54cdf137840292d6210f94a85cc2f5df49cc8946 b2814e669cab92ef5ba8b7172ca685593e0d109fb50fcda3aea015d620a42772 ba384d5b5174f0b4387acec2f3654f7f1fdbf516d151cdff483f7c498883e1b2 a01a993b4654424969fd1ea1296bec02a4ced86380bf061d4bdb8141d95fed39 534a48e5ca27adb82b5d95dd1b0bc9bc278ec3a1d7b33d77e71ec783b22788ab b67efe7783c6f15b834e5fd43b4641920199fa85f06e45b871aa83b35c44903f 0fa5733a9029be83e72d06e566fe058aa3e7d81d40fe4d889f95f42cc4ee1a75 feb2641a479ba55adc5a11a6ab7137674e65ac9bed555323fbf0fca0f9c5c589 135a93fee00c16e4031bb73d5bfe7e3796f98d21d27988794fd4d855c354bdee 566892ef3418970de2eed6f126b239ec312524d63549c6243620e9fded957ebf fbaca07a57271bff130872376e75e3d52748ebdd8881eb74fc9fd1f8bc87af47 289b77edd5c4aa47a5834cff59513f62499dd3921144df502f7b206244801ecc 1b6198cf7985e21303f8d3602df025112f141547fd0e6cef628a90406e249d6f 99198aa61b4828075a39fa766476c61c2bae380e7a77cea486db66486f1b17dd 45301c3d2f3ab7dea069a323e0b5ab567e4dee398c2abbc1277dd5d7f03b6cdf b53b593f6f866f4676b38a25cafb7f46e78e5ec25c8bf21d9f53a1f2b43b0616 d249b79a840ba5dc970d4023ae92c6bcfcd211c3b1bcd3e83a4becb05842481c 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 false +check_ring_signature b290c04af485323186f544045b77f13f55e1122272828c0dd1faea87cc4d7f68 d6d7299900bff94c54bf4408a0ff68bb53b219d5cd8c9e027a7b1b505e08c8ee 6 b3edc48338b6e95cd92d54c2ceb34e9b99870788e4930874fe2cf3af2537e64e 52620f44412e2f3c5e4eaa8de1b71d4aa8ff2d4480e89ba1a849816d99de9547 2e8ddf621c59bcc7589481673619c65931ed17faf8e5c6b858618092b7f0b27e 9563f108cb1d9d51cef978569c97b4db7f2905c11bafc44f036e2aef396e0169 15955d23d7c485674e51f5d2fa1b2405c46d3cde5ec1a6319a549f78f7f4d858 7dfa484e5ba723543fc5db19f3ad2a7089f58cc600eac44e67ee2df80cb949cf 5ed56f3a85681b126e415cba1398c46f015df031a335c0990685c8754f76670232ef4876bd3d7f8169c8357ca94f0c668008b3121a751ee7c35a2aac620abc092b0ced009fed3624e591b9015f0071fd24b83dc7dcf9bffca273138c262c900a87f216d3b79c055c6b49b4715dc3346e96910c5661634e5920bf4343e99914037c800834847fffd8bd732520f1afa4675936b7960006d6ffc06e68daf8f2db0d62290e434c6142c7e74492d41168831b7f0d05c9789873ab6e47a5a1fdea7506ccff89a0e8b706ed1775f366ca486f2d9c6e56f92ab7bc3e20a15719bd2db90bab5dcf279b055b24cc1b6a9845672583396b30d22043f1a105dd7ba6d8041a086ff1d0e6ef61dfea05048a62ba6790c028ea3a575e88054ad49bd958b52a620fda3973d2b86877e41352bf53c75c78a681343337637b9e0751f428fbcaaa2d0fb224845c81a4663746d0fe656b8a3eeeedcda51c304c08db9f7f5110eb0d3c02d6bbc397aa382ca46549af1784a567dee409472826b3c2c02be7d1255c5ccf0b true +check_ring_signature 10f452fddb3d0a3b9c684c85d6ee95ac46ae3d84a6af0d0dc1d8a131072b292a 70940a965ee2d27916a0c770d1a23b5aefcc03751e64573858b76a1a0aa2efbb 14 880b09c4fea08fad3dc513b9f5c406f63ab9f9a416b2a0d3023775d39ffe21d1 11d14dd2496d819324120a052e5d0a4f269596baa52c8b0bfc70022d00947196 e81d3a5e990fe9918008dcd44bf4706ac4867d47d5aa3206d39ae5959912070c e9cf1b99caf4ba146f02283d66a0044e051097280883fdddc2c8800614dd6e9c 2fcac311eeeee45c94a9e4d063f91ad14a42aaafef33a60a70a2e6407c2de0fa 835a2ea35274b3757ac0181bb8320d2906ebf52d2e977ae19c73c87fe29fdc0f f4d01b10d401e150387874620af6b79085cd00e0f286b1ee02591d4da924886b b553e492a2e1e4f6b6283e0ac9f18f4349f0166388ded537dae121714a97edff 7a37cf477f50a23afbebc93685295fb1a14e2f5b8887d7bf84051d2aadbb34fc b52f7beb84ee7bdf57f801db71cdf78c835a49cc2e73116fe3db890ac7640c9f 073dd0dc33b1a956efc1a524a95e66eb508533a3afdc50c8555f93e2c89275d1 92fd721819ae1f94cca6afa74d7a59de504b253a21b442e27e01cae3b1ab3f56 cbb7d37c133952316ef9d6882f3a410a719709aca92794a33c2f6c7a92a10e33 ee14823cca605fdfc2a154af0af910ceb0768abf494c09398632544df3bfeaf9 f5e1e8a07680a575d364fabf3883373e6424a064343c8ac901ffc752d4986800db491b1f78314de9a38c8e5279eaf40990b122048ff3b5c97f45f85ae4ec3c0c971220698e3641f9825c5a2f69ff1b402fdd29820cc297c8d2d6ac79439a1304ad0810b9426a5f2bb2f43d09ff0819234fedc443bec28c98e6169bb7ef78090827a63db10a153aa0181e00aa3be88b189f29bbffc40bd7541301df23116df9064307d388d5162e0e0a504b72e6dc86c6658296321abe65188fc5bd72be5b360ac243ba1537e7192ecd87e98dd395cea1e3c333cb3206e3c2d30a3f547be83509b2ab8dafc020b925165543efb23047aa32ba0ccd275f63ddcd61140d4c77e20162ce2a5c393da1f01455704365054e5925a12d46cc3ecaf5265f3e554b4d2e0ea608728f15c6b625fbbceb8eeee3dc60153334c23de68399c66882f4e6a4090b7d1a233e4df789c8c0cca9a8ef3db64ba3b0948306a18b327a7e86cff4e7060eabaf671c0f89b73c3433049ff53c50f6ed62afc54849f6c84f33b4d5a8a57907f82b1b379539dfa6da3019efdc506bc97c65b5e4242a4eb25891b90266eaa0031d0afcf4f36901257b6c3b2d9406c6d976a1398febd7e3f9770dd0ddf81de60db93b893eea1eba835310447c45696797a257afa2140b68f7525f591bc609ef01bb4bb2ae269f70ec719bb3c175f0aaf0e9a79f349bfcd43d992894f13a225900f3809c7a3972be7edd0dde23c4971216d7f244576f694cba0e26aea0f83d35003fb2b40c860d9b6b1ef90d794e435dcdf79fdb159f454476d0c4918083514501bd44a704eb5905a0280c7e0a947619d6e24765e24b445b6d0a41cf4f1e2f1b039844a9b7e5ac425fa993c5cdec2b4232a6439ce57e6f9484bcec9789765c320af2ad8dcad2f96add99c80e597e7285d5e7e083afd8b5c33a63d23672da88750e7c0c0d847f94af77c8311cb1099018e95f42bf34266a71a5d0a31196f3c13403b3198a8b5b2ab1ac8d4ad804a3febca212f70ecf35161a34f52bf268dd44740d2a3025648a61baa19dd38733f25a72af7433390dc91c97b417e71859fc79db0101dc7900b88bf2dfa89d9f462c01c15dd0b0528701d6a8a3f90400b29b67d40fbbe2ccdca793f1e1f1aab7896821e07777762503af814f47e8d2c9f1d7bc7409928cadf762c5988e92686ed31fb5e35276e6b5723cd9672b803ec796bea78002b0fb3549d1c5075a48eed362212ab12c7c6808faad4d66046d01aa87696a2a0c true +check_ring_signature 8b8052fdd749cd8829d04c5673f9fe93a8bed11f9fd8b711e10e39ea2732ae8a 045f99c6aee16e22df83d52672a5406a64b9da7da999fc09f8946845a0f789d3 2 98e776eb4d5f9dab271cde4925df0acef546918f71ad9f3a6c8ee44009aac8d4 12682ad2e5d23b23537853bf1d8954f8ccc856829672d04351babfab3ca3a7c1 9884435df7b55852bfe6286fb7ba6a22fc9e10fd688893b788e55c9c7145a3b0bde0710db0b95ab355b14106f7a0cb4565def61b88ec218b9f3083157f469a0ec09abf9399df7e7cdb36f46ec50113e17598512c2c040ce1e760891509cbf10d209ac842162e692c55da8205c994dd0a0d498d34118543468b552d9934183305 false +check_ring_signature f7bdf378c952d98f8b45d6c944a90029470a88ba352d728f4bbfd1752ec51a57 09457dd660ca181c80cd1699b0eac6a3770cd060ea29cb8b43135efd62699a38 9 53304409375ae7357191240ce60c7130f4a535eb00e2a907aaf8cbde79b603f9 c5a8b2b3614b564e64953376f6d59c5eca4f5f198fcf062767b50d7dfa692c3e 41bac0673f2ad39f7a7958b0bd7da19a65f132c55752a033f8aedb8f95d93b5f 2aa8c34d9ae71bd938d0454210ac3518b50cc29d78fb621611ad34a21561f8b9 f4543105d394123091c2f0cf21c9fb90930427c2d467dccf6dfc374fe4a0bddc bd1c763cdedcb4e471aa02a7d293328ec06508353b5a53ab5b323301d5140d14 93e3c7ee8b88f30a118eba9cb981e09afa4d68e0fd59c402c0c8c38975fa7b74 a1a9d9e453929743640e7f3746c98f9ea927c7985cb00966c175b0cfbcdff4e0 08f9e38f4487d6fc6d2eb66369ca20922de631c1a40c710b922441521cd3f36e c2de6434074009274bf3d3295eb565dc37efd6fb105bcbd44b6b37ba7c80e4088eadaa8fc016e70261af012a63879a98552ada0b76dbe5d74242e27efb72d9009ff3eda6ab2463d56ab67ab141146e6fd819784221cee1010371d2dfd6528f0c09cc11a03423b249f9acef5434b1b472484bfae909a984675db3c639f7cf18019d51ca19c87bdf7f63c40434bbb20ddf93796b21745943505c14a837b83c4b022a24a68f007a7c56af86d5e189e31cdcc83b742cc1245740b7c94913fdcd520edadf3ca10715bd9a3568ea6d5c826269f46b5029ba014fbb48c63ff27ecfd90ec5393a679c4624a60d012cd6b452519f3b80e8f84494c70de92d2c54d958510a564675bc3c7e3e10204f0979b95285d10f8113d154f155bc39795d54b9acbe0123a9433a4f683745b5044fbf7d136fe0add30469dc28e6ec66f36dc00b1b24084d1ada378d991c46037f9e8affb8193e9e4fca53c86ef72ef8ebb30761429f014ba12cb4166f9b75eba9049648dad76d85bd35d1b68da5a33b75abd6972db808dbb8cbd7851e7617f6d506b37d4ec9609e7333a7a11e8a9f30772cd4b8dde6003548604efdc6d42aa41af84804159954733f84d427bc9462fdb9a16ec7d50d0af9470cd82133b632ba143d7bc217107a03f1f21ba3f37f0b37678bfce1151d04b6da144f26f32b94ae0cb771bdd09514e1ab7d1ec49206ffb5c301e75a13ce0bd6da2cf034c95a86c6171984aec44d6c8e4ef52933ee4aaeb473fa40c00f3e0e89c9f7120b0d5de1b149c9ef5db9d4b0731613c01917c58849f0dbae72e87d07 false +check_ring_signature 0152908479776a953687a784d6554b5c9e91f66409e8e43c1ee285f2fc99471d 0bd543318da95132267d35d0e91af719e02173d19a9b9196351040ed2ac12e98 59 1628bcc1b4e6a64a46ab0562cb51011e2b16a0188667b2f346506a4c6d007845 42787c4d1202a0efee5dd69e2c49c7bc2125c39ee2b18aa8ed582db81592b9c5 ea990d2e8a8ac0fb1841753c730094ed03a427966c59ce7decc10ce0ce980a60 a0161df30ac046157bb094248071b5153961748b146bd016d7fd128596fa6fbc 23e71c9c5b454cabc05eaed969be1bd03ef47182b807513e526806cdc4aa8973 56769299aa5a0f8ce651f09827ebea8b8c485c9b3dcf99708384f6c74316fb92 f86ab994c962e0c8ec985907a9d23f8110f46d97774bee19f27f6adc950f8cb9 da79e8700f74b353da39a9ecfef4dbd7611b840dcf8f455800801a6c8b9681d1 1b3deebf2b739713465272a42f9ffce83e39137717b3380547ba4fe27d156ff6 d4f61846f2cd7b38aed5a15572d2548b7bbe79f1e61579401fd11852c0891891 ebd4d5ee8bfafab9d5221b88a4f0c2914f6b79dad4dc4ebaeb236422b8a74597 b39b8c14600a666f0538f2648cbf51a5c8a09db27d51ce377a32531bd81b004d 8df2c271f744bc2e4f20e3f93471d945e175e0c77458d5ee15ddda88812b3a40 c5f128ef5acf408e4f8f8338c302a4e1407597e3c272e9f00c28f7067998105d 87329e43419453466142fed426d2256f5431fc45a8c0cefb4fdb923d6476f3bb e346d136e7fb72adad417624a26c9fbd2b8b225d158cbc18b036da031c3f5b0b f460e1f3e5344f0d7a11b5ec35aa382ca7da89f821a8c72fcdaf9fc98e3640eb 884f5ef688a9e78433b25abd86c360152324d10c36d39ccf61661e67b14ddac0 e39c9bec3d02a135c5f07de18f857c1e16e5324ae513ebfc18fa796765dcc55b d16f3247e27ea2c1ba34387e456c8ab977a0d7103e10e1cbee2bd12a2da19019 e382ba49e25785909f36c518814934967850a94a2633332d40f27fd38f0eb946 3858b5c2c731a4dd98cb3656f2e505ad3dd95a962499a24709514ee10db44c78 10a7c93a8a1759f6b91eadd5f4b93a69ed55e178655fb30cd9a6f46c8760d32c 66130e12c3acb3af49e252e9533f43600ac2a2d1c78c9d552e72f8c44fc893eb c76747446a6bb51d6c2b06528cbc84b488bc95d3e5095787963459b926c7f4c4 bea180daf39a856912cb6276c51da6b104c3321c8029cde33f189f348a0e5686 a09d06d129f686625fb105317bcc1f8cf7128d65141f5ebd629be73a9330f0c2 1a2f694083d535c8db6043c1259da33b46537d264c42a08fdb9331d2c0d0c0fc 19addb527dcc189399e6457c905a8a05929c08cd9256523702c291ddcd89a561 eea164fdcfeaf9cc6c6c2cd29279d6e3f0f249883c2d5b449ed00fa54925c0e4 79dc45111168edb808afce2e330752c3f774f0c82363888fde912bab15b75af1 758404cc56d80c95caf36a8e72f3bbc7ff5afcebb99fbbbdda2af6fb524d4c5d 3799a667efe2eaea4ac60b4e29fc23ce49bc1793a08f85bee2a6eb216f7a93e1 a004d17ff260fb97b02684f689904aa40ef93b52aa916ca5c4c60dc4c75d62c3 41740eaf65b885907c80d0fffbebb01a9f9faa5de0124593284ad584f606ee0c 8cebc0a376926190f67c95b538b60baefaa785c5616f6b0d4478210a21d23537 4548362a74cffb5296dd08fc650c85c16efe84569f8a94551011e56a09ed9618 eee88177079c051cede5030b965331cd5eab796c92424ef2dcf7a89392a29f62 a300e956f2ad4e4b67d9947bc4f2fcfc23c3d9aaaaf58a36508c6cddff3cbfcb ac174dc830e6b88aabe189f57cf1ae851b4ba22154f3f6d5f37f3016fc4a4864 9d694ceacb1714ed7e879d571b14d639260bfbc3b61e6068fc2c78bbdb5415ae 8c73d19b6a6a96e932a0a303601c58e29176fb04b808f14b7285abd2b86f07f2 bca2d6bf4cc3b7ff8cf978f929556f53447e2ee52bfefb4d3c0fe4044b6baf50 9371f82555f7019ad4a69deaccd6fd6ab3c3d890f474060c7d817a7d8da73176 de212f99f4edfebc0a5bf6618b0426ba720a6c0ca900d4d37f9079c65c035502 583c0fbc3b0e24f2040cff9b6925c03d817a0075c77091d8d096076290db6d7a 4fb52ad360e689fc357adeb889cc6b4263a5dfd44dc1cb2521cc847211122572 f35bc2b7fce75317815b0f905472392c3d1846cd8b092723a2fe4699a09c6f8a e2fd5ea1fd9dc33a1f90d8ea1ba4c52e0c6b201bc7ea07aab69a98ecf16c0851 3c16585af5c424e968433624dacbdd6184966a5cf8c2625783824e2a7f96fade 5e8525af0c6e5533eff44c90c04d10c16f02c3b78e31291a4eb22a6ef24d347d 0efa25e30ebc39fa7c834fdc8977f51573a60cb8670ea2ae475e25f7801e03c4 96a14a00d1e02cfbfb86633d06ab2e72babc9391e4ef78dff7aa0601b196cf40 b107beb98825dcac701e3ae9d020b29b7460a4b52ead478b26807eb8bf6b292a 54327c7406b898a5a6dfdbb1ec1f9de740a487f061957e83388acc67fbb41177 46b3fcedad9c9ca9a0fdb1518a89c109958c0003bf04927353642d6937a5e07c bd353352a415db9dc3269b65e6b735c775f15ff2f3aed3da5ef11eb3006ccc9b 2a3e868c9b88e68373815ff5171212584fb732f94253efd2b07edb35ac83bf98 eb9debe6ffa9c219e078f4e18c5be0804c55d79979c542f62bef567f61513858 c13eeb61b1903c58c14f72b06c8b32c61321b93017f45d636bbae186ba2a7f0d300022c4b7620cba4a267dc6987a4107ef59e1ed7df51b90aa243646b312290d7ca669cd5d4026e3d3fc8bafb138281591fef507eeba6171db097bbb45d361089f9f892ea90d74ea33fe71a8ab0a6eebb5c9603a46a607816e996c56d38a4304cb72e9db021503a7cd0145a3c1e05791f964f7f7993656e4ef4eb4fae7b359088909a0d11954a91c39873e123b815b65b1640b54ea73bcf6f45b2e236c7bd20fd97e4edf7b86f50de6c5b7c20bc49dcb3f9cef447424d9f53c362e0cb264260051a566ff948ad61e1e0cb968f6c47d038fbc20b356ac87ec4ec0a7ee34b7b50857b095f4dede777816282ced67bd1d08d3f1e0e25e110394226fb848870a290466cc57a88e09b2c6dd53eb1e739db974353b4082773a48d4c4ddfdb230486700d436bc996aedd56e7f3aa37110bfa4e40935eeb5c260d3feac026613a045f90c59bea591a3affbdb727178ed748876c5a6c554671c7d050fcc6765e58b544c0185046f5ff3882f363420891eaa8eca0ea30bf1c85bfb834ee8d5a7acfdbcca067932f0aa80614aa16bef02701c4af89e635a2ada728a9fc8c2139a5956b1c6046d8a495ab1b72e779b960ee0185a828b369f23b016ee484b561feeca5692ad0892ce1b67d40db9e0d08badcba0afe73e12a827caa57a9190d94ed9241921e3059ca41502ac9ebcb369b7a4c93e8d3ac7a83ef9c57e0d97ddcab3531c9dd65c01b4efd9b29a9f2c95a03de90d6d42cd3f90e39fa19e11d8feb2448c454f4e14062a80cc6efd0a8020c895c394f2bcfc53a29d3fcf0f668c155f2631fc2512ff04974673799c9fd146977a5032e96ee4bd5c7c1f7a0fd0b46a19b7fc763bd4a30934d8da25ea4d6657d0fb028e3b5f8d13c4b79becb454511019f829edc5c9df0b3ce15fdaf1d5487d75a1d3946668449c3781c64d4791b5dec8bc289b4cd1a605fba5c3a5d9e02a9e5df920edc77bd78e5a8a91000798b91fe6a5d4f545a7fe07e52d49524202735ce70eccdf6b6f267c97530cc39158ea19d787557b5c0a560b6fd989830f6fcf4b3e2b6bf00148c13041da2941880f909ca07784e7c9765d0780d3769b3e4bcbb1bb41c3e8d16aea560e4b85288b18ffec009b6115b608be054e5d1f2f7d99a797f1531a51e26eea4c1e3e0cae860db46d70693401a6cbc60f7d5fc3599d0a95caff0af45d71d68af58339e217ad24e3b2556753c6d296cf00033d78eb1fde3861b2f73b6e8b21d201f5d060b72ddcd3788dfe88e7d1fbdc03a8afc71bfca5d672f41234244493cda17d9f18c1dc70723c8e098035c1b9fa01c13e7bd859c2952b8e05254ab415c4c41cbd9a19156adb2161294cad0f0ec0064549830754bf243780579b9f024ec9024f60386314e0dabbb077f3144e25d304ae7070e27aec712c3562b6825ee18438434e3e2277443507d3f3572332fd3e0dc51e266b45e7752d5f52a7bcc12c252742b698df6900a154449440d94aeb8f0801e531869b5ecc4aecb2aefd0a4d92cb92bf775fea08958458bb724f7a48bc03e8b1a6cab7aab06404acf4ce182a1dd835df9b2041ca5ab5838e7deda2cf9e02265c54cc13f9eeeb2526419856749c558188bdd6370ef83f33a444d29a0ccf06ae2042339af351dd8f9b55e793016924273db28933cd03e278dea45d236f6e01112d5ae6ec3f9ccbb12d4513c4f87d07d1278203fcc93390ec1887ea3451c8060ddae2c16724c971b6d709a36a9e682793e5e80577b70632bea3f319f87419032f61729622c289a449e10c686a3916c2c8e0d3bbc3677b512425966d12640d043c0d0b26cf2380de7055ad4ddd1a84e18a3c685897788c3470eba9ea04589104ffa9b6b4fda501631afc97b357797dde2a62a1e9d702e32070ef7e81e119410ba647f207e0de87ee06af9ec871c9ef3e5b433ddf94026edca296349f5fba24068cf6862d95474e19d0a872c1c39f8549276921587f1b257c850b962e1f05d006b00513d8c47120e764436251c291697da5c5dac00c4a641073ca79e8fd0b030a1118a9db891807f58dee79de4453a473e9f557923b612fbe2732b414fcdbfc08db4988cfd2965c0c57d45d807b8e3a2b262f129932b6f52a1a9b4c69427d9f0586d172c70704832149f2d4b84fea91febf3b97db3b4cbc92982db394280d250bedbe9b15389599818b9b408f6b009fc070a01c14de250d20028f1018b9b00d0b9fa122f23ca8294f298bc8216e751b586a6ddd3e30f6b30b0f2a61a7c2cf5e03359c753436790fee5847ef1be1fb290bf320193e1a1416390e0bdc10a6cc1309d2af65d7ff959fcf719c67c76ac6f60ab90d06e808899be7a5dd4b7b443c340ee36014390659768ffc4566ad22e5e53e9c92d143af5ced003ec6e2869009710a2f44dd857ea2bfb902bfdaf9c9689f37a7075a152f299ce2fd036eaae3a44002ffb8d91f707048585f3daf5a99fee1310067667433cd0e3b466a65d299b21701abf28dfc4a386ff026787e71be0c6dd3d0ae32574817acae975a0c12e2ac6f0bf62bbb022f213a0f1f8fad4f78df16518325057cef3541ccafd1cad8f7a1190b1b329c28432db24725d9ab9502bb4e310391a435cbd7a6d52cf8fb22c2a2910772e4d725907884f785df54ac1ef40bf1f246252997099a55b080b470f51d690886892c7f5c8ed805c422e61f6086145546449b24ad428ca62e1258ae86fac00477806d6bf801f1165c0eaa7fc46b4450fde7af0ef14add13095f17c987266d06e8af38df547f877f6675e6030b635e2d60b6bc7a817590b550757b41eabaf4008f168d7dbd325eb3f8bcb3bc5e3806bc85f1118aaa861f9fd4cade2b3018300b25e8198bcee8a46ab6ae78dea3fa25ff2a3e4455d41dccd30b3a80b82179a206e18e11444125b2cdebea016cfe77953aeb4b7d9ee9e07b86b1f088af7444080fa8672d4debb320aee1b2cd03a4a1ed8013700da2afbc705936524b001040bf007d104168ab7a2f451a53ff71dd9148b1f12ab13ba954c798292d309c3cbe380f4a41e7c05c4274be056336e904b27a155f26a950a0b65c4a5b7d4f80aab6090e68546d968163533bc8fd09b65a932068ec872170b6f6c4c9c907e10f333d790ad73bd4619e3c1e10b58c9b750ef23e7351aaf1d6a0d7c8f392de6ad492f2470777224aadd404fb3e312e2592ff1312cc8f1c6673e16aae0d4f603e6dfbe9e80deb2b531d400052126fcbc2c7799f241c12b419f8744fc72be5f82330c1c920072edae970f4d05cfa501eac02ee76edc1ccd2caee8761334fe3da8e3f50be6402eeb86c750ec4083454b136ba339252ccd8740aa8ca09ed2e206709a1ed93f309f40a9ae8b1aac61e551ad480a1332aaf0d827f9463198baa4e0740bf4e87a60e9515e80f48ecdd93aece8f08ef1ab3a8ed4e7926e120ea1485ce005efd3f31018ebf8f0e4a74c754e210c4ffaacd12db598eb8c40856e5862e95f5a15705e60bd95101cd0e2f7292c3a91b0ffb6db9ba36e771c35b20f811b58d2f3a32039201570f9429fa7bfc631b6d000920bcf03122152e1cf4a6274a3f2188b03d715c0684ac8a7187121b46c042c86a608f94545b6aade181b993d9bfd278df7d94b4026b6a16a67e868738404a8e7774c28fec76cef38183462a424034015bc542330c2e51a2072c16df8a13951047699755bf04cd4a59ea935fb3731c41c5e880de0861212b33f2cb9a200c1bedf4ee58e93a07fdb45cc263d379e151a36af522fc09f7750d85b6c1a23f7f85196efa955ba81ee6ca9170806b8bab6a1b39b7b99508d0621f7a5cc119df96688fbda210d586664779bbae2361f76b2911db028a590d3e4c82a8236b011f55a88f4b7b9ea55f6074704709c6fa781874285e2643f807020e2c129ba550a33f708b7b2086cbf959d226be4e49bc9429ac49613331bd0cad4915f4165b14026299480bf5040f9e3c00c2ff9a90b6799babb0890e320a000c51f74fe2a781cf025ea3d37053fc7c9048f5427c0630b2856439c7318d0306fb8f3ea025d10891598c52650305b5cb5c218484a81400a08eaece9d26ac810fcb681a4534ed133417dfca8dd1a7a30cbc5068b476f2d01de0247fed70e6a60f0ab7747fc1edf56e9c819d4578d225e3d50f5fc23b4b38483241afe135798b046a77f85d9b9a1179a8c2f2ddf8708cca41094eaf5e27061ecc4dae7413883f00c1bc181feb85965ebc9eec0fe0028e0e778756ae10e5342e07d3c7df2b8ea003104205a4bb1aff385d82a23cc0c9283fccec5bfa43aa13d65232b9aee315ab04d5e6874778a78f4d37a5e13c70f2e7eaa8818c335d53c7257d53b10376100d0b07240a37a5c74eeec634640515eef61568f9c1f429fc5bde3f3fcdad27df4909ccd213a4e28b44f4827b498102991f245b0a62fc827758917128aa7b666ae309225268406ac445c3afc85e179b0fa552b3a8135f09b5bd1f3a9d06e8503ac90ef4b895849c24df9f64f463fd776c9b1a47f3a2d5558c6fbf29eae21b80cde1042399b13d2c18cf3c6dc6e82d8d5b42cda846f074bd9680f206b51ffe0c7ffc0741511b7b26d19bffc4199e89eab65a41cc5b8d0df7216242eb13f3214af7920aebec68112f16792ec5c598f4064515966ad093508c6a912cbb5842f3074c860c2382ea17e6f5c0798dda7ff97991f6d300de108a6cbff4acaf418a85a08dee041d46ec37cb85e92d5ee761beba65bbc22bf36cc289a3157b0e186282fbaac60bc7c687bd6a8852198f4855154d954d68c1afe93e47250ab212acb2df58138102d07e0173a8b0538cf68270340b0c0ade6d2d2309baf5666aae4dc58202acd009d040352f4fa00cfcbc44d21bc5d87b421e7c952d262bbe1335ea672d9ee4860182f25f3a6b8126744001a90c7e7227e046914fed18da21535779b2dd17682e02926c7cb8bedf357c869041a9fc6ff603e6664a9df7e4c7acdc1186f7f18a1406d64c38739e8d45d565810c41b2874c58d25943c6d349ab15d592dbff4ae79a0dd6e182dab0507427f5f6ef0418a028a9248b49f2dc4b919e20da1a343c61a000a522d9dea20b6caf609d7c3c2e3073f049c5ff349e67faa6ca1cc4b3523d8c0ae75b7ef0158057aaaf7e47f3a3cc2c64497b9492a85e903fdd5b439211ca400e5317ed7a898134b7a0fe6a46b106f575f85223962fee1b5f6f160bc8794837053d849ae44406faf13b5e5288e1e95b77edc591605f2483198c620d6542f9ab026cac1b8b083267bce3d769f2e05c08db1a28116f474a14956ba03f21905a2608 true +check_ring_signature 9029d6c3eb54001c384fdf2eacef42f633d9059b96d756456e48ba23b08b097c f97d599ef1c8c9fe1dc997c17ceb9fa05732e83fab78ad3ba1fb143e83de66b1 46 396c1f3380ff3f9e8c4f4213198e5faa674c2001dddccde83bc1531c7443902b 925adb92914e7838a7874f7157894a0550caa28d42835ab2373ab0851f84493f 9a2c9cf9ba01965aa306d71a665163efd47e9e5db89476d59f942911922c48cc d607aec9899cfb6e923b188d771b8dcf8b1d32610e180ba6439d5f16f8482371 f6b4d9fe3c872f7caf33d0f6b3385753701868048d0f62b56e64639e045bdae2 89351c23c5f6016acbc189b86a3654c1ac8428ac39c9eb6f8eb8dab5cf445e4a 3a2967e0b01f822bd28d79681f8fc92ca6fd527f368f4a276e5bcabe095ae975 c4ae847dffe398ca68a2e9fdd546767492dc4b37f44e21a8493e73722cb5c260 b252d21599d72ea5062812d28f8ad89b703a07874d9cb912d1d278c5a843afbf b4980e66b4c6b7bef82df93da7eb432f451c1d804e9f852118c350c154b16aef a54c44d2a6795691762eb43ed0bc4fe343f78bd778400713386dde9a99f7bc12 43f48aeaeb79fef93ae9ff3dbb237eeff8c98c3b1ae6ec562a3b47c127f546c2 c931d4de2da0e028935551f7329105c5e22b0ac2725bc56d2fe0a54da53010b9 5bfc3c747290774cdc01ed2f4c71c1b9a3d6a88e4001d8fd83f29e5e1b0e6686 a9efdcc5bff8e5cbab4addf205f42f6b3af8d9ffd0130b8b0869cb4f6715db41 f01d11f7d3034aa6b9d40724d33c81e07d487a789d09c9e89c1cf43b4c500d95 45327503ecf7e8dcb9af55b93b6967efd893ccdd91f8141e9fa95ce2ae630668 ae8f817bedfab571d1a207dbfdcbb518db0530f1bd14205f42113a144c698411 bd4fbca0e2b4bf4d576e06b8bb3977a5e4ce716320898975c9577da47ab62cc8 a5b5a4e608acd368d5a1718899b59882b91d0e02dff515f005cd030a1279525d b9cc6f971b2ec5b5c58b239e2e348b04750b4a5d4c9dd76ea1c71fb40accaf48 4edff9234e1af2866ca31d401f219271703482bbdb201e22704353d5f140d191 46195fd413ca7c8a6bb4fc34f5580c20a994998624d392c028cc85c243a5cf33 81af4a7d1729c1a39880011dd50939de06f20f1adb8a61a72ef1a0891c323edd 86ae261d4a2c4ca06a3df46958c1fb854bc5d6806bbb578870e98d1d4c1aa0d2 56a6fd5eec396533c7ce505ead145a1097b9f25b4d730a4ab0fdc32d648d2fd3 284ff3c4acfc46b5f7712f8eba13168ab671578cbc14b67dc97fd429ee74debd 6b8cb17d33c91b0684a5ead5256182b5272fcb0f6197a0bf3c3d3f25540fb929 2a5ea5f801409a3b6a4137d0499e545735593061bd66c2ea88073942fb8836eb 66d5cf949d099e6c62da9441d3810261f4a234a0b1f3cd94e86c9c7cfbb942b7 e1a8a1ed8dbf10c9ebb5ce80afbdad637aa9fad60383735e000a0a0a6d92e065 525c0500fabfaa7cee9c015f652111de9bb22d99527bcc1b38c95c98a2a88eb4 5f2af4e0c0e2f7ad1005d8fcd2f70ba78ef82f7420d529e2ef275d694f1065b0 b49ee4c7c0110eb2f0bb381cd978e8c62c84381dfe0b9a380e43b842f0c5bea9 29d29d0862de39e4a25c83a177aacf17dbaa83f3fc079a86187954904fd5f02d d353943ff019bf4155faf0c19516af6438dfef160af99f2193c1ab8e39d96792 0fb63e510c694d961101d9b36308943e8823905993ee73f34ed746298dc85f26 c9738d390ca145d486a04dcc9f5cabb9d04b719d76142b10d99a3e7c52ea3ba1 37597c8faab3f91cf23a5faa15f2f8f177bb7eb68917c92ebf93de8a3a7c85f5 e365b1a4a454f968b417dbfbff90937b423380e68a4dbaf8840eda9dfa755472 6ad3876d6089ac18a058455e3be49c506a615290db6f44341b3a1bc235bec9cf f2f918dd6b7f233528e95ef7b96aa9b4a9e7f888fc9adb7331c45bff9e3be7f5 905d2ad1bf1ada8421c3b104105a2d2b2233f0167f26f96c8a425bb922f2a1b5 ae4961e3d4daf8917651f0f69c3e565bc12dca0ebe1594650282298285688a72 04939d774d7e80c312c801e0a77b2ff1dc373877a214d4922f0fa65d9bd590bf 02510fb3783a26c420b9ea3cd2a1794cd62c109c395561134f1a1909cb89cba9 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 false +check_ring_signature 6f4a353c98d17d690766152c7514af2d0c90b7b22a652c90187df0771968128c a631361abf7ebe5449529d94cf9a967793159259a85159867940befb5726d469 131 5a63a6cdaca831224a3605fee9d1ba737cd5382b53f99b6d685c99d59d9c7036 8ac8680db875fa26e3a9c0e56c3ab4a1b7d75444d5c5398a16e46c90029d71fb 54cb5918cb9fd7773cc2d87c0aed21713ae309de6a1a525d9130be747694d192 48ec122a3e15fc1dc97e38bd797c5a5a0666c9633774805ac508d8581304aa63 7caa26c8fad164a80ec7a14d22f275ac35e3defc4d2438cf03cd19580ba7e0f8 1c3b8d594626ec9261f9a121e9bb2753c9f33337b0af2df6e44af800c1b2b63a 520e7f3076804dea2bfbb3c236378f18178ec407fba9b8b583330ed62f313b3d d04df52d53b4220c2885514563381b3363fad15d65de935cf170892d51bea618 9a85ad8eabe7ea1fdb0ceac0383559d645086a5c197150bf82fe06ab3a2124fd 69c4fac644a9153b66ed1009f0607d88e8f83d47e3b963849c0b5681f29963d4 9c765ff37ddcff3a29e770987856fc10b5e5bbb37b69143c3882d3f383dc2ea3 3759fb46d89097ca92c19b017b6ec55dc58b966b056642736163a44f94532f4e a2151b7b55c200bc90e684f5cb5bc4623a7782449054c0eeff9b3fe608060dab ebdf6810aee38aa8ef1d64c12e481a046ce02d52170ae076e73344e81c74dbea 25b8d4ebbcc976f2d994c3dd44ab69d994c84810e450c1c96149d5d35014901f a7ecdbc7663aecd01a2212b25d2c0e5a0fb4717c830cc7143c24eddc24f5db51 a399280ec5a83dccca6255a5308cec781e99a69039ab1dffbe27a2920b0c1b00 06ac2c3a341a7bb9558c42e8e2f5d3210bef36a4f41fed5947ebb3407285b76d c376976edd098fcfd2de0c529d2d97d2d30a69e2a44ed98b31b7d23e6c45c1c3 04b1c371c20afa0e33e2f59eb90040980dcf4b966c8b44a234e7a159db7357fb 44cf13d993c7ebaaeeb4e51853c4e17d11935977458fdc4c5fe689ff55023c1a c45062d0cb44c031249042eecf0e69d93ac520124e046b1f14450d9512743af7 611531a984c9eb7b2ac037138281d766ec1137b52305e65689157e08558bbb07 697715cdc76c03de9dfc44dfb32bbcd41cdfdbb9425353bbf4b8ea8fd1a6d7d3 69c6d04ebede43bd7c0c759c4daceef5cdf9eca844f7f3997e41ca48c95ce393 addbefbb1830c9977e2b8afe590097bb5cab002b02ced6deb9ad474fa489e0cd 199755eb513fc04aa7b4a0ae5b78ae98f8848cbdee8d26938f1505dc507bae17 db27126c4c5a5c657d6a1cc87da1df63f5db4e1202175b5120a6a7b5c0d9767a 7e48fdd0c4c8ba4e857c7ff98eb0048544393eda6ddb8b779e46972582114a24 9dab90ee09f6be87fa7758d8e137b80491003b68f5023178851cdf4b51aabbb7 721254afc66aa65aa711c7bd0792fafacc3a5d15c54bdb3fbd07ef4a03cf0f6d f68fed9eb7ceb2c3f607dac93ceff2c05df4fa81acab368da22d4c2bed7cbe0d 5bfd80ee8cb9f3a939855c174110da0532689f8936dd52e1cc222b860af29937 18095160504e1940fb2b382f2f4972e50670cc2ba6d6ed730c7d678a87e4fb9e a406ad8970f7217cc8fdc42907f22cce0f82928d3a7fa588a207b70080a9417a 9af6a34745b0f9a2f88144ee6b083c73b7b6eeb6d507dca685f83ba9ac1c3a66 2e429d7eb6bf3d3d3bb6fcc0058775a9f34ee7229d57763581b08cb19b465fe7 66639884429e973d7586e9bd855ab6c0a21826d8f26363738e8adb7317e8e360 08e7fe1a4f190a16131044b2318b01d168c040c4d0214dc3fb64bf269533a2fc 75ae8010ff0a6eb1fb002b920f7b92080a578d044a5da3b7d73a626cfdc8bb77 9b11f45a9eeeff10d4fd93255784968b4d709a05660489b0801474f8f595797c c645ed6437125e3ad384890a11a64d75ebe629c4d0ad34aac14417affa050b56 1eba5600b3d0efe85628ff2d6a88e5961c48d3aacafc6bf5051172270572902b fe0c4067eddb22a49075c8724421b0231c1566b41ebdb67bce0f8dd5bf20902c 9296847a37b6dc52d7d3dcbe60da733537e3a337f5b9c846230c9260864478d5 54aabdd44f329c08ec325d05645f8d2beacbdb2743b914a27e87f16da3c434ed f3857c88dd7004f672782e78bbfbbfee2e5208a9ff6668f803564a71fb1c164d d23ad9948f0154640e1b137ddf90ef41533ae18aea4603d366f25a1c4343e100 a327fc978eeff82c23c810e536d75aef1fe3fe2bd9488036878f209e723557a9 dc9064bda2a1664fb6f1bec09158a56469f70327f8a8d63a9cfbe08d954b67bd 8bc2459cafcf75b41f08b44a6d9ba0ea68ee6a9ab8d69befead1e83402d5ef25 79b6a6c3566a8adcab67d0fe5040fe8a90a06543302c419696dcb6f59dbd6aa7 8a2667cb62f56bdfa9b7a4dfcf19207b870590493d984236a534a36f35f5e1c9 c93ec915437590f67d6259bf8fddc45bb5e40a5b0617f698ec342d91a974feb4 60c57e687f8e9ffd5563561a6b68b4de7ff83e90e82cb55d178e433aa97832c6 9501640141ed72a7523a3872e45e2bf097ca106eac29f5b2d7f913aa53446590 e85e4ee068f8f77f3e13a118dcd60a3a6b2461c036d2328d40e8fe406448b79f 4a3244fd9d62aaad96d7e070d4782ad1877bdd545bc6aeaf6a9dd22547e2f77d 003d5a3446361ab57233d6c96500c6cd17fae2ff7d1e47c926a25de8bf3d857f 6d3a430c5c84932ec2214147ca515893cbde9394a4f38229d356b463936e7612 6740a3a129ea7625ef1476d45f052e5d686c2072ad2b341c5b81e98c38f50b83 898ad045b8ca2afb8d637244f8b242438397d29325eef563ee976275e6d4beba 3f94b81f74f0b962d0732e4aa0a0a1c114325326c22f3926f5590b7de250bb9f a80d6f13d050fdc79467f011e8591a16cf8a386dd5286ce361cdb2bfe40804d1 bb8b413e894fc2a8cf818d1ede1225cdd130ecb470d9dbef8a42dced33644653 f29c84a613959640859a12dd967e1b1878ab09efea2ba8f8894ace206bdcc28b 2cdbcdd2bfcee8300b484b4c982d88a94ecdb47fe7ed3fe44d408c2f80ed4aa1 9ea4afe750d0df5a71a9e761bf16c7ff9d4c10ad0c29ba4fbe32e79a8bff2a55 22a6d452d15786c34e6d9d0618984836a932113e5046ed3c115cd1e140ba7ec3 a0c40a66488641605dce9fda22d251b70faf01d3a31a576f192a136b2446e7a0 a099747d6e82117ce533670f428a4dc424a5f3a2579755485f7448c315efb332 718f0d5ee32e74721e29eda855e7948939b389f42740dc3073b75e3fc9551233 f146879cc102ea4167ec679c9bc11f0a859bf5d0dabfffa408af83276726f4bf 460dee2a2d29d0e7f043007baf9063c5a22424a515c6074ed34eae2b0c6cc85e 90c26ee26d0596796a0f27d17a4884cc3d5878a3a8371f6838fddb4328040c36 6732fe38c3f5e8aba916987987c7f1fa4c3595ad61a122d5e75c7e254fd76d00 d65208d52b727edf133795c11c6181368a0cd5610f4db541881991c39a752526 ef6f212d8c263bd216b56612a4262611ee80e6c0ffa9efc4617d1b9aab5c944a 6b5db3abe7eefe24b1ec24982d1ad73eb769ec5b47dbab92e25793fd4969dddc ec417b9936d2a9eba7b971a9431d05128fdf0f064e6407167b15f2d3af0a531d 5563856c4c0b315ecc2e7e830319dd87d1901253cc3a02722a4a4e9f520971e3 1248ec4e18b826ab9c12532c04ab5ee139fb5cd1136cd0a7c88275f516352eb1 7b239f405208508958e9ee5465dd6edfa2cd1b2e236a05ba4b65a29a21b22f7e 63d8327a3dfa76c2956bc1828f28f88860758c5f7ac6a8f9773ccb95689f0074 19fafaa4738a3633b1e8af879464565bd72a59095a0196c5ae5f31b7e2b18b96 3f9b6300d5c6a8a2ed369a7ae9440e808ee85a3cfe991bde19202674ae0629a9 73ee8296922b7965e840296e96e90a2f31d84bb127f901de33b6ffd56d862e3c 49a081f9972eb60d2893f26e4c34f14aa4a78fc3bc658e41ea58675d97c30c60 acde4de0ebd65556f5de1d9ba134fc8662271503013f8174802dbdd468f275d9 1782cba9472421f1e9c82701a3b69acf1c98055126a72720c9d6890730dc342b 786cd1ab0717a4e62ea37d89a77da6bf2dc2267af497d5684eb829382a84ac4c 2dffa82ac4fc69e1bd92c750913603e00253c7ee108f6328e2ba442a2004e900 3aef9457a125babffdbcdf080325e9d1c85979cb7c5e716c654af5796a2b223b d40ef7abc0d5d76f4faad16a5096e20c435df9e9b1444351399d0d0dcd457b42 87017646760e5907215c6455f0fb8a257d8d82da4768b72165ad7eb6e83317fb 8b35565c4f50c6ce6600dee182cf259dbad787a8edc7216e7d1d3207d4466093 df955fad319e1ba515ea90635b6b068c603317bc73b42d104045f4f4972f979d d8c5232e2819058edc184a4d18cb44bafa8e6063ab367e5fa30f468579835008 69346bf5f225d5cf53a5e8f4e6ab3f99a7b167c3753ffbf438df5c5b54c4db7a dee18867f0c433f06158d12558760bf9f7b595fdbe4f695bb1be43b1d0540654 7a25907f55bf2e608b7f4ec0fa3ba641b0c854a0c2e8a481abf4072a6a1b5b91 f07514551ce7d7b0c1d5a2dc7de6a3ce4f7330a2b8e3591dd0e5b749ab6c4f74 2262a553b4ca0c06c6ff220de005eac7680a12521b57f5b2aacaee21c26507f7 4bd9f0e6f46433ecb3e5561abb4c8337d16eeccf7e7166823045cd0191b3b2f4 0e1cc89dd8a9b0c07f34b08b0e242ea4e63b7e10f08ca36be83da18ae89fd8b0 007a52e915e1e072ae84425c80b5b3d6d7a56425da630638e40a25498bff7feb 204e1d3711eb894dbe3b9452061535d8e24ed117b206e75fea92de7cce49247c ae55c56b06bf0ead2e46b8d1dbb5e91d0d43c9d93deb1a73e9f2c3dfd4784f6a ca60ff26e62c234cdc10918e0e1a55d9373d630b76cab480fb42bd537c0db5ca b1713604c3ba372d49d452dd4bd69e97f73abf00b2faeb9e82f454261fc16228 5c5777cd1ede5d8910dc89877f214ce51b402f4fde2d72c2715ba54d90e7e3c3 2fd374a77f3747deca7e61471b32515d84c7f13a128e8d4bf0fec74553f11877 7eaaed0f15b99e68b2e1943e282040a379bcee3f09714f3ebf9e37e394fd0603 8197388103b9c19612f3c82af0decc23576ab5fe54d789aeb3e81fe6232457b1 14670f134035fc8158ed7a9b73c740567de1067cd916869a60f57a66f0b0149f 0a1b1673c124d26d32f5699cd6006e029bec9f368654e849bb8b6a3194f6eb8b 0ebd1d8bf4aebad2bb2913f55cc849d5e3707204bb00290b19864213155ec268 58a1f1d087df3dad2422ca51e5fb5a568aaa3f62cc6abaf6ebaa84b8b9d6e16e 8bf5e7d7ec49e3e045ca39b040a40077051a51ec21829a831e50ff888c9041c5 03c62c01f13193993a87eb543733531e0be7a0253f3bcd664fa55856044ccca5 914f45bbed58a21e7c16421e2a58fa3ae31e9457254199b1260cdecf95bf7336 dc2409ef8d08f7da7790bd6bc80647fa4ee2dd3a7a12379617ec35d0e24bc649 963f10237c2e37d44c7b467496834e037b380e543c0f9b8ab281493dff79c745 af3e5295ad96ee6b1186cfbaf2d3c848893d382029d400495ed14da5ffa468ee 1d3b3bf7f07e65925f22bfebe2b71eb513d6c9e7121ceec5c37556fe1db842fe f2e67c302ce856f891e21631ccdc85581bf504a04752e620613b04dc7f3e4078 3f34f04af6b319e18224bd42ea93a12408895f1211254fbc70e9771804592c45 ce3e75c8a94622ee3178e7a1a7457f1ba5dd1210afad079369aa0567841e055a 36411c22b7f473dd9a8cd8712d7f61187ebacd3cfbf6294569739cc4e6fa57bd 227718c673ab52975d23cef5a11dee0008444e66abbeea70e35891ae9177633d 180ec8bc9cf8b201e545493fae127319436538b2b95a98dc7f321a095667f512 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 false +check_ring_signature 7c8d05a20b98687ac1eccd2ecfb772b100e8525cca6d0afbe4bfd55fbc5e68e4 4b7d6979c18a42f6ee0a614ed0c2873f6f1ade2f17256129f5267b6ee1731358 2 6353b88da00ece1ed59a80de1ee9e4fa0d661310fe40f4f3adf174d482452e93 9d1f66673abe038ace2f95a2246e51a2b5933790997ca8c14f3d0cfe8bd8009a e5d2f1308536178b2ea160664ff65176ec18c01e7b739be8cdbfabf5382acbe42e9a91c9ece6b9b43ccc036ecc4b351854eb3f197c95482abd045e600d72c432f44235558157f3f36c405b4becc08b5db3be842160e2b6803f6936ab0626b63963363ef0fcdf22f700edfb0364c862e6d5db1a6cb01cb317f0600ab891fcec09 false +check_ring_signature c13f95a3027c107e1ac7796cd5b824a45a43ccee64e58beae39e51268f359b2f f0ab4b582132aa491d6af701e4a1a1708d7f033b4686df97ae755174bfa64ef0 11 88bf3d90e14c27f8607d1bfe9da5f0c38e5fa860dd24ad8b6781d504bd7b4c13 f1a7e02a898133726b05171c54caf654df8f3a811822d5cb0353ce19675fdf4e a5f82e339d375fa345c0b3f75b3f5644d8cc5c24d346c6c63b29f5fde6979ea8 28f1343655923184026161a86af8a4c4287fcb2309586718561c765c55d4ea38 2a7aa026a43f6945b9a63f15d76c701653fbff4f7a4e4ae3a1e2440a70f0dcae 49dbfdfedc52f9a6f4d94f6d948a42e49d08a32e83e5192d7676c671658e3621 e9969352dd8d28a4771d4ea167079eb00671c03a166132578e02e263bd372da3 1dff250931d97017864939c082c9d3d96b2953d7986ed5e14700d13bfc6971fc 66eba2c01a761c933b8b2fa0f86cf290e1aeab212b3d5a86363cfe2d5d564e6f 7dd7850374ba81d97daaa651e62d0b4c9b979578b89d0102eb93f69ce8f6442c 39cb46a53ec61bd5e733713be26f54543a1c86b372f3aa78765b171909aa81fd 32fd960ed7c704485cfdbf4bfaf9e0d8c66ff9eab92f0cece6ca414abf164d0c2ddcd357f7c2cdcaa4e3908f224f7188823951a79b639d4ec52e0c4ae105cc05d00efa84e1e40a5f9acd94855dd2a6ceafd189f27c334b88b9b22127b7a3ef07f5efe8a3f3bbd894af90514909d45d05de418915ec17116d07a64e116a7aa3047f0d830b6279162558eb2bee7a94398041c631aa39649c22458837966f8918f493e4e356e1a4483637c4124ce764b625268bb9c832af336fa8b605436b775805bacac750779725ca79bf377796c4a78037da99e2dc48125f717d09c9b4d7dc0cc9e586883e4b3ebd153b782e4f065347adedc69e5bd7235cdfd65ca1927f65003ce6533befce0de583760848b30e47755ed024a302b7278a5d556d59605fe0017057b769222250ed70650f90001f36c9b12dcea80831de6568c38fe83df1f407808cb43fcef0be649d7f6cd259c11c63defc91e2b9d65517e8df3d1e60484b075d4cfa539d09b3656f1e63238b0c62a78b61022d368682ecb538e281a19bef0df9387f92aa2516a246a6eb190fd2277a404d1f80a0542a07b576b24c587442007377fc56cfe2165716817188731a4ad4f21b7779f101005f69385caabe9d9b03be83463f9e28ab2abfd5b86b4363784c1c8768cea13da920389df34b4d05cdbb1d34654d0ebf30fd504a793e0ef0243c708dcfcce1437e13f4b3d97aeedb71075e3696144959e41f7808565a14020a4fb314edbaebb56484b37f65dbf458730927714d3056773aaf6e6fe8de0d346aa053f5514776220490203d575412f7c008a1be0cbaac10f6abd21cc5155ceb2db781d89233e146e82b4ab024cee5d3bd01414d02b1b3a327458227b3e1935b4662b9467cb983c8fd13b603bffa977efa3c6fed07e5719e5053d7f2e9651c6c04c088db68b9784008faf474046fdde96404420df05b8bb067f317ae515f4387727cca49fc36fcbff96d46323dd852e56105 false +check_ring_signature 638d9987025495671172327e91788c8a7bab0bec5349c4b91a6e4192ab3607e3 d1a8bbd8681325216b01fa4a7f07efef49df78344b4d910b22b2bc0b5e4bde42 5 5c88b1e46da45684db1020ecd2a09cde9604116bd5d5791373e6456f52d1db02 e69ae5346b52977dea215a79a81ee4dbb6b95792e5ee6b5c3af981e945cbc23b f816c0e067790464fe1dd02d84b018a0a2bf7dab60c92fdd664212e60666e22c c1a27272db4d4884b4e0b18f883461a924135f281a2799e9f729dec4b73b63df d71039e2759581741004941d09b19669cec0880e74327126f793db3a5fb1653d cb93e7c28cc91c6e4e0cd4414ca6248240496c96b965b9475c6d0a38326fb602875a6214eb63c8e0f10d45788e46e27ebe359a85612173325d4b4992e1a5410b6a3cf33ab0169b46bce746053abcac07081fe60e4f8862dd35bd073bc076ed0b3d83f65191ec72593cc2722390fafece234117e0191c4bf29ce5afa6c47dbd0b071ecdb04356318bb15032428848fa84f62067cdcef9d279274114a944756a7152dc48768f8b9bb9aa32c3c6a5c7c6b77c263cd987dca8df5eab9439fbbf9a0aed36ef6cb15f0dd7648c016c48778af4d7a37b4de1ddb718697d92ae199b1e0dabd593171cf56956522798f9bbb15092320fa8ed4fc556c7b8a072aafc3162081e0cfd411bd8c88082c668f9ae7c551e33cd37d988788e103f9f2f5ff6d8abecc56f115e8d862c8d3ea4a4b94829cb6bf37a1c6e26beb0da7cf61419ce7c5502 false +check_ring_signature 039e34aaeeeb37f0d6fa05e5abf36ba6fc9894dae4db402a888e5619aaccee60 d024beebb785152350ef1fd7c9cbb71301747fa6828b978134a0e6309127d9c7 2 ca090b700b5e609d9f2afd6504fe6f4c0db56fa65bcb251451014dc89d2dc41f f416f1648d2c58927083addc884be42dcfd18cc4cad9913a6aa37bc3d8139a6e a8d55017d747875648f36ce82d1b1425b97b0621ee62331ca81d2b4cfdadf1024868b2b16cddb989386d26144fe1b09867c88d2c91a1688b3deef6839e896e0d20a2ca9b01e09a971550f96b81231709fb389272b877f075b86de96216c40697089d50422ccf8f7cd76176dc4571d15de2ee0fda6ffd9f9c8d85801819b21d0f false +check_ring_signature 78b44775225784846ab81ba1c616a7e97afed4eebdee6559c5221aca1cc1d9c4 5055139f173476256ee0ce773b455ba2db2f61abc7ae08e45bce1ace53e88e61 2 61e98abd06487b5291b4a2d7718c7a0c6f9b3cb8663798353d4f43039f0d75b4 18f8aff4ab7061303a3bdfb0cd7bbfc2add6077d3b9a60052561af184f872f8c 6f317fa8f71e0a5f7780ee330277514aea8e059922b68b2b7ddeafc2dd47f90b4953c7d99ba8c13a646d3209a039493264f9a080637f130676e894bf26851c0533ef670b1afad43d27609d510df38a92a46ea53300c89f1e686dd32ae29786f16bc0200164a3cc0cff23f61e547dd8b5fc890ded9c8dbb11812900ec7897ed02 false +check_ring_signature d0f745da75d38d960d23be792774f4c8bdada38883706f7785929fcadab4aec2 5889d6c383c22ab9c8b37c19a6388d155fade0c2742d37be754684075936be6f 11 17a8af8e29ae5d51a6c51cfa86cf3693c2e39ef4b7eab92bafa84d5a650e1aec 64723dedb0a62dfdd47adc421f0d64c548adab408950a001e416d426e0c0b1b4 a4260fe85a13837bba66d90ec18c0cd477c25799849e85de1fc3b7902fc95515 20c66228f8a09896d9bbc3bbf8049cd7f4b19c35e01ba92fcc8acefc17e21869 91d9b114966647e4b968c931a9203318a04e4fc3b54b168984c2f947ff842d5d 7a717b8d3d96d3719073661a5163bd81189f27a0433d7f6e9ded7e9df8091ec0 d9e00d6c93910ae1fec189fa973e784eaf7de5a44e83f5124d0dc9b15652bd8b 7160ecc05dbb139673e41e5bc8fc30c5da1836055a6fd96d28ae30391c8124b2 424658e74c4830d18c385f546889847d953fd33fc9775f331903e49ebfe05791 81c068ce05fbc03fd20946d31d8544f56ce6fe0fca09c1bbf8db8364d1137895 4624ab0fc46c83a85c53487601eaa265027f7612045fbadc05d3a0ac76e0cdf2 39d66be9f38e325a329312c48363728c55810294c7d80413137ff6b4f00173057bba15e353d04969aabae81c8e7890f7cddd26bbaa1f0e64b93f2dbae4a3790e37faea2520ef2639329484810fae36e422e2d509b5c701f86a3199abc4e69b0681f1c1a7c912e319e24221d31379c94fc3b8f51220b96544a030707530bf6f0e584d6bb0057fa1f0361d12ff52147d1821c0f5318ccb25c71122bdd2a2268a01c8780cfb85ec30337b3590673591325f98b92eb6bbee7e985975029f0ba77601f7f3e939da48e512e82bfe75bc2f318fdd943f69f20adf3f0aa7ca8ede103504c4cedc44b345dad13205b4f35a1c66b87cbc980f746199b9dfd7fe81a756160f4f7b7d0fea4cdd077a5db2d69714d08f5c193e3eb8640481d07d10b08abfe20b8b49d5ad2ec219621723f758d6214158e5385e5a5c4288cc1b36c761e72eb601270923089d79b405a4694e66ded4ed6025beb166b93709070df905bf4814890a10950e589e420cb76f7fd67d10cde49681012eb4079238d345d5ba95fec1e002186721fc717f0ef60eb897d0489003e5a83c9c59c058ce0cd0e81b615db5de09f030ee2aad3adfd7634010697816066fdf2ff3dda6400b417f1b151ff576f60da575e9dc14ddee5d5a8f7df9d09722d7d4056208d3f80e4bf02ce5d6913bdc0224c9ffa72f32b5a9203814582d6e2e80f21864f3b2d4c266ed875022ca3a4d0d1990f876c17db5a02b88886dd57e7b6d11f41d4c08d2d568c81542bd5c8e5e045d96918468a6f1450a33eb350fff56a065ee2745582b017c4fb090efbb549f058d78b7eb8b273ff02d0d2a532242ce948aac57c47c6f0da940b15e0109917d05af8c85963459e9b36ea07c1b5972f3cd350a653721cbde9cc3c6d79c8ffcaf01eceb4965a0a57e80a4a0150eccd099b00652aa0fb232a332fb64fe0b37503a08249f94dd3259690481182beab0b009bd6113cfaa8c73ade181eb9682dc82960e false +check_ring_signature 39f3aa455c12622db2de343cd74cd91477969573a591aa2840d3da2023aecfc0 0b681c1668f43d0b705b1d4724e9e5478fa800daff16d4f0b4addda13867e141 90 5cd5d4e53f2a17d468a1ac0f9e68ad227f2dee8d6857d956511b457ffeb2929a 461aa7ceb26cc23433c1e67cc32366c7690fdaa3b5c225dec1498e0e92b65cd1 20d2344133f72bc03bcf24be41b728bf6410ec1a1682dfdaba0f01cad3b56f31 4e11fb6df68780a0bf0f98ac497dbd739210585faabda269e8e991de0288b84b 99ef0a0e34151333e337b18ac8077ca5ef07f8929921b49b86c549f3a77cdc89 314901e51e5352c165ca03b7fa891ce93adf87aef1c2d474ee1fc0412b848883 f9bd9fa5ddce73a2a6b04ef6c7d2088247752ced476cc9a18cbc7c7a12af964f 820fe89807555b1b754cd0d8a6d618b98195c3f72ad78c42d5d450bc9a4b230b ea89934af2eb5ad6e40a177aecb6fb844f2e83f3d3d2fb706219af276640b75c d9804cf21a1190d072b0a4f543b0813dfb6a9af5dfe4b71c575472fb905c954c b90961cf9a4f53b961e247357253f4c4026e1021785a143855a55db42418472a 703f8a2ae3e3eeb46388801087c93dc92cf3731a57976da20a23e93b244e1cf2 87679ddd986b1758593bd5ae38b6b68b541811c6a1f1bc80d9cbc0ca0d7e9558 5feed638c2771b5f18679870332e75e742cb2cbda5863319208f8ad0ce2188e5 7ac09c1cc6a247f145fbddec247a09c95e0be535facf5a5d1b8dd67ad4b813df 6137412995a3768e649982e631313a3e8d2782e497bb8b398cf6714af2c74c77 b3ee775193e20b274be34a2018aa1ec119f94acef645f6377bf126ffb967e2c3 916218d6bef2a9eaf4249a5d29ff60cc6f419e38c34b6fd5a7bc2bec0e4f4ae0 8c1b4da04cef36ff4705bec1a2568e9efa064dd3698f80de5f9d76296b82c591 a61055e0ccb353bfb4a56a1d79a8c8bb72dd1f269d39a395048ea8662868672a 29e48610e42e76874f45017925123622ea4689fea5fd5a8a8a9ec1af11fc527d 6f10ccf1adb2e1e93d76cbbcf8b08155e8b20f8c937a06f1cf58d4113196f0a9 81d672400d45590855533457904188f6a8efb686dc4b25193b8add788ae9f1bd b969e02901da79e9efda44a8bd3c63315719f61764b07d67fdacf21accc6a01a f6125243786e4bace9a1adda24c67feafa91e36ae4eb568f72e60201cd1568d1 6396d4044bb0b4b087f3ffc5e9d81fd8935d9eadbb57e539aabbeaf1ce4b5e42 ae9bec345534051b459db732f8f1613d577d7bd72973c3b7689d383b03b52bd3 90ecec0217486d5741289263987214a14d3d892a2e210acdf71ab4cbe32cd4db 0a2e236ee4f53ddf158e697cd0cf8dd0f04e8b12fb4a02d824d1d34ea24678a0 18f6abf1c3831ad13fcf9e15cfbb82e03a9006f9bab89f4f18e3f474a165f344 d7acb523ebd4488b7a29957c8eec10ede51862b3015096115c47b56451815a8c 040b8cca4352ccc6c68b94e368b909be000034688796ef962d60d5b6a4830c54 4b4f938671e73debf2be4f88ae09b06dc11ab71daa3d1a187945b44ada00a96d 8c43a1b68ae4eeb14bdfa3de99818285c9ac766ebf33aa2a0db677a048fc8550 5a5e8ca64948013e2dab71e73feb1d235c184eef31802aaf438826f84d9ad64f 5b0e405896b3498c1c0eb88a3b0d31dff2fbcadb82d4e7a30f2b476de54897e9 a6b684b54357f53d5a31542d2c512fc8d5fbb7b07a2907430d39130616a702c3 72dc02f7353fc7f1e31caf8648b2ff8127e17df577c28832d362f877b80b8e7c a30604921076eef9bba22f2a9052af3e33b4a133fbd109d120aee8f4319235e4 c4bc288cbbe1aa2259cafe95290318f02830faf34e3d4368cdc6cd72edc27acc 14d5b017ff05fa87b7630d18cdc3c19fbea5ac7770fee759344da4339ea39358 7c8127a4c79ab550988227a3db3dd219747ba24efe93557289cc1709d3476ce8 3efa4bb285697d9a657400d96774156294caa5340192d01d1a45286b6741d55a f7f6b81aabe6b047142b4bd871ece6389ddb73f39be5a64fd8d8a6c03fcfb40f bbeaa401d61567f5b99d47d3f4da1ba4f2227f778b2b723fb9f5382b25ec56ca c1ac41206bbb0cd2f4d2dc2918ef6c268ac23c4c013028d55eb2378e7d56f634 60c1da098e22c03e22cc7305ed759fbb497f3150179b8067dc317474efe022a9 f58e6cb8bb07a01308627a43afe3254cad69ea9f1e06ed04fe300dd493c27ca4 051d6433a096e35ef3a44d7d2be1aa673918c9ef2bde2480b3eb3dc7097e4e99 608a7af4b0f04ba538da8407aab7d79102f1566f06150d1911a28e61b5c6a417 38daf29b30e86331ec888df7cb1e704c7b46ab57ec0559ca39d0f0f553dcb1d8 992744417360f88b46c870d5cf37eb999edc27351c837377660687ff3729085d 5d19bedfca142c5b36b756ddedb6d4d4e121b8f6531d55a47236d5077d2ad6ae ed41510a7df10f9f02224d5627046a7cb975c5c9285de65e4f5a15a42e31a98d 780521a49ba6a805769142e6ec97fc1ec5671e364da794aa1697c15f40fbb5e3 5d4f34ae2bb25f27ab4e19eddd468edcab24a6c8a35ece44d547536abbb9b109 d9606ee870833f605a8aa2996ccd9c85659e6a4fc2e4fa4ac49e6ec83e1aa4b1 269a48763dcd2d7a63e06bf501200fc856b66e9996d87208686d0a5031de0f82 e107ca080e3b6b928988bc2c7f64644cc5b694ea7360b61c20ee5725acab18eb 99b35336cd54d709fe02928a36c58df73fe6aa26b5cbf84396ba20da3d12c4d8 5029685ddd1b34ece484a2346b259d9311492b01f26e21000f940511928b8671 49d3a9e8f668426d2020f3e2a86f3e77fdce18721ad2a3bfff8bc2ec87b1156f 8a69be6f54bf7548bfe8c57262e67433ce96ec81d3352ae2b439231f5d35e95c 4e1d9356e0e2d36d00847dede2d324d15fe950ae97ed0e591bad75f442915190 bb85e3b622ebad2885e8338dbcd7465a0c6363d7d8688a8d3d56a3a1d386ce7b c8d606214d48ddafd42b4eadd37171e8295a9e8e84dd56fe43ec5f23865edda8 8476af82890f51c050e12d9f5557f0dd054bc240fd71065b9aebdb43d289102d 9dd8980372f442e0dc74d4bbf7d35ee8d8c0753ac1e574dac9b938777c81b718 690330f8842e2278b7f7c55424bd6ab47bb225f24d9b0c1838e530122918d89f dbd3329def046c5ca2c8bcfbceb65fc6b1919e276b71880e70cfc46f4985ea57 3befceec05b6d09b6b8fb4505878260c3141387f17f45b4d8c42455dfc185c97 6c8b8fe3de69bba004157b471e64e1e4372c075bb5f90b6ae4cf0280a4a87355 c559105aca2122297dcfc601982fe8be0062687d56463f42212a3db2f87c2625 916dbba1ac3a6da15b8b7f39b2071ce26ab4745017c71ed5892ef8e639eb63e7 9651eb589819675cee3152a9764731ee4aab92d1cbf91dd48ec11f78ff6cd40f 598badee97d427b2f61ccd39229e458eacfc169a82431acc299aeca6d83f35de e6786c85a9b58c2a8a22c265853b3593ab19a5e92e59f30a3c1f0c5e9d52a222 a74b43da21c3d8a67a580ca02356d38724cdf6369393f17ab88b9c7df00608a3 7fd19c96abea91f5baef8b5bac13b0c702961e911cee031604785947451329fa c59836f1cf59e012052d184229744375967d11097be2baca46ce5869a99ad148 cb22fbe0d70d1af45e8e16a16bc597d1289d9ee8bfdc5ceb4b1d530b607a97b2 7a23ad6698328583a8d7b94cc9f096b829dff64117db045432a72dd89370e9c6 81cf1399aa202ff986ad5a5a46292cefefff69e0439982f7f66e48b4c3a22bd4 609d288728c69662a3e91299be1788ab13b3ec7899bd1d20df0c5ee1733e7c2a 223883427061c77f7953943384b9fb41cf8c0992d5af91b3fd9acd4ecabab936 893682bc6369bab31af845f6ab4e0505416f611159dde12db8968a17d028eb53 5e0658abc118b92fc7bc88946ed4ba08468bff3a591ea59b7b3ec7ecdbf3ded7 fecf57b5c98ffc7fc7e9ea1c67994aca61e481d1f802b4443ce424ee56d5c50c 3f25a24f9cda2e9f4ea9ad3067c19ccabb33ca3906c471359368223b7a247518 67bb8779a5551cb32ade8b5715f9fbfc99a3e900d8913d3c1b5508f249485211 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 false +check_ring_signature b7af0b7d502cdce1a493c61b753f397e5aec3d0a611710326152faf9f36444f4 e4546dd97e5ed855a96cef0d313c6aa0911c329584fdc345a414377c846d5bf9 1 0b9ab3e49f2bfbd039e68df77ac371a65e05bfd4b2e007e21685462c0f3caf2c b3dda473867b770fa34f945c20d08a5176bf10e40958fe695bee9fb993facf095e5167cfa0b20cb76d7e6f12e557b1ad134886e12b6b4f50c6633a08f327f30c false +check_ring_signature 5c3e4765b1f76080fd69b43b8854785c2fae315475841f0b69297642c9b124e5 14ecdfa9fc9801a9d5b4c81d52e8ac0887b57259731f2acb68b59ff3e11c5b53 1 50749bef2f3cfdbccdcbaba32aac77e3e5dd5161a07bc3627cc4464c0b3e27b6 51e7fbd0e84d9ed20756c77ae043e957cac9c2c217a0166a7873e002822a430ccbda843b58ef54dd85ac8e0a09db1b0d7020318a9e92f35fd1dd6045774a750a true +check_ring_signature 157f9bb9f5b72a2d22e7213832070c3d1a5266ce4d09aa00be6d47fe8125b15c a332ddd8a0a8486e8b9b6b93ab3909c7cb1359cd6e2edae564fe0237ed0b5e8b 116 0a6d1148f4bee5fa507a318b4465507c47ba56b1b1b4ab5765abb2b0e433f907 748c8949ee79f26c4398739e9f151abee2f174573f5121122a7a06fb86d9f74e b3e352f38496d467a1718b13cd469b6c45a244cc4c3ddb608977e7f1282f875c e10998456fc71c920ec2e03aad96bd5b795486488bc8578e25aaed8dd50aa7dc 9adee13fd13435f7ce907fbb8a032a93788c77b967c5a15fc9364221186ef6fb 7b4d405ee33a82ada90966915771a54322acbecb160d0885716406ba62001fbf 87a94ffb1447d68cd67370461b062603dd2a4d4275482cd1e62bad7dbf0a5502 821d3c0ee26dc3ad86a4b6418e39757825fef14f0f365c84bc5a6955cc62b838 2214cbf22b25558bc53098a74203435285629cd7c5c6a54f6c1866b0666a1baf 0e1ddfa3d1687d38492afdc90f021fb88a884850707a11fb875fa33055429c22 cc9ef5336058b9a3dc69696cea6e391a5c3b9918dee73d0d37e9e93d96d39a62 95c84526aa6fb8cd01e89d3144e34a986a2a103416e320f738a8a9dd393a43fa d036b0244cf897d3e2ecb8e20d76729807c5a865a3296d49be764e3460a1b575 f24777daf2bcffc4ac674be7606f3f16d6d4980b3c6128567a2d7c77dc07e530 297b40d35f0aeaa60747747fab1bff114b098ac6e9062bc4bea7c6150e6c5123 89a0e447cac093bac9655462defb9ff954b3f3de7c5a33ab4e2a03d409a25cc3 99863d14b425793be9800d9558f67a036564ae32cf4ecfbd6a929877fe6401d9 d8ed8094c5e0285b8a347a283316df89ae7bd8830f1917c38b623e7f8dce63ad 22633870c9308117204bdd158b3d955d50aeb54c2c98c04f611454eebc7e0e87 c6ad36fd3a5ad526815b6c85fca2445e85b7a74757309b0b3b8f85f80dd97bbe d794759237d296771262595bfd4d93ee247f8a8c28b0fb43d6597f0fca29ab4e a7c91489baf8ce752a74cbe1075aca6a376a750541a81afdea198d01dc7b97a8 353576e025b27d14d2e3921eb6b057c1b4fe7df073567ac9a227cbde4795bbe0 151a3c3cb39b3077ae9a4d3824320a9aad096f61b8404c0c0ada0c9e25808426 5552a10f8b5156a3d6de76644c0c07b9a481253c4a7878c6bc95fb1a83e0d4e5 f32b048fd54464ea732a6b0f1f1511434da0d531de2e72563eedc9987e1342e2 4bd18f89d24e9d78d2e736d9e32a86079067a8e0af2287303341409543562303 20537e3297310a1cdf920399a1fb1dcf6a1db5399dc74fc7c188757b3b3d9330 fe63185247fa2c5b64f5b9a82e3abad3da931f7689fd3d2d50eddaadc0ea1b61 69cd718172a2551323a6b99f0c41065b99425beccccbd0189c8b18ed7cae3678 79014f2a977537542fe276f29d37f3a9a1128535e1b30931178e82f9c349bfc6 8aa4451f89f9db215464fd95cae7f4fbd4f1f7d1a63ea0a26421c62a04aa7a47 8c8a9df43c919068307e706cd5bcaddcd702ac620ae63cc4ee62c05e5e2056d8 425444975ea57580edeac970c993e3ba0a7fa63f683a9b539a16f11d198cec0a fac9e0f58f7be76724ae0474c6298e29090c975babe5f1a27d0bd6a2f2fc9f1c fc1235f0762bae61e2c5de96bd32b32a9b4901d51b7ec577b6873675be659d95 074a55e6172cb234fca4ee872965f1cbd7fa38c65e0b3e2126611e41f3dfdfaa 12f1a3376ab551ac3a7c5ec2e80b99f7ab19515c3f769957a65517e6f6ff0647 6eababa3959fbf4500c46584a18bf958272599adbb7b361214cd1577a50a6df8 d57e1c0ba3c9257e1329353b57ce68fa75af341abb4ca7f8aab68f39dd4ae56b 342be81ee4a5b05c13f960694b62f0ec4f28983b7895bdd421a9f1797d0763d1 af891dafbdee0c84fedf5a29ddf7990e397781c13dc5044254c57f925af5f535 2c1357c1398e6df5b272d43bb4d8b91c5d8bdc20699dec09ddf9162fc4641e75 370ceb57232ba40550de342b774b7a7cbb1ec7baa82477fe7953db88c5ed2262 59bc39b238ee7d4040f31c0c665ecde2d21ac7b97e758e16231b2a0f0e221ec7 785b3a226d3177d465ea9766e56c703b3fbf079fe106710b67494f46acc1797e 04cfb7c5bc3928031b19c2070fc63ace3bf7454c5c6ebd5b878d3996beab10ad 2a75811030a398c8de5398f13233f4024689b3f7765e47a1436aee1951dca308 2160a66dcd06948f80612c6d6868365aaabff1fb04ea36261887aacd2babd2aa c006eee85cab046664732bd0e8e1b58c762e25c215e5541a8c9815801d17e8c0 1c4df29de4ddc68c1865e1c5450ee1986d30528d8526629dd6bae50f93f5c2af 5aaafeb0618c822848d8f59cc68e3b45d1c42221aaaba72d2e12a683614de8fb 7c07e378275539bd3f1363518066b62551a70401731313ece2995a6413725660 61bb923324a87de279b8727d1a4f8bd106488c8590cc5bff22505df77e273b17 4c78ff16b7c0943fdae2e1156568f227190ce3594b7491bedcab8f432ff72677 2a8cfe1c98e44547bd9c36f03c1aa484b70f8c8ef3915c989fa7d944437f04cf 9c0e890ff3e2df82f83a4f0c987ebb921a66704da3269541112bb2f208b935d7 93199f512ef039d19f9bb018eb5a523213f79ec05582c57767416c7a6ecf25ad 51a7ebcea353dbb033b70f8be37d3022b0748718b89b7fd5d5240408f4ce11e1 cffebff7fdc6787ed546d638138ce0b748ea10ebc721627a7e49161fb6ceeef1 06377a9d67345a0c2ca10867a8339f5d350fa025aa26cd109ca4858bc582a59a b01a5a2efe5a22ebf37597ccec9329371d112953b6b19f06277c7c993027c510 57d1c5fde3b7ef596dd1547a988a3e81fa6af67152bfb9298ae4235bb801dd94 55decafb9b4e587e41685c4c2d72ee4aa8aa6025f42524f8f28fe4e2ac0f6a6a fe8aec0619428030d797acc24d3a7d4bbad7b51493cd33c222ed7847785e3459 3a0e601ea7448f1971e01a75bd9ee63a796828deb90afb089c074d3c8c7729fd 4acbb707c52448f2d8e7d0321f317baa3e03f3fe86e591e7677a11bcbdd1e07b 9d9720b7d83726371780632dc2115a68ace21ef63cf9d3de6533da936c3e16f9 a3f18b03182cfd90d127516d86646bda94f82ddf1b274a976b2ae0ffbd338a56 543d6b8af09e00beb3e17b654f59f486d6db81a3ffd417cae8ba26ce2d1062d3 686c62c86a0defc0147bfa93590e7aa730980c047002e99bfd1426a6b6ea4a1f e7a4df450aab7294471d1b7e9eb00d6ef7e4b97b3c811876c5812fcdc8d7b385 3ea264e3a140c0c477f0da281d4dd6e43212e6dfc4c2d58f344cf75a30f773b7 753baa5f6f1192782377dae0d8639e5fd8451292485735c919d3b998ffae7f96 b80e6e0ae7894240b6a1b4dd5de3b6fc07fdd5246e8ee7af34791d5b72fe3e28 d597b2f05f3f0283323f57f1b12b84e8461d3bcd8a2c3d35300250d53cfacfcc 275207051276c5711979417964eb428c1a3ec7ac1956628d48329e62d1070e77 295a80dea96342a787b4b29915346639276bb882627374a0a2f9127234857518 5f0c93cfa667f8f19ad2f225342e0964f531b19aa2baf2ad83a711b841237fb0 89b53f8063dc7edc0f4260b0b9b2efd2cf1e97d0ae4dc9af112ee5d027599f74 76b3934a7083de299063cd20b58022dbc2cd3bb50d1ecc0454c895d3012aa473 f215d071bd4449afb971e26d03725c093e1cc07b55c054a04153a976033dd839 6544c94744337f526622b3e4dea3e7f86e57dc54a255692e8e72aa20ecba5450 e50a3ead715e4b571508f5a5d6eb05d1e274b32563286007c22440deede0d96b c6345d7f08f299ad93e6c6f7193ee1e3e9933f7508ae7bac8d9983b4cd84064a 4942929341164fb29a428bcc82233acb4b28ad6df4225199fabadceefdef17c3 055aa64ba339ff6dda69eba4e5e3aa090e917591e1c5a308ae4ee8399ac16b88 c8fc1af1b50bb9ec410414404379a6ce0c582cd5e1dfcc3c94f783eb70058361 5d3975ba25b2b79b06c6122f52e926654167807dfade144c25b4bc487a20c46e d67f7a4f6b343aeeb9b469da8fcc21141b44b2e581cbb4e0383ecf8c09028778 2f51929847921ff586a222ba3b787891d7e6bcb361845d895f9037bf35e1952c b0d93953480a9d1556cbccc3c9afea197b0093489026f9d96cf73503cd87bc4c 736d00800fbbaa30df2213a8af963f1f92f0fb8654f8143b179358d649d5366a 048a50a49684cdeedcf4c79a325ec9d1a13b5bee48cbc1f42d60ac5834a1c620 4528cc2e984594bca9171760cdef09320d10b02c5db28144093af41e541e867b e281a9c71a9be93d6a93e6e3a886a769edafa87e89b85aa6b87110a03a85c5b7 bb9e024082f7401d6d43eb31f728d9b1ecd5b9923a050b7bbedbc8b77c01c173 9d6f697fd1f5822e458adb716d78d0dd07f752899f62c490e399f25558e929b7 6c9e9a5decbd0e582b84c9b0f236f270f82d0f11756cdbc555b4834c2b0220f0 7a69a13079c3e9899eb57c64a47804d65b6e35b3a660a07a46bfa914c0a26d1a 7d7572d28211a3259ce5b23a91793499577976be6a6eb8e496ce4f8daf54329f 353df8a27081965601ecf28e6d337acdd83a4bec44ff7bdc92019e99a908d80e 3b4c41a25d9f8f37a80ff08ad3415b851a039954c50d44e3eea6ab7bc5aa4f9a c9beda27ae053ee7d1cf90f72bcdc3ad73c7dbabbb25906f176aba29d91efd42 b511e9ec7c45f2ea1748394dae46358152232da54605d256a9ff14af6520e279 ff7c690c9077e2c03a75e4d40e9ab426b3996c909482b249fe5ae2201b868f2b 9429843e42076f5e18e4172d9e9c4ad4874548a270c7c882bd83ab7023586d41 23e9188c788613b5ab0e543e6d88e7d4c755317c94c88eddef03eeec12e4b287 c74a49ceedf55d33d429eb077b5bb106558c06b9f1eff5a9e526add820af5b58 43cdd55475b6bf9889b362c9cf8de1a1e05905b387e4222e95d2a8cf1ba61680 f424ec15ceac36c415c06ea5f29e014f0409908c62d0dfc4efe2224679192cba abcd3656b28b454c62e20d2a3583905d7bb77293ab609fb5adc8422b981457fd 01409c8d7f2a107af9108f32b0090c10014a01456cb390f2ef4068c0443baa31 3ba172386f27c0dd9f4a840b299fd0a023d2d05fa9c3dd6b00ee102020200d79 56ff8d4a75dae0e25d375a80240b0f1ea1ef6c81dd76762a80ace8b7ad00c173 923d0eaeebe1b707b8efba15eee27c847f9dbccd61de662d74f0a36a37728e81 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 false +check_ring_signature 0451d083bdf471234e8a7bfa47b8910ae1c9e6e112121fc43849d52c228b4404 9cb11e177558c72b3de534c9df95b2632473c3d6d3ef462330c7885e8e7c1644 4 a7d4539134556249b471b9f86c828cd3e13bfeb9df75cfad3fd1e0adf374a55c 96b35e3c21f7b8a1cc2e0582670a99d6777df3b7030f2f32e125a4ca923b335d 64e81651c8eb3e4ef34bc15535961d6c3588d7b5ffa219fdcf6a4491a1c0206a 9f70519cb1184abeccfadda2a5aa53a0106b41753d3addf588973c75a54c4d83 343483aef813a9af8e959ba01b97c4fb34ed7a95a71cda553da42657ec677f02f869bea53f0d206615e26ada508e52d68e07a42f4a74599212c10b5567a3d90d78deba42487d0fbdc279cddcc4c2a02f4daca6445aa626a10ab1ca4be609d70ca555dfd36c8115434b6a1a8b80e8f94e6caba23c1808d384fabad5f475de9c0c5f25aa5289e222f22f6c53d7ef81c1c2966a5591530f9b5ca38b3c735f287b00c4ab740a8e5c2381d2cfc0cf68ffd53e583de53992ac4b3db64310c50ffa4f0cadfcff06b0a56694b52fc87a9d972679ba83da2f9668686c0e313799b1003304648e8a4f87f67f95607540e8914086a90a627b7dd74c3dcc4e51cc90d1618707 true +check_ring_signature b51bfc2e56e39d769833c3e5a78d37d15083cd1c1aff59891ec4aab418321882 b3f93943f298b98ef2852fc7bbce9bdd8014704ba3f68f57f9198cbe785e9582 179 7559d1f05ad958af96b45a5d8f5d3b34b03fa846b34ee052376087101f9b4a29 4bfb313e539417c9515b7b5b1d1168a85596bd968954be5d15d65fef2a95ed35 e05a44c3887ca8b1dcd7bb44bcb1675d80b8e7aa7222708f65e807e69b0efc79 7bf4aad754bfaa0ea921de0318a3b85c754aaa1461ad8fedd3fd2f769c3d7a68 9c04e698a359739a5049bb561a01ab35240797f0d70425a8a86905d7213a2b1a 5284f9c7bbac529c5edffd6042200e794fd9f0eea90241ab06aa0f47a6650583 57739a26754c5e76c95aca6a94d90e839879bc575ad818653877fbec54f7715f f05666ae67aa3c1c4d51c45ae68ec461e7535d39a200dffd6a13f625d89f9823 55de35944569ef51344f548c236e0c6c4affdfd3fdca231609155e2448c71ea3 376e1ecd4817655d71a5abf3624533bcf20f1e974f2c69876d11b7604fd15eb3 0d88a55b9e59735a7913259aea1119eaabf38c45036cfbd67f6c510f31f5b785 c8337ee52f48789c0771be5568ee450a7502ce152f4869f69c9e138a153a3ff1 341b8e436786fe3e69ece71a9e7e5c05d0cc1c34155938855f263dcc5159c7b3 b7a3695ae4b81da6c4be5ca88f0ed8e1868e0029a1e61566b3d6b91db08636a3 1bff604617a2cf851848f29a2cfd1493ae6d17503389e77c8892d34dce56cab7 07a4b8fb9e294840f2ca249260d184f6cff2d1d6a7f938f2aaff214792b5d3f8 c4f0445247970951c97efc4eb65729faa9f3f45d9da3cb01b97db180ac7a0835 49271d95c6ed055a3366d3e1729674430e64881d587521b91ccb54ef7ebb7e81 079c7fd811dd8de1ad65294936d9ab1f26ec3fa5c9b8fb0d3506d47fdcc77be6 4c575aa96fa344b8cba93299640df1b23a2afbeb8d3a41dca08111f1f732f489 2b889364f921e2fe651dca752187e0cc9da8c800735cd30abc10c1d6d5a1ec0f 62d953d7a488ec9cc89094d0542bcb9fd670b4a026e102beea2f7be467c0e3d3 4039140a398ed7b0720a5b7d39c33164a00f39a9b53baeaf270b2203b8e398f4 9768abcab374564206d6f1041613b9e1aafd69244dfd05b46fa32ce0847694d8 29a7756114534465c2d8e2c438cba6631a96c718a77007b954878bb8ae237f24 4776d60c5040c0d2051d3f795d4763eb0b9691d1cd27ca786772ae48fba120bb 560425c81620eb792c80d3d7357b28d5d81e0e78bca7bdb84420831d37abe070 e42c998d64de0baf7ce80cfea527817b26ad7a76d5f06ef1b554f54bb2887b68 9d177de680ced823ae3857e264c50fc514ac9a3b43181f23ea6e34914b1c0b64 6e42e2363b94c1bfab4212ba02322c4d6a731154b42f88aba661aadb5dc5bd0d 2e12c313a62c99ab34638117e4f134777c2308ad6874569d900bba8c42ccfa85 595489b6913fe1003a8d9708258ea87f4b46c48f2c5bd9d2987661ef6b44bec3 eaee17d8bf69de36b90476142af1d5b190302269255858f0898faf8205438e50 f8130cf427c40eacd12e0583d9e4e4a9d83e49610ad1a663d4d44e474cf38484 7597f426a191d32b0bdf79072f12cd82b6d53284a62306ba3da6ecef16380dbb 211804bac262b13bea0ffefcd3032224adf4c39fb006a26d1b40f22a68224e94 5307449f218df656d3d643e50f5c32b8c2a6fff9d4576e17f6684cfe79828e1f acd2b86d1ec47c8df656ca5c7111030c3a09ab796d1238570e6a3f916f644dbc 6e44c0fc22bdea1ab80b90f0d1c8c803997cbb0d92907b707290829df3a02269 dda39d4c24613ab6720f21c26b690a1c4f2da11686f91a0cc114bba0d63a3d6f a1331db35f7995c79c4db8a51809a439bed2b41ef0487110688dffc17127c417 0725b496010a564e4654140b5afd5f1546d36587bb2f8df166963e0c8dc55561 698a27321850074d0ada944d957d62ece5a610fd8693764b64cfc4b75375aca6 e758ef759cfb8442cfee161f4ec99ad70823acbf26264d1643a00edff34d2cc0 abbbe3b88e7e2ec0e2c4f68feeca20dbee8caaefb8b34d98df48993194ddfb04 e634a8b92d054c1b49c5703c8c57270b42fa7d111078401569dc2ac7ab88040c 8a89d3f71bacd47758a3d869ae5163ef52ddec6d946b3e0fb584e3d88c2bfd22 fdeffb6a37d6055acad3e38665fb477c5a5318ec27910e6483b4081d499e11d2 f5cfb2e662bcf492ed4a59b6005ec8020158563225ce848b7511601ae5cc0160 21eba48e1d89338fc4a28d02ce8374bf27812f97b3fdbddb5520ee57cb143997 8313a8b0239c89d0c2f9de18cf4df997dfeb40c53436134d207535c0fa405493 0991c81771a76ca28eca587744f1be0a0a2cbb4d71f0f3b5673c12bce611b8c1 fc4bdeb1806cd69ae2254a1e09d6b7cf233de77467277965a21dd8900eafbe45 29459ae2cd1c06c7401f25f7398e9a3998e2e72dee7feaef74cf0b3add0576ca 40cdd35167315d809d5bd3d8e5b147a43830c2fa8821636550df8c3580c811aa 9ca35d65f81409598d3db74576c2d0ba9965416f01d24a9fbfb7f872913aef83 a86a38e22da94b616a4bfe0ce64d4b5cfd1ef4d63ab792e067e63b5ac8bdd676 69054f2d4c20ade5ecda71a99ce175e2010c293ee70b0a41b3f71967f4a000ce 15be4b8a34e9aa0d2b0f43b34cdfc3ab40cba54ec03112b8da92be5201d1a3d7 bb099d15de6e3e70cb5496b886ac719a31a60b87ec99750fe328acf65c5cb3af cae79f932b070e503757b559fcfd920fe6a1434d191f44a4b11efa8b6a1c3888 01c9a32ab4e4b847ac81b4b5b29bbc19ba731d3c7bbfcf6d990576618a0f2ec9 4bab67797701583ea5c4a29a7250eeffbd1359c2148ae6a871ac183bd38f2ba9 80e7d22eb7075a27ba0aa487272f44ad5e0b2a6062674182f8eea5eba6501bd2 a14e81dad1ccc4192a167b67e994f404b9b48d40110ca5396219d96498656f8a 7dc31e9dbfd211001e4bba384a72dcb2ecbfa2ded5723fc98a82fe72866519fd 2f4045b19beec19c29a5ee5a8f379c97e67df7f9216b45f6e57b9b29e04b6134 abae9c485c6c0204374710ba5bc6989b6ea3276cbd2ae45640930b265b914e6f acb72bb5932b5f624d8c741e6c69228c06b4b7ed4ae46d3faaf0ce05e59203ec b1328db0671ed1fb8efce44826ffe20e682f349d502e9fe9c66ea8b5e2ff46c0 a4f3b466eea2e22abd819f25353d62f9a88dc24a0b9cc16616db5a1f6df68c7f a63b62f9258d3b17b6f49d18e8a49f45e4c07a647d4496beca584b47eb897d86 d03e449a268d07794e3ef26659a7d88c5bce7327a33f84f5b54a0b88390acdcd a679abff99b6d521d6079b6317fbdccb243e16bf099a61cfb39eb4d70bdf7d2b 4ac8d6728a750dcf403290f0e12b81405faa2f799f8e62ff06bec39f9fdb78de 42edddd980e2f984e8c4f45476ae6d137d595253e377dcdb70e6721c9fdc1776 f873156efe5ee8b4c2f1ffd450195348cff5d6a76cd016f2267205d1eb12287f eee2bbed0e8bf5c357449920558bb7f472f782c5146c3ab6df51e966a4348d20 c01ceea4764e0e8dbffd5e698b1029e7c9c5d0177ff1ec83888b0283891d3d66 6091e486723f81df9b51d2024edfeb271239910bf87875e147cd7230966ceb4b 3b8bb6486aaa20444cbaf3543f228148885317602e6f72b11a06d9395aeac160 d673128b14824ab260e87ad6fbfc41faf4b16834a55d9b24e22d3cb964889ae6 87bb2cb69939cc9a7713ad49f7ebac2463df1b6a4c95f309eaa18e33fb314059 515a9753f31384c902d806d44639f320be6c1bc81703a6146d6fd34cdca304ee 5caa9ee6a77ff220f02e76226ef92b884a12a635f410f9a2d3ee00fb68111b76 f6da2f99501d21e7c9714fa129852a632637ecc04eb84107000eda2b866d150a 0330596061acba7b120897bdae9c801bf1f0fbc4b733fc334c3fa372db103e10 462830e89c7486b18cfe67b4f219fbf24205d0dd1289e2db0c8ac05ede8ef4d3 054507fa5625268952f103c936cb7ef93031586c325267cd38ba9650bbb928f0 984a8c50ae97fa09a58c848f7872ea6da34846c0e224c53a2a1e4ce27942da17 09bf4e21e563eda5199639a83d596bf3d638b6b5701bc390c9a37502e2a120ba c2094f1507cf817dc261ed9d81a67615974ff4e6a7c11cec12fadf357529c757 4439e960129f8aa3f21e90ab087402885deb116b7a74b5ee9ac351602fbe4571 34212a0089e4519e64963059d31b34275c82c031f01c02472d0e63c97b9854d2 de4cb8b0dc1b23ae413aad2dc53378b21e2375d9a039a92a250cf7849472de4d 89d1c1c20ea1e53a7cb5cf6cbbf87bf34454331e29781a96f08afbc33aaa5377 221b4073e1ed28f6a7036842d58b768fd2315a9261fd0ebbfe4859ed1c30af6d d0d77f70c340376f2f87d0b16f8778de6468256c64f5164093e06eccb8d4fc48 32f361b3c359d72496b55fd17adc6796848f0a399999f6fc79e53c673c219d3f c8d88f6c74e2a11172aa68021645838643f69bd804f247ab4fd007922869dfac ae4df9d333f9bf2dde1ac6815270ebd16d43b7298c0267a8e60c4ad678993ea3 6830283e625162ea036387120f0fbe555e1f52146f5e77e79cd05ce4616b3e0b 2d83c48716237ed8870e61d4d011732703fa7a1b7e46f1533e4bb259553d324b 6ba6b8190f121b28f4b8fbc9d7131c3d3233c1f90b956bc0f5d695ffc6c5e519 d92d490645cfac8ee49d82a08b1c03a2b75bdb129aa5a066874c41a3a7ed122e 4607858077ae50683159bb35078b15402883de00ef4ade3ad619a361dc5175ed 7752f211a214138ea9a46b27e36e5233a23eabcc95eddd5a3a30ea7fdcb53098 8959f676956482c74429b9edcf799160a94fc0450e497a94fd41d1ff37cfe87c 7b893f9dbd99353b1cbda8145a88fcafba966ee62653b8b5978021dfde6b9d11 e5b40e4e148ede83c5f3b341a8a421cb43fb3f474256b0f8b8e5d3cf3ea59009 9a3da58cb3623aae2b3d1e0617bd62890215b53fd04ac1092b596e9cb5bfb094 0d7d622ac11672543c8ecdf09cd737a8e4292d4478bf5b390cce376ac5407684 2886532d0ff3a5911083534d19fa1817b6d9c6aac8e99ef52b56ace144ed4fd7 07d7802eef870ca179820d4a885da701914ac14e2b7628f2ccc3309bdc53cdcb c9148513e725adae280f07f03140d08ea6cb8f65e2d6b86ab63b32d3724eb1d0 bf010b875bb01227e08ac3c3908265b4717d7c97b7f927a7a04610890a301d9d 9a5080307caec2b8ed8240041f63fa0a71b97f01db624557b035df733b565953 d0cb423a7ea7eb80bbe83eda791e58610e4a7e2cc9c7fe7887adacd66a853162 11a4eaaf5c4978d60711b4b7760eaadb076d8cd7ee303f3d2e09ac910fe4567f d87c3a85eb821acc0b997586720a9a31486ca9937b4a2eb6de62f85d8760f100 1f5d76a623a6915350e65d6aa14b1241e064f574f04ffd3221de90abb5416d18 00be9202b00b093ce9749d637456907fe2dcebdcb26ace6c34ae6ec7eb98a048 50e4bf42e454f5b0a5a4ee47bb276dfae11b263db8b8c4ed639b0993af3a84fb 54de058e2924c2af489d9f816fb2daeeed88906fb8531031fb034177c42c7602 b094959f114d786422744b77839184cfff0cd19bb803cbde01779c2311265dca 41f966cec9adb731800e77fda3567813b40164039283bceb8a0e7f4b619c6f19 3cc5f9c6d086d552887c4acfb07c23b32cf612fffe30918d2fda0c582a255219 7dade0b7d9f07b54438a8d786610ca33bc952e594562501c8a0fc4d57bfb9fd1 11b9648dda11ed27dc84639a23e6e7c8dc560e4fbe7f0809729775abdf9adbe4 17d7d522986bb39f7284e9a8b96407deaaac7192ae8c339128dd8d3c2d06bf9c 5d38264c960e59a5f8f8058e8e8afc106c8591809ba61bd4ee76deab8d10376c 37dad330cdd25bcf9156bd5ac465f3aa4988aaf1ae9ecce30b4d735a7ea0faec ec3ec149b928d99accce9af98498fd823482e237556e16d65d2d28d70f306081 70fd47692c192ff7b9803f2332d240770ef2078e55703fdf9bbc3cb2dcd8aa12 f4eea28c3301792ebc2671550b1b1d75d236729f20b45e8c2ac206a0b1e7206b fe34eddea927688f7b6f42da835d8b4f8182f0d8cc8a90385bada93b577704d4 6d4cae6401a1333bfc744172cbbcd0449139732a6c76f4a12b77232546a13954 db12a9f6b49815edfb05e17f1e2568232c6e2478d51993a72d6c831324261822 9fcfdb16d4255d5847663e9131e25211eee82137735f5f37b71a0c87d5ed9762 c9157313647d62fa0967d580e1225f32f179561074b22f4ae84591487a2b2d01 fcf714cbb5d0187b6287840e494f5eac3b55765ec81043adb856f3006da75cee 4895dadcc76b7944d400b520a883932659867ac764fa0b895550eddb2d2a896d bf9bca3dc4953a0cac4e7d159842bc66fa16ae80707da789852171a1c6cbb74e a0425d80a0c3ed2fd18c16ba3dbe4a8de65850edfd05e607b6c6ba25f971cbdc 8d4cd1e90396bdfc4f7211be4d6241188e13ac64bbe984df6e3330270887ccf8 2df16eda0e43285af892246857a4ecbbe056f4976d644ddecb24bdafd04522dd 0e1d0fe5888a1345574b073adf326ec4fa1c0bdfc53b1c7efdd63db1e4e7710e e87f15df03e60fc1d137b51a835f57699c91cff60c76ee09d9117e575ecade19 2510a2f1ff0b222843478321c9c87d7ec256c74d8be4a4a748350991de67ed11 9e8bd22cd61bb062f1609c00e4852be6d60ec36f1463d5eca4473e484d17a4c7 39a3418b65493af75520bad131aca55298648e548877587f2d81482852b90c27 ea0ccfe84c85281f6eb876d80db2b2a28872653369482ad2a986b01a1fcf2f31 ff75693ee337fa456cfeda9b5b23edfe87d2e20546857ec577d06197d9861aca 10dc2647661695a58ecb0ec1487538ddb63e8e21112694fe4b9f6fc3eadc5d85 6bce44beae8563801ff9a4bb6aa8226d14f11d30d5d5fd906acc28e0e2232684 a6f95e88150a096b1116bfe54a21cc14d8fa706ea05628405eb48e7fd83d2c9c 57970c38f2f0febe22585f4575fa55ae3bb3fc6e579acbc2e1da9978f7546343 6399cb2e92447063a84201935af97241ebec91fd5af4785dabe42d76c76de574 08170611384d8698d64047bce08f44ce2ae6e05cc5443ea4b6e1bc04a46e798c 7a586d2f86702b40b6d22fbc8d7ae1f254f6eb76e1afef11f16951b4ac586d1e 56aaeada86c10ef1f3a51cbd83a84d2de16391014c98ee328fb16f069eb3b5e0 0d2be2fa25a1de1d58b14c2bde62ddcedfa843423b934a6805b775913a2343ed 450426228bff91d1f8d782e21b7e1a239a7214ab94fcc2896792ccadde71a862 dbd5654208028809bc74ac224958f12a66e93f03efc2c91d42202a19ea8cac64 9827e9ef2161587cfbfa6b73fdb942c166fef398c99ed5cec6ba267fa6434db0 eadc885b11f941dc9d084a67d41409f6e4df20f22b605063753841e96b581bd5 f5777c6071b60dfa535b1f668a7a6b5f35f2c0924568a07060fa397570340e74 1708fcd3a5f32549b773818df7c4b8d2e59412264776256c9cf5ecf3de923b10 70a7052b60924e89f81c6a18eb1a3caa0f21ec3f27ea3b9ffe8d629f0aeb0c92 4154e8efcfc83d80bb7153c91eea07da05d05e8a802bf20a35676be59b2cbac0 b66dac31a49268ad87032404dd0328d8001a2a510404b83f5dc2cee793b3ccfb 52872d8c690fe7c8ac0783b01e2ed35105e18e377bf202045d37189f8b367dd0 0f675609ea20d487bc9c361c6fa0145e74d6d66c9df631b0a95b169416c7cb77 1a40dca1c30e45591db954ebf28e740072ef84f5dc86f1936acafddad3675331 fe2ff2e96d83f65106bd7f02e3190aaf1a1e31349fac0f39a15fdbdeecd8a587 62d8a66297ca69c0ea8e80071ba1d02cba8519c0b0c582b7a0a13c3b73edd833 791363fb75f2c6ffc92f13831df11ce9d0e76623041628bb31944650a3d2ee79 3e73ebf037b1ee22914552ad8d35872a811fa6e7c8b32e12a3d077fada30973b d1c083d9d844d9a5ba169d813dd4253836f60ac14a74ef97bf173f1cabdf718a 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 true +check_ring_signature 21dae28320107f6a6f150a6b32a244ba67a35f61c1ea2e54085ab2abc7f8af24 bc0b2eb12b78fb4eed6f9ea7f5e56656a02565841056ed856dda84083cb08748 1 312bbcb6c28ce9dc4e72fb21e9550e06bc42b4761ee408387fa7f8e0ec51187a 3a1931718ff85cf3868f5309f3142fd993646ac011ecd29b8fe747d670eba4e47b5bc2c3cae43c2f71054315cbf59229b0f7b8541b6eaf5c5793011673477c31 false +check_ring_signature 38898a2a056d07f3cd4d8f22c621ead1b9a98b854432ade1d1c1bfa1ca8a2b8a 81e3dcc76c675e94f6d45174aad57c0c99333be07805a00d545f37eb36d3e8a4 14 1fdaa78cd76b8ed4f6fe810beff019d5e881948aa90189c35aecbbe5c04dd3db 68e7b02ef14e94b248b84fa46a46474ba139e578c3bc7ec16c0d916d832cdc47 a1b6e9f4feb7c8a5d311796ee5484282e6d2d30e270b753cf6470f41c76ce517 49e76f8e625ab3acc522e8ba20681357a047a034677f049fa2899c475aa19a34 176e550880abd876c2307b4d6eb42b0020d40225124f670991e261ed9e74b822 fc5f1706677ee66d985d18db4da230f439c85d82f808a2ffe3d22d08318550a6 82ac6a417bda719cc532f46037cef471dd931fa02cf9e7134413a2c611524901 bf26e6a9203067b43bb70a3404d94e047675ca7ab70e25d11141911bb2af2661 87ac2e381f57cc1dc67dddc1856f853d2920e05944a532345728725fb333af86 acabca20b109acb684e1f344a89c72000014929301fdd6a854841c7e70867946 e75992d74ca21a03e48780b8f29738052cee235434b9fd0deb78644c68b95aef da0e26e90c43f9a3ebc6dc7cff460413c17267f1b98fd79d0dd6b9e94f684a7b 4c31c0ef9b1fd02ff8d4ed89809ea8ebaaded7db9a1cac184b56d85d9e4e4f04 1ad8a24e43a357ff444b5e9cd03287c508c2c3b2859e6c39375d221d420df347 5481f5e5c31ae253ff91df45639f8d235b06467c15b2941ace43eaae597acb0b4f00269b119a5914ab28706da4b2a4c32be6b105d6e6ffc77630dd8f1afe270244f1aa6ad8f49f4f2bdf94b370d114fa1f54ec5d871e0f4e8ef1542c09bc100b2da203e7845f71faf0df79571d4a1631678a540ff63451aad04288d3fb7f9c0dcdfec7d44ef73a51d6ead8bf105896513f94d477794d702e0f8edf38c38a51052d25a0864025df343d88077a8b6a409826af81792aebc48319292e4d561d0f01542ca0d2cd0c3c5ae83b72e002a19e69f6f464a2d7aee2332a5134e5f7f9c80061748464ea5f1c0263aece6ba673b721f0a6d64b812d1c0680e1237e2d06d80a8947af0325c7b758ee1581b88ed1f03646cbb4261665fe68e79e4d2549a4d70448d9dc8915de19d43197e6ade922b4d730bfc7a08e28a314c08fd8d8c94493012ac6ad69d6fa97bd4e9630b5a78e1e11b891f2ae3e79a34d47fe3b7ce6fb960dba978bc0a3b89333444616670af52d1053cc96151a7e3693d3411db738640a06888be99557ad57f6f5d1c9ce6aef5d3482fecf72191c8ec8b5d5c97fb3864f04477029ff97dc300d522fb53458a5e42601dec5e9efaaff5d52f280e6fb47bd0b86acaf90f10064d0e1bd7ad19988728306fca4d9b9ee826c52f568c096e3cb0a9b64aca80dfeff237d4c3a646bf1baaba212acf8cbfdad2a39f9b39fc8ee3a0f2563439fbd1bde8a40f6e55fa88ab10fee8330c8242c13e1fce9b83cafbf1603ddf4c61052967f0729c399a1c9de4c877b853825a94b45eb807013b73cfcb204c7ad35c8d1f051d781ba78eb98c91a37e3ff945e5759b0efa763f9e90800ee043bee9edfb942722cc03fee6e69fa5f84fa9d714bdda8105d8530da8d1f9da10b88b9cd11144578618293a986d51422d441ad6a260e9368e656e6408b46e5d70bd393e1b2139879168ae80a61988db34232e3d41f2bd7bcd0d233e8f3a33c320a4ab405e0cac707706ac5d257d0b50ab934d45d77687b78cc269bfbb22b56c9009d17a3d2a4478708fd75f18fa3a90ff60316a92287263b67e13aa73941f7c10f394f8c8c4f7ae9748bae8451b68a6fd3c9c11121dddc0390a3598b373b2002078c8ec8f69bc5b44acd5a57eb684c83f74cb596c4988a6b626470aee672176603566cfee4fe8685e01db57113fefa9a525924e5be6e91b0d9bd8dd0d56dccce0524e13b9fa7e5601ae738e93fe9cab5d8e265547c1268118b716a1f778f8fd80d true +check_ring_signature 6c652241a0b02dd524fba79336fedd548bb200275678d1bb7bc5c7289412d67f 47935302bb82b174364cc153aae883383deb4d64c34736c8a682819af4e034bc 53 2ba9f5a31d258685406b66a036887307b0e56d84000683fe7687c9a718bfba72 972d172c9b55d7c732189756c34be598687fcf6640ba495166aeab4ed73b7427 da0b7959c8fa40674a9ebd5b5dce8b71d3a1357630138bd54b6b171167c277e4 ecabb32fa4040807eefbe578a4e4f675e83738c41f71a7605e345353688010f4 fa379507e1c0b46e5b06e4a588561dd5c87c4e8b45ff17aed2fd1a4a9ba3a88e 6241d5d52dfb642890c3f1d0954b8f46e0af74ee28637b64121ae65622731064 8ee68cf20ebc1975030cceba430b79d45a2500d4c387afd6e15a386878c90bf7 cfafef82cc7725a07f2006979a9b9395fd5c4b0db6c6f03d97f97ee6fcfaab9b 2de44056196de83c7f67fc4e285630e85da7024c7a8e99db330aade4f359cabc c5e26831d95771a475bad2474a0acbf9e47110f421a6c87131da25ca5c154674 d94a43c38c3a3cc29f27961d311f5341f1420a78ed5cdae8a6763d3d27443d08 48dcd7a616178404526ae1dfb14d3297d4c8bacd29d6fcba44e76b72ec0ade48 4cced9b42a86b156629ef387d160cc2a7ad888e43e8d3b62a75950261799976c c2d2e0de535a3f4e763658980a73979c09c79d2d78b82596684017cbb77f2c0b f1ad4b434cd35787dfc4de4ca6cac299376f08ab26ab55173fee6bae23385d98 a91e2391c42c3e74aff8f3cb6b4cf9cbcd59629e991933a387e56735a48c556c afd2b8990b82268d50d7e00676b1b697970eb3090f277787566c81c670fa25c0 748212fa4c0bdc12a92123f4c4aa11f76960460780d9620e7884360d60dd2cfb 2a22ca837d1873a851c472e066aa2660d224990fa4acf3592527bb4c6da786b0 d7b8c2abbff9f5c6985a878ffe9fb4bbf3434e23c1d3dedaadbf8059c1770c01 8710d156bdaaed74a8cd0811454f81d5dc04d8ca17441962f6e74f6c21cc8741 5b01a2d8189764b752ff5cb77c4a5e9620cfed5e9108b18f59717253cc77c435 11583795d30925decdcd446173f4bef0015c84644c1860b7c186ef1affbf8019 64f4bf255e253542cb8ab343eaf9a22a8d7ef8a04b43957921380e2c5cb4d4d2 d505f3221399b1ab3e0a81260db1716b4e4f4b8d6f19f1baa87a2a65e5a7abca a53c02e1f21ee4200704bef92c785e63b61e2e096f909e26b0f5643048ab7b74 6dd9b92433c5c0c3ce77e572416e381e6e577d028c376c792e6c2b31b6cba3aa cb1657ec1603b364ab38f668ed2a7fc3e807217a1e2cc3302974cc9ac8d5e01c b60689e792daffb80ac41be54bade67e47a472e5545affc872701350853180b8 bbd130f41cedfc0a5ba1fd88006f711191a4bc63a0ed59a29c872b74ed86555e 2c80a1ba2778d2a9bc1fd9b0db7deb5ab35928f750970da576a0a2d0aeddc165 b4b4965444f7e41117abce553e28ea7ec332a1c8ff0337723685bb8acafc587d 8a5379f4334a6cdc41b31e510f117d076dd8c1010e230cb48c90c8edee5c03f5 36ef710ccf06de5903bc5cf761ce623ef374b5713a2375cdfdb1fad8e1647e44 990a0d0f3e5aabdc401a046d28f55018bb8789a42a058ab2a80adc8f7e8531d7 570943ad8b5597f68770502d1405534787a85de867591c1eeab16c349f6ddd9e 294ddcf9c6885457d3ac7194a562c4a3b1079c84764fdd8c7ca2036e1b35eff2 4e1a839ad1cf13e808f729c82be19c742ddd68ae1f1f1b8fff5d89e475feabcc 7d13024dc613088ce3ff20248a52171addc6efb00413ea987ba2d9504bd17be3 f55a04a83bb00fa712197607dd3661e388d8562873deaf797a00000f564798d6 696fa8ef18b1b5d54b6d1d0e3e82a0657d715d9ed73c5fc0b5a7bdd364af2b01 0a8c7fd8ad218e526f24590fe861849643e943d0b326719735f10796298c488b c89fe9838e51a734ab0468c09c72e259b0a8a7e591ea8f5d44a78acb2abcd1b8 de0ce8c07d91c0f2f68e8a7ca9c5ad0c9c02a7a92a9aca9a6b715873b6917d49 c56d7f18690cb556806ab1b58b83793d0b4463fad66a1022f6c17858c94f9416 60e93c25cfe2e5e19a46aabb7012febe6d74f0ab681f8ed23db103975ed1154a c1130500418f40991a658c764d9305e60c609fc5eec3f9a6f4e816db15fed61b 162bc7d1c3e172965553552f28d7ba9898c34ee6fe7afa8a1e491065ba755b6b b08afac5f4bf847c24ebc808e43afd3e1d51af09f7bb9f9dfcabd57ba50d6c54 4d4558bffb699d94cb9dfda5af99532efe4dff103a8fff80f89ea683564bfaab aae6c25ef1ea5f5be4150999ae3ce693aab41825c5690bf977d61e0dda919021 d1d774048f0e0260fc35c10bbc337ac388c85e22ecbcce9c41e33865960e7734 5879b5332001449dbaf3578debeea212a94b9d56855a0f9ebd193e8c80ffabba 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 true +check_ring_signature d3cf45b59130a7a7310595fd1eaebefc1959b14c22964e396fb877ef771980df ebcbfbb9b0f050b1d79e0bc726945b3e412c6f9e16f5301442842b8181a6c3a9 17 2b9114c6a80016864ee5fc7131ca03eb255d8e44fd947b58cbac4ae7a63ef80d 1aff241b0f57f51728f46a41b1fae63541d347b2c3c6a9ea8f92f29592745fb2 c34f923db1107e6ea18f19bd2365d51f3e2af5896c27c4876e292910ae0f9d4b d47c4985cb26ed6babbdeaa5b4293758c7007dc11a5ff24051c4e133c5c0c7ed 383caf61e4ca8a7bb3ad298019e8bd28b939c9c060b301facbe5f3dafece7a0d c52300baa5b97fc63b2a345fb391d3373cc765fd52605241af6264a8fca95b4f e6fc5a6ee2c1c6e110f21c7eef0b55e075bbb3fc6c9630dce88c3cba53b5f02d 4b786db46a1296579197d017168450bd80e186acf0051c2c9b6368087d278402 8d1c0d19093166cd209fe78d1755d0d1112f95121bd30f5bfe4f2605e7786448 3cd88d84a1075de2814c772480354b5f8a5ea7f67168c542f60e6e27e04da286 02462c1841188db411dd11d2135f7f542b897bb3fb0e20fb130e8ed4cdedc82b 7ebbf6736ca7648da1855f6ee05cd0c21a6f2573dd570ca6e8188952908e2496 19cfdb99a0191eb61d4843663e4c92e701b42908963d4cceeacd9ab86f5dea92 f2ff96d80c95a11db96dbdfcff228c26674d8d6bb511172ba42f18a29a275851 f59e6c9b7fb02c9b37a9ba7c889c514a6c24ce0afcfe44dacef385c6348d33a5 5a27252d6e6eefcb8818d817fe15208842d5bc11d49c25879e2fb86fd55e2d39 3a619702a0c0b1a8e76c37807cac1b7eacc07c9840e0e10a1d025807a4de7782 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 true +check_ring_signature 3433355d316784185cab4fc382a3ad7582e4917e8136f4c822197f67eb0e672c 27dad86f9993d50116ce6404f2ee1b22794b03b1f61ebefd717c33601a61833d 2 9557656059dba281368ad615c2a77c6225f571bb437b6462655ff394d9917fa4 79252d723d96e2c59b9828bbe1dbb7bd45488aa424af31acd3b152a95d0b56d4 bc25a7288f5d1dc5b271df927f1a80aef611e893212b3f5c9b320a4da72781038743f81b064a31eac0eb0e8ef0fbbaee0b31bdf64406f0c4213e6f31cac98c0f47b834d54125b99046950ae12f8b3ada087e8d3dab42a1a9bc85a6d5c49c07007edc975cebabc95065f75aafbb85ca2bacf880b1b3ed33c2b43ef64139c82c0c false +check_ring_signature ad9aa780723492e45f9fe9890a39383d651e51f564cadb2627a5bb7886e20918 2981b8e9dd156db3c1203f94a9f989ebfc3d50e6dd7c7b0bff32606b46a64f13 3 e6430ebfdcfe2b83208ed44d822afcf4a4c4fd0f305cb00668967d833a3504c0 fab2803cfd72a65c515f1634c010039db0fddf419ccd668398495aefdfe6eb7d 1e3b399ccdc97fa187d25619e9d690e57d3371ac5fdfd25727c4c6d9681ee7ee f8bd18068a6df365b07de09a4f2f82bbc1322ea31524ac6bb73988211c6cdf00ef4001c75f78e26daff33ba1f8b148f259fa6b70625cf8060e6dc4088b96fd068da598e13b046902c50a0d27c08d1756caa991d9413cd81d710c9e89902ac10a2109c829943fb54849baf82a08233b22c7a355cd7a63e0afe2ea479821e2da03808948f40c52a075d3062c4137585bf8d1479ff84a278f7716bef3ac1506cf0661ed71327af41bc77ed5d7afd8bf9ff54fe7127e50fe4acc61e7f84bd5e0080d true +check_ring_signature 4e84714c706df8c6c1efdbf1a4cb6deb82b5e169666dc8745686a2f1a7e16087 6f671d8ed31a66d9f08f209bd55e909f9ca888947113be4fd01f538d434bbbb1 3 f93e746a6280298b23142bcca2292526b7e8a7986119c251f435b3219103820b 5860678ef908ec3e4cf28573f7177b4ab2de6325d6ad82c14388aa478d74ce69 8afdd6f9ab6b202ff1e4ef57ee2f2e1361d36f6b80d2135cd8b3c91c096c81ab b953eef97e24a629c05b79d7a3451866f9869b34d8b7aff738034eb0efb9cb01b17fb95a2a36f759f46fa83d470769462054716b59e1180937ff27cff16bdc0cb64c3b2d9e8d94e92c225ca07d298e75bae20d0dc46748e7be5da79f9da15d0008d1b7a412b636291fe66e6e71d35aa57613ed028225defe307df720620579069e883ff08399fed740c2ea33ac84cc04f5af1fc46ef2e9de81be343e5a2c474a29484de63e667d8fd32327c57b370b35f2fe45600db53896b59e717777fc8608 false +check_ring_signature 25feb200ff701edca6f05577a6ef399e5ebefe4c30cd3d32fd8dc039260d7ec1 a0a0daa54a332805ec04b545e4a2c2ba33f0642d6e3f1ca86ddb753dc8ce81a1 2 e8d4554c2b3068e32e4577064bbf571b8b64a109c245aa914b7e66a6c65c1bc3 f78fdf5978d1800743d622307e6bf8167ed9d0cc93de262a0fb59bc525a48f4c 6846060b1d59d9b43497b66b30e93a400c8c1e7ddb6882dfbb53f08a6bdc150bfed92a1506be27f499d39afa10251cb0d20518e07a70b0ceb38c3c5f53241f024d96d9ec4856bdcf1cbf8914a22555d32283629993009aa450c9ddb030717d0f8cd7b0ec1f54f230ed5113ffe1fd3714aaa996f700faad06581a94310d9aa708 false +check_ring_signature bb453ffda56cab015cfba42204650422e26d715293459f3d08b4f50b3ac29c89 7cb83f6fef3d582f8bd84da32942cba21d04466f16005fd9385772699b33dcca 6 c869a0fccf8186de68b46338b470a7cd25a9bb7676f30005d1fd4c71107f08f3 c240f104da8b656df4f976f50f7c3703ffb3e9a5a8a6f498ef9b1e3576be8d01 a0382f1958be4a0bc7f20507f88bd81cb398ff28964bcb3be7ea1af94dd22978 e4f61d36efb761701a0b2d344c5f08430deb59bdc0088e181b31ca16d1d1e4d8 3a0333bbfe00906b7c2b5f84c442cacf3768433734807d82f14d7b9568668dc8 8f7fc2ede7e5bd7d5493bc8951b92167a430597d1865088d8bbe2f906981afa3 468525692a8304c984d82ad4a468b4b93375499b05c7d7eaa4834c7192ab5f09942ce459f3b9d9266668b50b5c81e0320d48d96a93a53de69c89304f6c22280c28d9e165bf2725c9a75f995235170b6e0a6bba3f4a1f014a71e1031f63db120c0decefc8719514623bbf45b54a03e797c821190b78a462c18d2d0cde087a9c05fb1645f7f113e4c1ec75ecb1e02348ffe60f400de5512a8f37181bc111f5c70d4a39b170ec31fb51667f2523a4f3382d2d60ca76f793c3481c9908fadba2c80a59d0d2dc6fbda0a221d9be17ba7c5f6318d71db96e074e2be15f530279e7810dd2e7660e9e2c00f513bd3466758482a5e4392a1a2a1766cd0b12b06fa0870a0ae4fa41a5293499be77a5548df5e40cfba99745b54e821c8cd90777a218f50e6368a8387eff6c937a9de1eea977ed891a50f1dbaba5c99c582113cd7e21b648005397b3302d73b477383bbc682161e6cbbf60c08245326035e09d2e01658d5c0cbb07f510553dd1e1f940cc1f70bdd4faec40aa593728dfeca402edb4d0f9b10b false +check_ring_signature 9bd8eb809b067fad780e7438821feaf7f855bd7b3254eb2c5c6c4f6dce89eb89 9472505bf6ce8c71d71912f1672ded22e10d4b079ffbf18f2b18ac6a23f5fc88 2 c78783be9600ba6ef57e00920d663a7786017a3dd496f76675dc1d673fd0fd0b 64317c35148071c5ba0a73dc12e54fd4a15937284cee09a5933bd5ec1dcd017e e19bdda781adf88dec174f4bc084cad19f308b19505784441f4aa97a530e2c0e52782bf3bb107d9d963366daec4e086685ef30c947950563704321ccdca85e0e24bd7accb150dbd1a5128667199dc5761d0ba2eecce6d864b039a1dbce879d009592f0571d114a84187f24611123e239aa10e6010b545dccd6e8fa68dd2dc50d true +check_ring_signature 8a0f915acdf93e40f874950e9c1fc358b02d41c0b05e243b365781cb40846beb d814d7e4cc04411bda56d28ca1eab20d6ba1fd07a5a558fd3b7b60b34ca23601 55 7c516380261bac0e0333a435d7b5f4c410f233ad9b03603eebd5c90ba7fdc019 5fe64baf0334271aed58c7e4f1880e7e1989664a34f09c5a0e9ff787bedd6545 66335e8827fa80e92f5fb665e1e6c37a1e567a8a2d148db917fd96d18eb90387 83693cc038a805fa8687c16ee717871f7f00f27b2894b90cebe0380763526561 0a7195255d4dcda5cc3ef502badb136e4ef00ae1e32952667192af3a58a6c939 21c3eeb23c6d9e804a7a0b99f18a147cb181136732f35510c4946d37ae607acb 22455c32637cdac916092b9fffaf2b5ad2efbf2706a2849c7abd124a81f2277c eada3ac9fa92f80f975da5e81d7f7b35f26ae50902952d6a852cdf05a7c56296 7dfd8bfde91d14b349b07c148b6991ea5dbd925c956a0ce7020f9c609713fbef 5dc17ca621476d52acf1a12e1d464fc1dcc68b20b7b8aa62d37537ca44b1cf80 e621a84b417045e9233ca9395af49863bf8ae1f778d73cd1c985f937bf7a767c 46a21d1799f534ca01f0c528754973254a89c8cfa8c9373f70a0b98002c174de 9c6dd09e90f65e337987bc362c796f98619d0fed3f756d7439024c9ee7686871 09099322a9359556ca43b429a5dc5574d052f5c82caadcf59d85769c6b423927 43a7242bee6f012c08b75fb1fb2fc7f28948a50b547de455a0422e4d9d41245f bc75cefb797590f5835795f64985c649511bd2a3c3c445617981c0392dac82ba d84aeec599d00210d614d83618e6915606847be0d39c73d1becee86991563831 608d522e1bf59f4a8887db05299748cf30bda8bb3e4194d8d3bf7380b73ea320 d22e148513ed18fa53ca1ad83caa982c432ce5d5b6dd7494d43fe0e7b51fa6ec 033717428316b611f70b28e5b4ae861307627885db8b49e0915f7da0b4e4caf4 9c3a6d5dfeac5058645a68e6be01ed7ec398d2bad97001d049dbff770f72c19c d9cfb5d768dcf962a9800b73960f7b9da892198a23a002999bb73b8fc52b6981 d3b3e1e8ba556ae3d5381507359d83da7d5b7f6cac4c76cb5251ba6429f0bf4f a536d23d70989a860b74c217b0a2997f1e8efb46d1b5325f32e6009bce07f617 9a7c2b8a80373fc7a27d8f9b16177d8f978cca020a849912bbc576ec4c6c07be 87271de8eab31aa3bd3ae07b2c4ddb39ab4ca35bac08cb64fe27ede10909ae26 23a35b92be6a6abbf0aa4dc76ed062af880a5ff9d242a30da92020c3be8bcc40 33ec4873e1f2f8c2ad69f7e9c017e20d890cd34029bb0b3c21fad6d435a4f03e db6b8fb710f83257e807a6c0628c132273b8f93b05a1b3fec3765c4fcbf07883 18db1ca2c69c83877a5b162df4b5b42b93bad09d8c3d10579952818b94156757 51e09a281eae003b04a31981497b4ee1f026b251f623835f2809e44c0bad0068 67e89aae7bd92895da5bfb69a754500b0fbd0dc2155431311a35e83b298d4d0f 356aa6c64264298c7ed48aad059085fb701288fa84f05c2563f41fd7c47fcd95 b10b5ba19a411302351944fb62ecea0294c750fd9543dc2dd0ac3c7d740cd439 8542da88a0dd22c5df6ab89145ee15dfaef982a25c6d14344691662552e96ab9 51da57faf838d2e85bde0f06f42a8271a90994f821bb33bf5015ec8178a2ccdc 6d0d4d39a841e942a57866794db1c4c5a5f323a475e54d44f01c95f69411c348 4545dfa50ea3ef0c294426146b549bcb8ee26482eb736c74508722d147b498e7 371a334d4ff6bb0d7900f9735fb915a453f7e4536e620a5401402575a11d5a22 a2c854d7dba715642a545269b9b93759b0e3997e79e809648572d2656898e3f1 b1198841ebf583c025043319e86fb717785ee4bbdc2a1931e1022aae4e04f0eb 7111c3a213d0a65396201d12feaf4651ac80294157457783079ccf6296ca13ae 16b07769681d49e34388e968a875cea5fb206335730a477537aa54d227cbd1eb 16c00e866fce2c2323d4dc4b7a226a5a5c66fa19b97ca08442f5ff53e7369103 c390f826a180703e0a3670accdbd42e34811846cdda8242c78cf1a4469608dfc b3a8b6d2e5d8a992546cdd1060ff2085981a84233ca1683b6472a427f326c5cb 7abd8efdf911fb46589cf908d76178c51332dd3de0987c284821e8b9b834eb9e f6ee51a12b838faebb31c95f60ed16ec13626a4aa7bcb47446c285e8f16ac61f 3ed312d82c0ffca86ecbdb342e39796c3c5079321405971535ec568ba1e68535 6951fcdc1ca1cdcd969b4bcc8d017f25ae54c693dbd119c9d20894d167e65bf7 603c0c659d1d8ab52a1e6bd30fac381b639c591e18848de2f78f90eff7816983 aaab4890ed65fb1191d4dea73f69c19e08ac1c11853023893ff32b9a60b6c706 d856c8353cbcc85d25a69c504eaa8f424400adbd484b281c38f0f3b59268ccbb 27d09be4ff7eb6a5d429b29c8b177d6cf72931ac40b36430e2e5ae71384904ab 849478525d8927c09b6930c05a5a8cac1ea30666fbd4d42baac76e80f49d7611 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 true +check_ring_signature c9f20d46a8081dc4d147ca8c908497e43d88a94cacfdce5afdb29f3e569ffe63 3b948a9c5fefc40672651781f36487288c2913cfead5689e48b27216c1f406f2 2 312216116fb3f6784094356a00c260b48ba1e0282655caf40b6764187eb3dbd5 fd4dba853b4683b38a8366556f1b96ce5192bbb1700e95eb87c429c463380471 21183e89cfc5da67e02f9ef37b7c2e95a57903dbe97edea68dd92e02d57b440ae3868cfcbe35cea154055a0844563afaa63813c790c2f7bf3ce5f5dc381a760ea41d6f985e9d8ab472a9f0b7858e12deec4bfedbe9021683bd6d1107f4733001bf18a8545ded2ac91edeaf898737b4cbf71c0ddb6db4780e8ef4b6df5a85ef04 false +check_ring_signature 65a9bc2dda76f945ead871beb5c97fae0558d6ca11b4122e271a2ddeedf1c8db 22a9755e21607f2554f5993c24aeb31044e4df69be4b4a644fb65489a264607f 1 e20f55cb85d4d2f70b5e6375921a9ccb307fb94d1a6e935d4275b60f87d24a0b 1bc9b77c0cf07a49f9924a710199410035594e580ca84b6c57a1609ef7d301365c7b87a105722f7547373509d5190f48863c66dda8f78f7c23e7568e23deebe0 false +check_ring_signature 66c167ffec24bb9ef57e8ae77e1c65d14aced4c56a51e135469070094d7dc302 e43c4d39355c662ac1ac47786f298a65514c6b03910e37f81ed0a239f9bb29e8 95 0b9fce587a43127b1a9257cccc96d558876a66da33d4f9ac5d4700c241f793b4 41c3a3dc2822559f7395be480a7bfe07acdd514446bbfda9c65458f08b9d4946 15116de2d7465fe26e003ce0c91b18518ca7188b98248c4db27020da343e28ac a5e80b63d9a700d45cf275f88c72f057b7ae52b6db4c332479b9569bc693bb79 e124af6817c4e8500366a987011aa7e1e43a3b27eb443b4a69ea367974c051d7 8f6fb3a1519e937ad4953aaeacd5ea0c765a9c6101ac6e8e23382f78400880d8 5080a5d8485b03c954a658705a97993cfefd49981af50eda73b3ff17b79ecc87 f2d6de6887fb4827ac64905326dde02dfb6774c38e831540df0a7bf2de5a803a 25e6d77f165b85b47a03ed652635e5fd1d0797be387b85ac878191556739e7b0 dfabd64df9299125e47837bb68ba5c2ec2adcb006a7db1b08d990faf6212398f 1cebec1f64ec4b7ab56201a5a4e276dd05e80fea103ecb41a093328aaf77f5ca 9d8fe09f648334c6faf5e77d9324ddee4f3077a7db5dd82db0cec0c99204b829 7fbb9e3091aa5e96220a9d2f0431b42d0b25b512cf3ef860cbc29757bcc54f56 8bdda1e94aaa26dde8724268ef8a37df0577b87562cb34df13eb60291265e4d9 86faa67332e0eae5a9bba0d3b6c2668c4596513b0f073ab88def550f4bc15098 30bb6138c125ffe620a9fe57648d93487054688fcc5219bee5d827638dc0759c 24b8b6d06cfd234e178e045f34bcba74ef9144a3b265e84ca0e06140da47a83c 4da0f7cf92a620de66fcf8aacacf9b09d948781ad1bcf0a2a66d8b67010eb6e9 b1cbfbc457832e4e89e14624a2edc0147a5179459080050978c4e5071d19cb0b 520dff601b0f6f64a4985113d64494344e2b835458326ced510a8782ed0eab3a 42c2c4bf63c996fdc387c3336c753dd616f3378f019184085be87d553d173b9b 86f624facf228bc9af4072c87f6d3b6d04b3f0377912c1009864b224387e2e2c ee51646849ed5bdb6b1021998bd715477036703c367e4eb6ff0fb1657b3c4046 09c482a5a00a06df3ba6af980e3cec9df7053ab944a052564cef5ac66c3f1591 e3fe6b1360ed472b82d3eb88094e8fa590f443a772d1c6f50876b13a3c08680f da2df5305f616a5ba3b4bb1fd93f5fc2d6394d2f5a7dd6f41bebf9b4bd1a9f44 2abb15b3a71b58ca448387a743fca2ad7f3ce041f3193d0cd9f7bf8bdc8d93f7 489fa20c23707c0ececc3c438bcdc158d374ff7cffd1cba4160d8a8dde2c6e67 07d409b984d2582c21ba02ab6fed9f9dc0c34e9af361a9be26c243c2ef8f1916 3c95c6580e4405b595eefcf0a3e721dadd4b8863105acb854c328793d42db56c 38a19815a1bdf73f9daa4c780691bdddd500099cec374b0c07537e510a1bb69e 08272292ef106c6510101d7db0ecaed3813a7f7cf6c03025207b45051d3aba72 b6b83b7cee72a8f595457c33d0dea9f2927276a3c569dd10e8307010027134ad c7d03f5cfff89c9f6b461a25a65e5f2d12eb10dcf26e485a2d371c98d96525f8 1ec1820b4c875b6d549c4aad462557279a667d46c9891263592bfa85cbe34eaf 49d195116897b06a51c5f03814900cade6f726c23fa6415cc9c460b607a7a98e 306cfaf43abcbc8524367ded0af1cbb10219131e58cda1651516817742ccb884 f635a55b01b3ff255904e72ac62d8ba0e714ba7d8e092280a468ddd57e26be0d cbcb53fd975e051b61f873e122524a4250a70f34e8abc55d57e0845338b794d3 922b743f263dbd6a2a9582340a868154984e438d27ccabe83c2d7f5c0f1a7860 88b64b3d6feaee38aedf3e4e687d6a07ca003693e9ee6a1986054ec401255697 e4db6e8e050d2ad411c2da19ede306282cac1ea838e7d12140537f4e176acd39 f285512e5d288ec2939ddad8cf472130f437e156642bb24a9fd01090c25fa813 bcb7a3d51756b5dfc868d322a461ce418a28017b0366764cbd4e5f26e5d7a51b e11605a7775e9623ba772448e7c2542461f01ce110c882a628ccfcea4c7ce400 f8badbb3235f790b2d479418fc0de7cd373c9e241f4fbe5e2484c135608ab9b3 9c681a7bac3442e9a4b4eac2e17b4f95b590d151cdb8f174ff7d3431c982927c bcde8c7fe118fa55b6bce6931b07e702c769b975a1e0cb4010a9893f6290cf4f cadfba5200643555fbcd230d6ad82ea2c10ae407df8d8393c35c06ea5c694788 f0d49ca6142eeb7ca03d1f62254d81791be143494dc05dd10a30b718e8a0a345 e65182a31820dd5be4832e35090edb69a6ee93e8622f44e8f1e230c66c954165 aeba6472d8d1bf2e8c668a38e35e58144d45c204ce99885d1107182740c0a037 7df37a7c38dfd7149a69e9d1e5461bc7a4e3ef1473a0923d3e9fd23b1c54d533 d9a9bc1f7dea44ba832baf68099d07471a6e979c065b7f7fc96aa8f90e1a2c96 9196cf189f43515e7fdb31f48cff40507de60e8580badaa1ad49647786c103f7 d14bae874bdf4c3ef6f18bb61ab3482797808f06e27f7606bfa3a0ca2134126b 86806485786145cbb9712dac37e727978c1e94051d26a1fe87ce3f764f595c3b 838135c69f71716ef1824b6e90be1e032c0e3c8b8e2fad1c5e7182a3b76b231c f366305683bdfa55c3ad1633a0ba7b6e580718dd5dbf554eb355202b4ce930a2 80b34507a87be6925f6076ef43ac1a308d7cef4e253645011f1750b0a75e46cf 64a8357deef2d65ec0cc3e749f418b437b62ab0dc3f3f150db0abc9ed1309f8b c0ed3dda04c874d142fc305d998c5a39d444d5fe2724300633b88094787bda5d 698b2e067ec96402930294ebfc71d4756c83870b2df953725de42097e8a1e4c3 7d54f21684877bad4ee0debafafabba0e579dfce08e28b392d0f502f1c15af6d 02866924a551f1e77d9deeebb6d31caa907271c187f1055dd4a1352a2275bfb1 f8f579d1341d2d173fd85e634336b63ed7266dfb6dc00b9e29322302a9ff1f7c 9beaf54077cf0738555648b575b8d2a370e24a88b4f9a3f877df316447b7e530 ce6cb3365137a1ad0e0000f97be79a8e0655d72eae9f42b887cc24f47aee0545 766bb1fd14af320764ec6ff909b6a178b0f3a3b9b5c48c6e80f38c2bdc105e0a bcdf958929d869a139152e975bdbf9fb7d0072e9152a1821c1b0abc736ae939d 2cc9f63b7a235d23aa62f00d3ac147e6dc7c9d84b2b19af27d5899ae8ac0f2f8 39ca3cded742e96aa9626edb9bd0deac1d99c6c0db3031f7318aaf92aefedfc2 50a69012dc38865509c1d513c11d77651a5bf8aa44217336f625d2f15262a9e9 ee3b1e803baf4da087b83bfe171a7383d06914cc081ac7990d0704f4cb819121 35df37b739660dc22c4fccfd92b92a54b7d0b4155c4b162b17d8a7d1f0c9159c 1f5452397b1598685904652e529f6528c18041458d72be556be84b6b3ab03891 9c9acf23a6b502aed977211f32b65f8638d3e4e7925452e2e0a5f0716feedc4f 7b30e4e085d0a9cdc84418d23963e7dc97e0c682cf1a3e7483add82c0130a5e8 4e458bf4be64892cfd87a390f6009544d253b8bfdbee58249c8a65e6dc24fbec ebfc009f647d8fa94dc5b27899e047a9bdcb89e2a83f79caf275a0ef8119cbf6 28f859f402110510e5fba0810b7d019de553d90ab61dfbcde658e682f7fa17d5 ae54c4afea0c32881417e45e6844f04f3237d27ab9e3caf6f9e2f0e88dbb0727 121dd7927c8c87a807fe6ff56b0f35cc494137cd8900b23068a8be4538f7aa26 84a2309e245d03bda8897838b4e46e811b602cc5c402cd4c6da2ca536ce66143 6250af54235348bb8c7f002fe67e0de8cc6d7d4a01d5faf308b3f16d59703e5c 708fe2643358169c99526cdc1040c4ef78bf0a7aeb121ae5d5aeba55fc197855 96f61439cd72c4879153e4231467c59dd2934d6860d055ac32ae477bd38aa6c6 a20f585c413caec93bab27e6503bec00306050391fdd1be5a566b50defdaa238 bb94114a82e8a53bb15e36c6a43958571c898a03cd6ee9ff63460918d623abc6 d7606ebd9c1253988d6899de2efe87a2583865d7dafc6d4f9c3c9c4033cb69ab 2fa242c9bf6962524b7bbd53a3df01e24d39564426c0fa3836dd3d885f4e7fbd c3f453b6b70836e29b518fdc7b0cab45749806b2edd8253ae665cdbb346c9fac 213cbdef740a2549d17f66ea7eef5e08b7682e1cde227bcb55399ed7967ada29 1ce08e428f9c49664a0f2c6c5724eb7ecebc28f7b07f21f96ca71ff39687d36a 2d22ea7ac4a65948dd574287f6eab6c7e86b1b4ef8ad4be9e2495063ecd7191e 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 false +check_ring_signature c15277871633ea4f3d9c1e9aa201e42d42bcfb6108fc91878ce69e7022032993 16793c87081bf034370d8751436bef3a2614e7d345d897b8a706e787afe543ff 34 40949ab5c247a53bbf047d55b689924dcc5c320b1778032ea29661e3caa32f72 8b532f25a3dc5d0fb4783d98fc4f7d7a3080d2b6df6a89b23413cbad3ca627ee 39cb00d338775178e55462d7da12c4e075aa46c413f79bc04c295dbfe9d80049 b0fd318475cab2a31f9e681773fe1cba9955e629eeac9fbdf2bbe64c21b8ed39 4d2478e5b08d1ab02ff578fb9107dd664c9860130ac79cbfe502f1fbb9521441 67c6bf7d11954a68f7428650feef6a227a07424394996b2966d1f46e797473c2 8dc28e24eb284a5f0069639b202c6c9409084edcbc2b572c8bfe5faf3b6aabe1 6fc120c25c2bca7ef2754f11d5df0bcb538b883da60e54537814143f193c847c b9036dc88f7b070e1f9efcb63adcf1d92d988cc2642f8a313657f28cb89f1a63 4d45f7199a5485fcf509649538025418e0e5cfbe24eeb7a10e37e6e7dbb41686 c3fefd65bb30a92376d7eeebc971a6116522546a1964e9dc1c5a6a4d2858103b c858c4090e709c76d0825494af7afc73d48b08bd65ee4180715744c82634f428 9ce01cb1bace2846548f583b3b3acd1dc7e35851482224d1ccc5086bec82ee12 01c73bcae72019ce934ee10a1228aec07529f2e7026905fa0c16ecf94265f996 3baa075b51a459e937d5ee676f500e086098393d548501ebb045ebdf6765cb9c 9e3929bb84bf26b9814fe0044df8bd0c434d5a195b94d7b911684d0a3020ddf1 823a00c0cfd45652cf50a9103063b2e136404f20a89ccf21f0a4cf57cb72b9b6 005634b15e1322f7fc4f5f807e2e815a565fc4360b07cd332d03c2ffbc5f863a 0abaa75a0c1c17bc02b2a151101ad4c8b2da112c517e3b97a65dd40103544ed1 eb8379a1e37cc9bc9bfdb3edabe64526c308c9ef00e708ab9f4959ee4ba5ce04 5f0390a40424b6fcc1a8eed480d47c52f86d1b015ccc5b95cdde232fa4a796e3 c57ce539f1208da0aff50d01d3004848a7a1269925c4eeff3cc9a56fc68669d4 5ae3dcff040f36095330f5159c10bdcfec1fe198d3ad25f6bf190f4611e41b10 0d89dd656cc755a003281a6673a1fb8fae9663436d7ef852913df50a9cb6e1d9 2f1a78ad511fe4dcf2175ae03e894dda96cf2e70514fe84681388d4f2b9dcb1c 743172e1f301916eb21e6c39918446728ff7b80e99f655ec4172d03b5b17b8c6 6d2a08f72c052157289ba72744405661f19e8c8fc34ace91ab4b63646f3052ff f50a39c117b09d8d5ec857a62ef9f1c6f35cc908bfa07f6895c1d7b0bb70a4b1 eab8b82b9740cc4c4e705d03ff8023dc99f39aeb3d37f1ad46f19e72e5b19ba6 2283bfa001f0f1086401047481b90651f1cf1828b8e1233d23e9be460124e265 636dfaad60e5544383e02f739edc278f083523086e7e8885b5a2fc3088e23573 44b3789147cf3e4a8814d2b57f1cdaf6400c0af051355fb9a37c9a315aa52d3a d324aa7c8fc844deae858cba2804175bb15c78eb9d25f0236c3ca8e9eb3581f9 abc28f45a261b049c61f8d5546156bbf5eb5ec9b6341f714d85c4795c5e7e457 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 false +check_ring_signature 50a431c72ba79852942bc7753c9488c77c85926dd57ccd12dc9a5a802daec799 1c2c6751b566a1fec469c69a99b7ca2b52c4423ebf79292b31020c329668c0a5 1 2371673289b34bfab9ef48b89e141a298f714665105b2e9525036dd4457c05ab 87584f0f3d4c9640d46c925b69645397c92f06dc943d86e158fcf6a2cde06600b8cd41b7f764bcda2f7c9f72b9f99f18bfb174c2dcd098f66cd46f809a0d4b4d false +check_ring_signature 8dd52f1346aa71dc6ae710af04ef2b4f2e1b46510ecac2242ab69ce5662bd19d 7feeddd00470974b7a76a10b8711039d8d247a5c2a4b35139c6a8fe5c286f21d 1 65597b8281972226b590c7b1c6489f0fbfb8337c62f19130bd722a4e78479913 090bdc822fc834a74964765f809c6eac37b84af9a1ffd7ff25c45c1fe759bf01b459445f98d0ee20b7a9f92e73240f1fc8ca24118dc4d78e163ad27f1de2ac05 true +check_ring_signature 617210729b255473a72b788ec5dc85428e92c03cab5b352046af3a54a3fe8392 e036f89e89eef8e0477f22002feb8cd3ad09d3ac771cc4cb09ff2e5b7ecc83bf 1 84c1c4b34e07d3d02d3e09abd0d4c5fd0f1bc913fd146a5c9f20e1fd579f08cf 4a719a65b106d8b4b228fe7d128fbc78f9b961ddbe9b4240120b6ff9c0ce2d6a0fb7d4cbb46bcf49bf72bc5208ec0b399ff6c8cf13023b633fff93c61a80941e false +check_ring_signature 4939fef9c3ee2af38f7d3ef855dfc5b26840e5a2a75cc0af7c2b7e6ec2c3b19a 23bff94b57d29aa5f76e35aff5b8b748060e52e4cad749c9dfb22f593c7287e9 242 bb993aacdf458d78c0fe6d2835b952443aae77dea1dea245c35964878ba9e50f f969d841d0517fdf47b7fbd073ad341d473f951538d0c2ad4b3aba08993a0bf4 ac27a3016ecf1f392ab7e36549245f78890ddf16f3cdda74998dc472c79b0f9e d906966ce26e0476e4c54a4995263ff007d363332b6c0793f4bd979b5c1229cf 363d074b6256f3fb9d199e1b900bff8c1cf76e76027dca93eff139e262888641 a3c718038e068a4aa5fdecd9c21e34469631c2270d454980f5d5ea4e6306a2d5 29036f5f5490b5cf2692740893bc297dde9ce7fb32c26ef1c0b5e7eb182d2aae 31d4c1fec453891d1baf53ed468266204dc46ad9560d3e96831c24d7bccaf128 7ec85aa6cc6813f20aadd476132a1d4aacfa95c21d9b691b740512150f558946 0d1bc8539b5766840810d5310f9046740107fc72ca61f89c09ec618e4ae8b707 b8b486952af82aec5f2b0fd483e94df6f540673045505119088e69e93cf6540a 80e71c1311bcbd31d56935a8acb6e8235c6385d96dffa397631db535dec59c6a d1efcdf9703569f20f2057cb8c454a510c058a5a615b484863b174fee0031a97 0df7f8ff55e5a37a3957e0c86e346a1646cc375e8628d436d7ea278665271e78 3d93dd0068e6c4cb84996f36f98ea3cd1550565a0fd1d5efede274c27307fb05 552193a2daf063d92f990724a98fe6c7d98b2a8029449887be7fd1739f6d6868 9638da7408cb0a8e0421e3f31bbe14bfe4c57b9c37d93a6e909bf0d42c0e906c ec51bfec1cb723fd421e0f9ba2de31af5e0fcd8ca2a70e19ed1d2b51abfd10c1 85a8265570c5bbfcba9fcf5a2042c4377e0d1f6e446765a455f9dd9580d61f35 16d74533e3367a3d46c877ee5a248c4f691a1e35ffd930d42865255d6c575cd6 0bebd48bc83f8d8e919b68108892562bd89ec783ce54ca01398af2704db71fe2 24d83646f4572c2355349de9ed3e5431e9c8513d518975b86b2451674edef9dc c70a7334ca1ae2f9adee45f08475701e9a1e1f425346e8aceeb7f30fb9f87363 1946559541ec5cdb140c9fcea96a26e5173cd430484e068853d5c163b486c59c f9daa74e79e0729d442620e5dc8fc34f107a2a9f895fcbf5a88f77512d06fc30 741bbe9314a19f4c85742a718bbcefc820b14d78b68ee3338b42c23c4b228b70 4e2e66db29d15cf54fbe1be69d6be62b938d81fc7c7a9ff63910a7c1906816b5 6a66f2c7201bf3df893a9240cd55d0f55c1d7db343753df335962bfdb3c7f58f 128d9f9f987a34ae994930c1dc86583952f3c031c353d815e8653e22f3907953 01422c906fd9c6359843a385fb616efe274318b8a17da19a730587fddd36fe93 a931826a80ef42b99e26a728ab1839f88dbbb4575cb7066d6848b3304e724675 14c0acefac76cbf972a207d740fc11e2312d466225245ce3910ed799d3887902 593a180d4174a39c7adf867fc2b2c366b38a79b8457707a9f13212b8ad212ebb 508d77d4409087bfa43a489a419669da65e0af452deef766dabc43853bf5bf8c c5944d49eb3d05e3a69ee1874cef459f70bc0cd05cd2e40671de143ad0ae71a5 32b7fcde567516a8fa7521b30a6d458465bfd4bd16623a1a5d58daf6387bc9d5 d4479e3aa99c0dfeb93b533714a63b2b459b84590520f6c231fc0df6ccabf895 c05bdbe04e49ac8fc101a2bb49fbdb6744318b54b07166505cde512788c23de3 6ec3e18368ff786b281361dbc78e3d7650d9c3d8a4ce9568991dbe060df6cc91 c7ea6c605fb8249a88403fabfd5d52c09584beb355627c1e9ae8facbbe7e9d8d ffb8bac8f98cb0ebaea7fc451ed3247f44fe6784531978049ffe48b56544d39d 8962a7faa3b8acffd3a2e24a7fe6e04241f284b7fe099f57464328674be01cab e4a21cbe0ab12ad84fa95e0342106e2c8dea05e350ebc975aebec4becba9d4bf 107f8754cd21b9bfae40863d718c9218afac197f42186603e74dc113e0290df1 d86014345396034eeda279bacabd36ca3462c41e3f9942ce19761d99f301ec9c 9315804660afd649738286a5d115c4c7ac82e0b9db34de7161b581bb9def5246 7219acee2936b9c47649dff1b07a5fc525778243a48f1b901a7c05afd43eff72 28aba96a459b5fe3c1cdf15a7c71b91ecab6b87ed2ac1108e8de95ee538f370f 867a6959f8ef7cfad478e39f0fdc85bba9a1d5dc12a03b0dd44deb989fad00eb 20ff66e74cbea326527834fdd399c9c6f3a2e38eed5e8c25b4763c27f9e27f93 7224f4c4049caae5277d98bfa421bf1ad07ba9601f8f0f3d9bd2c9f993e74f6b 31e00b945383ebec48cbb73580afc78d2b101c1f0cd018294fa4252cd9e30e56 0500d69b144b50e65753194d2ee9249dcd662abfc66f1c6b49d26205d88e6d05 fa6c69f7ea5363842b6056e489be66a8c9d5b226f757e25dcae8cc748041b52b 8aa275536249fbbac6e4c1f123bda19aed6faeb7af2bec04e4d01687cafd2796 17ad997d184ba9c7116c9cdb4e6a86a294f5f5d7c86570ac00e062c938202de8 0b2dbbfcff9731b3c6e7dc5f2f58363387fe461e790d57d291540cd412d8b549 efc094e2a64dd75f03d3ee808efd4468273d403d06e626f9b56e2e2ccdbe97ca b040a602075a0f5dd940cb3d27a4fa4e8b1146d59393467db4a2c6a5a2845957 1907a1493a176b42c7d386121302dd11905b5415ecf833d4e98573c658c7e837 db29a8fd3c651232b8803881d0c9b47a5d048d5ee55d1bf6b3254de75d45dd8e 0d22ec6dfce5f8d20095b6e37c0115740af8409041e3efc96513664badf44e09 1f5553a2fbde5ee2efb2ea27f1071a8ce804416c25b8fd33e7c02deb5ba8420f e5875c45ccdfcf96594f712387b7a48467070846f5c5450ec2418205a5a9e625 be29065f55fc663eb19e274992274dba50ae67f7f8941086d5522cfbf0152b6b d7c3f65653085595f144bd67d7409bb66241ea61694e6f9cb9d2bda7679d8a7e ec8d464a68023c1e2ea91919949f71ba55f916a9958ff04f079e6e77e4c30bce 9b736669a2a10837f06e8a68e41b1b2c62f2cbe496929a45c7eec687ff3b1ab9 f77e0e5ab1bc5d35b5927016c24b5f9376d608f3db4ec60a0ebf31da50811597 8e7660d430dadf75a1dc26ac38b45bc8dba3c7993939fe53481378be48d771e8 b239efb6df394b771aa3b6474c45711f5541b6f4d555d1cb3f271a161c1c02e2 451539edc253930d7848ea6a7f13c1259c2a6d1cd3e2df608fefbf239dc2dc8e a2ce86ace020ee875281c9131690778d09bc6571e0fb7487a5493f78f420b811 f4018a0518dc619771890b97cce0a2ab22e13a2b3df5b7337cd8965ddcfd7ad1 a3c9b86fc5d70823dac192389abf80cef7fb6487178d72f10ff2b2c5ed79465f 5a845a7601a00745978e2dde2e2cfc24fa26702d0bdd6b36c33c57651fdb705b 92eaf46acda75ceb04de8a66e867ce5805af352d6f40cd4256f556b7d9735e66 dbc4ec8592e17f479fff6977ce0ee8a7a003ed423719e1744c867b25265c4e6f 189d079ea744b7f6e24b2c932812c03aeebe340067d30ed624b090f35da405f9 d5dc60afb3958d0ecfaa2d0e5fe125745fec56abccc8103e241e5448408a8a06 1c194bb7882f2769d713786c0d43626142bddf70c433c05560fba674f45f802b c3af671214f3781d822368f37feda9c5cdc43b89b45f9eac3f723ee06df91b13 d6b889e71e4b7f22f2d9f30343757d48e7b7d0a91de713c7abd6753759cb3ea6 7f098775aa71a7901a3fb81c328309bc0dba857c05234dbe05e4de6bf3e7a8c6 3c7b6a9bb597bec9365d8d81f94d3c5ddee5d16e2b2fb4a1aa070512205917c8 0fb6fbb66d35ee28f926cb580feb5d4f109124f668278819779600016af5e7d0 55414eeb02e7682d96910d782d826ea18f3a9131287de0693cb173e27611907f 6b7a8d419041a43d45d2acdabdba6d0cb38b0c7fd9a1881ee3b799d59c153570 375f4fd73850399c38be733c12da7192d50d4f87d7c1fb0212a54bf45511b77d a511f9b27213ef80381895138f59977fccfb231f8df45ebad1dfde7ebc60922e 8b0de0bdcdd43ed75e4fb315b67edf53ef629e105e8ddabaf95768686479db0a 2c129979d5fa42766e920183fa79e3f442669ee8ae2fca604612bc97977addef 92be3c93f487bf5860787c02becd36bc6aa4f8f2d9e26acb735e9f42da5f0874 df016169d480e40f4b6d565da95bb9f2769144ed73675d965ac0c091ff4a64a0 e00e09039b8f70092cfff8556c10549dfcb6a5fc5299fbbfe59ddbf5e364128b 27f773f5f70ada279165e51849898a7f0a3af110bb4189721a7397d0f0ca9c85 f11ecaa852b3b18457a1e897d2ca382220e68311e552aa9658db3e1b940f8a7b 040dce8ca46f2fe7c256cb01a450ea2cc24ed06f6482b9945bde93e9c068ed3b 151a84a13eb1c6979b39bdb98e79726cb09b6b238fe1eaa336ba6aadf2eaf2cb 70f8fa828aaad64bb8c9a0614c4630b44ff960456e6cc5eef423ea5f145c25d9 cb47792ec423df63232e85f656cf9044e0c814fbc6b275444561db70280be858 0cc1cc31bc838f0bb76caeba9caf39bc84ac3111ee2664051d61ffc09c1e2424 d052d545bbaf405fc1a729beb084bc8d8b5b1ffe24c9a36542db693533186f20 0fe5e42213b16a24c9e35668a7b7dcccf7b3219a9e9ceae0f436e2507eca2096 f75f806b4e7be01f2604fe99e3bbbdc472bc567a39fff5d1a86c7f64f9866aea a33d91cf529ea547ea44c9d16dec2baf9184383ab40ef9ed18d2cb1c54b0a900 56ce16995bc801247240194055cbd95d9dadf1ea82d109bdad69cddcef7abdd2 f9f51e0c57141f157b70c85c7d7787b922a23617f6ce24cf27c9a5211d4a167c 8b2c95f8f045a9859e36ea71856a44d37ebb9b53221205c1c042b12fced16944 d15da8cd51863f960fa183d4a1402fe34ba79ad5d1c7fc38fe3f500790c5422c b6c44fb9537649a5cb8cf29ab8ab7d55a6d63dadffd628b572e131426a94412a 6df0b99e07a1a686868d32a47c6012e35c0aec71ec29cfc717a21536601a4738 3e0874fb7853816bdc3d59faf30c8f4e75befe4842cd085ac43ac3ef283b73ce 2933230528c1e50e54db78f565beedfcef4f56a39cb6002b01c6f473c5928166 1138ac154dd96951a3bee348c82f52e7bf1c984e6266ba43845db2e1f9cc41f5 ea9363046e4c157c853d5f9b474f570a1e577f6b06d5832c94f6bf0cb584c4b5 83c77409ada63196b404665397316c5085e792b8fd127a77d7f70b567f6f1e1c 04d05e49d4ef6f9b99a8d36aaaf2b058e2016341d4e34c3c406a99568184b834 36cca7a29b32cd9740f8221aee2bee35f31c119273dc2177f08dee70d1cebeb1 be311f238de071c03db91250e57a58e2773a45d9390cbeed6d9211deec9a049b 423f73a2f661099e9f0a1a535ab7f6fdfe33780d2f5855cfbfa1f19248af302c ce75acd0de6235ea99391d4aec2e8133e8596ff8d9056cfbcfee02b19a844b65 690fff6a710befca988f721999a7c542b4e68fda95ebe76fa5466ae63235eb07 357664331636e3f4b09ee201a17e34ccd5582f8f3b8df30f5549924dc371a102 632f725e288d57ec6f8ed5ad5cd3d616e2da3c451d83e1d0ca258b9a2298dbf1 0df61ac68f4a544650e37e32cdc0ddd572275c4a6d812f46331e43e2aeaec497 1d22f1f19e7e422213c46ab25c50dd955a0973eb8a5fb0d1ea57d5204c19347f d1faec0cff1233feadac8352608f19e2b15c460df409698636f9a32212a1ad73 8cf9ee53656f63cf521f5153bea1666b76a1482cc30adeb5064c9bb4ccfef7d9 5d73cbd0880fd6341cee16320bc01147daeec328d80f828878ef9acfa366b3a6 ba5e33ebed89e640a9f2edbdd0b11a49a03080e1fe976cb8fcf1a207d1894e88 f5b200886f5fed9e44b06eefaad0b4e8fea0ddb6daed5183d761644ea8c8e6b9 4cea1cc77c99cf37377dfaf7de1917d4ea440f963337c59cc5dfbffb03c40967 e8731dc00c1a24783c78d23a775efa3c2a7b8cd38b1598026e38f919f0f0b87d 3f49e190415324a6eb3d15b9719dd5ba7ceb93d678de149ffa6f9c3a1eed2d68 113afa195e3e6cfe79266bae832c3d86980069d32d1b82e4278a5fa75fb50eaf 419314fb75f9515bdb01397df874ae89596f21b39e7e75682f4b7b2f98624214 4ed89a3ca36e43545f9d064d960cd342c87bc2848b39c354e2da95650ce149fc 09e62b60ce2d26faff550f05be51fe377b523138fc608b8ada091497bc303a67 16c40d8a6edd7ca63ffd97f2e487543c0a68a8956a00186317485861aeb029d6 b3a4619a48ca138c90fac43232efc3375f990b46f975cabe26fe3ad6fb30e055 0751c0a6600c16201cdeb614063bb73115c5ae9187e662b580d715da9e9f73b6 fd8676e8cba754a2fc01475064e943e5d93b2b7a945bf2cf6e752c9a81369c73 545ec777a15f8e1cf3fff0f7fc7af6fda45654b0197049a78eb4432e4b73d972 434bda12c2e417d37df5ddd723f4ca400e499f57d972310f2bf0ae2e58704988 e0dc8ce7f1ce47cdac2da58c884c88edcb9d6636513558e9b7d3744c4b89c9c5 b1cbf701c2a1fd7c2d400f3210a4b7a3bc8187a8884bb87356fd3e0764d5fbd0 1d2e83d004a80dc22f9adcce778127c75de0d6e80e121cefe4cac0992bee6aad 42aecc6c3d4ca380696d7ad71121e1b7f7883943faf32402ac1add6432edd093 790b2b994c490868179f083614975f9b5c674ded71de2f0397f56f9a39b0e336 74d30e4127b22481d9ffbb989888b270fcd98c39cc7e0dd5c955df0af1fab0c1 666cda49806671b8e52da7ad3f4dd408e1e7748b9703e26bfce7c5a9e5a61cc6 2f81b2abb8a2c888636736162519b1577296a4d2371cf64dff5d67464d9ef080 4e1eeff6de6f9bebdecfcdb529361c4a91e7cee288d0cf64e6d9dda213233db3 b9086150998f58b64f3f6a7e6e4071cd3bf155bc8815a63057748e5b08a6dd3d 18e1351afebd7a5e708c9257aa2817d9ced565887865e83080db3e3d546b5e7e 988f944090ffbf57cccde2142c953680564f2a7b7fd8387b0645a5cb32be356d ba0e0a9ac0333191ac10420bd406e458aae8a5648b6f1f0d87f13d834934fd3c f37a6bc5a7c39e6a21293e154c67fb74d45ef6f66f02dcd2b9261c894b71c8ae f7c8e9e1f38bf6f1250029e63ab8c8352f44373063de3dd0b3ab4b34917c18c5 e18bd218dbe459a832d511aa2676a0f2824e61a2408ea17c7028d2b5103101f7 d701798ad50b06f0d64de613f8b1f97dde0d1d9784004b9137ba93ffc5a0b9a0 0dffe4ae094b95758543d18fe1fec3464acaa5d765123c6852471d0453e8ac24 971849e7b5fa5afbbca7f7b8cee26ed3e479c1cee8bc1a92e7357c4c340172a0 663e186f23b74806bb0287c5d36b27f38dbc2674d79275e96eacae4d11905f26 1842d798602da40368ace7eabc3276c2e8c8e84d3fd93ad6ee99ff11511d59f2 c82a9be6796af2453b3cfcf4cd174bdb8b8e197bccb169d0d98d9c5e6a071deb aa83a14347fb678aa6ba41c80ad7d01ded3550a50bcb4298602b1a18cc3103cd d3864fc47ae91de6fe57bd05f9512e6437346cdb42942e654596b9d94b462efd 60a83808c7c5fea7c91797f76c4c701bafed2eca741030fc201c4ee36689b934 35954c564986491a4fe27d85092ab85e5e668ca0b72ea20df121c63ad7fdb2b1 e2af6a814b84a2cfe3ebc96ee45e3f5d3ffc6febe90d6f4a04554024bf8044f3 d59b064d64f934a61819f41d5d881e7426450ff24865f0dd0d1a9ffce9675e41 b81f94ba994eb4848109e1bde452a9462e6d3fa2619197aa944de4a8a0e7a91e d1c2fd8e02055dc5794e92612863c7b08928a9a8343d0d0d81877421d648da3a 87646bcc369c6cf8529f10957ac3a5ef30dbd9f68552a0b6f511d8538b60e212 c700f0a1778a96d644b951e82273f989a970816a397598759c524ea37c8c3676 0fa1d2a2acea304218cbbbd30c7a516ff4d943b80a023d54b30c8e32fbc18890 6ee3ac77b326e09c6a3d107c2f0c14b098a4bf0d2fda1a6d27a1ea36f913c3cd b511e3f1f1514aedca9f82b450ee6da478cbf981283f9fe6eeaced50b4e2322b 5ce703b93a43a0827bc78ce0f730a3932514632b46597fd27a12582cefd8f0c6 b973db5ca93c5213445d03e0aab73d44976b2f38f93a66068f9d79b58f46582b 94f63a035a4af439918e6f045bcd631566f7e0b53d668d7f2dea963ffa9bbd95 87dd188376a2a1becca2ec64f2676a0a0266cef87e8d201ced87c35493f0ebbd 58763f32bb6ccfe5f3c61bf5867b998984a0bd56f211a6f3e46f3eea174d3365 cd83ae7ab10005a86cd4b03e1a241ea3d04e2ccc8d1ad2faf9b2438309ded3d1 142fd82e1d19db62f64c45483fe51e2e6f1aeb2d9f2f0a23d97c23ef4e45eba6 2a6ec642a9677fa429d1a4524e846211079ecb2148ad897cc6fb82b9e7e3f8a0 4c13c5177a0308ed1606a24f8f10abd92d7e53059936756bcb7bd328f98cad1e 6768e92bbadcec64feb07e1c65400edf68e3b9e1a3f755faeebca903c1c30939 8be9eeb27bbdfc5f3282818306b78f9647769c8aa78f4b022be62d0b4a2c4901 2671e1874130dd8284becf27dd8fa4af8159b63ab16033fc3d5b0d13eda62a5b 872530768bb320e7ae3da9b71d19f21bf99a47d0df151d9441f71c9795845ce5 d55a0e5d3a9d56127879a2d943b6d757275f4908d445f799fe8952cf11b359de ca0ca994162394fead958b5d5e913768c5c57b0277ef2833c7d1bab4816a00ac 443b470f8d69b139497d01d30f60d88690519efb4d42940d65bff86be714b79a 59906ba1de2abcb1086485a3a7333efc082e4309bdfd59a9be05408f85584bfe c6b2e5b32d57ea11c6459be5965fdbf37bc16e62ebb892451c8180a9fe46c2c5 247ddbd8dd34daabd9e0a869468d06ddfee4e9ca4e301eb1ca51bb8fb5e6bb71 5240e6436a56320a3375ed877ad10b77cd02901da06965be172577cf408357bf 7f25cc1338c3dd6053fc3a33363bc79bafb95489c4cd62630b3be1df7c8aee4b ab5a21f81c7fc4af10ce1eaa84481e49b81817e532c8df53ee33be763317c052 da5b6db2e47711543ab4c3c5d71519728a8e29d17ca06147d6c665ec594ff9ae 8a48dea7a4fdfaa118da6c417228a460af3be80454b5a6f5758ac793f1fb1ff5 be5433a36244c7a3ed53690e6f8c2295434402337a34d1401a997705612b5578 2a3366962d7fd65c3d3cfe842f6f659aa548bd27e3e40a3d9285c86c831bac3c 92cbd2f85e90e5f78d6ac64f87ef730939962d4d9e3c2db976e31ccc7a7a553a cf7b9c422be7d268ed7b8596fcb971d838ba05855ccb100acbb07fef00123e52 611f3c3166d306375a5408ab3122bed0bebc9a7ef8c76f48a442a19b71f0fbbd 05018146adf6f4d96636729f82db2c821628b4cd0d29b8a9bccfc04b9ee0ee3c 76f09916d789dd1cdfa8437daa5193ceaad30039979fbdc49fec3eea44409377 a672e637d450056d3b6b1a7dee47651de63f87e51202779e990d541ded44a259 ad0faa367ea38efaadfa2f84bb0f8cad9e93919851d5a69858df10ed19b31e28 ddd21299cb63cde6f61c1a6591a623341a422692ad812e441302e02b3e76b638 80fbaf7ba9178b5b9adea7f6bb12d0b0f77eb39e7c26a1031fb9c32f05353928 7ee23a6fd69ce52f78ecd64c48dc98b9fa4c0c9590ece601ad9a1f5049a5e1e4 b565511dae423183937515217c79a629694ca5c88e7e82243cd29669d196ba3f 54f0e958fd5484b65c53742a78658b987c19503fd7ffa31233c23c6f33209121 5112cdadd3cadfc43637400729cad247c7a619e36775df7598c5edd841209936 8c38ed90d0a615c8fb50707cd7e26faa2a9a70b6820093843bbcd1b6b97bdceb df4e28d2042b988f84f8efefcd2497bde9d6ccacd4225fd3d59f05c66fc78d75 97280a601512c5f2e082a6f36e54f41cf82102277d51db9a4d575cb2d2903129 74ccc9f17d227652003edbbcb61ac71f969101ecdf69ab307ccbc7d6bce1c624 3654d211fcc407144dda3384b2bf110ef0adc89ecdeff01360122b188ff4b628 f6180b4078988a1a46d60440074ca4f0e64faf66781938f71561f2c14438e0ef 55e94df9caf31aed29bc71ebcceaf3425be641d3d310e63a0a0df3f55649389f 0bbbd3083cd4eb8c610b73ba13b118f18e049a5ce1b982b3a95808f9a97f212e 17bd1a6b42a30f6e7723309a6ecee538bb721a6dd88e19f9ded503e85623ab92 5312a7f5f7732d9c14c9b2453563d5437999219e50a8bb1a42fd59dc09a9a858 8758375884ba530e0741f0f5779ae9603c35a466f29d92846db2e463fe2509de 299e01554dc903e926078507abcb46810a84f5848692d02f941018fc7906ae83 8cc8619a0869dc06add8000e240e14741b9551beaed0cea0f18032914b9fe0b2 9b97c5c683a2de0b03ab0445138f8599251326e8cb7c4f32dca76dfaf7922288 9fb88f4e9a2ec7994eccb3dfa6d825e97c4880351f02a9c4542f93162bf36204 ffbf35dc556453fb8906e02dd87ae32bf30b17b7ba4738f9bac7d1cfa27016d9 fb902aaac54fc93e3b6edc64d6149297d49e5f6fc449ba43e7b08564cfe45bd9 bce0e7d134a64b05352872ee3baa3e942eb06270513ec71da9450e166d59ec07 7c3ca1fd318c2baea063c73042747afe00ef7681d5d2ce23f58851af40503d60 12f8a863e109504ccc59518c2dbb072052ca33df9b4347fe801b95eb532e092b deb564b75cfa9f4aa1a00615a9dd55e24d4b3cdfee6228f0069059ac5f7b31cf 44eaa8c0499f2403189df29d36782b905cdb28dae267a7a124ff6668df0104e4 3e9e455a3d699cbfff0cf9b3a69faf612755691fe03a09aadda728fd540a3dff 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 false +check_ring_signature a13ca2ba0538621ab08fe8947d8ea614dcbbcf738666eff80d2e92e0772ce79a 7d21fbeede1ec81fe0c012f86497de11d17a07d962c649b934416be2e3eca19f 8 914f44b6fce6df64b9eabf794f85c7f95492ee11289db749bb88a2dff56639db 756f52262fbdd1456d917bc8b60163e1c874101e9e4688afde155584140e7ad8 fb11345278a3986146291a2df6052a0461525911b391a206dfd2d081fa6cb65c 238aa5b011d0ca6197a4677940a343ce4c70ed882cced15f95c6d6e41a5a32a0 fa3125a5768a5788350e10431a84a7a46e55fad0fbe1aa98dd9b9d299bf394c6 19899c784ed69659d2fd0366467e5a0e05a41e68b78198faf1489b921ef50673 df13262a687f210630b3619680c77172a23f268687cc1980a04d2877f2467317 4edf47b663d61fdfac74b01749f580aa2340619a1ec1333ae1cb2d28d8083de5 9c93fd33427b97bdd63678be72aa176a27e99d425856b9ba4fd8b8d76867ed0269e19671d9cd17176bfd25c4eac1a434f71ca0441a63478e600a8fa554468c05e490168bf030404d9689f85363c3092d041bcbefb51b6239981882891be1d40c67075c0c6dc4c0347220c77af60191126b605e30ef695a7cb2d397535606270912fe8a9ee4e7bceb79ba82f2bd2c3395d0a40ddf31dc8b3840fac3eba7ce3b0dd0ddc6dcf80f035556e2b456cc8d1afc52c3ac93c1a4d4fff995d69695fc700bd0d3d7e64e94be945a95806fc67b02b5ab274bd26c6c7460eb8650a9a65a0905cae043a2859ec34dfd68a680ae37e35d946df867e52cd1ac38fe62632d8d9301eed5408cacb8dcf8062222922deb7c56752b3519c967f51cff0361c563649709dfb085fcc4b488dd703de468905896f8a7f37a7b9a2501f99993234c8875c10afdaa6cb85945364fe50ec34106d0ec7918e7f3c8da1a63ee0962f9ccc40c7104698746fd9214c09c3f2a704e51d1255a46a52c7093d3a34aa2158c9760e79c09816308a736e2c91f3086d3978463dfd06b9efc21845745172ab6f10eb1eff30cff0cde3e7b846b873ceb4f76a88a456e8d42e614b7adbda4c7e6ec2c61a12109b9b2f91ff3d43293a76a62d40dcff1ea88d110c96d00f27a6bf709187e17490c2cf8bbf8330aa0e556cc8414cbec200ea0d1ef80b3d4e14dd08c26a3b553b90d true +check_ring_signature c98ef1ef21a48414f985b6ce150f538fc0d9c6dcd0b6408cc4b8566adfe7ad4d 696bb839f576237b0ee5c7213115478c77d104d9f72b229baf1a3a4954146c25 77 174144d2e13cdcaa9ed1a39c5c62ad432008d4e4f9b2b35dbdebac9124e776a7 1d9a42a2d17cae43c4f9272a03b2847ac42b2f63703f94f69ed2f6028ca14fa0 4ac64efd0ccd5fd4c310cf9d8f949b16b44fcd3edf704c59137390d04f3c8e7f c8b2db867af423918f8caf8794bb1753805844f0b5547f859d31aa2b4da394c9 b3faf88c6174a7d9beba52d624a4e800fc558e16823855a957f6a0509187271f 8ff91f126dda6fde0b1a2219397d4ff7f3d3133d120ff71938e9aea84439b772 24df288a6f57f35c09f79e6201abfdeb0a2b2e350066895494dc64ef9b3f53d5 5cd0bbad8c4c94d4d7591bdcd46893ed451345f9dc3e03578669f69e17739972 dcb4502d8612d44b08573f31abf16e099de13d348df35d56f190bc173b14d76d 0d0e0e8fd3f4a517d311677928acbf332c047777756c87f02652b0c20fb077fa 01a5569ef1b3620580324f809226a43f58501bcf2537dfdc69db4e34f134110f 554c679d487fdf9d102c50227b24430302fd5b6c3278618b194c4990f0495e4c 0e631c3c22743680f96c29dd821d0c59d4ba5afe4097dad1cdd805d838aa2fe6 feb46718840b28649f0e0af3fe1098172f4b6091aff94ca270cd95a209f3613e 28bfc1849bc6c8a066ae2dc643fb5f68dfb75fc4fdcadefbe05e9b29ac771f22 209592a5b7242ad5a46b2557328b36c58815e8e4f0c275ba6aa9be7286482fde 6544df432b847e772e4d3acb33380aaf348f4bc3d9d581be843ef08944f94b1c 9b919039594d312e4c8277ac788a79f44d432f11eabe0a057df221efd504c4c9 5b179e90b5adac68ad128e2dfc688dda7bbb4ab4d7a9b370f74d568b0edfe0c1 00d839e6b1e6817f50c54793df90c5909e7bcabf268212af5da646d3e8ee48a5 ff550020371752890cb997e7a99fa60f17accf4d49f7b610131b05420121e205 705cd8ab69ab1b88a356e45b73b07ddeabd1a3f867efc3cdbc9d06d002508466 43b7cf3c7c2eab384dadf9258b105bcb88f4f64ec6d77df922e1a6160e0b2173 5af478d4e4620a305189b6c97136c2d798883bb10e140a957a47ed7e3aa990bc c9959225c416ae5f6016794ddacfa604d084615fe6dc2ce49357e92b25c0848e 179c0ea6669c78ad5511e6824ca471695d514b7717f87afde8b771a2b5dd7186 771790eade1442d61bae067b26a937bfab6b18a7e58f97f7a24676d7e6bde58d 42613ef66c464c93d645485bffa1a1de38b57ba77f302f06f13d2894fca8e41c b590315beb50c6b6d64361f10a2837acb7e944f9bfab56d0cd274d8aef1cf4a8 711449ea8e8536bbe43177fa8db9a2a97ee3ae99654c8626a0d05e3cdf1bb31f 247e3bf95fc4ba59a92fd0010c7e89df4c7cc9ea96949027e89e4a57bc6ad102 abd358adc41c5589e0fd4ea06a08dc879328b25adb9b97be1c029437c99d61fa 5b572850ee51ca14e8a36423f2ebed8ae4d0444fa6ce4652b9ba3ea2735038a5 9acd385e461fb7010e19341c78a741ab18e7c14aa813ad5156bb650417193189 f144b4db8884c9f028e787078df4232702f73e20514acea8499001b7ce7f6f6c 05647cf5334ebe15d5aca86bdb0af5ac0a25263e7e673ec012b3fe6c99fac92b 0805fe5ac222a8b34939ab3865483518dddab45498460e025be8d22ff9063678 636045ab6c223aca087066f441c2f8a00a5e54dd18d963adf9cefb943ef2d5b3 52d15b033786c93825b7caae205079c2bc02e7b57c64a255b2bfed646d78ccc5 006db202cb4ad57c340b687df350343db14f147811fdd5432cbb3f0719329d99 6946877a707533ceae915714522dfed00dbe59c1fc3b52eeae4aee2e1bc3cfd6 990da17547047889d9a7c4f91f6c5673996bcd9e86abdfe60e042eddf80caadf 1278d02941f5664442a0335fd363e0ea5d9d65eddc42c95e8c9be172443c485b 64f3cf216d30bdba10bf43e33b47b487e1db83ea48a0cc6986ef7732bda43f03 fdf1970d7d8f95e941ae87e6dffbf4d3178277d19144190483c44b779b2cabbc 1ed1f21e5991d1d2cefbb9ccce1c742ccdb603d7917859acf0d6798df3f03e0f 24be770bc8fdb0151ba92d7dd921d20491b05d4f88f4569526af324dd74a404b f6c84522fbf5cae78c89b4144db680dafdfec693e441e8b4dac8397210855fb9 86f00c16f0c94c2514a41d39d3bb02fe19a3b0eb7811ff79b0e12644e384e8a0 e0ab1a9dc48646af03c1c488b53bd8aae52fc4ffde28b732963c4065e299be2f a0fac10c6c6dab47fbfa46d182d09870fb1457475b0a071b137d9c738ea73bf5 16eca91a7b9a416fb4143998d90eb1579a6c34baf22e1dcc7be519e7d5d054e7 5be15940cb9eb51eadf55c3d80241157bbc5d76d301772031bf6e3e0f9062d5e 6dafb56d753434bd76a5116357494556cc90e32443d252be68163e552e023cf8 acebfe51431a1b1ea13bdc132c4df1f7d247fad69b384fdc81bea75627beca6e 24fe3d94e2eef96038e42bfffbc90d681f306e857002e1d442fe51cf527eb0ca 43e9a139e162a03688c5f8a0e2010d0be6bc70389519e7bbc4f8d7f5f5778a39 39de2934ff524aa3447e86976474688aa2fb3c044a55145f4e02347e9a8a85db c368422c27e99149cbdb5ab236954b30ee5cd8cb18100c09a872e13bc8951416 eccb926091e4ef11024a6f82cdf89a0ddd52c9dc1eb139e14a950c55c4f93646 d11705362bfea2c19d6d878f516f88c92bec9c17c813f3c3178448486e2cffa8 66c30d0f6e8c70c3019857dfe7e4a203e819943eeff3e615706510fb4c625721 831d8c5430decb6ca8f8a827995ec447e3a7a7c042d9dee9ebd2e5e43c1a5e6a c910532ea50b130af3e939c8ca9be7fd51cc57c28447387160e049f3eafd9fa8 302a41d8147f4970c588c2a9104b26f09eaab0fcdf934ca7d8eb84c5f1a1313b f173360f0b2176fb1cb7d28642d63093a7dc61f28df49ab883a753659117cd59 fd151ded7639a95d15094d34263fbfc47055c2564a7fa3b911dfcb112e797fb7 f56781f30593aeb84190438870b43ebce34f8922f5ab30437917d06e98a8dfef e7bbec1457dcf9dcfc5a031459fb48fe8dbafe182749fa3aa68d93c1b252c8e6 a7712d2fa423b4849fc8d9917c427b67c0bc8529cd24351b8834a8837287ed47 463784ac8cd7f1cc1383679965a1888b46006472b5feeba90825e6bf7f49f1f2 b8760ef9e718024d78b1ab52860c0b56b8a02aa3ed60004803847db0ad930173 6c718d0c8ed5e5d24adba50897590a9ff5683be41ac78ffde1a6c301e588a0a9 dd82dbb8e1c7ab2baa02bff7396df81a9b9614a9d4bdb4bb14b138e9d9dfe5af 48cc19784faf7ef22eadcf428290eacfde0485e8619a302c295935d70f27d970 fd777ca1aafe9367e22bd9df1b71efdd6b9de2d804a4b987798824900bbe6893 289bf62cea9911e1e5ebec24294b32be2fa808d413cf0e03b0c3b6da9b26dae1 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 true +check_ring_signature c9e936fbcb6f9d03ee6ef18ca239fbfc24529aeb5f726ed115332bcd23ddfbb1 6acc8619f8116ebf026e1a6c8e7bb23bdecda856e2067124d31cfe8cf1df7c94 6 4d1ee5c173327b207b33f1b228717e104c49764583c9a30aab86c66d66b8f198 502b45a7eadf53e4ef48419ea95f391287b18566ec992dce56a2eed9688941bd 8e49f27795f3cf4f34073fcabe9cd1fd9ab4eff6673199471c5e3dbc0bbf9be9 9bbbf2c97c5195807d178459e87e86400a8fe5529a765f19f5ced0702d28116a 5c1987b07fc49c2042fd2d03e226ba9223f4a2a6983ea3e995f566e36220a47a 8f4b99cf871f449ea14228d9c13c4f31bba06fb447f991ac93c33d10088eccc2 8cb885d425c965710d2601f533202272159c4de864d4702bfabd75d66d03a002ea50be67774e3d71bf646ef2855c99f9189b054aafdec7a27a2427ab7c89350ae61f8f70b1942967c11ffd34e37111a84f5b819187a8b6c5d76da207de1ad906d28f632008986f5937b68530805358c973b126bac97261edf1addbc583edfd04679f51ce1bac9cab19967b38aa5bb0f2ac7c95579cb8026cf136058b54595803cb24b6bfe12f6fb3f496488bb9a2ffb2035dabbacad725f6a3c66ced8ebe3c09858a5523d8ea9903fdeec1549c33bc4d3f24b28895c632ed657a1754f10b090b6e6fbcd893685f3315e2eeb56004efa9272de12de2465092a0073c33899f010d0304388f301cccf2819fd67f1592db9cb070879a819c38ed77747e068ad51608d7cecb4bf47820d70c8fc016516cffa49ef23751d09b6a30ef5850bc7ca82b05103c3b01d4f4548cdba917703b3e1220e19d99253379e461abf18f4bb6557f0c5d975da70ebf9cb51778a065f6507f485faf14f3e5829f8a5c4525aa454ab40d false +check_ring_signature efa8728b4c73495803a2f40d8b2a90b775294ccad6f2ffe994c885ef91da190c a03e7861558bf20876cc05c633b32a279a44265f946d4518b376f1c4be526b7d 4 570fd537410c3bb1256a8636e3170ce6f05d50f639932c8bb9c93b9219ea892b 9e789bc9c46e20e58f22a8609b85256e05bece4e477511b535386f36339f6d90 9b33304cfc3181f743501c802bbef98cd0892d71c3aace9dfa0fc8895a7ac29b ebab5c88b00b183cdbb2d6d2e49e2d4c3bcab555860ae7e781e554e9d97ba4db c79e70a3a08e500ce3c13565c68abf26f416d6b832f830be9a0ee031f73c04083d3b33bc7e6b0d0ca6a0947f9520ff2072a9f5c17ce9aa5d6150bf3717c4d10f0e7f79c87e34937d24b2ea3baa1637462cd08f4a9cafda894a65c37772986d0da6add5d4a1ec6c7cee1bf2385d8d5cb8b36bd556520b92f7d6dbbc08bc4efa08092137e04b7e1278d64b4cb48111f0aa88d927bd68528ee495d41e81f575c70918dd9888c0a34d9fee02346db72913306a0acfcc8b255c2421aa6cb9b0988709408d69bc7ff7dd4700a5b34412c32b42bda5e3ceb769c38634d49ac32ab79a099c1ec0ead5f9502506683cf023ea0f7030c7ea247fded00826735bdab5ada20f false +check_ring_signature 7ef2a188cd6823b1d06083edff156c95671b3c99e4f96385f2c05a1e4f370657 7875c64fa57cbcb3ad6df531758ddacc83be916dab4580f2b2a635d409302d16 7 952d98b8413109d7ed04611ccfe0e1ca1c5a75f2d7ed621455698539f23fcc9b b3478964129d268251e5f2030a24afbf36594e165fd7a50838037ba2a0f84266 a04f952225ff31d2a31cc290d9602c33eb832823445ffa49f00c5cfccbbfd24f 8ab562f710538aa90b0477ae14bf01c41644f4af42f8b076d660b9c74d4b60e7 1592ef92643c9407a6168874570d60fef92f082db40dbdc5d240b994805b0c3d e3e28e3f949d1b65f27e57aeefadee893cd8a59b455be7de06ab8e1b2a3732a0 9b8e9d4ae630ce738d3941487937d2988b028ee03915bc6563a48778038068a8 d8bd424b457c43e7e24bfb5b20e37f94c558b0557d9965dbeb4e9be6ed8ca00b8f6c6950e0bae4374c87fcda40588d597c05ed2955cec38c2e03bdeac2dc3100ce4674ba26e234d6fd6f6be833b89785178aff8485b07cc8cd826dc9e8f0a50cfab96bcd203bb749a091d33c2a9d590a3cb1a94e48dabf27cc269ea773e7860da4efea6c1ada07670dcd2da63038f894e89d531cc0fa324bc3ab6e470256bb0baadee0ba39c49d2fedf5948629b4f28d74acbe603d26ceaacb1900491fc4750ee88e5a3094660fe4ee6db0e5b928dc82688e121a3fcbc968bd1a3a3cdec45200241500d50c52382131ccf211d8a8a801b845d0e5eda50c3288e62523ecbf300152063c1a0578eaaead8a0243bd970a57fb41dcf2eb77d13354f3154826bcfc059cc96528fff4f386fc0975755c86e1f56a37ab1a65a6d3ee99ad0394f9980b0dfd6df6ebb1f66017d253190b69cf87f853f2e688b425287fd720538b1ba9300fa3ba6897b828e8a97ba231152ac646c7b59515ae67ca1cd9687fab07fb4c2906caf074b8e8705ef727cbaf15e63a21a0689ad8f4608d99bd0cafbc5616e34b0f00ae7d5e8337326e5ec44e9201c598120c7d9eab6df7bf51990a2fb62a204a04 true +check_ring_signature e6813b49a9d6d091116bd4f13805684e651c5e573057eebd40e67738fe8b4048 d4d717b28d98217475f67e6306cfa308207c4f8b71ac0c2f9c357358082f7a29 1 c0ee3b0d4956dd9da9a2aed06674d495e9146ccba672c0aec7bfb0acec4af310 46d82373cd414e936b09a9d873006bae984f6d79c6d1fe6502e16e33397658069baa5a1addf0bce08d3b6d4f803db65608fabfa7774ef94195fcc60cdadff009 true +check_ring_signature 451780677468c41b8a80ac6816f4938d320c474118ba2f45bbb8a30b47438715 51fdc6cd99e5e4693dca3fea1142938e2905a6c355e586f21549b8479226f363 14 b0350c313b55ff48747e630975836da50913a5778bb21db591e83d3181cea3b4 d582c06533c625e5c5ef46fa6c018701c9f1e6cfcf49bf77a40d8055821d0a69 8c1441ec0e1b9d932ae947d1428013a7016bc8400a15beabbe5909178c07a403 e9176716be7db4e0fe0f32f1502a13e1e8238e44dc58ec854e8457a665219213 1290707034eab3f998dff43d150f5f8e6482852555ba524690173ce6a566a145 58a569564b43e98500392c0d156a0a510ac54af060e4673e912018f36bc36aa0 b6cae06c8e1052a0f6341a1e1fcabd85a6d387151f8b5c886396c73a3b1f9694 082fd0a0f2e33ff0630f398c0519206410906b0c3a9dff5f10adc25d21bf0e81 a8ce052e31be16eb4d062737765b6773951a4fd98b4b999231a55a4ffc8eae05 957c35d8f2b1a6aab066757737551ad98164cda3ac6a1f8e07c2549a13decd33 ea3c7fefa84cb7ca698cadd1542f1a274d51cdb00d9cb5445c82245feea0ce5b f1274643cb0a9f92f8633443d6087bd23ea3fdedf0b0f5edd461cda013a6582a 835763cec46f5e17fae8af7b0bde98ef86a1acfbdf8ef27d25b5c4e5ef33a8d1 dfcc47b6a908bd0d4261545b1a9bbee32774f8dde8a79a93621582e1f5fb3109 dc27e3e72aee55048ba49c63a8724b194c98ac116ce8639352b36879f3b02b0a317a1ffa59d7aabab262364d066cefebaf41c550c80c527d1ffa2f53268aee03021520270d2fad0f9863d4e42be4998c6d035b4f879eeb5cb0c487e08c3c8204616e4ef127c42d1723d8ec09d5f727864b25d9aed7cc7f87ae68c0bf3427df00a8a5ea2a7044ed8dfafcb493f9204c4178cf57660eb4af678ed70ea27cfa1704bdd8fbc37089a4465eab2d0eb6d2b3e49e4984530cfffa72d2226426a86c560857c490ee47296c5a10add9474b634f190c32117dfc04cb02e4825df60b4a55080c765ab63d86b777143c16015212e7f92ae1e6526f5ef4b1908e3414f614310752f687680b799043e99ddeb4a164ef69d424b6c60ab7c777922a144f3218270e1e3717b3cf8740f03e9c64f01ace67da70b35e47e8212d534675019d1e2859083df76a9f4f1bfdce48e6ca5d3ab17c08382c2388a8528b934c34213f6749a907772e714c85252b99b99c22e7c3d26b674ce996a8b6e9a63e2b261b7f0f03ae005ba9f1df329dfee7b00fcb7eccc90d418445af8f8caad4eca32b19b0ca7ec7062426017bfed670b888a626bf4e6dba5df8dae272d5a8d5c03e0942a19d1b0407780c9b20ba7125e53afe4c8d237fd397720b6c85e109bc8c17c22fec2741980cd375c96dfc3aadb7f7864d1a1887d29d8c5cdceddeb84c5d9ee16b5cb7dae6051964fdcc702c12949b54add8eec67f93a195b31eda2ad406930504be5bac6e0d827dfbf2c99b14646ceb0c5b2804fe8263984d726c64a56e01b62a1eaad89b0f28db0f14c01e2c63ae48d287235414ae9413264c1cfce9d650b91c1e9ff21607dfb014f2d756b16348a2d114e623072fcf3c0ad1b9a2eef391d54d20de6342017542c97cf868ebcf68cbb74916f5dffc9200e587be1f951c3006ad79b70ed80897090fbde36554e5e9b948b18bee971141d1d32f963057f3db663d0497a78e00f28c0ba94fad149d71e463655acba33519730d24f9602d168e23b201fd74db0cd0ead9fdfceab47458c77053888f9be064d641396e9f0ce5397c9109673e6b03a9f0e913d6ca62b861cf19266c7fbb112bd1a2a0d278fdf2ad75d06c40b0d94c33d837cb5955c93f3e7c433490fece75af51b324ea54c3925ab2d18aed9fd00f68bfc32b32ecc775b08aa2f2719b2e495cfdc74c10db2e6876bc240a6d927d0fa01737a04a136212c3aa4f5fd077a3b1d4bf87c8744a8338df792e4e4e772e02 false +check_ring_signature 58b0ae0a424c8295154f09c35fdb205df4dedfa6bc2fa62e95932218091e0ef5 c44087b9415ef5e814b8a1ea0016735649c6490f68fc7c97cf372116208c7d06 6 743fc97a477485918a496aef17a91547a069ccce584b96143152c178b812d319 3fb3cc31bdebd54fd8726044b77dfbc3bb80e9d0894b6f8c76b7f07f7b0a4522 6821b583b38c9ad4f8a4e462a17db36f5036c581c15e496f70b4475d7fbac3b0 e5c06e3d523c2f14719f8a2bf8a8c31aa05dd032c4ee10233c17b3271b4aa856 64c9d73cfb634f00e9f680328faf6f88f8162187bc45119589089dcda6a657e2 0a72326308e742a235afa3d3cf5eea6d11975b7c49af90f3ca6c97c0c59696df 8b0d586caed0f52a712c84edcb5f9574a264c0898e5ccd5e511ae629a5876b07c638166b8e2e437cf3cc7315da7b95b9561391a3c70391089904be9110ca970e0603998cd87c70fa0b1b407ddce2e4fa85d89d5e1a651f042f59d00e342dbd0da7513af2a7f194edfdac2adf246633ebf76d1fe0a7f4cf731de5637b2e0c16060ecdb60e516b94c14209119774df5c8b7a430e5557fc32f895d70a3e288e7f06250dbacf140d6e916df674d3664c7acbcd8d701da88525a80587f964aab57c3230cb73aa3deca98378c473fd069910c7e573603bf5263cb34e12b5d93d952c0b4f159ae2a004c7eb04dd13e23240316a31e5bfa62d2e4780e05e6e2361e4220a6986c975e44d75e80cb78f18877d7442108c322360359a2371e96e51d247f30d7a5892b8c813aa4f667d9e15b6bde3acd924017a6c83f62f7c64b0de0ee23709f3970c408122423ddc3ad25d1fbd0fa61c8094abbb20dea6d22336b87810fa0865c6ffee4390f2632323f20093dcb8049b9cd71c928204519164b49509fdb302 false +check_ring_signature f6f45a216dd65427bb171207776c8fd1e2073896bc7b4e753e9f3b46e46281f2 10027958980d3c12e52179ff6b42d06971768640a977a000ab747fc9e1222aa0 6 f9693aefa1ff7f631bc00dfbad50acd2bcc72810af6cdcde39f65fa531483f02 b3a2d78546628ef799823f3ebca4db8667f80508a2583c78527e40dbedc5ad28 cd3b704b997110b32b88b82fc411fee76a756a4c198b021842354bc1baa3301b 49ec9cb0c0d3b2b81c31cc89a017e561e73027a1de650a144ac1833e8f8cf32c 0a30ba714c30b85081d9916f23b0e306bed6fb1f4e7d3e23813da310a7d47578 8bc12be09b5e38376ed51fb34470ba58421cebe312fae36229ff3c0a664bf124 2644a3d56dafd4e4bb5f9ff8849ade6c563e1c2884038416c43c751c84017203c3885fc58a6c6e50963252261912586e4e6f0676df9e7c53ccdd723b0597610af4a97efab9097ff92023eb15473c0b1b3a74479973c05d6db79e927ad93e9700ab4f45461707138339d5075348cb6f7711a920c165339f0f1c0d1fe64859a10a4db32e3156189651095fbcf48c18dea419b4e710d5f6ce93b91d7d1fdbd0b50556bd2bd860b6835e2c83646031e36ec4c639d6b05f2f9d6ff2acda83d502b20ab3263032f54819af0dd1ca5d78744cabe8fcca947dddc86c551eb1fdbc72670d860e080468688a501e611ebe0cb5df725ce64610c7e62b19e1a916777c90040fc535f6e50a0823900466a02402eeb8ee4252daceb52b0a89656daaa74bc1d70bcb800af38740eaa6a7f5243e1f7598687c1b9c913366d779071e0836ead1220600247034c91013af3d5c8985323fe86f47a2802ad90f96d59c903b4958184b0f6c4fabcba225c27a78bcb19816c12569c7749c9bdd960d19e50c1900fdd42702 false +check_ring_signature 3846a6712e12b6f30679c60d2817ec5df21594e6554291ea2ff089b624480c3f 9a066b15c88157165710b97501f5fb5b3a82787d71492801041d26211d643489 2 f22660cc480d6225be531c7e5d80fe35447d4fec02db657fa527073bc99651e8 55d7cefaee5b8b478aba01d718a8888eccbe572e03fd41703644b782fcd7a40f 8dc56fa3176a5d9afa0d322b93a81af1ac92859cb09dfa29f566edb588c2a80682b442e67a42b43d8e3c0589f73309c998973c77c641c2380dafaf0d321e1405fe26b9dea33a740cb996bc759d6342c2c303687a6b9377c20c13602625eff40189fd081307dc6009ddaf235d44a56be1ba7503dbe54f78eedcecc4f6ca71f90d true +check_ring_signature 88538e08ae78deca19d24cb3192eba32d20fa5d5f013550eb7a532178514bed8 92ffd5f03642ebf7dc4fbf0f22c862a2b46a7e038539d1a78f3ad16f83d79a43 2 264eb1a6aaa73498e1c01b9bd79fa030fe57a99e9c9dc2c4c59515d85e7ff139 d3930ec1b42e38386a07a2d7ed83a9c94e740bc44a4a5f65199aff96a3cd76c6 f2605f4500af31c6b675f23341566495638bf2802bb5130439766628f0ce2d0a30b5d858eea77e416aac7e95e97fef65fcd7c0301eafabe9c74a2a78d6fe710101cf96318afcb77b57ab23269a481b2e26bf6746468818588071240514141b0ca5759ab91d3ce834adec55749f789c69c32af0fdaa27ff5d153ed0c8631e8306 true +check_ring_signature a4927eae0ddb081c39090f24640092026a7cb1fea81dc6abdce9d4e21c763fc3 10df5df67a0eba796ae639e003409d5a28ab0c19b2053b15b8d798975ec1f642 48 eb4a7a98c335c3e432d5a0d01eaea5001d3d2eac2d82385e37aa55f409873eb9 1fffc459349e7fb4db75b239acc03d24a01e97b9ccf7c23bfca4ceac968de7c2 f1b2af37196f7d2ba7769e1733b4c21e0d625be2299280a5297f9d0c989b8117 8ef7320d05647690dc527ba0a35d1a91c858e7ec348039f2fd80dd41d2554a6b 018ddab2cd67ea2302375c0a302418e868909ef2a73c6b87d781089821a6dfe1 87a375b383f119e32a5da9992495688f6207f3f3f037b0d7864920367a362638 2814c2d95e4b1fb4f4391c5c05f6fd0cf9523717fa3b095fc8eec85dcf8336d5 64efe3c3a58b46cccb82b47d1a7d63bd40937455aae137f7d59fb14a256c1271 7ee690fc0a3450870c1b25882df7e8ede1baf3528778febc7b7daea82e503720 914fcddfb8fdf9bc8a53c3b347910a6acf6694840931b0c669ba2220caf021c8 f6ade69c454b1092f6ab7ff8e4f1c2d25bc772085bbddcb4cc6f86aedd7b4651 9df59b35fa114e1ca51bfe98cc62a17529a3171c513961e3988dc000e347f381 04441ebcd90f58e87edd0c89f14a2e085a10f7bc113ac59679bbc05a59ca320f ea1a8bc785b9aeb5f370a2e160509e24c8654388a410d9a1831a7b009f233538 991a938497f69b1e361dc46e612659b6310ed5d5e8bf90376e6f8453d4e72ae2 44ef74774ba1a3c0308500b70e61297548f4e2f99d94e5d899a96140142317bc 7d2cc7e40f21c4a0d1d6b0e8a4fa6d80f5f9c8e71fc0e99af8b592417f278f4b 4d3f3b2cb0e44b7bfe6e627f0ee5948c16b671fdcd3de0ac897cd11d4cdce639 377b4fbf72d5f1ea61d0774ac57d20f6decb766617406e693ffbea5bb19ea6ce 56d8d6b40fc8ee5bbaa658bd44a93e8fd4298b601b4dd0a1ab6bf9dba807a749 0398a473c7c2cb3bddcba74057df285f6246145bbad91be10cd414737815d52a 47f86acaee2bfe97ca9062dc184fe45e6e96932c6277cfc09d4eeb6a45bebc7a 0469a6c67251ed80d28658e8b1a645881d834d6035cf65441d20cda656d1f4ef 436e1b0dee35e9a54fdd173f9ef7351b2ea1b5f0d8ccfe88bb654f79707641c3 7b781afdfaf203fe0c3f0ff3ba746280bbe1c50344cf2b4532d76ebd027e5342 38a365281983bad350b867428b06c4277108259da2052fbc108a2d18f7aea789 e4e9018093f5c28748826a65b753b22dd623805559fdb23de2848bc17ef14d28 ae5ac1c7b15c6d0b012a8f768068280dbf59f7b908be3530d6c8f65a52435148 b4e784721e2f0d5176e1fd3cc2a0cda6c75f24d4ee766dff6631348eb75a41d5 e86006d8d1be59cd2c82e2db50612d418346442cd4c72395937d600e7b2f33fd cabd100ccdbb740e790a44f2d84f881268d2404536975e9c6846c38c9b4c12b2 116a54cdcad4f3f803affd816bd6592281df1febb5bde46eddf04bc6c0c50c7e 2a698b9a8c3f5f6bc471f614133a3b620dc9c3ac7c71772ea41bb4a9963c2452 a9d0d98275ca3475aa5a138fb6d45b124d799d82eb84d756fba35d950447deaa 76cd0dc7c7d9dc27d9d7b70b42b226bcc9dd29e95b8ef1186ef0faaf20ca4825 4cbc61cafdf07e4d6f70a1ed3bf07c1384505b16542dc97c2a2d67cfe44d697c f3114e8f0559d3bc6c8088e44d8f3210e907588f2cedee794df80f9a009478fc 649133b77f0730a47f78d12904a3f3117fddaba1ceca85f17c7c593086d77026 f2bbbb977b0655fbd504e6a7f6b0136b27f58b3b2e7c3fc189b2ac127f48bfb0 c3fed52f944645001061558d6c45b3052f6f44f21af8408a404a69d2bee8221c 1486a840dc79a4faf620cddb44e9921c218f667df2377b975aa420a2cfe80b1a 4e2b70cb5a2279c8118a33383d6231796e9a11c49f75cf0d773d375ff50fe2ee f6d7c8308d3d6043deea1c59259be8b81acc105b22f30881b6f1b3f5eb0723a0 7981cfcbb82c11cc1d29045e85a3bdada074c08ededd9818cc7bcb8f79045b6e adca5425dd382ba22c81800e8573fe05fbd8deadb615c88146a0f70b4fb89b79 f81dbea88f8c509519d23b30cffe8f25c239c402e2d3873e87687f13543011d1 097acdff224a9f64a84963dffe000f47c4ca28eab8c3b3396d282c29f51a9164 500f6437474da6115880d1f7c2b8ce76cd95a1afd69bbce7a3dde6156f8bc368 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 false +check_ring_signature 2c1ced99f4d3a52c4d9c8eb4e26c8ee0bde43e5fc50e1fce0422d43c71abe137 2c412980ffd1b6ee90f07bf8d165ba73e0765055cf1fb4688f08068b8ec7983f 7 5eb6fd7f282834ff580dfdbb7f225f9681a4956ed56241c5af7e46b548a7e130 07f23b44e6c5b5e7cc6c7fc6e2ff656700bf2f5e4664afde71a416eb4081bf96 e649b1a48a246e1e33fdecc1cb0529ccf740c0dd1f90c7f92a1380368f3863c1 1606f4e312671b555a5f69dcf2876d29de7fdd175837100264d2aa7f657bb35c 9bcbababf11fbbafd29c8e6af367e3c8b2f9d21629ed90eac92fb5698e391024 9d2b248c6f6ac1c457c54ebc0df0bf849ad504f29a09c5675644d25e9f816b3d 21207d1cee1cd01e244b20105affad6213050be27fcf81e31ba94a125ec79562 56401256893bee35394f9110bcc7ff062f50942abcdf17453f89dac39ab1f507ba7bc89a3d6f9ee80fb00fab4fe1c14caab19f443e9ed77dfc7d907288fe96013092cfd4e578e7276bf16c0a80204b0c5fb9e14d76ad79ad080a9fb3b805c201f649f03a6ef6134ea47ae6401f10dae94392271c3e79e518d15fbb806312c207678933f350e01433b8fb188a2e28343e4d403a095b1df23eb70b12a782e4dd04093cdd138a4a2c44447cd5c6a89cf2ac853aa8118b1b1e4d98fb32c932bd8c058bc7829bda2eed6f97cc9b70adc44e4882591aab00772bcc1e8552c0db1e6a0455eb112dd91921bdcd303b71eafe57603820195748b207a56bf59524bfacaf0affc7f7bdc17cc7f4106df0220daac57622575dd4a3390430e2f061514379520bcbf4db7abb9f59bdd17277d27730f351f8ef1754e4f136c04ecf6ae676228c0dc1da81c983b71178a2886835ce4d220eab9451c7cca5ff68b33173b5460e6504e1a5bc23207b96c932d3ad6bb2e25e1c0093bead0aaf3dadc173c9fc47aa66068f35453ed15c0b32abf230f6fbb6dfe4a560640a414062f2aaf9ff18b18c1608df6bcbaa38cadd8b95892a32f3c514558f8f0587793eb8856f7a5eb6cafb990e true +check_ring_signature f6e7f2e662437d94b6387ba9c37c398ccb1bf773e2bba7625e556b0a56adc5f6 1a999002c2e1f8526e0fdabcc127d743bb82648d4a280708965d1662002e6660 4 37182e118d20975f7cc626b0fdc2a70afc6515c72d8ca4ace862ca690595745d d786e466fd36f6e871bb9342aa958ddb6f1e71e7201e54ee0633c4b47929e6c7 4d0865948ad033778279f09fd756874733633c566735707b8cd04bfd7c8bd23f 27e144c111d0522e1ace2a0a40a461edc10dbaa7bb09b043563167c9879470f3 13bcac2063cee06638de41e59ed072d9b8a9d0043c0b1dcb1b4b40ce1d150701f8e9f300adad192f3330fadeeb8fe90fba3d5bff760667e91cf16ffd4860ea024d313bb4bc244b4ae40fb2eff54cf6eb0ce074b6781de7ee1e7132676f7c9b0e34db34dec9e32edab1af3511513eae70c683a444b7448d3be2f121c689e5e307e45cedf295a7b2ce45a8c57929f71e5dc9254220aca1be30489cb16c69905859d1175a1921eb99db73ed265ec1ac45246e37aa8617cbe1be8567ffaba6fbc5072acb3a6ce6858ca2aec04e48151d9981aef9219635180c4ded8b5a3beeb8cd0a74e8ad2cf912716d57c6c14dd6bdbc88f38b90ac2dc2c438c81c2d8d3688a03e false +check_ring_signature 57a5251950ea5367c700b4299f0dd21e067bee4196e0882927abc670d18407b8 617508d9555035adddd161e15ed8ffb8f5d8010b8190cab6b00ec09a87836262 4 e225954de663bb14a866535faf2b421ba4137cdad41048ac792b432705ab7784 efc4eead3458499a7957f902c6caeab44901d080c10a0c9434ed3398b0180e8e 95d35af2b06ab32e6a5c19a300e1d9601f64f4da4fe0b5ce408d3864839e4692 c8c5865ea1a5b0537313c20d533d7dcb27ac5c164eed0e9fb8f16dc66a68584a 273acb2ce1c35178c39b8bb2dd1d38f1f7500e036f0859b36d62bd1582bb370701ab4c25b684c815e98271c18fb5fb266562d964584e44ee44b9a2d9faa985062bc80c14dad2e39874c786e48718283b8e9d3e5f5cb2463d30568fc2173cbe0695c68a7e3f6d74bbb94362ccf7da6fa8de23936f00c33b4861cf09f2399e9a08214739524cda73529f788d88fef348d7172e407c28280b3d175f84499668b900c8c1f674ba5d12e82ebad110aec8ae99e71ce6d8ce94fda57786508c253c8108f78f9f85e402d56f7d0e9d12618974a13734d2c6a6be78a84e79be41fbde420b472881fab1ba25f045e7e521977cf57a7aadfe97214920a74712209b36edac0a false +check_ring_signature a8fdf65f29745fb17821bb0a807c325482800e67afd36ceea9dd189ef417c8cc bd39c65674cc643731e9d4102b81eb9a595ed7eef264a3b6765e07f241de98f6 4 9cc22ff3171d74226626344351184bca102a5618f3eb3ebc774d08f92982a96c 2087238dbc426275ceebde7eba70500b5b5b4baa9d5cf3d977544afaf5d1d867 93b4bdbeb9beefcc75b8228880cb90a8b2b1bcafce200dd9932481584a8e9c12 b7bf3850920d10938f89e11a1144f67e65c6f71d28933914c74b81078aa87c8e 84ce13afdd5ded8a6c082293b8e10507c7f97913f865e2f49aa025c26740e30e3fd976821e1bd28c0f08043e75873cb534e88286031ff29faf283bc5b1c7da0a57be993651198f7f7ba1ba8fff98f420adb2374688496a765d111b1b79f4a00b43296e9aa9fbf2fd843cfd318f7b32760e3dc2cb254ae91d8b0c9d209ffe140e9f1046bd8092aa7b15c6e6ebb540a0d42fbdb9b6ea2140ea2c4ca8c6ec24b7074eba64c79d3b126fae80c6d1397d278df311ff60f6d3cd9b92b5ec5ac741510de32d3a9c1e5c120a5b59a633bf82eaa490cb193c642d1d92275a89b2c2c4be0a367f2481f5fa65444968ad8e1281b13e6168013cc9f802f99864743457d17a07 true +check_ring_signature 405be8e7758656e57332a9d05c48a4945782bc31fb303f4081b4795d5770c014 29d8e678e4f8c079e03dc5537f46e10558b8955b06e0bdc7d2ce420f21f3a6c2 5 01f50cab1ffc07ff00c9a0d9788b8b25de402fe54da9f29cdce646f334b83764 f4eae7a5f0c8e984b5cbb7dddcfcf6b8d6e75eb88e4246fe724c7b75b1982e95 7e857417ccc4957640296706d5b6e8e11c8e3d75d94605cc520cdefe13b37ee0 f68921c5815b29d9b0b813473a57e1b46c075420df01e2c4470a4bd1c9f13dab 34116bd13f0f6bacb736daf840ae6fb6cd9253f3de39e5cbd0c7fbd5b088f4e9 4dc3bceb886fa82bf5bdaf9e83cfabd2e8bae6606e06611d4fb6cb50f7b37a02c8965015f09dbd98f389c548540c80cee63d437f081fda77160ec45895c2b90a424aecd13c47a8a7fb955094af0ad673cb1a83b1adc9e24830659b8c00355e081671f36881f07a0a854f2bb88c0c33c3a56c529997927d566b52c4f96741ca043404951560c9bf3152be88d2e706662e2f02906b5c2da0e377147504cac28907cbe023d0a9b4058eb8a67c1ce862622cdae5b244ece48cc05cf6c6edd2dbe4033d0e294264502ba071fd52632f676517cf9b97a552e5ec8ac821ba4fe757f606fc2d9091f151bff2ea2691f7205f060da396746aa203015842f0a56cb04c8107d9fea155bfc1a77cf15df903de08d59f7f8f329d974f42da24d5b94719f0ee0a50f12038c1efda4f131327ab673a638a2263ba9f6f9510d7e731541fcf578608 true +check_ring_signature 38b95d1ecd7a2d2a906c9de66a62b1a55314c0540b4f76b3c01b7150843c81fc ce2afadf269244e2f226c65b7790144bc2c91379620a16b6bf4da32e7f659f4e 1 193d65fcb9acd2b65a7389f01c3b2e4c2a01130466e8c641545c7d9f14402cf1 112ec31a39bfbcc60cc20a3a3f9440c7a9bf122912a681bdd5cd27e9c42deb08d273d1e845fd1f21ad3f5158da3ecd5a6fc9a88c9ea4b6f205725b2f55595f08 false +check_ring_signature c564248394961f6a34fe9c881bd7f39bc9b8873b3331ca64f3a9190beece11e9 a1f01a176adea62fefe43ad68a4056b5c607a7e73dd81a8313470e3e75ed4ff0 1 b03f0b3774dc8faabb38f1ff7cb55ef5f2e1d44736f85f6ea758019d1be61d32 5853448ae84c32a756021a874eadbd82d4f41abd679b79bfa5ee0887e94f7c97cfdbd051e4334c70c07625aef8f02f43264eabf8ab1b0d26f8b9db5c36d8a053 false +check_ring_signature fecbb3254642b839ced69a1e607b5263856ebf57ae75d37684cda31f332230b5 e5ad5e9e9f5292ecc2832532c7250127a46f3e00ae7b2a975606e747fce21008 9 7263bb833f58fb8a22e5e52898853e320cb7a726798aab8a8533882afa23f074 8bdab2fc774da7551fdc639f9d2befbebb53925a81ed01caeadd8b1150302c17 fd8a4f609ece869843ad7f925b8b68af997260f002cce266ecf934296975d8f4 881b789f5ef4591d059f4963e5627f72de8e4537d0e184fda11b3ef8f1fe85da b98bb1118a38c32337087f51cd762cf981286263a10bcca16d9a72d390e32484 bec9a41936c61ce8b7b1279caddd64a0f3443094466e7f5054a24f184e5ae79e 76e502f677787fc73bc50797a01b075f91e28a4685468f16f10289ab63524fb2 84a6a943c31b766628c535760caf2050384a51b158e2eb5b364d977522b42354 bcf7ce9f6080cbbbef780e97d75725df3166b79a5e5ecbf059511fe29c5cc4c9 d5a81876b8e464b81a74345c0cf238c355baea9a7db4f7bc974ca987c3051c0e598501a58a1fce8b7a0b7e9ed82551691dafe614577e211948846b0468834b08213516a0c09f5c7482521624379fb0c3de0e12418e76bb844de50cc964896e02c31ff45df94eb8f0d7e5f3d51e2c6cb6c5cdfd48f7a5098e59b5204af8a9550cfd111677c3b1abb446b4c1000c400d75eecd6ff3b0ab7df6ed225f4f7c18290121b45c19c223ce5e9c7115595ab637f859cd327c7fe5965596102b99b349e8089c3e93630df948236b6f8cdcb9f3a58ab213ea8e5d28497fb6aff8887e018f07419f74847e06b7cd5ff8ee89f22eefc65b5826a912c843a392c4fd5fe587d60224acb898b6422eaaa97c32522d7927280dd370ef6a50aa318d66499d28d32d0d12006e973de2923ec142bd02e279b4dea95747874225bf3cf0e7a44a09c7a8008427bb2c45b4458ff7189875b4f3bb611710dc3dbca55651cac9aceb31dd320136c64b2e6c0e4248519552280093ded40e722c706a93be1870b97098d23b020d5c9cce04296af1b681fc3af189dc0884b6eb1f2682b0146acf364905437cc10188f8ad4241d4ad0cfad056a41ce0ade3124332ceb6497b116bc51f0cf545670a94d56aa4089b488a54e9105d77be1de9a28d482a7d938b1802fa9be271660c0fdb8eaee438ba1744cd0c83e6552148bea2606729048ddf6a602fd5d5eb3adf0f7ce0af8d671fa0a7d783e469aebef533a36dee21925b64bbeeece3745a91c90b3c21e8bbcfd4f2d4dec9fc63459cae432adc1c493c685daa42ec55bbbf6b9f0a true +check_ring_signature 2cc767153d536bb921f22a319064025e5080a850745d52bd0bef7e0235cac2aa 3e8dabf5fd0fc55aa7f5fe715381b894a0b0eb0909fab23e93445c305f8ac2e2 1 56415114133747af07210c32f89cbff4b73c68f6c45f4228e2789d4ec32ac802 82de5fc2f2b34e84dc444ed844ab335435825e115b6960932cd2aed743abd30f4dd8e29f66a2557eafa90e4bbd59c66ae1aa5b05e84b2b37fa246082848cf406 true +check_ring_signature e3497ce4b127e98596f618cc8cc346e19de1c02e0c0f606fbbca7a4e115b549a 1d09294c65c11416c667096701cdcaf2f8d12b2ed710c5ea73cb9979d6be072b 1 c5088bf473c60e63d2cfa5e09edbc0d7e21b7a91a1243d61ae5e044cc0792fb3 1d7dbbff3443a172135bb67a8925b8146f899320530af5b036e7f2553bc03886a7044afd92ac871510e3a7a888490ec84c9d818ac69409b3a22971b3572ca70a false +check_ring_signature e38577641da190702de58d7771c63f5cb2b1f2c6940137b0e6ce8279c4a97fde 44dea500f8728cd953a3f3e2cbd24d81f9959fe844251766a738f53f4a0533af 35 2b3246ad118445aaf0e65777830105320a782933796b060d63c597818ea9cb1e f64e7ad43c22216b962d9aaf239a777aef5a07c3f215b0c878fb71657bbc2a0e ae22ed337a7a28a184b74db18daecb7d532d5a94eba23d195130bff5ce3af0e6 be7cf7cca8fe7175d2c42736c01edb578078c9855675f06738bab2a98c457e5c cb6f2bf64f430f14d03e696768e5c19042ddb23525658ea4806ceaafb5cfe2b5 873c9d296059659ff20ec129924585f028f7a1b2c4e7fbadb998264c588ed233 e1d4a507dcea648fad6da1488a502ca7e515260fd338db170c5a67cce924e32d 09192d53f9aa93a7ad63813ec78d2c7c7414c8f4acf34b408c81eea460a1a245 6653839fb5ef10f2dc7bb0b045e3cb701115c3f1dfe38e030b4fcd5a4b780a84 8ec9d26326a10754cc7b91b1fa736d6205997249262767f31e0b6568e6462bf2 0de8ac4846be991d27c4a0bd350886eb3d020c1c7811da76b06412fda3026e8e 48eb9e072f05698d31788c3414f02e79e9f9abc7685a81c21c949c94f115e3d4 67de35b8ddf6bdaed150cd16e877641c911258f19d835a058af744f8a4523475 487274622c2116d1c7344e05ed4702fe01fc71648a9344a21f80827d00e4d9cd d6805c64f9df9e7747011a57b3ad5374ddb7ba4ef8bc046d2a29555b89bf84be d912a6d70268e0e288b6b268b9ee4d7e7b2f4ef080292cfa13f8b3759eff0cb5 44f632d39241aca1e39b9ce5c58ca31d7b04ab265c288de4bd4ad8875457dc2f a1d0631e13b92681464bd8bf38b212a1aac3c228224da133a224a14e28bc0151 322485860a366de05d24010a52303de1d1565307deac3d5d00e22c870eba644c c9017d51431dc5ed2ce387f4b4115374c3fac8b6fea83e9edc5b4e2afc5b3c1d 580bfce9d89bc4fc2338a429057c0eb90570121fc478d011278e5bf499f2060e 3612fb0298d52f51b912094429c84c1b00a162002c20a299a9e2bf859257ccc3 0c557c7af7702b7982edb6c90ed9a8e1de952db2ecf07fa4da40e67a3606d244 d9aea29db781de5a6618a5bc7290a90f3d50e8eb6bf157fb06ac97cc9a0c6e34 5ca6623cdc5b5128c5cde0c37babc8a7041514109f8ddb3f38253ebf77d729c4 07c4dc5a928c98e2fc0eb71d758b2b708d853fd6baa322874a522100e2281083 fb76ff4c01a5c3d930fc09c77ce1101420e117724ff12f62fbb3b6ccd2942bce e68a66d9d9a4dc8768c580ba6d79febd3b0b17c126f0c9f6f22c2fd45011fec4 7c3c9379adcf648d4c2668bcdc229094dc0f5030018329211084d9f1c22cd0c6 54e90e2666b4e28985ffa407c681b149964d2de3c5b73a3bcd05949e2917297e a167bb02b56188d3b94a360678f94c74774e094e572057a6f4d2aa4f352732e4 efd06d7bec7328cefba3ddeb170c4e969bee66403ff54e76b931be9cffdfe6b1 4dfdc5675f093ac048d6619fe6346bd07544adc106fca5b75a7a5840c53e50ac ad67d15fd937c283581f1518ba94946f7212d707ade00fc31d4b8829721eaa39 0bc436f464a12e5432292cb8cb70245749ef18a9bd3e65c434e759021afb6964 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 false +check_ring_signature 3d16458bfa9cbc0c805e78d4174bdb5d96f128f2edc6c5b60a661d9dfbb6eabe c069a7bce95dfc6c8541cc595bb392e8da448c2ed9e50a073188aee85893ccf6 1 790790d3bf1d5e4eb239ba2c71539e512e222506117e7c157465cb570756535f 26a03de47a32903d75139ad6d4d5c89bed4dda48b8310c81a15cb96465fa98047d71ee0cb2fc45844a471fc4408721e28678ff1e3220d3a0a196fd0c09d3d409 false +check_ring_signature 35091353af008ba093777616f42df61df6dd5c5d16ba0a471cb4f605662d01d8 ca8b3a78044378ee5115b4bbbe63ed84338e1c1155f343761c13591712db769a 42 065f7f22698b25eb03c7e0489596b78b7c06ee0980a05b6487296f66689c7657 02c004aba56bd760f15bb75c1d5cdd6e0e7e9bc2312750656f8f37ca00af8a50 3af002b4e79fed6e71858a2aa26ffecbd93a6d78c58c13f9a342de2b473bdca1 ff9330d78b7dc754ccfd493946949494e037cf5282aea812c4efdf14ee15cb68 d0932c71b197065231a59462d5fc7338431003e1ed02ce4fb22f8073037f6ac8 99ec92f1f41ff68c3e0b83e1b0358b88db19a781f3db805edbdd674ed2b5ec0b 37875451dbeccf24b84e221fb3a1a3e92ef1280e16da92627c59617cafa464b2 ec215d4a3946b70485f7ccf6086f7fe96573a7440b16382c074e73b91b35a079 198f88e36909ac625de2a5f71786b3fe37640f1476d003e2d204e3c42c9899cd cdf11a005c04670fbeeb3a6626e16d34e7bb2a19974514b136ddfd0aa49bedfe bd3149aa170199fe0057fd6641f37584bf6f828d31cecaa51c031309c638f5f9 78689ff52fc8f35cd4ed6efa47d22308143e55d789b6a7066a978ca932288de6 b56d923e6d4708ce3834eee37aa960cc8e1b0274be42867f520a660d7b344b1e 58b2274d04851790d18185b2731f7ec623e84b55e6f13a67e08ff5afcf80931b 2c3a31070223126e6e1d75b0188670e4ab8b6b27ec7c1aadfc0c7dd050d4dcbe 7fe9463c018b219f02c0fb1908a215effa85dbb1cd60a3834141b4d4da8ed8ab a15090ad04816ff66086b431daf60f04c7d84e046ff1e505244abcfda1caad7a 69823cd6d7a17c3d7c3d066f71baf5c111de8adf4a20a682ec57bce4643f8094 27a9b8cce32414ef52f70dbec32d9349734668604f6f441b9d9a4bf0c73bcac8 dc51881356b9154b6f1532fefa1b0047b9b51d7042296f5b1a35f1374dd74a2d dfa7fa24d4b9737b66bfcb0069e2c364e9d033f9bae07635de7b5acd2f95384c 61b1eb05cf07e9c9675c88431775eeec05013fe660e688472950ae7606e72ace 40184ad3fdab88c16edaa943321a51a645cdd443e79ee4fe6b705eec2d67de3a 2af600ff7e6e0036bd2c68d97af9b7184aa17ecb9f4ff24ac289f3341a4ac136 cf47d847802b8e12a51318bc61dc439ba3f2a9e5ecb401b37e68b75d7c306a15 f9c1d012de07c608c529e312e8ed5b9258590ed42f3ea53ddc1abcb8597c246d 8442de89f43c02364a827b2c9ef97f6880bd91fa92c94f256a6d9281f5292069 b514d2d179a20e6ed334d0f9c7675ed0d8bc88bdad54f9a56c849dd4dc7b37a5 82d81511287a3445d47130adb5781fa8c7c2c27aa24e5e187699ea8008e25d25 b4b69a6a2d64e921cb1db91ce8bd8386ba464608ade33578013b9f3ba3d490d3 65aed89da0048f2b8925a54fee42e98f1a5832725e2568026699e102925a8cdc 5ebedf012e3b4678f8e162fd86b3cfa892a4da947d8d395286dca737fb4582f9 f7ef1a9bfb43a2c945e50545a703fc40aa30f961bd0d7c2307cfe737f9866c5c f55264bfd21101919f57969a5af8bee88c7d54a2dc1fd0e9b7a21429e8f862ea 5976c135416a08fe23dd0e204322987234d2ce0cefdea7f3204b5a60ec000bf1 484d33fa5096792750edece1b0e04963e32d7c7c7c85494eb8e68c7b6f61db01 4cc9131ef362a6de288183666c6f104796b07c931583b257c7966cf4c459a810 a287a4903c5ed5138fad9f3f528012f2c4c65e65d6260ed6a0e29d91e2e91a13 a9c750ce5f1b08c64813079b3a7990eef800d794088e98096d0da72c82de0626 383cc1f1bc5be550c796bd21ff4cf41ec73407fd42b63c7736a97ee989b1a596 3c35822b821941528d20464a1c36511c0332233e373292e7d4b6c38b6a8b900c 6c1106b5ba9f8903c5f237faec7fe3a05f4742ca2b8d2f16fb6c18d1ced7b4da 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 false +check_ring_signature df8cb84d7da34446207c0f8756625b681f7d3cd198d93661e5f926f6c1c5deee 34614b82d672606bb8501f786a3fa73c22427a296f14f60c272752af79355d3d 1 7c9838a762a0689fe972c51642b39cf89ae9f25f195a8d76233d8cea0ed2f001 80ebf5a8183922f9aae9a5e523fa773626d6cb564733d46a03a0840a1fa192948bb76ef5529011b0fa5fb92727789a3a7f6a16aa9eb519474006a5522b3a830c false +check_ring_signature 98fe25f69d409a4dd8f9d43d68695915ba50ff77e54489f6099a3d83d368ac28 f63767b1b30f448c73ad4e957a62b31f80b779600899ab2c8f3f82b807f878ac 3 958d84ccd872d89af9cd584b1176c9f10e8befe4a953df6cf716f566ebcc2785 8d0c182bea7ca07ff2d19f5b822880a3d89ec1c590eb69c6bdc301420cb8c50b 6211101d2399abd17fd876a4efedecb9063168b311378a4ccfca4e4ca30cf76d 4af5fb678df6e15e6da17660f87559e13c85c5bc14358a0addfc0a0a592a0e03f5f83e0766e2cde65928abe34bc8fcb60c8b0cc23bed87a2eaad200c2f8cfb08c997ebb1fb6dd7b1fc455c75f6365dc8df6789b303e71a2c515cdffc533c5403205ed12295e8a89f6c08139b495b897af819ddc69fa63516c128c0d09fa5d3072975f8e04e5e9ee078ec955823fefae2f5e6d8f8f88ce168d443a79624a67903a546618f0ec4c93a512a123ac47d9b926241aa66af42f32ad88a1f8fd19fe207 false +check_ring_signature 007760c59bd77bcda55132b54bb87da8431a36d8a0f115375cb08e0fdf834047 336b015961db1778a272acb36ea8848338c1ef1194e64a51f49467774ea8e2d3 46 c1fab702d3c600b7ccf4961aac90380708f35f1d3be861bcb656c9876638aeba 5cfc11f8c65398123e595f363eb557f57723db842f1947a2777df79ae9c10dbf e5195a96bccbe765a50834493f43bdee3303f5528e4a2dd261c0398bc49eaf8c d9358bb580fd402c086d5efaf0eb635cf7b2fac3fc0ad4ec11efba99892848b2 b14c8cc1cb40224c911494d743a185bc4461f21c8c93ad5afa8d8d793766c1f9 6dbb8927a3492ec2a696bbc1e7bb0a0f094fca8018141c072b9fa1d531be75d3 b6205056ce3280b40b23d84259a8730220e85f4b75d1ff992d21323c9bf41f26 4c85fc3b1a6f6ed809aeae815f8dca648a1a6f06515a83443bb70926f85d421e ddcdd0f75521306fc74f532f65e5b21707ea75d1f91e8937b723ff4ec7ab4193 85ea74173826ea130c35d6c8e73373b78939dd9a38f0f04614cc5308bf28ab15 5607a3b632230455de38c027dafde68281c0f1a21c4ea55e7caab4b1b787cae5 d9aafa15d934e394a6b66fdd8a394e9177f07701bd4205aa36a7d2044005605d a50ee129025bd86595940c679ac152eef412d9af5af041d3378d4faeab00f7d0 8fa3e51c9ca0e8e774752a83a2676dc678e22c530cb4b8a3c6758010a74fb0a8 0980c76b242f9587102e2de530478be81a1962881e1244d4db24b76ff56865b8 ee513da0388f9d4fe74addad02fbed0e738c6301ed37590df84a1c480d7a9c92 4220ca87c7ab13e1d84bbb18e418819c0244855c47fa0c23c67937873e1c5853 a7cd1b4155492963f0d24bcc03b032ff4d74cf0e9629bea191fb8e2a2105cb37 516c2ec4e591180fa1c99e992f7896bcc40fae31ae7efe2474615026ed215ec3 1bdfae7508ef97c0f3df1419eeb8d180049ddb77657d9a837eeaf69332b805ad 22df34724741a57779cc65ee5c2d1c57d3fe56e7abf023e8131a6de2dc45ddf6 e26df8f97ca5ddebfbdb422e00bdd3a3e02e91036c503f7aa55c50eb22666abb e664261871333c93f8227b7f077285dcb6e58d1a4978e538aeb714b373a00fde d70d34541ace5001358d2388d872953043a83a1daa1f1823ad4ed2f20f59552c 7ff38a4de8336e3a6c93b24844bfe4a92fc17729647fe1bd6a02c7c3675066e6 77ee0c974dddbf3e7df5fefe13efecd4045d9b1fa3bc7f14c22f57fbb7fefbd6 85913eddd1574082f863208ef160c2e9ded86fb6f8d8af03f1b2fb9f703bc39e 4d97eeb7532d09739abf380373ccbaf29dccb30158d97242d9e7fce24244341c 6a9275fa3c3017ae21f6ea420d67a98c29557a299a30aa877c364a8a9ec4e325 94891b7731c6af959cbb2b006ce04d58e3dd7a855825d5811d83b0406aeafdc3 6e10002b444425fb66aa6ba14b639629bc766388270af14d817cb8f35dd61cac 04ba890385e0d3c5ebe21276c6cd55638684b1130326e2a4e1e4ca96dd2358ff 2912a9e1a53bcf4ab2295bc0a3ba488997dbb473172f89070efcb0a4b7d70b97 07895ce9825066e2d3a8862b378e7e5822df5fbb8c1c042cfddaecbc595dfa03 fe7e14d34a147888fce30bb610dc648bb30353512c4f537dbc1f50e622ebd290 06e5421e7644d67be424827088c99c1de28055b65ed916cd80cd406cba27369a f13770fd15fb449d65b2c4041129eb81b6a33840d7a0c32766d2008176c05220 4cf99f96d5916e2cbf047c07ad8b6dcadbbc14d306f27af5791640f98751c37f 26d1e0d771171f3860ab9e89137e1a1984109be545f61ef224c91721bae84ee7 7907a66f4a20e925bfdeb21dc838c3e2b650d289e5778b4e5aaed7e94ba10d6b e133dbd3298593d420a2641679b736bad54743c13eef61823dea2744f7e0481e cd82d27e1a0d6bf0003599cf717dbbbb2486954e99259ff2698469c897416b26 4350503e58173de59a449b1f4710a516aae72639ec80339f2978f1f7d1aa40a4 30fdf6af3eab36da6146b423672397c932529f585eefe884dae6a2583bfc66ba 243205456c8234aa7735efb6bc4b32ea8ba398a6effdb0deb4d6f249de3eb2a2 e624d7615a575334b3fa7cf5371b277705a5ce51ee5332b8f7cd217cd8ac1428 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 false +check_ring_signature 354e1b2c1469105519eb3481d4ed7c9b7aea78748499bd433c520c0bae28b901 eaaabe196f961eb0a612831fc099b14686c71cb604fadac80fe8aa0d771e8318 4 245afe776affe277cba8760f8fa451105ebfc67123e161582c8c265ca175eee7 475f352271ee1cd1933adcc1b231fd9db14cc569fd266bd634377da07334376b 9401823d4379b5e3033368a7964b189e6d7971767754adf42f74ba00c222cb62 5007995c8921e550c978b83ebccf8b9ca99d41cca70249eb8b1d0e4a41516e2f 7041aac2a2df190fd27ee64e7e4bd05007265c17a92efd1c6cf258b0add4340fae0f19ec2cad2bb3435db10d98ebad09ea4ec51f7ede076bc041e086f93e0e0b184c7db1b77f2f6e543da8d69838a2dcc0eab7172e493b24b9d8552d8d16310614040ccadc51b8f5efb466e8bd205a2edc1393283e17075be27e4a3b3a1b9000a32bc88d89ae281cc49bf4de2f6d036e25525825a3b1e92ea1e11abe4b854a016cc49d74f695f56a41c9b88449a7149be313d02e00649311d226916f4c47a50b04b18e1e178453914d13f8df510ad14fe6bc4d19b1cb67ecb994e75e52a49d0081425eccfe55f85e6a69342938d28377ff6d614cbeea0ce456f052e0440e740d true +check_ring_signature 03587a5a814e95ab9af18e69da6b20baef894c1e24583a9c312a453ff8f17f83 382a6d0268553e2452920e25ad1b04781821d7a6590ca35fd2e9005b6b877822 8 8c74a82587ef52ca35cc043a31e74390cdc7dc59aca829a024fba43139779ba3 5a7f54743cfea4475cabebf2431e07c2aea60f94e3dcb2494bf23537fb3f86df b5595afdb15207ebc5b9812e0970a9ba85ae8f20a9cd4049a6f5ea2d51fad59a ba712b1ddfc2607bee925cbebf4b1e10f10d9108dca4193c443399746ea81c0f f92a4551530c0fad25dc0b36342f9d161523acf8a02adbc072e090bcc7722db1 37054d81d4893fcab1a70703e01e1a34ff07bf7ebb7969a22464fe31bff33908 8116baac5f4fe8151488b8f3489cbba308f6e41cc1e12828724d076feeea0635 752ea01d86b343367889bd36cfabf9c40b8bb9a166ccf84892a7689ff91ae9d1 02d8639af50ef08e03d7aa524d9527999857c2632dc7ec13d61b5325ab40a100c698ad327fb43639bfc3ebc03dbbeab3984938bf7778131f8ebb950fbf08600446f5ef425b28cb1a8a09754dbd610cc18b84dbef16988e46f64561b842f95e0e7426e41ef9b30f0f810065c40f22cec0bae7d97e2e84f345d00a4231de04100b9bc5995a9893af3e0ea477413739dbf0712a2ed3d3d69b2c35d97525569e110c7b68b4de7954385e9a2caddba5892d6b8fd756f66ef3c910a610c95bdd8fcb03a34e1e23e2d24a158185700a6453d7056d3eff6959142c60e604bea07a32c30bb410095e5c3109f051f0b0dab7f1829b9e134b203ba5a8ea1366839172220400c0c3d24c1fab0703a9aaa9b8660039751f8ee01c65160b9d21b5a737578c400af29cca0fe9e8e210fcba84b7104dde7b46d749e878abc56efd1e00efb8300e04787319575a0b912e8d3adbc1fb4af1efb99a0a55105c33c973ad685a0f09220c0866441ad54e07ac585c92a3c2cb925f43371a0e1d6834c5862586b7ae08f607323dfa68ac076dc1c66aa91c2fd1d95af904152666d40bef910a38b5ee1ae1050c8867c0a6cf370dde79aba708b238b4c9947f2910ed15b0214cae77e7cae50c61354c2238365a6a942606ba618d732674d39f56225589094f36fb13ea81440df08efad222dae068585a2c842c59bd19293c71aea510262460d303773f2d8907 false +check_ring_signature 9156dd21a52badaea45b88ef71e890c39d8231fa0e46ea8de1c1d58add5d3da6 54c96ddc8e8e7a8b6c606104480e870a6407991d7acf601c9262b289fe18174e 9 d59b01e12fe1d437dc6f1ea2dee1b909b2869122117e0755180a12ca3785bc5f 7f66e837bda31a84f1aeda702dea7701d0fa5f492a45a30c8abe050ddeb1b4aa f18a5c9240bca18c576a0bba787c818f24e8959885f508bfe5e791fd472cb71f fca71c19b8d9837fb1238814b6cb70c11e067a35389e727376e52a8ed5bc9068 8d5bbdb91d3ca9abda92e865959f1fd37176465e9544c7fdc2b90d104165f351 b4e6b18dc58a8e3f816e1cf002bd56ebd2a57e6cd5a07cfe7249e2bf6581181a 46fccdd35e89ce00ac2fa6d96a3dda49c6d12f79713ced1bb178e133e40f3371 41ac4b7750531358d319a2cd01386c51f8893477b73c6fd14b5b515f3dcd47aa b0ae06f1080e180e4978d0817f0a8fb2d89da4a50ec6783a2bea21253585f3f8 3b1822a27384222e63895a58d69f8897a71cf6d597e3b8b80c2b972396a5df022e1bb3c7dbd98b712b8b30cb762aa70c069cda95c2f3682e2cd59db5b192760657aea3b91d3eacf4d78701c06f941cabaeabd4eb2e24c91439b5e18e7fabca0c019134d5e4d6177258c6a36e6553326d29a74663652316ab09e0e9dc262c7a092f357e660bfda8b12e4cde76080fe3d85011612aaa81c3fda31ee1c0386cb90707d5fd1b9daad5afd8068cd500e359316b3997b462302778e3e7f4433dc22a0156dc4f28d42f514923601d827570f573bd96817883472efe492fa609ac7e0c03496f6301fd5a1b4fe3aa0f8f1c481caee57a260c155728dec7b6ea98065f8b0b904375ac6029657564c1be748e68e074a914deddfa6530b08fc6c2470516e100c98303cb7dd84bcbb77e5340fbd7921333ecb5f35b7469661ff54c5f4868f1027735508c3fc1f7a667d0a09a2ffee22fc0483b5dce38551514e4364975ef7101f5f32d4693ba7d9306d62069e24e50cbe935a4e0032560fd1ac1229976aade0a8eb7628fc311048035e26786780ae2419f1a7cd80bf6b383fdbf77db7410150bdc58cc90404777afbcf413660ba2965fd0df6f6c44bb24d359dfefe93d541104dd9fd4ac8148976a0634eab59be3a4d81bf8e7a3cda089edf7782b730b5b2504360abb1eb7b28a4fab558dcf36c84b89f9ea3b57fe046262da80c838c3ad2a05800215f367a68593d6cf770f8b9feef93058b7230cbd5b4ca19e911ef2f7ef01b9a0701f7c64fa6e116aee808386a6b92e2c390f153782d3e337d9f07c44820f true +check_ring_signature 585c0b4bdefdf0912d799b304112f4b5de480076a086bf6e89f7c156b61b0f4c 7e78677790a49fd49fe65cc337266c094605135be3d46e9a5a72cc220a847edc 4 9e7758093936d9bb2874114a734c5bc9bd5a94f1efad78654d5378e6a80748a6 861d4971540a79f09431aa79d8aa7f7cdeb1a34393813a60d0452f7ad9be7b0b 2187b8e2e58a90e064008822e2141abd534f54f23d0f35ffd1ec530e23828251 8177309ab9af283a77500678882e4592f21190884184ee2534e49787677618c8 ea9a30efe9c9da0c7614930e7d39608cdb9b9432cb77a30349fc05133097b2751eae4e09903da18ead3e88e1fd1789dc6096fcac6a59fef9604e7880b6e54c02efaeb5731ab68a5260bd3dc02033ff5bb9a9543726963f807db0bda42d93860975436ef97bf25a48f00d02c4f834d46463214cdd50eac331404994e35e64eb04d775eb7efdf14105c7d5c8bf464f5293e3306af957a16786c7988e979d1bba0ec5cee512b7575a404eaae8f5e5567191d5f76c63e89d1af7c1d8fe5ff678aa0b76700c66bba6f32640222b8e9e4772c68b431a54c08236ac3408caa69f575309488adb3100b7e35799eda8ce0ce8f7401ad57ee48a5186f0a5afe2e5762d9a0d false +check_ring_signature c947233fd91096b791af86485a53c7ca45fffae6b5ad70f0ab7f109f2728fccb 65925aba2b4a14b067f43c3deb161afa64164c625e3d66dccbfae479fd6b0bd0 2 f57484215841e38b3a326a154073cd910586683c2b18655d3ef6e366f3914ac4 3c362c3c5ecf59ec6aab5af2cfc705d59f1dd4e280b37a2276075b432d46bfe3 ae6f0de3bd43f26f4b9ee468c3a6e801e3aa24eadee29d2a52bc2bf5e2f9e3066645ef9e31a5a756b5fd66082872be78c9c3e861e52019fc2178a2fa2caa2703dd1e64f71ac3cfe18c68546a234fbec427dfeb72b95b46959be3bf57ff95dd0b4d41df8d6da682fbf774818d9980ea208404b693e4d02697f0cf453f3da61c0e false +check_ring_signature d0bddaa35808822f4fbafb7c567434e588f62dc6390ab7ace611da045fac4644 09c12b6ad739746e7ad4dd1bc217aa1fc88fe6163d324efd607c9aa6e6837e5a 86 8c1a5dfb44f10966b13ff84257bc4ee0f12033d77d72f93c857cc1d63a013fd2 c8afaa47c62dd0ba081bd6f2d00832b07d1b182b956460d6b7578bb310a50f38 e3455ef855b174b9c4e2e15df78ecaaf81c02d56a4b3f24aebd4c0db128b883e 59aea3d520f7ebad3d2f625731fa807edce9bac1840904e66dbff5132655577d 0756e405e30374739413a4d1353d0c67ccb0aeea4c2b6340c97811d50e38dea0 3c61de250a9ccb33b0e7372193caad21a3ef5392114fbd87f56d1248947e87c7 1ed134b253849e8a1253df367b18327147beacdb5b5942497451856df1885cf5 ccf7070f69667b1023fb51488c5ff52e27a4da4c27f36fac1c958d1f5f27f4cc 46b65223049ec9f93ee254dea9ce9ac15457eda2b27be9cfda2cdd9656619cbd 6419eaba3fd3c966f93a401b85b014894d931afa353d22d8e6eab228f5d340e2 a5de7f6fc59494bf96519b70a8d8d12cc05cb5fa42bdfe20a6a82b48b6226c43 600f7ff9e9d2098583fe3f4600bb1bc8e09c2e62db968e1f7f6c35875022339c fc612659cfe8f4213d40f5ad8cc38ae887615271b446497c50ee64d80de019a4 ced26f742a70d664adff95f0af7e06ba1cf2b2d3aeb359c85f50f636eb6b95a2 e0b23dbd64a24f41f6027e8eda023e2d8c2f5db381d9649365b7114a9c59ad27 018ee405ba71ffc46461bea400d5f3996b99fdc045b2308cfef6945dda7cf41e 5ae91ec4689b99cc7ceda0d412c9d0ccfd904541a03aabe803210cae72850ae6 01cbd63eb497ecc6bc5785385d304ac5dc16b859852997aa551938d5c8656994 d71d143a4a2f6b53bd393e33fff83cface13b64a2d42a771c0f3df890cf72337 6e9e8374344601843f73d6532d55789182855185fe6a0672ba8c9b8c18d924aa ae5945dce1ae9dfe9ac3c86941aeebd4d49bf5ad82ac09ab0ede68aad29d412c 77cb51d024da8fcdaca19a2621f177972378504f42e36a50d0df397864c060df 6c73584abaf2b1ad84e5af9a6a4c6550c9b4766d6e4289c3d08148236c103762 13fcba79ec1e4e77a0dc05e3c9abaf46fa77cb589f047b743006e14cd34c16b4 2e76373a6276ae4ec57075ba74aa111836054e3c1720f0fc53a5b5b84aae03b4 585ab842089b6d8384154b2c68628e6c9c36f9e84913486739961e014f56339e fa386dfc3fa1a2d07c5590da0a2e95a9a88ffc934508cde9fb11a5da05c7b8c9 fac39379aaf3ebc6d3a02f3721da29fcc3e7923ed202046ea31c8af63273ed3c 982d32845e3153dbfb28ce9f8a500117c440bbe08e723e99c6d32b051e45f6ff bab8dfe86f0eb901217d0f2683badd04e224157c19cd4124f6d3f88d03569645 d113613b9075ee0354226e20efb1b363f54af1363e03c37aeb41f2c8f013f04d f9045447c72a70cd4b19fffa2e2ad92a3c0540855a25eec8dd725ff87c7567b4 24fcb60f809596313c4fd9940af8c9ab02b8a24061ae7f8737a122afb86f1b26 ab389d0bd514d9caf734dbe0464262c54524664bd1f1f5c1734491fd48f2edbb 37f55cd4336ed3980091b62914c7977377b47591b9a9fe4ff1fdcdcc8fe1b1a2 87e804d8ac805a430199d045047b7f83d3ca9f445008edbdec433e45a28297d2 8530d37a2b5093c04f9c2469f9a37262be8fe51538eb5a05cdbcddde7c945f80 16791d341b3516d0469c1849246ee5669093bcccd365570ce89994bcbcc85f90 ac2a71a67e129d19207e0bcde33e5f4f8c3f682db5615f8770af2bae2d64d870 9d0ceb242d758d316ac01210bf31fbd17def8f5dbfe861eea17ccd385260faa3 8f62daf2fb45d745aa4fd2392eb29c939bef52d4132a13d0a9c66d7cdc2731cb 1e14b2f9702145205788736015f8a08a32dfb57cae2d2e27a55745fd06290c29 225161ee8aad027fc57fd4ea105292501895a6304da026a648947ab89860ca6b 83185ba652d46ff96c7e23240286dc120c1fda5ee1474de6ca819e17c60da14e 9d5e48995b3bd308c07b032a8a459f44be94cb8ec0ca97a09d8d38166f06f84b 54ba06d206896f910693feb5f401a8706e6b4186f9a6f07f616cb61945819e0c bcc047bfbcdc91a4ac31b81e7f97c76eb6c20e36cc65b1e7256a2ca3bde76764 13c7bbced42ed28366994029602403933d5dfee86bf9a58194707caca086e543 66eb6092e807b9f5153f389c2375a2140077954ea7c6911153421d87ac7214d9 476e046d5ab9292fa87ed301dd0246c7250aac5b9af68e7914ae39d952b73c5e dcb9476386ef5571efe4b29f5f2215e57c3e85265f5d5b264c5dc4fdd4b829ce 787014abb8e70440a23fd19475a483ecfca1def2b54f4ac35b0feb2b3c05bcce de6413ca0f77f2dd764298005e75878221ad0b5298881c9b0ba5f76fb28cab3a 959988ed8a498d83345d7a874fa9b31fffc0aab09cd05ce2535da3bbf1741d2a 46e08436743f7155bc0edaf6dc63f7b747bbd04f579e7ba152276407a8690890 1179067c0d32b1f636381838ebd9cd7f9109b785d33f9b5e3557fe008fc3dfed 0795882aaeb2e00f25517c654abaaf99550113c7455176a09d1f5baf5e50687c a76c0bc870cbabd958f3c784ac4f0d15e714c0586472313982999fda65faa73a 69bd041759b8a74fa299f1984c6c6719fac770c17292bb97333537dc7b2aa7d5 26d2075fe33541d77d8548d857d793b21c7c0d5d60991a0e1b58c0bba645ed8e 1a75013dc2bd6c38833195bc8f321c561eeec36f5d442aa136694d7c24b6c620 8048f087fc68dd02905b790843c499346350ffd2b53ef16882f0a038216a820e 3599bee562636866683d53b21c7c7d2d3a89f01677103a285f1b1fb1e1cb93da d27b5712cfdf8f66cd6f7736e6e729ee80470382987ebc5cc31c1832f05bdcce 07be3222fd858d416e268fdd7215cc5d7f60ecaf5c9ef86ed441803b074fe60a 4d4656ea0e079f02ef199a21c5e26209369f0c00cab7996c0b2573dfe94ca046 5cd6b14beef548902a485cd18ac1dacccc83fef696ab36a807d2fe9fb5db5d55 c9cfd738089e569abc1a0b19282e269224ff4b0e6736882e95a9b9ba5efcea9e bd03defcfabedf9326c8909febf6133bcbefff5f8097b0222e4007e97f53141b 90833b2cb4327975b4eb7369a8a894b76f29fc248097010393937fd869d3dc4b c023a09b4b75885e62924151ebe4d6df2f71be1f7d997bbd9b97e83722c579b3 d0ac9047feb39b2d7433b6ea8db5275c5385742aeaeefa31ad7ab04e2d2ace8c 665653bc78875380fb3b15787f51db737b8a374c3758c941316a007f595f2426 7536f35ef3528b445241ee59541543c7d1d7699db1c83861d317cb243a0ac3ae d39d2224e6ed373bd303d6a0d6560127fa1fc2edf1c8ac1c5bd8c5363ad7eb0d dd70dfd5d3ff785bdc562ad4742a22053cf52b436d9466f1b20d26532182f373 e114c393efedd9d6e7f9107192f9befcc28f5cc33315715e4344b4b1655ddda6 0b317f39d0b86d1de547a4de92e945e0b5ae60d5da4eef3fca8cb0a9faa9e931 d6c5f4862598d46f1e2c349ec010c2fea74b8e3d538e7b108baf3e276436bf1b 09cb71998e14b7880c6271f0ab3f135beb31a0e5a38e874d97a2220acada3ab7 28a369fcfd7395357efb66fdf3f3cd01aaa039bb5827e254f9cad9b790167a2a ccf8a6b91c3469a0ea8c350d980d241428dd872a990f933004638580f34f4d02 a9871b98e1990fb220db2d1b99df295f7efadb9940a85e4f16099cd0d342abde 7027e55fc398484937d87d44045dec5d29475cf270ad880da6290bfc89af38d6 b597f47f856b4438ed2b1acb80b302aae7f2eeb548d4fb1b628eb20d7f433e62 ab32b6cd9e92b2677513a719bb856393e17b87ec0ff4bcded6f1377eb1141c9a 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 true +check_ring_signature 450bd461774a2d2dafd59ce78c00bf797e6aadfb8e0a50e883720eeba4c7965d 8bcbfa4064ffa636d7e6ffde9e4033f0d2318b3964fa91f1a6e0b8b3ec713ce0 3 b6a1cc122e1df722a03a2cb917e66b96c1fdbf4d3893f14f9df63c4b41f01ce6 c43188859b76b4ab3ca277588ff27f9948bfb387ebe33d41f77dac63c6db9988 ae07139aaaad29b9220b036e781a4554a51c72f953da754fcd3d453b895fa0d3 4ec7e778ec9a3d49d77e2ea87b1d8b6122c04ca2b6a69371a5d02bc858cb8a02ab25ebf6f958027ea1e9d0ffc11e78f18178c7d5e7dd7b1d73f73ecd7219790195be16a44f442a73a7e320b96524d24d6037767e21bf8ca4ff710f02f65c070a4264f8abb50d681bbda76b7dae0e5dfffe3baa54527044ec3c201f2db3076000bd03ad768e99f650f09f901800f0f163a4edfaeafcabea009b69a3960972a207127c6724885066e3ecfb07e35a1298ed8d00a90d82fd026c30e782fbdd77f703 true +check_ring_signature a5587a1ce8c2d0a202c84bc789e52bccb52425f15c4bbf70c8332cd2443242ac 9c4865ae3ce57ae740f2478e93f4a198926b41b9d75feeb3ffda37b8c4c93c74 1 35ed3d5c2070d05da2627b97347ddb942ee6e5ebc0070587bf6ef733e0eb0172 9bd70456fe554d55767755aa837d8144d5869390ebf5ac0c1dd55f5f81892b0e609e147ab6b47ef0f7996feb33ffa7693f6682e6bcc2343432390e551d62890c false +check_ring_signature 67106af702b6d5be0ab9987233a1635996da23299e762cb305a8b713fb39ede4 e3218b463365474a20072ad6525709f4b44c2d4593d00c892d37218ec8a0151c 1 563e935103d8d94959d63783a33529e018378085924c615d32cce6119327ac0d 85e976cc678b7b46bba79b6595a7fa652fecdbda0460d800758c829ec3547606109774b64129b562f26904155853b6007f5809560fe6c765a7078fa5a2e84802 true +check_ring_signature 245329a6e8baf1a73c10c61281fd90fcfa1db3f60d502bd1bbdd2fce7ef548a1 85a34cb71eeb128ba08e9240d7fce32b4aa7a3ac13fd0590a831b3eecb9e6112 1 a8878644b686d2f75223656f1c9b349b620eaab93d1eefc57b2e849ac3e436c7 fc9918a8fa31b6e71fba49c4587bc6ff735638059ca4077085a94da3550e0704cf4fec70ebdc2ce47c87b67e314cf89c797d38aa27962cca9171b689cc320574 false +check_ring_signature e53abe6b382aa3e3ff8c2412234a2b9875de906535e8c316576d0afa01a75bfc fe73a9dc3389da28cdc073d27c22585dd1d45576d8142a0611132bb43ae420a6 60 eebe59ed6a653765e0d0f17af2d974135bde55677167c03f7cc702d7d3ac871a c5191b60fa7b74eb7b055dd2d2133bcc42b2956cd62e1fa0c0ec142009c90a36 8f69256e6bbf1098e4f52d2e772cf2dcab8ac0661f764ce4081dfa1b9d85a5cb 2f550a67cec2744922e4c77c98e7c123fe9baed85b9dbcf799d2b07390149f62 f9217d094c80ef4ced1eb321e6b41b367db154917315574d10784c26648a4ce2 cedb988518ebdebac1642fcdf323c94d2b7429382cabfcff2adc242ba15909f1 611da9074af86f2f6ec85e8723d740ce0d3ad15643be96ed728d7cc923dde8a9 4947a4fe1a6be574e9182e404d3f1d7400355e6e63cedfeb09b276d19f1d5974 5f8846a3b6ae502e370053d61179dc04ee089f687b81760d9c39bf5a92b42577 65872060012225682f3a2f8b1e416180e9815574e6fb69ad2fae42591d4f4324 1d7a6e2abb722ad47dfbd37473dd4b2e1c491817961588de0e4533f3e2fa9d8b f623e065bfccfd68ab6bdf01c6e8a0d207cce1edf1b6bb1ebe60f6ecc7574ae4 d8f2c6883ac18c5f06cf001dc8e17050542605d4c55efc01a11bf06420ad17ee 2e3fc3b172074b8c7a6be082ed5e2c317b63794a0295b79ddf074e61f6804516 ed314c38b20cd8e69eb2883020fc27d689cd634a4d13cad7785eed9bb44a9e18 35372d36511a644733b1bd045bfcf6c12aa00c45b68a726d76b42e90de918918 b6e057d02e114e1eb75add16464929051d10310284f19c61aaf8b549e0cdb423 15b52863af69542bd67776dc00f3f5e1fc2a8bba93340f313cc86da9a0f00852 c254203893be637c25c396961b3b7dfa9a7239066509dd0e2ada8bd2694377c4 222ba493bc771286e5f1e300ff590034cf84404a0fdac40466e0a70687030dce bec6675b315b4e322ea1c9e1f6633b3291535c9c4a013366968f687fee371fbe fa06b1219cf7b494e4fb43082684e45498db06fc7c29600ca3a9dbcb20d8b390 5adf7a5a78c3972fc991ccc2ca5476d755539324e65ed2b4612ddecc5255366f 3c6703c06f2cc9c03e01a393a8d6081f364e2faae7a6c761a79fa4ea1f973315 8bea1495ea4d7cffbfe429c19aeefa8f9a067ce64aa4411b6db128a475a39b4a 4825cb3fa85c2f73d9fa2e8610714d1af8218250e73adc06f0e2e1db49a6259e be2ff1115459d87f95efd27490cf02bad55bac68e70dded56e6b3dde0342094f 1083758a1d5f93fe2d485414267f4051bc924822b57e8bb85e618237b01062f9 0cae60a0dc113995fa8b23ad99f4b1b2785651fab8a6bf7268f35e0eb5612f76 3a7d7411ddee32b9f4b8e976b61c7e3b39c974c815ae3d4841a4ce8966a8b568 37bb89960af84f2acdd1cee584fecb0230727de5a159d6cda232a468e018c251 b61eb0bf7d119adcf089f2214639915347702de8cf07b478e20550d020744662 391fa9f1a75056735bb21f6fe4c614167c9e8f9493e2ca11cf29d3a69f90f760 905c8f2bf6a0e2ce880efe9d43e7a1d465384192a4c4dcc8bb3a6fe9d08b877c ebf91adfd0a8ab9ff81f8e002283ed5aa8aa19bbed5e2331bdb252d5ac614a1d 3b3063f7143c6e6c17abb0505fa4b55ced2d35eb19e15df820cc4f6b97ad32df 88a5fd68199023ff615b906c69f25317a02393935c53d573d4e5bd63947ad24a 31b09c53397e6efe82870771a5bedb9b7b9db54f1899d5e689eafad90b2a1760 9de31ea49e446fa2fe64e1bcbb0c205ed1b5e3e294e1b4ee4b46a32f91bc4e23 3b260079a62abf5e4f8d9354cf183820b802eac919363b8cf831b91f5f098c90 576f61cd3885dacfe80b8490b219918b5b79b745cb9b8edcd5e316db15a620e2 d983817a8fb9a6eb3e88975d821939cee7f233b75ffe9f73efc86069d0f51413 7f4adde7fca87960c86f69d500b041467ab6f88cf4c8afaa5566366cd52e13b1 bb5cb46ea92c08ce99eaea0c38517c52ebcec8f2d461a1ed9460fc05a19c4409 620ddbf7b9668d29ccf16d3eef716e39dccf71f6bef11b8caee977adcbc23c9f 0fd3f908fb51985e652d9562a6b6ec0a9c7d4702851449260e7c7f8cb99c25b6 d4daca60013313c28e3852746b914e8551437ceadaa10b112f38899c4f84db2f 636519093069b6dbe0ca8f111c793d16a5fae017bd86aa3f9ec6ded80265ec31 adeaa361b9b4e4c3ee55e830172586dda96bc112a6e55114f18d1982fa1e2227 df835eeee42db50bc049c3c12b6b96e2ee2edb0a62213564085c792cbebc791e 2836f18e550cacc35d6879718d55aaaa23ca801ad7228f09850b3c28289904e3 ec8ddc800f7cccff6c3d6acaf93b0ebebd58daa42e927192b658c7d1aa6b93dd 8d1388195d0d480a8138cd3585199c7821d40025275e6e5eb4dfb2ff1f72fc2a e3275e3b4dee933832416043d57c6ff40738198b0d41218056995a3e8e0dd377 d1d936985153b5f71463706809aaa4df0514b136cd6b4461718d4ea8a9e56e12 c3f656be397fc80f6feaa2eff4ee4246d1e6f71798266572630bf8205e3b5c89 9e142ec43b4ad5280885ae359b6cb1b48a6ff038babee173c21a172ca9967164 449c7fcf3e15edee6816222626a1619aed39286638f0569c0e47ebaa5bb9579e 2289e09b8a235245c6f350f899a15c8ae792591cdce284f71a8dd69c69a68911 a9ae878e1eed06495d1e326d182ed4bb21db495baced36f73fc9f47900374e7f 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 false +check_ring_signature c0a1a9df0939609244c0384a6db5044ece394799458c4ffff0df754801c61d1a ddcfe950a3bf82a264b7b0891cad90d530247507ca9c334b558ae175f16283ad 1 b58aace2caac842e6d4829fc8139b633155b45938658436c3c23e00d1285ab81 794325ff77835eb04c8cfb255c00c1d600d30ea93fb033b713c769879ff9480ce96fce1a593700826a096f90f3a300e2d320f7d7ec62949654b0dbc9cb735e0b false +check_ring_signature 276026c337c55791cf0a9d6e65f31fa25a40a28b8ada504287e25d997e2e71e6 3f019e31d48ce9392eca0c8a110bee604dd67e341e6a5459334b9548f1fb7b0f 3 7a97f8e507c39213984a8dc464636bccd5a7f71493dea157fc1a3271a07a7f2c 08caa663024942fba96a402429febf3ceb0d1acbd56bdad74bb6d56ad0a9f550 1eac4a2bac76d882cd726bad995dea2f01840dd70c1fc97c3fa993cc5ab82c62 c430e3012a5d2c59c92726562a462122f9a7ee167d9c807651ed62e9f9910d0217cd381d9127a1ca9ec3c3ee501e8d405d3f8a820d1ba4d8388290a9ddab0305247342ffbe454f3de1f3d8cc25786ce1852015f1cdc21623ce22e954dbf8790f0360dc3ec507f7937382a81e38d1e20a57035018b762e781c4134b130b513f0dea072581f1a0f5306ea14da26e90da1e457867aec9ff2fc2e6a15e87461f9f01d1b50a33092f4f7d1c605cf986df5d42c92df79995da06d2961fe144a43ae102 false +check_ring_signature 70d1df3165f91778c7cf4120a1f2242c0f4d8b44a861641087cc5f7ba6954929 e916797a2e9b672a85c01902a9848cc82489be12dca4afad50c84a0f6d286005 15 f0ed65f3f57e16d26164e49d059c8698f4b7cfb17131ae2e4245546de5fcda9c 6d41299d86f49ca1a46f3e5a47e3d897f9a42861d4317e423992e5fdeabf3de9 7f605ab3e1f76b624deaa07045e7cf8332fb8804081168787df1bbdc954ff6a6 10b3095439600fd8d6c832599b0d3cd9eda606cea542f399de667f53120d1713 7fdcb7b76b718f17a4dbe7858a9ba473384010a508e4971f665436698b605def 55aa10a0162e92f9f213d1d3acb1114b12bc077114f17f76a57494e003f3b48a 753978010aed159f24355c2651f454ab0abcc83996859c86b8ab2c5953991e32 45d51fb98b97cb81b21317fec9539d873ef1a29d4606dc3ee4682049e8c7d4c1 9c2c0c55d059bfcfd0e0e253c05520ab0bdd5045ba1c3c9aaeecee1da34d703f 10c72765dc9737478d334c6974ba67a3f6fdaa3b810b6f6cca9907cd467d4379 ae7a73d1b7cb98d5899e58fd05df2470340bf1a0c1e52f71525f047ab8d19017 1b98a319b9ecbf188e93ba297ad277241b84a9c61425bff10424c163868a4a5a adb545ea935d7342faca9e57cd1fa3121b7644d72900290c2181613d31211c41 cfc1018e1ca41fb39af6bbe71c3b0a2ba63adb83137695177dd1acf5f7685830 4134eb2d9f3f7ba5970fb8e7aa526e03b006fd70ba622313493b5e949d89fb4f cad8a60b4fddb267121b3c3a4a118eb9c4b0b29e0dd1584518848ee0818ac90baf1edffb03a4a63391ff7a6c9befd50ffb6c0ad88541ace84d9c7634572cdf0d3d3f1b68677eb029fcce6e896a1172bfc7a4d87ea49f0c1986c763c52f0d7006e27fe2f7ebe5c739cc4bbc34205c2e3508977fbfa86ab7647b074567eb772f0a289d33c0995bfb9e5adf0c853bb567416477c8418a323433fecbc30e195ed40166915e185f293a32add45b0cdc7d224641e62931d5bcfac1518c203c0b728206d117dae1d2a693e63b814a57c1173737e91fb834ccdd246c1f3e00b5b29afe070714615bb7ea118a2fb1f8921e43208afd2116602ca48d4a72a735bb6483a1056a2e46c57e163baf18bf78a323d231646d90f2a4843ba27c9daa13375eeaf702be46d6da2fdcc3ca227557a906d4c18553f0c9ff314d29195805c8b7c151390c83e037a2948ea159c9e580b421b4595fc0eb4bd575f7fb3b99fa96710321fb0e82b3250fb5509f4e313e2cfc66d7692453e0aa3113b618c80483ff99549a5b098c7c4f78d6203de4774fa8a7f813289e2218a456463ae9c2938a93915e0ad808f9c25c2460999dd1d47874c426ebb1b71fb4c86e28905cd5faed586584ae21039da01e398914d8cfee26075187db341ef3200ea4ea98a6af3083d3d8e5b83e06db5585c395b85724deed31d96b0a8f26392f0c88d37fb27bb67a84cbb695260c8f68e3b78bc2cd2a1d08ab946613dfe5e0aa3350a7c39b39875cddf7ac4f240a9d51d613b0577e6a709cb7fd744d9c6a612e4f3a5a432db318f0209fe0f79107575deaaddd3e9403c44a8eb9a5435a44e546eb2b061fe5c2b0c5ad8a3cf17309aa219d968078505e91aa0269a821846e9912a8b3251677f72d4d740f85c30b0e91c351256caf1c0b0619c1a37245a999e5ec0c55377ede5039e6646e586fac094fc72b7accc9d209b3f81f53ba257935da5ec5565c1d257c6b17bfcd554a7d0226a3d24ecbf4508144ad09cd3b0fc3df89c3b4709f512eb0b6b51a3cdfed2008e3136f823856bf62ed042b48c8a5c75c0dc29e6a54e7ab3dde1e6139095e29034c2ab9b7daf86d055c9ca3b3ada931d1508921a8c3140891a8229a9c05ebdd0cb0e12de8f52f41ecb185abdb1fc55704d867b573788dddde5cd5acf2170fbb0cb2e114f3f222870c1c4585a272aa150ff519b6e5ef40e3329b30265e654d960f6406665b0a61573b68feb828f1c972eac050eb20b77818a73553ae9be9c72409c90246304e60346fdcf484418b9ffaaa4eb664a1c49157d1e151d244157f8f0cfbaccb4226be917961794ff4a8534f8648cf5b727dcb380d6d1c051106bf720b false +check_ring_signature 3dddcfc838447e025ebf93c012d70f8785b35134b63671c01fbc18c5ac26e556 ccf5324d308af68c896b3bdbef78e656072df53c384ee6cbc859668c7047d28a 8 d54f087b046e25e397c80e528d7d275ce1f8be3bb6b71394e66a98bae7ebc9f7 294b10fbdf0a24b9fed4feb1fb3e9f87d45006b856ee845a9afebb11f96e8bc3 bb3988675b60c41360ad1709dcd470b3ce4e5c59f39a8c0ecdaa7db4a97a31c2 42129bf0661de6715642fd30c27757fa60a9a80255ca2c012fb3a8215bbd0e56 f71fb5a6c8bf989e52a59203f84230f0379a2c91e7d6f6360f00d7a2f7c8a00b 4f0ebc4237e251ad14d4d520cb6a283cca4bd2e8439914b755bc0885ea99a7d6 3dfd9739c70b9300df064fd23b840f6d7df4f47398e339bc80dcd84da531c413 74936db1bd6a3b74ead39e43c624c80c39245d7cc85d325f91defd7e3c943f73 70ac9024d84c691797be6918add48f7a34742736748330c2b7e3cffc244d190f704cb77e4c56d1931e0e5946df047c2c1372c555f3efd4aea10098edae5c1005095032c2ae43d6a0f0566d2c5cfc18820f222d2d6ca94f6f090706cb9dac5303fcbfce841dfa3c64f5b78667b518a179a7c9c1e34e92f4bf1abbfcfd4cba1a043ffaa1cd17ad2b61b360e4b07a01f0f87e9df8df07fa12a0bfb7bfc3aec4c63d498da4ddf61f0b97e0b3c1dcc523fb21ff5fcdaf03c6875f87b72a529c4cdc03822bce6ea38cb110b1892fedd2e2bf6e88bf8b9d492f4bd0e200b743e613c305ce8c9b710b66af3d33078aa1889e8d4db325d1d8aef859360a31dd772b1c62093566edcb92c16ee8fab9859163faccbd9795858ddea4821bdda7461f43466e053d97d8e2da382e28099c11792e66b1e33731b4e86a385ab3977a89db544ce2075cd61ce212639b35a8f07cec96fe27d9d8a8d87214fd773715b829de4ff1b505e681eb31748e8e71e7b713461b683492357e2831f83205fafb9b6268d81f97f342984fb1d9c3cb1141a813e65a0231dcde68378addc1fe306e48c0d6e21db40c014104edb97ac1e1f119aa2bbedc7447cb087ad843527e6ecb6cb5d2bfd6eb05662795b5e7bd15ea933540d370bc0ef1fc62fc5745d5c4b1f1d181a63b55fa0e413bd3026c1ade9e224f3126cc43e5f52ca76c7b41ab518c0af07b453007ea0f false +check_ring_signature 943ab3ee15cab5ae4ef0cfb51e8b41c5a25d944e99d42890144d55923a47a6ab f2c092ef6e6290823d44b876b234df505266fde9c9908d32850540724963d1a0 7 e836eedfeaf2dc73bee3282eb3ed2ca29821bc2dcb2464e533a281e6865a14a2 ce5748f4a372e81a0e9fd17a6d60a6fdca4b8e38a9ef325b5ae2912e66a5440d a2c0f69dbb9257e66657e172ad9b507737a1228c60bdafee0c0051a63dbd58ae 636b9eadb746b4c78ef16b6a73b17b77af0711ebac122fc9d7819d00350eddc4 45cd07d3d172ef7303471575267906f87e83b07109be654f4f9ea1519f43eeb9 6e3864dd79659f013e794daa49402dff700ebefa170de26048906f035a1c520c 4b0bebfda2d82b9ddc1be8423754af5072e79401b41e52923aaa7ab9f4aeb3c9 fe7daeb9d83a135b2bc799d4e55da53d72433a3526f4d34ea79955817d6d630079440285019177ff6d15215e1b38321d13bb89e5d2dee2900dcb044a161c19021220cdaf266b5e95a0e5a9809f642981ee9f9d061e9368dabc25b425ade1760a719e07bc30c984f6ccb60907a129185b770e6c0004c47f92026c4af477457507ca806f8cd42490d07dc68ed7cd85b50e9f330eba753e0562fdfb6e13de1bed0776c50ae59bd87446cd1dbc013466a9a966656297c3671be4502823f43d67a60c48a8d330ad61112aecf745c3f80379b12af900adaf26f7719e68d7ee41452602cc0138d015adc6002a4eb83dfc28aa74ad27d8736c9c5f7e559bcdc247674309a6911a549620a580b0aef1b5db851f9c527da71862c2803a510ec6421e9d590ba7bb1741952f4d06526336607b6846f8a09428450775bfcc988a658bf527ab04756304da1cdba70edd47079f4183ef99a193c16374c058a5f50db87a99590a03475cfd853b513db2a10825f4ab8bf31dd34410c53ab094897d98a3501db64704ec5b3d68f45251c971ab501f47436b93d95db280f2c98a67bb4a0356fbb686021f3dddad789860bf5b5a41743b02d8d1cd43c7db60831a42f8ea2ec5d71c3d06 false +check_ring_signature 4d45c77100829b97bdfe83db61a74cc78ff81a0203eaed667111a3c9df1f6980 b88d4db27c9a75b70e0a9dfb8a3d47425870f225c65acd8f2f69289a6840e5b5 1 2b20c49730e6930d23c107fa58eda3c619e0b190b8e8edd00cee2e74767745ee 413a1e6d308e98de33c16665a4bcfd3d4b4fa6ac51ac938881ab0036fbef490c64cb2faf9de490f27a84ed4e08788b48dce3541f91dceded143afade0406c808 true +check_ring_signature 7c58ca693623e4288b66e0217c1eece2147927c0cb47915f12128f3b4493375f 7b1ba4b0284af18af14162ffe7c6fb27dbba446a828c5f01aeed9669ac42e948 1 369c2b3e7d8f6ca89de3a3e894f49515c4dd289e6873bdb73c692008567fa5ef a7fbd4fe630f4511f576d2fb57c5e83106d0054fe83498ab40b31fc50877fc0f045d415f115a704280ddb6d73d8a30d1fbc19516508610cddce4b7c1ad32140e false +check_ring_signature 83b3d658bf6a2e628ae5098e26d209df295fd28afb0c20f4369f6cffea0c9656 a39e1227187c6f5c1f9b55362f59895e27d568bd55c04ae0b300de57f0e6d48f 243 284df5f2ea15cc4507ef615ba09a96bbb8fc6c5c2e290c7581c6802799794eb9 efd27ded642b63bab26af97f61d5ff913a4d94887cd939992844056a3ed3273b 4aa547c14622eba202a43c338886a747c879e13c277dbbd28e208d80aeba576b e3119f86e46e1e0f2ad6f53b3ed569ea0890eff8292913973034e6405656e2b8 0932348cf19fe46b5868a05f6be78e81de0cb47d74e0a92f9a0fb2b090037117 67fea5c8a9946ba3980305a820d2e709900177f95ad35b2d7539cb3e02bcc024 9f75a1ece3bfcf3a1c05c6ac35c9caf1d9ba294c29d330a6cadb51f73b61a988 1d3f5f944aa58e425fbb5c0a3334bf83d49c6971eb09aa4574a2021b2a00571c c55b6fe51da6b17702426f3a3acd4021c088eca00b89a47a02a2ac4803a6beef 4a5a96cd8ad5987580124a2f2c2551367bf5aaf4a4279960a71f340c03eb7602 cc0edfe788dbb85c631bc02ac5f36b8bf3868f3685d14c7662647e6a9c908df6 f4683eac4ab31f4f9b0ec2fd9c997e6de82900635d2cd47dc7d2e801baa35676 8058d7f41fc16e429abbe43c3186e251ef13d97d9163da909d8619ce5cfa5d09 e1f6b41c4e680b1b6e65fb7fc9c5f4127eb6a4a91c4d226a46764d2ae008a59f 722c27ff7acc23f4bf459c0e56236a866c869ac634c7993ee283fe064035f395 b75d4378b1ba54710ffd6257c7c73a23544c416f2b0dad28a201162b638e0d5f efd6832dcc2b8f69bc7aafa3020f4dce32ac30ae85817c9f7a42a2f2079f8f28 52c79b3015b61ce313f583a89590c23779f15396a90a3dd05588cd5d607d3a23 41020511c8efb0623ef9fe28d4f5a696f2e2c8c9002f1e7581a2bdd3415b24b7 bbd0dadbad4773866429d1e3f7cd02ac3ae98f58230a391b440f866ae30cbf7a 03b3b187e7cbdaa3de72a28ced23e5d23d81e0bc9da73bdbe58d21d4f390f8d6 90e499b2ccca1892fe7041a3522a0e731a1bb9d9781137abdbe5324bf95d054e 869ccff8c5d6d1180110664757f6618f7c26122ba1452d009b191a3c8bd6c1db d190dd0d2e5ff39803e1085bdb877f9e62a8401b9777b3fef4929f05ee60e5fe 7925a9e8ddcdeddfc5bb95d2057c6711aab4380c0702693de6f52b718059e981 c2b44b961d4a4a29663765200f5a8ca323727b5f77774408d7e2189224117c12 74eb1f638e84af422944934eaf6c6c15a28c92583883b40c3e061227b514e50f 503d9616f989251c2aadffb81d89f0995e0413cc9c2a06367e42c0008a5732ad b198ca6843ae2044aaf491d0e82e271fe19e96aff1f361b84840cb7abe555490 56e9b6c9e2c5dbcc4a7cb8489ffec09dfc8151f335134df6bcabd694f3391c00 583e854c4460c1e95d62edced8fd15b5d05e9397fc1c88b90b6d32c545e36218 fb4652337e6d3729f1038a8b5e6c5c73b236c7611aa972b8639e9cc57681a6cd 86f4fc94b750bb94c84f4f39750e4e8a54ded77d289388e9635ce99a2411dc88 3a0b13030dfd21dd95acd394bc350733b7add5ad0f02992fd0887da5333d9870 2d496f88c133f15577f2dddbbd8ab55523c817e9dfe18b9743cbf78514b52597 e9c959be1c480eafdbb69f02481fa10fcd76134240cf1ac0eca7acca38b5aa10 bcbf64edf64c48fc6e2e63dd0d30bded5bbb0d06f2925cc0d80a11bffea61b49 9a5b9b5866fe22e101bbc89b56ac8f5da7058edfed8aa94b9c36228b7f857a9c a907a702e98faad5832d6ef161fda4beef35d9e901bfae57df836a83912dfafd 3499c08f314b4e3731f690652f7c05d2c1a6fe350cd7554f39bfb22d09514c33 3e99c24f014155a5b6eca08b942c032dfd58d8b93a31f9250a986ca6c5d4445e 25a4f5c6da143c40d045a2c76f2bac82b8bf72baeed87f14454eba8d0be242f9 415e6887e20880674e1593a9c0715f90ebae7eafe19ef8528f5f0aa50a4427d0 af75f7a882c2604e90dbae880912ba5e77fb0d6a82aec568e8da44a99c960f6e 919de2fc2763e47ac7532c492c5ca05e2cd28f060645c310090a57d292bdba4e daf2890030397573df3969dd7840b484b0aa4aee1b72dee154a911ab8aa4c5c2 b63d3465c3506a891272da1c2cfcc6dadeefaac28f104e3bc89d76d74b1a46eb 250d71097381778452e002b826cd4ae790b8d874ba3e3d71b908b3b4d88553df 03df5e25bb2db1e98f53b862fd3395cd586ecfb5caf761e66406601b98ab3ef7 58558ff526ebdf0278e5f27b2f0b581097be0e9140dff34ebb8cef4293224c67 1573966caceb4a5ef581700e6d89c55500bf4bd6fb42f16da6b5802a4a18034b 8217ed49c890f71cf2308591573aee5e0a248f572ea89120f824bef12e6eb703 1a01a567adf729e7f2c454ae4a46ac290a1c590e8618c11b2053a1baf8b9396d 0b49622c12c3539767a1bc3d9891749d4eec6f6b698f4640423d01e37a083176 2232db9e2875d704ad473d1d1e982b38e59aa6a6d5922e633f276147b44115db af9f4b91ceb1f585d0d6cc43e7a5ef760332722d1661ebf7a7d68be68e53caef 72d2141b140c99a09dcd98185684cdd62d88a2497f34a889aaa4d1c1aa5d3b7b be2b4051c0117464d19b6dd016aa1e265b0f30035eb627c604976c9ce205b940 f65c30be51cd64fe47bb9c4771f3ada6c8105cfd6f3256663db536ac08ba7bbe b5763bcfd3e0db16131aa30c3e5fa444e345fa8413b7962d322415f533f0e827 918d31cf78101dfbbebc06fa46bf66a78caeafb3f3ca5d6108ab9cb4ac5ce772 a559c1fb62b1051bfe6e6d3364be03073ea6a20991d61d38920a668c23010261 0bf659cc2d9f232efbc534a2cf470e85895371a8880162c4099a1be11712630f ccd1715d31e6207426c0d54589618c35d67a8dde1052cde32afa6a02d058e067 d83d96661b6fa3be2e6d0a98e62a30db9f8a8fd8a6b8f95a42163359547d8e92 842f13b1951726b879e3107461da9e57005c1fb3e323e40adec7befaa1326e53 d9e646587ae9dce86b827313f5cc38cb75fa08845b9c0ae24f397c692f9ecdb4 dc55c31fbd7744bc73016c024b125c50caeb496856ae3b1d042e57441c94457a 3d9b30bf67c0f8b2f5d9f0d3ca7a8e83497be9baf2548f878c39ebe7f337e678 7bcf79d1a0923c9772046fccfeb53c593528068f89b615cfada570b52d5e4a9c 0a31217879bcabaa80b0f06579b2c8ec6d2eb167632dca3ff21fd96fe5abb3b8 5716f4ca373204344790b8f8a8808e38b9d2be5f95d57b7342efd294ec3ebdc7 6f473bc108eb118ad1b269bbcd4ff30caf6b51c91df7b4ef72c318da64f87b9b 2d246421c91a65d47d205b7d09a3eebf897437d236fa7c46a5652e49416b7e0a d0081fbf3a5a455a5556388f8c269437d4d35a05ea1ebd96ab3863ada1f88dbb f93dd35478c457ce395383d7bfac52f38a3352a68d6b36279754b102f6bff0f0 89b36a35ef1af052f37632da8b41c5fb72e103e5e937449c6216eafd5a9986fd 3236f28299c49757320f52d8f00723c4b495e14a7a9edcafefa7e29b9e1110c8 5289a723ffeaa0c4c3208228f6715e655719c9eedaa3bbdeb1aa8daf46184c4b f0e185d735f9022a3c4190369d458bd00461494bb6835c015e25df111e75fbab c58da20c76bcc640c8b16d4bb88c2501cd83f967b7eee3d34e7fcaadf99116a2 6fecac2bf7741793b9b88fa07bc5c7fd870c0059437eb6a603985bf4c7d395a2 2f42f7d6e93cbfed0796ca322e94ac2a1b5e13af312a519153b24107af087933 d21c6f4ab66cbd14af6d0c0ef8113700da88ddec9fddb92a8beee6ff2506485b 85c153c53312b5de4162d5aeec67c3e5431be8634cebf72c613e5490b5318067 1a76e812c8d3f62cdecf91ceb8c6330fb04765fcd58af80e4dbca3ee89e2a1ac 40e6c9be924bd8bcc8a6b8c1acad66205f73470281d93fbb961f0ccd87da36a8 a6560a39f63ad20ca537d4dd8e76d9606453c6f635253bf5fe001fbc433022b4 0b4c5eb9f1ea7205e217c9d498609c6da53cb1737d894c6b472539387cbe85e0 f634f9348d3d5ea560c9a812debeeaa04af7da270de7989aea5ba3c8101b45a7 9ae81561aa7688819dfc77157bdfb8424ff0199e8cb10ba2a0a001a450c1de2a f4b83e5ddcf606b94a5edec1252eb46e65feb258037b54a547481fa4401edfbf 5b3bc8153b0ac0a8793f74a2e640571dfb679ad3d9cf02354fde58846a2f59b1 d9b0898631bfaff64120dc8d74453f8250e2b795aa0c564d9f9a203593f228b4 99ad799ad3b48d7079ad452c43e2c7806d2c25d03e9ecbc123d9634eacc6ae0e 255ead2b93b2f039f04e2e25a754ca1490e26a3c81d2815f400439f3775a74f4 4ae860b2ee1d10d8d2677fae96a99c002a01b87a27690fe121e1a27390337d5c be501dcbbf4904d981574f066e87c1d5b38874869dced20fc467ad51569ddd3e b05df33c00b7bc3d93340d2267b9b175f51cb730ce96292c1fc8520f65c2434a f80921039d581fa4ad8b52c8ed4dbd20304423a44477a2144c6472c446ea8040 1364d69edee377abda0bca76d60c1c3bcec4d5c79d9c10cce56cefe90a7ef586 10ef9033d6a155037b7592ba028c0a5e93a2634c053454ddd8dc173b5251aab9 c7b2446a57e3b3257dcaae4cdb44c43546a983f1c0b45f25abecf0551dfbcfb2 6c70892103bd8edb9226b73b4dacb0f09b75b84fcc8cdc630a855a5253a103a8 0a8befa863ec3ec48f150c16b81dbbf246284e9821fc0cf5920257299b06c9cf 3d2d8953fbdf4eb2d8e5f63652ccdfa76c1290495e4d5edd489d6ae898607503 96b61c9f0eab33d9fb1988173095402ab5292e580fe400d6ee32ae7620c5d23f e110bf6b5bbafb047073a5ce1cab5954cf2702947e00f2219171098b4048bccd 9b39c810842b401b54d11c016a2b023d184adbe51920028289a5ce74a03cc153 c19e6b512567bc00b788d17e05cba5936051db3d27fcb3568b7f42a610b86617 ea84f148103399e2eda9211583514e118e897a6fe08164030cf5e96f0f842077 6d125ac16cc2c32a677fdd8b127a4efc49e4a49c978c3a93cf05da0d89d0e3be 6c05296f5f5332eb921d2fbff7e9b752e9d91ad38d783b71aa0fb841e2364cfc 2db3cc20b1ad4957ff841aade419ca91fe4356f56db21ad02e3e671ce3278434 38ec5e10b104dc9864a8f4d2d4a5743cf87d5c0ca521b96f23498d233f971f31 b717e72a9e3c1abdee96204e9b98b8d01ab0ca6ac041b1d470055b5bea33ff28 219536c36cf24b67e6fc5ba9483ee8ea11779c2d9b79f0f23b1ae77bec33371c 867e9efaf6355c966a73c6098b1fc56bf525c1c2c280a08f4a5409c15d940f66 b17cbfcb2a5dfde9ade49b7b70342e28140c50abc9ec2b14e668f73596e79ac5 94569826e1d6d4e31a379a69023eb95f411e79eeeaa8d619714192171cbf852f 530286e570057b8a8aac8c337755877f3a4daecb12e01ff7dca911b916a66b5e 2dfe12f4c698aaaa63e7d394860757aa5ad9a53db94861ce1309ce3f56cd1ca3 5f281b80c4fb8cdc19baf1355852c2486e3475fc4e312a6e145fc62c0f45d756 bd977bb5aa97b555940c986ee14bd56f227849512c221a7eda5aca9ce94d8cf4 86c0bea8cff253dd61e48f5686fa18e50ecd034ef4880110ad7ed1d9cbbd3789 2939334e364fa2d9e83cac972dfd09ed025b8ccb32264e796a204477e3a39d08 dd2b28743317ad27f6759189fcd581feba28c93944e3a77a9fd79aedbaa88745 3dd4f7096e4fed9e5a4382bd6dde4cd2bb25c8e519bdcb10c6f249397fb05254 ccc2417699c11f53100d93a44c4ed4e23c9ac6e839468e28ff36b0bb44cba48d b6afd7ba8d0b563a07bb66f1c40eedcc559fd2c640f01b3342bb636f6ea765ce 0e6adc6cff62f3e5037f0c458258fbc55f33003eb64d7dd41af5eee8230e03d2 9677c1f2bbe2ac155a2dab74c8460443508ba9ed00fab86fc4dfaa6b5e04226d 175acf2cb4557c070fdff48caa25244a74fadb66e8c54059fcb2ac9c8158f31f 333f9ce66c52956127e91f8e29def81e02ee2522dba1b71a1059a2f02e621d68 0e14cf5a81c48b6122505d1f646b837485574b5840ea903e1a199dbd19943e42 308c7e440a1835939e0d34ec0b99d778ce67a0cbc53b057f7e037df5872fdaaa 6f10e4c8b16cc40d199fc92cd92bd39a0caf2531f9be3510a738d2b60f2aa28d 48c4f0c258d09357724f1228ff319666724673a0bc536614f8e6d101884dd5a0 6f80a11cc9f56a55daa20e6b8c07062f82c5db13f006e6dd57e2151b3f04dc8b 8dadea0f0ae85cda01dbe4a2850fa9fc7688bce7a097fb30856e12a4dd8627e5 c27472a571bcfbad6648fc0b0952c0d6799e23ae2460a62275d790b806858f6c 0a0d4af0fbccb5eb4aada3ac9508a98e43cd7788761b7b110d1ba1dfd82c7d4f 06dff22e0df78b49659a1f17123436a89cc14ba69b3a83d4bd560dcda179b906 11c49475546850352c593680c45eb4ca64f0797d4be237ca314f8c5e2ef7c2be cc3fe333f8dd869c5b08e892b6f51ccfb013907eb546bbcd5699b68468641028 25685968642e8cd119e25929cf48d7ed9b3bb19db236241c20ca8769a9938982 4361f1a122f6be4eab064ddb7e55833b58ac17815356997b7fe00ad9886b5a01 b1001afa86513fadf5a1eedff46151a248568fd1fefe949246425419202f5bc9 8dd0ae522ca0d2b073c79d167c27ed395714885a3a6b80b24aeb230e22e3d9bb 5012bf351153de192d1b4cc4c9cfd3fa7ee24d1e7f7120d65eb17d390a23db1c b17712d1da49b0c20163ec4f98810877264fbf0408d2a3a421d97371f7cc68ef 36212653483f5277a1660137d19f85c7d18f360e409d284131083a82c9c48423 4af560f0e7cb883e660c4f07da9756f0f59319e02be8f878212894c0263943f8 631678c031e5811cd9aae7353c836e14a8bad017b32aceaae9e809d3b43d15c7 634e4c02269006a370dc4393f2698653a69e566864a59c27a6948fe952e64bcd 1fa07f4bdaa25fd03d9844efe8a337102cf0dccf5ab2fd255ebac8632c128c14 537d1006e4030453fa42cb93a4148145bf4a38fd72c722fe593a4478222f8936 774582f1097dfe1a4e812b8ed2f873af66cba9cb9fe903de108bed8cfd81aed8 ceaafa0305cbab00d57d86c5ac7692471297fa3ce2f650a4e0495863d3f34307 fda82555cf58825fbdf34c8c4a48ebe00d50a4f73ea92b5a98e841931a58985f 7d41a5656634030e3efd72f6e0c4d3bf2bfa087abae635fdfee8ec0525c9635b db2690cf86734ca1d7525b17b502638d74cc28977209510541a1618fecc6ac49 ff5f62272a3c4e56feb0bb368bfd1f776026fbc8afaf6302c4e55ed363584e4b 0d618b8e89c8e6feb3f49a5a931b8c4edb6af03fdb6d65ce876c5a1869ac7aa3 dab34174b47222e116849c95cfe4f01b4e5dc8fde9e1760084164cca15795cae e38e8399699c4262d8930352294b9a4b34396fbae793a974256952d1b58403a6 a98982b7c974eb1b214d297f24bc111aaf532b623025cb4350c53159313ffe52 6d78c2f8fb4e06ebeaa41cbcba5e5408eea0132ec0fec244e8b145d351119b05 fac9325cce6c896b7d7ee68b92f5d72c5b6a4c1889b97bc0843a5ccfa5290921 856b7eb54a9ebcc03cc5a8720f30e8f7d475bb07ad2784ccad86a94402f2c601 ce0af4430aeb48a496a8acf494cfccc31990712e9a3d2a0ffc7afeec8ced5e2c c99bf124ea0225361ce505fdc91547314f4959f28b50babbd1dad8f693a4f0e6 8b843c44e9c771b90ff315c64a139e0b0e637bc76444c8e785fe82d398c36ff4 a415b04cef2e064762eb57a35687fe7e16d8faa4bd3e475eb20a67cfb1a06de6 c1bef2a56257ed311d6cdd5ff843ce80ed9e3a6fd1cc4e20c668b5603067bd75 e9c15051cb0cc3eef26400f402902c04e200b0acb949d2718615a8567bed71d6 0899aa4b02e933cc963f75e2d596ff996ad5e2aeb1cea3efecf36c03a47c499b 21757fa18a3cd3d597d07568b9ae5f45dd0139a72e3c9160e6a8413755d32c82 f31aeebf6ccdb8d506b3eb416594993dfecf3b487b7fb1972e928ae5e01466f4 09240021436a20605cd5bc30fda9c44754fd37eea8f2cb8eac3a11850cca3ff1 58469924563860d0f5702b315924a413fc03452c16d06437693d59f46e6c885d 1167130a36e3e8795e17ab6d0de75fef039e9959be15503afaa469ae6c7ea6f5 fb910958039ce4c515454e7e9323c9133ddee5cc337d0cef266719047b24f497 30243904265957633daa01682e0a07024bc5a4dbf5fb50a9de72959db1fdbd58 200335004fd4a2b809aeff0431cf7918231a0f49d2ae75b2fa9bd0fce313ee1c 19f108da181cb44a5aa3654b08e487afb2ba9391f331b7874b8da7c4cf640f28 74768f5ab8f4c91523a9936501424d45ee50fc2124108e3a5611f35021f05f71 5bb5b90ac48bb97bc0ed83ca460b03543bf8bd836e6710ac1dcf640c24e2dc9f 2469855ecbe68ba37e0b67c382f6e8b37149c059bd4768f8f45f53710d16e079 8e9f180219cacbfcfe6209b4c68422933a968130fff0e07ba005e76329556325 bb1d39710def73a0aaab3e29aa64c98e8e1cddfa5310b376d99fa39a256f4bc6 5e7f01fc6c6ae59ffb567be31c9f06f4849161a59e3c8d6a5e38d44f01414050 b6878bb608c3a69bd647a350c4102e8a93a21ee434051e6c2b8e3f42703ef237 9d5516edf509ab789a5ebe7be892c93b285014d7c443097b137188c6287507d3 608de6692d3818cbcb08ffed93860df8eb022f2c09f23299606bf35d09d1ac56 6a56a52dcb35ba322860c89dc53fa68bbe003cc8ffa2252f066ac0e77d4ae83f c9ca9826900c10082f30e963c0d848c964b060137865304e03a72ec1d41d85e8 697a9c53719bfc041d841446e01af0cf420bf877659874d046e221cf26c879d6 8b9be3ccf1a2529981811a7cb162535c0c661f5127b065ac38e4fb29084d7b44 196ff681eefda39b11ee0f02b3fa5fdd04e8d3b57929eadc3c2b4f9b31ff5082 8f1eb5847fff6ba8add1c7c5d2fc57421af3f8064221a9ac4457f60fa199be7d ba816a07d65ac7119f830799d98c35d0154697a8e8e59b2122c98134ae29b544 159a3c7ed97e181e9224a18034a05dd2faed08c2e2ffd0e1f383300d8332f544 f7d17eb6e67acbbaf6b756fbf91e8871f1d42b288113c6acd8de3e775b20bc90 fe64f231e06857d241b68f550810ef5ce120b2d4010b04b7b09f5c08293e318f 3fb56b6b30f329016ec7d2dfbe88d91ff71e26ab6d59021a8630cd6c0df0acab f0b2375e11c0fdbe6a1aec5844a0096dc964945c44b793522a4d68834c4e5f9b cf8501905b60752acce92c793ba26feec3fd7ab2bf90c705b929c8134aafa0b2 9a79d292e808dd278d66c3d14cf88748fb7b36459afedde58c85933657f374e7 28029c093db7d1d24d3c2eacc57ae559fdd93ab935dcca02d4c33089d04323ea 49a01054f4c7124391210e50d3d10a344d5c428d02aed59dd1ccd0663ea4e8b8 88d184b72cbbc70338238a684e894e33451b8249ec050cc90bc0171b57dd1af8 fdf71ac8a50c8de0e02839dc523048ad1c81764e0fc660630a0f55f0240b6eee 5d09e23b1780b29f6f14dbad9387f6d64c55127528b5864ec3ca285c14cc20e1 f72da001cfeec323693a7b77ef46f53f278d04916c139de99c54a8e9e5e9230b 8859c6ecb126eb47d6e8ea21847f350360ad0d81a6b6ca0a102f63d8b80e04af 9a876c9a8aa25d8ed32ec90b86197781aaa2274527924954c139997547b47f3f 87d6cbf9cd2b65e30f6f98ef73787872e35789b4fe63f3bdc9360a871ff60585 8882f91c0e5f5eb16244ebcc326cd74164397ec40c8e8d9fdce45fcd35847cc9 7d8e93e64ef49c3efa1228cce4acffac9ab17ca89a6ed70964b3a4e4a34e7d4e c0e73b558fd5912fb2c2f91f9d95375eb4eb11b087acdf57593a485153661ef6 4536417bf4e59926bea208dc1cf4040232534b0eee8ee83c84146a52a372f612 3f45fe2d60fdb1c8b0dee743010bdcb59b16fc5743fd53f05807c466d7057a95 d09fd5867758c21366c9f7e3efeaf117c4c60a8eafe720680e79db81da2c2490 248dd60d3bc43e59545f310f980815c74a0ee725f9b28adfb0cbc6a58511406b eec3206ccc5fe19e4647a12c75095d484f62499b016b1637362cc51eb89dba9b 822417d7ec0028be892aa8ac36414f8dbf3125898393b2f0929ae3ecf5165ccf e4e202ba4a63817b54b51d5b94f1bebc3096dc9439eaaf44a9a072b1fc11ead2 df7288e17f586bc6bb9fa84ab72c442f1aed72b4a2b9529164ddcd18d5a4bb0f d2fa22d1a3b8de25cf53c7ea97087c2980047885eed29d96627ab03ad7f798f9 26b8e9d03310a7b750233464c2c284f8406d3436729016329d8e301efdf9bcb2 95b1002f196e1c8f83bc546bd9b6929aeea1f7d153bc1c51250ebeff4bda052e 043403abe772c964071c4acc9a691237a3214b2e537ec98b3d581e3ac82285f6 9e4e5bda7b313ca6dd8820297f93ff4c0e6a096fc51c3c82059def3df1ecdaf1 36ca836d9a8a92e4df97443565c83e39062079d832303df5442242321fcd41b8 b85dcdf870806b8c13fcca1a0528794cd2014d54057f58bec3019142f664d9f1 8925be15c4485f499ee60fbd2836fb016f3925befaf1b7e9924dadb22fbe3eb3 54dbb4bff3dcccbb40b8307c1bde9820d9347f4c739df5a6c419cb8accc14434 90dc3fa205842eacfc8ebdf1ba236b08802ccbf309be7634d0ee908741aad9c5 c6f8319ac356f8c27ae8776440e327a674cd6ee6837a3bdcec7b3141cedbf642 d9c1e8af3453ec730dcd964c0264816e6bdc3d31eb83638b71d76bbfd10a1d66 b69a4b9254fa35947c78f7e5b4869ba043cd4d2f72c50326b666fe4a20a47908 b932676c61a06d0ddbc6122f6906637596c274cf2175c1b2799d68ee959771e2 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 false +check_ring_signature b52b4383b5f92f49ee46662be37941f51450288fab9d804b431dcfd6eb0e8f57 7312adda7a1289db4bcf89f2dd46b011a01326ecd40cb1a8a6825e14b2150f19 64 2abb356425ffbe96d2eea1755d097fc6d619f00cf5f3b25e083cc1670f37ae99 5d33ef7c04ec5448a52f8f71bf7118886a358998add47d91a93f5473c858c638 2182cf5f0c50f0688a045df60fa6f47ac8bab3d2ed72445d6640cdc7ea90628e d85657cdd454594da975bc5db44f9300b8be080aadb16372c0e0ed218825d6af b7a837ea26bacc8788de66f4a50744339ba760e25f58d90f9eb77f72603ac75a eb54a8b0790a458d504d7b318159db0a96f0798edbe57822e137f0e134f0466e 7288f5401a9ff1cc7ebbc04a56ee1d14ca64c7c954f722a5d072cebbbd687d63 404444cb8fdf70cc1520ea4c92bc8a4cac1ba274cf22a034bfed5c0edf1446ff f3c617bd98135a87055f6f1addfa0df48a20203905c7bb915b0d7518fb92608b c42a58f6f9d6df2e6fd4afd7baf66c52865a1d005eaaed600e956f7beabcafdf fb88014555bb154d605829930c84bac2a90817b20e1036b87e54252d2eb3c67f 61fd21877cce9094420741de65094b4608ff9a1fc2b962bf5b7d423e4ff87bd4 d2916e4869c5a8ce3bfa04f07ba345d619478f3dbd75c9439112a7eaa0ce983e 763c272fabe6f9bd53bc4532783f68081ee46e49c861c8b499e353720b549a63 dc939f103e133ab1cbea1c6c51091789111925168d67a7d9ec84365a38dfe4bc fd231009f2114e3165001756aa33f977695c7b289426a167a18db77dc60f1e68 05b321c7c9e7060f1a2ec73531810734edf8ae6e4d6c5a3ba3496b36af415de6 69f1c435dcb0a119986050505a98695e91218100af8e900de6b0150f58b16bb5 f08393c9f8822407a1dc6448be20e777a871002eb62945f167721663eec2f5ba 81a0c5521d618aff7d8bc02c89ad8e19708a6961b7fdde79a2af4fe95bfb1cb6 8d631d90f4517545a7e832e1121993a525045ebff348927864a5cecca829888f 9298ace9d423fc5bf3e8a1d45107d296b70d1d6f3e637b0f53822b6dabeb79fb 19b382f6c89382a2c987eea05733a226ebab8ee9efc262e22e8ce21aab59e947 149da3af19e9f49ed3d03c1c7b65bbc90e282a1b9213b8f3d96487b5b71bdd86 5c9f9da811f9c2896a3d8dbef69da7d0099306c07a41aa0a7a8eac16ea6dae0b e2f9e07dce388038fc6bcf94e6c94e99a9645bfb834053f32ec41515c9b0d3d2 c7d40d323497a599b0f8db0d69a4f8dd9a2f82be600a8570913d684d1644b841 bb7bf9d0225e8849244403dfce98223529ba8ee00945ec206672ccc2e9cc80f8 7b5527c12b90639f4fd6b6bdc33f72b9d6ab1fd087d14da4490407c05e397beb 4fafd17749bb53709e1a15ead80dbe7060faa98593b230fd439a5f1b49af7c7d 072d8e77dbe1dcf8a86aa93a53eea329eabb35f438ebe1bf5792e117a29a9b92 dddca68bb0a01c19b1a542e19cc7b40f8318b5363824c312840d6c2e17521f25 35578a5bccdb4b4a6b20b60e3b5140bab4916a365d97873d4e7909ae848357a9 773beee68ca2a23cbf7929bbe55fc8ed69dda924567d36479eeeff0273d16105 952ffd7362c9d5363e0337910a6a74b57fc5360d8b34225de6649c51a128c78c d4f5b8dc2d83a35f5c9fbb1a96b67bc6b1065c4423a9693f9cf4d734286e0d28 027412ca6982aa98b248b6380b7d25fca97672921f2e2a15dc5b95126f782f56 b84a2aceaf3ed74248ee4d5ae738dc439b3eb949d97a41adadf23c648fca3d1c 53869b5e7279c29857a63dbc895a2202b7251c6ef64d7be943928f3b16ff591d 023c2df66a80d83b6cad6e0efaf2d453bd423d1a6f8d384db2ada2ffae3ad154 a7bf8ae680e5fe1b9a2a07500204adfbe932f750fd43da8e92324c1a1584bd47 ab65d4f9ea9235ce45e5c61d323b94f2a86c69893fcc67650a4839a379f78682 9974543a2f74ae4b35423c8a6662ec6011a480dc9e503948aeeb848e5f9150db 66e402c3fa10a0221f86b82b8bf72ebef4be709bb3ef8c4f74d79c8fd814dc17 c148d1c3b82849b4fee9a741d84f4636b5c112712abba0093803ba92b941780f ecc814ce9e988e6e5bba19815cca8867f2feb58e41961d13bcc95a25aea5a194 59c7191f48ac6aecdac7c9ced51e5061f934d8d05924ad8576e33725e8bf6b69 1f85e9b866d30208ad63d5876c7395685b1cdacebf43439dcebf4824af651e33 f1ab8cc43caa91e16523364f2d593a7c950d2b258b214d8cb61b82aa0b71e5f3 4f88e7efe5deb028040a8980463ca0812131a7a5097051a5ad38f9068f8d8fc3 1db2188138ae5d26b00ebbbd6927b02ca1406703e6c2cf3929208a9a25ec5baa 2e349e799bf895fe90a656138e9ed46cda91a33e4731fe5cba6f2e64265de078 c245ecfd514b329345db37b93cc0bca66dc41c0acb64e3217d507c58c6eddb99 5c2ca0e8289b81486bcc8dfd4e24d2bdae9f9707123507d473a1be906e703329 bc96e4a8dbe542da1c4afcc0ec860829f83c9a173ccfc0fbb021b7654e5c4e94 832d16ca07d142b982ae9040754103ac0751bd8843b31cafdcad859403fa6a4c 8048633967e3028f9cedc8280cb3586a203641834fdca1dd3fad9cf67a5bd2d3 f6e7d2eb6fda27e00bdfeb6b6d06fe8d5bbd2f0583c2c35b697b682c11017c37 29f1314ddb81a9d9e6911dc57ab2d27a710a68c70eea4c092bbe68b44e63d0a7 aa18bde7aa8b3e35969c3a29af9bd918b5abea33c97f51a79a422f8893fc396c bfdb0db70f84cb8c90991edcdc948ca8fc092fe97e9e8fbc8e6b508b1f729a73 fcb11115332317596b4d8dc3fca94f8c73cb6335d1e2cc78c54efb1454f84929 c49b6978f50c0185724d10421ef59f9bea74ddd244b8d3a8b013dc3218fc2696 09bd5ebf59c7026295e2dbbd96d0f24f4b96ffdeda48b7a39158cb68c03eca14 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 false +check_ring_signature 893b74017235d7c31422c79d2bdaf12185bd2836f45dd3c0a0f2780567b58e32 f53338cbf277f1af860fe825b230976777a56535d0ac6050746f08c0df2e1fe9 14 0221ac03734db6743f7d1d5e7a3e7c266200d9ce4e9e7b707d1750dc100bfec9 6574c6969f76d84b8083d5b049160a161cde8a635e46e12bc7b4c3221de6f4e2 954892d4ddfd8dafc10cb58404aa866826a020fffbb997dfc160edab8496fd22 61ff4118513199173b3a46861894a24ed72ab8510984ef659456dc55ef699b26 242b337651f137fc4ed957cb325f001c22b2a40a753ee67a2d42b90b6dfc58dc d2374e5c0d8a0a24ca673f0e7586f4e667086bd3338ba5aeee328ee4f5a13686 efb83ec4f71030ea886143daef3fca74b5cf2eb6565bc2a420762ffa557737c1 113c2db840cafb9c9d561dbe038afb4e7d5e893bcb858279a8763a309e0d9ce7 06c398c6821bd80cc74c469e27645213e42ad76e07d90dd5a9630fad852c0864 9abd121a70e2023e8d9ab920224bfd16daa13bb9577195da3cb40c70cba52658 624bac3facd929d34414db9e6169e3c9b911dc5ab87eb4041cd7149d5d210048 4c95d113e74f04fa208641fb79c4eb7a79f5b941e55318c267a522f90f274de5 d08e9c591cec23a9b9ead71469e5033b27dfca6499542ee10dfd46bf30e516bb b1717785b25c209b868136701d5934f17d739a63f54a2d0ac958e8bb7cc5a5de 6102b6ee1ce61c4ebffddd032886bc5dfb10ea432240144b86a1adfb022f5d0c16aaff9761704a5bc38e1b5b9268deeeaac2a8230951e6598751aec70599eb0de232d72965309361f5405272d021d5fcca5975d14e492c74d2715b20a679e8079463078fa879b3030d212d0ae002f36f4dc5ef10b7593e9668ee91f1f8abcc0d4c7f6308db0b2575dd8a9b608fe6ad5c08bbe96ca35456b1fe297e818288a80a825a4fd7bf7ead55add52269fc4f2f077403d7c59ffcad095fb00e30f6f3a109f30ee975c10f2710e9dbac42823a29627bc091f1c91216be0d5e10f52bf1d40c85cd870586ef7bca7f1badd7a7430dd1d749cf93d0b47d7949bebf6f22c68600c4703592705bbada2d9949ed2345926ec3328427e4004ee039c6b671251b5505a2715855eaf452a62e05ee693605f491cdd96dcd90e04248e9094aca6a112006148e770ac2a1b1ba7026a9f4165b61185fb37847d98b46dad32692b1c67f340a478804a9a7061a887ad472e971c3c661f2ed2e0b1ebda2ac26d34a61935a7b017ec994a3a6dc2c4efcdb32d447ef3c446ddf0f1bf3f7c55a979b1c5af7a29d0d2392981e177d4896f3eb0d79815267296f731ed2b638cd4a766a4c14770721004f42648a8bd20e85b9505ff6b47382fd80441f01cf51fe11e4ab9d64f7058a042a3e5c0ff5d4b655b1da472dee0abb76b9768b2be533dc2cd31160d53a7cca051b9b144083435a1a148499e9aba52cb8e550cde2054d9de5b5ad4c9599a22b0c7d6110afb4fead688f4f125486f8ab50eb9265431f5ba55e2d62cd62f85a580adb0ec6cc51b687bbb6297b208676f43d774deec9881036363283f7e7fedd04080d1bc224ba7de21edc744cf27a883503bcfdaab1b6ac7e05ceeff3560608ed0274dffeb411a9a3e6438d5d6a757e12608a2faa3fe6526a2d8b3e00a1f5e2d50689af01078c186375dbeafc7eab339db0b2af9707c2b8e8810ef298d880449900090a8a22f27be0bf1bedc4d1331d8abd81dc460b1ea2972255ea981984b7f3093a63b1ad47476668d6a7627bf0259f2174bf605fb9a638e439247e21888015088087b597ecf3de665e9805dc8595b0727d1cf1aa665d53c69df2f7f59890800c3c3d3fca4094e208a2ebc9710d1d034389a05ef9c89f7a09fc93c2e40b123d064cd8471f4ecd5e78a0499ff177b184cb950eb47066b7866da00af4a2ed7b410f4d2078293cc6d0e00e1f816e6078f5477905cec38064d11fc1723d343987c301 true +check_ring_signature 93b1d7b30c1409424e4282584a5d1fc6d6950557cecf2ecffd7c19afd7afe06e 76b86f6456a2f8526dae70d8ed372d6c3060d517acadc27240e8dafe8ecb7fb5 1 7bd47e8e7150f596490bab7b8e08ef8f5880add7e8f3fa91f29d45534112ac6a f3ea137c6fe209f57cb47736a56b3f24aba5ed2fb5ae3ac77d8413d40314c40ecb4c989233dd0d20a452e4c51dd9c66d4929875b64f35c1aa3a1892cdc5fe10c true +check_ring_signature 6c838ce66974cf6e9610f53c5e63034c3c998598542ae6ae493663e0a9522e35 4b36ab9a3e926fb822b7a04f45726172d144294d2ac3893b9ab426ea3275dfdf 2 c8569384b426cc7b9071abc23c24d133783cbdd7f481c5ac3e30aa7cba3a6b3e 3e4415c8f1ee444a25e4501d640c020dc4636f16401e07171b49f4108fa0d1d0 8798e3a9d2121f13c8f636cb3ac9f4b5b655f6557f7003a4ea2ffaceb09335089ff4d793e6b9fad93a1298f20bdcbe9848f6512d6a899875aae191e20bcd550371f6417f1e9165e6918bc65ffc8a63ce2b49fff099286bb70d03013abfc4130ddaa42d9243d0dba476bbb5a515fc9ad3ade552d933368a71c045f2b4489d1c01 true +check_ring_signature 2e18122b7ae793c92fc2c9d156266616989e656468f7adbf10cf991a56d7dd58 27a8667fae13a215945e94737cdda60e629374524a6f7ecf971870ab3136309c 1 0c1d4c80fea84996007a7d944966912b7faf562542dccef453a9d9afb2797875 f4f02f455e112c914e8a567d856119c29f4a59b7706ee1ccad0b8a30c8737c7a91f46f77478d2e1ad9be4835ca05c334f8d697e6fa4842368418aa8707e2fa0a false +check_ring_signature 53e2db5d49273bb204be4e069a0287844ed4c175dbc8e39dd4d82a6f394354bf 4ce610477728e3bdf02e8dc5b1c5b3e33f47287b1e8ba4e510b12ba0b090dcb5 2 6c8b3a00d4ef4f74dba7b1b79279dfb6514fabac02189907b218d574c312199f b61e0f412de72cbdf457cdd5e17aa914f996a575f3976f25b983379ed0e77d24 33fa285026fb0af9c2c9a85938b572b0738036b946e5ad1d16c9d47bc9a01d07f3ef8f4151f24c1d8b7b2f9303073032c3855203794a2f9ae035306a9b73e30e70cd812c7b7257dfd9727fcb24413755aa82d7db67279c1ce2ac7c29254ddb04c4a2bc163e5042e0f5ee850a04cfb89b7d03c0ed287a92ce80d7693ef89ad50d false +check_ring_signature a5bfda28bb84822d5a28a578399c41f066e9060977fcf35b7d5a3194b55cac45 38fa92aa896fe57e1a4e6d29e147c24c3244561c368e4141a4ce3190c156fa5c 2 0450c81ff08630e9f69026b3defed75f73b44e12632028a4c4c1792dbf35a4b2 fcab0150060439109570713b6bc67266cd2e9aac119e2ea3ac508b2704a48c5e 3a2f4626a9de16320bc121c906e4468ebb18a4ead6ea4b041cdcbaec9234c605630b8dd61c8e89c716c8003ba076c2da372a3e62acf7e0ec027513eab18b230bcf8f4b350d7910b5fc82493cf831e0d84e115d508a7487eeb1ab32837ad9b801a0dd462f77a6b239291521f2cb6c1af8ea58b5e768880a5e6723bbbe39f6d10b false +check_ring_signature 62af0916ff5dd4f7eea40f034abf7dab4ace9d0a55c13081550eb00bf35ddc85 eb064d0485c8cfc60b0a44b9b8f41091196731b3f0b209bff98e66ef4572177e 154 83329cca8ed2c3b18a3cdc8de3d7c79a272c5490d143c5ec3f363c26aeaa3c2f 29e8aa616b19a39e6e89e0124c2dde56ab808ed6d684531afe6bae22b553e5d3 3388cc16f66d3304f602b060fa2e1a626e2ddaa0b2d6c4e993eb17473c9e1192 cbd036f61571a95e218a40a29acfc0951d495d14c0898209ba06b022e37d5da8 9b1295449fc1edd73795cd50c542b2f45342b550d81a3fcd3810d153f6844726 53399c61fe902b4b9d8bce25bd58eb8401f236031d24834e2329d0250dbc5a25 9f49b1621fcbddbfed7b71e3f642962861ba864c523a0b5c64e29713a4411181 fd062e871794cdbf8b58014232110a8a7d0b2ef68101f34c2c519c5fd947bd96 f3e65fcde4dca9b431ebd3e30397170efbb272bce5722fd77533e0463e7319cd e2debd78bb29dd6671e564c772a0bf2764f3865653da01a3ca7b96facee98bc8 c736856a015af569c84651bf4a74cc7ba91a6a930afe85369276e1d1b5dd0b1a 43eb143de30c824963cd0c0f64605bd79cc7adf9eea5c7c4250ece4582733b63 27033c260b35d4d35034b482ebe734c128787a9dc4cc8c9c58ff0f069b9ca00d 0fa337443f6e29156cc4211b5078c44344ba0593c691d382d486d2c2c7a8e128 fd1873c19dab19f15b3835668c3790ad2bb91277fdaa140ce12c6ffd62bd94e8 66f209f0e0d420db36d530d9489e60df9b221cb8be773d309f1f85647d34e501 46c9fc3df5ff6b311c39d0c5f0f7cbaa541f2d897c54b42bbb9688362b493641 4190c5881055d5552fbf38ece9fba9c0f3f9e6ebb574aaa68c55fe62e0143e76 fbf65ba2a879cf189b46781b6d21e92f89a030b8f41f013270ea2c51b85fff9f 9a4c87e361940e89527429b9da8ad40e90f034667c42dfc011a3f5b02db1e97e 2a2bf2c3bf81110367b829d492a44e46197473d232d821189e6a9707e80381d2 354f6f3f94b1aea24469eeba6d9032598ffef279d4910df936eeeae316912503 9c5ad54ddda65bfd8bdce2e260bf49e3d94693b18b9bad406e598fe8fadaf7a9 ad99bc640dc9d85e3defc0101c8fc6bd464f198d4ecad52500a164081f67a9d5 dcf42cea7bc2ab0681a0979baeebd75f638cc8688593f3a995038fc4d9f50d89 9b9a0451f4f7d14d6eb2be0a45da9aa5150fc875eb67d15aeb3cd96069246a7f 0cc6ad614891b994e18d8a13439dba182c7953219f65598fec73a6c2754c52d1 6b0f2cdfb76c8bf7ab3b190c5bf05ccee3af4247ac5c932632937b657e4d4b94 26dfb5ebf126a9b71272704f61f6dc21d462e9d3feb5460ae43578f0085285b4 f318e25bac2d8b07f1cb84e0c48b218e3b6f5fcc4c637fff0eff54778c2e3568 035817ed690f7177936146e9a45ec78a9d40fbc7c1933b9c6e0ebe0b9e71bf4f 1eb5f321f4709ae8255605f7acc7ddc24879af4606083880d289b1828e885fde ba1dcf6aaf5f9eddc6445a6c0d23b4c1aedb8b4104fbafd5d120780cd4e7aebb 3d4453c71009ca67254be1042f998d6f8dd90e7926c71a54db3703992a1360c1 5d8ebaa22fdd3930012c2561a899f6a80c655f4763529e3fdc15e3caf4070c2c 2e128f0af569f2488ac40c1efae9db9eae3481a48002cb05261a68373ae8c405 de8887e27e02433c9bc47a1249945b202cb58b5d2cdc871ade945db145998460 c8291dfdfc973179162a6b27af776ed9e7b16445e6803106dfc46f228e3f1885 1ad3070724f0fa4126f8f4fde1d29da1605e46c8265096afbaad77e2552ca469 3f6756b308017d145a1a936d16586d2eba7ce7ba74427971ad54590a04ef70c5 bfb87399868004bd841311044d2f606e17a0fd6c4e247b160006ed2800a80e8e 3a5dc8a2a31706f651beca12ee1c87783dc5de45b49ee10da0038f33c3f57f0b 1c8f5b95cc85a3eb01f67da934d6ccf61ba67d89dcada0915e6c83956159ec45 7e6e33b9e98f3e3d8bd07ea43dfaa8e8d8cd66d165c4f1253f7f2581c8c69fc9 f1ba643acc93b4f496954ba877bb9339b20d2c344bca2fa2e64fb232edda7688 6f0b88405939f8254b759dcda89215f67e823e3c17f2cda272f2702a29f9790c a19bcfdc33dcd9e2d7bf3f1c13a25595ed960b38693070ad78dcd8fb58707d03 8f3cec45816301831b3351a7ee583bb99fb3a638c48410aff3b197440951040e 65e943612f3e018bc633287fa022c7b48ef253ea9a03d199763cd4ddbf65c563 17500021ff5efbe08a7ba5783c2a3db4aaa365e7d4524d58568acb33ee7505cb 589bb6ccf7207946d867ad42086ec7cc735bf09b767e30f414f32554eb7bdd05 7e271561ff36b6cadeb3d4e2a2751bad74dc04bd17cb41059aa94f84eb8ad12e 0d166e233d4316ff472330444e81b8699d5451a31b0dfd507481776ddd262bc6 a03a6fbabb406c10692a6fbed1caec8fafc432b69ad351c918b44158c06a28ac 9a4192241f8cf2232cef2e559f9e9094511ba1946cbc7f9691bbce0c1a02c954 bde7db3880d3c6bce2afd44d827a6068d8ab87e7b0a856dca423356d0f11fdf6 3d30271f2adc74a535efc0f61ddb259d703dd22d3d44614f99325b36e7d630f3 d73d41de01b8b9e7cdd6ba356bca0a37c5782cb25adcef79fa4126cdbddb2c46 66d804a345945b4dda1ed6ac8c6735b01405994311090b60780589fc5282bc70 8c458956e8e30535ea19dc7e7efa211149ef06fc1113c5fa77bf79feb9aa4255 35648fc9cf570a77f990f09e0fdf2e013fc162bdbf07c0495e9906ebc2abebe2 b0b4488060b0a92da0c3d5faa1b48baafb0d84347553c2bbcb25a8cdd267ee0c 84318740a2e3e3c8478c0cb4a8b4c36e57b8ca08c6da285844a79410f3382dd1 070a03042803061d8d9a16586ba9e07cebd2092d8f988f885bf4252aa0e29d9b adb3b2fea4f171ae5a1c8e37467dd4579e5adb86bc44f12e371dbab463f04590 aa4fba203c131c9ab9062e9b0b046410851f816a080b29be6276dfa44334ad8f c7b12ce7887c970e1d7d0069df8d732358c517ce336393e866100acf88ccefa5 f0adc7e8f5031944603fcf1f40b2f7b0fe571aa45ebeb3689738f17e64fa26eb 908b9088ac238e713d9cf2f187a0f60f05f7e1057679aa3cd7b88494c21abbf9 fa49f89c94273355d08ad634cbeb319c77085f8551ce83667b21874e54ff9a55 a4fc4e1fa6467061c54641f4d64393e264ede03ce03c5c13eaf35698bff4c266 99dddb11f6e51bbd123a25a241edb4fe829579f7d7e89c935ede6f60f92e4e90 6c566cf1d6e6057372f4576ac8f9d4285e8d160258a65f5efa4b0d64424c731a 1349b23919c62da12d9b130fac8a2127a236181f7823bfe46c4def730b686b98 67ba68943e48b6dc66918e5acb52c35db76e76d74846298d43a77d0cfec8246d 5bae800d3754822321acbe8cfd54e2d438588be5d48a0772d23a77215ffaa6ef 8f3ad343b3607ed4e596ba644b45fc97e733a0497ed793d3ffa3aab4acd45aae c4e861e3f465dbfb4bf60ef7e41cfcf6f664beca4fcb0917334e62a2f1b7642e 0777b1ade1a9d063d12f4b13bd9558328c1217d5811af3d58bce4f56f4130f44 25f48570d9a4816770eedf0cd0e6d021a4f88301a83c1c82a5ff5d99ca603982 039195837c08b1fe06afce2769352b28c46a4fc267f77899731b531ef48c7bbb 438d326c0562b4f07634ae0dfd662acada29c9b8b684309568c9fbf73f873e5e 8fac0006545ada84b637396e74f31ef2b38b9592fc1eea2f0730a6ea9d08eb88 38883b65eb7bfc9ba0e936aa8e85e7ceba674a6493690e7d7d450046bf851239 f1dcea70eb0c052a06167382bd3ed098b03811824d531dabe7fea4fb029a6d3f a45cba13cff11b3c6845d550818ff3476b3b4986816d4a9229ac870b53cb0c12 c483dc584392c6f924bcca6c06165218db5586d3f9f51e542afd04229a4eef1a ef44319a8db3f89a83fd04996d1c40cce80aeecd36bccb7c49cb0f10f03cc685 faa162778fe1f649277c60efdae12fceb793816e7a93d9edda0f512dffd3fa51 7af93599d98d50688b5fa1b0fc77bbb06c1221e4df96b7d957263fcc302b1cd6 990e6fff8f30ff6efd4e23ff4114b5a695c4cbceced7aa2f4632811ef4ff8e59 800e3611aea006e5a6927d6d729e39cdf104ffc0db791add0d2c9f1f60d3baee 9c21b43f1c6854bb29efcf1edb2ace2c36218c309b09579a3d8cc656b5b0f844 89e306109f992d17c2123f3a82b5763d32f0bf5b333f342715e1f268f3b2fde1 f9fc7f9ca5adb5a6acec5fbdf595bb3d67899bcbcf26244ca1bb961588ddc227 c23d2233a6dd52ccbfd90d05e079caf09c1d5eab377bbe1383ad4f2e6eb2d55a 4779bccb15c4688d36643ad62fed5271b27c1be86b752ef16b87179e15608977 278075105c6a351a313d97bd5123a9dfa982cfd66295bf33a3d058025d9a3eb9 a0dd758e389049d06c7feba77a3240b912449e7d9d8dfad27c7d0225330da807 4acca5062ba99b35122d4732138c61e82992aded4d45a074a66b5ff6982d642e 9a4c04b8d9db04e9c77216c99050679a04d72f5e6765c28cfb5c45ee1b438143 3f6cd3d7e0906ae8b24d198fd42e5f0ab6b16b334ff213d2063fbf6f0040b83b 31d109ac56099f9e972cfb5d8aab947150cd3e1c957548a946f3386fdaa01109 94f661a3a8d4b4594b4978c5d0b8cdab17bdb6b3d14888f77ecc07cf1bcd6d03 d3c2fea2cc711b985310a4ac2bcc9176d4dc2c37e300bf6344031b211a0e95b4 6cdc2ee6ab853b4e091a178235b1e34c9df07bb53fe2409c5d08fe1350360286 10725f0d251999abd348894f3c583f832db790bd1a449e3afd77c60331682044 d31bfb5533d076123086db63e1d297cba34f4c71e2da70d52278697f21500a73 53599b611e74eabb9369d60c854786f84cf1843464f9f7809a1f1573a4eb0169 8d97c1996ba9456e5fe5e86a2e8e08e8bdbdc6e15830ba52586cba7cbff0d2e6 c50a93571589b625d1a23caeaa6101970fe7bb05bf041b0bdf5eb9d0b86f4152 b35f37d7b95f15aa6dfaa27fdcb15cf14c5e8796c812789a49d47719c421b321 7ca5fac436230d668e5e91bd26293e4d97237b0f5022a70f61c844e49f938d6e 7885b638012b4cb5b6c041d64860ab4f1824050e5f852d617085b6af548056cd f973ab78ad4d38d8c35cde6f977db62d5074d9cbf5f0fae2722b88da17e1e260 64fbf1bffd18f4607f08eae533638cfa9051a3a20e9fc181dede24f181001021 e1ffea0ae3a4c394c19cb84a61a401c183d4e08544a5ea8fe324f477f0d712b2 a91998f76f3999cfaa3abe09a288c1fbb024f7eeb8d3a2c7ec81925d68bc4c34 9f12412424b4517ed6f5974d856a2f4ec3b908d09bb8bb33203ef2c45a34a120 b2a639f97e1f2c1d7988d5ffdcec52156b5cc7e107437c5295a43adb582263b6 910a5a25df1538a8bccddce6768c9369c0aee62c882b1a53697e6f87fb5ea0fc ccfd19adbb5009f5d66842042d9fb4d322d3dfaf455625ff465f7f39da96d3c5 867290032d9998675fe2a03bfbf4dc5f0218f60ad676932fa38e0e29fa9eb0d6 cd63915698b4fdd83f905320f025a48f037569217664d78ca5481b38f26e5b67 4837835fdd034d1164902ad97a0e179fe4995101ed105d54f47d6ae6c586fc10 a3f329331c1123131cbed064658127cf8649cad48455a89b67878ea496697992 0a202f93aaefbfb1de8f9c6b197d9149a77cb0f83c94fed583f6775ba28b468f 83af3e6fa07b82bacbed4604e9aa5f93d87e197582a4e1e9ea291d1e87c91158 4f704de963020ab2dd7fa778595bb5d7d04dac159432d5cb4a9769edc1468fff 4979e38d09c52e6486219cb4ba56279ec5a4c9ad5c1aefb8838f20cf8c49062e f43c98d1d9aa9ab776363796f5d624291dc8191ccf61b966ae96ba3d8e193cf0 6e0dcdfc9da577d3a65ee4d07ccf36cb318c17630e7ab75c8cc70c88846024fc 3c1498b30cdbe4fd5382c4c33af19513b4d94f1e4415734090818cdc28bc96b6 aa833bae5725f7d6b12c00c24ed17b8278ef8d3c0f6896e398dfbdcfd8cd881b fd2b8997dd337f7c95d07048cc734f99cebd5ddc2f07511f2bafdcf315dd0da5 3dfaac14fa684d75c29b79c59504a1625c0d366234e18c924268f888b6b6c287 6b80f9dd9a18d2d08aa9b1d3cf26693100de2196d7d39e4fb61ee62fad0288c2 16ca81fd35dc093db5fde18d078ab5cf02834314781de0b3d5d971b7689365b0 17ce1fedeee356599afe366f82585afa871dacf7c537bb9693302ae1e0e43d19 7900aaa2c7aafdbb3517acf4c2cee430a12db0b1018326a23c460cac7ee41fa2 f7e6394fa50909fd321c9ebc8c20ce332e2d4a0c7fbefb803aead525c7e68459 0e8d57825aa73e10d1c4fc97926cbc9057f89cd7ebdea5b91bbcf881d7e939b0 d1325b42c4c74e9d097b08fc9ca91333dfeb4962e149c412498325b07573fc27 db8fabaa3d17ae296b862f9e55ddd7dd26fbf4eef5d6a4615dbd79da01a98281 76c4d4c0845d3c4025b6af7937023cba46ccfbcc8e7994a0c199dc311aa4e728 5811d9bd04df184fbf130c8e885fb9bfcb9c83b1107d59b74952039233d6bb66 c02c25e3a016735e293cb059f3669f98960af05254b93c5cdb0338e15b13f90f b2ce47ef9291a75d0e5b15ba75264a74c23c88442381b257009660bfa9bfd7e4 266f53ea339d27d7ef0946ac53b391bf4782f633164019d9d5f5d57e7ca0b5a4 cda0fb76563a5f9ee1ce5725929c73945ebd5b7edb1e82706731b56b1393f1fc b7d87508f04250b79ff71001b0d6f3fff67cbab8deb7e412d356b2cc9bd28a02 4b247111d326316d70b7f56a19a26b3a68ab3d1975436b64d632ed42240703f5 a8e15d7461048f8738f6de064df6e22b0ba38289504e07b39b3e5dc53a32cbee 9d9175431c8a952e7b9ee50b1971828fbc6d4f9ee90c938e40040fe348d63342 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 false +check_ring_signature fcf8a0202fdcf0a7024db9e0a62e99f2d323d48575df4218c9dacdc6dc03a043 45bdc2b62682f22e90c115618fdb05fc708bf6e55c16c378d4cf6487d6d66ce5 23 ae7de510d614d6dd36f1a18193c24e0e0895814c2cf4276507c634402c95293e 8cb417877cae65ed0a79eb5f51f289223c6a2c6508d263c7bcd6a99af2dc2ef5 41cab6c84ed126913290fc9358e3d8a70af3642373740cae0ee89e3c2bb43b08 348a0f4a6ac5bee6e77342df78020ce2b5160f54be86b191daa9542f165a7929 e6e7c4e543f04a1351236458eed52da0823bab39425aacaa0f64f250ab2d4397 148ddec7258a0f631a8d6ac62ac7f97988e3e1c091c8ee5ecc00cd692435de59 53941c3d7571db7d937ee799c781565cee1130217e5ae09014a696bb41c7deb0 64d5f227e198f1f8249c71b3f9b2969809d45d2d69a4c01c94d9a635395c2e01 b9b8be1889bc692e345723f9ece603c925118d6eff2dbed5520a09e69c648056 9be17734209d852aa54f6e56040a353f3e735d28be6037c62e971b8178674847 e51567819bdc4f75c4d706b64fabf8c24978011d0c6eaca3905f3897ec5d5428 dfe555192fe74e99f220902ea81387c909bd6908e1fc64503756724ef244250f e9f15e665f5b402b9ff6e2bf5265285de026b9fe3a51e347380998213c661e56 3d9c7d52216543f28b1007afd06e0be9dd4fe4e43747fffe5dc862252da48ac5 d35b021155a7b6a6805de4fdb59b4c3f07818e804d85f81e3b49accc0bd9411a f4917df9979aff5c3013929fc2f8f8cf6cee048a02eff004054aabe4cf335de7 32095d4f0f34a864e1153981f39d9bb40762ab6d5dd918c43a0bb8fbbdc2d7f9 c541fa21fa3855fdab64941bb0663dc964b2547bf3b41c380a500b27641ba87c 10d62d562db28c39e9ec06af06ead01feaf7a3dfbab3ad0593a90385af022291 276f5712f11ba4c813c20640fac6cf1a69c7569e595abfe9b385298a3e54e090 5b3e08b0dc7ca4ff9f5b88938618e31d8708a550b4ceb4c0f82742f75f534384 c35c53a6c2dd3cfcd81b6e95ce4e24caa70f8be089c470f9f3f0bf8510de84f0 7fd6de27722ab64e62460a514a197cd5c4a5935c134615d3348a07c462b70110 e94b95d07b3693da26285fb2219b39ab63913e1af6eb7fe9d3454ce548812a0ae096ef42af5d03f7647944eff81f250c73522a5c0804a2df616bb10d3f8503004817830187c0341aaa7d55a6b3e316bf9fa5b5de983fdc379067073a3064440504ec4e3776738a8688a22cd1b62a7c79ce266bb1e3939e22f167874494b04401a9c78e4fab2fffccfce74ea981e1022bf7d28d5b2009bb75ba6b4f7fa40d5f0cfd4b51fc6852d046b65b332d9579af3525256ac1e59487f12f92d0d9458f6105f28c3f71c6f941899ae4b836a94c63d9d55759835ee94b0ac610e4928bbb4c0e635a1b2eb416294ed0e27624b7d40853a383dd6c7a653c87fffc31f8dc23580c11d75151c96cef3aa9d1357c1076adf188f33acc9a089c160885fe5585c3360da6ae941837b80b6fdd67188436836549998850eb4f1ec8eec6dd2a9df6dbbd0abcf522c1d3a52a1ea2a29afc5f023d42cf93dc746048276dbac10969ef9f050e18514730dbfe7eb5f1f11f82fac2a7ebdc889969da93fb85afe08d9b02b37a0c9eccf38b472dc02fce2c3114fd01311ec0c8bc75e2a29c56932deb869ee59401e339eb2432b8a358c27eb5d12a156147b1378f5bf6b4234581f617ec1d808404f16bac9f8c5ba76f8e2a6906c5b50b37f25f3670141c5c4c1aa1b352e5d47b04208e37393618b893095701c49e52bdf47a9849158862ecdf4a81bc98da21f303c1df78e79783394f6121f956f850890f2dae85efd000af8147d839ea2f83c204d4711cb26031ff5975bba9d9b60b0b3e64f4eb0e9f864a126e6445e9ec92480cb6d3bbb4716be4a3c54544411f87f7a37c53e65bd1f7c69435ede5e9a867930983d6275eb9ab06406051b7be90c8d68c65467cb2ad0e95c4d576f34acd8193001ea4c6261d37b457361ccdaaffc8e189d7510cb91f4e07e5a45942993770bc0047855b3007f8fae2a143ffca68f71fbb7e81107660fb3ba3484b4318f58e5b0ef348bdffc235faea88300c065a8816a2257e366d939ba71615daed8551f6890a62e4209f307a946191145c4812ff380ec71b183667328ca655bef5f1cf9768052c38a11a6aee9ed82e82110de043cab8ad0ebf92ccbc438b1654b129c0a1ed0aca9baf3106acbf2aacf1df670398f10ee1d5b14f8ba77e9ed0c5649a7138620e985fbf187f4340bff0f8ccf7c9221c89144853c4007255036741e9a30ede77043df33ad8542299c55a0f69cc22d3dc35467b4216984c7ec41d006c8c5438850f95e07b6b5c26eeb49c6cf827d62bf765ad69c7ee7fc3bd060f7658cae95e4304c0677dc6c7ebddc9eb0e4af729c57ba6949c6b23e567409d426013f643eb210763ef8b38a18c2196b1611b9ceec27ccc3033b9960c586ad23da51ee57b737e0372fc55afbe3f502728a316b12504a6b861ac25e9652dfe1c0ea538c4a87570020c826c968a605d8b24d829ab3e639760973f92126f7427975c8eb2faedf4c4089d9508c5eab075a58479234803d6b9ac847d2935ea17d6d127ad3c5815a2100d3d617f86b4836f709113f032eff71eaaa1d4552e1e8a7300cdddacb7e7fad805b9f3a626f23f570b36c2b90aeb2a13f447e76fcdd7731fbe791cbe305412a202f0c59691ef261098cde442df2cf474a389c52577ac09b17e7fd399214854150bdef1d232d4342a891abe1c84069b7a5f665af061ea70578b863e2919d7414103da3a1cf001140501910c5395e2a651e1a7e23fecd821eff5ccd8b4c5253cf80474a9afcbf2612ea0bae607a94595a3e3654de8e10aef92510eff8671efe94c076942f4d4bf267afa8fd1d9a8204ba078c5606ef8b75ce1806d029b5af4738a0710b108bf1f4595900a3f31cac81f6bd5d28e2410940faaf6d70bf0db80050c0546cbfca9334fbd205d98121576ed23f68770ca166f0eec1b60f1db4222971d0a3dfda453a1616b80a0e5e78d54f790b2e1c42abedd665e37040c22a512d7e102bc6a4f239553bc5793e8cc5c5cb0c60c33e72203cf5e0bcc360010d5c30da9016f42021533d5bb685335b48e448126dc3a26b65e474b0728de17e4060bc1e100 false +check_ring_signature c718221353646ce1870913b2a79162bc869c8cdc8b7aa018daf80533fed3327b 935b194d44ce4db6d450b7b7b4cee1bf7317cd99a6cf6904fae44dc2a0452244 28 8b5185ff67a8177aae023032e0b6256e7195b4d9f578a974630a21772101717e 8e5e33e4202f1aca6a1900be0fe27911c6a3c0c3cf8095f13ef398e96d7a9cd3 f2ba924c74f68cea3a85273ab1cbcdc2477f3442d27bc16da77beb48e4bb36d0 71bbef7c79b365da3631997aac2ba9b870c9067f7424358ae9f4bbcef5ccc700 b368874db40e6e6701a0f42f611486427ac4be4dbd728ae1ee48f1c446221c08 a654f3cb6922ef823099f1235be8c63b96450c7cfdeb7479dd23fd424241e058 7fbc86d898f13989ea1295f0e4db696df3990189ecd81188b59f10e061326b21 9936c83fc75b73b0aad9c53e15277386eb9288d61cb7f033144f4e1285af6c7f d0ca67710040cdf81e3632b70a2dd60d4d0b42f417982d7e600b99c237ec6915 f03cc3689a2a836e41e120297a86a5afbbff8415367165287510300a4bc67bc4 7647c5d15a428c81942f6da056761e4a940bf8ee241153cddb2dbf9cdb1e2c3c f421ae8e77cbb643817f1939fbe40f2d9842a115312d13091acdc51cf700ed10 1091072a84840b523a5db4b4b9c190ead2db33eaa2d76bb34678c0c4f312249f 1e728e13976d3299a2a2b4042a03452644abf8d9c03164a6772b9ecff03ba3a5 43cfaac6dde1a3ef7ebed3c1d161f53e3b609e788d84e37e9f51ab0a2653b801 98d50dc2b67ac54304b2b4432cf5ed4de34f4625d8b97c0b7900b6de01dfe072 8d162f04d8ce5e3f0b224e9354f690763c5e24c28f13392b414c4d69e3e59b70 0a7a56df43f251590c2c5c3012231814c2daf2588b182ed5df1a9dd1ab1607ac f8f40965945574b87392f59a9e90724bf86327d71a1cb722d5f160e1451f10b0 01b578ba561c87dea3e92357e599c976e20962b0d6775c1bcb04f5592d031256 de4061fe09441905722b18e024c38b49ba73edd1f417ada7b0aa8f77d8660434 80875fb23ab46eaed1da6aa13c2d9e929dcbdd35e3d478972f3afa27039def63 ef04ae1d61b3dea09b742e526fbc6310d288b8393568dbd45692ee045366eb6b 3dec069c3af060a43cf1c396ed72847553f30d5a7e5b87a8299afe02109e7874 1adaab380427568e55445585468d975ccc00b4ef0461881582895069d44ba20f 48ea52d4a308895c011d460f5a3943d7d4f29e59414900ec0d0fd27a55e3f488 1685d56bfe1cfaf3ac92db2b65d9463fc8fcfcf56202f22d451e74bd568b8440 ceadcdc785a5678c28f1416ebb65d1358a7031319a9461c7b44edec5d740fcd1 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 false +check_ring_signature 0b0ae2077f7662bda2e5222b1d703ad6cbb6b1980b112930825f548172610802 b5d3c62099c06d179c22bd15fda141b102db0512d79dad09b1fd551a60b84b5b 238 c836b577b56043b5a7e335adb9b8efbb5745476c16a22d2a3c5101e917b465f0 88952892aad7f874d7af0a353fd5309448f4617f0f48ec013c2ed24e1389bca8 58578dec4dfe363b779055b6093ca970bb0b2d7a268f697807195a329f959fee 028acc952d4642a30b95a8bffb20ab37802eac818acf14463f61573e0729c906 c5521667e6226c2a2f9c382fc6e3c73d263c139dee4e064642bc0fd18854de63 1a552afddf6b5413823793f9dc4f7ecb2d16fbe3a61b34fddfd0913edfe8a7ab eb1017e2f06cea06cf2559fa007563644346c86d9b76a56f48131998d8ab557d f810533db562527ddef02346e07aa46b9bb7b80bc00837a3027945ee1ddff78e e8a155bf6f45bf6c1c033ee946b50d053fa76aea0efade6aea456daa83fcbe2e 9931ce1e691bf92bce42b9b8a80aec82cacc7f5c5e376a0c51e6497b2cdd2659 760b55a0eb71d669fe2ba26fdda7d7f2d42aef7b4e4cbab54d39c631caf419e3 c0e5fe1488dc96552f5fb5c39ce083ca564c9397a14bfbeff0dddc0ee83f5356 cb1d0680a32d8e7a969f0e37a5cd106e7f110b6cb2d12595031e2a5a2baac3b8 68b26185ce302421ca17a6c9a39c578398b2f69fe59523b15db9d6d018623a46 42d9a9eb4254ad3bef5fe6419dfde2bba0c5b67ffd793fca198157cc22f0b3ca 3485f168175f41198cd79b49d34f6304824811ae6a93ba93c2208aa44af2a6e5 ab65afb7244880dc195c8af7c0c2a80675427f28484041101735dfbb0fd817d1 d7f0b179cae8bd1af637e21cd1b0d39d077f0c89d6bb31e0671d9059b8ab4686 96fa36abe158b96dec2e4de94fec46649eccb387b246aea886d42c2f6bc92197 869b2f745c88f381ff102541917e42b02db6231a92a285006769348289bcc74e b23bb5b751f07df29d23a9f7212506253475ff4a16ee662a41a549994e2c0d96 916f6243167a4ee51d00362f87074f55d6e85edef025ec05c6af5d2923b49d7f e09ac0534f55bbfdba1b1e532f8f513060551593310ef2bcdf0a98eb3641e9a4 2c8ed1fdf321e8169c39bab8b0407e9818f93d778c2c711f28377d2f2b2e55b4 7f2591e7ad4c7d7cf10b670475a077292541936ca690d5b9f3b5799cb8d3efe6 387c6697f630a76f9e9bc0d491c62b2e0658d2a33186ebe69f9880bfd6232faa e34f10a52ca206a421dc476117207b4ef1cdc297b58d42a55d6c81ad46c67402 3dab6dd5ced59a51f19ddc090332351f04948fadba30d88344bcfce88932f761 a711f2de039bcefe427177f0896a63b0cde2be4ff3ea6a5bd0a4196e69b69a91 5f63dc61e2ebbfd42f5268b3eaaec092d0a504545f1e66397ca91756910d0a06 9b05a30a51452c24377cd641a61770e73db52d4af7041cccb302655b7e25e035 5445b217b731022d434de418c344bb038f2f828174c585b208384de498c585e6 48f383d7cac2a830ba451d6015ae855600291c0b7a3924b0ecd9a10ca402df7e 1ae6d5b980131b179c80e0ba0518872865ffe21a9fd1f3a3891d4ba4767f480a b4197edcd9f2f43766addba8267467f686b455461d652b6b4322283bf76b280e 1811a0d80b54cb61c13c907a68fdece8dc56d4d3b838489be2afb06e800555b8 8c355fad2ae36c51e188375464262e16d94490699445ccdba42bc03b22388d73 e10769dab394879e46b8d7f4c04769a258071475e4243b341d8a5705a5d104be ece9916d8433d8555da6d802f1041846b4edfe56844225161ee9a3cd7cf83e53 219617bd206ef106e11c5e9eec9f462536842b5e8cc61e9fb3f59af55de25ebd a8f476620b5a88867548a76a19b5ade63e2293f8ac576a682f1db14634d992c1 3ab60a227b4a80cb1b4ec20f5711244038c0dfa4a40d380eb0c5583fd47672c5 61b68fe1b8bf7126a1466ba57528e3f99ea3159f641cad7051056b43ce25b7f5 65cdbb8b6cc44c4972d0ca322c58105fe8052af3f212262e7e1dd1cac70cd05d c0bb6ce9000a00cdccd45d4292813a3b3d0f9a04ebeadee449b2f2771cdd4967 26e83f7aa0e3202080e640531176af676be10baaf7691a56a28ce97150839883 074f087a3e42647e6becc7b441a9040b2659f2576f320336b36e9613e8f623e9 1298800094c59a209222b93ec076a292a0fe7d8f1bb2bdf64906ec928be16a4d 340c94ba14cc24dae61a9cd64154e15ea6893e7c09ea0b68d57cc485f8c78519 8dddc0656703354a02841f15d05e34c63251f0acef6143edb29ee5d049d70912 8d2cb5e2919e875b300243c4cae56a7e4aca2c3fdda0c62798201e76bd957f92 5646078daee837db178cc9614d6df4810a05f885210656f7eb9d79cba3cbbc90 846ed31c753f79b83853112f0172c4281c2ceb34dfd20f1eb3a4af916aa3169e 8b3d79778824b3326c9e8cbc4279752327c1bc4ee2650fc60a8a1d4e9ce0f45b 28110f0c1d133a4b3dd957a7e897542bfac43eddc0052009937454371835f640 53d14ba04bf383283213d4cda72f01fb5154a39a6a8f836f0f162d71f3c43686 3aa35828fd146761c4ab9461f7ced2d5381af51ac206f845fdec4c3d7cdd177a fe551e4b205bc38ecbd79f37be15e461bd37376ccd653c4364a8280b7952a816 1214879bf5ff8cd9020fff56aa2e9fd922017223f4d63de30236477ef02228ef 4f3f529b0be447f43ca21ef4adb125ec5c2f0d6a9cf7778fbb9860faca17deeb b26e73eb349abc766d25139d28eda9e5834e0ee14fa0e2039db7038326ac25a9 1c00b341e093c7065a1142018ec13b53b4e71fb0eac5d4c82861d8b91dd5b12c 3f776a05692e669a57084635c8968167fe2e1af87fa65937871e99f89bf4b469 f16cfcdb2a8af83492ed5fef970f4bc4ed889a31b4394b5d7e54d6f7a9a90bb8 006d5646b5b8b76643a1a0b29dbac886e1a9103ba38c20a6841c3f13b8871d68 c38bdec1730ed3b2b1b26e47a6ddf67157cc81d0a00e47123b01110259015f96 961815836f3e36238d33cd9396dd1bff25872436e5cfac2d359f9058b47ee1bd d9d27405653016e199cb9174a05204daf35a3478ded4aef4c5223215c7f63362 89ae4faf87519c27cdba3eb4bdf1e69e96d6e5bec164c4c8a98923b86fd623b8 0f34c5323d47a51196fbd0f940c1829d225dea07f4affdbba0c91202ac721973 fc4832b9ddd05abe379e201f09e2b80c43e479fd588fe37378c011bbe9581aed 29378aee1f918d648cb2a45a8dbed55eb75b923e58ea349729952faec4351ce5 e0b8c9e4366ed0cf8dcfcb1b328997924024665796d08733f503e77267d222e5 e6cd0a5a466ce71da22edd2516fe9801452f341483cb9d5d8f197a5b4a07aaa3 f232ee2f1e574cafcbc2dca08fea5c53864a61e482a1e2f0f7ac0e2f475a4fd9 d9f6934f8f8d100472f2d1feca174e73ff7decec861cbdcc935ff9b7723ab351 a05b0524275f7de10afb0678b9a3f0ca7894d5af8d2fc3b78a144989b3966687 1018cb7dd8667b35fbba580862c7c33201e724cbe051a4970839c04a4586dc05 ac32a7488345cc28e960c72ce41df864a0442f74c75d2e43a902ac9bd4d278ba 18decef621f97761a1eae28ab26ee14da402240baacc5a48d8cf35f17968cf4f 9789eb5f8d1f5dcf333f6b35da0b8150832ef477e2d8fda9fd6ded1670b3d117 efb24596945ce8e0db2ceff01a04d735496ff515bcc238895a9260ad78524959 c640f0a11bfbde22d40843a5520d9f56abe6c3461c61e4d08e90a2c85887ba8e aaa5110472b6443de170afdc530002c5d708c36c55f3a4b91579fe78c2775550 7db81fd2b09f654c25889ec3afb065894fa829ff4b0b9faf0b6f7edc67df029c 776ac6a4eb41380cb4c304c7214b69f6120f0aa09cf147dc36a4bc4cf04c412e fa16d5f2d085c466c8bc2e8c4ccd84c1276c6341c15d7c823cb539a4c60b0aa6 500f8184ff093fe4ac88bf2e801bf0bd6722a8b87f32d66bf38c45889bcae123 74c4010855c5aebcd184c640c7e9b41cb27c33e8e31d89b9a16794d4d3789fcd 9e53a00c85d8c60deaed4d1833ac0b7d7a5fc5c39b45d7d8cdb35fa39ccc3814 0eba149b52163c6ff75009c6ba7d7289bab1b880535aa754a971f18fef7fb3da ab6e6e7542d0295307011ebfa23581b4dbd9f30380de996b32f38000ca436280 19efed540b6d05cca93aa054e9f84b78d341d75835234233539bb0cfb30acdfb 322265c158ab69fa5b8e2c5a76593d648f199c4f3dac541748fc0dc046c1c4be 360050b593931e8e3230d7a2e79d7f894d96f04f5c6a3e31f7d5c0ff2cfceb32 d18256f8ed12b84a12f62aa1f14226281b422636018a51a7a966982d1ba0e2f9 894a50119814d3db021462a9ca56b3d35948cf18c37b7deb3ea95a2fb523a091 278b8163914d2f1412d440d2b700678847a39ba5f1f50a7ad3ce2709ebd7a299 72af589f8224f57a3ab84d0a69f1733483179996c3be35d0c9168f44a3b3651f 2c63b2fdf7f55b62632917fd1d8c4d8f7b989b6c16aadab5889dd2d424a25799 97ae87473c94ac1c25a3dd90c24be7be4d8285046e060e7b86941e36ab221695 3af3b99a1461974a385cd770177ef9bd84f36c11bef5ffa3a3fbee255ab0493c bb0de73c689d15759a5482fbe887c4927ddbedd5ed44289fa4ed3377098cd65a fee718afc352674c79f3954f89256a8864d76cec8e94c497a8ba0975d0f5a3f1 81ea847d6ca34768b5e309a5a1b912d1f715fb7aedba3c5094a6913a0f7e02dc 0023c603aad954ad222cf54738330fcb1989ee402889f6bebe5dc3f47775d9a6 50f1c3c93e359e9c80989effc15b93e2524772e458e7670f27711989cf82ab69 4e004e27fe40823fc76a8db72813dd4babc196233007a5f44ff7506c3eb243ee 144dbeed30c52af443ca9468f6dc32319db61b28e40df869a18ec480c8209b76 7167c4cd2ed88c8e9fb9083a0e660cc578ddc0b3b78e0d4b4c70c6c02a82d120 19279fbed5ca5ce1379df075efdd34a09d145fe822edf4e919ab19530d04b53f 586024c8ce450a1ed577ad010aa594b9123c5204829cdd17783e01f2357c6875 94da6b39ac2ca6dc64687eb6f6bfc162749b8a694b6c8235a184a60b5f814c81 d53fb872165b04f759cb04c5d428fc3e723f55203519b569fdf8f1e0550e21c3 922e0d6da18df43810357e6ba38d505ab1762a3d57b3b55efc902bb266dc6e60 1cd62f2e0579db4529133d55cbd277dfb26ff5352dbc261273c80c27a5201f9d 70f822aa7a846de6ae7d5141c8d1ff8c3ac3410d1a6e560b84c558a848dad5d8 8db8e8d03dcef052408c84a81843940bcf687d38e3ad268274424004e294f76d 19f242c1b041b6ec179cb20162fe5bdbb9c2fbad036f280891fc1ac4ff49dabc fb145866a9a69a4202c9f4f8753cf738a3e75434ff076f2da6f651905e85b4f3 0c8351a09095cc678c1e65db78afb6c75985bd7ad11943f62c90b315a32a53d7 18f5ee12195716a4ba5f43cfc213dddeaa2ea296936ec1e71a698f8cdbb8cfa3 8aa8d4c4b710d82155eb53b81df69b0530d9b6a740f56a3c5937fbf35aa5312d 581c3440b834c514a6c996d62ee985b7f20b4e4d4a19ba202565833c47ac02ad 9035946c030deb8eb648b9a2ae1ee556ae701b3deb952cfabee186d04b653bf7 c3263b6cb558ee49fa7e28a03edfee099592827d3a7a30dbf17380457b0c073b e24c9631268ddb418c5899bcdc293cca1c87c68fd8d623ae13112c53886f1c41 880e643914375207c118a2263c9b39aa705a7a534acdc1e0e94b27104cfc9d2a 734feea041197c63bb5abb32d86e161f39e8d1489aeda8aca23a0cdf271e9b23 80919380f078b614823a204e4fa1ec8f3e4e517451d4d6a012111804a021df07 bb456f5b12a617bb3a9e6c173bb95556f8ad9648fc0fba460731dbc3d47a19c7 05a7098ace4dfd862e543d3e440e37e9c30096aa9b9257ecd14a4b86bbe48ae7 2d714a0d7228a76a73d90c92668621cc1ffce966650facfd7f73c3a398d95086 96989b91228471ff5636f1621936df49af3f8f53691d5977e6a6e9af4c92956e 671c605f8c35ff06c04ac7d350438e93b431441827f368f636b0d8eeb7dab560 4b4be02dd6177ac2802e5fbe6e5fcbc71c1b8360b57056c7b1ed0e5bd44b1519 0717f93923215388815d85d34125eca9c5fa829e9f87120e045f64088f39e57f 23b2f77e7b4ebf39666822f98a50dd40f3cbaf168e8a39ddf8422768ef3c97fe 2fd01339fb35362b72fa6eff23bb2139965d71eeee45f189f55addaac01dcd6b 5dd83f0ea83945d6c872ff09d1f74b133dd1c3de3b97d62a9b7a33f638a93c60 b9ac0c03303ae68f72f66200fe165f57381ffea91425cabd7e3d4d3e03142ccc da9623018c880dbf6183d4c5c41f38184d8c0525e28731f84911d00ee75dbeb5 8fd79ddd4c90dad1cc85ea8fc4f05ea95879b86921b6c6fb72de643a5725ad5a 0aad91ead5f9c18437fc8dbff098b21a1704b79f39b93bbd58dee9579093554a b5d43f697d021c75e04a6d4eaa02449bc5b1c3d8217c838fdbf034208cdd6562 4a6c43530af781a15e1081659e6381d96514bf1a96d35c886be3ce3670dc23f0 ae301b8e26b2ba53fdd66630c79684cf2d6d8863a7fd1de832892a499b8e6db5 1a70990cd0db5f75884989c29d22b61de5fca6411026063c6344011aaec57767 f5c020f53f9e1835f7d69b7b4867b8bc986d043f151231442baaba1cadf72462 02bbc509f4eb2e3f965836d4ca8c8d1b610208b67fbac2bd36386250ade4f42b b2db863733abef5d81d5f81edcfb6ad581cd96833a7b2f7e43364b6232672ec4 e3101e5dac895471ad43577ddd819b798794526ebfe701872a7eeb7b289ad42f e811073bf731f5c5221f4b58dbd3d7220ad88b621acc938320e3f2907e53c94f 16e57f56dffd691650c925e054bedaee3c41590770b18a5d9dd832c411cd391c 8a584d72d0e22ceb56b5a8800fa08d9bd0911a100ce146b1d3a9f1b05fe5d0da 5e5e59f39f51a8a8330dcad1b40da3933bcb7124a59aa43caf3962e7c52db264 633ef6875f4406da9f51c2b93d02c9c7d03078f85b544ad667e67baa2593db8e 0ec198f694e7939a2607c985f31ea48278a14cf129431b88a2ea1af2e16a24fe ba126e60147656aa24b58b25965ae4754c6526ed10f9cdcf48cca3855f45eb13 adb54ba1f991739a2c0f89cf446334933bb5aa53ba78342b4ee3fbd89679f651 16156de2694ea69abab0f696eedf3b4f2c9f61e5047f42aea8eacad649c41d8e 98706bef5ce682d62d03da7000f9ddfa8916afa980ab5a706a83f002832c571b abad677494b55399677b5edd7213c5caa426cd4939fe8a446324ba08f2a4af33 89bc3a2d7bc5ec92e5ab93740f5b370963b394fc6d347d4ba77c14bec9a89720 8110846a883110dcc3c9c5fd44ab0a534831dc1801874aedd56a4c824138e89d 5f546ab5f771e1a29c26730139a8ba89e1802097bbed9807c9c3c2c751df1c85 848ff8984328432f8563129d342d7084f6001de21ba264db1adf7b9517032c43 e2e973fd149ac6d49dc8e0a393b2b2c1d4261bd1065da20b37c0b2b214643831 65e39a736a5d260ee5fec3f8bb63ccb5e258530a13e64e5aabdf03d5f085e982 2d118d14ae5b5a8c65a763332e34d79b9536683c829f7fadce929b68663a02ed 8d50ff8e908397b719103f27a263fa84919d0b74e9f95c4fba4e0bc03b7a82ba 030b73c79f0c4baa71363b88c4bd43a7974d61e07e33b94362b7097e49145320 748e64d531b2a99a72ff18d284142746a0f003f0b734f94994e0fe29eaf9ed68 044389b618b10b81487ae27ef10706a03392cd3479c38562cd651a4b3ea6f328 6730b8d5a0155f0408e82ffc429f4492a133c54c23b74135bbd957219eadf413 fbc55977c66ab74ffde909980e0802e005dc1fd78de8df41a3fe77f9cf7eabcb 50d1447993ac6ebd9e514fbc9ae2a719d0a911e3a73107ea328d79d9d7c558a5 679e0a61cd332615e2efae2f3e7050da8ebcc76c63d071096002acd255d24c21 232d894bf524a6e2814417fddbe12cebe28d9754620fc04b9a5e4ab110f76154 ed30e4739ce5e9f6bf32b4c0c8483435320971092254712784e2e1804ee1300a 78a55342a5558e43f36cdcb12c789fdc59ced07a6deaa1493cc01b62fd79f13b bf41eea2706841f792c9a4536bf61cf914d009d7e21e63aac6c8062deccdc891 1e4d95a20e97eebfb875d1d3c2329921b4d44c0ada21b713d94904f6b8f3b652 72b50da9fb4201d63c8ab548f1f10c9475865a8267be7895c2eb751a3a873c4f e79169214edf4f7510a75ceb497a53bcff9c603efccc0b721e5389e2fe682f8d 348a7f687d680e78a92a4d49760e59fad6d8b2adf636ba4e04742195a628088b d6e3cd66e21c0bdb2f3e34d23fbac07a699d6a33c3031043c1dd23a7a92146a9 35824cb76b19319a7cd916d0b180f71f38c03949e6093d26203de9fe78d9c10d 8ebe929ac53fc83597bc070bb316db54c0620b9434346f952d358b0ef2c78949 4e64849e9b1e4f6740defd1135b29de5e6c2fc0dc69793e310bedb987787890e ff4091ab2f13e8b41a4f9bd8bd6f322af666c231d5df2f4bd9dbebacb6487fc6 254f05b3f679fdc4c9462eef9f4bb3776a112d251d8fefb9a213cfb5ebf8c029 02efaf2dccebdf4c29090ddd24dcc2f5f0dfeb6031c5c8ef4d48320b630398ec cf7a6d5d1919deb1239248556da0c4947136d6df401e2b4d5e718c6de23a8f6d 7e609af6daa2a85734a95e7f388152fca23e75edd0034800d946dbc97103b30c aca644892cf9289ff70f3c3a92323793507901e6f6c2fd92650d1e236a3fe1cf f93e492e1d57180bb389878715f3b94a71b1d3c70376bd20204b414b94dac1e2 8f4f8ebccaa1376d644bb2bc36a4e7c1ebb76aa3d5d84176a273f58ad71c9e2a 48f6f435b16c9bdaa4dce5d77d2200030f85a86c5d641d764fae282997a18e01 c29b8d7214a15a5e087bf384b8fb65b06bb696992d72e05d1a52af9f9117eb3b 68a5f84ad60d45f6eaf8657e3227cb7af943599122d1e76509a2122c3f687b82 8a8ba27248440a19d79af8b764ecee10b691100133e55c04994b46fbaa48bb4d 52896b2abd668802df0043c43ad3c0f77ae65e7774342fb2a9233cb546772326 6cf0aa85594c070240fcc03227e303474f093666c480d23d8133d48c3326ec89 28ff7341c7a4b316313c5f106968340fa8d3f8f33e348534313dbe1a70e87166 1f8b557394a7c7e71808bae676e218fc255366de5a16c4759b60dfc6fbbca894 17193450a73d9f64bcf72ff35a87f1780ba79578dc86c17c41c364f69db70453 fad0e78a0a92ae6a8a704a449780848702cdc2092a3e4e5b21c68e0d48e0490d 1f8ae17734ebf26c7ea5fb3e72eb79705d5fb3d9e73b080fa307fac23a353ea9 1fa5dde96ae0767d981588e8b70f45fbf9c5be0a65cdd8ce34748c54af38f7cf e47ff6b106b7c4504f4372cf8fae905ca7756fc649281cb9bcc1b58b9e37ef71 4519581473acde2aa0a72c9d6431c13dc09b5c6d414150544a7b9b497e1e0d0b 389f7936477fcf4a017c74813c4489f38f7c722dc66c3ffc8eed78f560a37fc7 a8964dc4e54746470629a211b5c091f73c6250d25f5960c9cad0f2dbe737de4c 4687db8a11ba9e3be2b8c1607adeb1709b8bae9b925f37f730b03013070f7a5e ad63004a24d640aaeb37610343733a2cdd3f0a4587758a2dd4e96f3b9cc7783c 221f909d356f8750d0873e5104e7d7d1d1133cfc34ec182b9db806d39f60df85 8248e3ea7054737ab997b2d29a79a0728209c69e627f821ad116ee6bf6ce994c 86f035b1b9ce498e9250e8a5cf0a08757e01995e9c5fdbcd7111f208df89e2be 12d009f934cdc3f2dae7554bbd0c0b391f38e29b976ec45cd1ace78e8931849a 6e51313195fbaa97ffbb5cace94623dad3425c9464bb4172f1a5973fc2e0dd2e f579e307bd7bc44a962cc10e286d1d2169b0da81a3126b3daee71637d767b471 80efdf9266f5b6ce5d2829511f2ca208acc8ed0d9652bf1c04f1ef81f8d95082 7cc3868b1586eff60cbb69e36c37c574c31a6e0880306129e99c67d8210d95fd 67d545088a3354829fe62bb2d5c6970d65b8dbc6a99766b6866251f9ff34e6ba 3add6c063247b816a5eadbe899ca952589063e9d21a422fd7ce29f8a8cca5325 5020c0a1d4fc450e6327436d0178cc092763ba954934e2581d912d5ea4d5bb27 21b6578f49c1cd0eabc5dcae0d33e2480832f445a27b61a6e170bad0411dc2e9 291b832a88b08a6fad8c2b353a692bc9f097070d401e46fcdc2b7f0fd4b88d71 d7065289b61985551accb16d9c1effa8f38a78c7f8b42e8d11effbaa290c7c5c e24f7647cbe230816e3e3042cde2abef5e411f38f8ee3c0884e2d263d9fae66c 146187cbd0b590dde5642bb2b9d6c2e0134d6eb5db188e8a1bbf6532420c6a29 f499cfb75f64ae162d8611827e14b4379dbf2a4ccda8d792efa48e889375cbe9 f780b4b482bc20fbd556ac9c8a856d6106d10e0c8cebcdfbe3604ed794963661 6a8468cda7755874d478360df80e38d968d257f77e2e83fa62835bba308fd464 b62adbd124dc1fd4a1d69e058f774e41643c6fb64420e15c73c2020d680c5794 e967a72b9f6a63ae7093b80130cd8851d03a4a06a36d896faabb3885005ac234 23e2da06fb8b46b5110020d74464c7165026f548e06aff5ee1f402aef20c6116 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 false +check_ring_signature 1404e39f6ee8ea61fe70edb9d798c4336d3ef33f8d296c117e96b65d10aa6949 c2da94e891bd99438406b7fa4cc045cae5ff5583ee60447b7a175549310336af 3 bcbbeae5a9709fe6d7f962c090b46c4decf8db5fd3a0d2eb897982a7491253cf d5fa29f371b1168de0679da37548977802768da1ce5ea7cb0c5cc101b360fe62 5fea607c4fc7492ab06be8b478a122b8ee51c47681d7ee3d05803412426e213d eec19d933adad4d92979beb5f275d60c704181b809db8a82fe10fe56ec6bbc0c1db67d1381cd8710a27c9717416b5c8d0dfc6c06486381995f109db01a13100ff321a3b1c09ff648c0afe8c72ef9e54ed71d1bedf8f2969d73d06eecfd21da013b8099c72b8e4f93ff99337101a951fb8e93c7daa719c3c046977827bf6b560db4265664c0117254d168fa118bf5aa0453da41518e6966659ecfc5a9fd2e090535f78c62bb34c04641daaa3f6a85b0fc60ac502870b90edaa49a4c1f8b75cc07 true +check_ring_signature 2425c834c1662613c6a73cb2aaf781c020a62363bbd96038aa0410af93bfbebf 4254df0622d3e85efcf3ffee6e14eab8954692df1cfbb762d317aedd0b3ad403 115 f21e7df265693eaea9c4b8c44818a110fdc8869e0f449b3e9b1a0ce57e47eb18 c8aab90fd916a674cc196c000b86a7af1b130b070b261e179427a7cc61a7c482 14867a67b0a085acabca02fd0267de3fa68471d0c8a8753fe8b93eaabd6f44b0 a5ca40e3b2c8bca473cb2b3c0b8c7f3c6980d7d17ebd85604d8a06f46ec0f39b 4cafb90afbca275caa54af18e1ddf9d24b39aeafd455b9415c48ef4bb8b9c359 cdb64173c229b352118599a5656f2635322eb7e77a4659dc8cf8496dd143bafe 9f26bdea59241ae843b208dff3d817ff54dd66c3da2334f675e73a14701fc9bf 8f0b5cb9963ed97e871c300cb5fa086b193102e41e5d618b2257cfc3de47cc63 dcec4c165af81413d97842a086bdc8fcece9ba70ac2642f2699913f0705b4cd0 083a31fb7baeb304e4be0268eec5afd984a0d5df8941a391d24425706e9c6c38 45f758bfb64ae814f836458b7c3b7b7fd0ef93566dcc0f55170af5be49f24db5 cfd491a6eb91e9056479f841c481d1fc0232a27c313b130f443bd603740292ee 561eedf667d01df5c6296804e3a1e0a4fbae178217aaeebb5cb4d736d0812fc6 278d39a6ae654e76f29e91b639dbbacba5bde880d496c70814397cd1d01c51bb d8fdb62a08a52544b2e03f2f791d815aa6807740ac93ab9708ee0d0a084da36f cd86874944820185095a76f1700d9f6a9353c18a2380067fb450bf0c63c4a65a 8cbcc936ed550cc91b6f6a73f1343facf6f9326455d708fe8636cad07012f34f 8c0c4cae15753fd65f7e1147a6f488faf8cf3903b006a73d0db2034ff07599cf 56069f17845fe692d19004bf5f9e4c0cc04dbad96b1a72ba74cc753335f9f05f d6d82f0d92f0b00c66b654c6f4ed27acaaa2e5c9aebb35593dc9ca52efdf0e12 994522fec3890c5c2b8eaa0746145a99d4cc6c17ccf0e9463950bd80e0fc600e a02dba717700071187c6297947cbf1fe3f776450469fb879c609758038e9b85c b2a13f08aab720aebe3bfcf8299ca0a255224b59d063bd616f396b3e1d5e4fa6 d6c415c46e3b43965bea029c9e9c4982f617ed70b07aafd5b5f3ee3fe4caf861 f2a472444d3e84c0634509891b7fbedc4cacb000ce84a27cf40fe3443339d163 f4e8c30367ad38dd9d529805fba09388a9d2f8c553f32707541d8cc165700691 51efe0acf6dc9747b5d8c61c33fe7bb21528081a51ff2024f7cb445d564a4cb8 db5dd0fc40412c9e19b84242604cea309a253280295cf90dfebbcd9b187b66e7 85efea3caba6a39088b49514d95b28ff46315b0c3015d99702fe94493cff882c 6581683df7f1a9f3510cbb92373ee04710bd03d9b7b411d0615c0f99c0f30331 e115eb93dd687018ade65d9f6661eb9fcef2f7da018d6b24b589adf571303eab 5451337522191b4f9e59a5cba8855e88d534dfc2f1bffe30fde7f7610b9536b5 a187984a872d10622013d8b366cda785be1ff8e9966db31a80593726bf57ad84 e9974d9567b3666bdd3fa1d8f3ec5f4bd79f290893a5e2040f415cf55b488b11 5ebacda1f9f35b06955891ebcfa567562415e718e753a0a76c740a7185ae0f03 bfea353e2f50bf53106d857fad7994b4a8a9e8330b427cc33df3ca04280c9de6 dd85432ba7f24fb1054927ddd350c2c8d6b0508fbf7531c4fc8591ed60be8dd7 66ae3b00c4b5d4a4ce9c77ee870cc86ab589205018395737801bde602c47a7aa 8fe8cf1b35bd2f6a195515333407d3bc2c31d5c3fd8f04ebc63e68c7caeed7cc 8015d22bc9fb2f482ba80608b7f1bcae66f3aeabd6701cd8754fb2da413d62e7 5ad8edd21813d246c6e53aedcdb0e63e94b3a4a07430a1396e5892f2d85f0575 7dc3c5ea2bc0ce44f3385fa4b30df9e0492a15b788cd2b3763e8d5191dc17450 318e59f22b76902a7b8ce2d4e8a30159a6e43d715d77b0175fc74a3d78809b69 88974f26a2f4276ed72e24f7b14450e6251cba2c663cbd794f6eb460fbfa6563 f34a5288663d694ef25230edc5b0a755503aaedbc5455cac60fced14b4f1da23 d79dfbc80c2450f8759335f3470a83ca3930fe99a26f576b692dd24f55f5e4d4 f76424918d4a54600379a72a446fdcc636f615bcce773bec2b26ef41c334416d 286a03ae011406b948e818758f067ea47e48ac771d5e3e44506550b834e7634e 93cc75db4762a5ba958a470370f93fe337f6baaad4f54bc0d3e7074921ebda1f 57402b9af0d80c96c5fb814e95253d262f56792b6fe1872afe691a1238e51224 48d44345f70fe6f8b823da1e3b949b4ea42ff71ec553941058cc62a76f2d69c0 c35d5b75daa348b791b8b9ac8cd15b2a50c59f804ad39f9ad6fd7a6b0ec98e04 c652fe8e2cd24253aa46acdbd9d34cdfa3ae12d12e5834158fc1c13e90ed11bf fb4741192331c2878b5155a480166ef9f9be33031d6c2639796865bf1090594a 90d27d8afa623c20e3c1e737736a0acfb14dac780a4a9b885f4eb04cd354d071 4bf02e826b8fdeec68b317371b1820712fcadb46cf9b02c18c3a320b013b5049 df14cf5b362e1d07c3d4e128327abbaeee7cf96d54f71327b289f7637bba5a94 18caf22b3bd1f5117b43da223048bbe37f264f344f38f70cb855ec8b36676996 0d096ba50f9e30dacc4f9acb26f3e0e18eb7091aff8a4af86b0e05b59a1c3c0e da5998a6e1412d5d3c12bb43012b8424473334600bcb67299381e08d7233bda8 f09775b4cd9543667c0c56c0bbe05d462d741a04aa55552f669150c29b13a784 452fceae8437344b63ba764d5c439ecfc4d9b3557f131a81d452e64e2e8141fb 02c23c6ab912b316f58d4bc6adcb383df274a9d16bdcd488e86505b2e99e1c57 d51a0007261bf0c3546b45e6ad0b48e6c113c4d0d4d46bbeb2cb3995a3b4473e e7d125538e9272c41544977a3b6c8e68247d754845eecaca16f853a64403e91d 242daebdfd493e541f6450966839f8dd705da33110175eb39e75a3b35ed1b42f 63d59c98561b0ae391c4c0561be06a30d26567b6465b0d5c8f40d519971666bd e822db39a4cd0046f7e2e1585cd78721361206809a99671f3f47b576c0ab1e8f 5cb05f0e9f35803136b30965ce8776490e616db224efcf806a19858fcd89dae9 930a543e53bea48423ab82c72e4214d884c4d77ba4855074b2eb8cb31b2f3659 6fe868e30ccf0a7547b7600aee2179f43f5f9e4e001d348a21e234fd5c2edadc aec2d25d5e7ae9c26a69c76114660f61ccfe7ceaf89d4deb2730e586ca947d17 0463212c2dabb8a4634738f52392da3bb56dbaf27b5215e9a5c8a2f0cc4b0d52 60d1d5b65d46b21a9555999560ac83e86c8aec2ad3ee6722271f2c13942e3711 984eae1c3a3bd278aa58ba2f84748d870d633c52c04f031a66086d7ef967462c f9d5ff2c3b68b4b65d3164f24bb6fafb53670024bf20b721101c58ef4f24ba48 6ad1e742c475a0f0b0cf17568ae3297397599df42993996c93549788f635c102 cc2b0a8a60a6e580f5d6dba4b079321c634018417981b5802e186ac8dc3b452e 0276d4ee119b12df7b60a97dc657278b0c1466f99066b31946bdf88e38330046 5c548555e54ced5529b92ffa616b356ee5c54e6d662ca9a1792569ee7d71a494 9a8fdaf4623f049f2bd8f4eecdc15c846fdb8141a877bc62ebef27c283d0b47a 00739ecb1f56c5e03b56095c51fe06f1c085928025f4e7f035f8cb863f17a477 917cf2b0157a56c646589c56b84079246c08e04d45c740e1162b2f06c7b2be03 576916725d9843396eaa5e718a6e81104da076f059db60b3ad17fbc551ed8620 0908028de77f27023ee3eedfe42b3442812df0e478db36e270eef9beb3ef53a6 7828dd366eb9c9e70767efb858a8e5d7140791a38aaf068085771c72e27b400d c6365d427908e91e2852b553f56694f5e114c2463318206fe99874d70d202f2b b9c0f84ea54057605a9c6048dcebd3723177c365916c773b8125ade5d341ecd0 6449521b464927fe0cefeb0e4921ab7fc00a1d4e8d3a9856e8e91851b740bb16 c04edaa6f3397c92803677e95e38a1e6d4aba5842a34543185ad72b3a40375fb 4e58420ad1492de6dee707157880934e25d5e7a509af84948355047004af9d95 9417172f55e7dac8fa88353555d05541ab92b589d793710e95e7b607c59201fa 94fb6ee58bdbf88202e8d8d6ad72711a5cc7578a390ff714ee198dfc6c2b6570 fe1c3d2c0aa07ea320a6d868b98c87b9498890ce1129ea050995f6ca1a5e3715 75c7b67921ac3abf605d3c8e78562dbd22ce0b042d87da750fea38b4f567678f e7a51068a532e0874d02064a0b021f6b633f5e5a2b302c3ba0789265a41bdd78 09fb1bd81a64daaf908f534495f744800246293d1d0c51f42c23548a629410eb 452213fb51fab56e14e410c6ec6c9f0699ec4ccd529fe9fa60ca7d9e83f4945e 96e9bbc6a9b0f2adf133bc3a6b64fada30046c6c214145a041c6786e73696e52 d69234a9e58b05adce13e768a68d3024f0f4ef3a346faf90235e9e1bbceaa6be cee357f5918d97d9fbdccee15f346981f729df36713c614f403c5be6c7b0ebfc b14ac7a219309449bbcceb7cbe99197eedb39489bebe8010021d1ea237ac32b8 0772d9ebd5e5012f7799993dafcbfb44e31f61e58c99c29cb5c2a9b2f73122d2 ea69f937d1895545a9f40ee3533a2502d8a66aa8762f33149e41aa51abe8f917 71b6758af91dfc138a7c1b4d2fc51bbf400040adc7f2ff4782a8532aa58a4582 3c2467898e5cdd4df82eae87ccea2509cc8456a8ab0427f3185dedb0c81c6127 92fb3a1bcbe51656407033366eee4673f1304330d79b34bb0869f0c9fc096643 6b8196afee0adc37c5da9773c1ba09ecfd81deeb0936b5fd4ab3253b5c65cf48 491dba067e6c20aa0e250f20c4408b69525110c1aeaa71b20d2860ff17fb02f8 e1346c55da38e76729119e842664c50da636702dbd4c4dcda5ae1fcab96e5eb4 d4e8062dbf51569dbd75d582556d288c3194917b8fe2a9d265fd5fb08f973e51 33833f5a74eb72ce179793c909eec68c933002f4b9610520a32fb3a6bb07264a f843a4e0161a6f75ac348f98424f2b42b32eae64bfcb44d37e3ea63dfdeb63b1 c8c437e4948f852fce64d5693d22a96b145ee52315d2404101116a897a345a84 01babe817e14be9968d4227d8791d17d0787cb033454dc5dbebf9fda79de27a6 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 false +check_ring_signature b2e52161b9b5ec3368fae241457af6f73803ab754e21a00f047d92047c26bdfc 9d4c3f1130eafffa6d2d1979163b3596388f9c0331b927a97a4e559d2f018f7b 1 d8dd5f602f3d8fe98abb8b7e35563361944239734e08c62c1d5459cc4ffe4408 b06926489eb45ee496fece954b9c4329666554130f7b29be29a993f617c3c302c5159353dd7f6ebd83fe91f3b266f388700396458de75524864c2d3110a2ef04 true +check_ring_signature 994143a872a41dcff222926568492dc435942143c3859d6a75bfd9ce1f8ba3b9 05f653aa263a123a34efa89b7a77879d7442577d3cd1b09334d0fc04acec7f27 3 699a506be3fa870d4ae9c1c2e8ed1963d06800ae0f4e4ed450162acc155d063d 25a9b045afb98f4fb7533ccc545ae9b9b257c914c326f354dd73b74bb94bee65 b9f561542e9aff0aab5fd3dcbdc592e6dd60d4d06728d3211401bd2dea1acd16 7757520bdb8d74f120142f7538b9b91dc1b40570a1bcc70b8278ccc04df7d80bd0f6734ecfd8f7e18c1ba5309d9886141be65c0425cf6a67bc65763ddaf9f30166551991343a78844acd3d7727ebdb0230724188d48063dab5e954bcb0ac7d04ea2dab03654cfef9d9c03d6859302f809aad40d03f1df5945e8ef96a9c7a5d0b3d8133208b74868efd1574be852028af43a12db9b5e8bdc96651b05fd865f50f97c6793a59e5d1e29645b837e289847630477ddb24f3ed27dd9e0ebb04117a00 false +check_ring_signature 95945ae812702dc0800b1b133d3798aa641e3217bc034832cfba7132bca21037 f737cd3588acfe15ed05589d40d00ab996e71d81409b0c61cb738e152d0d29d3 95 1253652b6bfa52105466eb067358d94ab62ff31e1c65740594ee54b5aa61c581 440e1fcd6535dfcb4b7590767a896743f4d6fb993391ce06eb059d370ae53584 bc2464a9dd0c66f4223e11158cd2a82259a4a2f827ce3f0d0fb3258cdc3b646d 9aefc52782824367e07df46aae28b45f99d50ca8b401121d4eb5f08d7211c98f 5a01bd9a07516653d6c621119590397f9e9ad327892ec688c681e265b6df50b8 d0908adde268971bf7ab4b2238a8154d80b6c459b4e32e4946059658471fafa6 c23df0890d388bda7f6eae8177d78202d534d13013371ff4a9aea453e8ee7321 2f8f06b253685e7b609a083e4681fcbbb52663879a300b1e4215788822d92ff0 324b37dc536d455eaaeaefeabe473ae667ff5d05599d3968e09c3aadcfb5006f 7b460401a8b91ad56f85b780fa9f50495faaec5b7360c99c1f6548369920526d fba88f9477e3771db452ccd27ba7ce96f5e5a76ba21338bc6ab115d736c19f87 1f0af292863abdbf2521c994fab8113ee19c4f321c21b7dfbc72eee0016b7a10 13de8d7da2e109ec1c6499aa7934370ba1753893cd4ca76acb275a3ab92d7956 a838f24cbf215bb864fb469d47442bd6ac298f98935a2c204c1785644aaa5e25 28ee5c13cae0c723289716270b1398d0350c02585165f97b88e1b7db19743d1f c189f1e13749c4e5b6c260a6dac361e7b961e0e9f9534c925eba0fea8468d556 f809e80e3544954982e3574eb97039f3aaa536f29753be5f9fd1eb5334c319f4 63f786e7b2306b7ab235f2bb041b97f153d7a7e0e768ad97aa8f68eeeb9a6f47 f4846ae6db35d3802f3819738cee200551d1e4d884e91807f7914a7c235c9352 d2bf280ee8d6b1db7f72720b0188dce439da67bf0c9ce5404a96615d239e7f8f 2082c619a2f14c20b454f37b6f0f1d97e2b315c17c4a0def22d6761a5df10b95 b8124c71e93d2396c4dbf3b67629c9f2858209034a3432bf02b74ef5719c3778 6bff3f878efe4a55d7c7a69ad7a8aca22b8d71a01f5103c5a10c5b5ea6c02550 c163c74efe965a03aefce8424aa14ab40f1f0e25381eb5959f10f09010383609 def0bda494805746e55b6629abe3eef91539bb587bec943900a2f9afbcab43de 1c6a0d7d43f11fff8875813cb8efb11e0d1e8040d35b4f4fea32856bbec8977e d725ab3516c92fca29c596ec9ed1627549469efff8d78274705137b5149d5beb 73b44416b75e21d9e160b28c245463521a133633b3b4421749b5e39e4daefdbe 3c38ba28c0dc64be11dddf300a903bb08b70926ecd73630b68eeb3356933cef1 da176dfa83103037ea20094f00ce2f9fc04180a927ba30a38a489e4e08aa5156 a38c740bce470f15c92cd1ae55242521b09234b4785c351516e1f0e1707c4161 53007e8fceca002d3caf200d9830977ccb11a3e467b9e7332a5262ed351bc8dc 66d15182310a3f0ef49bcf447ecdcaee5e704821b5c0ad82679dedb18cbe6d14 e4ed338fa6b18528deafba9dca4c5e5cffb726b1c0a192fbce3d27e134b9ae78 ea74e0c198c4b28d9d8fb1a736f26891963ac296cd2455320535dbf1146b0bf8 994c93dec2dbb2f8e011e5959b2bb86958664f95d6f8af000a7c8080f0deb559 bc43bc99eb850c5594f19ed3f8ad0b2ee8dec7909a163b95eafebf7fc7de5db3 39b9e98b515fed939146f4cb594a0ea6be11f095c40b72bfabda849a1858c665 55bd1f6039f871708a5edb1b71112e197f0ae131b47350b963e76716927e39c1 4b6052a074b85282a709a55d8c00792a2394ececc6a0edebc97d99b1d1a6c86d ac8fef56cff77536cf3e14a9d09f8632bfc9408d78ce4a53744d3a1a0f7da7f1 ed3487997589bdf91e89d734c1fef7cacf3c7ce2c8978fd9c27fea457ce86be9 19dd2f54da6d58079eb4a167c497efe951c0049a8bacba2a5258f98186157f29 9fc43f8cd77588470e31a231141d8a678a7c3b1f4a20cf498a58e306719c3a86 981a2d76e9b75b9665b26b5b9bb0a91787ce39acb83da2ea2c684700ae4571b8 564d5ca55cb8f4f2f0a7c7cd44875bc0575f1954812caa012dfe19e8a9fcb7b2 1287d4610b56cf4ceca1f164d78c3df136323ec464748ab4d54e516c713d3074 34bbb3a3916bbf9a4b2fcf9a91f093b1194ff0f1de4d92a17a2c6ea40cfd7a0b 50db09f30d7304ab87742c8645f87090f0ca2c42dc7c413d25e8848bec2d1e68 e61d65d69d953798c2a90cd28fe802f9772a73308c293344be59935a5a73861f 231930039eaa8bc3377188a1c4e0640613d4f946af70acdcc6bc8a88becb37d4 cf45dfa863dc05372c7726f380c8a14d817d292b886d390de3f1a5903a1e41fc 7ed4ca25550e802cca2d617b6a58d1ff849c222239bddd1d8e3b78b16450c4bf a92b9188b2a01dcb7d75a614cc21880caf09c9d1ef8252bd5ceffd850add920d 3977956751f73a6d6ee0b396169b6f63326516e8d2529db80511f5d2f58877e1 cb2217fe1c8223286f0b560218ba68545491bcb8cf3edcf96854118fe6dd6aa7 fd6a167c12dc7e84a6f3337274ca8160a7548d67f38d2be296b124ba5f3290c3 efc4accfc9cf7bf12b24b6c64bbb810e4d9f4a20936dc5474b6f26bf2893adfc 96b815bb0f600c4cc68d1fcdb7c0b4c70c45f91b8f94aa6152d0a96f79abe510 b8f8b1743bcd46de65fd6048f9d8f8edab3ce72a5fc9750ea1c007337dfffff5 fff7b9e9c9a33b733eed150a7128fb0a99a4520b7f72163ffb51955fc421a7dc d102b447d96a3f4c7b619cbcf9314234dc924b1789fee700b4e41fcecb3ba3ab 6eb44fda7d286088d51c38e3705c1c621daaeb3d7d92021a019aad5f53c744f1 d061fabc7442f130bb30a00e15e8c391bbea0fa00536a046114cb6fc106b6c3d c3dbd2cd63644b23f33b3b8266dee7206b98c4a7bc3f2efff7873a649d4320e5 7a162aaa40262735a9f2bbe4d0e7e5496d4cb2729b08cf961d11605f4be04ec4 12262db00d583ecd4779c148d7d36eff3d1b8f074e915f89d3e70f7e84a110e1 c8b6c6d096e68798b57f222345489a2678f532bc6174bab8346f1b698a74c42c 630eac3f9fe92344ef8fa73fceee58cf239049ca595e617603844d0a186306bd b1e4f487ec022706ce77d4e5a4b71af6a0b8a25cd0a0624ecc34a2de068611b4 298051d27e9052c8d03c40e5ae61856e41885c4190ba8d935ed4335a85f1c107 eb137df07c93e19c79ad03e933287eef3d3f7319b27aef8f914cb873b28d52b8 32ded800b65054ce16e62fc079165d4251fb6cd2e9d152edf228e8825ff199fa 6ae0e64986cf5870db14698853af117e094d4cd3b3f8aa04c2ffc0cc00c9c8c1 1fcc2251bd7a4903458ff5bc2e835de36ae99a1f09981bee21b89b321d33701e 3e4d904b0228c85578d4cb408a12a8522ef3acd66544e4838139ef47b2ddf288 c176884948da3aafd00cbb3dd710a8fe2ce880c36cbb2c87236992adc46aa2ec 805b1f9f3a99fb70beac6d9da58adc38a18f3a0b578a16e7cb2033d90e8864af c3c324287068d3197a7a5409c83738e7b0150d7230e7d416dc8eae19b0cd56fd b6421cb476d46477182dff6164617e06d0b680f1ba3e50c0cd942429b282dcb2 bd1107bce0c1dd75d1fa50538a47573760749fdcd129009a387f862ac682a4cb 3924103fa33491ff2479fac38eb71e8350c92fb443a664da44d359826f282dc6 f5c1a95337008091a616fb0544fa9f79af98d20045257b5d9408da476c5c5e28 ff1392a6092343f3545a63d46f27beb2cef9e9b75235f23630cb8bd0b40d6eab 5f07da9b25203e9181096abba91d726245297af19d943df8ca3a2e1c4ebf6472 1c4b25112dd7e19c959c2bc98daf2c96f169010b629e183dccbb99fe7dea4ea9 29c7292ab296c1e536325eeb03a79de1446ff891eb5db718cf952821f596d8a2 3ff25ce61e0f7b236475f495e8e563825c0f32ca65b590f702309b357e409b7a 45007241fa939dede382208520f6c9da48a796d6376c37e868c44158d3cf6961 f9d97dae850a55c786ac66c5669937b44c8219fbd5e5b6a87fc253093f7569c7 2225f2f93f8fd06e8eb4601a21fb847dcfad84abc6429fb4688d725083b88c87 be2e05b1a60c214c75ac2115054c477399b0014103a2cd4c26f6e2a9572846de fd58bd56e7667ff1ae833685aa678fd08b2f7aed2bb2d7eb4d7162e4cadab35e 3172f9b961eeeb1b098c84838752f2d9e2ed2e3f140df6af3ac0874444314ee6 76b9c01693129d79d7de3fcbffe158184ea9a5920658bc3dc4165ad8a97340d3 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 true +check_ring_signature aab2431a31b07e53929e6cb25c44a3bae43942818e8a602b70181698b2aa196a 08769384a9ccf26c6c36afe908af02d999881471448607612ea51ffbaf939643 22 4b47b9b485e0a0463163fab7e05a6cedc3a620b407a6cfbaa2b3020885a66d33 8664d52dfc39285e7b116a8cf2c1c2998f15e82b7d25699ccd7106c2c507c0eb 5076cb0842764c8c073654d944a661b048622be4179cd33bbd0e67701d829e2e b686dfbe8ba7d6a3419d25dbf1e1c71424a4b3cab621bd03dd312123a5899a6c ab2c6c7dd0e8b6720808c83ba34723e8de771786119e32d8f3501af5db4af749 5e69627817ad3b57bb0729cff5dec24cbf26aa6deeaabeca7dc08578f92c495a f2f16abbd9b02f75b03d0ff968f7219673882f386bb6719a87ceb47d8e2e338f a578a370bf7bc82ed3625080a8d1650a74e80205eda0e88126d7a844b4cd8fdf ae35b8aecd654d75264a0ff566bd19f6fbf5be15009e92a884a1adba77d5596e 3a2be5ac07e8caf096c8afa4c9780097d0553e66a0f98ec4e3561e779cfe84fa 1e937926b6698cfc90df4c5259830935453b27d817cd5c1c3caf71d17ec154c5 b781b95703a3e97c57bcf3cd47c3dbd8fc2c3a133e9e031bccd4677b10dbe6d0 c47cd6240c6c9c2f9ee21467ef625b27bd47baf65a7408b1b25e33eb835809eb 4cd3b74f0610ffdec34b3938e93192dff945331771ac31e2e3db984e262b6c3a 35ba04b2d71ca83cf092d643bf88b1e1a4c8c75276ebbe24d7b150677d57dc8f c299fbd2fe907ca66c0312f7e99cef46fe5aee540eb2d486bc90565bc28d5292 782c9b32061e8e56c47210bc47471de6ed85273fc4535480fdaba1c2b1374f09 dc102afa6b9e0e05f7141105b3e4fff6725f99b5bec69b14a3dd5ebc0b54e99b af3492d86792603e8719344d2e9b9187f69a448ca7063d04786d07eba0e7bb1c 3abb90326269b8f2d710d9afe7dd2cfd7fa2d041bdbe62c4849a50ea10e6b3f1 75a1cb14efe17a2d3d25ed77e9e5183f1572daee16d8ee1444ec5209988d2093 bbc7d21ad6ec092096f1c11ada626d9f0d9aaf62ed69a952e58f5ef306e7bc22 a09d58a287da3563bc41939861fc2cb61321c9a5f78fa3fa8156c40a2234e100c9f1f352075b67bde44e0ba3fc1db39953c149484faa53180fd7b6b9c5bc640ebfa6d052472a056a0fb84aebb4820602c6520c1a81fabc357716312c9da1c205268e23b0b46bc66dae263bd5b2c72038dbe084a29ac410be34320028d87306046a92000d9f1a8e33ba1d27b40982d67f204b1d9b9b87b49cae8609b0b28f41055f03dd099b6ede0ae6a80e082dcf4ef6c47b8e8438ebf11a9489065a1a6545064b04d495a22adbc25633032756b23c9a67a449654aeb948c37f2139436e7cc031d81cf5351736aae2e31d624ebf69b1c752d99da5791109c212e92494346ea0f8e6fc6b40a7bc9c5fceb8ebdc141a24398f3b6cd7f5c89966efbf7d64cdc120ed641ec93bacd1803e5179111394598eede84181566c60398354a26e41474ed0963ccc397fad0e852376b4f348fc36da3b95894b6dbfd50650a73a22e9701d2010109f34b2c5a68f12ee4f34a44f779be42b6dd23ed82a807a28591402f7c350e8ab7d6bf98095fdc5510d067cecfc7e1ac32db8d516015bb646c0a59eaf95201aa70ee8dc4faefe7395ce32276c813b662a8339bea6c60ee974f4a74a510350a5eaa8ca369663787fc72d77ea2aa4310378fc45c848fbffff32b9e9d51a8e800c796c0eb19196594193a58cc5bdcca8323ecb55c7fa2c502da9dc5eba86b6606f2f79717a9f7c5136ff945e990133f29db8b4cc4301acd62e9fe7f1ef858d802cdd1c7ec15d8f20d99a7545ae50a361c726824de9c9c7d3ef77ad3a1781e1608254b80f8aed2ca3a852e2dd5a03807cde3ac628266d9185e106b7cee8ed4420a227c562f28c3592bd920d54f4c8b3ed9871d85f4d418de88511e5b738c4528079f627220acc237521673c5c31f420539b908f8c335b9cc90c7ae6308b53edf0e08f43d20e5262e6d27051867ae34532db0c1989191a9aef1fd285722cf20a80fa9330e314a557cc5464a03eec3704313ab99838756d653d94badc05f832bfa00584ae931a2391767bf0099133c512c687622a6cfb967df58a381220fe81bbb0108693d51e2c9c8d84e6b0d9af3660b7a95adb786cb2c302b0e6d71c17eaf800d5837927a99b5d10a16211d1160593094af7392d1c76ee331e60c786ade187103ba4d175dba0f75c6b9a580474052095bf1bb9898c4e15bc12aec050e6b20a4033f486f28a06dc6f327dface0e4bb975355ffb32ffc33a78278a55fcd2ef49306468be087f8a5c87846f9b0f437c6ec60d219c6f0b662d5085d078ffed8388f0f085c58a520a89b740f2485606fd0037b5d0adf98980b6c2461b1c98468d84005917a78a0140fb7d8468a3aabf18109ecf73b61abc32093745aac34ebdf10cc0f0828d3db7ec16dad2c63f086b5e44f414da73fa9f6e95372d3415e932a10a80a2f9b78baf4d814f2039b6e2467f296a680b5b42e8d584fb661c1d9166a7fee0713f1139669bdfac09d7b9c2f6be10bf7e962e73f4fcbaa040f6c797a9de32002b9eee4506973426447dc7d84db28603db4e4fcc565d0e804c7886d61a18dcc0341cdaae8656b48ce2dd59eec75a0228407a25ba0a1e2c2e63e3266f651fc92060e4a5c3f90873b1fa8ea45bb7f6e114c9f2cd91ade91eaef4fc9415ef285de0936397413655993ac5da29921f307d9307d3cbfa0f828d5ad04d412fa73fcfc062df7b681c2869095097d4bcbdfdbc35fe9156a5b50df9a83707ede6c0c5a600a4046513a29ec4ac9fab3a9a74d4a834e58cdfdf3f7cf5e6b7ad616694c944e0c11e489b75be4e24bf5f560f23a5e0443635ce0f3fa8d920f011e554a64cffe0006df58de25fdd1f57cfcf1a20d24291788ec7d4a80cee93802c55c46684ce2057e8761e71aa1e9a55e414f04e53e3e4ec78a9aac14fd1a06cd9117bab0c0c50dca386a00447e04f80b56496a16b674d56eda82cd02ac2bef90b4d5f991d17d04 true +check_ring_signature 3744f83417272cc1a3437a19e87f18040e47ed03d7206f49ed0c5011084cf453 49d63590dbf51d444f7ccd63b187785238ec89566526d9f3b6a62607d6d11503 14 7d76e58b98c69e3d7e1578b2ff0b7971d8d0493843e1dee6d96aec0ef5b5d34d 65eb296c10d41b187e38fdfdadbb598f7f9733ec5e7fc891dadc83dcbff70968 f704934c51c508aace64ec1698325b527e0be2fa30eef2d4cf24af7002011d80 b6707ab274081142d8cc173dacbc9b886ecaed78d9ad6c8be8bc6395aedaed7e 3824998bfdfaedc6d940ba8aa39800949c27ac42abcb2299f37872cb2b6d1505 e5e6b6194d9f3b59801bf0845c95d542106b45ba38d36e3ab2566831996eec9b 2daf990cf8edd24eeeb94803b8afbefc62bc982c6e011cac671daf8e067155c5 8b5f761bcafa477149d7d116f601560b518cd265e712cc571f4a233d01741b94 8c58ac854350b4745cbd07313e852a3176e388b6c90394b3e6400c3d94af366c e83ff2962747247e87add6029507dd97a886b17807158e0382ee4ede0a6fb26c c43cf34302f43b24eb5889a8efff02565519cc98c1863eb341d1318088a39412 569b1b5080b47caca9b0aa2ab11d89f3c31494a835c4f30748dc2a49d54af667 92bfc7b4bb886cb6b5028868dd973954b61a0bac8481fabce315a08fa15f1d2b 7b4423049181e507680f94829f222108ca679bf81d9a675fa44896dd9ff3276a ae4f40485999a10461bb638d5e8d1986de26fbb79348bec93ae4fbd4d40eca0b91a95cf5fc86195e2967241aef95188fb05d5871151a0367902e302ce9ec660ec6506e47424220a0652e97fe7ab1296a4e08fe4c4a622e3db4920a55bf0c990ff9cdf4c777db2958bedbfd225c8e2f547e724e47007453bd2464da43c314d5080d7afdc769743d76b87449462266bce2d067fa28855b8b4e5123f8a7d06e730a345552249eb06a7a9b5bbd9bc05ec2bccdcca2b532e63959f471c05a76f7a50a276f96372ca9aa8fe6d1676f4fac70ff4b30af8cd69f2bc18444d9244e7ec20f846b32566d096853561c0ea53d1034a52c395c98f12f8d56e6fc7cff93fc3e07b5a21ab0bb99b8b12b9db0a27e1dda8c00f290d795371c3ac7f96b037869520fbf2e7802b7cde84801eea9fea3cf22edb8a0279b47cb0ba07b3dde678258ba00052ff400b873f3c8cb0c7b12b0fdf81011baee5819642aa1b5283afd2363fc0edbd16fb70636a70bf4ded08c76e23abf2118be58400234cd39cbc4a352c6f304ed646bcc4d762419846acd9c24bb7761d94b32d638fbd093cb2d92133a90210f41344d2433d5ce08e11526c427c8c7b3bf2b2a1a06acad7ec3431a62af165409d0997ee6ad04a31d5c18aefb9227a6521a7cdd016684cc0a9c097ba6057ed50aa260a9e41f22c986c3bab48d4a0112be44860f08d50b21d12cf9e008afe2770cbcbafac43337c12b9332cf0bf127abd143af0307560d042a072a690ffc55df08f541e76ab09f1b53f6fcca4ec92f6352d2fbe85359f56816a953b196acc0b509574d2bb0221588742214dd4f96143b2db8af1314bdbfc5073b4b4a8b260aed00cb943bf0dbddbeb025be94f241a182a12b7a4b3c472ccdfac06c47ee114f860ecb5183a7a78bd14ffe678b9393ad13f48d94c7e46a36bbb9c81cd47530f6b3064b48a0d709469d787b845dd49cf78363922299682a846d2988bc331a1a9af306f6d0fbadb25cd3f6cf0829aee05092e0f66a4fcc208801b900196302941f8daa75f70133d55cdc05b3933d5c6c7a3a720cc3490eb5294f26171cb3e151160d01bd23be02e2494fec02675857210828e73e7e4b208037d5982404f3ba11226302c01a0d6c01ebeb70fc51b6f028b8411d0370ef8f13a07085d57f79abc8eb0a0ed3135481bb51c6838baccf46fed3c0023aa9deff11c71e5af84838a6835d2b0a35aa34ea3b1306d298265ee7ea1d11d65f0ac241f86554a9add2a29927d58a0f false +check_ring_signature 7cde12ac0c27073757451d17e30b84b0afa126fb07834ddbe7513244e6d7ebfa f83180d44a384f65daf2326b5708eeec091b179d9867b662bb1bf0e2612b455b 4 5d6389f0558fa1478a0f10c1dd259feb09194f8601716f22dd1d355799d62a4f f97af9e41f740e4e2a58c65b354b85feef44fc42a5af06f248742e00a28e5016 31c200da6d38cb9c84632005f3b0e14c34191b52581fa63cfa5894e42f3bed54 4bb5707955740b8dfd8da521686881a7838c5d7597afa974828a897217e63c15 3ea28558b4197cd94b41203efcabdf57635df7ff2978aa11deb47d9d80bdf8060db1b72be8b3c3935ce3d51be2a06e62f841d3cc6070595583a930a0d2f489083db1b7f6ffb111695644614260cbf2920fd1ae6e0efefc152d041b29f6ef95015515505d57a0a2cc7b3c467ee5c262f5788bbb9e1ebff3d4ef13bdd84762340b2941ea53bce73f1fcce920a2a1cb0e30aae1da869901971b464c102857925b0763a6c411fae7b08f78434922d74bf2269ae3c2727989498098a72362a3abfda0fa810340f492996401c9b3adfef06e720beece774529698726872f0fbbc7170faa508584d2e13c562fb8d8ad184ef9f4dc037a9cdca09971afaa678db9f13caa false +check_ring_signature 9103b9672fed8cb41812c986c69027aa4a30535ab28ed18f0d271ac5e032d6a6 cfacd7681ce783496aaed2b43605e074f34308144a3db30caaa402f49151b5d8 1 f93dee7dc09537b5e2241d7d444c10e4c2584dacccf4f7916fb9372ca95e458d 583e7472390c812bf28f64d56f398cb3d10c06bcb2586b1f9c8a663a24e90a04f11c37d552e4e69d8a87f2a256f9a07655f242333b70a4aa94e927349d6ed501 true +check_ring_signature 35f7b7e75c1e7de6cb0aaa1d37bb75c64cf81c5eaacd381ae990a5d46903dd91 edc57b8022029f3d68789192b3c4dbf88fdef2041d4a7ac772db2b84372b873d 22 bd94b63e73835a5432b6d2acba4c90e3db988e539b821ba2cf60b3667e3ac7cc ef417b3b4de887649ae2b4f07069cd3f59d3ccf6d0357685e862bc5f0e5e9fc4 178de2234eaacc6ddea98060a73265ac5697bbc1a06202fec0a519786c769a08 69182f8cca69cb52527ab82ef615e16d80f661b486ac672e4feb32319a6d79c0 f0bbc723ef43ae8965100b48ba5ca6d3aa9e1f34fb2d3953865989bb6d1c3255 56bed5102508c79282094a519e811ae1b888a9bbc17aa9e3e4e640d9c5fd72b0 393d29b230c168ecb61279cfb2326891f78a65c4ac7f2d8d9bbe04f3de99538f f6a8edad36bb734594ab2351076d69f3a9da4ee4d4ceb8ea05ca2fcffd994749 431855643898a82d3fc71725c8c522bbbe4e08409572a8098faffcc30de1a0e9 2ffabc4a9f969608f27e4fab2f934eff249e30816296784ffaefe130b6af26db ec12dae609349fee20bef45d5495fe1ddc65e23933046b1a3caf6f07acb347a6 4ee516b6e10afb840ff2195d6554f8e627d24888a8771769d02008fb27308bf5 ca2c9053b9d80546cbc386e18037e8fb2acd99e9b99f8f9aa3ec0f975d7759a3 8142bcd99b8a6e5b53f5d0737ce77eb052c9a66ac1551a0a9e306c074fbed9eb 473f20d490949bb50c7f6a13c9b8ca62cc8a498ad42bcce80e8ceeb8d2cdcadf 8a6c8e7944bd5d371af4548a2910f7a7c907663a67d203073c02308ff8ad2fb2 3be66515f9885e1169249dbceba868da247d083965ab23bda74106b7cb5d1883 3553bf18432cf50b24b1e43fbdb5feff17f088203167c58e0e50f9f05f28a74f 955730a1f691cb5e0a4697c6739c5de74602f9e4a509352c2217e9d64dd7cb46 27383bb63b49c87d3d61d4e38525a562f3bb3862a7f5e7dd6aa335366f22441f c0d79f730f7430fe2bebe9891a041d9d95cdb8b4ac3ae265c87586f1a8d3e053 b401e6f1802f164f0ad72120155c789b5b8f26f7ac5c683c98e76f2e60cf6230 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 false +check_ring_signature f7abe637668845f6ad1ccdad5fd7db39a4b7d8bf96166029e04bb386adfc0331 2577dbfb80b090cc299a32c02c49541aa082e22d555c60b66e7c36c21d101751 1 ac8e0fbe20fb55b45547f7af5f581c41617c8049ac11a89775c6bb716905ead1 e72c14c3e53c49f0787e44c0aa173fe124eba68ce69b31705cbdbd2021086d04a4171a09ca61bbc376c4c4c646bfe2f7c02956b22142034cf5070b5d69cd140b false +check_ring_signature 08949dfbd51f606cde77d883eb6f9d416ca19110b2701ad94f1c9e07468b41d4 f57135751dc5ddaba671a2df388f1236fdd04ead3c6b80cc393b8ca727a7413a 4 510ae31f0da5fd8913960edbe8012e191f08596964cf271ce9cfbd76e0df7f2c ea1e3b9f6cc0ae02b2b760bda6eab2d1515f7dec9e4dc84e33bc8ba5863ad5b3 efc5d6a84e1f39643813fe9f4a1fcb429f6793f70bb654aef7d6ffe609b78575 4a300e9573f92058d473a52f15317d949d63328c20426e32eb8b27fd66eddb52 76c2f70b0ca17d0d1be02d2fb4e0866735634fb024f173ecf0f40e2173126c0d00b311540600fac9427cb4ccc6365c07a355d0b35e4cc9533d5c2517f46fe30ff8c9e1b9f9a91a4d022c5e1c0031be470a9ae79704408793a75a4096e0fa49058013b00a7fe095e5082551aabfcc13798a5094f958719dc6bd57aa3116011e094a87413dfee8c8837837125c67b4eab659e4c19cf63f562cda93d8c095e37908e094a8bedb81652c0bdd50efa299662e477dfb1961a77c79ca96c608003d220f19532727706b4ba6c1424cec106fe663981625bfb2b7340bf050f65f655505081c184cbc625b2020ad6501165c05a272e852243d2b28e69d66d8ea446ea7e00e false +check_ring_signature d3a90bfbe2f0e5993dd93c1c10f01b60f8c8c41d6d4b9c4382e6228181e7c151 9aaeff5ac2968732b8305ba961250946eff69529e66237df6a67a0a63982a233 1 53f6b9470331427a9f0c9ba440e70dd24c6dce9399f0989062bc614255f65a94 efe23b2a6333797d239403692216267c6d3a868fc0b366857d379c75ad4a9e3024280a4f66e00635e554206c051559706d468300f985f182fe0b3f0400ed9c08 false +check_ring_signature d893b3e6f1348b23ef6c8c05c8c45f07f72c777008100e9dc8a1d980d37e191f 51eaf7eef9b68f8fc71836bc060369e4bef87e4a0a11179fc13b6df9ce4f9049 86 76c1253769256f955b0f6262f05a1070f778645432d9ec77f3868c1932329685 89c8c71d2cdd80643444d40a5e93232ea82365ed60aa768d6a27347e385ceb39 7caf32682bb45c8f46e9da6bda7e40c294887a76f88280a1d0fc47d9c3336af4 da95f42fd04aaed5d9e18019b5e24c7865c4b5f00c09ff6c047424ef3f068c97 fe6d6c13c92554f96319efdad58abd227825009b35ff66a8e0327768756aa4fd f3e3f43676ab028699a2694212befeea796faa3a04cab451ac43298dbd27158e c147ceb008df08030306c65fb0f52a49c2b3ad90ed753af73ab14756a63d0dfe 5fe60ec5dfe74b9dc801ffa29652c6cd38922cb5ab4b33ab6b0970c5b7746eda cd2baa1180b732a9841019b439a036260fdb76679116d43497601eafe27bc68b 7a0cb67549944c3b4501d404cfbc9921c4ef19d9c539e4d7881cd564d18c2844 4b0a1154ed9625aa061e6e3088a545cef4228c0fd66d8ccbd405731c9cb4b920 ba5ab5b4984c23e5267511dcec3f6d4045c138be2593294f990e5de83dab51b8 043fd61cf8500c82a60b94e700fa4d50d40d1ea7759f8d285dc96d48cae367dd 4dbe1d778b19333d09d4c4e2d4db4317f9a95c0c56a89b3a7f70c0fa3a962785 083b07f3e5bd7afd3df7d879b3ab14d4be1b6f9e6cd46c7c9fccb01ab2695e40 1c517417a24d7d04e8f4cedee854f72422120fc6f74863d381cae9de4e839505 739da8a17c07434d581ec8e0ee41e5c96475656e40389a692c134bbde04ecb8a 00f77685546ac919717f65fbce680d5cb809f8b2668d47f02074e6a2d7ed277f f39687de32e02da5743f3c6110aacb74d2c55a454080d53106a2b1e238c1c9ee 0b069d166a77f7d4b218a48165b8e1ee55c9be40ce917c0cb051c8a85c1b2b61 b5a51e06df2802ee2d96e1bf335c81c3cff79810dfdc84cfde0b1edc724250df 5f983cdb42354ea06628c21699411b69f9ec0d6e8a34064cbd80161e474989a9 e84e12c396677eb6a44f8301b48155cb2942ad64fea8f278bd1252ff7b300cb4 e899a4ed872ca35b0c75c2f724f0402323e180e604c890f00ef49560e35128c5 67fbd075a3901867d6425d243cc0aea1c66cb54446d3d3bb307a7d4f3435decb b8f23de47e0e8b8e5c5cbe735aaa64273be2ae60e0243be459534fa42c0c3860 7dd2859dc83edd781ca362e448db7df683c868b47d492d14a5b1a181265c2bd3 175094dc958395514813ee56dbb5a4408ae232756becdca6bf11cd8fa8755752 cebab02e691de22299e26c4dc89058b7e24668678b91817cf49cb61545caff3f 1262c63dcaa802f13c73c76e0713a54d8149e821280492a2d92800ef79cebb84 5711aacd3392e5cd1ede5e67add30624bcc815dce4484ec48ee487187bdf62d8 77958a6601ede5da6d217cc4d11afde56352ba7d17045ac968c5b78b6556eb5e 4595ab8309e6c9334f70fff223b82bfeedd8a14ecececa7164db32876279a217 16e788a1be11f91938dd1737b9cc2cf4ac4bee3d69f836948265085821994884 3c3f65e17a96b57303bb1076e7193515056a99c5a00cc246f1547b541175cbc0 72819d59372f2028c18179c35f887ffd43e0f198e36c7f5047c73e9e8811cd3f 38634348d65b39ebef1b36f9655613003b5b9c8d4ae9c669d1add385e811cda9 e88a3eb13a555e0473bbd0e3a871604834d8857cd1d1d7136e852f6df503fc9d 052a7ee648946fbc7a03362bdd432f2a7c0bfc218f16eba909ceca69e1483e90 384e98015c4f6d95eb0235a3fddf4bad48a8ef50a3ba2cc050718fecf489a1e3 f2e2f365a380a17ece854d3c01cba1f473fa386be9d94245d61205e842b14449 bc7e376ff5ab6e40e7abe9415a5382ed121cfaec5695fb8dc4e595a064585199 786e4f9de78e110065b99467b9072c43da12035d04420298834c35b0111f4111 edbc6ed5b5e0df0bcdac6fbfdcb6f089d70c653540fd4e55e35d6c6efd53a32e 56f3d9e5a8caa180194abe2617ad59f79092b279c66e47f6d29f4b9c97a57348 4aab20c433815785ab986dedb3caaab2ce6fb27dd4d171b9d29885c0270adb72 0d0de485de1e8ac335138fec34b15c2492371f00244115b21e85b0ce227581d7 602e37f97014fc8a6177b3aec32ff1905c20ca6fec865668af03fccf40b663e4 a62c7d23e96c2e349e528296a442ab8bf7860a5ceba8601f4403bc817bba68f8 312467e42cf0a503008c9e0d2dc6c84aa78ffca4090423447891aceeb4f4a747 33144c4cfd377331644a639c9d543815cc0436591fac2c1a882fdb62bbc958cc cd9bfb61c9c65209c5e2f2692d1e657bf2ffa75e8438f0ff7220a3a208b02e2b af2d48966c7ec9b7865bd356c1f2e5ce677241234bb26e2e5c7b15a772558ff9 219ba3dd5d7ffcdd351d9aaf27cf9e692606023937b80dada0b3dd33560f7893 dcd8368997b5062f1dbd7e2258c2e53b9eaf2bae9b5f5caebb5dcaf16892569b 0a8024ea3f7ce4a0433fb137ed0f07996b2c0933a6cea76bb9cea97538dd3248 5ae179e4df9ae5ce7e618c10cc584b6e97f6158d62f2f09c20395dcaa8f56ee6 57f06cb47abec6ce36b8f940fe92dcca6d486fe8c8fee42b03ad48794484bf0c cb787a6a50093292a193fdda67cb7cc6d5d2efe320e555b3c34f59a2576448c2 f1bc6748f1107c422746bf7bd2ed7963ecd1065a28fc23848b92a212c1fb1f4f 3185654066267c1fd76bd11708d84a556db126d5300787064c6885b26693176e aa4dd1aaca208b2b22374121de8bfd89c5e82d878b8227817976a6c2a8ea7736 f2cdb8d1a5c124ff9b1511941c2416cc35074d0f51dab39b048f54c1d47424a6 ebf7b2fbbc7db369e49b7b9181ab0ebdea3198885ccc8f9012805579cd45ce9e b46020c450eb4c9a8a15ef07260a251c5f895afe8b56851db68aeb4df19b1b36 9a4654b77c65d05fc78369f3a7b87631cb8254355aeabb29e32b861df55a4679 2ed64d813e2e78a23f2808289a24901baf9bbb54e1ad72ee02784659853f18e1 3421e1784fd6836f30ecea38a8f01bd0ef2bdef9f4ccb8ec466145a3858ae6e2 aa05a77c2fc49b3d0ed352c19e7df0f1837e258a3c2987690f2eb045af9ad4cc ff70b21906671d316387d636fc894a39e29039c11d34899fda175c5ac5df0ce4 5fe1daf8ea85f2048a37000c1b41528f394cc123253c677a0244e08b9a3c9d4e 06088f5f4199c74bcbe8e07b11f1ea7fdb98edf6b2693a724af5d63eaa840b1c 1e5bc5105bfca0b3edc46926d76d99848a08c8ed4993ad8187e63a8e38abbbf4 45953abb2e824885bdeec0a6b7b620a2f03b4957f72eb636bbd95d9f3211a424 46bdf5d54df60dc4859159f116e1e7a76b326935fab4d85feaee20689e43c6af 819943ce9e3d1b72ddfdd0b8ef6a40131c10f96df0adbd0e803f6f185d0347f9 c8f5f6ac46a0796eb2684122975c3db25b59b9bd4752b7fc2b81958fc80693cb d3e550408362f584a9d5d9a90af207e171ae972abbb0fa43914d5e515ec70e40 030bdfce4771bde801c4765ab899e3ab10e4e0fc0b4c7de4319224744fafa586 e79084661e9d21b6326ba61625ffcb5b6e16e1c9c98efa292b09e79cad6d264e 778709e5e2d538bddaa965fe273d7a85d5bc3fdefdc5ba0ddec57f39dcfcbc8d 47879029cd80fc2e601310b83fa070b941e1bd47fefd8700c9f37e6893c88a3d 60b6b6fd09d03c86419572f5b57c8539db1ac6c3aa098b82b7d2d6c43d29c330 27aa05d2318890a4cde5921127343fd0b9237c09eb55393a3c05c651d84e5083 fbe1172476de7c62150c921616cdccb0e36153cbb995d64d0a4fbca26f92b8d4 c65ad68c388fc26f8a3d57f1a091d556478f35ba6de707918ea6ada7978fd5b2 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 true +check_ring_signature d2fdd0d83999f079802c700a9d50e907b362bed64ce01315bc6e2c74d5cddc5c 69141739b9e5e7533969a1d580bdcab655128159cb84db1f433b326a80e53b06 3 8efb0f43ef622122a1b3201ab69cc6ba2c47a426815e5400a9b0ee4924b51baf b435ff343b05fc91d3cc618f9f0ea82101543499689d23e5b1e7caf978ac90f9 0a2be7fc91ecbcd4e3d5dfc9d1b024a8066beb51f53385db126b0de3e1d17ef8 861fb3f5b7ca2833c3b47f5df2dd51d8ab34ecd7c454343496252c57f958e40fc3ed1b2516893891b4521630d037068630c27166ae8d70fd6ea439d596384b080aa502526358e7b36ee645af69ba99df5d83cef2be6b28ac923ac8febc0e770ff48480acc340ecc98eb7597ad5ade5c231888b8883194dd2c5be89d90094650ce0725bc923438636bb727367f41ded5c1deea325a1a2c0365ebee08407d7d501a135b3fdb4a366d09328f065a5848c57700b333431e0cce70dea1015623f250e true +check_ring_signature d31475028e8b462360bc6cb5304158abc1253d573b51ccd8d5705bfc2139be3b c37e822ab905014a9b907e5ada0e586304ba172805dde350b2d35838d4dc9bb7 1 5d7f238a75fc818a6249d70d17703fbaef95a993239b46f8ff7d0528a2dbe451 60df02eeb79181b730d2a2cf50b34e809074e620c443ee98860aa0133f12b1d01d324bb70a19544dab943ede42b576506073b721c4999d9039b50147f3fcc10a false +check_ring_signature 4620ebaf2e2a4eba507c08afdbf873c958771ade1d6a99d35863af641c688ae9 384eb4f915428bbe655ac906ed9eef4188ebb9b3007e2e045c0aac20f8ab319f 1 c9e56d726cfcabf3b259583258c60f3cfb504f4a70a03d3c5662e3c3bd58f757 31d65be891997a8ef691111d7f99b9d67a2aac127731b83c787668aaf0d1be056d6f84de587f84cf141f76b39baaa13fc23729ba2d87cbc009a52759d3eb2403 false +check_ring_signature e08b9bc79cc08e5905846d3f602e2e07839fcfbc8a9401b1d3e6549bfafb62fa 5e9091071ebf9bdb65d1450d1927c5a292e4979d4a9e3c4c0b08a26cdcb965a5 4 f7ee8dd1916823a4e5ea93d74d50e1af91baf6c45c1818c1e5a255e27880bbab 9a8b9c546586ea25bd1013efcaf391d223e11884e6c0b9c27be4c54b250c38fe 55173258e8a281755f1df061dcc2d4fa500bda886176da95be4c89a31946f475 215bcdde934b24e3ac123bf41298f5c75fa1c6ca096bea06e16616d5c04c31f4 a406417b642082cb2a24c7579847c108faeb34b4f68a97fb710bde0945fed70156a6e0483595afbb33c14625433a951a3b243b456076540d4585fa2764343b08864e9cee58282dce9b427ab099dd482771a532654dc406e3db361a91d9acf30a9cf408d34d360d7e40d6e15d9543abce721d15967b343ad2fe0c44d311dc4608f840480ee3f178bac876b0727c53c24aaefc69dd4ca69e65a5e5a0e5bcd0890779194c203360cc5d37c2fdc78dc19b539e6593138f6833f8bc855bc4d9f8a90d145de1b9974ee6a7b8c4a6aab78128ceb59e6070f8c24613da0698e4fce84a0084c13721d2705128f0d6058535446a817f0133dbfc698cdfb1a6dff4c4c2b602 true +check_ring_signature b736d6c791b847dc10a8f406f994f601c6e516d0c8e3426115c7976c68c9e259 6a00e577a27dd8b96d67b33babf209f5537333f679a6fc04f43199a32ee948f3 5 a1ed562d8c77c473d390bc548374999f7c474b8c239c9172f02e0a8b6b62b884 a31acd1c836059f2c431f9380bff4e0ace367ded5f39bed0efe6b3f2c09e663a 1df6cec895c0b9d05c36e081b813fbf41bd9cda385e5436ebcd0723316adecfd 94185128209cf888ca12fcaa6fde98c574a74de4d4938ac1dd1480a7282bc278 aa084a4b4873adaf6bda74a84a7e04e051695ca4384bfb3b66f2b4d4ae6b9e97 63868dfac3ccb8446f98dbcfd8977294c2969325353a5cbf418695c38124490e8f804968a57b578196c2b1787dc4f0b98d3eb0f9c54b82fecd048d3a60d2fa07c9425ab2ff23431134648b738ee47f29d48fe378e81233a5aae68bc43e308b0a538fa8444164b7ad513d4df97bd520b4719b69117d25285e9583288fb182c9095d681eca7b6307f30e44728207409fb0394c6b664a86fa84af0f0a45f335940ce5161d483d19bf1c97c24312af94d861ef005e2e10316c543b2abfa77366660783f0adc6aaf3d2493ffeb51ac741e1aea833e61526e758835af08f5e3b76a50ca57d7c91bceac39c9131dc57e71ab1c343967a8e45e703e70fb408ebeb7e2608d9df6172086bcac8754be5a5aeb3923ea48c444badef678d32ae43013f08e00d20cf8b73e4e839b03c55e3a477e6fc861b8437cc1a19d0a81a06a1d2b5590104 false +check_ring_signature 840f20f4c2d142f9e520e19041b3d59ec8ddfc89f6502f9f8c58d93058464625 aa467a623d219f75ce6797be1875dcb5158daa8a5fbd9fb9520f793bbd935f5a 63 ae05d916e30325335696d426f689c616b85ec5eb553f5c50b0cf87ca4001d35c e3a4c8cca56b617903e21cfbe43c5bc808cc81c4d166d1367f4291462cdad22e 015db4e32a5ffa2d8f20f00d93be3066d45417791b93e37e5d09fce797bd5310 42d1fab416dc3e8306cf81156cf166c2e97f1ad3cae0ce200547622dba1395fd a00091f373537f25124fb49e38bc2cceb22ff0a1f70ff29cb08385d9778d96f8 5716b959cfdafdd7442e032d155ccab08c27a7a179fb53c3587fef237945097a ee21a585f323e46d6aafd408d88edafbd5117bf17ae020b077a9f3762e71f3df d6005aa5f21ab5a7ffd7a545ac73b3ebbf7e66860b761e0e4a4aafd5d04f3d91 5467ddfe2546d649952dadaecd2ce51248cf8d36200a9a2dec341069d7b50c38 be61834ef31d3a87f09e21f9a3236a8f6019b972fedd0befa69a0c0b9e660f93 fcdd234324acf90b3d45b4a7cf54726f21df94da11eb464bd83dff566a221645 f97e3810e4b579731d4b485fe6d49e61ac6cb3893e87fd4ae8c96103149bf0b1 66724ca67f1b8f51acd15c033dea076ba983feac74f9e63fa4dd8843c982fa44 c2503aa037e675cafa14db28e2a9495425a3783c8e60ca19031d4a3c706ef686 b5345a05db9d9bba9ea4540587bb8e7435f903e1bf32d96295ecc1ae3894cbf2 29d929e5facf381b2f64f279da0e17cd659ff38c8ca20c6b649ad208012972e2 0c447a1aa23358c24bdda790209a0e46183238a97dd24cccc1c71d56f1f6dfe1 4cf4e5144a1494578d74a6956ef1a921375ffaaf056b323b4ee8ecc6349cad29 551e308847445a8003cfbceb0c6a68100bb748678ccab8a46db749767a618933 5ea25a5c15037631289d5fef2498999bb2d220788c2839228ccb4f430ed34aff 93b23b104f9f62a09ca5038665ba397e7e5f3fe8dfa11195ecac3a96ddd5fbdc 5b6e5635b896be6da3cac6fe25989d2b7221f9e430d74246de553e8a34b86f7e 309496620ef1c2fa2427a3ef9fd0d3a5fd88374308c1ac9c51c1b8b91e6b5ee6 71e1a4787e58d0d7967d321ea9917107ce1fefce0f84c24d93e89bf53540bd86 cb44fb8c120267cb4057605bcd08257d4ad22487aa232bc49046c8fdabe029d5 f0cf5d2e53c518a761b9a8408dab6461856a08f43bf28c42d90f1f20370f8459 99ec83f7fd5a979428564161020ad1b3d7fcff0bfc8ebc4ca7f6f9346163edb2 d3e8c3fd0cd844c159bb3d476120d78890e787ffee661c9b02b981df084eca26 adb6f0a43043c5e2a221514f97705e3e51e4ee78bb281dae1ac6cb9a6062f432 972a3fb61e2f3025d971d0c9af874516d6ad9f7a6114004e2e5d075f9b19948b e358494024129a7639ced01db22cbe69cef5dd41074f5bbfccaaac33ca63b98f f72e2e5dd370e5e36b912a6f986852794ed88ae6a90eb408c8b068093b5950bf 3903c257986b781c26caaf0e6b36d18d81889d8928fe36d74766595c93ed7eb5 1f2806f48c5e790d719c1ecf77d92188abc52d83fc1fec1f23e5bf788172c76a 22faac0d37bf0a9de64076d824f972e5587546b34f78cf4253f876b4f545dc89 da1ee529e9072c7fd02c2b9ad1254e88d74420594e24614bdc88da94e4a2d86c a5e0b8af22a673fa01360e2aba190efa9c23ced61b66065119ea612170a67e1d ca67d907f3c11bb8eee4c890c44a6360131852aa892a62e87ea8b07f4ed361ab 0864a77c99162e20602ad8e8b93c7e3de13c1303af2804ca52a46b0787e0f3b5 2682a2098d73ee4e33757398dbea15b61fce81ca5665a64425ae0d914d042aca 19459b1a5c34c9b9aa8f11d328714fd8953d8ed26904f85245916136a9310e60 24ae993223da2eebdfdf3897da29f1ce4a6a6627a7fa69b7fdeb93a680cde7cf 738e0ea6d8fe637000e281669a8ed200733ff92e9d15c3e97aec2c52167c147c 28654b7f874b963e58dc889c3757fedb6f86de11189a5e165670c6cef3ea23bd 58cdbf143f044bfa9c97ac5ad2ab4e7fbf309ff0ce0d64328725e8346a228403 63d07feb523cee3c4ec0fddd05138a1a226ff74648e3fc9e47c9dcb47c016b87 9572858a2e741a1db1665e6f2d022fa69d832eed8fe8d04c29a03cfd65078c9b f5a56f83d692b0627e567cf2cacef6c3980a68d17e9e46cc0b815174e5591306 a51b79410a965fe6cee61be9d152397f0460fec265f1ce9be0d332f24c8a0881 38fc3b5ea555a8b0d623cf57f691e015524ce0da9e1661b9550654edb6f7dfcb caac91d7e31e408a5380400e46962df61f66cd8e00ae423315d9564c5d64ce3e abf3c3654a51d4e1db82c650af15305822430480bbb2af22b8e3dca01b39aca4 d03bad22649a077540c7bd63cf0034324811e5fec157822a2974e9bb76b297fb 8f27154492961dfadd977aacd02bba0abf3be4eca3703a61c09cbf07c92c0ed6 d282b86868e0235329d661c0e074c8337e5e3cc72cb5f6668ffe466c557a1766 eaa1256d84d46f26dc06a719283f72f2f390a734f89535355aefd7c8963b11e1 00e6019a677b99c9f08d37b5517d47ae11e41b910218897a00d59de3454cf9ed 434f234d3b326bcad8f7f26afd92427b7042920857e960950c18db54ad221f32 499717d7a1b46e5fa499fc44bc0120046e30b66687c4b59b5d49927b7a3e7fe5 ea9ddde6bd0391f1472a5c36595ec58501bf9a3cebd1d3af67ea425f6c3076f3 01a252a421b915b63000dbf1acfa1b290368f22899c1c47458ea37afea1b0da5 32e6f124d070627a69043f4fabdc732ce2f8ac235cdcf90c6e03d50858e5c0ec ed2d8adb4f856f88de2e66aad573ccdad14eeeb9ef74739b36b24a3819aea3a4 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 false +check_ring_signature 56f3c66bc7088f954b843e05dd3bca67310ae334f4b86e1b1003c025dda2ede1 f812382e80c2fcc2c850f8d887e8a19f04b6b269ede1b3bea9f13bed1a46f31e 1 266204ee2673344490ae9dab8b8696e4d526d8aeb6fcd235e4dd62509807f781 65b394ed8c30f4f84df5101b3844fa191afb1fa4880b5386cffa86f492795997626034a52fb6018e0994e77e287f4bfa206e162db863956b61cbdc93c7599800 false +check_ring_signature 0d9c18ba68078422acddd8b791ac3abaccf00a61db4e32f83b0550f3be8b6572 32c452bae0bcc069cc2825b517179324d95a56be31dbb733de595d490406bd9d 36 07f410517cbdfe052cf6102fff61482f9494ae7b29805d34ff438467d41aa317 d86a205a5bea750720560945562f01bf28368c55626f415024a36a744a82d4df b21e71404fb2bbb415536a860090efa487bfcf4816f3452c902189e21aecd5c4 f2543ef4d0c80e83538fc0508346cfdb9d30e9cfd15298be22d91bd6af876622 b440653942ff720c2a383e9e6599bbf121d81646a5e8f4e56b46b3c973144ede a6dd87e00503e2f32b682ceb6435841686327d86fe89fb5aef62301bdb9cfd6e e883fb8612424b75a314281721252134448447c99d101cb5ddb8fb0e675e1210 dc3fe4b5559687a7d9dbaf3bfae00412e4ae24d831e423b3ebe3098c47c4cad0 9aac33e96736a08594179efc2f9f62489a5c6479c4036e2cbe48a486c9312d12 e33ef1ddef296afcbf563d2db4b0686a02cae46630a83d557095cdda7873fc13 71421909407be81a06cef7e19ed9451015d69b9a0656ed40bab4b52713d3e0ee f5671d386bf4cf70ad60416162bae84ffc3ae7647376bc5393feb8554346e165 2673b517782e746daa1deb2aec56148941ca7ba0e573c1592269f579e89a79f4 854c7f04dfd9d82525c3bae08427c238bfa68f38dffbbfacde8e043732a7f78f 9de047c945bbf265d4e3f6c498147e1cecfe8e8b2ef292484ac71f58889dee2b f47d09ad61d3a15585a64dbe93b1f88fe853b76dbc1d6d206ee590d43c61bfbe 5ec03ec902a484708ab6df78f8010b03905b92dcb76abb5d1ef9efd687652fc5 fcde496d2c3827fc3f01e72bc83ce78f836820d7cf2de286706aec851d0ff081 2e746e60796e946eaa1b85fe8017b4227043afa35e35d34db225251933c1cd89 e94970ef934f620cbcf6bef18202e1e91aac88ff61e08b0e844c166a35c9d7c0 2a2e1ef5246403d257f7a98de8f3cbf9b9a009000ccf102cd23eb50c19926405 514f3b9aa77ff41c214d49aab248ba9cb2030fe58170332ff117e98866adf801 d709a5ca964b388e5d09a03cb8bccb035c48b7203424ab88f2c2d766150ff5ac 6459bc37e55a97e7763dbbcb98b768afa3375afeac80f96321f1505ac3a2fc8c bef5cab44f52b80f348315249f5d276d552e1c1bd00bd342abdeec872a64c20c 9b32668593a6bacb0ce6e3f51c9024841a657a786fdda0fb156db0fe863867d5 4fdb2ecc809d0ccda808b4c1f38f19020c545e61fffbb051671a27f8032905c1 ce28a0579e3aaa672be667e7537d6e205478f70c9171e0d36768893d96714a33 94600e7cc80633342390d593a1ca8f16393c39e52e7c4bde5f939a29165a13c0 93d58cfafb13ae2dba392071ddf71631f8ad60d1eb71b16d76236724e11302e3 058cffac4c071a835ddd018a4055deff2b41ad45e4fa4d92e2f548fa904ea48f 904494a113c1b4acecd8aa82de6783e1b5c9b5d232f2396af67d711dcc2ee73e 35f07f7d60f133096f9761d43e2882bf5882f54977aa860c014809561e11d705 6ed4ea935823deac004b84b6d3b77dd9731e614b8347c5a9e9ff0b8a5d0cac28 bd12b43b99a5b1a543219d95890be067ef22a818ba08f4ab8253443752f03dce 681e51c23b4d22237d9eac6fb979744297d645e824d928734b0044cf29255264 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 true +check_ring_signature bda516656f81ffae2ffc93be2192b78492a35298ee4856b735b44d381d4dff5d 1ef197d228d8651830ddc7539b32464520ce0eb674b67c623922c787dd97ffba 31 c4056a3e42857f9be6546608f7ca92153c47302c2bfc5bd431e6f83d4c6e9b8f 4e30a53ef6424075ae0859d9c952681732fd3986d4983181c44055993e203ff9 d1ab6419c9e26340eb8cb2cd48c87546987b0d0dc2283ee2a261837e49ce491d 99be763b9e82f8ef4e2dd135e155af8a3d4aa4dd24d46d0a9db7921147f6ccc7 62b34a781edd73f1b727b502a6ef67c6f82088242b6fa28208fae1973a7fde08 32ac6832a8b070481297fe2b72c98635e09ea11a88d463bac9d0d98136c07500 b8b8d94c4537009913cd5768493443d52fe2bb035c0665a449d3d69ac3d9c099 5f861d9cabb80bcf63c0dee7c3aa76237ec49dcb3f68dd1beeede5140f14eee9 f9cd7321c1217401747bf91f3fe82639aa7ca67adbae7847415fc65173e8ec6a b8267f3ba26841018dbdaae833fed1b50ef8720caa0a42996efb7cf36470c423 af18a6e2206b1ae6b76f14d795be8776d44e4d19c3e5fbaa6cab1bdc78656b64 a6e9e1016a8f9820c3bf47057488eb2132e2b861f379becff5d9b2f24c0be1e3 39f9ebc5d8668c84737c2e49c3ccdac646497cf4695d71699a85283b9e18de7d 889b70eb2e7ee34e48bb526a7cd300713e1b638725ad163c3d20e1afba65232d 0ab5ff4e209d2d36f22a393c49078ff60efb97c73f4023e93c5c7a30e8108214 b9234fa4dcfc54eaac78f9e9e55083e814195f0da5bf462ff9f7b0b92f412129 6d551ac50913acdb43a47a994b9ce0378098cc9b11009317e5c5797336c1e699 6cf0a6b17dd60aebbbd1f141c6c86e97cb7d49c6f9b9b1f70b79452d6e5f5a58 b9d35e815fd0637f9119607dbc45a78ecc8ebcadc5c0db46b5405b8deb1633c6 87bd99f1d933e9d927912922f466539d2edf944faa0c4b87e72358885784e4dc cf11ae1ef5bf4f80829f3617a89d1a3bc283f2cc341d7a2e93ab77b73683e335 9cf5e02516b8affb8c754209095f404cacef0f1c4205c35d8cb3f78a2d014d76 4996f60cbfd982d8578b3f4285c1fd81b74bdbbcdca3fef094546aa10602dc7f ca79aad4e1c511bbaa141ee3f4b084341326dfa639cd3000d1e0844f4b30d2d4 89fd5143a30a12ecd6dd0f3dcb08d3b8319053816ad2e7b00ee3afff96740f88 7e5f49faa6babd9608c26fc115783e8e0553f838161a9a3e39691c38b5972796 a28b405299c297f36137dcb1e68af3f85299570ebe4fa572bdb68667651a6f85 4ce29997c77c4dc3bf885c5ef8548c84fafbe13c77b8c6b4e1bd9361515aaba3 12417ecd1d0248cd2cd6ee11667e0aec3547206298480d65b546b58babcfae40 20ea20fffca11263b4c29fc773df39924b4a12a2b40e40c2c94986180bb7f2f8 72dae1473bd34081f55c050aa30e6e2c05e20fea2a4e0f4c649175ff771c6943 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 false +check_ring_signature 626561727cb98e78d772c6e0cdf2fa6d33cd65e055b7f765b830fc7d448b6022 bc18cbe41c9e290f055d839750ca93e12b64833522a7a16ddda9db5bdd1ab616 13 7a9060046b43ea116753be7e1e43d4e3ea33a09cd950651ef0c973e6ecda35c7 316d818c4ad2839e366fdf0178d8d8ef2577dc761ab3cca474a71b4181ace667 411822075056f4394dbebf1bc49b84a806741709653aee72907b72a5103516e3 ad25a922ddfb20a570808774ed19a15faa6e509187eb12a3dff4d3ddee42d3cc 16cf1ebe751b6d5d56565f23cddbf4874a37597c3fd540ad360dfb654ef26796 a11729ee0437e2914630a685b18f332c59fbd4f9383dcf31a7c094273df5bec4 9211dae6dd8e4e85984b4f457be236a4b76a1cf0fbcfdda2802af7105ab94fba d4a7c313ff04eb40cc30e964e7e5469446859c6041e140e31fcf88a69e526299 c9222ea6f0a8708a52683345cab1f4e9d6e498b080d665924c43d69906fef194 4818cf09328b62652ad425fa2eb24c1148820a951013fc571c8286df65341f60 a24ce1773a62c99cce7819cb35a97d8b394538abff1c9d72ba5ab5588990a286 457400131326b6f854e1781c3d87a62a3ab89f6780cf47f7e32cd1957603de6f efe0b6c96ebe71d6eb56d6cd194eecd485bc5740cce68f148531f23e30627249 8efb198c4f65f180a3b38ec9ed1e8db6dc1f7bd03a0448b5a006ea6e6b99730eaedd72c68bf27801b256da72f19d6091ae1194313b17a4ef3f24a3f6ff90790ceda6454995aed21075f21791af78cf05fab0c39c7283082222f6023ad98aa10b157ee8c04018d0e83674fc00d0a3f88e1514203f2e2645e7e6d7312fa6c54709dc8bea1920f5bef5c1f57a06c3a5b74acf397de07f964463043b186c134106096ab43ca3593043b5dbcc453819e1c95bf23d6b592fbf9f7c5555305f0cac790330fa5b6a3d25ccfcc513f55ee8983e44ce3411083d232f105ace47d43683c400d2ae1438b040c3c8a4759f7553271e9aae75f7ae4458155dc068745d0dfc7c095b2df161204180026210eab665c35e5e307d80823be22c5440e8da31d3512c073f214f6160a3dddd8aacaca0c2c22f378ee16021a536348e9929afab65e0f605c430be7f70119dd69af21a11fdb91fce7f1fddbfc184dc24afab801cd4bac804d1c217925890ea9e39027e46df5127c91121e989ebf8f4fc2508ec3f54b8f00e0d3e0becda3e9d8e9f93c79158731fba312a6fec8e0d9fe460b73ba58e77ac05f1c107c330dba63c190833b761a7fb9da50c85801b91e6430e2016646cbe0f0346f9173d43bb9e8b0fd911f37509b4b26f0b1003b00e5b0d016b75f386c0290ab8618690ced906e7b81687bd8791edec0caeeba950b92f9db17fd9ba83f81305d6bb4b94561842e1297ac732879c716c6a423b27d40eec25621037f9e5da45049ae588a707273d56efc08b2210978f9ead2bbabeeb1d7793ca9803ce71ced70b0b1dc27117a8daa0f93153c0824d76099272d8c81dadba9bf6eb35b377fbb50af146595a78848b97c6a6b568b3533093279f4c581812bffa46801091976499055de29544527565e874c2ab49b4dee379172313ee86af51b48d44cb8ce05b550834e14a444a615aaaf6507cf31d3b3ce4804a2c959ecfada8b6670d8a2690dc04fdf2596b08e6e711f21d465a91edda0ba11a9de9af580c3936aefb06f5b4140c856bfc1e2adebffcb8ddca5659c2947cb891a42a5fcef68d6a875447fb925007ff288201ae0fc4494b88b341c97766604b19bb2715fc9e219bdef769b0c79f04a48da92e35c4c996100d5435cdbd74538d8174cefddb96d701026a7b58655805 true +check_ring_signature d33628558fe7212f6a83f3b4c26b6ae8ce48c8d5c27269988d1d561d4eebdd68 49c7143b7504e5937bd6a77298b55845e37a69ded944c472e6a1066fd1ab5968 16 228808ea8ae5a16229d5d8e4acd2bafc566693597235df025403eaa871a3481a 390ea6e282fa294f7942ca45449b80d9c724a8a3d5f4a9634a60fe2888470b92 0b0c6258d9676d4294f21400753550fd26cbf0bec23e15df95745a85418a76fb 7461064e53608fe67e317692c2bd45c6ba6418a5bb1cd95444101f0d8d5173b9 00472a2830504da3e2a5bb302e110718b5773cc9e191477003cf0e229bc40e88 9086df79cf86c9f79f706419dd08676d378c0681c486929a2cedc4a1a4c3a07d f57fc6332e01960f904373b2ccfa03cb1336bbd38020a51a5173bd7afad713bb 526b77c07e8950e6bd2105f2710341f3ebe3cbbebdac63741aa8fbc2cefb0a4f 1fc5b33eb17b23849082f2adc739e8cd89717c97815eb2bc41d929ba5eef35d2 66f09fe3c7f1032c1562ab78974b8eb06ab72bd497805f93c3206c1922dd66e0 ce6ffdec66cf0f1881d1a9b7586ba1708bbb2c687d5473fa640bf2349ee80fbf d17d54b8be65c9eda7d06c2833ef3c90fd8c0609925c0111aba1c04c29966d0e 0f6b22c6c9b79e77add532ce84e8d81db961f859e995f924d2e4f9c04b758422 426dbcf019f34fb5c190010782446e3d135c39e59cffbf1ad3761b878d426e3c 17cd05e3edc34f8afe9149d5ccf9e6231201e6d8715b3f2de4541ffdd6d1d6a1 fc00a575f594afdd193d497e125b7fdb059536c4fa535dece734e23fd6afc1e6 ba538f7cfb8db0489276357cf6804ce2367c6ff2fc2c846d7e6fafd19fca350a350b67598610739996e5c8a20b356cdde28d781e4f15b94885af0eb316ffb5029f4a4683a7195e0570cf5e1a5a2f23b3a64f2b2c3834b38d538fbe85595f6b0cf63a21bd1ca28eb7be650e2b6b1063cdb2f97a0f8a989e58c3194b9efbcc870dd3c37aef64d38d46f874199a3868b0799934218473201c4d78408d745aefc20aaebb16d31934c3ad3507ac6668f369ba90674542fa95148e07b1563fd08d59b386d7d54b4b8aa4bb1c990f7e23587ee8e1a801a1b4c5b49e72c854f144cff1029efbd5b988ec215f526750f6b2b3ce768a933505bd79ed49e69f1a11ce78a50ffac65c4306570b0c481dea5f96086e08cbac9917871214d570d857790cdf4ffe4c01270696fc2be8084a8c5b116f69a2c87352e37819c594f455d9d3b55eab0e6188548a4c7ffddd000fa334aefbad00fa8b21622398f847847127d876868106932d394088b5fe02e162cf87e4b6295c1689de79fe2705f3791ca1fc8286860e6b03160019a0234b476bf3e03452a17b72212d2f605fae80c127789667e8300b8620bc8f4adb44dc0200292dde03bd007adf3a0d8aee62ed920f70fb5364c20484a51fb4018105b3c314625aa9775c0a9b6f474b8f4d112e506059db815ba0059d4e2ac31ca4e70d411dbb2aebb61c68ff022ca8edf506ee92829fe43c82a40d5a1f1659e6b57325d7791c982fac0a2e9e9301f0310d39925d2df7ee3267de0607b826c21f6d318ea6f66984dfd4b73663069eca00b4d217d508bbb9154319021111bf83ac7eacc9499f4fe4d13b52b259b681eabb8d3c0e5e3fdc2b52f0c902faa8b12834264293a67b4f2e90a3f82a44244458e2debf954ae0e78293478d0645c91dd9b78e35d36d098a11d5e762867767628b74121f50c70e2457e954610cb39af0e5b04608b79ce9df3fd934913e5101c1f016878b57914801dbf51ed104acdf8cf42ecaa1b0161d3ed8f43467373f3c3f2feccc4668e8bff474b80a71002b6d79c1d74319c5948742cd68508aef8db3f28c0744c6cd1b4d3d097e178e01fadf911ade5d014a7d1d5e6cb3993c3ccd17075b0c067b03f38049bbe7c406004037eb9aa6007abe27d6ba5db90dc5164e3e4c1e07b7855f2bdc3ef8027f6e0ebd7960bbf2048c70f8a6d8412c0c5cddfb24fa3fdad78798d8de87fd71ce310e14558ec0fc9a77f90588aa74dd6c6448882bf57f50632b929f52a63a7853c9083acd604d5385515cc0a0c1e9459bccfb934c12910c725aa0f770315462ff8002b48479ebd31be989fb61f2b934b9ae912a3f56c198c58bd34c11797e3123d006211c47b1d5c19e2297f08bc9e269e0b17b1704169f3dd65a090281992586ba0a2e325cb76f22c52d03859f271cd71b2cc668152198bcf098c4071d1bcd0de10a false +check_ring_signature 7d25bad80d06009b2065258c3262457d829308d3684f061f70e2d1a7e7c57a3b 9d9de2203dd6626dd742eb584092ff60cf553374ac6e9605b5ea1015b2214a6f 91 a02fb8bfbb0c08da15204eb4fb0f9cb392e27c7b6e4559057adf22327097ad53 2ee95fd60685f9922b2a7b26c6fdd3ac0c2f586151ea40d0dac7ad71640ed954 5354a631cfb9ff60312ee42b71476362dc9469762f38c7d2ed2bb0c564d20d1a bdc0804f6050542ce235f74ad134a75c0f4fc1c07fa7a68f4a1cfa5ad8e4d197 7bc6e0841a3c22a2f7ba15ae42376969019623f61867621b76a2b044177fe2a0 fe4b250cce8027b1fe26916f637566a53f0e5de3e71363d05c793fd6fcc6b010 86feda665f3e5fa45f7826d02e5ae09c3dc332cb134c96076b1146b5789f5f81 60abe03058b8b3ed9dc25c0f0658ee6a5f4a80f660a6fe043e2e6934e91190f3 14954011cb0cbc1151ea6191d1112a0e348a56f2ebda9e448fbb6e57577c71cd 7ab7324a81e1e3045dbfb8a952dfd00f921dd9e8e388f07ee711623f605cba72 aefebd1f106210b15d1fbb13f745cfaf21f00145f4aac75758e9962e97eae67e e49fd11f73a067c5e055e695cea0bfab7bde21635a97e5f2d1523a0b9a677e39 14e0e833d9156c054a1b7100c1389d2360651184a18eac61e4e5e8e16fc1f051 a6a76af45376caffbb78023d8bb5adcc350af45a5dfdc2fee02bb24022d4e5e7 f3878c1caf2a913bf4dff7062d3052a5b757de1d1c78b7936c2b925e1ca49cf5 4ad3a632198bb46602c55e93ce8e2d77c91c23c3a20986b3e235dfc55104169a 8b50d7ddfbf1a4fd0aee9bfbac54f482b0ab8b728763e66472afd0c6054821ed ac34c3885d2c03b4967178f81aa1ef4f2e930d7cd3ae2508f8b2db9b19cbf597 e7d344adc26a8968990a6ac82d4e77c7b0cf5691d3d919f2da3516b819450106 9e85ec37bf0232b0a16f53aac291924a1f648bd159cfeda32bcc8258841af59a a57a662026f680ab786ccc9ab004875eea22baee16c6297e378fff9d85abc52e d50b8bbcecee9b2af1fcf1f52bc6fff64927a60202aeb56f5d49bb29a8dd77d9 90f27e809746747e6e3b2ec62933b225beb341ff2f1d4d71042e616f40f50c57 91fb188a87a0ce363b4919094edd2fd6e4b023d9067806af816c5f858411b7f6 366bd6df3b42c8342174ca07eade09216eb3029a40da51edbe0e0dcdee427e74 dd19708f18c440258a3ff8e4df195446cdd8fdc332001cf9611de73087bd88d4 1b8b63308cd5ae08495921411696d40ce68c176d9548d85b954a41cf7034a329 3eb1ad56f4f7b132e883245214398ea1249a253dea5ac161137c8bc682c6b786 5b1c1946ca4955a4b9fd979951499e3d7061116219ecff8287021e146ae616ca bbe312d2fa4a7701b7baadd0e1c7d52351e2028529d337f964210592d7eb631b d80bdec7a4606a18980380b57ee97f45c106c657932d2abed70c3e7940438c13 0d70fd120c713457fa5de9249e737ff8d04c33ecde9df51260374580371ea719 e68eb0bd01628a0f563f8895c7fe6b8a4d78fe627fb2b160b76797c66b8d1a6b 959253fec70793c6347b1a8370ce868ba89da55c5c1775bede9a3d3a60fdfa64 56340b96fd89c69174819a3c6fadfb20bf5b2fd6090e231f6f137165f1bf9d39 fa5962fc4dff1d96eb17ab1149478cffa4751b0f980db1cad59d5f31cd7ae79e 6e100546cec3ee34d6d5ddcdcbfbafcfa379f1ed32531135c0032571abf0ae28 985feb12e367b6ea9577a71eb115c98312717d08423a67753b8ddd9fe44ab0bd 669e81de2a3babe861d1d9763004a44e2fcf2a0c354413648d61d385feb03c07 00e7d7e3fc319cf1ab8d68cdc27f7cc9302e3bde5964fd4f376eb90feebdc296 3a45245defca585f40de78bca1c01625ba6f1976e139e546ec314ac9640f18af fe621749b8057e7b903a96952ac7c6ffca923865209f5f6adf42f22ae7cd6543 3f1d2d67d19e89ecfbd799edc5f97887ef628b3d00fa7c47910ebe672d94a884 c37394a9d2692bb742a3318ee2753552492d6482a79511f622410e684a2d9304 eccd1ed75b8f6b27cda72d1259eedb718a638767fa830fb7bd4dc2282e5abbf3 b391f628deacf4272f35980c922fcee4a288ecfb268a487c48f41ea04f7473b1 26bcc442a1f072a423d261a96065939b6eeb30c5af7be2ed6490e586c3ee0fdd 91f58e9aa07465ba5d1388b2556824c6a3c393df7239527d3572558c5cacbef5 964a6ba8a7f34c7b389be0ef1ebe8fe872a9ddd5dcb5a0f7df22dc837f55ed0d e8e30c458565d3969de6da1c96525f92f5c5950c6a4a3eaa5db57a6a296b67c8 eb709517981611b629aa71a88e5b3e220004842fc88e393c5f49361c42fcf7c4 4020541760741e2998d3f2eae3d07773ab8fe9b106b5354eff3901b963cb95d9 c027624cdd4654372b10dc4885f8e8c1722af0ac5944de57962cc924e9d86cc8 320341943b97e7bd73526ab47db08d2461b156cc847328e12fa147af032543fc 7fc3e1111caa7badce78f1368cab573d71673cec8e0cb0cdb7ba439746422890 1e1305286a190e18312e053504468e495156b8f4ac1096b16db417ca456ed535 02d9829e973f7146e5d322bad2de78c2789a71f88546a5149b9418494456b6f3 9bbae86b463f9ca466c67358f1e99d5930e68c492fae8eb3d9ca77ca8d046b6f b557c902c7d1266b013a6767482fa2d32df94a183ba28554be95ab382849e3c6 57d695a438a1384db0f28fac0755da054d57a7da656e4d71a7d25e18739a2e5f e6d936379361effec64af862ebbd5e735ff455a3551a475ed41926fdaea4f11e 1ffbc0d81249368b8ff7b1547bd42f01a1328d7f1fe5b1613fbca9f9f016f821 3781da804d8cfce0bebb263a6fd2abde713e1e42551d04c0cbe943eea53c4098 13cf02b2ce0ef7d2ef32e6c9160b21d70c30bcc52112ea851ea3bdd42e23923b 37929c09f2889569bc78b584b051be956070ccd3540a96cd49df454fc6b2996c dda51d541dda80e0e4c0d43087c5022b814e93797e673bb245b554e73856ccd4 f95a30584fa057dd74a81341d4424230dcb63ac4973f7e069f392d3167fb21a7 fc8f5aaa66d63c42cf183d09cea1506cd75525f3f363c899a32a17f610e1e454 625c9bbbd215ab1b6aa43876d37e469d09167f2701d319fc555612ace19971c3 574e406d419392221d73ed76479bbe2c73dcebe1ab7575acf56ee4a937edc886 ba68d6b2b8226f7d81222d62cffacb4d31c1eb4e114b42ebfb1b6f61ebd9a6bf 9c063d320dc4e553df5f88a44d83e1954d67cfa9ae1dfadbebb455e84707447b d2cf632016b19b58bcfd862edf64b21fc904c9181dca9c5c4a098cbefb240562 a839c22c34af8b538316e97d8e731fee3d99aff57cc0a12892e907eafa100e10 b645fe2499951c0060c84b7aa08d382ea8654f05ba60d391edafa3d5e71efd12 ad6fdcc6e3fdb0f015037039a9acb6ed2dd3e59202191cb58b61734ddde85a80 eac58a697fd4d857bba8b1814a8455410a5ed51e838fe06b8f086d8612de531e a98e3afe77916ca1e7605bd8b2dad9c438e5ab05dc8c3b509126680a9989e2a5 6b89cffac8d1f7ab52f6d52f95dc0ed39bad1e0c7ed26a0a866b7695d076252c 86083e76874adfef03f3c97140ab04a2c0be83f42d6b5f12a59596f0bf4de34d 0557a4097aa25dceac984d72c032c6773a7280d5538383af4194ef99ec15a2e4 f5623c3a41bb595ac7d9dca17b561af9f04f8cde77ba5e5ae29574a0596f936b 41e99d1dae5ca9dd8c418925fe35831d3c258d7474fb0e0da27791264aaa21e7 be9508e8c39acd38f44e894d60ba3410b7782b3e1e0457718bf924764cf5d6d6 0bf74216a6401bd41c6471511c677af0b26e14c8602d6fec0d5fbf09ca6d64e6 e20d1ff591d8a7ac515e4c11121319296cbe1299202e80b81e0c5a2fbd7dd5ab c243fd95c27df8eff688a6d99bf97998995e370ea9a13959cbb5cf324322c5ab c31cb7635f8e5f9f5fdca35d49a4e8cd39bf1897ba8e73a02eeb15c06d02190a 91389c0fa6cda22617b9f47584684a48d4bad89a47dee29213cbf9828129e6dc 683f86d6ddda5c611fb74abab40716ee6212c3b7b3c9075e8a05cd7511fab850 40e043299be5259c5ea08d94f6e078010a11b4630d21d0bcd82e5711e6034aae 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 false +check_ring_signature 8b12ba376980d53aa0ade70a284c601f8211fc928a097f2e6e11773b1f4aa938 e20904bdc6499997e09e99c40d4ed220b22d8a03698e8dd533079dc6358a3b94 2 425d85bcdee799d849b9bed60bebbeab16f70df53fa8c4145b6a3579ad9908cc ff26cee7e9a20cec99b7dc2a90a6cd7486726391b5be42bf0f309e2f16dbb4bd b2d03609b4853696538b01863d89ac038d9cebb4e2fe536fd45414f0b467c904d0e97c432f2eecad112d77237fa7198be2a6f428614251f1ece8a28bafdee80afaa8353bcec5722d58b49624e27f250766429708e1741c11431657e4c0826f0156846ace3ff16076c802b047782fea7d8a04c7759fccd19f6b16e2955469a50e true +check_ring_signature 432fdc81eff2f6dacf18eb3a19afc88fa9759ee7f7ef237059e2bbfdd8de39ac 645908a558fac8da7eb1f58395a7b0ad1765c8561377a3b76b6967146cfa7ae1 1 2a5c52acfa8f6a8485b76278fa319ec83c0ddb8241629089c0c885342dff8cc5 1b71ac657e6d56933c55484121601f2b5448294829e842711358f3bda95a0d3643def5371e4e177f6ccbd1068e87d402fcbded074521f4926ffb3373073db672 false +check_ring_signature 78f8311a5b613a26a9a0d147b2119a438b7084b444098ea33758cb92f0d3d7d9 37fe511102a6523b32833e4860b97b35a3c79f9806311243374f63dc080f10a2 10 fb80c2d93fe824fbff9422e872326807ced5760211ab74315ed6537820fa4032 d383678030877970224979cc98ebae53181db29963d08d29bd455ff3ecf5fc77 aa0c44ff7b0fe9b2a5e2336d42de11de51ea8d94a5c0b23cbd9f3a4941d294f9 abcb04401b480f852dd735781c64b12dc24fc4b6ad95ce16dff5d20571eb9d11 0ae0d73594f696f057ffcc2080ebc2e382e20b72560b4207ce3af916eb5c5365 365fad4e0434fe44668a04d92b94bcfc98623d5e7e5d8b7f82216363e1fa6a1d 9589895e40d8111522df521422752d219f75a79da6965664c48ebfe57e916a4b ccdbd1ce8640711d398b515c31885481713cca90562434529306691efb6785fd b7a7758c741bea4cd53e374dbb642d25da90a8bd745c02eb0c3913ff87f12b96 8f43ba4fb2033ceb507cb1c0be5004437889c3e2df5cd39d5785079553094793 c51c3f6d1d08ddf9fef7a9f5ac74a66cfe44c0f369f77055d958b5d16bafc80e31f18e7b0ee7482fd7b69c6f6e337108b857d26a529e9978c0826f760752e1014469d8555f67da85885c103195e431549d2d7b7988c77e0cbd78669c546acf051d14d667da4723f5a8f6fb570487c61cecc0131db17889092d140eed93eccc0f8e20916b27ba93ce6c225827299770b2d2c7a6fd5cff322626b425dcde3a1603ee7fe84bc953e5ee993e6c119173ba2aae5525c753419ddfffa0b99d6513ce0356e5e032adadfa0af080a9e84086abf99cafb0242146ee0338231da16d6c5405772eed84a21b37437aa504af23c63084cde257cc00c278baf8774aee2fc2c400ccf1c4aa1b70babd842740bb0604989774a9a35e5b1b4c10b9bed7807c42d90109bb810e2e6ec9b061821ef42ae4ac9491f872bf5f2668a39681bd2cf36f7e05e0b945dd6da594790fa1f049c8bf5407f7c4411c04f691f9755b714c798c0f017f90cd090f69ff222ec5e6c8972c4ff4d66059a0eb1e5babbac74c3120873504b360c705028f2db106806fcf305b512ba5efe94c92e38770a63d9b5937ad4d053dc175197c4bbc9989da568d68459406bf3f663e9d694791d7f57e5a3dc3970407d88f253c1b9d91263c7343058c7c62388c6acacba399587527ba00baeb3b01799d8e4f2329ea65bf6276d3c9079252e8a709d4571781bb7cee5df7178d82094d33cc2166253083d668494f99145e93b12e8784659c7639b50e4072a9f442046ad6bbfb04711e9298c397ff412816122755bf2328e156b41f46c3e4304b940b26c85d6cae309d2821bc924f80ff3cddcfe740fcd115d451d3122270961da8054770333e0579aa2fe7345aca1538768810a14a2f6491ae1a3c79a10022020401 true +check_ring_signature 04237bad03d745e05778f16e14b10a48cd1e060ebd54903cc5bcca1f8014a3c1 872a0848e03be8efe227bc117b4b4075a8b9bd04506a7c0f8745d6ad8814945c 210 05906a7d86ad7e0e7ce78aa6fb31880ee11f7737842dd409a0c75f0c5a355495 27a882c3f2bb4f0baf6150f2604a8e0a2e064850352c400fdefb1a8e52ba0f28 be4226ff0e9287452fe7dfe0743006e3fbd4db4abf909cf53cb490f7cd475688 62aa3a8e3d81959d910faed327b844ca7e89e5f4e2cf91bc0635ba7653483114 21d28a23fac979629b31f50cc7aa1af07fa8fc884917125fc7908a75fe37a894 f5b9d5ea4266b86e158e717f0692d6dcea89846fa22c0e9de73bd88add07958b b4eb569f050e1d6058f8f2888e3dc0817887b2a4667b7fffc3b645f1f0267d5c 231053feddbcb655064bf403c252e89ca85000e3c726f73ab6fd6c9ccc9ca7d0 879fd149198033a3815776098c8b03137b2e1202c117b0557302cd9ebd754ed5 06ef427d1ef4d8763b4a194c97318b10bedecb922fd57a63b7dc55f6dc4a2103 e3194f40675ced0d33e9fba0871ee35504cd143cc0af80c25bc18d3c6df26477 0b4d9e2e7602593efa434b355be82a86fd0dcebc8b5a4197784c8b866ea3f004 93a17b1df618c143bf19a2c864c18452baef375c5cf4054712d600916a155dc9 ac0372260a5917d7e69d62eb83c73244cdd9f200e55a7ea22e1036425c363f59 1a32849f9f985940e0c1a24a3f6c7e331a343a4bd3462d06c9cd65be7c467100 bb33566f10e8a150a3077a47c56cdcadd514bb2b2673570019b8a30025a45c1e f7c8d277ed19f2c8cbb181647f8434674d3e598e0db319d189cb6f597ee06b9c 1d20c86c2a44c90348c4ec0e5e94c168815fa09766ef23d4444be8d6c2aa224f 6df7c806be112bd229d08cfe075faccb4865e518d6deeb7d6d682ae28e3e840d a88f2b456911dace4db31984f6c77f7f194ef2960ed52fbd823fd26d68a096a3 2c8899651454f542524615f2d723c0d360b41b531766d2b1cdaf2a8c847a0f32 57e81e54bd73a309921612152328849cd2fc2dadbfe8b1c34dcf5a455bb48919 b22af9c56145846f562ae8c87e0d09dad62860998c67099a53f1dd0994da0657 d9c107f9d0087d81092cc81ea410b1bb6f55c3d0f3e353c973868fdc87ed522d dc4b00434591e0ec1b3585251610a1330e84b61a1aea0ad083b74262a5109135 4ba9ca5589227390fca21a15252842c306f8c3b9ec494ebebc9a0b8ee82c0085 cf4e2936e2d58ae6594945f863e3af87030240f98a0619e53ba3652e1058c996 6d68d5072dfe8b074aeb3128b059ddda2f52b8387fa71075685ad8b961c3642a f60eb1f485b002c1ecbe73d45f3cbfe1efa51eb3e0ab554be3801d7dbdbeac6f 9e786f50ac062ac290be1f3c3d318e00dce0f28de1a49b5437f5726273608fd8 b6c3a089fba3cf7d5fc4075a34e2f27ee6eb03090dadd597dca6b2677b16b737 d888da9eaa043d70eb8afb5435033ad3734cff99ba728dbfdf35c3d5e4d0048c 05853f3b8b85e3887387ba159495f155e47ebbfb1036bfe484edfea3c65c66b2 9b3a1641b38785533a844eaa9ebad3694443acbc75fa69a09908b0597cda66d4 68514512f46624d561a9158eff5e4a72da751892129d98f85e4cbc804f617786 ec2a0e09d455c4f24e721c385be0b35a2102c14cf45c475ef2570cdfe73c9809 346f789f6a77e44e1d3fdf4fb91c80584c4eaeb0288f234874becb5d14a70477 354e54afe912da336a0db9eb230668de8b72bf432af683f8d87704bda65c8b19 731b5df100c0b48389b7177bba743431beb08d26ee09f9d0943ebd22cfa448f9 95d1e3b9b893b43149f73c54922dcc97f731f103ec6e5dec55278b88622e2d28 2e217c4b2771f9996e702ae5c64ed1352937d325bc353c7626ceb7b9337ea781 742563da3a9f009539270aef69d5105316db2c599eb16b4f5539403e0dd439ef 558a0ea7a058a513bde73055574bf66e77915e4b6afcf66734a78cffcbfa4c9e 33ebaf9812a098090f7a46b690027699414e5e0ad82a9c7f63665baff8e8a233 72b1490e36eeab0ae34514c0d2ede72a4361c9708b3276dd6155686bf34f6cb9 a52c7ed58a150345827456f062a5c7753cea0c50022f8c5a2cd4bb1c53131cf6 5ee59d958f69e6dde96a5d018185cbd80b5265a7e0f7ab5c7d80a058758ad4c7 a5715b1fdf16c9f07610bbd52e4f90b5069caa6e2aaf3c8139305b15609b789f a4e9a74a325aa3c23e238f0da171484edc06c78f924347183f504e4fd5614475 0ef7ec71bcad7b48e1a9925f42e6dd62f2a7e0aad4414d8ba9c9046eb6b396a9 e377e3745b79fcf93265dcc44572d19fad791da87f152a35304bba5e902e670a 049fd52a636f4001950cc08d6e725dbd00596106c1c819a1add19b23d626ac75 353dc849267cbc3a51042224f563d813e27b9e251d692253316ce955dc91cb17 6a54693a6ecc83d26047a3276aeb4b0c685626104ebaca48a950563588ae0408 a2fea0578086cd4599ca7829baa4dbb6da7a18494a3dfdcd6c8ea14ce452d08e aa056f920595e8ac377b62a51d2cf709d5a41d40e7dbe3dbae0aba2bd8a233a9 77934a0376436e73c79bd56f130adbd9cc6f5123e885294cf47bc1dd3c414fc7 bfbaa3ecc649004bbb15cc7debbd46816323bfe0105b3791e0e57386ab487745 0db947e59dd3a8d40e44288cec4e625eccb3cc971e0bac45f42800b1b936cec8 521a51baff9d302a581fdc8b6b2a082ce168506443cc80a62ca69f14a4a0b11c 76e10ba2190ee077a12fc79b6edaeb33c7bded50db3086da134bea03c40db8f8 f37b234f26035226f260ff57ad8f84f200909a5cd110869d6005e0035813a55d 51fb1a164f3a7c2821691e2eb24c2f0955c1c740559897b83d08ec32e800632a 2bc61522cfb276c335d8927d1c6b8286618b00ab24526fe802ded4d3bbde53c1 67fc357d58c8d43662c0874f33b21353c19a69567399ea52445b1849b913a909 48b52f16b8b3981b540488f5f6acfb581d294450d65be14e65e58dbbf60253ff 1320a2c1328db73d7be68bee141437bf677500185e6fc3e929dc3f9dab95419f b18460dcafff16da86f75762e218c462d9289e8d6b2deee0a09be83e6705a3db 90d39d4010268989663f3d1c9f299def738e997a0b7079050369a5b53526c4ec fec94f51224c6e831b887efdaf6d5870119013a2fc5be56f27d7ed38bb106b7c 00dec43d73b11b205b4f87b477c5a83c710f3c24acb593e867fb0c5daf4464ba 2ef9b0b6244bc2b13027ede7831fdd68c81770a4deb8514014bd67838a80d9fa 6894fa92a0f7664270334fc97ec1bf01cfe6b0095f335e616c01d02b32ca9d48 067a8e3008725671deb5d7ddc84019b94a9551dfb73bd641b2ee9d871fce2705 1b99e13740cfcdd7a6bb8209add555fec9a81a7afb06d748713dae825267f76d 863b8e2648a9608e277ef5707e06728b7c8b79de62f548d37bd77a39202b8a36 0db33436281202e971b9396c931144a74689c6433bf55bccf33c6041fda7ec95 4a9a8ab4a6f29c183fdbd5a80d811e8aca72d00ff2de29dd708c39c761f2fe36 13be0aecc992e4f22fe4d7c7992e1752d33cc734ad259037639d6d32a3047ee7 049f80fee9feeae6580317313af61e626a33d53d878eb567ac2d9bfbae102248 5ac30e124fcf168aadd04ff3b7fca5621acd92d5b6f06936c1e616937da8d331 1dd7d925c3797a072f83836330b32d1e7c6b52778cdc92f72c5630a44e91220d d66b2c6be6b5aa0f1a08a6792ad38142fd2bcc51f361715b952d13067dab1f9c 6d381e22a2726f8020e97cde4335eb2c56527a9d11e28655c2b4b82cddbca3d7 6bfcb61c388715ac72cdab95cb33a7af0ca1cd9fb5366cc6dd93f4fe468d132b 8b2454e566e21ba66d1ca980fd00645b4bdcfe0c2a84c0af2533e2dafbdacea5 8459126df9d9ceb0300f76c7595cc5a8bd6471d878edd7f8b384d0d1fd0fab5d 8cbb4f1879dff562fb19c5cb019ad8c23f8defb7e0227e406ad4053f1dc32755 f43a6fb903cb42adae1324ea7994d73a1b3d5a5042ed73edc212741077d24766 243817fe1658b55a49c8ed7476b495025efc7291c96d4d7ba183b484d4ba7e99 875e114d8b496e30dad537fb9f62a4c890a2e1a84b774babeed789fc25f73c9a 9dde7100e86ef6ab7f69c183400a70d43e373b75403397e39cfb110c03f9c6a4 333915296becf857cc1680394b7a3729b751bb6a8278003f44e4235e7f10e439 6f0f0c32c9de9dbb47b0218df572b90f9f96ff5f0d4137d85cbc6c9b176e4d15 364401fa3266e249799cc402b5d97f72564793739fb2680bfe2b640b6c96be9e b89a2d9b796551a88aa683db8be2088db68c48ab18bbee36805b7b88cd5e2c3d 272dec6c03cc42a9b815b95c943e6fde71cc503822c788ebae9af0967538eeee 6191c9ad0f74f8cd8b89d34802039d3508783dbe2f79ddf5a8228ee2f926c8b9 0133e73a1990987e64f84b6c1a48362107c3d4a2c3cf3891a754bdd97fe9c42e 9eeda660ac5a7aa58df2f8a0e6e41737f740a49500fcb719147e0c2c45879390 31e115ff5344b76d4b61beb667c92630089ad645964c7ef0417a3185225a6254 d57d591fc4721f3813ab14ef59ff20352fd5a377a09f79154d723070471d6216 6e71c41144008da8c2967c77960e3cd50fcd46dcb630f771c70d4c69f035e58c ba5639331417c469cdffdc2edd76d89ea8daa8b06de36096d20cd2426e58a52c 9a0e48b9d72bb4f8ba1158572ff086209dc2c8f1fc78bc73064fe37213b27eb6 7434614a6db85b35b9d58ca14348330ec4f5d4af8bd17e6ce127d8dece89dca5 6e727ee9cf224501a33f4f47e6a4451c5aa6bf929a37df985ed701952a81af30 77782a0fb3abc39148edb56d7d4b537a227d41915e6891d2f16b2972a0e70058 14f5cb8b60e2f8094e3047b9f9c308b10f0a24e5af7af16f64bdc4c3c77bf3d8 dd20d46df69e0c2f5016ed036e03b349a90f01c084989e726880f8361d5cae84 e851a82b24a7b0ca3878a12482fcb1f60ee6ce4f4cd47597bf9cd22f5fb1e568 2b7d5a1e872724783d86da998b1fd93d4193d0ce19177cc71ddae5d760635fee 71d44808af76e22dcdf3a16bc1877422a5fc70517fa198bf0f155bc8c5fced4e 2e6b8bafbd14fc9b19fb0919e3e305439e84f499b9a14ffb543475b5350e6a7d 821bc4600e1d2a5c7a14d67265bee4b030fd2ae58d87eb754ae8ed27e682ba9d a8fa817583d67f918e99ae69e8552435d347fe8a6b52cd806819f882526699ac fd4fe251ede77348949a17419369c58cbcb991382bc23f5aa36f5f19b2810aeb c8d6daf1c7ab0123cd8583eded55a897c7cd36a5b8bea937002c64ec2c1883b0 c36e1b5d1c21febf5dce40b32bfcbe6327de0a38918fff2d620e6caf51ebdcb9 9e88fb0d78ddf334079af4ddf23230870dc395823e4bce47209f79ce6b477940 7fdfb9f6ea3c8c58fb633d31016df64d5ff69f455f83e2f867bb13ea1354feb0 104decc7db38774a234d12051fc3caeb468a8e75cd71bcfd0d26cf0c67c35951 82176b3e7d5f0fadf612c423ccd0ed4d2ce649efaba968e4df54b3849d0d17f1 9e6827d1ca0e143cd389c00ee002b3feaca98b06664c1ae31911bc764ce02071 b9f0f644fdae5fdac3d826cf50855c20a7ebee5cc9695244423b95aa975cc751 0fbddb9441a90b7c07d050ccfbc925a23119fc6799eae55fedea3eb0b5aabf6a adde6f441d16751dcee18d4a91e6754d0826f8a01f8bc7484e64f041b3b02d48 dcfcf0985e62c6c466adc2600953e08255a7a00fe9becca70876669ffe13bf92 0f448e104a62db888bfa6e8ec59b05495e8941df5888c1b9b5d1e23e368e1bba 213f423365288408cc33c05b704faf223648c64a1be8fee5922d2e570c534959 a0299c33472c6b4a4d9567c31d73bbba880abfc45ad36c6b76c9d609fe339228 14e742056c0586cd94294182d584a344e1983b9667b217b2cd0062f60959e913 6c6a8e654a74956f16048a6ecc86b3039c0eb2134da37af62a96ce64dac9cbbe d0afe0171370f1213682335e1ed8ef8b86e29333ae17f5709d1f61fbac037204 c6fd55018cd447be601ba759811160dccb0ef30a3879369f53f849658e59e1b9 53a9e18c47c7902b3a5e37eb9cc01dbd047be6fd8d0aefd8b834ece1dcc73d91 10695326df92c00e94ee5bed89db47bf1d176ec77ff909a7ce51b80beb9cc73a c81f80913b460b131991736bc1189e47bfe750c5eba7aeb7c9706fd5504eae73 ae3376b66c539e57a3a85b0407747b5aa4a808f881cc8b28e05598753b1c7cd0 dcb4a75073ec0cfc16742ee3e11beababdafd2c2971838f9f61f405198b9cde2 4f43453234ff3cd83ff8610f0a11a3cd80ddbd4f2b01dcfbb7eaf9b0e34d6780 b1e20924a708035cce261f22fa64832bea100bbe25376710a1d63e28a141da73 4354238d27c5b245ee4857a61b672ca134ada33bdcaf96428f04a66a808af020 63bae93da99a2ee4a6ec49040677f4e6a40bad4c507bf8f53b80dfa9712529e5 9ae93baddbea01705e27d4dd13a399083112085a61f005c7e64004717dac37e7 35274aa3354dfe2b2c6dd3e9f518ccbddd08f6ee8ea0bc45713ad8791d579ebb 3f854a0ef357f46db968ebbf8a2e686c05b3addb16ed6c5db3a7c36e42cdacb9 2a266c4a649e19300e55b98f85848047c657680bcfe24ec80e84a8296345eab6 48e89f8a141a6dbcb3f85807a3af5d5a4cc8268a7f1af7fa0fa76659fd3279c7 0fcfe21a204db6d8e058d8865e52f2114d8edf6fea0353a7e9719d9ac8a047a2 d21119a697a400d04f91496461a93fda9c0c2ad605ef625a3a41b7c24e31e669 7d6518f8e138a301da092c5133039727253495b8e2cf5acbec15ed7f8415557d 7e86fe6445a668559eb92896d11b780f085b3c7544f57f81801b58116f4a4271 49a18999aae26bead623c293a6b7a71010979fffb93c058485b787a31fdfbeb9 8889d89d2fabadcf70c5a42bc7aac69e6374f9298cc1bbd1d5f917f1ee08dfd4 dcc9a9f6c6b429b754daa54566b6d93351228b1966c278329f898607a44b3bdd 641a46c0cebf5cb6cd9b1d7c91f5a3f2231afb3c3fe5db019808d316eac1362a c5ecd18a3e13f4dc954d62243270db3001e96a24813dd29c795690afb8a031a9 9c029f54454ded36a88edc7b15e341aae381ebee9c31e86348b16efb7f990bba 3958eef7ad6ae2ba276770117eb17de9b960a3466937bb1c20da5efdd3a60893 be87cb8fe5a362f53dd796f131cf79f13d444bcf8ad60d4f25f8fe7d6455fa37 18af8e9664f0b5deef56a7abb8b63d502388417cc0f644725fdff85cbb5b9e66 5c70edfab8b45b804cb2ba4cc3b1021d026d83ca3d1580c3f14650c097c0fcec 24575b1423c908953e36a6a24c54e6e621f06ae843e9d89f2f52e3218768a456 0260647016a82aff1e62bf983e30a17640cf24ce3c73a9d8f89f59d226f32b83 27535f0df1e54b627ac4a37cadff9e6cd5c96f43855559fd563268bce841b335 fe9b1154b1297bdbc4cfbf3daa035a70b79620cad8f6a8523ed2e8fc9c1ddd97 944ae90c5f38e6358e93af183f715cf4a3f3186a9eddcdd592cbdfccc3799a0f 3e9e657e7c8c148a8fa07a4b67c45a2f1e69a8aee84f3b3b40898db2d96a7e3f 6e1daf3bf663ec8316d25fbfe77ad09f19549cf04b9bdd3e0d48e51de1234ce9 3e62f566af10f50651bdfc2b2a6f932d26010a3065fe765a8ea0a4981fabff37 162b843296c3d0c5972c7c0f90e1c8e40f38c3515969fdbf54c45ab437ca88d5 8e8ad370cd30dc8cdffb68747a2a2560977d1b2c59196db372e781ce8688a4e0 abf3d8aa5907d51ed62cef935e4628ffce6deceeed64f746ebc169668f2e865d 9667dfb5fd135771b10d10ed39e012760b5fd062b063cdd0e7d381be79918b03 fdcd73976b5896cc5858e4c31122f954d8eba6868a960fcf6cf5165b4419184c fd955a19c747d6a59ae7fb3173feb7b4a504de010055458b2a9286f1740f7d6a 4cd76b98c047fc6a90f4ae937d3199d4d8fbe664799ec75998366a27bca4c271 e4b619e62c2ec934be420514c44c1da07c127e6e125c6e019ec0b7ced669e777 17f6e3cae742ffb474168bb4e087015689155744009e1bda70076d309893b82d 2a460b4dd1245bb5f2f66164ecf5820b29739249067cf6942511bb811c3daa18 ab0523a1ddaa8788076c7c9599c06a4f8bb19dc90cf49246aea691699ec09870 688b3eb5ec3f927524328b145326de1f269743cec6eb374692b9092a7ee5d14d eddcbdfba55372d653e19f16d08a8495161f1a88c2132ca559ab42b89c719378 3d1f8e63d4953c93f38459dc0a65b8084b45394c86147209d98cb775915ca9e1 3ea3833810e1f68211778d5877a92758eedf2fbe1e0aa7c62b58f5d089990db9 f186ec1c5270e1b0f2bbd2c051fe290c46fa439167e1d1bcbe3fb2402aeb2c39 d63c32f5ef2f0aec6c331482e6938df511bb49598f7cd6d826fb727678e8ed23 73252d0041c16b46364ca492edf0deac3f846b2324ebd7f0d290b9927946f442 dcb299b9c841a47c5045fb3f1aa2b3884fa4649cdf5e1d5b07e7c9c971d40ea2 bad0e363c718712dc48087b175fcb8144b1645b2511ffd4e225a285fdc5a3ba4 654cfbbfb2f1686bf62b3786e671e1a09d8f360b7d194611a50300076c3297d6 ae1ffb1a87718f167e2c6c50ed481e4a42f89d6cbbf693881736fbbefc91f23d 4894425b4a2f8a1eb5bad108304e174032e3d96366ecfe1685367093351ec64d 0bdc2a6d32ffe1bf7125d96936f318f354db32713467b5b0edd4b2fdec836807 b32a4e79b2e71df15279f8a316ea318f165c54228f38db6e8d7bc856e8daf4fa abd6244a727172ad8012e0a4fa9c56291aa631e4e44e4aef18ce61b5832abb9d 785663d027a175b64a09d175c4b5af36b7f478d50dc9bbe373143a7edfdca4ce a8d453e7cfef64a9ae74c508a8f6e9bbc055203fb76ff0190e3a64db114549fa a6ae712ef2060def16f74154df71aabca7452de2702768f4e7e0bac77ffe253c efa52b382578423ad35ab41eb1bdea3bddfddeaa05d92b92f18b669abea7b871 8466774991795ddfb8d4c5c08edc32775c7ddb2a4f813a2a37c99ca3d4cb5c19 9b425f646bc664e667dd4bc4c234852dd0a7dbe655407bfe1ac63d718042bda8 52c74c8f9ce6074cebcf06b9a198fee8bba1abb4e671d5b2d90f491f1aeb1d0e c598d4307122f91ec90835ad2a191959a9a9e7b2aa79d30037d39d6b93ca8795 369b648ab0c6913d71536c95a98a73163ea47df7a9120b2edf8ea969f92e3829 171e0bd2c68b457be2cc971acd2ee633b71c037b6b93877ca603cac69f393521 4d2f9ebe8e1d02ef2a259167da946e6cb6451e5233cad44a07f1a27bf390e497 3741f8f6a258af381071d689f5b5b885f1f180e5dc873806cd35c5dfd2b85913 4c921ca4eb0eee796cee46ad32c18ab739efb8ec738e148472a871ea18bab81f 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 true +check_ring_signature 0144a0b74a680a2b78d13017cce8ecde72b0782a3b2bfa8925608aa8619e9a4c 3a57ec9b5fe3a67a42583ba6a131d52204acf1f6abe55b030252293b26e9e551 6 c8d30c0adaf02612481785b440fd9c18491b596280baff7aa54d7e80e9d074bc 9f211eaaa956d5ea768beff07ea8cb3764a20e2016fa8e5fa47a10832faa120a 9dcbfa44fa3bdd4546fc33b201e5f0d604ec81654561bf2e82ca73b23cbe09c9 8bb59f9be016a7f42fb8f9c5d7ff5981fa403cce4afc68d602b56e9f7637403e 21c71cd0895d1672ccc995e64460d3afa0267b928472fb7aaf4c2cc2c340d67d e4dbe3385708a672ac93b210f5776ecb59f0b8fb729dec76cf5c3bcc22a00ccc 0000f9965b3822d910df4a98538d154c741a91b95653cb76eb7c15f13732c00798be0069df127ded3e87cc6157bd08705a24cc2d25d56ad4096546a813e7c808bcdc9ba1420bb0e14bf27d7e212704a66328c1958eac4af9b982a6c0524f460dd11d45e33d6a21cee4aa900434d56c791bf44fa68b03ac94be5d301630a557088f056c432a182911a11f6304fd974dbf97433bf14b674a6fad931d70b413d208fe0e4f5881188e2b42d466a97bb95951b3276adbb6eeda8a99a747eb456e810f440472429b9e769987bba7ba74f2ba5b814eac6bec11e7f04115b90a6b819609e9113e323295b8642c4e19880de5dad9d39a72f5342a8366466c9d88a84bdc0a2af144557990644eb471c0ad06974d8bb845695a0796fbb07a34483ca2a09100fb5ce76339cb1c3ad161769759c5c006641719db1b4aee1a82410f9daf7c7a04bd01a2e2b62397772a28de636d8ea0ca46f4da652ac29247d052e0845109f55228246c58c6cb5298fbc5ade1019208e4bf0f3a3e57d92a7e9cbb98b3d9b4f701 false +check_ring_signature 4f83aebdcef5d39f47794cfe45ef4622838f662e1fac5ea99b22d5a314da7ba2 969f46a281afdaad7910ca5db41b37fc432a9b61c65da910bad5636995da48f4 4 795e51da2723179e9b0e58438d61d150be5218035ebf310d19349d115a4474f0 4fdac355198c38f28d9413b56159870e5fd1052e53dfa487192cf54b031ea0d4 0798bc295f4545dd306ea8f5d0abf8208a6de21515a1d64d590fcafa0d76d185 f544d561dc2891a0947bfa2b267571785e0b050f61690bf1ba178277823a160c 4b046626c7a0bd129a83f55650c7324957534f3c769eae557f2239f75a608501550bfe3c7f84b319ab85dd186b584b73950cacbb6cf683c7b4df484a326f8e058e6a56cdf4009af8d983ba4bc3ca0fdebd8abccf8706c4423d904228e4d20409fdb342a52e371be8693fe456e9d11c6ee1aa5d450678947f1727137f83dae70e6004e7e111d54329ff33e5aa051baa7a1c6638e8a4deaa9d520a4c71892a4307b6890c8cd8151dc0d0102ad6d92952cbdcda22bc553bdd7e369516fa7c8bed036af01da2d50c663d1ccbdee3d1d7d014fbdfe8a476c2f86887e2cb869a3c7306461120a1c2e737690d9e1b0ee672332f551e477a8a7748050cc559fe1d668205 false +check_ring_signature da9ccff187ddcf3a12590e551251878b8fe4b54fbd1be8d083b7b74afe13dfe2 048077c69457cf9310f137f3fca30aba29096b74b8c536f6e1854eb298127118 1 c147349bf4e7451b058ea5798ed2c21cb85114c8cddfd6fd87f57196d926dc25 c4c4165226dda588dc5d7bde4c1b7a9f7210dfce53da7ea3feea5b55bcef730297b10f765472c5fafc3d06477a208da18130fb64e47c5c201a4a425c7e0e9907 false +check_ring_signature e76e4f250db29f5f15816fcd35aa761786a63b2d4429c18f9a413a5d5eead759 1f6b7e4b16ddc0732bbe15cc7ee329ac34133f08c82f48f774df1eca9ce51a7c 16 91a4085484d4c71296ce2fe7584e55e170315717abd9a81fea13be53d58dcb2e 9032a982f9537deac4a391725376424b1707ffa10b1fde705c47231b9b613224 12e811bb1b1b2450553626afe9f419e616c06e6fd102f8c186331f61cce0690c 4cc4ea4c0ab8a91cf79ef7a1bd79adff17b3741120d9e8c537da1f2d37af41f7 301bf78f0cf82646af699bfa95c0e9bfbcfa7c89d7d324cc4d490756c0396cb0 faac565e09d9aef1f2d20033fd58c17a4e83071a43eb0ec3990632714c2bf1a5 e60fc26322ea001370416454d4b4f11f3f747e0bbdd195974227e3caf867ab48 1e8dcdced9baf07a2426c172a931b8d6bfe109fedf603567da6becc3deef85d7 50a372bcfccf8f4e3e449d47d358a736cb952e0dcc5974c738e63b0b1ae0ba77 1b689e9bc35bd0d43d662d5ce32c2f9d562bbd4a5390ca1fc41e630f7e86f93f 0ef7edc3aa4f9e22a9880f9691fa39fe1c81cf739422ffcdce2ef0cd8ef481c7 18ae00b796c035be4a8c0d5f0faa5bbf9f4daf1f638a932d2cb43ede3fbba1ff 7ffdc45caba07695156d0e7e33ca9709fa6a1006db30850b463d88b20ed54214 050c03eae91c369abb054f80d67fbd46d9b2acb60a65d3109979733d80de410d 99c2fe47563bf345c341c6875367d66c8716f2576647a3158ceae69159995564 30ced922d2d9a91921b9e05e9f665511fcca6c30e0137b2d5f290d32947d660d 3cf2d7f7c23ae3372c56dcf966d10a9b509c96cc09cfdec5c3301da541579e0a579709f793270c8d14234c0bb25ed9bf9709af8302cbc295bd41aad5c1a5430d4bc259fbc066d9b2fd951b2b649bdb656ddece9721969653ca07f33f2c6b7c04cae0e443202aaaf8b9b04bea326aab95d30b79ca8df2ed872d46f584cc962cce9fd01d63c39aa6583eb3d91dbcf853597e7ab073dd0c77d0f9052f501d6e98096af9a46884f3c42feed55c95e4e7b3320caa4f0c50a71d33bc47e6ea6586eb0ef374ae381ceaa8da9137f3676e1eada22a4e4aa93d7de6b928c9fcc6cc8e2c06dfda24fda0a087b2cb27fcd796817cc8c3cf18f990033b5174ceb8e008737809c9b668c2dd89061fed5b1dd262b12ca08b8ba2dc65dcd03711d5f3b4812be20c72313e1fc6ce7002ef277e1b2227f5f0c3d3aa6236fdd7f7d7cde09259d5860f95b5a13299130697f598e829be5e38206b85e5364ae471ea13748a13412e53adf05d0f9c726d7db0d2e2ae5af9068e9fc85c5c1675190cda0f6096566088e50fb80bc7487ca903757201384d6b153c78385184ae580f15ac5e630f9b47c53f0ff036e5dd31d35f15710e054da21e8df97d2e247f8ebee71b84859282b895540080a3355356ff6ce6b1706d65c8761f77c9624fbd446ff0de47b5fa791d45d70dc354d605ac0b383b5e43932a69d2832fd2481ab050452f3b1a599f149e73c2029323aa23c31f1c36943389697a1c9600bd50f42b0196569581212a070ef41c02ece1190af52a53ba0518f7c53f178fe4c218344f4078dd6a2ff1a47861cb690b270c1e3df89e4312e47140fae5e42d165e7827a6fa9d7c8d4b32768990e59a0da8ac91a1f6131534125eab29bdf67caf9f59bcf345ebd6323b5ff0787cbf3b0709e76f7721d49653a0b1c2de25f22204e8a5779485dca941a0be01b9fa884304dc8117519e0ed3706b23bf19ca8bf9abf2756ccd02927951662b7824faa0f300c13357a8796db0fbf80a7164b19437a1d6dbab50596678e7f9b3c8f725befb03e438d69a606705bdde728a5bfe510021a48bb05d02d5cf583f23416f7506b3032ed7485041fb5bf8362dccc217ed66b04afb45b9de463650f3a8f2c3e52208080bf66f8c6fa0dbfe8d8ac800aaf40d1e1b6c27985f3fb23da18bc78ca9940206000ca0f511e2aa3bc5aecc5bdb00a50f56c0bd19a3505cb02ae3223429464e0950549514a161ccc7586635296f1030fdeb2c079116cafb7680c5154a7653f60ce44e14788aa1c20ce68745a16182efbc7b433f02a3fa7cf39adfcf9cc47b4802462068a5ee1a12f47f53a3001e58a3841eded63db640a20e3f998d1d4235e2048112702940c8707217261b36c5d69052df0abf9b82595e92b9151e5606e5af043e440041a33ede4bda674dae8605ae7f0be1dd54efdcb97a71414404ec7ea20e false +check_ring_signature 5eb36f8f5d00bffa2803883c08220399b56f7e19756d2087d85297a387ce45c2 a894739adfda4613f2dbc20f405fc7c046937c67230c9f9c5c89a558f6c2d47f 2 638e4e660b5132123c461bec7b7ab70ddd7c37c70dfc301f1cf375b0121e5b40 527d1b58fcb11e4021ee1049e3e95624cdabbe0fd21d5aaef834deab089e5d7d e68988d7953791ee9ddd486c2f068a61d9ff20e8bf28a95f4f8d2d933ec3bd0443e0d1dd5db11b6b1db8592f7316071256c77f7ce20ed59c192408231e364c0d44a9519e9bc8ff18903ce47e89eff3f72d24b8ebe745d23c7213b11fb0e0f402f650e232f2b825fbeed85b07473c4444e3476beb94ef8712ce22af65f69c3746 false +check_ring_signature ed45b2cbf72203a24e2fe680f8ac83068accfe60547178ef6b97ebb189ee12e8 bcef8b48e5b025a1759e051c15d05dafccb13b0d22559e750701fcc1b49016c5 1 b8dc1af7d36ddbba51ebd223f961faea932f6af791caec7b3d63af1c33912000 ac61afe40282eaa7c17e053197cf1fdc3666b5e1c01c8fc4c8b1ca7d59922f03980133686f5e0bb942c909a513a71d70562c20050a47c540ed3154ced935e906 false +check_ring_signature d4e524bb0b72bcba13fceb1506b7aa420f3c297b3a1e8e12843f046f2dde1272 fe7047684de03904416f7e9bdbe790c2e3aba6be619286c46fcba583bb07f125 3 3b865dac2e1346ca84b9135eac5cfd5666f78fd45d7db4e186867f655ab2fa1c 65accb09d010719f7f3893f14f7c26198e795ff36e6f4be5235eb9a3890a0da4 2c72ceb549ca4aba882e73d90ecddb4bd1e439c8486925862e88d9c8f388365a d5d9edf1f52533107a02bc5d82074843267355e1f2265f739030106b41a47608bee390f9acd34f16ccb8893a5770c6f9e7d4c889e12af2efae3bda85bdaedf0f4dc898e635f86690b0905be258b0701c95c117db937e317a6908307865fe1a02863f0f9a30b4f6cb71add11e2fa4db2a27cd067caac0ff54fd68b195dcd40806438301be4a95348fbb850fa11f42a6b6f47a129e26afc57f08f64ba66529430e4fa9fd2d165f1f92d12b8029c4d4367b95de014621f3ad3fff3140cacf655008 false +check_ring_signature a5f65aa883fa8ed0cd4fb38c9574a28c9866927b00a55f18c8ab090e9b1f0d91 032fb1891a05ad610173f19efc226e0b0a3fcd71a8132344bbc219f9b5936140 28 b6d6a6855431d73325f286e13c7d8d139c55755c4304f2b5d44b679e8616a54b b96a9fdbbe7ce8ec359d722c74efde6d00f206154a35343b67e22db57a6a1bcb 128b70b632b079037314d5291e65e7f55343818f271ddb7aa3707585ae6bc152 8ecb7c93e5eaa97c955d187a13046f8d6da02db4e9562587ec9d0d90ac786937 4e5bf46be662cc0bd93075d4fc55999442eab852e67a98713de500e2e197a4d1 6cbe306f57a8b0854f6a8037f0954176debf0a75427b6baafc548ea7ea547552 f948ab61f2160fdd0e2216feac929e5b4c980baa8cf81b9a731d3135e5152a4b aba09aaa6acb7a2ee0dd9043fe09b2f2e2f0953f22dd7838521242b34a170fc1 654ce03bad6648102ed56d19b734bab8978ecdc26f13f7b8e32aa20f8fa2ff81 e6665168971a93c44bf37b7a7e12c3755b03612bcfd1e7c865e474e7cd65342d 195138dd7e7909af2802db22a854a1196c876664d60376a60bc10e6f485a49ef 15d6f5a14c05f95ba4e87c6c1a8056fb85f182c116fa5b9b0960cd856a599eb8 953a629c1c66f17f3bb81e0c501b7cef11fc462ac9c0e95545d1e54d22a21b3c 1530c82655487efe81a450788d6b7d3cb5d90b02a46a774e9f06d06cef98abc4 b00e88b3f4b08b3e13b6899cf0e20467e985b904f286cc01cfe45d996e6503ba aff0e4cbf2ec83375628c66e4feaef4e78356d4c439cce282b0eb401ab9e1464 266b5c381d58264331396be04adcf0983cd6ac28887a0008ea1ef9c7506ca695 09e5e42d394a84ae6bc54520cb1996fa09071dc638a3c24ce1be43bf4b198335 8b297bc7aeca5294ddb429dd328d6bc6ee15b48b3155d651cb0cf8f205e593d0 b9b07b10749955b1cc49c28780726bbfb37ef6216ac28a174ffff1fcd4a7157b d260a295da11714fe2a6dfbc528a57e8028c1004d9673fd0dd80d8dcdb485af7 cf3d78d49b59eb583ac29e9f6a730e314bf1417dbb2d71808957ac2be84c54a0 bce4140c97327b6f601753aacb9ec38ba6a6b362ff4cb601be21390fbcc3e490 b4bea55b6f5c7d8185c5528b98a5d8187d0bc6cde4089f825bd51b6b48039184 75d78361032d68cefb973624c56f8a2343238f3792c4ea78c9d711fb47b82d6e f758cf2f4a7fd05b3eb71963f69bcab2e4d9bc43832d4ab7d80fc67d30f6293a 474a808433e7e2b98d369e472c5f35d467f743e4441888d6c2b0200ef798914c be8384b04c1d119b89d3b8d458af102fddf8945ceed0e7464cdf49088a01b30e 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 false +check_ring_signature 1caabfc4cb272a1c99233cca2040a72289f7b2d1cb61392d1715db9c19639313 d13aa0d6bb7d3ae4cc10dc6af4813166b906a0662df996bbe004a14aa6ed3033 15 c5403c494e60894b1e6d5d1b72135195c1cf536c11313c0913e906a8cb9eaba9 43883f2b5770527b10decd6353dfb316b2152f1141c93571ea08a70cd3cff9ec 93addfd2eba26263ca0e6ea83ff4f90ad5bec1888462d2d2beef74ba395cffff bdc039624b610ed87eef4336460ab5f5d20731e861af9d27a4dbf71695a626fe f272a3d40055223ac5accd20cd17366a1563f01b2263a3b82b858a7dbc021aef 06ae6f67ec5b767d0c0c6df6041a455bdbeee017de33c014260e93c81cf3b478 30767f6dbd5197c05f6c3d0c92236291d249152551f2207b4d8b54dcfdd77b5a 2ebfd4d85dd3dca9b2ab7fabda04611a4483faf5a41f9f810b00676aaee7135b b2395c87bd8f3c1f22fdd49779e469f95cad7a6ff17805b9de5e093b30bd23aa 56ce9e1d056d6111a703ea415eec509b8c9055fac9253511789dd035edef6d0f 6f3cd2cd0a22aa36b8386ae55143d4fd8ff36fb288c4b4cbfb1526e37abd18a1 519a6c32cb517b08e59e8b5344f288a4be5cb7bc72d10dbb701d4d902a1c597c 5dfba5853be68c2601e436f494344638655d0adc4f7c2a6359ed4ac23c0b3a89 f57a910cce83ca989e65233901627cd8c096be137313616e5a5033a8379ca2e3 db25128fa054d0b4ac4c595f3ba98b476d2844c3205b6c75710536823ef4096d 134bd8356bdb64dbcc5a4db0aaa352966283471599d1ea0fc93af4ad6714a40923e317630f455fea731b43d88033874d1ce7fcb712b53d556505466f51a6ef0d6936bd39ec98b4701c467b7415b670f957fbc0a478f336f10ff7bd138315310e043af3105c56eeea0b554063198c5bacd8b486aa33d439e7ba43877dd8d5d90420c6a1ab78aeb4043a178ba8888ba1c49434879e41f72fabec8ca5282c43c50aa6727247898156e863c06fd317b28cf1ce3806f078778bf20635738b67ffb2075a330165415480ffcf175f7d7ad379991a2c89b4b687360eb62f2a683121d5092c7b41b0ca36e034cc710019b3df97e203466104ebc8ce744a9570c9b23f3e021bec755822a22cfbe9091d6b10975ab7f53b0575ab19100fd553e6adc31a7b0e21a136b5158d611fd8b8c973b57aeb195830607fbcea97959a9ffd8964a99005002e76de25b2ca445c19cb43b90f8de9ea37c6a25e9c67042836be44f06386081f6d9461c3b0879d9c658afad1de6d717ac2e688fc11b653cea8c1a4fb1a080694565c609035dfbd7dab4c7ecd4092d1fcc29d4164cd49990d87694e667bf902abe7055b5f5b9dbfe88d51a50e320ffe38ba821e595ab5b483872d795bf53909d2c45e246dfaa86cbc3713781fab64273a2743629432db4b7bb5f6dc4bf26e0b262f41e3c87cdb4a95f956a3acb4aee5730f9f07e350b11b49a6482274ce1f06b213566722045e81e0414b0960e10b0370b4b5a4ecffa4e72d9b5ddcf0d5fa02f893a8e656ff3b31fb29fa2c7d68eb3897baa1431d45a987e2043a462e16ba03a556f72c2554be0c98077a31235958fc5b2b80d21dd91ca425570eeda8fb3b0554647564df5ff1c8ef88d20d26a7b299c08c5e702724c835db54c31f290b750be79b7495a3fd8854a4b5dffe86688282cfddf4a77fd31ad1105976d0c7714308503619436527314911e37b9d12c5fe8466b0a89f10b1c3b7644bdae40b1640052bc4a4ccefa8c22987c277d3cc0dab7e73bfd7c1db7e1f0fcace077be70d16015d1c7f211981d84d2dfc0381aca1f204b27b02f174d8649162d652fb7176fc08e45b9dc79c9109af724f8c122d8b5c6a91aee2f0029aa5ab8661793bc3a41f012a8f1ae8afd8732e6f0787b58ef09965e7835bbe9df3dfc5a37dc675d284a30b53c96e914b5527289813980b520884a86d4008b3436b70186dc60aa051530e0552ff36cf34caae2c71fe89277354d98f45a17926879262805435cd02e3094803047a63b1d96d28fd287504544a95d4e1b8076f501f816b5582535982a1cdd904ae618667dcadbd98cdcfb4a2b8a807e32e7b1f0b09b8f67b17a38f3f16aa280d true +check_ring_signature 14cec7a88b1db7e34d8255a80ff4008c90c89d2936c2c01a3d45d129c4aaab7d 78b8d4a9e2d0ca6741073628ffcfd8a96e2f7f58fc492f4fa3270ab5ec001e8b 52 ee062814248864ee2e23b1d175466508cf1d872586d5b7d9538ababd5bae738e afc4d7806ca36222535864ad3573bf463b305560b252cb021ae864b4147a2c21 b8a809e7626fb3edf221e5bb666f278a5abadfb108ffcf130f5e041a7359fd57 1a2b8cdc12df83711aa55dac0cacf32114097dcc9e2e3a001cb593539ef0feca e4aa8a4d1a657ce2afd8571ce52461dfb263ac731abd185aed7e290fa89676c1 2028b043c8b597be5cf08dd087db0bc2fe1a85f5ecc429cf784217529ad522e8 8af88a7e0dc9595b37a9baa1fe04b3a2a9be9d7206c5f2425bb19f79a363a69b f9b79e1eecc9f6c7aaacadd19341ee869c4d9f68f099ad16d724107522d32f0a 6acc924fd126e6202d710052406c2aa926971b9dc1664540fc90994c2afa4bb7 8d677ce2bf108fb1ef3b2fb7500ad61f1529aff9fa5e6ec67b6051a1bbe183d5 6fb28a67377c073db6f8bd16ad17756ef24b213bd117cf7ce8fbd9ab10bc6d3f c9c2fdac1ffb0c578a2782c7d6d28e06ce51fa211dddf88ec665ffb588847503 6b58a03a8ee0f91e2f8b4e099799f4ff8aa38ce95b54c04a794a1183440e7377 36ded8c5b2c38be68e01ab8ff3f5487c5088d59f1944e40c58ed23a7b0946adc 3f9387af625aa07bf633112abe1f56219a1bd330c8eca6d9a79dcc2c59dcc283 7f6d825db409c382bacfa1eda36f298ed07b5aa6834ea2347a2b30e8d39f0b2d d0caf9510e24a1d7dafe61a6788e918211e567aae8f29824183433c6f0f90994 34e6e16ddcc513ce8ee88463a075b7194307d319f4c6012a3cf8533993460d76 92c1fe3d0161d6a112bc7804fd2562effe4bd83a41fa3ea5779f5994276b0e9d ee4661bbee4fb7c47a6ef264433f4f5194d880c8f5657c3e7da226b1c95a3879 0b5efb4d7e9d9638317ae773e28760bc9c95fcd205f398ebf84573863cf6e2d1 fbef628bcbc50bb7bed296637275a7e2bd5539d6847d0d220feb647db96d7b21 21125d1db675d37d2ce8f72fc4c14cf57e4e40b2b7e57d9828d7660f961f5751 dfca9b014ebedcd1566f9bbf737b043fe1f50411140639c381b6fd930a4f636f 458d9e5b968420cb22025283b749cce26c1433ef0343f570cd9d052ce8ffd8e3 7d16800adace032fe6a8334ef5638791415f3c1a1482c34ceb766ef2b407cb6c efe2da90c97cbfa4d96c75bd37aca98395e9498435e719a98823e837e7d3d776 30528ed1cf5878203c4a7f52c5aa24463421f8fc1e5ed65470bd42ecd19b9f20 9644aa60657df3352542d90c4208ff8da8107def4a40b1666532886aca7536e4 af9ab06966636864f3c3291f40ca337b3188dfe6bace350dffe8093e1b2466f9 930a0493f875a4bcdfdb9e8d21b8ed861c464c3aa15214e0126a58da54f2c435 273c6f065f604b7a78ff91658253203102a3d69c643bf3be7bdd7e3387ef6cfe 408afd05b348b67b9d1b6566d299ca0c9f55ab9971f59771076019da9b95a001 3006d42a922eefecbf8a8c70a51c95a5e81d24b760511a703936040bc9747d06 8ebc392a2763b1891e0b1e997e14e0129f08de1fda72d01597b44b96af08ac32 6d651593e283cfa6ecbf572c8039234d7c3e37d8aaaa0e3566a324989b1976c2 f9c5971fa816f5377a5d69303d4a65c472e46f85422a70745545e9e371bcc57c 942132b66e729c5ed96f136a5421b52a313f31cfae70c9c6d7c668e6da5f154f 2ab986fc91e88fa111e2e917b69d1240f1697c1dabf14a14d2dfac083ce0e200 93f6da75ae84168f28aa08d7e1083c72943c50a4d81d6f2c8152ddf604c21c1f 3da01f20ea125674dbfea9c5bd7ed685c0bec63dea3a3a32a33a5ebc870f7c1e 7e6c6ad8e349089b5b2f76b264ef65d7e47d649150a7cdf38f4592da8dba2baa ec474d5ddcc892e8bd49b2fafd0bf8ecace8897fdb19b2c9d89a7a30dad1d1c2 0acc8f468ba7474c92242204055a23b2b2b7bce384d3eda910f102ccbf0f1379 21e2c117bd7ddbc4c6e55732dfafa9cfddc52cab5f70803e60f52eab332ba08e 97235a26bba0fc5e1757e185461a321b08402369bd46df0bdd59aac92f4cb301 8710afae0a79df4322d26b333cb90c5d58bcb5bb230ab64737bfed9b88722534 0214dae84c9c6547f192cd2093158bc4ef6eeef508ef10d7d14fd5043cc63e62 773a40017e4faeeb110098acd0fc4debbb53fa8af77de58fe0b3179ba78a0320 1f76ba24695e7975b439446d5a5f9e7fe8976b9b831ad6847ad44aad92a1fcac 050c12a767b179b0c75d6d2491b54834256a4f9eb2302953dd41dc358a4fd8ad f8d8ee2137d7e6864b8a955505591f142a4a28223d1b73dec189267316123ac3 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 false +check_ring_signature 762bd3a06a4dd56358fac7e77977443ead6b3f5f378e4baad2b67ede666d196f 900b491998497e9d9bfef8f456b4fc88d3bb46aea910e49a90b8c9198804a315 1 cb220a8f68667b8d0f62481fac7d6c58db4beaea7897442bfb617635f7ef589f 6b10ee00f897fdee42a8ff346db7e8738fe198720018d9d3097eb8ba28fd7506251676f6808cc6d8ba082810579c375c18d347fd8829cf5b8474804774f9bfc7 false +check_ring_signature 4033f0d0bd47a2dc672c26f413aac0cafffb682916f2bcc82bc1c3a1dbbcccba 63c5b570dd3ebfeda2e636033cf594057bef069203bf10efd32c0bc6a9490fd1 6 0db4487116f0ddb4057b19412ca18f987f1585a70a4c747b0526d93a87e896c5 c72ad6aeb7b24f270faaf060883f1fedc7e78059edb4374e79a785701e9170c6 e60be903e12cc0a4d8abec391e509d2afa1b56fba22e4ba55ccb473cadac2182 8eed5ef33c5322d87151cd5e40b4a45355509f5336a1197794c4fd3086324106 ddfdbdd980ea208422f88ea3e25f99920795cb79b5cccb73c4c6e478fa769f2e 61db8c42ab1de80873ee4d84936e6f823d14a1615e5fe6a2548a345bf8ae121b 6260f4356da15ee502c396fc75a5e674ed970d0ac1ad5cbc7a4de7ed73e9fb03d331bea8472f32c932ac9c297ffdc270a0125ca4fc86c9b2a46621cbfa6cc205aceecd7b8fa0a133bb00013f7e9769431d29f550c57feaa435254eb50b17df00ea4259dc0d8b1445b4e283d428bf1ff3916faed80496d2d185d7b52f04a93700b51251c2d70fb3a13018213e072a9cfbb1c93e313bbe9e335c5a2a042370bcf53927433894a30de6953c5100ce0819671845645b89bae7b19f156958640f116d23cc844a671e09724e04a26c0e29bd1a1565e7397d7aa005e17dd34d2ed94402f034f5ee2965b38fb40761d85900bbeb2fc4bd735ab8db5b087209c4ca391e0d9c3b5a212f2ed6d3eeb25c8b238b071d1393835b417ae22e96bb7e620d8bc907ef11f2511071428942fa4949c44bbe42aa43720d5f72d8aeec3c10b178e9720dbff8ee6457e2c5d2c25e0d9daf9b44820effa14283cd6bd2db9a9974e6ccd90649dcf3944c24e81f0bead30abc44588af41beec32b6cf77d81a67c0ed3b49309 false +check_ring_signature 67133b9068d59b16793b9558054b943a87c349841763304605b4e15b8da7e23d f6cae888fb80bfe5d6ad155bef546efddeced8da0b88e870a948cb9d403ad277 1 22bbbf6c9a6fd8b93c945da2bfa6850210534c8836f1e35c7b27687be4f2edad f0cc521234e66b2ba29cc0f78dd0c4cf728ccc7b2e44bc0178423e113871f1031415b89739c67173b3e6905af77e9c3aa65640b0ab05186e4e234d87cdcee90d true +check_ring_signature f3301a5b608b671d6d97d065547ca3c035e35d7d98d3c6d8e4edd73cb5ba4ef4 e36a7d86f3d3e1c47afa38b7d2eb18c3ce031f910673bd9ed984fe224ca694c4 64 5c26929354b0ef79e6ba72cb4cff2e56f4a29eba310ab3ea5b77c88e81e65e51 d66f89b4982e68f2c9da046af1aa09120f3c7dca4173b4565845740de9bc2af6 45b10842da80737846881e9ef963c4deba36ce91ff3e1c0b80c66a58319e1cb1 92c8a40a91b4e0ad1d264a502aa4ac4ee5fa606cc25a0cf7b404dfe505c0cf94 93e326ebeebfc415ae276dd489eaa4ce83fea6593bdfb43beb6ad80ae87bca5a b0f2431893d6e8830b64aa25ee39923d954c641b1aef8a6b7667c2abe8b114bf 9908ac981fd8d3fa5cb7a2f2d87e8ed595ab581dc539b57fcc0fe8eaa0d0e319 c543eb90d34037f7a033954d6b14a893a7bc3f6b67083159ef243917b2ffaf65 732eec589f0442baa2d2248af9960c4fdb5341800bb7509d5dfb96169625d92b 5b46e9e1d8f109f48302d6b8c773181800e4056523daa1175e25ecf01fcc42b4 6906ffbc04364948409f4acf7320daf1ad909169e84eef2b14bbc71e6b54c498 3d47f89084270a72ff5cdb7505f2578ad9d4a91578587cf01b4cf0a6e95ee7fb 4c3dd143dd020a82c67b7353015c7d9cdc11f3d91f7fc04c5ad7cbee85823434 620b9f6d8153dc939b70fefd3c73c5b52a79254eb15bc71de6eea2d9fccbdba7 71ed9b8addbd9ec814669a9f005b7f8ef71d72fc6463b394368a0800aa46d34c f44e49e56a436babde084d1c55097c32ab00cd377004a2c43cad72ee468350d2 831d7fae2cd48600a8c672c6b5533a7c211dbe2eb3600fe8f1ab675199915d16 fcb10addb174bdfeb578289a5f339a5314f73f8af3947957ad65daec30747356 a25fbb21fe3f35e6fa2412f2915e3d94f38fbb603533d90e39707052900d1ad1 1c0e3cc4e36206c17e5c8a9290b47db505234d661e3e217076d9b4385fbca821 68fceb6c948c3511a86edd64c434e90349108da8359c4e55c7ddb73d98761f30 e3b10fcae480bd0531152b3276fe5625475d68e5e0b0b46f29fbedf42d778c4a 078643ea663421e5fc3512d146ac2f75c39fae239feec0b9265e59cbfcbe2926 1a0c031e82265e093e907a1f80a9ce136babd580e4087755ab9b38499c057031 3c84ddc96d2a6c0d13d70c4ad374362fb972b8351468cd484e2c39f6b7d23348 4d0f47645fd1c0ef7a072b4ecea9f3682a915789ccdff8c82d181671e7a1da8d 66b9c859f9ba8f2c49610a632913900a6e56806e5a84a13222aa25e0d8284b35 f8e738db57d7213a00b0336c781e122b6c53ff1f903aceee98a5dcfee319f944 d3b7940f07edff5aae2ef4561bcadac6687908de878e0fcdfde9cb3c6baa8979 423398891cdb4522d91ce8bf4cf951693588bbe18df92629f9c6e9443301d030 20f67526a6333a84b0c41ee8dec1b18418cac8409acc9ad48334d7644f02fdd7 d6eb508e956268fd09787a4baf20c55051d55c522ef1c74454cf177521c66d17 25213f8e3b9646b4a3b8c9e63a9094e4e5ec0c1a208626bbd17829b6f35ace5b cc6586ed17d99241de48c36c6fb1dfb266c6213b179b2b35fa054046b9050ca5 6242cbc596d77ae18afaa3f4191ef7f414fe8db044952121658bcc4d368de91b f67f79a601e2d9edab13d2e2c10d26b00776ee4edc645d0fadac7ef7b59cfa81 03d528b06d8267538cfc78cb3378d5e13734bb75922e8695c8dcfafbce9240ba ba1de7071625af4581e43ff8948b113f8f157e487cab43698336407d29d28ec8 c69a498c5362c659983a22dbbb65fd3ba7ddcfd84e60971c13cc0e1282ad301a 74d98e806448ab465a4f30cf63b3e8aacab518b74ccc08c2c24b031ced981ed0 cb028a169754903c88d540b9f7673a5abd382699aef890e7110df8bac73b5e9e d06564d3edb2225c80a7c62badda94c3134e13e2e0b5127f8e58df4ebf121f53 484128b25cc95d138c1c2469eec8182b50a8f1c23c1ac3afb73ad85c9298eade 942cc13ad46dcf06d6c1330e9009ff5b8b96f325015f41df98a879bebf467b35 6d47d4b10ec46f5b6cf3c597a46d4609ebcacbafbd0bc484a6bcb3455b51872b fa45a7286732de2b0a695f14a1dc29c5b97e498433dbc101fc12dd448f8bdd53 b6e7f9ac636ea9aff7d36c9a4d770c92d0c88bea9a091f006b460ea1f6a3333e c2ad4e1ac92a356cdf85ef34e8313b99697ed61360593731e182d451c35f87b7 39618865abe7ab4215037991d47de9fc403b30787b8228e266c975c56494ac47 9d6b7acc26b9ea7157a395f543664f0debeda6d5c9e306d7f64448f5a5573db2 82e259cad3e01024829822d7749f198653010de3f155c45b99054c78bebc5491 957d15bd22c0d3f247225d2ee4fd7068a480c5346c9c7048534e0b8d12c878da 5ecf09565a1f490808e59c65bbce23f648ae7b4f9568740466a7c93f2c9dda70 e8b75e745bbaa70cc2ed75d8e9c7e5f52c4945e253574a753c7222fb76747ed5 39e1caf4fe8bab8e58cb8c34b17101360e76895d26e8581a5d484a47db468bd8 414e059d87b806104055ef5301f9933451cdd82a77e61a4983dfd419a00191ac a09dae4824e381bf3e8af04779339865be5a11bee249deb6a19364c49aef0806 b28a9c81de271bcfc61fefeea147f7f075d628f03fb125656905b9902bc3c70c 55850ca61317027b15243f6b8ac91a4465d16acda3917e609a3334eb65ee44d1 0ee5384d47b00872328b49fa9c84337a0ba159eb027354d7ec44f72dc3de6e9c 4ecf5061de70931db95a1929f66954558f500788f38a4d2e83333e870baea3d3 b66dc73c085ff1dd555f58a69e656f637c46d6a24cdf1c9afc255ca928dba6b3 bb6cd272b4f21426a48515f011f6561adc689e862dc009711a649416781fcdb9 55b7758ba50e6f088f2b0cf75306441a27bdc87b658271e3a212130dca7f61fa 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 false +check_ring_signature a93cc480fa556bfbe776ccb489d9fb8f4e8fa35a6b5f28b0c42cb49f5889f54e a680340c321f7496ecc9584da89dae875682fa8c5a550a4dc6c3c0ae51c48894 7 a2d9498fe8b8131d8a8cc6f4be2c00dee6401edcda57d549fe15e60fdf90d5f7 13f17547cd8ba8d5f908d8a239ef7ef4bf082d2428ce9eadae4e00d172f2b935 e26e7d73d84964dd455b54f639c92aff81e8ae8f0a42b62941a80f82716000bc 983a893529f1d12ea1a4b0c3591641fd2c9159e13dc886f9aee108db2cc55ba4 5fbffc1a2375100be376d130aae4f5661880457b4e0241601b39def039c38dfd 2be9b887e1916c6cf34568927b696a75ae34aa76508fba11915c71c3b0ce1c74 e03f70f31c9a9544a082d441459d5f2a284bb89755d2631e6d22ac7d04743982 8989ef10880fdb4c2e36fc3dffc866ed644529bfa2909d5dd007f399ed206b04671c19ac51a5504c3b7ea73a8fbcb43de23c5e5766595e25a3a8c0883f64a1051e96b12ffc0e8a54c7d210bf97683f915923ce024d160a1505133b94f8caa1076770a495f2440149e863db3ead1709ae18d9c580f94c62d48e9177aa19dfac0418512cdcd9b7becd7388f19e6703c6340effaef6aea8b9b88e8c999d3259ba0c3ae6fdf1a9d9640d7a431b3ef76d8c2de1c186e9c44bbf548d2347dd69b8ea089cef644a56b9b863876ada0a2a048b1b24ad7da18c7b1fa9829365a41faf9700261c778c643c9d526a87778613d1cbaf8b9329720d7bfe36062f2cb0753e8207709639aa5fc8d29d4e6b09c9ddaa744e8c786407498524ac442173ccd7a61b0375ed80a6cfcc463717e301bffd2e5281c8c5a5380502d5e6239664c443048804c777c4958f371c9bffd6bc4b38c99b7f2627837a382ce2233ddf15a2fcb61905d3282af9c3a285e2a2f73e0f593d04be5f2f6ce7562f641951ef96478c0d2a01fce6b0169537dff7b269d64711bd9e5c9c8c9393c1f2006e9afe7d7eaa546005421ae39ae4c45504a96bf116a1fceaf4bd20fc87a990714461d5171f59a5bb0e true +check_ring_signature 8bbd08f5737e4e7945d62b15c2cde771308bcde9b740b58f37bcadbb3b8553b0 2f66875d82dd597ddd7a2c9156247973cf8ac76efde34acec0d4104d98f0df8d 1 a3c1f0e50c7b7f30d4257422ee4c57b4b335222bbc570dca063ddd78724ccbb8 ade1b33503c34f3a63a6dd377407994a8a90c269683f212e5d3b75b0bca18e4ebd073fdaa4eeb1193b6d84e0f8d9fb7568285bcb1e8c4de218f78314e2c49a92 false +check_ring_signature 4a410a926f9806c0f93b4996c4d36e8824ea1665cffe33b36bd0db229aa20a13 5837fe7512b41faf906b265f2f5152b84e5edf4c6a4283ebe0a031e3d1ebda86 42 59a053ec893222a4be88fc10486bc47e9ccd7cfd2ca07b2defb96601c3576eab ac52ffa7b2ed2bdc2afda54a4be6fc8fff7e5dd3979a3800bae3a13906d76028 ca4be13ea19ec1dca8df2cb0191d7ef6b4b53c5ed9df1bbaa4711586f59b329c d1ea2a05b49d0501642acd024aa57bdd199877845a616083e6c72c8b96b7259a f7f71fd70f96990264292655893c49858dbae39fe6c140737de1b72fc2de3bd9 e0af5658f0df21a1c1f0f141019c18fbd7b0c1d0dab7ba3c5b5c3b3f84061700 efa0fa83e499c895fa5b9796d38bdb558606c409e0d2a00b6d2d74f642aa467e e6478d625c2254c83dc57ae68ddcd17c5210bc497bddae771f6b9a22c7eb3549 5d0773852b3b1b11fd27cc1b0f537943aa979c09e8e98ebd512979d8398a4659 cb8a8379e751f112cf186a05c5ba956ebccf57e29d0eaf1119bc99f442150032 e373bc2f6194fb15f1754538eb27d4fed31d2fad80ad5bd064f5525de5ef1b75 826cf7db49e6c58c054f7556cedb918988c36285cd37e5ab6e4e6e84a93ae391 9650c9641cededa4632f36d0230a4cf64dbc6114dae33547c602b5f1ba443d26 b000af398909c692d585fe520d1936dc3d3531bc60396e8aa0699ce2772c2102 a424f06b439e6057f5c1410201e6bcdd86b916e4262de61c8e78e81456bf8dd6 364f3719b5538cd9d3df5141b81b4325a785b12ef5b51ce2ac7cbf0b3bad3e63 2e3ac7b949d16cb8a21cd7a58e0fcdb52cadd4f65950f64cad8c37ef3c68d78d e73dbe4abd40b877078a70e3affaa483ccf642428364f91bbe14505c40eee765 d41b05c654c98b4dc31f728e313881be1f4e7f699d356c0077c0ff1c24f984c8 08d9fa04e2903ef70e31610a59fa8904f0d6942e171fd40f8469eb571d048c4f 205caffb80877d87b53a476edd75c89ead20eb734f2492bc8e2d31af3a2ade6a b2ca81f869938b2fe560ace350578f2f92f725afe5ef30b177e6d9e6e9b71ee7 ae6548e808cdbd4dd7aa3f78978b2759dd806383fc482375add5755d04c60d20 3df6ea1991a907c140c5bc18b50ec226a0596d060db0f3095019b7e35d837abb 561d6fb64502f9e6d638a738dc1b649f113edb7e689070cd40e31de53b23fd91 e0059f33342ff672a69f53919031dd43763a8b5280fbf8e6eb9e7be571ca271d f9dd2ea7532c65d9a72fd05c420e8090382713f344142fec3e0fc78fdbf555d4 a8e6b8cdc0b615585c21d66425d8a9ab9a57490fd7f598c9a730fc5d9a6497b3 784c42345a27ea091508b79d9055d3c5d53c50accd36b35c43c4ca862a281dde 1679367a61ba24a65ea427cdd2bf3c9d32c19eec0b18a6b30666fe5c95959cfe 4d6fc95b821bd5d758b847821468bd6300816106319a8589ce0c9f5e03a768f8 8cbcb54524f58d5e393c794c99d48b781d11a46e265044214d473623596103ee 3bb149bc6f3a37019618d10d044c22f152e769942544a1b35123c3c231fc709f 20229641a6140efee69ba3e4829ed0b5a7c7f62224cbe5d906936badcc176257 98411b723e0c255ebca8d78196e9c1b38cd7c71f0d6a96bc7bf92fbb4ac6883a 3d0b630379dab35bc5bb4abc377781d2596b24eefeba22af76bee8202a9d49ee 0160ebd4998e01c8c85c318a2b6de38c994804d02042ede554473b6f2cd8beb7 35f99b9357d4a7b27317bea6c00fbeb55d8a8b5b3f1080dd4c9945b410cd101b ed59fd30512071765305525d047bd09085dfc1945dde17f413b51449a8471bce 7962750132ea9928e9b206fbf2cde38ac4926425de16d8c56b99185a591b862a 0ebb323d3992dd11dbd6f38d7dba9c27df0d605154981552fa7201fe93982f8b 678f0841e2f77c34f8288a014d8dd639ab44dfcf618fa7b565575287c5e51177 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 true +check_ring_signature eefe1a8cad003560bfef693f5acfe6022301ddbff05ff388a1b1de2121af09a3 f4a959c3ad6822dabbf0bfcb5d92e600ccf9172e28aad3fab6d2ad79355ae47c 5 0792b14ac2c5c6bae74ddc655351e5ba414992c742218ee5686bad1391d0949f adf8182b0034f99da19f70f017ac741acae9b74f60b8e96c43aeaf5b58e3b037 bde2d9b548dc7b793ee0277d046e3bdf196ff74c30baee1c428f7f5c764df2e4 4ee45d13b1e39a057276afe3ed3ed5e6d5a679447cc32c814092224f05a591ef 13ddee10bfde6caa22efbf04ddbe9aef0d86bfbbb0bb6c874b37dfe1413faf26 9672e0f5e131567e24b3c261c8f1abe0277b862387395c659c5f2a2fb7909503922a52b76867cd5e3f8ba19d689a21bfd9ed4a128e4ed7591438ed69861dc70258581a443e3e6ccf679ce8bc7f17c2e112dc52a92f34c734bf4c3b033faf5f0a4180af9a7a4acd0d15c8d9ad1e69bb0da0a8d81fb3dfb038b253aa658d570d06a558245d66084ef8668e223cc18c75f4c81f04477288c752aa80eed1c29b410ce5d53e52ca74fbcb1b4d5b664fae289254a35a822c423238d2be0d6a2fd62e0bee6819ffc985b3a20a2e4ab04d631acf3d3783e25d8fcdcad39b931b3ac1680643ed5624ac4ba3bb4aa3dcdd80f34bd2f3d6fc20cc2ec89403bbbed10a412c09dcfc8ba5b84424a12533fd3188f48fefe872ed43cd09bf48c3a894ea8e487b0471def6c507153dd7d539ace5c513777bb199afa023e67d3bb5af793451afbd05 false +check_ring_signature deb249abba8c88566cbfc989199f810245af9e4b3df0dbe0349987957b5ac5f4 ed1b76035a4f1a856e3afffd12cccb3e488aa1549e1ca2d8a52423d507d73cbb 1 a01da5a128f055e1f188c33636d695d796870e4429c1b7d40df7cfc593235cbd 4ce237d9ebc78ce64baf0b1c5c6ae7766393c418746ef4c8fb100df72cbcf40767b23ca65c5ff09c8953f2d7dee0d5a9c499f7dd07b3502ae4e281564af89309 true +check_ring_signature 43a4fbd3ca51a65bbc02bd0ed4a8e07d47d5a066517df0e172bffe55db7f9623 a31555460e7189533b21e4d06e9515effeaa0ce9198089b2cf1204d31248debb 4 b3ea1cd8fc4dd627369217783a79e6cc8e834a99422127b4e305295d9b912517 3f7fa562153d5dcf8a0ed6d0392aea3cb87816f771933003a3ce6a0166912512 668c0b24a4554c4b9de0c335f073ae5b98933b2099852ac80a7cd0be6ca71bf0 6b134e2ffd9836fafa8b1875adcf48a09dc05bca342593329c5a9e139478b238 21ca8d80660863659c7346a187ca180b8fae00da8e28c0d4611d5c2e4119490b0e801244a94860441d82097f7b6463d82bda35b5aabc6d9f9a237e69c6ee980d4cbf02ebabf777404075d6fe929a6605fe0d171cf1cd105b21304c23032e20003cc3a5df67ac0a91892c1e39a5707bdead2e0b8f0f01a582a77701c80a3c5c00de1cd92695e25fec7e4ab4e1766919cf0d94f9e9c7654ab747b19ba5c3d94808721b46bc55b12f4161fc75d4cbb6ed69333052f4e22e18eb2a510c94e3d11f01515a06103e8ffdebce1a35dfd8bdbe0dffe092b2c8323ffc2ec1675f189ed00a1e30bd0a806e4ef543b9ac72f77396fa55489619c98b6de8231e534da0117507 false +check_ring_signature 3e59602ba303a74e8bb3b5ee0762f147abee1bcefc82ac61378f4bedada65f6e 40197ee776b2aedfcf6041bafdd15d234e51367eba3f256cb7868564a9004f52 84 f7668255998f96333b62df775bcfd6f91e73bdd8445edc45e9146a91f37bdf5e af752bbce78f138357f7ec567a2ce9f94ebe3b358fa0769752470610965cc5c2 85e24acab0059cd8a5d37cf1b502abeac504b4b7a09358706351dedc198cbcc1 c8657d55f903c78957c035aeb6bd4e29786115ed83444cb9c5089eb758a6c2ce 5eb5586e6902d9f9c8bfc621da589f627e23d8a8d9f89c55a398ae76a3aa928e 315a52fb5faa2df7e3d29f7e0c7b414fe2305e9da555944dca314d81a295a29c bc319da939d3d932ff2b17b770baa8c73b6471eb04f9eba73124e1d5e1e7c5b9 de60a95eab2439398a1ba5bd166f06fee9ccb145a1956bf40dea759f29bad314 d825da9c57a453b028bd13b4464a021423148f086187ef9b5611da2785a132a8 f9e1ed6394c1b2de95cb5bf7fc79bb158126b5a9a60c5366402dd257c1868158 7e8130edc164af69f0e565d447dd276505a6b848badfc3ce435d50998f847d0b f0ac51c33c0b35d20f728fd4fbb506096cce6dd1dae5e8990444ce3276403ff4 fc28d89000ef74647822efaeddbf5d0310bb006cacf82b0e9e0a01d05cef5166 f361fc1fc5f0ad86ba241eb93770caa2c6b2fb7b12bd111d3d3da13fe6abee63 08ae4ef7600f57624aa894d2e0d1a07eb5603c3280a4545f56be5804b0cb3658 bc0563f6d02e99496f9327a762ebf41d9ab3b3f6b41d3a5477a834e949f9fc64 3a9cf812dc9c4071ec7a6bcf151ba7c29d8daa8170d9f6c13dfa280e7e91e943 25eb7bddfab72308ca702d6f30299afe6803deabd17e9bfd7c920de893fc047e 19d013f8cc2b62794531b303f2bef2ddc0db6607e7b0ab3698548492dca54a84 9b29874a12a8ddc5785bea156a340c878a81d4d889691243f10b85a2be5a8eb6 c4d0e1c0526773a447ef8dc9a2bb17fa176d233795479f0c9029c15f75d106f0 868033fdd8289f012f9c2b9b8217f47142f46d6fdda5bb9fc45e710a84c39995 fb3bb72d8a2dc85c5ad7fd6f14ac9964f3744d5bc2673b2052f745883b9a8d65 41c759e023c7cc264ca0b6fd3765e1cf839c5b271b827a2704f07ddf8b421e1e 17148fb764016f5f93dbc05387bd952c2e2716f23a4dc92a8d424ba600a61fff 083cbd1bd09f4ba51828fd766980a83d05524277f9fc91862aef43c7469edb88 bb37cc9330d151387144338bbf2f6ba38a43072ad997dec26da9325fe2b3a73b 4b51a9b4c58d4909b60a7759b3d2edc6b0645a01c699534841d6420d1a56c939 eab513f2c16e1b65acb1fae5e5de7559ad93707ea0e3efbcbd7865feff95c9e1 5b1ee74ad757339cf33a00642041644839f307eb16f48493c8d943e9f45fa64c 0d88bb0e2ecf84a849190aa345c11495057a67c388bd23e6d99ca4e273fc839f e8da2c7f76506f6baa3895ee441162ca0fb705a2125f3acd17536eb3dd410538 07cc84985f503617cfcea700848090fdd75d64b44a1346f515bda1e3a857cab8 14414a4a974def02d94674da1376ebb8449c09e97dc56f804809b08dc0fdbcb3 b213fbb325d79410bf93a71d48d6ac80c3d4bf13aaf89cd50f174125ec60a756 cebd3192e9db2090e14ccf20acdda5163e0872c36b765fcbd5a3bcb36b6ff70a 99c8f9578511d3c283c7f82df11d1d6a246766506de09c3641713ee7f0da08f8 2b4ce483ca998fc8092694671d9dd0be1951857ae400f624908c3a941b89b666 023f7ceeb05c30d4e95c6b6286e703b4a5001ddf9b83720930b50929be9d542b d873aa6b1bdaf7d284d94a8258cf5e04c1215badfb1aa4338bec9c9b6d974dbe b0f4be57ed6fffabe93a110216ab68eb0315c8ff983e56c1c4f760d039af5010 6bb2fb7a0fc9a03080d516d66db5256cc348a81a4424f358e94c85c4c1024f98 0cf0832ab1a69ef202115bba76676298caf227ea80b20374ecf7f7d331242eaf 301344900b41c6a5828e248354019cea4562dd013e9fddc08435f8b53118d274 db43d9c2db8032150a31c5de4979bc5182479c81db2eeff15b1f4bdbe4d6e906 e95407608161f1dcb44502f7f98427b654b537be834a6edb0910f649df78e970 ebe8386f5cfdef86a88cc432703aa3144bf39fef429378583b93e11749527a5e bc5da2cf8bea79d415477c9d68fb4d51596041a587c7c63acafc5331c2dcb0a3 89917e9102fe2fc78962b7c42e90cd81aebd31bc42d5abf25eb2087dbe54e194 d37ea90f47141687a2c407ba26762d4972acbf702c7738ed68a80c24749f7a2c eaa63931fd18a1ab212451facb976ce8e6c951dcdb5c3136e2c9e5aae1630b99 900cf5fb823aafaf17fdca5df7ecdc0b40e65ac30ed0bea1c51b374747ccafa4 c458496b0aed75a87d7182174813b40f81bf2b47781db588c629c8b3ecae6881 888531bcc9e7070f67be967d2aec28a3c39a9b340e7581ea4f17c618283412e3 ee14e1cd67eb0064ad9bc5fa43c7afd0c3ac59a99f92791ce11bfbcfda4fea5b fad0d109cbebb624ffdf4170ceab007237326ba43591967cf35cd20583b1b2a0 f0341ea3d4685f5c8d2ee2eae19efe8226250923ac4f215845ac0453fc686bb5 f533575574247ac8f7e3d33edfd928b144357e1332633e141421d06f6f659d43 bc3aa353ca8e325b5a7d35f462a11f003c6c8fc0cf769effc897f7b3cfddc1a9 4b80b88bd7e5dc8070b2a33087d795e6490887f65d41c79d11162707a1291ce6 4b289ff4ddefbe00612b2785613672cdbd659600a8aaf59ba10e9e76d2834244 f8ade76c5db411d2c1f4c08bbf2e15398e9509b064bc4524fae666866127c475 800caa959f6df3adfcf2ada21a65535302e2d2cb23a6df44a25d350ee797dc79 b00c7ac3fa538677e74c5495b4c970c71967b98b76d50943b84b2a0e1b001818 360f081b01ef100c004c02f410f27807fff6687febfdd6ac99f3f48521838229 d471c27e4dc1af2cb2102705e58687dfae61dc1117c5f6c407db78c8bd7d3c25 b9b55663aa8ce6fafaec0e9829c0c08524d427aac4ea03b34b24d415c15e167e 4a66a8f8011aad36dbecfe808deebd0647c68d2e3e330788945d045e92b81324 876b8f28986e5d3e24dec8c2b75a96577014a8921b8b77f4d11b306539b29df1 9f54f27ed60b4e9a691b2061e2df1effd124da6c2b56fb321d1daa44587b2e91 1eb8510265a0b68f34d82521252a71889721e89e577dadd52c299a0ca789752f 685cc1d33cfc4e69081fb16d44ed5452e375eeac0820160130f51c5fc9e48de8 11df4642bd4396c924b9131c2767be28a0ac83b69bf4c16cce0e99aafa57b5cf c0cdcd86bc461087a2ce15ff43469899abbe8fcce508a395c4fe4031955c1ea7 12e805be2bb0bad0596e17f6e678e7b8452efd18f4030503e23e551e6949a6d1 9a0b9a925636bfe9b5d7abd170a5b0dcbb6da93d7652348db4cc48ad00d2dc04 665689fdb290c93da2481aac3b36ef568436e3831499e7657ee3e370156b8cb9 7ec00e7d6d17722be8021f757b2f4fc1e7c1f36c9788de390dcad3cfb7ceb6c3 be6494a15aaa326549728c685cfa18739a6f2981c6a8b7db63394cf81c3bad44 a8eb539d25b0f83a585502e8b5f68d9d96e2fca859ce70b76affd26dba91113d f2d0afe4a4786649816e9b49edfcd447d2f02f2fcb4fc0ff7c8e0eb77b590658 71a26be9cb35e99dd3b6d78bee6291b05bcdcf000c5b7c0293e5d9431b81b2cd 88388316f6d328dee2cb7897cae4556ef8d7479d5730532c8f52aaa7003c1d28 1c872b6d3ca44269d8ba84b9f042a1a2994b79dc3f8020f61c4ed7481556a6c5 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 false +check_ring_signature 7303adc0c3d2d4c0840eb27fde6b2349e8551e5bf2db3198a31d300bc4cf0863 59ed58cf78c826028137929bcdcaddfd1b50f626fc39022133fe1b635cf7719f 2 a03478fd70f347f1636c39c90db7187dd8e053e6de1a45b0fd462595bc66b27f 57dad4f00dbaaaf8cfb461aaf13812319f11e0dbac334656fc76c959bea754ab 1322b9ddb96fbeca97c07f275da1938184a80c59fb6d2696d35985b3e5da2b073bbb2f62facf924bdfd0fe7bef34a800f985fdf1bf61ef9f99ebb2f1bf20018e2128afaec498404c973297d574d19dc3307a61044b4410998190c30bd7899a06cce6ec5de643e08da5d0ae2995984083b8974d2dbabccb37c209955d6737fc09 false +check_ring_signature 18835b11c801fb636495a3e3dc50ad033fd357cf0b2ee40496b33a59aa645a70 bea31ffff7f1aa23dc3339a1797a8598b9e51f3a691f5f1831456fdab940d6e3 3 634ccc39dca614954a8cb4be1ca442f8aa92fcc865fdd8db7e78199fd4d2efe6 63f45402d7e587f0a5d4a8f597f916a3d4856f6762514e86ed4dcd2a8c0ec203 4449ca24622fecb7db12fcbe982d3d6ce13372b62890d98870e6b9601ae8d9c8 ab65afb167bcc993ebf93407abe2747629eb6e2741641af9f60d8b0973871d0765f77bcd2a5604ce24a9c764c572fb55c392e82af7e5fd48794b53bd064f75062114911f0b27f06b96c077d350ef9c5f28ab1d55325d7da161169b2b563a020b47667582ee4c765bb38eb4c81040d753f807135c4ac41dd33e174b2598d7700ca5e9e47f27421c4bf574d4a8fc2775f60ee2c30c1ddb94165c1633b464583903bdf6478548e18c0f901da95e02c8f989dd16c0575fe8ba9110c4d9c35bddee0a true +check_ring_signature 57ada156f409efd678917b6a0839cc132d98169df72b00d935c3b87695fd2cd2 17513574d294da299863b188734762afc792b95450beead2d5584af8244242c1 31 c11ae9bf0c0808e52a55cf6dccf6f211054531b7257c330aa75fa947ea4d9cfb 63e7aafdb40fcc5a2936b69192af1b54f4ca09795dac466cf4def6c3f5bd4ea2 c3970bea792458be79a92f41c7bb6f77816139bb19e619a88ad1e8277dfbf63f 236e852e65a00bb40f155dddffa9d9ea70266812b05f88f89cef7c4d067b58f4 65e432d3b07d23006cb381a28e802f7807372cc7ddd3dc1e3ac251d3b7813662 9c3b75e4bb0036542328aca51fc26493565b4431c57a5e63534361e22153d811 aeee311239808384c1913617fbfcfa9de82e2b14fe752a3ddf6948a2030b09e9 be023801474399b56503e248bb088341879e1d639444551c3c447bb90a60eace 29af76a00e3808f12e01c25cab39129dd87c9c15117f23ed25c12409ede51e1e fc978462488a2ac80b813cda482c26d2cc62c2163bdb0b40339764c43752be3f 942a6947d69400864cc4bbb29920465eea07e82fb9917c66e939deb2edc24e00 fd148808b060647c0c8361775613576478b5a7291cbd18760daf090df8cb4b2b c077ecbf1a0b06f7cf7867a4eac7b6eb33dfb8381919a97ad40deeb8a2f5eeed d2e20868aeaec5056e46a89acad384642143ccde5c53464c4bf6acde8ec8dde7 725c6f9c4cf555cdebf7970319fdfd764c6c49ad4a33c7f22af388bdeb8dfa49 3fde4d9b4eefdb507608882f0fae5131f1c817cac2d30c6ee049a09f99cfd51a b188a6ef4aa01d9397fa1690191ab49b22c2850331466cf1bc81331a5cd10b11 0e9ed64b47cec06eb751d19df9eafcb92f6b5f9437da34f564c2d8fd1113e153 e9990c7daefb62c5246b2a2c814879aa5f804069676c53107bbdbd90f1acee9c fecc4fa2f9ff18b4f77269f15aeb3865c60e9a629e2b8ba0b7b3739d03cae81c 320e30bbca581b5df562ed953d0e712fa1e89de702a4ff103a6f4cab7f73a92c f55f3f00b52dfbc54a967c55a3da4d0dff1c1740dbffe3f0cadcd175dfc1966c 3d0608a65ed70c21d7d99a3eeb7edc39fdb7145ffea5081468fd413a07c4fde1 2b86ff84a00533d0a221441e4a158865f5f10a9b5cac24b778e2ba26d2e868f2 0baa3df46cd910278da2a47e3cabfde268cd1f74e03885d26db32a6efe9bc1c0 67296d3a49f9d068662d5ebddd35d989abc642ee24f94c87faa05b733a96609e 50ee75edeabf180b49ee1f1aee9259b9dcb504725eca52b7c8105caa1c797f38 61646638dfe570f8b9a1471106829a9b3e9fd2535d730edb863a7f9816e4d2df 5742322308efeba721d5c4d14cd87dae27c83d978d7e9bf1df421b992edf1e9d 94647f286806042b9a523cb3e5f67696d31112f076d830c21d2622e1f2c85cde 896816ca3b5d135d20d84194ce3b411c063cc99a6e0f42dcb9cda94737293a59 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 true +check_ring_signature 4f155cbb0859fb3dcbfe6cb65f240a7a0f71ef07366af1dd6d68d5eefac6504e 6d3e6de6e178254999fccb9317b46669350d80d51ab841b69bf4849ffd8b2ceb 57 41b1310b4c814052714f47f8b731069ce06904f6e700abe3342857ccf52fd841 306dd290595b7ce56cdc654cd35f5a37087c17079ac446df6a8216ef1a3c1392 06378086aa7bd0ce448ba28d6dafba5fb239bfbbfd9e61ee88e94b2472dabb01 bf2ede7a185a93d4fcb4230518a645ca8e71c475e4b3b192b2e0fa4477174741 1bb7dc9bde1fa1873aa5acde07ff15a324c976a49803861c599ded1940b530bc 034ffce396967351bf5c909213b590d23bf236fdff99ce4b5d06aba0bd759180 646b7183f9a9fbfa7a431afd4a696dc8a3ec8bad4e6e299b596938962a1e44ec 2c128ab5ae6f90f240fae129ff6bb724123cc10086451ac0183228f706a64199 d9c21d2b17e355ba25d27162fda31f496386947bd838468a0aa02898a230359a 9ee4d4b83e1599cef4e8bbb314385444fe20c60ed33b683cb6dcc9d580fd85d3 797077b03efd4cdd0507ce95ff84fce54be15a9576b4db69dff5c4aa005b5474 774e2b5d5c75ad3f9b042a2dc21d17b0ca39f711fc416bd2bd09d1a8c8cbef44 ecc1323ad0d5c1b0411f3dd326bec1d095d27d5fcefebca64b623b04d2dc1d51 bd2973a3c3c84bc25ff1ad3bf3e57921fd99bf992a9310b44658bc3927ad149b 563358a8c69cd971350b17224c21991ec449543c205aaa1fdaca2cc459a086a4 83cf3dc6f710115b58db1c9cae600efa924ff4336b1aa0c81f2f48d5ef9a3998 37cf4631a7c372b5fbd53cf919493caab5e22ab310e8666b3690cefe517e8d36 1a4b918d106c7fe7bcd7b952aeffb5faf9d1e1f73e5b462dbc08a32bafcea4bc ed33f19477bfb3cb845769635406f2174d50988448e5f4420250deb1701568e4 dd486592fd65824ba69217a4a38c763edcb350d291aabce42cbd83894b5304ce b8e374557533dfaddd91c5ddcffe575d4777557a8d44450183bf5b1493c7879a 121272a2d4c2ae81f9b3eb6d47c81c0ea335caf4be871b36d5a605fb67b6ec3f eb8cbc038156d58752a598f234b2cd7e28ccf65b9f00a1612a56ab2cf9c3c9dc 5e5a8619ecf6be12979f4a8c09f526f05fda0b8709593dd5fe061782a6664d7b bf9841792089e06832b8fe8d57fc52d0929ac7c8ec7a1a7ed5372f1c50650956 8f859ad997c58550585a2a5872f68fc0d4ac7b324c2f305747f01b03e4c597af 940c9263cd37dfede21544078b0d3862b37e6c2e4cbbfae6e8b63440e384e155 5b5912c90d12abe57cbf2512d67ebb4a01717f1b587efa08ae17e4b07d737273 017d761d2d5d2f4628e0020f44e25787a83b577f43d318f63b1be8e280d0329f 8cc6c43c303e0e83a4088ed45c55b3e5218f2caa26a737710f57a9e2c560d718 d9398c06a650bb17ab2921b0d5db7d9e7b0b1f471d54ed1167f0934056b0c44a 15f85c8cdd87bdba76f2b2281e8a7c5b99baa6940d07e06871528b31dd4ec2c4 df1c0da96060f5e4069d6558dc3901d435936fbe2482b3a451004fdeb7ec12b4 aaeb5b52acc5130e98ac539f92f76148c5ab2fe94ebda1fd5a80e1fad243c5a7 4b4bc7f30a11371ba63520a010cdec839645729fbe21c665ec25add1b63bbef6 eb9275b2c208a97ca3ba9d8d4cc403c37ff0abba7916e3905149126c9923f0e3 e001f0c67a1ca99f1f8d5b20801f34b50cd0c3e29c4a623ef707ca8f66ea9ff4 06419de5002e55af964b0870899748e041bd1eb879ad434dbd85348feb835f14 05cfba8d6f3507fcb9b282a5dbfac28bb8c348b6fe22e0135070c7824b3cba44 c9d690adfc10876063a91c86b5e0272de42441168a9b7250b2225e714439ee8a 364fdc1fe382649d7b940bb9930a4c4697010ad6a88f61d778a207a90a429eae 220ea27720ba24cbd1fd33b02b192ff197d22cb37e301bfda898d97822ed34ff e5dde188295eb632cf0aad9d9bae113e7cdc56fabef45236f13e77a97d38428e 9f2759f2139661f8cc5e0d02b3377db3197705883b1358a869549ec7a6a00515 5e1a58eebb20e044cfaada2c5d8c0de9709df0b5b0046e773a94512c80644763 ac540474a27e0369bea53be80e6b375ff8421b39e786c451c27438710795f99f 3daa6329a5f2e3c23bcb1995818738343003e727419f88122d78a762865d6039 a0fa3ad0712c6f74f58ba60697e97b7861df98341af808a9a3d720cadc02bd35 1d9bd724571da66039a8064f62654e528e65add6246b01a06d053f7cec578fb7 e6c82313e29734f071610c754bd3a475c3ecbd79f1e0767319874cff6a8cafb9 3dd2f24fc30f6c0354b546c596b59b425afc534a7e2d5ce785aebd05c888942d 802c1e273a8c174efcf621a752366696b45eafe774406fb79bb5b5dad59dc015 e9a875d1aee164acb1417a6856f521ee990fa53fc3169116c31b02ef180f5cc9 c8150da28188f66a08c6b8060b6d5dc9a571a57e18e0d48bb30c741e000a93af c721b72277c0eecc0cd3ea5291c24a5c81bdc0006e4e0b5c6e21bda4f61d9f79 68a07eeb196a748d3d989a5f64126d51ec4d56815d2a4e67ddf565464a7e74ac 8b5718d58c21a3ffd53d76d963cceb5d79eb2f5fe11de73a050dabc9ef56bde3 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 false +check_ring_signature e094be8daa195cbae877ffb0bd67ecc2ef3b1375e7dac11e753277ba45f96db5 d040bb07d8287ddb36035ce316e969a6e0dbd183203c0a1ce386e3b6602cada5 30 b3a49ef8cd0cc92024278ee6859b3827afcf313acafa8c241f246e9a9dd1d447 3bcd8ba4edb74179d94fa8d576eb7a1fdbfb258acba90c38549affe4d55163a8 997365d3670479dcf83ff90667a27a2b077bdd190a543f2ab32abb9bef9e9714 bcedf2189134cc70c35c0cfd65c7da28a8767d000bdbee2244d402e01bdac26a e958ea2db379a8e2e334a1d0277dd5a92c8b38497d5f6bcdce6a35d6b734ebd4 7126f309da3c07b04825153185dc97c9d6c6caced24afc46d387f22601a02a7a 89c32034e13678344a76f16980d605ad77f6ed3c1b25f7bba6fc9150e6d7701c 4d07ee5de9d858849b3f0bcec46aadb05a69aef74ac1d0cdb42debfc109baf6f fbddcc26f062e904b56f1ddca12fa839d19e410560954695159ef5e6c9d4dc21 b79fe31ea977a97854243a9bf072010c1e466adc644a624eec81fca7560e9b99 c94610fadc6be5587fe2df6399f7c6c1d4fe03961a3e6051a944b34505b03a55 c14d7efdcfa1cd942a7c6c46ec77b9489bfeaff618702e4b6d8083e45331b0a7 3cfc09947cb6a7728840af7f4c6c5a8d0a663777b32c8abda4e594d2baa6d1b1 a801b9541f41df1a8b1fe201ea64c9046d516118cdb121c175690d727788faa3 aa0f6106fe81165c60f0dba47f49a26c044507bbb08089669192b57f52a950cb 7299a4f76fc7d3b81fdbebfbab0e0ffe3ebdae01ae39ff88d88003d1755cd153 37bb7d2c2dc5fe2eb1ed99a050c4e6b6ad094481ec9936831f8d9dc183656eab c83ae53f14b712cecf53c42ffb5b1be31907d76badcd085bf6d52f9de41caa1c ef3e048984884d6a1bad135daf24d03d5ff3d26e1c7514cf02ec2eebbad61806 4c02bbe501b0c2da8dd4fc0ae679c293e4cda89a7000e9fc32d8c94e80f52ac8 dc253429d52c864195ec57c75e78d95d0c4b31a54ecd8198ae7760d3ac17aa95 c0334e3511dbacad7deb52346f0dc6ad1d50207d065838bdee5cd2a1d078c2d2 87195bc91cb132d5b3f5f3a45c70fbc7046880925ea1018980ee8611ff545b01 7919a88d51b8bf21adf7fda63a4f0da23a1d10e023bde197eea9d63d79b98027 34cbc2ed4d6084ff6e4aa53bf1dcd1ff3f66dcd3a1343e3ab3ef34444028173d 7c0a119d9906e05a468d3cb1bb03c0f0f8b0082d22a607634009923e9a969dfe 0a8201ce36d159f0ce936c7c70637eb572e062e02eb24756e526180925e8eee8 bfe17ead6a538ed20b5784d8ca046ab6616c500bd2ed4556abf090ed54daf899 17966eaee9a5d75d1fb14946573b9a05eccb629ae45e5e68744f55c2bada57ad 518f08dc43e7fb1f50f5a7ef8b478af37ca61f02ae613ee7583ccd1ebdfa1099 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 true +check_ring_signature 7c98cbbbf7e1e2d844bc77325f38a18094051ce11609e3e4c70ec58ce0ea349c a0601447fb3ccc7dd4be17808f3ab33de0c3a38ba8caee424da351daae60dbbb 45 e3d5115ef151f7325688c86ffc4b2cafb975d24e2c161a4675e396971bd82bd9 20eb8c30960bee249d4b3b8522b27e7c85c68f2cd856987b6311f5f06a130737 bad54fb59de83bf8b899d52ada0ec3dc2d9edc50ea42c4a04ffcd72a9c810cab c3ec7e0c67919dab570912a41a93e7fc60b4e1e0c844269c01ce09a72fbfd1cc e707cea657dbfffe291164a28dfe6822aeac48fcc03c6043a622bf9963572cd9 3f1da424b484b6fe9db528dc5fc99356362ed7a97276c4e0a035f60c75bcd5d1 b2fd456d24b50ca6cc30c5b361f6c1ff4b8e92cb0ea533639b32beb9fb8bf7d5 94ffc9034904dbde45a0f2220ff3b97aa7fc571ab3f94dcea6bd82da06f381df bd7afd22e55bee939f1c17bce72a7d42a1a36e2db25aed49c01f46ba2613374a 091bdf9b9e4a61c9a7e4622c52ae35a7adb54fe3515ce20ca6e17202e16adeda 4d40755715910a3732d50466c05d07a33987cebe6f127c4f0dedf0f279ee87ae ccb315e3526a2158e6ebf6c9d9843ab1668a2e52acff6edb362ed74b4df66eba 96887b7d80119dcdc025612765cd7865364f9c87f4e4903fe071a0e460671f11 4aa08da4e03a22e852911c89d4bccc9c71a573acff9df758e5ac4e607f27ecdd 3ad7b171e30acd1883d5b2cbe3a2a218973b8c59760ab803e1fee138addeacd3 a3f356504af8566e80c3f3d06a0f20a99a8e4b6bdc26d65b1deea525728980b9 e3cf52ea76a21bbc0bd30d05635b8369454ac2fc2c6de44085a57a770ea8c736 ad7578c222b5b2f4e02b771db75fc8b840328393b38da16ae05db1d0143c71a7 cbe08c03529c433e6add82ac7190c6803a3280239c80b38783d0512631e47d3c 0d4c8162bc32dbf878fc08533f05488f2ce3cfc3aa76ab06328bea8c4daadadf a15ac703d006d4f1cc54df393b9bac05dee2e59f7e1bbd241b8260f93dc64f79 0784970e3c8d5710b109360ed2b756f099fc00b5142f18c40be351214c4e163b e2238ca2a0a70ca8e9d690d636a20ab2ba5491878ff387ff331c9063df3c7a62 49a0c5e76e82cb9477287059f1861cabf47e285cef5bf48773bcf95f1a5d4216 877e77d28277aec92c081f7b67ba694b23afe24c4148a3eac7ab71351658e992 bcfdddb74812a15e92a39f5773a1438d797d66ea98204b6047453f2513582500 25820b7a100df1ebd57c3cbf58f2ec1e7c788331f22f4e472f0b741761f29a02 dd93b0831b90046529d42c09a4186a786c288c9d8dba8d26a0eab5c8e52f0438 838a32a8a4970653dbdfa578bec3d6127b40cb1b87e6e3fa81d57340591d758d 362e5ab126c7275c97bcd14e88983964ed51bae2323fbacb317634348e4ae7b4 5cc00d801c16e8bc073648795934b603d6c373f2f3ca542ed32b6f1259bfd7ea 553326e96a626d154b0d55b8155b338aab59fd20b7034758205014ffffaa5ada ba02fb0391384c43dc5660614dce296c84e2d64bd95a29ae6acb50ee4db65722 418b5036b67dae3fb1de46899f901035d19ecfe602738aa48bb1da0d1c631ed2 573b538afd9dd7ce8df52fa8bf47f8ea5c90b0818976b0743108f07c184b13fc 21c57eae485830d20f0a3f504ff619ed601939466668b1979178bc8922cea009 2dc5707594d893758ea7063b7f944d6e8e50f9cac6b6207da9b3018f8bdae1e4 878ff490023486801b395076a7e35c05028b7ba31ef2a93dc2be4b6e3f947f6f 78d4fdc18a674580b048e07e8c5aaf07433c21bb061347f1f6320ca25f651c5a 9b2f36cd25888aa9eb91f8df5f826c22db714b1834bddb0c80e28cea7ffa472b c330a6cc3a66163c981aa1353ff696b821f4593426c1a1da68ffe80d052bc549 e4005382610e2e84e9d237c5796eb7872b5c0f5379114546942a35053d9c8032 856ba4da22d1f73d2ff2849249b345c9df41bd623aa62a8cacb28bdebfe7180d 82d4671825e91894e62151382beaa160f21bb9e4497cb5b79771c81c954bfa7e eae0821e7cd784d7e5b99a7ae470e85dbaf488121873a732462616083c3188d3 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 false +check_ring_signature d59e9f1184390e5d19af03cf95f6a72c28ca50834b2dae6801f3b6250ca31ef5 20ff34e49749b5a9b79bd085f1d7b68712dbd5f10c6f45fdcc75afb9a0bfb1d2 46 3de2b889d526f2de0de543863125b81956265d4501b664af98e28f4446fc9e11 1a4122fdd0e28acc5e5afac2aa7163427e09e0239b1d7f7370d020e0b9b89dc5 1b4d8e68bd01e73baedf4403ddfdb7c1170350b39866746ca7b57305ceefcfd3 1b64ed671e83edd56acd18a3861bdc974476f087b922bc309f62081ed72d209b aa0cb857f28ebd0b2d391ec6a6560851eacc703f3c3c83ee4c39dba5e505fbc1 d3c7e71b3fb76482eaf775989a124646f99c214e86a87eb358d0f0f3dfb8cb77 48b1af82afd4e0caef29b39669fa4c39c854a1cb21192dc1b24786163cf4003b e6ec35094771cd499e7f46f432cdc39ea76c9f5b244d2c29aac52a18c797e9e7 2b0b98b1c15111d64a017920422943911a3306b565c8474eb63466b93b92c7d2 ef2f039cd2d08f558772e550ffc78d57bb009de67762a02cfafe46ad00431329 bb636d5e604ec9dacea583d096a6a9d2c29c9b3688b58ad6d014d6cca8699678 39c4a463b74ceb9203bfd093ba0bf9747a4f34d9e7bd1472e0cee309def3e7ca 57aa569b70f02581a58efa9c80be8482126f8eca16a17365470abc1c7b530059 ccae7f5e75a4393b7ec8f3d0b5f375f9b61dd558a7f71bea3a440604397a50b5 69450dd9c2b8c7fcb0d33dbe36170f668074592c4af88cfeda0e1240e3dbd1af ed3e5d1967802acc3929d94ba06826732799892c5d448fe39e7954d936815c31 95793d46383614cfe389d5d47b92576416c285a992a785bf85376cf53dfe3ce3 c82e97ab1e2104d41673edc2a12e4b143ceb6fdd2c4969b80aacc4b8b8f555ab d4e2ce593d29c0be2b9075337070d945992d6d6445f67077bb35c10e1232c9c9 ffb018be2bfb63f42b3bf7f8e836d6a5332d8efc83dc846d50c56a657b831e58 1ce31127761999b5fe7b46998c367f98684c604565bdc6e135710fb80c3af53d 842edba6bcfb7fedd9c62417485a850aaf69a42a4ca5c8f6b1f44bc2b87ce86a e636b3f9e0198b425e038d2b96444fecd430be28d9f54455856e90b054832e63 ac78fac44893730cd6eecc712c6a1cf5b30d41280d8b6b1da92c4d1b9b1d083e d6da0dd40fe41952211e711884dec2d8237a2f5c4f8d46e58fa7b6efabc4818c 9307b9be6166a4054d9115e00057c126dd2473e8c1832390d7e87a176f5ca0ea c1c1c59792191116775b7fe868f97d4b88f50ab425d9e553ae583f610caf4926 bdf1fe65c30c1c23d131aaa306a2125c38f902e69b1357faf5e1aef03a7a5322 89d989972fa846d905a1b8f8a21fe7243071a5e96dfea95f2396525b3af15c55 3bde16d00a75b534004ab00d421f142d87f19f31252b17f3b116845abb070741 dd602b1eda910143e2aad6a80c519a56e569bc11da4c80e2176a6a934d2c905a 192cd7c1ec0debc28834ce6867c38384180440bfd1454c84289d2d0f0c71f04b aaec6b1b2585f8b6f6c979fc11bd0dc3cd695d8a1aae939e1f3834c239c11a09 b2960feedc1ff2fb95ceffa4ce6980c5bdd2c78b3f2d10fcab1ef522d762c51d e884b887c027f92230492b0c033e9776070a2d0b6c74f0aed19f5582bbaba753 0ea2047c0eefd0b24bb3e92b8280e27e03e600e4cf1ea27eb761d712fb51e4fd f4e65354ecf5c8e578411b966dd4cb125f0395dc920a458ab0ed411d2140bd19 1591dd0c6dff3690c712fcd11ee070ce285e3c50d87ec596e37c206c0cee96cf 42257324ccd1f15bb68dbbf9a6e9f909a3081e2bdd8fee8e1acd0a5702217c35 6981d74a781f41417ed0a8630b43acf2add3a8b6bca902d94e4d00def93794a5 cb39ccf6abe2fbced449c5caa8a54e445d0c082d964bd45635e6a390e80b2c5f 3d86a9e3306c9d706915810cc79341920ff88b9aeadfb6e2fcfd9266102eba9c 45140cef1be97db6ce88e44c6c6b12724338e77a3c96a1fcca335c6f43f81782 fa34e39a78d2c4638264567734341115e51a4fe2f1957c10d5a267d207e7f1f6 9a83fca60cebe9cb9f07e7dbbfe2c1d5e3ca5b2d0ce1dd6a5d5cb2c0291b5855 c6089a6d4d86904392cbc3e89ba8a153ae2f978cde6920c5f0a2b968b6d957e6 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 true +check_ring_signature 737c93fbf9ea800a95a12d65fbfe12c662876d1a4e9965e73ff5bb54ad565c56 be02985bf02867d7a07d1b300c71f93977dadd52d6b3eae567178a4fac67ab77 15 f85603f140ed01280ff1a92e92b989e264753b4d63aab0d3af4915a051767e9a 9451913c7b47b04680f0e9f706b09b5a4d66cd0aea1f90f6c8cda0b8485f1f7a a56a3678a5e312187b0275028af890daa556b9bf8b133a86c93da80b1e529488 d8f88ad259e11de3309649b6d2ee229a927484c971b6a41469318d9b27167e69 835cb00982c0939d13e1748007b5b87a7caa6498c9a1f2b3d13d5349bdd2b85d c50e3a78babb2e143338efa35571773fb5afd345f2c061622fa4bb6974a7a0b9 186d449279d7028e453d311e53f71fa35016d5e86cdcabf83e839453e138bf8a 0b1588b2a62a8e825ff8ea82948ecb999cb8e7743a6bbb4347e80df8cce3919a cdd07d6244009f9c9d404f8dfd70c339d9e6c8b89b46ae3121a7c0b0cf1d9645 6faf7071806188f5c623e330d76dbdbd6124c76f00162368665f53bbb1bd33e2 d71b9a8830ea0b2c892dab340e86c1722492b61cbbb8d118a4a90ecc6632eaf4 dceeefee4bef18b18c416b1a75750223a6f0218bd9ec7bb15ecceeba1fbe767a 098629b5ec476ef56930548b6b4737d3c2d77940743c5b881527456ac733d00d 8678e5cc9a3567e5fa202c4240a2a2e65c13aa0f5579b178af1eb940134c1b10 895fd94303051899b3994e4075e8c9f3d674bec07c2c231115085e5f203c2452 160f4a996c145f6a4a5883ea3af5ed75870cbf350fa96a0794909d47c3d7ac0c394611f4f726dcf761392d52e635437d6bd682b1b945e78a34b41a0ba15b3301e35523c36396b6450674134f65a8d3f7555c2c73a4fca4fe4afe75face185d0b8fe5eef6ea9ddd65ed30ecca403eee1d1df0b525c338f92fe4bd62ba531b130d937c771b35bb0aeaf30ada495540b9bdd938faf0452289ff9b392e2a700785059e31bee601e0ed5f4beb928f0873780cfde5f45c03be5f0628695df2459bc206567403b439efe3abe4f9e2f2518f20c025413faa443c625c21ec2f7eace4790d573f2074eeb42a99885f89ab8b22eb1d7257b9fedb15a43a2be82ea48a8b5f099111d88b60ac45c308dae3caa9921f3ddd887524a6a2fdc10ca3e26791bd050bdd5e52a4f1f30c4de1668d73a267dbe51020e370447f55401111b64c7f2e7602b2bb50383b16b06f45f9497c7cfe5b13af05eaaf5a9fd24e136427f988b5f3060aeb1425d2e1187f47970e65cf35fa4c7dd092650e58a71c9228fb1093441f091b6679e13f180e78260fe135bb1c26c57f8e0647bf1848940f727607ef8fa9076f70ed88440872d57efe342aeb52186120d8fe70ef031bb6c1a168a2fbc43c0b18ebf28107da3659b0cc4d8550016e766496333312118cc9fbae9828a551100bbbc689ac226c8eacab3fbbf88751dea8c29cde3e4e67f4c291381e8e8f73720ad7c594fdb0acbbc6230bc5c6736a29c41a0414f4858d5608b7b7e80adf6cf806af9bb27b2607a0b372e7e304dfdd39101d24a4d3c922e329b9b37ed9dc722e0e4d0115769c24dab9a3fc312005fec8b9c08b628611e84dd46ea717d47d484406ee209ef2325eeaa9339ddf1e0d98bc7574124fd26ead7be62a4933d26c3805022d3a68dfcb4e2757e3b4ea938abad5df2a9a880cbbe1e75ead1b3848e415380eb03196e061ba5da68d8e3bb25b143f6b9b5f5d98045a550f9a592e5dd042de04accd60574a62033c716be937b63b54b00bffbec508cc49a605612f9dcdec59098cf6a35fd8c2813b77cdff4ba7fdd1617116fe7c8fc789ddcd8525b28c6da90244724ec97299d158d2f3908a5afb7eec23c1c4c7b750af250ede2e2cfdcebd0c8e0be7508b6f41659b5e389bcb7352e100172e1626609ead550f47b4a686c40c0cf6960d40837d37ae0b8ffee692f9fff11cf20a5a85f3024fbcee13153ff40602def67a6c65c86d1e0ff2fdf2bd3d0790b3ceaf24a1843ade2ac2555ca8800dddd16c7a957aab6abe3954a9cc36bc7539091092c5eb9fc8b16138b207e3ad0380092bbf5462462a8f9d7f52fe31376044c354182aa2ec4e84d2753a320df800 false +check_ring_signature f942fd9e3c7f09dfc1ab78e0c18926d8ca9073295fe4ac9f2a73319e2184ab92 65ddebd5a0b39abd52a46a596d45eba3c323d4c3ca4e102349cb7dcb71c9ca92 224 081599ca5f1f030a88c07a439e2be17702fe56110d4bcd12e9892558ecf6b17c 64285b36e219317d271160a9696fb1b0dda96315bdd1e18b6972f064d29ddb2d 97ecece68043d0f6c18fb56cba9850f46652a73759d9f9931de36a576733d77a 85e4a86d0e1a43b6a168228218815f7ce6fc7fcf046163704376418f57d9ce58 2ad0a327a2eb3d012f17de7568f8f2aef8537636d33e870c75866f3fe70424df adb7b3a3a1d3ad84e5c56387b98c8973c00b9ca25fe65f891d397c8d5b0d70ef 24515020529e7a2d7c0fb40c196291425c36c68a69ee16da1d19a381d19cadbc c51165b2d1f2b25f5637ba6a7b90cce3e0abdd3c3533e7e7ad1091b8adf78218 71c4cbc11d042850567e0fad2197cbcc57d8f68a942b2b008c3c5c2556de83d5 dcdfe54daea685966a0ff6bd0e4d9190253f447777614f88a1bd64811e3a6672 14d0b2cbe53d816f330aab3263ab2ac173d519851f93025f171a4bfd4abecc49 1c4d6cd0374411c1cec659acc3ac12ddbcca76278706b008a0b5276805b9fc97 fba1cefb7c30a8f502434359be5779ee85bfc4571a254fdfaa9b4c8ffdb7357b eaa17a168e85b8c7f4f8ab7938a7494e8aaec61295bbeef586948e7f8eea5cfe a29512dad02fa408b07c33617ae7f44770ea8bd633ddb442a6eabba3cc2e64c8 3e7f594ac85f56b6ca7aaffdf2c95348c95f3f1fda8d24fd1087d63cf00db7e3 95442f15f87b4c67e73fcc4d45b72e2267aadbaf6b2a0c6a8ec0a5b6938e748c 6294faa4e381d21f71efffeed29bf256158a2d52732aa4499562bae7aca8f42f e6a01935f1d21304d4029b4b80ecbdd7aca063bc8b3bb62b0202f8b2cbdd3111 5434adb1cb5ca490ccfb10f8af664fd07877cd05f81c50c2b108362617434fae 39fa884da10dcbb8c107d7e04824af86a9db1bef0a73bc3e29976021d586eaa2 d1fca96727336d7f78434cc36f67daeef4566a27204599dd08b25387afb62444 ddeb205697c3278b958c4364eeb241f4b91469a887bc4dbdf462659010b70089 7a8ddf0803990e744acde0968dd17f91047b96d0618be43ecfbe88f21b21c848 826218cc6f5bdde5611df7aeff2571c84b6b5827df5739f7a8ad3dc56e160ac5 b8734c6eedaac63f5a80e7f53b9e77fe90228fa656dfae9f442f8bcc42a6356e 6c3eb1cd41a40f58b78a3a068bae4bb148aff4bfc792d00c2b56b89b4a811fdf 17038a08d380af3c7a112519f83b2896b63dac686bbc98099f978a4dace9869e 5a49012f65463580c6a25b9c8349cb2fa0c9eba4ae8f4cabdb46b4fa23d70b8b 9b5bc48b6696ddb8e9efa6e0595b93670dcff0631b5b1ccf1fb17fe00fe444c8 5014e8d398d3ee3235580dd9e6bf376dbdf5db10fa7027406e63b5fbd17c5376 b5aa14a42097f37f5eb225fc8766ada700a922887cd77ccb3264960b27ffa7c3 691156e9fbc2fd4163bda5782da584134c225ca9558a4108af172e3253ce109c 4fb9df911cc0c53954b82d76cf3c734a83a8c7064a8cb707e2316688a0c3a74c 6a8861382fcd89b7eca2a1c625d8eaea5502f3a019c171b8a6b6d242411f6e8b b858913d40e6f0bc3465085ffaaa2d773fd80f386bdecc0a1d95f518c99d1b01 e84b78a6add6172062bea901b1ef3081d87453d51a55d2213bd6f7c488e1ad97 5a989a9a9d32e9b64a55c8fd86f40ecf738e9cb3b0b3a348331f4c113e0ac44c 06934618f17791cf76de672e4a68920b77986cbeaf1af74fc8bff9e808f2840a 9903e88ae26dd8eb768b517c1336cdbfe4b6641b0b2b1c6dd65d86ab4c6b3cec 477f599a50f3bf5808fc4e7d25fccd8b44b0636e5f2db298459c345fa7154d5b c8d2deb05f7f98e083d9cb0b0f9082053c001062fde1b7d13bd759d8343d2ff7 e4388fe0c7d33864321efea049ee5da0be820d83fc5e6d43070e9c7595ab6278 0943c0842e338924bf60332f56839291863117a21c9393cc978c89b28d709d7e 6490472aa5157703efce1861eb70b91c85ed1f87ce7b28c6a36f823308f5513d 2564a32e6c7d4238796338683db1a1d92609421b3b4286842daec15c8322399b 0b83ed9b865157ca3b81773260e91976c8ccf1c1a61befdaca6a8d78965fe90e aca21846bff5861344561caf5dc67fa8e48abac0f501862eabc91b83ddd5ef5f e3b06ae255b6af003099d11e85a4eab13039006906af4d1d0210ca76e73a2b5d 8de0a2425a653ae64ba46414aa221b089b35cfad89381a18c0d926fa27f60fed 7a4ce9480982240486dfa565df1d6caacafacc4a55d7fe7173003c58cb43515f dbd0e681f739c82b8a338ea1dc6db89c1989aed69c28c94e7a364646fb977e3d 9702f14ede2d091e3f8c77f09f293058dfdefc8e42b3f322afc3540959843885 73866b144498d3ea1a0487d93215c0d4638fe332ae1083f82f502ea2c65ccc95 61c73c8824c5ac655b73d82f04dba2a2358153fecb6aa33b90a5a4b6df2d2072 84501f067254b1eee96d0fff1660d23f710d9210e90996d53b268dd2debb2981 40c85664124f0651d11134f7c8b8442529007233989fff918b5ed73d807c7438 87ab6a8819b4e946fc8fca0996968025f1315f68e667bde2610643803aae22f7 8713e3d9209c79e6a36ec2c07567ed41ce23c86efd66b54d18a154e6d65f3e91 6874bbf3d72c8245f8ab6546cfbadd736778813c899e3a409146383684fbcf96 eae3d24daeb5d60afbb732a2ffe0e7cc287f2f0a96f838c906c2652cc27ab514 dc37830c30501296cf4addb2ae7b237c44a9f9d2c66575a4ac1d3f30f2ce8e77 bf3e2522306e192f163e81dcc9dcbbd93d19096b3678f7132ff44b9f03859bc6 f0d4d1db1d196637b9c615640fdc08bff2b23681d6805a555a01f453cf8a9343 fc1d63fc23ae092cdad0e93a02beaecade321eba7f3484a44c8e047d48529812 25bfa01e64f4444a1d1057b307ec9047a2c69e097a9318f2fa0425d86f8f009d 30f72f50954b496fb1582706fb2173de773b84ae8bc9f924346b299568345fd4 0885a581065dc2f7e2c42c43fbc6bfb4dbeec50cd67548b666cff2bf6d1ae227 3205539f73f342f7a4b1b59640c32df027a8f82990c6c52774d9d36c94a0506c 6cfe8497320204bdde8865c86852671c56ee37b40333cb23f811cbe5307d4912 99dd147399ddd42d6d17530b29baff2815dfd461b22fb5c0538005d15207418a dafae4893ba9100e322ce5d1d3a0aaccc0c59bf24ba6eff722b4da069250fac4 33893c461e682b09c0f09355b9cf899e039e999384eecc255e17d887a7090ffb b72a46a396366bcb9ba1a1b629bef2be2c918625045037158e5de6771e60ad02 1fc454dc6cf00495d312cc12fefc0b54d3d69ac52b33ecf05a6ebc70b31d1eaa a49de1bd26b6c2bc7e96233fd3dc30b3b7de7d3f0d4258bb07a41cdd0b723cb0 25620034ec9130c58e0db703c437e989397cb09dceb6fb645818bcf00cd31c29 e10887fccec63043ae88c94a5e90e3a911dd8bf432e41de183446807cb7e8cee 8476bc8b19e269bfa5f9e072f8c3ff44bce8837c9651baca235962f102416bd0 eaf9c6c9444fa6ee5452978202d36381983448f112cf1cbbf433851113bfa5a7 2dee625a6fafa9c3c586b7000b78460cdc26baee9603adce98b77295f5fd6cd0 65b83cd112ce4863fd802e2dac0c054a9e1b45c88ed7504870c1dcec1c0d7149 64c7118f5c65cb2d471e3d6c8506d9a66de910fe8769d86b1576a25c922da2db 513289a074666a5172aff29b8a940cabf350d6494a0459480a901696ab3784f2 d6a3b14117bf506ba18c6b708a2585b72fedbf2fe2c86da64dec62b50dba437a c4a3fe131fdae5d2e41c19fd5fa88c2ea8649213c96842eb11b7905cb7347722 140c3ad3fd481ad8f7f06b4c6ce3a52aff3dffc93c6f02ed646236b94d8ce0a3 dbe5848ba2ade1ec6bde2864f712a8dd038e12b82aee38ad9716dbf0b8c30144 f528d25ad0da19a09cd3c1c82539185b92296c4aea5b6b2cea8584f9a7839bd2 5ebf6a095deb902f24953a7e2d00f7ad6c0355463950282cb68929f57acd60b6 0bce1442ba6c349a5682398bc6eb38c71252ea1f93bfa1591d72ac1839d5b06c f8f70d6090f6a19c03f1dbb6e9b74aa072df654fb06d9df0030c6204b378e2af dae1820241ce74e7ac393ee7acae48c6f66e0c19ebcb2f9be9d4dbdb2a0abbb9 75e5145918b40ff3f9a70d4e350aaab67eec432ef11a4b68c639b263030e59b6 7709ac517175c8dba2bed36fd3bfa4abbad312cb427272ea5c405fcf616a59b7 df7c2ecad089ecb43ac6e7541a7aba28795e52a4b1b362c2a9120786e0493e22 cc94c1f39a29f589d870b4c6a871436920b94bd4576cb8496d63e799d7385253 8269a92973552f819d57a40783bdb8fc4621b17f332dd352fcb36924b5f07a4a 9baf9e8e7f284ba86f41c01e6f156a9fbbd0132b2dd64b69485ad52228b117bb 1bbcb63d136fc886d7272a21c8e83705dedd9c4d04face6a7bf3a1b37eb94029 5a1359d15878e71a15628c736ea9288cc243e6f402568861245a6aa58923de6e 665d3b6e13efce47c06c6c58997a9b481fbace065f1d5d14b9d1e1137571f39b 280663e811962b84b3c1c5d33417c6818f05640fcedf084544c97cdec2892948 2570f12843614248f8e1d7ede40b7a2f9120da1aeb4e2a46c6531e972b121c23 a932c28bb22fc0608ae0f70fa926feab7ff7721eeb788391724b64a60b37283a 95487b8f1bd06351020544a9d2cd934e8cd5a172b9acb4dfec5050e45e0f880c 55ee7c96c6368fb68074be1deb2cbaf9d5336749c496f7c709d4fc356e6a2c8d 8608e3557dce392b40519750395d1d2d8b57b3f74c825345dcb44ef6c2082d36 c05e14c89c180e566d6ae05d5732342a45c87d3066f2fa8d513d4dcb59d34c22 a703aa5dab96fdfeafa961fa17f68e0c6015b6ea342c145e106d41e46c4af0b3 cf7c1b3194ca2b9cffa0333d922f145f6cb3021d157159f498af8476649ecdca 21344d9f65a0bc612c27409c5a963f83c1270972aeaa3323634be483f50bac50 48f2c00228ffa430276e7bf180b330e3bb8d08f8f50f98bf5b2d4df7dee55690 063b7ddd668f308d119955fe7beb6ae8ab424572cb3220fedb35faa9db367eb5 1e288180a62159f4b3117df49ac01f34dbbb93cfed9405ee1b87215ed9ab99b7 bd25fc1e454e09fcf37313c51ba619116ed0ea5963ddbaa619b5d7db3ceb68f1 3e14713b9af49720d5d6cb038e11171e4e4660af05c11a5c19eb75d14e6c108e e11921cdec2d6dd59288fed616c81d17211ec6f1ebb6923f9da7df4f5c137dde 28d0d9bed6a1f1c41c5b6c7ef08999a830e7984ac7504d9c8d8f24465d9c7c89 26b98c0e21995894989f04a821efc6bc716ceefa8d3f90d0578b05fe0005c629 6ea85705b06b8cbc278e09ed6d7f4959ac46c436e59b1b961a59dfde52aa7ab1 92ccfb983899bf47dcc59bf855215bc2a7ec5fdaf5301f2c25994c75ff2e05b3 23266bc685410b7681c5872ba76f546aaf17867c33f8582702ad427d6db17889 ded532abc5d97c8398bcf41ac69cd24be8114463377c455dc1d21b877f1356e9 0e0f385137326a6a87a97b408a713d785e2ba616df66b03eb07318ef232eef9b 056d533ba6e7fd63505f4005b46ab5047bae3003071625cf8f422b3607f1c56a 1f3eca80eab08a0eaff87f42e70f03747c87ca176407ea7da67e970388f181d5 509e2fca2f660a7611465f040669343b6f022051c46ef81b0aef2b991c780c82 8a09cb2c7308e3f5fa25a8f01a3c0044e7867072b1a0b5dc75b3af8039b4a4fb 32e13ac891091be59d6e0b08cfd9415a845cbec1b67447b88db41d562225be1c 9b57bba919870f1c6f47be2ccc9eec840616d558548883080b24723c6bb4689d be0f43ca6e5ed1ef4b633be91f67e50150b6096c2a959c9e735552bf631d5f36 7720db0bece2923dfeb0bfe9eacbeb7eb48a2691bd78f4a7b1e6383223b066b8 8e2e16b7895f96cf00b17acfef8fc22b708ae571ab6260f6203518ba33a3bfc5 c2a86015f5b5399718ada1ba299669d7b1f3df3cf32022f6a1dcc1f01dfc571d a9bc7ee976d3111e1b2f98f412d75379754ee43d568733d0c0a590823054bf53 1d0af5467611f252a1505e82bd92eb7f7b19879472c576325202d2a213db29cf f8cc81e96827de371930d334e41032e08a1843b72d883c6415785f554c5ecc29 e3c0734a52ec6e565efdb016b6bc22332ec6169860941a5af885b325116498d2 706db57dc543609e7ce3963b4dd2c04a4587255beed15177e34ae8b97c65c670 8f2e3a0a1da376ed690c8063da48fc5a6292da0fbe4806e0b9f624d2206857e9 6f1d6f45723668239a557e6ea2993a2af8e0dd25c1ab086629b3229be394669a 08d18eee83b61ad0475b200c02e9cd876ac2bb62351aee6ac06b8d16cd3b6f99 362e2c87e65cadf0ff68b785ecb1eedd856e84383c58b9a82d81d22703aa12c8 78b8a96bbbd6ff996794d98dab11c643dfd0713e8ecfb3d3ce6166090fc9b495 d0483df1643c8f03c2629be68e337d49289a307646b46132ea286b2afdd8ebe9 c2aae167059e1575795928463d7b51dd06fd7b2bbe66f4a4364925cccd55e1f0 0667a0e56208d45ba62c471ed106096f77c496906463fa5ea1f3ee76bac5a4ab 49e4cdc6fd2404149bc99016df63aef37e89de3c308006392a8cf68c4ffe58f5 1406dd3067600a8119dc6f7ba61e07572590588170e60627af00a6114165edf3 498aec93692b272fa04437b7fe889ece57093f64efe5c3960b8db0d152c1da01 66bccb24ef7af12cb4d86c033187bf52a6e2c505d5dba5e15f8d099b04e01c80 17003ffd4ad7601c5bf24dc2d82a28f45d8336a7ef730e52e170bb57c2df4626 582d0dcd9401edfcdf95d119929859bb3eab4112130e2acf5893df666acfec09 6fbdbd44c01e9bf5ba03d2383e3698e516f91edfa27d55bc3219b86c1a34d50a 78a0f400465167902698b53403d128590a7bed575e3a8f1d8afaa74f2b30b3d9 cff14214577586eae5bc9850ab3d1f98c9da02b32181cc4c19f2a17b864e9c84 0ee8f47c89cf54bb65119154c8cca2f4a1059d47050b63cd0ba77f509a664911 d09922af6095d392bab779793ae4b5c5bb19b71e02b3bbe3c5b4238d1c7a8dd1 dc567422d4817a27c904d083541da2382b4f894092a676928dbac978c6622903 8afdbd78c86854a7db86ad7b5aebf47fbca686e7622a450f7e69bc8294789ebd fb971cb6e1f85cc85f53b14c300df4d78bf8c8533731d7302bec8e42e43115b2 9f5658676c02c7ea6ef06e2121b6ec07a709fbbd3aef4019434aed171d4aa2fa fa5785423f86600239f9ddcf3632d2288c44604221c94bc39e4799568ac1c3d5 ef3a9dbee19eadf0e6d7aca3f81595f58ab70c8b54f8b60536e91049539c5c47 cb1448194c6c466d31fa885de96bb77af735f06e034c240854a33d2f29e8edf7 69c0d73f656c611516d4301a2dceabaa49de9ca62fc9383362a3bd3c83b1527c f51905f617015c3e97be3021dd07b1174b43fb8ad475a42030a77ea2fabfa797 e619e0d4219cc7f3d7d57dc32b121731f4efc66b72637c4bfe85ccfcd72418c9 407739e939d18f2d5eff8aa87e122d54c4eb78f53050c039b6ab75e54f6d898e 8fbd61a96e0565a61ba13b14ecc5c1646d9ef012e4fb3b3684c55c37edebba65 f9b0f5678a91c08aafb656e2df15ac47b5ac58874ab8ed1802ffdbb4eab4991e 407f5760dbd6f0594ca28382c68efaf1acace6947f02298190a76bb47e97d692 a6f6d830fe3458b886bcc8743c3c321eb41cfc80dd90401af73be6acf4272fa7 d0d0f6b65c60eb02a94dd7c43c8a55fa2b001666f3ec046cbb0c8d39b89205ec 40d5e28f0092b929f1bf1b808cc22ee7819a1140ec20322994be809663d4181e 395ac11fedad8d79d13ed0bd8c8d806bc42afe6f81cc2bf6bb15b285c2a84cfe 5c34a63ee9f67d4f7b47a78b88c1feb74a02117c3cfe34e7b786417bae045112 71a95d3fb166fa39a3397cf48a0c44ad023549fefc774893640c925fb9bc9374 4a6d7e5206286964f521f8b1ee6da187dfe5b7d54e944a7a9d3ff46b100599d2 ddb6d16c8b7dc00333158505549bd75f1054dc8338683ac9ff49117de2a5298b 7e78547476c22eecd979b02c903a0d2194aa3a1fe3ee5f3fff7187efc08cb282 f43e84ca4579a76ccb412c7f50449c541e3379f27f53ada2275b4109dce50b61 87eab533080f558ee908413be4be6db21ebb9059cf2cb13cfad8e550be95ac28 920cad260c58216724dba701b470e8b66bc55a2c255bd85d1793fdeba17cd707 30dbd6d88c5a9d468f13dd80907a93ebbc1a149e2022ca6393ed64e561d65753 82ab3ec1a2be5102bf6e7db63e4177aec60283cdb36584bc6f09e94942ad5268 819516c0880a31c4e7431701c9a2447907c84803ba7822598f0a716fd9a65b06 37f938e5c90ef0f2099d9305ad525cd67b704636d74fca19aeabd8bed9e84d48 1e69db24f4ec6f224ead7271f895837a26c787ef7a04830d8cbdda854c126bd5 47246c64559ca286893789e24e4447be4bb41a46a810791625c478c001426450 6d10d1ce8c281d94ba2eba4eb2c736d4365ac3161df9bd861ebd6013582f40f4 bdd123690f2fbe90a771d6b3112cc7bed97ea153c46c5ca7a407bc058490ec95 abc934ac7a74246695d84964c83675c65bfbee72cabb3b317d8aaaddf19b6cde 862ebfc59de1a5c7aefe529c183f02a9a7b519c4f995337f43927872a002edee 3ae22f6b80114fbcc1eeaca48e441307b7995f9c1d986fd2fc003f329d64912a 96bd9771fa72c9172feb25031556a013a127c6f0f23aeb1c0d52f53bafd72098 9948d740dca9a1714a3825972e43cfbf307ec7e61729eeff8bbf6392ffc866a5 b2d9a2ecdc8eba22b9d5d649a9aaa60d8a964cd2f6d8918483ddb6d791852099 b008407eebff36d4e47ec9f3084cb228b4bbfb209927d37e159656bd58e68130 57767a5bedce8d5b025dc8b174b7f5d7303966b372eb5bd9c8f594bf82bdb62e 2556d6a675c70a8f5e3cce63e68eda0db7d00001b182abb0748029ce4e43f511 e27cc2150d130d80993c7fcf39274f794bfc4a0727b76897dad4f4776ff20837 7256b1957caa36f450d4dcbc31d8e63305477a60e8bb270fba670fefb748e58f eb76f2653f720b081218a52cb68d9129519a7c3c888b2f84d11ca1a436ca8ce2 ad8d5405b9bd82b9ee37487c561b47ac1e4fe52debb24f9c1a1276afed596c92 7bbea5c45136612e44b5b93b53e8a643fdc905a92ae1e8acdb5d7f66b098e235 e0bf461b82fd26e3a54fbebab652fb3ea80950d14b8687b574bf31627d81c494 0b2337263f988a1a3f5c18782762313560ecd03e19ddb7a6b8014fc4659914eb ecd04e6f361f40f9434b6015a9b8950f2929cd82130accce501a031a1bcddad2 77f36e1bff7fd550bb50de05222e7c5889c88a1c07bfd0716f087773cbe216ed 82499961c4594e3f584fac5c499853be566b3666d34e5b68e4cd092228465c95 b356f99a0d0e9b280f7efedb5373e72956296cafde56fa7821af1bb904fc258e 653956533771863db4590c7c96863cded27aaf8b73fe56dae7cc28aec30318d4 193bdee418a24bd4e2895ecb04a70bdadbd0eb05f4ecf777c04cccb245ef51d5 9c848b9726add2ad7c9be8ad884617d02c17e69a8a9123165bd039048f263bd9 78fff76b9e3c69ecbd7df5b10b38cd87630f74cd66ec46a4edfbaad5c405e617 4b1c36b47b22ccab43dfe2294841cd6ec0243e27b383c6bd0e4ddcaedb417ede d41af1b94d871d716d25d1c2cc05770bdbf4f61948bbf6cf463f582482451509 bf792f3a21df2b41d485df5403d2b918da34749e6464f9a759aa2fe4802f6c32 0ba08d46532ff9858c773a0b7cf5fdf56038eb6e34c44e745eb4e00e3c90c6e1 79a2b3e079f8867eb5345f7c90ec5f9550adb8c1e2e1aade6fce9b717937ea6f a748c7c52ecf2f3da0fec2a26986f669264d85d59015885f634473a19674f5d8 a7b44839417f481155bd248d52942b7bb55efd17e003feccba48fdb21a7abcd8 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 true +check_ring_signature 2073a3a4e983774d43c90c4ce33a887b7c564c3af41340702585bb7f951f6149 9f3cc9b09b0bd47caed175b3f2b7be55b53f1f9835888e9b635e15354ccb9314 3 4970ba0ffd00d0e4218cde329bfd68755d04ba27249ea2e1d0c05f5ca6b1aa52 6a56db2f64650dbdd54ca831201157d4cd3cfba31dc222384b31582a36019742 f2d5a9376471146cd10fe46b821e6e0d5a32c4390997cb14c21514d1cd0bcc34 7120241bfcaa026cb29a31cae6eeba06f357089fba9a35b5373c2542c37f600eb81a0e8049a5fb28f074b0ee8092fc74e06b5a7c82340422a5627e4e2df35e04026070a028bd847a0f146b854601a41db5cd8586f5c9e5a51804fbbf5eaaf0063b04ce0922b98547ebb7364cc177a3491e000742529fb9e4d9da0528352a79037eb774ef5c8b6396358942b12d32893a689c4d42cdbd6780e87e5d851f8ce701d87f77a35d6e8ff287c302026654f6c24eeea2866ea02182158789a1b59edc05 false +check_ring_signature 569decc62841e7a1bdac1c683c92399947ba732102dbf0ababe69180a0b5d9f3 c21bd25cd8df8432e2b9763f49edc7c8b4c77ff242bd6a4e71d3c57f250ca6b4 5 9cc0494c241c3d74fee1478bd3ff227a65fb8d396b20bf23bcf26313451ba8f1 d3df1bb51d6786e1276eb06ec5b4b12fd5d5c7517597819657736ee5062075de 57b5c993ea9164f5d49f7becaeda6e7f4b7bf50fbebd0de7c7f09d3da1b960e9 dead93c36e265cdf573b3768ee6cbe2b6d1f89ce4ba8d06fba74eb72d5d3a0db 644cbbae35e927b1deb370e52c85285d5dc0ee39a2ccd2e23e27b2bffc3f58b2 2ffef52311c1baf1837d13f7ff38f1fdfc7333e244a42bcb5372290009595f0421e669b18fe8e7cafa1d90c41bd27ca0fcb0fce6467006c385eabc609fdd300343726046b2df6eadbf204de64a2e9fe4a9af26385807c1dd0d8191bb2a97fe0612221e1adacd2b21a2ace928fc979a0a786c74dc6c6e14ec3929f86c958a2f5768e60de3272681552445f814ef7fb0a27976c5b2d1ffef7e2a10dd3c9a88140ba1b02d6ae6646c0e3a66a91ac7e8bd43feb84b46d755750125d6383a40fb1d05e108104094f92bb5d68b6ac5c63f69f722937ff2649464736f505f64910d3d060d34a458fb38261fc831e375594e92cf436632cc50dd97096c48f235801c9d09899500ade25c5060c01f9fa533d1b4bdc302dfff5028d340cd14ca596265e4070d7a54ce1acd2826da8a8fbe0e6234ef234e79aa83ae45ee6a3ac925087b9c0f false +check_ring_signature 136d0d57ef64463c2adeb95a1b0e82e5340f681df179b5cb2c26115fcc8e9652 31c8f17b26ded4ab7573cd707f76f8d27b286e9d3c5d97e8a589cda513ec62c4 3 02a35e6f86e7036c6c0600f4a3501b1ea21357cbfe90c16a2fafab9f4f20bd34 175c2aa1e2388e5efd98320a9e213df6cda41957c1d017ca36870edab6db95bd e6664552097a271c32aef7a3c5667ac5cab05bb1800f9d0532dbdec69998e278 107a6f7722892b62442c7a25aa222f01af25762c7a0498abd1176aca9843840e63b4b6ef922f5a0e2426d8ec2eb0ce1620ffba28540b2a4171861baafbbbc1073352bc5bf6dea2cd610c2c31df7632af3844ea7b15165de2c6c6c65547b8ca0603139c213af4fd09d05f0c630f5e914dd4a892ccffb9341f3b71c06303c3f206df9b4cc715130d545d21f17d0bde2faa3fa8a9fd8abf35be219638c957f69c0a08a3c0fd034d064b4c721be04c9c0ea584b1f80fe6cc25b44f3e880fc602a60b false +check_ring_signature 2d030e50f9fe4c8b564b215247e15be9ff4ca40a3ed9a36ce3beb081f760e4f0 399ad6c08f5bcc3a02e5840c7b49d51d8b56e892be2a5c4fd21391a9e8560012 8 8a6d835bc2200798cef18c93a949e9730eaa0ce960ed9491d5b57d9bb15890a1 613655b02b5b1cbffc492ae4d68e97121ba28fb3dbce5d4ac3aa8ce64a0f38db 5d4e5d94a91f0d409c3919ca1121be1eae44d885fe185fe572c93c87e9e5c8da 55cb7ead91289b7739f328f82ab0de4f65cf47b29b6055a760d7603a39731f37 4795aff098106a1ee047ae3f1cbc5f81e8654216a330045728c73702e5e96e04 ffd7d17c62da4509b5d9befc917f1859979cdb7fd7a939d5ac83a48068ac6c87 56cca0085a16068d887bb6c941fb99e700ff1e3cd6cbd6ba3566e6a9a88c3c52 a0a4f4f689292fb74832a622226ca48b7541322e887d1d4130ccbeb2f4355125 315fb7568cc56fb7cf50b3d1d8574d67c17446c71346fd0b939d1effb1c0320c8d8dbf06a6025c68814c85dfa3d640593ea5829c8ce9380249f11524f436ad028a2da9eff383db96d6c4726c12a450b0d0170bf2858c37e26ab7ecfbe5a6120f00ca55adb924fdec01ad2cb4e39686bd61b55f6eeb8477331bc84f13a7fdcd03cdf0b9a88f11b7aaa3ce4e8f893a1dd0936a4438263d47d2e6c212f2f6b4b809610c307ea9dc77184ea151b96f4b0cd2b9be7813d0df7cb8444ff78d2bd79300f1b58034759d2d220fba2849dd4066c01634ae968b23a974555e9a0b09856a0c03da518f82bde9bef3cccf6fe035e6230ab875fb00a20ad715bc799a0d7c440913ecb12b041f09b35cb97e8d40cf30ab269ca3ad73403060e93fac1af8f98a03c51d0c5e45c09a6c5c7877dd6bb2ea7983664e5d479421a5b17c2d127690f103b657d071ca542d783a503876d701582a4500321b718d44252c2db39c1dfcff00756310d53dc5403be04bea416d566d882f5e5fc10b0b4307835d9f8f434aa90019a69e62f0cf23a243eda6d0b24332e33a24369e2e39202db883685596c6530b7453a23d0595a2d27c30c835d75b070369fc3605ced927147a3d7da58bfae40eb11ee0b77d8e503878e787398939cd66c1f8fc0d5d598a180281999e48d1310d830e5b4c12f4dc378db9fa2c13c284ffb6ddee741f9fbc3db622853845cf5c09 true +check_ring_signature cf50e2e3e2e7d09b80697ee34a204c452964d428cf210146c051e012252f2565 76a199f8eda53881d38f8af1bc002a97e71bf844a1f579be49661448ddd31221 4 f132fe6177b90e99f222d6bd6977b965e484d5749fd189232a064031794bd34a edf5e1bac2d769f5edca297ba8e5b0a6119a3afa931054db6871cb8ef34ebb7b 81d41cb371105b162660fd8e4ac6b9ab8786f1415047cd47a884dfccf494d568 f78cc0533f78f867d0b8e7d66788eb249c28de90edc8834c77a4337f940febb7 9905023718a529e4a2c624cfe1521bea058c1b444e9048d7934dc9f90c79cc0afb7b3a939b2fb5704b1e563bb11ba1403aeb88de76b3121749c21870e2dc4d0807ed13954e3aa164ad59926f4fba16759fd85b2cbae0eee67d21fc4306e67003c52904054bc393cd2f730dfaa67a4b4c27a4f9a109bf90a80c6ce2b459caa10794c0b5bb294100b05bc84f84f2c7482038697affe88386e4e9de6f25a0cfaf03408edd93f364ba6f0c44f157e139bc420b71426ad61540d05286d5e279707800d03ca41b9e4725ae16fb2c7008d1e8f640c56ec5279b7271b99550d9e34afa0d6b6285f37dc7c2af39ffcc6deefe1b770de7ca373e12760eefc6ae04cf4f760a true +check_ring_signature bc33166d3b3d024f20fb44ea67d775500b97f41789da7968c6d287d69919774d f04b703be02a91395123710736ce574af2e5925f3ec2cf5fd3738a79d2d59757 11 c925f7fba23cfe2afe5db1f492ace163e2c777b72e0a2df861175ee99d15c31b 7182be9dc3517023411ec180b847d398ba69a820bb4ac6d7016c9557a09ecc37 4a774e2f6d05810fb99becc17ef04902edfe13286249fcf9122c0e0235bf5195 cc97ecd383db62ed0d27018943e29fc95fb92cacd1abbddb2397efecb6da533d 656aac414ab63d0125c9f4fa1d50f29db63a845c654024fd1e4afa27c465a3e2 70b35990355a06ba67dc3a54d885cfd868b0c19b6f5ea44bd65b4ccdbd0b309e 47e8386f9be747b1f6d48daab621bcff453e8036233379a4f9e2e07395da96d6 e4eca32e739071eaf5bebe569c08e6d0988a3e3da4e336404fd851f33dd2718c 671b22bdfe150850a91b8b5def5958208c69e58a06a26364fce9a995689e10a9 da7bfe494c5c5126e0593ddb8855ba35875d0adaf226ae4cc8668307e7914b3b 535f8f661bf5f91ae82450358ecdd39fa996b9de888b72f6047dd690fc33fd9e c2c994cee76d86720d565d68f373bc77041c7682304484263e21fcd4a3fb8307f6f6eec37fedaee93b0251368001e531dd440729f79c813e9d9f3e7fbac0320ec52b5423ee64f3f064dfc688857e183c253468b913cc53e6bbec476f4703a40bef910fbbfe62de3303a26054adbcd006d40634c6ac98964e64b832655aaa3406cb0719729052b721e97454cd1ee8caa2ab10be13d136721a43607696996d7d0dec694b474f7752beabffe6196a9890db498222264c8558c9e3f99fabf1ede204cb3dfa65fd28c18fb3da73bbbc21b401d8529cf1c8e56d2d30748296206b3d05f790f25ba3d4c539e72664c2272b87aa91a34350431a2aae4347dc1c1aebea0ebd2672b8497f17a6a5bbb7fe197e04a42ed83f90f958abe0cb5a67ab4fddca0f3f327860cd0c3eff339ffade3e5beed613c0be21fcdd339d993fb797d8a32e02966859f78e8509c3c8fbf15019a9f02f1cc25c97eadd07784658b907a56bc100104b72ab013f401de6e7a7b227e7756ca874fa1c92408e7397aa1effca29e806c2c2d199f3361d112c0ce84a18f6e8a90d4e686372a99bb13d60460d935b5c0018c2ce5de07b222cfe6e58bc1c80c37463fc5025b067da336f44bc259ce8eb0ebc7ad98c6d52948d36205b2dea6fc64211431c910d4820df18b1b985be69dc0610b3144c4ba9dbdb040d5907a1098fabf6882dd485f8429e8e48f5329f532309806525f73e09322906a8e52ae2993e6326f28280ea356c6a9b894962b3e5150b51b6f90da9ab8f04b863c574db9d8bb6b660e888fe17a8a781d3ac5324c09f0298a2edb0ec72e9dfc7616511534c50c1457416ede09bc53bd2967c90d23b2c08b4c7f100ad6f60ed3d79f40a6fa57068d0d18df8bb0f729c7836163338861101b1d6cf68ded06846c9b43a5db079209350e562ca41e6834b9d44fc988e8a4a0389f4a1a421e194770815effb3d6ecb99c07cab2ccea145006ae9b7bb044e8c03 false +check_ring_signature 4390d4d8e02f3b2bac2c2b4782d7f076e501f2bd29620c71e34555903266899e 4cb32d313e358cbe88116fe2a67d16ade245bdb501a9304a64f2118cfbf8fffd 111 1605f70f376c1356d64d94b97ee5a93a2da27b71ae4c545bc4b87419d44d15dd 4b97e16eea15ecd5e920a48a8600d637f429af469e9969493519ae88a6a3257f 37bc2b4363c6c569e32b826144ed83f85aa257830068c2b90671c054774ccb6d 43ef9c2e23a2aa1fe8c6d08056a01f1b3c726af40a299f3b693da0cfca72e82e 12d1367deb6af672efffa97b7bbaa9cc4895ce1b4dad9f146aff79cc0c1c4e85 9e3c12a06316d1938d1bfa2cf80123c146aee4c72cffabd4d846c1c833899205 2dd3c627dcc3c8d9ee2cc50f29ac5039371e05f56127fd9da602ad083e62bb5a 594dc217bb24e1bb6b50463f43815d5473047d952dd79dd5885fa97be548ee35 f00c1e9b2ba1433e1987063317375ba4e51318c6c845eae60ef28900163ac1f8 a556d078fd8eaa7e36bc53102c605120bcb63a7ada485de40e7f0bbcf52fd965 caf8c7f1bafe687c91039608e2b0dfbd3248519766fb3c161bb3eb5383520543 b1e80d7487d22986baf9fdfa9fc31f44abb13910e3d2fa062ad55218c53e5b73 f1a3049e218a973533c0ab6aaf315f37e7596bd353d315e227ca6bbd03f76803 a6d5d2af2259bebf8d9470b383b9dd5ff7c41ffd03adf716d1c75842edd613bf ce456e878ddefd8a0d4cd545c25fc3098eb005abe5bfacc1790a161539ae1851 aab57e2ff3415f332576d3234e6061467a69315d24589613050cd6e1d7c167cb 35fc69b1a3a06ce4615180a3a7f9013a6874f0be063e2d6de632ac8af49c6801 f366d4763900ebe94f4345b195e5f6ec5bf5f992d8b08309d982ff26dc865c67 1c9a096954c02badf4a0aa57f3f60cba75d988ca53d3f8333c90f0343379620e 631594e5536b0a49d07e0d66ad8cda81f84294ddd1efee085d0eb1210234b2d9 1aac2f99896ccf3530d4c21dd9f257499e63c6c74798253b47a8b171f626da33 9582af123be3cdebd109b6730c9c707e84324d96d60d5ae62b030821f3edf17b 0db00479589d1331ca5e1fadd493e5ec2357af7837c454dffc0425199c31ecde 9015f4c3f04d223c15c3387da134684e33bb2f879d1d02a7206a7c5533b5c414 2e3b3f29cdad88fea5b9ecce050e6ac482731e1d138f110ca177320d73e7ac31 5a75e98c2c0b04487259fbaf827e3bd49baf635390994898b9cf79355229909f e92d4c153a1a209813ea51661ecef9534cc8dea965ab1bd88c7ea7e7b4b48460 6940fd7200e49daf9741ae6dfb1a93979f8a19ce749d1a84380369941ba2bf8a ba732ed198bf407fa2aa0d939111a79b970281c0a8551de2cda9d2534c719dcf a9fb652f06696a83f473a3fd282ba8c8305c461853f0b56c37d6d7355d528774 83a5b3fcf8308fdf79c7f79e213e848c0f8f13669d0dbfd97fe7a707b88fe7f8 ffb7ae2d53ee221fa34587e9a363e7405462ac023b42564460f042e6ed1d3e7e fec96aaa3d7cac92383e0a4a8f3699e5dfe8aaa38fbebd156b37f0031120a415 7d9e74bd4ae2f2d812289c7692c07902a3f8a164d5c69670781890baabffcca2 6f8f58263aa97d1dea1a41bc7afab9f7d618b5332bde6fe7b80e8fa175146277 d2b5b62dab27d9c79cd15863bfba7a0fc2d184e32c4e45b996de5cb470ca4653 00c31c7ecd79158dcdca73fc896332555b8dd979fccda6a66ec1a81a32f8f675 474dd30efa2286288ab6c4e22383834f56991a67c7727fce3438619e6d7b4a04 42f61642595edb571fb4ad214beb751878dbc891d6712e7c63bf72efc050de4d 7494caf1d92d658ad46a47a158a3b8aa698076e346daa1e3e731689dfc8cfdf9 d9cc9ab1b4bc89d4f00eda143d71848a7e4ef99e334a24208772c44576176685 898bc6ad0b96a90e03cde4ac9c9c10bb3860d4d68cc9117b7decc994033c1ed5 75f10d95f0aa0996e583307277bda91a03d639128c49be6cb1449d4230af8eb1 e7d1521621b9bb27c633dff83d18b42e5c02a0cca79736d0917e47dcfb2c7b63 2ece4af253f9f85e0cdbb0a7c692b6ba46ba1711f2b710721e4cff7062faf101 77bbdebc81861560098d331956b6fc12b7ec47c7a9da6b0365bc7111fb92961f 9a9c957324ea254b6ceab4f18c28d29159994eb877538c593fb512d856f48cf4 6561efc16bbab400fb3a76f885adcdc5aae89f853f30220e71c0dd850781d74a d4a8d0dda83b75ef5aede87ec187357c9410ce0d13bb98207023efd84d2e4af0 d0dcd91bd361d3fc12e3b59a3bd7e69445ce57418e0b26808bfa34ee9411fbcb ca0c948b2513d4053a12f02c1d7e81684952bc3e2e373b1081b0796fb0e37443 8d532cf002bb48c3957949dec43dc1b61741878f8246b05f31fe32ee933f8d7f c2453894930737ae4940a285132daa497ba121e2f9d0b1889120b87782ae6701 790800732a7af393be48300ac566ccca90416827b79e0bd0947b0fb519967c2c 53bc768ef8d21e48241492236969bde33654a402ecb0e1cb7470f44e528c2690 251d656153d5c2d39cf4354724b67c0be084cb19e6e1014f5e1c595c89b8f06a cfd2950b1f2e71cda52103c9332f5094a1efac51cc5ecf8de388904bcd92ddb7 899b1066e37143b3b917cbde427dacc36d1892edc3616ee7500533d48337c26b c55efc30fdeeb4d645b315eeae3e7cf244f255020189dd7cb1396081fa0cd8b1 7d463573a0b4f9810178ad0e0e1bb57761e439a9171e90b6d0b0748fa68dd9fc 0731c1b53c2fa5f5d8887445dd09c73575397a6b38f56e2841eb06e9a1dcddc9 11247daf8e403921b421ef33486d32dd8686f71f547bd39615a281e0ac304869 c67c0ad947ea612622c92dd388a9deb0d72c7067fe3576166bc2730af557887e 18635e4ef7c6cd410e3a855fc9e10c74c0886bc51cd9be48ddc1d38bfa0987b2 03d2f20b3c0451ce656a61f9735a8dc0a1b640b4aaf59f70d57400891af30571 04fb4d71c268ffbb16f279ea6cefc8fd88ac7ade38142b4df4f5894d1062ef45 b686c8d81090c90c4ce2b60489eb6f353c9fdfd65fbcf292a14bffd97a138232 30c82dbddb9bae741af30800a6c93ff7c987297a486ec6c6ce0b2981fd6a1fc2 d4046b33b39cd12c318fdca173e0aa6edd0f03c351758cd974403159de3712f8 cee0ce0ce4370c6ba72b6b016163dbbf31cb230338356dc79223fe51897d4679 f3011565a8e08a4d65f5b6e39f754867ef76a1b839285733470827284b107a8a 299f1735627cefd879753484c4005c8d7571aa95ff223193d5f7fb77364b4bfe c6a14e96765ec2ad5b5288ca4badf4a4071d41eedfe18f47a7680d50b05a88f9 f067652737ec9a2940d5be41b87caeeaaab6f1abf09693fb2184614493aedc49 a1e8f03a80a6aa6b67544f42f4ee8c2eb8b51322e643add1251bab4e81730714 497867ffe224eee0d90be4d916de981c6297e2a893911b4300254f1f951ab224 1cd888ad46325da99ab38efb41955cc3b7e22a030cf5e5c0b7bdda5479a20fac 7753f347c2b86a8c933d8069d5a50e4a5770aa8109b2d74122872abc18bf6154 d3b4700c59cbb8a1ca5d940c1cf7cac0b1246e313665956152d2cbe5246cc6b8 245407071465a28b192a67665dd7078bfcb28b7cfb8d0619de51b77e0ffe7f9c ef83c5cdc4f50bd626d0f2d267f34e830a50417d43618d41accb645cd59a3a26 b091376173e9311ca8da1c959d13233ea00aa4c2eb0df9c076ef6fc9f8f531b3 aabc67c2343f9819b8f6354f0fcf0066c79e7bd4e34dbe4bd3e687560d51d01d d6206de6f6bc890d4ad6324d720acf20ef50c964597c43678fd134d27b1c45c9 17d143dcbc1fa1664c922addb51682b2b3c3393ad74c991338b3066c54813264 76ea1e8bb41cc561eb0caa2a2e41c244d1929e38d9f1c9e8e38f3f64f9142a9d 66544756fe693abd94d2fe966b2030e196f17c2357d416020274c9a7061548aa d2e9df6a878fa0c39216c1754b0d5ef8e12e5efc042195aca93deaec9005734b fdde01dc2faf4fb8a99b963a9de1ae9da620729545044b4ea54c312a977849f5 2d1f7d98208c44af0f49cdb9039466031b46e7fb149eb45d1e7f8849aae41c03 b0e8cf5b9f84b6a56d95eca40ad2ac9c1a75ebcfab3b8938a3c44745df6bfa93 0e3f58768be66e0e0fa3f158df167bf361c4e64db0af5e58094f165bb942892b 9d417a8389f2724c5f78b1db8fdc99759f820e72fdbc53e7e2ce0efc4c1538e6 18d59469bf630b38e04ba5ea6f6b4195f0dea57ecca8998100951e096583071b cab5302bf6f8d2e14333c524d7db45dda1e54e655d620dca68db2e5a306728b9 4724f151793b62cab2cfcc5500a15b498d7a5eeef4e918e515a418e50e040531 47190da0235215ebd4f3f5c3e8b428237bfd3d0710ef71a6a4a25e1bbae5dba2 8898fa04ab0ca4e704ad5dfe1278b8f392663186c4cdaad0ef5eac77c6041e14 e997856f44443fee8aabc2b8b213474754f81816038f0c2e4e8cd5adcac35e2e 705359442f20089fe6b4db5f4cc40c5ea2506734758477be00b61e7088660bea 26533fd93cfc0b294e29557f59eb6c869a0f911c8c2362541eb49503db226bc9 bc057b2f794bf78535a7517d2654d841963e525e72c7f007a2d1dfa0c8f6d23f 46ed7dc78a56f2c4d5b961a42f476a6a55ec5909360a6eea69f73aa627c7112b e902bbabc3a518873f6fc9a230bddca6e90560a904ba726ddf93ad42b20f34bf 3031b30bd6e78a462f387a58204da8af876add7a09454fafaac485cb952a2e87 9811d9bbcf2ba1e3bf1d18773ea7238dadec32a79f5c302317aa716831ca3ac6 5a283ed2e747fa3cf15eb65f4ac7d5ec5a197de3d4f51c05f9411b67f6db2d6a 7879a7eafe25c05f3d6b13a7e3ca59ffa00a3535263aaa2b29e9405e888f62ae 3b80bf3496bb2833b2d5f624d2849dc14877ed11f769f9d86ab6a1c1fc016fd9 2e0db33849e26147ae2cbdf6408acab59beb431b8d5694087bd2c7f48f84007d d16c690fef1c2ca013191f7527a724051fda04f1d65778c9d19e2fce8680ca17 61a38a6dd51a5bb31165c2584db375b2bf8ac60f35d08ffff799411bd84f500bff12e03f34434da924d86a648ee3b0bb502eebcfaafa4d1b34fcb3a5a2eb260e8132833d61642dcc3cde9a6044234d52e2bb4b503ba9467dbba4e4ca1d276709678900af1eeccd2d5ff428db0c94b9e92cac272b917fb085996c4d2a25157203df1fb1981ce79eb8c747df54c7e05cec6d01a468e4b683dbcdc9b192b7c74105bfec92ed2236c920503346d0c664bc57304a22c8133956d9c37f0e0e7ea6160658edf886fb43e0ac23c49328d45027e184935ffd3085428fe7cbf73827e34c0abe66b46e917af640f9a38480198dc48cc8e634d14036d83f28e34c83c931980089caf128a06e5c34be585fabd2dbe0fac4e2c0d15a50312b1ac66fc0bbd48e05305e58f638a85e8902fde9b7d027381643c5b4d20d070fab4428fb5e04004808d3e79ff186c92a684690e24915336419c44fdc9c3a4c9dc8cd76514290df1805a16cbb98c7226c4579d989bf4c51c79f6fc1b39b31e70c7b3742330f4f19e80c400839e54e6368ea00505a3c40b1dca39a9652a94b281f6c47e9a4c69b531e096f2d76c03d455c29edce9c1993009ff182e3bfd29a27f7127a78862523a84b02c90a2f263ce8896b544e79b6975b03096e18e146b56d1ec56299be86b86be90bb585054ddec98047dbef7ec98fd1da05ba8b0aefda75e9c692121445d3e0340acab89917c5e9ab376ab020d8536c779d3de9848fec334a82b515b2a61cd2f70a2419ed55c9ffa2a0943df7a8bf7fca2bdbe6a8473c8b2ffbd5860a1a692bda0fd9808e71bc2404cf82812607fcd1541cc05a7ee9b3d0fe89866b0c789a9c1304ccd552f29d20eea83bee715fe5c927b3417f5154668941a865e543b046581d09bf000cbcd001ac336eb486220de7dfb1f6133b6550672c140ced8afc8b5b280721e0085238c798b6bf3d11222284d1a8a6575dab3249f19ea6ba54b18468f902897a212c37c784dcbe3ae6e88ecc86b467bff24e964c0fb1847d6473a3bf320f8f3556f84e603de95aee0c970b6c1fce2c808fa644de848e8a65e969431f8d01728757b5da2e6ec518c057224164d89aba6f81f8559592df81e08938cf00150f148aac2ff4e3d5a82ca740d9a7448cacbff60a80e14e4d4346a14c3d368d8e0f572286380e5a03c4b23ea6c30ea4235550a1b7bc7e34ccb2dab612c6e8e1e00ce08576e32ab35f39f1c8afe3dccda6e8878200e2cb85cbe849f7532fad5cf80c91dd5783a987c75a82243dec3cc8b7794b4ed4ed283ef8795d5738d7344d8407d32a35d3053a70415f75605d4eb2a58cc0dca547b028ac896d1910dcf43f70072a7258966d124da949dfc7b23373326fd7db7f67ae9a4d26d38b42dd6360910d5b9f4528697ba91d646d8b95be96c41c42269b447d8c9d648fea317a7a0451058471d5ad35b21c1a67020a29708904e0d6588c4842af3b05d91b3edcfda2c509c4dc0e3b07dcbc2ca7c70a0821cf354dd19e28cdd23627e295f0b36f33168904d2f8fc8902e39802d2fd1127a03fcfee5d32483a40e229f8cc2d1a063cc56703c0f72318c738e6a926af2f232050fedd8e5d7d38113248007a87a6493eefd202a61fd80e684e936520887e069aa85f1f82c1ccf211892a296323cf2a7f2c3501333a264690448f980bc9e2646b1390090356eea8a63cb7be0def27757a4e2801bdbf9651d4e9e322cf51b7789273f768b73f7d79732e75ac1c57bf9520ba4b08a70c38b8d5b39a9bf20b3c99c2eaad809aaa873621262827ce548db817bda10aca03d568a91a96c39eb10d161c3ff5400d7f17eed7d9c4a0419eb1da566ae40c6598f8cf31701af66520a57387f90e2796f9e8948a4c275979ddfa2a8b4f6f0bb9243dab4f7cb99dd2eff33e797359158dfb61ed6ed465bd45c0a01c11f82f0749f0ec80b12c07bd64e6fe85141e7644027864cc378bc5478b5f93eb3167c2062a2dd0ea97b2856bb46ab4d217886fd24dd786c68f69a312a9159219c8530303b657af278a17f9183edff64aef72afe55ecb94b2a10918ea30aba1fb80c6e20164dad58412b6f16692971781025f28a223411dfa51b1193687dbe61c49f52b06a40250add41c553684f101e3e52c9678ea545c0dbec25c1930736f619ef8100b5b2937cff4b1c592c615a256b0593611b7b6f0c34ade189471b2242560ed730e456417f3cfe4c4a2d5d9a202b3de6cd144ab600e7d7533a0c91bcb932d99c1010e8bb2d45df6652424611c6028781d89d8ada119445c90e1080d7a5a491cdc0cf2c003b63a45b0c75e5f43522ad444c16b394421db8111d93fb51de4a1214c013bad642696efb1c577ea00776b5d7e7a738a1c2f14233b521e52f6558e85ce091d61cde499b57438347e577b0aa26a1a896d3393fa221f92c8ed01e0176ac505fa867cd2f7d4db16614aca6228840db2b3eb228594efa65e6bd7c0247fe279024aedddb64d2f55a17f34642e5b538bcfc774b932eee7cce242a07cfc26e61d0c986fcb216db7f98c5bff0270f090559d39d478b374884d3aad27bd403368850e01fa7186f6828300c7a6b1ed6bce5d0bcaf0655b80fd71d94b5b6cdacb256109e0a361fbde3e98bdb34ae1015847256a9bd268a759b1b40b320dc1b9f88f2e0ea40f7a30e1f595865722a15c87cbfd6f3af34ab71f1f9417ab5296bca6f5490c30edbf2c10524dfd00d81353335d6c043835c04050cfc60cbde6ae3479a8b301e248b21a6fb9e325190af889cd9912c190b154fd1d4fc18123609c8ee0d6bc0c6d111a9365840e98a37d2b854fa44bab2867aef24ae8a56893ae66567cf1570a5cb8894550770ba414b9c7ca2eef91eccc7ddd1f65086bd12af95f6a26b2700ad3ab64fdf564b36fde19aeafb53506657011a16a11146cbafb7e9019f9958b0599b4da9f43d2e3abbe1a2482f7a3ffd7c35ed9b8aaaf936d45a069fd1f39a60ff6e65b6501866aae35bfef8b7f6f96e73419d306e802cd90dc8a005fbe8fc40afdf83729f9551ec10c8016f601122a645166f31cf4a93ba9e8ac8aca4f9e1f0230e0b68bcf4e763ef369e333ad4f2ad1e3ac16f8663b5bf5fbf8b57b1c52ce0fe5c39cd508aa8cb3689bb3978e560a714880d2cf87551313c776e4d70a5e6b0ba5515aa7d298c5090963971dff6d5212d1f321a64b72ee45685a93768ab49f0218d0a42b1d09c68226eb01c346c8159a60e1af2bbef8e17a0a02c6cb6343bf0c12c6f08688745a87ae1318462799bf8bca9bc50e4d96f47ff6bbdcc783ffbe042686d07a79e8b9f07d5bda583b013a35bee276f66fdb720fbf006d0719d7050c232cd184fc92d4520adc81fc1f95b791d43460a34daed1058b4384c3afc5f606f004c88723274e99d56b78b58079492147eb65bc8d9fa3f78de545a252bdec06e050dfa1a15da72393b85f2f4772674bc8db49217ad85f7cfa52b376b261860431539e57f94038e4c1e503d9ae8d898763f54ef6497c18101c49cff55309b60a674f11563e2baea75e64b29ace682f1b8441e885e01d04df45ab027a25f0710db4a5d2832ee17122993f02d0d949b612d6844a11d1c43f03b7f95e8cc614be0d7b02aedba99cee6b7ad6879fa269f5d35603c144fa1efeaf1dcb42a507e47303c9cde0bf33e8fc47ff7460a64c6a3d6b24580d00eb1456af35229af8c270e707f6d4e297439576c484e7b93e505b39e659b58ee9e798cc9f545e7cff336ebc004f487b440cd2418bcd74200e9efed4b2bc3c6d7ea450b6affaac0a7821ec5c0a9c1b9f0584ccaab599d7eacbb845a722a325e4d5c6d2305f9c679af3b8db0e05c81d247fbd792eef53f987ccab9d16c2b5b171ec8b38adcaf8b080ed79ad060251ab9709c410d417ba17af8a784113d6c79000f3e48e28d6b50af7a70a99db05dc640a319036be9cf8f2591abbf05acad0c63b613c78f0925136bad8872f0d0db91fed01ffd559282ae0ba0497f5b6d5a5cb81bd01f48cd7a341a17a9ab4390f061914376bb9d3a33a83fa8f7d0947aa2829193805d23091edcaf511cdaa8f021351d039168722f35f77908a5a55982b36dfdc666a5eed1c9e274d624b77d107ea6d4d0c9b19cf522823354271cf958f3424d5bbb0a2b983687632a51110c70c4a43049e602025bcfa703d254673dba46ce5d119b69a90f7a4040242b451a30e1100ab01d2f4e9e089dff1831e43070c7e8c782f3eb887256de06f33c1b9a30e56edc291efc475fe6ef774240f6f305b727d76988117c60daf0a2194b9538b0376bee5c41523c7cecfa2f556c21e5597415e9e85eff8a9d4a78ad1a03940a30585c4634edb7a28417594ca7bfbba50e4f1afcff04792a7ce4874976a3187d506285ed21fe847a51b281b2ff17c456dc86b63a5fc246fa939a8b6631c8c20a80f7ff24f6a16b171264423ac7c98f99ffc39f34f30de7df822d6ec4147e03a50025ffe44b3b914c8e1cd417dab74f58f41af27b9d25227122abd86eb5fa57ef70622b34fcc8b624360e71ba75a06fd91d84c099053ccefdbe4f300c9bf5ee20e0648e658e508472449457b48f66abe5dca9f309af97856931a2ef4c4a0f090790ca3cbb8916e39b8d1b4aeb0cdd5162afd51d42fb685bdf32eb3c0d2e4ee45450969e7f489cbc1bf5268c5410df6956296b4e28003011c0d64798f1f4aa81bfd0c7dd7a18ccab5c9a00f3a6b5ddf5c67b3e4563d2610b3db8e7726c56914cd97054dddbde4b43f85ab2972ed6b10f70c933fda6cfb390d3f62c3f1be77a3f5ed08a44acc1a6eb4aef795ebca1607bc06884a631f8b9c58a1084aea73d87e669d04f7ae5552f812cfec53311bebf6cb3374d18b76b457b732d9b56b0998d2da2f0cc48b222ae1725f2f38baf91daa8c5d017d2370c6881a746921d3e9ae69b81f0ad84bc20192c98445bf14b7db1f1a2a274d07abbef51b197a640e9c8ba8412d0fcf9ae2c84d1f27193db7b5b7cf535a96031f77a8521cca2f0e1b241c28caf102a1d3a36e840b9bcfe88306d75684353100312d0419191bb63710ec3e0a2e13055ac4de9faf6a680fb803f476dfdb5ec86a1008a478bdeb3fe8a1cc4bb8d67c0b83e36411b5a5026765c003071c730f384dba291ed7ac244defc1e5eb26ea4305bf0a6fe14ffdfe1c75556a35fc9782589dc336d6169136c7b32aba02fc46c90d3603c63f85bb92d9fb336c174ac5c97693b5f792daad2ff95dc634b088e6710c89f0b14c9e578a5a723dfc39923e8b4502eda852c59dd943482b7d98d952950b46e0bb201a6c12eb167be411f3c6f5cdb9580ec985881c5f9780e827a4e52008605a0017658d68a88a6723e8e5b47dc4ee9a112c450ee54ceaea62e134dd190fc239b17a39e611a5bb99368efe1fa97bc4d5b41b88e9ae69eeca43e9593ea40b7601b479ec9563e4a4a475f18a730cffffcd3548a2777433d0dda14ad54709076b6ebb686a925daae646ef71694d682715ba159495454f9fcbb603a0fabd52061ae289ac7a46ecf889c3904f6be0e71c5b5702abe6b607737ada649cc75d2e0b8cad0924861308b3ce555de1c5895382d9c011737c3ad248e30ef3f6ef59c403abffeff41b988173ae8fc28093d5d39005e3499c02817bcf6c3cf7ad00025a0bdaa5d3df7cf411964ea0d1d4243fd5c1e8db01b7bad864898274c1ed40208c00d433f51b1a61e6354cdfa1db47d41d4c1e3112608e1fdfdb3247b00d88992c05a916e676e5238158e3926970a7ce4943b9d75a53549df7fe7067cdb34727dc0c2c001d56983b21dd9f9b81419e6ac1abea64de178a89d108045c7a5671a81f0880ebb72b0de2c0965edf92782c0ea816152827e03b1823e97bb68d010b29660999e545b3d649cac8f60f41497ae676aca8376462caadcd778e9d642d7cde5503b27c4aab65ed769a67288c77323c98f3f2d1950ae501bf0e27439ad839cb2a07b219dcb3c1885ae4540c8132bd01fe786ca642f4b380da36597bd0d4524d4006da9840b46ce5c75510d72eb1b77a45ade86d3aeeaf8dfb95c6525c1759ddcb09564217c8eb8693e71799664c0ae95f05ba01cad81e87f39fb0dbe27958b052080c1a39e535aecd50f327304c674fa2a68ef926542ab8280cc4c0ba8c90eaed043f997864d1cb0d66fb85ced02a10a23eea4b65775782636ffccff20cdd131702a93feb3667038a595e3fe5aa9a88194b25e153c74b56124262338591e0dd9905f17eb24218f985c1d0c9c0c681439eb861d0010cb2fc4854ae1e1128160d8e0d6defa0c629a0bb34087fe84d35bc56b5f4bb490d8d7d1da9c1bdf47849f9bb0e5bd1dd1861f28e9be495b6204c3a361c65b2761a1053dae635b7755319e80302e9045c9834b9d6d88221c73576f1eea1652c85071896e4eb5bf984cceafa5206fc1927d362342c2806d885ae40d02b0440a3897b7c6948429408bd6ed321120ef9daa4d7eaf2e440e002df81ae8f8767546ead8e6bdca085af1a8eebf0af91075d0d28fac115b4866a00229fa2bcdae1bf9d9132f68a1a433c38d789d7363507408658806e7d3a39da75553190b88f789bd0a4c3611626f2e07e99063259760b4e6bfaf0f9214d863b7c43c8a03090135965f5fb4db74aabbef2001e0725e10a0e130d05581723d0b8a336ffbcd000a93d4b11bc2db7b9ed64716e0aa4419203f07e6c4f7a3d2d2dd0d3af81a8265b73cb887fc92bd49f76a42dc992cab0950cedede9b7384803ddcc92c59fbc9ec958210e2ae434855423d2d4cd38a33ff00b7adba3536c4019d8943600813330b405cfa7fd9fe863c5a9b5097396f70b410c532320cf08d3798f88122b5f1f3baa4c32d6d72cfd1397670e5c62d82348f70ce9ead649cad5cd2a6cc6f589e868c3ac8683723377e8ed7930e202a35b5d52031022525e3051b844cf9a58d58ba54d936b65c0ed5cfd7482c771c2abf5fb5808284cc5206ca5754bf290edcfe40eebc92f1ef6df11d65760705ef1b5883a8206ec993655a5e1423ba7a36e9544f317d089b059b7bcd6822c99c8338bb6cb090350457ee9d0e05b57379a73e2e9983ada7cb00930ee90d2e8f0381c70d6ce390918afa6db7ac572d0d0c8b8c2903cc43b56ce33240e0d48db5d610bd3954b9406c592cbc1858b7dbc96856605004dbb7acf5707ec7c34dbdee028a456b36c390ffe6d4f43f406d55b119d8f01eb56ba3b1fea194cf245919f431ac703f6ba16025ce8f822117f9b9e984e20061a4e41ca72a9273106c22ec197ac4a7dc4711e09687dfffe7740b0e01a10bb96f9321e36b89fa1f35920a5c927b9d1344e73740feb8e79f44bd52591b72e07b9fec70ef3cc844b6dc267648591221964fc19b40ce8314709b74213a6af5d1340808364e3b60af034dcaa148982101bee2f428c0e8ad1e3ec035bea3a4a43caa7de9dd175a19aad97b017977a7dca43a31c60c50359820833f911e912f12b67fe2ae6f7dd2451c652dcf41cb3b6b5db96a0b65a0808a159fb21a3e877379e6fdfff945aa4d30c4551c44c18887cc586ab66c402030829b961e60dc59b74cd6d788ba6a59bbf83ed228554bcc873efbb8cb59dc307fd664f62ecbf5838d7dbc246a41e90fb4d8ba271bf2a2911e6f09dcfee5ee808519de922d50444e04dcc2079f6ac52d9a86efe267ed71c26e1c85d7147037b04b625ea06ea8ee9613539296a46cc02ad97e8623e6693ae8dfc8f7110b1197004decbf8b48d50ca0272c655bb34ccc18cee976bbd0a35266c4819276b097070008deca6bbe8e0ea6b1ec1178e48e7beed2b37a028baf5e040927af3f681a0f58074885688e46175c0e5709ee9048f5a767063d994ea8918b2ecfc637142b76e00c63a7e4e01d494dfa73f830e5c247c1f1c7f591e81eafff1bba572c79e883b0c2047ca05c903808d92f1fa2e19ed1b8a1ef0e8582d8af9b55cd5f636d9d1820f0104a571317a1683109bcb4ddc28e39f64ccd54ff95cc2c0f34e1f71aab142068f4fd65c4f6df25b257e1dfaf445789d38a2ac83bd961d5392e75eb6605dc500f04b65d8e0aff7b0164ff0705aba0030c17a6424f83db71a5dde5b8ffe7c580f39e2dab17eec81bf0f2a23c8576ab0700efc2ee711867459a00cb3459768d0037c18de8b55717b955d138ef8f7be82eed9543dc38873f505074ad0eb4b86ed065246a75831d40ea73d8316e6f435f4c115e9aae470b7d0703142f3db34ae4a0eeccb29472500d9fa7a0b3deacd26fd9bd0256ca7d08ac4b841b3238baa278905382032e52e58f9d38b485d94f25ab0c9c03ba5644eddae2c1781caf28790df0962f883d278b00a76124d0e7ad068a44e16af4b7765272c67d7a7461c3021ec067957ce294f98b3b2e003ed6f4a6430ec293936fa5ad0f46a74e84b46533b540325748d5ab4885d01723b18288b291267571cfab053b6df70923b508f0dee780e6970d99120108765888bc88e1fab3859d6f2f5e8097705e69b205c0f9d941e0d933c92ab8f45cb4b1f9f6838a77c37d3c89aa4b383770c13af2fccb437cc1f00529766fe661e91c00cb53e986e7f2687eb4f5b1cd5d90a265af1acdadd08fd06a895dbf7c7e51bb6b9c35d1f903d9baa13fdb859ca4f484a49ad50dd6df28b053f50bbad9cea4f309463fb013a6d30fa287d1849980e444605d722ba18db670d080b64b1adf3cd8c655244177920ad3b1154b1ead7dd1ce14ffdbbf4ed782805ffc78efc9abd979f0bcc17bc1f84694703fdacf0ddd904cf69cdb35f115b330f002d22f87ac711c6c50f68367220f253fcd71c553c3872c4999979ea23068306ea1999ad5dcfc9080986896649a49833de60c2c6718ede4c7d6f645f2e6081067e3bce8f395ad5bc44e9f479ee95c5a48c8101ea5305a6e2674018d113a07104233d33a01889af24da08babcbde554c1f6f6603c63fff163bff7a8cb0cd57d016a3e24c42321b59f7c0113cdeda199a4cb815fb6d8af154065cff67976a67f0a53eac37510161f36310c4a8245033f39e00ff8541ac768cf2c516166e7ce5d02c6f31a5c9a8d44be3feeac2c74dbbcfcfd85b50cb74c00114ea0c50ee662320b6ebeb70c8029bae8772dd311bb5461efbc56b47057cc8f1ab7b20f70ab15a7016440e80f385ae79ad50447e1b11040834bc6712fe4ab3dd3aceaf117f02be80418705142b99073bc747f61622653f1dc15024e05ee70bd08a5dbf9f5838dc80f6f9ab2bbd7e8f70c4729de313f315ae2b67bda03ab54cb8eee3e0b44b348750a0cc69ac95b17cc96a128796e5246a1c66b0b0d749793cc37c17987ffcdf6ea0d66f3403f3779707ce9ed19f436a27f97c403f81b6d596b81e3facc3f3ad2a60a927a05ece1d1b06c9071be012db017aeb9de8d2d72f01d6919bbc7ca41e5ca08e259d36122ea279984774c5d4c7c836ba261c0b17933d92b23b84ce9c612170126895d5ced98daec83bb946f1dd284bb849f80eecbd81b0c05831a90fb364a059aa461ee4ad3b2b056dbab48cd8b0e122165230abb33c04e164e117c7a10bd0ac10ace3b4419b5825eb638e233ac6b730a957de4782bb5a7fa4aca83d9ca7409d26036f2dbfd4049dcc59579e8d0e335533bd8ca5ba4d442ec156bf25abd94030d7b16d9046faf0018fd042424f222797a9861e74053db1280cc074eec218e0756fbde321b1b6a6d4e3cfe8abf983b0de1c08cc62d6f72a8196a65025c227008dc1af9e458e665433f3fa5bb5ca8d9181f883437ffb3ba0b122e6b93bedc49074728590ba626035fca0deee2beb1336e12a8bde03330700d0e7de485886a070900b6337b34262db6505d563f19d1c71200595045c0547b0c11c16a2374f265027e4d06a4e55f45be75e2c9c8235b2f6ef22171c8661caecf6cef55a467050202a3a023885ad8218fb4d27f7b2e30418a489ea62d90ff8f4ee3150b3060c067077ca08c50ea01b7555e948325513a3b2482472c483ad02a41043b27e1809c07043d4b39800bcf180636bcb6e4a25d03efb251286cd6bfc93ef0bc0454de8e180d false +check_ring_signature 8d6d2be44897e1521be30015615f9e8be8aa1d029d11fc1b3ac5f162f5cfebdb 71a7c6320d819d428e34b676356456e78f99c7453955d957a60c225e0dcc096c 56 c73a03632eb08bbc229d993ab8fa5df4aac6fd4a1e9d76b1169a61db54e2c745 9169b50f6deb472f55e03e2e452f757f55f439a5207411b90e03aa119950d5fa a3801dcd7ae4ce268053e193f5a299787759f08f866b9bae51ee5a427045b1d7 412209a1cf868f63a903b4bd7cbdf8bd2106263bde74ef0cb0369498f2cce383 5ab0f50bf7ed69b5f232c9c96601cddb087f3df9b1202958c01a4d6ac8e57846 8bbb91806bed8c48ba4688bd559428181b578409eb242f9a761622937a6a366c 6314665af26151a83e1064c0549464de8b5f4d7e4e15af2d30ccc2a4cd10b654 0a81d727be5acddf91a2956e833ae9b205ad409be3fab9926a342f6f71c2c64b 8d9b984a3ca5efecc8c733e687a7ee6374532560ee221881d7d3b221cec79df6 3233f9b8c7b21dcbfaa24a6f7051b6fdd1228fcbc40ecf29b16b0e31c13db337 9583c014b5651e6ea68157c231e621958335511437b37870a6f129c3a8665a19 05deec48669766da17139f4a4a286aa7fc51b87abb0d0ec4af955d434bc3c25c 2e7d7ee6e556eb14feedee8a502ae49aad0b41dd39cf4fecde05965fe3e3c69c 2e1ec966bdd6af4f16a84ca3ee129e91d237c050f8da7c08ad737125818dc7f3 842f9026c9c4c64410734cca5abf509a76a6322f670918bb17ba3f888dbec2fa 710235bdd1937c7818002771c374d06e0d29fefa678cbbee953152dfb4704f53 b5e0fcd6944753e50d38f81ad595df265d2a8d260b7de939a6b5240d377b1e1d e9d4999f3c694cdb5f0c77054c44d69fbf0203a9ce0ccb41ee3e7467263c1ea9 eefb6c8e248e59dba0539d3355a25c998c0fd7c23af9c8221be2cb7a18068d99 8d3a8794b8dc11df53844607ec1f2ffdc949bbd0da3a2733229e7523e74fbcc5 1176744259263a868a37c45b601ecc32ad26f672dc19e9c1a08cba18abafe3ea eebbd914f30b3abef93d8dae9f86dabb904d7bb5702c79b8fb26b9851bde88d2 e068326a79cc57d7deb3efe67dcaf3d0278c53157322da79108c824d2924ce3d 89836a4ec863be08cdfe646116250c9ff0e8b11d64aeb0e58281f7667f609fd3 51fb80f161e2460c37a5ec64d88de90e22105848e2ead1de9590351c99a7f66f a66ab5bea4ed771f21397286e6293edecbc0cf9e0f72c7ac32388adbe23e38d3 7744c9c52e1c9221430a7c582d6390b68e3cecb341f5700fe8d0684dcae98eed 7b831ec359f560f4508a5297f05b3d662b5970ca4237a6c2309a198fa2181956 37afa7cf08881907cf7277176d268a7efe031247e694ec8a5fae57637863eadc 231b267bfded4f3ffc985cc32c577898ff20f2857d5f0404e616bb109d060816 b96e403d84062c54e20d6b4071e5e4dac59d45aea3121e62c3b897b838d4557d 6f1f1267307a205b89b3ccdd2e24cc0b4ebb4cad4be8c4cbe6f0db0f88d5b3c4 30fc53d76b63e056bc2ab096d02f4869ad2d0736ce31d4761eb99ad45c031c8c 03dba861d6166af4a0438d87550a30ca62ebcd77fd94decad76e91ba100e9ce0 4b139093ae44ab9f8913a64b118927c7461fdef467ff3d50fd7ee3f913ca023e f8e2bb6501a984347a58e1fc66b79d19173fa190847e58d6c1267cee4f71b4cd 3073502fa7a09fb536c5ad9667663a811d3981a129261d540dc6cfea7d36ec5e c834ddd6091357184d56f3b0b9ad29a387f16abbbae18374e5ad68516b00ed18 e166ead15e3c8b0bd5fefc648a7a3f3a173948c00f796cb22feec91cef772527 016148f6e8ea0156adc9bde8b88064cd0b2cb5032382d1b661f7d94ce221d1be cb1918c4a756ebe8b2929ff0210992120d591409dc3dda7cecb2b7945c47184e 8e324bd163df227e7fa68e00f8d1de4e375fe1983962de441b3ee32322f2ed05 1403a5ddda556250514b3fa539be9e9b4e06f69b0be972921e8cc8e92752dc35 0575d514a1a663cd180300b08a0b65411e3952cabbe253e031c9476d6a5aa701 691045b9528b6bb122428554e96e0075518dcebfa22a8b8a715b1b1f8c42e680 fa781545b42529ff982b3db0f7a9942db59625cce28f3a4d62f89a2453feb4fe adc6da5be19cb601570eec9bd0abfc96c4ebbf78817d1cb0db62eed149c8accd 58c5bbb8916a1c4afd554c9aa3f9e57e4f9f6d4549f63a272e13368e9f7b2012 39241ac76b27f42c82b883c2946a21e3007a1f3ac3a86dca947c97390eb54df0 7f5d865d18feec6339d65f2d5e7895fbf98a72b5862acb9b335a5f980b798035 5b573e428e769cdd502599834f4c9678d0ba778f2491ac93694c910d7380b7e4 0587ec65b97e32df5778abef65fe82724a65833c2199607f86b8b950a68e1d5c bd9ada8225857babb7f13ef19f94374a424e0c1df1aaa8aa2be5a66bb9a20c0d 0d4ceac3757929380bb136a699c81b9a973b8106a999ac18b4223f8ae64574ef 74fec52351432cc70039a1e806a059f3bba8fd39d27d3ee8f5e934645b9f522e d9d4cf99213cbce323259af81e292af7e61b2a39040b07b1ab6285ba5b75af86 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 false +check_ring_signature 5a74e5137be64a71609a18283430ec626f918e8dcc6817e4cf9ae59089f56113 879499a6ae5750eb6e56005330d2d0a769e67b66de06a274bb84b75d5dc52e1b 4 5485e31e4b9f4d17efcfb36ed93102c2ab2f7aec79dcb383543f4bd5bbe2bf55 392d383236a3e10ec072eb5d658bccd718c73f86fd0e2535b0abf5f74c2ba5a6 955404f655439ad9f8601300749ee0385ad5a08315472624ef8e94bb3ba70d8b c9dbe9925bd51a45dec1db26275a653149104474de360bf596c2b10d667fb10b 0f9f8d6e9e8c2e4c8bc4c9364e3c136ac19a2b1a9b5450c3c2439cd86540bebf7c614f689d07014ae73a4cef3ab73c2a847e6091264e8ad97c3b88f133df23b737b00d764dec41c259cd96a746a16d06e33adc72f32e69d5905394179d37a60d03aa45f0938c0b84254536f1c8ab48d2852f09af5a44259c03101ff6497359f18c0a96aa2f864eef993092124e7e72589ca49b0d3ede994d46f9eaca71f1810f3681d91e24895573aabf3c26159db25db0609b4836793a699690e6d0d04a5f0396ff9a309e6ffb399ba6124358a3c553af62dfe40e5140c30c04c2d02a603600959cb702d6884b9e4ee1a7e6a55a405755c7cf66b55902094e21633d0ad8f402 false +check_ring_signature 416447b615d74041587c83c7bcd22170a5b75982bf8131c67e4dafd9cd4ffeb0 17e271485baaa53d44a201447f85e50d6c0fcc9135ca8676ce7afbba7d4aa5b3 4 307ebb2882dd25e7169f4d5b2f36e97dfc6dcd6ba613b275594140edaa912745 4bc97c8fa2632140ab3f24fcb8ed2b6421d67a746642fbe45d8a76d8c1b34d00 26d538a9cb110a3146655cc9a5cdc8f299f04872f1f0882c4d2b5436b0a6b722 b0f622cdcef8a16f8110d5a47799be6a1193a7f254689e157f75b47a1147c7c1 1e1d5d6e5ac64c6effdedadbf7fa80c7c969a640101ceff41ca550949564460ee4caf0b4ec13eede4642580ac00dc45241e8423ad684993f7efb231cc4431a0cb497aaa29a5c67fceed6ecbea35dbb80c177d587b5837315224df3014864210d15981cac99a37ca7af65021c4021952e328ebde9b13de2baff2a135ef35df706a2b3f67caea4248e45ba8bfdf6e8b04394db686b7b273938e989c3616cee09095fb733467b128d0ef10be40ef1f5aeaacacd373d833d735fa2d790e48cbb1e3452f0717e19dd95f8aaa741342f245de74abf94833eb0c26851f62eee9df1b1047e10c15801fb644c024fa37d8b5fc13811e4c5e6bf4dc88b5d23dce89144280d false +check_ring_signature f079f6209b34e51942ed166402bd142865450cc2f71e458791dcb7b13f5a8c8b 68a49e33e5aa0068febdc4d71943dc66fdacfcbfcd48591ba99588f25b88112b 2 9cba43da3312bf96b001798a6ddb377cdd0bd08bb0431348ae2153e3551a5c5b c7b82608ae3bf5d2977d0643b063b388e031030f7891eecd857cc335cc240410 4f43383f2ac01bdf60380da784cd7a5087807fd75914476cbced0d49af03f40284e332ee7ad9410cddfeffa78272c961f48d465ed0f225956e025640c3738b03a6d879c748264b71d95d5dccd581b09f287bdc715ed838b4ced3d4b59f95c20adbed4f2c55cc5af6b441d249e457919fe8fd63a60d47c3417f1b699495c8b40d false +check_ring_signature fcd5619225e091849d87754fe43abac5817bc05636f46bcbe16985de52f5c86b 5795066b848ea5dbe2f19cda70ea33fb71e1f542d3772f2605a2a24eea1b3342 2 6564fd1366169df2afedf4b93329d698042afb2d9aba22ad50c84406ecc9c791 a6a9ddf03310544409d8801f932b0827a93852d62fe5c5db926aa1e2d8b83dc1 1026b671a6ea82615ae17c6e3826838f6a0e0eeb061721931365eae44e95a40f3d193c88e86323407bf056bdcb4c42c1116674e1864266ad62a432bfd22f760eb156e6989a83fd7d1c34ea58c71c14f86c0fa84b66a45a45956f503316c5f50c8123517147499c8850a8ce387d9db0c38d0dce8e4f697dcae39c86d53f3dd708 true +check_ring_signature b64c8c0b526fd3d00b1107148ffdadbf1db04c9858d4a8dce37d941dfff88e53 dbc2f47a2a84f00a84b44400d4bd7a4371f9410dbe85173e39129d5ae7c93ab4 47 7246efc7036251bf59bb78ea4b5ad2332094e4828d13d24b762d5f79ff2f43a5 16e42e91ad9353ee6813a081d2e558d250866009fdb427dd072aeae745f982e6 73254cfc55e04dab34f02e02dbbcf92b480d4cefa1f6e2ed88a10bc2189a39d6 5dc92fb547acb67b963c2edcca3cd3681758268a359796bf63bec5601158645e 42d761626c20c299d4fa4178d88a64df665bfabcc991e5ccd62cd3b3c13cfb41 194c944989211a06a5e85300675a9d254209a0cc38e4301d66d9e559d4a9b687 37671c338af0e07a9a234af3f0c0a692d93363d7f6d5ce65716b744258e962ac d87bf44222625b092df38a8afe3f91dea09730a18357a238766c3db0bba04ca9 8187c37b0054ab9ccbbbc032f3c70466b5818b1862fe8e41d3b0d65b3419a298 31df4d13f7c6d99ecf314064205ef56327793436da9a0574300e413e4f3b5b88 1d54cba4ab9018effd2cc1686744e72e2e74680a5c0365cd8397c00e39fd3af2 d3a3625f5528a423ff5810124806f5ef7f0d9b82f69422fd070a884f69058d2e 5afac695a6258e1815928189838b712772bdf8dccae63b1dbd8f714e4cf5e761 86b091303818a88aef1d06a5749cabc7cfadc871dac827f8e4f77cf43520995f 7a630733245568575071253b1a36c15e12615fb66cf4ae4719e1508f01b34772 693e927bc99482c2ff26ac56a29398c9da3d3ab53f060c688349b9f9e724b648 d6ed246c7a92290318475bd82a6ff2ec0ab3889b75133b90f89b8820926fa50c 9ac3e2b8269a92c436234c1ab564b3bb1c2317df06646fd550015f34436d89d5 c6336cac954542a1bded68a691770b136030dde116288f1826164fed14606653 94662197b1d245771edd2528ad303c784e4fbf1f5e3a963e11af8372df52b105 ee60e2d18ac31580906839f3d1a47a99b7213d97ba443a7e3ddd69386ef2ccf8 f2290c3f37828437f114e79006189be6eae57d3901f4ff80eee8c095e08e2808 ced01f0b05275199b4d4edbecf8979e135577080532f3c54b0d8e2d306c68532 f8a2609dfc62431e17fb6b6469f743b7b949987dba461cefcf64ea3be34ca213 102410a9fee1e66600a8c8f0098bcb351d4df0fb0cc56ef5bba2bac0a09bfa5d 7036744b1970e3a4485995a739d032dc7835009641c035f3afea6ec652e627c6 4adc80e081c2b4283206682b5c4906c57e904b45ab275a3ff59da88c4ca246a5 092e478abfa1dc949edde7986b9c739e221bcf52f56ed1f9d1dd58cfddf7f68a 56ea63a1faa9819461633b08e26ca22c489c48ba47d29dae99c7986bc84f1087 a5f0e8b17afe456fdca89cc2f49f041494a57ad3175d1c67983a7ff1adc28991 c519d88352a0e94915288df367d91db802ecf85aa7f68bd0b09e09f2e5540be5 c3a474db2ec4435867bbd2e5ab817aff5cf7bac74a63333c4992d71a3315e4e3 e1a080b2f0877dbd80ec2ef9593047e8007c9ab8ecc34e633313b0c3a4f95319 da80de2766b31b4cd2268b82fa5bd6decff58e4c041e729f105a74c1ec30d956 671d6ea27904bf48178f78f0638744a06139afb67b8513ebe75be5597e278910 74374abc3f371937efccf41bce7b03f36cb1f69800a978a244b1962510429332 df9ef2563561eabf19520590fe10214f3266b627b29916018d76f1ea1c19e664 3fcf1804e24a5f244d8486720c394ab96a7e0b49a77a4b804c74d21df1b53335 8bdf390c3b333ffe9f40d76fe58b62066966436018cecdbd0e6b8bab8e7035e6 f33f7363fca8ac00dbf3a4e57136e4ef7bea767a1962e7068aaf49e3fb033df1 0264316e8abaca6c94496b77365a795b896e402cf490215eb3697819af78b30e 3e2444b799ef361d871986f320e2abd3e713e0239f7e2c0e85b7399768bf7338 3f0ac50eed0da7d6b32213c7d2251f4e65f225656e202bf1dd059bfd9f0058fe c00b656255ce74e5183757cc36b3cf7fdb2b51e443ad2452d32a4ede74586820 5c62c3a00b362c0ab7310605550ece9c0a1fe32799e3649cc533f15ed2c431fb 2539202af4e5dd64fcab4630b3ddd16a1359e3d19da47334e258b9acb8c24eb3 d6183f0adbcd02d9b8824ee0ce5e58f5dca8876a2bb4d3e5bf53754ac7c3e1a2 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 false +check_ring_signature ef2ef2789c3411f400106dce54ac25b8d381d8e70ea165234fc9216d664190b2 0b6f960f3a615debb9814e8030675d4fce622f7bcc2a6f6386b96effeff89dd9 37 94a5d42c4fb62b1b55ec7ab4128887b5b5c568fffbfb2b06c275a1a1b4465d5a f35c26053bbe35631a2920a68424991aae4157e6a8441b331da42fa4407216ad d0cd249b0ddf98112f15fe8123fc565d41e1c7a2f538933d2c33f64074f2be84 8142adfea19c6cbddd6bcc24024fdea70313b4c556b94c962b8845597e4605a2 93b7e37a0cc6e6e9052914ffb80249d6322b377e5463636084274325a9f15e43 e92bdac610c9b1dcf43be982264d3dac4bc10dff109cb2975afc87fc3bb137cd 6a5d5113f1ec3979898918423d09e80d3ee98f48f821b963a5abd63de1ce2ded f44f2a54bc21f67655c80066e6f7ef1aec55eea195044a0b694619f9deb4b709 e55b07b147db8d27c9c46f595a2ab7b91306db8138f8a84937eb2a14df6a0ea8 d1c166f0e28277630a19f1dcde59fd4e3ef9ee0df1124a189cf0cc9fb2616791 18d78e373a2efa6e9c7c6f8191e6fb864271ea19b7331a1f112c87f465a96af1 9773dfa4cb9dd2bf3c75a9dea8a7ae46c127654ed3cf9f7e77b33366af29bc18 6327b452c0e9cb6681ef7007866d758d3fc741bcbebbb6c293e5c6e2f8bfb2af 21f2850dd4b722f9389af8a05caf3f37bfd14e2966673abdda2812bfb17f7bf4 a0fb5b11ec48e3535d1d52490d1fdf8715ac0a3021e4e19a73ee070814f12afd dc3bdc45153b06e34289b018c65e5a9d6f87aff9b449f3492c8ad0558c09ca9b 4abb82592795b8445efcbdd185dab0608cb40b9a1d44af9e89b5cc2a6c25fa8e bc1cd0f6cb6c3da98178db1fadf932651d47350c44bdf9fe7d9f99df1bb225bf 57ce61be3a1cc8727d2064a8e2d2df4ac2414684f570b25d1d618d50ee59bc71 70ebeca57163cae88d7a837652c829ff695387b4c7499b4127fa20a9fff6a989 a9c8e1ca0cd77a8ec1dfe0c1e93f6d1c1c529670da42e23a158cb6cde41ed23e 53656612b801ae542d916a48f3e4a2aced9a5dd81aff2843bdb912922b602bfd 1dee1983c43fe2dfba069176a08337e858474009cd0d9fb1957d050d8c7a91ac 38d3d22051fdc5046b4de6febdcdb422106f27b6e0118e388bc6d189927f6541 e268cdb5db5d2cd030768ded09b9510064298a60fea651edbf33f79205268a27 e4ec9d168583c917dfd365542ae6fca08b31a1b920f363c813315243708dca53 de182ecaec171b4d5777d0832d8d83d1ff2ce7616b4e9a9e758e0aca29763253 d06e493089c971bd235b8339c8ad72de6abe1ebf64d296c615a713d5ca2cccef 875f842e43e5d3bf7ac932ce2b0007df9beb272a24ec073efa9d41fe964c7276 b430315a5677af4b962c710ad2a6b2d2e685ec4b3a24e51121dcee9755e0bdc4 992d20d4592298e58ea5212f89ace7dbf78f6ccc72c112a8edfdd2979d69411e 1224d434c9c85f3d84718c53a4d7d3b884bc8c53925a5ae50667c87e5b791e7f 04a9573b57e73d3f2747f430ba54c210586e1f5d39773e6a29c0d05fb26aeb90 1e1e686dd7ef998ed1c50b964287adf5cbe59b89476357b5f0169b1339c44bd2 6d46da10d45898e8d0dd2a4e8de1093793404b9f2e875f3f1c066cb5fb73140b 82de964edc7ab1f0f0a0270b8b7624672bc30d671225551db84bb10bb4624f36 9238e1fa4b18d7e3810a6603e86204391553812513daaf2a0217b06f66239877 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 true +check_ring_signature 07e0b77a81c9d0ef566a3cd7ded0fc19a334e6abea7fcc9c54a3fe0f95bc9877 39a9f896f176bc9c2bd473a72ddaa25d4238c0606ec4009b5222458333c892af 98 e620a165f18577520be77e4bd2cebbb174b13019bf307b5abeb2169e743623f4 bb9e30f7125887e71d97dfa98a97597b7786ec633029419a0e35cc8327aecefc 1c1d065649e7bbe2101bebafc8c3b731814dd6bc3743df89d6b9720cc34e9fe4 b795355040fced71226e407e9a10163219cb08f1fadb094a0fc0b5447551d7a6 8f5801e4e3951ff20de26c90c8dd0102a36aa1e51ed7900ea67c54bafab97110 c82407885765cae1c67a3bb8eaf26aae74490a591fa22a3260f5df6df88a53d3 534f00eaeacc0bca1ebdec65eeeb768ab1a93e50ba63541e839ab46c9845debb 8afcd54cbfc9abbeaa4e5e0b641642f8cb69bd49cf6642e88dca5cd25f77974c 0af2967464e048c64469cce88e57808fae42d72573fd5df4762a1b6b7de9be55 a771d15b2cc2614fcfd882b04d1964dc71826422620b21efbd655a478f2fcd9a be489a0f34728cf50bb4fd5b908737a4a4650eea4f64b198e74c6bbe1c4095dc 1801a14b84d4fbbb3d7efe44f867715c2b190abc6bce06a3fd2489e658756c67 ee7342043f8dd285241e25f49f2d48b11a193c8f6eef21e97c729006833383ec fc12abdd485b162e7308a328b4add880da72eb40fee745d9f14190d3586f0a84 2298501e4b82103b967f4f3949ea519eee34664a49e44c780b1d6767a01cf61f 6e5ccec6d88fc91f1b861ed693a70cad7646e539322e44806d8cbf4b530e0c24 181b58dde098bb7bdd70fdc43156b6d83a80b329d435b3b415aeff2263af127e f0e61de765317b14106500c7d34cb667c666b263f497137558519014ba231c8c ceb55912b41794bdfd0671d417d695c881700f4b023391296b67913ac72259a3 55270bbd2fdfcce81d45f551daa1182609d443f0256c768fdebaecb661ddf87c bd6a7cd055e3a448e47a939199599638434cb489771152a6f15ce4b812d539de 9476f699beab0d4cb6e324f0686b86e595be6fef895cfbea78cd65b68d39a2bd 817855b61bc00f7aca519912c5419740f72bc3e1a3d1e69d37f195e2672fb0b9 62e3adb144493344401a8b269b8cda2d609846691805d052f481ba705a334ee8 79830f99bb42486ddebeca917afe0214493788b650cd16c84c17ad78cd8ec646 967817e018084e34a320a0d7da9709231e8a7b2c48eb76247e75d895e4087121 d4c21932e6702d75678f0a8417b732598131ef727678afd8deb63805d532bcbd d41060e9d6e9567e3430a89c0ed5b1f748a7f736e356b418660f111ce41b5c00 47fbf33c9b06c3d65bf1991dfea4772c3bba94a7f384bcead40ed1c86268db27 a91b1dda91bc98a69533e5905308f338ff064da22d3244d88c1d0b1d006f068b 94d31b02cba0661b2611819d9ce0596dfc677edae4c8d8f9a47778e986ffb9e1 8b7ca82141c6bdfdb48f747864bbd6290adbeb3ae7f99fbb94d4ea249def8e48 a904b9c09f77a580c6e8e57223dc18c0463f9bb5be85dc65b03ff5334db809ad 526ddad2dea02f7b37bf266e59e6a495c4e2739900a0e95ed98e2c364248c3c3 fb657e3ea9b78fcd17395105e96ba5ec13f6a7369276edbbafe98057111a8d90 f1f5cdef6c852312b200b1b1f63530b4c629315efa055e7981395e18c45bb942 c077725bb00bdf3fdd4b49aa1b223a9ec3d4df64dd02a71d3c5fb07922c0e219 df07c7887e848d2ce9fc560f85167747a3021f063b57994bcbba600334596b9c 192007efc3d5a1a22bc8f3960b7870c364750157216432b96837c2f97327739a 35f76d80246b0f08a3306157f53e867051a8f87878d40d6a79e7ba410c46ab0f 29364ddfd4d1baac1d424d1b779022d6b7171ae7c4d2f8b6659383bd12fad045 5847e457799a42f06c9331e6881e2f94c31e30f53bffaa52edd4736a81c8f936 bd077921914f8f55e1a0b391287da07d5cc4a775438d2c1f2ddb28c94103d525 ac028ed3e60fad0729028e7c34fe06b7297de39c4c419be0cac2bbd3d7292e16 d1f2f8ebbae6d7f32df2e208c97d230f559d9f10e46071b33641ac1386466913 7f12380b702ae88bdf9fb3b60ac4d4909cc7a33f3e14d2f4254856f3e7017d1d c9de67ff7cff9c9a3e1b2b8251b4b458fadf6d872f6aa7f00b083ee8eb530104 3d30b8f635320a891cb510cccd028a4796709a343782dd5ccc2db51b294a9536 4375c8d368f9963a0e6822959fe87814945218aaf7804fd36c59618c3eb899f9 2f281631d7aa246f87a7fb6e5e060676fe69c40e4656acc02c282ea977bc0e24 af75a6daac726e4c30e507a5b957c84d6599c6dc936c4225e517c17aa63d553d 24dc7c1c3e92c4d669b7dbc7e57acaaa4bb28c061ecb6252b16d82129764fa7c 0f1611a587a3dc6b917d6a57a1cb5067595b12cdde7808178011e403a9bd21dc 9090c62bf7ecaf5ffeabe29de51b6189ab85a26ad2ef016c8f7722deaacddeeb 21b391d960724b6a204b17f56c0e19892ba6f280d803fcff15ae7d03ab34a5ec eaff9fc70f7a32e9fa19a1fa0f9e358a857588b2f61f234f97c84b5bf13c1fe6 1c6c009bff169f28fb2139748b0e85cc199bd45bf22cc1bdd2a4c9a7dfed6f38 3f5f5c51a3eb148e32552de1d2f4b16682edc9422c4a1785959a2d4d9a6a5caf 0a4d902123d5b9034d40b998a02d574f4608be1afa58f55ef076a5d07e9d3684 96f8f6983755f18f9287b21fcf6319313f525fa71b468144e568af262f5d4bc7 c3e3d920e0362b53d649e8cb6f04990406ef7d1e8d0d87ea04f265f79e372382 acec2e56b95bc8c6973daf789a758fd69e441bbd4f5ade7cd347f6133937c076 850304eb01de560c738476546b688aec580d86a877d9e95ff78eeb5cf1a6c638 b6d386baf61f059477d148f295993022c8bc7a1ddcf557b2513f8d487daf0ba8 c78c0b80f6158048b85655b5b42699198a9ed180f4a01de24e38a1d0d0fce4c9 8a9e03749e77b458568ffd77d9ef1e24d199d197b5b1d8f2321de90ab8b98f82 d9b9a2544c7730117b55654e3263be6019fd69fe538eb3f5d088f6856640812e c80f26a320a949ee36c2cae6354c5aace12b45190788b9e3e05b8899389c61a7 1f39fbe1e380bfc4a41aaa6c5093c2b4155040828f91bf48bbf8f54baefd53ea 3c12a84a8f8c52b379941846911554f8cbcf7f95a07f2483399cff84161f5299 85b4f1367f68f1822ffb66cdfbf43cab820d7750a956d17a30d0fa5e9e46c3be 954c107b92d3b2151b5ace042ec2638f3a28beff03e5f0ac56a44d74c6f49fa3 5dd69058fe58ae2f77ba23cdd00b871b50c87713c3d60679696836e6e037f3fb 93217a9b8c159388be1f07a001ae5b0059446383484343f314587dd757ead388 93992b452db2846d58aa72ea320dc1939e0c200cb3c325b402bde954035805de 682efbbeaf892713f87fe2db2c48fc71725038db6dcabfa2c2852ad0680d9f4b bf890f8a31d940e882319224d4acf8f99c4035fd022f7d9139d5acbe8990c0bd ecf09ea80a7962f2d192819ba641b6f6cbb655d7331ba58037e9133355625ac0 2ceb8d2907d3bb153e2c024ff1b18b0cc476c65b17291deb621d33949b3d73b4 cc8dccaa97982e052c226be60594dd93b92891275fc03590c604090ca11171e5 85f7a56f6aed6801b45ce17d32f8d5a7a39dc5f759aeb4eaa13fd67525f75c48 b705f2e22736a9d5c946e3544a9315af9b638fc036f9449a37e60b6718ac3ab5 9c184d1ddb8f660e9c96b8413f21e7a3511f59ad8449d393089e0dca6592d88d 512d2c06658b08f0869d616c2f531b3c9ffbd60d6b0992d22298ce14fd71fff2 63e7323a19b73d6ed32020387a3a30ff4d678a182723c2d4a0fc269f0aebc2cc bb4ae8021dcfab3842359830152e5c35a77154e779f2f51c73230cedaf046615 b66a8071e963c6c40aeb7a459cef29d5e1ccfe36ba1d2990d81448308a908618 70f1082ec8e9e344d27f4138dd702e9b4f2bc0eafdf0e76f47fbf794aa71ffd1 5bb87e3d548e528a807cfa38059503c6c0956764d9d3d95e4e3c26c98798133a efb2549635c389447e21349618d013c0bb352e8583cb18cc2de56bf0b88ca2d3 85425ff7db2c54c8983d260c155fec920b61b4ffc31aa3438907349c3b37d6fe c283b83a012da127e84874ce4554e51643f3c984553f0bda57fc7890d9c84dc3 36db331ae4eb55ac3c8b32b209e884cc35a05b0394cb34fa08495d8513076658 4c54a81c0d15b75475d6c276d30777f7c586c316edd7725281a2580018ab2f94 2ebf8e86343d1a5394e6d322c8c4e92ecc922ec0b5d73dec84888c69805c3356 a0547f37a5bc6e8eec700c671fcb117068297ce66f45a6a73fded49a9445b2ba d69d2ad975333617262c589993bcbb6592ac0258965c9fb921166b5816aa4126 0404c1220c529d06120943f599ddc15d35d218195eb3aa2edf930e3d960ce8f6 564d45b3e1f335759918b9ed78cafc619c5405b77cb9ee0ee961ad60c089350e9fffc69b64f3eaa52176f6f382181b8283a7aff6352367766f4e19419993f50d76e2f7c42693e393f4d2b2f9c7f7d61e65dfbf3fa4bfa674e6d1514b821ee602635df0985365f6aa70f8dca7d9fdcd9404755b15222c5cc6cbe3394aa0059d0873b959343c514442f1c2dd464e65dd7a35f87a68127d60372b103124fa47390309ed053f381c34a4ac027e233d6a824905ed95fd651166d46e8b3beaf8d3090714a496cb748b61ddc96d6f380e26621c29dd84d6ecd7b68ba61ba1ce49f9000a440c7bf529572940074f9926463c4294da45f6ecebaae65c892f7ec6a76d1400ca37ff84c4a7f610d10071a41ef9ae42c2747d14d89bb5773aa2a090a27cb00b56a14738dbf71aeb2c655f2aecad76ece17aa216cc68902e0544aa2fc42893015f321c8035d351c4f8ffffc235e4627a03c2e740229775321d58d67ad256ce058a370061dddd7bd5e9a554d92edc4e31f89f8f7d9ccbab8a268d0d33abf5600c02387e6fe82508771922ceb782d08cfb95e25f1bddc7e1ef6a096171f5fd3901a6a55fccb85e6b5f2bdf39f33f05bc3ad48b2eb3f2d6131f9b43843648e9370caa5d0ab3c6c071d1dbd036692332e9f76d790258cc7047ac48096b49848da605f6df47097a4c95e219ab6a738b29ecc0e838b468d66e11e167341bed84a4df0447915fe62290446718495e7b25989fa5e8b33f982aabd5ac6491813fbe6b980b04e4866ce7b2b48c597e5931e02cfbff8c355d940471fcdef2df9d655398ee0f618131d80df723f2ab73233bf06f32631025641fbba0e5cd12d350fd976a6f04036aafa5d6d30427a0ae3352dcf43476fff0a13e1e562e84745f853c64302b05364f21b89001ebfc423167ba164f0156088425a2b425bbd2bff421efd80acb0c3ac0913d06af6e6cb377369d2c9a5a024aee2b0458087600026717199a6f8904225c26b0cb7f1f4aa7cc0786c79dbe4c4ab92260fdfe9eceecefbbb68bd1760a327de83a708ad248d79c43d557e52fa39ce7ac0cd7e8349ee7daf6ec5910e4035f2ea5c22b234cad80a14780f40595c3ea05e6638fd97ab6815199056fc64706188baf8ade68dd0550cd480edc0b5cb7f521a78c22a31e6e0f7db41bb78f0a0d687dd9a976e9eff6d33506a6c2ac6319cc1e3907c17f250465c1ae101a2f3a0eeab54f3b65e462fa4b9ab38e30f34b51f7799d8f558a98641e11e7931e69750670e74b1c70c7c6490bce293f51804e4c97578151654fdbc95ff380857d58560aedad0a186fe54df5b98df662b197a1950b08bcf44900b98339369fbb77dc2407d89a4ba71bafaf28ebc098cec6aadebed2444ec373b8aa6bdf13558f95c11d0dfeec0f2cd86e013bb863b0648da6083464b7199f2797a96a79dd803c6a8a960ce5e7157903ecb33c76e71938466548d88273433993d02c7c7c8d5d54d57b340265a1f1c4b7bcec702c4823f6b2cb50618cba452f01f0e83f552ff02da1cdd700736c4e89a50c9b0d55cb9fd4f0733a339b036b7f8a909c0be58f6dab51c7c700b75c4ef862ae4e9e948ec4d93dbad389893bc3a3f15737ff069eee29a8ac9a03e4488ebcb85af7f1ba2fb042d1a35dbdf17bb590dd98fba97f7d704d4c4775016225f2870ec70aed79c3798ebf6e6f161416846ad448cd0f9f01e2823847dc0bc1686f5e4b83daf3b4b8501ad45cf1cd13a184f97c28c4433edc05f6148c910d86e71944e728429c035c9169f4bf5d4571e50ce146c1c0219a7eb1e6de7d620df3e68fe4db715d0f02ea8053a8a0dac329d8bf63281d901075ee5c70bb2ce3042e09048e54b14f7ffb260a7091cb2a549aebe1306a16748031ed600dcd87e209d4835373f9c42ee4325160625679065e9a0f1ece0f7231b7f741797c04cc8b028097dfabc7ba008a195b99dc5bf5facfbdffcfa48c09d6235d8b6f50b4d1e7082f9b134fbcec968a941666a9f55735563b192d396969a13e111cf239fe7afd005728675dc1d6a9e4c658cc342f58441b38bd85cc379bf6ab12cdf212710da704abb4470080c7d69cc391fc5d9507a1833f92f9a34c53a430c0de52d476c0af0f183624f88eeb7accc68519370efeddc38443ff72e6ae9faaac45dbd79c217f07c386e3d75b2f664c331968423d4b93e3ab5c88792241ed60bfcf9cab71a10e0a4dc0fb1922028cf8569f569e9341858c92c01c58d76a804ea7300d1dbf732b04054db7a0a0ded32cb5cdd8417f5ea54d654dc3bbbe438d89463bd76368138b00a5fb87e9522cd348c05cfd4b9af4f3c9e8f1338ac55654387627315062c7580665af677b30490e4266b300fe10e2ecca6ecbd589242803d6d39cf3ca2a421d00cbd6b629df05644d62d6e104fac8acb5d8c2132440b720abebcc52fb993b1c0c27816ea19f54774efd83d5c0fcfe32aee74649e2dd5efdba11cfd8b85ef7ad0d91b5c16e0bee111bfc012d4de411a72aa9b6e2aa2d8fe9d1b409eb7cd5b6c609a3043cba2c8679523d78fd02651e6093f168287fa2b7b5e5835a27c5cdac060477b2f67fa35bc81847252761e3a4d05c2a39503479051583777f6ba5d1ff270d3987ccb9aaa29df455a1d346f8546a89f9a3b8095a0fcfe80acd8100b15c590a7b5435b3c566de4418c313d4132dbc9bae8d7498501a8b657144e60340732b0625a2ab9b5b20ec78a9817210282672c08e48a39042fa081b58310576dca5cb06df5a5ffd24c08bc0037fd610bf179faa2ec06a2587a28f60a18ef219035e1c0ffdc68043394c2cc34bf0086a22fd3de59e0de2e05a725324e9077241b32e2a0af9074bb564297f9497c9841f65c372328b767a12d73b001699f415325e89460e97778269ef78f0adbff8a0ec1d1ee756531c1f5c98618fb521858a0159164f021384b0c688c877f817b20df05926ca0dbc2e9d3a8c4509cdefb9378129e02f04854738a592a16bd0a5696254d4307a19d02ac736c1cab918c1d367b2abb3af0e17ca3241e11e1c8a028bc7631572d06829ba86cb8455823ce7c267394206d70fcf109a1341b630b3d5ba3d9ecc8067111634bda47c4f1c57b62bc9442e4f5901b3d7a1c9c51795fb4f3b71a772ff2a2efa60961a6406ed2b63aa21acfa7ee80accf6cce1265ad96d221d735f3e1ae0d4f5917c71f59388c5f8d6158dc71f940736b9bd892be5fd94e13fc381e279f52b8a22e3e9431b1756d07e78b257463b0ea74ad961863fd9b523131be1eaa4dec0ba239e1d954d4402b120c284d0a6c3044dde5c52e4753a270d54015910adaeff7d0ad21321d56a6ec32464a573cf400eacfa0e34fae060266f3e73b47a5f430e8502a881ad258b210cb84633a4eb6f0b96ec9cf763a889de576cd1045d2c2f372c67a8bd88ada0cda36189b5401979009f237666a2238b2237fc314a5b1bcc33be08d2d48b9ad2811e09b304235c8a0ab64ebeb719fe1235bfc81cefd52dffb8a97bfa23ed7e1a919ceb0eeb9d021b0249b5650a0a4e01704638c4673ffd743917d5ce14d55c57000f3961526eea0803541b5c876ea36be573cb0f06405584202cd5579c515a0a0e74067901b39a3b038961911267339fd9955f9c5934ac2b68be6368640ac9c1d456a6ad9ad841d80c044d7040c68f85c6ec7ebc68f892a0cd762d1049c86329253b55eda012115a0936eac1051656cbe775f332839daeb08ae828d847d658fd3530f2cbee61ff6507544a42a52fb5f996aa14f6266f80723e338bfbd816524f305eb36aa1ece98b08cf3c8740db207923559d81a206a7015a7e7f3ef813169577de5bf14adbe725021fb90859ae9b186a167821bde131809f876a4dac601a5b4332a4e6caac61ff028e278612222723e1c27e983eb5e3e1c8f07f02400d910830d2a3ad1af2063b0f15fd0a6b8415b592e299806ccec324b6b49f33aa11460856392a54cd4da0f10ba1c58d27b36142d1e006cb2ae07c5e218604f5ae766fdcb861b8fab47359c700ba37d66ce98fc9727f164e8ec081f5b74c4f6ee2fed548df0fc8fa4690bf7905c6422fcb6d15f958aa110f4a24859ad45d586502b88335fb3416a88e626a72059a321b88d4d05c838af6ac16d58518dae9684c3489a4cfd058490511eeb3ac0195b20e848520257482d0753b88e19733979fb4c9ad1b9de9029ecb7e944bbb0f9bc831bc98459af75786c9707ca61444cc2d65c60c9617d539b148242f9d660b7c4a0e69a2944fc664b5c080787d333e4a516da233989abe401e6c05d3f2510df7da434edd41740f5a483702678771343ef3ea2629097775656335e280f3bb0e17f0b6c3f70ebf38e6cea7a0d159b38631c92338920c2919e1628dd11c74080a058a8938f206fa0469584aefcbae3eec538e1aa0a717913e8c75ac59f338df0f70bf44ad5cbfb709ef70c69e1888366153accf04059be7395e34c1e3a884c509d654ba39b8f50381d44115374f19375d5993b72f4bb44ab8c364020b43b8930f6df5c04168d10ad24f9c924222073c5c4a3ba7e96a6ccb31f684dde190cb210dd1f2663d71da05367dbf9f7e5f711d9c087e7c683cf964b18633c67f1273630094d36fd2676c4f969253bfffad24b60e2b58292108fd6b2242268e32c7a5b40426fb4c2b7262c71bd794ec0f0768f8e8a8e31771fa3d58a83ac1c44402476104973e2ddb2e979c3ecbaa1d193c1c434807d193e7f40043e1d1ad66f744cc220fda7e04c633187ea0fed0e9de573ae93544718d96211f16cf0dce760e58e51c07c8511241d090c4ed60dcab8c29ff59c08a11d9cbee0c1e47977d541b8a2b020a67498d48b135c2346637ba988f7238411ad7621ba79fd1731a0271cfa1775c074e2430d058f17364b25cb54ff4d4e5a839c93ea5f16a686cc33071bdb088610994219b3e8feb2f2f4ed6a0355f486899fb7f903753a34a4c38ef72ab54f5850968c5ed071f4fe336722c10ac5144541ebd1d4cb01ac678ec036bfb35ffc2b10dff45bddb6099c7e28a4884636edc3750e1ae92dea41fcd7d3827a7dc2916bc08ff1c1f8d855faa9f0f60e5a9ea5f999bc66cb2ce5f5f95f0184778d63e37780888b8c66a848cc563d179bd57de6af8280b549652ee0262900d1abbdebe90e40711a89bfd3c0135895949de834c690428d7d1d8b65a4c9d53e32e2968b8df53091adf439e7e77d1cf7ee81c39b2feb2bacdb6f023e4f2041da8783c040c02690f560d5f7f7df5d3cae2dda1ae74e13ae18de2940086ab2fbd77fc1d8ad9298901520718cfb7cf0fa55861104a16d4d34e52c588fc29a7ff21ef50c45279182f06d0f4290bc3edfe026fd91f0af28b7ea5916182899d7293eb723ff230b13ae70c5b9593330b509a28d7f28159f49c84dcdc1f73d512aaf19328cbf81b0355920efb76535d14aa672a90fabe06552ccaf25ffc218721478b4b5f5e49a34d70f3045c92657be112265598418eef5578dd16c56c6819e40c0ecb1dcf31b56c058e01bc7e326b9c442430c680398def089aa2f2aa8b0feeb34647b6e19adf01d3490a5ab383e0daeff434865edce07805310ebb250d12bccbed8abbadfc67ff79f20dae0d3b55bdab53409ad1c3b2a3c2e7b9b88a266570ddb69488249e89376299095c23e825eee7d3b4bc32627cde5203d68de15f52db120eb026390e15d961040d6077c0b22d93142689466ff356e21d3006e2a3d2e0bbe85c4d7ee1176c7bd90c2161d24a81490efb6c96c545fdc50693102ab442872669f64e54a79c290d6a0ea26fe6c39fed8bae97db3a0ddbcbf6b79363ee64b6b3a6392655ef6771cd2a0f0f9c0407c32d94c2e741477771c8254b16b6b7f8a61eb4fec436c762cc2fa704235e74e2308cebf464c55ca87da78bc4d3441c7a39d7615afb615baa940943029402c616c0c8dfe562cbaaa123cec35fe991db312166575479cf3bf65011c30592596a84488c250bc166609a9e3dcef26f80ec77f208a6e87a2a82c05d2282066f23804a1b0ea3cc826c9286bdea30a45f6a32eb13139863f3c42e3d22086809285ddd9923b71e20bd8af1ad1ef513ab2c4eb2485ceb0b7c55344b44252cd106be7a78b24f2384ee5d65e904ada3e7126d4868c0edce66ba3c95b39fc5b2660eeceb156743acb737471040d2ce8929c978eb376fad551f287b826c8d7ebe4205f5266d32365b3c48336ea4eea9d4432b992fa396baac87f033a17594cff0780cd691e7ed78e7200d7ca53e18f1313c8b6586aeb097b7040c90e14ec2b1ddad05a04de8864efe3cf445d28a665a264624f4362cf40a14bffdda622f47e4d367015ef7d59b206e99d72da8e242a7430a9f8fc0d4da69885cbe2fe9f20987d97803740f0a5c9a0371b2179b12b3f09bdbd11c7bf428f1c9d8cc6536b13296dfcb07676db014b5bbcd7ac2b38da587e844430762f03aa01ee1d53dd1bf90be25bf0343759aa0400108cfbc2709bd944ac8ee4a0fec2919d4f2749e468a07d0fc330ce8f2a27056ce10e80f9d7c6955cb8decfd25ad35b97939c06bae53d870ff830bead8e991c6713ca02a0fc10884d9303788598113dad5a9b2954a5fe8c9164c08bf6d3aa91aff2a72b0eb32443df4a942df507050a2bd4bc61dba174214b2d7094022d7d92a3ec28696740c74d89eae066d7c1aa9e023e281b921511099d74b0c8a594536c7f18e904fc2f73da5546a693d89ae5da216a4d6d1079f3214c83305011060446a911c6bd00eab9e818bf09e1ed58dfb63392268fd69c593ed855e00f43a62e095c8a4b3f0030417de6c10c3261cf961cd32d8211c8d1c5d0897a30e056916be963a34a6dbee7edbb073a9d95872f6b107f7fef887a45d1b021c09074ad222877632a932d61630e527d903ff8b7a98b14b625077e2ac5cdacf7e7b05447e99d539e3b1cf21af0ca25beec9629a823778f05b4e80753524c546460d08750f57bb12ad0f7ad564128ccf959b4ffdac4ea5a56f2187494affbfe94eee0cf4d0499e83e41c2250869b8874894fff40f5ac8faed42ea988ae9ecabf72570c0686d16c919d4c6b8c736dfb412b8eb71991510ec74b16788732cb4916d5db00dd2aaa75003d5d5cbf5146d8abd73c26173ce3554beaa0976ae38c9a5aebb5002215a19331c6915ed636976bed60e121a2f1d5a351bbc8fd3377613d5bd9db092faa99a012fff971a7bfcc7d32fa8e3d3b2793aac7751538c69fb5b24d51c7054cc9b7c4fad9b52ab60dfa85c98b1264092a736348329a2efa2a7d281a148703f78ff54120f421105ee38f988bb0019a871f50eb994e034507d3837d423642016117f54727c3bfc2a665e46b0cfcb1381de45d85dd4ef4b0963e1f4ec6255b0b02819fdc3b8bab935112ba6d8e21e008f084c0e53be8b81e83ccb39282e5f00f376fbea5bb7f266f316027e28d545b6b59c6122b3f54a4e9e7660208ce6fcf09b1db7bc61f406760414e588a462f781d5d4bbc9e253de69e64035fb4c60c31013d5072674dbb007727d346715c710af45b93d85b6a707dfeb4cfaaa8c52a1006e02165a800671917565d7d96d355bd231004ab6ffd69a77d3d4ade1cd27d990f090e65fa1cd4605516cdafdc03766540f0659606af52c94ea1ac8122524afb0d7929ddd810ff9db9e071af0aaa0ec7aacd9d819158da08fc13059d6b6ced8c00a1b337494d545960df134834de7b3263f03c68fab331ea08b25b9ab19274340cf519dd30e85769fe9142af590b4c251363a34097c5df3ece8f7c188646843c0f186eb87bf8bfd6fe936d8507666236a9ad10e880e40b4edc046e41ce93d6e6047322ed353d2de3bf62cc2ab650a4892d1d1be73bd383eb20aeab1a6fb055ab0859495bbe5e38b9ca0657280277330072f4431739bcfc53ba1fd27cd361695e0116660c9231c240747f00638b14a7e8ed4e64e6fb1aab61918e9f34e2ab40d30cbf2b97c91a105d9bdcf659eb7a3fdb09c6e51a3ad5e1396762d6f840bf1ffe0364e1359ff787d3092637c32b1e0dc9fd561b18be1a17abb6067e45976b86bd0b91b014e60dd07168766f188fe3fcdf854dd2c3053cd362f8bea354c38a47f902ec7449a2295f1ff6b4e509cf581712830fe7ecded4e245910c057b541130f7046b9264e52853c33abc64f111a9d5cf8c8f1220bf28db736fd565bc0e57ba340f49fcd4df9980ec07251453965f2b8c484c3d84e4d9af8655e2bcbc193785f50e952205f171171c84884eb78e96bc1a53c8c1e51a07ef1a99466f7e0e749f8d0d9745c14bae6c12710c1eabbe85756c2272039ed942ad929b819c1d4a7d286d0bc4a5353810da8225cda10b323736204493150901cfb0a51e93766d4d5369010411e048d1591a7a7c3409cb0fd04852b0a4257a3f5dca0f80f2d5ffcf6811f101c7a4f345fa700272e1fdbeab0c9362b90d3ae2e9545d7c38b40f828f0928a20331bb88a0208137f5f4de98bbfdc6ad3736ec50073206490f7f5d37bb1c5ca606080fe4e71b2c9761cb6770983967da2762eb67d992f42a0d65a3a9231a78290d1140ea0aa1fdde4498cfe84d82ac569c91aa8425e7cf7ca2b2e60582c3fe8706e2f55f81084fdf07bde61270967b244431fc7d3d7cd4738bf85260c7dc190603ff592bf61e1e0bb4d606881f6ad041faa21dc3a0dfd968eba161f2044769180d88e91ca069058fedd75eaaf8e3fbed1693354f37136661ddcd90677541bd640a4ce9b189d3773bc789c9643cb7242df54b521ed05b61197d19fccdc60b17910e7d2b496d706ebdf275b2cc0103ea2c652c53bc08f5cd2248f4b710bb70270d0d7126173b0168dbf9a8c55167c641186a812013a5f0f22f029636cd5994dbfb0e false +check_ring_signature 1366364d335b3103c58af5df162cf00f91e9a6af1593553892a65d09fd528736 d0ee526df7747c2bdbd1007fa9bcf6a9246f0a95c8ee6ee1efa63ea89095d14c 1 908004e7d18ffcd92acad9dba6bd29e3074773aeaaadbcf2e1fc08ee6fed4578 626ec5e0a9812ef2bd8f383c11001af86f7fa85d6cf4357c7bf35f2e41f566a739d88cb96a9073243cf7125efdbd33daa12f50fb1820b1019cb4f76115f9001d false +check_ring_signature 42dcd3232ea28b8f2fce849f08d0d9c7ce1e5a9e9cbfaf1e9bf94a6462cc8b0d c4bf33c1b461d64225ee349d7638dd1079c798b9e19e6800011123e7db3ad6d9 1 121cf6a951aa96367ccf40bb604c935014f6d44f7ba677e8dca51357e7ddcf85 1d4a2f01d526da442f08c5ac5e78c600dc07bb57651e2c34659a3cc45cccfa4cc76750dbb04e724909a9d9a2ad6af10eda3a90a7a31f3e168464b0f1f0b50b05 false +check_ring_signature 11994119fef5448d4d3283e54b59124dd53af6f72344165405286bf398c87e97 4c0c56de0f8a747310968f4e76c37ae33f864d6fe4dd1b3d367ede69102adcf0 5 ad3a3817396e0fe445e5fd492dc2575a0c661432760d269b2cdacc9830a562f7 280b7b7fcd19a714e00dd65cbcdca2a232c030ad6438ef1210c23cfc5505c338 16d5e25a345980c53e6357f8202eb5fda37a6dc34d802040570d0b621031dd9d 096dfe2147489db5ac7fc28af7bcba682a859d56c8048d21065ae69be4c871e9 d2dc2e5a8434ae88c8fc45e29b9e9441af55fc8034296a198c093c837efca93d 0b9e78fab2d3c419f3c8250776e8b543a006fd874c67b6df76160ab5be3e36050b90798a759e63e11b4dd535ce7a5d056e5232f936c90e0d7bb23ef472a49503bb3a4a6ae0600be90fc0abe02fe3ab797c6e0bad8c25e550bd71a2ec51e4b905abcba3b65d499eedfce08561fa354898bf81608815b3c9ba70918b233d96cd0098d9b036e4b3b396d4e641fc0fc7099715733efd8bf0fee40451b3a3a8586500a1f47c83abc54ce3fa10f88646984709930b1b6b0bcccec9b57aa92803c59102b34569edd7cbcbe2f51a5f9f0d4e871a0026fad6e6a24adf04854e1a3896d4087332fcd5bdc8811b840463726324da8170d4e497b16028cbc3540520a0bb1f0f5114bbc54aa0b768f87a32e9baffbbb33a1fbc2e138b906839a4abb9164951029d5e7571d905642ffdef541aec22ba39b6441cfb710456f23b580c901085a40d true +check_ring_signature 3379f09973d8371a8b6b055d2429e3b9389ec65baee8b51e210af44ab70c3b89 f79025bc8a27144276f5daea1f2157bc40748d3e32b11beb7094613c837f726c 1 f10a082be84ef9fca3eee03995e8be0abfa6c59cbc2ac940bf86801f0916d02e e956ac65acac1435ddf61c6cf41a659d120876daf3a8685eae053471a8449203077426b9d4d2500edd41d97d0f33cafda522e4550673ba27f3d6111ffb2f2abe false +check_ring_signature 6aa85286c07346aa94b29504b4bbd42f5ac2a7bd6eab21aa79db7a766abe99de f4f279a31a8f38ae54a721764a208f268a14e2139df5a78e3990f95384303f6d 1 f065039b219d6dde631082652b6550767e1d34480d71efba906d66c79f99c221 14c728388a388a00dff5dc30f948c2d6b8264e893a7fb845437581b391719e0d12204acf595b84f23e6a207a0da59cefe9cbdb7c72627e875dc3749b68713200 false +check_ring_signature b6d685cba67319419187e7a28227a416c3fc293e94b0e4c2e94d04e277ec9c64 ad57b61f9a16be5ed216a124e0f91ef0368a94f0c8d91dc7b73a0dfbed82c87c 19 6a188f014b63787ef11aaad56685a20481fb33325f2cde0a8fb39585934e2ced d0e19149d5aa2111d6015a162d74333944ce64362b53572c7da4f338bd463807 4200f4b789e714439c4bc092f0d0d0d0ebe1a188e09250d6238ad58e5909469e 77b2adefb5c3d42732caac56fbe719f096851388236733a50077b893a02376e7 9d746a6c03cb824aac6abaf65dbc5f3ced3f7957cb4f4eebe01a48dc828ee559 7071ff2bc986df8f089ca36dffc001a0c7a80bc6ba6a54d7655139806f5bea95 9b4240af37de14a7c2ac7e3289d4a421d1f4eb9e471fb0fc2054b7c97ef3b3ca c8d1242b860c8714a71a310d1457a3bd50697b4ae2063c5718ffcee30c8edec3 b4c20007b3cd6fbb8c60c673f1b4080a8c9e3bec34929d804a65742ab65c98ed 1660da8dbd944c907a0d9defe5bd774bffb1e5bdebc9c3f15536fa7c5bb1e6dd 465e71bdeea5bf52244b199db9d2f40d117beeb17d0a7bf9d8e2c7eb87fa492c 789c8531387057d298d7d1ab44da33a54c3d2f6053b5251af45b4f6a6456653d 809022370f9efa16a5a62e954e1311897a463d67fd569021a22cb4e4d22b65d3 2bf7d695d7971ea3a152c5b4dbed40a553558ac8869b28892da2e7a37a73d329 d07cce73be06a26b2c7e05a6d3f96697a18eea1491dc09fde2843da14985c5c2 c6fd2ac63449e81b061be12718ed2118e7b3030d9de533b97990220b97a141cc 9fe1d65b83897eaa398c2ef7d97a7ed52bd471b9c0658653ebe9b3f4522b03c5 c8d5e4dfa046d2027f3dadc779fc7c960081ad19151c9d901cd71653a1d28ecd 0d999dbc1bdc7ee5c13088791993fb1f440ed795ee08a209b9eeacdd36a1a618 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 false +check_ring_signature 08eb1f2f573540508839644604d7c7bd61e76086b3907b2cb7b2d9cc351baccd f3fd87641f336e75a4595d936c8610cfa3c2fcb8c6f54054f6a18d6eafd09b11 168 193fa8763b920daf9a60dd3d2e1e71a289e38a933ebcfea587ffd592c6fc8926 74d5b46db71ce9d37c9b639c928b9fc0dddaa564491d0ccd4bf0c123e128d84c 7373fdc49b6a7b214f33a8a09fd399232f9bd09bd37c5ffc17786b018b262ebb 2de44e4d0f1e902af04e591ded67baeb3dd8c9d799c5efeb58831f63951653e5 8c3b6b616a46580d81c7d1256ec12e35d4a0f19df33a29fae5528587d388f7b4 fd4897a9f9d1d9d5c41e872407d8ace59dfce68c19d27779c736b471c96e1f01 1323669ea1102a0df5c3066445cddc91d73587de479ad342e929ee085cffb1f2 23c04bbc77e9fa5b6bd1a8a2c67dd0df7ba7a6acb1143e938b74d0d6f88788cc 015428e4853e6728edb474c4dca122367151511f56c5166320492e59b0e76e33 4437c4670471dd2236fc9b38ee67ac9c9807bc420ef1064224730c01ddbeae83 5058c19baabc11ca508beaa8eee8f56830db5976979ff79aee11fb8864980529 f29a4028a86b1d1d43160b5653d3f5dfc41b3ef0673b688b1efe3095a32cbf6e 7c3de1e109eabe7421b13d8710fd22d3421d3000f1b81a219ce5b7d341320e21 15cbf8d2c969006c84c52f4ce747bf89d8cbe59c04315be6f1ae80743941ff3f 52cf41b3d200237b96384ccc0538dc9d5b85ace90f1d1fa34ff3580f55a2d770 988cfc90202a70f79b38b5efcf8fa4b8145dcdd4d7331d6d5f7ebbbed15fbd30 2fae7c2f1a99a9efb8713277611e7637cc8a488a2086f63456fd0407d64c4805 35497e688a8254a68dfbef394d43b7db1cccef0124147351c526dabbf99b01ab 65a35dff5fda0acc1d58e024241d50521035de936c814223f4cac32936664398 9bf63e0262e3c0ac0ceb2b7039597bc2db5dd896653d21763b27ee190e102a0d 95a9101b4e32df2034c714608f378440983ac5a36fbbe1ecfa008bc3dff39bf6 f173abdc9a1fcc4d004d343e05341f4a8caef163f16daab18a56e59edc860e2e 738cd94aac031d05ab8b7cab895da4f2d4828da82b99124e62b3c8df54f7e203 eb7fa7a64ee2b5fa80dbcff9bee70f8ec5a75b7370022fe9a707034ae016ba27 964579956733c1f2d4cb54da0ca1b8653709a4dfda568317f42069a9a54e54c0 96fac0d532312c4b8a88905b30698218c85078bf76aa12b332a783b739e56d55 4be0c502eafd978ab1051bcd1eb1f514721101b9909e06553ec0a8c285deb02e 9bc48e9d2946551519d196c8c315016912bfe375e54c9e3d8eeb5d17e1812ef0 306e8d2bcf23f84dc4fa39a0625beaaa25fadc7ef435201373d5f6d6b1546594 889bf64b0121b7cb19b2aafc6280c150bcd727e189fad01f1464d07eb716c9f1 0bea989866253276a332cee5872e1d977253813f75108977673541eecef74d65 9a4a7557ba58edb10a1ad7e818993c1dbcc1e826591ca2f55c1558256bf7d6b4 1048c9ca06cb67a2c8128b44bf996fbff0fbf648222157da96dba44f765f41c3 303cff0c2718ac64efa7ec949be311f836436abdd46193a0826517203d755b0c b0d91bb83f77e9a08a2a90f2d6644e033394fe03afd5a4aecbcea8c7150e4a5f f09268e280155678a9621b7961f696e7cdf87844efd3a96f6ce5c9ee4f22cbb6 fab7fe124666466ba8326c08c042a92e98c0e58195443d362aa1b25efeac4eea 1df0e420df7690e25401ce1bfa0bcdd4b9323ce98c42b64f1747262832c41006 79095f6504c2b8ecb99e0e5e3644d76e3e710d3c75903ebcc7ad42c303abef8c cabbc4ccb52980f8fb3843396d313209f4b2d43172fc8bc81deff28423b441c0 76f43a8217429b8a37deb77d22aba664ea64ef6155323a1ff891d72bf7f507a6 4a7f0e68f78a0fff8f19ac6bdbe23e1fbebc5b7147e0d12f9247d092493f1a48 8be5909a758fb59ebc6af239d84a98edbb19504a4f0193c8e0771ab5c593aec5 7abc97c95d2c4665ede21587110e628e2026e45472e81ba583feb2d6aa4be1be e69a6b94fe232c3c35536089e3aa56086cdcc0af719bdeef66e059f8adc1b637 4d5976d761859cf12e903b6d4272f4121a7cefc03d4bce8044ff67e5278e2c5e b4ce53c0d1383bbfbf506f7ff94613e23aab63aa89e42f927fccf654f668461d 9d11ceda0ca9cc99308b626fb02022713d9f646d7357e35b0a254486ae26d6c7 05f6c1cf759645e4bb74a9dab8bff1e94f405759e1cc2e7399b14b5151627dbf 69063b95cffe28d40eef277b45a0856ce5f5de5ca02067af22476c34216bb138 c5d1dd133cb8587aa54104bab6ea2535595a0797fff1376c85634ebb8514ee77 399d79fe43a36e3d625f8d6ed7643d49f649e97d405451a2b094a432519cf994 db85c9cca26063e3cfaedd898f0c9f4a651411f3211f42198d88446749ab8a23 c702e50908dde59f23e994651da6d5365424545c00af7e622ee986cbdb78ee3c db2a2db089e733d0e135892c63f1edb88eebe7135d790aee58cecd02c2ef99e7 7ef1baebb0902affe3e0b96e83eb1de37eb69d283bdce79a0d475913d3fe71b6 0c820af8075c68c7818e3c9d0595c9c6c6d1bebb167f1defb64dad6ceb778c93 7e3bb98aaca52626ec9cd22a9bcec8358950a5a7b0f483228c022c99caf4c688 cef94d48a5e3798696b3ac625f1e8d1d6a6a0c40c8aa71b381ce46088df22362 4a0c2075437952ab9087f5d297a4db8dfd376708d2551f33b8f1d3ef672a20ab 23cfc9aea7690664eafd0db7f53303f68da178577c772a1c8912ff321d3a0f8b f02279e5b04f266551ff6027212657b37724c1f48497ef154f83adc6fbca66ea 6c908a79436a1744bc7c3a43008861764e46739c765346cfb24ae11b622ccac8 92738ddb13fc1e09adbfb0421051c1e98c7f6b0b3ec135379590ad75445802e6 c39d81eeaff9ee602916bbbcd57dcfeec538021bea056df9c36f349c55ca12c9 b3a08c76c6219c0db25b5bc12f4b1627eccb7aa99315a0693640702e0d4bef51 541945f8b05bc405a59adefa600fb39528b4d0c0a192cba742002507091a4f57 f00a0c6eb27ddc350a140bb42e7c80ef5afcf1cb82760b5aea1a51e7f863cc17 344549b7041442e494b04eac2bd2fa9a928dae2ba86a6ebfcbe4a663b03d7fa4 433ebe46b60db7f81ab7e13dadb91762fe6362a97b471e1f291b24ee1dce1447 0df64a99f67a05047c27042175dec07210777b9e0a79c501c2688363ec067073 31eb68c78f04b9fb7141d5efa1b076d13c102febff96a287fb73120dc3a50e1d 484d17a5571baf6faf62d328aecc15904f0df5f6107895fe6e70c13a4f7c8b85 004b4a97001ed33f083093a4bde8ea0f748b5cbb24d93f1ab74a2f5fda175efc 8ad10b0f14dd0da6168ec73eb2bb18a05a70292e3ab609f15c1f455d01fe919e 5f31905d62cbcd3a3fc7f86b241cd9df430df4f174e3b66b812abec5483019e6 b56a7bf9e9fc7bd9cf8fba4b830b82c7d264bcc39e285bc951cff1d76478bb59 5428562d6cde2524a28f378afd44e55d2c9ac43270e3ec731ce0077a06d44358 3a73e809c831d4f4fa15e9735fff626f82e5552828057029e34a36be43397dce 225bdf4e958f48be5a7abde0f6c2544c544de53f877c9790d8c65ee891c02a0c e137163d28bf91ab45473bcf987fe946a93428a5d53358d9989b699ff3071e7c 25ca2bf47bbcb52a9760a7232fb1ac5d8058171870401d97d85bdea5ca386961 509082e9a4995b37a787f2d31e1a17ab8f8705cc968d3b0a8660f9b5e95c0efc 20e3d218cdf542021741707c934e7c5c135cd561729a37fe25414065654d2c52 50f55c1ff236b79c6f52a2ac977fc272164c10e555b467d011c28722cdddb785 87c5e2516ebddd9348c9b397482bfbc83b7be4d4ac670b2f9d2b3feeb47e328e 6b2fcca2a0361375e0d38f4db8846cbff7f3734e0472e2c6d38adf224b7fb9fd 0db7d10c36309bc5365720c093e0387f5281373c1d1d717eebdda592e4592928 977149fae9628187bc83dd3184a450d1b9e2d9e7e4c169f547557450aa5bcb0c 177752b932dd050ab2dbe76d7b2b7fd9e73855742faf7b8aed5e55df5108556f bd6b0f27a3c34c0d2cec08c0a4d5e828634c22cd7b46a119e8a90deb9686902a a6eef816519595d1b1ff63fa0fe5c5387818a696e3fbd996b39bc5648483c5c5 f2d7160c99ec35b3df5050da7d9629656f39313b55c5ac53d698d6db8e377562 12d135fa38ab24510f2e06f456bc7205127f61e589d69ce79bc479a518d6f1a5 17258f3bb08b7fb8ffc5f256315eb68c43be5503c763cc56b4b618028ec291e0 86bb3833addbed68d37b98646c087d6795e5b2c1ba0dccf98b430fd3213edace 9fefb906bd3be0063870d24a2fef3c8c039266d533b54641e2635ddde4705873 686287044dbba0c1ac7fe2aa16b3d2ab20054eab37a5efa3b629dab518dce3f2 21e9925551e71e56506c359e2738f7445b93fa645d18535cc3209695967602f0 c22f8f2b3cf08dd55dda98ba6d15615eea49bce1471e957ae5b558a32643483f d92e2f137d8ea178963c7c77936d7eca9d977eb97e92aa47f61fe9f200382ad4 2d15fafb53f20a54193899f70eb550030c920045a48c141552420b0fe7033677 294a64acc624a8a51a576eb3bfb649caa2392afd8c3d2266f6d6634917268d88 3d4a96316cd9c402ad871ad3a212102526e9c1eb908ccb1054f51a58b14889fd 5cb27ad83e7011d332364a75f8f37fcbcaa20a6ee9d7929cd5d614f49233de1a ca6fe6e5bd9dcd3c72bd8cae9fa3aaf6426ea8b3e99123cb3badc943c37fd487 d7bca1ee3e8a65c9ffdd65c423bf59b1198f968e0c6d4920717fbc87a2474d5e ba13a8be41776ffc7c63129bfc03e00b83f5aac6eb77421d3d8b35f0837249b3 4fc94da568b56d0768d901f3625b3db74e43d41690b8ecc09a30bbb7fa29f1a5 8761fb1a127678ce232c1c9372477c478b522cd19f28bf1a27d8cb118e461c81 ea183e70614e20883e6da162e03995fa26c906856a3b7e3451ac6c69e30f31a2 0c503911984bfe8c154d0c84d74f4beaa0439bb22beab91cdbfdcc9f5c65f2be d4a6e1de0c9ada16c5375fc986e7baee19505f944f4b4455cd0c7d7fce89ccdf 1280d94a967d1b391eb7949a95a95009d143ce05c6f89d760b1bac998732c7b3 e8d8e0d1a1f210984edd13e2ccf0ad8f0bff8ab7edb9b612a8a1e050becdafc2 d59f625ba4cb46a2a22ad9d15bf0c03db75ee28528a3c488a208d4e599cbbbbf 0440ce804ad36e5eae792b55fbcd4c00ae2908b0912e01f15f025e90230288ad 00e0377677411b118f3203c9a52d1ac0fa12ebb597ca2a4d6b985a26249bd8fa b4cdd0f1b570e17d5c2da98077b2546ede6cde2cc4035993a8c0c33445a30733 5cabcc7ee61a69cbbc2f0ca7883188e47b088574c200afdac8f6b29df6da4eb2 5ee85b4bd7a31801abaa5679fd9db0c25e794bcdc0dbb585df120951624b6bb6 0cb2c8fe4d819dc66e7cfc3b9be5082084cea45881ab03903ece77dacd1390d5 3c7147ca28cd7b7770ab26b717e0f339000bedd0b71213b5253de5fabe2afdb8 b41eea26b0f9ab306b6770398801553d529d1f17d5081a4965783e25713e76b7 cac339be9b14a892833d7a6a597d9e62f8ad32b9d76e7245aa743299c051fd99 b1f6b109307b7c30357760f57d9e54bd4f4c8323cb867df5e94d48f96a41b8f3 fd295c17c9b55e34af029e914c0fa564c43692cbbee57c76c3f367d50ad72928 bdbf90559d8a527ef00c3f7e5303e8198f4ceab9f2087b271cb38f1631d7ba7a f845e80dc1594d06d29de473acdf215742cf63a0945928a9d0baf6908ef4cff3 54cb89d33376656efb62376b54b1b07e8ae0c88a68c54c874e281a105e6f0341 9aacabf442e41e94a08b5afef4471c01ca8de154f5f5da1955b5ff33af0e39ba 46d8e6c79b3e9b92cb3dfdf03e138b29e1eb9911da980ec7caa5fa1c498af800 acdbd9dac8ec0a2cab6eaa7a2691cd0430282ec730bae3dbe5a0130d7c33320c fa8e7bf5d43485ebecbc7379750851c56c03cf5cbb4dcd09766c99ad4467215c bbd65f4b2d14e85ece7d9fbe98bf32be139969325be1be0096b958586ac72a72 595b2cb5745e198127cbdfd7a924d8df77f7af61807e6ae821a4399715baaa16 a225da8a20f3fed872a75f6f0d4da3120126c23cec61cf38c53488db567ea977 379e979216796aa0a7be8b69239af546afa363c2b6597dab88de14a9e48e9d00 fb32d3343372ab09fa1b7c15f54352023aa4d37d13443e263df9fe0327de0193 3570c3eb75d7b797e96d2477f5c8118681203477424135c27171ba71451737e5 0bc7727046d3cf287239b9089b7260a7c40f1f8bc8fe9f98a2f462b63794cb3c 24ea53cda498fd607cb9df3167d37a1fbcd0e19dcd0cf72caf6b32dec97d608f 4d5d7caf077d14fe55c81adf642e153564607938d059306875182efdc13511b5 71cdcd3b8f1ad5eafbbe554b6760f0853ae582aa88c2c1f67bed443f749d9c63 cabc3809bf09ade439027902b287eb67af9dd8657879bfe4495b48b6065f265c 7f663b7ad6c09053fb02617cc29d05b39935ba761669b188e651bb282dddab4f 65b1eb6588dae4da078d7a12c9f9f766e4063fa561fbc5a0b63d8b700010f3f4 f105aa39b344f9a906afd635e3bf7ac4d5ece281519951291189e394ab1bb783 3e598f28e522aaadb582411666c451bcd5b494696345932286376c77bc747c95 0e7ab7cfc903c1b51d047920603e903a152db0e60796e99ff296571f4315f29a 2eaf905878ec5c5124c3c6920a72b245c15a994d7377edd00fd8cfadee24e4e1 1d95add124a1219a0d86674eebb8eddcbd1802b4e94d42b305ddaea70648d6f2 52252a1bbfb1daddc6ae67184d9a09bfdec81eb19f20de674e2155d221d63205 43a58eef37997d7c66e43c6cebe981d56ab10672e388965289eab7059852150e 56d9e7235ed6563c096cc519e480529fbf9ed041b0422829571887d5b8d4d174 ce14c0c896a19d5de22708caceadd8af707ff66be570ef25514d433a4a3b61da f5dbd1f711bb28b1f86ec97d482600308c9a08e3de3c28a961f8fdd35dc9df48 7b449face4810a2c596ca4f1f67c60538bc4b6d9805d4e803df3b77063f8cdc5 d2dd51f2f2ceeca17b4874541e49a9fda10b4d7435fd6f20a74870af4d7c176a ccac3315fa6fc631e26e786086d456ede4e0d791d70d1ed688adc2e8769f8235 f8144d43eccea25d1df11490f2870cb16429a5bdc47eff8ffcb32d76ee4d94bd 7e447d65f34cf3fe7fc726e240bd6b9ab1a5a1dd9908a9bc01a5d03f1921002c d97d77126eef04bc98ce8625c2778d3aa30d131c1681f427b221671c212aac76 27bd90f411c60b207fbd6bdca0dde276d66f2c76919c71889d4b69b74ded6d55 d7f79b8ddb34efd1343542f0486144c039b4a44560c7054c9f416acafd1e9af2 2612614fc3f997b49d9ba5ec03cf15298da0fbb497c1f856006b455adc9c68b6 5bc41b0775a6e3606d25c499735d458cf328311144ca4571ee61fc19dbdf1c6c 740c8e80fade598e1228624d458b197a4e65f0ec136232be9ee890109d8afbfb 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 false +check_ring_signature 23a522570737a8a9d7275e22bd68e24ad5cf13d804f7b32d080a390fb9c3b95e ae16ce8bfb6dc0394980947a20e225a078fa18a81be252146b58b6d176f03517 27 d0125e08c7ccd586cd1b36e40baf58339825db8f9448a328245aa511f4d91af4 8550d71f746002e8e86e6e189810898c205cc5b7a817af4fd7ffb9e6585a54ff 84fddf48a6fafa1b5ffb519c1ad4666bed503feca19e0c803f1c2ba3cb990ee6 52dcb5a0ca3d361e5fc842bf143f5a852f2ebf45cfb112795ddc1f93b54ba2c3 97b751b04eb7959e7a41cfc52091497a75793184c269d27befdcc6cd1765a9c5 147af8836777f2e65e0044d82d1e01d693e974fe674b51f796cbc5036846decc eefab71e6d1b464fb840e24548af17016d2aeeaec8e8783a36691f6f2e8701d1 f22465958702cb43db5cff1f843becf46831dbafc379a2be30fa1a40d5508ebc f89918df8e5df18423d4c2e6fae8ebe149324422fdbc98fd89686e5f9b791f02 e47dc3f6eb5d8d9861b338411b9168cc033e670de0e438053ff5e65b49c8a776 95f1012f7638be63b46767e085d0b70b9c30e1ec7d8eee6ca804085cd331729e ab8983c6213fc8459b02079095f24547b8ab729406f2aaef3eb08cb043bf8c21 2b9c0ce7056f933d7165cb62554d33bb4b15c82ed566c080dcc07a3cc4c96e8c 2d0a8d4e0cef449c2a751293d153c8ca3d58c1a893534b139032226470cf32d3 8ea623488064f6873ff38fb366e5f5ad1eaabd3eb76d21d8f8a794478cb9978c 4092af7126aaee499cf2d4b463c86769d4f6c707cdfea28bf097fe5dae77bc82 027c021dd31fafe2bbf4907cd34d84b6ae93b84b1ecc5242ec66220a4475db50 dbe971295754243fc4ead5e324c6f2f8de5c9ff9e3757996f0dd8831c273e848 fad7f329e9f3a20501f9b4206c65136f41a5bd30d93f07bcb6fe62e21ddb18ea 343f473f2bc0b772f0538a03457a1746a3d2d4ffea7b795604b48cdc150e6258 5c5fa0ee9b139d1636384d84a9db39fc472e796f2981889feefc34921f45568d e7af8dcbf6463ab86a1de5798f3a2f75a5cf7ba71b14dc71d09e60980837f21b a7872924347ebd21eaf40201af3f0a6c94d7d0509bd3175e30a79f271fd5345a eaddd9a67ac7ed0aef9fabcf66b054142200abcb8b74ec5807d8a50604219e54 f7b05f69a278e3fd877deaeddb570c75b015519d2ef8f17da8c2ed0c6d9dce90 53e634810e4a6e8af3e8a0271fea951c9a93cdfe775e2d7062b712479c08c82c 076b1843c4e8bb72a36a872b1e05fd91d4344e4039a291fb406d69901137abc7 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 false +check_ring_signature dac8e851f03d366c6ab7175578a9bd39fdfee7739e1149cb441dd1d4683b3052 e36c8c42f292a1024bf2662be9fbdb3a0924d890c5634c504ed7281da9bc60ae 81 6b886619358a7f141e17a4bd3edbd040c797682e6771dc6e77b270617b3ab128 dd5b5b52f25d7882f0cde402b2f2b8d891aabf602e88ed7b553ba2f048e11791 74da9d8b99cb8c43fc7a2da78c2606f781056303166cefa30dc0b3215b0d4d06 d0007e19cf11cf3a36d4a025117831c7ea4a6e8c2c0b6162717b60b5821a2dbf cce59856eb71d7df4d527fef5c900c29413228a9f8ebba2f47cbfcbc7a77082f 190febb53c9706cc8138840a5b54fa2f0f0a8c40fd9a77dd8bc64d1d1c3ef3ae cd59ce263f96927ac7cc5454f5ef68ea50b236d4a33e1df8b40249c0cf3c61ef 4e75846995a6a6dee40a9d92bd22357034f052573f7a91c08fbe2715bbe0cf6c 4c93f8a020275629783cbf0945579620ed17e08881c3f83cad00c8397ee7f655 980394e1e7975eb0d42a97864a2a298807856f9af132d84539152eb3cb1b0f2c b8b2216d6abeab7fb11b3e58a9f278972a6882cf83d5ee86f035b7bcfe50d0cd 5a6b762ea5f34194b3aaafdffa94668cc931c83d9bd69bda7eb3707d77f726dd b4d83e9a063f7f5638870b16ebb777bf78ce015379fb0208c1ace82d86f6d2be 801a76436e4053b33979b87231cb7965fff16ea4a0206502e22ba4f56f09f999 88b62acc70d88a0ce0cb89ef08360e55c4de32dc0685ba73737e8cefc8cb238b 291775de4f254b8a6ceedc2144d24059d751a376aee818138f6d0ac607f11c41 48dac887cbfb349894f47e6a16aef2586e81d9321ed87ac864814d4fd3f635b4 581a4efe7bc69657287d12ec41c65fe9a673617923ad0efc7b2fb805b3a77756 0f690e56e68b2d59f2f8768a639dece865fa9b8154b6d63a5216e8f21e07e6a1 48bb8092e81b4f036520c77179d935940bd1fec9af08679886935c3f4f7fe9b6 5d0cce8c1a85bc861a11ce4516aab81ea2841ec9cf9a0df9fb95d0fa52b49232 bbbaf8dd613bc95fea734321566f14cac992e00a8b4143bda09451d3f4ed9e61 d892e9a7fa21c2d2677a96eb40ea61f30d99ac0f26a04889c37677218d5b0ee4 8ff87ac8920d0f9cf6f2b6ab90e8a53fcc3df1ce8a583515332ff719494e90ee ec000a43db49ae57f43827d8adb9251d7079e554d4bf911d11a919efc2756c23 cf6d8fbf46c913f08cdb48c692060328c3f98a95f81edc46a230247607de19c6 fb7d57f5555d09b9ec09bf606fd35d26fa1684dd5c5f2de7a9222b51ec8a8498 02f40bd8d10ebfb7bbad0aed4818076a81d82081b16b30b0d0c9e6f57f6fe1d9 7a0b6737738c0f478f9cef1b297c73b9d518276d4637b27a426babf60c61155b 511427b5aa785da6098322ad39a235603f30b861c164f22dccc9ea126de906ba 7aad5a146f5df617eaf15583cf24e9b6f3a176ed51e5b0cd03a6d3ced3a54491 5824316b08304eab88718f8393ea7f6bfdc0fe298982f9272867f3d814a385dd fdaa8fe2c7a32f1ab3e9aaab84e5feabb96b0c4f43d7a8908ae2ab253790886a 3e9548514ed02e99f5115cb788611e3321a5b62721247a91c48aac16ca0be7ac 085ae06d9f843d9c668440b7fde9cf7e25723f94eddab31c02df1aede298fdfd 4bca4450043b64e1db8fadeded0053537a752a3d050e30603b1d7a74f245b6ea a63a99d19e914a98fa59eb3f966ad076e0dd80331e095c4ff75575ceadbbb6e4 2e1795320ee28ed38325f9f602ada264f61434dd12919712995eacc58d096c97 77013ac5f19d45aa226d0cd334b45ed9934b0242a9024a0472671b5600570e30 f104c3f2e95599f94b24d29a11846fb58fb1fc57720301411773a60526ea8375 a4ee7baffa2dd47cd691535be9028677562647a74615fe835f799f701e57df9e 2a274bea5a3bdc0132fd38b04236a273b4bd9f463b6f24d1937d63dbc530f7a0 5e76e39c89120d374393754b074711182ddb993b2cb0453d8ab735b33b76d19d 7653b9b706337c162f7d6638a1dc4a97fcad82a906f84c33544ef65733f0b255 eec8d6b02c7abc09080b5df210f4eb0cb317383a2392a9be4fd80f68e44e4ef6 87a512b93002e4910ac8a67e961813f916dd7519cf86009088d6cf7ba9b097c0 f8b2e7fb4989e4113b1a9b67551ca05d73bf00a404dc64ee07523d3504a1c192 d3f27fa98c1b0df5779469f9bc3c3aa7499fb037f7f0ad7a6f4f2f425fa2abc7 33c86146419088d015dd2aee829604833bc456957d5250747a94b3b3d4185832 4f4985024e667adf3ab259acbcb0a13492a718328b2240ab2471b613dc05aa75 3517344734c8b6725e97ea37a26e45c94ed2f776a46684f7f652184c3ff7d18c e9270e774a09747f3cc3b4b826425c325d7a2b8aecf99b61595a2f5e588cba48 b6bedd36cbbcf139faad054dafb0f5e167f9b4f1f424fd51970b53498599121a d0ff4df1e3d865ad6313ef4d599513ad24356b28760f9b02d443c809689a5f9f f7883151ffa66da3bd7cf7b5823261bcb990dc8883182f3cfc956d9e4ff6f4a0 184a25170d7a09d11c9112e90a94af22646360b1f4733db6863161c2dae157e2 b213d72170e4c6a95128af13a5eefbecffd8eb6d299076fd62128d2a8c8b1a93 c1672e9aa7a965519728f23c68b90834b2a7dd069e6878005c8b2b884ed41aec c3bfa855e7b94d1c7a2a82fd28aae213824b111dbefd48f8b451a10a3bb9fb7b 9ae2a2be33b25fe2b4b5618f506665b96f9d64e22690a443ad010ea3aa4c9941 dd92aa391d0c41a117b02bdb597545102e880ec1129deb7520145adf93c025dd dc6d8ace123dfa6cc18cd4ea8b62e443e4c8a03319ef87e90499a3f96b22acdc b92a7a9224e3fda0a3a1099eb22812caa5f1f1ed364f07212ab5f9eac52ffc62 1798990205d3e15917987bdc4c2b9d5bed0a7f69f70538abf7b68f95fe07dd7c cf3c1aaa641eefa072340bfacd3c6bcefaa114404eddc34285027cbfd54566e4 78fcb481cc4995c8f48b91dd72661033898cc8dc4b1458b59393ed00ac34b4ca e77e6b5fb92eb43e01e1d1f38c48390b71db8a9423f1c39cc4e7f0a0d7c5dfa0 1c21d96673159c2b7be4bfa8616fdb47cf191c149c2fdab62ad85ba186e4697e 0d0093d296de57d0a0e6e8cc5a7e234b9542388452f2c5bbb203f02a014642ed 308fa19978e30671e16cc986309348a531915a60949ecc7b9bc97c29dba945bd 965d51dc66e458a767a7616d066e36eec9774cb0e011d73f3746f819efd1366f 7d81f43b772d6ed37208d96e0ab9db76fe60b6596ff32c7fe743e87ad16b1feb 23c83cb4b812a893534eafb48685a81334fc74e1e8b3e085ce81ed7b23c51ab9 9580470ca5da620d46ac874e7ec00977d59d4a6879465c4a79f5a325d41b1a8b 0e0441a454b02bb845b25ee27ef073bcfd125f5559981e3aee9943af5d5d29eb 3de74004f540c4423d8a4c51d2f3118c544f3f980b706a5501d398c4ea9be56b db0cedb80b88d6327431eb30d118f86759712f5bf0d0388af7276bb27d16daf7 2d3e5d2a19ca26e8bdeb1610a8a1c46d889b55ed20c6f322586b31fb0fc25e43 166d8f46007e730b51bc4870351829f199ff4369144bb64974b9916a80448a3e 800e18da9b2aefd399dde973ac738b58adab8bcce79fc4e1f52c6a9725b00384 a844819194412dc492604907ca27264db48aa083a497e6b2bdb33359f3ebbcf6 c03902f7464422cbbf32b5df8c7295e4d654c93770f68e85f0f1ad030affc40bd206ab94b185a66271014c28de1247ddc054eb4d1012d97e134bba5f0c96bf0e476c360d7cb5ca9ff58c68d4e68f7990b8b6b539e56bbc66d6c51f4ba065bd0c4b0f5cebeb3eda9a69052f3bec3647628f29ac2c19f31df14d76bf93c37c6d0ab6101d77650af195411254b5fe7622b2f540864d4e2b477ff44bbf80b7d8a80acd24ba8faf2c629624fe96288d5366258dd174f9b612ea18d97effb22be1fe053e6b367231a8200e4b317ea17823d63877d66fd3ec4402008a558b47adb2cb0e78133ad6a570eb51f81d7c5de245c43f2d9fafcc57e13ab445387badba2fe00d9083f5ca128d602138d6f5e378d665a7787e4f38fdf8247812b76fa323d64e046e65cde28ce3bebb688afcdf385e77292c2404003210bce0a074c972a9beb7008b0b5d7b9f23fa461fb9be32f57c594949e58ea4f05ca3cbad65f853f7a98803c0f2cc9d0365c5b04d22e858ea722a55d91d0ae057e108bccf4a5e13cff8d1095cb85328d4fd7d7fac91ac43350b61dce9a3c46a2b9c97c9cb1344e7a584b60039ee2eb8821e53d34696247ae3cbf1393248f182eb53aacb642c77e03ed8ed060bcf2d45d3858a8891e0aedd6b1a513f86cbb13909d24608749e05fc8ec6b20c8d5f7baac4751e36fc4ce2921cc83eb188ff63c7c8bcd3d82bf4ff8a9517cc079f3cff11c1630b5005d6e8ace85bbf1f46c63ea2a549f5925b575351f193cc03fea9a8debdffe24a1e0bb0a217b4cc8af00abc499733e4af119975cb72500b0634cb7a6e697c9ad65e85549b14db02d0099a5a3e7a28fa4304a88f2fc8b38607ff92f19b0e37838346851e3d1d05d3c2f8919225b206655a2dca0bc387607f0e7e894fd0bcf1f0f777bac8acd1214b032e41b8a0d6ac8d2ed7925c66cd13900cb57ab55bacc3e5e729c2a6ebf9750482332bd03867eaef992a12864da2331904b7f4cccc8ab845731785f54488ba7c6b8bcb3f4fb3bb14e0597aef2489a9730f7de56a48bf623627e49ad10c118486276268dadde4783278998773e9e50ba80595605a8912d0f19a40ccbd7424ecb1e530f918d35a05babd6064741eb5bfae08c0ef387ad9f9ca1a15bf94c4a09f8e9b3b49f9fe1bf4517d147b81c87744840cea35b5eea87dfae3c5ed713063e7c0c8fd4a9a35e6d7b65268a01e4b7ddfd105e315882af471cf13d72740dd69b8c5abea3ece7e24bb1e5727e30677521051035abe519cb7011af3dbab4a4317e99417bf1edc03f2602ee30a6387a2f012330ae381a3bc7c6c2e0ee8b6dfe6bdb871f0a2a382db168bd59f0e87dcdc049975015823bdf796474afd93a18ef8d101509de4f42b4bd60ad8bcd2b4f01ac32baf08469edbf7dd3c99da8d35ad7ec068afc04f10174f30db145c0150242a74eb1c02e898737cbcd0e6fe8b08cdf10b36f0502886270e5d11df9ef641c6aa4558ed02e7c99f8f82c85f757e25ca0cdd9f0fb26d934a2a7356898f40f426c884d79000fa94f199eb9421421b6d770b5e04e9b18dfd9da511f929d9d96345e7dcdb800fc187cdf24784673484edfe725971c88683202f4a3910097ca7525da816bbda08aa40283f057f5e03d058deb4abb08891972e875402a004114ccbbdfe034e8e02c377d69ca55ecc3eea4d29a60fdd51dfb095be718b88ee221ed7d405175dba0aa7af6b98d2b6147f90b651edd47bcbe53702ff307d106f54467116ce82e18503d6ea461425a14abeb60ed91a0ddf80061678188e384a1386da65284b92f76003983fcb16c9f955cc9cb636cb03ec049666b5687155a7d7e0d3f53cb4e785c4002313aefe990794a1e375d05dc5c7ac54351455a28b3f70c58296f2ab78755c0d0d2e6c19c8d4563553cc095911cb71ca26929edacc0672f53ab9c6ad9cfb1b003f5ea418a7458c265e6d095c093cda95e8da891fa499b29eaa7fa9c055db6f0be41651345e0bac17229b280f5e65178b472fb37a6985d5d0273332b4e8d7c705767cd5c69ca09d87d332e607fa72aad090612cf4a95ef33e10d057623cccf206429fd0b1be0b211cf8e369241e0eaf3842bf76dc2d0fee64e9e43322dff7a40cb505b68f40ee56f76fb59e94e1eb12e6fc65f54f2008ac7f87c09d82af89dc0d672e56d72ab3065891c14ffbdce10cd14263b839c540412b90e433c13e08bd0d37f7d39db80c0c6ece3759ecc57c73983972be3af74b9023abb9fd9ec73c61074358ef15fd85db4c7043907260fe1a973cd5d339e0073d174cd75f1e9530ca02023a3a975770b335b6183fb6e112770584161c0bb97ce2104b67151b5df2f205ca5b976666572bb7abb6aad08d98fa525529e89b7fad5039d14316d167ba620aae50b394a86ed658f8d58d949bb95f8a81be6538e47422cc6ba45ce666f3fb02a08f8695fb79e0607055fd6b1f65b2647760b53604aae2f53eb4c2a61435a50dc8b8a78a72fc9413f75710a73c39469c23b71a740db84fbad26c9de5bc7feb042a5af1f64b8df88fedd88b05a71f122a7201e3ce2aadced37745ea4ab9fdd10a0376189fd74062790324319e605bdf8b5c2846bf2791f7dde6381489fa646b0b931d90cb3dfd51ef895bb2ac844b25a1f14aaca994a901a2723f08ede289e2038fcf8710f4bf20705f58894800fe3ca28c2e12652dfa19fd08d67e6cc861a20210b5761870eba9ffd8bccbc95f8aad7f769b15d91d86909665d1ab17ca15720132c62ea02267a635fbd86e85c7f104bb9538eec57774a77627a0ff6bfba71b08b03fe6074f3243ad6d91fc5c2c9153b00182a2aca61a5bb9ddf4f2ca3a34ce01409452a2375e5404d1fb6d541f4d8996f53e598019581caa9021b059edda9a02065ecdecb5ebf57c58841bdf178c7a9930cd7eeb0300a24a9143f20f9db87604a5b82ca6d68d45d3f5ffe0e4a9436f9bb6f8c0d6a464c085d0095d3f0e7eba09c928cc8ac1d679ffebfbce2375902d9d563f49bf252e05c687846bf4222a6d0da4a4e1d3e2f0a673ce8392efead8fb6e5a191042b3b3b46a778c84dae8302609d91bb3d522521dda095ad78693f36bc3e48759b13c9950dfc48ceb528a03c10a12570e13ac51a689e0056ce1d23682ea048582cf9f04f5a90400708c9ade190eb296d110f2a011189244d3cca8beb54608faaa521d75b21e0228035e0960dc073b06148789ac2146fcb561d11d9779dc3cfe49e7f2033993e53997cf5973c90716dd54ef9af15597d1c224e9e4d3d183bea1f74997eef2a9950780347aff7d0111930e4922c022c95cc09765458a1e351220ecc4930b26903ad5fda659d23b06e18c17ca794df871a3a123c06352ce057fb1f9a4e5b40d0733bed0088a716407b2f431a1d1516e1953f6f4cb921eb7df8712282daf8a6c38f0b9427dfeb16605280042593535c48d2576e7b80e0546b66a0139b0ff9274ef652a0ee3df84e30c49d4a47077a7958f792c11fb61aec7a85eb84b6d934996353d6ab4b3c65a1f0226fa54adf1090f0df112d813d6a76ae066167552b1341844510c4bf7145d8b038eb048600e7a9c2412159ea6daa759cbbdb9041c7316cee81e287307a77ce10af40c5ce438d9aead9b25fb13fb1d7c2530a6c7473ea386ffeafaa39a3016120de46453b304df0d2e32529f13da4337857b68cb97ea902eb6b3af5557cbb3fb0323f1c9d19d729329021d2aa835d23f6298acc3f467b9963a8332cccd6fea89029782352b55ffd760310e0a201cf6ed9f90ec92f2427f1943bc2e1482ee7ae3021b88beb5319a8037521a9afe014bbba76b593fb461a156f03e13bc5e2480f204fcda6b9ef533c5854b7abb2db0b138e732135adcad9c6e5da0e12211117b4c000165c1565bf2a37526934a45257fad46ba9f8c8a839128544ad2ecaba50f3b08307b9c10091fd083323ebcc7ef0e4dd2c5ab582d37689905a86b9b7f170c8c0bbc385280203660520bc25f93dcc00b6d652843b3cf6942342bc24b1f750b51079616fede7eaae11d84528e8301ed43d38c307a5e6c196cfe32d2ee3ff1dd6509ad5806fd052efefb82ab68e5e35760c42a047087958ab77ae848b008c2066a0ecbb3c23bb5df7e56c45f7c14aaa68d5c2f0d4bdfaa75ecd002f32286890337050681a88de1b74b65814801f9456fdc6235a140b764ea5e9ac56acecfb038400809cf8d5ee389977985548f5ce754f6ffb0f6c4b5608d160831d7b379be20a50fae5e33d53d98d1bb8cec4d654e73d1bbc4ff9cdee23f226c3c2420087eaf120f4e145023fb5d8a0f9fe3c73eabc9f56b0d6fbbd7a7eefbc694bb38d29230ed03fc950f751aea4496fc7e558be6457728f9f5b7e9a51900f6eab73e5fe262ce0ff4eda0d00e57854776a0f4021f4ed7bf264d1199be2826b42b052221dcdb5e079a075210ea9993ccb2de0ceca091b00ac790e5955d7ddf52ab7e435694cd9d06e65981e12e093a51802032e6bd291d4a50f01517fca8160d282f7e3988c6da02e3abf1e2cda1d02855445e4b4b49afbd7719de2bb4303084c437112c7928860d75db7da40b6f2e20acc9d4862159dd8051cddecbf995d726d4cabf1512dd8b0181162f0c68beab2811de7e0672e2245754472bcdb2e7060163f3d0b6cb8f8906c64e4b106feb9735937dad6ec5514ce1cba687969f7304efb5f925867087110b3fb1b38be935daa70ab0b6fa6b0d3e51afaba2894fb4a0e5346ce744b032600a7b53c4ef2525d29f66416c44096ad7c55c99d018033cb8cbdf2a90638d839e0f319897b39cf1efcf6f6dfec2d603a219be87d378f7eaf22e84f64ae9b2e1ff0ea08405363f8fcbb1dc136a568fa99b32c767499897b38a61404a0aaf8472e60421826a8cba7c302307c16a38f59699c8d914f2a2baf29d3e267f0d7854c3c90806b0311a9a6b7afb9703ab2fff7f2efb94d8d5d3dd4870ce672fe5d196dca00ac66cd4fca86659b3d20571ffdc75839e54e592a2e2344938671ad4701c522c0f17e1bc1b7c9f4c381ccc86bc796b713942a1c0e7912273e9e3f417be2ff3410a5ee984d018463abc67d680b712f2c0a7f203a13e7f9d8f59e2bb9f9b6c56900d644114196d49d3b09439e2a169650828c1b19fff573bf77a8c546e288db64a017846b067a344016d65fc5716087c24d930e195f04e4a9e672b23756dd45c6c0e97e26a198bf1253946cdcb3a0b6ca3b39c9780b7e8dee27a30a0627cfd13c906024151a85e6482e1da905c3dd482bc79652457f5cb46e816231a301f72bdfa0cfd5b2413d939f55eed4b2182a7b5870493105fe6444d747ff948b1d842fea30eddeb72f1edb9d3aea5b9631080c0553006d8de8ad58d25e9654eef9e1636830244c53846e799e7605484767a9bcbb059db75d2d1d2d232a1717413c2beba6e0631aec5bea7a181c89263a278c3f498174c5130b82e9010bd4e08c7b15b50f0060f3918b590370b543bcab739fad7ad1d5eae32459f1c9fcdbbb4390f922ca20adf819f90be7d225615fd410eecaecef29688cfb312cbaab2ff585f6131c4a304d1952e3f669848bc0c4f26fc810593f7ab7bcd3569525bd891cd3772f62e0108d50199d2e7a1c01ea09a05701be0f9c43deff0b192daf4ac3084f389a00f9609f9eaf5e0ff76020612ef163cf1ddbcf27ce624e32d7331aac7af5bbb2705950c41054644dea2310f8e1c7b4886ba1e768ba0cbf6e7d064254c1a35142604de09ab349deacce679a9fc272edfff093dfca1777ef3b4ef622438d34bbeef642b0a66d6456a1db19083baaa29d7bc6ee4ab90c0e4a7ba173c7c3dbd3533cc3d3d09abff9fc6ab1c2aab5d42f54ce8ef989fcaac419f5cc4c7af00acb526bc19ee09bc28ab7e41eb20e110406fb9330d0898b6e27003e9f568c5a974a04c383c63005f786dce0853ef4a712b85d22776cb8129ada8c184f84fdd817c1dd662322d0abb28a894a829e4c61c3ac52977b5938746579fb3df65f168e8f92e38616be7020f937d880a0ca98fd53f3b0fccc8e6447203b85ab7f3380e1efb9c9ad417660905a500254e5425b59caed8503596ac187b5dcf010d758dacfcf14996f4378700583d9ebe23f2e02c782661c12312c251bdd0b164ded79916dc70493ab313e004d1e4d2cfeba8b2038790167f7c682196b9050468198496879be36d7a8ec94908a870b0d2c31de4b31b44af055e23117f5954d34240e2667e1009211bad8fac0e5bc67939e4e60b775f1e6d52d8324614e753097337a340322c079ffdc0da54058486aaa5dd61801d71bb527e815dfb4e0657523cd127c795e78dab563a63570f4b9c2271620484a2b4633fefef1812e70282ebc4502ebe5b22879e1771d12006e1851903f1362159f7720bdc4e733827dce97999785a388c5376094cca712506f8692b913369bd8427c8bb4ecef77047f613f0e1911dff1aef8cc514ee01060c3ecf17596ad53c777cad4644702eae2c388d465d807f792f033585807e960607e9c32f0b24f177c5aab2330a71c00ae9dbe45cb3a3a4d403f1cba0de24373a0e5906924ad4724b298597fea251aeb5346e0bca7a98db5fb439f4838f5d15210834c0598e0054bc95625082f3decb63e87741e49e9e36f8af8ce6e96636c2430e6ce489fd3a0ad0a0ba14219f90a2d0fdb05b9e36ce417de182ec7a7075f1dd000ee7b40f807bb8cac3330e97524bdfc99b3d754a3a5747034d62bc99b6e4e60d77aab76652a6e05d303199513b3ee691dc5544f1c45e777892bd920c134f4101c2268f49d84a5d5e7202372af5d45c5a86685255c3d2accb8f41a0119dd97a0cfe1e1149fb1093f9fc5b3de112fec927cf2fad4dbf1f6e915eaec782d78cc900de4d7c71cae298e77a80735efa227d328da5d1a5b3da17282124328cd36bad0a77cb0b675a1f8ca608925b3022455f3eb2cd604ab6f0d5b818e638dbd8f45a099750bf4413990b40183542da58539d8c984ab3d219fb8bb68a6de2eb60bf5b032aa28e494e335033507cce5f63b095c776d7f0096d68df83a7687b6002bf0306e6ac11f2435fdfd61143ef01bafec37750c00ae1818fa226b6f9e266ee8ca005fc0334b90c77d3c0ac3fa1b0283f0dc85414d17eb00cc1d098989945b7bc830664863c27b52c02f8660b0444592c1b4c3bd4827f751d8fead32b46364ff8570624604703533bab54b6f9b2d5aa7d97235aebe07c57f73b93f75b49530c39040f82f90692607720a11bda6f7d79974828c04dee708c1bf850d347b64c14aa7709b391567283e921e9a75b81d0b3ec1a4dc74eb74fe563b5d6b329b4d16b42e909 false +check_ring_signature ddacacbf70e20059689ef56490703de883a60d106cd9463609f3367aeb8d9dd6 21093235ebc1baa439f87123c4bb33ff80c96852542d4a7b417bb6011fa12d02 7 262d41d285382761e321fcef305845fea6cbd4f51062c562fe326e28fff682d0 7ce1cd53dbd8eaf4b4c5280308d69be10a403133c524b1b07523692b36bbca12 2f107b50d6a8fadd7cf12989c88c76ef56f28473d23af57ebb93cd14bd7dbb3c 53e69445240fba7ab3566401a735319c943e591c36b075584078ac7cd111e948 8793978ccb9462778094f20278627f7a8277293c8d4a4356b94f6232a6dab536 f26e3273a97e5c3522ebff165bd8e86ef415e6ecc0b7aca91089198c3ac51f24 84ac887ab30fcf354c86d2b44722ca02e5ad09319e8f97717a3a9357a7e4af4d 39096e9732b7f90ae79fcb20c90b8b783cbf27a7fa1ce28bd651fc17298dd606ee005c95d938e11b7b6f03dfb66bc99e860a2c690c948ae892ce45c34af0d502771ac57d81c80bc8cae326b77225442817a3b4d766b0802340f1ac3d1ac4b909a243803acdf10e35702ed2d0d04603ebe2750e54d00f4c037ac02c425cb74806de54d3e97844749a88f40b14ddfe95ad7ec2d528858b4787d39a3c59f017cb04baf19d939bbbf3beb253a375961164a4f0f4a724de19edf3f04830a6cff86f0b494faf793089fe1f3c1bba6d978b3995af2d286f4567dcbb52957fbb6b69440f326e22b1df0f59b3340be128457589c47057ab62f2d55a508801b5480798e00a59da8c4fece877c052c3ff70d1ff1e57a98334a2190ee04109891eaef8822b0d864c99aab0c192352483e746a7264a0081b7c9f04f537cbf660a90c88e23a10917cef3aa9d417c30eead825821ac2eedefa72bb74cd73200b007d1ae9e9abb04f7e58bb672d7d413d90aa044a20e64ddc50c2be37c73e11a99fff669587c0118c87e40d35532938a81e7ebfe354cb3b0618ef7616b2cdbb59a8333686d3fee0d757cd4901138fc967ff01789aa1f267191e1368b170e6ae0788046bafcf08502 false +check_ring_signature 020c1abf89bba29008dfa37fc57365e0c315e54cc132a6af3a8045d042dbb1df 29c8fdc88b45786447907af87ad9b37fe4c3c91d7722705c4afab0218809f2e7 38 f7caff3e9192b311a948de5bc168db3bad905f15596367932f6b1541c5f48099 519bdec2f59d1632cb5b60bb21bfb6c9a131707e079a247f8928892bba8471bf 8e6563aa06b0f45d6d5b59b68c1ffaa80bfd5a3685d6c18796442c1ea171ebb2 0b99a392813a735dc380afa1d5cd61c8b5ca9169af47ea96f1f9e11aac6725a4 0f5069f23392041d5c3cce8a4916dcf31a07b909f1f967fa4b681ced918ab6cd 567941bd9fea292b7f4d2a867a0487858307977675cf023aa8c9300a560c3284 0b096e259630cd439003dcd0671d7f68ae8ad46b7abc754984d2315efea02a2b 2051968d33e8eff6d6077570f98dfea2c22fad7a4b78e5a7d4d361864eb0eade 8fc456bd917e9867c5e7f7bdc8e43e86c22d86f867a0067bccf426002c1e506e c5fb833c2905b91d2187fb4676ba8008b901f3e8f1c04a8b882b5a2c598f16c0 9fa14230794596b838e4c9cb9b8ecbc3aa11785dfc45a715eafc94fac2174d91 fc2757bc10885059901c066a55d90b71df889bb2c0635ed0e0cb087e1a32ee4a 967127cd2b59081c8f0e598cb05aaa1ab1e26e6e73c872dc8ac7fca643b9010b 9a50c679478ee436352556d70a27cc2483376baaa3e9ccf682594fcb23566c66 21815484d4a445ebfceaf5cfcd3b31e03db6082d54c7a2db513bca8795ef8967 4ee3e391c4b996feb592ac0634a51035cd25ccd87d29ce5612325b94c0ab82e5 85f978b13e909ff5e5c2f7da656716ba82c21a450fa7c26396e5835ba4dfd86f e76b2d341b7d055f3b2c2a93d38df2d1618e8df9c9ca9b5a33365cf341211ba8 c8132d71a34892dec4a1197740ed92c2fe0cbfa042ad9db6c8193caed41004ee 0f7ee4b02bce65ba033dc550d5d98711f06f1c955cfb7e7a1bb02b64e48e301c d138ffe7345d0845a052e3a78be1fc2e28a953d55c349b20298b134f2a22df16 00518b20e48850797ad9abb3187d0d5beca8bb523662b968e3a910a95c77a71b 57c6ec95b448709739b964209b650db7b70b07e3b9f6d4cdc61041ac36eb8ee7 8c4cb69e3f23267209ecda480b7b2b5cdb8f02bdf11eea72d10dd5219317640e 350db558c13021800c59451d316060fbf861837d3e2dc8ddf7fe8cf13b080328 df3884fd9104e3951b854e48f5e88ea5fe6f4b5c513cacdfcb22e698cf318320 cfce6a72d1b557877ad41342485080b8d83a4d63b6876baee52039522a6acad8 8757afc63ededa801f499bde3789ea9ddcb519f10188015e3b17d0a6a8c57b88 644fdfecbfebd07e51cec67b7b8e5ffa020449616918d09391a36890731c3cf7 9c143ebc9de667b5ec6d1bb9492e17ef6daa9e693076e25fd9a73951ed22c0d8 8650b7f1260be0b86f98dc630c8ec51173303c2db4ecef11d2c335a5eb117dbb 1fad73e9cb2a74d8575c3552f8d4dfbfa76723a6946a580ec3fe7f484d0abef0 a910b5b82fcd7b791e49e3de3fe9a1c8f157a32ba9759b623b58a538880926ac bf7ab116de8f7d51ab0827ba10579ee3f8b7f803a699f28efa7bdd835acf9cde 023cb4d2e1fa2ebcc6914a4965a5e088fe30dae81626cca1f7c1a1a33748a9cc 6ddad4181d655923e27c2303e41b560a6d506bcb56940a4235ba2e343d413b87 a3ef37b9cb68cf6fb83dcef8e357e946b093f5592a4965f9281c29a6b9f1e7cc ad467b4a25a6a93c2623b78ea258b7506e19f41363307f4767a551049e4ed2cc 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 true +check_ring_signature 4e1945ed23b346d3cbe140d3f9cb68a4e1dcf515998caf7c30b2921863ae01df ffc9f86d8b6d12e5c754087338f6c2fb59b02c685b9ec9b156f33728435b7d29 1 a70d9d5e0ee74ed85d5c0426eff9529ddb4e4f74acb096470f0474e511dfc6b1 e02a3413c3d9b8dafbed10dc9e168877272015f316aab00580e18a81e7861f07aab71eb1ff0d32ddab3d8913b5b8e8e4487412955bfef608c2bc11eee18d820a false +check_ring_signature 0395b5e5284698e3ce401f8bc0096fc621f0577643dee8494a91e7614e3eb77c 66d45f27a319ccf3f54d7effcafd3d1ccbd74928404975e8b2d56de2ecb3bbe9 5 ba51365cf7f6088922341e45ebaf29271ba02adb5e7ba4c69f788b1dd428c307 c42ac89bb690c829eb2f4b640a18ce18f515f204e2348d0ef3180882fea0df64 a048e1f93168be5d8e63332aa6ca03156cd7b6de44709fefcd19748639224c86 477330df28fb508027e951c403b87607f9b6ad2567ae8000be7ae067a598585c 972e78efee9ed5d9a5a971a3a686d0dae780e5b8e764e00284a6f347feee992e d022f6a1825f8e9b500c10f1a150b7d6ef9338195eb29d598afe1ced6c997d00e8f46b2b36bab7dfb4eb710c0e78a2af1dd3acd087880412c9d8a0b233d7b902e047c786ce330025a29b3f81e0d4c178d70a38ce0d482b1dbffa690aefc9a009e27eeed958eb5bb263785ae412bdcc90e6329ce15e53880a82be8b9607b12202603ad266b9638690cd5dad9cc2cd40fca12234b4c4b230a011732bc7ed5e560fab092652695f6bd942b3537d4f50501ff2c7c858964246dc9f88f573cc017d01f8307c892b7c1793907352077c6bc9eb3eaedb8cc4a444780c47810d13945103bf6ad658543ac308b5e9307c58f7eceb6a303117b07f391ecab54a138007d60d591399d9d3328b59b1827e12ee816160e59a667a598682f7e33d7a450f95c90510db699ae3db443014293c77395ce6af4f0b53394f6b29d46bab1837e02a5520 false +check_ring_signature feb42639abbc9a20c2199e2deb92239654feca3e219fd5933738e39867f7d4cb 4c1f045afdff7350ec2899e62d0813dcba940b6728562f50fd53dddba2231792 11 5474b4946bfe2c9de08e18e8e7c578789cb5e816f17a2e9efa83ee656d3ce3bb d1a3a74b386578795a5904bcec56c961c3037b1f1c03604d9eda1952893e7d89 d6a724a0ce83a58bb1bb4ea9cf4cf4e725e696490a2eae8a5a0e92e8beddec43 98128aa2a43c214efb21d198a3734020f593f86708611823676ea0f21f4a1f42 2291c2b7ed7b4b1ad46b1df607bdcd66613cc2bf1750591d64b3d2cd39da9a33 6a3d341aabab7d777f80fc15551e4fdbbd06758db5013aab260a9c6b89474813 60e60004984481999560a75626f5ac60bab3cda1bbbcc684dcaf37c6f023c767 2bf377abe9e9d8b1448a09954b6a17be2e6da63b4e29c0958f039c4f7d7f3d27 270203492f0733ee59d9dfe6ee5127c67e388b52e28d7e2b7602aed2dedc06d8 bdb3bb276cd9cf87f68b1f396f35275dfb2909ce0dc1a6079316ec88d837aa67 4508fef27449d8d7575d01e21d626ea97ee454f3cb340c2496d10c51b0bfb374 5a57810362664b60329c6dc24117219556c8976ad21e35625c9132196bd58c07ae0d6dabee8d0fb11860fac70cc98e027f32b262220547cd78d4e2fc1823360180bffb0f9a444f53b4226f7f1d08a0720148a2088f2986cc1ac21a6cd2dc990baed4ccb7301cca955591a8764006af453298f54586d3beff1eba491ea07073023a3338be1ada896d724a72161f800637676da0b29b9ef4fdcbe15e5c542e000cce90ddcf08e7a482bccd04d065e99cf32458f45f564dcb70bac1d8da5e99780ab07f01c5e2384af215cbd048e2dd2e7ac10f99a557de2bc1601a2cf2ed46e70536ad88a685835add872a85149fca9dd35c18c26c339b6a1edd47ac2758c1830685551eff802859e3d56ecbbf9188b4300e0aef74bc579a556061b44b76d7600e45cc74cef0da363cf888d97c381ccd7c649d40b29e3b4e799c75fa2b4089d202477b9ca08a4b4be7fbee4416cc1833ee94efe3946527ba0b7e68b92988cb160db66307eb66e06d5f96d0e0d9f673a3c02aa57a60db35f7d9fd93fb80e6811501056ce4ee4e0474c330d0e6c4b321550a1e520b35658bff8b1ab4bd10c0498a0c010ff59b281058e9468a805d4f0b9b0d01fb98aa2fec08c803aacefbecda9103848aa12b3146d8f5287e4baaf48eec5b3f651326ff9d417389611fa72d313d09b46ed19549513567b26a5676f986971d86c7ff5ac544f9cfd270f7e0cacf240848c3b727c979fca98ecbc28c6aa3f5f91808dae1e217194209bd191759c5bc0e98543fd917276405f4129012f27b45e207d6cdb74e6ed36ffa22e28e91186c09b8ecc02a7d9602b1fbb2fb8bc9fe4e94125e13096dbd8245bed8b240cebe9d0e2bf729c44ecb7c3ac64754610e1b52bc0ecc2860c1a09f96db2fac4f719f56013354b0787576332c2bdb94f8b42e6df955ff076203dc8c1e1e42876407d2b6082de3f3a13f5f05447975e54f8c1af026e16caeecc575e114a5543467d8a0d203 false +check_ring_signature f5af9fb353138099a2e0fdbdcf836cdf3909f3766fc309488f171ae674c76b59 0a34f2f510b1b8175e7a7cea7da76cb2e48a60aa0edb70eace55e7086f182c96 5 cfbe8a4712a68a14e8533bfb78c501a7e15da3a14bec1ecc5189e7974feb8727 8a889179e2bb05df952861fdfd4d7c4eca8b9de1c60ddb109537fd6d7ba44ac5 ce6662fa54bfd28f7cf04cbe789d186ace0316ee9f040c32654a70249800126c 23294c51294cc85cfe22c59cb01480923e4be256b68e6a069b18d83dd55073d1 8b86398f0146dadf887e1932f97a0a35df18b2cefe17773b25d7b85d8addb4bd 1344f7f9c41a5aa6d68ec10d355900bc6541da828d9d21be9502befb59e73361acb2d510ddf1f5fb5f39397d3c9605da159f10b84bb46e1a0c88d25b31cca30e2142dd3911f014c4f1227c05d5628d4c68463978201325fc9691f5910a97a324299954ec3c81ceb6c604c85386c5a7277b295713ca907d933b4a591b4a2a540c29ccbf2cb2a7141da3d6fab5cdfcac37b72d67da38a3a2449e44fdb116d770b22dd8d6b341db5d5be3259264e55222452d09b7f3193de54bb53fc5a513f0650b030d25c8a0f30ff748206831f29784558f1331a11bac29228db6ca9cb066d20606480658904f83aebea1cb80aa8bb803365d0a7f5d19293046dd874cec3bfe0ceaaf9e8df03b240d71c3835e4bb7dc0eb03ebcfb10447ffc97cc2d6faca12302617f6bfff2e4e3f7b22ca44243c4bd5b77ce59c77ee65ccf1a440c9fd6229103 false +check_ring_signature 67cb13193b03026ec1237194f2ac58ae268f1654fd94d095215e2a3757ca7172 3b3eb7c08dde92f18456b3462aaaa5b009700ced4b41c5228ba99f9373ad59b9 1 bf54cfa8a2b9fdd0a5de95eaf4fb32a3a946180770ef66dce3dcce2746af3ef2 df363459058502c564068a9078fe97d44227bcedc4c8e8019a3e4e8988a80e030d503e9b75c5c5d6b06517c86be710c77e7238c41a69fd45c537fd8835da60b2 false +check_ring_signature 632d65e6ee68f522f6f238cd1d6e01f9cfbbffcbfc66e8bf3e4c4f0178409612 da3965f325a705ec9d876383e8f723e35ac7136590008b758720c2a856b15536 112 9b06691eb81af086c25d33effbe4d451ac6f2957e42752b8d3733f418ea5173a fc66f27ac80449fd42b3969ffc1d982ca2cd5606db42188e9237a99e28dc9b96 4f005a1c50825558118cebd82e0506b985771acb881bf7758181af8008f73e7d e9c193a0c412dd665a6eedadb520707819d2f1396718dc493026dc7d8dbecb25 420db0a4334042887dac09328690eeca53efb8e9756e3fe62965ff216b4ef6d4 12c0f08d85d91741f4a75a9fc1aa4f7ef3e4d204c464c00c5f9882232b28c466 5c607ef62d83642d2cff3893c68f21e3bb8d6c161fff73a25f40bf72ed08075e ae3fb2442a7f83e647b991ee26a14e868291721d6b8452f469afdfd471c1b7d3 b6bbb8627f1fe0acc7b254c94a4be5941b7374e4c1285cf806a24fdbc00f83c2 693e10f50ef40e05fa7f19173080d1c15170e20b726ec234d9c21f18dfe96fd2 39f6fef9f90ae4c5fc49c364fee226162042984ed83e5a4f32dace9a63505fa8 376aee15cc1d845be68afba71a87cdefdce6166004e400f847c92d7adbecd1e0 9ceefafebfcbe65456fbcf30bd083b09bfff8c26c0654cc934c7c88bccf0f2a1 965c183baaa47a952c971296ce8a9d921d707eb435c87c510882c33b690b8431 1311a8d5fe4474437ade829df305bcf782f7f23543660c498b2cd5d038778cf6 8d2bc19215a56fd0eee8d9a22861db35ce8a79064893e9aa474757bca806ea5b a155f275e4fd97f07eaee1bd550aad6ff3112d870be9f9fd5a45ee6d509eee7c 75998dc51aadd9736511983b3fba1b71df1161a5fba1d075429f7dc615ee1721 3c764f2a00bcb6ee2ae876b2c1a067b61ee4ae800d6456f883c7c9c417f80899 7b32adfa05af2a40b78acd2ee7ddea0e0c08da284f1a5d1b5acd64982492a22a acfde3afe6c14409bf540517a69b4591a7b4b3934712bd1b30e3aca048ec57df 7ecf94d2207de8d27367441bea3d95ada7d3c724ba70cfa05d1d3d307a1351f4 ea0a1523454da7466b7f2d041ed6d8e0fa6647e4bf7bbdd4f556536f79024ec6 1092c284adcefa690a87f463eb2f1179d0a1df94bc328fcadbe4487e54206083 949d257dfc1256cb08cd0e3dfda4c0a2e7ab4d58b6bb30f1c53995a20fdd54e6 a8820c353432d4a5870f0eecbeb40dcf9fb090feab404f0986ae344c2324d7b7 11b79c7e60042dae862d55d294a6cca207d8c9dd2c55cdd4e7fbd74dbee81c9a 9375fdb122707fe650cf95b2c5bc0ea86e614a941bb303d8ad758099929c5db9 89e80d7dd1e0eb0f811dd58c6af823f0683ca47d72e46f52b01bcfe42c5caf2f 02fc56909ff81f442270995464c53b7ef5041ec16b6344aa30199667f9e20cb3 a601554dfd1b173f62e360412f2c7e1510e9393eb257eeddb8a89bd47eef40f8 c4a7e5885565ae702e78e5d5d9f1f039b297a8cb3907e6ec6a395bedfd881f3c 7f7f9669b83fddc30310db9f980185b961980ae47ac52e3121e3627ad6db863e d1c92b001fac8eb4b735e49e7f983046e1ab1a1ddaecec2d88758870d2c1fd96 568ef4bd91566fb31d79693620a5997545755c8b014f1c3f3b7304a99027508b 09dae4e581944b1e9e82e5b3b60a9d5670486d5cb217caa2e8da7e3177092934 aae9ad96364fd479f99388c8f1a8e83143cd63208d41c6d533e8c1970889fb12 5f3ca575653d7ba8c172b67fef4531455d7195a90350a587860e981224b95b1b 736bb828f5bed553ab78726ba1f668f320a447061794f5e902c265b30a50e598 510bb20cdfce58e15a447c6e1fbf6008cf2cf6ecb154426dec822c39cf9055eb 901da16f314a4881ed91502823016ab274a4defccb30941a15ac44da885efed7 a7181aa105659b62f45a0bd798bdeece23145e4018d3f8c017229aa651219620 f9b82f5107157d2bd73466b3346d0a0cee14ed8c2a39a752217a641840f25e04 dacd749fceae680928d54d7e8ee4a6ba9a643a0116ef4840bf3cefc4b2b63fbf 182c5759eb53a8a774b2735170a7260e0095d6cf50252e0d8436644e61508f77 c7eddcb6ebfc35db4182de753416807955bee687dd0fb5d75125bcaf80f3eb9c 17e19b042b719e3252261689e88b93a81a7f2a23cc46521bb987f31bf08824e5 abd09fd0777c64b9191bdda75721b00a1c4ceb604d89c71894cfb78aa939f846 9f23e1d26101e4761f3cfcc6fce8023a07d1fcc00daa4cdcf4b0c2e250fcd43e 9452358fc5886ec4c0f2fac219fc65778505f40e46d4b24f75bb548684822b69 6a8c3d0cd864b28a70aa8f42cb0592d43c964c9454617aaeab9d6a1567083721 a99c71b1852ea91cde969074ab9738ac9ec1a1f6b4e2660a67139335d38f81b6 e80b74f712193d20c89d950feee6770e06e22a3563209dafba2b37ecf8b309b9 bfe7a00d83a1e6062b5d56888764858fe486dc6c06f78a4679cd768598bfdf32 246a91443852deaeeea21449f4cc3b1eba4e80545fd205f5c777c58c39133a1e 06ffbf75155e0833fa3f163ce282fb589d970679c9d12e325fde4da86512a7c1 26a0b25b053b306238f03da2a73280220b0722b6b45bdd0464dc53e109a41f11 507ce0261a02bafe0954fa822c42438ee71c3f8325ee17a80e25b128de7ecf0a 63802ed683c78e0ae93c4418975967407475e07d70d599abf4dc13c3f20640fa c239b0eaaab82cf43e643dec29a41e500474ab243e2b4096197998b24a1a7fbd e798153c4810d31fd484cd880138aae786687bed1f7bc90de2a3991a2331557d 8e12e4c229ce16dd981667a7e0fdd3fe6a1129535c9d0dff53d83a34252b9c03 c0391a64d46cec4e3e507ecb38a621d2a7b1cad1720d2bd140e940dc869ee406 8d618364f48234d87e8e97a9eb2bf95d97eb391b9ad924c793f209ab3141a1a2 6a2900ebf2e7fd4a734c9e90307b0a701c6fc985452591ca46cc6c7034aca603 0d1e73d1f268318b25297e4a7c25f079d38d495bc9253cc4ae92c16402c18577 4ee4166a19fb3efaf1997d5ea1957421865b9dd1ee7f5bcfcf86a4a54e1352b5 38053e51fdad9944c0244141e0b05046948e93d5a0f40065c817762cb094b995 c548a25f18a0e836c2449fc92c215ff8ea0ee0b997c28fe69cb86c99d180f87e e07e49f9a9991da86bb4fbb71413f4a03ae471cc2dfc76996c6bf718f3644818 517066972b60672f903e53d3adab4e2c690f0f31b5ed144994a691e644314ef0 c285fad9d38e2d49439c83ef188f44fd9fa3b0cef3f2f77f31e8e42b28b2bac7 486ab6e08e29f39bfa1e4ae2b763d2657b3840ff84b108560dccd2f73efe2345 7485f240ff47e14ebd6193d3362f1ed28ce9631d046d60a284b4512f2ff98645 230d1ae27b3331776e5b8433c34b5be5f66f59b4250765adc81cde19f01e0994 fa3a772b5a6e2ce9f7d0cc481b9fec15c8aa01007b75ea8c5105bae26a43bf79 aa27231826b28b087cf8bb0d4bb0278a8f7bb96938f5625770203e3800689c7f dd40738744c91e93b10d2d0947cc847a06a92904bd3b8ee1f7c5c2d5e6f7cf49 b812d8d915addf87227e68dacdb0e0e8ebbd4ba22a37dd56387fc09bedcfc62b 55b1f90c1d3eae93f25186f4e91abc2bde316d7aa7ca7998cbf365de487c8354 35074e6cc45a257ccb5d37a90b145d6f90084a25485733960165c3f8a8ad7f99 b8739625f5c935a936a05ee98e348c1fca45bfbc641db2154c67fbf349a9ec3d 72954bacff027610bcbf824fa9800656dbd93cb54cc921c3b8bb444229543611 885c74daabf5b3daad2f78826d9447f946d9213a5014ed652b072853b92b202a 5fba2a62dd7250afb8386672baeeac8cd25c9f20008e9a629440bc8c1fc0ba5e e842a4e6066749b6007aa3c5ce5e34d72474a91ebb29554cc15bd3322fb2eef9 6a996a1d6812438f43fe69eeebe0c35144bf0b912ac08ad325adffaed2a01c06 d9791de011c2d599f7413ef2299c4a06186f5a18d1ebbf52a16609a277e6334d dc73e2f0cf1473e4fc82cfbd9d6b3d057d3dc43dfbccdcfbcc9000a0c3b5a831 5aa5f10e6bdcc19f0be5a23e437818b76a566b8725562c55b5f04a87369d05c8 91eaa0deba2be41964dc8271bb2ff1b52bdf6f0bb78d9b93a4963fa27083d6d7 a491a62db5a534a3621a9fa0ba9483b19a7a26b0ddbaee45c6aaffc8444b8295 ebf03a1e5bfdf7b51347d9285a48965be630e668ae068bc046ae652aae3e463e fc73321fc75f456fce2dd35ed9dc3c1545e5e5855183d1b050d5cb269539e36f ad7d19e9f17a912b8620b9ada70959697e50d557b539da6c6407a729e21a84f0 a509774848d04b59953e69d1d196bdfb9cf72204674fdbff0fa341ea081dddc2 9e4826cb7df8442b86ae772f21331c4edbe468e727aaf63bd5da47d55c43dcd0 9772981e352d8ad2ef1a4178b725369166f5f6ef8df18c14f031089ee0ef6d15 b3fd3a3d49fb4f8860537ec6512d1d656ddb9b6bf4e050870b854bc73b8122a8 65b81d6df6280a5bf96d1a14e51cb523db34a4b5334b826e970f55847a20b01c 479c87cb785965189f3541856ea0b20196a888990869e15b1eeb2755f170b0c7 5f4f6145be506e8aa34061d522ffa259b8d9c9d9ca7c1b8ffd6917c31251cf45 955ce374606c426e587f17a019411d438daf97651124c7dc0a28acfed5e38b0b 8505ef7b77d64f4dd2883d3518b5fa2fba285bb082a5fa8ed0aebcf35a4128fe 7e168833e41b06cf8f6b4eb9187e7173997194b6ed0596351c28352239965d8b fb31bad3e0f0dafa0fa2f572d37663a08363d749012ff29426fdd33cf5591c09 82c8a557b009e980a238bbbf2fb69d10ca8ca1d3cd0c23e7965b9800adfea4ca 079ca8abf96a112041b6321e1e655b1b74da9c0273123127a75fee1a2df8de5a f92d112f3aa791c1c3139125a285c60b2bc97587ce1449bce2d531449037567b d46e3066a00df0f955c57461e82caf2b1a73b3b986c45e35298a435495bd8480 b0c68c4f5c20484f4d169f1195a66507d1ee749c0647ac28459ed4830da2d5f0 820ae0b4c10b53d48631ab0c193fce9aed65bcb5120fd0478260196e07bec383 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 false +check_ring_signature e3f3afc1774fcbbc9d0d9853fd5e5ba344ad06b283031716b1512b81161bfd53 a556fcc07052e0283d45391058fe5f0c0290cc40874f4cf6dbaca098d5aa2465 6 22d74d1c6ec3f9570e6f583c20d3c91059801f82d1e544b5eee0b9057335fc4e be5096bbb327cda901c552a2578d2df7623ede26cc7fa67f9d12f2102b99cdad bf27d430aa1ed70de5df7f5e5e859c57582996425aca140cb6fa19acbcd48af5 02c1ac26aef8b1b80f6a3b1c8e4d36a78f9e9be3efc61fc810b7ef485a08ea37 8294fdaeedc4e952e1a4a7445656e5e3769d29eb1a3c189903431fb8514e4bcd 25acc5da336822183f9479becd091cd063083317211147dd99531046e85f9d39 e631d13f24920b3248016338ac1b3e494c7988d3302992d202d377446157de9a8999bbd50e2c68628c9f1cd1a811583fb82d42c52856af2fc2690a53782cb202a644df4a73fd01bdd973e7e614f4b59019f911e5f251c5ce87a89fb1f0506b080e8ec103e132da55d8da39f3e6ba55c9ded204c55e2ac9ae96316359b001e30e0e228421c39c4096394c49ae979832873c1a896f6780e9ba61df9ac2e37cf4018a3561d8c3c555659b5fe7dd0137ee274fc2baf698abf57d2522498fd046000c7b793f25ab0c56a2929a00f4dd6ac9b9c18d37cab2ce2a1fb50e6bda5fd86c023736318504f6ec4a0a46ff71a9fe563e262ca43015d4d1de6cc538f031ef8e0da3cd3505ec5f1b914cea35597e25835868966dcd0f975c82ad6db931c6b94f0c78be44f17e0c8b43915e688f6055b113657f7f697f84558ee67b284f9fe76907a026d975d2afdb7f12c9911b2d5681551a72eba11964cca3090583b6ef2b22a24a4f5fa7eb0f881d258b5a03f58faffbef53ed41ced322d58390779eec4f460a false +check_ring_signature aa91c87aaa8bdfccbf37d1f5fcf7eff86e15711fefd9c0cb0e22dbd0a7ef04fd fcbafe21a602335c8e3f0dcc7c39776c225e867c1640902ed8837e63bc96608c 4 cfed0b793fb5da05628020fc2d4a36464ca8982c43f0566c4fbe19186fe02dac d8b98e75e82f5bb7f445d7c147255d3c571637df8f8cb24345876dcb989dc428 b720d961af8a8d9c740534413ac593a0008f90af105bc2da7a46b2e61ae1d301 a79c53fc825521efc217711315a1271d836b4e8be31c50a14b3c5e151a0c9041 4d907734ff7ef3c6132cb60e810041afacbc744770e0f118e94cf634c5a7480977cded45c84052a7ad4318d4d2b2b85c39e7b77b45f629f8df5c1c4d762820043ef87aecaf9b02ef99b3d3b8b5d5e177e777ed5527f67be7ad09ec9f2695a8085a034b7b1e2b73599b10fce1d857e5add4d9f518f71fa1461e2c5f918b4c4a02efaa881c6a88e2f37c49214f18c5f795e4d1437b2b10da50ad3a09fe60499c02d2bf46bd4e4d61d669d01288d8fa9c481c4ee528b84721666195768c83cb8d0130ecf3e264cbfed6c8bba5e0d982aaf6a113fc95aad46596305b52640d0d3a034ec473dc095c0569166815f8f973eae950eb8e7212b81decc1952c045c47c70d true +check_ring_signature 11e8ab7622df67854c006e9ae2e836fd3668fff50a44199749acb73b866f9033 703ccd341e1d8b68ebe7df0ecd0c0a0abaa10432108afcef6de6e78b13dbdd89 13 5b224a970184cdf350e4f07f4d4119acb77ceb50324399258ed2ecb5e3e78183 98b69a56cfd416086d72d518794a84f8f236d78aae68a3190c6ed63027153d52 8c6823a4fd95f87fe0b92e68c13bf6de17cd2f74b45090fd0f3ae47b82effeab bfb50aa1ef0f10da1efc6e56e68fecede9ac157e728b476ed1a8434072ef21e6 a0e06f1445661f6295c341f594473a8cad1c9df23fcd3d93a6cd4958d35b4759 7bd188c46ae6e3038aa1d11cf89d3c3353a93ff1273c16e99dc2cf7e6b955847 5344ce0f4b36c4bdfa3b47908e2493b869dc1935c559a5c90c14412fbbcb059a f820f3ebef59b31d927d336ae8766f35b828851550ae21b6616b376b4c5d7e66 386257d96e9b10988df64356fbdd36a396b3b6be1384c2511581609424e99c62 959a39c032e7def66ca639b757c394a6737e2223b398062407d44b2302555b6b d8c0961cb4ff67423926aaf4a9d698ed1cf77c91e7b20cc552603f85d316e32b 8ed1f5b0a6c930e918a524972041ed3547bd11dc75cda7f5af09ac91f4987530 e2e7fec5ec123271b45e8dc1ff21c05de39a85bd02a730b56a53409aa336b0bb f104c172df6ecfb5ddc0cc6666cafeffd0ee3dafca223cc66219a78e4186fa0fda0bbf6bbd1772e68835bf60702ae07bfe2ebdb9e960d8ea31118c23a39c4f0c4b6a304fc859f00840608da2c67f019fd684fa56372f3259c1a01517b36603087c6a93cef3f1493caff7ad723c20334fa9c85209b18d76c3206aefc2e0a8fe0bc02224210c6e1edcd03eec419a3c917a2d8522d5fda6e3dd4f786ce142d62c0dee96da353f0d819ff9059f6eb84eceda525258f48b7c086d31f999c93bca0003a6285a5a09a9f9a78576a741c54587bbfb4deb35be9f9b531390280572011c01d16d82db54fe1c52ddd32bbdf22632335d3e1318cafa4e475f6d05bf9ad9f90f0c1446d3251676e748755baf5eab5c6077a2d707eb7150e78ae06aed2d62870797027d70e464c5729d5c643a503b540ebfc079443a0d439e85b8b927fd29d60670e6c3b3c03273acddc0725815ed4257ca4d6e9a61b4bfbe05a8c93008b3ca0e701539770d98b6d7e81d0285d1ea4c7e0c4cc77137bbc25d65113c575a17ab074d4be4669dbada7f215315d25c36fef7dbc92cba3a07193549b3bbf1d4f68904115194f9163b644e1b85a7d192d4ab8cebeedfd77a9f2e291361c1d9d7431d0e245e365572f356681a3cc25542c1276028070b4da1272e178fc444b00285eb0b7e522d4eea1fb98b33057da5fb016a369df82000156d4ee0c52fd91b87a40609a5d9ff64d2ed33252da57df9da4bf06e3cd65407c38e540b1de5885e1401d54656dec87640435ea1f33d6130de1171918fc8202412fe063c7d7f422729ef150a46354d80b468edb5c293ce819b0886e20cd9dad1ca21e07b2283a9b4cfc25a0cb44399d1965bffab12f79fd3c9359650c0ee0c036f314084f264c3c2a608bf0e0d7ad82d8c7fdf0270403406a8f1cac35bee81c878f4cdbfeaa0a149a8b08c0ff1b93a6f18f1b0fc0ae104ed1510486cc3902e6ad6d10b76e192962ab32ae90ac9a9e35a11b342d9e6521066f0af2ca1708251243887036dd4b2ba5e8e960107d3ef35b8dd0407d0c9529cd613421e3ebca84577391fb17ff2849a33543a2108b84a2a9b72ab0d7191709849c2901006e88527fb518f0ab553f46f7acca90001551774b63e8fed8115d34d5a97c842cca3f4245b8a3bb5f11d4715940b1bf101 false +check_ring_signature a4eddc0c60ee41fea8b752fd842e3f22136bc4d35d42e3dfc3983cd8212b9349 6371128f78ee9dcd818af0d9a9607f76c38162d6dc17db88ca74ed9e8ecfb19a 7 a93206202f6387035642c80385fe922849b468e65e373a673e2c35628440e835 9d4a85d4c61f79c9cd24d6ecd07f1321831d763d0c575870ad040badf282612c a331499f65c9de76625d94c5c6a67840af2a99fde53d9ea7a43cea0840e0192a 3e380f3879615ff6c0a92cb9977d6b31f1d77baa1c65323ce56e21282376a6d5 f34b181e9a176f25693b4b11398e72a4a75f1a51304ae5780bdc311121dd61a7 18514ace5719f46fcde43f7f66ba94e55cbbd72936741aa109879cb3372757c4 e30dce3cc0bde202b3ac84331b7782ef2b3157cbc0dba7cf175efcf132839142 34b6fd08a17befb149be2e54a8586bac319a362b37ebd697a46eb648f325e90af76e422fdce12d2a0312351adf782d1cfa0c901af33200acb0b6b987826d200fe48c282d2e829a3597f7a7046ff044fa39f3f6662083209cca29d260c87aeb0f84b8e41bef6d7006fa14c49c228b7ce220237fc330051b8c295de469f98a3f034cb5bde8db37c9206414ee1d81816f9b832e4b29b50e11e0d5eed7fe2a786009776417c76a4b0459536bca7fd8cb57eaa1f234fbfa077ede80d69aff6e002c0c9ecbd22405816fc9b8a01b46396a1965f5dfb2bd2616d7cf5e32e5e627bd2a00c27ed68bd85612a48d9bf646d005ce8d2072a5c2c74d3a958b33db1634291e0245b2e42596962f6da3207c6ab9cc61272c94e2ecd990f9600dd39027a24484072d2b7a5e7bd02f73c9afe6b57c4caeaad7427aec5627e31311a65d639efbce0ca76107e916e2322de7337452ecf97f3e373ffc283495d3ee7328fa160be299077ab75005df32f9d0b222efa8981615a6c074ae59cdd52e914edb8033ba34a700a9f8c31ba5b8bd0cd3447d1ebea3259d23702c5842a231a3a48756cc6cd2340fece8f8b27ba23e510a330106cf5ca897720c16790246eafa7a60deb17a80b004 false +check_ring_signature 8532e12992910a65520eb7bda5fd9ce8f5201a3d13a292a948a547cda585697a 5bb53d6512d6da1947a0eb42e64e77449b2bd4fb63cf24965c86b7beafd55f7c 234 9f2299532648d1dc8e4f50bab31a4c85e40fb9dffcd66782b9243a953a67288f 382bac925a3a15279c0aeb979d5256a5276f6bdde14a379ff380e803790d44ba 24bf22957537575e1779748f80364f33e597028d2532593ef2637cead2bcd5eb 053046ea4cd05debd531bb8dd381975b7a945430d6d0036be53f7e17aa2120b6 ea5f21a5f5bdd98a753d16c50c4678148678b021ad42786dfdf10a7efc5f6065 1bfaf4c574f98eb6bedeac61a4bb683d3c02032e5a881fb7a51254871c5cd7b2 365f4a02d5f46149966d787728c1b6b66a54502e173b616140f70a86b1d13ed2 9a271db1e0b1bdb2847c74d95f472ab8d51ab2ef7457d0d0f3114711e587d946 b6ff146a0885108fe930f0caf2472d24a79cc38ed67f9f4dc4100bbd30303124 b7b6c3b9dfcce2a57513723344338fa7d9d29edd59d8e5a8c20cc58f7194052d ed81eac2b625277f06789a011181bf54ede487a44a6310c5e4c53d36df302542 6794f20a8178ee2c1b65f6bbb05f142e2ac530cce432f24507eb835503ee17c0 5502ee9dde670fb4ad7040b5a61a7994f9cbfa68dc265cd42d5199e01e42da65 c9c7d03ce42b36ff9a373ac7b055bd009b8162eaa4bfd99e5fe960bdd9b7cef7 b2922fc21a940632598fdee4c533b3effbd08f1c31466d9f7c4b092bad4967c4 057011f02fcd0d48cd40993845e194703792a36ad74c498c11639c3481ffeab7 b7f447ba90d084f797d672a5ad490a89c4417773bec85e0b06dfb6783a8faee9 9183c936ca23d5a3ffede868f01342730f0941e370d1c84b364df6ffbb5c26fd 37f8b336161b3c3cdd2bf937832ffaee35d17146215e25a2e55d06b58a7856f8 b39337e7831ba6b4ac0cc898d8f0afe81362a981dbe4853464ac976b0c497c88 ada51ea55898574131477dfdcb4a14172093c496ec5fad7f3bee87dc80209f0e 49735c48ed953f1b909258058efb770965f670ee88c9a231d79882e3feb324b9 8ae3accd8d45b55dd4ea562411d107a3e5388efa714299f56282889ae01a36bd 29d4728215194b6c92c472d34825965bf4b9cccde6f9747d71431471cea24aa9 e8e465061cc9b541ba5d661b0c6941bbb7d253676a2ecc656789b71934409a36 14b0481f87c02a2efd5abb4cf564a5852504cd02b047372e19eeb750c81b181b f74bb856694cb50780fe5f07361cce617b1fbc2c43a7ae36e618b5a87b09defb 5bff570db6db4d6fe4a37bbcbe8a1f16951ffde699080f2e3675246d26009a09 dfd6c2bf32df8c8e1ddf6034340b5771f22b61ab9b6642e043b236a54b428020 daddbc7fdb17a0671daae49013b7fb11610f5d9284abeb02de9f2f727f52b8b2 b4335d443b5a053d34e71823b2355d509d3584f08cb7c13e480ea5fc331b63e7 aff9e3719a4f6dbb4865ff767637a90aa209f806e5a42ca26fbfb38ca6148043 6189b82822d9c3dc548a6d1434f43fe19c5c67e70b8361d75ef5e7aa9bea9c65 5a01fd8aad1cd6fe78c1ea937b3901f0b6fbe2bcb4abe9ab78f8db9436428d33 2d791354977a97f1eebd843774bd992ab763e4c7c05c1640994767018a6f7aa0 e55e540ced2f1964970292e1b9b2a1819635224d4648747f1c4fe44b54e23f2a 2a66a0fa6e4d7bbbc000c75d00921ccfd8a0917c8cbbfdb1d2ca50003292a148 70058e5b64384d1baf2ea64e09cfd061aa843bba24abf75197d70ec36fddc837 dfb9f3e9a1a7092ce58249cf1d039418aef42e1690c2de632e00409348259cb4 61a9f0d1ca0e37b3fa8a18198e2389bd8f425295cd8976c26ff1300c1ea1a2d9 d03607280f59f0cf79c1f053ee2b7a96a606b12a054416fa051c4051c9389150 986184dbbec098aa0bb933ef8566369fd06efdd4a9d93619d6f6a8a744364704 fdd821d63f69e52800779d595ce849f0b0e98d4401c17c1348798377be579c9c 7dff222d905067654ad92ff87880523cc3fae88b0570ff462e0c8de649b938c1 34c865bd705921bea71fe36abe4e85b5b5e7ec520fa540a9c4c2e3075492f846 ed046f3dc0ebbaea0da82308f289ccff4b0f72b4badb64d77667fad14253909c 909a6e4692d803ab0d3316cc3269d613a0b76a51f54d2a51665300d15e1a72ee 5ffcca063a929d08d5c1925c1229fb6d6315f06a327785c5f084ceea9169bdb6 de31aa6dbff9cb5e1219cdd932d2c3623d4dbb9eba26f49f04fd40a493d14064 0ff71108884e30b00a014a114367cf07166e6edf1917c7084c018bd7222246cc f65be0dc4acb6ca3fd9e85dae2f3e3c426b4fab35dde26fd12654acdc169f05b 1c49379c57608e7ea58844373e4d91cdf6cd18ceb6bc14590ddbfa61a472f10c 81cb407a9303ed2accbf669607b0e816c94ad2d6fd279504f5cea6cfb6a9fef5 8045769cf18d6171a426f68fa378c54f50b9a594227669675ca1a364df4ba39b 4f61c7ecf13953ac726bfaef87d2eac6e5b86f9c0f49889571a84ace6df3405e f89331f658ab4529e8a572713b0401b7cb253681c3284c167b93da20e213fd25 f2614c9008214329ff235f65105840ff11728cdfa93d0feb2bec2033d145ed3c c595c03db904680e0e261bbce9ddf73cfba1673283e807a938858a56d55baae8 d9bb120a6c390cdda16b1176a6a62712450765a63df5174c7086a3932ecaa75f a20e9dcce6a1c36e95ff4421c49035a8ba3b24e3430c98641d79a2b26e7d470d da2eb079fd51d4d7aa67ad1b3b727c51b4cbf98e0256b0ed11be7f3da71d7be3 84bce11e6bddf11e22dd4324c076ad9c302f4392afc92e1b2833ffd6d16d12b3 55a6ec8236c1314310921391c989ed94f8defa75c1037c4e68bbcece12ee30de 4cf08f06eec954dca0706e52a579d44e8e6ef4a6b54a2c24abeb5a450c1607b8 6c38a52df4d8623cccc451282b316a9e08f840962e388142663702c148d55eee 8e7756ac1aa0dbebdc0439a74becc62a37de6531db2091cb5194e9e2f19ee2ef 7cebf65f4fed2b1ef0c8b296d091cffb7fe6521e50dd2123ed6574f790ce19ee c101e3e8a08af60ffbed628e4237046bc3398e5518a0ad2b9ea1ef672f66a71c 3f80aafb528c3468c8b0e6336425302acea1f531ed1f11dd20b54555a1eab38c 337013a57c8a6da5e9f7502a390d5d99933ba379788e67f7b76fe43582c58a2c c11901f257b296f3241fa3c4d5fdfb48d43e7f48d487283afd7b0e07410ace65 b52c32e7163dbaa1871c8829e646f206edbb8d489d4c40e330a5a7e4bfc88040 4dbaa549c1d39fd6e910df30342f9e306fc84a84afd4a48f569436794a669e27 487b47244812b2824f431d56e8f3d5a6a4798b02be61521c21edc94575a57109 bf5bb733278932346b1031fa3ffd67e52a4997b63fc96218b8a56d316b9f5a3f be3b573869d334959a54563c2ede68b1831c12c9100dc95d58af97e77920affb 322b489186bde338007028a0fc2a7e9dd3182181bfa71dbc909d4dcecced2151 d9b5a3b98d4bf5b0e43c2587a9a74160ca4c4c1a40c0e88541c76b62967fb1ab cab0b44c3c68c95f760822d69123ca4e7e62ff574067e32fc60212d3dfaa4741 62db7fb5c1db8b240cd7e5642a2c689b9bfc5f20535abc8493bb273f375e1dde 941629af2919273abb2a777068009737507bd549c510c81d457016a62900ef81 f89c3474141868a59aea98840c4ccce7050230981ed172eaa8ebeb003ace7eaa b89ee24e023c4964442b43647403899f4fdcddb41cf1a8db81ee3fe6da37ea7e a3f5d092b9c802da41be509dceb20e7452a509ba1cc7c0e1adf7a5e0b19a6a5d f41d5c2d8cec6bdc85d498b8f6ce8dd87607c738dbb5337c3648db6fed24c18e 737ed9e9a613c7f35025d40ec9368c2d3842b380336dd5ab0f62ea4229dd21a5 97dde1ad8cb17afa3283d1b98e85093825f424e6b701f9428e4a30c9d26ff682 749a75593ea31d30762ef42f34c63fb69b0c2bef9beb2f689432d908fccf071c e000cb381cb442e71ad804e1aa07dbf678438dd074ac2320389120af853f8ccb 5e73375f1a38f46e4050a9b2ab417b4d7ee85ca4c6af6618d69cf930b1dfc22e 913f73699ea4c9915b669d73276e941d33c4525df8a4863d7f3498faba340c4c 53d0292484299557d06c5c9fb4c0b0af947d1348265d0fbf5563baf328d9cb84 4008194b293cd129e2c17624c909c67a1d4ca2586df9bb4e1aff45aed7b285d1 71d3bae149a0ddc2258773d3c40556c792890634a64c676ee51f631f3eb72d38 f07f66ddd74d56cfd3e06a3a4ed5bb606c55900cb7b3a239d7bef9edf3cebfb8 bf5d1510ffd93ee1df20b7c5d9b6fe94246f396c09624008d08374a5419f543a 165bd87b266f9cc8b661aeae621acb955eabddd4996598898dbede31ccb68149 d660ea06dd12541de507789253b88416e64279d39fa6fa82b765bad77d9008b2 f1ef77dda6c49ba9630ab1f4207fed3ef196fd24278278c7d2bc46520b872726 964387e394679772d03fc2d6ad436167d73fdfb65608bf67e3cb7cd375ae019f 9ddcba8643eb6103cb69b6bde32870477fa6065187199c8138b6cf4c1162bad0 1b068d2e1ec2b9e70b5276ee6e9d92f0ec325872304d4b6daeff572f5a0b09b9 b2c729991947ebd2176674a0d1cceb7555e26a1f03130d747333fa968f9531c1 10e2e2ee9db704bc324f96989b01f0a0e48671d50101e84ad72eeea87d706393 3fafb3d29ddd41c5a92a0b6768a06a167eda64b034aedcf1a590aa4897d4501d 4dfaef80e030523d47aed63681ae761ea791199a2fe737cae233c96a964a67b1 279eaa108b31315547deb2d0c55d22a55235a40ec6e90b769ffad0fc7569d047 506c936d87c884ce1da07273e2062bde7b26fe111659c55ae95626a612d1272a 7757311c55484dcc6d39cf2ecde3d814c13a294e6ff7a46c3b4c061018daed76 3c77472d98a26243865f8ce9db2ff33b1b4737ebcab5ce83b37e327d0e7df167 56720a62b1dbf310c4f82e02d51c81f46ec857d5e78a99fb0816d174d4242cbb 88f55c3eaed767a8e05af8a0b47e2da2a2c6ee72f67078018fbf0a9bb6f4c5e5 fab2e7a5df14a8a97e91eb77f7daab618e7059d17872fb17ba70503b27ba20f2 32a98b2a740456f94db9642c5eea68d5a88102af88c902c1eab515ed2f3c3853 cf2d7de33f4e4b08c3db0d7461bb685d4e5b5dd95e60d9364a39ae2949d22721 9aaa25e4ff9d4e2bac799af1344fbe242c74843a1917aa6e35bae09795442d7c 22a7b8030b5be0aa95e3b474f582d844e1e662b9a8458307c10ccea3b4295c16 4504c4fbcace9e746d90abd792357efe5433e7f4772658eb531122bfcff916d4 4333a1226dd55620610e45a05ef5ec722b4412148b5bc9d295f8d7811d8b5819 0e222777cb75e24afc0952c5f1dd7ca5d5ae3b7ad2e7a54b1afb0618fa7e414a 9d047eeb94990ee801fd37e7883bbf57cce026dfd9228d35490176d638f5bb37 556e369598c1c29d4c14d3daa8faf54ed809222f41333df486bb29f0b97ee0a8 c18bac82eea60a22a27dd5e22ff997e4193a74ac6cdc4f929ca661c3c8444837 954eff279a58f2c723c4a0f57472beadda8a068307fcc2edebbaeda6061626b4 6627d30c84cb91de986a6fd8cac2bb784dedb388e066296b092dd3dc0460722d 61608c852a263f2844e916512e24a2489c3666925f5369ac423023d84c4ea3af 12150f9d2b3ef8d7149da6a072786616b2fd613029024243144326508ebd7dd6 0c82e6c64b9967249fc4edcd502a9aa2279c06bea46030501465b040712deca1 68a5644275152964b7fc2a19993ce54129d77eab4b1da460810bcefe6c087fd9 130a349f6bbbf3daf6879d0f55fd2ad5a48d9af74a3ac6c53ea2d3ffab7def21 139bf5597e8504dab1702ba0769f282dac506895beb9ef6b0cadc6c92f40cd85 45ab2399e77be937106740ec8ca19bc88b37c9d86dbe085d3c775dccb7ab2fe2 ec33471a49c94ec8ea17b71d5f4c1ffb8901e6aed6e1fb06b53a3e02b5097a03 f4b64c3a25de1a87f270b9a4106b33806a684fc8b85f73a45e2cff593c857a43 1062bdf6c0bf3fa3327ae80a75a5f286efe1db32c66dcde985b6470c60dc900d accc2b5988363a4291dcaa99bfb1e9d13d8e83e0b7617287e3a5b8816db28f0f 0ea2d55b0f9f9a7b4b2fd053c7139dd4c68c849fdc0e4be0fbdd87ea14a508e4 edaee675d4ac66b76c31718c9020469b326ead456871bcb58fc25b5c73aee003 12e2d1d2d7df027a22844c1ddee2af5b0200a74b268003841ded3c2fb6e701e6 a80bf97aeadea8bdb143029aadc802aac6095e4140e372ff277e412426c1a3d7 3ded4bebe2992564d883bde735dc1357963660df85469c602b8ff7ef40b2a5a6 5b2c8154ad4478b37d5eed36993b4b8a4c90399e4b4d8a8d221c16dbb2829607 8637acbe0e9cb5ed769fafac41f7ac4d3e791279e5aa281a24a1ff2df840f539 2fa3a7d4d6d868a65e8a0d23d32e4a60300eb7bc53de41932d395fc6db9829b7 a5e6a13d47f09533c7579de866f961cf03a57460f5f0498e5b2f2a1074bdd4fd fee489bf604679e8ce50e16074f2dfca2fafa8b94f19639df5704e806a406850 4ae5b9cb6b7a6bf4560984ff58074299facaf4a43861709ffa3ebe08f8924394 a0912fefcaceed9086d8aab951d66526d0fbfa4cd1a62d55d8f506cb53758ec1 7e499c199ea33c3b45be521ae9608edf1fb987bce62849b7f1d5dc408225ce87 12e7607cb54621cfc196b6163c26aae3dcf4ed38e46742f8cd31dde691423035 b33a9a19f0d416d24ef784520570d53e9575d29a812f6e66995656e5ffcaf5ae 985753b12f333018f65fbecca80c5e53ff06df8ba1eb27c66cd84b4e906bef0a d290d78bae2b7303b6fce8016afbabc116ccf040f6c8be317a252e78758673fe d74f0f21521998df1813068c78c1a13451aae164627724134f8fec1088edd7f6 62ba4914597da39284a7647102e823fa95e594d67c6f6faca79f38f84a78b278 6b29da31397334815e510c4eeef61953e322454b2ec0c3189e5b35ebc2b422fe 1758e01e4bcba19cb2f06f41ca67d140dd4e7fe6e611f7334e33279681625350 1f6f602bcf697bb4edda2716b4d23eb338b923d62740fe3f26b7b2a85544a858 6f4829cb18130e115c8ba595216846ad9ac6e6c489f015a858419652054651c3 5cfc518b81568a047f8540c5addc3dae2e372608a2d1000140c7590e978258a0 1fc22a223df8c5ad4e44bb23d4fa9075bac37950108d8a37cd021d2a2f382b3f ed637d8a92f5a740f8effe03dc960961a510c2ad6ac10ec8a48020f012f8cec8 625a61c698e2ec73e229558525a4af49e636bac584993597211dc08a59f50b90 ba19c7457558fd116a8e0cdd1f3fbe294d207eb00063c1312dc0c7eb02faa622 24afd5d046c6141681e9ae62bd22d0b5e1fd58aed5e36019e71d12b2c00337fb 79e5940244ccca26a856457d5280b9ab68976290f5fa2985cda93dab0b8b95da 22b52f0e4d727e4447b023acb1873073a19dc27ee16ad5053b249977f4f557f5 0e7dfcef46a9ee3c304d651f1b33b1b3d071503be06aa58466244e73ffeae8ab 818d7b0e31d0e0d4070fa9edd3bdeb49a114998792916ebc1afaa62e8a851810 f0dade57621836fc70a1f5016109c1ee768405d05134f2979d6bf3c018b0f71c a4dadfbc71e5caa0e67ca3e8e3d84e32e782ca968e060b2f84d104c5b988be23 e348649edad034a2e540a94c8cc6e8863ac013d8c14460509acce9023de3ab37 9a93de0704d98aa7a5681aa4af0a123a698c13f8980773ad47b8a84b9da7ec5c c9457911e715a67e99af4a00280c7264b235ef57bcdb15944f255915849781cb 7507909953c136748a3fe8e71737e25e358113c218515b3e6cdc2a909a9ba934 b96c07e2d026aff61f3b7c90da7ef7eed4519b2ca3eb37a47b2ab0b1c4fef160 cf2f9fc6fcecd01cac8c549e30fe1ee85c01e8965f072cb4e3b431bf0547ef57 50022a377a180a9f02040483cd5d907d9078e87d190fdbf44b81fe16b989621a 8cd59716ce123e53a52d798f03d652eabb6179c2d6082f40f07115a05737212f 11eee1f93b2d71b85ec8c5d39ed529a8a21d34fd3bc627778d729044f15f2074 a23969ed91f75df3cf53ece866a273aa4e8a78e171bb23708b23380e3883b350 9eb30b986cadc6a2c2d06282fb736bd2911d9df1edc30249cd21b8627877ffa1 da3a45c0ae5357c45979b7371c2de5b2c18c8e2925594858600d35e752271d70 76981494009e56d5ebf5a5aa9a429cc906ae4cd1f0020757e7074cf50dc62312 ec242eddac1c24aeb429785bdc358f6f5845d521196ac3da438ece8447906c09 8a129da943a1d79a9d88cecec05bfc20867e135bc95b18e10021315aa6d612f6 34075dc35cf3d00fc5338b2b2d45a6d854ed09eb4512c17c54e66c8c6abefb4d f67fe95153b17f7a0d5d0661a1868c53fc4a8d42c8fd1f9b4e5c75749905ba46 1919d6ee5bdc234cc19558fe9b06a94fa08de3828f05d8a1d86de984f0263fe9 033c240550fa133103c0cb6bdce1096e5ec6f213130d5b7451ee6878217dc5f3 2c3719821aee8f30eac0cdc78d5fd678c010b13ca1be243298b964a97d16e433 6c8ebe4c96cbe908fe545dfda791010d185389b433663de5c35b31e7c2699c0a 8da04fdaf5aca78ace5312687dd010b7ef982aaed184477118c5d9e040776463 62552c3c2d409fc2ae69a8abc7256fab2622c63ac699809229baf3e93d83e149 00b9cd7d7630888e8380634af1c97d2e5f13c3c766df92f89c8f7b092b30209e 311ff25fd505f9ff435107ff443138b5685d703c27262a97c5b17f3b20845037 c9d624bd4c8796a5298fdb214c26467afc290341139c3a0c3d69c563789099f5 4965612448eda64a21b2ade68b0b63f0fb721901b20f521854569aab2938cccb 227974457a350694f220a8903560a8c41e5cb3692993d3a990b2504db9450013 a47fcb5c855f81214efd87676d801eca490799155eac91a7c2493e263dcb6213 1092d3ec4e0a1d0345e92a5fc226c1e1a36a5725dafe89b5351c83792e3eaed1 806d80ed0d026ec8d8c7ec80dfa7f20e533f47cff2c5e0eca0f37454bfb2f53a e27e8a76941f058b3830876d6b634c7eb90de18c112c39d7e8f191dfd1f26958 58df0ff5a530a6b05025708e3110453cb98bf405c0a8996abfc398ad28ff48ad 77241265f113585fdab0dffd0b967af079a49dda28baabfb170a6be648b5b8ae 2bb90ec95217f0764308f48bf27485f6ee19a59bea9ed75431ea0d458ad92a84 d35fb0353ac1cd285570d0c767ad826eeac9391c09ffe6b2614769643d184f9a 7d6a8ca0bf6f643a7740ad514378bf63a8ef3bd0cc5db2a71e2c1c94b463ba03 76793d14baa2f7e8c338d06bc4bf1f4f16de11f19db163fd1e7b21eceb0e5bac fae6d3094430b187a37e1057b22c566206205680d448fa73abe17574fd36c3d1 0a4d2a14c4215aa83fe829c1d893a5f41d7b777f7594841e80ee51f5f1494f8a bce92ed776b33cba21bd6c2395c7dfa7d82bcca7c2076f4e29bb7a2a6d01f697 434785260548d3f252d7b93678815a74c74edf964ee66ffba0e12260f410f9f1 6dab132acb28e62cb07693a5d4a099a3f9bc20d8dcf6ce514c10701b9da28bc4 2ff418dfc2152963e022bd1a2b632d8c6e3e45c5c0ab0252405968a237989892 2d8b472375385b19a49f779ab62f7395ae0a9de8373e8ddd28055848b11d90f1 ce3e47374bdd9d33f925d3813e0e74afd2b2c93f4bc70733006731bfa100517a b009a765db7b6075f2282774506883f7c82f49bb38debbee20f19b83f1d7e331 d7a778e0811bea8885cf8c8c0f1f4a9321f548b61e326f9766370b76e3701b08 db89fbf4cfcfbd7f4d0dcb379246300389d79f01baece8102e8a9cdb7bba1bdc 8312e240ea5b10032d3ee2eeb640d2ecb6b55459b28bf8130eff8928801e75f7 65116a530a671874863b4c657790020ba94cf297ba59c77dd3d801bca4edaf42 42947049d665210abe403b199688c99f657e719a19fd2d8fad323a6fc6b79ae9 de2fe3e2bf4fa548d18c29e66ccbdf90bae954b4ac3e730644cc4d32e78e6e23 9f86dd222547264819bcf3b1d42aad4606e50cebe610af71e982a8d19ef0af0f d9362b84c4c631411c1d7f43a9c2a6fd1920660f845539be3d5eee0fb31302dc 0a059233a140ce0caff30416642ba7001d8e4d6f39dbe8db3e4ff42f733c2031 f3355949e9bf3b2b22ad299802be89226adbb27ffb81babe758c17edf4a90f52 4250222b4eecf3badbc1cd95b7853ea756018b1b3e1a80af31e0022053aa23ae 68adddf6c78a6d2e3a75f419c957b8eae2844468ad47b9b5d323c819c8b750c4 36c342ea101e5e4a987b67003a2908246a42b7140ab564a4adfdff61e40bdeac a12e3c2f80c5ec418eb62c5b43dd9a726c9defb6c7b879eb523dfa9a7a47b092 41628d4959216006e469041e1cb13818f49e9b0dd66907a0e080065038c66c19 7d7684661f222f777e642d94c307c7878adb0e9a98ae4ca43123be8b2243dd36 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 true +check_ring_signature d61526745ac6c88721ddccdd54dfe5924d6baff892f1b85c3299b41deb239148 1f935108ae0f3c986cd8c69ccf5f6036bb5a28d7d6d7af6002ce32dcde8f2ae5 1 05f047c0b83f38b6d08f065d44c44581fe8ba625f5b3dbd6c0e947ed2fb47ac2 64f48ff19665ae7e293fec7167d05b4deb025cfe4b2ae82b5b4b27d87fd05c0d5b82ab5f278383114418366a0e0ca4c44961fdfeff0798fe9440b0eeb3ddec02 true +check_ring_signature bab347b7f7523889b1b47a52304568ca383c2781ce38b30a5f4365be6aa937af 9a655ce01269c1b9524cf5f01ed579925108224c7161dfd775cf660674dc8d87 3 9b6704f1d07fb8887f158e05dce53d654255fc5f5241d2e9e0c1a68f0ae15926 eb13afd6917def3c000e6f240b40c1fa0f6bdf72189a758dc870329de75ac83e ce49b09f780ab6b2f4f16187bdb61b421225996a77c349e3ebce4f582326f4a8 3dcacfb61dbe601ea57a4ec4784c52d3890acbc6918711203d03d72f3e08910f1618e5f5c3b14496c3e88673aa19f25246455184b6cadd857ab032cb8273690b1e1d295a4654ac0962e6b5ec043aee1e0bbf6e9ed81db32a6a930c8828d3a8017fb3b790ec2312b3018406b962255040b87142ceee30e867b1dfc3c32d8aa40b5f618b2172aad0915c05f1d0472da29cc186bbe4b43786be72a05da32222168256b2a655713bdcd075456e80e59a997b65eaa6fc6122b43b5c55c923bdf26e08 false +check_ring_signature e463c17c525b65e87450956096e6eb122ae516d186ee1dc42af680952def9bc2 22567b526e05cc4a4ca7dc7b960ef0b515a287fc62210dd95fb233cdda4e962f 30 eb49786080a4e784e4af223de134d97e5de03a807500669abdd93ba1f2f1f92f c9452db13c54534d93c430c61ab815eda220882ceb3784b9447e1a4e71d65b57 ae00560ac04587343867f8e26f45aeca95d97126d07fa6844c8948e8414e9ef8 b113f337eff7144ce29a77351308ffc5883fa3b2844967dab78ae9ed79238603 943f7fe1f28aa02552648f5e1bf685b2bb59557fce5827a64e6deba749d0e1e5 f200a21c7dedcfb28f7ea21b2a7ef223a74c2a38fcb78dca5371ce142259404c 70dfc6b2c2920fa7dd43a0d447071db904a00797221e388974a76bc0e0b4cbec 9c8842577954694eed35806784e17c6ca25dcb25f39d6c1600314940658477e2 2fb776af046cc602dac4dfaf0aab46010e0f793695ac1f8a42277580931e493b 30c64ec13de75c414c75f7b49b40c967bfedb8c3cd63e5f875618bbf25e21484 f0f6bbd1574a59d48a067b4617a114f3e01e6fd0fd914c84a96e13573e02e319 8e17b2be818deec5fa1bf64165abc469d7740923ebfdc49c19d9a78b4baceda3 41673edabec6cfd8e25f76ffc554bf61a740dede73e8b022d2cca90a2dfc0fc3 a47dd5b9ec778d44bbb0a220e6a557ac5c0d2ac895cb61dfe086a7feedd7c3ab 902ee29c4aac2584fdba709e0fe1d3c904d5693d65dd99090f8850916cfe2ca8 1d920d9f5935724adde7f30e6097d141d37e7bbac7b1ec7143a8999b46df5013 67f1dd974c80b35384e77c1e17b13468620d71a1d7877f1fadb2a2fafaa69dc8 def20e34cb3f07a5dc80f1762ebeabeda3af9636c5a588fafb870620829c132c f6a7342407f40c9a2d5bf4d347ebdb04e47f17b0485ef6020dc82de69af69abc b61c6ae4601ee1a1b706061017287ce62b1e9a331d4f0f0a914bba1d799388cb 88bada33021541febb11c0f8b2cc9a80a1125094f9dd75ba105ae4cd97f76b6c bcbd09972a6a6c748f6db02e9b8c8dcae23414517e9bdaa117d0a6e73071de8b 8c2288d4a1430a4f7c1cd77b2213d344accee4a8238add1a0a28388efe93a1f7 4ae63f90bce2434c4b18156092a2cc9a47497a13eb2d0a4d487dc5f4c80f3d1b 6eba6f2d7b7811b759dc8acc3251d21fedbc6d0a1f34253401674d028d4c3ea8 9ea6beec69c42f692cf1a4f9fbd4d82c03028d91f6160b28f767bc356cc115fe 317512922f76ae9d9222f95d1e164eac7e1147635e56c966fa511568f11497eb e586aaab30d173622cee6ef5156c02d778d784590c40faa796d9ac3532ef524c fb891a66efe9ba48b3c2ec6388f4518b051f2517057ac240b2980dfc93dbdc16 30fbbeb076bdee931d33348881a7162cce7bcbb1ffa967145c981c050d4d9e07 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 false +check_ring_signature 8416ec3b38b8a1f630db0dafe0f156d99d901b1e936e38d392c30b07876e86d8 60e30422e222379b1cc432bbb40dc745acee0b2adee505638ce648736d7ca74d 1 48ab047042db7079abc117da677bf29825bd955e405f6d2031737c7d9cb41d24 ebff080ccd668f8722de8043933cab9c30bfc67d014f21d519005f0c4ee30e0025ce4ceb0c09eabe9ff9f019af70d7cf84e28913d21435372c0a825fbaaf3809 false +check_ring_signature 94309beebebb9a9f45fd19ff1210533fa81e92bb219b3dbc4e8d5545446386aa d368d4500ce8c34a957712cd48836ac43fbc92cae579c6b7098046abd9eb1680 4 9b593c7daba4f0cdb29d974ba33f10e8953b8f82e2b8abc586a2dfb033254fc6 7e79996dce1272ee4c372825b3c9e0ade9822478f8fda3ba7b27e899c4b050b3 0cf719f2d963efd8df581b3984d03bb7d4858edf4f073dbc72fbfe239d3a4e00 f48e06c888933b8fcdb826c91b8465673c3645aa9bd4a3574610cdf221bf6136 1434b29155e21fb577523fd19a0c23195cc39c1021edeb75bf371118277750475b96940411eda184f201870a06b45ab0473cd49def2678ab33bdb120756984059ea7fc2f0b63cf48a75686939fd2a967b29393894d3dab25e63e9b9817a8cd0c7c14f9e0a6445e652dd244fd7335e1bb8c06df36565051bd95e538c1b055ec0889fb3b126b5c8813b8e6d1002ee6a15853fabd8008f96224282218999d325a0afb43d7efe66eccb4acabe3884d4bb4f86138567e58e60b17f031ac84ba156c0027259110bbe25bd7951855387578201bf703af3927f73cfff04c303348fce305e8d0d2403f0384b10ed181d19dc715c15afa8014d53a06b713ad372b43a48b02 false +check_ring_signature 6881b7e8db8f25070d5002211d5d762b6181e7925f5bbc655dd0609c6f5ab1cc 2fa3ab8a5e130b9c7dbd34f2e305825fb7e9525a50929504a45985c1745e7510 1 cf2a62616de966e3c5f653e21d7c86acb2f758ffe75d9f4bd204c8a09aaab1b4 ec6a2840ffbe84e9ede5b9580601d6f9e574c2dbc16398960e8102bc54497f89300796e8f800a575e2d8c37190a6f568544d35d3a11d9d8b6da464eb56035931 false +check_ring_signature a68bef7ac029089d0bae40e771c409bb66c81241f40d22cd3eb76724e747ac7f 6221981de048ed5c635f24abbdfb7c146c998263102b97657a1cdeb6b005d408 24 891f3f1a189f3f84165382e9c9e69373fa754aa8521d45cb9e9037f49c19a2b9 c4bea4ef2185ed4979665fcdd2165b126abbc547cc1ed09986d979358ef5170c f052086f8cf502c34f2718a11d93577d0e435c6e237aa005a046ce7b5867a843 9fe20e8e8ffe4f7426fef01227f6b189ab94a30e2ea71c8d06a1a2d65ef7d7a0 00dd8c0975bfecdb1e988bbfc3fd26bee645523742015a29df4cb7327675c7b0 5c5da731cc74da1332b2b9f990439e9501de0832b35b8968f8ec163e0c53a7b3 6a08a28e0870ddda28b5b8a47d676334300be37b50db544dd52a7efbfc4b8997 0d2e70756c333cd8591930e83a965377b954c1c63e5c2bcda69d453a5eade684 5df73cb6f457e60f401807cd3909d37ed28c72de81222817db130c838b56c09c e8a88d179ec5b11dae1e0b587f20726c889fe57ded465caad9a5af6c0f082133 2798700cbe66247bc6ba87e906458d9a47e0e1a8b7dc3e5a630ed76efbab13af 5f85ea58dc2fe081d37765d35a08092b60c5217f388dbec5a7691a90036fc4a7 f24f39d7dddd43b283eba668d530cc5f0f7bd1880ad333f839cc14963b5f245d 77a75bb692f6590b35edd3f0f6e4ab978e1f5ef513307ad13e3310eb93781169 681aec7ed29e1c4f0bccab5c870be6b291582c870c447270502e8366ea2e2917 657cf47bd12c949af4b0ca42d8000accf30eb4b5c1648bfa2452eeff936c093f c12d5e06f0e70ea827987615cbc6ff992e693caea46ca60dc6b9c64d6e6a7fb4 0a290742acd02a215179bd5f16031574f0130728c8990cf2e0fdae84e4f58917 f4106ec595ac73989746e818f556a57c741d541bd533267cd7da4ed8fc1adda1 b88d0232799f981dd00672050136e8ed8be5ba9868bc854478d78f92a32d4262 18fe1daef89bc54d278b00ffb7e0343f192e474c7bbc41e3a77fc01d53f8fe44 f83f01e918ef56e94219c588e98b8c4905b75f31cd818b909ce0449c62818f88 93fcc9b04c9ab2fca45ab8aab8e2dd052de3e627dd5fe7a996bb5007e8295925 4997f23bfd88377305114db2298f70c49719b25670f12fe442b315a1e85afde7 3fb982166bd4ec3245cb450db62a0221b9968f32d121a63a375592002ddc420f71bbb95df880d93860b8058aa9f489718cc4860215932bf40203b5bf60912f0f7b1a5728f36ae9bbc5bac78538a46a1d88148e12f1e7192af522a0a0ceaf7d0065d5d3f291e6c6dee921fff24fe40a2b2a96c3794c1bd178671b3b9b0410c2080e6dc57d4e453274f7345b3cca7e7edcb10ce06321b6f8a60839cd59c35b0000e5eb1a1232817b73821224c4377ffa8dbef499198099b5f4b474c93a8637330fd21bca2f7f0058399a0d291ae5b943da641bfd6e3e2b41743bdf3000c52df70816e8a6b18e8b14f3c00ed2c9e1408b33323645fe50a4ab1866d0060ea2ad3205edbec20bb4b86f27d2a5eb8a6ced75c375a220b3ab1fd4d1e162728346bc67085690e0bfd0164f25b3a4108a62f82f0547cffce231e27fa7f84079eab09a230ec320dd3a12a8478ce73f10af3e0a6683c1ecef5c0b540e207b24fcae5400fa0f89530a22d262160eaf40e9d97b9d8ec2a82863b6c74bfaddcf792c40a48c70034b68e83ab18b55cf03c849d751f71be584239088a1ed85ff5cf254177b198d0e8f046f05c37637cc92fdc07f4592224b6d8acb8457064d6f6e4a4cf57b3fde0646fcecd725793606757a36b22b4c1a6d6de0b693b003286f8a9a9088d88e0c04e017afcab605cc52e470e38575daea5f0da8167669a64848e5c26542414b940b449231931316761df8ce280b2b743cfd3b0cb9e2b043ece09819a1e9a27c940d46378d5069288796b88bf57abac09632d5eb8b49b0a7ebac0b89f15ff9764e0866603e21096baf52df0eee537982b9a333b0800fa87aa9baa7ca8b5863351f038c108b9c87408b661a228eb8b20d32e0b53c80db8e42ed7b19fdde2422dc5601ae40ea6ee400d99efdecb7ac75b9fb92457caa9ce653a30f22eda25ad006440eb4b98eceda4d29c70ca15feebba678434091381e99ae7ff07664a9ad3e048c0a86ac3b92a5915f96f814cc9f86d8fd89c45df8a06400b51f14c152fb66a6600a3496f6bf73fd129594ced8dd9a2e069c6991bc8a783c747b42b730cb8357a004c0451286bbc6eb9ae19e91c29a135ab29482375fed7dde26908a5dbcb10d750ef4f62003bb7c48b24995a3bc8e1a36e7b5cc73fc8ea4625112648b6d01d32c011e6ae3c0ff512a1303e7108ee463f6e993b0cdf81adbaa0cd1ce2bbd95c6bd0d29ad2d5df20492b5684952856fd7250a33d36086ef62003d886e872e35d69b0fbb837b3f55c3c46c70aacbc0c290b9f46258ee1ef6eb14e783b8392cd44fa40566c3ce440b2d0558e830f946dc7881b0a2d6f3cfd5cf2f6ea5f481c233a11e0ac4e289188b73793ca5b85da85853a762d894b7d91880b9860abe70ef5f28a20af224d9efd607420cd4169dfeb8ec788d87d9223bd91af7248f8802c651ddc50c9c5fb6c595d13fb0dc7cb446c2b8218231c413cf32b03412e3639b4a7eea4c06b84046614996a7a041ffd6c58b7dbc252cb8858d6b70333ecb42d800363db60d8d8f85b1c18c59475b81d4c19443e9627e5e51066c8261a457e8395fc4deea0ecd5c46405c24ca623fc8a7156e84e7658486582be491178a0ba1e83a4ff79309bca1d11fe57d610a634c2dabf4fa2dece6a2ad0379bd25d676c530fb4d9317020117d86e4aa0cc84611f19078704d7792e33be479aaf603a29993ed62152dc05fca56e8e255af63da38e1c25781cd0626d17bcdf1b55715cd4b10048f0d21b072989eb64427ece04bccff524b20b4e897ac406c8f731e5c0b8a4553be3e30a0396ed9bf0d17ffe5af704ecb924424149a371310ee860c2afc35e629b45362f0c641a3c627b8f276ced77be16eefc6b53af8e621357a5377c08ea5fdc5ab6e108d24f0fcd868f98f4372f76fd18887c22fe8a53aa5e4983210c3bd49f0c285e08b382e43fb93428d7d2da187aa9952436835bf0ac9427d94aa4a8775856b8eb01cb48968f1cb7d37d52d6df0f1d83bac5b0435f9e02ba3a1bfd2aa6732b8e450e8054cb7f2ef6898aee735ea75e93ed71441b0b75a0cc78b74995af6e0752db06fb6905d1d97c26cd6e3af00da1f0b230c6566657638c556b31d8d938dfc9b909c13d0d0b2653fb5bf42bb356ff7cf83bbf5bc713631fa10e754fd7e395666708 false +check_ring_signature dda8c96060f5d18346aa4e34a308ab5644529082059a2f3e50eab5d7a646bee8 4ba9d69808da60f2d202424a9d9ba8f31e0398e7df0b9973c907f726e54825d0 1 ae5a64b5f8bbd8dafd8016db8084d3eca467b00876b4e84b21c9b8ac7dfa19f4 739741e635fb806810433b38e9df00a933d8f5cb085fa3e450f0068e3fa76c087ef53d76ae8bbdc160bdfb47daab6b4c11d2cff6ba8384ce9308c018b05c8d01 true +check_ring_signature 276e3c67106378a7581e3e070b9085ade1944a04398be785322faf8cad9fb4be 5532cae293b02ad3df3d82ee23ac44c426bb65540b1ae5ceadb8291c3ab83101 156 65b5fe57540dd6c228c4b9044da46f93efc98435099b71874c0841842d45af72 34bb878f7c7625d7e198ffd6d532c95d19ac627c89be52298671c16a14106688 84e2b63e4de822f4c43281f04b56488aab89f72307bff17d1dcf5bd737950741 7103868a316522d9e074798ab50cfbb0f92311e87a07644a779e5c1689b86df4 17405de9833c0c0f20aa11d44b099a328d5164737365d6ad5ce50006603a7f78 59c689b6b857467dcc20587e7a8a948dd03977635c3021dcda82c9af2f3ece5d 94290ff444fe73c48218d6dad6a9ca5c60206c89f45d867371ee1175cc60ab62 6227678c5add793ae22bbbbfa8b115451826cd6c3b94f071cd45242d6a5c3f30 d11558de4c1130bf455acbad891b9135c90d375e415404d5b6178ea98cce14ca 3efd62a67e69a368e546eb7395a54c5cc83faf0edc8363d8ab9c2b800b95e32c 660d5e46a8eb614b394646efdf603c54ffcf233e678f0cb8677de732a473fe87 90ac7e891685c378117f7e1b7ce66983d0768c804c0663a18a844db4eff65aae a57df5489626a8586275c571731ea7140d88964af588c5e0329dbc7ec68c6bec b2f514f34813ad9845de16ac20474e4efaaadf74a931d50880aa541f31da8308 93bb9ffd47996d622c16bdbe8110e7c5f570b5f19ef947f680fab403e2beefd4 b0614cd1804467119702869cd204bbe5acf857f1220b92729fa14fa199f9898a daab33e8e711198512d1a7035907b9b95ca1eb72f49730e32dddc31b9e0bfbe8 28026c64a677f492ee4458941bb1764584f8c9901b54bd81281196eb267f7c3d b8a2db38fef01c5715a7b516c2e9f9fc1c7174e4b592821517a8d21089898313 5971241aa177d0f5afb229e9e6863b58e1a2fdebabeebce22c826a56b02eb42d 0fbf4170bd0568ec0050d82411eff9151b494ab458f44c70dda3d465c5ca20f2 a0ea26e4b2fc861229f8a66685b782f1c5a1abf88de77bc1b6b912ce96263f9b 4dc3cb5c76dbd2fda95cd488fe9ab49ec6169ae728af63a776ad465dfd0c28cc 3af87d6515ca06b3958dec2a7fb7b4a9d5af14ec08a5ea3a02d93caa40ccb1e2 3633040e904a29a649049254b7906d51991f7af3ba395e29ef1dafbbc794ee79 506dc8ead0fb8619829c5d2665ef4d0f56040cbd68222c04d7917531762091b3 06160beab321dfdf9821821a8cecbf2eaae98e11147083c5e46cb744692d497f 161b66285f36aa40dd765695603f51f60379c14a10099079d29cfc6e2d8e5a20 0f44e3f2b15a7afbcf8094199fea4c1abbdb9f80e003859818aa2b3aa83886c4 05a5546381cce39b8ea0e327fcfc95081208f95e71b2d06fefd076b4454cf65d 4870c2a0773994b7fcb1c93b357de1df88d221a4fb020e5bc992523a08de091c b96b98b5cf6b1052c716ce1d21f32e75be3ca95eb92a9de729bc9a7197b62a49 9e48222c847f90ee463c28d4fc4d6e39e7e08ae250bd543132b8147f3d71a2ef cb3351e213d21ffc7d60d0717c757772e4cc11fd66ee8b3944ff23f700537c3f afade2b6dd45abd42f2bf6d4b0115671cf55ade63aeec12af8c5e5de5c2a21dc 70edd0fcbd79c37cd6295d3cfe29ca33bc8fc6854708eedcb66220a667c23f78 64a45e4962b5cfc7ff232e7cfe0a677d4925468d8ee92ef6065368de17c7b951 c42bfb3952aa740b0e804f84c29e4e745697d7dbb85856a27cf53afe3ea7f577 2988663989ee6ae2d816028d0e96b10fee5e562a898d13fe7db65453670a6fde 00cc5e0818e1aa3a27af8da47a04f7440354ef422cf91e5e4e4ddb3ac64cfd44 b6aa98c46e5df5a2b21963d147c1b9cae498725aed971d744f3762a6d505c29e 5f3e1fa45a2f7fdc3e3a15cee6d690014344fe253a0540c9a642613bc857994c e824138d7897d2a9392cca20fbac3af9869fe1980c04174c3fe94ebad3062eb8 c6fb9a9c7482b658b39bed2b027e4fb17fa793ee852f230053cd464f92ca81d1 965afb02d52768b09a926c1fc5cfbf64fba25b58b1ae0217928dc10de9fad106 cc0fdd1d70e38f4a38d33e697505e9dfc98c42875911f4ebe91dd5cbc9993719 8331e95c6aa5aec83307afbcb33197ec4fc32b2050f7763789faaa4e0184c17f d6ae4ac6180f3ab605eaa05be916c53f567502487753ea296dcf50c4fd8f298c 405a47189045de01367b134ae9f34cc2c19606ef2588ad7f8b77d7f2553636ab 68e406ab5f8efd29768d9e183672d25db58a67d751bcb711d3437241022a0df4 3c53fa3659c58379f4206529a4aa4db5de7223467412a9458ddaf448ff2775ae 1d2f029f2ac40bcbb42c63adae28819170b9d82ddc859e7c289efaa9087381d7 a7a0ad1ee439af4347fd0ae14b0baa5cbfd5f03fe5cdcb51a7658801af9b7b59 e1e4631e1d36f5f5866cd75adf407f1dadcaf7d989011406b63310216cce57e3 f59eff9cac1ab32a9d21995b1cbb6df5551d292c39c1e1d34ebac94afacd268f 428b4c84feff28029ff8f6819f9e76c99bcbc1240fbd3136bf19556175b0cfb5 df66ea94a2481547fff0fdfd2ece82bf4ccc4b46e372e7c1e0f5aafac5cdcac8 8ff88acaad48f8957ed6e9858f8b1ba7b887a22c499598b7726615962d176440 42417d7dfe3d053398ed3e78e021f20e4052bb7f6d0aed9b70c21b69c9cc6a95 6295956ca016a0044ac574aed2414689fc4e200dd8ba1b1b5a95c7b4d3b82240 908020acd9baacf6d0d044a73a562f65eab779f071eb7832549386d682a34a18 c5325d8cd4c0d954646976ec05bfd0d532b6adfc2c2061c5f880d968f7a4a1bc 50d24bfb6a9f8755603da2481273c1bd441a7e13869d37d6e6e6df2a07efe1a0 5d56e324d4e46b6214f308582558cb93a4e6f26d5ba8727ed3336701bd0ca69e 8aa4ee01540e93603594e0dfe7356306f5c7429529fec61825c0f921d01f7ff2 e833209e5d75596196c81e915d4584b0e40738dde91bf15ab7c7973d2a09c36d 9a8ad22dd56d94b326c3430979bc0f325ad981428184c77c39d187731bf96912 b17dfacd6881c9f8e4521a5cb50407c2c3ba64fd145f12c53b261698fd37b154 c6cf71d99496db7f056bdd86d2aaaa0bfdbb208494cc1495987bda3f4c66aefa 302601ad40586f0372b0d6477af5f0d6f7497bdbd8f57518b0444a68dc9f64aa 110e872f0296fe8a393c6b067e206a52d9e8199d4098c3c20cbb3edb33962f78 90df0656de186e23f3518388fa7896d01feef16473932f3744587e649271398d 28ddd78e7e8daae4d17fabadbe92d7c29a55fe3043ac48778e49da559ce64fc4 afa68418ebc77b43812b27238d6fd5258422b869b4fdb5a0087eff020c8dffb0 2ea60bb46b96a1dc3911c7ddb29995143f22f62d853017c26f18e89329754b5d 64e3747c94dd6086368a939cd2934d820ddd3dd156561de15f19d5bcdd633a6b c91632c8b7c073110828ec7a034c54867abccb3392fea3eab465455e1d994bfb 770d8e90c4435deee65084fcdc9208998954532a28f91f410d80c9f112fe9136 3cab314c676afc51baf83dce6f2068eb7108c93baaf3dd0df40c0ef92dd382ac 566c4db491db46f9520a3a868773bf38e95c92e6e775d1a59083a75e8b6839de 64502779775aef0ef51bc602989d2b1faec90df0144e3998fa314d98cca6ee3a 207d3246d2700174b6443600c0a08ed947c6432fc99a579071c62a05859676fd e517136c139178f1bb2c428b9a20fe13bc4d41ef0c91e7022a665b5787f0ca61 ef913a3cdfe1b6d7fbf52ab5a3ee42103ed6006fb598702807b5e96645f038b8 6b57a514015099a23194ed7cdbd6fd313f7cdbec7d22695709677bdc0fd2fa47 ea37b83248b69cbcc28f5905770cdfb572fc71fafc08e5fb5697eab9c38ce17d d1bf3333a894dd3954928b7217a044d5ae03989309b791e53dc28bf7136951be 4ae6000ec1f4f0ceae8ae8020ba23d946281fff5e20cdb4abaf0a609ccacf23f bf5e5fbed86e3846ccb194ebc3b0ecaf88fe6c49bbb521bb326334e971a28e61 61d01d789f9ccb5cb7351051466a9bb07b956a163e531135caed83c33aa362fa e9b9291873ef01223e51f81b6e947924fa28d52cb0162293f067101b1b0f084a 801069de40a07be1a0b61fefe13ddcebefaf2e52f39281f1986f3d58b4535bb7 7ccf1e47d53c4c89d11063694a67fef1b16d9f15f065decd91536855a094467f d994ba5a55549ba19fa200110708899325a53f006066ee7fd426e63ac6ee5558 47cfc2088e80dcb06802e99d2d592e1ad3da90832c848cbabd00f5bd478fe299 ac61f0b9f8f0f6195419aa47fe8f443ef994cbf894d355fb00206aba03b29a70 c27e14d731741fc9dc05e2cbf11d60f12e415bce4340248ef1e8702498b41a0c 65fbb037831ab8dc8723075bcd2fcf63b07f207b5441b7b59aa94f1f8beaf635 9ecfea44e3d2ac28d75d56c736d31bc41bf21a6b4b3d3e232a171dd4b99d8d0c 5ee8af170b5f4a82cf1d4e2a929944dd446fc43cdb50c0e2fab95d6380100769 a0db33441e3b433adc4cc6eb44c470a0c51e7980cafac57cbdd2f3e3b7f6e8ef 586e6d3461de33bbd79553ec6a3a3adb0748179b52699b8691d92660898dba64 6ed7ca00e1f6ac1bf9937b7c929197cc2d1dbdd1d23705e50c9ed23df7391c2c d59466884f989958fe2f293946e6391de9adf59f9cf6cc50098b1b5f1b417874 38e8d0d68c5dfa615b363d831e923d7e6320a787506d5e6c3722d95f41914ef2 ca60f75165556d3781ca280f7b7f715d0aa2bb6a40467e7f125e080c60b422a1 c06815714926a38ec5fff89d67b7d91ac9deca75c9a0db4a85d7d744a4c50158 a69f0156c511a805333c40d0196c4a4868a01e3628fe4a55fd06bca7c5fa32d2 4566084577c12c2203d3860dec911d553a97f8c5f335d4f34af66b427ec7d993 52d4ff90448c8523d20ba3d856c0d0a94d10efab5d343a17c7655123d5a21734 08a39e10c8c5221f309380f78c97feafd09799712b1645f1483f31d39deb9329 cb6eb89fbffebe86fc743e0939d365babf76b22a6fef00b22b363a1ea2ac51be 86c03d7c4eb8b260fdadef7f3506e7339717d606202b86749f6eb4ab9fbc58cf bd7337fe2b0c932a5ec4a9337ecbd2eb6c4a7a0170c57502d948adb3966df02b 0d1c86407e38cc957ae45f35663c8149fa570f58376c37cff922d35ffe9cafb4 57bb54e63529c99f9cce1e0afdc1fe7730760c9641f4ddd4b517bfc63f1f1932 f5558f7f1d922a1d6c0052ecac7f4c605ed1725eb123520621b32047bdb5972b 56471fa15b7ae7dbbc96952c93df685041115a754d033f8a9fe48cd6222e7686 4747c7c53a57e1ce4c8033a7ae04fea4577fe65be4bbe60ab473d0c0edcc6a7a 17315b7d9aff88a53def34a46690b027331d2c2f49469ea4ddfc0ee51dcd2a4b 8a8276d6c8ccdd0b2f845b9c44d597481b8821fc3e0c865d7f0eb7bcc9f9719e 98d8eba4fb16c17871aeced9dc54671ef858b2f656fea8f62f7356b95072cb20 0ab0d4246b25f98e4708f3a0b4378bc3e006654c7d7321c8bb4629ebcdba5244 85aefd42e14c103ceda917f4aea1719b228d06ebd8b23bec8395af6f8527f3da 4c7a5b7e6f8f97b781cfebddaf5fa9952e3fee0bf1714fa0b5288bbaf533c161 2a85c0a9646db046b91c411c29efd3390b21ce94f07c2022bdea4c977fcbf674 ddd089e731f10b24e2cc9b6ab66b03d102c490d51afcb6a6eac9130774668ff0 c7c40d0f04b39d10abf5f3fa6c6f883ab5a71de8e80f875fd58a95a5f4d284e7 ed7f01c9966127bb9eadf0a9dce1ec091c2158d7272ad2c93198ef80a849bd5c d1e87a816196ab50e228a43667934b4bafe2207281cbb03ce1210286f9f92818 4b67afdd757026310a3debda8b834c951438f72c893998c520e70c4bfedf3e28 cd55395eae90926f735bd762b307d4d1e864493a5c3257f2a8a2261b04473370 91ccc664bbae4f70bcfc20845d2a44502b32c966e4fa0fb08045853f5ef2dbb2 5ec8dd9f0763e22a4075ddc33ee2f544e81c172e652ec1ebc69f4eb10caf57e0 a2496069972ae6e559cdb5764699ac9885c2f3f0c5ae388b617f0ffc0b8c530e 01ff4eb03cf7446d87342f64dfaec6a59cebcd2167d0956ee8878bb964936bdd 1467536dad0722dac294a54aa255adb7c83a7d8dcba1265c0062cfef1d3cf5ec 0c75f0e1a483152d747b41821ae7aaff8f20414d186a875b9aa01306f76ee57b 1cd71efc31a2d40ef3337d2965f74ca00b82e91461df6341eeca2203aed6a267 7e9338b9bd0bd4aaa700bd7b92a890f16ed9790274b1a77f0554872b30461e96 f13ae7032d699f9a65c1533466ddfe26a2f5d8309aa2c8a1c34f1d5a31ae440b 3190e0d8b9d8bb6002e3d034f84909cdcb3b167f77d466216114cd70cf0a76de 244b0d406b78d8c0e6a0de1974b81aa15023b46cccb6209be5f987ea4e09e19c e1d63bdaa68df26f044dfe7d8ea3f4eaaf1fc10c87a86a5f7564a981d7f26396 2f04520cb7c968413eead55c6831a0b9ee0399539ba3a4bb163b8ef544254c08 aca1f710c191469d2beeca0a3ccfe8929f498c72ace027fcf6e123ff9addb7ca 4fabdc420bd2cdbec3aa516b1db42652e9dddf22eae1e150da9bfa3f215cd585 05e9f7771cbb24dca0ca02c6497797fb612a770873579819a88e72befeb0ec23 9f1112a4d25d7b3deb898a76b3cb302fa273c08ffa0415f711a59cd5b326ccc6 c32be754cac3558638f46ef85fba5ae5983506bd193a6a9854636d5630cf297d 5fdce8c0fa66b69e606e9c49393c18f254e4bc8d664bc3749c5cb2ba0e657c3b e3630ce33dac38b66bde125ded16adbd1613315ca5f39ba5b7d9c31b15ef29eb 6737ac8ad56f346b1545c1114955a0a0d89b23042650b337b121b135e96634c6 070f4d9e8b6fb56a41816480880ee1d0d155a7373bad862e699806005cbf5931 4ee3ef97c025425ea81fe1d95de53f14d0d5875a18dcf589aba934e05ed4b6d9 73933e483d15d7c315aaebf5aaf5a0dbc4f927615dba02ebd4675a665505177b 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 false +check_ring_signature 1d494c9f62eee69f9b132533d838857abd0de9f85b7a81ba4153eaebd59559c5 3293117f7fcab5791ded1e914d2fc65cb935dcbb483f9e27525b923404029623 35 6d8c742273aa35ab7af47723045e7e8ff65b37d86671b46d01c8c39caa09087a ec3f16693c190a805173dfcc7719940bec26d21ead9bad60fb937321ebcb1bda b4ffff3688c76f46b2d5bb1ce04f13b7481c10ddbbac9fb80e30337200649089 0b839a33c1105ab84277755732e923ba04ba75162346cad7989969a1eb5cdb86 7a43919efbdea58748b8fd150873703d1791733afd3d94bd6407aeb22ef421db a1eaeb06b20a546eabb60aada962b61cddfc346186004a8dd0822d96f1241e21 22b64ead1785efeb90bfddb30eb0c3ab6e24245281e5c0407191f5803998fcc1 59c1c6d2dc2c37beaefd646232b87ab76a7ba6fc9a76398e372ab283bdb92e17 9f8edea78cc633e9a177a3037e8da358405248a602461e649973aac6332f1cfa 1e12e18f11a898275021011e4648fc950d2d4e433045df5167404d919fff04fb e0af4ae07ea1ed5ab2c419bb2685a7a03cc2e981ec3b05957c6d158279460bb3 68990f98726feec159afa438de22bddb1e401d6e876184f9695e2f60ee7737f5 49d32dfd7513f77915da1b25d8b7d671920c9aae1f152f7d3881cd94c2a4727b 26d369af2b98c50ca4a699a06c20dc888ad4f16e94a0ee444a6aa452dfae4944 a88e1251d0ce963af2e92cf1c2e38fbb111d16734aaad06e96f1a84de1093efb a7f62cb3d7975b0479d237b0e64d636abea2c084f38fbd61d2c51d30db897807 de1ea408029a51ad28543eb8a152892ba0b954053ed722cdca846ad008720b2d 72a207039bc0b9044126f9907fdb6d2d66eb15993935af46458e19f58db3bb7a 05a424aaf52f6acca3846f4e80fe6c36ac9d9c4c5738af258ee5efab57a23eee b025e1b1788d5d00ef7d1783c16ad4f8c0c71c501e69fa1270de8d48dacb7434 721d1891e8e8eb9f7f9abfb15d067b96303bcc85c1d7adbd4f804f4ed37873f9 f44ea6863980795aeb97458e9edf05e178263261599d663dbdcc353e79c162c0 ddf85949e8a9ba4673432f2043a67c7165a43a945a953b092bb54d5ee687a2c4 12d7291ceefddc3f380f2d2334c0db3fccd529227b3d3ea0a949b448992ddde3 2215307ea076f9ce3703824460c3c831f317ff93896f048e20e6fe70f890d287 1d575b20a1908f0c1b99f1514ae345833d1ae321ec264fbcd04f1959f5e67dfa 488e12d84cf5d015282f902ae46d0c19f0a32803f9f5c4fdc66ec01971270ddc 2e8e8c28cab5247236fe35607e2ec457b647a363833ab8f42c987f5350c8b29e ee439e5b6775a429adaac42d60392bbb9057621aebd0d9dc94d8196190a119c8 e2be4311e815afc98e41155eb6f7b52ee24eb1f8cec410d443cb94376eeab844 7922106121e72a4fa42d1770293db90213e122ab7a3f7b9795bae4d41a831a0f e856c063d6b227301ff44fb4e7fa585cf30a0fd3c9f3a68a5c0d5f7f65454caa efae169dec228d42d8a7eefe50b520683c049df710f36e9bd8e5dbc5345aeae0 22d489213a615ad0ad7a35309d340b9eeafe24016b9441171119481bec91b080 5f2a219e1b1bd6f3bd8227f77a8ea1fc54d70a7e6327728d9c83706e0ca28432 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 false +check_ring_signature d1359ef7bc39bd95718d249043e04e9facd17c27c8398d0b5c5a5e05e4fb05fe 40346a808a10775f12dbb8ea2fb2cb51ae015641a84adf35fc020f3778627132 1 5eb3f3f79b9e5dbf8d50baa985fcc8b76a3e9a39bcdefd32262bfa347ba6d0d4 3debd752ac08e7bf0b3ac57fa3b7a5cd7b1a9a64ee8d4e0152ec40d041adb609f3e67fd5c813257d56675ba50fa276647931c96aece152dbeb265888539b860c false +check_ring_signature e69063e6cf60512ff6bf4ca77f6bda997a49f8ce788f3dc316003b9fccb9018c 4951f224bbabf07b7bdfece2bb5feed790a52ebbe8ffb9da1c7cb42afa6bcead 2 08439788470b3394b7c0972dac3ef1c061fc0ee6909c03719b2aaf42b26e801b f0a68c724817d37d66a144cd70d61400116b1aeee71e603e3d4d31eb8a14f2c4 e890672d0be0fedb685aa1a04c8c44a923d91b0a80f07e006484d234500db402289c8900f66c56fb003032878524b42a98859f1e492871bbf0d06b0e9ee5f30ddfb807780f43cb9e3978287768709b9d8d5ce4c4bac4131d13b6d937dc6e5a080b6ca672088d216cdf10af58dc53907f555f34312ca368ca3de2ec4df3f00f0a false +check_ring_signature 9f2022522588d20752a215d43decbd87dc38d86e3434d5ff9c4eb5b36ecfa6ea c1c6449b808f96386e734b8514caaa986d9bcb005cc74634e40cee72d331ba53 1 737716c7faf1ebd022d89e3238d039222d439a58e90aaa77c0ba01f5192b2551 fa1d00c2b0871603d65f0603128315f35c3cd47ac6805d30e01b4b7742789f003b9ec08cda600059996d83353f130fbdfa4e044fd88c03bb22119b3c00602805 true +check_ring_signature 43f044cad1da1650bf0adf0fb27eebad8b5efa1183812e2463f5a3d808a3d1c7 1a99eda108e780917cd4d7cab3301a5a595758abf4290bcc748ff13e4696ca66 2 dde0e4e85650ece7a93fc09861bf2b70fb2d92ac9354a869537250a339efef5e 92cfae54c77c09bfdbe2d05431e8efffaaec40e15c105978cf3e87b467527c4e 4c042b574a6b6f0c77dbc7661fa1c33055bdcf5feca2f533d5d8bf21f68160075ca8b68ff11b477f486e0cd85df2ccbdd5c2827ea5e946b1689289b09c0ce3037899d071c52a03ed934f36b45b325bd12b86d25d9332b89c9edf4cca03b8f20f7279e0d7d1d0113c638f3ec59ccfb1526d9c7f1197d1f66894acfb31fa075b85 false +check_ring_signature ea8e9558dcb64815781ab100cfd4cb27766d95b6fb1099ce8e6ca20457c9eae0 548f79f58e4803794e1846454032e6b1369549a7d891d86f49f2ef1d121df56f 84 0bd270d7a664883621800b4d2dbb14958cd02c40c87d18807b9b6d5542519cf1 33cabfea0bc327b96c3adb5d158d8d30a8f05747b66e2512cba956a9dc33ebd8 de25955f0b8f2c6fb27dbe8d21c354d1bbec66aa3978333f2ce73896be9c1a60 72f26cf326974e77af01f4beea23b1410b7b747c2dc0bb7ae871c22c3762381d 627c03c212ad9675009241a360e1a850050fa9ea519d44447915887c91e54325 c493207da25d1a640ff02be6a7c1652713ceb2ed62c5805a9dc9c4d4bbf393c9 5119cecc79ce79961b934d2712f5005c44696c5aa0da20577fc8f0d80f331900 37ce26a9fe3f1606f068fe11ef319c6a88d1dbd3cac7830b862635ca020286b8 caadc57314013fec256dacad09b207fba5fcc67a493cd3b3f5a46b09ffa79e63 722c7d25499c2003f41921df4954c937d91682a037fdfedb879e3a27ad663158 fb1d8cac2bffd8461ec6c2b8782398364b2fd2101858eb7bf58d0aaed735cb4c 5003c3512cd8d2e596d0dd07b18856892fd35d9953cdda7c49b0035fab99bac0 b4230e169b3c167fbd1ec43c27a1ed04eb358ef081373c88c5e4e68e7349a2da db4eb228b5fc0a012d519d2e3ccdd4244089e09ffd2f2f1084392a6300671f65 4040a4abce754bf0049bc27e492f2a3144cbb8a36f012ffc75d02efd67fac2e2 77d6813d92c7bec23fd0feb53a74d886eaa61c1b9781455dbb839f1b33a17a2c 2d0d1bef6db1badda49ed7f8c718e1c8e3474fc880afee13ab598ee751fd29fd 47a742fa0e5328b8e0a030157cf664e5280e6463b41010f8bc095f5fba6d9fe8 8662ff5e20c0cfd2e479dc429bad184e44f666194673e21b4b20df5295adfa7e 3aeda7e370dd3d6aecb411baf384b47f372856873ab2abbc383d63ec0a55a6b9 75e6b0f0e193a77f1e9cd9ef196f014f6a6c128a89758ebffcad51b20a276a70 10f6ee5b03a77ce8c5971a96077f8a51df9dbc7e1709e86c48423d9b4fe93699 53a05cd5993ef81a2d4e78929bb65eb022410f3e8a89fd6fea73699215eed243 6933ae4a424660fa29863e5a83c0184ff6f056a81d450c4280609fde7f0289b8 50f8cf2f537274835af92c5af2ec40dcaf66c7d1d61d15af80f137e4d8e1bdce 34292b469dc032838cce8ddd584eeb6eb640123f1fe41bab712902ffc1896bf3 768ab47435bc410e3dbd7fe847992394ff62a57a42194d05a753ba9720e04b38 86aefc0cd509d409f14871beae3ffd6d41a8bf30d3201068d85a3671b84c1157 b2cdf9f1e419ecbe573a1b2df8548ccbb8b21ee2c49090ee172fc62808f21d16 ccb1c7e37ef63f2536ff0b337bf1f9b05a39a1b419b3b7fc88d628ed6edb13fe bb9a21b84342c586402132c5565a657ff60f512b0323ce82f92d7b928d03ee22 978b797139886630ad4d677200a7d5c950e296cafd2a6de2abf49c87c9ca9bba fa6a9e78517dea355cbf84045e1b1b2a70861307426d764cee1b8d9b3775820b 61e8c20904872b72b3aee51e8adaf787c8ce202714d217fd5f14ae16d2181a22 91af28c1ae188dbb631a05af63019f43fe2731177ec1ffabc6493fb14065d98f b3c2e607049e866644769e61e93756f648c81e96c861f459a4ff7e89b2fadb3e 13d5cc13ad593a2c086d705f23cdffc7fd692d4d92471465a5dc0ee0e9c44491 d9440dc23b7977ad079622389656096fc3393f81cbe4f4a20676c4ac7f18040c 74bb828919f95dc9f6b1ac2d70f31af84f9bb632e22da014fdaad8d3b1f550d8 2997026042af76afde91b2a280eff32bacebbbcf9898148507f2dca58e9bc9e1 f34dad0e6c049d35dd247d21e9ff98e34931ea84730057a80f4306a6153d88b6 327df92bf2ef2374e60cf64418f1ac47aac66b50f521142eff76716646079dfa e461b32ddcd0c7f4d924476db752bc993e271f54cf890976bd8af04e85a6cbeb f55213e7a38dd21cfd89db86a62d6c52c3737b9bdcdb9cdf424919867f729fb3 439491c7d2d44dbec016f219d39e53b9d4221f662518663d8f9bb3c4423f5d27 789be546055390b03f95bd00d43320aa849f25a7e798221948270827c651775f 50e572a1bd87e5168fbe2d02887f9b292b19589fc4a89276b1f80d7611de207e 503d219307764f4417a846ec11b9e14b7949db9021d86c3d09ff9727bb790597 04c81f7a0996e6195547cb783ea06740b00147399ee9e128dc1713c1e5b2bac2 84bb080d21e260783f12f86d988a057ad444132b790703c4fee00d3c815c784d a3f5734f0c9e2d071f003a213d359a59e9eccd84a99ed983e03ac6945880768e 91e521dcad89d481f658399ab6dc0a03dfacbbda9bf8dbb382076e44fe1337fb d7adcab91e24b2a3844179824f0c4e4a28e25cbbcf5b9c94b6bdd3706cbfdc0f 5e77f521ffaf8d2c66924de380a4bb954c91b40daa6011debbe6afa79557c2cd 91f8001482052f4474375216197046f6e97a80e3fcb4e4b69922dabb28b84295 577661df59427fbf287d421ec2a0c799fc49b1cbd48a187439f697c7e2d3380d 9f43c214b154513bf538c4885d52289909788cec3d55897d6e3d92d305d07d2f ae98e0a221818ec0f3a2b6a7634cd0558877d5324d1d87676b08485512becc66 f1974288ac7639cc554193d623602be00e93ab4ef16323575a6a35eb1f716a8d ebe8fd7212ad09d962e0d69d0938e04c6b8afd66379c9465ae9c65c6956b8689 6389b42d473c24c8903b5e452aa22eb28e5e83109e76c09f2417ccf248883fb5 774695b8ba28c0ea8864b6305fb0ad20afdbd36259e8a995f3884b6d7ca34200 0d4ccf2b60ad80796da158bac3f192e18cc804e5bfc988c7c2f4c4a6d0bbc142 f1ba734fb62c6501e147316fd8f362cf23b96ce24190229d2fa7fad1cff08cb3 e2ea17a73637a7000b998926b322b18109dca63457c2f9891a5f6473bc8559f3 db74d8d639a5123afc6b24e525bfa55e41e21a716e5a47f727120b14df5ef279 85ae0288f68754ce363b3317ffcd8d8fc5ac4806547ecf1526b72d863662aeff f0ab874f30a8bfd016e2207425ae274ca10002ff34cdec1267e97db524771890 93ff4a75b658765e9be73fd61811badf2e012f0c2cb9d001f2d2047610ae3f68 d6214325b2ab7b38230f01bf5bb963ba166ee34737c4ac5d9f1fc46629b7562d 0d85c9ec409e74204fe65be3f2de6f508bd45ae5db833f1314e562b31995490a 2d2ede83779a01a145824db65e431162accfdcbc09abff06de9715bb74a6d3ed 6fbff187dde4851aa0b9cbe722c0f815fc09c675e0a5f9694f3825763eea02e8 47313503021b95b5a2a3e12bc87fe255774a6553396eb662bb78a7add231843a f28b35dca7f4229a129a895aa026f54dbbbf0b1c1c081276c2ec789bfbd6a523 318885bc179740c2a51fc4bf50b24288e025c72e3aef21b1603de6488e758992 d16d1d096ccd93a9f6a86697e5069e4921da9c3065382bb56a89ade4ccd40e91 197135853280c2177909fca87216de4af66087d47659c1173beca0acab5e9ae9 6ad54aff2dad7a3f29ad48293af11878fd94d84b4a1f11c5b274bccca48dc6c0 2f2f2ff89b00301e60b5c78a17afc515f476b045710a8a05bb533f8bb8b590aa 268fd836ca6cc9f1fcd2bf81eeccbb124d36905785b250eb99bf63324c3a696f c856c032a53d32ac41c7800620109afb89db058d9fdc1f69705566f5c8ec9ca9 0826b16077b97e944b14e50cdeaea528afeb2157c67368a4311b0ddd93008566 91a356891d29993efbb3df02c1f367f65a2bf078ac6213ee5e34e63ea6483567 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 false +check_ring_signature bbd3f06c617084a283b4f2fe818e006925d7be6b47cdae6ac6b62af96bc6b4cd ea705b1d87ca561db5946792324638f596d807e3c21482715501802f8a4394a6 147 7dd495d46b35cd6183ecc302cd70d381d66db3bd3df20567450511185c95f578 fa5ae3554f38915c3f23b991680d91e23c059473027567507b0f8a4fab4f8ed4 69a8a26c9d10f19f4356114c3f9dde4480835e685896ad9700c640dfce28c628 a243bed0074d4c8e5b659cd3e27c94a2662aaf044884ca7da2d24537bf3c3eba 7ed030d418d88c0b2677f7791ff3a0d5708088666b0d6be9e3271fa8775db5c5 cd5cfe39508801776be729a8b4dbd4f64e7b1a6c5ac3537689dac6bec5121f78 13f826f824a0e49c824dbc50603cff78a3488d55a027f75151cf948cbb990801 087e0f3cd78b6b4a344a01c3cbc1ee098e04cc229738239bdeb7ee52b807992c a95549f5933389d9fdc463863e5c3e5a28dcd678b253d0628738fa2c88fe33cb a974c566c1bf6f28afd381793132743b5a4d589fcc34c4cc26cf686c0fea6a2f 2690a2ad23203edd90ca23dfd9ea764737fd2e487dd4f7e2746ccd9d76b7c402 c3e7e67dbe912c5c98396fd07ed8d019a019ec394d6d7583debd8353501cc2e9 1d935004f40520587c1115e6bc623df28a4c0e437778642f7cdecdfcf901f45d 6eb533735e084fe85b50f8b2b7ecc51e4025f33fe873b3b83a05f9b2e896fa6a 15a4786c2268056f448c0cb5f948ee1996f7b8617af8eea01cf6e0938867c92c e1596b6ea92672998c80d5ffb16bd7c7ccc04b359515ee8dda39b7f77b8c14fd f4ce43686f3f73a31474fad8c402c09e26ec198a860fce5af00a8a526bba4be7 d2cf9c4cb43fa1555a91051e85e91faf5558d3864124967f51bc0247c7afb64d d5dad7c93f0fc2644a867861b0d3b07586ed757c61b4a538458620b54698ee78 5f075a6923a754f54d5dbef7efd07b45da181020360fae26fb6c27414a91fc47 c63292e6408fccbcb2473ef1e7cd17a9e6841e07b51134e8970ad4f5b5ea9938 898532fd843ddba47eda62667d3e1ed4195dfb3d10928d2afb08049bfe368881 216e27f21a7e9238d16e61112cb52ad6c556449a94f2d5c7633fedbc37e7685e da74ae40bc4923fe7bfa8622c49d4f5bd35069951c32b8ae6654789b5ecff6ab 577526b2b0087a6bde07c004db6f3a72070df799dd92d7df4614378bd2443e9a fdd357cc2349349d05dc771ff0571455b3f85f98fbe7cd4d99b03397ee50707a e5ae8713875d3dabbdd3a23a9ee724727766f2917cff0ee94de02d83f0a92d87 e601e60405f47a38604d671aa28f328510d37af902937ab69b5424650c2c19b3 806d1d802dd1ee2ad9939250c7f7ef99f0c5ff494beabf05bfed4afccf1dab66 bca64685fa9b1254f10cc50c7fef196868dab2b8036ba15674a5519302976408 7b73d143424f0e53a0ffce85a9a6ac22773deacc249f8d3057aee8ff68622d09 358643ccbe0150c4aba637162ad0b319fa8b029338eeb88677407b0fe03cf92d 653565b3798c5406f9ace323dde5f4441730ba1141a4cbdec2305665b7b601a0 5c2102fe308cfd61d3c5af8101fed03e608e7822309a0a77a7d751ca058eb2fe 1c8acb2a18c7d1a359f4ba665a18c0b588d7069a35ac0ec8984756c3764ad4b8 167036a356c17893170e9b102ba6a668230e5582d3c2e40de8ff2617bbbad012 a71fd408afced7a591e549d84e5d0f567218d88019923f720e66580105f05414 354254b4e7064847fd24e61619c47b87e4e4a98c93c4cee7f5bf2a93670d9eaa b9ad48e34913cb70d0c7170cbc0a1f09dbe4f400840602f78d37fb5ba55cd486 f43d9fae9f6ec3cc7b8542002f5efee9dd03e0c515470b9dabe3311364f76bab 2903f24a8132541ccf6da4b1351a7e5d68d7edb3664e10033addfd7d51e267fa b46a9b152fc73dd38018359de56969a099c2d1850b84b1b681183fc32dd03d78 1eea10e9bf865179ba86ac811c590e63557e052326c7e73abd75fa9d23def5dc 035b63a5d38ecaa51515cad0db0ef09c24b482d073c5d3a8bf6356b211797cd4 fd2d5b5aa226e377debe0db917c4d84476a01cc470d377135767edab9c3ea3dc f8e751f24a151685fd56cea32e46e0922c693c3f4b40518cb7874bc019a712a6 ff8d8f61a5726ebe6081633b10178835a654e8de851a7be95ca785ff53497ffc 3646fcbf1fb4fbdc5743c2655df83d0ecb2f0f92322538b7855b6625f3110152 5687eb2d149fe524377530ec07e6b3c0cb4faaef316f6fae7a99dc049fd8d72d 309868e8f88c46ac67edf831ca29c125ca54034440cd458936f33ed2fcd7a2d5 a851918058b3208ad81a161431ad52411e9d2648c71e680f043c929efafb2d26 cce410a28f342cda88856e0231b82de6320c775237170fee1edcf4a402dbc306 373134950331771f3fccd3a1f2842a944311c86626b910c9d8a5bf32699a74ed 694e2871867e2c6b6da47fb9e1970816e3fc1aed764b66179cb0e6028250ca65 317c9ab026461173387120f3ae4cfab12b6de41fe9d5f6f506e32dcd555ef4e0 e205a114404bfb07aa8460406b1d561fcc327f57914c4e38c333cf16a1e57937 be53d0d3d56fc3973fe3ea71530fc8155f9894289c9e42d519b605e632aaf562 feb543d2c65d4fafe804ce9af41e10cc7f161a15ed83d30cae2224071bed3c67 46095bf4e829163969836419b57cb23700faaefb5d2d73c646ba2d78c9d37407 cbe7509b424e55a735933cbb665cdc99532b158b22199614d380997b8d1c121e 9212e685fdd59a48c6e94d7475f8376277c0d587716175c8870e81f9fb2e437c 793800db17beeda6dcbaa6fa3c9ff798c654e8f188adc9b26ccef21f05c86dc9 17fcfc205faeca2f5c091fb215f2899b6fbb752b7839c6994eb4fcbf02d401c4 390d5231c2e04b41dd59b6ef8b92b24aced02bb2bbd4ec34c92f55ffaf593ef4 09c2b097f6274b8e231e33e8cededb2ee7f638d5478d1d1f934ce125fb622d69 b1129f2ce21d471ba5b4cb86e012e3984ad83c023b26052cc9eeea8329f221b6 03bbb0b417d3671cad3a04dc41af2decfcae747973d5250ff34322ff71e5b692 23f2b95240643512fc1a758ba15f4bba6a214bce563a8e792f397770185872d0 870a715c9e7235e9410f987bd385c9823a25887dabb42d05f3ecb8ed2c743347 a7055a6bda61dd3c57e7c8b945c972d44aa79eb6bc1d7b46972fc7fc516a238c f3733c573fb024fe039500f048a0b42a9d48062547c7c02dd8303c7a500cc623 74f82826ed78112bd6b7fd2bd63cc9d42fbb890b1146029ce758da793f1bfced 05cc3ac8da1f4de2854f18e5cb59cc30e67c88b0d0c01e09f56751fdf9bbe49d b59cf75e425393faa299cb46ce59c1b706a5c3460a60378d652db2c7645baa0d 0f7f02c037e61b53a073902a72d2c55482611b04c614497733a8ae25aab2e54b e0a28f0e82bd944255ad1d56845e5934f515af2dd32a2ba43c8de17786bd5834 62a7f8967fcc8f659289f1c555e7089f6a74fa744233b163ed4f58a4e8494cda c058d278e277c9c384310eddd365edf255f8b7370c8edb33304cfbe9ee502fb3 382dc9759a4815568c13f7f064e31ec6295d074e675da7f878a726d8b4bd0ecf 8beec119b94705c38a18f929955e607234ebc32050bfa27db945b996c587f7ed 611e4aa0e0402ab34f6fa49f6aa0d0688f0489ec864ebfae547614cdd10bdcd1 0caf1793b85152b6c0fa11f600ab53ff7715b9ac12883a738b7289fa46dc3fe6 b3270f4ea22907c6377bd6566e039bd968d8aacbc804bcc7f07da794fa0949c7 8f3e2bd24b1749f46fe2f70519855e24a4196e815bc5de2708dcd8d1b3df49a9 0bfdf8b73d1725137701d0187a6e62e25530d65474c507e67504184e396505a0 b3b82292d500a98ff9a3a432c2f8e785e6346781b3520f25e2479f1327433d13 d825cbba7fc1d96f942ebeb0d8fb8865511201dce6288e78f953cb6b2df2e881 609c42490b41bb1f1634915c40a6194bdc630d0ff80064720954901fa4284654 3e360491446fe835acbefb68e8c8bc5005a371c3db20673806a2fb7608798498 075fcbf84e3cd5db60547127f8a0011761da9e48a7182b1f2989f40764820b5b 6063d6615d1c221c45b6ea2c76225e5573d5560561af9f85aad526cacd6869bd c5b4a1de370b0c9a61b2d37cd7dbb20dc6844a7a65cc89705f08fba82eaaf4fb 594b4546f0f76f9fb943a01fe67479a12f54a15f307335cd415c5634bfd865ed d29d260cfaa9af9c9ed34c251191fca75d4c782e5af2a1e160aa41e7d166c7c5 35a281f33e17be4ebf27ef450943749bfcd3adf153c295378c96546023bf1fe0 a685fe8f44ae1506fa88519cc1b38f1b71896bcad67f6bf18ed041c97e1112a7 ecfd5c67cd74b7eb366d850388122b45f8c4b0553836cc03d0352750e3afdf3c 9d0b7e3b7935ff82b056974a829aad1aa11cece575ab79bf61cddec96ee26b69 fb78d011a44f7ec54ea20c529f8cdd16caf8ca1c2dee1e48dce07af38e2d2797 85dbcf44fc95b4d62fb43b0a238c61a1ed0392283e8dd27f63e47a086ade3791 d721e2367b5bf4b235b5e08e56965438ba5ee3c960f46129dc40bee7dd14e2e8 3acac53ed33de4f600731cda102032a53df9e7ee4e9bb92b2947d047c285c4a6 4a85dfe6651d71b87012cb19e7aa64bffc84a0358a092c03d017bd8ada6db4a8 7059847850803b1b3df3992057ccdf9d745306f19651e0279d365bb7603eaf21 73695072156cf7ec310b53cd5b826f248c1874cb3c6273e6c26e27413d615e7f 1fd3a70e8f45d486fc23ca06b35bbc5ce5c153978636d952b6fc7ad8623f40e6 c1dbf9970e63fb5864543d5f7ddf559bab5f35c61b94617edb85015e7e39754d 29dcb261ddcaa2f103352d8962e2973cd93eb2acab536003a87e55369884467d c2b7885aa8e7c9e1efa3b1911d588abb6f9608c7d6d30acbbf00001ea4032509 ddabfb30a01248084ee71711686b11f3e72b1699ec666e3544af623756619a2e 65dec59f2f5d1f42fb57a4b171dbe6e00d4f9085dc7a4db97224d5472321d43b 18dcd2d81610026083c4af0db2b23aec462f99552ef151c93aa79a2d6920ae22 4c38524baa7b495a582dafe5091b08a312b9c812ccc29549be83f041fdcdc524 8195ea43faff2b72556964d86af9c28204d990a3f9c989fa986104ed57ec9d13 d5589330fd4d06c4d2c8bac5eb28a9997ac2ff9a907085d1710965831ba80047 faeab703071c02dff17cc320811e69d8099547442a896dcd87abfdd2241a9384 a303dd2b8f8a59d0fd165e5abb3c7e9b32d59cc2c00cc02dcc97d2295d6d48aa 182eed9056cc6ee492949d5fa740655aede837470c15be9463c5538c762e75a6 3200bd9045087940b91830a647e640473b9ff258b0f076026721ac76998f0b86 b35ea8b7c4086c4bf121746d63192449a1f44396ec7d4ba19785987d2dadf834 f70d76a9431528de284b430c26c0c097ab7d9f5fb39f8a6bad389f9248029beb 7bc6bf6c6b778a37966c6de1f5bfe5f912ea5d0aca1032a9c873becc0921e9f9 dfd0c41236e4f6c10456f7f7e6f14d06d04489c28346948036d2f5352c8e202b d0b40b0f5ba91f53f773c48336d1a545f5dc4d838c570b9dd97e63f535da98f9 a09906519c308416d01c3eab78e8801462523cad6b765afde05aaa6df14e70b3 d1a7793d3c32e4d73c54310da3d8180335d69bcf47db9f97f4ac47bae3e6ac37 eaf769edad139064f4691f9df7d340e2065ee8daf35cd275c3a3242bba133b4f 2d2fca8f7d611f49a077920632291a035c1dc4a7dc63eff6afc00aeb0ae9c0cc 71088e755493933f1c245ffefb0ac457e7bf8747e317eeabe8b0c421e1517fc0 0eb68461a58104ddcf52bbd4a0ca2f1e61295e239e2c2bf0d18aab32ce0c43b7 bf255054d5aa711903169245caa949dc2c2bec8a3313278c88e2446565075a51 2ff9d6af1adeb93181dc8f7357c25680bee52ff7c6f50654f7a4b53cb88861d2 adb707a645ad628b29cca8d67dcbff397cf004d7e11b05eef4b9ca0102f390bb 39a53fe77c36831322d55f3c2a424bf94891bf3817abce8d149b7988b7d2508d d73edaf28e9bf69ffd3f92d8d389e9e5dcebd246f5f824958ec86543e3765314 44c63da3df860bcc03836c05603ca3513fcfc50597cbe3c6e48abe205b940dbe 9a59228e31446d1c9cdca0842092fdaa837e9847338c36cb9649eecc0286b9b9 69987d672928caa5ed2d9fa7fdfeb531a3d3fdd991a8e08e839f65ade84412f2 84f1d01bd50ca593da2f823ad136df022dfe0af507658c4cc16c34742001618d ad5e1390a1a0c5e513bd919177c757c18d01522fb890c75c81be9f2312d08df1 2d6ed1d63639787c77718df2755579aed937a848bb3e2bab58b086f442c5bc53 3a3056251b2522fe62b6d62b316cb9b6e885f2bbf680bb97906ebfee8d293a68 e7b730bc51df15c95787d597acc6b93b22515cd479bb068da3c9cd5adb748ccf 313eed698d50f4b5c9dfae924e2c198552b7076405f8aecdfd3137a7d0b1c71f 007314119d1e7d8fc2be369a4c70aee6e5a68e99a297f139b6f7130671694ac9 835d91932e7d16439629e284958315db8f1758537bf4943236095c110882d493 191c81ce4a864a4c0d3b83d4ed84638fbd9737b234951ae7a00bf2e855bd4927 f7e3cf1f6514ea9412c113dd3f7307de8aef5cc0ecf16cc18b22dd685bd9cd08e1a946f3bf6b85c442db8693bbcb31ef61ce9aec1db641c44b5094c28c081a0a7686d2b96c1100de4b0eedf0600aa866ca31edb3fb0fc099516a12e45869210faeabe32fb3cbb42e1abe0b98cf3fd7a625571606734c48862918923dc0876b03fe64b66352aa43fb57b8e0829e7b7cf29b66787dcbed0a4183d55883fbceeb0b8081f8b5f414c214909e1e3d9e73f1bf7b75699de75ddd5493e3c5480547db08ea8216c45c0cd11b3ee2a86b82257625e2e52c17084f7a7e0a63330b521fb205a891b5a63fb6134466321991604090fcbb24c4ee1bc12fd78a9489a8798f030b4994f569cc6efa34ce4f7f0045872eb1ea352da8a37c860f2c649a059510f90e4aaad39cd1c298eb3bec650f51bad9c79f8221c53b7223e53a22b6e898e2870243283613e0df1d1152c38580669fa62858e99bb4dd43b318a8609a8752ffd005af33fcd38c22403d7d3558baaf1dd293ec851942302d15b666112f75c7cd0c03e8566aa37a4752bd074d7c8955aebc51ac70ef0656a9e3f9cc0d2d61b2da38089d5a0da06e8e952bc3f56ecb203dce5cc04f8abf187d60d53d99f5f278daac0ed07b073d34fe795c307579372013a96845aaac5c66ca45411411e9a89ac37b0f50f99caccf4bfa0d4a36e422ce602696c4ec8abd4e9ba7c0da01c123d7dbfd092b4422a26365ab62f89c2e74e2d6d896f2f9ba01fd75cb3d78b51b0149e0b9069779500224454bdfe2c459ab445dd77bf90d66a87ea3d252dbb82a30a885990ff36942bc39e99fe41ecb04d65ae6fcfa035e243d74ddc41fbe5c6567b9026403a8d946bdf929f33c16aa4c96c0a99569be453a2db5e13f0a5de4af1f453f9c07afde586a87ec86c916f100577ca562068c3efbd0e7befde6d0cb02cd4091d909c6b6784a8a0329dc534a30af45af1e8fa5e07744af334e4ef3fc9435bf00c60bb34a386e600aca1cfa6cdba6e7d3d3479a3bb81deeee8abce04e528933557c00bd7eb1305ad1fc211526b8d0a5a39d64dfcdc47bb268b133e00f376b0736590cdcc3bc8b50e9065177837913fce374f0bb179eb119d8f70db884df15f319b804f94c869b61e80386d3a0c231e1c2105db6de1e8964e3f25442c243ab6a3e0209981b10b22ad209d35b7e4e89b9a6da176ed17f2091052fa980b284de85396b0a953dff61a37686161b94f20fd7764e9dc817925aa0e5090a7854ca710069de016d94993d7ae0d7d5e6b917f855389860650ae8eb354726f70a09813250cfd603e10daf0c8f4943c94b65fe01271a9a314eabdb152d1cc48acf04f56a3251c9098f720240287393b951d748aed1b84ba1b2129abff694dbb57c9f04e1f92b8305dfba346875af2cfc09e19cd7e473d8e96f976d1a31bc8ab1e8427ccb53501e05530177566efd86536876f88abe362f66d5bf493e20b1af1514771d1bfa87c10dc4cadafb1dd34cf867b151579de1d8108ea8432e1e5379ecef1b58d27746010155e024777caa0f634b62622a329d81bdb813c441d315a2e98f1a951405307403bf16cdecf55e03a4fe61e077c403a6d47ce1f695245191fdedb65b3d13d3d7020c5d14f81f6c3b6356203fcb81676abaa91e43f532479d36ab6fb25f3b25260dcf8f66c23ee09776a5995615b6e6a74759df7948df6af51566d83a44e6f20f03ae9a736abd4b763fac8c4538207fc19ceca08af1506f4f9efa0239eb75837000651c39062b3d6e8f0142834abc88723fce1effdd1f2065c32c9e62f373f00404dc424cbf7b26f373aabbf4089a784398e64f20c80e112bc3145ea4e667e6e804f905f563d7cdac067ab4a038ed04674c50d8be2d5efa7453ccdd9f8793edbd0fa132b51ee955bfa4e88d92f9b40f6698fa3bb0def1c0c91d986a3ffbf921c50a9319785abf7dd6efe571246783de2fb7b02c55a18d5905525ec9b145cca7760c222401324a6c71fec4c46ff9d1c263437b324f4d5d311d6e8dcab56d72f9af00b485cc1ef96d797aebe4400cf57cc942d4caec06292e3c8aa5d92718d5657603c2c353eb654daffa4ce6d6f51883aef567a38cd08377805353b15ed07833f3049f7ecb76662825f5e7e6f94d655a498f479da11ec25011e5eaae40912f63cd078ba6402a191090877b4f01baacf5cfb2971adb3503259a9c5f2f0de6b15f4a0c30282e97f35951c9672ed00e526b7069c0ac42b630525db86ca15e8a7c0f6c0eb19307a3d5a1234100e5573372005939e574d5fd236abdba23d4199102f0f1022bc0dc61d3fb9676c2fd1b8fa0a4d34964da88941e2a3019a66030a99c5ee9090dc49b56b949405918aa537be6bb53cc3673b50cae43714ae1e9daa864ce0406c490b2b6c763417923c52021552574a27c93e7bf935427ab55d8807f683e580355cc70855f018510e992af237a3919291d63cf0c736931e04023177344f9190189c6561f4b391ebb5ddd91dcef92a9b73f8f06ccf76865afdaf878239e3d3f0b5dece693b7b263f93028da0a95f57de490743b943fb7690b639c3eb29d858401a6d076c9a63887966511867f18fbba9ceda45a449cc1d6663cb91e0227fe6f078d347c9f1f5c14e969ca5a65721d0cb0d59578247e5ad621a16e24de8492d108d127976ead4d8cfbc8bc6472e09cadd3ee094dcbccf0ef316e395696b8a6f40f23114e472dc656a8005a43cb58a432852c30bfc4c1b8de3b49c2ee9a1a2a8d0a4dda239dea5ffce753d5cf6972e4d0253a415a2b49b6f09d5b3ffa8cd0260c02fee0cf5bc5ede02015ecf6d1fd37b5f6502137dc45165f5c05c5ed6e0b026606c8f3c502d0aeb97b5ba0e81fe7681891a7276666f2aea5f1da2213afcb24750b502a28ea58217d27ce0eecda42340efac00b2960a8ba50e792e73063f49f860740d2758148e2072acd22799a006e9b69491d9a541af12cdb1264f63b60c6000c41c06664960eb77ab2a35c358484d5549f4646e06767d27e67389b00b77d7000843b6509c22e6c4500bda73d52853f19c3db88af2fc8593df80a7b401dce540f7980eb9a1a3ddc9666374ec18325601bd3c5900091d329d65a264b162cda500fb58a0a6b2f3655f00b5ee0c0a96d85e918797c511e7e5a9daa56d59a7523170182e85898bfd84024e3fc9924133d8df540cf1f76bee62477dd9ea7894cc2030d582f8cb1684723d5f4c48bb91d5ad8ea017aadc717029d780b2a224e42c4950938927d13838dab88c6c630d483775f7c2d22b174dbdf1aa63e91d9f7e330ad0e502eb43343917d78b885eb82b3422a34f95769e79910c49aa0238dab2afb5704a4ce6a52e9c6bf4805369af7d8fd911bfb7a08848b27f2e28ab213e241fe6f030e85ebcdc0579588b67979e045c52f6e434ab8e334419869afbcb3f55eec6300847f948934d6112815b73f95103a871f82a2e08a099a897239457045632f5c08f5dd63ab3a71bdeb0c3c8e218b7677ed6ac6c2c46c29fd83a8eb595979333c0a4236e24b8736a31d5f0a3213b98a4f5b2361b6733d333ef273884cb6d3d88d00d444fac85bcf35c53881e04770fa4b0077de39e51d373b3007282b3ee18645039217925694c179c4583ab42bbf31ca8660dca6aa9864a1ee338f11995cde920b749bda3cd1d12ba77beb55008276d023b981e42b412729f4c2802e69b4fc250578c0cedeb8a2cc3482ef76ff23ac97a5c97d33bab98ae7bd2f23f11924f23106480e6423cbb2145e14b17c91d47527eaeefd3c0599cdb54060ae73dcdb0f780da407008d6206318d0c06bc59032e149029e1be2fa794ea795e374980aa4aef009fe42350b527be41c53ffe713bbca0e507fb6583430bee7116e4ecc5a3008d0db6118c79e0e2564e33ac9e4310a921783051a0586a6e997115dec71c96cd94061172ac40faee995c938d2dc5060535c938b4091a813578184c26d7201889690dbb60e80ff17800830dbae469fbbf5f915ca8c40b06a722cb0e22a971a7138a051d5ab0e6c532000503fd346b791e289819eea19f9e3565a9b8fa2ec4bf895708aae4e710b37aec5cdb556a31b3e7784f545eb0f96cb27fb8a4ed5540a2dea200222590e2e2be054d2b310343d1ce0e5cbd1a275ffa76838258188e33f4212803d3d8164d249075811f79f7e035a85b071ca414e366f5f07fa5c4b902991f8d0c81e3b64ed92bdd566f59bbeae65fb98229fa6059c7769279252805b92ac04307d80bee7ac0964ca57101b6bf197e2ea59e92b6e4075ea551a485b92bd030df0f41e7669692a5b9a4fbea98739e18a71775acde17596f53433c14577863cdee0ab43b595a22bfff452a5ee46b9d3b094ecce3c5dfec4f94318ae22b7f6188fc0e95807beb8bda40496db225bd718ae59615955a87557dc01e3490471807ae4d038f5d0cc7bbc3da93af208feb99a63bb8ff457154d93a70ef8b609b613c3f83068860e6a1091fa3c88e0e2e0efe4a61e7ac69d5618d555443a05e12c628271f0bb799f27802326a47f75172bfaba8eeab9f429a227f937d6ba07629d94685680a6f2f3f8c71b709a9405882aa67216fc072f1902d322c56c265390918c0d743031f697a780d50fd5b21f42aa4ec366eb061182e25a6ea0caf982be270c5212c0656c375d46bf285c15a55069d829bf25171db70436e1a1afa89766adec5f18700d846182fd44ffa9465acfa9ffdfdd4829237146e74cafe07fdec2f2ff71dc501b4b9882d689a109d4cbf9737fbed7c3874e176a12db13af51fea40a9b0e8a707dad45557d87d97848f5f34e53871fa56acf912122d344a4218514b3d00cd98099eace64141e6a79af354ef7b317c132cc754bff793aca76d96cd12768e5ee90b99143ef1fd7e2b4e759fa2bad6bc713d0e0c75247830f6ab932251905966c00a2184331c3e3751735131756a34a86148c19cbd59ccecddd7e2cc6d8fdf6b540f1372c7a198390a2bf98f455064bfa5911c67a8856702c0c19387d9fc3bbe6d03cb0993c76e4cd3af09361137bf4cf39f011eff34fb75754cde6e3f9220bd2a04a5b36646d0021058fe30100873c4336a7c5d98627080cb23efa372355bbe4909876d74b90717ad8ad75a5dfebc5f8bb86b002f7e95215944b549db828b0fb60db3140f5e78fff4d6dfed154098130260d7a2c6b99b57a2e8f0fcb88734c67602965a030032c6dbb2b8d8f80ad4beda558ff293ed8db69e45cca6902965ea7b0d4bf01afd0f3e59424c4f609a8144d6e1e7e88a75f28a14106aebf2fe7836ef0d82de7b94c6cddb2cd370ff88c2ce1eb8dc725798c75eec6dd370bf804d27070cd8aadc0b10475fd03fa7eac9f9a57990ad79827856d793d86ebff3682337fc0ab79289d8fe6010938f3282d9bbcb9fc062d0b2583d78e2166e110b0bcd9f7803dbb788a5cba3958bf3e6e680464fba62301355ceaef80c6b35b7e6335be96400a5400c2b08916c9c2333dc48f5925bd720f61ffd105c538f8b7fbb8683ebe60f20b00c6b5c626399873748bf600f689687910e6f2756f7043b23f01f6e70a405fd25fb822afa0eb47d0058224909e3545e387d16d7d43a410d7903892e058303e388fc14fbd43524b272467c2cfe838148eb773cf24ef07ac618d2c77df0b709fe466e257f5112097ff7f12bd9695dbf895a9039b009f2144ed030927747520b37f0e4ef932b9cb8e2fe33f475dca23d022f716c3076964360a4cb2d79bd3e0ed6baff7905cbd2ce2d1eaa852b73d8cea02fb41d54c2b9cbe8f5e7c8ec0d3102af1710e234d5b56013fe5947572099e54412189f60a0c18aa9be0d22fdbc320446d4734f70fd260db22dca798c22af434b65f8abfcaba056047ff49ba946f90483ece72d2be1aa2bc8308b772271ca78bdd0a040d95f3a0f5cf4d351bee5fb0d8531200d92d47c90ae8712928ef419ec7d2e5764abe14bfa10a4cd3d154e71091a3fe590a21b927e3d82d3159f05d2fb37bb21e318f731bde44d4d0baad705074d253502431bb970b897c0f2fe18718957e376cba619fe39f1355280e18caa02efe99f82131e596fcc60940bbbf8074a4106b03564ee20fd04ff69fcf8aeae0ce1f56c2dc6839c5e91e9c501224bc427d70f703392c03b4d83b7fb5fd5bfce08fc85a1ddd2adaeaed92d1a4ce852e2297e3ac02b2c48c97c61c307ea4033bc093881fd008c5712ef93559498c8939b0ca05b9e7576b03cd1f4b0f141383c9a0738422ceeedbb79365fe8f00df1bcc6fed377f68537978a8488977c4f51ae4104840b7eb053b711b3274a9b3662772f0be2e11407721a61c044d7461cf22f110dae7254b2f070d114b7b780a287d7f9a16505051ccb4201a7acc4ba4db7b142039d3577d761f79c6c70061e4f56b43941bcf1b9e1ac28b3ce6463e20ff2dce60f31974db14cc502ce32cb3164fe94fd827808ae079ba14ee4cbde5e23d608f5029055c1d2c4cf9c4f4ae06528acbc6df892584f67406f311ca87319bf7d7f210f46d5e296f6928498a33cc9e1cd7879428ddb5637e27be1bf6ab4b6fe32f08207f2e7729aede94aff4b42cd8e45a7a1d28f102b479e2923dd795c14f4fdfce20b7cbeabba01caf76d7fb8def0fc1651d26d52dcfe91e6b287fa6622e6fa4a5a08c3e99ef0a743868c15def79a1b94954f4269e84f8eb1102bb10693f4b2078906fbaff40bf9499d8f8c7e03fa8bc1d973b6c393fef64e578517b245a25de7780a684fd7307d465288249c4016e27872184d1c40d9627618e1579cd988b5c9da0234abc8275cdc81890a5761cab96bed29bd3896577c047e8bd2cd91225b33d506a8b30692bda2e21d5d5bfd4d8178ef66f974d3420653fa3199fea4ef1a143707d5356c207fb28fcf0fa8e4977af47cea0e15992c9f7dc7d7b1d9a3c98e87c60ee6f01d9ecd05ab60940f004cd01732901751d2a65c69639de50ef4f2a9b29e0eb29e503f582e111ec79a2cf0f7cd6a66b30c087b1a18e9d4f19cc5117254210e59603e371af3d2678a9ce8d039dbcc2c3120e2043efd7ed2b326a9a892d1a40b9b1886c455fba5dca282214195b50e9275ae40522b35c54e584192d52bee93001ef8f8046bb54823194cef31887b1f986ef6c5005015c17f12c92f7dc553ce04a8e746d8f0a4e5eb96e646e35a64c3243f21df3d3915a890f21e527253e0030ae9198a3c4e699dfce690cf6d68d291d5a2a7abb2888595dc09425cbf5e45670268a42da638519003e064fe47529b26d8ff5f5a333b98fc13971ca41ea49b4a0c7291a930c1400ac79a73c8d5daf488b4026d8ff243660c7f3c5636bf916c0c00bead2bd3e573daa0370655f79dd7dffc8744e80ae984937cb99466e43793bc0f62b593c4a1830fb07ef26f1fa39fb9f4e4ddd5d53b69090b23adff13e5576b020a662259a36105ba71eff29730283b986afd0a6cdd34ceb3d95f05ec715d1401027f6563c7e8f3f5ddd1df52d830160c670304ba8385afbe1d989554ecb06c099418c44e6e353cde226e83d7704dd6ae56c0647eb1db290df92c89fbc6c5d80556a89d0de748fb85cce6987a037fba315b8bf21918c5edfa4f5014d84789110deecdc36d3d140d251700910d0efe0eba1f6995a4e07f9d15af2cd277872f700c13f77553a8f49c26c5bbbcba7d5aeb8cc0c179ff641b012ef271bc87b4f250008cfa1d4952960a832f4c4f690a9c9f107c50827052c037be983136425794a10d51caa2c1f12317f6bd5a111501f4c11735e7e91ff187913910bf6d37da248709b4456ce075dadbbe05fdb281d71bde7d4d2d07da329d55196af75e549207cf0b7b7fbfd1e5b993d0004669033d257674927172aa7a4f10cdf17b4f77c8f4b70877c78f245bf8a1d827e7d5c4df33cb593173ba4d14a9bff7908d0ae1b283400eb5f6cf4bc89ad0bc366376c85a93a6650240941e34549838905f49b90c671907863c5e3c8a300db8c052c74bb1df6e357b6d0382a7f5c4c33a556513316d490142d2d496d4de2981d8de05eb54a6b2d5579b0b6c9ac4dcd063d0598a8e3336087920c0f6b1476b885be323e02499730db939b6bcd4a46244201c4318631e3d0e0ba23190a0d1bd6e72dad5dfdb94313fdc003320dd71b010efbb3f64c7e12e0473421a15dd7f8c92f98c2bc329e39034ae64561241b5ede5402e9e2fcea1730bb3abb509575c2690d3c415d190b233c01352dca5f0226b29df8e729586c7970847839a5987cf51c981419032945a4828dfbea35069c4c8e59e8ec53ac72d610293ed001850d0395a2f064f36bc4d0bc1574d5389c14c394f5775f9409fe7430730ae8a3945af71fdf34759500410fe9d6582b1d66829b4aa4157dabb482b2706024e4ebeb91fa1955d726b709ad52d260408540fa60ad0c9187a2654115e46063ca9554bf53eed267f82a375cebb6b15290b6ffe40393973448ba65b60b91c0c0e60966f3ec3c8a7800ebc344918d985c46c9cfe7283af78d45abc8c24ecab042b2f6c40b19acc7da31dd9abdbf79741dd8adb6a0931e409f037d95f9f856409d8b217a21ae8f3f53781c8ad909f18424624308563c2ad542fa2b07865c3d50dd65aed4cce3d5c6ad092e88e7f0e9947b35bd47b5f097a9e2ebb23eeaa0d92098cfc174f25e3e3b355310b3bf7bc3f5c02ee6d93162784872787b0d56ab9540f11c83737166d32cb328afe9b2552dfd7b0940599568b71bf0216cd4914d8c309b70cb0edf3a5522a92e85527b170760bec19ad6b85aaff61f91b98698788e80fd329a7c4c979b62f0d3be3eca0e97aa47217b904998a59bc59d9e6da49fa730a9f37ac0b43861128735b92f476ff43dcce29479cb1e793293f8ebd71cc04240754d08aeb6f36644b3f3bb04d6bee3dbb9593fcdb3a8f5eecda426b9d6c224f05c8e742947a6cab3c95fe9800174d2bdb3e9f547de37fd62dd7837679d94802094b965c6dc6520e4c1b5213e757037f47115e35bf3f14272e402f7fbb3c40f5081e8aec8f0b1af96abb9a31a67d6b06027a8cd22d4c135b62c18fa49c86dc8e0b0400b8df9937d216ab3c2abe634fe88df916d9b5fca2833c46a5b062a4d9970f6ff07085789807b5b987f5b4aa1f42f9538d4a8b7944318c46c5b099e4e53a069ed76209c9c0f27402332bcc0c8240925992b7a89c08d6a7b2a69da7a0908e05653af5e3e4acedbbe5b307ad75732c2d4ac4c51e75d838baa697cfcb21120d016c215625813ff3edcfc5d9a2d7f97f7797ee90c530becf9b49c45952d5cf660f0f8283414799edbe8a6e07b3f15efa06d724de8d341214aa18c67654ce1dd704e10069799362df76dad246b41926bb8c1d1f83f4ed99590bff006fd3e2f51f01a140eb2ddd8577802864b6b53f741865a940a1bf2acd77af040a6add404f260208db48652ad7840ce2d26dea5cbaa52fc1b2e5cf8a517dce3fd382369bd8500942f1aa05bda67c460cb5f2b6f0c37f289d39f35f881bb7ce4bbd3dfd23ddcc0137a78aca135db4bf8bc2e1b01b4da273ab8cb6d38e953ed5f970e20b49b2110eac71bf7ca763d2d90ab757793315e82094364691ad58ae4d88009b77954d0c01e2db7ac5a858a52d6028ae354df27fe26ee8af5f4a7231bb67286dfe8508a40673f85a15b13084be6292d76678b06b22ce7451e846ac74434a92f22bd054240cb5f0d5c2cbb0b06189b99d265aad37e8132eae3a549734bc8ac479bdb2e67d0b6c61de484c83099daec3ca62703c10d9ea4cda27eb039bca19ed89dc11145607afd33204a7baea7302d97793bf14a3e4b44cd427a4b582e6df1167240026d3001d0352fee4ab2f4c869043c6115bab954d61591b9c5cb5195258ab0fec2f3d0bc069352df5f5c008dc10b175ba431177ee597ff60b0c8d90a3e307c0d2e0cf0521bdb1188def202443b099543bb4f8678e5199bf04374ab88b64482ceb5e640efcb6facfa1b8be95bbff9b7e9740017491bc6c270dcd3ad747dbbe728d2502003488bee021fa660432775a60f511398095c726fe762f4f478ba036b91f09a60872087723d781bc277309fac62ad69cef4c0dee25bc3d1f2a78ff2207d601d203d4c95dcaabb231a5087095dfcf670942f72ee6e77b60acdab4021f5155c4cc06334e421c507fc2d4e6b031fc87cbf931f887169b9489841b8e6ec8c883ade100c5ac49682be1d5138f24e5c711b4b60cf7efdbef4ae44b025242aefd6c30c0098ede8dd857a74267dd01cddd84b591082e8ab86b115198babfeff4b0fe0f3b07751a1e81d51c838a787869a1699f771fa97a10b43700c070c6ddeb337e96140edd4a30aec70863ae62e0e17004d3232ead54a23a019d9e21621e97ac1669b10f0695813d28b164a4112e14d5ec6242408c9d3bafc0406129358eddd1ceed460cd33f8d412e4a8348a43b50fd15974b981eac964f879982aa011f3b84d795d90f27c8238b65552ec701d254dec4b875d36ac02c31bf8f02288a22785b7fa75a060a5659ac2a349359584898147b58b5ccc48a8f564d2d069c0020622c7186390c827b543d4d02717da4a34fbfe911e9d0f72a6b01c5dbfb906080c74ee0c75b0c6dbba53dbd549d8a90ea51ee5f197e8832ae7ce9f95a25b2ca7c9335f030860da797bee9b30474fb3739d13ee261f41de39248cc319b69bc05a7c7d99c77800d138893be49167b6de6575707ca9bb3ec74c8cee19ac8dac6e607d8b265178e0840b99f9c443b832bf10de1360407707df72f534c52331d19377012126b75a709dc936a74cea95152032efb9ff85b619d3e0a8496e5a1ffd291c5b8c3bf9ec309d9ea30f1dfa80467100de5c541b34d2db7a736b65a644ae60e49b4da3e66f80a3adfe2f1665100ae88ca6e6cc72695c1d71ca95a682af86a4aa50a1c19a35a0c0c67349af8512b46abff9ae81da45616fc3305088a566c588cef598cbdbaa00f041f51b8ac0f9b328ff9ca7e1d503a79b37a403f0134689d09a828a30896940f192bb3067a6a5b180d18177ecda10285a856e6eaa2fc9025f781a15a965a0f0541c60e27da346fd4871d702324214e7f932932ebd4c1b379c5aa6832bc5ac60ee29a9d09fa5d1cc5bd819b9eec4c54cd4b38ee4212397150022ea897188c6a0f2af6337fa41432b2f1a808ba4f1d25dbb8c656d26f00bb9cc9f1aac8aa71f70b6f676a11005f062bfac1d41e04d99196eeb6417365b7eaae2b72eef1d6622c077c3d88e18ddd5b81f5996e8adb50958cd07262c7989220977c17b733a7368c0561e1098f323fd527e47c9692e07abd2814ddd84101aad75a22cb99733b2e790b32fcea7b4d655b57b3f759f9b988b8dccacddb031c2ae2550ffd622a698da80727b4794cae3f90b71d78329202e9986e58d05e6a5df7444d7f0fd9a83a4fcf0880e5d92ddf3d6b84b621cce630e51d9260e641e072b95f6764aa35a44d9f120599f084e8d48f8cd55505ab15b1def22946d180eea6685a52d3b54c70685d830a97e8095a8dccd6e3d99d93e294cedeab32ff83fcdefc444b7a7f99f7504007071b04b56cacfae21689971f3d41af62c5e2c5da4ffbb4b8405ab64ceb3e39780153d6210c5f0f9ee8cafcc8794b503a7e44c130e894dcaf59ab7e1e57b7af1a05287a404cd6bf98780e93cf64095b6e5c478f6033523d7808eaa1677685ef4e00d189728977f764fa1bf75a2b099bb82a5790d98ea2e389e2071ce1b103efa203e1311f3cdec4f65741e58b2dc0af80a9410b7beaa3f9cff65bacb2f2cb284a0ca03f94b8bc408d4f890511597c7da65049b466179237259173c5d85d8ca63b007ce8cb9423eaf7859748106446726f3d4c3c0ba666ac95a229596989091dca05e18aef234df915f3e20e19fa9be8bd9268e61ebe0796de33bd8b741a08e88907a3c2de7320fa960c94d98e279b7a93af016b9cd58fa6e3d1d5a45eefa296a8019efd1736a02342bfb938ef484ee45ff6b788e3d5fe1e50884a51c316b015f305bd48c9d87f24ce550b7080319c24d40afe7587e9d4db7b51ed274f7f548ce00af009cdc5b8d050589be9c484437baaa9c2bc6a7dd24daf6beda9f539c923690457db024a0909162ef3b399441c104cb3607c68a44ba84cec82a64fae59e67800e366345b592979ff8290e5626a2a901455d4fca58421c179a6167ca0ec79cb0b235ea76868aabb6884ece7c1c075b68af392b01cd9369508f42b2ffa5da10200e561bc372ec6cef24d5275d9090c709a83915519f671a6b25866a8280fc792033b9ffab06ff31f95367d15d17beaf300c86fa53a388036efa499e03b4894960539d766f85452c678a99384c7bdfdf12cbd35f40f73d9615adb4cee2a7f5fa8048a1830f6947291bea9719604862d10fd09e5e04b099b9aaf581765d2e89cdd0beb7ec312b3826257fc40c227e096929bfdb15809d72ef9abf8acafa05c2b9d00a811fd7fa4022e24f06dcda2bd62be42f2d408a1ccd329bc4fe6158b3a25280ea1589add396ec27d423e91d075be27a964662c067c6413e9604ebdda3ac1620447ec22b30ad153e4615b47cfd0eea27300721c3812d4f4dd819191ec50cb1a0fedf5370aad82c28d4f4e63d51220ca91332d0f247b8e8256c422a2bf1ef64109fb4d34e347c549968c561b7255b5123f9e760f37699192ea61bfc688c07999015176d2257350d7bdb1429e340e8f0d596567c59a5f68575783e2aa955979bc0c1888112303d9217c4229b8f1c8760cf6db2c2bbec5bfa37447fc83a8e89caf08384c6d6068ae147684f4c24ba053739298380976acc6e038d017e2bf780e67065be245e64619eebe165e94ee0957b90be2b629dfdd057c4dd950838f604dcf04f59bab1a259c1c798d91f21b37a2b8aa79c099b5e31c3d141c89bc3f8b80220eb656f6c52e0669277bdd75c2ac8b06f4829cf7b10ecd0cd3e5869f53b3227102c7e4580e110851c9b90bdb1efb773f50a176fac028026d055454745ff156a80e8a17924b982d117e9baa2ee7913a9095c4f955ef55bd65992d9b421f7aa50b0b4b402b9b899cbe48ace284eac2555d2860f774e0faf7dd90b014ca6aacec5d0af0b7ca1ff0e8c8f4de0f81c224166d3228b029005c9c8ec57dfaafc545dfc20ebbdc2a8113b2a0e6d62c1cf63269a0c7d99cb5949265d3a7ab4150485f0458041b4ddc94166e3793c7ba100619041c886e4d76c9c9840594d77eaa081b02f504df484a3d5ae9b7a2e9daee5d8d7322f00617a3087dd43004d68df53755115b0a847b77968ec0e8241f38af5c4cb2e842a3e316eda6ac26fa3573835211d95a06 true +check_ring_signature 0beffa2eaebdaa1f1c21636e10b5f416f3acbc83eb161d8a25f7490787b8be02 abc6daa173f9629941f6fd539dd119d44a147e6d383e00341ebb04321a62e117 10 cb23c8c65e9ff50712d4b08683ec599b96e16cbe096955bd1f82fcaf0855a83a 713712d60b3c37336a2a680f4bb2a7c5be7701128b5601b56eaaeef39f51f117 03b298e854317ba6ed0bb0c72b95629a0d0cabc3cb7de2e5404724eb3f50120f 61e30dfa1782afcca997f13bb9ac755afbd31c8fadc4f915c910a41bb95f0d4e af2010f38d9244133e0e191acba1fc3d457be12609d0c2117ecdb705d4d96703 692fd0d45042340f8b5851f3fc8aa8e26af8007420282144b96355e7680f0c56 beb4a0b78310ae3c63c924b3efedf6b1dace5a70bb8d1979ff3856801618346c 4c40b9dac64bf7208472bbbb65c29233ba64e0a75da59bad1044f75017bca57f c011312cdc76c1ba3a17cac155dbb1f37fab023df047dc53d9de127218f2de45 426beb94453cab67ea22d0c22c7c0e7fdd7665b2534215ac2010407cc3dff802 618334c8dfaec67d7f2c113d252b079e0f6913e2ecabc442b9d6acc32aecd70f7a39598e6166fe22d4e6ef7a3cf2f6896f988fb5cb4ecc9a65bbb8d3e93216078733a8f24b7a341a643712ee161213d22d70d1c85322bec34cab8738ff59c10b46e97b19a7968216ecbccbc35b5e261fed778ecbf33bfc8a2a94517df676ec04eb8124b2a1cfd962fc87d9e75691fffb179ca1c3c9e7c3154402b4a5a04480027933137ad6bcceaddaa45a755979aee0b71878402145988f31d2e9822a5074001934f1410f670d1515a231e5407330c5c63943ef3164724c75bfeec720dabf01394cea4ebc395e2a833b21386fcb5d31ebbac0d2dfa765910eb7f679fdd9710c2935a0768a0d47c9bc9a03d375a7308ff1c1ac1f8f68abd7075b61e66e5ef107bc8f47c62b3a62d2320e4cb5bb7c4b132e4236eef866877e99064ecbabdbbb0ef2e7fbadf6693b983c50f3d769505f16122202bc6cb189f21e0e1a38c6ab4a07e8a15de4e3e38b5db5bf475b7fe84b3e5ed545e39fcfb30a459cb9912e8ff80eded1b672d5c8ef81d9b888366985913b23b7b50bf634e0a2244086419a836d021ec9daa203587838edaaa6c156557278e8908990231273b4395e9b545866970f26c6bf08ddd3d1ed70f9f4cbd22488f08a9bce60194aadf0a561f1dffabeff042d912c2ba87e9f1284cd30747d5235bc7e23596a91175c522913ca272b6fe70c2558d661cbd7d4b0de562feffb19cc00adef6ccad7931e74c56f1ecd8f9a18035dd39e56c046acfbd843bc1064383003c5a243e66f431c69f88a7b676c51a40a4b5b994a67c334c680a868b6ba7015e59684db51205806026f239cd8fc3dd006f407ce8e2148338bc0ee513750991c6d7e6801132da90a2a51b2f454107c3601 false +check_ring_signature 3ef0e6e8cc86473d0eceb746e5361e4366ff8bb3f1f484dce78c7683f306b89b a53c32579932cea998ee6108757cca08b6bd14db4ca307c8380ad04ca1f4cf52 1 648fc363769b719411d7e895ea9454bfda91b7bdf8d2827316084686e9f8b495 381c6b57c7a88a2770a3cf4efaac0839aaf6bb4e73a33e6c712bfcb85f6c61fa23cb2b450061f74f54787f497466cfccc1a97f8fcea6c3f6b413f1f0acfb0e92 false +check_ring_signature f97ad686e23979204a5bcc589711d4e355570aed221eb7082d8f537e3c487e7b 6c4dc7ee773ca6f485e288234c818d3b4bae0738cddbde16aaf85e2a572d99fc 76 638247c5786f438dcde66ef07c85bc86cfd251b6bf66529943e14b844ddcc581 800da8bb667c6eb9c16744b8aec472b5e8abaf2f86639ec97136b777d4b15a14 2c6786b8fe343c6a48b8e327d12b72a88e77833235d0ada9c725f22a15929f64 cffac5de95063dff441d4cd461214adfc1f5e171bd4ec9c4bd0f9bd7e0cd13bc 579cfd1e93e6e78ddf99c6a6e110f4513f001cce30b59e7dfb6a2cd79128a22c a6ef9bcb75bf7ba038b38ad03bfc44e7e4c176846a5697328a37416e07e3b263 10dd01a599961a77225bd95af869ecb436db92866a216696fd57587027512668 2dd345611f617d5b5a318460b7d3503ae1db592bd4d6f00dd16b825e7523e9c9 8a125fee430b2955ce0ea0c94704d35d797fcdd2be51f4aac56216df43fbfe11 2c504925d028acc5f12261097d9694fde5c4926f605603649493c96f82ec243c 2acba3b387a0ba261713dcecfd9fecf5545c4aacd5e6648577de5e0273525001 3e306e064be4142ef27f8ee57a2cacb448a700e5be5b0542fea636a7b29bcfc7 12b7f37ef1e3ead46249ddd0c84d2c4c7f2988fed173dbb4b1ab1b8074356a6d 511a0baeed351c5349eeb4da3e322118bcdd29b3d571d4a8cc2d4e44a282feda f5c5c14e6057c67bbf0b89b428bd18f0b561ca623dd408f62e32fb83cf0b7dcf 5e8ddf0bce5cd9661e4a5901f6270f86180b716c5e4733845ddbc0da02ddc1c5 a98b8edae4355b0d1a3a5a791ca255ea371fc6cce4d46d6fe113b2334b153934 b9273bd6f33bd69a4c55183e50d52a39013e10262e4e31ea8382761b58ebc7a2 cb83bb5bfcfbb2ba35d95a513a5bb90b627de77d7c7c9e6a6a55462cac30be12 fdd9d3dabf14112ea75b8acba3c96fcf66ad2850f01bb601a37b0f5d8bc92303 1772d154fe5c4dc4c55baa72d24016e31be4a19cfd47e724ad1ee0e4b20267a6 df2b6305266c9ca65108255919cda8b16d22ed18f653f3825a8b16bbc21b0605 948bf417273c8c563fb4391a2a7c472a3bdafbab5632c52e3ecaa1997c7a4f00 6c8019704761be1b6198ae337b1800ac2d9244e1dca9d8e0d9e0750540ef30e9 1a75799f67109b35e2536cedb1bf111eb1e1be4bffb1b187727e209f60176640 dd0b1f90a474eef2bc06b258c823393402328045826527700237ba75cf43dc29 863b711b5a88e2080beea867befc4537600c9fa32790cdc3501e2dee96098fc2 f51b5cb9bf2cbdb914b6d0b2295317694615eefc0e615a644d973d990112027e bc85998ce578187955264652e78e697193dbcf8edd264a8faba423b25c4923c7 6b83e2c3c80b5b5e5ef14e4781604760c8653d68db614ab87ee72f45a3e93703 7683ff33c0184387ba7fdc178f15a5c3a4dae2e9eb7ab32b27c6b060a0be77eb f6bb9c919ae7690a78e82e7721ca047070a70426cf7cb353739ae876a76ed358 cb652b83157487ddaaf39a54e22c637c78c3a31e1053d40dbe4062c6aa774952 5a29055b4332df9a86a538e82a70ca13629831150e60799ef44edaccb27a6016 f9e62a63cc4c3240160b33c417e48af4ce14168513e224d618a0d0aed4b12bc6 3d259fc14950d01c5aba21ff645d8a7498e2b4040c42bece09de62d9d7f009c8 38cc26b2ae1ed56c3610f0092dbefebd1387fff060add95a26be2c6e50c5bb72 272208b512331a1feaa6b112a1ea82dc42f9a7abbdf632052b9406e1afd68007 78d6cdd427c1a6b4bf26e6fb6945ebd76aaffb577c068a42b3a2004c199b9863 71964b44986eb5fb4a9d04cc83222a05b2abe0b85e7abf444a15033981906e47 1a10982ee7475e06c8f3b4a43cc6a8d6e120a3935f5288f25ab7eb4f9e265cbe dc8ae0cf42970caeafa45f6c60e70da375a5538bba996fe1f2866ce568d62b9a 55003923511518e2d5745232a4dd8cd6a590ebadb766e9b4e9f5258c8a0eb155 0188ce2323f4a5fec481e38a3ba606d3628da27005820a8724291a47d1a6acfa 39227f17623f0ee388f147c8df97ca2fb004a560f128e6b54959f3a361b80e14 bf2121c96280784f878d48a0543d3433a25a4411c8b9d073246b1ae648e7f629 4765ed11ce9996f2f4ad4e3952aec9e7022c95e5521088e073e86eaf47084219 535884de3bb497ba0bd59b849a89ac8ec4fddb071f9405ad5ff439df0141dd63 dd8b5e4d556af0425aa6cd966786013485d63dadbd182d75a564e0d6ca015457 5a255d3e12264e77fe0cb320e44d76d3f6b5d0823c81cb6c38cf775996a285a8 9a28f824800c866ebcdf586984b5a1b024db9b6f306b21dea9c073a5cce905e7 64e90b46de69c1601358c7322b8de13ce662e7578ce0917f08549aca2c1ceea0 dd45bd23feb4c14b2de273c8a45cf5e6f984b05e8c1b38e651292bbfd1b22f1c 5117a532130d59d732b70e5fa173eaa4b4d726d828d9d85ad3be9528e34587b4 f6a379d01f5c8c3ce11b8c05a3aec5c5c4a4135aaaa93f214bcc58199a660c59 655fa119d02480482b6b153a1121bc0912aad94646757a29a1cafda9fe4e5b11 90c8bc15bf176e9549b6a9f85ba3d6f0da87ba8f9187f85f94b6ac267a5163e9 dd93b42aa1f6cf20ecbac679f8187bf58fa669ee8d4b00f63a4a7b25a0e51e3e d60c27fc161e4b047a90207fb8ea774fc53ab224e270be538ea1b3607ad80bb2 4c03bae6fa018677afc1fa25e73efbd61cdb9e03a91f0f2cba9be6ed2daec75b 31fddd2c121403dc3053f65b851c72f23abf1f78ff255ed31bd851e46303323d 5af2801a02f5bcb8c7845f2131b057b11cdfef83a779969c82dc99768b2608bf 248361245396fc31d41ea89e184558631ff06ef8266a7174d11ea053481edf7e 4cced1f82860aa6783b7adbeae62d479c95fa2b8aa14ce03a229d13e918dc748 64d3cde94203cd13a2d3fe78a5208dde676e76f6747c9922d49fea94af9180d9 a45cf81100882338cb610657c4a0dd2aad0c9cf95d1e8521149ae99cf924f9c7 40a370a8bd08e3dc3956d6ad363b5e45bcf8c6847ec065c8a9f063828a71664c a7dd7b602e2ba5e197945c7628b1c2ee9f9c701ce1c5745a8633048a40be7219 1f29929ae1a0f79fa9d1910243b738da93b22454bd12e27d2d97db11603f392f 03b56245924ec5bce85757f44ea3bab0b0e841583b1c642f1fd0342c838e5d7f daeedd56916e909eb1f2db5c86147a1e2cf8c73c3b008e25f14e139bf8877c16 d071dec0215060a0f46f3f1d9021b7f4f0c13ad83109141bbe6bf802d9132aa2 b6038e89656172c3303f39bec0f685eff066838a93ac17cb98cb314ca62c9acd c4beeb43818d7f1983259efcac6dd0f4ab70fd52183fada50948ed766a87a8ff ad57317408c49c99b79c41edb978188f9c0dd1e5d81527b1f28f16000b0b8107 eeeaa945e1a57caa1631d3b839fbd9096f37bf7dd91357d5bc4845ba580fffac 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 false +check_ring_signature 92d78b9de3b6c118f1eb802b7152242588db219010860898b427a1864f7c7f16 8e7fde2fe4e3014c18f8dc1bb990cbda429904c98465cc087966d6c8a6351881 1 950a9c2167971bee8dd3786a37a773add8319501ac43fc6aaf05155350b99746 89f9ee0acb49508c68afa2bb9fbc35bf2c1a1e6bd0fab4ef7712c36bdb266e06c1cd446573b2464ff8849782eba6c91e7a7c608953e363e93ac5f1805d5bf107 true +check_ring_signature e95345fc761befad1235ae06ccb771c85e21e1d615ce95ff2adf1df9a580fc79 5e967925f08a4b40b209818b35913003d189289dbeb27e9aec6a0c98aec33985 10 39e6c05c1175c9cd40dd2fa9e5c61eb79d0218dbfef54d672f97a469833584fc 92c46d2422c848c0dc1516a95a72f93430b74a9873335b1851a021eeb92f06cd e29ecb3b1549f9b076d76dd726d12db7319317979b2fa509f4f06436a4b66577 7ec86020ecc1b25674797f01148244d21c76a06e991f15a70aaf9ec988fde33a 33b174dc6462b2a8d9d1b5c4770740936442cec871cec6c2f1b7a0b9dd4eb8e1 1ec8b4445e34be366e94e11f1cfd4193ac0fbf4aa8a16a5998b6e517e30d15de 10a5a5fbec77f81aaf0ab738a02d32e08b4e0d4941d8faa5636cefea83c64ac5 64ff2ed13ad3d074c2cdaa073215d16d905ce5027011281a85f0931808fbbb14 9b734e2a79bc87de83badbd1f59488601f92b1a4b596ad0c6f93593273b115aa 6aef38f79968106f327adb934bd2206ac9e8086f0002589ca7dbcd6c7e831142 50c647a690330942e373d9d375eb1350d45a4db38ccf282570992f1f9f97a00a92468d8af35ddd1df8242f9163673e9cded762dd50eeaac7e4b66853873f36dfeb65ebc4e54ae7a7c0c8405a3f5c7dd98ad3f05bbd0f4f7713bb6ea8a934eb0fe0f6e2181021ea1fbc9e5d3f88441bd55cb143b464aa7edd630e7fd02b00c502a89070bb7347d35d45e0676158fe4cf975ef0e461ccd0cfbb1ddd79217cffd051e44cd156119af81429f55eb1c09e047c18f319f2667ce3ab43f81bb59bf3e00eb798d8383283cd233ae3b8a7bf39ef41355e08faae35eef782b7a117449e80aa54ac162cf68b96aca9ff6ad679dbaee0ca46ec319694d370e18c9b9da181206bf7ce1e08caf1892d08d26055f25b1dd2339cc0c63ae3c86b4b97afc98c15d0561ef0b6a8f190b9efec717e536c2bc139c20042c5ee5875616af888ba907870576ccb78bbd5d0079ed98d282e40785e83fdb3509229ff322cb4fd6af1a2b7301deca33357c5298cec912bdeca5f1975dfe77be03fc9885dd56b6600847992708924c5d69f6264b081b56ba5f04ad6487bf8033bfbc9d3568e105f63e212dfa06ae93924203b199ff7307007033f7d45a8859e3d18a89c1c68118796ca3a0980cf35c128559edeb718428ddd4d8b5c193adc7a6e2d47609b33f28afe57785ce0a35475aaa00b7650a5cbbaff2111ee1089c4fc4622fd4ddc63a7123e1483518066c7259ee18b5f9e9100a07e5ca6ff628de5e0d1acb2c142d1b06848d2c9d5700d7781e2f7dab7f1bdeb5eac00ff29445815772fe28adf8623af60832b0fb530d3de1aa77f0411554f521144a7e5d94f9c3249a54f1e71b29b50859de6657750ec1824fb3ead989f311590d3620e8eebf3cb97f6d3f5757a567a1c9c9fac60e01 false +check_ring_signature f312ec645f2da47e3841afaf640a081cca4f083b1d703a65a47ff62c75157901 4fa2a7de08501b601c12b683c0d4427383394347a4dc5c94d5445130caa784eb 64 9015d78ad5b67a1fea2bc8cbfc8675c17aa33a793fa66dffc338d2fba07273bb c3d94bb0367e3f97d162e3fab392f5edb54522e5d73119700f74529bce9ef35d a2bf4ae68bf6ca2ed3b97220cbf8bb83d9e821bedf2dd87cd49c076e462cf236 7a6699a997b934173d1b11b6044fd110aac7eb4df98fa146361b04101e52e8b0 32f23e67985bf7f6e638e298477bf62d50d8955da4c278fd574771ac2032a63a 00edadf8c2fb50ad1d91147b53c1666f4e38adfc7e4e286cb9a167dfd7d618a9 16c5198b1c50046d0f40b0636a10c7b1abd49ffecadda660bfc5c86380e94920 042e75296b32058cfafb6db1638fecd9f1df49461c861e1a2e11ab5439ae25cd 4314093fcc13397110b938e2c1468c2273a39539dd55b8c33bf6336dc9d7abf5 457ff44a70b018f954cc9b75b60c89536ac612aa6c2e9a7a53fc81e41ca07667 99f3e3860ef04ad6f60c33c523a896385d18a1aeb9c6fa7133f50131ea6ffa63 ab5cf70050dbc597fb2e9992147fb33fad71227b5d426898ad95d9f45b107431 91a124e02a350988b14f4b2cb17c4a1f8e987d8297cf173dd188b845e7aeddf6 1093f0d3b2b9e0ca17f5da995501d9e59d3565239aaa72254e17cf56a2027504 2599078e646b9146f2cdc76450bf7260ea605d4a649b977a56b174dcbdae39ca ad07bc27e901ca82bca8bef989af7b425e8407e4167a79974104987795866135 9c05a8495681c3d892a985616f8a74a33c1791a25d672cf8af0548e6fc040334 33fffe66c55f3a7472a28d709cdf56dc2030844ae22d9d1af92e97f7031d5c60 09760bad28c543cb2b8ae89a1c743a7c62b71feb338fa766d91534dbc6d2b6d2 7aa1c7b4142e7fa51d5641854e2618c19e7db0695c5a627eaf5cb4f23fd7342e 3bff169c444d6b48d799defa44eb2b7ebaaa744a3430f792f36d40d9f4aa5b37 cd3891244f6a5dcb6bdf0d047c4f043dabc34f56a901b61ab0af021fab2b6018 dd37694d354d188288b79ff535e0e3d193e31c9e47b8f62d96f1bf79fb61be63 5b50b23b5f3b1e9dab38a284c6ae524c31dfc44d3470979cb73f96d62bebee79 b290b89cc2434709608b7ce84d66e14fcb8a8c2601f62ced30f0f175f661ea47 e668e37925d0c7066e46ad54b873318880523a98c5f781f7961515417b095297 1d173c8b2c7287ac037bd3febe73f1f37561f5daaddee200ea8d55448546de93 395d96aea501b004e4e1819f95c3ade0cbc6a843979fcd3e28ea969590c29d08 0c7673e5d6c1b12b666a5b703918fb73c7341392f30be4f09dea421b16fda245 1d8a7a063aa44deab876af21d95b477d6ecb325eb631007400b330cc5b7a761d ee89a81fb200a1c02a874a52f057ee846e8aae44214ad9aab7d23bb9a7a1734d 5c73c6590753ca7c013059d0230b2755aa20d8c153e661257e68eb7965ac212a 92972bacc834c78ef4445f51662910dd1ffba8a08bab689b42051b8a170d4fe3 2799eaa88f451dc80ba98189200cb3743805bb111b7d13dcc6c75ae582617794 1124da01d63bc97acca5956714012b65e0e5d3c7af0e01ef4cad8e47e49ea2da 646bbd8e30b3b47a8916a0b37cd6c8ba2d7b0aa2cca37a49d6fbc3f1bce3bbf3 8b83b11f60f841f60973ecb7f498dd2989a1792d5079eaab70ec22c0f620c297 ac2de97669b5f780552050b8fc844f981742f9116f404daf8e06f4f9218fb94d 5acd257ee9758c459a9c8035f354c14f2c3d569ba06a286de9d32d3da5a9c025 6218de21ab4dea7bbfe7e8ee1a66075c842d89ae50aaecd664be8a3438517a49 574b26d59d4430df2f457ab0c0adecbe63e8eb972315542ab9845bf973fa75e3 ebdc14c6a3154255d9b46b71fe870dcdc64c3e6f33171a1dbd29f97685a1fcd9 d7cbeb6194270d84f5db2b306c9a76c29415dbe71cb6edaf31a5e1a6495512cd f4ca6d8c9d9a83ba39647a224038324cebdff4693855c032205254bb60b6428d 985569069283473c8b2c0b796deb83975a417cc8d7e52af41ec28aaf1de1503e 310c9c52f0f6d9195677ac08e1299a08f6f33f5f6c633d35958601782291a19f 06a931888387aa648e089857a6aba611c022aa186a23daeb226fb512abcd3300 900f81d28f3cd38cf1402ddc22d105b1673f044c66a9db802d53d5e260bedd87 1e40836ec0b3fb2e103016fa4611a75bd3169af89d751600eeaa0041abbfba8d d2add5f134b3842d7bbac61f43aabd15300ee937ab73a535e91eea335ac0354e be6a98cc97a91deec7c7b0e5eead0db38a7af083dbb9e35087df8ece7632964d b43e772e6098ae880b0ae07688c644b6edd21dc84d34ba0775de8eb41ef6592a b76f08ed078d21dd1f44765c4f916e58d110c4f866ab7922f70a52e55e813a90 6db2707a8003d399680eb6bb92841d75d3d149248b1c25c206bb5147e18da46b ac1b92db118c1783bb55d9b444eb82f8766113d952328283f7efbd30f74e741a c128eb42f0ec09e2bbf574e9fc29a7f8546889ed8717b9dbdd5b2311ec47381d 9bb755e5f4ae04008ad6f90e246c5ee0ad280dcb694e4f6af10bae5d45d1726c 5c23c4fd2b9dfb2fb088283f64f002050490e74955ca29b44fa60cd2af403c0a 92358066c90befa6f8607307b95312d751dda1983242d13f1d263622eef3fd48 114589fb77f51f83b15dcbd686a23c7c2fcdfbc5af01856498a70a80026dd210 e1a398c69505f9af76b74df68aa8701bb5e65ed4a738385b21839525b05cdce9 5d983391bf91371662309cda695cd05a8c62b85da74d69a0bb8394b072635dfd 2860acda6602ed924f8d4984a50e38d5722e7c096f0ac40ad24a17d378530981 6538441988cf3f75b01f1273e6506fc6ecdeaece17e2959186446c3288252783 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 false +check_ring_signature 1d71504acb517677855d479b4d8ef15af3bdaca5d8ab85a19f38afd8f1c0793e 4de2ef09c9b2951200b9afbdbd4db2f30e50b130200f5aac479b440c882a67f8 31 170f8834134109051b11cdadbdb17fbe7ae3addc6e9ef1469af186c78b818cc4 da6b4ebd9a3b6b43a2d0fe3980f2c77f795fdfff9df25d60c1516d2460797704 4a7882375d82fccf160136c4dfcab7b728cfc36321690e7a458e61090a108988 a302565ce16261d1505b4a3f11fe2cd3c7d2e081d6a702d2b6bb16f1ca037a19 92881d91e5e377cfaf9928f92cbb9c750fbf6493899c0098dc396cd2e7f844e4 f4688418e84d873a0fab03c216bf341b7b0a9dcdeba4856fcb224c2915fb9175 4e967a03eacf61b70ac96800285a2ee675cee2001b153e02397eee54201e4b4c 952e5474b9ab461c8d30376e7245b18b0b1075359f8acaef12784e9a988bb9fa f0bdf7598010b66a4b43b1e5548509ce1310c8e0f00cc425b20ed183d3f648c8 8bcbefd1740245b608b243f5e9a11b9919f2b6ed119c0cb3b41270c89f4e80c9 bc215f17a53c43cf54eff7ccfa858d3964713075a75955b4a0d8b89716a84403 558bbd80075cf9627d3ab12c7d215126ef96893780056ac9610d22eb9c63d41b dcf4e7e9bddfadff0ae4740a1dc31e9127c59761c377a849ba23ac9e611dcda7 80b8a7745fe9649be794a6aa17ef8b78a6060dae6254d6cbbeed51a0e47906b6 06616092c4069d9a6b2ebf3cef46f1eecc53b3874e918b956f00a515d4cd4d51 a363323c2a089a404c696a556184098f53f8af0ff8e520bb0e26326959319892 f9a13a463732640e8fcb595ad96077329589dfbb21472a93900b21fd4dd395da 56b7acf8bfc5eba8d76a2e396373e2f139592309938c428e847a6b4edd5c5e73 6399119e2b22d5584a525cdc5c2d16b9777020629d8ba21b7c56c55632bda2fa 4e2633ff89a2091cf01216c457716276871010f6789c48c9cbb49275a59d0a25 7ce931734ad21fe3aa2d8cb527296e05a42d4d73f26fc7a25116539f0fdabd85 fede3b5918cd8d58e2c2cd88aa4b919180a2d90688e88232637ff72f988a8e7d c25acbd7e16fdbfdbc5b1637c7c34eb803389952fe9c5d389e2143b976fd4681 d8f14fb40337e75b46f13c87ccee596a22ebf79be85f9a026d505c01b1e7fa8f 1440b07070f6673eb772a85a33e782902eaf399cb1c121992db5279923274375 b592e1013d1632490f73df5b286409b8996f0ea1390f976c2b02173326aa9221 7bccc21954a654d6a9e2bb21d42c353565c97da2902b31b697c4694765a81f64 a11eb65f5ccd5586bc8a24edd15fd7a4533db4415c9a677b8479ef26f345f910 7b718b1519f1b0452fce146ba8b48c031ca3d3a41976690904fd2ce64dd2e232 0c0aac719e4ecb0b2de5e96816c07110a6f6a7dba66bd4e97a90a6ad89a462fb 6ea954d5507a3b4733fdcf5e6f59e17b744272ff7897d159a7a26105365fea18 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 false +check_ring_signature 43d3d0925c083611956d920986177f6952efab33ff1440002b9be5efcea8b1f4 823a47fcf711a997496cdcef7695ba8806d84b7b4b86866eb6d89cecad4814c3 1 7d02e4d3c711987a2f96894b992b5407f4e830e8f2703da21a442ff38a4c2fd1 b2fcf6fb1a9b47d0b208ebd22062d7a1c488b7ce78f82c2ea9bb4bfa995b7103fc013448fcefba5260cdf895f63d36921b0df6b099464195ef9313a9e5038b0c true +check_ring_signature 919eade66c95045f782876cd1f9569c1de331c44576693778b79b3289b695110 f88bd625c4a9b3bcaec8d722b351bb25ad4d4fa83c0624ae055495001df7a1c6 1 087759f40c915ad0a1699fd72435f39e00234d50aa43436003298f78095c5236 ffb05f4b7f5491f4098f0e56b0f82842b54af37bba0ee9a94b88aa1527308af703e428a13f7bca095b6544844651bb71699a4033cda45bb6ad70b427c7508ff2 false +check_ring_signature 2deb15d34aaebb7288d20f145786bc390e43715766510eab72f8cf41e60abf56 94c8984db985b49ce9170f73dacf9c54166fb767a6af610ed8217aa93dfc00e4 1 f3afe621273ffa7d863612188e3cf9250e12881ecd3b7cf5bf6d3935d205d29f 4c0f17f8a02a1afce5c1bda7febb2b7c1b020e8e7e451f9e5abf44ed90604f08f576cbd0808783685546b0753cbcd280024305ded3caa5d259b6dd617964a901 false +check_ring_signature bfe4f73aeb5127eda3859d92f35c1bdc9a45c00fedd53c574e67937030972f57 2651d1d7d05d03040e6d5bbe3c14b980995d1f1ffcfd485768a6fadaeba97f9c 7 1f9d83074a850413e4de0ecb6f0581865854f845203e320c0e7d054cd5425fc5 5856da93971cecb6bb758c123acd4382534659a239adf8a691a3059963844eaf 01098859827ee64fc26a0a406b598d0a85b4fcca7768ba8c2064a7712ae4321b 4e9f87315add6ead52777cb077195aa4b983bb7f9e205f26fe8adc0577776d31 739215ff791dcdb74aff1107044d9c8a1ffcf733106373b3f2b300199c81e3e3 bc694f04747cbda2a0d0c93902f9efeefac74155b9f9ca23c87462c49ac97cf9 468906ee6180fcefe53d1a3f90f44b10afc8ea6703fbbd09fb78d817befffb71 2870edc75470912d60a825c49954efcd2ad132069263008c86d505dfd21b3e0cb8a187c4de1557d63ff34f523d5eed6b7caa9868c4f679e91324de111285a404b29441da0b05b77b69df528d320f0fea25cf1c0e136f867c293cc0f18037d6054a7a4b0e4684d2f1a3982c733cb5e16c576e6354ee54ec8e6ef882ea5669bf0ca462b869640f15f8595bcaa411e74b4513dfcd5b562c48671118d740f58553079ab1959871f20862a3c200a07ab62d541df7fc1d4ea8efc1fbf6e419ffc2400a92502004476cf583143ecc0a2ad762255d6cc12367703f7319414fa2142e480bc00f9e76f6e92ab9ea942431058f0e684d1439612348a0b7cb119225b54f640970c9582d2eddd8c699a7f43c891d119f4601b12fe80df4c8a3136a7301f56c0e5751a1ed6af45e2b346da0eccefb0000b078edcee8ac5276c92834aa4627cf04095ce5cfd166e4bb6145afcf45a3496a218dc471ccb52c8a70e1ecdbc188ec08ce44427fb7fe6b0fb4975bbec5d71fe67b5a48539ef9921618151c84c35a3a0bb239f89772f9e09626689d56edef502b0ae8d7666a387dbc13fcf3c2a5ddbd025f3d5f0b6e8aeb8d4de0e2ba919a24002634393cb63c5f3e914f96b289d38901 true +check_ring_signature 69f9a24f007fa94e34f22fc71736c68ca5dcf3a358d2cf3ef351a87b7dd398b1 09bfa9493d86f9dd6c03a8d45c7d73674752133863bf6afca54f2a1dd5dff442 17 de9495a1bfbd935e35e9b1a836de68ce3d9c7de88416c58899976233a01e1b7a 6fda225fc95dde47c1422fe34778e3b4347bcf0ac4b5d2a84476d3c535c32be2 c66d6783662fa58920fd2c3c8f69dc50c0ed2f25734d8cf425825746ee0ea2cf 20ca89626a35abbf46d0626c486a8bf0ce818ca885f825f34599d3a6ef19b82b 1fe4fc234ca2f17736eb87b43a3414288d118883be74375a1f50fa3d6291bf2c a5bc59ae3a31aac23c0b47a87478cd841a4760ce9e6f4d98c238d7cbc43e97a7 c80bc47c468fcff65197672dfc1aa4064e0b1d610d1e68586994d1ca2ee23adf b5445de3bc381fd68ddda94879921aeada7b411ffc5ba4faef857a10fdaa2cf5 26cec6a28a6e1dde1f1e744fe7940e63df9df72283bc5cd820ed59ba35d23aa1 9355e0bf639f4bfd1ee49ac4df61bae2b2953815fbb1c7792eb219d318857f88 4bc3834c923a1c3ec5301974367c8ff6379666167a79b971056f3b202ec2adfd 06ff9a88d81cceb1de2b774776545da0f69732e13bc66f492ee1498197e71cba 26ffd5f74e1872f0d536d29a8ee9aa052c9e44edd365171aeda6419c53f4185a 6138958bbdb3fc1aeac8b5fcedac6d1aeb73fe0052976ffa57d621dc4c9c5b66 d6414f8c945052dfad9de522b7527aa2b25177f40c6910ff617ed8becd6ddacf 88c4d87c388c18c248b78adc25b224eb73bf526d69eb80fbead6cf6569b15bc8 c60a06f80d82cd4d6f858eb39b2a929023ed8d51c6e525eed3c9ab7caec81191 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 false +check_ring_signature 1542f56231765529ce0aca8f179c7f56e795caa2263a5fe1266ea459e2e51e59 68d106a4ad7df34cc677a679b644e79d8ca7ba3a8852ce6e68989f453294cc5c 1 21a006e2ce1a7af108c9ce448ce2cc8d2ca4b421f53917cb1f948ab7eb85a6ee 6416e28720671f82d6c96afa8e09ca6dc65f8dd2f969cc40e8e9a5e5b08f6603ff1fb8a68417528cdfc5a62c4609413b9c0b366522e88449aca684945a992704 true +check_ring_signature 919accee40a9f14947bb465546ed9c827462b6ebc7780b8071b37ba7604809dd c4e88dce81546128c28039efda4f879a3dcc4127cbcddff7f9fd53e6af8d55f0 1 95f4988f8e23f12b2b31aad728b74a334681a19eeeb71a46f6046c173cb71bdc cfbdac5122a44a1076d331bc35f07a3b7c6f721ca67201a0fd958f307c4efbf6c30915e0ac3132630a4dc34bc9b69479b9c7c97a05fee297fbbfd74ecfac3608 false +check_ring_signature 54dd1f031f1edc8d95bd7eda75030ab57703c52226af37aca2066a1b5d6a075b d47061ed214d80e5f886e4c5a0f42e95a64bd8c34388e99bf4da114471845415 2 77f432a285a7a9883fbc2c05b807748dff572c81b16c84ba87b95ee28a951e42 8ef6664ddb4403a8e93e655dccf51b08d7cb9ba02fa16164ba0a8bce3b85d226 3f479a64086ed59961fcf77a55c6d3ec44bf642d5f0c2e10f925a200751a660e194a71e90620aef8ddb87274135d7b5259d56b60bbc299215eb6cafe23ad2908f77f9e38aeaf9e6c92454311492c52a10c2c409eb99a943d1bcf007517497e030d10d94c9c0af94a4d4819ffb79adeb07b05ec797597deaa969ad0c062dbea09 false +check_ring_signature 39b6a0ccd41ace9ace5eb82543ab211ab76a8921bf8f184248eb3c82776aaf9c e3418acdef44d51ea6ea7a9f1fa10cbb284ed1e71cefbcb140e26bf85f73290e 3 2ea6cead4bbd022f5a5e7584d9171adeb7eda72366e5ff4e7daa82632e7b0d66 e02c3bf733f14864d3c08f4802b74236af9a69d0e74760602b5345add4d985ce 8c481b7e272bc1365e8beb9e5fc0bb9bb24a472a1f7d1df4d61a8e93cbf6ed5d 71864f6d3d19781afdbd0bb1a9877735ea51926389c0fe6ff7663bd53feccc0b67567ed776d61893fb56394b9b03ceb12d2c4414457d8c6c067d535af6a89b000922cdc4ba5d46ffa1b55d839a958d0e41b9c43ea09a070e02bd1c6a10b08f096b5090f6e7e5df206e0054a408a4c3755b203aae546b2fbd2fd150e57bf6b906a758645c150118aad857c0a3133ccfc7b51841be815b46b680f5c100fead1b07ae3c46b8d3da2a17341783605b72d7bc55bc8a3926c4002e7d296d926760ba0e true +check_ring_signature 10e09e2f2643dc874673410fdacd9f18235deb69c160aa69be736f2318978cd3 b951a3f8699826767a25193eedb3a0f08777f223fff3683572f309c0a6b650cf 126 3eb0be40f3ad8cb954d027312f9b4a5072e0aecd0d7114a921dcad2241b2a0f6 c2f8544228bb9e3823f87f2d948a084bf68b5396194535dc84d1f73b9101e0dd d31d9845ea0404a42a5915e085a5d0dace0b8dfa9950396a09a696b87a211583 7059459080b82cf4c2e7329255598d7383a700c20dfa2ef3a827db904a737567 656bb0c1f47b0e401cc74480e61b92898410c70c74798147e9b776eeeaae85c9 b23633cbf85088fbbfc5e1539e6858b4f8fbe941d2e207030fea6461255b668c d92a6bf84392392a328327326f0724faaa7ce5ef9e38f402016f0ad11a39b441 547c34da9161f86fe8950ceb961bbff323c6bc4a29b6591501c8fe31921d1ea8 99d06774ecc2fc89de907596a0e953d72e48fc1fe1f40cbdc3ca9573ab9d8c93 273d4b9249d79e9ff6c17614845a5bc6cc03d4b625292265b06e31c1aabc3606 e5de06ccdf15d9465d4fdf36e38e2f45c5b3d07a5af8a3e54b28d125a9d92f14 ab2ca338c54f6b9131b840f309784364454d2d169985f7f92f6290de7e34535a dd9d709e95e271ded59f16558024f411908f10ba6f5ef604306a551620de57b5 87d8194c67e5c3c8e5340084d43e76aa201056b797600d43fc9adf4b97011014 2a13921dbd7d26ddde1c609fd528a195e65ba41c627700e273c751e6f25a8a07 16bcfee6ae898a903e7dc182ad950af6b18c1ce709ab7d7042f1184480fdc7dc a212c0b130a5c7a1fd8103eba7638887e8e0565a51d1669fac93a4e7e29d7eb7 a03cd2a3b6582caaed66cb773cf7b3bc1e14b52c80440c0a610e3b9cc03270cd 49dd576ffa372890b1a88ddfaff491496b41a2e662990aa3c85be2419554c21f 8f237fe85ed33d0314b9e65093d9ff0a687f16724f7f10f76e8d76eb1e92e8ed 7e859616a01728f19e5612167be6f7d6feeb587021c336100eee22aa8b58352f 4a1b8485e1fed1a7b906ee3ea15876145231d2516239f123af3f281df36c4745 d5c150c8c2a64d14a188ae07d140ba251d3295baf06f4c7ebba5a7a768f92594 87871b3b826bf56444d8820ff66ead5cae297ea2273253d062d20d01944c8da3 299c462d49267de22a63dbc7f64f6aad0a98a800f2bb5c53fd0024233e5dda62 a6dd79bb4c0ebbf89c544c245bdb9f1e2e2139fe1ee0542cb15258497ed74e0b 91895c4faa8103dd648a3ee25f8f93e2e31a74809c961b06f507c741d18b6c5c f3a54e9af91c314388f1255e28288e53bb1bb222dcb8cb6ebc64583dd50c273b 4a39d3e963bdca4974549f49c9f80fdc6d16a673a230efd629c68c9162a9a707 66beb78ee385f9b5681ba7bb4a880549f246aa59254972e756101d21b25a91de 58efe78503e72c93751376e167c797adb682d8ed1befe1991c9c13ffe5c97685 1244bb05114d3d79180f44584ced14fd9f8d3df890ebc8599479e9c887c4454e 7ca55346aa9c86e71a8dd43d58adc573ead91b1b9fe652614350be02debc510a f2afc6829f6dc946482c96d44daa5ded3fd6a4151329cfb074e27307fb9063c2 7e4ee01621521d5220daef30eb79519d4ec728955e66f6d89e6371126cbf6b55 94692ce3fc55adaef894cf3981d9c89b054facf875c93f3dfb34a6155e4cd318 5884fa2de477ecf760747dfb038502f03ddcac6c43fdab5d4f4001dddabdaa26 d5b0f9d69664e85ddeb65c2e459742f29b6c45030466c0c0d5b9bbf869280e95 02a4a195de258c094bd2ec8a0f54b7f1dcf30c7409715a5075bb48c35c215202 85f2418cade92b9aa2376d149fbea01457fa5133248dbb66f5ca4361486ee700 69944994257b6febe5d4792c554a125081448f901018cf00ce0063e82af86ffb 2b63ae42de5b4809913a8b143e8edc693d0457a60141dc9526f549d2db4dc770 17f30bb1feaaba0d0d905df8e68998612c43b52c44b8ef7baa28d2bd3cef9fa6 960e5875c1e2ddea82d791c5e779153e8b2404f13ba935c32bfa38a44fa3236b 899a493d8fe9ec25adc69567d80dcb932caaa8ddb387624c57009ea7f530ea03 fc8117a6f724de8f4b4493b7692673c2bbe21addf0f4f3fd9f37ad0fc281cce4 b00e8dfa35dfea11721c8bc33fcacf7476fc4f45bc977f693b9e5eba4c58ed4d 70978b2a6563b89df18c33db5f9334fa8170fb8f0b8ab913d52e8aef54befba3 01e0e4eeb54754e865c0654b78f760e28afb619139f09473cdceef9bc44b6dba 3c9317d7d0f492321bf7870222c815aa4e8e5633b773d4c34cc17b24810fc68c f05cd0a68816bc7a19c49b31aa30cb086037ab9fa0f39a624fc5c0ac316287bf b75fb8532f6af940002a3c68d3a6f28868b3fe12a4c7f6e10b8554d8029b5713 55979641db11ad0940b878bc6bd2862ea2c3334b1c62701482707df38cb75ab8 b9d18a84883dae3bb9a18a73f9ee13b85f2904d5f104e8f89034b4acb633fcaa c24f16b363bf2ed8d8dc84932fc554eebff25a0d6e4775f3234a84bf62ad8712 959486b2aca40247339483568dfcd1ccd082eb38f7a3fb5be04643359c38badc 453dfab301f500f4379c1cae17669a8970a52520602d7da0b3a3ce4b021adbdc 583ed84a53071c41ff7f93fc6e84c026671e6b4a043fe2fa155e16b5d35526b0 b2b536bce67b58f038bbeed8341cc7040b620bf7da87056c23d18bd70fefdc72 1964aa53cd2c53143f5e5e75d0fa5d77a6ce13e10078bf195a6959a2b71f4108 fbc0fd057f74ae19eda9d047a7e9f7f252e734c203e2441f41e5247f1e52bff2 c3ac77fb2e06aa846a8ad6b3c73de27fdf6c991d956d6cf0dac774077879889d ef6b0c64755ee8768177444b63eb1a89a5e7c3215ae070d7f025a6d813c4e989 6f79f03e65484fd94b405f2e5d70fe1b996753c304a93152230e00c51427cdcd 236bd3fdee07139c0314d1d19b307968dbecec9455e4fe81046fea47903f8e00 a5323c5277fbf10017d8cf7c8f8635ca2294efde2dbef872c087fc721f7ef35a 011560996e47feda7a2e5c9f9f3ec3f47b24035f585b02c87a0f9b95bd6d58e5 c86408329da5f2b428c2a1c2d9828523f7770ed545be4eb451e03f33f16b8262 a7c43e1ad7c4a9ff9aa71789eb1cad51574eea6e5eb16f89f003e8b791ba23c8 d373f10470cddfb7f87e9398bdb28306f3d846f81b292ef31be8e679b72854d6 30dc5b666e14abafa2534a4c02676ee69bf79fa1e04ea05592f62ced6e558f94 dda6ee84b2966d64e969292382014a40a7590af3fa7ea7ec3e6c87201ccc4fa1 f190ef69606dd3f02a107c67efa455d38f16d17fe3dbb71625737e14708a8973 b3f5ea0301259ee667e442cf310bf8e0b42deba5320332327b9af19a05fa3f66 863903cb527220921c9ac6b8801dbe692903738b2ddd19f12b2ffa4f93a01fdc ad0bfac8eb05e23858b195bdc9bdf0953d70e33bfe1db4671853e2523d7178e2 04552f28767ec6cb44a2ccd7b335e85e0165773d4a9f6f69c5367b252e937eaf d83161d392faf06e4d24db28efe709a29585ca96e1fcca31eec997bc6b366ed4 fa33cbfa15dcc437a1c963d0173354fd4d18e2db0f8c2756aa95a02a3bbdd244 9d3e261089049d58f922585fb6b17fee1a541a4d677249ac1693e50c6a1ae6e4 5069498bb2935a8384018aa104c2a9045a5b81928aec4802a1a949d417a77cab 9f535b917cc20914259a5b2c26fd30e8f6d867f1cf2633b8d2c851cb4b82b16f cb8a77dc29d82395fa0d5cefd3094935940ca5d3ea7eab019755439d31c9db90 ea2bead70323e183ee330968ddf531a88cc84a2365808cc5560753f2a653710e 07374e7991e6b7f4ef781c230693ef3ec0b349de5bb3939200a35071048de265 82346f8473c9a0dd1f978a072b35060c2d91f4faa5c97ed4347c92baa02e5aca 2af4495d7af6d50d6343ae22c402aa63e54075f3d4a5e1360abe7a4828717833 409786af62b04c59460f33c63e1c481f2a98ffda45426bf3effe48353c24dcbc 12b0ba7809f79da1b3bab2ebc21b98fa0ba597931f088d2d3d2230add5db6091 e86e07543b10a9e637dc7942a6449ead4fbc45a302872749c15d18c59982d2e4 31d2b2542475ee8cb1054ad68a6248b3c96542afa7d9aea12f1ef6edd9d9dc8f 70062410bfd6605b675b115583d4ea87c2cc9b7d5acc9f0e2f0c764426477df6 43332b943ae8949c3555b1fa13122226f22c2895f23d76b06419c7ae2a0c2c46 75c49ed2e7f11984843263db45ef1494f1d7a6b835ce7ffd18d2df371dcfa52f e30dda1edad23aacd3ca369baddd0ed737a74bf8572f60d0c5c5aa95d119d150 ebed68df53568458e4fbca0c5acdaf1d6111974f4cd5f3ea1e8ccac608b4b2a1 6976d0a8f3cf88f81858405e4358fcdcdb1193fcd02c6a68a0bd314c6e8ca18c cb396525ca1259afbb7b8cd1b5d76fa6402dd73277eb0a6ca9b87ea53098ebcc c70343b2c2cec70428254e3a05d1732524443c0ca9ec2fc3d11b92873162b89c 8d1529d1bbdbc11d6650e36b5d3e81ee40bf1b0c876835b1b3da0fc756b18223 7b4ece453a140d722a848ba8675c7ec70867585e7b9b983d2c2ede092093af73 5dc2ba8911fd4bded378d8a2aa049b956bc34eab46717fadfd4ceb3e07a617ff 2b2528265bab9c8c7b4993d8b817edd2963112b391752c1a47af7810588e3dec 5c5b848c96f41ae0886aad9237ff9839d5ad723d6856e521cfe77117a076bb98 5b39845ad8f7aff139fb11f43cae4f818c59d197e5ddfe3aa178c1219452c077 da59d3cd160dc4505c6d069821c27d0207acaf8ec1d4acb799900fd506ffe50b 89104850838b618ca0046bbf0461066e5328a13b8ebea71dbbf90b9cfb4dd8f3 84018cfd702781b4d90f6776370176e8952ddf62c613de587c22185d4c3fb183 e0dc281715869ca2bb2abec85bc410935a2ef01d69cb4a72a8de220fe9450d82 d0eaadcf78aa1af1473813a7be767ecdf0de718aab7ddd3f1916cd32aa24c698 37400c2da0a552923cb5aaa41df14909a40e7e7584a20f4c5a25d6f84ef36505 9f22589fd24186fc27e0bf4e63e7cdbdaaa54217fcf3e75109b2920aa9600ad5 6979cc394aa06967a00f2ce0fe2597048e1b0b436e61a07c29e0c7a95a54023a d2adf4a1ba8b0021f82eb55e11d2b3b4d6a6921ddf5e7e121a508b9cf13c2119 1c11612b7d3cbc471e31886361a0fd92dc7ef69011336d9c842c8896568acaee 2cf009c2f9935fda652acc29f172b30444f1e16fc47ad53183d8c736ed55666a 4d9924eb766ee454b48740afeed733591b871503032005426b18a20b3d6cd8e2 bef2c50b4077606a8f13544af49bee01503ef33c0250381b103150a7db786b6b eb70991f58587ac03567508b5efa4c900acb162598999a06ef7cb9d384b99834 db0aa3cc82cbdcb42d99c2d70b8391eff877db50de98c15bbb24a4ec73116d1b 49124cf15580e56b7b72e9b8072d5ed675e4dbf088a4f7b43a33a42c98e15e10 cb3ce0aa40b4e0cc4c7b417c035b366b4b3b1c5fb40d6f3f301fc9d89826e71d 60d9e42df599f981f51a9f34382f69c6cd26a7bebe8eae35d45fcd71237ca6be 2b7c162793529b64f5eae00034e6a9d4271ae548ea6ad0c67363258975e99e67 6a4109c88744a9204588476f862c5920f258df7338d0b66c1078a0b8fb0f3fbe 682352296b5c5da29787aaf2cb6c3c866db3df2f4126bd3be488ecbeabc207db 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 true +check_ring_signature b630e3a4f361a967ae9f83644aab92626d8815ab3b84ab771a0c1cbc976e19ac 084557593cb1f2e57d507f2c9af1a16b7aaf00c2edb34ca756354ed990b00386 107 2f5581d63fd0de55e226060960a8d5531ea85e30635d30288d4fd7dd32bb83e2 bf034b1b9f663b49de4435c0db4785e88327b3313206c510653b2f653a8953db a5b852fa01951c91eb192f226ce81014396c24c5d0596fe019457e2f3edac131 3fde3c00760c09563406bb6377daf2c89d7b03bc85350a7c8e623e9707529e7f 002e65c65178e21b65f30219b89877a9b11b0342ff51ad132ebff2968d198bf9 de67332e2c4e2579af29cd2bd39dd612be1142421edd40ba0851b3e1799fec08 aee5f8a7dd5be2571d50b1fe88bbe4a6351731754b86f39309bb3c3ca363cd6e d24084fe11455576102e89d3b8e74c7ee7acc9b1c2b9059221dda56e1132ff72 53ac0c13c237e298725d1bb84f0922c64d43eb143102f490c8803f06c58b9c1b bcc979b10b10b767fec905741ea281cd6821ec895a43fdd1a49d7f8d9f32bda4 90f7e5a3f2a4ed3c8acbe0be971dd3914d6cf7f11343dafd1eb0a79593e34070 872d548a63c195f8cb35c29ece75b311c2d979cf58dcfc401ae269e371da9f12 fef61544c4bf9bbd0015dc313dad3cdc68eb3865b52db7acb02ab80ee3a57821 c181b3631620247637780380aaccabb57504090a7d3f7e98fa169b924b1d554a c7fa227f77318cf115b4df1e5beb0a511c1def85daddef6912d03cf6e3383fcf 09461a4c6d063bf2aec32a45a41be6e5a458080dfed23c59e360598530db847d 3ba3e240ed1a388962a2ccafc623ede418702de35a047f1cac175afb47a7bafa a2f824bef88b6bdf1b743c53f82573cafed6dee3ee6f66ea1c6b7f077b9c05cf 6054876140e599be1241aef5af43516dca63088c1cc3a695c91c5f6c178a798d 3e4d704c658cb3ebdaba88d6fd5e4bf8a98e35958b11817d04e59a6c152832fc 931504a0989ab3181657100e5a25410555462fd73b01d88c0e89b8dfa2d961fc e242ca16d6c695b53ae0d8d66a0bccd71be921f1dc116059ad49253cb8c6eb67 dfa861fcbecef5bedea0edefd12868f2103af2665e18a5286164f5b5f9c667e1 b130833c3f169a67a55b20d121886d2071c58e3bc45c57a28444040013560cde 65b5f022a457e03612b2c6a777b45d9d7cb2f36fa2b1c14e9d85afe77a59e59a 45733aaf3d62e8f4989b9607c85a243ec9a65f40fbdd8743a7f5f24684fca766 e9bba6a6444ead0b23393bd5437bb41164d2248a32311a78691751e5bb7f9e0b a861f917192b1ebad6939d32661ba79d0f7af5c4dbb69cd4c3569d9aa0128f2d 3243c2a98dea15b1e65a136081278aaf6c93975147e3d7a3bcd8b3b5305d6689 4a57792e2d27f621adbc1da26716148d6c53cde370dd0e0b16bf18fe0700f9bb 4511a13e9484bc49b152a4cd15ecd3e5e31bf39db70a5ff24abee42146cacdec a3786bd0cfa2b24f5a6b0ae044c1972c8a828ad17f423a8d9cae0d0d608c2740 a542c77e863155b57e91428d02cb6f8a1779a40c19273d49ad801a4a4fc917f4 25fe6fadd2b0dcda89f198b2d42a8b848cc3e6b12ee3a57d05a2053b06cda398 3b946b86a57645121109432cc9771f84751673ba989a364c62403e049da1cea7 da907420813147d73cb2b2df2228222d905aa100252e09ff8f0f11adea356c89 8fea6ca48c991c1f6542cd92efdc2ca279e77a345be845c33d77cb555dd4baec 69b5fdd7d21a46d16d74f8cf97a840bd7fbdab165d91900960b65f71cd4676f5 394a5a6cd48e22dc37f80f441ad20cccb0049b0caeab65abcb2836281889878c 1ffa29d0fa2dc6252fd9ca09fbe2ac5a7ee4824d5d6d5869f18c3546c6fcde03 c8c2e8ef112f87a6ab1cd587f1ea4ab800600a14d8af9f64d880f6b94777c75e 324591945fcf18eb2fde577fa687b33a3b776e567c25f2597778e016aed8826e 8e66f2ce7dae8e850331bcc7a9d88e666a7b00585bef992ac95298df8c796560 27543fddbdad74671abca9d56264841bee9c53925784256498d9c5838743fa34 45c684d6c9201e958a45d36b2bbede4beb278d08386ea1914b2d8e09b8220df4 7340dbb2a7f7de507432b35c725190806b51fa4c4a65fd4be5efa951136f645c 787b133fe3d11784e6e28b8b328345743626f5a0a938efba32802fcf096b053d d145f68c5c516834a08080c16382c9a0ab3c171e146545d9d2e1d916148859c6 6e0307430cfee5f9a6a5b2f7554bbde94c263e87d0390d98a1f55ff306fb221b b5879f6d9822b21364a9a05e6ac47c035dc9880a70c6606e2d8d8c585acc3a1a 061722e467f4058ea24631765eb560abd6ab16d3a0d8befe18df8f7a000beac9 7ae48a537f9cd968ff6794adbfa73c866389dc42fc0ccf62d480f4b224388af6 dca7b014af559bebc0513f6f747bbff815cea1b5a8ed91ca2ba5a7f6371db3bb 4fcfdf42abc0d9224a5fae14db474880b53da1109c0d4d1cbfec2fd8c8b608e5 929445955634bea862bc5ef6ab04ecdaf799088dc6e6a57ff1c8a9fe9aa43fde 73824a7e85260c36c9e6b048e7a457b19213b4fda6b55914cf9962ab44963d36 179ff451e4429c3f3c16884f0b088a4fef8cadf9107e1a028b25102a2672be57 5846ae1ad16ed2e074eb01c3772accbceba8ec0d075ec3ad07231347a417dcff 16c3470bd5e415beb77463181cf328f6b05d18e46064143e0ae64559488a305f 2f09a100f759c1cadd877788e260267c0faee9215d78f0f0b5faf0db8a665509 0fb67c8e2aeedf7b534764c8d2171175384842a42f3cf39067b99fcc37804225 9ec9324666eca071012bff20835a0f5b799bab941cb8f8f47bdd161b54373e47 1d0a9bc4e697707a7714ceeec154e94450fdfe79cddd016e26af1845cfb10d66 e75b8e7ea47ef7a112502ad999ad6e0e76bd38bf8206c1a627c901d1183c7471 f14861cf591b39a4d5201a756d39619f26d052c915377db52f3bf5a2599b50cc 5f7c181252333225627136e1d5966c9f976af595ea38fdb8bfa213d835f7d96d dc0aff6272c6d5fb6e5b71e829505d1cbcd06f29688870b8e460aa2faaeb69a5 e02c0152edbe88ae3d39b598828197be8d784f6f7eef2b543a46eb951d54df2e 8a08fba25cba2d00470c8b1f332303c8c7fcc6594e67e705bea68f62905f4b24 d6a838d040a426b8bf090d42bbc928583b01a7ce6a3c896e2aaa4d28853363bc f6c4e9ee7640c7e7a63ff9eff31ccd6cfd303ff1ff173a2e169002e02960515c d6146363b9fbc91a75380e47bbbae70042c06d3882182389f365a9c4f12c7e41 eabd855f55b98a38ea1f0ca26cc0ab80cfa017d502d9d0bc6d768269816fab81 7705fc7562d051b8229aa983a1a7255965557716b6e611b33ae3a541441edb07 b89753b40d53a9e779ad2a7c3ca7097fa0b813468d631dc7770a800c80180011 a2859d840559d9d7af18ded5786137b6f72362041a41a11e67f1b187145b39da da4fbacff11f8be9f62a9b245cd365e29e2d08972390400d15f873857aa75c1f cdb1288df7a2a0d2f8b02ea0bf1be311ab22d2d1fee6bb75bec20aacb404b7ea 72787741daf49ded89d6cafa92579681db1b94b8de1083868e28a3624f19975f 373e2f9caf611c1498fd0a572360ec01dad07b29123bc2ff54ca9eb31a67c76b 6a2648d5a3d9a1942cdb73c24112580d85591c2d95064c20e26b62fc7a516db0 6535a2c9d0c4714b8b1eeaa5d262ccfed5d8d3e180fce4b17076ff9e7914f932 1d8e269b7552c060b1328e3e0bd488713948d560fdc4f8e26eeaa6a0633118f9 b94d844cb00540becedb036daeb2b87267aabc3638e3dc502c8259ab5051017a 7f4f0ae0d3b77ae63f07193c8964a1612fa35eff9e8b84364fc4d39eb563d777 e9dbe5863644232a032181564515cced0b7ffb23bab9e5cb346a231f4385e735 aa83df3b5a08c34292f4ede20f0f607fa0435b8fad6ceb4625dd0f96f939c3c8 463c337ea573557a802394e2e2f4dac24b43f7b1776196028a832f5b2c482233 f5fed4fc45667e503c69142d64af1b8fa6ab7b1a978d2728f1cbed8bfcdd677d 8a338f83dde6f4fbbb5a4232acff5ae753ad20004836c71f2a20e173ac7b6bd5 2f84e8e7f46831028fbd0d378da89e5a3a0fdacfcd1a572a62da465a14c20884 fc03858b75f785ded3c112962367e5af0c250202595beeefae24fb15c21a5350 179a1c026758a042ecb624d1e13c5b172c23871bc4941fd45d40bff56704de4c ee6bd6b8bb40e9997f4a2e98fa5adcc342f4471aa9bcd90291c546baa06c4924 fcec0dcf313ae6336450c9d20250c1633c1c67d1af201468bc4219128232158c ef947777c0dc868ac558be0929eacd2019f4ad87dc299807b1a160ddda1b821d 134d499c2f166256019daf830ec013cc0ae6c4bf05fade746e2f478b05bcb1a7 a8853a78a658c1f7f3904787e60cc2e992383483b22a535ae137db0eef8ad536 b64b330909b08540d059509c6ff6e9e625aed15699d66545a51ee4263d968d8d 797df0e265c03b0a52423b259e3e6c0dd15213c265151b3102d431303cfc4d68 7779737f2a1fe5fd2060f6a22c52de3c2574e3017bff88b631d1d621dcad2453 1cf4330a87aa3f2c450789b6f9d546c683faf06cd6d2aa28458fb80fc79c297b d570b46fb094d78d0f7f76189100b6bbfe575befe9699717b81f966618706cb2 f55926bb6cc1d7bc603543dc3d23f3d207d2ee3d560528d7d2839daf41cd56b7 221246720ad02d92f772dc0c2312c7ece9082452722a1cac66d4494aa0266f6c b25826d68a4a166c392263b52a241f4a093b3e4d838528d6d3a1543c2bb2971f 08a6546d5c501cb9e9688f5ab37f566f523c05e12d0d5050731c3fb0197a31c6 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 false +check_ring_signature fe9952686c53f4fdb1c4e0601d52452eeca4ca4b19b8ee9b49f4e2fe66146625 73be376f2ccdd3619500ed0e8011552d42203ba9c549a790bc04774274711b51 26 c3ef3b32b5c7429974f2230b9ffef54205a7a9a9cd4c9e442f0cf203fcacdb34 96835f36ca1cc7bf5ab4db5a59e1992aa73eb649540d2bd4eb254e3732467510 d3a352ea1d2160284e1b6b62d679527d9a475800fd65dc62f062dd574bd6d8c2 a7a809c56e1a9f114947977d042f61d6ac9d445cdf027226f9ebe3611c836f50 4e89615747b111974a7fef7d5d3808fefe967029cf7268a61584a033e1d77473 a025dfbb72c15b3e9c9263d6e6df02c60876c3b6647e7ae081ee3041ed6d4261 c452be4c69ba5eafab04f94d578ccfd26327a466996015ed619a3a0ce0f1585a ea6e66b0e3f0aafabe4817f0f2c746e9818434eca059df6bc51c8f72e4c7b6d0 fc9bf5d74ee74d60f5c0c11809f9e186dc0a9dc725d067b193914f04d65b662e 5653f7f8643f574e0c344e5123fb78f4439ceae805548d16e451c681fa769f81 5f96c13a98ff318c26323ba62b8e8626b7e163f4f9c60992da5acd27182f14df fa4dfc658b61541c160c1ad81a29c614849770474b37707f6fcff5f713346663 e08545e4f9e87154b4b131026adee7f1846c022c6274c60adad740211b0ee159 ae438399c90813fe86214530ed082e91bd79fb1231ea27079fcf95ba4e84384d 73ca611f5e296f74ce19c9357a2fa8f81075c10c72de9b3a57686fdcff3a7a93 9720495084e60514ad0d5996b67860b9b64141cdb78ebb87dc61269cbb30d9e2 96b4984a471c6055d54372d4dcbe644ec8102d7ab99b0207d146b6e49f5d6451 1b5fd2bb5188a5ec9709b38df7a8643e5117cccadda382860f3bfa28458df7c6 d9040430ff5a36199845a5601a2e6b11c5063db360204558c2d204a53c89fd1b 5acac6a52f70ee18cb02ab6b41c9f06b6d9dd332c174f9a429ac79fbef42c17d 18485a199d4758a3e218f000d65552f41166751e33f58613ae53e9d6d1e6c777 e6e865884a331e765e71984d4da5d03c1cc9825fdadc666e774f49f0ae7b145f 1e2d8c6ab1a8370aec6351341543b2db37f6f62cf18789fb356422773f3ce080 f406d562e4d83cfffa8f40e8d8f520ba7daba55c3ab10b2b18674399619fedd2 e518c91c0a14fea3b1e602b35ac4644beba9b0ef516573b1cb5cc16d9f8c8d5a d21fef6d6c7e3b961762c95d41bb19815cb087a9a8f6a130729515771b40ba95 25f37a2dd7b9f16dcd2ed14c934d48faaf7aa679abd4f69c0cfdb818bee62e052e8a4e42a5519f2e90939a36244d2fc7b9d1b0daab63ebe1165a483501775d0b8c61519ea84e9352e39210a9a4afbba7d326e17b2d4fa8c4c30b610a361f99081f2e80e89a6e924611c2657537eafa6a89d55c8431d830518cadf0bee88dc602a2b558b4bd07468ad9a33005809a4c7ee1722c0cb86ee52e5b778a45f5019b061d9e4c4a3571ff79a2fd837600499621ededb5542880e4e095cbd15879ebb4097eeb5f979e711554a134e357d7f304291389e8fce6cbd826a7379e4043d06701dcc331609ae789ac81933a4d800043f0237ff0cefb8f7efc0b9e62ba9a9ac305e9a1c47f8ac487fc0153de27aad8764d395120aaa16e7d1fb0fc0478f7ca9308f8f57adef2c9c2bf1d3602cac40080a384c8d827fb9a67ce0d20f8640dcac20d9cdea961f86dca991373954a7583872551ee0147f9b904503dfbf908bd44af0baec3b8cfd8f496fcc8db22d2afc2381e03dabd99cab8f16838b52109fc4180011a4590eae81fe5cecd7907096304d776a1953ff30d6ff530fa54e3fb7f672b0b93d65fc22306bab18dc274607c166022443c88973d103ce3be930a6e26e55f077b60b6138a4b1e67696cbd87b5e82a25aa7149d5587de20a0d80ff9d22810e0c90a5ba44986b40cebb23015a95b55efaecd553fe86534b6aaa215f40978e500bd236542cad1f9b1f3c73b4bb500dc4d7385fd40244c261ee936c985cf10e400a0a00a411bef6b0eb3ed85169fe7e772e0d57165c16a8998dc15e97263362b00a575bf49a684f70af79c2fd223982179051096aa53c11fbee69c923c19edfb801a100e01d333971279697fcf0ca17b5b41ed696afa8cd85ac76b1e7ce22f7050d6c968c40fbfa30cc4f0be44213ed9a7bec24e8b302386e75c2ba89f058b4b9087078991efd38f81b05ae2763554710129f5b979ebce13a83cdcbca44b7056e099dfee24d54ed0b8daf5eba0d830f10daada427c33ba8f15952eef4bd2b5707009aa4b2da4bd7dce282cd36e600371c13f299be69d06e5b66dd738b19e8e49b08d1987682fe593ed5466a8e81c61a1472af4f709738441455c5ec0308bfe3410a4ee1d2c69d5941d12c0a89aa9fbd450c5a288fef8dae69cb7359bd32e0e8a1090d3912f0f2a4abd0b73c79624c2be6f8f6b96807dd935a0884cabddbe6a2ba0c784057c2b9e75dff8bae5eb8afdf8042ef94917d383ea6095e60450758772b0484cf19784ddddefd60df50feac4cf9f8fd103b46466043f339e95939bb7f4d0282cf900bcb3fc6e13d109b8f752a3dca11409a8607bfdd9f2d6e06e96f14a4089c98ffc8d5ea2681c55b2d56f76b75ae136dd72ed2f6a8d671174ee0eabb1d06c575841cfae1f21013c252d021cfaf6b98fed73e5c75b9d9e916abc12ab79007eea8e7d2100af086a10b233726828ef2463874e2760aec917e533f0855cbfc022562151aaa3b344706d77be5cc1f9ef01435c2b2f6e65cd1f0451b6781fc410a81de2418c71152fa9fb25cd01d0026e577754e2ad0ad8aa55c4ea25f75b71e0253242fcbfbf7ba18feeeef85a8b7df7a316151305f6ebf7d36f53512c74d4d0cbc83c622f3b33c1aaa17e53791729ec74db2e3048e7a79583345d6cde8686c06e10b312a0ce0c932e6eae4950721ac37deaea3a034ea0eea95aa0147356ab80ccc7ad4df7a67eb28ddb19ef48c5cac0fba3fe252343a000fd7b2259f97ee320d83494b7206d49a571284acae75ade2130e3c030972e728609db37ca92cc5d70edf1625dcdc23bc8f7185a2aa8d339c62dde8040f8140780b5278bbbedc06300812996c6650021e38ee559e0edefd7e8e5a2e7f63806e73893f6faa6254101c02cddf03914ca0eae32e42ebff0bfe70773ab1006938bbe201e122b25f235db70b2b9e86195597d4b2684517833b87fff1369844714e9639a2753602bc9c70da0f3f239db5014c2c2f63b53a595c8ae5be119c348086840fbe54fe2365c02d7c0f294371a97ac08d40273230f3daf01da30480c4f4aee226023454cafd21d69304b4a6b791aae0981cb7cb850319a7704f0f42902c468fda61724fb837258112065f8484d6824d014f65172a3ba04d958e85f0595c2cb6cec3b9ef940d80cf0201f3655796ac5c6ada28428c31984b34f21990aa67e51dbc4c4ea897808a5cc1099a45d2619476733b8019a7979766a20351962c99bda7121d4f2f7ec5728707000dc7c8fa2d55ef16eb848774b590a7e8d1d502ac5fcbb8648a029cf21ddd250c0cd4c4efa8a30b269bbcbbba0ce3eecf9196a4e447d958a7c351410038902604 false +check_ring_signature cfb349e6721775ea1753a0d1ad3e5caf894aa80887bbd1cef6cbfea16bdc6b64 766f7f2cbcf587f424eacf415efd62785dbcc2608b3b7c7733e4146a4964cff8 9 548e635b529d75a8de19861e53fd73f705ccc31df6f69e629c996354b648a2ce 8cb4fc1c864d26b170581a848543a50e6f9fd1d2ab9203d13fb4404ee9adcb17 d99099bbd5c63069859506adfff51b0f592da292c452b45278619dd811bc463c 94015f72f07bb2f2cfde22e3d01fd94acd657b31fcd5c9f29619c89ff9c59e6a 850315e919e5b6d0e306f33fa1eb0370208d8ab25effe41551fd7e0e50b5d7dc 1b4dcf76f7ba65dd9d87b1120cbc0bc3664aa313118722415cb3b84e8f622c74 34d7f969e3dbcc775666c177d11423248d37efb72e472fbf447d3ef3b4443552 67d5e136b86e6397e56604d6d085c8078d2fafd02429a4e359248a9b2e44fd0f 5673a218a6e23925b4e429cdf48f7dd72483790806bcb910714dd56e28749882 de00f7b6a3ad8832c6c4c9413a83cad95a91586b6c29153f646a9e459a1013005961a30c775f71310be926b19f0e19d488b06b7797409643add59d1c07b7e4004473e0a38efcec7f62e684b5f4875549eaef1bf6b7d72c24dbf684e5d7a2080ff614e34606d968d214fa53c322f75666dc4eb67c8be470b10195a239aa68d20ac346958c031f13f40d061222cf6c746031937a7a8af9de13bc0fd3bfd6ede40d63d6584ca3db5ac19b07dd5021dc763fad46e3eb4016c0dbd26038480368fd09ef47ce78f4270aceed0342c373db43f30c210eda315356f1e148b3cf17c20e0bbb6c6d873858119b06fe98feb2dbe7302eafe0367fadd9ed6feb5cd3eeb3f9046b1bd86818e0373484a7ee7668ba2b496849b0725c27619f894cfcc884322e57425682f68e4dd8bef96d032c96dcb2ffa582c59df1cdb8a044ffac3f2ec04602f085496620a09b207d1884b0383a91a10eb90832b0e5bad2725c0e7700f31506be5d78aad4dc40d954e52a0f4d34f57b277107484763bd239616a4c81f7d240abc46b5734d5e86f94313f92984d930f401c58382e929a121d57f5f753ba4a405fe8e1f0bf1c141583580459d35f95fcdf03577bde98168d3c8fc7a91b8337200cf1c194f642c6368b968487de3fbd3ae66699588b0da42a1047f7a85eedae70bc6de5c7cf59edd7195bd7fa262e02633de80223c72e4dcce27995f1a8aa9980881857bd703bc7a4752bb2ecbfd15dca2792507b86eb0005da799da4236152e049e2cec84ac4b2b773e14b4f8cbd3c70265a6580bd372933cc2eec216c21d8501 false +check_ring_signature 0579925c87974728483dda5e35fb760b93b84077173c41fd7360a6f8a6963da4 73f34654549be2c0bcfd4d9ce0df1865ee016a8ed460cfdcad8a2d63f0c9d63a 4 bd44d8f281b384870a52ee2b03c036419a8b3f9dc49f85157cf2d062ed27bace f51292682ef93efd2d1742f4927b9c98744113a041eae84c5b40bfafc2688709 faf4c7c8787e13f6963923df3d43ea441b63b95b72f4f6164919ffb719ed3fb8 95dde5bef69e177e4a1dd80c6df71a17a4c1db34b15c6947c0fad20da57d149e 6ee00104a298fe21bd3601d68d548e805f782a67aecf770528e79ab510e30104c6c1675366f69a7fd8652c5d4a1318f6552838c1d1cba8dd3998cfa7e69c540519eabce786282671bff0ce80743646c2a6dfc0f619ea7f8233db7a310501dc021cc0cf12dd6fd1cc95742c5cef9e05f5a5bef17746ca96ccbd44276ee03821073ee1ab60c0fd07f9e7fa471e4de72900d1588a227c66e18c8a24ba3bcf08fa07911e3ce9307cddc03797b5e8dabd6848f24b96e18cab32a970e2256f3edb460f43d474cecdeb87e7514c0f6e048e8db2b666728b954a31417641aaf2fb178803c89f7445d32d5862266ddc0a54ea01f89f0d6c959f86e3402c396db056784c07 true +check_ring_signature d628269f5c6027b5096e6781f83ed613d521a988891b4eb35c0816442c9ad6ec 30f49dec73dc0b98ed8e2c784cc058b7b18e77b3294e77a3d995b4237a7cd6b5 23 a51224b278fcdac16fd9fb0c211f38d5ab7eb29240f0730cc7649a6775976c1e 69faee5473c35b20888a4b3b9259f9589b4a2724d55af8ff3511e75a3d7d648a 249fcaf728124a6516f3ae97228ac91b5dccc34d0f09c80ef0f5ddbaf04e43fc 1427879e12511dc8a1c270e493c47bacc2103775665fb326aaf24f77099fb900 b42a7ed8db2faa150305eacf0dc7f8d6a55cdcf9ead30cfed2683e6e1d79ccd4 31a354fb8a5550c751260afe94b3de28bbc3aab05e35220e8e90617ba00237d5 0e07f74a9435c5f6ae7cc4e89a453f1efe853a5b54daaf4c5c364543388e5d61 58b0213fa68f317c2beb860e92faecf0e76eb3cd16cd52c1fc076edb17f9c1f6 b1b2393ae80d3f2398f1db06e9776dab6b8a21789d6452626059e4f683725b14 37634494868fc41331c4faa424a5574bfa01de44b756c8e544d7b8fcfe20e019 47d356cec9a89635ed388c457f706478e576b0863a963176fd9986f8e4e3f61e 9aa4ea77fa8b42ea7319fd1bc5e0a9ef8aca92dc56eb8b4467305b5eda05a1c3 890975c5a0794235af2d011c3c3edf38950a3dbd97b3d09f80a6fb5d6b97f2db 781b0ac91b062d6eed2d34a201aa91f709b415ee1be712158355b98364b27516 ee4d2a3189248ec753a05dbf246fbf0ef50ad48d614021babaabe00f75db2f4f 3bdc7aaa8bf4b60fb672fa14d0537e9577c625e1f5b8c1a274f6515bcee526f4 08b54efcb94b590f5f4431c549eefcfefc7d247d1b206a6ac3d7737e1873a103 0184968b53eff5da944a199d1b8b9c37144e0e5b84ccb8ed9d89532662e64502 4de239f448e8a0ff25ebf3f36ea164edf7fbb6af6c23d84c6e906d89aeeb1cd6 df030952067e03eeded0913be2ab83efafcad63a66020630b12c710c6691e9c5 e3acdebb7b6b6d1aac6db670e34d96e04be5a103d52d97ed57b98d6ad67ac626 fae01be1e1449baef52156363009376c55c07420e044ac7594f2eb4e171695ea af33e2bf30bed7495a28d5adbfabc3a5d2f8ab936f3f35d8ba22dad2465c98ff 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 false +check_ring_signature d734f2ab429a78cc1818c6946542a196053f0bb9a81741398ec3a9b4d6f428f4 4fb145af4081c3305414f9dfdd81479451cb625c7c5695807b2af0facad5b528 1 10c0a6d3f058b0a56d497dcefac54185b03954f19d0132941ee7ac8214eaf9a3 8b9997b88e01915e06d03929e61ecbec2500693d909a6146c0a1b4c3b86187f1fce487f85f2dc63343bc1dbcf9f3d1850b6c8e2f138bd42fcf21816da343050c false +check_ring_signature 45a02631bf0accdc6652bebf60cf98d040a85fad9794e59480890eb285ae5af5 7a02e637531c17d361a0d0646de4571627bf1f590900db7f46c4db9106b71f1f 52 ecc3b1dc582eedba3ecebcaa004e79d569e7b7920b3c492fc6899918754074b1 99ece3d6e1d9e1a81aae39229668dc68f803332e45c2848b711dcfaae378c1d7 0ab7bdcad2d1c4101ba86d719880dcf8b3b9408353a70c993123d01c9d7d04cc a8ec5021b5c4789fb89aa2cca8199d081a311e1118f13f17a0a20a385a21b9dc 386dc043ba06c2f952b772a1c6027f61a42e5b1c60212e7b60900d6598ec57da 075b8bf5b28da9a8d7b0f31c7926a0b39538872575ab10bf5dd315aaf84f7605 a90af15d9dc38ee97e2626b7d106e84ceac22326f96f649c76b53174af1356f1 df801a2236a440caf6d3d0a435a9a2ea9102a7d8e28987ae3eece0f5cecc6ebc f34ff09d501f61187829ebf11f60989c8fb292811e00d6fb95378b630cd9a661 91e4792f31294835ebe49f22f2a56b22da92d150fdbe03b75983fbb8b4ecbd87 a2756572e38a72a5904bd0523a7003414a292121973cc7ec82b090cbb57d7841 d00207e83957969a1c0b99f1b84eee3e0c22342bbecb87766906a1b1cd5a488f 2fec82026129e0221aa17d47187da29d62d76138837f9a3abb1b269e2b09d63e 6318b4fc81c1597ac2107515e4f67590e701ec716d459fb9da7d1a643a258923 ac62add03c3bb919f72fc1990d8ac520aed13afc4a4ca0edf8df9caf83dbcfe7 1a2174226e49d13e16c1528f433efc3947bc8c7ae1eafe85c10ecc047e221c9b 13cea838137c17d960e5b052ce88d7f724df4e1d4b1bb7484f6e44a07acbf370 473c030a119caa631c4532aea1193121ed8b2161efeb63a87716d8be972fa481 481e44e5820d54684388e0bbfcc61d98ae629058367ec290ed40caa5a289eb3a ae970ec5cbe3a800aa68e10a5f7a4e04e70a7074214235d5ec53c7e7b384074e 6ec305d859a4b0ac3b8789cadead9dcb38b987509259e5fddafa098de1d43719 0b73835b82a497a25cbecf615f7eedeaea9936fba5cc78932a3f85666bfc8e18 99c7e97a3299f9bbf42e3985e324b35ebbc8f0f151def4df6a84dca5825d0cbe 3ed0caa76d802c10be701f357ab14ce0bb35be26112f2df11409b9500de63bc3 97039dd31b470308d7ea3deb0b992241bd1ec1c74bd24727f0c15252e7bcb5ec 7c5d88e03fa44478de8a72d1534b7ffe57b446b55cf8d152df41fd241b461d19 eb99602d97f4947a376bdf84132ab75b5ca21e4d0a88c248c792adecbcc2b24d 0b5bb36021f6c81d7afb4265ce4e7ee6d2da20c29e80bd1a16d5a01b54a75c35 c83ebcf021da04949ce3ec23f49c5df0be06a7b6d45d97e377a7acac3dfa2787 5cddad888878471d57f1ea36ff657c987ee86f6e1e7ba5276d996f9d565be8f9 b70067d0cc5bf0ad1eac2bcf0cc081be3e3ab5526ac44be1d2d8494df1d3c812 801d834a10dc9c60eafc1b5f0eb8167fe3449bffbaace76bc9cfba77fd2f37ee 7b8f96447c3cbc4ed9c5a647332a1624c0e4c9e685e6cf75260b1bc8d0a93a6b 9d2a5e7a59203561edecba72fc70f5eccbdfe250b173d28c77337f009954b0ff 8965ef24d6ffa810073f54168058f23d9df0015d6ba5bde1a83e2775ae544951 2bda2e1283776c60045ff6e5e0e2e9b31c6dd425d7504d70cbef3c066d25a63b 8c6c2ffa72e0e3438c1fcbbe3f1426910dcc934b53e999abfd65b3636b3ef29b ec05cfc23054f7e496e382abcf8b1fc9bfb3056740040454df3f6e59919244f4 a73b8bb49e5ca8d4d942ee9e610e6d9ae0280e9eaee2637fece87af4318cfa7a 05c3c3f0670fcf7e7d561a55226269b79e66b7099e6ef151f498546f242870b8 1a448f986803995831607ec209f2f20aab18b64a10430fc9af77b09e04ce5123 a28f1127ef8cedd6bbdfbe3c3f506067800e0a0331145b3a4357c180f7927051 c9290a58b0d3c96fcf80318ba9cc9525f356aa167b0b7d8303d95f121a8ca275 c6dc0bc950509ac1358f11f2df7ca8c7aa415586ff88ca49ac948970e7bde93b 742a287c9cc86464991cfa1eb78dae6ddbd82d5217fcc1670a9206d955d8cb2e 7f97f463135d720b59ee0d28898486aa421ec598264511560530e22e743f4ca9 d6fd3ad49e4d76bf53847e611c51f0e63a2911815a640a6902952023149dd33b b76cbb19cbf824c13ba567d299a638bf957b163187c5065019195e9c64440528 5c45ede7004cf920d421c1d3238deb91d2e3b4e1bc4f8d50f1199c571135b515 921f4b8d21144b9401be367b4319c4e1aa0b18ddc86befa5a28d5ba02f273bd6 25e9dd77e70e48648f315f726875a9fe091006da5c5ceb36388e4c621cca414a 704491b2ca7f9cc686ae1d6b07f416d0f7bdd16e0e020974593a7f6903390dd5 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 true +check_ring_signature 50395014c7a6c05346932ca25916d518c350993a72df0c9997a0c69d94dfe114 e522bddab934c03713931783523e6968cf4b2ae2cb9a31356408c7ceffdcb353 25 99094d19cc3fd029f63822b1aae891fe08295a4e48d64a2b386825d7231c0cbd 8cea9787186d94a0585ee93cf64b1747523c6cb51c756134fd6daaa888462027 31227674e3db2f03910ad32a36ccd54aeaf48ba8dd2832366c31bec8d29cba95 03d300ecc486b5cdfea7639c27cb643bc003a8cb4eed879b8530093a1d703f28 c8a476b4189fb6a6767e0c69602c9cff6ee6de79fccde3d64c8b899b1fcd2d73 af71a22384e68bc455537142b5bb4e178fd8eae6ff88c9125592b8fdb05081c7 bb430026fba6d1a3f8cec9cbedce048a5fd78669341fb1bd55b35550e8af8dd4 d4484e6a5a786dfac8479f2784df49df88b9025a34327625df639231ebaf01d8 b7f946a684e7712b167b332568d3a6d8bfb77a60f3a5c54f2bdbfb361f3c9aee f4a227e6aef78ba1aff440f006be13f830de18004fbb6f967f0d3cb252ac89b4 057f9e16d7c4271758e484e7f9cab4647d1b87c4c317207c599cf2e61c77566d 7997ac64933168ba00f1b62a2f52743922dcb54d02594557983496bd40999c6f 5c4563c954598c4e5427d8d496b07fa3ddeb8f2150d5d6e747d4e93bf6101c69 bb41f371a20760bbb766dbcd6495955fd7e5c130b86dda00e07873b108ce4edf f70f03f546980c4b93e6f29d5cc1650d1bde94c3bb5abb96f695101e3deb87fc 9a216ea8ca697124e7f2ceab308a14c8da7b2bfdc1bfd7e8d471983f29f9e93e c5edb05f297ea75b58a8490b783ffdd385e9befb4dd031e2dd7546c9892135a6 a70ce26e1c3515aff80fa8f66d2d502ab07f6fe2e76caa27954bdf78e84a5aa4 0b4f7e8eeccc274e4847b9d41ef9e63b5565c65a1846996bbb00fddedc4c9316 cd0ed8142c10b1625023b0052cf939d3cc1c4bacf6a276c975d2417537fa8d30 524251e525b9717f9ef464b39f696d0b9c94e89b167c68351fc3ec5095c7eab4 499bd397dcafe052aef39abc01c943a9143f34cb260eb4ee89f699b894931b97 68854000c6de6a2f1b4fb183ee2e117cf9f1c230e177669c8af750d893f39dea 93ae79643a6ef5f3d9aa8f28f01b00f0fb54074eae53aa9c1ca3009495927aef cbf193827668cbeb5125f64e729ecdeeceb77ef6a9cb2c4902132ee3e8d40230 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 false +check_ring_signature 57b42d5f87ec871f9d539e2f1c0d3954435d0f35a8aab8cd7f539fe6f1b8235f 6aaf13f5a6ef0ac163745afa35ac566f8164a32e778d5b2e74a7537bb364cdf1 1 dd28b81df56556f11417b5e31629dba0194c38f0856866d48c3dac80877c9498 9f21cadfc9d0ede2071362fe22fb9e451a89b3339f0227547f249ef8ce9368f5672efdb9a26aafa62fe911069f41f62ffb3c0bca841922adc6a1ce1e4419cb04 false +check_ring_signature cc7bc05ff7d0da18a71693f4e282639e416d6d42700d40f6f89e11fbe21af13b b74be110e8c29af65b13e7b502409dc55c73ae09734fbfaab6f5db7b52fac21b 28 0effeb9ff22dd928dad472f6a7f8df95e6c39524f8d747f9c9bfe76c61075d47 33728137257602bd17a29fca6fe66cc23685da86bf92c305c4114bf8792f7530 07d570a991c7e7e3b72170f7ef92e755510244d0bcedabb6633c8b63eba261ef 17e8fe4799db6a4bc7dd53e1eab1dbbe1a2ae555f09ec9152e00a0ad382c89b4 ab2b6e7da64773e34c349144655b0aeed7c88bb37598cd75b583101ef82e0643 bf52ccf08e526ffccbd05d9766d8c506469e3229a1cf56283ca058f4de32ba41 851182b0051964e6f884347be670b45c27a6b503faba19db0760815269c35410 d239e8ab0c8101a0a939fecbbec658b3d9a5edc2fbaa10bcc6b26bccdc3e5c8a d834386f939a3446eeb893fc795ca437b26af07e34d3955bb65d82933f2a2edf 3b2aae85a0c8c37ffdf4175afcd60619bead7e6abed0ba250804d5dedf97d9f1 d55ebac09291df7ceb23a8246c15d6da68659e42ef92c861578d0c6673f49c2d 7b721e4847e0f64b92a3c590213e5a404ae35794882daf5dbb7b91f8468c2114 393809bf09aed7ed5e68b3f042fc25fed600f328a6016afcda188c698c259d74 542294c107769ca4c0aa6c6c2e329cc09c250cfb683d7c4d4bbd94eb48417c3a 2e70112eaffc4a87427907423f62525932f3fb14be0e1aded5dd3d03cd862f26 8e900c4220a401cc58488a076e2cf1962d2b61de2ac0509e09dbfabf7258170f 8e2478e32ec2aa3e2463e0bc9a3c10c877fb9df305dfcd8f1304f64074845108 a09485b65c8b0b76d6c8135dce6f9e27bf8dc4d98eb404c485e3592d7c2a6ba6 20b0bac6ebd2e6dd4545d469a687c864c02eb3acb4534086fc4caa833cf0dcf9 de353fe9bf02ebe75fd4fe318362fd5041a690f599e1ec1a2497b1a458f12143 99c84b8ab8a0ad36aecf578db55b65f30df43f33b66f293073f5851d46cb0990 4bdf1fe88b9341a6a718cb3de9826e710b956fa69a0fc86628fdc2bdd4c4fe2d c263da92d4df28b4c7f69e28254357d2e03c23702208e8b5ba929970243aa151 8642885b3eda033472d2967fd07185ad00838f892b50927a50d0a88990b5ac3c fd359163ddc64985438cb5622b14de9acd7bf0c34624ba1dbc73abdbb3cfc2c0 fab1e17e4c6b0f2579a39953c224c97197d8204e78cb384c7f5a78ea72ad2f19 df974cb376f995c2ab1a83eebb90db45bd4f05c6a17df73dfd5dc9e34b8132ad f9f0f8cfe4332b62d4ed3ab8e8e0f793690c0de0b4af23b52cd5c136b3cc9c2a 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 true +check_ring_signature 2c65d67c67dc2427225d2b590d0d55fe958b11bec8fdd58ce4a947bad4a0fcaa ea567f314d02af402aff547226d2973cfb5203ac8888e56548b17a997ce40802 162 1a21400c2e1ade9fcdd97d8adc989c5907592bcaf432deaeee9a695c887a5384 cbe8c8506226b797448d98ea7afeead5ee5dd0900dfefd4fb3b84f83c8134683 0976ace3df7cae00f6ebd9f0ae44b67da5cd439ff40eced7d8d1405954aa02e7 65d0fd47a176602e1864d922cb8012da088efbaa4ea6aeef3b502758b6f8effa b6dfaeeb5aadd902a273fd4df1569b18841ae4da435a8cc45a2263d84e563c1a cc312991705f35a724468b5a3079e4498e062a1eeb550fdf584bd27d61bded18 b6cee558fe20a2ba6d3ba11091547f47f0ed358476581203db2e4f423a28b241 a8e832473098798b2395cebb5251338efef9a598b72e671eb62026286d83b700 8739f7927696c938ad40bf0fd3d24f8eaf06ef1b48f3b4acad1ab19f821dca0c ea668bc5bea84c7a5960419df2d28199bd99eb34d146c2ea50c97a2f184b7dff ab62d3abf9358f81970e9850fe7ad0d9af87d5faebfac7cf0db55e9d3f8080fc f3b6ac60a92d7f3e93c8456775594868ab610862ed14dbc54442db2a667e6f28 da867b9cba92365dd8482c2a22426cb640d097b9e17a369e67f31d1f2d215ac5 d157a3b5ff0659771a748b6cbcf57d3a0c7446feead92a9c04ecdbfa8e97d3da ea57a1baae69dd047e5cb36de19fedb6435faab1b74c52482c69b52737e0ea76 cc68d2471e14d975ad5c54459bb2621d7a03af93ac975b62942dc93ee79b61be 3ef505b37ea8fd63d0eb3a2a89066593e766cb3565a9de9928953e3889a0078f e69617fddfef05c80337b9ac55510ab48662983abb95d1e58fdfbb855af4feb4 6a2301296143de57768e742f3510621ebbb3a7b8b461144be8ba282d29f6d6d5 1f2c28f7ba194712a73b0243dec6d67c0908ccb478f652c65c0ac53c3229ed81 7477f5af121087333d10f458fc9e9428602a4b13d566c662d3800868eb6b956a b9d7c242e9e7b6cdfe1a5c6e3c8bcf80f2ec2652310fc04104e152a4771fe387 218af5294f46dfebb06204e6c406ac0afd3e4b09da5ad900a03c0a188f8cf012 9e6ba79f690093d5a6704515e67d08b8f06a4275fe9e6c7277cd311b094d720c cf8ad5cfc3e70853ec2a4cefb9dcc8e92608d54650439adf7d166be354a274c0 ba9457d0e179a10be858e3ada950c92826d1d56231dd0beca6843edb4df51d15 056a0157214b04d31da220a421d101b4991e7b317e38daa63e8e74566ce272e6 cbdcef55d520e3353f1fe48abcaf0c61167c5838f528d05de5f2bdba176001da 0ea413eff5c814c86b61e97c302f7e822bf6d828e2d5f378ee3a653b4a0742b7 6fc58064a57e40de83fa76b48a46ed9643ebcaffd85f1b788e46761751c8f72c b2a9691e844e81f2ba07e5fb8256bad0a98154479461b20c369d8d86aacc28c4 0d7020a9f766a0dbbe4a2a31e3b995ad1d47910024dcd3a171ffcb4c30af47a3 b678c1fbe088a75e3b3ee6e42095542feb2d9e0e99489459bdc253597ae525da b75fc87c4135d07070154b6228b6de80564c29f12e291ed8b7b4fe49306af59a cb01713e14766dfcf02332946c616e9946ce15a88155cb26faa3dd4bb23f34cd 75efd6e7afb4e3ef23b53bc4a365fd5312b8bdf0e04f58510c5f66d37c7b4ddf 46643148af8be8901cc4a7f99e5888308ac505ecdb6cea5f6ed104bd635f14da 82c5269a1a4c0133d532aa845bb1b28d2ad010bcd153dd948154dfa164a2c73f 3e7eb8fb9fb339efc1de931154404e9e4975ceea1dc54914ab8a19e6721fbaea 24d81e6e68f65f4c0f4294c87a4fba5544646b92d3dccefa3dbaca1fd6b62158 01cae3bbc44641bf1572d75d819d3a00355175ec38fc62d9aee2a94ee6a66daf ff08eb43fd826031cc9e74b576cfa7f860e0ee99261bfd551e6c3926e40483f6 329c3afefa0843e2585de861e04f99b90eafaa30f626b32eff766b4d04d907f1 1c74b58e38942d61ca20f994cac869114126460d217aee0adc11a591b1fc64c0 2373330c28c40b9ed922765d0bf48ffffc291d1ac272eb160b3e5401ec9775b2 ec8df70c67c9595e7bd51602a5e2348cd28f90326df3d6320c3ebfeef800ccc9 002373b5d30cab1b22faa107d240a76733d8f9b222d570720acc6cad7592472b d2e85f7a876558efc69ce611d0724301616c9cc9d04a78e9a1ef1e4d6549f98e a24e70970167d6bf445d2669a38151b4e791d271a0526e96579658d731dc9ef8 d49d355c8fd5975a1c973772e105a234fc50301fe00b3ee8472187ecbf8084f1 25715b56f4f0b4275cefa0658f17ba1f72c2db4bc4a5cba08a1968d908f06712 a9fe6ae7a1bd7b7c923cba2b788cfec6e0c76ebf3a78d61745e80ebd8d6e2e94 ca923e1051bfc66aafe12881ef80cecaa00ff1705d7e255f62455e1f6a645a20 3825e1efcfc52ce3f41a1645a2d7ddd1b01bf1b632c685e250a2cfda0d5fb17d 865ab5c50e7d161ff9e3761328af7fb83a38a176593fd35891c3fc5981a64755 df8748ca541c5185884a076ca9001684f015ea8d2cb6eead4ad160a266ad6896 ac8dba2956bb66b1d19616ad1ae1f97b8945bd09dabaa58c4a55dfe8a51dd26e 5b78aae2b243ee42c859593f4903e6dc2ded56fed501da9881143f110f6560b3 f4110220605721edce3a902d46b32fc6e5116a432ebbc6a10c34ed4c2d1a1faa d3d6a6795bd5bdae12cad29a3c947c0f5e98e28d7495f7fe349b573d06b50074 cc4eb28116c4493f799640e9c7af4e979af9e37223a4d973b66be499cad68e08 0868c43cf2e572c5a7463db87589102951a278df3413b4eb0f4fd83d3659802e 223f893bab0996abc4fa81c7101f2283dae3c624e7603423a5897e57dce63ffc 74dc5a93c3fd1a42217083da3d372248ed8ed98d956e7f86cfd7591958c43e2b 4398561c19e8b728408e51e15464c95c52c88605d4731f1fa8486cdf2e6e8584 91f54d243acff5c6ea50cd49b855e2d8e3d59d4f258dd42d1b452058dcdb2a61 d9247c66ed55aa1b6e5f192842f93d10233d5d64167ef3f8a18d0587237227fe 3c05b22665ef87508199d408030dddef021aac810ad6ba088fe4b92d5c702b7c 8350750e34a95bb40fb68875d3016deb27fbd38730bc57fe31d94563303fb6f9 30a12d8ba24e6025e14a3f5b3a715feb35f58c50b67bf27367e4da8f0bb902bd 7ea5f8735f3a5e4bc6bbb6ce14030890c497ac86b58c35436365e04d3e47ebe4 8917972122f1be3b5b710f4afee9fe642ac8305e5fa251cb65b6973d1f21bc75 cd27b259d39a6163622a83cf57a55f786d0827983f8bd47298105ad24d07d9c7 e67b3c212b33a87e719a82ca791033eb0beac081d2a57329acdf51f977da0e26 ac52c8ac43ae6497a0b45693dc3a7daef46a6c0a4c371cdf3936667434154c4c 81d665ce3589ed5c65646232f7577d50c5abc1a398d17b43368dc61343b4b3ba 27576e75a7e045904454d9e954ea3ec53d064e9f4a5f6640aa925812a9aa4c61 2d818e59d1cd2a3bb9872ad3cae28461b5ab3555d2d7368a32edfa65da2cf29e 71439a78518c554552078af887a6bffbe871e305f9b6b98392d46b82ffd6a8cb c5ee9a56badcb53878c8561c003dcc8961e8cf9a80a619f4dfb91a1a42fe28fe 6dc36386149db2ffb19e418505c932d83d2ed2855241505de659f3e7c83178f0 be3272e0235acc3e6c6edd900379391682ca6fd046a99cdb2843153b787d7a51 2305cc9062fab9ad450a66a4e39a9da0e07b83237732992cb5a688b20cb7b5cf 1a587c348831e29e35fca13909325ca395051dfec97a7bbfb0705f450f22b622 257c7d64bf44e5167f2a47c956610abaf1de243fe56a82f683e275fd9b0b11de 00a7048a5a092c5d8dc6dac858f4bd142bf6611e8afb76e5c3b8839cfa0834cd 842dfd32f51260318125bc7f4ff62b6883174c6b01248fd98326b2f8caeab165 02f29b6938f352a67ce6d288f8555b119c553f361b08573c99fc7ca09dcfe478 4c2f4619b5e6252ffc5bd11a0474870097509fb6bf637a68ba9acc5724f6b63c 8e084a80d17b257ae3bbc9c048d2d9b6112b3862f69d2c9fba5a873b69412fdc dff2637c30123ed37a3b569f7f58e6f180d56936a1befe8b1bfae4d5e875735b e768b920aa15577558a793269dd61450451653a905050fc71f35696abd5e58c3 2ce8336e57f76fa88102cafc9b6ba629d3d24a3e2776c9b7a67af82ce937a594 a1a3afbdf80a37454a9186b8b4344504442654f38f303a469def440d04b858fb 42ae034c9c04238c39cff28cd1ae26459d733da7fc66c23b5de5bdddde5fd196 38e9cb9bae86f1d7f03c4cb83bbf15883bd7d127c6b02661a0d061063737e1e4 dd4d47bf14e6e2c7fba1e255ff73c621da0cca33550a5c9cc7da9eedd4c14543 a9065528c51af4402f1e9faa1cb4c5b258ac9cfaba78ca6ad51b1f50cba29330 8fe7b900f328ddd25bcb5fda8fc7924a6198d54324f02fa8974a732a9a9456c6 472bffc1e0bba1d3baeec1b3800c249029cf0604ff2ac46a87170080a4c3de0a c8a151737b4236a52c3844aa92206425f04193b9ba15ac88e27c62ba9c60a60c 767b9889af076020c6df7748884443400b8d075533cc385a463a0462017be10c e3e7e3276ba22eb4748a86081fe1e365826a0dc60a55c68411c64edff69bad9b b160e61c99da3c7970496e788fe7e2f0982f39f3cd37aa042bf044438214d8e9 415c577a2f0207106ca75a86470a27d46c704e405ccd828b2492d0c037e3c947 dae96edc17c8973490334be926a4e9a35def18c7b5e48178dfe12ea8d29b5242 9f9831832078763a2ba8a89088d8d4e44b3dc45b36de19aac9c1d81a530ede1a 5df5d4a1ed07291f88dec6db5d929ef0561e0ff6f356af2c8186fd1b36e4540d f046048e53d979a24c3e76dec54db9ae6aa01cd5f02c1467dcea465118ef5812 cee85d01d7e14057ce476269d5b17d67aae9a7a6b6acf5615fb7bcd7ab95b77f a6cb2133deeccc4ef4ae0e7ed90d1b89a46b4df5c858f6da4e43eeeb88c7bd25 38cb5414c71ef963583b8896aaa3490d3499a8938565ea5ecb9bf6938f8d6d76 190f40112acace7b5e3f5719ce54f4eb6fce0105315a5f7b5e2a3aad5dcf3e56 316e2dd1ed6e2da120a8c617912941326259ad939d74acaa76cf59ed1537db69 65618672f397d282d4a18eec7aaca6439a261da6d668e4d69bd314f168f3612c 836d145fb11329b9025c166504b35ff448c391d8bf0cf732f3a28f53ac4aae9d 145d281415909566c7d058ff560ee8bcfa3c7ebec533948e7c319a3c347d20a5 e88a611cca1795382d02242fdd488798d9c69d46b39c21f2d7dcd6eaea5e29d1 a0dfa76fa345d093483efc7ad0a27f5891d78882a5015b935ba8c519c9cc5a2e ecc9a8dd41feb69c4bb31f0668aaba352ce077c7d8a86023b24e8d5454ab17e0 fe9d42ec67ec3927d73967c91362a44a7611bfe82000c334b277b978c63fdd0d 9c11da30c0d48e54e73af0c293e6d208d7de1761dcc598a15366a4dd2c529710 6be6e0130bd6e4898187379c7d98c0470d9865672575cbae6f2899ba4e854a7d 8207484f083ce528fdda38c7de243e53d4a86346858eba00e0412d784f5c92b9 86bfebd52bf90da55e3113708a4ae85d4c05ee9b16623c330f5fa640865bc880 92e57611babe4e7f6c8b34e86f0745b8fe115b6b91b49617a86f99a625884ca4 cc5c6ac01262085cebc1094e24be4d606ac8dd4b6d3cd6d231d8aba29ec9f6e8 9fc60cae6ab19e328040905c92b7a0996df487303e99f0903c7255681d4f28ee 8701e892fdb0df89095d4819e7587a837b2382b6f0951aadcd690adf71bfa72c 955bb1994662de428627e000a3826a9a55932f99a257affb9d70fed749091abc 0aba49ab1a8c43422941032940810e184bba72b6ebfa126d836b8a2584d0fd93 e018926564473db672f5ad160079e5e0c047a1d2551ecd8565174abefece2d91 6786d375ac0fc3c29b9eae62120ed05cbac58c63537b85597406f97e37490de3 7c9d4b70416f14600539f2b69bf216554c937f68dd94256591aac159ac6114b6 f77cc035f60af3c8dea405d1ea8a952c226e57160dd0477844608cfdc9fd2406 7516ef0cb4c032a1d5f6f2b0166a0cd3326f38243b6feab683d9f74267d22c17 cfc49923ac345335892cf9bc21ff3d0337ed1650dc19e679bca13b18565f88ce 9cb140e2d23a71b877edbcf6f9d65c7a6e93d3bc0fd90ce79d2be73a71815da0 4342e81ba2a5c289e110761fa39918bcddeece1e305aca11f17a83a4d191e551 36859c0b9b3b20e2a5ad47d8b7f6d2106acee8330174bc204d8d8b640b3cd2bc a5e399f2f8a84447183c808a267c2597d8cd7217e0624d211464564f00710c3f e86d2cc218dee2038fda744ac75c261e5a636e97c7064c17454657556fdb69ca 63221397d70dbf4ab38ff853202629e3f86912df765d0b865cbc2ff2946c2494 a3e19da65aea4de2686a19cc0bcd7c6d7abbdaf4fd33fdf1e9e69e71e001f5ad 4cc6ed8a1d19da137563e2418d7623b83ae4f047aab22a9b010938c33a44b065 f4ff7317c12e1efa60c92d0a8616a1a1f7c302d5ce30ce8599f19cfbe96438ec d0fd8642788f75345d176f877b4d85b15c497b6b8d203254451fb4353fed9dc0 921235695227ad030cf34be066e0e36ebfb71d33611db1a44208c83d642f9174 1ebcb8bfa3805ade05877e961804b7f228a74271f7f91b0115292249aed5c449 c4309d55db22737ea311c000f31edc88a24e846421fbae36dbdfbca6b303f134 9ae6a15c563e719640cf06ffe845cd70c2674b672a71bbb71d0c1e99083e3420 273b24661cc87cf215c50f2c307707bd313c0d0836e2c08587b2d66a401048e1 d5bfbe22cbbbf87123bb617709570435d5a2fb2ba3e32e2c8ad614883eaaadfb 620e210676f3a86a37add06b19a7da112349cac1779c25273439d047f7962e72 aa6089b7618e706ba5ffaef7143faa457cda1ad82bda9fc96cbff2dfb1d53f22 9fe4120ef2ecacb37433176dcf5934fe230890f4d8cdcc9f7fe086798db95eb4 4ad2f52ab380e2b391781cb5ae1d145c87d7be1099411b43d80f37833ae3e6ad 098b95f451162d2a7531e38fa648a0d56a232dec8b3b616025cefafe641f7de9 735f2b996ca731000fc807248a74907c2c7cdc1f9ba35f2b2d9b84ef1c678ade 7eb9a2404cd69abca95cbb875533fc84f5a0c49a2d6d4a0175043082f819816e 853089636479f225009b1db70e30e8006612874299edd3449c6df89d839568a9 fa8f5cba0ac4fba9a948222cc647900e337e363ba6e58933367abef9d84469d3 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 false +check_ring_signature 69a78567fc93048a14a2fc379f6942cd8f71f592722c0b322f64fa6f2fa41f5f 362d499c108426791ceba065fdf4e34fd617e2008645fa61dd0834b6d8841869 44 4a62c686c5837089ef7efb83a52774270783731ae64c522d391e3c3a197e6b5d 2023f50a063632d264fcb180fe8a0bc5c8a0ba720be3c28a60d8bf93fc7f6f39 7c468a8cf2db0c23641e1b487fd3fcb60d66caf04af148e45a88e801cf949b92 6d168a47da1e519fbe350c563b0ec476c84c08d383a2e5cac90ed9610cd752a8 3c2e6f0ed8d6d20f024cea470b258aa691ca9ecc795f9f1f05eafde53a753212 00c66ffea39d420ca9c946273b6457a37855e3e27c20cd6e971f381f7256cd9c 1e57aab320cdc79fed2ec7223826aa6474e864308396740b5fda28cb093af2e0 ccb5d7b2a1dc4dbc3428b0bf73855168ab7254bfdfc4919fdec3276db1685389 92214e0ecce07601d09fb6b3ae8b09e811fadadc588fedd563e65c71001d7b3f f7beb3c9cede250a4f59cf586d22ef2703991f93ff9eefb3cdc42b75f879a5ab cb767ca297b3df457dfc1c9372abfd5929194abdc3e6269d6ecf76ea725ce23f ca398ddb5c2738ff7581e4ba4eec6a7fa68a267797fd9cfeefaa36f0683a8519 f484fb50e073c84cb94d4f06f50a39b3e71354a48494b5cc08d63be84c7eb5e9 2b3cf4c6826ea7d40959235626074684faaef8f4630f9c983ace6433705aa147 3dfcbe8e86f8d422793de338d69c5a03704b86f135b4f48fbe1d1cbd9bfdcc12 92578f1b0f3deda54fe7b9a52c41be4b41946b63794d52f5b2f8708d8e1757a9 e3820fd2dd450663a43529129d4f3e7cb32584facc8449fc09cdef26d083c53c 17f556bbe8f8b1eaf3760ff834aa850ec8b04f04205deca20418f62e9884c1a9 95e17fa1574f3a4ba7f130851fbd5b299aa9554cd12090d4b0fe39264f36ae00 5cd3f61c4eeeece6ec12d33ff08ec9ede34b74f2717b82a2a93aebe31ebca221 829c598b3e2f0060605d055a759a623f26045d681aa162b8d151a373a6ba8154 adf31be635684c05e8ebd83f080dd241df26cf935229557f657fd21b10fce8ca b37ce920f3326b3cc12e8586edaa44b1d4b23c318f50784099c6679764ddd602 d98bdc944ee08e847ff9a6e61cef8e042d1ac192fec36eee4a8e2b92a41aefcc 9e98cd4a2a43b856ee0350b161655208b86ce2855e5469de17e4246b1e4d66f3 0429c0ceef5fa6491c6fb72b076f5c7e7bee9a8c6214f487aa0718f65295a86d d8ff74793fdca92b1452cb1df3cb61074945c4b9b0a543d0a46917be74791374 1fdd371ca90ca5a925a93bdbd06e9f57776e1926064a05a7e89fb93eb53a6645 fa8cefe9f14c57309d266e64c1ee0073b706e0ff5b66671f391d13fa0ad82474 7d753786ae656354c697ccfd7aff55d061ae11d21d090fd64d5d5c4563527dcf bd8c5dabfa300f6a5bb2088628899df5d09fc651bbfe9e37b94bf72ca82522fd 209a5e3194b387f935e57fc64bdba5df30f75447facd0107056213f7c18aeeb5 ae84bbf9f1064f3d5e7c80bcf66901a45e4358023fe2169ca0f28090cb3bcad1 c68209dbd09bea0ff11cdfdc4afe5daf3c0753db16deea839f45bbeee488906f fa7007ce87eb1caac991cc3dc34a870e7404f00eae24e986777c5b130f165c58 710895afd7c668637a1697245c6bf6c9543aaddc75450d80e860cc4815de50d1 01b060de3e91a66e99524c9c5972f8747dc3964c6f2324d746f3e01eed847143 c1f6ceee13811891fd063c084fc40a65afe6cb4512bf22172f9386ee97819baf 2afc2eb1bfdfc8b3c56392aa666b7413c8fbabd8272201fa55ebf0cb94f08cc3 4011e419eeee55751a5d00304da85a160cd8430fbe820860f20a2ad5d3171903 b85e625564283f0ebadaa3018aabf0a33c2c6c537bf20172299b3a86470b58cf 05e2b28bde19db1843d722502cbc87e59e0db73a30de020003019005ae29fc3f 7d9f7d76032e925a374b34da9c6eef62f85b99284c8b1df2ad9f0a2bb204ddc0 73c4ad3907deb268106b95504e7187c647f5ed21627ad881b36ea91026a5e742 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 false +check_ring_signature 67e269be1ea8e4f1d64d219607269c9308257067c30d48f2c78b05a22414ee96 0587b23579e61e1ac42fae4f53b8b9e11ce54a4c26d86bc19c5f18af11488511 1 7b016bf6cfacb9b7edc75c1138f3cb527bfd42c97cecbeed58f1feb6c01e331f eed1d4e566a306a0a96c6f3a0291a1e2f03fe3e6b7b16d9ef7dfe9d716e75d05a16f00c377cb663db0933762e61aa577e3b1b00e2eeb3dc8fa1906cb5426da04 false +check_ring_signature 1253d3d1e901a71b4dae20f07d7cfc71ba78ebb5880b8de66539f028d9964423 38c5ad08412fa9c7ec61519d16cd35eadb07d69d2cf8749c134d416cbb641ae4 30 b9276c08e099ed15a4f3afaf50bb4bf47f77a445aa101b4ef6a7f8aa7d1eb36e 9294f236655fc7f67201f7b8ede1fbceedb5886d949b88625a08b4e58db9be43 720297f8580c9ec15f7440cfa814ec439d547b406573f9c448fcdd261623b86e b428f468851f1245bcaee380a4fdb2c70096dfdb19fccabe04f48832052c11fb 12ce40eacc0705e0b2eda0b3684b3b870169a3dd54ac8286c59d292a751a9711 e76468737ef0270b7c0c430a0d5a6eb408d1dd605fce146a840d9c2f61a18cc4 5fba11ece95f131852438705daee1f9a0ed37e52968e167db18465e914c0ae04 1bb038139ffd48a5ad46d06691a01f0ed031a320f8c44d7fe137eefd6d5e9aa2 98325d91f2b785600c0bd3fdb40211642a29c943b9241f62c989d5c32e167790 08ad5ebe0c6ffb475c638bb70d43c1f783d8af4b9b635b228225ebcd642e0979 58b2f5c48dfc440d9b50f32259893529314900b41386b8d16ee48c23ee0411d1 0422104b4edb38f0cb69397f84011011fad2b1e0f65bc8c761bcc9c7979ea4df ac1315730c5b7bb409333c5479963f3102f75b2699d4475e367ebfe4c8db63cc c313420e1fb1853741d68830f6073102204d71c987992a446766d057d1d0f24d af08beee6950ee79c55002fb80e69f5c2fbacfc4986161a8fa663c8b8c5dfa6d bfab67529c0a8e73196aed09446b761d03a175527d47489253cd3ef37991891d f145f65636c41eb8cc5a62d6d1d803471bd094bb7e08fa4e01e6abd6541013f3 7fc8449d67b012ed862898510ee6cbe4905dcf663b82d0a12f36bf3571eee734 ebda3a5c4e1edca4570cba480c2a14325f90890e5324e908f1e4d825e125371a 7e02900a5e7105d72f9372eaa98fd425d503f531a928b344f66bff0441985169 1d8cc80f5ecd54a08832178b0302f8f6966f2c31043eb67f3beb62c9fb4994bd 389d4fe06642c2dbb5d967a60b8e554226f98e1ce29761ee7e9b14a3d4387412 a99616d2d2329b462c72280703b57ce173c1cf8b6eb104741d55a1b640b49d50 8e765afec7879aa1c2af4214bfb2e7894622a549faef0de156c7b153713b124b 40718b35d82dc7fe6a9cca50965211f6f0623850768f4182aa0f9426d95ceb83 eab79147d258c5964e9b9916037e68c8c7ef78093bdb1d521413e16c925a403d 8c5e707907db4231f885f90f17d974cc81fe794d6af8e37d3d6fb68b0ada7be1 953069f78b090c486cae7a35ebb4413ef9cb60e54f7218c7ff00af6e614711c8 f5acac36d6d3f7c9102623e573dff3be09c57ff2af0eb517ede3385b7794c299 7d973c175b36fbf33e4beb3ca2018b3daf21c64b4cc96cf7d169a3ceb4f2f20c 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 true +check_ring_signature 3be3bf8bc6ab751d42d8accee5d80ee75e39f62e25b236e4f30c442f7a1a2c76 b8f3cb5f4238e13b2f3f0b291f0ecd0f4bfd48432fe69f580bf039b092188e97 100 7a99edde587cff201d403ac91b6699046acdde2a60489562ef5dfd344261f694 54b4398f76bf79d1c47c34cd2e036c4ecba0175c713d6c2a7ce35e4188d0aaaa 082fc4978b1a827f4f9f97ece436edb576f00b8b188a6e0be6777c393e864d36 b9cd30aacbd1f03ed3b267391223770e7902f34ee88e161ce2216742c5c743a9 a6cbf7cc4cad2c2e59966b6c37e75584fe245b811c58ab1d32586f98a9fec1b9 ce544ee77870f6ba34215509ee41acd033731434b8c63ae1fba4d3add6fd3385 73cbfd361eec552b280dc3c436778dbb55b3f03eeb8d5f5f243b2c04d8903811 97233e87320d0db12f139ebf5dab8b5b9a0292765f9bb99149917dc6c009c06b 1122a8722135560a63ba9135e60e91eb892dd849627dac000054d643a5204bef b2d7b67635146d7546873c5550ad89c73ebad6bbc78f09ad473b7434e914f544 ef035f2a2c325eb2e37953d73922f436c720dccca2d9f400e4b17726ff667402 6ab0407b7e239267bca490d4874aeb8077e9cd6aee743f7ce8eb37615c61914a 2105028a82bc42701f48886ef90d4c0112badf041990678cb598cb3b26b371f4 9617c954265fd60cd1ecd30557f355446e3e035c56e374d286445c2439d3f149 db196cef6c6c299f92eda52478fbcebb66513604b7a38b746ade19ffcac92895 01d496f73cbd39535826ce7b4fd86f443861f1c42b3f871c889ca924327668bc e22e85123207c9080389c5f2620bdd5afe3e0a8e9b83902a0dd8956b351fed64 6497d2b8f1062d3251d49d0c6af0406a955aa2c788e0ce1bbf527fbf6660de12 286beaef8818ceeb160ca9593521e5a27564ae40e252d3fd5a88561affd36448 f4b8f480e294927b66b1e794c64d8a80caaccd3578d36e7567fbb630b5274f86 b7e14124f6aca561f7ea2208f20110c37a053bd8c7e5132915f35accf87b02b2 7db07721d1ab75b509ce4a1db042e13bdc6b4bb00046c6ea647b8d30b0b9627e 0d0e922382ebe70c595e8b8d88944834acb4990a6959bdaaa946c4e213008456 0c208e40fa1724249610631dc528d61d8648dd20109c79350f8ca932af7e8e67 352dbf114f659c494f0498fafb51cf554e5b9a4278a4eae8633d224a219c8a41 0e013baff01e12d87a1b3e4d93da019ebe68d6098c2f63fc5bd4a8bed632228c b7029489bd41fdd981db0af17800c070d6a752520ca708de937b6a7ef85ace43 9fbaeb3d30947dfc5482a5ff511fe83e37d96c099ae03b683e8a70904cbbcc32 4fdbeb597a9c400dc3adeaae17dc764f9d7c24962fddba69f92dffe023b0c3c6 6a4a70017196497bad647e2abd096e5b9b13bb0a1e3ae62f3dd9098099ed8382 1e8b80803e633778e95f2dee49a77ad36005b27ad0ea56df93c596b43fed77cf a853c8bb66889ef68827f6a401df487c5fd1723417ea4bcdb3f983398b004a59 b560712be697e81da16e1cbf23f88fc6138ef432a5b938f3d698b0aeab2e6e7e 5a338cf131241dd35692d6260cda7db8517081f479ff1870ca9cec65c002d166 4309e67d1180cb97dc9197dcdcdf3ceb8572796fffbfd116a5af64178e2922f7 cc22fbf80b776588a4b37a4cae2abd5049562ab8548f0c699fa7fdf7a25d5e8d ad6c6bbfe3387690d58a787cfc561ba584ff3503d990694a88facf020e2a54d5 db92c04a96c06c7c0d867899479d67b6fdcd54090311bed97f57b70326cf070d 5155931ee5ef7f4981e93db2fd126020f3999415cd41f412b2ccc6fdc3890128 0c585899fd98d13e323343d481602bfea2801fb5d341437d14930fe1c2b4fbd2 6763cf6da35fe1f5a18f5051cf1c3edca71c17ce0fcf2d9ce5464fea70c518b8 606ec6e1ebcde84ddfd7c634221c325f307e442332638ae7b877442df7be6914 cd4d13f03e6152a503c939c41ed4781a29a15382c165596046d8b5ffdee3ef1b 6f9f400eeff244c7a58739f3d41505f740a9db8d2a8b15ac964345202e0bac20 5901a9c9394fc6d45e7e6932ecb870010530c64463f8080b7eee21c59a29894a 9fdfde99b217f941b8abb10d91faa5466b2216df94572c06b13f0012126781b9 95e4b4fbf599c0d492a7298285bea71a1cf3c4ce529b40352aca472c97e1029d 1a4d204779d6b6a5879c9fc2ae8e218f82a9faaff6dc06c1c31413f2de94a374 366e1a2369644df1e7262afd69c3cdcb8020fa3c0125ef96ca2706b4b0439592 631bba7415c1a39270ae81e7ca674476f6c78227e527bc1addb9d8be2d339777 802f97272b1880dd7f76366be333ea4fe6d9b2ffe5431141bbde64625188f3ef e876416f78090e73480e01f6d5f256619ec02ed7e9ad29e5f20ae2d31ed01d69 41c287f45156aab26cb7e08f71cfbcd35f7ad9b991c604c4b777d546f7124653 98e90f74f35fbed7d6ab1a82c052193c857e88dd41cede6ac1145602e0167b21 beee6cd9a0d9f6236efb8add00a29c35400880ddd198fe748be6d95c4e204c35 d89c37afe1b186def2a6c4e3ed27616ac066536d6cedb745000bb7804820b39b d089502ff09ae24ce27b7c244eaf94710023534b3fa5c25b8ed61c89556c979f b051220fe860d60122bb3397e90e22ba9d1cb8fbd964283b9d8f30d84efb2839 476035779508e7aeb7965354be15d7ebeb94a8a1914274385f36d7d60e6338e5 ca1fc3ef06bf8e60b7f4b8b09b286529d7291e5ead87936c645faf2b3c553527 247ab92e7860e9757844d83ec746d5a7dfacb28013677a339f24c244c08ee12d 899e1d3ecae2474857dbfbc361009420307dab73728026818dd5dc88aa9b6717 efcd0600f4eb81794a1b0dfcd1f639e4db64532afc99dfaddb126fa1cbace6e4 5df2183961e8ea106f9046f8224198baed8bb5c9f25318c6d6ee6912e88c7348 8805666401602911d73901c9ba76e6d76726b28d5fb483c4df2f7dfed0115080 b6d7ea798c5c600f84355f88872815c1f19a04d3398f3f29893d8f5cfbd588a3 882614b9199606ae3370554c8460b8f99d7d60bf465094e14aebe9444e85a51c 84b47c832e00075151575dca52e4236906118de56a7181fc90476cf68bf84676 0b58196525f267661b4f029458e85f5f0d0caba3b094c38703e0989397cc884b 3fcdeee3e129f571f8655e14d8a238752b823914f62ba5baea3670fec44ff806 928f863cfec5fb9ac886de89f3411fd93b22ed03d6da694e310a678c7aaff79f f89d1644d01c68a1557810fd29f6b016825daa61a46ec2c3ad7dd7008760be59 081926a06ac4f2dc622ae557381730f6854295cb744147476477128ddad6fa2c 7bfd2a9e228e24e13451e711d98d610dd6181913fff679b8351eb6c2c99d80fa 628f546f91d91c2ab47859979bd266a2b348779f76507c60defc94a9c592fc8c d79ec01440afd7eaaddc370b61e631eefac7fdde7c41d969674288b30b042774 227aaf3cdebe5ecda8c3d1c0d5e30340a4b313bca6a8d0a4aecab757f25a21e4 bc51fc445787019211e76d14a4cf555088cda6fa9250059c62868a5ee1d49348 9c165dc0edd9d1141bc7849edb66ada204bf7a63eccc33fd065fa1d9f763a310 a361f22148cdff9805f6a9e1e114765b9fb73b5b413a585beea51d61de32211e fc4e5ab56923a44b9e2935520c5ebbc1141f52734272c7c1490bcec6d7e6f72c 5775f84231b7213f7174e6c040658b97961107704e6dd69bb742797935df8f92 89f7c4ad3f059c4a6c956079bcd5ad8f107ee25f0a39c12f43fbb9911b2e9bc4 52026ce4b8b00d978644c932ce6f0a8e25d0586ff8b5c5f37d38d263ccd24234 1bd8fa4f2e184cc30adf1b33ce61aed244deb3e06e42124d2bca5cf67d80374f 0ddee4b110bea0d209107ad840f520e48e6a7684d77388db6f4c4d147707dcda 1e87ca301045da18a69391203ab6bc1da382971054c6bfc78b4b60e2049ba78d dea41c4a5093fdb53e2b3b6ca0f4a407fd0c3bd37a07745fcab47a19d940474c 57e11e68f87f21d204fb288a42470ffebf6f9579963b29ef0f87cf6cbda47749 c00cd632b506e8ecfc9424ac5a643b35ce03bb149457843ceca820c1abca0499 5531306d147c0d3e0f98d9796bcc42fd6f10d90e1e731f6da78a10b6cd52d802 50b35bc432da8b3a5b3c20be34b79486ffaeed2cc874d09a21b17eb08c2c1da8 9b7cd4e202479dc8a472490a999ccca15f54fb3ef6a09ab86a8aa0756ebc9a5e 1d8d3ada5365fbc1ff362002b50aba9a8b9239cf228c2a1732aca5df9d3234e2 24cfbecd02ffdbd33ad9ac378ff45042555e5a9079e0108213fa57e59ccc64e9 46cdc2034a74d5c1bb28a0b93b2743dee39f0601e3a8cb8511da30b3a045d771 438a66b9fbcfeabe41193a4c78240dff693d8c11bdabeea8d92ce12872467daf 439ea05906417708b712d6d979dc5a291e82b840c4e2a9807d8197aa7bbfe65c dcbe8060e2f62e1abbb518880c168acd034204dc4c889a5f86e038a8ed1d6363 ac98ef56e2bba074971846e11ef2ecebe142c9133e69cbbe6124efda3041c859 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 false +check_ring_signature 6e7b7ea886f0271884e33dc8fc1ac3e387f7f4bf91d4dca3f10e7fc1cffc2560 610d75edc2838b6fd146ad2c26843f461440a8f13922c5855a351ca9d0f637fc 1 7f5a20daab072ae9611ebc6bd4e6f909e94f2cc0d729129ae8fb662045e4fd50 63f31654a9733e4007800b18522ae2ff22583129c676eee1d51589b0e0e2ac0928df4549de3e1f7f44a3e94940b6af3c225007129145016fa15eff4074b2683c false +check_ring_signature 8a712a80581c2c6e5f7a72ad8b99849301422221790ee1ca082c9b811694becb 19eff5693c38befa84fcc2dd66cd30c6b2790f750ff6d74868292507222a21e3 217 4ea00ce3c25e45c845462e95602b0b0caed04fbc87857230fd2ed33b9306d4d6 e7675b09714d2cc7100ba012ae121dd851f8c84550dfd876566116d18d8563ca 30e83cde368210600d723ca1c65e5ff4dd7baba4a7c037c574f3c641bf91fc60 6fa5f18a92161fdb64d4c1da99df084716694c004b2b4cfc208fc715b8178466 546a83811cd6c06f0d0e096bb731d671b8a46789b22da6c7f807a23528013733 2e906caa5895eade356bf252a96905554e4780383cdaec877d9b64fd3e1c28d6 c89412a383d585f1ef3f99fe50b994c4211785985b782af1394748e794603861 b71674d40523c1bdfb72396189a42209755bb4039f23ac7b8f7e18075734501c 1119cb75f42327e7593bf976a07d0288854031cd9c2bab9db275c91adfd138e8 14144cd556ec93a7022b5b4cfc50d8462dbbd702b024522de917d9e790186832 907b664af008ed866282a70a586be5f1ac7dee275b2f68e027fc783bd4f1b758 9d68cafece0fac7ebf911176f3d81f52d55ee96336bc0ef3d47f5c869ceb4def 0a2997ad4d1b22d1a6054d2d598deb3259151a0f6e1eca5ee3a14932beae5211 3ed781d314a933b09ec20bbdbf568b5cc8a3de58cbef5e2137ebaf0cf00c2fd0 4025d382d91871eb8d6c7eb6ec064960e5a615bacaaf056de8d4a04d67b3a026 e52e4c7181b41aefae39fa418584b6bcb6e2a7ec8d85353065bc1515a8a4be6c 4ea5ebb2577a6f4b3d2ededb15b62ce47e0e67bf1757fdf056746e6d84ac2a0b 3c781cb63fb7da9fdaa32a6881fcd3f6c884d3fa8abd757eef03e77090ab6ab2 4a5154684f5df52b9ae927ff7092af4049ab0e7ac8a8144ac16160df8d6826cb 18d342650783c9f0987264574e19b1a615a9efa27d0d32b68f97baed51e0fc35 85a1a126f964fc727ec50652a94e02ce5993d0b06977fec4b83870b2c64bbde9 76259109ad7683743efa7248daae602c989d59ef616d156b29d701938e7d3bdb ef98a87042705fed5f4ca46507ccc830c3e57043576b68355bdb097ff56c2e59 f09117ab6c937f34eee2ae82c38b5d401cc1e957ed81115470b76e3f1a6ff1ed 743ba95a983b5262687a46da24d3481ba6991444d5a0e3503d4fc4238efda916 93d4ce941c4955b2f0d12c0fe537726cf907d42455232243a77bf64e3447888d 8fdbbf291bb92124ac03fb6f70dfa55c7f469f0f3d1a7a1cbb25fbd1b4c416f7 2f64bfdcdcad6716b2e58dfad4e0e765d9f98f689cdf7bcd012b73874512d409 2d41b837205713b54e89fc1cbb4b904b8c0c57e2e0d9c6c799b6a745921476a3 5f33d1777ee6b4a8ad5a4261c1d9cc39fd28db620ea38beb25289c4b5f4a1412 dd00cefc5ef16d2bc23d1d2a630622ee85bf9b8d11b8dc02a49166f4f2adbe42 375cdaa4e07174430c4150a4c58d7b8e2fa539eb9aed772ffac04001299300cb 1f5180fb1d6a1baa138ca6bad9796248c161db49d8ba30f50362f291b3e0187e 3a92868e74c01a32111e86a3b657b6331f3bf9f6e4c865a5be30154fa67718f0 ea86c14046f10a449a82c4562a7be39673ace96313d2e20bb4efceed618babae c6b4ea311d7845b282ff45d530e27c43d3899f6bd961d21381384564b9630e05 1ff10677a44f6dc04d05b602c48e26ca0f2e8f911685b619c03489bfdf351827 1f9a7ac43ca21bea08151fbe39e25407e4215c0ba689093e43f3e32e0fd830fe 89b3f9a953a7136c5ad75e8e9d5d35a8e23fd8fccd084e500405f71b53084aa1 9f29bf0bc81d6b3ad2f697bf26dd87e8e376c85ff7ce4d4448fdafeaa3a1c937 0c5eed015cf6d481caf3e565a8894cd4166742dcf3a5bfd834508d090f066319 e5d353182ccd8f9247f22219bbc7f54ebf3589475a1748980ee2199b8737e169 6c4898e89bdaefbf42ad6de8130ae14100a1e6216d21f2aeac8fb2782d1a6e78 bdaff671eb42cb41bf07da72bb61a00a85b576b50a1d56a3ea7a7708c34fe70f 20efbcb6c8c86a9f0ee27739c01421c9d855e580e81da0fd022cf56d558efa55 504801db0572bccfb8e86a0736e31c3797bd7565d29389fc5bae369993f7865c 84f0ed907c449faa22bba30fc2c773922948d4f6f5bb3071745788a66fdd78bd b01254f8a1d2dbd979e8219ed5861897f4ba58244ddd3230dc89b33290c444ee 4a80d55d9fbf51d99c7f3ee09b93bd3866aa53f15b5b2ae1307f8aa84f22ed03 42dfe824646ebdc3d52ffc6f8d23cadd1e9015bebba65d91cdda603e0e7ba205 9bea4ad7f2f9eeb783e91ac51b4a8f307a8d8bc21293cac8a3cee5e05a55bfe3 cc870f3ce56a0eecd49f0c179cec8611cbe9da73f134fbba5ce2d51dd35eac86 d19532e5501c2933b07b165d07199e0d9e1a2ba7813ab214cd1a5ca9ecdaef33 2d132a914618ddf19f0053012460170affca0ae5d17a4aabbb0ca0e10f6de0a3 4aa48a7d1e2aca5feb74e4c283ee91b19f1d1de9347736eeb499e23f6c223d51 45877b1be39731400e377e822d794cac12af56cb148d8b1c40970684141fff9f d5f164504a696f944c99e5964f4899b5ea295591c6a805b1075864fe891d1dd7 1a58645fde42937e58e408ba9c486826fa5cc1a3b4c6d5bc2707d0500a214f71 b3046604e6e09f29a165c69901def705878a186c8e924285f8182c3dcb8df3de ba9a07bae47e61aa94540af665b216b346b96006aae3cd82c2259c7265c52dd7 879e9e536b8854c7dfe96c9b6f0f6b061b44b18e5cb1b326dd61f4d689a33836 8e6bab8aab45ad9776e3528a62623ee781b8cc9019f655124f0e109c9f68bede 22fbeed255e2c4ca6e4f4baf723bb3b5b6b2ff6fc1ddc4b7593e2650a6884733 7b581e39b83b97bd9437564d26d72cc0efefa8629c6af6bbf6f76f064f8b38f7 e81dcec143dbeeb90ff8d96d3308e57e5a18de269419ce10a74f91b42fe2eb4d f12fabfaf879801b9e4c8376b999affe81890e79af219e042278f3b39d2666b2 4f4ef108b94ded532f059d68a4209872cda5dacc2f325ca0380d9891ca661b65 3b4c6ae481355f0062f41f0f7453e29edf655e1a71ead2f4de0498297f0d7036 3e6e3a9a1ce1c3576db571857e3c5d91c63cfab3d2290e59fc7319e38f06c2ea 2bd15b746dc0251ff4d0b5446ed2d3f84a3b2cc79387f63597039e5ac33041cf d92fa0d25c8c66ad1c24bd492d3b191286d20bdff302711e141c6447cc08f3b3 9abbea980a3657f75f4ecc1f67b00e5d0aa15769b03e9ce19d8633eac7c5cdf0 333b41694f7600f6ee624ef087589745de098af744c965d2893e21deb382b768 d646fca02253c58c97c7bf4ef3504657efef8d5c33d480eac4eb518c07cf38f3 31375eb47f2003cad6bc0d3e68b0ecd258099ab5f1246c5ef87dd27c61e8fdac d694ce7217173bc2ea3f7e4d0432aa4f8239ce67949f7d37731519e6e1503fcb 568b53cd0498c34a4d05eeba04c114787fd0eb64aff3ca11957c49d45e6b4025 6191d5f5fcb56872c5fe2136c697b5251268fc7ac0b0b295e63c50c6d611ad3f f7d617d27d206467ec7698225dbec6b88837f0a4adc62e01243d005e5cf9df3d 9586ddde975e4e7a1f5d192074d66b52b20b7f9c0f880da6d3371528e7d79877 a07f897cc86ce717909795b3557a7efa3b3908c914da5880b60a2bcc16f14019 bfbb81e7bfa914a0c02f3c34a2eb8a69eafd29c649eccef7ed9e7488c79512ec db1ca2d183e8cb2257b0d6a070d98c857e5c25426c9d27ec20dfd627b61d31b8 d9a1b92863e717c6964de3f2c3a9c89ea1b9d2c2dbc7b257764fb23009253dfa aed15c2bde7f3deb0914565d8d331eda7399899aedac8b6849daa8d9083eb6d4 f8e0e46717740cdbe3faf66ff9f9ef86884da6ef338c4f8be2df1e0ddac54124 ebaf591c68949ee834af9b9b35baa8603c04cda4f945e021024ac4bdc54311fa 2186f7743efa5a1652932cb53fdb8a9243a626641d8fcd7e16372acfa9a8c19d c00f9b8e655f7cb3db58831b88ace5520311273a9d5b4c7c830473e82863ce59 34abd38423f4a5ba99bb6e835248320573a4468eb09fa23e24bf0e576cf454b1 8eaa54ee3f37b903e1e6b2c78d44dbc8d0e09371c6d81cf65e8ba489ee28f48d 5746064fbd7521fba25917d8d80c06814440adb5d29530c813abf7fda4ee5e19 356babab8e048494f44550c3ecdb9c209eb5df0e9bd7b2b9cfda61a8f5af4606 dcc044f9718b3877083c64fe885b2a404ed2917a5a5fbf1eaa1415b073aa4dcb da8d65a3b886c5fa7bca282154ebee52f55c22c31370f11d5356c5955db8916b 8a1b1023d7fd8802380315357b92c29589b3cf03d64e1e921304d02c2f9cf670 72594fcdffb0ab1b30de2b6a104057b5f010e1c60a344ca8e898e68270fec760 1992e7e941586618cf408127a0677b5b55c1a77b45433398c87a7864193e548c ac705a0f0ef1a0308e5467bf3970b42ec62306a19d767770e32b9d18dc59e0b0 31970eb2c177c84aa9f2a75b9065573d5dcc437318e7b39acf99324f22a6cba3 6b8df112d8b3841c0c390e0494c81521fb1bdbe251a7615fd15bfdced4313bdf c1e684d1a5a313a4ad030f259c114a7b17c1c6c7fed39343e979db4aee1a726e 88a37c55e648ead961d30a9744840fbb8708bdfebf19d897f1b99cfdc427b095 88132d63485740e9f8b0efac8514ef6bc9d33f3d23f443de7554f2bc135bf322 d5ccbfea27456205ba172756f088e5df187a9206d433e438339ac25c989339e8 63f83f5e99d0b69f62ef749fbd5a6ce871bf138ccef57737da102409b3b22f03 176b9667b59895a8af8a0e8c02766e46b94655f59944e36d0b5839571576847d ad1b1c8c91d23d9c3bd523e48034313f020b6af1e3febf70bdca9e56efb13bc0 06f6bb90c3871d1f7f60db3a924dc71f8af7d1a3fb32df13ca2fc85e7c4cdcd0 772d39850ec6e7c96f54b132bca5642db737d1cfcd1675675ae5aace34f533c1 07a4b2e99a33205623de60d67975b96d98bb5e7292a556b849ae1c90301f3ffb d47d61b6372a153f6c139b01ef59ee8e378df2f3063e4dd702003ef7e1c0bce8 8d5a85345350753b382a72e997c6a3ff4092d119f627041d05bc9a67c2ad0c4a b22c995a99d231aa9bf432c1a82ecd00c82bfbf4ebeede281c7e2f7c6901bc8e 94a4fd3400bd348c6cb2eb489709709fadb3488430fd203654d0935a204e3125 189c1b07ee52013f06964213f8e1561b38c298c6f61e4ebef493238a661b4f58 c8cc4b5bddeaa4600c7f9778f30f56d4864295b7cbc3b20b9baac0344d6aa6cd 595672ecd3abbae160077295b04fbe6b7101d17fc83fe03c9201f55e5284cbc3 d6a29d2c5f11974ed61403756b27cce0d34774f1af812c08890110cf94f3aa9e ebd900c7754eaba20474881e3d04e55c9970a2c3dac4970639585a6109368b00 35f1b57d507b52254abf99f0f806cd7c996f4ef617bbb5a8ff203d2f3fdd872b 81f95f3cb4072d7f3b0f5e5afdf7120c594565bca4d3e9add7cc76a196fba0d6 a34cd82715bf94b80c11653c1ffdd5dfa0cf6cc2347e0ad554807da767fe44a6 2510e8899ecf750a58de2410f3f165f08f5abc30c65420b691c351729fd3d288 9e5b9eba4fd6f748a1c56f6d25ac8a52d27032873f08329ab8bcf0171e74f489 d178c8e32f969746f795ca37ab48b7f67ab194680cebf814fb6e02d9484aabc2 f9094aa45c1e78302ffa0038e9b26bdeb0fe0d57b28dbe83a13ee06ece81b3a8 4b70695db9b450051b36ebd4405f19286e05e5bbfe71df6471b15099a73b104a 7efbd879d58e7433f9d226b995ada2fd6a774f84b46d3237b2f177d5d811f0e4 f3f311a555809b4ffe188c66914fab7ed6ae02ec3741b256f0610bdc36242e2a c83fa0d40354f7834264a0188f42d7df2b5109cad1e24ffc60ea95b679a5c4f6 40a5ba65226c6aea04474b4904a4e71e1fa7c414a06a505c6ea1f5ffd85aa507 481dc8fadf0ffdef29cd3d9944857299cff21e408bb7f295a3a6c4b0033cec37 78e32a6811e53d150d2186cad396da137982ae2e89641d684f172bae35bc9483 efc712ee0007cadc16e6771c72d8938f2db4b9e59987eee85a691563ad877832 54fca588a479c631943e89d80162cf78da07bd834dca1c43874cc6d3a45ea48b 5c993198bd208cc062938fd38382bf6873f34d3b731b367717c3825f0977875b 5a60d4e1f63be651be933bf0affd2ec9f662c726a10d107e2340874fc0e2d9f7 d87415e5edbc86a4f693e130adad74c1cb7e09ad22a1d9f5c143234ec5530574 552bb5ee4ddff6955b6ada69d9ab4473cb8c50dd06ea3b918668eb9b3635bd2d f52f6222a3c6f64675625b0512effadbe48a0a392d98de15dceea5b20f62b0f8 cfd4e7f1cdcf469989331c40e4713f874d05c5ae13ec0f04baba75cdb1c5ca52 04d9a11b79c7d20bb4663eba94ab1d35149f7e9df1fe2c8c9fc380820df4264c cb4e0a3ca6fc3d0c373a829c464c7b6e75d53d4b825b1d46c34c119acdeec3ea ee6bbaa6811789af6c6662bd2dbcbc8a44c0b750a5d56b02a4fd1d539d10e7f9 1717b7578141cbafa446190da938055c89ef71cfbc8e1d4d9e7f9ffc73c642ee eeddaec694768503ca4f0d1c94c559f756999ca74dee6eb3d53ee47f22e51064 904c37bb6d942e3eb8aa41ba0534d1ae7c9d71e1956f55466d70c29d6216259d df064572723c0175a795101fc9ee0d3127d0f3edca38ad4aa904136eac7fed1f 65e6ba66d3b8243b3ae55b613e769637f0b25343c1b781263869c02cd947805d 05c0cb891cbbe9aa0f537feb7086b5bbd4120735715ec454ca0820f7a2bf9a12 5e60170ab0f49fe21b20112314adf2ad600e2b383faa56bade852cb06dca4d21 c672a7e4cbfccd0967a5ad8cd71d55ddfa891d7c5cd7c12c0fd0f55508fda5e5 6f1fbdb6ffa7cdb87c6503ff432d210a19e36a5f435e4fbfd132de94a3e55502 c27fb033e4649cdf9748f29c3a6f1149e1cb5396cc6e7fe95d7b622b5fbe71f8 7a2e2a5fe61935b339fcb97a97e5eb1958a920100853c0e7a17b5f8de39f0e01 44ec9e0c2fe1452a382d717292fe321ae79da5f7a14faec7989ed0e200d76042 f540fa0995710ffbda6c3b0179c9636480646285ce600bd7e4769dc431c37b93 edcd552d1c2621e3f1e63bd8f276a8d9dd28983b57fa8316ea76ddc53564ce95 19297e39b267afdbd925d87c290aff154d892a4ada043a7e815881ae4470675b 0756e90412bd820da5d5507103aa1eeccfc8ede5e212bf91c95ba9f10fafb52f 38d02b1f2fef1a1ea57a43044519ad1ee241a5dfee3710cfaefe40a3f3947aff e54cd6c96db095d5fdc0cdf4adf3747dc4811acbbe7f6ee384aecf5f7ac7c32a 2de5e4f5b1e01ab42283b181014bd65b15657a2df70c3dacafe632d6ba6e3418 81e90122e30712b20c28f8e4cbd5f5a36be495361238536f0483fba3fc6d9763 ccc98da48be44b42c04cd5b033224bba73f50ee3117dc20ff3adafba884c2e0b 2977c7a0513ee643567434c434e8426ef7ba5e7d3787b2b83648834877231b06 73449d3f4019fe8cb47482854f1ae93a568a3f63bb11c697aed5395393c6abd3 9b12ee4e8966700751b773014834ba9b2dd314dc5fd76f647003c91aa09c427a 222ee8cba310fe4ca1db78b8c14327f343f123efbfedad7b4b57b206449aef8a 20ef9fb665392d96b6871263db599b870e424ad2f6dedca03a876c70c0f3651e 8f1f090bb444ff7296096f9bd090996a9d02463c46d695301991bcdecf6cff67 a743abeb935f0bb2509b4669688f470504d035c1a8d836241a62b2b5e93330da 3c251fddbf4ff2830f936cf47e1da0b7f0f734298c11458047a87170bbd09c86 19de48de2bfa1ad6cf0371f8c6e3e7ec8e84194ad55370c19e66eaaf0db1c52f 40335c05d009eb33394acc930e46e7d356c33bde1057722dee9f9e90cbb0c199 0ef12d0270d6378571d2fa0dad5ce0db0eff6c521ad6e685eca2805b716770e2 3d91fc69afb2a2d7eeabdf126de48646db4932695c63221ac6daa8a51a417bd2 407598e3beb1ea3183474bab723fce159e97b649e188c257032399161ef3fe96 0eac8691b0e4f9a55934c7df535c46d77ccf0bccd31dee0ce1de02b4de2014b8 2cca28d40f93a0ae902c5c08de0d0cf0ef41113ffe41dea3a98a8fc77d0c05dc 236021d333ae9bcd8b9850e8292bb8b3f51030749267ba4f00469d575f086737 59f81adf40235fc4f02de6bd76ab3beba405857e1736832c961a38369132417f f2d017920a9394dff9df4bf3c65841a34a8881286b609811efb051d85368955d 6c9af8488df4d8f395dfcab0a3022af9d21ce979dc6844e8892c12f926a55fcd c5258889c4d503c7144c39cfaedbb22a00c03a879a5e3658cbbc1173368ab4c5 a00e6fe0fb9b7bae8f23588de082221afbb93ab15ff5b23363060cff2efb35da 8f202b8700ee4e354fd04179b619256ac175a176527854d76f5d9cf68402683e 4351dd866a0e36d0baeee7964a3505b693086d896889f94cc81292a7fcea5e88 81b3c5b0da17045771146d9511ca6aa742082f7aa4939f9fd62f5e5f21b57555 54f2238bfd9f909f208a94460a4bd26744c3f9f76a6c13d44630327546a7420b 25404dca648c59751e9e789ae6224dac8654cf36e179757d0378e51f52618832 5367c0c2649324280ae296e6ee5eac8798f2601998d82988001af2346cfb7272 0c7b5fb1106db006a39245a1cf8b24611917b6d8baf672984ddc5af10ddf030c 44606802fe0c1ffa54a3047702dd0f985efe23d1dcc8a98b8d4c9a4bbd6d358b 9f702feda51f328a1bd2e5b3c752ea668b4734fb7c53fbef518e263016fd0165 25f7bdcd7180b1757df76a21b6de94a3018db8ed726e85d838529b4b0b769aa5 ec956d1acbadc976eb6dd7b003267f7ef2b590aa0ab7e786b3a6750df1220280 62ef6001a1d18d2a31971ab0665cf8c3ac1d76b8ba0cc45d471a7c55c433506f a85f7793a522f18cef9c44e0d61172f0eb71e445ca3e810f72fdab1f07168d0c 175391427f781e0e9286124c8bd8b3693b550e803038a479e82775ea728b9060 082c10c22b8e4454b58fc1a3207bed980e987b291488656a1a582170049a56a5 da7cdd3419e051afbc33367a99c7bb1975f79c51c560251832735ea12ee15d8b 702526fd15607604129aac368079974105a4a183267e04e8e7dddacac26dcf51 2e7e20f0b19b697c5ae8dca0829e502a62cc2c98d9a573b8f5ceb8bf2f5b9b1a 08c73b7be62b5ed8b4628f149a3636b7f73bbb6cb4a6459effc1a3f7122b12a1 1a260d2f556a42d6655878c37b97bef17ccad98de05631f7b0f47b1cb1458f5e 54fcc028db9168a1b05f84dc38db2cb9a277db4efd4ac2353f689929bd9d90f8 ce3f69271d9bb6d9ac3a77f5ce74f8aa108448543e9d088186a5f7da68945962 509bc2eba10408b67443dcf0c9c72f2194fb230ad20be96cee8b034670c47335 53ed81d17abde6987c799706460e22736d994ddb28fece8a11d620cf220bd40c 4bfd321b0cf1bf2d3a4e0293d75a996613d033827d9d7b2169e4147afe8b1799 dca9cd897c1e499a6e23da9504ebe124456e746a0bffa94d36d1eefc61d21265 45ddd34291c6970bc4dc7af1ebd02568b9e45f600d2432d8971e2d4b4cabf9f6 545c7b79e57c22b66c6d82208c8844bfea2e411a8d9a490e0c2799f538798090 f8c40e67968bb40fb5c318f724002b1be85918da47e111a834a6b79e3ca0f5db 1cea5a15f610493d2ddefd6889165d8b023292e6f4b2b5a835c63071850b6a0b 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 true +check_ring_signature 044907f63d2b493b608e2c1d87b80c95f25c47ace1ac4a1a95ca9339d930051f 4bd5496222261e73c345f4e8a3f734703b8930ee82ef837ca60ed101c1175aa8 8 7eee0265f020e20ce2a6df8b3e7ca5292eaed46319d9136ce619aaecceba3606 2425f48a50f2221c5b2fa8e6a0c94a90fa2135e382b0ca0c689da12719217089 5a4716010d44396e754b0f48468871abe8a3b0411a962b901010803af728ac8d b5569efa5900b9472c298e6c2e28da94134635df7aca1cf4e9449856bf836e75 fc67fb7fa15cc88ce34e74e2ec6f81597053ed5faeecac6a8da89af3eadd1547 d932ce703020c5c28068d12768862caeed7a8786ab6641f8997b5f910ad77d69 f05c1ba4427cd321090aa79375be08c0d76d79563556952716d5d094ace0d533 a1536426b60d135a2db353ae27431d09404f990c5d02f5d19e46afad00b98c95 58c81e73c8a573e890bf4c34bcb801c68ac33b5053cad3e9033a42151f274453f3ce83c813c3900a721d3c0a27c531f4f4b79550067c5034714743eadac726058e41c29f15be50163234b95226db5740eaea3924f4ee0558656a85b6d75aca089971e47bf07bca1fa7f04b2f80f781ca2b139ff258521405809758fa32abbb01b69e0cc1b1f72480e2efca8fb26f410ea801777d3edf937d70e964ff31e85d0f7aa632274966553ca34a83001d9374aac42ba3ff2851d5b21a641e82b72f630f06a9d00d73b9ea7751f6bfc04d044f10c94219108dc40cf45088bbbe5b44bd077a77ec0b3b844b796c4ceda309f51e2d08bb213f005a0503eb1541e85b4bf80712c01315cd2b92d08ba54598f4d3c3245503009e7fadfede964d3032ef3a43140c10e1e95c40f03e2312cb06eb5ed478debe98c8cb3fbd3f8455a1ae7455a90bd3720eb84349ae7e0cf1a12d5ab8d3c52fb0bf7d9390bf8d3808df92f3d87c01007b6f0dc23f720d0d6f4ec7299656cb6178f2f9f3a1d2055a920ed99b86d904170114e7713359df26885f489264b1d9869d9a8c6b35345a8975818b32fc020154f1a34eafa62ea971cbe140a4f8c17f52f6936b54d62efb5448fbf309e07e006d26da9e21c68bafb2e7cc6614feeb747963c18134472718fc44c97ab9390d07587d95891c369253011bf4af15951507447b812636c6bbfe9c4f7c804ac79304 false +check_ring_signature 2905367904f07955ae818844435b271b35cc4882468878470bc28baf02c2d808 5471f3f43cf1ad5fd8a47bb7fe186865f66d9ade44d0345bc4548b0aed09a26c 125 24bff13a8721e479e0c4bf79adaee5672b05a4f153f1d4ec5264b80c334ad736 55a6e07963d6af73273dbd782944d07d0c4bba169dadf7a31baeee381aeeb26e 75b29b1eef748052159ea90d3ab34f26d2326217320bdd452ed5b5b50f339082 bc86507e37abdc088f24a8ff8c5e3673798973829a6e98565e895c5d5883a0ea 12661d44ef3f4cad053f3f329b81a9f21b8adc4abb01165977ad1b3cfd6bab26 bc7d4c3fd7138881b61fd298e1e9a160e3a0cc582e0874647c45fdf9bac8c458 0241ffc34ec7a643e20c0073a2e502992b06d228a5911e210232a95c7965db36 1f14c062310b4be1657fec6891c1585c79d69f9e4cc79e8378d776ad67f56092 77aed6dd3e0e5b9bc4849715e4266f132294df75ff195f7ca997f58845ff77b9 c5299ccd91cbff1bed15d98f8ac64d674ab4a386a35c6512a964d1b1f9a0ed60 c996dcde2bd4be1426f46d683932a471ab701970b3714e5d8e7976d494bf9f92 4801717d85df4683dfa1bb957d7344ac1f40802ccd1c0bb80256178f1285852e 9f53619be0773cad992f9f7e56d9c59ca9d6a03ee6b85fae10cf1718b2b771aa 406ce327cfa6d038dd98603ae2d96b938699110a37e51118b92aa59cc180540b 689140e9d062ca64783eaffd73b3008226746c69ef59be2e36297f1afa9b12b5 a841668ab922fa2d87900b94a45e932a89e76e282e21ba69536458bfdc05b4c4 79c3dfc6962e56fc6ae32baad4366d3acb1d3a28e4f622489e8cd123e0399a5f 388297d9ad36b169398737f894d65449001288cdc4d69736eca8b1c3ca45e55c fb966b8bd6f7c6c1a6265aefaeb215b0d9c97c529f32d0c3ffa6966ee79cc5be 073547488bd044c5e3b7639bb75ff89ebe2e3331bae1b8e6769d6d32188b257d 2b68f1cdce7b126eedf4a0d07b368365adbe35c663a7a5c646447819d5e5cf13 c32d0786a6d79c950350bd20753f1efc4651c78f508294d254c0636ab2e56806 f09fe77a551bcca1dafb3ab2f870163fc2ce5bbeaf75a3fbc39de9eb14b11f83 f9d0df85f66890e1d433d1d81155173a3cdab4b91baac13d9877230e8bbedee7 1f750cbe611878ee4f38883c6389377b93ca0572c3993d77541e0156df7b2980 6f798c4a4b7a47c3ff250ea3f3f64f7c254029c4d7f625f36802109766764e9f acc4af369fda3efc8c5978589ab59da3c4cedea1f073d54b57d87e8438853e24 c0b2fa23f38e2bba92f33fd216037fe5789ffa231450ad45bcd49e405ad9c443 77303205d2863a148df7b2fb64d00242a913aa9c98d1fce51421c7e78ffb0fba 85702ce5d695b03c25031a192c9ec9b4088be3be2d29bf57d710d732519ae118 7a103a765c72d1d606cdc7de9c182b93c429e9cd0687bfe40fb147b616610e24 5371e7f647d307ea1383315fe79387baa48156577977ef9947aaa63c7adaf094 a3cec0b51f79a4bbdb2d470c204bfaf294d9b340314cb640d0f828acf2a1208f b471b5aaa529a235f2cbf34efffc692adc1069a2d5d1264fe59ef83c3f4b67de 01d073753f5514e19948427dd53e42318062f8a8e0b5b2cea5bd877550ee0c76 a0b04015112e558c98270e6ce9986a96182f991d798988da08a680a482fd47d6 e9f5b2d2d270115c03d5b43317f7b12383b53eb8f24990080a862ad849404fcc f7313690ae6d1125d2a4fea52782b8f85d8c64f95f8466a96c02b5f8d5681372 ae032415ffd86571296c0bb28faba1192d046498877cc8959036c7fea985630b 68c81ebfadf0fb13d49fd736ada9bb90fa38e57b2649af9fbbdf7e7b044a28e0 edcfffb0e82875205de3cf038764e846645a5cdd89d1f6d312208cc24f277311 83b6adc5e92aa5768c4e855193a333be259be457201dcc2cb98f761b5aed5093 0524a07895342e91f3c8481c0ac037e2feef4d141a2721d7bb1d72aa920bcd86 d919391ad399f66718673f875ce052dc2ef4596e323404706c023aa237d7fcc3 a9f9f70e327006e10ee5e0991e0b1e39d3dca3e7207fb9445b0867fd057e2093 5ab181a35cb4d6286bb402366913a1c885e9fb6cb178e8837f935152c1641c22 0a38ef48df0de0f892b312b5e273a7649c1b43d1ab056c7e3cd18bef632c266d 1ae23681b9c600f6a06564fe63cfcfda034c4b1d8786c81241ab50d243693c18 e4f1f9742271bf73621cf6a3585adb435bf5acbdd40d33224028319d2fb72d27 bed937714b17d9e5fd14de9fcedad98533c6144c833fb341e733c1e983bf40aa 55ed557d8744740a41166f141f0adc28580ad06d2b5d28ef24fdd48ac00c9415 483bec922fb31cf297540112deb1462b7d6cbecdb7b4015aac630a67c8f29328 78577804bd6d7d8dbd10a835be03c7435fc1403351e7ed2a13ce1a52f50a2650 aff4dd460a3bd67e464ad9af2b2b04a9d6c0795e5434deec47c72f550ec4f14d 70a0025545601a21df9ad1409deec2e4fc73dc657185076e986a33546440754d f60f20ae0122d171f88b958519c5c4edd3f5fe61dcc16d9a1cd386d7632c630c 93211431b8e849b0e874dfc367b24673b389bd3018fc3e6d87f95185147044ad 9449dfca120ce9e6d1afc956e71a1313ceb3738a3177e2785d13e6f9b6f5e324 765442f06e6895fc8cca0ecec4fd659a255de151bbc60e2aa47d4893fc4bb2a7 780cd06305c07d9c43f11b82f33bf13aff63e4b999ea74f23ab2a84dd8be7d7f ecb7f3929e6d3f85207c8c42f3f40d587ac0d88b61636bc570403da967ac13c9 30cb165e4007a7a919a732bf3b2b1df924961f921d7ad4de94ea25a77f9174e6 ed097b0ae4646f1c95749008870486ae82efdd34236f21af51cc8c078dfc2aef d96232bb0078969f29e3f62978937821c8052f992de7492be36d7bee4234d651 bf1ef2f34fef9028244335a51acd3316ff8064fcc3afaffedfe3d3bd421e6cde 512c977217c244af97ac88702ad3e67a136cc933cd7406ed88d911e223ad0231 cb088a4f84cf5e80fe19f0222db83a8ad4c96ce586f39e4ba0901c577facce15 034934f44ce6b0b6e249a333941d2bafa0838110ea9a67611f9112d813bedd8d 9351650ea079c181263ce37f5e3a0b45beccc70668eaa02aab166c57ed8aa476 09ce3aacc2976e2137813b607904c59ea86e9e048a6f1ffa6231b0cf1d5168ec d1c4c9accd3d82c52963118f84652a8b05d18731e26ed226c9b756a4a05dcaf1 f6a31329446a18b1c7371aaf1f3092ffafe93614392133c4635477985324e622 c85f493e0f38bfdf2e83a4dd70b2f027afef291effbb42e9f0e4a0a48c628e60 7dff4c04c45fb746fdeee2b6a4833ba28c4ee29e8f0f393d2e0a5408e869b7ff 460a271653be0d335ae2610c113e7e5d41ded303795b2ce962b5e87ac28b6307 6c5abee93cd0d034b7da83009d6ba5d7cc4606b21cc7f4fffd61460b8656d633 ac2832bf4d75acdf885c47270c2c7a279500fce8a4c94d38c2daa4dbb19508b0 654b03c1685eb29f8bbffdc3c7485820c409fe2a7533c9c2b6fc071484deb025 873983ea91bc46c0431ea8324fbdccc05fa53dc5aa7914335324dbfda1df8162 a001db70a42002cb96db9aa4a9cfa1e2dc78c7e4cb55115a34d13fafd489a66e 8a7f2baaef4b1612cdbb2f163c9d87e81dc865c0da4666f762dea6a58371e7a9 77752b91709f33f8bbc727799c3aa59ce7d26662ff65daa2c56bd2cec5889b56 a58a27493de129110d62ca707b17d6a9c35dbf1abb7f033dc2288c443ff1c8df f6fa73b4cbd06eddf5fb9b54609f4cd83247f231b64674fa98c8f78ce5edfed5 dbc2e960ea1504cb6270c1a329c831bebce0bd3a21c0c0c5d96324553eda1334 d616d3e0dc5cde60f0acd053ed42ea309c9e7512ebf33fc6babff2f87d05b5ec 07e51d281ebe37ee71d9e3c10ddb6b3d1983947fbf3819e8aa067f951960506a 6033ad06cfe4f5400c0cc5b734ba8aa26b26032ded0e95f75e5470dc0e9807d9 293bc2581ab23eca1b4354f0623d66dbe74548dbdcef608d3ad459da5c13e6ab 238d4f52437cc8c98ed13b2f8e9261a13d31c80c26457843df2b0db09d2b23fe 437746184ee78c24733c0ad66f5d13c6a28104e27d6c7d8f51fbcb76e5bdd0f3 5aa8eb11ef4426f767e4f20756b1f76a6ba36bc9d421de97230fe36305601080 ad890d34e53b56914bae085412afdc4cc1bec0db562be5f5f3aab4c7912a3301 9b823cd77795e88e9688a27288a4e048e1d44981cb8297d0c08a3655595f6f3b 9ed938f5872056245186354f656125efb21946dcf31756cbb5bc7c0c94153c9f 21d4411933ef8c914645e8f8fb30f6cd86ec0045b264cd862bd6fc912aa05eca 953f689ccd889992176ad0dcf1e56c4045d8797aebc11e0840329037c060ea3a d044c3df0ef59c426481e799222d02720380756ebd1e2c9d47d7ea32207bb97b 70b08d1fb213e7120d74a977faf19895eef6b9bcbe6fc37e7efeae1d3d918c5d 53802055e058b6887a182dc66a73ec421b42c07a21cc041340a47c89ad5d3412 fb5fe089c2689e8eac6139f26ae0db9c19be9adee166ebc65a8885cfe0ea3821 2c8b9e03dfca92ac8408263624c68baf80f42e6d5785d604cd596d7c5f70b338 8ab262f46548be149da8e35da157f2a20f7bfc9f1c36da46921d5328d8b22427 a1f9421b8485b0e9805f0fe56e144dd7c4181fc3e80f9ae36f80cc7ac54b85e7 f30fe136998aae2e385af866afb36248ea6b5b464b59742bbe43e7f334290ca0 1599677ed07f3db69959b3d14c3792e97a82933f158ba4d2e585943074fb7a91 7d6cb184c2b8892119265b3aa882c56dcb835334cf915647c68bdd8520f71b5e df553c31d718533342fb0bfa975b3c91d89db0e80d317efe306ef5341c410dca 8bc5d24dfdac485167671b6762aaf74aa21ea437f4af4a1a12539dd868ca76d1 e0fd2d50d88df121a2039eb5c01f13d277ac83c2855633f55d888f517125b5b2 c0b976dbab7874c35a9064d8d23457b1e6ff3c1ed4ed3fddae24fa2ea5cc9b7d 42c891214910b8628a90d83bcc1563ca3f73d7547d99dfe79a474c75204295a2 d7ff843ce324f302b17425737445ec70197ca44aea6753ebdaf1102fe56bf590 bfec250a04cc336d716b0aa605d41ec0a520584a48d7f087c958176ebcb6f917 5ea5d874f63e43af9530701ad98292d269deaaadc1ddf0026acb4611c3c966f9 0237ea68baebacc88b807e92b5b24b89ba7416bb4c291080b7741e681c33d9e7 40dccaa35e9cdcbc9f36081963f0569e0afc393984bedfede9b9cbf6158b619f 2f892e10b56c16b3c6f2141062c4d4157c184411998260d65f6d32698d48abc8 233400019a89a8092176ea03925f2c418d7d461a33524062783e8b238f0313dd 15aee9d64d73e2891460fa9263be3efb3d359314ab33556666671c8d83d135d1 9a45e92b04b11e80e22505e7b3ad0e95b04ee4cf8ce19736761d37f2b6373d21 3e7d283c255beb7f4d930ebc64a4812144f25f211b2984a1f166be0f877d30c7 53cd8e98edd3beadad4e89eb2fe11e50ea0b0c4aa866749c702f73d667920a43 ec04d3a98fcb55034f04ef0721a05c232b953f9040821bad6a8eb77e36b31647 60c9fce71c95f127e3700042428a5aa3d2cb5e3cbbc776ab9e31ba9a41f9d14c 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 true +check_ring_signature 05456b761b894503eefbf94f666ba089c73ce567acf3e96793d648deff6cc7cb 9bd537aadc7cf3584b89cae70e0c664c1859c01becac9f649cb1034998658cc8 1 22c90464db2e089334a2ee6393bbf2ddf556e5217fdaaccaaf24aca4a952153a 8364bc2b4fe6bd3f37c59f4b740c089cf4958bf437ef5fcc97687257c70a6a08cebdd402dafe49f07f0b9ef4aa2eaad78e66c58370eb00a01af32e39e2f3dd07 true +check_ring_signature b12dd0992e9da6e78e786f7af05b64271d29b78f8ec1f037aad6ae8388d7311b e4bf2d087da68d651d9608c31be6402e4c32979bcdf2c939583fd5259522ffdf 37 fcfc5278dbb5abfaf3143a0754feb75eaab47cf204a9d1c47577551e14b12c0a bc7dc2c818a3ce30b8499490acc13522c3cf418716f5df2206e83e652fd60b90 770b7ef51c25222ea7d0ad23b0b2c0fc91b45d547ecebb66f4fa5040f0169ec8 bae007369337ae40294331135d2c3e3b65609bfd28c6be657fb75b60df99638d 124e522479bc6edb8a17fcb242b4009594a1dbcd1e6edb41e1f8b58c3dbca9e7 080136cb3cf3064f9709d3624349104d507c2b480638e54d1487b055504d094a 6bf45e1cd43f29a9fae608a081d17294dd2e0b9277a47433cd0f95cf0385a42a ac0bfb0e8b6f8de8c8ebb0fb70eb0bd4577e1e1cc06b215e5fd6319567658f3d d6a7100a010c1a029c677d0fe8be24877b6051b97f15dd19c2f6b710bab30390 7c9ef9a5907f5ed29e18db16c6326ba701f5be5abae539293eb811623a17f9fd 4565ebd18eeb125fea4a5904af9f2941244bc7b8299479ad4bca0b46a40b3318 9d6b810a8861b779fac59de7d2450912d08870b50784b4a0d2432491be2022bb 0869ca0c5c5c2f8d5a643d58f991459804cb0242ff95e0b6890e2b81b3bdd53f 266caadf399b77231b141577346daf8aad3b9ff28b46840ef9abf82ba26c1812 abeab35326179fbb39bae5ff4f88bfad5aeaf45657e6592e5834a9474cb64ea4 34c5ca2bcc54f251a3517300f56cb321c626ca3c2002da50f0afad0d5018c035 35d7443ae4edf60200d7b02b41617aa273d187424dbf54201f163facde87cf0a fc18e8306913806c6d6b0761d8eb2416c2f4934bcc1d3785ec2ce44bb52aa0c4 162d7f3fa05a81a90dbad10d8818c7f6a4d790f526537ae6ac16fca7c22cfd98 1a7ffb004a12f8f5667253ab2a9cd17d7028df6a28d4a50468e749cfde98a461 960cb36c3b1e1bbc30eeaf5bbda19add733243a9c1fadfeec7e853b8129f124d 5c6bd2a8fe3501257291b202f5e496ebebaf02c736ffd71b761f7e717054969e 5f2c09401b5a1c5cb3a38e82f92111b6f1714efb92dab78060dc392e61a8b06c fbf8c89de25f773b534c120ae6b278463795f0df173c152a3de711caaf36a617 7a638e44cdc2826d4df0a3bb1d617bf983c428f39af7ce5abc0c5adcc171cfd4 fa6e0bb008e9af0c10d4a6f9096a919948bac7f6db8198a47c1c7e91374ec6a2 0093a2bbe7a198aff87576a5b94cb81743b342ce5a858c98b02cd892cfab7ee0 43d6f0afbf42cf8219953f38c2c6e6aef79c5e32c35d9e2b371c400a31d7598a 90403e30f3014c8767057fa340e65925e5fad4eef1ee61ecc3965c42a02dd70e c7ae8a5ebbefff599a984fb0564a801aa0b5a5f179b4d48a91a4fc9486bc168d 9eeceab9aa77e92d16ea547a4eb0aee09cca915212b05b37cd97a501e729fe53 ea080f10d390e0dc793809526c508af13a320773047ba363f57ce6f448cf726b 958870c90288471c5b3902579a25acff761574a2f058e7f146d37a0e61c84308 a730fcc236dbf955de1c3485124d880aee0ad7a9ab109c380aa1db4f0d9f151b f071e920343be458eab9500ad4e2736031ea08e0050731becf0cfe7ee2771a3c 17f2a9d3e837a84121fee34055f651793c37de5c1e650b708557fd8801639dda d48ded5505b1a84d74e5caa0331c0a57ce33bb7aaca436631d165f946226d7cd 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 false +check_ring_signature e747365cfbb09c0a049dce3f53dc0d2123c8e3b25ae3d596485be3e381a367a9 ad7f700883c41f32d6ac72b826c125ff409592b9efa34dcb3707106149359347 6 b4e6bb568a2f04b195b8ffd23c470e5d6f27bc1d343687505e45094466522ffd 9e6e57f99c4ed840e5cd2d25f22dd1b3082de6c0a4ae4891e4b94f522e4b5256 954f59a21cefbc11bc597eb9b2086c4c33e72436b3936c0cbe1be60fe06ff2e0 35e229f17e9df7984bab6f22a12efe4a735ca54430ad55f3cc33a2ecafb06ef9 68434822df292d8a53437ac01e0a0a2c5307b6afe181cfce48930c9c030de888 d71c0590c4513565758b28dc2e20e8536867f94f4948c16323381228da7b4b38 16db11a0abe1a79d832b365a09d7e306e4a71ddee37ba8699ed7e253e64167071d19c1b81f872beb338f463e503e7ce501317c4f01afc3be6860a73aa5e2ac077d45a5aadafb21d9b85176ba7eec57ed95d211f430828a45e09df5235115550304ae7495b9aba58ae2b1c03354945d2592212c371b454afb69698ad6521c8c02cc7d74b4b49a6eb96374c473c26fe0df49cf345d8806bf1f1c2d6b9beaadb4916da1d4867ef267d1fceca0803dc1cf93a9fec8242b031e29ad5b00eb4e548f0d0c14bd1f70f692bee8e4a3064941dc37c22e492ee0dfb325cd368b3c610b370adcdd0b085f9be1011b329173ea1272b28a19a5f18716aff84adb88ef3e4707001dba2e96fff855b982af62a7a14ffceabd9902a9659959775c529db2d4c0a80285781f657ec462802ba85c569f0eb5d39e91e84dd49575bc76b3c3238970f7030e3c0306e2ce4ba3f24b6050490c16c0cabc59979ee56634daad61ed17bb0c0399e05659ed90afaa12a49b98febb51a1725678a48cf395135e810438c425cf01 false +check_ring_signature 178ed73fc5c05fe9e2e7b391d7ee1c53f10943e1c0955016cebbe1acb4393c8e 73ddf699be36ffa9870ded27aea49abf40abfd901ff8d7eb2595d623f554c955 1 47ffadc39d03b0a0420c82230f2e0a4ee6675829630179df4104650754b2c875 ee17f26844113d55ce8207bbf66b1b7b2bf8d851140222a9188447e504b81deb8e4232bed230dcd13b4a6f760f6db46eb3c517f0b704cf13ffcd122ac295acd6 false +check_ring_signature 5646f272838fa2b00e184498b02aab553efa76a164b6757f6a01c50338c56d52 e50f40a3dc6393003d3e7a391b53290537cc57f255f31005e30c6bada833832e 1 15b011b76d774010ee77279a736894ba112db9737e4545b861fd80fd13cbae2e 1c6f2bbbb1a50e010ec1cfc94756e438b19071bb0ad221117dce3d759cb3ea0955e386d5f36ea6b0b2d4976e9c32ba118de40b99df67578a85a4985026e0d300 false +check_ring_signature 34cfcb5eb516610a5ead4eb67ffa06519ec9a350d99ffecef79f4b44fc62889e 59424c22c2c1cdc59c0edd74a8e259947d9f54cb8c6d4fcc901cb010951c9eb3 29 32d19e67104fcd2137b2de3d15afb289f2ac8464ca8a480b0b89a2cb4dfd4418 0d963bf2558b6ffbdec3a12dc5e3f14283646c263c971456f5f59dd9734505f4 65b3464546a50551b68a6237cb49e585a93f6a791965701f26864dc1f1e02d87 fe1b06682580f3e91f0f499147953bd6bca83b3168fd1f67a156d8ac557268ad 430dfe8043f96cc3275a672fe7c9ac6dd8a8d160e5f87356fe138cef3c3ff2c9 29eefef24e0967d6fcf9ee3635658a1a2e6187ced7ce2b09b069303e792e95c7 6f29dc7b53be82a0ff89588e4613e4da22c37bb06a13dc010f261d35de2bf2d0 6d1e03a492fe7389ed4d18b8324181250bc43f10ebde30a08920c621c5aa35d9 897c7c206482f6156771b0d51b0b140b7794fc0d35b9eafded361d39a9aa2a07 ff26e684f6d1c57af101571858b158406a54f25dbcfadc4393a48bdf240ae67d fec27ecb5fb4e560199652e719e21a104774100aefaa20487cf798460a747ee0 cda3dfda857942ca6bd113372e3530d72b2ee822ada89d19f4c3692479c8b4cd 7eaedf0e12d3612823092b0510f813d029a74f64b294491f4cbb4e39d416ef3a dfe432de969cd86f18d488fca28fa0cad12e5f4c093af46369c450a49a844b90 9e230af147ea444b54e64a0663035d3a47c2b20916c4d307c54b5ae98e17d48b 5900137d52228da024fdffcca9428e563c106e056c44ec2045476b34a7f2d437 8698a8f38af40bf71a554eb04be524557770e8e93c52a0cb277d7a176d819679 a9790f055873dccbb4df6b6ab64b84399735523b52786fb62264c5970ceaf23c d44e96a2e97540e02926c470a91562d36e6dc58cfe4fa7bd9fd498cf4c9a1482 8a04f299dbb55c4a667940145d00f8d9d8c16fcea699e958d1f713a5994d287c f272d76f82ff418fd3d355bae9673cb3e9cce813981afda2c5283e162522b848 ddeb6842ee7e38667dbe51e401a5c413d3e15c69e5da30288a2550c078ef7e6e 2431b46a19de4fbff8cddf600647b5eff55ca3520358a51b8fee1ee06b7221e5 1e58a0b418acc7c1772a17eadd28eb404dd9d8c8a7de919084eda831b8dcc500 4656fbd7b7050540a3dbefd1677dfdd81f37bc39acc577e1affcb88e221e932d 111c6520e8533285c32bce53dda556752fd37abaeef70c793a727a2b67516ab5 ed10e2b6d651e6a9820864873cce7f95872f747b63aa33772e2ea748b0ceb4cb 67c78cfe25becd469f4c868fff223f73ac6fb8b7e9e7f7e3eec888c58c880efb ab1afb33729690d316740f62cc64c97519e2f016f5ad4f13e2a08457de87179a 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 false +check_ring_signature a34d4ecdc8e1babe4686bf0ea6479df368d97cc093af8d3347091d4c049f9bdd 2043090ceb976ce503489e6043d73b0dabf89d5aa90d80eccb6d5f8747839ac8 2 dbd8675f8fac5cfd49bfe50eb237f8bb8a4c2411e9afc2013728bb7cfafcc4ab 6d1cf784269f656cf803e452d82b93c567022df36c5517b1f52cdcd93833344f d1ec8495236835587a9baae0a4a16c48a5141e0e843577654e563eeae077900c2ae35337bb8835dd8dc4393b7d0661cba06d5f540faa0104981026a54092bc0eb80e68715a00eb0285317d874c00c871e526319a9c89529565120b9f774cec0e71f97cfed3df6c22ddb621dfab50b3de153b1c2c9dade791e42b1d8e1735d301 true +check_ring_signature 22698321ca4ed8b8b64f711ed0653be98fad4d3a311c12f55e3db8a5fb5da0a6 863b21fa514a05cee56c87fa15aac86b6890c72c0f8638558d3509f12f4f11c6 2 594d0d852a015f04320178e9ecac6f1103da6b686cc34ce221af6c11cf88fd29 631213a7ebb9357b0342bdb05d7b4612096e9925bedf87da92e228a68398d296 266038a56a5b08607da0946ec5d306a76985c10761d1be70f61ce23232b7d9051d588371cc6deae7a0f24be635a2413e8c8bdded6f48df1e78de36394be6ef3bd7f9acb86749ac27536830576039472647fed813180b442adf1237c3183ea70e2d8139beea5af694e7b9d1ecadb50d2c26c4912d19a0be99fb845c796d056b09 false +check_ring_signature d2ed3232385a77c538df5fcb9f173dcc6199985ef773c89ecb32529212193056 e6278c1e99f6d3a697da69f762a0cffea387aeb037bda85695f25858d6cc12bd 10 bd7335b6d36fc678712ee5c7a0cbf2c97240704349540b734be2e739b9d0cb5e 7111a1b778b46bf3a8a9237f1fdcc60c7c73792c15b6ae1b4c316e5e57ae3485 d61426813f9c92118c7eae32bd68c8d1a9484d3e5329425c258e9554013dbd04 9251b83b620863fa7d14f3a0eb792217e66ea7a09db9d0e55a120ea464a49982 c2afbfd41ce915ee0c061ba782423d6e5b6f2f4a8db4ec3dae6154c111402573 8ecb189940eb05ab960c629d111980fa1b389c13ff6f580cc98745f0a77ca3bd 0dce10904d217bb06bbc8805422ea6a15e2be1aa473f870d4a5ff9eb475bd07e 6cf15f79edcba96900fb19e997e7d4d831b87d1f24b246d7c35d0781b68a5db1 0e031963c581a0f8e890ab793b9bc0a249bc64659b491c3603815d580d7d6932 ce481571e0c42968f50f5163581729a3109c5032d401ef2a64cae0ed85c4a769 829b21459f55533e0d55c4d1ddaa2d7b2e4b0b3c38172a807677f38fef488c05f821e8465543dcfcc273249d5b9dc04124338817b5fa01576f0c7a26b0049606299bb9814acb4dded1d78b23f21d03d3dcf00da507885f2cecf85dbe39eb5801ea87ed208c2eb159e83a3c6a11883c65bcc5f1c5a1a015760ef75b65bdf4810fc96dfad6134249ec0799b4b7f175654eaa208bebbdaff5e7846929af49189e01c4872737223fd0f7c83b8bc6d0cb405873d352b95013d7915845277665483b0f004e709e39442be9ea2e44f14ba2af757b68f1c0e8d1842ead3747d6b17dd3096d214f0292904a510c89c20c8720d2489c58fcde18f5a68f4f18339a9d988a0ace3a49818529562d3e838810384caa2d62a8eca3ec22cc9cbf8df21a8e5f2405f98e02a15fc52ce36f335700a2da6322f99ff9db9a64a046348210f3d22ce103af92d11d58971c1366f4cea065a3fb8ffa9e1b3e0ab6da5ff83c516e0b025608170ff9f780337bbfdca6ac3796aa7a4793f047407bc6e3c203f795a39fc0a701e5f8cf5fd6f1bc2d7bf5a98bc343d44963b11919b3ffe9dfaebaa9fcb7887e0baaa82e80bfc7cea06baa1ba90d545f715f9cb88f0119fc1fd1ef77aba09b840e441479b16ccb72df7b6c8b713d03ce34a52cf054699249bd4a76ea0e400ef30bdaacfeba9ce026a4e7edeea9580cd42350d80cf01105020ec93f63af60aef70d40a88435e53c3c1c65238bf9cb8a982b3bd2ee29f2e5d8fc0dc23dba24d94408418cb4ce400b738c7d1c8e9a488e22d54360a7788f614ba02b8b07331ee1c1053b613d219e519b8135549d9f9d913f6822f1c2793998f807f62652edf0d614048651868ac31caefef9c15fb121f8e8d5368e9c313d8dda1445e8f7cda9a9cf04 false +check_ring_signature fb25495cd7bc746e722363a94bc7755234cfe5bcc53e54308053762dc6dffc12 29fa0d1d400c0e88cb0b25f045296de9b2957e98be9f7345f053183cd8aa3c7c 28 449bd90c98576f745d432525a9d69b50b321d07b236183d5f375d9b60df1f2d4 27e671824fa4acf215c6e6d040129d49ee87051d4de922b552f145703e660277 2384ff31a1d74a5bab76bc1dc7c81be48cffb419cb2f7649b66a1f83863ec871 905d36501cfca32191121ea67b38e35ea1549d11981631567736c2ca22429090 6118d974054b72e4cbfcf44cca33296f02d533c982b62603eed0db097f920f9e 352bb13ac320d1c81b339f9d71924a859c8ed190fda41cd214c0e638acd88537 1aee7d5cdaa1399b30e25aadbd40e76b490d59899e40b6b5e9c79729a63e50f9 b233800de7977575f5fe50c4adfb0dae8673678960d8b1774dab45487ab5675c 6d604daa73a60943daee6f5ed2ecbe7583fe1dc7b34ca5ab207fe9ac0f132830 6307c7e869f138fe4661ab27e2b41eeb8d8496be0c06298c0596620e17a41593 e08f4cf1c6ece6736b69f7f175ebd1d9c8d07d7c17e6f003d742b47ea2f26a9b c7209d4601f717cba273b8dfde0123134499e72be0b46c03838e0ac9b926b391 ed245d0c073726e4b6dc39de59883d06acd471e3aac75396fadd778af8305086 b3e4dbda62a1f563afe7800b1014f6e8c00a2c02c096695653be91b2c59aaf1c 5d06006889fd560f3b2535fa87962c67c00f956414b61a72e98f56274769806f 873dbf0e0297914c0b77fa299846abaf2fc413de72d259c38d35b57bdcf4efd6 e7064addb3b9b0884667d732a18aaa3b5adc231f255b06ba7d582893a5be8940 2b4f52b0834e483dddc096791b4916c602947c69ae4c644656a0306ed3620b24 7d5c604c716b997e453c93f722105386b411e0883d761857cb9b7c315f0a7295 4edef14116241009ec89bfe99e69a039851391204400dafbb94923f3eda67a55 d9dcbf42a1171dde6204fa51ba48a48e95949ef5d3e1f37f12be641f61f5948a 3eb64a4660ead5c2b8ab0b9961df945c3df986ffc6a590ac574c758b9218a1d0 17a4a8cc5ed9080f9adc5c0f0bc15ebc2d9818a447c5b2aae233cde1c28cebee a1198518ecaab28929fce771e54977153014fe6c8efde1c79630a5be779c096f 394ac37fa5cc430d85d8ae7255682a4264f8412fe04e7368c30edc04b8b3be7b 34875013ea6ba98860fd071b1be944ece3c255914b434298ab30253065e48a18 e13daa1f86ea4cf8ddb3e563de4dc9ffbcecfa956d2a8c0b97ff33405c46b5a7 62c7fa0235034bcbb1d3880806096b87144b8cd3ba7de1423a689659ddb9b90e 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 true +check_ring_signature 213a4a09ccf4e26a277dca0441e05474c457991e82bb1643d2607bf01e39d57b 3f1423b1973955adc5a7de731f2f62690d72414e0fa937b50391cf48d95a131f 6 2453345d568af45ac2f6251ba0fd8eab60591f4f6d28a2a74c50d575ae275721 b111440c1c2a6eee772b3484878976d8bd1e0d41505e152a0e18e452cfea7ee7 0702d7b0a8b04567ee507de9e2c6787f45a0ca481fd813bdb1a5a1293eafd484 e5976d2a0385ff0e91ac45e1518afef944bd96e787f4a3e92e56d67b08b9968b ad5e98c23d41629dfdcebdc02a86a7e27dd368386f819269f7bc874cc80a5934 f2f513c6a4e1409faa698c0ab55cba8b50c39ec0f7c2642a76a487b6b2827b09 7d7391fa901d42e9308dcf11d2e930a65f8857e5dfc5596cd28ae0b374caf80116ab587732b8fe3998b4d95390c6f927fcc2ceeaa91a133d28f94bc3b9f4c30896c0945008fe7a718c3f644e5a71adccef9a013a59f4b658cbee214926917b0965b486d04716e9f8c4920d829c2328b0524dca7af9e1edbd55cca9ae8abe4506b2c21e0280dfafa63e799ca8081db89a51f4930afc392e11eb28730bf1b9d40c8d8d220f468d099809a537a4cb154ae3069499a3fedf7566373c7cb5296d20095b8220d78b59a190f91a26917c587b61735df387932fa76c5b03faeaef67e00a61f87f9a656f9fe42b4398e33494773c5dd4012b79584b189619d73f642c5409bd85b5487c6ee8dc82ca2d8677afb8a48e8a9bc5f5702add27d3c8ef1b0600065452b2c6b643be0935ca244dc79f8af85cb4fe0769e309284f935e85abe68c07f5b0c5b7fab8d5b53bc753b9ac5986551af413b27ed8783567e77a42a5daa50a6b5f1593e573b57bd676d0dbeaf2fcdbbbc107d02c093f4670724bf49b55a90c false +check_ring_signature 8f3577a9b1840e5016b01f2f7cbd012e6ec5d5d15b5875439f251223291706fe e206306245df38ed595934f44bc9653003329f9b393e6f073fcb6bf5de2c39a4 50 736ee6b905af8802ec4bd027002bc7d900354561fa9da8ef11b3d1b7346fe572 64e1d40d4d57345cb1263aa2350b381cc45d1380de7786b679a015ec1e3db052 0286755fbc759e00e2c2da5a52ed53202ca3040724affbb0a3069fc437bf5fd5 b477f6a73a6aa2bd8fa61660302aa0fdfd110db793c10c7c253b877d7ea90b40 9e5b376dd3e072ae25f78b5084c3dc6f580304bb97174431ac6ffc131a1860ff b631ebf02c7a7d2e21fbf7cb2c50156a8d97b91b55e0a9d11958636dccdf24a4 f8b37829f6bd0cb717f7f3db741c93ab217ae9949bf63082603a4e72db468530 32f8b1fcf5c904d0d98dba3dae1908eb88f609cb83da66ec4a583d8ab751ab5e af057b4a3afe6670f5d266a96f23afd815ea3936068ada1a9db9a93fdbf8714e 9b7cf6cf3c04078f6f489c44f5081113296c404c270e6730e7936c9c33ba6ffa b7f27f5a632d5e9708625ca2ab95b2f81f757f2fe783ad76cbfeacef1c5fb5b4 a817701c62641a169ff96da42c4c9780aebd6a36734e5869aa5aafd3abbf894c 401d26ddb1db7675cb804d45d36e86781549c443c4e5818d8fef3d3394b39488 4d07c43cefc1c7ece277bf24d805dacf2ac695a653d48e2fe23a83be506d810f b41a6961374a96822987b35de9abcc6b7501a3a0eb2c922fba96e118feffde96 70365b0874ecac4e874d03c587e08758cd1ea2769de0479c280f94d3745ba327 c94040939196e6061c5e98ef59493101a5cc9f83cd5af2d2125818332c662ac1 f30798b241fab898303a3c14cc55077ef2c715c6025969a1d48874a5cd59c793 25cd92efca389e49832c5a6f54fa19441eb1ee569af9567719e673be3d072e00 36f7c45d91dc3a0aa932935d30d4960820a6a90b4ecd5e358aa9e6404a5e1d0c dd953ac9f4188e0904a40363d3160a8f6575b2ea137df6061c76d7d933865d93 e72c5b438f54ed635e72bf9b7199af411ccc4f8c9dc6487fc7ec2c9264b1ad9b b04ddd229a4f51ce7aa21a393ec9c29edf98b044aa511f603b7f7283b165653a 42a08ca5f15e592a9605221fa1965932e4ec7b3530cc553a35c8f51c1f96f737 04f3c5867b2037f8672267d09c5a6d91cc836fcc3d237c60f100fe737a5d78d9 7396b91648f6c0c9b76049e50a754a1a74563623fe2305ae948f4c12a9a60806 a4b1f9b4e9b240c0121139a62713daf849859f8fc44aabb960038818dab8f2bd 16ecca64e33079a76850f8d8d5887ff3e7e81fd9f968fb76b420348a171b8f47 503b88c56c63e129f343213f95b83f529c853b5491e34f0752460ff401559e3b 6e6e353f0fcd4871984a59ad03ea3be18e8c7f7cd6c90fc1ed607770221ab57d 6e59cbef80993f9421ddf30fe1ff370026899aacf940a1785517470367f97a6a 313851f77493f9ffbefae91d5f62ed503c0472e6631df0cf0fb0c88ee2cc9678 8248ce77f1553dee47cf8745e7190652cc84fdeb8f7a3652aac4d98d114a445b 46848bfbd9cc4d8521591434e8942e55be720f927c468b26a3329b801cee42ab 83916ee6b530be39c6e9ceebdbb3f3ebfa35e33ee7c8c798217ee9b412d06fd5 ce96aa34cd0a7303372a82e3f3b54b3c87913f8f1aa5a82f546d13c5bfa9c7c5 71564cb932a57ea48ec44c851498a80805105eef87bd96c2067ae295e7090d72 20675fd78c3aa597130fa589b1640d62a3f3dbf133dcec1f3456ade9a1a6b317 539e4f412fdf3b23c8030527ddd30850a60224b4ba9e0099151d3eddfb90874f a12ab8155f57d3e087c5464b601a9d1afe9c981fd1cf34714f957931303c8f71 5a9800dbc0e086c7a9a813e5476403ba83e4d5314ee2778949b600ef34f183a3 3e6d0b887e98cec6b1b433ef7a368d1824bdff08dfb7dd304a333025500080fd c6c2806e82d8d1e7dd03b78ca99171e41d6439cac37e207108706aa1f2460a6e 3dffe53fd420d14f5e8e37f73d02f1d67d94fc8620f5233a39e142243d56d12e b7586bcbc12753e8fe73f68a8d21e061d5378ddf619aadf5da37fdd6e21b2a1e 8bef88dd9cd784506bae8c9efb95ded7f08cc454a8ea3cc34d90a6b12eb73273 6b171bae511e5b4c1514794205b44d7e6eae9491a4d5ac2af4452bda6ac13fa7 9423a7930ff0827923a092b26740b51a9f68dd8ca9085e5bb9595ff2b1df837b fc5fb14cf6902775bf222c77b9709ffcedb0e130eeb2b868c0c71c08de178d00 1a18088e1667acce8c43c6853be66a9317d743f2403652a1076a152fac70892a 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 false +check_ring_signature 788c75491398bf194e827f7ca4b84ac7a6bbfcf80f238818874d3184bca35732 3ca321fbe6607981314b41b36e335c27d09baf485b1632e57b9b05877306738d 24 409a19cff6af31416fea0c442af64a14c4092cca91328ad72b031b9490ef0477 c8a5e8f9d18950f56b6a3231659e9ce72f319910475b83b4bef3725b4c586b68 3cf31884b6acc44069c91d99c41cc880d253a1854eb658361122efddb6306cf8 8f5813d81c2d56d311e0a7d7fadd1044d8638e12cb9515f4ade71cbd44c35fee 77b0eafc1e107202abcd9ca06bc3cf024e034c06715410fa9593160f013242e8 b58f05612c74cf562853967e07db67f1b4e7b7d00edbb08bffe8a2498dc2c540 6f184896c52c796479c16aa14515c50c773d2186f9a85899a88d94023670c90b 7812572f475a851b0c5c21fd7ef5bcaea9e1bbb7eb38e3eeecac2b7babb735ee 59fb5e1ed9e5aa238b925bc643e3c11b2ec4a0e579d31c3c2760989fd3a8c32f 7447dd26b1dde04959bdca31502dc508734d3b6bbc371f69ddc900d54e32e47c 87928ffabef021bce1db9dc6618d12579ec9e6dac6f0fef63f6d6a4907ad3cfd df95a4b26720cca791b2e42b9d57748004bd311f874e9f115afc99a4eaee4a62 f786e28e546e207f6fb4ec538c75d819d831ceb778882f42d30d8e277c3441f5 891861dc5ceb2ecd926d14e9b6e9b86d8786d8a7112bad6f1be6d6303de82d4c f3d670b1138fc4624ac0e6d24a9fcaf393c2b40a36a4e2880a57b80653c85262 93e029ee7dbf126bcb5d1aeff7a0522ac191853669d4ce285b790480532a5f23 97e46e5ac688a47be4c86e78087dcdc5a061a33e6962cedb57c3699e3d53470c c537bdd75f228447115a7ac27caa8fcd50250da4e34a84725a202ea8de2a6549 c9f0b6aadbe4ec9b23e17623b4ea25e99f6825c883a7af338db0df7a9615e3ee 7d5d54034dae1a2cfeef3ca7ae9b97662df491b4fea93d14d5adf07baca7a663 513cc1b1b84bf36b35ef30ada5ad1dc209825a06a2459aa8e81bf4c2c5c39af8 aac5f9e167191770619c78443bf83b529f8b38c81e4f14fdb4e6102e5de4de24 c43cee65ae02e871e7e9d53e5726905fc140163734b9e20aa6f982f3de71bb14 c9b04db0f5056f2886c52bdf39e027d48c0de8f4a70b6efdbc70d7028679439f 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 true +check_ring_signature 1ac1a92d2f0956d0ab6f217e48c9ff9a098d558d79d4a15a5d64094565befaed 7ffe9aeaeeacf52eac08652309f910108482c59ae9809a34e703e3f7e3aad09f 1 01c1e0b154f1cd6a3c92fff352b6f618c698f53d20d3532347ed811222625887 3465d62ef860a7fe265e61998821f12699a66439921a1ce42bd341a7aa30e4005c81c24e21e7ba5f8c690706b3f982c9fd15181df9f322f8773dde1ef197280d false +check_ring_signature 3f080fcdbf635589ddcb71f987078c7f047849de2dec03055b69b18c0b4e35a0 2458cc2455ad40812b4fb58a619d0166622e2ba765a034f6b0f147b1e61ff22a 14 2537b293fa0ce60f941f145bc3ab90efdf8c1efee8900c66dcfdb8015b9fba39 1041f28cbe774349321377e72801c81c421a70de66f4db70f9c5938b083ab242 34dbe338f7fb2ce1d2ee1bc7e0b48f3ace71bd73eb80b8cf1d3bbff5aab74f5f 1da776557504e338d273a80e4b84c1850fd52155194a57b5bf37f9961266e9fd 2a5c47260346dc42b30848f00603bb28158918aa015998ec2e1aa57cc436c614 312bd06d455082cf05ccdffdb559bf9313801e94c69a607be7a71498578b94ce f0df4926511b011c39e054712c19046d7a073dd8eecc91c0b5c178f4ddf58e31 ef185abee10ca355331458667a9b45f4733b363289264e44c6c0c3f86edd1c5d f99c1d559c0a7baf6f815ad31251e53686ecfea44a2cc15872693164775279a0 72abc84e5b3b1e1d630a457e39b8da6058fe54cd2dc8648c4989d6b18cabeda9 278ab9b6e3792325547f3c754d6e500f5294a977333603d6b9865640c8c563c9 198d00e36cdf41aae83a457a41032701f07ef903e722b9f7934a0dc6c7ed6a78 02d86c85c0cd7f4686a219b770976b655d7bf44832bf4903679580fbf8cf9c0a e54e69b6b90d7454c7850a6339cd48be58ed94fee9afdbd599a03028ef5bf717 28ba329c74067c018004c6e4ed8c99f964ffbe757c04b29b06b3a62b8c23b3030bb195f2f2a9169cc54ee35a956bead93fbfc61adbfc25e859d1395e9e07690eb1d3bfd86a933eb425d433ed0f739bd52d298fe3f94af287b8287f7a802a300c03b4791a7f708acc5e019a9d87f0082d52c96745cef156351fd362c578f71309efd525c33a30a6de944328bb2c82030991231ac7020bb522a30455ae21d66200cfc807d7ddccb818c996ea2f62cdd7d65cd6177734f8d9a51f26eecc5098c30bb9842c70075ba13bffa2150609ce101c758a62b1a72e5cb0e9ea8b9a82231a0d228b11bbb8a99af898eb5888baf378f473f7e65f6ee36ef99c3ed1d51500070bf80d2b8ce98180edfc2deafb1ed85730a11010352f7e257cccb40c6438cfb40fd4fd78417bc9f8547613a798ff3d0f5c2c18df53b070432d1ebba114046db80625dcb2a497411a2a4f1c98afff4b292bdc3f96b273f00c82742c4083be709609ef4636c356b83108dfceac7357022a8c87a1c7a007ae972e449881658a914c06fd543e8f89042f6fc06649d4c214d67d699b083eb134682f6d109c2b6c59ff0f0ae19a9e840db5fe19d15774d4e6e4aeb9a1fd8e12ff6bd602fed781568f86045afa34001a4dcd7a445d49764af791a6c31bbd5964b6c63a5efdfd78d8c69602255d1b4582de42928424ee183c3272f1d051163afb6ad08c54a88b55e1f70803030ea438549e5a340b4c326c45d56b1a9c7c47150503791002ce47e3dc34af026fff70dba3cbc108582ed475eaf8010777f8a4c97ec7d82c5f8605e0a8921307bd6f42e0404b69a4d11be851d176311951fa2ba3709d815e7d8b71bd12b5d1042a497312849e5cf8e212078d5c51110105503df2708a675cb1e1780fe7583f083a150d475601a0de52d3fb11c968c2479f9408d898d41f9b686415ad300b6a03e25337aa42ca9b08db70afe99658de85dda2be513e3aff5392b1c7a874696a0bfa83b29c2b6ffd5e980c8e7a38d73cbb424aa61276f2e3f0769d277fe20a9d0584831cb594eca344f4b9e7d9780dc7474be3d365d6b84fc800642afc04f9520aaed6d2b8958dac12a05fb8bbbaf3b013f419440d4411a31aaa8fced5ba119d0384eea0ddbba12684a49ebf69c2ffc99aa3c13e1736d40b4f67c5abb84504590968786056a86e15abe715d664b3de0d1e2c22366edfaaca9fe0d6d15b6736e40d13e77eb9e9d3aeef86a2d79894167a85c9f92035cdb0c6b2a1d6d9eb5ac48903 true +check_ring_signature 94406af04c5918b574ed9247ddcc312270ba0d12d058fce0b3af806adb2f7e82 7abf1bf35ef10bc4f00211de2a2f51c84ba892b912067282796a93fa07f619bd 51 d8b96598d459cb65910c6cf64f65c6a330606b78b4da0eab123500dea0a9f0b3 406bf2e600842eda541c35945f5dc23bc53f4363a9d2e994b770424a63da9dae 9e42c1beb7e2ae9c96b2ff3dfb46db32e1a7f1cd9d43dab728da18e58c9f5f75 2a987a2671af962c852fd03e4012281836791e6504b8e689cb8b34880175bfa5 05383aa44acec5b6d4386c3e36d7db715981e63f9da3b2b705b2d94fa26aeb06 470c9658f7a21ad13911fc070bc3b4a2780d771180b49db3d2f7951ba0f9be93 30a04acb093cb2c67395c020bca0b5b6c2fd73aaa028e4c953422d830d21b7bf 0ee214438a4a26985efdabbad14f11e02365cf6a0db364906c37408a7b04f641 a450a55ede06e447e88e9b27e743d6b1ab2be0dec33de105e0e51649e4a937c6 abca5a14f539529919555cf8990ffdc454fe259ee7417e4ce7588e1abe964997 386a02dbc0dea9feb5fde40024eae803b83eddf74fa7a30d98420017018e103d 408b17077864e7d8886e51068aa50592746cf458dd1f1de1d8f7686a83ca4fc9 a05a1e3655eacac2d9b6a62e3f2fbd6525318a157ad690f46ee243f2bd330a8c b20a4d7eb5154d46dc4b8e39cbb7b0eae581b29031de66f86cc3fc1027dfe2f3 0e297c0ac37709ea3be3e3c7331a8e62011cc29e63deb5f56de101bcef71add3 39c0393dc42ea7416b53ef6a8cf2f995497a1b4a0ab1be166d8e7d5f193afebe f4249221108dd012976f3f3210adb82e2d8b2584362c3c1d9ad75f5414e16bef dfa7cb30932ed3dbbf354fcd66c97fe2287cfc04845586b008ecf7c202267766 561807bd4201fabdd77e5d2a97a532d7e20f1a5ac6fdf4eb33115c10806224b5 670bfbc323aaee1a17e0ef290d239cc5cd3ea07c796359d0ddee6589ad3ae67b c9a8c9deb9055759f206e41a2ebb10f1b4044e0fd1c9da4b3cba8f4cc81ae774 6f91dc1870f045b983de05fef1ffba0cdd9ebc4a61f44649aedaf59eb07f30ce 6c7923b42f428361cd0adff98c3b4df711c3c8a2c221d89f0d2f82c585a5623a a80ca0d2f38f700305f65f6320a87e562e921f40bcc49735e30779ee99625727 f38136dda6df66fa4fc09764ae3270c8f2fefd3ec2624197a17857fbc69471f0 b4bf594edfaf9b3f084b4acfffd0fca4c8f6b4e1a9d3c3a324e78adad66ca024 30fdf3f11b2c203615b214060d9c08032bf1455f2d86b57610950f96474a80cf 0e9771511db62af2462a0237b5b1240c7f43b8b1a2999f221267c48a30cc1e9e 7ea10af8d179f30c7e3c476339432535b64463f1b2c90398815a3b85b5ab1d2e 6b6d2204c06074250024f17d8eeec132d6aaa9c34642fdda255ee5408f590065 cda1a626c05b120c3957d0b520c9c052123ba14e4e1fc58ffd09d26f27aba0bb 3909938624d3e5af7bf0378900d7a96feb80bae0cb0ab9abf700663311cc90ef a27a607a2651b931f4755129c8713e0026b10f7a4ceca9818f2395aadc853509 6d01697b38fbc53ac8dad80a7f9021ee82af99f9eac26ca07bfaca3fa338d98a a8b39de1b392312c284c6a0317fd2d7869cdfcfc8dcb660208d1c013396a3fc2 5afac7e2bf6614b0c3379c7ac465f4644c0cd856fe15f9881558bad3dc38a48a 3f8e304fb97fb7d8462c322da4826d621bf15ad20b1419160948ec9e5d34db51 a6ae5f4a87a346056c8142341436cfc7c458f16a71e8e619e8f94c7f43076d3d 36d0b1c2134db1a4a0e9062c937321933f7af85a95b87a3dfa118bfd4f6aa532 ae4347344bcdbd76ff72c98e92f058a35356a22553c1d56fbbc9a7749fc17dc3 7dafb06226b33345a1966e25f90d25da80c47d7c299ac3058c459082ea3c274d 96506bb5f17fba82b1995de951d468542cffc4b301c0e37bd53daceaeab15666 0db2446e350afbfefaff5fc133493b281bdcc0ea48a60f842b55d27aab244657 47065bcdb04860d0e164fd8a82bbebf1e5b831d5b352eb453d4b5c4605ff43f6 6db020bcdc210127334f62880d282a63552189e7b005247c94c18356f008bc65 0a71f9440b719ec85c3bf7b75221bcc030814a4e1920b1a3cd95d11bcf0ade1f 043882af25c5d4392dff6c8c16eb6b2308b15a992c62c9a05e334ef996dd2f6b fa018b8a5556cbf76921af317359958c5a88036deb126497e9b143dddaf2e219 62d9a8c0e397f904a1fb0ef522735a1892e77147f34b8b0f0dfead2f7c6d219c 31837ea5c31dbf1c33b4e427e0b1d67a76320bf63217ee19c963817f6b5056ff af2eb49572aae9e7510094d6aeb42f77f473c2499640f4321a3b416f6d682288 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 false +check_ring_signature ec367ccbe3c0f1aaebdd2d5d8a8fa3236f528ca4b8bfd3df9b7e8d253ecc216e fc6a8ac3c76437892b8ace5a94cde695aac776ec9608dc42ce4dfba516e9b8e8 33 15023cefe65b03fec4b773c05c539cea4d859d5696cb95d69412f9f445a47d02 b4d7bfdbc84310ea87fec2efc04b1bf7a1a91df6793a12ec2706f167c310aae5 9ef3283ebeaccffbcd5514b5287256a158441e20faeb4d03470253a14ae0c209 b335a2982df9d2eceda63f2f550a3fff55ddd73b53b0be45a0b93576e55eb8e8 4ed429b0c948b0a4679e85b0c83340f73e300ffa0d84b4bfe08ab33a84b41d4a c016ee432cbbfcd3b2bcb48e4d17121144d62b181a9771165c05352400fe81df 82eb4bb7f5e139266583188fc8adc09bf9295ee2165e3e61a2ac2e65a4fe1f9b 1ea9bc3b882bed5197e3ca4227016e2c2e009228261c354b51788f5c00e656ae 6550417c90e7d4b24f78cc2502e65be427c9ad3f8414395854049a83765aebd3 73d195f56b77ce88b70ffc0b236e3bed86bcc1f69f1857e1ec2b96c4c5fde453 8357b03bf58895122bc5ca55af26968fd37ca19c3dbb044c5c719ec8c0ecdc1c 2b29dff9b9580f65f56dfbb66658c82c2d2de68ab5a3fe47e513885124f26e80 7b3f3792b15bd98b65782687112600a8e4c775ba60a9212fe0be94590cf13761 deeaa2b7c5f0b51d66643485d9b954a77ffa048bfb6204f3556e42d2bde2816d 7e0c04a2980c231f60d690df5744b61d44f77303f22211f0c1215ab4bba82365 e3ebb297c97efaedf349f1d2d05282788e1463d24664c09bf029f0cb9e571109 728a38ec9ddae432c7d57e51afb12874caf6d17f0cc42ed2cafe7b75532afb1b d59fb51460cefc75c41a82d82af3c1f7ca9396150998f82ebee957c82d3b3460 920889f5a37a736a187b65ddfa8673770a57da271d4b7d7a604841dee2a44b67 19bb797353cd5a0c59c47f41376f26482e167adad26561ee47e45943f18fbe3f b82cb06bd52613e58220a2b4fc66c815c4d68de34713cec54c916fe983145d1a 83c3e6e1cd49e257fbcfc55e1d0585569a609bb9e36d27ad8f8e8b8dfec9b7bc 6d5faf312c4b0d70cdad954e5551136894f3e16fe020c3636c0e2a496ecc8473 992fb3851b76a787981f1200300854408ab9b4028ffe8073d0db77034a0013b4 1bcf1673bd4befacf26ece85590dde17fb4b04246a5b56ff9b35b4f607c9f3c3 22c963f39fae4125d593e98397e1442f1b9e133da8bdbdb72eae58bda3f6eaa5 60b5eec6f5a4ba44225e48cc085ee5e984fe28151dac581c4186146ea08877ff 54f31c4de8b1d3d7d4425c6846ff3cd1df82096fd6c82423b7579f6695c303de c95a55b431d5c605ddfe463303cfbae86878bb70aa5058a15bd294954fd8907d 4383bcd96ad2c82d5ac757cb5b33304a8209e5a63e79eab4cbdaaaf15aebdb06 3dc25d5e9f637a6b23d8132f52d865490301c771cfa63a8d7a28460aa1531bb6 eefda0b0bc034b0ed8f1e0dcf4b2c9fd1a0891a9cde5a48224d4a27a8b102f74 d197d1ee83336a685b029780fb9894b18ca3dd42bb2ecf07ab1ce27aa69b5388 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 false +check_ring_signature aac6af0e0e6dc9ef4c04bb56bdee448fd1c55a3a01b344d005d9e97edfba8c43 843dfd290b9a909a20cf680e15e5b2adc416a98f610d2a51246f9105d5caeaba 183 5bb8ea5025549796a2678f7a731a696fccc134f8d76885b9fa919a4c021d9817 d3c334899ea630c1d197931dd29f7d0d06f7ce2f2f5d565c20f97063548aa021 ae338b10f957ad840199dc9e9e3721fb9af81f00112183239e161818002fc100 9670bd843b582496831fa07dcb6589f989c3f934c2517fb36b763da292cc9052 e05c475341b66cc99d0f702ba848c0fffd42a24df0ca45921edc61eb4c050471 08981ce019a1b972e7744b603b80483bb6c19d693fdd86b82014d6cedde93572 ea34b491c05ad898cc0ecfae4b0453c6dcb02a5538bc0ec723446d679a562887 8fc0b2d5b8f846d1c5a426791748ec6ff7b3c78a656cfe1c76265a8e90249617 3c3251fccd9f142e472989684407540f3fa9fc88d0b89ec1ac7ce958c9f3993a 6962997c36d63f075bcc8c1d22f951bc9f02d3fa9cfc06c16feb5bd870030769 befcac18ab4239c0ab886b5682a062ff555681a1509c8ad38d1152d5f137d330 e7b9489974f57052862b51efd996cb8feeabefceae75896059a85a5c26d0122a 533c703760204a8be799c3bdcb5c6c0dd2fdff95dda6f275c73482e2d4015262 361727f3f5f09333ec46b144a96bc5a190f49c914bff2fcec6fe4978e1b11c92 29d60760ef0a4b8a2de407de233d1b96ec12520a90e488fb490b9440c8955ab5 38e9bab4b383d0660175c71bfea4aa958eff64effd5f51703df6f434f8d33b1a 67d97fc635b35e12aa60c147375df7dde247762dfd817abe05c578aa17969eb7 f5a8ee63ceddb6954c47558fd8e9dec55bfbde2b07407de1ff67828941bb3ba5 39b66f7f8a886bb3decf58c6e83ebcac527c095feb46f1bc7c7be6c54835c3ae f2329d82536b92de4ee43f105c7576cc44620ba8dfab8096643e30d2f99cabb3 a530fbfac63099d37e34cc3943fedf03ef0805d0a5b601c0d63c613aea4be34b 4102dbdd720b5f0d4093f2e13b09836faf23a5d67b3b41523b13b29585608c2e 59925df864616136cdb4bf784ec6359b17e35e2840574f02affcaa4c99df903f 43f026ae53778284000316229677ea637869fe1d1f76f18dc9e0bcf38da94dc0 881b2f977821a29aa3e66c422ba027900bfbd6ce0ca8761f9b170b0fe9828039 2d1a03826b6329704e561224ab07df1360da1ade133dbbb55a2898a7c78e5e54 03b3a565e5e4a8e3f46a68040ffac996a3d7c05ccfbe821f69e9bf7b3f38a9fc f1ee9217aaeea6981dec78c393389dcfc3b53de9d412d30706c5f43a3e1e6e63 a2c623595887cb2196cbea16031d8d380c768603a17f9cb726af903115ef6432 906d85486501cac7b779cf1bcd3a2a331ed29e09e0d3e4bd65f8e7e8302e76eb b88bf752268e4a09a8a729a8c6afd36038dfa65b2f41511f68058ee7e11de90a dd09ee4b644a0d228dd4206442697cf6ec18c87cd18d4613e5976c4cecc378ed 311d87c054f0cd0c506cc1cd45eb5e3fa1d9a76bc2898ac4e42e5a627f03343c f4f1f949065a072539c9899746facc62e126aefb1d35939c1f9c0da825dcf5a0 85b996d38a4e9d64be7b1e2c75e179cb152f5c9ac9a7a4f351f50d58f43111ef bdeb0e5c6141e779f578125c60984bc498db773a3382f803ac7402aec114ad4d d3ff8393f339aff91a48a13abf2b696ee5d8381181b923cf4a8444562d2e745b a215bae63431deab9af548afd00434ae582cf64872b895798d157ed9b6b1b6a1 b6dbab1d8d7c122c2d43de322fb883d35c4856d2aca84386061e7c414717bcfb 6ef80171fcb78b4e4326eddcce687073f19a053d618bed132509641040193336 4b1ba7ce79feaf3c6e79642c2728ac423e324b8046f14d7ba8f1a8ed7d15fe6c ee2fc68fa0e66c18b3db9bec27184d78f58a864ad79ced1a6469b934cbb4c85c 3b9dd06285691bc14aba24009066a3f9a8682e1a6ef709ffd8e4f0f5b9e95b3b b2e247357570a49c8381002f46dc1119aefbbc77304a49b1e688a02dadf3b648 cd4fcd716ab4604b516d6f5d8697e18f2d27f8e02e3e91044cfa0b2945a19dc9 3aec6da4af54d483b2005df82dd27e4066a23d7ce47402e20e08bf450f58f0a9 6fea586490201fdd1f9bbe19ae46e6ebb1e3d96b8a3651c6acbfb9640e6e7885 f6971350e7be235e2d5ee4dab010fca1d57250e05d80ed53e8b59b6447af596a 1a57e2313b44c592b6113ac7f564ee33490044067607ae97b558695b1348d8ca 5c348e25ffac3b500f0ccec71cd5798e362dfbf42afed4cca627269104aa5d85 e1acf415fef74b5322b34fa07af0e96ab66397f07b1869f9e23745e6267095cf 3fa38feb317182581ce297c3e0e28a673ccdbdb333bbea3988a14698f4d23847 94aa7634dd6d282644cae4cabb14dfc944879e64710de26546c2dcc355ef3cb5 e89d760c45a769deaa6ad805b941d103d02a494e80e0a6251c3d146018a07e6a 311d3464dcbcac897b131c242e041c2bea144ea15e963c483b491d0f6c309eed 510d2b2d3828a839b519c18ac37140601ce83c1743938051756d95b15092df75 a700d78b6482036aaf51a777793f983d97be6d712eee25ed357eed354c5f6c9e 324568e1a39f7ecac287d41399ac452dbfa40291e5c27803eb179987b5d9c016 dcd22c0d81d031da7714620425350b079fe2988543e53c45512a3ff083cca1d3 49d0c761412fbc4676869da6101a332d4dac2e56b83ef26450e64761fd9dfc19 4150e2d87a0cd1adeb77aebd26d540d73e00393c44f5650bc3b5b5b3b1b8976f 1566586774822a9223246b28330514c3ae4731c3a6c1aff1cc0904916ae40e0a db6a9a7a78facade5086e7b1e7de1f82f4e389adcb3bdf18d1aa3a868f91e2f3 e9c4a135e48a8f801b99dd00391394ef5c6cff01c230b62e6ac26c49c9c76f86 355a5c7485363420c28f544ce454e8d7ee08e48de47e0433c983f0bb097f76a9 c2f65de63ebb6edc36386d4d20f9153c10780b7555eeb4cdca5a9707b4824b7d 77d67307659a8f4a15b7d554edab5acaa2dc11067482f7308b0b13ff5a867499 00c156d2dcc1d13aaadc1f4c0b12a1b5d5bf4aac987df5b5e8184c66ae69ef4a f20b6826f0c1d35aac6e80b76d3d5b033c3f4359689c1ece50e978e0bdee15ec c2bbab2de58ef8af010150bbfcb059603446d0dde7cfc117690f739ae06f230e 74d7d0e1f893e04de9722523e1d560c78027bf7f368f15f5e56fb930db64ec4e 37e87fdecdafb5ad988c148f115cfe31eb27fe23bc01168b492a775f63c1a0d4 88fb1b3bae2e6693b0e1d352e621b0f4e42a225eacf6e7e3a4bf32d29873fed6 720da624dd6b2889258554eeca8a5b28fa4f399e98fc649ee056a0f8baf2d69a f95ce6dbdf420f352174f58c0c54c0b549b231eb6b4b594d052249e347187dc0 868960c7d8e2102da30c21f30b962c23e781007fe147095563d2fd39651bb8b9 27f312c62dcf86f74eb119b2a5e831887e479f6545a08fcc3943a6f69cee1d47 998284aca87c65e934c922b7fbfdd7924675e838259e5c9b840898afd10172d3 2c173b105d1e0cee10abd8bce68f089730d82bb9cf05ac597cc6f4b1929ad205 e411eeb0e916fbb9da1d1e30e99d8ca4646a0efe2f01fb445a83e1a2f2e10259 1eb1b65efdf201f8704a7dbaa23ce1bf1c2b0f69e2440af0fece4ca6789f0056 9e5a8b063e011cd65b9d1f4c07415869b5efa6c54bdfad44988bf11db64219a9 ddcc21fb4cbb8cbc036662eda81eba080397bd181984bf344e858d5c5088dea6 4d4330029ea43ebaa8efde95cff2e58e3258cd92986ca576375cd88cc609f9f3 3a4db479c9ce28100020294dce99781579e36159132a932a780acf5a04146c1b 7ebfae3bdb624c987a83b1da3a59c94bbd78cd5af287eede2d1014528589aa60 dc851b1960c0bfb250758a4e3df6d69845a015b8a667509eea150e8dae9855f1 5e06f82be9c84dfca821c5970eb8deef2c5a4bf7071f2fdbcb91fd0b373639d1 f9b4600ca2621b4eb57d59e2badda3b3b2df07f5b800cf6c9bea7af33cc4b301 f953cf8b9a244a7fc9c0c788806e7644f5966e6cd8bff9176cf56556e06b84d2 2608a74ae2c72233a8ab17a87c403adcc9f86d33958986972343b9525943d61f 57c71541b0e0fa0c4e1d545c92159b6c3b8d04afe1ea366ec3cfbef2d34f4aeb 9790ab107742819573704d4e6665a872e4e6b1ed9b04324601d4e61045bba199 81d5e56fb9a269039e814cf43077f5223f15addcdb953e775bfbe2a3be581d6f 73af4c13fcfbbf136905338d52e6ab1441a663955e8e814692cdb8e16f0e4735 b2185efb468d143a47b463aa5dd1b32e41e9d04cac6000e484a9505b49632d5c 6022016272a2d92ecde35f78f522c5e01c2f7f5f0365205f21bacf15d176cd0d 332f947a1f6baee8d64175c418fbbe38bafc36e4ffa7b2f781c86afc597cbbf1 c2c10caf2ef735adbc64127c38a19fd50370bd558d74ba1e5cf2daff17dd901b b32ab3b7cd782948564e8d7ce53808383fa4e33d1cf632f549770c5152a9a2f1 6ba88defe05d77202a474529b697878b9a0b6e711d7050835a9e0a374ae64fdc f8c634bc70bb1afb9783cac5bb635d7df5d0d3a9387b5282750f6ffde72e1c56 15581fe32272902b1cc8ee5d242bff986e8dd0f7241a9a27b66f9771ff7a3a17 d4e0ccde929a7f047187044bb95ab7b2752b40d50f32ee68c8d4deade8b991d3 8430800dcb46bddd9df0c949aaeaa71a3e1b7cb56605e0d0a6d1177ee05dcebd bcc6ea06806a3a6f672160162c74e76093355c34d65a3155bc360c994700e207 d1c2832b58739bf2d6c5525f984ab4e8a1d3fa8cfbe4a51bc5a2ce4fd3fef6df 6a6bbe99e654fdd13236f6278f9f5064f580acbff8a1e906099024e21308a1a6 c65d046ab3e0cec20667b4f1a7c38c21a693b72fff7f12f80d767af8e3db3578 5bce1052b61a75bd1e80ea446b3dc1df6ce7531b92c34b1334d10c7fde7c5fc3 debf06281b55d4a26c5a68cb2abbc4496801c032bb7030936e9d897421168ba1 beb8386d87ae229e22aebb4b755cfb2f88356a1cc5331de7320e676c5d8cd3d5 5ad634afe6cc36d6521be097ae607629a0a5a569e95f8ee8f6bcb79751d68cd7 669d16a0cba40f540a204691f13354c195e2a24c5b01fcdca77eaeac3d8a4088 2c3c5b7c793af03283a9364c53c64687b32bccd6c246372dee22b074fdd09e0e 8fecf737b78691edc834625ea68d6f5454ddbc2e447068fd8505731dab11726c 1de3adc58d62c0a0d097293ccc99a2f0272f954893e9db59da7d1c8011c48751 12a1ed8525054a87c0783ab949eb4a996570149e2a93af15a1baf7f096ad01aa 5bd2d6915bac859ab5d68867193c890b49c01f00993644fe6982bf8b8a8c6d35 e6fb6d8e80e1cfd220d52985ec6c7b9ee7d2d4161b8a2e1d8cec96df624c4d73 634e814b07f4e3058948b7e64616bc09b6248e2bb037a343d7efa553c980afe5 d2279969fa62022d458182199b3316e249294b3734e3e30e663f43821ee30d70 c50c710a7a1ded10be9e5785d304c11d4c02f363b1f862ed9ef771885be52fb2 ffd6047bf37d16d3e02cc816cb8603b5e4d98613eafd4710662ddab66a54f8e7 ef3fb8270486557c7a8f3b040ab7a800dc916a0661556d2bd6432f169c538f4b 07af476fb6d48ea6cf197afb5f4f0fb62e92345c02a2a74b3864a5edb64d64a9 546f71a30c9b6173d92cd7a02cd60f18229dec62353df7547a28265b53e36131 21571a51e2659168ce933fa8d34743fcc94eb92c89cea98243f72233f115d7e2 7d8c2be5080920a54ff0dafe8f152d9f1b1964cb269ee8f20a2714f6773eb14e 27a1db2e7ed45e0a5e51a7e1c88abbe0abb84036236c3331fed2697e08988521 2b73d74acbd5e25e7e560917c26d48e3ddf9673ab3a98b74c67b001260ef5dc5 6355be92d496d26150acc4dc1bb2bb7e6c30bd58d16587ca7eccc79f55e5f40c a6144818533f7e5311ec012854326e36fea94d5950bad1386e0abbd4721793ba aa2bd99db155eaac09d54ecb4da80393848844ddd9ee0f25a921e5b7a993b3fc 9ccca4de1ac85e37c46afbba406faae25be58a76be28cfed8bf9d3112733ad21 0505c0ec120d85eb26221bac0d72bf1906cc172fb20f9be01c445854dd1974bc 48de5717030c767ab2f630443b90782d0055f6fc957963fdbcfe2c939439d639 a971e71ec812c59528d3f24a430ebb0a7ba38974b1b0a3b647ae5f858b4ccced 6b5cd75185c47dda1e354556ac1a0e555d9db105076e52ee4de7a72ab16f39e5 3c3b9b13cb8a5cbf058c6b850df95c1054445f76fa814acf1205418f6546e133 b55bdffea66faceecfc5e8b0f82c3d5b96b6e5b5dc52fcc9a392d028fc01f58a 3db9fbca2b634ce4564d57c13294cc4bbdddea266a25365e8950a6edec1685b9 3aa40a2f9d1bb63e8f8076e0149cc6ba5770c1614acb5e921607a74a492f5767 d82eb68732336ed44f75c2b338fdeb966a1c70b1ecb566565b16137c539cf2f5 6fe35445c21f6e134a3326002c0c190bd189c5f27c6957adc21c9eb8dade8ed3 a2ddc9fc4a6ac13c9d25616d6751415cae39b96fb029a6f9edcabaae451eecb2 0113f3e8e48bdfef9e0a8ec40c9ffc33fe1a04e35b968e3409bd79c336b763d4 261a9644a7f6e10af0b903f01b2420060b004252a00ca05c6dc22ad4800f9d59 3752c9944873507565b8954ff06046daf4f949f9b8d79932260c1b3997957076 4bb7088a1cbc7a6918325e5a73193275282c4ce4300cd9686d667c7f9a617517 f61ae69220c65e13447ece497d6d908e5f830e1fe3dc44ff98fff0e4a4345d41 8418ea4c135098ebc8427a75c41ae64193ccefe54ffbe6cb513516b5745b8ee0 02f825a1648b9b1c8c4ea94ae043cb4b73c8b01a77e2bf193d678736c75f84eb d5d65bf1db73390bd2ef41b31e169ce81ff2159a720a6cc328dc3821248dd88a fcab6d45d14b38aa9421707da0ea5b93190178b174d06ba4109dbbb80387f9a3 df2c62f1f0ab82c3765d537f269028fc821f0c23a970a4ba8f40c30ea303110c df1cf534424cfe43829e4f92884cc21f069cade533a1094dfc22813b06a8a2ea 0ad3f09935939185f70e5bd0568d76c357dc9a6a0940e06fba078a0dacdefd46 4caf904ef9712ed788a99036d395574fac27e6df478e880f775ca098d920d074 cba1da34d12d7dd3dfdbd6f39b45ddf5a0947bd160c0f667d1d46a85ad78a71d 5d07585bcfd4a90b446598fee78213c1b0b1178c7998649d9427e3fb326f3505 d2c005d652aa3414929dc315f228393a97046639039992c4e0c5232df88b2a0d d70f9eb737cd3ae4ad9b6a3661c10eef8bf2e79d3da8530b02e4bf5f425bdb30 11547844c338e92a94a72fc18c1fea869730639e7b1da3b8874dc922d32b1429 3395b69a0903f7646860748730d983533d5cc4ccd1b0cf4b55df5e66ea5488fb 2b709b56ec5b5c006c71151ef387e6e65f8a80b8bb4e7d111b345239966462c9 755446312992f7a27158c327516f427c8162fa4962d3285ba213ccdcde803c5c f3216e0b90187380ac9ce71d2b02c4bdc757db48d44f587f6c7f4a7f86192980 ee4e5a46f33ece0f2acf26cddbece3bd0cc09dcb7807d95b16d1cc751ff57240 eb84d02069290b614f70b46c71a10f59e13203da30bb9cf4f72f70130b803fd2 afa4e080ec67f9d15cbdb79504854b5d03dd22ca685e5ceb4133e0b14abf7d51 1029fd9e6d3458854ed99f4223c1d2161c540bea84a363817fc5b8e7ee8fc4a9 ccbd26cba610b4a9c3397349267b670588b75d335d9e9edb5b151d6c424d4c4c 61911b8e32f36c8816f4a4013bd67efc05937b9f897123f61e4eac6a88b8d135 7aaa07a56e7d6c2e8125592c0c0bbd8520124acebf6043cbb0c89c90cb1ff64d 85a35a7a16a10c1b3f48e37ef620862a11564aa96dc80dcf748d29031f641ead ada40d4aba58b8d7f68e64fe172c1bf527fd4244bc229dd54dd433776e2c8a27 8016327f09401bd6f5558d3a885d316aeab8165af24cde5db55a4e3897f116cd 2a09bfb08636d33501ef7b01a2b907537f9ec643552f89551e207b19f3191307 9b9cdde443552c29488449b6e7abe4a0f2aae000cc43ac12a18a4ca8c82ac74e 6501b5cb1a997ffb237c345add27f0b9b1bfe5c57d88277869c4bd335bd27726 7d9dd3f34f4e111453808a41e9fa1a1df0d056573351702aee774e42169ba958 e997018a8c2a155b58b1a32c7e51787005378e10b8394deab895bc329d5ba8ba 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 false +check_ring_signature 023fd47514cf450a08b827bef3e6c3bfa5ab451d07d32450cc3282cfa673e902 ef8564c1dcba06245dc1cfcdc75031f10e1a0dc2020940bad64679ebc2cbf5e2 32 4b8149e2b39f7e8b535b72876b034059591daff044d451df83fb465165bb2c15 0206bfa00d43756012fe104d42b2e4795aaf8b4b7381761436cc72f77be10b08 2296bd981c49b1bab0fd88d2d20635125eb514663e6df602818bbf4f9dfb53c0 0e2ce1498d11412b51be78af3ebbfb24e8f88960e24556f5ec46d9043d9f9134 8d1b4fb5d35b55c5d19b5c2e17d5f97bb8d05b9f16e37699a8dd9b319ede81d8 f2cd95f099f673ce36e9d0300bfd64ef13f42a72f4ba644b9825478a25abbbb7 98f14885da338bade2f679b293eb87a0b2a4142f4725a3776e5d5fbf9376046a 5427916a989c72949e5268ddb3617eac255cf4bac9792df7215e85cd9d53b3ba f79eaa259b026e5c506e6844230b01ea3096aeb0c3ca78b61fff6ba4bb5cff26 cc120fb601bd341c637ae69707a2a040c1bab044a6935f357ee227165306982a 38cbf123c5001ced8956ead653290888909d3c9ebcc8678be7817352ebec018f 5fa35d6f1003d37240321070b758f6af55a5f448a7753d80f885809cf7406f15 9541d41580594c1b20b4e33ea75fa9066e6dedf5b91d0c3ab3ea7dd350d0a679 85f05ae9df65027fd50eba86f3ba5486e97769629a41f4b9cdc70bc3411861af 774cca36e9747382ce2fd5740fe734f2d41962906c94adcc7c47586ac98e1664 245b4dd45e800656b7a132c189764bb992e038bff2f0f8ee6f8ebf28d97cc250 d24e9780bf30f1c92214a906694a29b1fc52f7f38a5cd1f4c824996b049c7f2b e0e5f303af9823f241ec05859f37906e022470a8c97a8ca8acafc8f1070eda19 2b419b5d4557ecc0aaa3d5f00cf1294435d4916daa3b08e0a160ee4664109a25 9a24d6bcb53e610ca3bb27155c238a7d24dcd233344ac36bd43e9dd308161500 94b0072fd69c40f4cb23e9df36fb2b67c3907fc11ebb0a9846d0f7bd83d1c84c 24c2ba9b9a17d7d61d1c45995c69bb7ad91dd425499556c76f302bedc11252ec 55f49c783922e433a6e465283670583ea27c309560317e53481431606d845d37 83aa732f5f22382f9d704d80ab2077a166dfa5690ceed8bc8aad3a52e36e46d7 7348f4435bcd58ae45fed1c0bb26ebd273e941dac33ab7649e0a91da75fadde4 3a597392f9eb4dda42032c7d91d24d3cfb3c9f6d50ea85c5adc8174f78c5fc04 103ba21af097c6ea6265d56a956af038fe430d7fed70aeb22b06f1f31f92508c 03feaffc47c0a65dcac3e700b492b5c60ea7e25054c41e2e90930135a55393b6 de8297c80c497bd7539f1d68e44c2b8c5e5a626d2b830b868ff7c57f731891a8 f6c6ab844d56c2f2fad4e754c66c54a626a1202003dba3da247373a2fa70d765 a927715957b740f871063314d3274cd7e4a716a914234107bb33f6886631f06e 6c16e0a1870cb68d379d7c320572851364058b1e27bb155ff8231ad4f63385cd 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 false +check_ring_signature 15a4b76f4ab52957a26ba78d5d3b8902ce67e9bee2f5d416dfddb7055c5de203 effa6a08e4ce44fcb74829bdf5c21736caabf3ece1c983a8112d41df6dfc0c7d 30 16452f460b4bc2335f6c5adcf79b3e0572e5afb1b2cf3376bbdb317bcd75c544 d54b4344963b83cbd9fed57172e6ce638511f1c72e40fc29078fd74ca08ab9bd 2f0f204e196c2c7104ba913d3083757ececa8e207a4be73d38d375428a4c7117 d1c99e24c4ffd066bf155203b1a6ad80474abfe73190e88c93571cd09a163b8a 2f193eea6f6bdc69d829a033831eb8c34ca1c15a82a2ee5a42a43963a12551cb 482e64ce1c852564a80eca2513b4173ab8a565f945d32fddc7dac67bb7ee558d bc1938b128402f0104bbbda91e6bfc352de670b2ef67fed1aa12a14ee646dab3 26d2677c955329f7eed1b8c3f50c88fd12326c860c86ed372c0d646c056eb7a7 016476eaf6e760f65986032974b9361432fdc1267f17634f463e2199941e3536 dc36aed5b97edeffd84a45c4704059745c3739478f709aa104dbb7bf4f1598e4 3a477b87bedaee56bcf7b3fbca2d0651d4060269cb50414e905fec81701990a2 57c195b0edab5d1856c0935781dd3e10bdb90083438624905dc14b2fc6c37440 df73cedc38a9b083642e949269470c0382a9d32a742a55b54fef241e94955dcc 86cc77249a358216841e4b4f603c2ef0d5b2ca3f7064c3a1fbe33ce27427f51c 37fd12b4a9ebfe65cbb74adc78c994eddbbc795f58a09b853279edc01cca0433 8b3cfbe2bb920937c5ad4a168801327efb494fb195b3ba914f673f8c581d50e6 941334074ad539d8df23315958f96d2ebc37cec900f9e77ccff0f37aa089e21c 9ea3b26e85d02e70afeb26bf3d63d092e9c28ecf1450d1c2edf0c8def9c05aaf 7a546784d87301ca6eafa8307cf01196456b8e60d6593f50affac1396d95eedd 3caf7cafe1fbb88569ba004c85fd219c832c0f9e8d5cc2b5f0f218bd8d009a08 a121e6ab1e4b0cb1eb2fb73ad0ea39d809fa2dad68a9721dd5f20c9a42d4f9ce d3e7e21fb6b2ddcbfbdfaf405f74bf019f064174771ea68a0851954205000f86 d0663b8d5f4fcf3185df7190b4019b5c34b579dbc4137950896e965c3846c585 6889acf03a7174ee407c8a8db54d8f2a1f43b66af006b820717a7b83698bd6f6 6288857ca4a92479989dfe8b87d31bd0d3e3b1459b7d67709653ed0900989301 de6ca839c0cc5dc2aa2ed02d8d61b0dce6479068e5b5306c16916c5559822c77 1cc6365bd0cda9b8e13c3c5e13aee72244fd02d60f7f81190d9c3fc93fdfea54 c707c1bec81a3ebeecb8bbcb57e9ea28e314547c3a52ef42c1b6763cf425af30 d44603baee7940e786cdc1201b35bb9ec83562638b9ebb110c89043881d7cb2f 8dd007c2cdf01d43fee408bf57972f81e7730990e39f42e0b987d805c1c001c6 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 false +check_ring_signature c6d79acf9467f7ff14038259704ff1b9d793f5bc60470922d54499f1da5165ec 6f6199353c0dcf0390bcd4b1983b80ad61742167d55df7e7c4a2905ab092ff73 2 7b95d40a5c3dfd8b7ae249a2133c979235f3936110d0d08910b42189f6979021 41f95192c8a9ebc548db03458d97cba0fb667084c21e4de791950874b1de098a d535ee83f6905240801bae17810d996bcbf4a8e5c02b70ae84d7b16da72c230d8e2a2b66a12cb1dea86596c5fe1a9b08f730d93bf6a67c49bf5afe39f243310c7d6fe37453fd73a37c337ebcc4f4cecc43a7fd7b485ef9f70ae7949aa8f8b104028a5f4a422dfe9fbc06c8b6ad63f1f9b45a06fb390793135db29e1fe947da08 true +check_ring_signature acfac8b58cadee24cd9b1aaae0abfb72255d6c5c10b8b2d7a02a4ef74f00edd8 55279af1c5316be1a40fa3d55a6fe66105a79033052f206df033840a213b3913 2 8eb913d9da06649bbb1aac008364dfff7e65de56438945edd7592a2dda7a8452 66b2b1fdeffb23442248c2babb83d9e7ffb7522713fbd3713e011222d37bf212 f17964a75667282f2a5978c666668266cfab44984926c980fd6e1c7bf3e2590bd86ff442a51ac72be3bd42a06b481ee15a93bd6adf1c887021607c6b40cace0191429574735fda842d07bff148586173675ac7f16c50cdea21058059d41cd20e75964c82ac3a960bac1ad7c83931629be8cb7bd782bef045aa55ba301d5a140c false +check_ring_signature 9d7f3e97a5a53867b57e0e3d38700a4459e45038809ed6fe74b86f984281a6c9 63940c2800803ce780ea9dc51fbef2164cc7323073323d6fe2053200804e806b 4 7af6fcb47eb2c589285d25dfcf4277c5bf264c55882d586f355c3e5872c28e39 c75adc06a9d5cd4d6ceaeddd6ca778593cf34dac3a5c65bd25ef503394304d15 44b3f7637a8d30a9acc64763fbb182d03ef2d018bafa57741859658dc560b38c c7d9a7fe91baffda8e381b0792437a5208c0dc5191097b19da7b2080c635d39f e3e544b05ac8d384c45563571d67216497b8ac8c747878c922bf6fa5ddb8e406c480059fa4fc4a218c151dfa9a6f3740c9b3be982ff2100bc67fcde5d28c5c0704ff38748c7266a7a66127d2f6a044d6c45755b19bf590bfc48bc37d604c610f1a4edf66a6f8d9f118735e7199e477723745d71be6d789c447bcb5ba8470660eb6b34e08503d9b62a0e9a01904cdef867b7f709a5c618dea51b5a9329b4c990ab70f15ca5de9483bdc2e25112b7b24c44f770cd5d3e7a8806aa877eda76f1f0466f69c19c670c22e59f7f4dffa372dbfb8854c8e91f73aa0f71ef20775aaa50aface39e1a5cb9a31f3cda6be3c8e7a5bc7887357ee7047e42a21ead519a13309 true +check_ring_signature f860e5670345968f162300916916a23bc59346147cbaeb1dd50693abcdd1f2f6 bce6655630db94851a0ed44116490f5cd48e5ed831bf33ab86a97373c03c25e5 8 168ac2980f67cd39a4b01a7fb62f3f4f92e827455acd0cd0b3d1ee3274314214 058a45308b82ed8aad93a3eed60279d88a6b904770419883fcef94f1dabee341 62fa86e203717bd804d8f2a03808a221958a45d0ea9aae395bc2680e6d550ef7 1def9c4f2f3dde3bab8b51e515e6b2439bafee0ad454f37842d51d1ddad4e542 52a2493a82bd89e93e3ff75b3ffa7e2ae6a603f80f0400de1a5925cea9a92c35 3abd34a0e90ab696f7ab5a352f7e2608c551774dad1356e449eb326041a44de1 65f41dd5293a64b3a35dcb4d9e1103c3a23b247559231fafd1659ce37e88712e 7f3c6576ef9a1a2df40b57ceac637e0b73256c708abe75859ba762c31e24f23e e83817789b2ccda20cba7b705b9aa96866951cbdeb49373bd4e298db42750306b480568ceb63c17bd350d60ef6df2244d65e1a8c701190b704aa6996984c5ad73494ce9e6130f4d62ad9aec5978711cd6a0d7566c74c90c04a407c268596630a9fbe0b0da09796ee5820cec5acaa9e624e1a4c723133607917f94067cc42b8088181ac9e80558465bb8bf8b7bb69f72579aa9c98895982d0e8eeafd4153f9f0a2d336147b1f67ffba715b8e8192a064d48b2822401c099eb03e2e02677b44901d687c7ba62e952d68f586896bae99a45dadb57d277aa4226538d85957d0da806d185846a19a62856695c19862757adc36e14ec7fac127faf34e58d20b377000125df234174d37870bb4142474fdfc25384867244d3cfe49d02f8d9286ae2ed012347ab356712fd18c7907a3eeef362263cbf7be3ed9aa2dde1358652f999e00e9e06d16cd8340af166bffb3f48607b784bc85522b4fa393507be3e8776eea30b27bcd8dfb0b05838005a76618684b876ef490bf5b714e0e431ebcff2205be204377e0117cced590730641e9d1354b646ba1a2170368ca75128ffd120d75c070ef6906ebe8d2bf4caa56d6eb376787bc3924214ed7ea30fa8b192fa7bea9333018607c9a848c3298ae020f628e2848d4732684e9ec57b604171afb662f6c03e0ee31d6bbf63315bc76800035d05b7c925402d8fd62bed485f486fa3f5c5a85b06 false +check_ring_signature dc4b3d3db511b924ca224406ec2d9da0632ea25f8155923c40a661a5a0e0e2eb 8ea601b7eecc5b7a618e79c3eda1f473641cb6c51b88c2705d8316d461a9bb70 1 2a6a742e2c5e99026efc0d5cdc0d26e4a04f31eb247621e29e81bb237d34eda2 4c5bd6c8a8afaffe103bbbc8e777e39b75ba6b05b554da8da359d81168fae40fdd05c24236c91e9b9a06e4b8577ebc0304bc450aae6ca64c28efc7ab317e0a02 true +check_ring_signature e522d294273e71d8c12034ece67072c09f92121ceb8af6bee0bf1c8e99abb67a 79551ae0fe9e26ba1437a1ba4a563ed3b4776cfbcbe50fe683dbdb32adc48fbd 55 1ef00e1aaeddad1a010d7a7d7f0e771396ee676e9fedb2198f7f27756dd98cb4 714ee82b36c6433fd2228d5dceeeb8eda76ce9c2633f564e107feb623d700e0a d6ffb212927c8d977ad4687a38e0a69b74f31b92c147ced170fe947887f0f8eb 83fbdddd9691b80845fb3eac68e56c2ccee57c6bc7f9f1595fb4f6cf79972a3a 5bd5d325861abde6674aeaf9c6290da80f1be719d9327f930ae081c2b853ae02 59a220cf70300794ebf926cb359ea8e3da7a20791786d5276ae2a6255468ff31 2472a32584f185b6621c07a44033ffde522a627ee5dba772e83e750228db1503 5275719c56a6ff76672ab765a50f4901eba71bb21468cddba0072249b54548e8 089ff9217c6ba2152c37d8ef0b74cabfc34a80ca60923dc737c3e2f82227ea00 459f31e3c381ace2868a2b47c9d4c52f46ecece6ea03087d5a2212b77ba274bd 693135cd8a64293566707e99d6427b78b5a8ab784035751ac57524308d5afa23 d3185753aea91d4d75981825dfdcc0fe26daa1c0bd3c111775859a9e48b6f544 6639a7e3f4851826f918ba63171df8789c9f2bf1c4c52b4bbaaca64574c0be57 9c2e62b453c1e0dda2dd4f0d729e32aa45e82a7d01417b3b65bbc6c73f88deab ec1b205de6a646c1701fb7394125b38cc06c39074d485489f023157a1a02a1b4 787c1431c4e2c66f4d20daab9ef0a1ee4bbfe6e3dada832d5e4261a0423d47d6 d75e03dc37a61e72f2e77e84e6b527906246de6eac812f58e928b7293bcba102 91aa7bf486a0e08a0d8b52b4ce0888cab721dacb5cfeab89806da85c0a061ec0 63b5fa2c580acaecc7ed3a9f3b3da3b8ae756a55208bd9b1a53f663f0a2c1b54 e6d6f2b2d770b92ed2779b47567adf1a107089561ddacdd0b150797296e372b7 419ff95c4a6a9da94fdfb05f1178af3e87bf865240ae43a3020283aa5f56519f 44abb530b42641a1221ec8e396d619942e2fe2d0fe8094118a2fbb9939d31ae3 8266681ac691d462d68dfef0eebf7b4ec2903ecc09cbc79dcbd682c0f9938b0a 9b5267de2118c83102dfe1ff190e0284dac6d4da207fe9a4cacb92cc76a6507f 752164fa433c281f9c410346650fed6701b950747e0bac695a1d8b8b7b9959f1 f43eadac86614856e9461dc945b1f3bf8a73d18faf8acb3bdff80a67bc3abd83 9b44cc3ec1cc938e293085184323e32c3d448403312312a448e0bb2532aecfd7 e8b2442bbb64c20c35f86ea48cead3d63c1096e65bb4037adf9cc9b872f4fc13 0951cff207647aa7354bd5585fb158bba636e93b501309bcb04be34458e007d6 161cd44ab6fb6924ae19de04c2df14692d8ca38ee171d6d7d817fc55576477d1 61b95b6f77811e88e135405806d9491e14a895f0b661d5ac687907ad2796455d 5bc5fe90de49dcb23b30d2e95327e4a652eb563980b2e7d9cbf11d180d17378e 17e25b4e4671b3996adf4da195782a353938b407ee28b53cf80f696708ded3a5 a55213b49ca9a29084f22b120ce2203f9a6355453f63c08da37d5c8ae82c3e5e 7d982177c3a0a54f008a69be4cc709247e2c1875ca563130048477cd12cc9a42 a9e5dd93a499516b8d8238ed9775a1a01a4cb23f8427aa3e42f0171bf9b6247f 8afcc73bc0e16962ac1885b99f15e5c78bfd4420abae3b79bd586c50c45f8584 da2e7b2d03d48797ec189f8b5f4394a8eb7dbf90db83adf730a704b210700ce2 5555e572a204fe0be3a9d6fccbc92b8423907d6b321bdce2e9b0eeef68247833 cef0a660259393acd8f6a747f036682c6c99e1a130b343cb398dd54f50ec1ab9 44416138e60656ed628d1f33f558ced8e75dd306a1b3975670ae71683430cd86 3ab1e9697fef8e306a7f3da8feaafdab446b2bb225afa2b86f05a0c3bbad2b42 a3fdbf32c51f5be173e587919f6aea3bd3b73437b1d9727bbe05395285c783fb c3b6538d2ed8182a57dd2c92425867e38525669f59dca1a855e4eed31e5e693a 40437dffb546baf0875f5a0f665e1b411988c687c28b8fa9a8cccd55e04ac5c7 790f420d25698dced5a23bfbe46dbeb276d305b11fbf1d6b350daa4e07d34a18 d26bcbae86eab90f557c680d60dd5cb7778f3486b9701b4ef66c8b09e0dffd37 f36dbeecb59ddc2db4a8fb157f34cbeed0b1d1f5bbe432a7ec50b8be2fd4fb4b e292ececf6a9e091e23e9b82272f6d8fcf5f1fb48b20151e4755ad5893a35a50 0927f5a66fe620749a25e1374fb17c4d3227f9d580aa655f7b41bf37d50c5ac1 924d53b590b2de8c3c5fc3f850a7c193faea73fb2c4f25e5769e160fb851051a 80ac1e8bd5b859d2fbc37b89b93e9309c9df89235b0ad9dd05267b98552a1b2f ba276cee16c1310625d1ac22688b90d515112359c9630517c15bf437dbd24d3b 7eb378dd727655d182310f120362c230983a7ef31cc59c70043f8923d0ee3a5d ac96660ff929a9b108170b3f1ca7644628fe1f3b0c5b558b2667f4f5d946b29a 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 false +check_ring_signature 51d1f1e69069f042645d694c038ca24151f3dd2afe92e95fac8a3c16c60631ea 29b572ef9814aecdb56a3a4467e29e9eec1a0df691d9ff53f67b1e39f5f1462b 31 1f594c4ad175e2ef4ca86fb01d64a4f6c920632eef59cacc89fb7e27a4ad0342 4da1a51c491f1834a4f2805ede68dde7f3b57913d65d4f3e9f9e6745297dcbb1 416ca60db576657e8a3f0ee5fb037f88b561f05d60a7c39596110996989ce465 5d1e0b9459d04ccb576a9a92039e8acfde5332d5cd8d601d8ce740be091ab39a 08ef95ea424c366f9e30febaec7a576f22674802399217de695e06b7c3955647 159a9d4304af7729401c1e14d2ce8bcf1028d3f75b82d9ac837b66d62b9b8c2f 46b6c5ff22a63c4dbb57d2608b3ac568bc3633d4129fd59255e9c649d146d1b2 c62eb732c30d8ef825699c3c66812349049af354eab364dab88f4c59448c62d1 e2da3ad6bc12ec90afd759d0cfc6b6e30f2b224180e0816897ecc775a1a9e11a 0ee9800e8321f033bc4b13b507dc59401b9c9ea582a34dcda6b91180e212860c d25bdc873b229622b63671b0eda5f1cf08f4a511bd34abe0b47a7b7694c07c70 768fbd825468e73d58ef335529514e1295ae5500213843b4819843cb0192d68b 2baadea6b4c349cfada0ce13b83f4b394d5c98029852dca73adfd3146b4713ba 15d31fcec0527d5bc3a415611a08822eb7f4a27a3028930fd80a1a7a73c2eb85 7b8d3ee384cd95559b02b26371eefb4ae9aa4a0ae5ebc25ef2c8dd8627fd4e10 0c37eb117a26278f4f67ab81bd6ab912a50c0e49059388101d91cb02ea84e401 8c25421c4c45ac19b0c4c2f9d192e8799b06c7222b1d89a0da75654126ecd9f8 7c51d1c9e48c1c9a753e2fc98ada690bac70880bb54b6db242d8c2c2a94c2647 79c39e29e61b579501ed7d5b806870ec86ab19bfa6a6929ff74629fe64a54ec4 cc5d0523e14a8cf21ee4b25a52ef394b1d5677160a95f2bdb3209159fe9227d8 5ed33746518b8ae2e9f91e66b2e45c953539f2d8a4d4996e44e9d58f6e127799 81a0fdba95868f13ecf0a7a3d0315881f1415decbce2ad2a6418e079987ac5de f4ef8c3bcbbd21247af52257e42e97c332a0b44555e64974a44905e4e7e7cb2a 07ec90a6a5a4d2f8e8efeb216e32446af53b8b51760c799a38c7abcdea52840b 178e11db7595bfd5b70f801d484d82780155fdf27021990a4848f454ebee51d1 527c8f0dab1d54e196b11c746c0c06d1ba81153a8c90df37e8fc6cc4e07d7380 1c23d90d6cfe101d87356065183c53d7ca980a007bd1e22f16759e763cc53bc9 5cdbd79f935fc81eb00e33952deba6554437032c9507c9b1eccf907adda8b0a9 b8c8e863904126ba4ff37091f5b0250b8088d6f64f7497ad8185726fbc48b64b 89b369e179ce56cc3f96a77b90fb2259ab9e4baf1eb93c9e38851ee4452508c8 f57a2ffe9e6771b22d8d09775d87f73b924a87686c960a27f96e9ba4a76857fb 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 false +check_ring_signature 746971bac90d436ef9d2a96fc0ad439eccab203b06020c609f24f97ad2775c7e 15a17d1f22312cdde515d3034ec4aa71eaba3dbec9b15e844d5222c794287ec7 17 dc03b8f9ef4c33e4b82844e229eb7d07c49b8b9cce6fa392cf3876181bb041cc be6829fbd6d5e4089b5705ec83121b902b83291d70456b15a142dc0aa1e25e2d aa82a6973f65b27c36ae43cb73a94aca0a3f728e94f806321ad4b3c89d872d32 f2f0b07d949b2a3663657d8f266def064a942131b2a3da8d7ca1e2002be055e6 fa1c7c32aebf3f3870148052c00bc71c380c22afeb3e5dbffcc82a05ec9e01b1 5e6ac0b70d332e22c411562939cf54a5a234213b2522159f20df58ac07dbcbd9 6772f3e4405a71e292b163f6ab4f5638343e5cf27afb816f8e3f2be62b0a4ec6 3bd36cde8765f2d6da670de410dd3c69bf32a5f778024f186470b56466f126a2 651731ddb1ab397d4b05589c76a543b0231ce419eeb131891a624ec76feab8f8 de00e228415eea071694fbcd3650e541e1518882b0f729c6b3237fe66a3771c2 003600b85c9c5eb80ccd6080b8a4a0162fc9ada6019c639fef39632c7791145b 2885d2ce7c23bd5c005ca3f261eb081711cb989ba38f0c3c5adb58d9a0921796 8f3a359b7083c86be1ea995433f86b10d849a9d81b743d7fb1a72c691bd63f2b 7590b9e4a458e7d1b3a649131ca04d4b8265e650f38babfc941bf6b37905ff4c 288e6e74685075071bc62a588f5a2f03ac4c826a256f033780101af60387805d 21e3523bc1b6d300f1594586d4b4b54b0ec52e854e04ee169c88b031dcbfc6e4 5936b6626ed80bad581b0ddb8e45dd359592ca1b4ea5a6786d3c384aa947a9ff 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 true +check_ring_signature 43c67dab5dc24e2a3b9c731ed270488669f6f4aee6a2242945c2290317990bbe 7619e4db581f3290e66a36275eb8ab2f137f44c8b536cc03ce3d1cfac90ef488 23 54e61a07e87edd0597a90d7d2fef0dcd8af2c1f3813de5bd2e1d01581bb34e98 9e2cee4e9b35d158a390cc9c7d7219ac5897c89d5bed4296b0182cf46e23c7bb 6cc0e7b88f1f57ba2eee222d69a19b947e66dbca06b485b67b4993f42c61e087 7e95357756010029c1878cdd31c6f84e620f0db18cb8d2da9a9764fbc803f37f 9dc4a87c327111483bb74eb55e4e917efc3cbffc2a7859d6f0204df564838e9b 8e97f025f4cbcc8dad2ac01f99b4ed50877efa9766c01a294e306ffc6da1a3ac 217c3107d3f0395192da0d4b939181e4c46a6a019a62ce96087370c5a03d9925 2a53b32dfbdb53b183116f97fb3eba373be638dabc183e51d8c79a3ab187b1b5 05a99bf4514b032b0319abc95a3b10c2ed58cf4104d081ca599329bbde919817 6665eb447bb94abcd8d9e86e1fdc71b9b0b6d63517819b6f9b1fcc14892c2e2d 9b4a5f132a9bb6f9adcdb6f3bbea977e82798e40ba910d11313e53cae2374761 a76dc7687cbe13e8aa78b77c7ed6291b5eb23ec965f1f77fd7f5071bce03a3de 2f7c2545bfafd201c79c60a88b4d757132dc6aa4965de31b670d7d9a8f2d5ce7 ddb8e6d334a576467d6f0abca65338973604feb9e00efe37fe0c869c8eaf478d c593c25708d84afcea7f38b93da5f2de216eb850df4de3756c1b5d7efe9bbad4 8eef731df2210f887c1d1a9c856bd747fda6da77063a84dbba715ab6c67fe9b0 117211ed56f1f302dbc9a0458dec5e2d5665720e53c8add1a387e0bc7c0926a6 999297f069c48b9d5dfa83dd578eb2c9f2c6fd634b84ef5ed820fee2066a3a9b 0b46bdd8168114dd17833fd377404255a8e9eaa80d3619fedc77bbca99d9cbdc 56384c27bb3866874a4d09331df42b0832a71821503048ec730de5e951e496bf a2c99750a5fb38e30f61bf437d3ac59ce22b1058d58ceffff041c6b78056ac44 f5da3a19789750ccd391dbca16051d1d7db9de1dc71d72c43623c5f5afe78af9 99f7fe2b293e174ff627bbd0aed383c496657ca94b86639aa0491c0b69102b3f 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 false +check_ring_signature bb232496d8d50a29e9075e7f70310c0fe90e95122ab03fc9c0e4c22d67680d6c ac560f8bb576db54de6c3684f25370b0c791dccfddf3a0f9fe41675b3da1eb8a 8 c932168b3dbd9043c4d32699b8e0f450e313ee46fd062c3af5de3d8a4edab63a 5e1cfa899ab05673f6a18515db603535caf7a3d2cd1a0641b0d367ff142b13c9 3d83f44857cc95d9ac263f3144889f2c29e8a12cdd81b36f45fc422f629ed571 a2ff8139fc5e399637b428498004f00eafb6928573e15c1e2e64227d629c9fc0 8aa51c3e7769f946025e6d5474081064752b8cd177aa1af7e64096327d58c97d 444283a83dbe5c7234a21ae58672fea063d5daf29330f86b7c68e82078ab973c 97be5681bf9ec98e937f2e6dea126797160ebdd7484ed84d9911b6b6a8294eaa 4abbd9abf19ea848614e0e910e43f1909085bc1a5af063a3230a84b0637de192 8b3341ab3262436849aec8ee8e8d69afb0af2363ac406fee5e2e08596a9c7c05022b83837d5cf2536106365a87d9437464acdd0980a32f832a65639dee5d9f0acb9ba25aab8d2037843ec18d902277f42bf63bf1d20bdd05b7d41b4dc6d2600d861dc83cef1df27841249b9852abc20c38be1fa4e9a703b44bddfe9850121d0b3d3800acd48fcc7bb73777efb0f7c367e85b343a41426078a4e8ba20062e74076c5a8b4d82bb9027f514486eaa40f080c40898ea7ab40d7dd311aafba93d120194cc17aeb48cba5186a128d9ae11b096e559c3cd7db356fa8098e757c5225a0f44786f45f0b275d1cca9e934a78c25142902f878c82058b25888375a801c9008d92e028b27a93cc3f42858824563d011a99c036a9474ae5554d35f5cffa25905a4d1011011ea10204a1ba3e1bdb5746eedea375ba29d44895e0108b7339c690d2098a14d001e40707e44e9104d945ea25f59cac41974f82b55ec12f5ac1b14024eddbc2caa1bb0719d703e99aae92dc2c9effb1148c6938c5664d63a84433709eac9a8d09b85c63b4b05e47415ec033cca4a14e6da4bab51b8a7193fd845150ceef239760ac4c5da2996881fd9164cd9c714bb46309e48982cb6b8d096c46a069b8f889157f4bb178aad3a4b7de1d9792430e101099e903911cf2360be0dcc06846efdc425e4d62df0a0d6f033f7fc36ffdbe0b7e95eac247ff8e8a738f0cf04 true +check_ring_signature 3df25b8fd7371d1c1a4aa53abe841593c1df1f0700ff2105b80e09944f2ee033 bc72ad4da1d602930c1e7366fda554fa7696a5fd69c506522c831ce8905538bf 1 6bc0a806cd8517385bcac3d4f4118d7fadc89ee6c739830a8b03d97fef9b7159 26dba86be656ab5ecc1a16f14257ac318fbf09ec63d207dad2d96955d7551b0faf9729527eaa50673db42ec440d177093bbdd40b15051aff344cb61788a5b7f0 false +check_ring_signature e2ef9d0c903b49dfc64407a7067076eb8e4443b9006062ff7bc773726db419aa e0bb98395060e32a80c2cf151bdaf68ef088536d7c983d6523fa663799e711ee 36 06d8a21662534e26c0e2fc3c67796e141d1f0df295fb3f88391bb5a068c706cb 3e67b25d99d22c40493d15d0e0bf09f480e676d2a51354e08972e12c4ff92172 f01d1385cea278bdca8623f8935e5bffab20e314761dc8d982b10bc454849a22 75a724d3ef788868fd59e38a5b55b192193f2c428c5464a0d16efce5f1f90852 03b1baef94dc630289086907845921223475b83fadd48c397191b3da1fa74c7f c1448b12f02a273cd30209ea25dbeec9981aaafc581762ecd4db681a6e211060 4a8c42be13c4da1031f5f9d3d0191e2892ef02aa056df5e60ef10be7c229a933 bca0aabe4611e6c70ce23efe270c1341b08602781de11148c2f96820a76cac9e fababb1026e9e22447004836dfd8dd86d80c91421e187072d8d3cc25fdeece81 04de60c236e72fea6a1061c743f4ee2f5342185deb61610543a80f5e3b125e69 6c7fe57ef43ef63560c116c05719daa672664d5f4de2e48df7a61a228e987a76 ca38676ec9e675291af0ba62a368c1c4606ae9f16c3e50b7cb46a2a4f71e7ad3 b95c0d1cb9753a701614ac64b04136af33f7077a45f482b6953b08dcc0112e8b 33746a4f991a42738e5c96719e302d65d49b0b0e95f420d438caef542cfc712a 2f841ecf1d2d1ccfdc79b1d0718726c2cde63470a184bd40ae1337d9cd982900 4ea27ce3f86b0c555b3b7f9a26f804c97ddf66d101cf0b341eeac51aaace821e 20075fbb836bac47eb28f6fe9835e369d3f4e2b15da96602a42f2a233cd3a16f 0d6b1ef0e651e1ede7cea0d7e886f5238ff27284de368abe85598386df1e2a2c 4f3a08cdd205d87c561ed3eb2eb23cf29cc5b04c0a6f1eb2e3f5aaabf15881cb 7c2345f373c55bbfc7909b92a8abfc4cba9ba214fc863e443c7982ad8b072134 82676f7828eedfc4d4d03b4fcc7dd572141b28801a5f769d7efdd3ee7078586f 8be15698c5e7b634c77788673d2d2e942434d22db3c154751a4ad999104844f5 1bb00b48d364452542a4e16cd28ad898c78535ff3296f2c28dd765577770c740 8d2bbde978bd02e070f215f2b819ff75426b6cd0ec93d16f91ea4fa2a53c9e2b 9cf7b4ea824aebf2a85ee0c6f093a2e7323c5091df75258231e9b806bbcc0719 81825c1642bf7b6614d1452feeef1a1ac855912cf7f74d9e5ff05ea170daf4de d888ef9947aabcbbb613ef4ee080cfe3b31f8abf8e2e1a786ec0f3949a0c9b76 55b24af9455e7b1ec5de7ea22ab9a00a7a4abb3dffd3e0af5bb5509318013e85 45b69c52ed49a50068d1fce47e40fdbbe6a7ecee25186804dadb24e78e743b1c 76072e98111b3e973cd41324574c2031b989fd8ec719e36fb2c5bf44a371c902 0e5abf71ad5d52b751de0e669e08b1d0bf14fe996f199b73a12d165dba1a19eb a006c621e0cbe0a91c63d8e2cdda9462f3d81f3fb41c7f4fb476dcaa684d1318 c6d58d5fd7cf2ae80b49c914ad5ddeab715bbcb1af880666d61f82e7bec085c0 6bfc8b726ccc03857e922cc0f703ab00ae98bd534183aa25ad5baa460e6d01f2 da7e5b977258df955cc82fbe5ba1a4220bf776b9b1ab94bd0701f53c7fa9dec1 cd29d5e03b28f07a5c7350863c5e008a4e3b2f5b9b77a4971e5754e142a107e8 a5c6a5aaeffd692846f697ea95372fa4147f26effddd8e1d63df7dcbb8688a01b36f39e9ec6383915272d105f90ed49a33614839f21864977844be969fb95e075521e0a13980fa00e2b8cebfb9a02e8833c7e25b4692e13b4526ee95aeeb4f0b8a292cca0e44288f945ddbe207e7b3242c68a117acbb3e811a2061cb80d0d0044a983ea50e5836b9f4696ee3ff1ffb9c24f1b68ae011edeb8d3ef2082aab8f0074700bde83d24f97e679ed8c89f1eb07a0f0d076cb58818ee0321c690ea427033843c3d99f31383b5a568128ddf43bfbc4d623bd0a91b9dfc2414cb835fd2e07a62f585c397cbfa91b926d40159534a2bfbafd5ba69d268aa7b4617bebf5ce0e782d458e3dfc691a76783a968729040b134e0c2fd98907d8b822c4f3de573e018e4ea4a77a71ffd0a0c3a70ebadd533263fd91dd657592e21c6d287040f63b05dd3c3ed17fccf4bd8210d780382de0a43bd27828ef4db6cec6ad74a1ca21c40853e38b86836532be345a2129661b1865d820d4d45645eecd01093aad323ac507fc3e2f6f904141fd6b945ead8542927a8377715ca1fca66cbb7a167a1fe3a50ab3882ba15a4059c833bc2c70fb57385970ca2d311c95cdf0e3c312e5f334cd006dfea89ec6b309c0d8af9ea3ab990a7817001eb05503168fa9ae41c48db02509f96fd13b73ff9c262d6f06ccb7fb12af3deddac1c19a49bf56a2c94055d4ad0d5f150cfe7e141b356ada9ab07185c8824bde9901ea61e4ca8ce8bcbf520a220f4d9af95e6dde31d80d6e7ac897e4aabfae81befdcc2353581f1cd14349198f014618b14e862b88d345d70b47de7350c00f8b70475173207838e58672ee4aa7080ea1a9bc3bfad0e36b344f10dc6b0177a6250d73d21ca15395fcf0074bb6db0c674c10b9aacf354bd79c45da90fc98b4d2ddc4b4a5a5d2c7eebc7bb7a11f750e21644ef6d70ff992773045f8199b663e052970a28e7b71b170427dd1e6229107738d1153be19bfa7e1d4253d0ad7712274b5d9408e85c3799417eb149fba7202328eb592c45b63c4a2ee149fe93e341df71acea505ec4ece8f638880e70cb106ebb8d0a988a1c718dd959c844a3af383cfcbe0b4422a09c73962ed2c32d3e306d48a931bb2c92c6d27d33267546b6cd7c55dab86f804d38c5d4e7fd8c4bc2704853218701d2965bce2a7eae0079b043c5dee4314312c9c30eb024245ed120504bf3e07a83b97a019fbccb5b03dfb32a87254adf0430482987b84439a3ca4f408b13ffa633af3def9de1f41cc483fa6dbe09e5b84411a7169dc3d28f9f86bcd0b113605db4cb39a32a1a4225eb95788afc6d5df3e33217d1c9c6ad17fec500e03c2ebb9cddda9b990019ab61e431085aa607c5a3ddc0649042d1d92ff8474d40825ea84a1cd158b27638df8f8b5fe6d8e963167617d5e075d87f11ef75779370f165a26f4a6ee824ed4ace6f1ee0d9cfe13a7d1387f55f825e6657d670124df01640cfd99932a46f65f3b86773d36793151f2b900930c53f07015021ce7ef6808de60a5b610a34a85d3f62872ecf2a1ef12ddba025db5828596e67fd01870e40ec2f9de16e4a471c47ed692e2e76d0bf8126ea218c2f4042fc19f635657e3d506a4e72a734d74169cc5d005cf1de7af01ac3b7ea0edc67d6ddcc2467e6282350e89192b5931e4601afbf9c4651d5d57681f693ad5dfe74c7d9415a903e1d2070350e8d432fc28d566cf8cdb5bdd4d691c20f36eb66ea0d1b270609fe924ef840d94a33f8eb27a72320e77182c94e01bf2e6f11a7a8484bfb0a5209f2ec88cca0b9ecacdd62f3a3d18503f14fdab9b54dc2514512fb83ca333c1ada674db000508387e91625ce65c0decc5503a75a8d414fbc8aac9d297185c1555af1bfdc2e208c79b91949ca1fa05622a0a0a9e1184c983783f397cdbcd6fb81869c7d2346a0278629454f077e5d2d244dbbf182129baf3f7d9eedc87c4da57966e6ed0b1a003e0ce0036e2265d4df74267d11ad74148766f8087c2efb1c58cb8e2aecf3abc09e53f582b1d20cc0da1c7d3ad1a18c79668e2b3fa61988e047e92b5d72249a40a724b5b09523037f9382c637441ef4f95ca2240ac3ddc3130ff58e4793e967f065181eaa05152998f10fd5062944b27ed27fc4c2f9e3a188af55390f27a75eb0575e964ce09f7d8f5c0e7fa2176775001cc6e2695caaddc5fce3d343775230f027ca9f55a2f9a7ce14f3adb4a83e6440a5d228f019328e7a50e840cdac8f5bb098b33755876fce33c4a7b97f4df2e01d87248588da8375f16a230c35bee5ae40dfef82109652d8a8026439a68288c4887608108a70cdaf9fdf51026a80843300f6ccd102daff7629922719f4893639d0ae058d936651db4dc9f3d55b7ddd7ff0e233604c8eeba5ce58e077e3660a9a833478045e8e08a4aeb5e7d82774206990c2a384a30537a44c5a9ce2c9cf9762e3aa8d9bcde370f5b0048b4a2526f3c5603ac44da3b05c55fe459b26f32f53eb3e1995c1302d35024637b0a8877032def05c66105f6f6eb71969172f826e11f872638f05ba868cd7cac51df450d5afa0b0e197fc2c47618971c3496dadbab0d059ebebdbe050d4c425010a304160c35b90cd72154e4080e3ef1b47806c03eaac5434868c9bbe09848c7157d6e30d5ceb60a5a9f63a37011700ee68bc4abb6b22c580be411198b4a83d488c52fb663a048023f304c465c0189571d7ef9baba762df3669f226d5671cd4031df2711fe19640a0c2e6390c6d55cb69310159672036295f2bf8b776756983fe3c9cece9e1352066551fda9d6fe944857309fdd7f435a6ae53e655ed1778efefd93d4ca8dfbef0eab595af6dcdd9162af4ead9b9b2a415305ad38347279561ef4e3290878d95b0a247937f4db520af73cfa56593fedb0c3f4a21e0923101a738bf826180b26a90ee21860ee42012e54b407bbaaf6c436591c636430330832d230baa7d06c3b650a376379841f67ad2b52a08c2381ca665e719d98881dcff09a34b66826de5bce0c34920126eac1395a15fb31afccdd8d60452030859a52ceb8e36ce77dd2d0fc06967b03c217017c1a859a9d323e44b9a890ba82a0e67acb40e965d08c7d79600b0ca0986d37e0a502dfd63fb7ca8860a7134dc03bc7f5407fd1b44d7dc11647043d2e97e0967cb6ebff1249fa79d5081dc23a0c09c34bd1882d9edb34c50aff0aca8f21b92a437adba6e593790be991feaf15bf2b5d2ecd78a99056f4a3b67401 true +check_ring_signature cde59628ace31fcc34b2ca24e15f6ed9e1fd8882d3737281659d695cf3045dad 59035801a46d3ef6e7ad8c66f659a088e299929694ca220eac8194d7af8055de 1 b8cf6f2577486e977d4c6d68fe4fc2eced3c9da0464bb04802f489b335dfce58 4e70ada41139ab8c37f58298e78b75ee34a83558e7fc7c84fd0112bb0a464c0326890e12439786b9f0846d1094a23d42574d1d64e57ad6f97694d75e4a37cf0e false +check_ring_signature f8bbe0ae5f8efc5422267cc8a2f641aa17b4166a7f41793fc7ac175381ce0a0a 097d36a9b58f912c996f15f919e621fa37b4348028ff32aeacfc24550048d464 1 9fa4fbff08e1d5d1b4984f3e7c39f63bf6dff2edee83e3053b762c47153d5f1d 30797ad8bb83fe8aace92eeb0593b4234554c0341ba0ced68dfb740f8cdff1857a7bc71b0d0ac852b631414b801a36ba16e79fe0425cf98d8bdd9ab4e503a280 false +check_ring_signature 78fba8e0b27250c12bea7a42355b75a6c65d448b4627944669bb259f9c60fae5 5ff6044122a36f53de0b558fd28b0e2d99099040d0d21a89071a52201947cf82 149 472d28298ad3cd29431dcba63b0151bc679708179a012814250182fa5f9c8128 667cde30413fb5ac90bda398a8b1d7631062580e6d35dc19ead795e580e847ab 4a077273acad0f284ced78df465c5c41b7f17df4fad0dad49e81011e68e43102 6cd10bcda5343e76b5473cbc3e0ee67df772920037aa8bcf74caed2887379616 fca30e4d6f10827bdd427657b453669c09ec4e010ce3fa0e02bf4384df0e1f0f b4b63f02cbb7fbb7062af2b8928882059f504c2efa33c292328a3a718193ae2b 5ad6efce7e89e20238eb4e9f0e40477f10951447dc951d6cc34bf3cf89316635 f1d8aeebd5f67acf3b93b8d165e8041c078cb7f038b8a96f6ce9b2c486d8fafb 6c9eecf3aedc8e67d108f84e5f28155d0cd9ef93c090c99cf0db4ce317813b8c 272ffe746005819aeb8e11d87526f13fb6998660daea833cc95e5d402becc8d6 c20a90d71f5cd4ff8636de020ff89dd3b7746607141d127387a4d850f7700e4d b828e4d18ee7d414cd1928890d7ebf43cf65ae770df714f7ec57a95a392ed9ea 6289cbed62df8c0f500e223ff87e38214152c73adcaa0d0576a82fd7034746fe f0c6b88c39fcd17b9e3d1fc7245dc5fb6ab69554f368f29329570b584da3604e 4f1380200f36c89410dce48b10d4739fd2c8387af343607b9c69198e97bc93f2 1bb2f58c36e2493325d4703bc0534a0f94813da32e36fa8729102edfb41fb98a 0d466612b94e4f704ae279dbb3cc21cb4e502954a7751fe2df1491919e72d2ff 89512d6daf71d92be9bb5145c9b2d2381c7afcb72eec525eb8474992f1c898b1 4ead3ff4d2b2332be13259971d2d1a76083badca427e3c805bf47415ac02e3a9 40d20acf149e2523ff2fc98b7155f887d5957f5b10878d7a647c1cd4aab10467 d6bb5c7ad9d18a449574682a607b32854466ca80fdc267b73147d5851d6775d1 cecf34fb124446ff6f9d0bd217bc6fcf111c402754980bd58c04c74bd7050ff5 24432fbe2f1bb024dbe7ec9c7acd47f21b570af0ac84e4a00af79d56714e5c89 6ab6ae76f7fffac8f557c0dbd757c2abd85ece986b34558161fd446d48030e48 95df286af7202c52976b88c4a8e32007228d70a233dadb0d04afc37b73a9ede3 432e34cb4400b0b794629d03605b515dba23aa982e717305f377b59ed04100a1 1ab9360c6da753f7701321cfa460382566d3131c3b095897c429170d33f8e0c3 3418d001cd4af3f8aacc55320807d9d2ca2caa75897d61ec5ad5729afabd96eb f5fc3036bb1c6f743b885471ac8829da9f176a3967ffc2ffce9a7296a71ee7a8 fe961b17591e614408f8c0f911a598cbb987cc139f965de7ea48aa609eb483dd ed76fb1c4c60515c3ea625153d0e8332ef36c0f114e76358b391357b61eb818c 4c45fab0a0d12cf28b0d10540fc4a25f2a2d6ce1e078f648a48f5555108ef000 76f592324d230c051a45a6a2bfe90007dd62f3c3672d2c52669d5e8486968135 4c7bb972ff269367e28bbd1260946e087318f51b6b28e0a021be9b000165cd12 d5eb784b53953fe6dcff19bda2005f0ac17a1f45fa3706f95b21abf7c215b3bd 4b63ec3d59f8025efda3dbc4b67a4095a1851540aabacc6988ef77e3686d3c37 b1db5f47d7f8644d3c73b0eafe7f34859286cbb754ccdecaecd7e490b47f38ed ded87584d3663be2ef9b26ad4f7966abc0818797cf82255a9f7e749325d269bd 077c7838630d39561e7c1366ef8c8b4e0a218c6d4bc01cea3307c28dfd540a10 8d6d5b473dceff0a96b9bf6f95ca740f715ac33d95b247e88db5542b2331b472 17cdec341b5a262dce6f7d3acc7dbe7e593cab06d4f83a90abcbec07ae5d04f8 2814cc66d63093b746e51f430461e1ff3f4fd67a8bba88d69741936334cc76c3 d8328469bcbd966384d3ed6562747ee55600ad0134fc6db56e5350e844863ecf 69aa70c18609cc74af8f8739cba7d10cb6449cad27676ae8a2c2821380a4dcb8 553b35ff78c7a0487c53624cde1890e3c087d7296fae0c9a1aca19465002e1aa ce32ab3a09e0d55d43b3275bede8fcfe121c6d84f1c1cd58a0bb16d375734020 3c987ca7cb6815aaeda291e4313e7cbae901dfea0f76504b1d3a5e781da69f2f 372f112a771ba08069cd52d7e0e140f36289f741d6b942d2275f2dd3b8438780 4733c50c16aab38c1b2983e2f0747691e511e5625fbf4ac6a68da2cb4cb4b097 ee6186aadb493088e7455b1cb5261205262878a5f6a79b55c0fc8db1050c0ef1 4e80c8dccf4541ad17b4339a159195c7dee6d611eaeb42ee7405364b0f9d037c fda966d523482d71a9528231c982472868a94df2c96338ca982e0ab9b26e3949 67025f0d977bd103ae0202bef32de970c32e0eed29a52dccf53bc63b739ebfcc 94216533f981be6b90bd11bc4a3383b84ac93384b17911e2a9297a136ba95e71 c4e8ab63f668f4a5968d53d125ece46d51744b9ff9724439cc40c5793c681d65 1cb5bc0a55d17400fe50c50b2d94c7d2e9cd19cf26ef4ad5deb9a4b0e1afbf74 3fad989f57813b9c09ae252f7b5e1405928a3c2b80274b991f88456ecb6b1ffe 4b2119a4c39efe72420048b5bc904edef397fe128de0b945e85d6f8208433025 86ca96b15f6c459aa3120d17993042c9011721cc7e3b9a84b96ac339d76227bf 85306b5c4e7b1b41588dea1ef006315205ceb013d1cc7d100614be4469e7dea4 d99c9cf518cdcc183ffdd6254058f26a45050de951acf642aa738bffa0406d69 7e51ba4bab63d5186bbd3e0eb8a11cc0f6c5bdf74744cbb488d378b7db014a3f 47c81cd461065ee922da60ce1ec1212be72afeee8f7329f742074a219b03c8dd 9e37cdecbb0bbcb3c10d20d663812223995bc747396347373b46e61d449d9511 3e1aad4f71a5ccdf5fd2abf22cc0aeff56ea7ec55d06a2dc7ccd42a443f0ff63 a4b8694841c85e9795f0cba43525f04a820615109a56b26afb8b67284e30f9cb 09a0b357fbdce5725dc2f8792e88f26271843a1f551ab508827cbf2c4c9a5cdd f831e1a69aef230258c26f140598d21ea89c6356ce609ec3902ed83ed00b94f2 3e4b26a22240d3e6fb5e1baa93557a6b6854df12708c215abb1d5507d9423df3 a70491c302e9bba3771ca3f7b090069127292829592b13c8aca73c1084350bd8 794717ce00860d61a0a56190aa651da38c1de32918f90d93cf3b66e385ea82fc 988d8615356376ae3cd437c26efd235c4df5eb766208903c81baed3a05957e1b b5599809fe706ddbedc29268fc8a79df1e55bc2a9dcc9ec84d14660855ec135e 201c45514c119fc8bd5e15e2e20159f481c85973f0b31b435a308765f94d481b 1e4deb7e05dcb5bc3f7770937cd75ceaad56a99e23c47f6846ed04b7cef84886 a5361150242d062c31d004bd61c9e033529598112df0568ecd9022a57e047603 d60cc74f52c8c3db93e78083717d0091b11e2d67dd908336d395b53f25417168 426d72c159b2ef432925716c52d5dc7da9041567e57744218ea59683e345343c 845f05b3ae8859e82ce391aba7add1a6491ab65a3d44c98cfe38e8fd6d5be0f3 f6baf86a63c2a472118ec06492a90bf17d64d2dd99456358daf01951abd91668 6efa59a600c614f7d27b09ae785c262b99f2515a05e57fe8b9cccb4b53abf072 77440035802dcb20504a5abd1fa7d2a263cb8e6a58bf4892ab965022d72e43cd 03ae2335fa0169c910214ba68dd90fd7b8188d4228c02f2d2ca30c65e4acad6e 5a0544c60c4cb472173586d6ec9f0e3f9058d0daff41c4571f498f115269db2b 8dd6bb436c3b9a466df0167e19b415e313c39eddc19f2b41559ad9ff5cedeeda 73f083ed4fce395f014d94938eb36c23d24a0465517fbd18484b79b30461987e e3322ac73d76e4e1205ef85b2094b3490b9fd608a7693fc3942df3936b3a8672 155f8a68d75572b27f3a0b4ffa048a9d0cd8e121463674d39f973374e91eed04 f3217219d27d2d3e95c6da1c1221449a6a2b1e8613299feabb835bc980d0d157 72c6352281ccbc07bf9bee454f5b7fb06e0f8854631975f0e00107816d5f08dc 9c1e969c5cfc9563015ed954d16ae6ff625b2cd65b9222d008d7f130508c152f 78c37eea1939fb15ec94e6ddc6cb210c6e2e7676eea7653e59f71943d56d972e 7e2fb5831fe1644e885d3b7a60a31dc109bd4a934fcf34d0391f4319f2ab3389 dfa7229d8838aeff32b8f2f8217cb5b78be31c6de500371527ca0989c5643e46 868eb0cda8a0185c01f5a2ac1744200b548529920f8b16457b8f22c3794ef7f2 ddce630c367bbbd3eb6524b0a62a352785c5171c468786045414d98a6ef90363 ba5526440bab8ea6ad13b263e2143e1889640fb465f3b9b7defb404190d792ae 5ee6049b7d7f2d1ee4d084fa6a4ad028d8c4f7f0b2c3c76d458b0c6d842ff973 b34c55f15b0e88ce1337ca1df0278130d0581ee97522b8a518b8d2e2e25ea23c e3077a54925939c639264dc96c6c6c6b36f9d3dc93aaae9093fc02b21de73bc0 5cad325f575f47004e07167f7f9f04b280ecfd2b76a5d5367116fdbe99a63d5c 37e8b2cdcb4d207b52229050a271d444ef5035952b75c07e6d0fed86bac00d59 a723018e6c1ed4dfd63c49c6a13b832c6d9855e069171bb590267ef7cdfeac12 9862aef3bdf06383a18fde6e459bdc970e2b5ad2542dbd8633a0d1c9e5ba95cf bf6399bb892dbf1e2423d8e99172a46525d195c8fbadc6d86134cfeaa4038adc b1d469dbada2dafb49765a22ea1e8c2ae21c78bd3cdadb661eebe5280dab45aa a08225f67558415d568520314fbf1add4bfa1a6c10e1a7fdf1af55a4cc965890 0fb99a16bafab6134baca54a90ef725f29614446b779f697c6bf0e86af207617 321ec44857d5d26d16919f536f47753cc0ae72e8b85adbc499e6de838fa9ea9b 39ec5ee79a3a699b108f002ab39b34daf2633149b6ffd2c7116770d11e82f768 564aadf7f07386f5b71a4ee76da4b857e3d05d9e0b14444362023683d018590d e9d1cf20171968a438aebdf17b479914847e0cb4d9ebc4e5af9791a29c733ad3 3d51b7c3c848ce59171b22842dd9e11d1f5ec671622bd53d1639ffb65fd3f567 8ec3262d0e6bff92118c4223669858cb5cbfb8ff92fe761f4ec641432af1d5ab 1e7294b99ec80f734c285838d0faf21adfc3e39271f4cbf79da41c9572ce859b 99ce07e1187f6cc58e3033d0c72225c89d8eacc8947c61abac21c73ce3e364fa 285fbd7a4511e45bf1555e219552de27f47427ff8949bc53a948d941590aebb3 f4830bd3a89bfb9f64cb1005d739635eeac3cb0ce0875d0647a67ff5a58c7cee b75dc0c7a93e8da431f8c74c5dec821b4664fdb6a7dc100361b48d43533f9d6a 389b31647f120e96b334cb9d646755e6a0101e72ad2efe085e5518cea76dec4b 26a704b08e73bdeac5635a4897087b2050deb3183ab56e3d8c6e4071e37f775c 4ab105a90947074d0f28833e1766c9345626bfc66bafc815bbd6ecb9881ea594 03701ef188d594bd6a204b5d8f3004ede9f26c739e1dd5cbb413120baba9d209 2dd6b2fe28be5217ca7fd47f07849d73527d7c99b48adc7053813b43f62aeb06 a3840a59d47256b8b360a62fbf66bf7994f54f858962bd533450066b94fb69e7 1925c2b49a73640fad0e52dd7023e428be675144169e3065303aab65bc984542 201e7b844cb075a4e2ca7835e6b675070ec09f8b761dfff42e5f05e3ec9f2044 ff2553612198ee2ffdf641e969200875c3f853d3d76ef4b1b09efbd19bf865db 1648f1fed4ef2a4a022d0103840b5897e13dd65e0bc6bf1630129056c7b8a8eb 8a32055901f11500465016254580ca5f8b9332b05ee91b8b643db104f691bf82 893f7b1163b36e73d1967a5ab91e7a02508be9b77baa2d254bd3c1f923a928e3 9e201d7ffd20df4e1ca8ca3fa720d422d4383555f11e180cd234e9004aafd4c5 ea19041327ba3c0ed07899d03bf9ca7eedf08b95d869e73e817de82828049e8a 3814673d2f640ed53cc8df8bcede7e2acbd0194e5a5ebeef398d6801b9f61aa3 3ae68d989f03ac69f65b62098e504738f162fdf57c83bb75f1a9bbf3e128af60 8fea39a42ed75bfd2d2c5ba637caec01e2408bc7a66abf4b753e2d813900b4ba e66e7a03f4ddb60acc7f13668bc4212e3ecd54dc68a9ece0c54d706953730a64 e819d43d5e89710484d0c58a71743be67a182281d6d1021b8ac15a1f5360b4a9 3c0350334b532bbd6ec381438569ac44d6cd44e6534faf1d1e79a6b744dbfede 8e9aa15e649ecc9c9cdfa4529387823bdcada651fc86399edd2250726901914f 4bb55031829ceb6b4ff1b46d7e9bcd048960e747caa551c17a5a639357433f7e d646d8578e61c7149f7c1c5176317790335ea5f635fb6193c0dc570d547793fd 8918d2afb916ee5218e69377bf468835d954c03f8534e8cb1f898395a1c80f65 2c9c63b10015d07cecd97d943c3d651683bc483fccb4c5ff06090f68edd3d8eb 5425c0739c7c07e9ac6c2f5461c3b121ff6fe08a01c56085bce00d0e6d8ff9f1 3d5e483be30c7ac21bd624c818ded72cdef2020f6b6ec694c3d34fcd1db69494 fe0b313477f82914c5486674e1869f9f9f51709f81fb5df26acc8f143c40e8d1 5d2f5186dece078f4304ce0d81eec336ccba3e4f3e27d678cf85a0644bdfffea d28c114a4950063a251e54edc5f15d0e6e9738bf9a04e383ba4ddf9619339953 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 false +check_ring_signature e6de04ebda5b4af88394863df2fa8aec219230343f9d6dfa8fed6f43a5a7a1a4 e2b9bc701fbc1db34aef69dad5f220229610ef27c1471962bbdccad2eb17bcc2 2 4b0682dfdacf7b7c028b83a50561413a4486ec5c77aa95de3b0444045fcffe57 10d9273fd729308783c71352b5520ffa4fa684b72eba961d0a5ad08e326578cc f1b480a1870c4b0cebf062cd60fcba1df0505bc9b6eca757abdcc210e2d5dd0fd28bbac8455bf77887089a88f10df27626d54b56035ed9e7244409309a573a051a42e24be1b1b632ffd7ee2558126104ee2740978b46428061c852d583b7060da24aa045511334464483015430bbe3ed1dda9e34ea2bdc9fe79f220a87d98b07 false +check_ring_signature f2a12d6c948f96da86aceb38326b80215efe8fc46c27609d0885e82d997957fb 8d4124809821d1f7fe1dc711c28cc49dbcbb66018af435b27a09008edba3a08a 29 60809009b4b412ce45657f53dbab5e305fb0a0b8145f7abed008aa5437279619 20c027f36db2b80bbb482e6673f1bd4266fa4ed5ed182c8400374f06492a6651 78103cfca95e007717b22e261d27c69791f13fdab18d5eddeebc336e40079a36 00967d15b8655385cc9c96621193e02e24cbad6dded8d8f5592aa5524e487245 53be56baa474d6a2926484ba226659789114cdfdcb9ab26ba6f2b087fc3b6b8f df1ca737f4009eae8549f0d8be6a64c1ff1c6cb590af8e2b9b06b5a606c410b1 3c58fbd8a2a8077144352d51c9b8af61c1f7516193d5e55a1b73f7d4a06e5958 f72720ed4ffef4770c759f785c76735bc6d127c32a1f8707dc2b9e3af5f2f58b 2d2dea2212d7f5c1a49aa3372114922f4662d6da0a83aa147e0ffea378491ae6 64ae6620704feeb6ea1f6b524a29ab54cd6e0729fcca6af460cc2ef2cd11016d eb22bf7e972588d59ddc4f44833b113f220c0aa4e511861e6d9a87a1f6626c09 1adb5c2bb430e31ff03a47dc527e179254937aa07a46fd3ae39037c9e47a28ab 6be090e6e4132243d592cad0271b25b31b719dcfa6d1a9d70cc2f513becbc58e 2cb1a3ed15fce67611eec255407976f3dd2573d961aa460bacc1647243b1bcfb 11ee64840a39a2b87b58559c7f131d3c7479831042b05125ced9f7e166ba3993 35b73ba8827299a6aed92adbe366d36f2d8d5a5ff6dd66a16f1668e679a15d30 929df06aff20c4b3453873f880bd15bcf016e02ad7865377594949ab1d07126c 4a1a2a92b39f1be8ffe39d2a4396a166a5990909914628c98c1b93ec9500572f e0a3ef823443aa6efb58c06fa62b30ddf5f676ec963479df9a952cf1c9ea27f4 a4c560e761554510afb724196ac774f338fb7aaf9a321ecec5f3a34a22919d00 c2c0a4e8ad5197377ff7c9b9762ca9951b8d6dbed536761d6f0742d8b907f55a 4088a36ded75b65f0e4efafb341570a8388bd5a8821c3e289b165961bb2aa032 9eb5553ea97eb1c07161a161eee2bb59809085ac5505e5754f1dcf4566d845b1 cbd155d6c925358f5980a0aeb7a527715996f6cf11089d43c490958a631de3f0 5490944181fea8c237d67727bbbf6cb7847562552df8e9a65781bfa0c108732e 8417ab20a7bda9516f6c78f81d06118d6bd552df5e00302f1cf9f94c24aeba8f 3be63efedc00f2e646e72356c493b98e4ba4dc4df39cd4ee5ae84ace4d6a3231 4046e85b41dd574f93673f5b30b448b7ac9173ed0617142351cedb9e07c5c571 3733bc213194a4db94473bf4827af935230b17ff1d468889d5c9b81ece97305a 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 false +check_ring_signature b11e6413fefc72c61b1555aa7974e7c53cb526f1efbb8b1b9a4e0a02429c3628 7b2a4c818038e6b99a3c62e6fa7f93b5be66bc753224c2849a01931072f11c45 1 570c285a448dda4ba28e44f75ab3e810e9b4f154692dfd3ed7130b58c46ab774 aaca328ac3f9990e948e48d57e14ea9313db2f9a4685c787e34897ad1db09a0470d5ca3730410a41ae49c2eeb59f783b131b38330c581ad764dacad2dd6f980a false +check_ring_signature 14fdd68d4294f0c572aca2152241b6599568cf6913e193eeb6f9db43e1c4b30a be0f4ec6118499b3bb1ba12ee18044e0296b5eeb6e5a093bc4ca53035251e05e 14 a286da6e2eb20531d9b218ce7f1dc37485fce188237856c88e62b7ae64a7926c 93a2524bdcd2f44e2f43b868a3397187f9052ec9b294a7354c7b57394b0a0327 21258eda5023feae2e589970898389d63ff5fb7aafe05a7403dcc0dd82a2f5c6 19ba5655bda800d1dae11367cd22bb8c5be92a4e1b0e12c317487fb9b89037a2 0a485e668859de3430c2780847a9efe4698c08d51ff3ed40d256fec0ba856b67 d1b2f937e02fe6b6ffdfe6f16f9c805da33fa18ac33caaf3c6de7ef361f2e235 5805afa585d3c4f397b49049a6b8f2af53a623033ba08e1641e6c109291112dd 25164125211afec94f177f43fcff7da4af96df1144ebb5fb5acd9ca2baa0b269 b2164a63f83a7995ecc2a0e662af283c7b2ac5a01121662876c8e1a1497d9c93 a09636a0c701692518dd647eef097f4bf26606cbd73cda2b80fc43744c4b47f0 00c5e425880b5aae322ee5c1cf604c9d681e3ce23bee4d8ca40ef5d05b48ffce eaba12697ea0d694064b79c685e7d6d9c73e3c9659c01fb2c0b5191335c0df64 567ea299fa20c64bdded1923baa8756a738c01b0bbefb7ca2942c7043eaf5380 a99275f7e633e331fbf8b646eb40e0427b7f6380c4e8955b7574c95f4d785339 f6be724abec18e543fb44cb032ee2e0360a9db5ed169291e0520dd48ac47340cfd5710e5683ea184478ca1892e6231299e76e692db14e2269440d9a40f4c3c0f9bbbded13086cec84dba1d214539f4ee0688e87f26a14590a90371170902be0c5de433d01cc9dce598d8a4066f349a5590589af3ebdd464e4060d578cd91f00f909cc0c051cbbddf614707347a6441fbd10ff41024dde8cd9d29aec79a557f0b70328af70eff37dd94ee335702d0e937692a3e7cdcbb4cc443d50005715a550cd1da1009ad382638a00b1377b6456258a1f4009f5822ae4e444c19e16b39200282a2f2849775b683d6047d8058017bcf01c965734b0923d133d854add4eda608a5680b26313a9121ce9c4a0f63f2ed4fa24d88b62f852c8c60c32cb558fc760d3651aba81228172ce26ef1bc675f7488b8bf9614913d990e8b75333f4fc2f90127334e2ee7627d38c71bf1eb2f8d85cc3969617251a4ac1068841d488071e00546ce29f57acacef5083b8f6b7776d84c1203a594a7ec306325c225d136ebc30a21edcc50a5e979e2cba07e47ebbab535d8b6400b7cad0fcd8b8864c0cc09de003caf830d56460c58364df481f4f615cfa8f2c3f6fc4692f54eae9f0f4804cb08fd0fc81eb9770fcdbdd63a012267c81d3c0e233b00253c15a9de26017ed7b405ea39dfefe855c31e85206995e3c8d1d2906b0823ee534765252308ac59587f0846cf99fbc70e6afd9e44ebfaf4cb7d9b49d6066712dec822007bde53558ffe05b5f5801d34fe8179464775beab9548a3a90ca75a26e122417ac7fdc4825e3a0cebc27d110751fa6bf508a14d6b9bab26e0c490c1f7f5d519b9c0e0c79bb8e7001098785db7707534d61f1ba6d7c3f65f7ef63b6503a698f29c2fb5169c78220516a8a9c22d78d73e5cf129bd6844959cf7fe29f9e438a6533048690e6de33c07b944040886962ce6620ee80a24148c3cb40b43fe8bd7e40a844e2dfdf8b79f0f16d04ca0b347b5831d31f54d11744bafebd6fc16f326911ae18bd56cc90f290066ba9a3199919d03e0a681665e90e12f74c489af21bd640859aa5583753e6207e02f0915a27009f221f4586309534c3d55e37ca0e419c97c2ac466bd86d26407aab81d37148b207cc47bd575a92bc13b56219c80fc8cfa6ffb445a5720397008084f181425340da1930b090097fbc959c940c9a25e59da026aa56977abf7220d4c3175e8ee86b378f36a0e06cab6a136fccb8ed4491caf612ec6584de363d303 false +check_ring_signature 90ba498dd19ff603db5ad4b4f85a798784dfd99379a3d09b7adf473768393ccd ce391acab93fbd372ad66f79d494770621133589653800ee45604b6c49c9a408 4 41d38c8c1545e9d1a8a190b81ca63a6b77da0571fe5d994f6aca9b66252a0929 582f794522191e900ed0d9a159b42796856df0036e1562fe59eb1a7bbfbbab2f 825a3e96809bca750028f6004b4eb34a0666824b3f85d60e6432e145c6421025 4234ed77b9f91e3ef2878985d8890e7634716b6edaa5a86b8caca334f84c2a52 a4ad00c2952ae2aec4653b7addcf4af0a07ca9cfbfb37dc4b4313aa7709bea010f4a6003316a7b1b13bd16ea22f0e5a9f7186c5375c3ddf5ac9dfdebe2a34c0f3434d73503df35bd340e02e35bc12121107f6f6a32844d04d5e6ec04eb8d9705b03aa5a63070f7ece5917620c77849b546cc39e3ae32725139610830af0518031b8b7f8641faed0bdfc7009d2596391dc76e8a2e7c0672b3fe025a976842c50a3e8bed2968e669a8b5bdc90429ecee3a4dd5f937ce23ce9b48ba350d1e89810d444e9100e1ce571695b14eb47617f39f4a86db2532d2861a805efc62871d520272d7a245aa4115bf3168bbd82675eecd03b826ddfd0f614c54141d0db2ee9e00 true +check_ring_signature 7e826fe3b79449c35370763b7153f5f08207872227b8d088cd429771a50a3231 0989f9404f16febf3b7b199cd7e3b22fbaa080d210faee7227a48d968e21027a 2 9e1237bbfbcf9d1af1e37955296cadb23475105da5f3d58dcff32e6ae4d9b309 5129053d4c5d527cd1ccb8de536075357130b51d85caf77f2546a320c7320a47 9bf9a5cc1ea6189c8ef6e4a8131523252f3e6d7539efcdbd035e40dc1b810900ee024b9f83ff058c4d75aeb7080c87bb29550c13635812148ee89303436f5ff5b9031ff7a27cba351a88de73fbfa2676fd061115d3ac634184a19dfef9b73f0c9d4375bb10c1c9b69e69b22b69ba636fd2e4b8406a85237f4ba131c5e92de101 false +check_ring_signature 3356877db56c5b84c0c5f4552ea619dad8dfab91a364e58292ccbc7d06e6d2b0 65a3ce75b05da585a9ecb37fd44992c87d71399d8a434345e2641596a74cc7ab 1 bdce9f89a2b60736004b357239e9ffa88e50bae92cb8fc09f2ed00b7e1917f98 80e2520476d27b821a887ffde08b3b56b900d39c6781f9e8a03961f2f881df00e558e8aa9d76cade85d461f7b47ac1857bc6747c40e78fe5b9ca8e4d5e5c1d00 true +check_ring_signature 2df026c81a0f0777acd7521fb9669707aaa869d292b92ff309acbd9b4a6132a2 f6476b5cfad25dfdcd1f82863ceee082770f2d33e7f89ee8c70d60c924774474 4 6a36c548c6173b4d8206a07490b1f86ca4b9882adfb77cb36dbb4c729e4c223b 6e58b02f4ceb8eaddd968c49d2d14e8575c05cf1467b0c42b92780450d60880b 65dc39c71c581e1bed1bc6f15f66972a986a4d597a5da6cfe8027a9ab5868470 4c4ff494529ccb5872064b08576ddcf42d00434e164ce3b9bc4e9a2530c6f219 acdf4f6b1bf08b66568fe092826b4623e66cfce60569576002c21054c2cb20042d562777db653131096007358d4aae774207e16e352e93efec216c1b8c238506a7a27ee9813f0433dd344e75a18306bad2de9ccf36eb3247342638c219c18f0a326907a435e97c70ec3590988b87e87ca239c5f2e4b6234180f2332dc254740666769b24d7ff73af78ad43e0f619780c1da6d1f398434abc7c0c69b6616bf40c3b2782a17d040f8a79d5a903705968b23829077b9130aa244548a5ccbcc63d0c4f76942c888ed1f6528e1ad45e7ed25f05aceb444686e1b58363c0fcac3b8c023254a242fe849bbeaeb87788e45cb06909d2ae44f57229f4784c0f13c5444605 false +check_ring_signature 07df28cc034994a96e9966aa9f56d1aca465e4681eef6d18207d3be1ebdd19e5 bc5f1f1164bed5474b3b90f08f158ff7d893883ca8a4bdd3ac151168aa8ab731 201 7e3938d6cff042b85a738aa496b1de03990f334d01b337fe4dad4bff9df36eae d282c3bc88c3afc1ade2df267e4c9114c85ffb62c2443074f014255075e3d374 fc41362d178e88f40b57840ba665030bed2165ed3c5e529954fc38306160e6cc 63580aa1b883985b722e684b75e8d05e43160da738bfbab86c1243ad1ac938e3 23ac141fbdc6c04c9f5ec062f2fd788be70c185c7b768809e37aab1797f3322b db6b122e99f0917372d75b37c6fa8a107a480a13062db9e0dd53bead5dc89fad 42a5d693c9c44816ced5c201d2f98193bfafe28a2b8cb82e94c7806efb973337 85a0ca7f47e76035ad8b16d462d2604e6ced16a266bd128107d9249be5117da0 190b1781b728829952104e0fe5568e09b82ed832b084e5aa8798b810ba098944 95f37a86cba7061d31b97e86d7a094584837eff2d4a35975abacf9d3c99312b6 0d14f9161b0e8cfa173c71565102de23701107fe6fde4e8c7fb241472b4320b7 fd9604dd813e73993956e946c2bf0b94eee6b96440449e981e72d8935fcfdc0b 6322e01b407d3d7d43db42eb0ee95d88efd9c32a4016621f31af729fa3844b49 71cc9743f17c52411f42bf59e0e9a31176d29481063f588687c12b3512e8723e ca37013afc605e6e54b4fc22b21ac5f49025c2849babdc07c6e231db95935fd4 d0020e5764811b53cbc325984449f3f9536ce004e91768327e69816537e1320e 20b6bcf4a06b4358e97695b77dfcd976eff409dcbdc2210fbd7bfa4438322746 b28692d7bd5d477ca6310fcdce1f375b41fe7650272b5bae162a0b2956b42d7b 5b9fa82fd5a508f58d7f3b17d4ed1edcebbcbd1b1060410ccadd891dfe5122ca ac6a4de5b8306650a4ce444d49cc22338e1876d89ac2f8543aaac8ce2f9892fd ce091899962ea1b39c339f709954e47811e0b93d9b1ec76e4ae0774740e6960f b34ea3cda01974cad60e2875f9d822255f4cd08366e162ddcd3f233401ef7df2 9c9326c4c65726114ddefd0b5d284e41be71aa80fbfe5aa640a09e31fc4f37b9 099299f692cb6328b44c2aa370dbe90167626ee6028217e352671c276a9a87d7 a5ad76f52a5986e68630fd0dd2a9c0925dea8103978362b5769de5604b26d480 c9823921f5cb27450268a9a3da957c340637a542f67eef14a0c9aa3e99f84729 8eb4f9cda91dd8438f25fc4004f32011f87b8d0d863d89ca1f5b0aa491633074 577b7e7c1d14da8ee694bcc1e4e1c6f3f8967b96ef10302e756233d1b55341e6 c9ef8a813585f8aead054d50bd9e41e1f6724b45af35f1de8aa0418a980b00ad 43d260e9a8d8c940aebe5b3c06ee391cf19e8606d429a4a37664e6189c19dff7 c3608e78703375c00cbe321a6f3ec4cc7796c8d9b45e2292c9dc647ea64a7e01 ba2065c1559d3cea9ef535a10361231af52023fd2cb425a2767d5f4710798b89 5383b761778502818d70ec80aeb42f0e299cc125042c97a7a724cd98311f8705 01063c33fe455e823ac79d9125c72af4ba1ae6cdc3ca672b6dd986140698bd5a b48a30fb7beed3b2871ef1a4d53c2eff8c0b36aee0b9bfa5468ec8823343c9cb fec08f2351265884a87de667c7fa0c80ff2b5a43eb32b102e4f7a4cd81bf4a6f 094524e299626efd1ecd74a13346a462d3fe6c0012becd76795f26e5a0ea4a43 a8c5aec6bc43600e9898bfb5effd1f6f5716332a2d63396c1f9f8e9da3f480dc 8dd16b80d8958654d86f1304df23cf362eef89519aa9e66f723427c4d115fd52 90a360c8e65f1b2274b08b2076a8ae4bbd129bca43e0b783faab6950ff19ac46 886c59a4de5e0c0275aaa4d0e4bc7aa31a27faeb61ad13781bf91d6830a95c07 a6b0991436b1382e8516c61fbfad4f421283de677da8656bf56a107953835d44 b2fa67f1d2f241bf29351042b471b6eb580e9f94bd1c9f451595d5fb6be110de 20d1a2acb1d80ecb93d36e97ff415183bee8088a64bc4a142ed15b7cdd108c85 d0626db96666567dd5ee22c8b64f0c10237f0e9a94c8954a5c7f4f4b1b81ca19 1a3aa4c876253eb456f737cf6c61954151f75c8f864b2b9ce1ad584682000863 6bfbb80d387a365a414a9c4315eb413818785b8ea351e5e1ad5345460790752d 2888e92a949cc94ad79d6a2395f9e688e8c8ea9613baae5ec51c6ce16c3896cf bba36f647cde15febce73617fc134c387a015fa837c4bcd837a75ceb82ae2d88 0db57a44fa562ec435b3821f9b5f18135e4fb88a32610b1991821133d9e0e435 eb14b914152d2b87b11603a78d0b6e7dd305a2d0c985a69c37b289859723107b 6680eeaf77901b99ece5e6e1e48de54b2cfb9b868216d5365db88539f5585943 a96259763d0cdbc8807dcc40081c2f7c6b2993abb912340e24dfc169e58d0b78 fc78795927c348fa001fee2b5a08adae3e86abee2aef4e94680aec9271b7d0be 54f19d521a339ef988c1a8c44e13334fec55a8abc832d37611c3954771e3d4c8 8e15ee0a00f1967364a9fcfb9e69e15d90c69c6d8e6e192c25d578d51c1e7082 03e8191f6e51304d5552a7915bbb60cfd8f5bf57c98309e6804185ecbecfbaaa 416ef2aa552bb2e22a4f5bb4586b497efa5d2c1cf613726acf1731783471941d 155f2bf399a655b5963485fea5c3f7f44fded5db3fb233c06ed87f84c33e8374 d46c7e2ecc624e86e56668ac43ab9fa4cbc0be413a39e4bf5d328bd421a285bd 0a74ae0ee30f33a42c1cc7befc86bd0dc4b133e8dfded6a60bf2eeb2f4a81ccd 2ec63ebf97a75a285873f78edc85344bef402ac042c3a21a14dc8753ae13247d 5c33fecc576b3372362fabcf3030af474272a1a4490bc0dfd932d13dbddf555d e4f7dc0e487ec715f87e85ebaa05b2936810b72b4ad3dc8a387a3df1415f5859 50ad069bb26c85e1d9b3a7f1f0adcdcae11cffa1894e61cd926f811e45d98b0e 8edb4f16c4adf0b20833a7a4cde95ef72684607b3fd53777b4b430573b34c885 d209dd54c3c961d0adb0bbabc0cd051aa54cae460a1754b91f4234f4042d2d35 b3da90f80665df8e0db8cf02b1d609739622688f62f991b60e162b0f57626e6e e6d2556eed69bbe4481ede57cbdaa769069bd5d0b0b8c5418805dd086988801e 309b112b60ea20f9c2e1831050e6a5ec400f44c62942177998e9d18480aa8179 a5476bc4055a48e296c72f6094931efc0d82c88e01b7368d4331b9574acf197a f0d471b6180e7fa971cff49b2b25316dfc829d856701d53f9bb7e28e1f166f3f b7279ffa83819e211a93b740bd7e69679af9c145e004d092462981b5fc3b1525 ed26c158ed04938c0a9ba0fbabe3e707fc5cc6e2f8fb859345a351f527cc649b b30c880bcb0119687febc5be7f6d4394f7ed5b2518415c1e0ff88af18eb5d09f fcab1aa36436ee38549134cba25da7236b2caeadc0f0f227f09ba6e06ea5b3dd ae6df4b18bd75d4e09dab959649c03e7e1475ed1e10c4d70f652d479b3c06d88 dfce48a680e3d1d839bb5ba1b04da8477a7db9b627082b62d09e49b2969de12f 470cce5013b51dcb6466a462a7dda77f68fad48676e3949935a8ab57651d344c 58c8940085a949ee25145579f92e30feb74bf509bb7fad55a0b5c8ecc9fb96e9 2f345bd442f4c377e6ad0b928157b765ddb0492c1b9eff2a152f611d1a52eeab aa0fb3d62274c2e92394fcd31d278f4b562f1f0683805e0d7c0b26bc90b72723 863a17efc1d9a9f8966fd760ec18f6c7a525626cc8adde18527627ceddf351e9 63341ff088e9d19fb4c968c25485dd93f5add5ca784bce9d6687566facafbe87 6a6b828998609949616135213e0d14d49b2647458f7ea2e49d9cc718a41bb5d9 0b451caa8b16458fa8b41b586e3b59f5fe9ceaec415de265b9eea2cb478e6f5f 37a2a5cf66a2d9108a713428cb636c4cda5a0d676aada6676be12191df39f7f3 d822dd93a2d5e18f3ea57fe188ee3eb60da731cb8f723b84617617bc70b1e522 3292ecca6cb8fbe4f3f1d8fe5aa2c26b517f35ec171bea4b60b9f5a948be1802 cfc2a18acc47d5854c8dc3c7991f1fb69aa66e64f8b36c8f08d6612eeef6372c 5004ef81cde36ddfccf78029bac8ddf2a89d500e1fcbb301a6bd6542c5362a91 cb3f8006dc2dc06856698953ae1179811e1884cc355a3c5eea8e66275d8d51ee 6dfeef38905363a9fadb5d6d91d9639efbfaa97a5a281a9769c88e2767b3d861 0924ae6cac131109d3abfe1fba02f777937cd38f93c748a560cb7f8580b8cc7a cd353244da2feaf0065bcd3c72350535249676ab57d7336b4ad846e628b14e04 ebfcec89c5ebadc078e5417f8d70809fdc6b4f703aa85165d0e8d038aed1c711 1ba94c943f12459f200dca5cedc486a4b3e4d9e3ddae2b0f60f200c3f109045e 99816f327b245c272788e1cfbd16dc89200d4da530549ba1a34a4e0ac939aa46 4b73701566cd21f1883f0eb39dc998fcbb42960103acbd87a0b2e9fea000d624 c90f319df2603031bf8cd8538104935c963b4932c9fcd603775657a9d596a702 e9d7fca3028dc7afb60ddb4b5cf8eefa579881c00f4465cf8e948841b5682776 47600b9febb24c0ae8cbbb96c5b8a82ffcf6e3dd0af14c5269c1e6cf87f6c319 f862861f10949a87f660aaf02b2e445dbbf93538b4f38c914dbaaf35e3027292 672186ae2551bdfda7a636d449393e5b81a03763a7dcd907981c37d09b9bb630 4c6f9fbb4eb8fce2c1577dd925ac197215a9a05aba0c6f99abac5e582ef1ac6d 54a98aeebd0d5e71ed8a9745401f7764c76eaa19274f7f5b60a342b64f2822d2 f0e2e3e775a45241a8403ed120d7d8d47feb52f3b454da10990875629889e618 9f3a90276327b83e92a8c78822c36254c9db63f0c1c79c4955c6ec95e069ded7 473d7d402e8c5ba48e31fa115360bee41d9a5415b2235343fa08ecad3d30cbe2 4e7c6b74606ff51cb0f0c249df2a4a92fc1c8834caca9448fbada83518361bd7 4857a74c2d6899b1c76d800542d40407fa93e0e9953c953fcfeaa97090acdead aa64e6fe930271626096b24f53178fb1d3f12608ca2d58b802d6308e09bd7cca a73d2b688e096a76dbdde9f53868c09a5f73d42b1f965f6242e73e4e96bb1dee 4566961070041173886245842f9baa9b816a6ded629b86a9b3f031f4f8200d93 36a36abc2aa7a3931cc9e8792c66abf2acb2fd21efdaeeeb7a9ddb75dfccf3b0 2ed21a329fbe2f66d4760bc655049f30f7533dae000755382a16818aaf0e3d38 cda808820dc7d58d0d72eb49439c78c31769a3b2660fd18293bd6a58d9d0edcb 5a274887ebf8868a36e00a22e9630923096cd67205d73723872e463bd0cc6d21 786ec88502fae0ba99e4df7889c31daf2e368d574a8a50e64a38174f46eabf12 a7d64e85c46c230d802c29e43808268e529b2b531d1eebca2f25e2e306533cbb a50ef6bd325852069bc43bb3f7d13b4ce8493926ee9a0004597240dde4a7f625 cca361364c0b9bbf4bda4398f87dd0f72b60d8f747e5b5419c75f56e79bbba86 43edc301e91855cea8ba0d1a2347b6ce30fd8b36d1f961ce25a6bf1d2504cb0a 73a1268dc219a6b778e84601678b79569dee6367c536b16c0997372c4ef4bb91 3911bfaa9fac6a66438302fe1e5017261692ca76113eac02c5ebf726ec38dbfe 8b8c47982b5f313262ab063bbea6f2f399f2015225109cf9fb9ca8835412d7b5 ace8f2db0d900bacebaab28c469d9f107ad84905687f5d9902f7f0ae1f78e04a d963e3e909d1a57192538a93314b3f696432e50c504359f77b85877abe711ab1 6cf25a70312c450c280b9c9943649bc7b010f3f5a4a6b6345144659b33e9c1d7 12aaf21015d48c098ad66fe23896f6aefa91d51467eb48633d4cf2319091bb4c bc0f2f372a8222b1be5aa8a02c043b18b05fe19389e4a3018aa650a5cbcc774b f93bbb56bc7c233a704bc8f5c061fa0ebe0924e3f222251399285d0cf0f9c864 c87e635d97793d3df9d5ab44f150b5f1f1da0955426978dafab71b774ed82449 f66c77c31ce742f543203fdeb924291488d72490b2a36a29299450d2650b9222 3fe0751bdee404f1d8da1a9fa4c7e403548b7f9cec54c00df5d88cd7b419d32e 9be781c68570072d6bb731806245d7f24f437f1887413b551400b0ca9bc45a40 b6f80074636088b03077d7152dec88a5991ed59329531f8fa279cb4b1ca10fec dfa1cafaf6dad3e0e837bec93a21243e662f48bb35d0355fc95a5b5ae1669899 3b405bd3f73d00ccd6209368eb1d202c111dfcd49eddc2076408d763ce0fedc6 57f227e5bcff1c9c0e070f5ec368bb227debc8b401a27aa880fa11193763bf62 bd721d54286a863fad56af3a3c264da3dfa5ef4c2b222800486df9a0324bbccc 0014760eec2f8f4dbe00859596fd584fb3cdc7b1bbc4ce0af9411a3824431256 9d9389890b439ea2a3faa65c6bb00f9c585e90a3fd3d50459fbe1936badc3b1b 06bf76202eaeb055c733c94298ca9f0025518c6cd9d43ecd6b942724afdbd521 fa5ef3f7ca8f09e8301c63a258c3748e100a3e94cdefec174b4357138e170117 448d4e9ff0f31cfbe621225ec82cc44e7536714fe8449513dda2ceaa1705cd4e b9ae52cc3783690f41767e070d4c2eee1f724a6ef2e9887634b25e90aaee3279 f5fcd45a5f5c6c1b076dea9a1a6b2976f5c592990cb467dad463110d786043d0 8d92700986a88afbfc6091d076e6ee610a79eef4ee4d941cf2cce64be7aee41f 7e044ef22f188de855565c7eff654e45c16123df4e85d3cf4ab9f7b19998c2cc 322d718d8f04618989c220d587a2257edc7c2a3b1fc0873118c6037fe35a4c52 a784bef5193ee6106752069b5ffed38e88efd56c3ba1022246ac912d06e6e170 861bb8499dd57af6a549b6599f38894979206b7b8c62800d16acc5b59d716790 9a9e3e521ba65cf8740aa1f482b6ed248a12029e2a1d9b5b23a2ef9d682de193 0967a2cb0937d133966483c49f721c37ffd97837c8b17eb48996a7376bd9794d 00eab064a5a7c7d9a01425a4338e97a42e9263dcec3ac3195488fe081680070b 01eca5022462ab571a3206123681a3a8fe44b953be2d7c88491d19498042d01a e2fa28933408066e3d8479a3c27a13b8766aa260b8fec66e377e002fdae9944f 5e60815bf3c5f8137b04a10066babadb70e7bc100c39af8a313fcf56b079b802 1a2a8c215e6a13e39d7ec16581baa31b40befb17b275014c0f704ba9c1e1624e 9b4ba98312bb1e47794731a60850afd81960b33f373e940efd6bc634ed1f9fac 43ff3ccf9f3de82d29397c969b46d6162cc709e93c525a0ce8d04cd7318b182a 66c0b0b796e6544daa1590c1158e3b3f0de560be8dbd2c1449bec73999c9a94d 358a52e4760e68f3485623de6bf23faf37de26ee49b2f6a2224721528d945a40 208d0812aa37bcb075b0775a7ebf68ae00a6cba454d003b7af0c4e2c81cdf775 c792dc97e57169038448fc8fa7697f7124219a9a25fd42115217f982aeb41088 88fd6edc3c519e844b9d53d9a9c585b48cc81aa37a9ad2716d50877bd2b4ca16 9c738fd97ccf2b6d0b3873ec65dd0fb52f0219114c3b1d7d9f76d55bc7432d8a 9899fad2e7fec95db52c8c124fff85268ed529b962d5c7dbcea4d9ec86f3547a d079486bde8a260fd46d2e7338c2653d4c0123c71301ce98626b8ba0665855e0 17d07eab73c03010c26a9e78377c6cf80683ac072cd5544516dcf12d50b7031a 17a4dc6dd6f5a9798b42a89e9ff65f1ed06b1722f4d4a77dd1f231d791e671c5 023cd08b0485386cf7b6111227b0e302a3e32e88e446f64a59970a2e93576217 f5e77c8ea6fcb46abc2bd22d08a15e57fa799fa94346b969e1f72f475c66ae8f c9cf90441cffbdc9963e1a141fc87cdd2eb65fc53eebec6d2ee44fce3eb3d059 d5198da041974b4df2347b5e92e09551017839a3c7ac02134d7bed6f05a13c73 0d53c20afb223cbe0029180fc7182ffe26aadb70a4dbcfd77b575d10f70ceee2 20ffe3a07f0680f8f4a9497aea22930fad8261bc85018475c03f070e5701ca17 cc7a022b637fc284781a503b2948b34e4e4de553dfcb16193ec6d3e910c10448 356b96f9ab11dea193ac334f7107ce5f7da0edcc9dcd7c6c0598243721414c1d ab1a39431987b1fb80e1b142d3d27772f9533c02145f9134909557abb8c015b6 7e445dad530a509d2d2eef5d95be0da04b1cc024efe7629f94b399bc0ea93446 96197d76386acc58d14194798d79c3f30c1ab466937c2b8e8ae9968db2a714db 2e3b23efc24158bf43dd8d7e631c1360881f6447e07b40a0aef8ea8d23ef5475 d4b2ee72a713a6f10088f7f1b798121ad0572794121e685ae1ee0b95283da2fe 4b5d454324b9f11ce309d81da71ea2751e08ba3acf6f03dff2a76761e36c7255 b43e22583015f0b99725c9d5f030269b75057bbbc648de553d9998c28d98cdc5 31ab872d720ca18161a5eee94544d96ea5e907ef47f1bea19dd33456cb7117a2 51f485bdc04da03b84bf0c983e7947638c50b199a0c48d2a2393a06f80fb0b3f ce092628487a41116f804aaf617aecb3217310c990272e5e06183967f274d09b 0070d6fcb351a23f8c37d50b6c7ea5ce493fd7a616b968cdb157a2302a6db1d2 0d06a51a350e56bbe853ed77e6d93389429c70df30579e3ea83d28e930e1c0f2 5bf29f7b81ac40c8bd90f0d917e931fc8b6916a924f0c7c3f645094d2b7bcabb 10d66b7a39310d27043cd4e27b2d5e9ac92165f54313bad20735134c4d2c3ca0 8141e83d0658714827dfa4f4b13baf44630a4d54755b2901a15f8f07c2883fa7 909b06b97c4c77e4c49a838c7200484ace26887f3c5eb8052643ff38ce003e8c 9da3c87c1f9171d0b4e712a6023b6154cd4d403ea82fbfdabda457edd536e93d 4fad2da0b68fe0aa298e3194117a7422d0353658a9efefbe5753bc9609bc5843 ce06ea0bc3e8aff9f9e13b45ef40bbadba664629720aafe1a2d70e6501d77011 380ab37a9a6b8599557be2c2f5d86c1afcea791ec1c1d4542f34ad63d0bc36d8 26f4131bab52cfee9c4acf0b187ad8983dd55dbd0ff23ff2df617374a8368a0a 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 true +check_ring_signature 1d1e5a15cd3bd1cb561bd15536f89d3327fda0f3258091ea9aba0d89de2883a1 1e7c877f172513c450ec4cc5951d1382da06c42fa5c5a716caeb53f8a71177c8 26 490b3a96e12de5e7be4fd711cf5093b6fe2ea6014738b62e29b8dee99eb1bfe9 bd389717ee5ba026c93b323a8ea03994885b42ddd213d07c8a89858a61427817 98941e82f4f2867ecadd8534c0c4631e403b4c57b7dd78b65aba6964b9727915 b053d6d30e9ac1c7e964e2dd607a6d9e5a02c54aa6aaac9a90f6abf8b8c72213 2e2e0b08cb91da695fc549c207293e4aa23763965dd36cdec2bc1424a18a3cd3 69bb756af013da2838da043299867db18606c19e8999b55936414d9efdbc4b30 0cb401f0c11384dbbfc8ab40e6463473b43980270a9bb1968866f5b6180c69d6 84babd8d6bc84cd14905dc718e58fb0a45ee79b2c9a82328e42df28f2b017123 75ee08dde268bef336f93c4ca558c9b76562a8cfaa1041905b99988ab6df173d 86c45465be1fa008ad33291940fd23566c74e9f4529b6c11ecb09068a1629657 5fae954b00da576684e3d8e4b5effbf95e30d717c2a3ef8af326a08fbf0930cd f6b36503eaa18863e4d96052592daba3a7f14767b8f87a57d9833c3bca457d01 c3cfd145d1d0015718f893ac56054d34a152102c41619fa93222add516ce53e3 782f7a73a1bd40bd5ce9815975a9263c016ff3dccfad107eb861773b48bcbb7e 09db760830b5c718262e928af3464b4484a938d1f4b75a614756b330b96bad95 5feb2c4c1e64089f1f18ac62f099e04bf03bb27d919cfaa94fefade8503b8d0c 776b7bf921c01d85ad071c84f20bed00ea7273da6af2eabbb1cd0c27febca997 5d0d5424849d5b6e8835a7a1b17bbb7ca86ba48590a9cc9f137a6326979820e3 97730127bfb40e457a243d017a8b4bb7a159ba06edd47885dc939f9d5ecfb5e4 d9c175733964e23cea0f8669d109851bdf9a605e9434edd6052bf4128e9843e9 ad77caa1bc19ebf05ca39efe1539743abcb9c640c49009a1b4524d68c75b0d8b 1f08437d3c9feab5b90ce46ae852ef155d3663b93ec50cf141c169c6ad1dac07 5b88e12cb38188b5fa649c6fbe73d3a3a2dfb8a6351e188acbc7c5129e370d03 0359768dd47f6bcf4fd6be9b8732b3dd5db87a6d2ae912597bc54c7d44eea5e8 acdb6923e3b6e7c465c8a7dcfacfc40dd0e3b181ed0cb0e686627e01cb4672eb dc3a00c3d7ab523253f7d03fbc47b6723cc1090cab4a8979ab90e0da336488cf 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 false +check_ring_signature 2c41ffa6a70a4d249e665aff7c9e226c12b21359a32008dbebf543f2a9b0923e e078d651b69c9c6f58bd573028c47b78050ea2dad2867a8a854a7424d4ff32da 1 e0904a73a099745dd5856d1508257b799fe9adfa16f1b04e424f147c29a561a5 6b93275c286a05e75a1b2da1da39136912f37e6d52ec9f172c9c0a536e58fc05df6739e40d72117c6bcc42d6545910813e5bbf54db321234ad40bc5d04af0a06 true +check_ring_signature b966101622fb4711794362dc3c95bc32dc81bbe54417576d84cbaeed02642532 dd99466e2e69f11820990fd01b6a7c117c2b411ba58f55a972000e52c763e2dd 6 63ea79997278b9ee8b628be838bff0ce74c2c4e8118a5339da18ab5dc0e8999f 9138033ee7e1f8ded331cf108e7cecf5cef7450bb50e9a2d34121d41905f2b2c 6fe2c31a206c975d11f86b551b183f6465d5d69b1efb3274e8eb881fcc6f9a25 6a716d31a6c99b16f334e8e668639a612fd3440ce297f6c33a4e10e9d6683545 b4a2fa41ee869fff886a78e71d9a7889487a617a6ffa15465b1ce84bc243b6e2 492bd31c01fafd0292d2070658b0b6537852837f297ed0db7031fc82a289089f 77452f51fca423546ea9322c30a0def440cf139f4be6fc917f673402c9579902b29c46c9f6accd7f74d597a0fd9463abc5b36f478e32aeb35c000e9b5fb9ea0534f0381045396bbc9cffcc32c5b7315a1858bee73787c258c13bec90635e630dbfd2c66728d282954305d4725a1786c82b33972979da1bee6954bd3aaf819906c733da11a82173150e9eb740d65a152f74c32e61b4e840a253196248963f020144f720e982610763d326b410668b70ad592856d1e3ecd0928f6bd071b471ca098a89258fce35ce8793c5244c7511692089dbe2a8c647f095c14d82e46e49d1049f953c820a85e4273640e6291d80509853bee5377d544489131a9c2ad063a104554895d6fb5db56e5d5a8dbf96eea63224f431cdb15e5c4c9437b4dffa44a303a554aac2e568a53d4a8cc033d0702c754108c8c10bf5d865a82e0d1f191f6b05693535e883f6e31365998aa746858894065d39adc76cd952130b369753b4fe04e739de4c42e2ff1e63d09f4f5c2a895668eeb260beb87656bcd5eba5063b6f03 true +check_ring_signature 5318c46b99a3eaf48b5b449dc4547939e6f2be178ad6bed0a07a98be72a69b83 a6c05e262054ad28577d628c4ca75f3895f5928d8b967de70728f3adc71198ac 8 aca0c3cb323fbaa3c1767ddb7166566cd10d88691c748aadf7787c766be44145 fd7ed765565a729c34d6574435fd7c400188da70ca9b6b17f5a0b4d45026e50e be5eaca3f2709ebe564428346f358c75b67805d7f5ab76acfcc06f017ffe260c 1af3ede416e5881bd692e61acb98dc9f70469e9d95a2ce0a24afbf6f93a1f648 6fd0d0219cd2e5dc4cf6b0afece52a31f24f55846e9664987581ce5174b0de04 d1b5bc859bc83176ae2bfcc419cf8f969dd9bebb5d0ed03a255eee86749fc6a0 bd335732b0426d2c2f7c689245c34be40e65a0e35825fc3d52086675ba95063d 4dda32a69a26703e2acd24aac8ad65dc0d1c3a4f8fb667b6738e9006c50b92ff 718558eae98fdb71aed479ffbb052e145f9e0aebe649fa40cb878142a3ab520fa588ce4f952869edebfd542214ba15f0f6379a026475bacd1f366080e520c2096b93224cef8fa46f08b02c019d68dbb9c0f9ae13a346ba97ce14efbf9b3b67013c6c8f4b5d56433fac7fe9698dbc69ee426ebee988a0ca14241d7ef75f00430aed9b771277da111fd4728a9f6c6cd303130c4534b4d5845f5457f0fd7a647f058934e13b21272c546ed0e4d1477b135ac788d29ea6d305a3bef3a5b2526ead08c29335748b0ffc202f4fcfdc01b75e74a9a04787f5ce15699a216173a2bacd03ee29208f7e65d4a8e0a0af9d5d3455b5b9166649b0c6523ec12b6f549002c300aab5cc1377ef809bc3cb3ce10085f8c8ae0b0d2d351c2827c3e27c5c429e5307e161158f47ed98f157d8235353affed63f50e1a82b99e3a01adc105d878fb2047191147d99221f730d75ee9f996c707293ef106537eb7ee948b65384c9f6d40be26e625df7385860cca53bf0ffb9b76831d447759ed4e620255b19c7939ade022efade63e507f267c76c2030272b3cca75e66879c81115d43d92946fd89c860b43ee00b1c2493e583f7043b09a609d8003b42d7b3cfa6f690ed8b5993265430bbe03229463423cbe3eb6799c8d75bf7aa4fa07d1ed0b9339a9154a9b8a8cdd0ffce3b665bf8ecb44fd13a1d6d87d5f3489bb5808d9b3593f694f450800526902 false +check_ring_signature 0b4876e105402ff551f2ebff9e31bdf01760d809c3ecffa40c00fe5e9cba50d6 9ea334db8771651f1368a306f41d9780af56a542d5aa5eaa495557205008d0fd 118 dd80c0b1d9f37a534ec35d8daa854a8ca3dd3737bfee72e9af85d831f1d2d7a8 2153bd00f81c2128b4599bad6801d898308dd17da3d3b1abced8bd4a6629858b 2745d9b6004693adf23811e5196cbf006d001fc007897380e7a187b078788c1b 2098dfd63d94caaabf4aa996d344e4ebb51e88603407d33dd2be097393a8550c 13895b1262196650c991c9647eac66305f35d5d4a4df75645b2ad4f8f9979968 d0fcd2322e43cbff818fb9fb356d2a5cc2e7262d996432610a1fea7bd4877cdc f14b5b70e9849bb2a621252738aec5d96dfd20c9f39802b895761c790980abb1 53e53bcd988049663fed8a2e23e5db1d29e18c93c468df0c6259b95f442c61da 174a46dd923d6f124f49be0f88120a9309b36132d6f58f8dba67a94a145fa7b7 7923e3ef5d4025d2cf9518423bb5949dc4e8bde214018ccf3edba7490d71eee7 7b0655e09b15bae6cc2732149bc62f9e1c186b8bdf1b605405e7da8c9cb8e610 f5c833eab98502d229fbaf002ae4242a4a61422cc360724c3b04c5d415888290 c2463c64e1daa3eba952fa318885172518964e8d77f9395cf0b12b82cfb23572 f8ac2d846ce7a3c87eb33ee3db77ce59e31cb9587036ef50a3d46f5df305ce27 e07886fa982752a2156cbc974e2c9dd575e881b615748f76502947ac2bb2ae37 2f132c65376f91dae32d04e043e4b8b24b63435f0f026f6101b491e0205c776a 4e57194ac8f6d3e095fc3209783db783901e9fa22759e3717e661762e1a6d864 1cda8d70b69c15b48d3dae48080fa03a45c2dbb6a5b6fd0e77cacd39b544d79c 0ceab2489d831958cca64cfd16c76435fc81031b0164bc88e11478cdcb7d1a8f ed4713f75e33a2aea2432ac11cfa1b88041a487ce1692c2e5cf79be5ee728e9a 97f607d99cee394d4827b4046ff116f5c263cff47c5f935e527181f86818ef14 4dba8945487b00e4d046688c117d31475719d323080accb7cc45ee776f31668f d863a0dc641289cfeb4a7963df7050461696d20ed8cb0738d20133e43a74f342 68071564ebe5b151ea05a69871dbec049313f5c657454fc8127669779ada7b11 6614cd9e15b6668dee7404bc38cb511b26570549b51466e23c04a813933142a4 5b1888333fe5d5d8c712c11a8fde209a97b9ff326033d8acd6f2827f6607cad7 445f7fc863739f23e9a3d4f9d04311d9fda794c51ea6ee69e93cd8f4272a7e8b 9ebbe2bd8fa4d50ee058b2341676fcf831f7bfbff42a58ca4548e2c892ac24bd 893804f4c50ae51c645261432d3a63631609c53a3858e75798009a8c944a5124 9a5c39313d705fe9ff96dcadd84f3b7c4073c33aebfd7463729deb17ebfb6224 2b1980b4cde7f604db1419102328850c2babcc7fdc81d67db7f1e5d7179f2aed bf33883078a971b91e729cfd0774a34a422d856639e0d99a0a187b5ac827cf30 569c6b9200f843f23175080fc3f02d81fb038c7eca8a1cf1718f4da7654693e4 2de675647c44625bab832e16b28566dcbd7183aa26eeeb41cdf36956c7914425 ebb4b5cc097cb63cc66673f06b7c2b6e8cef9041f97c1a9f37aaff9ff0419c2d 24c9ca2a524f12b0ffa10e2f5f78149062c0e591287233458460ebd6cc374093 d301e277ae6b4e9cab228335f30be00b1fdcf06a709ada75693a668eeefbc6cf f767805bf68d56cd6d5ee7d4c0d90156a950e3f946e5309bbc28ab4695c7cd18 808616e98059d16e511b56a70e3aeab960e0a790cc1b4a2e9955305c4d930298 ed6837bcdff01ffa68c8f0988528c4ce6a6b2aa2c0fb53cf3287eb1190b9cdf3 fcd65dcc6db9f5f5eb7ada6e31b6be38d2fcfd3e9b31850aade772317d14e352 559ea0873abc4dc7cc4d7b9353d16129cab6e98fff0af99b5a500501e5018367 a68339d5f621192b5ef8197bd703b0b676c23173402fa4f3eab9fda5698b6a8d b163be56b5c60fb91da9ecfa4474a23aae81677193089aaaf9f244297d96f863 11dbb1fc4a6ea42f3776a0b7c0dbbedf67271960e24a5dd43032e42bad81389a f33bb3fe3f61c6359acdef06afdba28f915c0f09901299a75e7641bb79694237 86d77f9002b727c0588822ffdf6077a0dacd926a8f5845955cb33cb54701e6ed 002d80dd93833dc1bcbd90b5fe10f67c97e92caa22fe2cee34d07e44bf606555 c3388bb9eb6fc5f6764df169b0d7a8fb30d7c176bb7f08557dfcc7d2e24bf720 5bb0ff4de4492d0eb819ea0050b9ef15193733fd6c35b1e5c3308f9b47b3a4b6 8e8f5e416a1cea31ae625c780ca5e176138093425bd95bddb3d68ffa3ef497cd 64458a67b1c4e476a2ffeb5545426b6843505fb8d08b9f835a5be597c49a7076 5c59925ee660cf4e96133efc4685761f83635aa7a77dc157f1aabf18e22339dc 7f810e7bea2b258dababaaa54faaba392f5aad45d6488185b8e720bf6227645b 8cbe9ea05db46a61bfd8d03fdc26cc160cacc9add977d394cb5d56e0e2912877 1fe6c334cb69147c43a9fd94cdd391eaa77e5d8ea20689028d827375c46c9e30 2d746c82aa66624d0bca9c6b6b12323c047543379ce3dfd3bd2bfa6113670caf 7e4fda8cec545cf417500e191585e08b695675eafb9df0a3bdc2fddd07e792f7 9b4ea1c2a9b96f79712acdfbb7defb2cbd0faae96c961f1660445986950c71be 0511a268abd8ccb82726e96456c17aaa0ed29deb41aacdcc27770779cd0a9f8a 4f7b284f242c112a34ef3cfc90bde004bbd2159c103897b23d8917019554d507 75f270db41ae6414104bbe298b2b1b9632c0e8635bf07d966a3227db7952a758 e27169988b87879d82408be83933f9a775eb09541fa1e4ef5ac17f14bc86bcd5 55d0202ecdf160b7e07496324937fcd601e37d938d9087d74eefbbf11dab7fe6 41ef6ecbf709917b72c1084f66920c02818dc83117d859d2c41f91228777732a 387451105e702c73e578ead45ebaf3b4a2514b7307245e2fab8c33d4ab28f6ea c2ac61ea4817294bc9830ed54bf4016f1485d0c68956419e670c29e368511f28 bd10da1d5ad923ad7555dee83a93020eadd2f519aa8e1f32c2f08bb63fb78632 ba8ba7e7f931bd885f76c9cd794e061547f1a615a5665710e8dae01b715548e3 bb0cfa51577066ab016eeeaeffc56f41231deafc0fb0b21d22ab52490117edef d0b17869dc3f0bb04f7541c6da0f7d9607509421312bdc870c28df2d37bb074d 3219e667077d5133a57fc31c4d8be3e0d3f697fffeaca42af2f8997d41acdaf4 276eeca7769d462ef3ae465caac30ff4852d069984aecf333eda4aea86e399d1 b58ef4540137055df09e05b9919b63258c9212a72b529fb7792c8d4613ccd348 ae3fe2b56ebcc78ebe4ebd0e1e1ea5eb6b3dfcf06be872dd7aa01fbcfdfa3f2f 96f7b28e990c719957a1451f423564496d024250002439552f273c07fa3032b0 f2b35618dc2f9ce6e0e3717963129ca9cdc5a5c66099115545918462a9ab146d 0bc372ed7ce6856d934e1f661a9a4ed25be042d40d0441c203ce3e8248c646a4 88771091355d9e406c45c382a86e8bea1c947ef5035c7a9d03b1664139604257 49bfab36d1177f885fe00f753e90242e0787707b8d77f3fd471f4f5095f97a2c dc65dd46f0b6e3becdb4ad1819e3d34080d472bfdb7fd67a345b3292b72a1678 4cc700b5fd17839e82fe18bbd4b131ff5e8acab4a2be94fd4b4b976157dc04a1 99d32f5d2ea18fcb5ab6708b8a119630cbc8953ec39dd322bb70eb8f4fe9fa69 7ecd1dc7d0d000ac01a4f6ea8f4ee6c29058a31fc7676523df31fb4d514b02c1 02b9b2184a59100b81e3070a4051ff3b2c70ad9dfb6d75179a678ee8566ec9e7 814db4badf5dc06938aa771a03b501207b83f445b7c8f347cfaf9b7271a792ea b9bc514502c569452f649da1da3073af0af913f7c5b5de302ed07910506bb1c6 6492d18466e8882373f6c94f68d8d2d506b0ec452c4d33a52460182811e0cd41 d71d56ef267d02026eadc0576806006d159b840f8ad09dd66c35031b16f48752 cb185bf0634a87b561b9b43711c67e9bc4041ed13ff5813b27f8b21f445b061e 39749388e49e2292ff8d4b4107697c4dff32af574d51b2e4524ed6df9fc63cb9 d65dece10c828c4c510f3cf7d899b2ef6eee2a0b90ebe4102c15ac6ad8413985 ac26f02375e09b7c0cc8064d94891d33107497fd10d8713ef8fceb58e3eb3c37 b356541c4d4386935eb3c4e1cdaff3dbc8a8a79d26e3d39455d5568b6a421caa 5f0e0c2b58c88095ba3c9654e81f6f7702a755ebba847a7d2f6537d961b4cc4b 36fe237dce6622b1b6746375dbeb92c3cd70679e77028e2c5c557a731aed3a07 100bf307102e14a1d3c38d51e91cd5fe480a1376ab93776acb56ef2444307c17 130806f22b0e9108c84c4d4d50a7152f5448732472c3a850f3f49a3be8b6eb6b 6dbb51f7096ff7540dc7c97ab17698722bc89ce5844336d0157cc76ba935ceab 3b827d661d46aac58e049a3ba1c88cc9c67922ee2a592e345dc773df3f5efba9 2df3a818fbf3570fdd50d43f0a8f7953f97bf74b5254072b605f137e1a3e06ad e30bfc431698235ee99cab9648e1178180fef0cd7f24d3d5ad1ca80c6dd91145 978e6416ed62d462646ca1e799a0fc0686874031b5b627614bd56f229e52ee82 2e762a6cac6017de0dba6639fd678c7f14b477b0480d742e283c6d5f4d06627c 1f9da9d98c7dcd48aee8b906d03805998a3154e4c3cdf19b270b8a44a124025f ee073e08638d693a57967adfd7141f41887ef98fcc73193310a814d8e1fcdf35 5496c5c81461f73492a9972cb3808de831542fd41c36bcab8e96535d7f96e3cf c9cc483aaad63dee8edad625200b4e1955c2693a9f3451cb91118f84536e9140 65af27df9d26b9ab1c7d4b61e5735d8eeba07de2a29b180f99105065bafb3b31 a22044dae970eb70456f15b7066a0c2070876b6bb68a05c949c3514f198f3b66 1e49ee8f6417ad5807dedda420eb53be9e959d77f9317dcecbc90defc8cf76cc 4ba339bf2fed981e3a18b3b9a66f22825dc8bb13c1d2b9f715a2a0766b1e1e62 b3f77a20aa40a841fc43cab4dcb6a9663db1517d717b2e6b5d22a697552868df 4f65dcb0affc8815950de88a0a2255845428b0db65d4a11d5a596a176bddf4b2 dd3b3d84e07e723729a91a5e4a52aa4b8f74ace7f373ce29306c1e22ccdc776c cb7fb5bfcf3a5f5271148708a25126d27e32857e61c8135756014dc6066f97b0 68edf471be230ebcb2cbf4a8f38415d357ebb3949b622f5159b3402ea24e281f d09553a6c6c3bf11c062840f8651cf868a5943931570fe13d204bc6f0e03030f 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 false +check_ring_signature f8b142753a3d5b49aed5c8993b17c302abf0c12db4beabc5c5ffa0a02af302d4 9e70195c0647dad2eb67dfa5154d3e71c636d8519ab525b6461d759b78242ce7 28 50ba24c12fa157bf3ff4ebf548335527acd1490ebf5fbb18664c8c5111865512 bfb31e42d8cc4d51945ecb68c78219c21fe3e717f779ada009dbffa7c190fdd5 6963290091a523e9ad75fce4f15f14580eebe8c46e433742e0461fe3540d6c98 b45d2615a0c5c6d21a4c667bb12cd01ff165c5d16fd1151f7476da5c306b7dac 423fc777cf6c6e2abafa8676d2981321c395c8d63591b51abdfad62e2fe6121e cc589256ad104b460c64e392010546e12b766014fb39ba29ba32003a10aceae2 d0f1f634eba470384991ede1add67e14abfa0db7430e117eb74b99b625425095 613acadb0381ab7501a997f63942bda855e8a50fef8782b35e7d9801c65e28c1 0a23ff82008f842c96a8ab5b21e6c5d95a07387150af33d8da98757ad4fc3865 17be4d1258c6229afecc50403c623e27a369607e84f1f8cfb4f95fda6bdd01ff 013ca1122ec4180dc5417226f5beab736abb6344bd6660f1fbcf1063871ab2bd 4acae18b0c2c245907a11bb5d43598ee81d9fc232a537d578c49f5ea36a63d31 9777c10cd138fab35bf0ef48d44ec253af18da667085f225e266120d87a94dfa eff38b06ae5c7862e172af0b2bbd76f7b96758438cc1e3e71c8a78e3224f0599 b9e1345ac1339b274873c919d723e27f8322a0ca4afd2329a69f2a5b10091734 7b78e2e5444747615abfceb81aab252ba1f76a57b19e71f0f6b8dc03249aaef3 2496bf91c576f559444992f47db6c5778a782730ec81318fdbcffc3a79ac399e a6278a6b1eda10f2e11e7d7da7c193439067725edd243de5fc1142a8f9d38f86 3c0b6ecfd2c31a6ca45b9b2590b614fa3a47447f449495b6ca7f267f8f76439a 47b4bb4f337bf9692519d24aabec70a1640ab9abdd18f38badb1c2b0696ab834 3a6dcdf6453be7b1a77b20b2d304a1aeeaa1456ef58df973066c963cf6aaaeab 02b1ebf128ef9f10282409b780f6e31d2112921e22f2f2a9d5525c44902b766c 8ef08f82eea54369e24d5c1ecf070c39286ca765ac50526407d71f546d2f14d5 5e5651d2f7808ce083cb1fca6f034180cdf466b74bcbb65ae357c17a97def622 f996709559e2b5302e30672e868324698d3034718d350d03f3cd44803a8fede1 be83ffaebd8541341031894a49a4e00978de87d9e3ad6c1513363034ba364209 68c725a84e672cbbe9c1e8b50ee1f3c5b082d49935bca9d5179b3aea75b71e36 4ac6a5248e9a10a37938a3e64b298f8cb88174ee31c03cfb6231df6e2ad1b423 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 true +check_ring_signature 8b722c3a58c48d947dc39388cca3c68cad4fe3025f461e8fab672e3b8e2fd3c9 8c64b2ede8b325fce26999fff0a5a76cc6ffb7ad86c9ff21b9f0d5d4fbbe207c 2 d77670e961abb39449c7cf085f2b4034f0ac4f8790693415fce8546f452b702d 6fbe0dbff38a19328949a64c6ca14db395fb715d60cdc24381431be5fb123fa9 65317c57c250d52c7709efb50b59ba8d89e209f91c24b8e0c72c88d81daad305bd06a9f7b3941c7ecd7b653e03247f9e27fa9046b1a3ce63f4f75fbe12465a0990bea408bd246b32da427bd33cca15327fdf0fb503d3bfd93c99ae03a8254b0e9473c5948685efc155bb7a281cd22d5fd15cdc87ade916faec6400ce567a2f0c false +check_ring_signature be76c0587dff567bb2702410f9c08d2fe1993616e5972ff2cba9d648b9ac751d b27ea994690e3cbca794acfc79c0915cfac1e5a7d2e841292b1313cb754797b3 1 6e804d99dbe0976de2d353c912005563ea9f3a8f527bb46c8c44693d47b8d8d7 1b2b2f910477d76ebd28c79478b2a5844bd080a8a9bf8bff912a76982929750051290729749779b30811c5a05f19d69915f2831d636676bb13e5e715a0d14b06 false +check_ring_signature eb27bc8f46d2af820c8ea604301c3d383af6f512d8713743807f4ade81a99665 148c330d4047f84b948f7e0f1e837513e55d4ebd86ec1cdb1fb60160ee4bac2c 32 015220c5a3b6f7430178d8a4dcbd62e39120a301e400da5126b6a7d057051c19 710f81dfc8f62d85e8646a65bb8fb4cd1f36b665d91a6ecd8fa58937c2726738 4e8a492c8a0f9f5126205e01bb46bfa5db49fb0c58115203540fdabaf7e6df35 7cd33a8b2b600d1031b8e534a554f5ca7727960fa8c8e5a363d1d6f20cb8d5ea de22cd8bee081e72cd5a39ca44e8bfafbd5aaa3e1e14240a28d91eb3c5da8088 44eb3833a4d74454afcd52f905c173085581d11b2b4a03eebc7e02bd14f2ec3d f30a31bd71adb956e5932c026a78a28a9e976efd916b05c8e7b1c83d0256119b 47456afd89180c28417102b8d07995fa8e5e38b995f3346956be3df855ff8797 f42bbd33b9385bbc6bfe584bdf91dafe4c0d11e0d451c05b2a901010d7ea1edb 0da8ff568a75e3a528751c0d601d1ba11f62250a20fad8992f12a053023c36a8 70c8da32c23b91642e77fcefe274cd8597dbccaabb80056778c407c0a9dc6719 2ad1434c035f9a68203f697c3244aaa3e9494cb6d919fc57ee0706039fa28065 3e7f66858b00e776483d5c155702fee00c2c28afa36134c34cf7acb672cc5507 ac8bfcf85673304d04db00ee8600c001b2604953e1abca94c4e6cb3472610de0 6078e256d9f1f279f82fd272d0653a0b38a9c3d3aff326f501c17ae04c7a50ba efbec693e8922cfbe63a4f6feda118134e9c6718bc216531664b0a496c9783ce b96d4859cf802237ee57cc2e80471a9f43c488c2f64b5ee7e5ee846459a9ebe8 89f8b1b111634005c77c39bd2785880cff07ad2420a74482f073a3aacedb8903 e689040bf2b7c60ecbc6551d84d0fa0bea2f7d3949adc51548d8a31b428c9c6a 64748b6d3421df3ed5e07b50f8d9f8de405d74a5593fb8f67ff68a9f3c33fccb fc8749683b6e76bf4772ed55576b903e46d62ebbc7de2edfd3513cf279167417 d93bc3cba05c1e1c2065094439d8b2e1df01652e4c69ab224bbdc01bc607d8f6 585287ebf11abcfc668088f638ca773215d9402ecce36a85c2ca5c9de28ff363 3aabec5eb5396c0d23ff6fd91016aa0daec249054518538523b9519a3bce4ef8 84b590cc2f501f105bdf1d028a24ad9700e1ca76492c697f69935101c520aa61 50078e220f24b74840bacdc9bbf9e0e6affe098050cc6babeba78e27c8417cd5 ffa103f27d66e84e4ce9d5c225ba1e3fe09ed1d968bbb4e18744e734e7ac3426 194edd6982e49941aaa5bc8c58f2379ad246f8dc073444c7c3972746549a3657 2f115fefc22c0c79c350f96ffd49c8ef154dfb3cec8a2863717a36129022a8fa e87c35277ad0f04e5a94f53db3c1454f1c45460c96db7f86a2aabca5bb16797d e6a58792c33c87dcaea576778d47d9bd671d9be4dfc7b5a88bb28863f0f7607a 0218b58976f755e7848daf1d3fe9875312427b57c1eb90264ba9955c6032de6e 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 true +check_ring_signature 48a9080acb7ed93ff6ba36a40ba7edec49888373ac50388cfa72a349c16c1f14 64edd70264d5b57464bb39d47ac8a2d695e239e536c40ba17a09d313f6e4a462 256 ae6c7b47ce6a743e686cc7636c94cbb9cf2b880b98bef795ac57bff1d2e2f732 f3704a21c37c3e006810c3b28e5d75ae1da4e4b6508145e6bcbb9fe1b211832f ca3449bd6618066b11c42338442d5493c28368e759274e44da421c93153dcd41 c99eed7a469e1306789b5e15379df011a3efc413428083613c46915379f80a04 506fbefa2d80d37844f76f649cbcc0c521d7eae13fb2ef2085f52f8e0e819679 23391e4079549a2eea6ff3ed2893cfec272b87316084169062e37306629cf68b 3c35c8808787d0fbe4017326345a57a80bc95a3da90bb476d377cc6834cd8517 86dd1b2d943dfb6358e8e14b9f9a3aca56e67fdb1e2e3ca3d1887d3409be5bc0 4c8a2925c9e0c1fdae13d9f9861417e2b75ae9b1bcf9cb78e6f02b91c858ac43 50ae86faebbeb15c36f343b6d36e24dde94b2dd6c6c58f0a5924a0ebc7ad482d 4a99767aa4a638ff1c201bc98abe1a2fa13b4d1ce7fc5c232834ca2136bc408b a60e3c9410830fa4e7b11511daf69c6f9453589b3df9930bf6be5c2edfa63af5 d4a0c809e57b5e7dcf2326e28e9d3143b98aac9112f73dc40dc38e702f30b9f3 78812a0ec8b1bfde53ecc3b0e371557f2457a45648c16dcd7c8f5b0b2eefbd20 fb9c6602f377fabd18dce6394e48ad90c2d69aa27fe087a1499fbbe713a432ff 12c8cca4b9b119a54182796abfd8715814c8137ae912b8a13e3efb2a39f426e7 75b787cea70161c9f8714078357c2a45ff47496fb404115a3fcd0ff43b5425f8 cef99a001ac0641ac5a81e5f67aa97842e0a2d2bd8bd8636008c9374ca61a53c 4f02867da61e0dfcac81e449c6d227ccbf052244552e98f276cec1a63cb6a672 60f7d0db5f6f83b459d467e355a8d9f3219b1e2f2639749d5258866b0c485a32 de8695354e9b3609de0b6a6ae17d37027f86169f803010fdd9737a232e714a51 b60f6c4d090e08447ce14123dee4c42510019057b68d30f4e9b2fc81127153c7 93c9eba7a0ef9a7b2d5feffe18cdb1d4537b63206daf08965e4e0795c002ddb1 aa070d325425dc3617fdfb08f2a8024e3e4baa48260ea9167bf6b6e6a0dd9a98 77d8873697744c2400fc8fa166396abcb1510d5f4d2891b3ae0fe598fd7845ca f91fe422be89bd2e36c8009d71ff1665274b11825321d7f58b361c7bc53c767c 7f45b21936c30e663e9bfe27b1de5ceaf226f4677b2aa72cada5b0a3e3900e74 b1bd986dbfa9e30e33b28be6e2310ba2dbc00be9ec04c284f94fcfae3dfa6f1c f723aebdf9cc4eaca4d44fcf7ec65818c6036bf8f26cb4d420c5fef39b018cfa d88a0cb13b26fe18c17067715410605016cd1c6f1890603bbad269e3f8474537 50dd083f8d52f7f50ee75d08ea7446054fa8268899b122e2aae04fdffe352111 339081351a1dbfee92a63cf245b59cecbaeb6e22b358c4f302d3e8b52c89ee1b 699cdf9efff580fd9bbe60ae9b43f85291e5c1e5021fb7fda64985fade6be278 8ae5b9711f18ca80073dc981a044f9e84d288f06304c709eac795b8d942d1865 26b28b90faab018beb632dd84fe679787a9b21db67f9e32f2d3562b6d5e98dcd 86de913b4b334c990726aabe51ee29f4ce2c0e01b74e51dc837b43af115fbf48 165e7e153bd5a37e253c477163b9b968df09ea97a2fa3f8c7cf282f8b79fe5f4 ad66f26cf0169482bb43c68ae9a946a81198f64fb6a3c3b5a58bfb285fc3af18 4d38ed732bb34ae01b67a5399831accc7eeb78c0dbe0a987956b3e6b72a360b1 7f4789af279f533c6435a1c8b753c299a4e30458444ba857d5e1c1ca8e6b909e 7ae0836545c136e227ba9c28fcaa2f63f416ad1bf251a612d277134d9d5fd9fb c365ff2c608f4e2b654888b9fbcddf9e31e764de168a72fcaf0e520b0172bc18 d8319e48c1656790e3dd61e37a322d969b445d73ebbc726875d99383d5127daa afd8081e21337a990d126c493b13677d481668832b45a528dbafbea9e79c1670 86d1deb1c89d02d2585603ecdbd705ddeccfb469519f6830a4fa83a5a7d8de0d e3b05286ae595a40fab9a8022e06220d54133276c299b346eaf4a0a81799af16 d1f3e445f288f93b8dd5824c8661e4d0acb0786ff87cf02b01df2ccc3d192efb e3f0998b17380171ee7c4b0bf41da87aed6c09ff94f3c060c2fc82ad657bab2b 9bfd98dc3680604bf5693166635487b06eb8d793ed8a9bd3f46bf1bba3ccb32a 261ba5a61858c0b1f5e682ce92fc7c27f41a0174b5220c459dff24524bf41a70 3bc43963291eb29ec523f80661aa539f0449097ac088d251d6f19a92e444fe06 fc0707370c2a793b6cd16f3e6845af695be91523f12013035f832e4dfa22225c 825f6ae66d553fd0c6e2a2d9b8edf2a0d0d114cc39d19a285f004abe9895312a eb2fefbbde2b6e305b711fe90a05593c706d69ab00a2fd7a631be6c65837d34a 6c7cc6ff3421639349338fb83840e119d86170a1a8d402ed0749ce317da92369 1e9a97cabd98bda4b227066899cd3882994703c8d57eb57396b70f7adbec979d b1a32d911648b8714a39effef66615f76ae9cf26a9f9cb03021f27afac616b40 b038ba1fac0ba17250b07442b0a410399820c9e2b8e315d5b08bfc8a80328848 c0a1e953663a0f6ec77948bd8648663d0c73195adab5ed827310415bb77aeb1a 6a104c3a0049971b486c203816407beb95639ba571e7b9e0e302b91295be8493 04bf4b7c48abd37ff095254fcad585e3ee4d0c91b17e69e32066bbec621f32b6 48750742a8149a695ae74b747f507a638edfb658e0e2119d62942b769ea6f13b 3c444d032b3f16c05a16000750a32056bffbc5fe539215d0215bc278c164285c cf577c19f362cbab57ea9a8c10d26c219ad819f7a314123f90b819d2d33ea980 f9e5c6d23b1eb936e1b95c3713fcf111ceaa52e167ef9bd50cb094b554cc282a 33666ddfaa878ac211156557fd2a03fe849f890f20bf03e44da38286d31b381b 131ccaa51765b9dd0cd7ee1b2b52a6d5619acec8208ea24e667e2f22eae5db4a e0a664832b4739fb49232561489dfafa9468f28795f3a6e3a9c399e4871acdf8 55b8b7361c5dd9b1ba187577066b92f786be0a1307a82e0f587080fd08a4c7da e02c764d8ec14cb371ad6db38773f59e0e749d64e4bf263b3ce82ccf2cc04359 fa3bb7a3a7066e7d12beba3ef26ede758bb80edec4d329e496acea884f470f4b 9f051c8a1bcdb7d40a55a467e35d55d1871213e93809d53146cfc80b6b84d2b4 fabc7b45032947361fa64eb11e1f0540092c93ebb2612bbae1207ae705cef3cf 1d720392856133c6ac0f6afe7614797d0db7bf2198c3ec0b26ccf1504ec72a3e 38fee0eb8d01d5d5bf76ea4f11b86cce4d571edbe47f07985c7f0e4d2b289d39 e22fa963fb752e1357cd1df4703bcb7a51f8479a4cabc84142a8c9bc7fcdd627 fd2414f8db4b5c72955272a35301057a61afa0b2d4b3c16a817b1fe1c554715e 0aa218370dded31b6b1a1284a43ba966e6ea2f11f142e79cde6bb919ad7b52d9 92c95be07105791b4e13e8943824d26466e89358e6b0e58f130121aab2c56d66 c003814354d402795bd9d8d091913c3a1ac6210c8d242b6c694bcb602d387bfc fe38c6ee6b89e5b261415a662633139695f9dec780ec17ebd7ef4a8b0d202677 0da116a7b64c942e26da2abdb7d400f63bc05728da972aa4d1f3c4681a4d39a5 3a46b74c7d5f91a7eeb5712de881af51530161425ce74a9ad849932efea113df 13bb3d42d32bc61da7e0645768da0a0491d7729e22801acbe81b6143b35e73ed 75ef5475eed7826e5fdc631ff2a18358c514ce22c0702ab7c429c32f7e5c868e 99eea8291e5de41377a7e694ebfc62ffc9e681e98dd024f085b0400be723eb67 6a46680f537166a3f103689bcab3f1b7dfb272ffdd17faeab498681c12ca963d e65ca6c6eaff19895bff6fd35d2218430920ab2144178e850bb5978579c6a882 8d007085c9d1158ea766a0970e9754248a9955848fb8b9f45c8d01d8dca5cab9 f8f7f641a5dee7ae50d6d3c596b2047e3d4b5629dbc331febfff18eceb8a506a 66910c5b6cafa901dc146367d6d5a5d72c7795c58a78829b5678d0d88bbb7004 4c9e78a674890d869e6f3b453006a6a06f39b26dc3d17e494511ce8de4096727 66884f41c8728935c84a345f9b20c1227b147b68f17ae98a551dab74881a6a36 5317c53e0b743373eaefc98b911ec9ab712def730ae88da0de49e0c8cb07b762 436f777f23bcf7d060b40b84377519c7528542a7ec37c4d75da9c348a13feec5 cf81275ed332bb601a58ba2c333e2a06ac09481c7a09f441a8f8dc73ce0d5648 012d1df598c7050578c440039d2bfc95f2b5e38739595318eaaf60c352b0caee 186edfa14e8468337bcd89a4970e66f3213b3b4f3f2355182fb3d42abc1e7513 1a25b4b0c90aeecf3c161273e2d168827c27723444f22c997cc292c97e84ccc3 5ef5e41683bd0c617f2d07abfae7f1ed74eda4731c7da061f4a6dabd2ab69cc1 d14d09046d8b7fecad47cdca8411fa9697499cfc476fc2ace068f87767a1c064 20477cbfd2532d7382d1b80ad9c4cd740b02d4cd49024c9d8d39c41a46e9b8c8 ff620609e25425bb4d6ff359eb37f3d0269274b261e6f3e1b0cce6b8ad85aa13 1b28fee79b842829d80170752739a355424c0ae2935ceb9f123ffec73280e970 1044ce9c622c990924325bae9cea4b92b2d3d3b705900c4f1e574d82f5505e15 7fcd90fe1ab7d2a5ca4aaa7dda34117f833b4943ce5a6d4fef553cae627b54f8 2acd674202126c69f78f4878b752b748fa14300105246acb4a76ba1f235b54f3 b4170ee82970e90f5f1559f85cace4e0d51a0873c336a7924080788a28c7b97e a6928d84fc62a9b0c5654317730c31c2aa1a3b0400fd8a3bacca69f810700f53 e40aa51cba6ee754beece43eef1e0f526e8a383230ae737c10895581d50314d5 3ee21334338a1637d3be3820f8dd742b8685d21e885a34a257dcce4f6b883e96 04cab10923cfbb9b9878ed44eb3a96c256a7e385af5fec34180aa8df80fb4a82 2a10c30cfa986ac59d6de4f1a81605dd0e8df02a2c8bb26a8111c738d69e1e15 0aca6e0074813d50ef8c5289d272e39d74a2d2619062fdff4f5ec5b628ecc3ae 32deaba752f9dc9c51885b21047db057befd9765567083eb485b4ad1b4592fe2 55d46400347d4be93cc5207857178a3d2ff28398b5c8df5d7af8115f90cd6f7e 2137776e14ed3a4f7513883b859923db35d2fc01ff83b426d37aadfc2a809a1e c40a1685b9b9a1b67b4ccb4a64cd83347e8caa1bd0ecd4e6e3ea45bd5d645051 de3f207eb7d5d883626fef31bb99d808fd8ee20a7189998586b9ea9c287c2b7f d5c2a964379c8bcb6f06ef0b9623f535d0d958727ae375c5714fb691bb69af9e 1749b1f4ce10d2d654a34f588422062549f4c353519f82e61175d193ae0881a3 c6895e6ec82c39a00e12be748c36cfecdb03313baa7f746554b8db2850a7a4d8 c1a8de4d1e127e2fca66ebb58275a5262b05a759fffc8648dea83858959aa799 9bd0888e430bc2f09b15594f947e02fb38b94b7dc18d728cfc5bd0a7d4f387a1 1256961f771efefdc504fe09d58bf7720c9d2dea45bef969a3258a3f5989d2a6 3e88c13ecd7216f8fef0724986fd17f2e6a77bc17c6b6d67c447b9e0ca157b5f d24cad5458e452e42506c6d8f4d12bd01cb718d1401a5783e263854dbc59108d 1ecc43c3bc2b4c0959388a1c9c0ee9cda74f11bef13bf3ebb4b22ac104026a25 91253e69b36b2293c484d8259bbc2c9ecd67b60e11a581576881c37c351d9803 8cdae2823e2dcd4248b4809196e90abc1dd1934052536a5a490047a92efeb87c 9870e344da88351566213066158f7a8556f4e55473f258ba32dd09ca77164eab e3cfdef9034f62e5794ccbe5ee51d7611ea54fe9b508b0e4504e4038e69bfc8c ba05cb96a730267cf6100383fe1602d689a72efaf0cfaf1db6196a7cb4d4245e 795dac3c9050fd439f17a5fc9254257fa4e42ccb0253f8aba2089b947dfc9c4f 4ad8642cf165c0746ea5c3b16c03e7d67f7c58ef25a533aec1c30e0cb481b18a 072fe5b8ceb127887291f42f8a6dceabf53bb319b387c42b7d8418f8940334f8 d6dad6028ccfbe4c0c82c34ae1acba46db0a31af7a926dfc75244ef2a777072a 2982f0f88e3a5f1b96fd303c2bc16b23c0ae6e17de929b1641999497e0e72c1c 1691b4e98ec9898b8bd66f72d3870d71125287ed6759f2a7df134f3f43ba4ddb 7f7c3ba3d0b270548aedf97c09fa30bda09f531be7181b7626ab76b1d5018952 1e13823ea64fff21d3ff8d058dbf3325ab3d68d8e736c8ca625999e5e042ffb8 8a44e03c41f7df101642fc3cb9e91237c2d0b2c3f7b72cc986b59a1eb366dbde 133464b5fcad4a2f72945d1a7e1e9977b15ec77569fc08c275e777d36a09bc1e dfc060f68450fc3a9d6f812b3a8b68901c474a90c4a3bed89e660950e4fe63b0 c0bac4e4dc52940c514807b15d56c82e44ccc13c81c36c4ee20df73dae8bde67 fd63921708789cc140d6daa4b220bb52135ed39d9f9b064014adb098a620fb84 81c46ccdf231bba42e60b6a4b55cf8b3ecbc28149a86e8f6cc858e06b7832d23 d65d87db73deccd9670bea13b3ae30cac36a3e6186e8529cc11f61a503318898 8bbaf8f0f68d2e56b0f028830d01434f99db8edac98fe9915250e0000876fe24 a8e630a1405c2b18403f11fc3625108d8011072a326f2e057b8e36a9df9b5cd0 01f4af440ac9846ed9e4713e9db3d9b5a570801ae078664d9cb6cbe68960770b 5f487a273ef2334eadbeca483a4b30b78f59f245bbff7d197537f7ea2d714b22 db8474cb9df69bcb26297adca2a642e5279a607d225260c4d6c430240b9421f1 a5ebb6d7b8f7caf0dd14776589c6b1dd16606f4812a709b599c9b10fda93de73 5668cede82f5de291e9d8f1c45c252786cd72d2a6896e8a9a1f0b7afb0a446b4 601f109b5a11bca660a67c06f35833656094c5d4b2a636bb7240e9d503f1f6a4 a469396a1461301a4f8e66468f10add685b676d222ec256883d19226dbce93b1 7e17ed8d1169201afaed3b7583b5e4cff90a41b87db882b3346085e4d9a89646 b78c8e3db2a41cff99d9cac69c7d64c876ed8fa9b79b6f2cbac18fa9f112a28e 8d466b451f7033376bb7152f2a1f491be19ce3b4110b99176af4012bb54bf2f6 f0c76d82ad1350f93d15c1836bfda15d3dd7ce2df76bfd8978e1706215f9c5da 02a6b47deab74224dcfc763e293293b0d6cad511ca47174956caeb9d7fcfb2d5 9407122192980b7241a8e5ad4ca926500a058a586061bc78d4981a4ac3ce5dd9 c1c027db507f964ba9c2b39c0c1adc96369753c315260f9017e0357e665530da bc0b435053a6688be653d1b424b9bbeff39cbce5816bf861c2e90f466c4d3431 07f6af1b1b4485b06cf75219729aa9d8961beb5623d1e1927e57201744b653b1 24ed05fd6ad90dd6b9b1bc6bd32abf7e5db7879fa9301fb2184ec76190bf91b8 e01b9a9483b406a1c7685848543197f60f2da6a792c8760b9258d5729890fd32 da0a4149f55015ec667bd61f764cdfa6e22e3ba916a59727520fd9d44f10cfd8 a0c79e8537be627accb017155070709d44e707d9fca964801491c5edffdbac7e c6bfd82f59b140e0cb1b9b5175b31dc3b46ffdc4cee3161bd7e5920d9f56a45e c92419f341b6ea2e4fd9a33fc16705ad9bea517188c8081ab4d3bdf2fbf93c1c 4753e1ee170edd4d40c606fe444f57dc4bf6914109a64316ee7cfff6a5c4e679 8e9ff471e96ae735d0e1972fb077205a581bbf08975c79c74fa7068d6f88d864 c039759872edd01881866a26ba64239838f5d03ae5a3332e8e29e585904546f8 651b779b4fe258f735a7e445c38be578a67f66f9a98539771fe9264cb25d0e43 a1b78263485b7917a253ad2833dc09ce8249306a1b7728823c84b9e8c11aeedc 70519087bb6005b18ff7982faf2ff336d283e1ea0f2ea8b82e87402ee5a9ccfd 1e3eebb6011a1460e1bc22027710115a59658790ea820f735ee4e1467e23792b 812459760f353d212027cf6aa7f848f5fdce9631e0a946109aa012402bc94407 909d8db9c38652416c7306208e2f0b713680e1d5106dd913fa38c066a70af87f d60543f6dc530d88e26fd012ac6cc35a38d4a02079eaa7e18aff5edeeec07502 89bc2d5ae9e3d87212dcb994ef97920fa99e94ac699a724251db7cd7f785d498 a1fc6214fe7df8e9e5f93f8b358a7b53faf0a19b5c89ee73e762cf07ad11252c e6cf3454ded99dbbbadbf85afc558671a03d7907af4766c2a647fe4210a0618a e6c2d40c95ef90680a2d50563cf7ea0425916846b401d8728c1bb45c0a7220c8 872a28ec8362ecd342ff310a6a6cd3b1e02714471ba8103b424084150feb4112 b2388e5b143d1ccb23db04d989494bc17906d155f3f79143b499522b19d9fb99 e5f85acafd5deb5327fce7629186751e513419aacc08fadcf28e5a3f97631f5f 02baeed1b07a7aff9796f9c7adc212e4af8c8c94c12f3b4929ecc4c2de0b7035 cd09587a6288e150a3a1d768360c7b31d3216a17cbbdf84702f9ff987795ec75 3a4b3ae89230a7b2fb35f33856c06d9fa0ac06919bc63aed50dabc93e3158463 83244659a81b65636b41d088dff412b7afd300cd38e6e5831cad510ba09584d2 b39f4cbbad3e38844476a7538c9315b658ee0db512a079c09798a26143c50fd9 1020af9ce4b3cc03efc2943a6be4664bb8deb038f090da6f7d3835229ac22e6f 497f01e5d76d88dfd5b6cb165125917b346a488fafdeab701eb12a09d84500cf b802c7a8d4ac0248e66a83cb7cf116c1d58c7194694166e192a035e61b44081f d398e16e0ca38825d62cabc875452877cceea121cedf8a4941bdf9134d9e9b1e fc36d56202ce70529dd1a8d11321d2b50610b6d3f7d839ae2a420f5cae859d1e 7e009a13b5aaa4cf5e83f91a86ded20a1642e6d97ad141e9606af9a60f661d05 160be2a6e22caf11dfa0531b0aa6b5bed79ef3d0c869aa069afe6485d9d130b8 98effe4f099dec5c166686a45231e3fc7752b8f580930f74e789912b2df1a5f7 521943f7e9369a041d97b47bfb1ca01f817f65be3d8fea6d631f5d3a16f00313 f18c83811b55dc5a1b964e8d6bb47cda6fc2fbde38972fe3916fdc5d50a4d4d1 13bc6df749c02ceba2ac5118c343cc49ee926c37396d0510cacb309014f46a99 ff45b3fd1cd2c67fbebc799ca79435488935b378aa2ed09479897ab98553c1d9 f3134d8055e5e980b3f30485faf1faf541c9b5de6e646cdfb39bd3066174ebe9 d21a35dde7298dcaa34dea986dac935a7cbb2b75886cddfc52ceb8885feaa421 34b75d8960df56eabb17cb7ef8683cd28425689592f2b4608a86c5ec052cb48d 111e3b9555c17a60d65151a6bde7d5b310c68420e1d6473d12dfe027cd9b4005 0f6c796371a39b0391471ca65edbc83347e50ea5b9ce7a68573bf122da725667 71ac210223d2b44e2a998ace53443aaed0e6be7b4e6f10d62f80968f5bb4d1f8 587c8ed2b155d598e2193fbc41af9755dc78ac5aed6bd5e1dc9585a9cdb3c7cd e1539882ed5e2b8f58c28c8342401c7e999aa4260fba0d254670f4337f995344 644872f95d4bb3f214a7e171d4d08dda506600799ff2ddc445f003bf2703e894 9cfae71fd8b188a4e138950c078a45b8798b62116db40c8b3bc210b60e006104 82312abbfcb29e29445fe9f33f0b68a92d67bca96248d747b1a605c5510db418 bbe3f57e6a95b93c7c0f65e3aff786a98db7b1328c8f78d1ad04304383e6000f 13e20b74726027b754b56b6325311c595370d85912b9a567a1f7ab7b9ed6e3dc 5d6bb12093f296fbbe238ccb1c4484d4628c532e8b688f50366fcbe4cc41eaed 1bbcf12d8ac20050c25c370d7105203c0f534e1737f156f2fcf3edd9e7d54830 adf89fc67c222e6246ec220df5251442514685a233635aa137d10b5c97352900 18eafb100f37536f0b67bff7a751bd25c221eebece828da50368cb5a6fe274c9 bf867b10e14ee6ef3b0441844c15b3d69e51a71298b7dc13c410d1368a1da384 774f4e585eddd03ba546f0a1094c0fc4f4344abe42e7ee1e548c4bf1151c97fb a63460d98e48ae654fd65636e729009860e3b33e7ac2a1bee476f8c6106b6f90 22c8033548b78aaead87f097a0d975b52049cd3ee66177ef1e92dc23ce788520 eb9cbb904faf7d8a52235dc05f16ace00c4c57663aa7129afcbb263321dc4a92 5be55b670d63e213a0db4d0b7db284175c4d9fef5089eff2b687b110537c51df 377aeb41515075e95b611e74fe4458b89eafe098c44aff2b720c021c2adf9f45 eb4d4dcbaec1a03d08add7390088a1b6f78ab7c656f7b6eb80b8554b2b81975f 0857c3125407dd52f83a0b0a2b28e84d9649dbc53a3d7deb129891a856362ec4 c1ca95afbe51a06f02f02d086cb23b8fadaebd61a54aeddef38e3c2402cf87f8 a485c2b74a62074114eeb52be6db88b0e77eb7d93f2969a6d0558b37216f868f 211bb3c86eb6905498dd282cabf7f5e0158b4cee713bad6b485b9fbe6ed921ae 4e3e0e193251a5eddc02dffdfd44d1554a24505758906d55badf57bf362357e0 037e4ad427edc9e1b886310c6e91ea188e4834e03523b4f73b0a020d9004fca3 8218be639e934724475a88042b92b4744d8bc554c86cc3a6c913d6c749680329 6a38ed66ac3c60824bac4b3e7d5fe885b492b480cfd4e7d4fe59e8259d556dfd 37c937fe74d6b2570c3407ea97ce85e208b4642fed0e371842819336102c9e9d a2e5d2aafb845eaff397027a8766ab549fa2972c7d30adb751e2b0d33bc1dbf1 76d7deb2ca4d8d04cd588e5b94f19c45204a4be00b278b47c473d181b9a61d2b 84afaa89c024dc8fa2059b8544e0539a1529b709e4989952de5df69063aef5b3 26b64b27e528dfb646b475020dad92aef16dccb497093c8562bc53f7e71e6e69 e3f839f6a39470ffb32fc898dcefd5bb5318f51c61bf6a19de1b5928e24477af 4feafb54350899bd10da84ea262c0fca17df1b5d5fe0dd9752c45dea7749b8b3 6a4a92f5a1bf6fe26d743852a39eb158f99e0c3e3a21d342ee2c330b0a0b8f6f 82656a40b7e1e4af389606ce3167325a25155f117ffd1b0ff7364578c76fe7b7 4253ef0949809d50e9de9f14459f0aef6253f434d37ac518905bab3e1eea1906 8ba669a1152d93b537834ed02871c9f063858521b0c66c090b5bb2d024240517 6f0340344939d2a1e7038b9ccdcdd68e259e51a8334b913855d1f5b2c11559f5 345624ec3fbd716ebe26d307f382c141fe30c281422616e0eb6cd515b2692bb6 e21be4924ae2d87af502f12d16598d2e86aade0e7b51f1cf14e372c912fadb3e ec35dbccf97cf18bf9d8b531749b7a63ce1c3aea12e9e97a6c9de80334051841 a3c6de97b996787ae19b86beaf897d2b09bccb9c51878da44bed8eb50ea413c2 a44e2debc66bed4012397f51078c5fc68119bb2a18640e7f693ee03e5e024b34 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 false +check_ring_signature eef27e4a2da883a98e758181e540d268f88620ef3d44014b693fc5f9c7cce13e 65c7c2b92cad0d1841d182336af010aa7b2c3a1257a7308e6c7ab4e350f9d339 225 c808efad8a3f8156560c1ea14906a8fcc729bb93ff8005ebb53d71b7fefebdd3 78925f49234ee0fae2cbfb218266bb6846f38285381f3c90f6d55b87fc79de3f 9402bb20bafd94f157cecdc5729d9421239ef54e929eae462b085ea4bba5392c a208abd81cffe242a250cb99a64e524c967df158ae55c53f974fc08269368d41 4639d53ff559975a3613fb13afb7acf6e813028b1d9a59f0c0bf6bf8523ad8db 3301155ceab385386a1c120f9b285e8aa7711159b5c2c43fa9271b138215f4b5 ef02137d17f514495773e43f4c8b105fa73eac178576eafccbccfdcfc5aaae2a 7d64f349a9c8da5035eb3dea05d548df4756e17c34e73b8c3f76e89ad760fdaf 08acdde11f2a167deceb0cbf49bb0c47edc36dbaebe0061c7055805aa8ea5e53 00283ea7ca3d7840e51a5024264ca0be61db961b8ddbb961ad2fda5d907aa5e9 5179d57b85fd5ed63a3e64c4b6a1cb2b825ad2c7b4fc45a650e03a930e11b2bb 2abd1bccdf7262821812631615561cd1a131aa6e409206c936a13ae3860a4d2b 72a70a0c8fc3fbf2bc98a48d34be710b31329998425c73649f06dcc200ad33f3 c5065c3fd6284099fa4bb307c5ce17cc9b2ea54c2f8d53aa135a7e2ea3b3df79 1e8b4f6d919d18bca5538bd6b789a52f87f54102897a09d9bdd53cb71d15c1f7 eb4ea00936f7f69460f4f5d11e05c898a7ca5991c7494e0f8f46b55bb7b2a7b6 3e1fe34c1fc02fab100fedc895062d11ee8a64386d5f7fc2b526286c9f708375 b737dc96477a290d5ebfe038f9357f33365fb6bc49a739c4a8f95daaa9ede139 da597a73051a20a7133228dad67218adb899cb6180e5c248521253572eee7abd 2fedaea0fe0177acde8cf8abe76422272b20df85b5be6a4c3eae9767db7a554d 5b60911e42938fffdad3a34ed2fc906cc2ceda592c8c10d172d8f7202026b043 da1b5fbea4e1b8c19dbf6e9f901a1b65b8fe2eab266feef81751e8a477b708cb 863e7d829acffcb4cb761fdc7e98d2fb8faad17356eb08c101eeaa3ccdeffa03 a2dfed009afed7aa9cdbad6628b47001973520e422f48045fb65ec51654aebf5 131e36b0912162445d82d322789a59f539fbc214dd53331c4b50304abae2d4aa 3faea3b8ab161e019d0da8c3d3aa7b618aa74b7a5b03e14e1270d21d07baa3a6 b310741b6065541ed0fd0f005a3babf114d471901e2902f844cbc094374e97fe 59ef95d9671a37d5cd208247590ed6d1a4ac09a696183a26e985716dc7a8c3db 2840d76d97ac799cf369f94a785edda82d4fb0c4520409dd03606c22f62c07a7 ebbac3fdf8437b20a0ed8ad98113e2711ac191822a671789d72afe6abecbca3a aa3da68fb1ee5a911bb2360a3903957ec24d507e06de23528f44af06ef4bd20c e967367de87e59b9c2a8e072ca246d80ee762b5c4db756a56f60fc24acb01fae 94064b02c4f424c3744cee0c9d65cba74370c59893f996d73db2ce0500d2ec2b 4c31fca263033ac18d4780dcb8ddf7fbb1cdd5e31f841e6e7d4d1ea8302d5f92 8a0749a749d67acde9f9798667154cf87fb82c6eec279206c02feaa93a6b0562 d130e742c07a8df2bb188f05137418f2237320711121cf2714f0aa561b4f71f4 bac4b10ae6fdf78941b61a790449fedf61533c9a02d02f1f92bd558ef197d070 335a8ed685460ed02dd313e1cdd54b8bc178d65cd70d281f8d8493bcd7e4ec8a 1b355c703ca75d5837ce3635cd265651aebcb79adb127bb064a89762d14d1cd0 d1b4b32d218a539f536089d8666eceb555138ac0fdddac1a6f8908dd061ae2a2 63c4d28012b17c33ac5303e093a812d239427a8efae3f1830c52325108c957d1 176ca6345d002d3ac55b9d60c10270d4a5b2ae81cabe91f5519c8e69d47a1e2e b2e1428456fb5d003bd0ab408ccadb07cb4b0c503dd43ab456341e8b6746f0fa 070477450a9dab56d91ac08963f05c4546286a62223b1d2482a049706b382937 3c430e9a119e73e2395854973d1c13c4296f6c282217d337edba77f711a5a991 d226c8d1990fd6fa5e029f98133acf90200b732d6586c589927cc7e3bd3aa9af cab130d0734711f4516592ba5c4fe7ec47b065e2b4d3853ea5dd5c05ed0dc3dc af5c66b80aef9fad3c4851ea9414f5036bc0c9a7a3545e507e6c35bda9f63c79 fabd6c02e8983b3729c49c91c4a3f21ecae05fd964b62a16362bd781521e635a 5242694b0ef55a474529766aaf3a31df7ead7d1c5793fb8a0be924f073796224 9a173b2e5e83e7ca46af4748f98e216a6b2e323baf9e200ec9069d2e0c1ba3be 88af89f592caa2dab93aa8765a7bb05d95cf2e0aab677ba3e9656fa613d96ff3 81d44359521129e9ce2d7addc9a7e6eb80639a82a0e81f4bb3bb9122a0b1fb56 981ccf82f234e26ea9de71dacacd8c0e98200646281ea39ffa9f364d9004f5a6 54adb7cab99b80e48fd306bf40e6789271447b3b1129f2dd136c6db50f7317c7 88023392c759f2163b5c5cbce8de93c7cd232bc65b9ea0403b0387d9e38a6a02 b49a0f7a34b8486b67f2e7df26a823e45a035ff9d3eccc4f33ebe28320034b4e 82a448d4941971d317c24166be3e38ba1bb903f972604fee39286ebeedab0b39 736a3a1c132fa5cca59cbc3d78b2a3edf7600f910867d68710724e332df52e11 b299b4f6fc51ea90865007c0d84427ce0e6bb0f4ce7122adf47638d3bc14f84b 4aa3a6225e9231aa269e069ba99935dfd5dc79a993b6c5f1b9b141eb45c39ec0 a973147f2b9faab0b55d79e017f8266638a14343485d4d34a007658c8294a448 40a18828a1f3898557122edbf71bd9475aeb6fabb29b19aac24d3abad503bf3b 66f014ce25a58b460d68beeda9321ee68d8cf2cba789a8d6b8c61610774af6f2 3c7c45b9b5d0c340dca84be33d58477922d5aa6720d600af1a5c4c9ea4002b08 4069710b05cea080ac4c6838ecb15de28ba8a87d00c9a565c8972805846d98bf 8395ebebc3a76e81cea823edaa8794ef92ef79fba806f25bcc6b2e11d3b29a9f 5861dcd23f2ad7eb4faada4d8c5ffb47a8887b71700e45c7143dfa521e3ba3f5 1ae9fd3b25fcc8bcf0572b483c2e47ce9e61d687a33d9041a93fbf6db0804fdf f8a5cee217efd65f2421addf0a34d0ea186ca829835db4758bafbff30c2bdc34 2da6610724285113a04a5acc26f74191d1e8920e52741a2bb37198c23b98a88c 043abc9f8699725c93ecf0795af466367105ad0b191fc6a1caa924b6ef1c4ea6 4a5ed419457d7f3844e7bea0620c916befb5cc9dd639e27891f85a1209f92926 7cceb2af3fced88a3e1063481b496f6b7b8b3d320cb07c9e4b2250f80b19d64c 497f014fc15be2fb2c8829eb860ed640d10377a1ca754a10661b4bab47cc2e7a 8e2c1ac26973ee72f60b7be1c864eef8036c7f585efee666d1f9fec1a33d20b0 0b002ee7b984291fd22364609c5c0fea84679a8d4678730fe541fd879a1b471d db4053f1bab9241d1a0c3afbc42464e5f17acb1c4275df834a4cd7924fb642f3 ca4f2ecf895dc232dfe175c0669b6c4b20ec20e4120055d9aa797e84144b95ba 6660a8782664433ac45be32b83f7afd26f3d8a32cc8d345a01299ccfe5403aff cef9ac827107993a7ae92dddc0ceb5358bacff78a7bc60090cee383922859740 cd68991e1474d382c3909834669c37c49cb3c24f9540f464df7f4a2b7efd0340 fbe86a2f7349c64ef22909d840a19539b44c5f57bca344df65141f215a5dc8ad 3491df0eb0cd232c99b0170c7cbbdc04204302b0c37617ff990b0e2760b58849 5778817ea20a8e73d49c8fcb0543dc129695962dce7ab5ff68c7aea416e2110c a1ddf2d62936b5c77f6501eeba9eaec1eb98628b037f6b7bea27824fb85ca83a e0dbecda21dd25c34d09036fe753e657ec247f415246522685e76bf5816e0670 1f5d908d69e0e57876175f0850b31e18b8dedf8a9d35be327817ef751f275ed4 19ad8381be1d9c43fcef0d6315e3c5037c1b5484f9ad80fc40e48c0c387f01d6 ffa371ab1cefde7e819659a36b4643af195c3657e12d9e62f546871e01976ca6 0d2cd8156c263349798651a306fe3bf192c7f3e4b34cf621bc702d405a4a4b50 2ecf8b75bc5dbc1c0f61bbdd57175a3ba4f002fbdb7745c0209925ad870573f7 87494f245d8218f567b27e0019ba9c5f0f76a0630efa0f2a5b7cae66b32c03e1 1526379fb1ad78105370e4341bef9e7ad460963171dfea3ad7c44af1d730dfe1 360b8796403fb2c8755d3a4cbad999175d84804f063ed348804dcdf927ed7725 2340692a33a9243da85724afc67ceca3ce23d8fbc664cae2937564d97e58f5e2 38b6295656edebc536d6611ca84df64fd2b0d55c50f271b1695a05b237e08519 6e217ca3cdf2343cd27994e06d0f95b29662881482edc8f6f386f5681a775b29 1910581f8989db9a55ebccb377ede6512ede84306e2ca3e5df70926fd2c39d1d e72a0e78a1b3f3ce7779835b3bb81325aca41ab3be49c6872b610105f8749800 ad0d9fe6d4b649a94728410e67a1dcb1a58ef5ae98d7f388e88611319012d32a 6b7a00c47fca62c250208978a540e0e94cc0a071e504bcc474877c9f863adfcf dc8125e89c19b8fac0b916c7d3225c2e5929c14195bc74b93ad4361e3d745805 cb1e3326ed208eeb1f8ba0b69ee7e84184f39415ee37f90461b6188f6602fa0b 2fb8f4506046bc46326fd8679318899cb6b0d52ea2c78adccf7c71c2ad503494 75383b4af313f45e35a9250fd102ec3c2c6853b9fb62928a232714050ab3f6bc a251dac125e90ad2af82b6bd27722af2a9e6123626a18139b8175a648eda5a1f ea8382234d591796d8c780ff5b391c9bc6815953f34b17db14781f4aa55a884e ee01e8e9956aba42a7d651cf2203de2616f930310eeca629878b85053bd52d38 f88d93414c4bad0e916fcdaf8a412474b646b06445e4d37e8fd3eae8ee0ec0af 444f3549571c602ef925cbdfe6af4548bf8d5f9c0ad4346d6a35ca8c80cba3cc 1576c1a2d93c70ec10adad48ae9e987b0cc86d9a1ec9241a8e20e1beaa1e85ea 5860bc797b10b7431b46946bc32484bd61ffd2a5527db765f9973d0e9cb7a2df 049a3eeb0af87d6db5f494bc8401d1f3d8bfb15bc8282388d23db65879a1e516 b502b98777ee70512f82d3a3ffe4452f10818f46325ccafa4a9645569d02b246 5cd29e0b24a27fee15b62578c7c03c4b7b9e8029a8c2ac11d3808effbf1f1617 2c49a35144aaa6461610bef114c5f254348ac02f00620330a2634de4d2a44238 6fc26339e6a5f0d01908e53698c157c9065d2a91e03532426a4024bc7d6f727b 12802f6fe2ac6bb7a15a60f6372e874cd6da17f57cbf2296a21d7e76621b6cdc f2ab475d9942896710204d9d9cf78d0d29435b6c39d23f22f27a48f166f5143e 81a80bec0d937417b3d2a9a933f0d59ce8060af8c969b0573d72ee7afe8788da 812bfaa2ad183a9842d325d6c586c6449392c4587a7f368cff776992cc73ffee 9c00160ab70008acdeb46b5e76a90d7344a9a0bed18b7621ae03bceb3ecfe061 4be527746f18524968a76951c1f7f4977169bf30aea23af0d29b0b4e67ffe3a7 5911a0b42fa950c31678b820767e834a168171f845af011d6f487832595d913d eb6af4fcb3945da3fb19f9868a6200d0c0985e234feff0a3a13813b40cdfe2ba 5d5eb7863d0986180b23698cedcc5995a580a4b46bf67eb73f5fc0acd82f29a1 63c24f3a78eb5602d15c5cdd4bfa32c3636418e059ff4dfa38746c79602be2bf a2482f211289f086baedec59b53e55be757137bf10a1b1d69030b73c57515b7c 809efc969c03de97a96e13ab4c74e424d2dff137aa015636208b1bb02edbac5d b2b97a88cb15b0a9997fad0aef437aa980dc03b0ba5764edbc9cabd176e423bf a416e5d8438416f2a7a18a4f3c6c7f9721e90b6bd929376d42629410f3d3fc48 d70cb54099feb38eeaf785b5c3b575060a9f82b68e76553acdecdb338074d387 139ac44fbaf68e5fc6e359bb3561f79b157076937e02ed817fdd96457e8ff469 e6cd131e5eb186b73bf17db2b968c7dcadc97c7f26ad8304eb002cfab7c2906f 631aeb6102d4a324943c8566abcb3bf649fbeba454fb0e56c1cd3a3b73c7a5d6 87581c71a5b582b421c7080098cdeb179311eb3dd5169161f57a9b24feb8193d d86eb4827bd6584f72637997bc35898865f846ca6ea518ada0461f545b92f277 e34ed00f896fc5e1f042511b09e7c63db63706f69d3eb33d2a6f31c5d59b8cf7 eba6e195c0995369c153384afa6894e1dfcb142fa23583df1227b1f0da1cc8f1 6e8a7c9e5e386833ccb41c6ddfde64a2b36bb50312400b0aff6a3bc87dc7ec15 aa86d5aa97415eef1e4d343b197d56df0153b429e5a3f3b5bde8285d79749145 160aabb72390be928d4d9deee4c87f52c8d3cf4f83c6184703250e81e6f4eb8d 8188fecc89427131c20eddd7963ae081a3f46291f81f26faffdecf921a2de353 dd4e7e49aa0140b7b7c616080fb96c6fb5b63b4c1554a1372d8a55f31137a2ad 8e66b926f8cbd177e993a6a479ad55b31e139db6177f2b19ad646f2eeee3151d be4cefd54aebf81d314712428239569b0ffec56972cf304a7c16e23fb13755ab a737a09ab9bc7a86b48f6a4ee96213cc80aad17483369db22afd85b07c57448e 51dff80a3d6a077bb4b46870fda128e088b22e25fe49b91b6dae913e7d16b747 a887f8f808e5a0dfda0c71fa1ff0bd1bd772f6290f5c57aaa8c27c2d06292929 c4b1fc513c155bc327333607a515c5650a7930062b147d5b2c49d6c4145952d4 6275915e4bfcce38b85071576ed7a7b539ba587c45ddfe39085da81a7b13c672 7c093af65a57d4af0c2b437228f76f05795169b4ccf8d4478eef4fd69c967c9b c44f2ab3f7c3bd15a756af6b5033aa1c7c500d2f141fceca2bcddcd4b2baf2fa 315465d1e3acabc70958e67e400f23a85278a6b669dda98a302df6b952d3897a ab8ec100f7e459dadcce90372571da0029ba3b860c6823f0dd7bd99b42468c17 207753ca6a5f0f1fa5890115183910a32d2d270493522a788722d591a9d9456f 13507fccf39c7e9d2a1e7f2e15c1a6b22ad97185cae59a607fe8b102f99cbf51 b2b09836f414ce167188a9d01fdbc69f3db111c67206f583fcdc6d2f00638309 2947464dfe726b06d99ecffc9dc64b9b28d10c458222b1f67c2b8b35dc2197a5 e0f77544693152d702df5dd3e4d795f82b23066831f53c9bb23a8ae2303e7d34 8b3ff66b63378621713c3aa737f36f8c5635a1ffe9d9a170d69e6f0cec5c5225 e93772a11556ad9e8cf4a084f742b3ba5ce2e575f152d2f55cfda2ee9f34d14c cbfe6ab2404ef0212356e5ddffa37be67903c6f109c30a3b03501e010350d556 8974e764c3f4ea6b0fce4dd857920863b4c613aa26f1cc305347d5b21168efef 2d00c72b2c0074129454de2cd835d4ef4cf8da6d2e16adbc42ba4ffb4b05ee1a 04afaa99e00374806315cfc8dc0c59620c03c5bc94666988a8a93e81e2c7a7ba 3bbad8e2ee49bae7f8768f49aba594232d9b0ecb1e1dec96362d4b85c2f2b603 b902dfddc51fc3df12c48cb1943c2ac15812b2f5f1c3e25d92a5697f92d5bb5d c6fd255ea9e9fa9e9f775ccc631399f3e91a6f3fc92189001860c764621cc26a 232da0e013d1c1f08a0f60c2cfcff8a90c080ece618a422694358e219215bcc9 f1eb06ee68895839a845b26ef73c4ef6f4edabbbcd551f29bbf3e29394238f89 0779da70ef0b7700215230bfb5c43865b4c82c43edc7bb214ced95bc37fc9a71 2310deaeade4fefe8321ca4e8f7ccd9a16e9b9afcc72454e8e059e440da278fa 098aa08ad28306c9e3f747fa24cc67b2cfbcab0e9adf34aaf7d3664b60e70252 6cd81bf938624f9e59d55bddddf7b2fbffd5f2f3c0236b3a45e4201f6756424e e012b640fcd94ac36e74ea7acdb6a08593ae861ef4353fa53a2ea62e1674c956 593d878e654c85250479dd9e8fb1aac0fd9e4c58cf5308f3ba125693e8ed9d82 8f7803e2199548e0673c65d32beeb67aa6404f0d8184789ce2e2fc257140e90f e7c430e10c4c45197f147811ae8c49439c70433ab2dd95232d0b185ca350bd54 db3c9604ec1d55f78aa7628cd3d22d665acbf51e539fe2d3b03b86715d091690 5062fad7d3b58c246009a4e4ea8ce2305116c70b41f41f619dc3df881d78711b 8e1dcf4fcfbbb90a4a9201260cf844012e1aa0e68c5a0a595271d795c7834b35 e3ccb4b363f6edd241e35e2bce72dedfea669d1843fe50a4251b180e8aa0f5c7 c38020f9338a1f4c3ba87d763506f0e694532776dc5329af0fc957e98e79b959 35a0f0a70fbec8f72237b58009e1a17ba9389a876642767654efd7b137875cd9 c1a2753032f7d59d089535dc4ac296e4a5ccbf09cd506b08c9aab59184305879 7408231dbe88ca7c9181205ae590c63029c41c2172c2a63790752c76fe976825 850e070a4719d2f5938c4485700dc5b1e038f6bcc109ee661b352aadd90fbc81 1731206b2ecf5e6d0778872b269c43d65be0497df21ecfeec4c10ded2336c782 7535d9a950950f486344d1110eddad1d9e7e612a74d84ab1faac4ba9f9abd6ed 25088e24208ee6e9fc78406921e5a4cae7069cbbed113dfa1c09a9b67e472449 f4aa5850012a2361184633ea4246149df2eba64cc3292c88b7e55609376de868 6e551b666ed357e398cfc65397b9f193c55c67a4076412c4d7a51ad7a650b403 10620e14636c6aee485c87e2c0fddca4ae31f2edecbcb1db55810016726f6e8d 130bee1dd5bed6ed1691ad501b5b779c2991f191e8bd2ee89120e773376be2b9 1d06e5eaa45ff5ba33302c449148cf4dfbd48c9a592e89ab7b81a6ba2905ef73 1c0293e3445062a72ed30b0d05646a7dc95c12fd16197b36057d1fc030eec890 1bf0dfdbdeb5a477e39fcdddef9af1bb0cfd909bcd8ba49d44a6c80feb85e4c1 25ac6efee7640ea7b8b4d26c6a901fd6c64df6b2686cfc093207049ffdc33b90 51d45fbe238c7cb3ad4f60bb471ab0646e0a6fecd1963850add0a7fd8aff25ad 6898a7065d8aeedc19389ef4d1e640e14815ac9145471b28f0c3438dba6d3c03 297e7b3f6f2945271b5a5017938af548c9f4d49e5907bcca3c93522eeb099ef8 7aa7533b6c617991c259911da4da5419e087958f6d1087cf6f3ba5b90185358d c6504594333664bd12f38a3cc8abd9eb15afeee4e4f768f6972fb206a5385a9c c29d4d53dc08ab9b63513254b03e04e7ef020c19722246db06019a28647f3842 776140b4f3825b52ab73546e3958c2d708bcda6a7280ef015dddfe609d53e4c8 c96d1ed4448ce66231357d340ad5180d99bdaccc9da37468cfe3ff30f1cb98cc c23c9ff6a354ec461fc139be24d0149f5ef5b10aca34f599a65c886cdadc506f 7aca10004df08f10d7a4f9ba0a1bbb5c427f1b2faafcbb470d1131f939e79ca7 90cbd85d63b11ea06301679074906a59bb6d68ea23fdea446e5293afb654c604 e3b181389b2f94b4905f3dd6665fbf07b1cdcc412849fa80f046cfe021ee173d ef91d0d007f82ce9abc84107cbf4774838934518298d515b7c7fbc4f3e9b1f50 1f8cda664d8d62e9b18cc70ebf8243ea57841f3c39c74db90c2668e2e7f878fa c782855f83024e323efb105d38b4e9afdc30c01af907c3a6f8a2ac05f5cbd131 f9a71e87677c416b11dc2605bdd65f658c4bcabfda834de889add478550caa60 d92548ba7582e6664a740f47f7f467e34a2bd9fc62a020a327ced1f2511be7fd 3024671045ea98c2393a6562375943d1df45307c099b65c839208bdde325d4e4 d004038d68592c6b674a65f2d3d527324429dc60d50c8dc371c5af1372a90c2d 8abd4c66534c59825ebe86ebef81a0ad5e1253231c1c27bd5b911d4cbe73d417 3a06bb37051fa123f4f78ce0d86089fbbfc3581392b7130f2a38782248074996 a860e702081e8edb99771feda1360222c1c2f7f6129796de0e303e947ae77493 050d92f3d33cb399717c4ce2fe2e9356e9f96d3c238a12307b6f3d1885f251e8 c0303c83ac347863a0d6e0c023db4541bbc4eadd75e8eb420cb5269b375203ed 82dc810b70babef5b698cc3711a10488bf367cc4a099c6912be9cb33610479cd 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 true +check_ring_signature 388c18af22f9e5f024a4ed02ddb28680b7bc3f3d8df8fd5aed161e394582f27f 3e4488dba58edef21ffec5c8a43da4ef7f0388f934bd4054b4d6d4b3f8d41b01 98 727fe3fc4766dfb57ddd825f573a0e22c7ecafa6dbc19356db90a408190c3770 af9f66df452e66f05cd8890ff0aed1bbde7d81b43e26b07e0025eeccd07b78f2 84afc506629083b43f60e0d309bbcd0cd739fb86a91f4a18538d127b4f4fa208 7ee47aa1fc6f7b65e358cec85ec93c0ed2225896359d6895104cb80bddeb68ab 214b7edda6aece2eab07aae110772118c99901b5c818891cd4dbad9eb94cdfaa c05dc52e09ca417b376a40b74bd651a7bad18c807f915e0aec6ab981bb73012c 39f743200ff38619555fd170f5eb25ef1ce9651b9083716c01ab6fdc7c021c45 0932a810353041469044e61de7fc67b02abf494906e5fb2c602d32480678248c 486750fec533bfb266abc03cb7a158d05327f3d8ae6b13ef681cb745613d9f89 f8344144c5c5b777316ab37c242b016e40306bfaf2f21eed50d374c2bbdf83a8 2cc0be0e24116c79883cf85fbf48f509397e8fecee8cc14a7ce2da7bc53af4cc afed9ebec4c7d5277852ad1302933baf2d8c2ff43a4d0d3ccbe9df9cd6ff7db3 24d634a9f4eb66cede8164b11d40d53fee18f8aace654c37c3ea70cfda71cb66 d8f8c511a016fcd544ac9e0ce4332ec35451085393ebe8fb1cd00159f597098f e7f05e54f8cf70d760fc8371e0a029c0b6a014929d875930e6f50c45e1fd0bdc 39b7eb39eda41c0d73d80cd2fd8ce419b55c0a37467a349b9f7d3db5db619ec2 66de334e9480e6d21a1461a4011c07f9091273f386aa284deb5bfa818c55ced8 aa635e769d5e69a0a8190554fe518ad1eed322fe147907401d5ca965d1b9829b 5c72bf2fef0c254f1ed3f4efb2e0c8cf93942d00859e3b5dc645c7537c1c600a c6ee83a6aed840da332c211f3f8ba6cbb98126eed1972a67ed905a62cd4471bc c15cccd6163d4ee6a496411b160c0f4d548e02125de05e3bef6fd8d79a87c70c ed535cdbb282e1bf7274e4411d8e2a153b84935baf9f61b7cc28179177204b8a d8264fee7213dbeadb10b2f28decd15da1ca5da1d821c310f46478987f5b392b 023a0c0f5dc2e35b4700d6b86d51f814fa728941382f0b590a7e669e3ccb3f74 3146bb24161e4d8fc3edb164c1c7eb3865d09810bdae9308091db16786e287d5 3b992804e1b8c2884c3205356aac9399a8de157e3d04eb95b2fc608d91af0230 8f81bd0b9962a8ade607b0a5be96798cef4f6ea8909f826566bc1194717ef546 aac5710bbc51d0c94f8b47277e325fc08ae39a1c68ed884bfcf9d72c47b492ae 5a3454dd2bed4e95663192bcacefb57d297839e54c55eb65734cba53b74d1f3a 47f990401f81156243baba847ac4a488a6e476e9f3c7b662b6989c893a361419 f23be093d2cf5f5a00e8a6bfac327aa37132d6973f208c7829ea994b8e6a0278 1c00f3f21ddfccb5a4c7ec25f7899ba47ec318a0f38848eb03cf0e3c3d8f0630 88c9decab70006f6af09e79511ca759ccaba96a650ca39cab75af0d7c9601316 39b0d3c9905201ea77c296945bb92b7ccea45a17ee9f906574067de8a53c766f 68aa939d3ad5581cef446164c7671aca75c98c50dcd829ce2f4ee8515da38d55 0cc0e96a30417ff0140e192444bc7394cec77efd2bb05c10eabeb265efa57c02 0703dbedad02b15c3f571fa9105ae39f036fb450213e0757fb1d96fa4a48f9a4 a14ad7921ee09aa4c4ebd7695fbd5c371c7774ba82bdcbe31bac0fe061f375f1 e5d3f3c03d3b47fa605fd6961ead9f78ce89f1c73903fbfc3aee8e8d09bf8288 56c162d4091be46cc93963790826450e75a55ccbf63fd88460825769118652db c85e4742a6a6710d7cb17f2a5e7d05e94fab056e7ecea0fecaa1be107c904fa6 6aaff2c41b3bff7e5399391ce5462a0938ac45fa789f6dda9645e834491e0e0d a1e592ebb23503e3b1ea6d8fecf5b6592b42e78075347c5c4ce3ca609f744294 dc6fcc61fdae35e8d1d567b729eb5ba87580c07752000a75ec911cffd3ea310b 6d379302a4b329ce018c13eeb8ebc4d7bbf58f6b7f288bf6888053d44005318e 5fec21e1cb1e014fcb1cbd73f6009227e18e3e0ecb839aed530754964999f901 1a17bd13f40febc26fd6b77991249fcbf8c6902b37c9f60574621facff00f3a3 b2d25c26684f3f49c54f7335eeca3830a06e72013871763f095120a8865fcb35 2d0685870c8d2431b71cf41c79bd32ca7611de0347be42e4d0a3ac0b3d2c2e1b d01a9b2347de4dd3d037717fa5f310aecf49314bc7d61bd2dea86668d59ca4da 0c353e70c9add528df474a5a95723344b047f36149fe69d4730620b043589a46 2efc0a0272259b049a3de34612f875658e68d1083051cad1daea3f3ca8f12110 e4876a0d39af965726f820e0cdb6100988be240aafb8c20b1361d1234410d226 e740c66ec24ab94a7c401725f652ab9a2a482daf6346938aca1061dd487e9223 c30a565abbe20c4ae4f5d6f7318945a61ea964fa43ea775f184678f4ccd017e1 2a0e3e543837b6b52e202dee9be7c353530e899e0743a39451980716626d6f80 3c80de7ffcb8e616ad87dd278a8cfd69e828708dfdcc16812819a66520709093 f5a0d245e55b4d8d4da5bb00e9f9bf8c506791a20183d867f7d6996fe7d8fc54 6c479089897fce8991ace4513283510886a402e56929a4029c56ad094fdb789b e1e8305dfc3f0b6b8ab054b929f3567cef4801af9ca13a94685de4b8159e86f1 398f5a9fe0f7344992ab09cebbfc3c1da63052e809b913741a4e813b46497a6e c442400888ae72a840a9bec27922132a7d44723a482aeaa16b0b89da1be64fd0 cddaf7b918dc3f2b51e7a807664b27d919fe1d9ec0900bca79dadbf21e1feac8 b98f83b6b060bbe8aed444f04d0dfcd7ab2ce956f91ed38d3720303434850888 d8345ac8574ae4d6fe4cca379101f7a7b904bb75271eb5e065ba0ee72322cff0 b82682345200f21495c1605c15a6686f477c37d764958fb1ac5102b798b1be67 06fdb8f6eaa7e78b56a7c8fa28043c14ce75125fd161cefaa6ad5496e7a813d1 4c4f0d78cfd1f4e5afc27f9dab02c7b3aaed9ded68160230f20baa7f4dfe6933 746c87748edd098a51ebb4de691ca2cfc1db9968d85b9757c06973b331826e55 0458624b3278f8fbcace8f559890fef1052d418716535127e8534bb74871cdfc 0ff81aa1a9877b0f845560ec3aaef76c522ae3e4f0aaf4c023e3f55fc4b1bcce 50341ba843f7f0cec908973617f3d03edcf2cfc4fc89c03811f101d04cd5e769 3ce6a8e92559ef56dacd981845054ecf20432f19576f27ef373d135d391c400a 99b1d5cb9e2b47b2a26db4ae5bd83bd6fd923fe586551d2428e5c9a91d21c6b3 f1072b7552233d4ffdd4fe4c35f2f7e0cae3e17c303f00ae912ce9378a25e961 e3c5d3a0da040c45d27036eb957adf73e71c78b1972db63f995f5ef1506c09e6 a825f92c1d7c1b290b6d67061d13a5d5a111ae7167ff0cc55e5dad13c7f5aa9e 3a06cb325cf77c673c3c1457d832a07fb03f1ca1c9e8bbf67c22756245679925 617d37bcb1c0f86e01a4fbd267c72f47e2de0f459c47c3e4a2f6a4cd8389b45e 7791cfc6d99b01e01cab5bad787898cee1f63e1b95fb4ce33a96e324767cedd8 e242202b950f2fc8caa5269dcf98a786bdc76f36e9773bf279e5fd08e92db518 09968e6572b7a51bbafb42b87935ab9bffbd8411923f5270da6bd3b3e2e508dc fc21504a8168dd5890d3d6c5585d1341f2572033badccae7ae3e6ce6ea74d13a 177f7f9af7529e31df5583a8a936861d64cd7c66e80905bd20a8b9dc6c9f0fa7 8cc9496162aa541b90aae51aede18f9112363f9af12d906c2d4915f180ecc8cb 7bdaf317e21a3e1f23ee2a16623eb7a9bd48bbd7c44b2cc1d6c8d809f8480bb9 cbaf68938d3a717aece4632e25f7c0f698a87d4630464956cd7ff4f685cb34da 6da15255c73ee6422cd8e9f5b27c0bfb28e91924897c8c27c45693f941ed8efa ab096f92e68e8f4f91ba3225d120a81a7e602f29c49d8f6fd12bbb87072e76a1 acfd7760a8ea527788cd642b510c5adf3f230d047645a57a088ea82141ca8c3c 015bc8a1515a17afd9b357317c5ce4249989d2d1fbd6e02eaa224e64b5654d0f 28603bf7247758ed38fb2773e0ee8856302167c9f0175e01f85c8d7a934c79c3 bad259e1a784d95448c008bbe1ad843628ae612a7c57ee66506f68a8d038b3be 275014a82e2007c4b1c0446646a133558936832b03db0120b0aae9793c6b9a70 9648aadfdd5a7f3ed55f58511de140fc69d0c776ccacd7f61f45640c3b39153d 410e6cd6ad76579a9cf292fed4a477dcc011492ca284ce4960ced97d07b9b30a f403eb0989646fb2b4f3fb9dc3fe4c6bf00100800d4d6f46f6cb6ce39ab70d24 d3493260221ac7fd95447b5e727b4be269bf6d115331ac906e0dc62437852704 9b4a4a768c2996fb18bb4f93eee0b6923eeb750e28a84bc3be17bf4caf6156064ec60d144d9576d8af242eaaf05321a2f8ddfba54a3a00275a4f37438ad1250420a3b7702d78f7bd81c6f1499f6712be891c675453ef3360973e2db54a3bc40726cda2da4dfc138fd72fa9944814ef6558de3f4f7ae4cf9596fc88dd78732e0324c67d1b5c0b47f78e96b6603e443c906fec6bd244302e8d8f54cd8d85852b083fd8708bccfc06deb4db4e96676dbc11976da9961a03ac1a35a0ef8740ff7e06f55ab55997d07f4eca490d2149ad2a54f52623a35536f84948356689fa95eb02331b8d0e3c615e4c2546f4276141fbfacb227b77ab7f2ce0f4c536611d055e0cb186d5f6f74aa21e32df6b2041bd0ec013877518815111bea2849e672ee213032491ba230b012933a80a2db8fa0e40ebbef3c5c535ecafaf42f8415b2470d20a87c80ec0c3a27cf7871f8e0884ed66376ce8158d7954ef969ece634fceeba50b321ae921caf29c2b77d99d41ef2f7905a88f886977831fe576317287218ff808ed0ffec487d2044fefac246cfd5757262c5fdcc55ade8099424e77d50215650d49cd7df5be6899324331f19ef774709f9d4333df52cc0f077218dd09ab6f5b07e0f2b7ab190669df1edd6e81e12818adc94709a19db637c7164ccb93f6ea100952b9b6ed8154fa958b6c70e686e2f820b38e1b20e950fe5d6c6a064e369cfe0d1029635b8e34701e0b3420da2efabdcf621289b61423c27a771d4cb7fe37610b6ea5ca3bafcb7cc3ece24cfed0c84fd56e02718d94a84d51406e659c96d79202ecc12095eb10fcf301c9dd53c45a53a4f958c7a4fc239b160da2444fb3ddf205ff56656b9d441609f61c237486fed7166ea4bd4a8f07b66e6e4e4833d3f69c03b7a1b5e6af0fd69197dc52f8b7b29bdea89de84af00361e9b6087fdcdcf90e037b3df7a04831809165a4545e4045dd549f5c3c6a0958479ae2ccfa612e55e101eae7e0a753a1b91b371e48c4a8771d5c3e1e03d3479701b70f361e59ccf7eb084413b7217bcba2cd3016905906e1f10144a75a7a38e57fb4a1cbcd1c219bf303e18cfff0683f88e7d19b2308ad16fc5e190a54c517dadedb4fd120b0ad446f058d3bbd259ad2ce6f5c81e52cdc35003a9652828118981cf9df1a7d63f53cd104fd978d058c189e5c57591feff1c8dca34963f6c80843352c2f96f7490baed204481396751311f615ed9abedbaca9afb1245f65fbef6b7e3c6e5cee536e00af0de48f8a7b40f4c85c45ab45c613cee0b6f22d33159269b8b1ac4c197b9645fb012011673cbb68c43a00ba024079e38d0b038ac5b7d2c937733be53c164c342e01274d42ddd027660907718db716c1310943f293073f6c51e57d2208711733f60d36a935ec53547486a557532404df49cef5a30342783fbf2e4fbc65c0ee74cb0ba076a39bbdc5749089ef57d9473e90f496d8c42cea520230ffe0a4af3369f902feb6f8b350fb2c4ee4ac02728ec4bc7bc67bef24a21f42c617061a7591c3ee0c3632d2af2a7064692702458edb1b7b11234ea41c94a3ffcc0bfd3246eacdb40cafbd61269aa658f1679be13fc0686d9149e12014e255f3630081a1e1bce2f50a062dfa398c3641b2c3e40be090b371c60397eaa7cf1a18b0229f51af98ce7c0c4cfd47ad9cbd021e3ba987b8cb45d042312433e7c409ff55967ec0648cf03305f1af063c652be652edb720f50fd94909c39b87a00dd36f51b318d0a82ade9e00354a5ca8d7abdd80d1fa48bc3a4b7c62fadbfb74426be090564fe29662dc8409f906d707f676a8040654e374d241138a0f451b39161bbb5970c9e1820d2db3045fbfcf1bf4ed4aab662bcba0fa282eaa6a7ba5f453fecec2438bf41555b7540e0972298064d318d2e626df3ea932ab4384cd3531e84e5f2c6d6228dd3b783b0c982c02c1d8d98c19e276a6291ffbeeeca4480d77cd0d41537316d91f7c68600e92017aeb5ca73b5037e05eaaffe1510eba0ba37f33f496b148e281573bee320e9a555953fdb840082864768c8497befdec2a2fd982fc2cae190dc0a6d54ba80a9e048e88a2d2f164e382f6a7fd951a4a7dd470b051dabd804ecd6f53f6657d0e5cf9061b6154ab77b6b061842248ebe5973861dc353f239db50cd23b1467bb0c55e9353e355eef9d7616f948396e513c3169442128225df50b19c9e57a79e509104962f80a2600fd5d5db50f975c37542e2ec5fa6e58e5fae5829221f5729906862f419efd2da41f0ea91f0b0cb1e8feaf695e3e548b9800b317b8f739d72a0b8b364032cead73ddecac5e9bf5edee4fe685c007af44483c050d00b986961601bebed141fb9e8bfe54cdb585e54c2d357a18e0fcaea39a8fe28d35e5c5107d003cbcb56e06cef5bef5a222b92c82ec0faac069bf201e616a3d420a7447215d06ce99f8d9bb9931ecc2fc9aa7472f3c021d28e075af757592311652557e90a60a6c75a7d7866583883150ab50424d9f087aab4f6d359d031b73226fdfab00080160611e14c5d88341f3060311400b74a6c98b649d0b4a2ea3c33058cdc7d94406ae1313e8906fdf0c8bcbade04c5b6c57acc8ff13e3500e5e50cad719fe91dd0c97cc83e237cb9473fc54fea4bdf73850b8bbf9e77e4a45b7297b955e59e84005d44e6a1fb0a7cf06ad84764744bbd7739696fc82a45187c82f01a5fd34bd0007a9f73c53ff732e2fb4c41dd812437e570b2c83ee69ff3dc309af6781b586070ba0581d24935ab1549dcfeb0709c4fa656024ecee2f41bb032b52120b52b9e70c8b54fe2e5761317c3103516818ec48b2282e1a639a554b396df5b22be205b70b326442c64299f7d2454b237c13abdbc5994741f00da1cb82190502c63a7f380ce163a39d70f3aacaedcc8f6f12be9aad0e6be0ebd086591c5e6bf5128a0f4c0661030867a883586093b441513dd80c889529293385b663062392c03ce4490b0efd320e9d78356808a395731d67c01eabdf8ab80a390ad0e783984583f3dc1a006d84e17c4a2c5191d681e703139a4d7efc8ff6ba2118577e1d01ba89fc7dae09122648a4e1b456dbdfee4d6fb39f685a7c261b3fe1f69b502b4b2f4b82cbfd01a7d2e882328da7e1783520d0aaddbe5e43e427e1ba2a6ffe9a72d32529483a04f5c8e82b8854e9f71cbc4b635d0e434af531d5a67205a21bb247fada1fd8d8029f1ff0281873e4208df1570f6a60d954219218b0ea5cee38d4f6265ac55cd1067b814942dda426c47eeca5abd5e9bacae9d9a178c431749c9a0290905ecf7005bcc689c8072e47e452741c870c972f4d09f5ba5cd53cfc41818430b541aede055262657f844bd6d58683af554f2a955e966a053b7d5da96af1f0a299acf85c044acc806728d9b84bae76ca05d5b4f109249853cec81877c0da6ce4b438724e0a84040ed0bf016ecb584a3f637af1fcdff2ee7ac55202a4992a020c3f0a067600504bd8ca7d061d9e6327f30da318c4cf93e7da3c412272d03efdd7a1737e0e0eead02d0f9825a96ebbd5b726dbcc6f8d72b1377f49582b6f888028cd9dceec09de7902871abad64b0d6f430bd9a1d4ade3553118e6eba07c0f9bdc4e842d170a64becb3137c4afc648dd5c9515772350283549a559453684c96411ef7c351707cb1bad2e1d6f9623ae19682b853af1220c6ce81104b33fdbfc367507e2c3520752879f9283279280534cb3fe8688fd72b5edbad960dd902807a1ad8760a98207b74224b33ecd2f875765f7f833d4500395bf7ea301e863a12a0203acedfd4000894d8a774835d0f51946a5c29389c949fce593faf3f359b075b3a16da9d02000fec68018f07548ccfabd6858342d5e9702300b2545fd84dd1381c8a069668d0967c08bf5b6f07d9623ce0521f82e1ed302825b8b40b63a973d8e48ba5d641107827dec6555cf3ff8b2c86e27724f5ef24abc0f4c421369f87d1a89823e195600bb9b2419771c3f41808eb954b0340d61ff96a53d9208bb509155317ea5c656059779d081158ba8696c5b3c3572f682aa90562b2a03a8c42963973d908f4fc30901748cf96eab917404d157af901ed138861c6d2e95293c654b9ba79d16877b0f3ec035bd11bb435c404f4de9e076feca0ef5160cbd3a308e974658b0a1145b08176b8df47eea99dd4ca210084efdf799cb2c7d8eee1acfefa441e846b79a6606560d5fd8958175528a729145cb8daaa03a625f4cf3a5255401ad58918a4ed50ed2871ceaae666b9a628199ba917ca2c60e6c742c9e93629a46660de440628a0a0193eb5a719fc96d463bbdeca7b590d686fd24f079bd9b18618a941cb7d7360692d00b8db80bd122e5465047aea3c6f2c60518fe1814df0e3c06d2ef6171dd0275391003e8472e6c0cdf0dbf1c2557aad267a2dcb61bba8a2dc39e2ad43b930ebb39b33fd24378101579246e86d07f0ae71d661009d1c50f7fedfbfac7d68306fad0647c8df90f0f5e0d41728b9171956e42f87079df606b43724b75d0c65d05247767443f967a5bc8fb6d30d6c0758800c8b21c55613e671a57f516f813160b6b57222a50bc12754830920b383eae3fb480af5ac89170a8de8603d0c5c5b404005fa9b45a50e2cdcb97151be25b135d940ebc1d1312c6433b10e989a5ae0a0c46b3c6f0e02b79b672d519db9c8f0adc5b9fc0d13383da5de8836a86b430ea0c088490b2389e8178636b13e6f9ae677e65979311a8516397e2f8630820725a0875f71ea49732448e4ba1b913d07875621da21ce0056871645b40d65eafd7900366c9acba8c48cd0e882b6e8188def18fc07bf54ea6338f6fb35371d098e4ce0e35ce5472f6b7e823e791d087acea083c380d71b2a93dd125bc21862d13a84c0f6aba47e14b526bd4e5434b2f03c801958b283218f0c3bb0b341c50839ba0880743fac647517af8eb6cd86979df2c0f2a25b103f2d9a7104c8e830129ee3b75091f170272e00ca05d521f739bbce52c22742bc4a48d330af6a0581cef97c32a0515d852c4483250bdf7e968f7185b9b0c03d55482fce2fe0971a52986ce0df50855e8b3a0adaa81386f0f0a30025e800fce1ac33ff728918d6e4ce96c59a5160af69d64166f75a400f5b2513b499b395a3bfcdec852b002161eab09ff2a48630dcc908c7abc150baa2d472461f7b9f6aaba1fb555e7f569918779bf766f52ce02849e70cf138b04b34dbeade21250774ab5951eac459614829b990a5c16e1c401f3a836ad31389a81abb82ea939ebbcd9716980fe9e2cd50d00c87de2b0d879030aed9073268b4ddab13e86ea44b2df57e2fda55a698233292874533c03ea830f1d532ea2fe770e9e41966136552f5fb20d65f31ef5d8ee5637b27f7198337a069c3563fe24e3db9f680a32c14f483698905dbe3c120fca35cdce84004ed55901ac6515035891309c1cfd74ed6ae57bb5fe38bacf3011bc863e7c3ce3120da80b7b8d1078e2d74b42f499e4a45635499061c757b7b60a71f778902f5b3b4bbb06cb47c7d8579e970b10e9b06133e90234db7f7ee0fd027d9f22fbede1f89d580527319d6d469d2d91567ceb3524e200af7b954b96fbfe7bd7ad29a73f4cef850e70fd6441c24151a70c8dd1b5a36d56dabb01f8e836941f012565d44866c7c20977dba3b69bec35abebf4ebfa8a796240b52f2c74adc72469a7e520efa35e7908ff5017ddb6dc4cfa8cb3b1d32d627b2a94251827ce814b58453f454091d9f70c6e87685da09dbdfd93d3ff2dac53ee92abfc1aee830601b51bae2fd746f3310be4aaf49f714075821ca9d25335825a6b9032052a46fff6f0de4c2b7c2a27ad01350842fe82c2c85b9cfc1a9df7853adc2f553df5524e7c92768369e17993f100326f51f0a3f7d629174546be99bcd69bf09d88a120267a7d9e24a33003c35a024c3c62c46571cadbf3efce1480a34c74d9a16346d3d7c268459e920591f83d00b1290bdef7496952497061880c4bae2d585e3c402547b704fb0d666fc3bf6204775ba5dbd45a8a9457ac750e17bf0527409e03f05904384336db4c8969892100c8f2f2f661887323b5d2344da251da891c3d93e192dc04c655e2cb6f3a28cf0eb385a8954acfb54641b67654efb0989b5f9dead0093cf288f29c19abe5a2040f7d5b78b561694a1d6793176e835ff68088f32ae35e92e64cccefb9ea69472500a1ef6315071d15291973f1b23f027bca1f6ed1fc35e1f76310c5160a22fc0401178cd7c910874c8e697f9523a8ac4eed38c92d11074c8e1177c3acb3573ada06d67dcf279d0b65f19df1b5186bf8fa807225f9038a78e54dd08977f55b01b30b17b2ac474d12d373ec2e32817bf60ac0c180ceb5a2804f33312f1b62614d580923d5cefe2ae48f109074dbe494d31987726b3c01c45fc0383a18c8df27e0fe09e4acf74885c9c64bccbc71622359bc26965155e7607a1dc1074fce1a5930700b039af0ac11831dd406be02ece05edd4ad2322c1f9a764382149d7d7a967f960feb612b5eaa31c12961f8605335cf2c33399873e74447cf99d923b124c4aea70a7c45e9287ef2d424c1c81f3927f1dc58dcc7375d63df7d82d964d885e7e76b0286ce8abc672bc50e3c2cba6799bff874a196b404abf4ff56bec57ee593fd60022f1358e8ce6e6358642276587bec683a398de664524a15caeeef9d1af1de540e077d036722a5f7b84a8422a36e26107fd500b8250b107b115240f367e624600cbb2a146f9a3c4f603c0fff04b099f192c11ff112c9fb1df41cb8d8773ac65a097d2d70c923589fdef67711a78c9b0b0a4bb43e3849538be334a76bf712566d0865ec07edf2b8db13195b00f65e7de85fd30bcb64bbbfe604ef93b091f349c30f007a164855c49af6988ab785f46d867d1fb2acd07726dc9973edef4084fda00ad08ac7e116427a8ba2992a6558f845b8de15723e097573ca0b13f3842196c2032aac4eab69d7ef675c764c681a0623a4dddf46cf78e6502063ff3c326d491806f21b0e5f1acbc4d8d93fd6546a3592440d70063cf1d1b35ce4d5a0d686092e05142055fbe77da418eb0a615d3baebeb0a1cb1e3e6b9fa6dbe9b68e6447985e0d95784c1841f699d70bcf0a2d0fc8e079ef78a8eb08918d05177db49f05467e086aa7539577f73c942340039e08bb0f5f3c9f641db9d9ddc5630b9624a31c5c09b0191cca79ac55377beed018e423a495cf127d3954436e6876ecf5d9636d0a016e50f3ca4f00084f258a2ccaf1613b18401f3ee793b685cfc56d0eee7c8f6209b4c35f3c177b8bbc66d4f9f32797b2f8c805fa1537e17b651e8dbc490015790cfa255b957cdac0ba44c04beb3fd66f006c2da29c21feb4c49868f0425788b808e4cfc7a75e0cd58be3c8e7a7122e82e830826125041fd90d5713bea4a6586008f8c382785a843b4ce2e4dd8b57c9772a14fa3150c4909fe39b6db4d53aaa500297cbd99941e2b47c1edd3604aaacf442c5929b57d124377d586315cbaf03410177215f942196a2c60d097ae568cf52820bd8ea593efc4be456cf2fbb12a5b20d995f384b5b3355e2b129a71fa848337f0c24d2dfac916e762745aedc0a28c50f65bc75d93517ecdf41d034c69f70cd4ebffc817384ad87d363cf2d0cc342f5023d189c8818c0e6111e874905d09dec7308f5148f8ee515e3824dc5e4b7ac5602429b0eb035a421a364c923584809ebb44e2e9abbbdeed78631d0bc100ee8ac0bdf78bfe00e22846ba32ffd8203f1ab413c0465977a6bbc0a253acddc94ff7b0fa66baed161bd505da05b8f0e1cbefa7f33649496156a593ba52f732e2f5fcc01f28775773a4df510ed5d47aadd0d0af6980ce4b4e4fb133531dff56fbf925001ce55476966aeaa38cc86507bd2129d1cc6bfce5fb2d94a54967447024a52330cf9a9aca148da70dc12c93c5a3a8cd33f1ec1600d6210e17ae33298c756f0900630ee24bc9cd48a051abe47c96899a918801dbc431417daa27d6e584ebbc5e303ea56106756da0ffde3364c7fafc0d29d18e157a309edc985e2d2df3d2df5fc07673168d2e8a226b67941ebcde302fa651936a079bb2f093e02465d730f73050d15ab226d5fb3c2c13e946d252e3deb53af71e3641676a1fe1390afa7af74db0f044f9d3241d6358afbac5424c5857b72686e9ffccd622a18b79a8393aaff8a02035e218c8d4dd0dbaf8ef9eda4e731acd0ddfb8e842039f157bd6d380cf1560fc6eb451d86956c6da0454caa660be04a617f9cd7e60611579ef911c75f0f6a085c4018341cc5c92d339de38e0160e72d50aaa6d117de6849eb1a51da8d09280774132a8acae1f0d20c711186bdab33241200a130bff8df684470877c7e44ca0021ea5e2a358514a0d5e8f81aed11d5402bde762e5cdfad8b6a0ea0dba634ac09fb456080f2b4a4bdd01a499aba44ee59b214880d6ca39deb8396dcf1a25c0001e92b4876acc94f753a1cd8f47ff6851a0b51425ff29c0128518c1c09a584c30779cb00afdd69becdfb7ece68f864202d5997c89128df9c71c6f3c2910c041a0000f038ce051131158c0471134509e47d49eb6856c0628cfd418e689f95bfdb0c3052ef98327006975ae26011507d96044011ac61723d391ee4f3032c869fa6084f0089ea0698296cf89e7105b37c823f521ee066429f6ec909beb1d39b8bc00c63741a30d7dd43b90c84a54f903519ee5c49e9dcc25a866af0f784c70f58520b75c294020e2cd9bb9a8d7baaf59caa82b09bf88abdcb547a171982adfd2c460c53e53af0acd1e2a49502422d9d30de6c7f5d0acfa27aa15bc09ecda18b3b0e07efdc88be70c16531370a65251f6b97925d95997dbad6a1ac5a5adf8924b7380d true +check_ring_signature 819c219002ca245696f7b889b2adba390fae33fa1eae9f250a9587ac9d74186e c204bec36bc59dbade5462b8ad2d4b0bcc6f44587e7a7712a58d41b61c9ddeca 8 85ba4c527acdfc06c8fb030a78c4b01bd489d672d5cf0a18c8a8e1aaaf7cd5cd f70c41a7a9abe4435a705f8ac312f3f38fbcc1d9a2558a030cf86634d929d31d 3ffb0a13791a3f35f59c8e253198e3d0c8d48d7386474642ae22569f6c5247cd ebf2b5b0fb9caf8fde5b33a507aa694020f323c44c0cd4f8767632c7cd732a26 e59cfe5b93eaf36115e0f48031335bc5b50dd25c0975494b37d73194fca08628 1d99334fcaccc6534dbee025771e6b6389709c9e9f2294a60c03f86a14b14739 4655723f038ea698a04c3091ffc1a0ea0f118f60a120f6a97839240ae3a8a8e6 2d023c4f1bb5d93204587e4db33713721399b5e52c1194954860073321a58ca1 671fc80ad176af1523795d383b82786b7542dd17b6d91f7e4c9deacb5b3fcb051e4d98d795b5ed998a44884bc8c82c35a1f4d95fb163cab5a85e58128d200e08ed660c177d2a9d0833a4138c63f2f85cc2f87f84ad6c25e0d141522e2603de0879545dfcdc24fb01e098ab65c2c65a86698d1731258e1d413f245f64ad9a860aaf88e52249f30e43024f6abb7245f93ad4b0d95d7b6b2e2f8f666ead71270f06f293d768caaa18f4f1e74e4201ceea885d3dc7ba6d9efba9baf8161dc74df2076ba4bee2e126c4a9da97881c7d2029e4e3ccaaef11150ff74c00c645184ab60313f9a213223f729eb28e0e412afbe2a4c49d6a16dcf4cbeb58f67aadb37d3608e47ba4f7ee8f35f8e84d3808717dca134c49b1267431a82e9bac6d207e58cc052c400bb5bbb0940d2e337f467a0fb4794f9ac0614efa30e23337c2e1a687ee081b3165f20151d2f1120b4b106c5cd278cac992670810554db6459164aa75ef07e863025abcfa1b56a56e57a28518d2d68564a4e66abd8604a8ee144902e6be0fe9abcc17946388d75bd5552d73d067832e19e9a29a642b97632d6eb31c0340059f9c844578c374012fb48b10a155be47a404c34f14f8b5319faa04055456e103a01ed601ae43c47cbdca97a7d468687585e5ebbc66c48a66af300d1dbeef7f06bfd1f93a66ab39fca37b8f79b423c596ba18192d2bcf727e9f0462789eafcb0b true +check_ring_signature 4e229c30b286ffb54469291a7b20f52e9fb21590ec8cbb7387001dd51cbba73f 5380cae1c961815bb53b400198bc293629c918c450054b96aecaf533f8fcaa4b 2 162004b1c38dad93af408fbd5ef129f779e7474df75c730d97c7fe661bb9e543 8dde899f536d209e95ffa5480f6579145a69f9eb45668c5118e04e0d2094c666 31eba92f5124a08724665adf922a4ff34e1b0929ce96b9be8454b5a09508b00acf49097ff87025e8740c75697fe1bd0e3c6bf5f32a38a9a69ffa132e1dc72a0b64ea9d894932528ab17f6d398eb90e5604f3c50c580ef0898b4714c92cb44702270567f68597384f877c59cbf054f97266a1f1dcd12c06efe7c36a4d41705a09 true +check_ring_signature cc947bc3e76e6f2c5dcb3ab258a20e2aa942b063a6c121d619e7c57029d3f284 9bfb5ce8f159e7157f31de8081908cd76a71de65e9be18e82968aca822b13983 8 f96279cec66f18d5a77f550bb2a2569846628ceee9ae3051a5cb0e1afff49ded 0bcd3d1abcd6e541a9561de548f84a21a0d772cce7172984291957162a8e46cf 4364c84058e3be62429dee9e0ceababf6f988ab367180a746ced6909fe6f8cca 4bb5270217bd073c4d203e0131310215ee7e1d3c58e0a00c2e713ca14d247dca c7f98f7919dbc1883cfdfa659b58cd27d9296bdbea395ca6dc622a2ddefed1d5 1951db8cd608ab7b21dadd4c1c821b9c7b1cdc29b53bfc6d9c60cf897ecaa4af 7ff700db5bef4d3db0220315c5feda36c5b8197ac8f4a600f85fd571b2ff2ea9 de55782c7a988820fcfeeb8c33301d333005930af155a2c8ef195cd7dc206396 f71e9c7eeee72f6b94f4ca958ac4f23da3383e66a3a1a517b5019a8f4b83e3076696f7ea576255ce1c618f6f3a2c7966a8c7a5a0e930e1c8ee9ae654a44acc08bcfef5d9c768e4072d6ff1401f16a2aada52a93ed45d90eff8623670f56151069c275b0e71eb840b92a201d5dd5c2071f3e1adaa70ff5732b32babbb45b09e01dc5e9cfe9873d275912b43c0ee1a0a056bfddf9b55b62b51d4a612e223d3a20ddd13ef7af080cf16b836589dc2e07a5b76b8347f05a2379face2b80ca1d5430e9ac49ca014e66284d96a1945c59c8494b5f66d51ad60448e6d4f029a7830910d34579074fc11971ed14807a6bb80a38067a0efe7265ec51ccc61e544781cbc0c577bb481e74b1e10f9fae17a2da57ac6583eca90ffba923639af5c96c34b7904cf4b89408b904531c6735f5fc1141c3ac765c596abe505c9ce59a3202e19da0f9b7baf119df257149c6030f07f165484ac3e986c4abdb238479da2525f453100a015af3e5e2a8233fb0cc652728e376eb5b5ae8cf598bd95573bc733917676001904624cce09fb0b87c466f0745cc0285315d27e59f5c75bbf8c050e65866f08691d941b7806138869acf615120bf3a4c21a8140417f14763b0b5f7298285c01cbba750d30ce6282ef46c657f2d3da0536ad94c3c3946c6f9487cc273394000fb822fd28d00e0ffebd1fc0c4e62554049caf345bfc69be3a49d66b6430fb5b05 true +check_ring_signature 5a3ff6e48a6908c67fb41441c19b1298be6ff37468addbafdd6508f7cc1244c7 3928e49977a5386da4d7121d82e9a688e407c76ef62817e13fd6f05a8310b04f 2 7ec7179a48d5272c7a4e4dd68490496fa2c52811191aaa14b8f9d50f19deba4f 7b087c5cc41be40521021d3b0b90880c88ecc247e3365ce78bc1655bb9d6d3ec 4814fd2285de739e8485ff2d944e5e7df217d21354ac5def430d254a5dac110095ec0adb52ea48ea2b62b92fea7251d940208919ec119b99a42bd6e3a086660d444d0ce97e8e250db1ff1a50a1f805d4c13969a1088a3768b83abec136168802484275d5dc6670cd16af15e5bc51b175da9fe39d833bd87100f2e51e13df2b08 true +check_ring_signature 715ced8a87685e1b2fdc7c50a40af34a3fb1035cc9467e5737b83242d4502ea9 c5ea2c9c8a79f116345582ffec5325f4dfda6ffdecf410ce4f32306dc7dabcb1 2 c47740912b02cee29e7aa341c845ac8fa275106947f299f4faad6ff9c7be0848 ad56e081cca82d7662c98edea0c6b4bd7b8e12df154d4c886acfa0cdb31febcf 1a0ab8b33c7af5673c17a72cc7f416f0a864f61d312d82a4e6f3c6ea26fe12ea8c37ef89037daf66b4161d0d6c32a8607672ab53d769603443f713061527cb0261cd58611841f1fcbc0bbe3fec87674aff7e4f4d9fd0781381ddca4f4605a8018fca9090f2c88dc24622c623eac03c061a59e112c4993291e967728fd3fdf129 false +check_ring_signature 3cecf1f08dc0d8b8591ad192342e529bd27cf8c21f0eb2efe5d80de1a5b504b2 5552dd8d7cabe37ad457cd9a84eb297dbea9242c9abe056f04fe03af7ffb687d 16 04bec568b2381a619465a4dde48c6ed28c7a2827dccd7828e83c3b3b8f43cd0d 0d14f4c15b9f8167cb26e4425dbaf53ace58e3d35c5a5a25fadd33d61bb38f6d f1095a2ecde36d7b76df2fcbf5775529ac1e7a82c7f97bc74b15f16fdbe76dc0 14f6c3acc8c942eecb46da652154f69c21dc63d3d20460752a1c09fc27759439 934779b23d986bceace180b9721bc377a620ca6dfb2dc5a1bda1033daa5611ad edebe0c79b246799fc7591728d133aa0a09e0e1a4bb8528c7e6983d58887147d e031003ebc24c2b4ea45afddbf7fd644d261682430b43160c8897b607d914d82 7f769b9c86626a9643e175371d0819b8c1af7d72c4bf1bc71225ee71b2105421 b4a8808eaee7e6b90ebeeb4cf73e1825d50eb2200d3abc5a83baf2237f29eb93 9db379eac92e598474523a0175fbb599881422c8ab5b2beb3f0ec69b3b08d7ef 9963dc5a72ed14812de9a766ad277113175e81510fb607c56720d643935e20a9 75cd2263ee415471891213886d2fb32118bc09ef446ffd3c3b530cb6b4f0f27a 5b73177962e8f4686eb45e04811f7e7fdb81227a9214bea029792adba3ad0673 c68188e40733a1b2609efdda2a3159816641939ceaca5ce3670105d3d1132dc1 2fa7dbb8d54abbe0a4eb0ca44ab297b85294ffc5ebf55cfa23d9e02c7c76fc22 ce9769142da15857cad50f8c61e6c62b14fb5c18999632a3e77e725066dbeade 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 false +check_ring_signature 8965d8ca191b163880bc22851538f073a8aa2cfb354c3e55040259b4c2aa78f9 d33069e9e90000f37fc96e59173ffc5008d3e8cf95e762ad942d4588143d7d22 5 4d8117403af68b086556140f6e0ad00ac5d2d02e68ffa08df951a72dc88e8bd6 ede525663181a232fcc7a8294a639f3c3183d15ecac6237365a0b976f6bdecf7 ff33251ceb6b905d315b6bdd4df4f42a37224d6793f4eff62bb95a9fe8abdeaa 6d4b37eedf1bbc8bfafab1ed3c337559c526b6bfad8ae48c71f7db800a5a4e38 0551ecbab23851b5fb2eda5b42e7a972e420fd0682b8eae90005a9344621e00e 73f19e76fc5c1595de47361bb299668b45bdc1c383925d9ec6149df91967d90bc478b4f38fdaf2cc343e3f25afc923bec2c71995c12f6a9dcdfa5c5884725c0004b3ed3939853e6abc1fb77820f28a70d9b6aa69c6f162470d888a6c9a1eba092f24c7e80d9f7dec1a4f7c3518dcd5835850378cd9fbf80bad367c277d05720b67e3a5112a6a168165d382b55c255f960bb4e38478eedb3139ee6469774e3601e79643bc342afc098bfd64b843ed5586c07cabf58afcd7dd7e23076ef605f903fa67ac78490ba13348eb7cf5141c130fb69d3935267c81af446546923746a802a1f36d5c65d5732b6bf20f386a188a5109cab1639a739f207c1a23976a3af30ee60c62e3c8846cc7cd7e838d67be99d20ec7a4d5444f3258482671f6fc350f01010f63d4bc5c2f2e3674d94c49101da4c8a57fd3796bd683ade5037bc28acf05 false +check_ring_signature 356af9cde998730294b3434b1a425e2f176f375330f47b5cb7966b648ed7aa84 1970753a2b762415441ea7d53e050c25e8e15331799956599231fd33869a12d4 1 fac3e7ef5230c529cdb34192302527b81b04f9cdde142e93b2bfaeffd31c28d9 14b28854f37b477b4b5689b46ba9c3a6be16779c942e8d5d6a930309008f1808be664d0015729618ba62d496ccd4a8bfde132206b30933441c96b9eaf3974202 true +check_ring_signature 5fd67f44c92c83366136145263c354d399d244ccb9855fef648076c0646c35c8 4b3b265abeda7463c9586e0da49ea5b9af515b6fbfc4b43c0f560699b4b59a55 2 bd0062c96db78cc866fcde06478b150161106ac8784650dea9f0fb6ad2d5da2e 8633894138cf036d9cf04b0e9cb60d22364b0f90889b2d67527887b521987ed2 77df47d437ad470e672361dde3bc10c8ab90b547c489c1f7661ca36b9b17cb0fb2af0f56d38d0a7ea09230a4da2903804420c7dc9a2f722ba9de5a6a9170f50d7217ac70ede13b2bb13ae17b70673c5b05c7d993e440832e8d8914fb53cf20088fe21c137e88296eb4877fbf35a3cc8db5770a89a06f548edfc70b1fe6564b06 false +check_ring_signature b86ed76adc27cbd0fbf43e96b0107e3e5357984dac7841698ea0c0f6eede6a71 db87c185f53be5a0e828f17184cbb61e3d226578e7bbc366263f8424ac34b8dd 3 2670c2e17feda9f65a00d35e31db714e711bd66f4aa2f6939167e3b993bd861f c1f6fd9030ae2bb4885db90cdcc6839965adecf01910d8cf633add691ddc86fe 9fa96bf39e45b80d8da156622fbe566e58d8fa81f4712ef413e1a0b482770997 60a38a6515f48d54a8b14607a09de882f6809b679cde977871153a7214f659020ec78ff9ddaed0e117453ad74606a441772dfcb06a836f0b65d7488bd80965071936b749d781727325cadcb54bdada31da2f018096fe2fb39c2841fbd740e500623e4d82b52a5c0cc7bc5886591412f6d7d501c4020d7f3e490e9d031849be0ae46b18feef43390ea66e3b861624fbd674cebc0bf41b49e08008b76f195e5c01566b70dc716b6c171a6085fd4041f5ffd720668842e80884ed2b8ef008df0101 true +check_ring_signature 881d36cf9357fc97f75014218a1dea74a40e6b716d5e1e1272c4371f329ec3a0 b1341ea2ff95b5a1225829ea285d4572bae50d819b27c9dbec7ee27c6fe34194 1 78eaf465fbdd8d23145fca7064cba55808e5a1e31825bdd9fbded0d97ceadec7 2848714af427270bb3d5882c1e84ad30134fdc1faedf450bb9c5acf9b7512b0efb68e12d32532594b99be920ee339169f403fb16c8caed0a3965bfcda27db805 false +check_ring_signature 24687d651c339a40ee6cbf682ad50c7e750aa6b334e409dc6093ec3f9e436b75 beed22f3dba1d35c17b237e61b6723162c54f7f2348b88b0e619018ae15659d8 12 41869c396ec90f7daf701aab6845050329f99f3b72db61ee81d64cb5d5fa4e01 b76ee966f70805c655734269b143c694a7e86177a7be54c2f9a9fcecf2c9877d 7427b6918c143518201d294c218d0b51fce875953fea58341f1cf9e906fef66f eb7c88dde507d9ab0c37a36a62bf64e3af6acb04748168872a07766b05efecc3 2d4b26cb62e87a576f5f45bed4850995f2b2aa1499f55c9bf943c97696642387 22731bafe312a4b0c159bbef59b5897c4462ae542d0b57da6c75e9296c9591f7 ba62243dd81b0bd7978fcc3feb7bce225c4882339a49cfe3f38cdbab21a51d32 31a7f2d672722ce755db9f133756ef7f80fa2bdaac9da5b56d78bdd81a830c28 ea33df483f91aa5dff075996ad7af5fb84998dd88709f2fb9f72b4dc669ec198 25aa7ad136723dd32110f80717890998350a7288d41a95210ee2abb47a9f75c0 b0f343eff77d295d6c4e4797c80b7f9f3733d7bed8cb7507601b3fda8d54f726 b4dea3ec49e4df3634aa882138da9543154ee68cc48054673525e5aae5c3dbfb 81ff7cf57a8484f0c67562786c6c4c3a228b6daaa95aeb0b9ad0e74241bbda05f4c2acf13955b0bfbb1f448e82dd1bfc02c1e03229ec2d60404b84dddb949302c238a214ca399647e4bc3ba3fc3ae00b984d58b99588a2754df27d8da693e90d7ddb9be791490cdc508f04352a91493633355cb05c9e461eaa35aa696c80c00a3285dfdc92ec89f1f6919eec932cb1997093b97b0dbb18d4f75c9440937b0a07ee026dc5e8af8e4a2f28dd3c02c8b162b274e3d13960af0aa009906d31fabc2e6839ba6e3e12c4f0e912f0147a886e46ca25f16f3e1e4361e27d9aeeea2b7302d872d6d83ef9d97e82af0d18cde1912663bc66306bf9cd42b7680b9534030d02566572036e7c64b901415c481a73ba781005ae80548c231541ad610673ee760716e98e12067f5d4cd92872d0360a3821e34e912f0db1d3b5e6f172840cb74101d4705cc8df34e032e2d317a7f02959a3763377a3553f1ce2b7077596ca2aa30def5a758f5ac6daec11f54177f1fa0c06f30f974e66e63db4171c71e79b190b0ce05f73146874b2f47f0b86537075b371e03fd1c6dadeb152f22d4bf869594809c1b1345459323c1b9b7c43a366fb35f3f68a120165f1e1fd212fab4fa125360343d941d528ee45f60c2dc176c4c621cd1729ee271b5138d0abb79e2ba7cfa00c1b98c1569148f5c540f6c466c7a0988c021fd37693d8b5bd85d15334318a6005d8bcdc82c75f658cac555d7885bb57b0f4d33374a4e073de252c2dfbf7a55902c99666324fdc02994b947e4f2cdbd384739b4a1be87539db098bca678b98f50fe128afa4cce168618c50b3a2059f4219cb906e0b8787e16048b27507982fbe030796eaf417964944a9b520419d7fcf5f3de403ad8ab94fba85e9a2c4773473052ca41125645cf45463849539344fb159441ecfbde01f87cc07a1854dd68e190f8ad65c47b8c35669b9202e411414c2407e531eb0e12019f31ae99c98f4f3db06ed7ecaad75b9eb735888598d85c8b34a221114961c2b32f5fe7339499018ae0af263e584af622352f341d4f6acedfbe84e61d7e563d9d35ba4d13fa0f2f93303 false +check_ring_signature 6ef8c2a48e0323c06c92fda2d699b9c39af66e7f2f52e086fada80b37af05dd5 a0134319696992020dd40c7ccda602ce8a183409ab8213ed2f454a857cdc1cc9 19 efc2183f160beb4f2f0dd24c562c172ff8275b792dc9e4dcfed65a6e8c4f8282 616582e4f0805eb0f42874452113d77a2abcc779a49a1d48cdb82e4b3aaf8bef 68fdd57c98fc1692758cd50f91b3355879d37249f02ad56fc510ec009e3554a1 75f8c3ff7e76d546590f7f6b46326ea64c4a482a213d59e750fb8b1bf8ed9bc7 60ceb0136501b3296c392773072f1495f997a36db92785d61ca258ad7a86658e d8fb9dd0262390caf961e4f5843ce97077021ee857faea12f9f747d7d0cd6a31 42c00ddac829281b16d6b3ba2d1b9f9714d5c45f11d938e661141300a354ae17 65bcb8cd20d7eda00dfc8e3e37e95975570b9da2edd71a28f2dbac237034695d 538ba06e38a41c02fd77194497329fcd557b6777bef5a88c502d5b50551c63a7 fdd14b49b70a3b6fdab8d279f11cf83931eb4b9cae0bf07a0d4167579408d004 6fb15fcaaaf94011e25a22aa60e411f47739b5b26bb72278743959afd847dddb 8f30f43fc2c70ade02d23d24d11f1bf2f1aeed6fad14b339b6bcba75d86c2e06 ec524b1d47cf21ae8b5deeb085f3c4a60495ce9ae7ea3a1f0600b041d0bc79fd 64ec33b3d530f9c4d3182fe8d29248d3efde6e02590a56761378d67f87318e58 2f7cdd9e0719a5ba7226fc90249e9107e60f582489bbecb3427bcbfd7fad1134 277c5bfd55aaf35f28531e9d3d61d93b19e37497674fbcb421a567da54dd0ed8 873b8126c77aa3ba56eb50a6f13b7d482a9eac14814719527acc5efb7b46c97e fbdeec0f3dc4648e17cb94072044c550455b7125b3c2937e00e58f865b60e534 0f8476a97bf2eac279772fcff554f480647f6538781951235ab935db6bf8be69 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 false +check_ring_signature 81bee911b16443ba029ca76e66dfe9160a0ead5581495fb52b6c1ef93569e6bb 2a9fe1e5cd6bdc8f46c10233467086d4f0bd56b30169702394f32ad394f0288b 122 1e0f3b58b5691c71bb57b151bb944d31c4a813f8c88d25ff7eea2a6aedf2e76a 8776ba6278f0cbb9fba4d252795219bf15317872f364766e8520499f4262a839 fc0e7d8276c9919d9abe530094f3d60d5935593b4e288208bbd390f9547fa30f 8b07d59020c4ff14d16546ffa1594ee492b52a8ec112303202ef27670b976d67 825bad4eee03450341da505d594fbd100576a62b07523552a0bd7541823e6726 cf3b1eb1d4afd2f538741df0f380a59842ec47c93f68e2243108f555d02ca520 01f7bac4e6c3ff73b1f3decefc6484ef21c763ee7e8c058275aea63ce2219892 f21009b5c57c739a73ed64b90649a1636ce07676ce91a69cd4534e59bb016296 38cec0dab3021da554205150de34605ca6d959d07280a94bfc8dd8fdbb537f03 f7b94124fcd95c4bbb5fcd4abc0517980b361b3e063cc7c5d9a93d50206c5f84 05867b28adab77dc7845568f5c47298c779c53b5528227d6c4e7db4680f38f96 32c6346f18c01bbbb5d8d6ad4761a8e02668f9ae3bc331e031087858c0732796 338d2b8223ea3d8c2aace14ec4839b0275911448bd7963b792d0e7acfbb135d2 dfd4f2251ca95d021750d1efeea64b5cfb13c7a7f0043c576af84e0d8353541d ee38bdf558248597a693aad9a1d8ebaecebf289fba782e84e47bcec99b0f0cf3 081248f67b1d5f6a26078c9be014c29019d2f80647dc36c009e27382d960ab9a c74f6d578eaa66ede4212641e3086b264773c00f916d908e58ef385262cd60fd e22e20f529810e0dff5f047ecde769d0212a9f82de177a35397dcb0794bd0eee cc0408922d137a61be55f413e92a731654b6cf766d8aa756991f9cd5c5da26d0 c0446f676580df7c2b4567ce8d54c432bec9ab53f6800bdff79d382a395673a4 34ae5b78208c203668e27d00f0011964aa40bc540411c324cba492dcda02cccd 96b81faeb6b994397259cbfd96b5736e55001f5c4014393304a057a13d7a618a 5998b7c022a0d2ba828c5b5ff7e9e223aca23521b1581fcb1e7dafbf70721ea0 eeb49e0c4bde98afdd65bb10c7c8789de21d953f485850dd8e48369f3e27f4df 25e477f581a603049dc19af2e81a5c9225abc131b4cc9c94830f6af6655d8c20 7ed3b5e96256a472d50448ebaa40671fcde34f63c73da8d969520129c5c81c9b da474bb7c0fde1e7ae0bcd05607ebe03f8a5a325745e3ae98ba2135b640f751d a12d58f2906c47a5757ff3b24a92a325b42bcbd27ecc7f4800fc58b556f6f857 1496d6f202b82341e7b6959d96bdb390ecc85c04c9ce9a5560b09bf6112b3b48 79f3474bc2fe7994ab4b4cc428d3ee1e0cfae9f85e068e0516abfd52e31bd7e0 5fa1a28d5bcf3d172d58600de20a9d799b907e47c30bbe35797583d836448232 6c7ea8340cb35d9d4c614f3801d518b0cadc4567c6415bb0b32f46fc567b3de3 d7482b8f57969e565771be0795806831c96fd1a0e6e0992c01e8ba2f7a97ebc2 bede671309469a6aea3aab599d063ad6b8632a69f0a5844b87b4be2aa905d0cf b7e88b4089354a337ecd3a32d47668b5a3bbc334eec139e81e69e39d792fbf5b bf5cd681c5bdc0c0d5aa37dadb58d4f3ba75d6acdac732716042e66cbbb46c52 cfb41bba823737a1c6b2f6d22d99ffbde00f3d4d79bf972ccf919e3068694f31 efe331fcdfd9250f7b90b7e60b0d78adfbfb08a81ed202308c1837d97601ca38 e2c8e6704b2cead482215f13fb4dce9661efb3ce7759da0ed59122cd8c5effab fd6adc288f4582db92cd3647aed431a0f057c30fcecc5e7a91129fc28585f237 2a67beb3b35acc0670b6832a7609401d4577b313596878e514754885ed875117 48b9d291a398e7759f7e7ee9ab59d3ee01f43215f8ea29178c96a6ea12261ee1 cde14d7bfbac05b4454a85f57b577952cc060495a6e394507cc1aa122cd52be0 4d8f30a8b2f9d17174511890a333ec2f03f09e4ed6077e4cb854a9913490748d efb176907b2bf5557e023afa85f5c584912daf55dff3fbea35e4bdbef75f2c19 134866e7ff62b347e1a5f3a20680d0573de91db71707d947b0457f9e2fbed5a0 db4beb574acad330f43ce43073c81e9580fa04ff20d512adbf4162bafa54916e 673d74dc1ec22e69867aef3075081a6bdf07a606e0a3ce13e233b16dc9d430e9 ade1a84e5ce21227d59b63a5d252f6b0ccdc9add00bc83b6c05721f9db2c8826 5759f78e9bf1ac2b6a8a66d154c7bb732f438b57848bc387c19f1810d505e17e 411c898ccab42675d5cc5d2dda6c83fc0121ae8a2a672be4519b079468087911 bf8ae11d8c4bcef00c0ff8f75fd1232fef2cd6daa68736eb4ea32bc71f64a1de 91b6a46122190ac2adf28982cd235012c2ac66d4827ef303f9c94fe814e3fef0 bb7f32d7f0559f7004c959555dbb7ce89e3defb3ebeb328ff77ad89969146261 09f898451987bfdb6f1cf6ba70c5e634443e7a1fd9f972b874f97c943eff3de6 98ad7344a734085e41772a6ac1ae665048c45453e53524522ce22cf81df78010 7820282649e7f2248dc97a83a629e788db1d620f6ba614a23b8dc2f02eea5cae ad3b571caf65704cb31bec6fdbd3106789c9c3e40e0a30c293fd05f7571bc8a3 3d41dc1f69029c99fc47abb23228495bcb1fcd60ae63d59379cc02298beb3d13 c72e6bf9e36064cfc5bb16cc707effc77b6b228691bcf1875e69b5df0bf61319 c0b49a45ac0772972cd5872625dad0ea2cdffea52dae86078843b90f4568979a 72541e77d109d12631cb06848146d3b812ac0ae7333a8691303b052eab4f699c 5eac036fa37910e0f3995d34f150559d96336a988bf67b3b03fe67b3edee74f3 1f4e43ccd4fd9f7434d4dc24bb18bd5414ee7698656aee324057e6336da0ef36 42b611dacf95990f4dde2b40dec64209ce9dc2f9990f1a5918c9e943fe58c238 c4b32807009c668062bf41eefe966ab2f7167d885fd85b4b1860302ab80b0541 ccd7c11ed3b3ca13a0bcc1d41de7289bfabedd31de7cbcc41f310289e6aeb4fe 8718770881cd44fff95d3070ae4aa38d88afc7a09c9db529120533a5fe4a2c96 baff538775723b816ce5ee332530b6c38ac70743c091952a9c601c5c93e78760 6d7ca0236ea3c5b6aca07c0669b99a611efcc4c3ca2bac5655cfed43b3013977 5e61ce8a6a6210f5fa113b20053aeba16667778f9a3c2e8d95c72db517f840d7 5fea51f0a29a2f635a9423ea1b414de5a3a6c28329c9b2191b15ad504a4fa72c 006b53ec7628d26ed34eb2a08a2161468120d05d5c2045ffb6e29a014c023618 f711374c94fde02b25b3fc448f93585204a234e78a5d65353f2a96a837ee6ec2 651dc885c6143d4aa9388ee09987519ca6d7214913de21f745ff2cd01738026b 8b226ac90dcfa5eaf94966d2d0717ea5d56491d62616a8bc302f984e7f9f3ea7 2dd50126bccd46372c5f8af58ef9c8b78692ae82f29dca7deb873fe708e6459a 9ae9ce216c55906ee877a379ceed5c1d6f743823323585bf7126696914036c0f 5141228b3bd3eeb6c0795f67de6116eb42923c541cce614d3ba2b8c4f7542164 e30793c025d20d15590c42946e9153353cd2ae70db294d625c3bc86611801041 35a6472e423d24648c7f68a9e10e90cb09e197394ac959d1c27d2bc5fa70d783 73def0f5567da24c7c9b72d8463856805df410046070f0d5114e14053b9aa087 6333062c1a22891bdede7a8311cb4df8e90120ae1878037e313fe51a65acea67 d4fab3e841151c85cc5ab6a875d6b8ceaa0776db9eff013757bdf82563c31c05 ba8596a42582875a0c1041519d7fe6195ce2c7109faaf4432a819f6690f1d85b cafc72e280bc15c236a4159545ee291e550a37a5858c0c692deb1e3c42895ee8 437facc8128d3958a9dc4de8090dd15fc9e4fc552c072b1c5f6e8aaf813fafb5 eb6d09442be0ab71c785dcefe9ee91fc2540c1c394012712e342ad3dfccfd458 60aa7ec5c9e9387a10a3298570a8e9440891501c5058b4c12085f47c068423ed b42158e20c90409818ff5dfbc09917a1438f96eaa9e2229f8ce03d41dbbbf164 8c8f3ed6ca64bdbb31b40717b731c730c61484b274f008f831dbc1e4b4fe2082 11cf32d0597f43ac5f2f0ef5d271e8f29a306a352e3a79f3134f74f2849b0a70 291a4be167e820cbb6b84f71d462fdb3421d8757e7ee8fef329e6461a20a5b86 c27b46d9e4489bd6e3c1a077bca4723a81af3939fbdd7f4f38612a423482a8b8 42f60fad14abfde9e8fb30d210ad76665df2da6ec56921cba422ed65929e30ac 5ad1c475808b79b60663f12565d16440f18e51232e960990e74cf92582e740ef b88d767b78c0a7f7006aa5ee252526f3af162bbe180b10785f65e144ec83f547 6fd64a74fe676831d72e4aed32227a81da938a01f96ba7468ef900de836ce1f7 26d4411b6129725c68cba986b5c2d274344dd9c757332aee8357726fd692f954 a1657140d3429b1c9444d4bd3976d0a82ce1410a25be88f4430eac75f5e1a176 206f7f2a963896ab9371b7fdc79f417280e5eb1d995968a76de3f347a486e14a c9bd2c17b63dddd2b006489f966c1ede0129b4ae55b150c8c92fddde4d96b9ac 8125ef9615d8bce1c76bdd5a188c2bf2423694e0b39bdb550cc5d788a42702a6 9617a8c8ab725186ec64d7371b55cef1233884fa8143be6eca37037fb6284547 d926e6562d45fdf93c5adcfb5136c2bd005dd42a271bf3ff4239ccb025671ef6 e8c353e8672ad537d91025b58d6ca2fb5dc90fc1f5853c42f9eaea42fc1e470c aab7b6b22911797b73c47d2d9de46d484893e22758b173a4d297a53f2026ec7d 48ea4de2bb4aba580715b355bc1f2f1e36861442a1d0db0c84f1aea7c316e44d e2fce36b7cfdd9740ad68ffbb12958087d1f4e6a8ccc7bdecd094b5a9b818130 e58a8e5efa14e971718e3b44c16f492a7e1044c504a00012cf8b49d711039a9d cf08e62fa69729d511d7b7e5a593e0125931120f03ce26a739db4f5922e77f55 9aed90314a1fb7f321b60b9bf7bd5a201f55022e76407694f6472949062afb96 b9ad468d98e1fdbe182d462369b5b259c67157590d1891f802c172c4e47dadb6 3388d62c0a0840b5caa7abd97dabc0eec457e6b4829a326974edea59242553b9 e910c0aef9070b7356a802f0f9ac3d135e9efa23831d8a7995aaade126462ae2 6fed3f83d3d4b92bd9a72af6ebf812ff15cbdb1cf7bec252b1361763828a7f4d cf76940c68a0a4a4b67b663ec7249ce2d4b2ec892a6b06f006b9075ede677f04 85114ed03a6ed577757fdfa793888bfcf586270319ad81618943fe8c0ae9d87c 71cefab25600aed553092337a549dce4fc3102483046c0d5980780844ab3a8cf 8179a38193f4c00e3453a0d864124c7ac03e2f9a156c715d7a653c5e2e9ebcd0 f466ca00dbd13872b5dbb59dccce27ad1e0bd212b3ca5ca9e93fa3c38aedfe1c 1cc5cf323e5d853be14cddb1f7c6eb5afe23c55a4e82451005c649080efb2bb0 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 false +check_ring_signature c76f58868151463aa5a449f96156b9dcd716ba0508b3aa72bb4cc41980b5ca1d 678716decb7c2b7b73407b2f2e5aa8b4c1f0f3b0fe0a63b3f07cc329bbfb7cc5 14 fdf415a5bc0ebb0e414dc477ed260e01974470333fbe9c55d2fda690c7df025f 5f6af3f46030f62b267a096a50d9cfb6346d366b7a2366c4ec7135b557cf9f74 d8412ce3cdaaf4921fbd65443285e1d358b734484a153e63205b623e76a17023 67808a9ceefa45004a4d6a11c2bafc000c385fe72b79b5cd4004b572bac60426 707c95fbffd669769634c2ea43fc7845ed588aa81054d5f17a261cb3d55c70ea f6651d6dd3f7986606d205001b3e518893c4ca1048a363c86aac29ed03d53fbd f9f8ce21a99806109ecf5c75928652614bc1cbd22a6cadff66d7b47083cd891c 4d688ab29577262bb289dccb2a46241abb32676a86e0bdca21270685e6e8cab9 997ff1e49566641fa9a00b0bd3c58c9ec8e2c8ecdde590d1cec1454a1dbd90a2 5852fb498465728bec1f9a7fcc6e59bd217349ef0cb817b481fefe192154f388 e67549ad5e86cfc3d22bdda49059d75dba7989ab0f6ae418ee2a770c7e8bcf78 af91cf60ca045ab092383da07a1d7e432b8694141cee4a72127d6d7f592c02c7 89cae3da0866620f98ec6ab77c3d78d6c7708a1235de6dec6a0e178acacda30b 625effd1ed3041bddba20cdd0324bbc812f184ccd30aac76cb105b351849ff15 5cabd9d8aea48efbc18e85c1b8d6bdc340c221ccb0d5a7f1f5d76e60d015790b31ffa58b9343bfc9168ff0e47a7dc5e996620f6ea1efe825165bb420a3a5ef03f83e1b234849c2497115773d1cdc2980c09b55cc4a6623f58f6c4bb1fba13104a15b9de4ac07c0d3160612d16273689e527c19b527a146244b4f484c9ed0670a620a39b8dd146e114a71980d51f94e07fc7c8cb7acaa0160e59614cf91bcd10371f7033a8aa5b10fa0f7d9eba61b15797b1bb74fc173eaedcb2669221921d600ee61926e827e83e5ca468e12368dfb245feab343c32831773047e5d468d11a7ddcdd672460559dee13cce6c5b7c2718eb0f401e8e56437006025751e30c13005abb67d944cee09243f721deff38aa8c36ddf23c0bb604053d56b0d30cbfce966cbce50821e3f18905a3624fe98b085a1c9bccd41d27aba4d17ccbe94e85e2006abd3475c4a305ab54372140f9ed293d18aaf8c0b360885e4b678997f9a95df0892aadff3918fcc2354eea11eb9a029ddb5d3eb9f2349ed6d76b18db8cb8e6600f50951ff6ee5a6b2448310b9839abc7d0849b9972788dea11fc6dfb07fd03901063d9e73120d0a4a30798375925e022df1f4a3274b9e0ae2e208f1333760d702cdc693dd60fc58339d50740865a240f47c707aef88cc96f0077dc67d3ce17f09417141c0f23892a9ebdbc85b7705519ab1caf3c24fab32e4416258acae68aa05543e33877a128ca051df853b89684e8647dff8975e031ecb8dfd67bd0e8afe0df0ec33734113c6ccb93ebe4a9dcdefd9f5846fdbcabf300d677e05720ab66e0881914e8c7f3dc759c79163b9edaf5bcc10e410e9d765b439a13d476c2c1ed30da11674165f7f430f099fdadfdd14a1dbcfac71f4c8ebfc17b17301d3aac0c9c946b347a6054c90deee0eeadb3b0c2ad73223f42939079361e8a04738583a1a0a1caeb3a16881a97f9b8fa6bdb0b7a05466c5ef46c5571694fff283bc013ad30533d646b9a6461f9b10ba8dcbdd876cd0b19c60d720ccc98d968b87cc5be23906e9b0732914182c72a5642da580e44510f3e8701926df1d2880fd33eb1cbb4200ea28eac4e1d12bde001f427847b66584b4e26f36293c975852041a3f72148f09e984b444a864534e7a3b1e64aed23812ab9e99fe713ca0bdc991f1239ca43c009a1d374a09a85be1c8d450d543baa386cae1ae8dc1cc27066f91b60257a9fd0658dd5946e4bdf0378c1d635c04e0df6201427f37a6826f9a537914d649d76f05 false +check_ring_signature a7f6d4327d5af8ff384ddcba8ef5377d560da56b4867332e162fad603ab3139c f10e8cd87bcb36b11b0375cece2d98cba99954937344b15a7aa7fac8368f6343 1 3ad68a7cb8b9d54c3f0ea39ae3885b8c1d37d796e3752e1162dba75ee620d2bd d8f156a6426d8d8c76f2f77213985e9a5ffdaefcf05943476a87e4f700365d7491fe403e2d037e0c8f3d8577cf61632856c4b701265e2b487c93ed2a1d7549ec false +check_ring_signature e6edbc35fa418613e388d15abc060f329d4a7a3e335d209c9888183768de080c ea26e5a5a3fce9949ef8a74cd359393fb2e629e2bc2bfb68dc39039fb9659065 2 31419a7488087ed6f0b41ef1e83c8ba10179ec6a97a364073e3e918d90d5fe0f bdf3510b1d325f8933de97b826936d48cfb4956f379a27a5429e8eeec47b9380 cf692ed7d62c36201a1fa35895c2d3c0d9424ce48d0ae08cd76f00431b418b02cfc72b29fa52eb7b334a96526768336c994757b16c0393df1217a856b6cd8a06c7491e9033aae9bd8955e56fe555d4d8e2075995f6b1ac344aff54ad77b5ff0aedbd6cdf5b36ba280d5564a3225bdef4b1678bf5a8324c39bf6288357cd7640e true +check_ring_signature 0f495a463d6f469c474fdefe2b95115e27c3b790a5ce028c0a39c66e2a94aff6 cdcad1e59a20d06b8cf15ed945cbebadc4787e828306b8f277524fa6a9658285 89 81a666870382ed98c507379c8ff944245945b9912d329be825271de30a942122 d9da03b797df6bbe60f1c445bdad970de9ec8c182859003221fc3026dc4626b3 6ea748dc60f72917bc4078b1e0c8e2f59daeb59d04629f7e8b8bb8109d27142a d53a4e842b0c6a87e311ebdf236a0cc3a412375588f653fede3190e8d447ff07 3273cfe37ee595b53393ba540d5bba545f282b5fbf9a5b17cc38d11114762bf0 a7e8ec868914949e1655b55596ec38ca747b5782d2597d8d25fb779fbc2e9240 d70c4350f0519efd276d86e3171f785ad233cc0cbf942fd40a55b9e228ee23b9 d2ee69f1eaad865ffbababa3631e46f95182419cd3721d65cdd5535ab2aeb7ee ea633c86559d4ea95441a23c61e5f4ff9e600b974d64d2680349cc338b11f7f5 3521abc8ca7a46ae03c50e6abc2cf5e315f919f0927803687594a14bdffc7472 d911d298168e47c228b116b32f23e1c31580303c058b68d1ae40536864e35672 4b0af04b7ef4c79811f90545c47a1f2b56ffc29a8ba07cffd5a8def85c0d69bb 8b8c184d088295d654bd630fe7d70a8216ba75aea8499b5e8224b0439022a53f 1b26768e3688dbaf7d0c1935e6728674fec9d8f8f3d513a8ffe74a0f8c82913f 8ab9618ae0d5fbfd8f182ccbd987875a1eb2087737cd62099002c5075f8616ce c42825fadf2f4f68a6b30d710afcf1bbccb97ee0080975f97296d30c455e40b6 c90459240eed2212d0b95d48a2388ef7edf18226540cef2765dcb57179ec97c5 30d93c25b2be9def7501873b4c7b0a82897f2fa30cea2bc8a83b0984565719c2 487609b871f03c3d3371424f46a244df445aaa5f5c4611eb4b3c58cfe13a1329 5e5406152f1fc9c51217d9ce22c5eaf6d79136bda253761f94a8854a97fa0510 5c05c2de8a04190d26b8d6af5004e9d742140dfce4b1669575f735563c7b3f25 bdbd5c462b5bcd917bfb32437a3aa9a3e2db3023cf6a0443146406b946f30e8f 725fc06104d8b186c7cbf0e8ef3d6deacabe4f904d7d01270b410b46572baad5 a513772bdfde75020b2d9df4beb32e35d7b3c9b16537cdab41c972c4e08adb6d beccdf4666425541ffabafe4f70104d91c14f48458c5c5659881a609e182ad4d d7b1304a39761c0677a079c4c9a8ffa0b06e8723af8ae12f7b13542eeb1c22b5 894a59bd7216688037a5abc15a37982464700e28e2ee1e461872db8d0709b276 86045367e41915299cebcde611a139f03fe06f472130fbc7cc6287f5b9846031 4cf2696f7d4a34146bc900fdb67773fbbd5499d83c80b106d2956d37f581a964 621a0a7ee8001cbd4936f011391538c5e690e32b7f15405d6a587a3f42efea99 e33c094544cb547e955dbcdd6e58dfec84add9f0c738651e908d0c4a86ddcb3e 456a2515e6da2db74bfb3e98a5c2fbebc5cd50f54fee0a9e64c2844cdee0bd83 e592a5d4236becd9abcae749115cad8358ef4e2e6b8a38937e8788a2cbcb38f5 57472fc6d0a11676670aa21b7365067184edc327d184c5e157f335c0b8e5b364 a628824941d8b2d9f8167133392108158d8ace410808921a6883ad437f59c863 70b4ed00cb6b951ae7f194df2f890eb45df7e4846f4a7d91b7a9f217f168f618 f54c5bf590eda90cb9da17f93893201f91f0c1bc9a7cc35a38ee5f6673e592d9 985079b0be1f385aacfc7d1555f428a46220baafeff45898ff03184cf82a14a9 e164cc9fbbb12c582d08f7938e2cce9125d0399aac64719b24b1e247d6bfd366 9c45f45d44b4e4aa1304fc0981be596a7d3361e96f2bc1be8bbcfc9c29e15608 e2640750064abc9ccd26bc99ee97f31a503d92c4b5ef6f179c711824cb57fe6e e8b4570f297832a270a039db79e47ecac8f41d94838e6e0d4192a36fb905574c c6d218ab5f5dd3a6189f0c56522addf9ecd068a001894632a2a09be5db5f5c2f 90b23fd6ee008af76f19e628a57bc83ef81991704395c6e87f392f9e8f658e2b 7f9236bc4f1c8cd7b08be9c44dbb8191eef5c3d39f032fef67d709dd6f97755b 33c925f4815eb03ef59f864bdb490cd05d4adbff15b1e549a44b1da2c1b5247e fdec36611cd56decb9f57c61d5a3c10e3f1d139fbc1677a1a165f75318a6205e 60bc16f6cce66ebbf7e2d3ef149729b5da82e8e884855ececf17f93927f648f9 2ca898a7c0f3150a29da7afb9a61644ec8f0afb37aa60f5fe3ad8593d7a5fd39 da6b4e9ea0f21ffc0863f41cabffa5a19b9da44c79c6fe80b25a6dd5c1c2e759 6ce288cc395d596af646f4f3587e87785b67d2b183d14fc811b439250d962c5e 637a4a86a78d532ec54e5b9ba743502dcde0fb6305d7b0eed102489823e827b6 cb0ed34c8e5be020c9686b452845ade599ecf9f3dca5d05c9edc60af9ff3c4b3 4c28b857c3c154cf0fd3001ab5b6a13a5758eb86cc185155e4f5dfdf70f3ac54 5a5dc8b5665b99aca8b14b8ba9885cd02c8b713b646c070aa0fd31deb1075e6f ac8ba4a4b86245d96fdc56e63a218e3b9e2db98f1a232bb0c3fe3c0f1d3da0ca dc4c26bf2bd0f1a53cb49f4b7c33691266de18360097644fa67f63bd6332cec3 77ccb0d939372469f243db664d57aa10f9757fe37456fd43228d3557f4bb6152 0e7a7718ce73a26f9f1c700d944f2dc9427208586ab2e0416ae7b610ea8e002f 63ddee085512706c955d887b5497ba7cd92481a4be313c150a7d4a25d75af4fd 7d604db0f76d56ca6dc0ab6d6e60003d5fca0c45b9d6c76ad5cc7842ee65e421 e1db8c262c535de6b9ee9f60b2f7f4160bcc1240f1d3293d3aaf35ffc57c6ec8 52f06e108f90a7bfeb155986a23009dd0fbeaa63b62bdf30658d5d55f6b416bb c8d054f9f82ddc4e22f19d03bcdf64543fcb7b96f39962ce7eb54062d868b63e 6a1ee1d0def6a21c748bca89911e8423114e36c799b5d2522c0affe120edf50e 779b9a2244e78ecf8f045c9552c4e304d47c666b3f8513461d3ffc44367ef697 4b7e20cf571938f74a406cfd32b82df9115ead40770806e2ace5d3d19d8a4563 45de1e277e895f6945395b5fbfbb9b2a84d95425345f09576e0f0d6e3dac0995 94e26c6c5ff2945f5713282327f35a8b9d14cb033e3a1ba6ab8f56c26e840541 a8bbef556fc1571ec0c12d1b4aec618227c662a2b3f84cd0c22276fd1e4cc477 9c250a206b8648ab2021e366ee73672f5df9e1e95192a7990d2c5ed157173996 5b60d3be981a0775035a45a8d6019a5b5d01a32dd4745a78e89d753e59510c3a 86c23beffabc990eef524c1b6af4769e1fb4423939acdeb8964b8dea63418726 dc9e68e53fc32fe90d1e0f3f5f5f2bdd5d45b206dc686ae93fff91d3b8e414e6 bb9b0f31834d15cf54345b31ebf6d3d35a695ae7cede1d4a75aca85854773165 c340e97c02e25727ec8b4374639578d3865fd7204d4f5e0f7d76039d249ee04f 0ab4f00d2b3b95d8259e2f30639974617a438639df3c66b2387fa00ec4955fc0 f4b03292da8982f6e6b27b405c6f72dd90142f9e9822845cf0b78451e37caccd 680357aed47751b3093ea248bc0ab7d1b3f3deefcbf8e1b1b5ce0b9881438141 7f9644876fde5a7c23202cc376192838d8871ea76cbcb806b53bca550a356cef 7df003df63c175e4cf243f1942c9d5c824e1e439875576d829277da95091af75 31a90aa8f513cbd8b499f47a5ee3951ea36e9afcef15e4a81a37a7e3e8d6916b da8b920daad8a0053725ba88cb8667af526151bef9f53d8f912ad111054c0420 6557db33184694d434da2a0d3260935d62301cf173e1198a6d738159978f6975 d4cedb61ab16cc73f7a39b9fe8696519d319f2512cbc7c5cb7f924a971e4fac9 5107275f2a744cf4e41ca49461a4d68f4d2035ffe76422afc1bec616f3a1e8f4 53d4b7cffde82e6ed474060ed062e7448dd506cb2146197444ffa4f7934396af 25fc5bee93bd111303e55fc8bf299a07b047598ddb9950296aff74653335e439 9d9221e92569a8545fb1d066ae7fb7ee9c4793e9bcff24e297097e7363698012 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 false +check_ring_signature 2f14480e7bdb48032ebeac60712fc2c26e9d3e3bd77f2d476d8c9407b6ebfb7b 553249a110fa4984df208e0fa2e0649e69e5a648c664dfa673b1095bcf980f29 3 eee26076011bfa3acabdd91b58e506a9abb40afe1123777d2cf12f958ccc99a9 74539bc072a556352fc62dfef0d2e3ea296b9821c664e825d8759d62ac410875 4c870c713498afbd362bf421f0351d8eae34f5b5bd4cdeaa2a3b37174145abe5 4aeb8c86e9a7c21f59a2a57dc6fa2ba9f43c0060834d365dd0d22d701d05fb0ffff76f02bc6027d716a48df432556c2e6c8536a9dea9e0c66766768f4de6b10b1574369f4253bdfdb66e641b50b8c8a33ad4ff011413447ee472847f91f3c90bab25272e62d566d962eddb4e9b8b084ae056528a7d043079a21fdf4b751ee000a3b492ee403f0a2492b801f6e7df72a61861a4dbf1814140231eb501d9a4fd16d7477deca74496a0a969d586ebe001194893960248bcdd315ab1059ed12fe672 false +check_ring_signature 93d33dd2482fdabab6d5315d5953e07d0c01841d1812f13243b8ed918635a0e3 8216808cc3a244d08a01376e94ce7add49f3ef600a35278aca7e02b83be4b0de 14 49acb4e2337a6f1e300ea6519be7e7c179b1bfd4938842cd98e173405c914abc 8548dab451706ae746cca54728416cc003e68648df988beaac486f98d400f802 5202bd557c4b4a17bca46fbf579dc3f2c8297b77df580e0f20209ec6bd512537 08c2822621ece09d9a6907dfc8d45afacc3c22d756514812600cce3acb7b1dc6 74d846217bbe36a299d6f4de035eaa519275b06b1b7ad2d733664888e337545f 3fc2212e352eda7bf681d3ebd24b75f3910c011d5b4ff90a136abfc67646ed5a 7e7ee2f8f5e61e71316c294bd070b26378c192fa3664475c5d6914ed03a00046 0ca2b2752201ef5b896a0c3c70b2043653f520417758089bdda2291df1f9d8f0 01f85e74d6b28df58f5072cd702adf5b075f3e2d3cdcd4452550331f0dce1749 be6e10e477ec150a46851cece50637397a5b303d1de94c369843ee52759f28dc f1bd7c36545b7f4ec4ed2f7b75244ebd67f48160b8d74d0fc56302900999c76c d4ab0bba1a7af1439886fe53a0185640947de3e579ea569dd2aa316d5dd859fc b1c4a1aa9b7241d01c38f167949cfccf9514a6ec33162c083cdf1fa8bcccb3ae 8f8fd81a2b2f1937bffc7a8f294f11d34878ecc1fcf69d5fbefcf4be6aaa8ad9 e7461d84c1e8483152f65e88d636134199f2efcb16549c1204333d333ecdfa0288d94ae95acd4429d50f3d8a10f9a711667527363b8c5644614d8ae3e7928104fe6f48f40bbd417aeed42883f3ad6cb847fb4e67878b92308678e2eda99d8a0407bbb871e0b64d2700db394b6966b7b4586e80e3e83bac50d647dc16746eab0ef5d4bdf433e56bf11fc459721119bcdd73ca36b3a8b8be25e7df49942de2e507816e44569f190fc30ad3023840644c04ef766736aab6a4312af136d5231bfb077c5a8c6e6d1246457e6b24758ef9aeb60d499288efe5be075fb3f99f3083180e881e236d3c4a78b6d3364b687606410242c01add3d62457834f7da971b2dcf044b5b041a562805d68cd2cbfa91b95ea49e4f479f736e5b94db2d4aabcd77210b58d25b29ea8143d225d6415dbf824036d147806a4128e11e219207b093f8ef07e87c2761d57b5d3236b6588db475859f8b9b37f70efe6e33382b70fc5eb83b019dba0faa8aa5d8878b28ed7567897ac3f3edca0159b75537aad1f8e02bea6f02db6bc047999684dd51a67dafd3a61f6d2bf84458cdff295a45b22e79ce737e0bb1615d277c30b549b4810918fc8cd94716ebd8238944bbb3d348d2168def2b04f282c6d7bc0134b9fe1d3c71ad9346077aa536b7c7b71709f681dbbc144c5a04f2ef20f60a590f3884eaf7f9e6d7f599932fa81312aabfa8602c8d1e86de0d0139eeaf5e8ac8e58c0950534d5cf7be0ada68c601e829d7de4622e69981624d053e021ea900bbedce6c72d80b7a09cf00d5e804268c0b072e10ec4c70d8194c04f2cc244596656b0801a474588aa046c857820dd7263934527eb85e8a68c8f60ff10824ce6196a7292b18049d84817d0c4396afddff376489d5c14a76351f840ea1ee31a121e078cd2f15c1c897d3b2683e341af98d14b2bf9cf6e004a26111098d5b32307654095690155e878120bfddc976dd5e0164915c23ffe18affe16c058fd1bf4b6b91468a3f27a030bf10c5f6285df609cac1f3f76eaedda553f40a0891997e238762a0c2d990937951e9b3dd9619d9149f684ec7e7c06ba9df163c04018c00d67d98e4e5d1ec234d703e14ffdbd44ba563edcd226f67bb4c538a66084805109ad4c01562ae25a07c3f81beb8a535fbb1467a0b249fbc8ff2a8d19307957dfb6f21001d33931ea1835900c66ee9d365448a0dc2c711d78f90563e7702bdb4268829b95465fe9b4b0ca069015852960679bf6334e82c30c8cbef548e04 true +check_ring_signature 6817240e839f4d39bde7cc9d63d4d28d19654211a85728f04a19419815531d42 8bcb59696808d8670c83c52edbd17c049b0c3f11ced2971ac0ae372205c89f80 1 f77b2ecd9e926544775945e8c50ce5f29f516bc9659462108913e05bd698e9bd c4c978d7b60b3cc5fd8c7ae3eb12e5c10ab5a7f71af13f2a52abcfe192b63e04b49b31a3d34298f7fd058f1aee593ab3a95ab8727073a6986f4eb4d5fb97539a false +check_ring_signature c94d29324fc26f1be8dbb63e3019fad9a5afe7bed7f70e237144e5c53229a541 622fbec65401f7d36e27787b8019c3023e2e976466edb3a6a2da823d5c5b65f0 44 30aa8ab589e6a3be510deee4b3da67eadb2e707451084081a1b272cd571b7eda 35b7e397fb0a00669d0d821fa55aaba2c9c2de9e839051d37cf0871e8a78c3ca f1484ea0f956cc41da36ac80d91060b102a9539343e888d6244a8a41a519e253 6784b11d1949b5acabeafe30575e00c8f19d24cea14887e5612ad7c46afaf0fa b4bf359bbc4156394b104496df8fcba1c342910798a7a180a785d29793b4aa4b 9631411a9936d10b6c6f3eb4a7714f6a249da2dd0e39b4da977336c5a008451d f0f4ac269d993695a57da0954523c92447abb9d961273151eb18d1a4c8d6f2ec 4e444b247c10f5337ac7dac3d8982f305c6dfd3d1f252e3cdfe6f55df0ac21b6 da4e24d575f938593c4bf26bb58a2471ebc93bb3f32e458a8d53c7c85f8e2d64 226d2dc52c1b70c947028decfa3e59fdc77b94fe22d5ebc6ab426946d19eb7ec abc60081c073bc273d26196f1ee67f1033c2f87b56f19c9d07920011fa16c0e3 3599e8ae92ceb6ddc04e85fe61b89c650325d93a5cc18165a8daa6ab3cf88556 e2587e69b19971a6536c9866ffa6ba2435c95ea2af165e4e8be6a96413455f88 903c9d0c8f1586bc8f882ad6a0dab91e4ab7f75a4344cdc495b5ce26fb9295ed 149a8a4cb9d04f2c70a783f03533adf360db41dda45cdf9e9c46eed83c1adbee 18d1c5aa10116faca1178db5ab1de0ef110b7b4d5295684e786776a1754fa931 be8f03d4edb24876bc64be5ca98f6aabcae1f5156ffa8b4b76f99583f93d829b 3407bf1eb0d1da0d24230441b433a729a326b5a85c0aed45cd4b8f6d4448c1ef 209afb0e76e0af8b37780b0e5f4ddc5c7edae6686056d25c13ef561150ed7e71 ccd43078b93c907c1e488314033cd7e45459d35528ec68b9de99157c81170954 1bf2e67d0bf84a95f565095edea88d546c567f76489dda0b2281dcbf62a8fcaf 78b04a4e794dbf8adae14c32e711534d06bc21168c89c7902fc607a438cdc16b 8313db373f4f639c82a86a8b09b5460d3d79d8fb1d55cb3c1b5f58f38a359eff c1eb1df2af9c1f03787d5fb01e0a326e8322b9fa6341d18c5c37b7400a352884 1461b3fa9bf92513732d3f26d6e9a7ac67807b180d238baee91eee2d92ed2395 7a02c0db9cacc62648d6278048c345421edcdb82cbd4b51fc2e2d93ff243c303 f260b5d5b826bd3de4c36d39d1072b592e19189e8fad9928741a09b6a8e11a73 8d89939b932bd154c347176b9d5598907e5f39ef453ae8329b8932fb2fbe5b69 27987bbd56dd7ac5ae5476756a8b7d248edc0963a608a11b0970ed99ea108337 3f917e056fc59f214a52648e43ad5ff9cbbea76f782192ccebe6f1f4697ed4cc c9075dca8f40fa6ff826838b09c2e805fa4b7b157b84c0b4744bb9e66e880d63 1cab4375f28294432a0065a4c484ecf887e07759a28975dba1eb016b70d314bb 4997441f84ec5c2d364db459a35555b7f4c1f3491d0fc83707a933aac467fecc 16e9bb5cd65c6719efefe8cdd7273c090779447790d3c2e910bbcc791d3651e7 4eb05e93c4a9443c3349cd4917f8050d99edddc7aadf906727dece46ed64feb0 f1c0946f9cd55ebfa76337ded34eaf28b1054f1c9747c15ec7a532e99782b8cc 6b1de5970671d1409355d49ee1d06c661c79528c0e06f6b89428c6afc63b4b28 c13ec399c391bf854e14adf2c4290bad159e07ceaef87ac08589f48648b3e5bc cb57ac08a5fc1d308d2bbe71e4cc1126290c87df0c4b916a356e14bca3301775 0c88300cde0eeb25560919654bff5772441bf64d5b66e7d31be3258524a13904 44fd7ed0a0215d02fc511de11ce9429fb23849564bb3a2228e3e71a5581bacb6 1679f3f149edfd15ff78484153f556a9ce229fd9f76381cb7e0ae7bc42aaf6b0 8032389093b984dda842a2f00cf89683ef1950784a3932222a512d14e00a139b 7f5e1ca35ef8594f3e24421e1a7fbe61e0448a848012ec6ae35192d290a3aa50 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 true +check_ring_signature 03b089a8d55169ee7b8e45e706d0f6bde752faa3b567842ed607d517a8846079 b80a91079dda33f6b9d2aa2629fbd4c203d977f4c7bc29d8618195175537a208 2 31704d326f1af42153812a22a3791cb3d90d6892593e60fa4e877de408599b69 63fb451290c8b00e332d33ced6990ba93ef1802902564f1699846c17007ca9b4 e79512cf2c98dedd49ec142ff9580c0eaa128d144756fae1ba4f64204da9230d9c96cecfab0f668a0dc499f02eec97b5cafa8d9c5ee235fac95c7a04e041a302d628ed6b34604b377a9bd7c11ba66231008667f730642a87c11b0342ec906f0699ae27f7ed6cc04619bace9ac062928d9c582c609a26ae0b66b1a16bf08a6a0c true +check_ring_signature a161e75bfef277eff94a10355a4679d0ed6652267b6e525ce85344bff50745b8 2a36425e3db875db14459b20a1036df7876524a1ad80723d16bd3203d78594fa 5 55697380604e786fb938611e4d4c7b6151162def3a60ae835baa20017a8822e2 c584f512887041a6f455edee05a081bbee42ad4aff3af030c5a6ddbe68026c07 1db786537c32fa92a18e864cfd6fbc1f1734d12b81aac169e77f3580461d63ba 4b502e0ba9f9be89ecc6b6f60111715f848931655ce7458cb6cf67031bec80b7 dfdf6b6498cf42e4e0addc16285169b91b1c676545a751699fd1c692c57ea1f0 5b5405e9a3c08415311c85f1025f9c1e903df994be5dd143dde71c42a5dad60a8f4abfce53f082d63f5b0a006f8835e8824345219bcf0d6a201711314c929200a7a360f6dbe6493ac88cd6410f2d41b1642f4382336afa087fa9c20c8fd38804fe99a1c54b534bc1496858e9571d05ca651a1bf33ad8710d88cf5fb11c3fa70c049794124db8dc1ed2513b3dafdce9f4386221f0c1e65bdf4532a40d00632709dbf29f27e490008a4665e7d6ade544ea414aefbe22c7bf75864569b091804d055d9c652fb674904300c98c4ffbdd406f9c9286044fe4129ffade8987e9320900b1f744777a47fa1e8110ef0ab9a0d942a6fd1e19986a0b3ef91f6dd8162e500fcb3bdfb5215aba269e38cb8025c7759fa552188a0ab9cb982921ef30fbb630072a36ffacf03f96cc16426889b7ce6d4fb38f6ffd8c437606461ef8f4be16e703 true +check_ring_signature f1784969fe53fb610e19794cb5ff25f947846ae146804d46b9233c6bda794ce4 1f5dece2aa8ddca641e9cd948e3a052500372d6bf1f7b41af3ef026a4034ac5b 28 216e39351692d0cf0c6bf4f09f5b6e8071bff658ec074b1cf8e8ffb592b83678 675d9c3e73299e9e3c0d0a0b262b28a28fbbd56ca011a70079e79033842fb8aa 265c8ec455db576467367e8b836d9bbc2ec8a3d91abf9a8ddb0d449a9371dd9e 648f63630e364d8324d9f6d1f3697a720dd091470b27a91ba59a25eb0b5c2dc5 b2fda266d1fa3d170478bad3a26695cab9e1805404a3a0eba11522ce9bdf8467 1f288d8dde1ad9e3fee9c235a9ca25138871537e61a7ab61e2f7f61d41d5bb51 1f008c6999346584f37174be8e60557ed1db6e5aff34458741db753c59528496 fe52178bfd37fa5987b13d479d2f455fd7839d7455733ac686a60ffcdfe43a0b c8432e85d9ccab1828f5acd70f1a3858329bca5d1a4579ee48f7511a3ab04ca9 5112c6ecce69e15fcca83bf507f2ad9520d914f5b314423f38db17474d0f3779 0f1ab3eafd95cdb5a30206df157239b0a2ea53b17286607b7c2043b06d8a9bca 86417c640f5628a05384cf0185e68c48937a5e16a68dcbf243a63cf0623f6810 1c946531637e04acb100bca679295e81c39a85f1922b5f74ba538f133b8df252 2a68f8c4b1322ac595ded91aa1788523f1663cf3355fae8cb6c0eefaa7e9ec09 9134d1358662689182a115c5fa07394800bd6e9a775558fa0c5d9d4aaa593e2d 471b38df1489aeb4e09a81e49518b19384c1de062bfff5f18527e6beda4650df e9c1ae5b97eae8aff32b13606cb21eed126597ef6deb8520abfed8b9d8ad62a0 63bc0eb8ce68da474c08550a4e739ab79ba20da426629b7304e02bc3bf0d79db 8067a3221989276108c056e9c435bab592b597646ad7316361027f88ac1001ce 57fb27cf5b39b8d1b59fa833c308ee82be0d9df049dd4f03c623e66e7ff048bc 3848e0792a1343eb2eb30251ffa98398fee2eeeb21be64035340c8c51337fa80 d3912cfe86c429121f4a31fbed4d564d82aaea1ae1bae5a3e3b940c753afc931 ce204ca0c637d3332d887f43672cb88f9a69854ab6d960ed1fa61f20318387db 4c109631033a2201a86fb572babb072188c2953eb157422360fe4fc1c56794b4 f081ce39fc0040b82a4765d89078e43815ec8d3d3eaee0d2a2975d77b7d1fd76 2876b7edc2873f88d535a627626e52b2051626940c090e1e95ec2f354ab6ffed 51a38d857f3c766e23403591977bbe510eb2349e56b3e6d4115a0b34430b5956 a3d046b321842fdeac426c2f6b28b61dda830369d9ca12d1dd0086980c4021c9 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 false +check_ring_signature 3b9a37ba19d2a810d2ed703f59111e01e999c37f7866138e2eb71d65e910afe1 0c5cc08e05b0cfe231d0c7a0ac85d04c1a51a7000f2a8c8bebabd46c83b5d720 1 a5db19884efdcc0925ddc2b6579afe8ad35d9bc5b0ba4d4ec50769bc802e0073 1756624edda52e34266b04ac00e8ac6ca1d8c5fac99a53b3abac376f9a03997916359ad8fbee2834bafb8c27f20c92302919f1998d9e333707b95c49b954d005 false +check_ring_signature a9090ea937ed546695d6e6b886c90e9f1efc40158d1bc5dc859742044c6757ba f5a3f60a4f2eef7b342d2bc7efb8f1df88b99e8cc61a9de05e8ea78714ce7ca1 1 ef0a423ec097457e946b07834bc88ef5c0f14483f7c3b46f2dcca5c29b2c3e90 3c5c2cd474ec25e32f2369c40b71bbf1c8f7be23d0d51ee69b740b1b11e7e70c2c28cadfb421d204cf44d545bac139d547b372ea255d221628f678840c548cf5 false +check_ring_signature 3b6cd04cc71825e08ab29aa81d4eaf5cb6f62378330139a192c5e6235ac2cdfd f019b4f3f4b079e3360764b14752d90f8a3363c5ac93b198aa3370d671ee2b95 53 1a9a6ff8cb5bb560d5b8f0c369ae416f0ec53732b1a52ee1bcfda576b06d82e2 1da2d770419d126f7103d791a84e62368aa5bd2be6fde3a1f96746a026284e7b 93595c7f3bb8a6c1a928fca7844c1815354615d575acd2129c806e23b3f06fb6 fb2e74c5ff31c4d4dbe5a192bbef1a0f83be49d9d104fb6bccde8667eee40b60 6c78daf91f4ead86306d11f095a96066d4cffb92f3096dde299d2eeb782a3613 5d38441e964ec8d1b060ac634f1a62790e67cbb558705f679dab842a633af362 21d713eae531c74a1d6678d5b5678690507f09c58d1f2a9cf1a6b9dbc52171a9 ee0519876ea73a99760ff4e8258f9bc46f773e029d2982f56318203f58759557 6cdfa918144c8252f058dbbf61fea027ecc76797bb770b192b41e57bb34422d8 28fbf8c395534bfb32d55b7349d0433b76f21f2002eb623e3b3da3b9a58e64df 118736eca16a2b5b668eec15cfa8d4791458048bec72fe2d19a0b73fcbd64f9f 735765a38b6f5e1f651a3ba2d8a2803422c164e4d062f9897d9ae8af71a48260 f0690d1189567780add430b42d076e7f702ca0afc7dabae8142309c9e1c8924e 1992b5d8cd840d1329be8b23ec7c17b6f8614e6954ae20b4c41f8f268a6ec448 d51efb183f532474452924e61711d5d325af7809900b4be0a47a31c1961cf68f 85e3acbfd082d155d57b987c0d47954bf79d34823230d2f5b5d4462be76b66d4 6854d478d98a8e1b217b34e22802e1330b02e1d599d7ab825aaeb5b4244e4a90 12d7600f0fbcd4629e481e189b7f2323d4e6ed91dcebe4397f9e7b4789f55b12 a6191795a5450a2704b9d419b350dabe76124a54937034487018621d2fcdb23e f8a6194e71327018d5e011433608379497e1a958ec05a921832c661224eb1754 1ff1f25810fb0a423c7da5354e2d183af3982b20e3252cbf4656ce827e389d88 ee69a7fc7bf59cbf740582043bab6f67092caf17102c1f791c88009ae95baa71 e0bdd1568e783b9fc4fc73b0f780c18e9129472a5f5a392ca6d3960b626b0a9a c34b64815e44fb22b1cde0397af30c7b1bd85ce463156ed311054a4ffe41dec8 51bae528ca67a6000f2297d7c5c08ad68491212dfcc56d987d4e50f77928860e 26dd96ca18d45df5d71f9ba64eb59c054d8931c31418920c2a67d5fadfd15aa4 9ba1020db56f2ff5acc2e87420cb5f8706cdf966f2758978989df6e773ab8d2b a3a7d5613950cb96b64eda0f372631aaf0396bfb39387e65ff571a768e3998a8 fab22e07673cc243cd0819bed68ebc52bd3a0c2a96822ef768ea63fb8fb7716f f5184016b37d436ac784c836272c8e9c7f58351617833af3107e12b56794487d af5a8ae6c3af6a53d804ce408588e4315fa5a1fddb807c75eb758901918ff3c3 bfb1962761c50d416a011d709e6c326dd9eebfad48723710a328a8cc0e31c014 642c3237da595a27443464af521250fd3f6c102a0e2576025a6c255d2b2e1690 0f7da704e7cebbf45e0147702a6720453464277c0b44d3f0d5e7206d8c932249 89b2514604f03a29d9dd486f6a0274b9d1e2a5f95ff5fda8797be5b5686892fb 271129971c87882c5182c7c119ccf711dc0d0eb4c8369e1044eaab7d53269e63 9e0ba31d532f85161c3756161cabbd8d8534e97e3a7fbc07607cdd6c1863d9fe 037862daa1c06b320d282d2548ace99575474e93a2520988e381c8f6f0d04dae 36a0191b518ee6925198bb94a791b98dc4d02b86d7295635889e03662b080442 b3a028300aa997244a6d1dc47eea34b6e4561faa66c82e57378ffad0e7da05ff b729b11f2bd299160cfa406083ec8aae7eb8fe951d12e669ac28d7ad2c157f05 979ec1ce4a54d33a0349f7bcf0287d524d90dca26e971667f6ed0f85fac3dad6 a0e42901310db9b9d72569274602ae4d8dc78567f8f334a39bdbe2316f7c9a32 bbbc1a8b9861596c54ae1f34a94876c6aa9ffc68ea5c3881317449eb83ace26f 7478560335457c340d6103d7e168fb0099a7e8e7f12b20533bc3dbed5cf454ae 466327660d9472a88faa80945bb28e0139bd794f42475ada6580000877c9399e e5d81509c716d228159cad09aa9a978cb590a25f30369105e9bf71bbdd3abc3f 306a797b36b89dd234d745a23ae936567cad2389f73dd48deef59a48cff1e501 9f7414cbc7a73a957fdbba292365503d78a12dd06e702e4cafd6b7775bbdfdff 2de66505a221cfe572acfd77ffa18148638ce908222b8678563483cd110e4923 7a2b1f729060f129b10212a2eaec11b4547904048b81fc37191c354cd3417eaf e3fb9d72546b34eb118f5e457595ec37dfefad7a0e7defb1097d0a62492ded53 647444aaa48c44a63d5f9b014d5825e132824eaebc10e51fa014ad698572c978 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 false +check_ring_signature 2facd344c520d5f6d383c7cdda59fedaf50abd90c1f2944d19b62fb406ee3ee9 77b66f64b82a085e8a504b21eb5cb83c043e94abac483d60a36e117b42f41732 2 8cb253964b3b5fcb5f598d5f849479e64e8e27716a695201e7e59e16e084c8c8 316591b78a23876bb733436c4cc4c6fb0cbf7d70ffa04f0d6e527eb7b0707ba1 c51b3694e1d061a64d7f98cb71204ec92fa8b9b8ea490ba66bb1a865029c0f0a6adfc1627ebf9e9fe5ac1e1b61b3a86442411a2af3af1106dd9e8cce1bc5c70d77eb30e26bb227c4cca9999f38594d1d0aa06d0a6419a169551c3861ade23001725506b8e2060bfa89c08d39136da5fc4f0980458ed41c9907aed66a50241607 true +check_ring_signature 23f3aaf6bfec264faabed6883e06361351b1c0b2709356cf20a84fffa2a9936b a6116b54c9c346713a7a9eab1589943445207ffbe2a5463260371f59e9e4c05e 1 659eea0f0466a72e3bd5f731059362e52920062e47452140cd0fd529fd59f713 5a85e06e136ae86600430daff6a95803c2d442e64e317df4632ffe42f05d8803394e99ade766aaf8518bda2fd389965cd679f87a55605bf74939f7bc071b0000 true +check_ring_signature c87bc87572adf259b82c1e891e59ab32f3497df9b56e2b6910762e022a2aac7e 32c23791b5e784e3629385fec72a788a63cc3568d8ac6a642b741ef411fd54e9 9 2930e9be1040eeb3f02ca6c91707eb500f2db91bb772e7f1a82028d844037dd9 b634f402b7f3ad79b4089c7a13d4cf34cac48e471f995589adbd133e37114eda aae72355c265d680e8e4385ab5f1fb958442a83ed8a5d0f89bf25fe32f2a930d b3568c36e56cde079c0feb4a3aa7c0f6e4aead793b5d7f51b48b144af6113d00 6619d4df0e50c4df6ff4e1cf4cb5d4552ab6d0054973c23647fd71e9614a7c35 0073602dc1cfdf852d5a412bdf0b2326b75ecabe44d6e126210af4d387bceca2 4f2398d5c54542a0538148585a648fc6cd3f17a84c45baaed7a4f948fc0a3c0d f47613831d2ff3422c084df4b5a202c09a20e95d1bf0f0cf83d528ec4490a928 2b0350dd6368b706238f557b1188eb8d457345f72e0a72f2e833546211ad6eb1 8641d6d1f324c2d90eb6477d2f935fa493a6aa112fe076e2dde4b0a403cb7a050fbc9257209b7883c3d1149980eb1acef9d6a17d6c8c06f55d631f32cf106d097de8c8f0381be7551c2bda31378cbcbaed8b8d4b1d9bfae78fd29b06b7e8720dc3c3f105a5c666a7326f37ad8c57b962e8f1eb77aace46c2d59dc7bf1e5f88075fe73a60dd1d486df2fb9d97fff0f275a66646a85c77c5588c97a94ff9389f07d0a173fc159eb7250f2c8c2e6c95c9cb9e8ffc437fc2f40db9dc504f27724e0dceb1103a1e64d00bde776a4cfcc079e3c4f55cdcfa7ad1c98dedc3883dea2b082730b9d83cde60f487600986bb357f65dd769bbd6dc992ed7b13b1d4cfceee05bb2bdbe464844d00a9371678bf421df41e5a2159c34c628d663d6428ee466009d87fb2cb8f532d4a6b3109aa69883598b5d1880ff80fd5ebda3bcef596800407d428cd3a27f477b2f529ace2d463db3db9756f9ce65228c124ec695b25099b0882f878596539aa0fedd67292d474868ccb35037b0b537d192293744cea575007f072fce415c38327db882c7fa3f0acc13b21969caa2d6df666ffd50be379d70eb8fd8088da0133a87d8b992b69569832913a54851e30d2ef47081889f702ac0622f140e77b6bde3fe09470ac485858822385f886016a87546ec508b6e07506057d6d3811659f56203b10874b62f60c9d76970c9186099579ee3043c071f34b033241325dfe1a5f9639ae1cd85097a5b19d73b4ef6053ffdab047e677c4aea103359387d4f9efafa6a6a1ff009efe51d4e88981f65026a09f519e921cf73f8904 true +check_ring_signature 7192df83c989e73a8dcba011717e9fb382ee5f50d72281768e0d159dd49cb0a3 75cb6ae2ede7beb5547af135d746fc7bdc94c21681bd1947476d01f9db3b99e1 3 a1f9a9776d3f9fa6d33a319063a35296364fd6fe4bda1a6db6f8e5d9d4f927d7 cde8d4e82bf18e4f1b473105918ece49230d81c2e7e76241b733b1d9ae81dd36 a3b47b4af94e6f5e0da27b7449b9d707626f1348932813856e16b1ff56c80265 447de28822e7ddad7d4c9ffc4ea7beaecdd6aba31e7800fce792d5cdd0dff4e95c3acfa0124eff07c84943513e241584780bd8c0e4b368181057e1fb2619bb0682e4b8aebf67489a0274239bb95fed7e296e9e0da6177b09dc2c892ff9106a082de9bc0612591edbd4aa4c6974db24296645cb04152cbe2e59550afbe0e74c084c2930914722f84e1ac7dfb3458c9c54bbd246ce4a3df2012edb1c9a5ed6e001ba0a48bb7f7ab2e6f5ad295e8ddb8e13efbdd794f58bcf75e089565b4c0e9e0b false +check_ring_signature d64185ca32419da32affd6a9f87c3d1a1f3267b977bccf29de8def7a38efb70e 81271b6e6e155cf51641dd9e097cadf39c25a6ec614c92c0665e8fce3db26bc3 12 cfd62f42e74ae63df3ed5381f24c81b1da603b907892409d9d83f4abdee521b8 b6f086ce94954c4bf672d497e014fc0a9d5f87b6f0fa2cbbe91bc0a646a2fb50 e5ec438b184e6a894fc50dea852bf7740c46dd71dbf97899be1276762339a23f c0ba0c17030c69757fd2f55364b98774ef192f5558a3312bd0dc99d3ba7eb6e4 b56f26abed3d72a9aeeaef0f24948a5ced36d5d254b5aca508f637fcb1c6530e 4bab7330164bb811daa9eab48d87597a294823f048597e0cb9c852994512b824 e90d4986926176dc21a441e05075fc8556b47e1f7d4492ff5460d2db23819958 6a75fef692f11f567d24e865183b9e0a75eae75f241b2166bb9f36ff48e26752 58f2a64b34dfd89c7bb1569aaaafff1cee54a90e956a317968b46112a26b8a2c a32b77819ab8dca57862c1a66fa399913ca912abe684780ba1e9243eb03d5904 dd432aeaa735f688a9dac79e321795f4c4e3e68f7c3bdbebc5ed7eee0d162a79 540aa2e8a2bf5316f31f95c756453f52fc63247831b1a055f001320c6658dc09 37950da0b091e20759654ac886e96e4d6177239be0719213c20911f38f231b07dc125400255fd5b7532ff683a25012c28db47c11e8e21e07f8e44ec986f4e44605533dff9009dc57cab2a5718b4c657447aac9f9bf9bed0b695cfe0d4845a452443e17539849ee068ceae5fd9980900ada1dc57d15c0889f04337059b912ab0fd831c8cfc4893306f9e4a85c5fdc8111181b313157be2e63f4c7c56192422102496ae17530230f1f413f0bbd2dda11e4b528cd15460dff9cf0ab4d694f5b4e0a8ed5d62d324648064255f23a63a57d0a261394a8251e1e37efc5920111379d08504b769fd0fcb0ecf37758951bf6240ececba32d64bde8dcba94fc6aa3c6cd0b77396baac2ff5fe920f0656c0d4ffe31329d89063e62bd684c00729684f22d033a6039dde87603e569ea6c6b0a176666ef867927033482c3d45eb6a439437b014ab2ec1e8d69f039b674f12ba9af35395c7d12ea2f358ea926e61816155ce20cecb13d23af5dfe16862b07173e198e5025f9ce13aff5058c6a8fb0275e09bc09e01e6b356a6dd964a114ae9a1a04c10a0926b7231364cbef2106353434f0700e234777ca9b26dda92c8149de3311dec81a76cebc87fb598254a2e2d5238bda0cdb3c30056c547de07dcb3fa39e734029a19872259e7123adc1788e1b8cc9890c5fb3533fa146bb24b4f1cdfe09d67c9e45677d9e72e6a49ff8e71d28db632500dd6d0e279c928003463f3b0126ba821eba398dbb150e925a786af6411e3b2201905cc8e229d4c33298b45ab133b7b8a265392a4248ac69df2c01eb75ee547e06529adc4977e6a7b9e383dc34c612af2fb87b42607b191f29e8aeb7ca5894910c6daf6775cb9c7211fef7f443c4712fedb297a18ad5480e41a4c6005f20f0a6000f597ad61d3457f3c8ec3b84d6e351e27104f9a8c66492cf083ab28f22c2d20fed2f31c4936b064521ca4631bba3005cbe3f2529785ee5b55c835d8ec968870903ce2ee8ab035d19c60dc3b1ea4e439a68a8c940bb7cfaffea0c8837728121090f1cefb857f4303dc4c55f8513d83f0d247c66d70feae3219238e6bb3d360008 false +check_ring_signature 8e6f907c7950b9603dcfad1559d940d33320518910f3169cb5230ed4b91302e2 c80733d8dfe2d985479f83474cf2d63e68b6a42a960803bd7cc7e41bc9241213 1 a9dfea982fe1282c4a4becd23845d179562da1826e57ef04657d0e4ac6c8ee2c e3ce19d2fc82caa77878961aa10033086f201ae5a22ef66969cf9f467a6f770f444c72f9e37ae6c9484f159feedb4804a625f784753899b9737bc613e4e0930f false +check_ring_signature d8f531ededb142ae52b7348356c31614c03d6747980c0363b02e65d61ed3c0a9 aaaee09f36bf1d5527734dd22116b0f138348c1128a6b809be331fddd4d44477 16 0d5719e3234411eea8e2023c726d2c9b664f6d37cd4fb3c0b2e2d5ecf5a69dc7 6064bfd761e3036c8300244df64e137fc55c2c7aa74d1740a10bf1e27fbb1118 6bcc645f38bc1864728fe2d1145bc50377a91ce80d85ba4d26b99c3937eb2dea d25191179f721e28154389e45d7c1c0771246be04f2caf8661730ec403b415d2 2fa51551002b5449ded43624e0ab4832366f25159db670d14ba73657256f996e 860ea567d1a48d8bd541ed2c0e3b4259547aab3620e9dd2f5fde2a26f3b7d1c9 47b2788b57ced7b62b471e56585fce099c51dad29d0b1dc195065d384591bcac ace8cf931b5b57c8217fd384d6429d4de01ccab57373fd60edaedfa0d165b581 54f064aec6c89591ebc1422d724b48a3553524822623e60b5771a55d7c04fac5 735fd16ca5d064795104bb79fe41c7bdedb792bc4e1a675f3c47e32ec1d06533 017bec8a22479fb45c2f5edea197d3039e15c6c5eb49dd77c07f53c5e277c48f 365b569060002dcdb31e933de2dd77d7834baee6b4de55bd614f2bdbf3ceab0d 11687d1e646595df413c760e19d3c7aaaeeb39d42a1276b6f616fca3b1452913 2d4b2c709bc9b24e45613a2ebe8187fc295f2cba48f746fff762313c97fdd4cf dce51d739913e5584e0a82a87d86a40fc496807d324f1d00f6850c946a754ba2 378a21b1a2fa6c0bb4dd02f2e2bc3d7618813feceefcd972bfe03b9d319f95fd 34c4fd0d279e7463f7c49ac011790ca1d15cf2923985a3c69e04640bfc1f660cfa2bf9fd9c796e69f60b2b47d6ea5b42c12d6789ddd9fb78fe9f4b3b2a289d0c311c4732b56fff156c34603b3b60022130359b2bea9920ef285a9cc1e8d94f00a8389141194cc4b36977301d9f226ed7c739e2639d87d542a67563207aa89c067dc5843ac367273fdc60cdce509562f3aa03cc08f1a636f70ef434faa2186106a3c7c60c69a15a7e7836e54884d42735e83f07be229512117e621a2f3e0a3d0f06289eeb83301506c0d9a8da998c3a21ab57379b31e125484dee0ea744e8f804c05997d842b7fa50cb0d838c8ad26a238fbb79c5f79407f67b21cee11cf89e0f941b6a330d4c160351acc1e622d1a55344110d8f4e6b9c173d280d6cd253cc0fc63b32624faef16a77cc754d457e3e36a85ba74149ff2210dbb83033c61bf805500c097a1958166fd501edc8c7c82cbaf3bf90af2270f10afea28a5082f89506b69d155e60381385a1878bfe25fc99fbea68f52e9917a487173110b9d62a1807f20d0816dca126ad21a3958862901b11b886bfc716686ee961aae3f16ac8220479e7651873d5d38207cee559172ab9fc7c41a1a1bfbc0230cc69e24e6af62f08b59bd5cb378fbeb46fec19b0dbe5108e3e43a965f7ee55c96ef416635bc1b701563e4c3db9167065d778cd53fa779090a6b54757c22e008a50361c82ee9ad30bbd992af55b714900c1433b1a284aa586b6b5f9a67a0291de9ed5711f16de760c91371aae81520d37909fa1d5f9a80e9a5e6ce80aa00965dc0990840d95c4b10ac1c110263085b8ec9fcb8758467d27cf88a17c841cca65c44bb127f0382219000edbcc4735f1bfa5d1bd3b8fcb0b86bb6b6a93dae6f676a9ff4917b41da6e10bf20606eaf5ab2363b7284bd08c822783c5ee55a6909a8a0c8d8697cbd8c5ca0ac49b931c01ee03132d387bb1b5d38d08ca976644b8838d8e1cc7e0a26d63bf0f413207195cc8c0c859454e750b2d32b1260acd9a520e6936e2cb19e8e459500be97fb17b4688f22a9258a3ad301d625c411a092ef3247dccc3fdc17f5cdb87061d8a6bfdeb4c7a2ddd4ddf562e6e971cbb5afe4da4ea26d40fe815bb20b11e0189ab1eab2985461dcba40bc8e8f30130fd53446036bb005a1c7dd14d8d2dfe0de3752f45a4ec2a36556b987b25ba363986c6161df2e6d50998edcd3684686c03229ba8e6bb5c532e16bec90d5667d505a9e218d8b83a30d9964a25005e89780d1e3b888366223b3014fd283bc894ed7e4c8378a64e196342ded7dacbe8a9e7047c95427579238482e51fd6fa38ab62988c5e6940b11e6515466fe38489eef809aa5509c7db56084a2a59f2c0d98ac3466809b5f3738ab20ac3eec94fbd76750bef117cb175e9a3ecd08b93bda534a1a5ca0cab9f49ebc1fee8455005a8008206 true +check_ring_signature 1580930e86b4af9d56bcb43a15264ae2f9f3c79a007668b29e8c5007f09f129c 29a7ff20bd25fc48a422f1b2c22e41943a452e3348adfbaef5fbf50eb5fdc2ca 165 9362ec265d17c90ead6f42b916d58fd3157ce27f3f8585592afef214898d3121 7f29473b1488762fc8a61cb679a40fc4ef63f67f3b651ed141f88bafef2c3179 7d46120ae3e7f606257ac2d39364e59946fb9d9b2b03a61a24ba684e30c39ec4 28bbde42a2f44178017e261ef30a9af75be9eaf3146da656051de6db4cb0324a ccfd6bb77ed13d05cf498b7f051067a78d7fd9bcbf54e7d9ed9eda3da0be0dd9 f50d0712c9bb074dfe6a6ad2adadbe5ceb58af456735b6331b6e226c9ffef72b ebc54d06ecde3035ac61ae3570d8e4d3d6c2528e8a706239914ea9d54c372d7b e26d92f5d5af01cf482d5642a27d12169c47bebaf79048642535b66084265996 93dbc0c92341f7bc2341338d88666516a6cfcb54e6f1057709d67d10d3039b59 83e1405725ad72963a61a4f7f7bfd8fa1c1d4150ac652eb01169bf195e0355f9 e9f3ea91ba5479f5202db0e045c3597eb466a0d2f6cfefbfed407d3bd49eba38 2b4abe18545428db457b36eed9d408ef6d7a974d7d3c89d5ece728746e96f9ce 7b419bb4b34e376a66622de78d92eadbaf3f7e5292dd1e36b1d56c81b167c9b1 f21009e4e912fc8f6480562dc4c025f7df22ea2efe6c293f23cd706efe08f8d7 2d973cfa0adeb4d396f86165b83b060cba15f311e58330e16893cddfeded1e17 289c6949e8dae9a11fd603eb0c367bae1afaa13105f0a79bc2a633b3f5af0e83 4f14a299e557273ce7ae4dece36889af1aaefd85fd960ec13f1a5704f0e9360e dce6eef1317a6f09b8d9a0a8bcca60ef338f9ba836c08917b6894a05a023a1bc 94108e41d4b581e5d9215c48661d65940d1281523ba781f2736c1d2320e61234 0ae072a3adba3fa989304e217b2ac543209b417d69e887a7c15ad65c19a69ddb c35d3afb521eefa5e285157af29294f658f0e8ce603c0983e1ffae795e18093c 91057ba63130eda7082ebfbe0a74473a3e0ccbc6644042ce0528eea7bec35e73 7102205612e068b2bf8de16f86df57c0536fd074fe561d64f1786157d59b4974 f5b5ea0ef461b4b1147c297d82b4834e4cd6f98c3218828a9cacec790ec37522 abb7bc63b0430b210b1517c9cecd02edc861aa248b873eeedbcd6b88a2ada79f 164b8a5576989ccb6c8d629050052bfb1f30b0a019d680945dbd18eb225dd769 6247ca950d909121a5a216ee98f5502ec3d2f7abc0322320e5fc6631d95365a8 d91fed20702b7e6365208e04aa2d5161ed36f2d57c09e8b1a366ee6863308f99 a4cffedef91a0dd9760112ec17919c7241fa5d0233950edd84ecd1ef43d88d80 4db1feb759ec337e18dbb4a7c8b0e6da4bfe33153aa057dab1db837ee08a5484 26ca658af56ff26630f8c0ac532ea9a8a7b91cd3fac15253ce37d324bb06357d b3df08efe10b335c76d00ba6cba74c64bd7160e2a1fc6e2271d60bf6224daa1a 8ead8c1459731ebd4b76277fbc7e0c253b9fc3c4b92642c4c619eb18effc6af8 2b57358b980610d55b6efaf504035590d7058b3732ea78151504b7e983e74ebe 48cbebd833e3d46147236704a29b74301ad60345e685d2e3a291076e19e97514 183dcaf7d235ee0f5684d6d9edd95dbb34b301f8a00440c9492a4975b3666f1c b809355f0a09750ce624d551ede583caf608d09c81a69409d5a1b5a83aef609d 425f9e52d55f6a5885c5b155e2c1abcb56d5e6767ff36cd98809bc3dc4f2000c d5d4877584766eca131e9dc1fcf9ab4dfc9f0181e1d3604607d3609387b5659e 6bf810e6353f88bff7acf8c7d84397742c32d274c1ccf8315fef520ee4d1bdb7 b1cb3500f544f3dbfebbab73663b42c0470f6776d8dd748383642a315c0055f9 f8ab948ada4a7a8f67229a33596014563e9664100ddfada3c45f4afacb2c33c1 9ab8af4e0c51f7cd4a1e9eea15ef8fbec830c10272108261dedc49988ecb9058 e5d8dda43129b513fe461671834ca1af54e524ccb73ee5a077bf282d74be32a6 5cdc4108877435300ee853f83eea79b3940cf9a8b619d3d00256d6db93d5da19 471f6904f869beba025b6abce73f77aa2dbca83c6ffb8613a6d770e61c2ed214 418df4b6e93a17f189e3df815f7dae91cd706a80e2b18a409632584cce37c646 7a7e8441578b191f6f1f6a5c0315a03dab47980a17df65d68bb70b30157344e9 b31c17ca6a0d5ea41b0773a68419b33e5579ef947e4c14f71d8836e3c66c566f 6a674faf829318e11af5d08664e9edc4655639d07eabb190cfb9cb1a2b367432 ac2c6233df4bb3e072ffcd406d8d3c739da4a060b83ce83e16cc66a0c7926ef1 7b60f1c2089aa7f8812b453532688eeb3acb503e30470fd08275f79289212f12 6683eccd89da488cb107fefe1a46c3b3d2e3ff9facdbb3e4c4f64b40e25b9483 4c4fae88ab7c5b6736e405157b232933b27f7c723b60cb62e2a803665b973c4a 1f6331e3f7dec9e5c34e4bfcd9da8c162a5f3a11b7146b16e0c22542158ee035 4f40e6bdc0281bf2e53394eb8ea94eea7fb301056ca1f7dc1bcb21831ee62188 d1a2e7091fdd0dc29bc5e529deabd2b239ccd0d53426caeec271fb739fe54848 6e8f3c84b0a14e5bcbe775f271b45ce9400720e6605dca7c7cb43094549683d2 f202707043695c90ce01da27b94c86f7b16573d75dd175b4f33f8b9e8fa9733d 0cd11d42a741c5dd79660e498fec0e594255fa25e697afc134924e5d231e100c a47cfdbe480c17652c5c7bc9f846e39cd39a9eca3de7b26eada69b152d94a948 b951f22ea0891aa9304b92131f6508c06be0be32266881ca924a19eaeb4e5217 d2761b30cab0eedefcfedece828618e702be59846bf1cee1e1d253f18c9ef767 524594e678227ec95fda67f1685f06d00e2b7a18824bff63aa198eb365dd02ab 0ccc9ab1fb176b64840233bffa339a21ee0ad391f337d2ec486eaaca0733b78a 2120de302532acccb31b24169b893233e21fb1448f63dc56b45ceba0af055f63 7f35938644a1b60d578141700ea894526c7e042c27aacf8469be4e7ce75eb1b5 a1090e221fa644bdbb3e0172cf2c24f99fcc728201e5d5f210b1ada45648ced8 2d407dd51bd4b82215fbd0e26ca6f4233fa2347c97e5ee7b1e6de9ba59db81ba 9b0c52a5c64dd6f3c8f29fe8c0818981e3f814fbffd1b91c841a20a035909cb8 feb0e7eed392e6906c39681844e446a0d754ab99b8a0d51af6c13f0d9772a84f 6d60cb718d83a3b17caa0e19ed4410f96bc9e0274d40b16a635a1a0202f65e65 9167f459e81e6120d25f13777f814764a73971988ddcd8ecb31fd37fc0c6ef26 5c658d91aa075ccde4e66e6a78f1fa2e901b75d840a80babd0e5bd913208e8a7 353e798ecfe9dcb4a11da16430c4f586ed205cbe5fb23287af154599801e900f fa2d9fa08ff316f3a8f3a0227340f040c67e2123b005a5735ea0da3ef8853ae7 3d38b90a9b1c44710f32d04a5e359ee42cdc1b14fac22268777c08a46f16601d 46a7e4f303de84fc2723f2be15550441379a2a555c58551aaf084ab4b7a008e8 835c0370206016d668635f3ee155a5f5a5c3ecdb3136dee0cbdf82b540cfe40b 56ad78610c8402f88025a7bd99384ecc687265b108d5b3c77cc2cf137e5c0b44 2d219bc9154f61852f183b54963f1bde905dde0bd51e1e3f3d5cb4b5a85e650b 4a3de6ba9ebe1223c78cf4add9b407685b44680e5f979ebfdb0a326d99eec8d3 fd4e0d0fbc937c13b27cc6439111fa9d7e41b5fc609fd53608e2172e552dced3 0bba01fcc12034c5febed8aeb1c1484e8df91ace96637d1ea33bf9f1086b977b 7a358607c3cf938cc96e0bee4dd398d2a69c1209533a68d5237d0527a2cb0105 88f179d7ffb0e6c15091999faa3c5608c17cee10e255d1b2f89bbdcfc1922943 50379f1f13ec7448360be7c361132814e16dc974a499051b19b2afd2a5cb61e1 8d27dfd0b73f3ee91cf94d0536dde83e74c40c6a4da3eaaf0bb0882b2fdda666 aaf07b604456020781a49ed47e20747c3dc0fc2915bcfc3b67ae47fc5b01002d 727c04c630425e19073c6c4efb8066636c9a52672b699e739e03692205f81e54 ab4ae98fa1b195376f2cbdff6c7beb10afb602ec85fc19629630d40d21385d1e 9f7d1646a0a7dd287da238dbcc304eaac383c98b5f0fa78023a5fe57b877e59c 5d620cdb642eecd05404696013e46bf89aa3f7161288d44d85c02931f06734f4 5e92f97711a8afd4cc831f3c045fcdfa3ccfd83cc3751a750d9d163e9baa91f2 80f8c55edd4521a24b22c0feefc6bcca720917e1225b4c53641f0f164f92f102 4d824a38a191a8332db60e93ad4768c5b8a528a30b5fc29d7ba2a37d8c621965 19f1d6ea9ce8d365e081f57254759ec8656b237b131198afb29e4bbbe1552886 2ea54a62f2c2b5cfbcc3c7048a35f31e25d5fdd5c9535ade5896ff101e3bff05 3092485f01dc6241680ee12d37eea7d138436461d31914ba0f56eac8605936fa be98bb6918f4a7d7239e7c974bf240c80533fa44dad8e120cad1bf1e447d803c 8d7f2e0600c1f11a873dda7682a9a9f7231f01717e695bf238823b30438c7b75 8e878fb5fa9aa807fea4b7a7bd07c5b5db7b51e77bea0b81d67cad0c3a22d757 f71019db90737d33fc20c29caf843eaf4f380fde8de5d924be49e4cad7fd5223 3f3205ed7d03947e51cac1fc1f634cf8c928fa31054b7de93643c2c888f5cb3d 264ac5ec5c00110cc215707bf08354cb67b91bf666a88e9dfa23b11a72fa8144 10f4dd7a04f8b2e7ed7e6e324387e8218ea72cc6df5cd47c238a027ae8bd4590 be8bcc628d3ba750ddefefbab27d18d2fd40fddbf6bf9b9ebbac8aae32f362e3 d5d3182334db5c1b026499745ca728fa38f3ff91b3181b16a361ab511d853f2f 1103d8b1c9b3ca9d659208322da7232a9f96085b135054c2ba685cb17c5b111a f91298bd7a3bf2c54eb71e50325b73e41057ddd6db3576cdc0c408a90255e99f 323a26d048f49715cbb60d26731a0234dafbad12ce26746bb992f65ef437ad5d b3bc8d86b875ebedf6ec5bdcd3389b7575cbbfcc92947eda15009753b019c493 f24639650b6853855eb34fe7a5b346e90df6cb35f9734664a02472d4a8b33da7 7a33a540ac45d33caeab0ecc15f966279f03959bb762689c729d655fd752b2a3 cf737cb74eb675927c5da3a65b9b2ce750158c30b114d7b8070526eb9f7a3d5c fcdd18cdbb401aa490477f913e4307d0cfeb374cd45da3beda0a3849350714f5 f11225dcecb0411b0e9187a129bf4b46bdcd738d4040760e798d1ab852e7633d 4157926bc36fd21e5617f604ade132e99c746b8f7744e9532bcd005bc33f7465 3af6f4aa0bc62b066754f323ab5aae0599113d4583e438f7215fad45f96d6f13 011b25166d141d5e72acf9ceb4e19c87692ac855e0eb75bf2f37c0a094c6ef91 9ce83c0e6b64d3edbf2938e18a8e08b074c65582ba446834247e544e27ce89a7 5a8f8de32d213f96d4dc75e3cd3b6ca9761801d1ec72291de42efe02cf10854c 166a11c4b364a22d31e979c154868bd64ef349ef77d79d8f392676237ff241b5 d0593d0b197fec971c94fcb13165285fed45d54a9bde0f56ed498ed17ce2ca1f a3638b111a6d860229e8f562717b94884a360686a87e9710f699c45f95ef866b 05eb603463645060437cd713211f7cb0a3c497b2f2c9f39eb686aead510ca2ef 1b8c618b598d9dd68e262da65a7bfa964af4ee523d8a0a6529dbce5720321728 e0f400203d1f31258c381ed140e3694cde01b43e3e17164ce7d5b2ffd411ae40 ff53e4463b413e18403ab5e640a7144f3bf5978a6756f87daaa3d5c4c2acb335 273f1470502c42b6f29baa6a4fe27dcdef2c61d3818b901ff34386cdba4e8c7a 3f8ffe09ad1621e99c5a98158227c64987c4cbfe93b7a6f9cddf6a7669248058 3de50e27d76f1e4f3b1a04e68887c436feab10455f0a9d9909566a62eb8791b2 4ed087943cdcd31e6f25a94647b2879115c30376a682c3c2e2b6060f7eb441ec 33d76b208a5c4688d787035b6a0c4be0981383e72cbcfd06791737b403859001 dae1e2725f41a4a6b1a7a882512e8c148bcdd148a47fdbf4fb257d0d751507c7 b2a612402aa3a074fb792e1f61f2ae5eaaee5c91b29cff2bda9edcb0852d51f0 2463123ddb9d139a020c92512e5091c8295719485f65b18eec1a3e3d5439d2f5 36a1a706f4d28e46e3196efd94403a5e391d60d0b61d4d04bb50bcc9681a3cb7 f8927ffb8475f207cfb68018d90059febcc9884a94af8fc6f69d2bd90d390b2b 9fa16641df5983ed3665a4eabb0a4be4d5dff60b3fd481a10a0f54c87a8804c9 3ef0cac5ac0c84b23c9e98f4eb252e502a93a79b2458bdaa2aaf0788d988c9ee 4f26e1010be0a212b103332a7a11ea3c277e3a2652504edb34a517c7ab735b7f 9be0c91b0ea59691c340a65cba314b5a9be4e243215cd3a3561319a0ffe07131 18377dd42a4ee9cad659f830d7049ac30f0bf71ee08953f6e6cb35f1402c69f3 e7cc5756359e9ee1fa7f68b37db6e980110069437e0e88f93044b01f00e1c5f4 9d9cd33abcb2773d4aed0034afc323d1e24fee4ddc15119ccc82f503c6bd43cf 9278a293054b0607240001225ab6673a1271fefb964e35d82c20ae06776d4dae bdeb8fdb412d9b4efd2e1847f507cb3b17f64ecfbbc6b7eee9c1f79eb0ce789f e9e8fe2f156a223c8acd03cecfcbc0d9024f7e92f9ba5f811226db0fa3f9cfaa c94de3606c881f4459963e42ad3aa69a7fe026454cd6aad77d505f17a2eaddcf ff4ff5fee3115942e9dd4fba7e3f38f2cef13c1b40fcdd86779a7bc59fa3f71d bbea16cf18982af3b211940c0c17265755f87d1024f678ccac1730f71a6c1edd 33b2e838e6d6827a0c7dac081d9c39334ccc1058f4073af74bbeb011bc37ab08 723ed0d8f44bcc758a91343372518778651afd13a24683aae89be5be29d78584 3591277a1c509fbad205552d4d065a7748986f51d5bdf0f66e7225e30fdf0681 f3ecc19eb2fdeea97b12028ed287c10d0c3067068badaa2a169d9a6fb518a84e 5e5161f69b2cfa895ab0b3b2359b78844030f4768d595e3e81fd51013d053021 85770328df3136901846e99d161fcbad3bed31a1ecf8425539b880588203b8e4 52714213de4ce6cc1fab706c0d37e957dc44b3cdbca7f480e169a51148189be5 337007e0ce5ab469d2790b28b07be6a7578f4d2cadf8d4e34e9a2e9f932b903b e3069e2c8207524e39c53f43fcd48f9fac8a175ceca8abe9845f484f2b70a224 a6fdc27f450f8154221e9c15ab89f9863d5db77b5663042eec318e5aa975e9a7 f48528ba81e7407d322d1a35e58f15cf3af6b85d2335dba156fdc561bf2ecf98 1974a6dc67287fe8502b7cbcd87b193d8e6914e594d3bdc41db55c6ed7a7216a 7c51efcb78cb810003a0fda83f63054fcaf4ad4cd094a0c08e4549fbb46871b2 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 false +check_ring_signature 88c494df6f7bc81ffced311edfa9326e112994848b78a98cd6540da2678a6933 11051bf848761d8599805b54d9a65b78e000efcfe7ec1f84fa43ea62b5d81ae8 3 26b9b18b7584980471bba772f47397f434e47e3392b2b695b375a2e5176c586d e89a2dc551292fcd3c5286f2625af7e20eb554a96551bff53dae696556bf7c11 96c22d1c5a1366f568640a62a9c4e46d60345d0c9e9a9e9662aee607c40f4510 45346edafa23ed1c0afdff0343857f654e50fc2d31f9649adb7e66bfd7da1700db39d9cf4f21e7e5b0a01f8e409eb9b630433d68ecb4e2583e95b1152ae547088ca1c9e68fc11e458c51434afba6d5ce28f4719690c03d6aa2f8109c1f45530b88060da82957366beace9c00f7e17d4bb4dac2cc1900a994b19ed2e1b8e85c07aa72cbd9115f925f279bb98cec8815a8ebf4d4a9c2a2f2e5fc8feba4cc97e20c97f0160174f6e78576034011edbb7a227ba020369a283154ccaaeb63ff17b507 false +check_ring_signature 63573d61cdcc9271d38168ba045f92f62ae3155f4c2917282f31cdf2428dd80a 0b9de5865c42d0a6db946f97e31a0698421a7ba94fa93cef496532e56f142609 1 1ce09b5a210be3d696fd40bf3f5bf4e9ff77895f2196092cecfc0fe655be41f9 8d7a34ec410c49e57a08027b9e73cde4248f6c91e172737b39c3095ee7806d0dbc0e3e2471d709c08192554170717ca17cb6e07d6637d34e2be34214bd267207 false +check_ring_signature 4a3c9f4b649ed993b411c217573b6010ca5e9dd3cf9b2800cdbdfa3a417fb53b ee7aee3233d7c44bb47520e054ba65cc66b7a21ee7f97e2677eb1b753264ce2c 14 0b09663202ab9f7a7f27ca56a5303d0418955ec803f5a6b64016707de4a57145 a4d6fc5efd725c0fe9ceeac903462485acacd9a73ee64d7c604072efeaff48a3 cabe46558b9dfd5ac68d31a749f26245ecb4ebe28d2ca1007626267a9241c857 44e7de02fbc3b5f0fb311f8b2373fef93b594f3799ceadfb86620c0710237691 e8a1038cda453c9aa22c6016f4764c1feac70fed1cd1531bc793b2209d9f6af8 6ac1bc1900023ec0f8a80f2e488d934c0730a69a170a2b15c35fd6423f72f854 ece85341a6ad687c03324d826cad43c041cb7bee2ff42bb4af137853e3fde3ed d5d8290306170d117b51e0a550ae3e623121d22b16f0cc12ef63d7e8b04d9a01 6df555c69cdb77d036cc8acb504b5df1db30a342197340db4ed3527a2673b3ff 784cc93ddc25a5bae830dce8d7c2e1b6d0e12839740030530e7bed0114ef0cd9 e9a9c72e146761efa5945702a2dcd96871fd65ca41bb2b839c637269d51a2c1a 1d5d708ce55fb77f01df2cff6e666999e453a9277e8d64c7360dd00a8b23ffa4 878f4911df9daca7901bc86c74711ac524f6c469b4298e2aab441c441e49871c a968c7968d447ac29b284179aa6a4ac54daa15a0b1f0b4b583ed70253065fc93 e4a3eecca805b03a8a2ed6e16dcb7714db6008b70202fe2375815a3b1882c0005f301e6d60f4b6b56315336c939c86ade88485577840954f4660504c423fcf0969299db68ba479bef80d9c1e15db1523edb8883ad9bf299b9a72c136543d2102f1292627401f4b5e1239fe3df2fb75530af6f820af6b7a481b345067b5a8340bc80806867ec7deab34a4225bfc132c737d255875725b816db60861e5e33ea70a4fadfe666e55bd7e84c7d464754503855f59c9a9f2d9270ebbf07f808471ee014bbdebea9a4363f69c1ef46676e3e95fadf56b08f8e6c63c1cdf9a14e844be0bc9d1c6b66e776667624db2d2400b213af9bcf2e17117a62d7fd435b70a701e0056c8b6e1f6a393f1c04c385559921d426fc8b1232f340042cfcdcc099ab495086f52ca6d1418f4821fe3b1fcc0d18505240010948e7a4b89d7fe24b81f3a55045c0f681a8edcb1e88a6c5e66df640a0e1b9c9e9a4d73e139a8168b8239d7b8039c95b07135d5cb7b65d06c1a60750cad01881911e35f50851441c413b37dab0ab6df2e3a3dc4edb8ba9aa179c9c14344d81a1c91cec082ee8dae0608d3417b073bae98fd04dede02dc277922b62ce3997bcb5c5bbd573e222c7125ae93070e0244aef83200a425c8643961724b56c039e1233e9f592634b1a1051ba6b129710218e0eb12641a4127435bf509fb78bb389ea049fe36960ead44d69212b437ac00d44ad310c0d52833f7a47aa8ba376fb2713a8a06dc6b3d0cb04b317d0a64e20c6af88c027519d5c2003ddceabcde27b5915fc964f59ada8095234a2715686c08aa093c325a84871bf7f18a86bcba6b5c3969b82229d673c182b09830045dd50c6292bfce9921a6d3fc738bdcd1a0c7f7848db4ab3aa2dcbf6a65d9167931010e14dc6240016595093954d762c6caa36eb49660fc58b6aa139e11a18a745be407bff075e9d21cbba1762a353aa93de6839b01808f76066aa0aefddbe03b0bcd0d1d205df9fa31dc85320e546fb919eae13165a6786bdf20cee1400a503143cf051b98f9ff59dfb4a3f48828a715fc21226600901dc93f7c9c4c50ca4dcdd7020727b05bf2bd6692007a2064ca2a12db4c3dcda955a71a99078d42ec74736c5101b5b9f53981a09ad19eeb8f035a6d6899b4b73b02e3f05340bef2de927efc2001453a2dfaeb993ac615b78c9855c73857ab984287e5ef0a14a5bc44c5ddedf306ad5d648eb4280037c74cad6fac5e15edf56d6201450faa790504a03dff052704 true +check_ring_signature b81ed841e50c42f03bacd3d96d4803240c3d8712e84655f129c73bc60fed153f 100787d555c2b802480d9b767427ce50dbeb6f6965bf647bcd21d9ada11562e2 121 a99905885d9a4f66e984cd59ffebd4f07c040333cc7cea7693857ca3c4c2296f 7b81ab61abbc984306894396cbb88dd37a5f38ad3dcca6af40d2ed7eba6bbded 97ecf7d8adede1eb9d16a958d2b77e81991cad49ec28c092205d31c9a212282a 7e7c6cc8022851caf9b02ff6b769d965e6d9129a6a1aa99f9c753b0a72f5ec0d 782c7353ffed69ff61e8f9615495ac66270f7ffd26e1c6f6ac64e1dbc7c6e511 373166b1400fbfb14a2653c348b4a4b693b827f49f407f4b59ab70d5c0799aeb d838815ec5edde27c33f354dd00ac0f180578f8bad7da15f843fe5df65575bda 47e5038f786c5c1696877126c54a1a7f5b7bfea9327ec7c936e2444e1fd97473 b0b1c89bb187b3ad3e9ff37d91dc9bec9acb2b3325ee013ca8c4b0e2eafd991a b6824454fd6f12e83a89d7b40532708bfd0999cb898e88730dccebc554edb9ad 74af945a464227f03f7289a78d5de836601aa2eba558ade619460578d6891d7b 774bf4e51675b368d7af2d175ba8f11b061b2e37ff3f3add08e87674b4cf4804 7e4d5137941bd0b1878be77e17cd1855e37f8564b3017852eb9d307aa16cca18 aa4618d64c94b8bee7bf68720a4f1609e4142018969727310fc30bb0eefe3ae3 5210f3ffaf98da5cfdc297670e8699cdd08bde1b75c580432bffbfb00ae7c6f3 afc2fb008fde6aa9cbc3d386f5b554b1f0fd1b7c6c8598d09039cb1068600b99 5c8dcde1b71aea687321f5f981fc06a9bd45ee91b5eee9d1df8f9b3709d06d35 eabf4fb764d29eaeac5594bd6cd8effe926aa83f15266a588fd77b22bb6a0c08 a66499c2da3998334869c40249eb89a6f44d5834fe5f294774d86151fda6172a d1a62c1f9217de30468bb277d5503782646812f6f0c7b8153646027cd31c8350 e8fe952c389532ded2bbb311c2ddd19d6092c22fb58ab13b4ce20462d8216a97 756a313245044e999731233922211f223b5df41071ac838ecb7db5eee05e10fc c8f979022cc9507ae0880911a88d83c1efdf660819078ee70dc9d6a03aeded6a 9c7f113ced63ffb9a152ab5a74850cba89128e528f5ad3db32736001cc269fd0 354c1ad7f3620c7129c6a9a1c8b828544d95eb8a71b3cf5117f8738d8d8251c6 0ebb1a5990f466130d64ec75009d4ce67b2104261cd96f7c56f1b6a42c66fbf7 230f68c81e24a2eebffa127d98c734b490c07c172bb66ad53b5faefc033af6b1 255ee3270370205ce675b28307c8217fd75a3f8a97d53144ce33810e09b3972b 3cbe26603abe7c9977bccb5e06fe8f397048f897a58179c0f046ae1939ee2cab 396c88f026ee7700651bad55f9177a87758de26da72c266e005bc937637020f2 85141315e3527e654d45aed38271b951da0dac935d6741526c2f991465b42cd6 e3bc9c1da54302daafb7e7a6f8d9d500cf0e9390e81ef4414a8fad0d590273ad 87a0351a5e84a0f27595b4e1ebed3d42ca4417ed4981e96c021a8faf82abf180 b5ccbe895915db91c9bc58108609d9d10b2b4d0a901c2002f71ff2f198ed7276 aa68d514a4cbcdf44dfa94e735e7076b0ca80ea56f4cf1012c09a67a2d6c4a39 12ef973fd0631493920a74207be7b2f542749ec6fb6421f84453065df901eb25 e18a44f458520198bbd51b0969acdc5bbdd13badb0c9b9a95dc3a47fd8daa413 86d57c42d6dcd4158b4a39a5c1462ec524d2d0539e605b9bcb857a5ba2a905b0 d747f7b12dd26bf56f630397deef5bc8accd175f54062bd51512ad06252c4c20 e4a484d1b16315ef24f1f81cc78f00f5682c1afa5be2305ce2d5aa4d97cfeaf2 901ab5ebe78e545f891e39d80eeb53cb2ac314c17d48b4b33ad9df9b6c98a39e b23f40ce28f0641167930188b54ba99dae03dbb96f4d047e7a1cfece8504b625 d77d9498a7e8b0410f825ec7747fada54297995a74f22b7a29c4b5eac7fbec54 505c10a987d10afe0897529c1d2f55cc5609edd9fe55e372cf30b9f6158a6553 eba67a5a3569fa32048ba352cfd7ff665b7a10b1092424023681f67c1b6f9eec f8f7b212a87075f65bc67e75331c923454ace73725539d16c5d9db8b2f04594e 737a79f00751ed6047ca3ae6b084a1a1a76cff1fd01f84b6980116a872639483 9f0c8c42117e0bb67ab333176e6758505af658511d776be6fa865cda0c4fde45 c2ad6a052008506c1ce8adf33fc3ba3d845f671a8b3aa57d05aa27cd6db6d2f8 5fe7a40f309e51b4962dd969ecf59369c58feb4ae970f8bb1de2e67cf9cd3e57 20b180e49a3757cc41a79860f51284b0d5ee739ec67f12c5db05c46d8ca10889 6b0f8965b38a60d07732d8bb79f42cc70c2edc9b9f7fec14b85d4954bdb987d5 85df86fcfde93878e93688ecf3efb7ffaacb71e9fb0e413513b5a54921130576 02678d48808f170d5334155fcf623e856ee4d495be3ebb1fa92361823198e396 bbe479178bb5d31c12f9648d3e877a96a45480de4c184f6f5d3c6f6029f73436 8472f6d9b5bfe8938a499f2fe06f4bfed008a0038fd618321d1f948a3c66d668 cb3cdbb8b63dec69dd041149978e34494e0b988f1cacdff457996bf4132f765a 8e2aded1591be6f51027e6ac59f2e62516e310971f98e1ae3ff1f644cd7fb70a fecc7072dddb352e2f7424b54bcdfe11438c21bd8340f27b874378eec11d0cd0 bc251034c2422557a65db565a59bfae22705c704d043464be64fbb785e04e5fc 7f5ee701fbbd3f45cd8114c9ec46f65ec35fd518ee75336d72d38e28236ad481 acd6f05e10d29af5ac804fdfba17900ecc160926bdc476a4f7e3ed8bcc989140 a7aca68ce2e762a9c70891ecc327036f3f3b73329184ce766dbaa8bfaa9e52ae 0862699f959c679738f0dc9b32fa0d140d33682b3811b1933c680228c3744cf2 440f12183de2f5a52b49d7c282e86e4f70ec317bfa18d8b51b378b89f83dcd97 184ac074b3557e0b05b837cb9b7cce458d4aef4c69f5d463477e9fc7263fad41 5f57e21151652e5bb398b03b86885a84f5f7d412fe78d3ec70fc84f59478b7ac 0a9647811948dafe88869538d8576c20c4aa2b52a4b37c45d222ab839a80d520 3d938ab98e2cc620bce2d316194039b28bb98ad256f9d1c013d67dec1911cf81 d1be725f31d204dbb27245fa9b7d4cb27bba8a9411754a1f0775382e0a273dd0 341568fddc9d7b2db2aad21751b429ee9a672cf70480bd686cc853388b12e3f0 200bc5a44c2c461e3d6ebfc7118c10089bf0c8b26efbaa3127645971df6555c8 c59252559490d4c7204fe51355079201c6f70661853e449c6685ae32e69842bf ef98f163e8ed3d500a9e88ea8940b9f51c4a7397c8299ac365e994c0d2b53afb e519c2b688f63b6b0eb0c3e24aa9b7859b47e79e8d22ff7c3094837b1142ffde c73f8a0f5c818becfcce6e23ae19447fb75c349f84438ec13c15a707043797d5 4d15f91ef41b816390b456e629d8759406ee4d6204bbb7e0602e12028753e88c 3a9c344848ba8d80c66c257e9bdcdfe058320d00936a2aa42e21ac7d21c6c699 d6b49521d15c3105bc6448998157019025dbb60fa079c90be4f22dda83ef6e17 44c90f86041560d499dd503ad18a1795e34eedb429382aefa27d60010c4d69a6 de791e23faeb745318a17863dbe3a831f32b8ce817ac311a6f2d7838bfc63216 fc06661cd479b3eed5de2d7e077828c96667670704299e8bd4af3ccf7eba851e bd63139c1df55ba714c77ae889612476a6dea157350b8aa1c43f62fda31cac4c cc37a05df4824c6f92d863daed22116ef374d279e4ef779e3cfb76f43c79b031 12630efc8f3d3949af257aaeef679557187f8318fd335f95a70cf368ecdc495e b808f0dc2708c0f0f3dfc290905aad9bbe45e2fafaa702abdd113692e17d2e1d 8884104c71b7a97b276e3cb559befaff259b680b89cb39e57e65640286454cbc acf7ce9e05d86ab4b2c7e859cdc68aebc1ccc165593a2ae079bec57b0811adcd dbc8d830cf2090a26a27be8104312abdeb6461505000f3ff75876850deba1b0e ed9da0032c3261e7dae501c55f5176494d95afa7587d05ce9cc208ae51ef98e7 ede16cf42fb4718ed24e3e0ae1eb892b429809536554b1a238a99cdbd1695222 4a5767f996b0754f4c8f9ca58ee3ca11f88fe03638716a8ee5bb1d0c4c9a1969 d3dcc31c99be3e19a90a36b0c747f20e6531f671d6ac603766c9beb01c5b4c14 75946bbea9122b4a11455a7a92bd2cc0cd0a2007f497d7b9fbbbee2ccef2eacb dba79bc92e6daf0ca524ac2d88bd0cf6276f34a9ef7c8be508608e89bc04f507 3c199c5450f1bd7c1a05ed1d82ac6f446af209d6f7520b10f96108038da320a8 3d8f8584a29db91ccca727362813d4239f3efb3afd989d1789baf965ff804e7b 359f19e241bc8757b415f79c1436ad63b46cc2a89ee9c008cedef126ab0db707 3612f361124d6433ff73bb1b0e9587186b20ec23d4a3b61f3d0aa7a49fe21f0f 21b123341ed425140d64e4e0d4008be823a685b8a657f32b7303da53eb3b10b6 ea3a8a5ad106ed47b7a960022e1db6d0a486102ff03414bff7d1f38276dfc874 bd3669d1eef37cb40d38a8574639d8afb24c14868674140823c6b16d11bf965f 2056926e15eb88cadbcad8d83950fb76bee42e6d40eca30bd98f3816dd443603 2de75702f24c6ef785a3d9834b51a975dc91cc0bfd8c2166d242c42f2330b167 4451388c1718d234e5c2b77b11125a49ac754b0c1183ce5a94c8217ebad91134 020cf35ad95223c253c3483c2246d35077518fae3e59298ae00a71290ca24647 862fc51377f81f519cc0708608ef45a63975665f43bb9486fa381fcc5c48471d 300c27589700131693bb352515f3de3d56234356d38768d456aff6037546e8fa 18b87d21d54b5a72bc061e01b03865f62aef5fb588e89cf19731b429591facf7 57fa7a5fe26494af14d1a1aee7c5206a788028d7a75ec3fc1c16f3770a71dcdb 506b60b991c90c37d782bf6241d15efdc71fe8b723827c567c3b6642b74aed57 7bf5d876e365cfd83dda9694dd695e79125b0ea178317eb2cec2ba6d04ba5e8b b871e119aa49424c56ca1b2841b943eaf5433660f39d77ffcf10c612a3e262f1 58126f5f0c503169881cf455b7ba0a6e560483e583fec1d629bb71852371c1d4 646985d144952918fe55497d8f39dc71709359c4c49254838b7408d175b1467c e57d8deb9fe93d5c51ba1c54cc954fabd12bad943438296317cabba1fbd064f9 dfebbe226306623055bcc0c4d157b92e39e5d1cc019f45e76230910ccca5e0ea 5d12ae55852ca6037f075da6cf8069e3e75cf925b53196431d90e4572d5d3b98 aada941bc3ce723ce16dc252f837c292c15e816bfbc357ea1ab3e4ef203862fd d5c0dc39752a48e1416ae009af877f4612fc218b5ff13023996af6958fc68387 8c4aaf8900dd816947e8de9417447f7ba72578839a26ee6dd825b8004a178079 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 false +check_ring_signature d0a2cdde7eda39f195cd08d30f5ae7fffae5b6224f164f3d8f0cd313cd0e5f3d cbeb01235ce4c9f93cc3988c7f7c1fb4ed5587a663dc2f8bb115297068f1cad4 3 eec05a6cdeef77c9dc354d9da1154172174903479843f15ebf3bd7c47de9adec 5ea782f8df7ffab84adba8d0dfd72dd549f48a4f1e91827c2121fdb671ba94a6 ba14fc7df8bcc60e4488cf21153bdce83a68d628b925f0c4dd5f6a155b7aefde 2098a2b85396ba3a27371deeee6e4c8dea19124c56e3f3f0efff894a37efd90c1d8ecbc45831a6d5ebf622a98e92a577f6672d2f4c2e3682ec1fc7a79eb9650b4384a1ba84bebcc7548ab08ab9925f0e314704775b64d12da9e132cb429987057745d473686e79e8330ade45e0770e0522f0d0f2f53ed9fd886ef3765f532960b2f7a8fc8ba6dc7143c0aabbd74dbaff03c06fba5e6d2a487a3eb69b7fd6c904a65f4ac7af93dcfd2c5e644ed160c68fac346e5dab70e3fac697ecf1a075b106 false +check_ring_signature bac3763aa5d8ca6cdb3fda581efc0028d7b3115157f2436867fb0688eda9e728 12b4cca5e2d9e97fa2de3df57e7eaf23a4760a2a56bc9c6b0a3dae700b0d89a2 6 6c094d89453111393a46b5034d8af9c6c839c1149ad7850ade96cd2c0ad515a4 33b36b8f80e05b2ccf4b0610f3c5f19196cf91e20516690d2f8d7834a92a4073 a74f6b41ddd81fbf4bdb9836f292a04b675cfa785443ac1c8955294fadae3e9a b52d13a10eeda475e1f015037f092c51094c04eb277e310776cf8c948c85d3ce 1f5b77da48496bae4afa6075505e31141edc12d94b795bbbd193d41d09e0431f 7cf325e5bdb04197b5384e6e945d911b4fa2c981512e889902845fe21c44bd99 da014c88ceb75882dae24e96b926ecd94f225d5cf2ef360ef7e5d1594a2eb00529f3b8f1e8a81bb9c337b6965bdfc6484b20868fa683be58fc9b5841daafb50ce47dbc50b91eeaceadc9ff76ba0922e35d11c24836cbf5b1861462160bf1ee0eaa78bb4d5b6e0e755a4d0a093667dbe6ff69b06179dba3ec030d9b8c81a1b00e9af6182fb2f8a8e6980eb56c37920930a8a09661bd7549be622e093dfc7c6102c5f828642054a1cb11a9aed656a56571ffd6684da41c337b6f5e2537340f1a0bcebfd7a5683cb9756af4bfa2c60597528e9986ddb224d38cc5324d8293681b0cd7fdf1d54825f6876aac7eb0c9689038191f93640ba4d81f6f7dd5c89bd3f109b81e36bd72883ca90ad8b76504e1c67e7df605c62d8197412da2f12fd61cba01ab11987a3c2b20e6b0a9719926144936f0ed79ee9ffb035a87d7507316adca0ee64e5d07b40c54fba286496c9c2dd755d9d00b00cca6cf5fe433ddd4341a2002b336f5107a64697ee29ad5532826159e8ac110032fd857e9a5e6e54cd8d91500 true +check_ring_signature 93ee054c86f3977d758b21d5d5e92fbe2efed228e2ceb0ddf6dfd247ea61ce8e 36f32fd23aaafb344b59462c00dd1f46c0d59aa5fcfcc5f441ee21110ff8f6ae 12 f4b779b2df9fb7b39c144b3a1a259d14ef602a70a14731a54f90a9e73707292d 8fe4b5c2a1c8f6a84193d964a71340835d3318f7fd4c0acaa2eb254a7ebe72ef e2f6a7d3285ad40dc5fa1f55c57590498641057c5e8578476135f386cd7e887c 4d8ca80b672be349a7aaf535a57481517bb880e4f5693d84563c206469ef6919 07fc9522e0941d166e08f8ee485b5f42637034c3eb0e7ec3b35ac12e86647f6e 298ee32c2a8cb6225f474cd58fb2d273d51e760f6637fd3f2002a1c8541f43cb 48f3fbcfd035405556acb883bdbdb2a8ad12319e46f99df5e4d50942681e55c2 5574daa008f24c04bdd5261c629196dbba9d18e84feaabef80164803e5293863 50ff6b25d208de4edfb757cdcde147256fbe56250f1333e90043f140f6d83f01 80644543a68607f2dca056982d1c9f95a546c592194a25b31d49fabd1c6aed44 842173502c3b0b6394ac3416ac731e42799d29edf302344f5a726c39c3ec02e9 ddec8df0196baba4225b225a18bde8fbe1521ff1cd372070aab150da0f4775f9 121d755535d353b3746002984fdb3065fcb3c592c4824e0e133210c2bf59a3074f837fc5b1d4d1f36acf409e9cea6b623ac752f81a3287e382b848e6d9bcf500260b26c342b538357ee78bbf3c18a004f719fda4fd334ddeae099531c4481c0ebf9eb01ca5b64b285776a4350000b82ff015b66a1b8a1989dfa0b3161e0df70d084d5faf053444a93c47628795476083269d33633d7d9e9ecb4219d24006380ff585b411c327b0184b5abfef6812ac73ee10296c3533d930b5299081755d590d0e65e11e125935ec45e1ac9706fe1ae908e11824b6f0fd01a347f8cd9082890ff9e8ad16928310b37c81ec66da071c6545339753a4c8639a3935a1fc3c40a40fddc265bc9609a763ff53646bec7e9f97d445cb6e9fa3e174b838971feba3ce091bb582a365b2d9a7758d1dd37b5f4b84a123c958040c0409d606c7b2c71e4f0f960dc93e321d69f2c18ce1709b8284b2b46d72da2d37ee3b625d91a8fec3f3097417ac6a49a0a4c1d65698d014491994cf3bc78c01f51c3b03062dac820f570372bcc53f4ee76b144b5ed7d06bf5ebd1f1e2e8285fce1504da652487fd4bff079d8ac60c8c8dc092977652f9979961cb56250ae0d8d305a0521fcb2f20cc6c099d3576f1b37ad284e309369e84d9059d1e2651ba6c4af3dbe8acc0c71b8dc604154cffb8ef1c745e9b3d74e55512b33a05ca0ee227710c220c177ac01bdbbd0ac21268a71ac684de5445256f9822a842de6dfcd913b9570071e93c3d553f0d0c40cbc8a8009cbe6771743869834c172f1a9c3ac20b9cdbd70162814117ff5c055a5fc90ce7b853260f8604385563bef48d902c2f475facfa06cb6b0151605d0749f213d2e82a926814a862c9d9017d072174e61511513f676393dfa4f07ace0b66d6b5170b47e688d8b2eba07fafd1aaf045197d5d121c9f3584ff181c48ea03c1a62f9222f267f07eb011e32704b597dee6a7da7a0c82ccfdb86af0bec59c098bcf74eb567b740652d3e7947adea9df48f6db04b3abc10914928d0bbbb65a06743d1ff07ccbf77274b289331924627f0362a2f59b93917dfdd01839ea859204 true +check_ring_signature 20e479abd0e08dcec6ffb6fa10ea8440bad7220b9f9a5ffb54cc084e3add05d2 162ad880ba72d17235ec11aa9fdc7bfbd5ed7768259a47b6beebc1a172c05ad8 1 18e709f27929de6a4b00b36874b4fdc027a681d1f073058a5be77af9725d65bf 150af71409ebfcfa9929ac74ed504d056ffb5bbc886362f17aff0f3db8e8140269cfecc67854b588031a24ddd16b6deb6f8e3bd4a072ae59a27b538e23206c0d false +check_ring_signature 099c11991ce8ecea2eae6d7731a264717ece178a4ddbbf5750c03f556a5ea7cd ab877a952c5a45043d5ba268fb997ee0c488ccc69252b31a90bf6336145368fa 2 7cc484c0feb2c01b89f37384fa0370ae2d05e3de06d6a3a88bf5e9d4038f5c65 521fb81dd04097f84701f23c370279b0ca47698e8e13a4986ba0f1dd945e9c70 494114c573c6e8bf76e309702bb92bc56822fcc539f78f736212ad41a74965019fd8dc43939a0d3a615e6d8166314792eb44011a570a104b67d2fac45be2280ecb48a5996642cbd26a15a1506ef581bceba6fda6abcbffa80f0fe81160511b08a52793659744b27be50def208404cd8ce0a9f4560dca67bed0f0f923da5f2507 true +check_ring_signature 35bba00f445a76479ddef3fdb5f130a27503a56a74c25011119ae92c120fb809 233d68b552455438a2d01b4b16430d78bec863ca85b824eb29dbe73256e209ce 11 3f7bd5821a93cc7899f198e4a0723a5dc2ba3238b6aef4efc51e2a29673709b3 3abeae03ecee64465c14c370db5cb1ce7f8d53bcc9b23c4b19f748abf3c70254 c3b3c12e84a239702aeb9806c64acb3b72d60f30ed83059f9cb3adde28347d90 2aafe58aa3d258dd67c7fb05328ecc2d6022d53dec91a3e83b311c41d3117e48 230f03c04a4a810daea4cce24a87b9e4dbfae6d30439c46f4286297951a42de5 983666cb284f727537146047638f9f6ab7e44da0b3196e5151ec89c7332399b1 29a2ce43a9142a37aa29caea09a59f2671a743e3b315c8b410a24d2686028e07 59c7708aa31539c921542c516583deb51442688bfa65528a708c78e9bbf1e258 572b58ebe0fe33dd602996dd28ec66264445722bff6bade37277c869b766d68c c0117ee51a3275a918ac4ed50ca183333cee56b1afa96c839dc4d446a4f83edd 0e1e931c680049ff10f26acd373ca34db889bea55691d923ca1e8c2bacab2448 814f1961ec9c9bc07d83f42cfe858173c8796b522ad502d98c42729b6278de0355591c2298b68f62c881ae71e77bbcc2f35c1147a178e07ea73bc06134666906ed1c11a80ea0afe5cd6bd4e8880e973b3e798ab76528b0afc6c25e8ff2f2170a9ddf49fa247451057d6acf84d5684c674a00296715c807d33ab0322b57a7480386cbde3aeffa8b38de58770270120b3a9943a36f3ac98bc37d372ec5bd7c990836f72d7776095ec2a55b68cecb47e7ba8a938fc02e11885de9ecd94fa302e108058e5025c1b5cdafbc25ad758d754936cdf50dccc758f3f95cbe8ce3fe94d80140c1b5a600bbf70903ca92c10d996afa97504a536da30a5fdb6c2009f454db0e0356888d2a4dfd6a5dd1575f8676a9b17d073f9124dec2b2760e6765986ac60cf4c7ccd87db10c7944351698a0b9667a0c1d0b8031f9989e157442274eb06705fadc1d420cffb9c006d41f1334d4c12a99fc86ce65817fe3922e05df41cafd01d0ac4aae0012d3ac8b4ba2665af9427e8566b2f21a133037b3b897b29d34ef09acf4f920570101c9e8240d27ebfbcc2bd7edae7215b0e4a408ddab803d8e1f02b4974738a35a2bfcbfc1121857047e4e9992af5f78911b90ce4ad2e930de9c08ec75f9f4e0121e584678c3b91877535e06c4054caa5a21ea9d95733ec8cd9b007b25010c43c975ae98a3df5eeb8e8da754d50e19545078193a0bd7ad6cb44003a92d2d03186e1d777f72f31fb4c07e93e9381881da6220f615905881424bf204d97a2e4e936054e0e13c08a43143f973b6b7dafb80ad0518fd9ae23cf7cdd5040998c55682e8033b18501fea75aae95987a3a411c80e2d01074ca877274b850d515a2d4a82c7b2ef36f4a8bd640204d3a7ba80e7c53626781d3f228809752005f07650fee0c788fbd1abbcaba97d8783d51c7b9d7e31278288546b3bb6e7890cfdd44c9230dd3dcd1e92a159de7cbb4a90c0db11217cc98ff028d1397eafaa06 false +check_ring_signature 073adf53b98b7dcffe2a7ad02b3de59a37960219c384a5718d52f2bc7d97e5aa 2e309f3c2805d4b9b6d307487613c438d487fed595e8c7e1ba9ffd5fba7ab1e7 1 efbe1f31fea3c583bc7e713c2259b2dc6a2a1708712acfa5f28d55eb0d61762b a1d087233c8d733b01003e23483d89da3d04875667d21df952e12a4c956b490514a73d513871fe301dd7da5a7c404b0a5092ee32612d182959bdfa8424035cd5 false +check_ring_signature 4f3fda146c22b590c79956d55bf9d9863bec8115855a8418fd6fe11d124cab3a 71c3ee133a1601d19018286997dec7a8ef58760fb8ba0e222613850aa6fe9122 16 c2d06f5e918f925f5bfaf487fa61fd5f2ace42fc24d7a91eb01fdf5b25a6b451 815e9742396c225213e7bbf7ab86ad68c86378f4ba1e3a68dccda2638e3ab7de cbe9f9b445764042debfa1719f75d8c4b8b6b19fc4d0f6dc3f108362e502daf6 1e5846b0789e6fbf657e5555b6054a8dd08c82f67b0d72d806b85fb36d20b3eb 1c0cda03096d93e77ef4b5aaf3a47698b5d1e6ef80c17db0fd770f868be2ad76 4677071cca2e2dea56537122831833758e2565590d53aaa6e27c28ce3dc6836c 3e4d17e4b9474a6fe73a27176637761496f17b014b4ee04bbc0acfa24a44749a 3243b449826baa8df9cee8c862e12dfb958baf204b5c9ca1d63a117ffa9ba0fa f2b6fb62a3e7e554a322c500a3818c2de7f61f9330806e14bc79192642707ae0 bfdaa0790d3d58d2ede8360c10922e1ce82620f94988aaf21153e093bb4819b3 8fc41f1814de07df77d9da97d8550c4b8f0d6ab93f08c4779cae6feb09624ecb 13bc16343a7c83e248f978fbfa98b838388bbb69465dd586e111337d8c4b0924 a6eae3d675ca65fe3ba45f6e057ab8ebf6aac7303930edc4843f6b63600815ea 1c57c888a0da32956c5352fc27cb14639c70dbc02e5115ea593a1239dbcab19c 853e493534d02e8a50c261b7585f98ddf341a87af0c4d05bb58d349402075baa 4ec5ed816fadbcaa2e3bea0f639b4548a229e391ce2d7484b4f3dd6aa26248af 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 false +check_ring_signature 680cd3102735e93b656f9fe26f9f8d115b56c5a42ca60e177da547483251a777 f1f2204313fab5410127fd112eda66790846565c18f7528cf7d9962d549a3236 4 66b09cf390898583608662c2d46a257fcc1b83d279bf8fec9ad609c2090d54c2 b286c2989e36745422f0a9b0d12a40fdd012f362c33b08ce2dcbfb80af887e44 e6b2b58737149c9c80be0a5a5da3dae9bb22dbf9b894a45667d74f5fc49fccfd 9b61083f20e94c98ba004973ac38060cc4b6beb6760581adbe4565c6a96c48e3 d91c7ae73c1c7cbeda5671e2c902826639067b841e270196e2e031dd05cfdd0dac56cd4f99cde5d2e577b07e0bba5bf2c1e75c7c97f6ca4a5c1801e13c295d0f9363dc93d31b594ba036effcd744e932974cf425d0767801aeace95d0f463205d8e9c14d943238d164af31f499ba86a3627b03607023453d8e520c85cc976207c76421b98c8929668b776090dc7b6457b54d4e18b90d3aa4bb2adb7e768de00c8ce530c942093a0a89791546b2b3d4db02c978042f9a68b06727f7f7e5c7070d67368f2ab42ac084a7085851dc689cb519ba88b6a69a37ce970919fad2747a02d703ca4743a31be41b41a4cc482c90a2980ede690af377483675e37a2b52be03 false +check_ring_signature 34a04d1cefb0509a2e00e9e16f8ab004fa588530758cce02d09de913c6b02705 c352aec829fc2ffd821c71b9369cb7fb2e217d0af82414389d5ece0150dc4e3b 2 d4adf47fbf5b817d9e474f58ef06756b02e542db9822bd3797ee4ba12ef0b0e7 e9d6c054eec177f8f90b134c60b5aa0f2424e6204c046a1a0d53a56e0d20f309 90c4216e7f57579363c7e951ab959042f12bfd0409f5e681cf9e51c534d26e0f0f92e85b7612375ff7a75d0c34020e6fcf452ba44eec25991322920c5781300f279ea050b4b7adb09f83bde7663a8977811f2b7e01ce6bb56cf17f999f60fc0c2095a10571460b81c5b9a289d03fe4b656cb293ca7950ebdde8e3a312465df00 false +check_ring_signature 28cbcff656898d902b62b36f1ba67f64c1809b2bc5cf63c9ca47714f845a705c e3ef7191c8004c2087cfa026d9c64512ec36026640d137c17a92de6c42c1ec7a 6 c07b21b4424710c522b8e5bca568b619f77637025e91d01833efd1cd8f9376f8 58940cc506db3453ffaf9136fffd86d7e61c6c110a54962a5d72d48dc50bd8fe fe6bb04fd0ccacccd7ee3be054c450bffe7c4f1f92bfffff5e2fa68558d3c146 33f4f5580fc3bb7b792628f9c871a41f6dce805c2ae9a59812b97ff7cc17870e fe63832f19af9161d5ef1e7dbff7cb187faff3cb66f081323739f522756cf137 9ea17e91c06cd80bb72dc146edb95bb23579327eb72b0119c7a6caf992b305a6 ce799e297f283afcf93cc6721ff2dc994737a71626ad25150ca4adbe181ad90b4e844c956275cc50c3937835b53b36c8f239e7fd9887147745c4553203ddd6078151455c019051a73a7755cd0657dadbf367b118bba94054981227289bf9274e75370090e24f7628d162162b1370c31eedb7d5c6c22c4d86375d73c24376330f5b5c4ae6881fa9564898114225c6f2f92f6fc09804c4635563dc6bf59e71c104f584b0794485561a35b3f90ebca65167fabea5688bea9683621e5bbff97e1b0048718aa0df6d6d2cf96c54a69aaf2040ff3cb41ab9686fe8460d19340873b3091b897e3b34a3f1eeeca0ca065c2cb77e703ee6f2e628ebe8c5f29a15ab175c0a093696378ef36f7ed75ffd802337f7816fed75f1e36e7770289af15a77cfca0c2c0789e79d659f304d92b922a78ecfe85da5a16b50edeb433351fdc3bff7b900e0089294d8eea252dca5c6f2c9115f53fd251eb7ec3f4d1e9d35818cf4eb4e0194d437431337ce64766c8edaa82139ef937d66340df671a03e2ecdee701b540c false +check_ring_signature 3c3c359c6146c4258b1d0691c2e0e95c6dcf920ef84704ac81563b2bef8d318d aae0574fdfb7008d65ca33c9cb9398e985a2362770d66610bbdbb32afb9f9457 194 ba3683878149012f1df0f9b0ac53712bcfa18c01b38655edde95c806ecc287d1 f7441cbcfe944e34bd1a531db14f2d960d2a7736a9c5b87c69066dfdb015987b f6ccb21c90676ca843371e6b3c57032debe5b4839c84e3d8ff4718878dad8a14 cb3a75af1072359a0ac3e8e16d07997ab3d23a3e6faf274805ab0e085b0b45dc 601a99f07b378f1c50011ab7b15040e74603a5d34d0f525c7558126b8c0e2d32 dd9e40fbc43c0cb1f4b7ce7fb56d518b15c10377985e1ca7cd70510f48af63c7 af27be689d3737fac749ec3b1eedc415c47755a48846eb02ff757e6a836d1982 23b44827876305a49928b0b31d26c332c06ad1e502cad8aa4eb5fb8bb43db018 e44cd0663d31816a50f022ca9b854e6bd5ef67752db88fe07723abcb1b8e99a4 0ff209ebf37613f92a1e10d6cc5a0c4b16b95ce0842b0b8656b1f440d4ffc69a dc63d6185bfbf416c24c077f5f859f9688af226bd0e688db15d562542689aae1 e1b49f21aa45d15583c8b10f2f5c25dc9f3cf49b1359bf9c5716236d58388835 48d9f0aaa512fe25f13fdfcae4f8c411a9131dce06abc0901e00adc08ba2dcf6 be57dcb7ae2b8924e04ddbbe256b57a5ac9b47d75c1433c34e6662cb2195ebc7 e4dad6626fce8618a3d8bac10730ebc51c6995a11e58f780226ec96afdec20ed 98bb0e2e65c49d516ab20c7c5222a25b3e394379a19d88d609e6e5203c9c2343 481bdc221b133d71571ee88f34c2c85a2619844cdf43f6c128e1cf3a7fe3562c 1ab1b78c1ac099c14c3e7c3cda67d03dd30658e1eff43db68ac70161dccf3328 834f4614b9354de9c794ef3e31e01d8693abac45e37b8bf16ff25c522c73d7ea 469039f9152382821246a90559175cb3ab207e8371a8bdf971f66bf4f4c671d6 26be43ed8d569fccccd0a2055485d3a7596f4f9238b70511c92cf22cc4558d41 a7cc0187226635a9a1cd5c33cb4476af082336b589309f0fe66b87e486fef224 2a2d75179e56a0a914087f331d7ac216badef3059651f4f2a9cfec78926596b8 09ac8acd9f7cb7dc54d8dcf048da1741913194d8595ac3f11c90e2d3c239171e 783333cc3d6601f6b36ba24bf9823a25fd721c7280ebe7a5c48d5375c68a79e1 64063763c32020bfd18f43e743d96a1a1408c9a0cf19a0b9b9f1d37f2181d914 70090c28d3c6c680c39871eb89c99c39d8e2ad20e92cff32bd1cf5b01e9a01d8 c505f48220a6bfae492381617ff8939ed8df02a05f5cc066db72cf2c1bad0b19 a1cb2cdc800d80858ffa8bbc6689a7ff092baef9fbbd8a895473f20bc19796e7 4628d547eaf7014fdf586f6dd57d6531a5906ddb2f350451e9e148a87fe98593 1b01a742f8932d7e58608501f4304723f2207d6f348cd85db0d81e98b32df486 0d631b24d530c30a08e8e08b2b01969cf9211ffa033027fb348124673fa4ceef 91ca998f166ff09ab8603b9cc47a2b6d6ccb76f1a4bd07c0f46542996c553f9f 411ff0d6cf362df01f2e59c5d52c13b0f26da0f8e53e6d60f363a61b1f5debc8 f65b57b8584198dab1032bf37bd477eda1714385223b135e001de737648ebfa7 89934917c961e7532a765051cf989444eca94fdae9e19f54f447b0b651828efd eceae7fcc3dd6540ecf30d7ccd8d80454a747a814813a6e7362ab89da1048481 cf3ec1d67e35fe7fdb090f57d0c1986ac3c13b61d3e6f238045cef9ab7fb1908 079e0760e2543cb662563bbee50b13674a5d5695d3df47ebadb411a30adb1604 c2d2acdf15bed5a526906ab3eb23b92172c9c594295b97d632694498125ea9eb bd4eebc488f185646a44b13af82bb29497eea4ac30e583d0f2147025daed5348 ce952aecd974865b7ff922d688faf11b76658235099ab4b7ca9bb4b658227254 97d9499281e26fed656e9095dc18529b468d8143f2b5fe9bd580104b1d65e49b f39e4a22c6af321d973e5112ad5a2e2181b8c5009e9be272389c16c1c86e18b7 062e8d291434ae5ea121e4bd03e3fb340880e5baad9db0b9e55d7cbdf9c4850d 76b45e296b5c43a114a8d431941e3aac81179d0bdcd2158b9d250559ad837b13 1251583656a6542d819a74845efce7e098e8531d2c188e7742d83435ca580e18 65168d8a8843eca5655ebd50e07239f30b196fa86749074ecd834ff50d3d8922 ceba4a2512580aa5bd69b5eabec26b70aa8035f88bdff9cbdee79dcb8b22a67f 786b7c70405d4ab9fe8bccbe336de56e96540bef64d2202893dc0b02e002d60f 033fda4f260ed3c866f22dbf3501dc4ff49bb2930f15bbc653d8ef0667f799db b7cbe04f7aaa29e58608e88809c2ef95dca09a9a0fdf6e605c40e38cec51046a b8c56e3a26ef65d48f69ab0cd22c71f227614055b405faaf1460b54fabf63635 655a5578034bce715a2a3fdecfda45a31cf7a6f07115885741f8a4fddb126956 7680027587ab0845ad8b53e4111151dc75e2fe999116fd4994f543bad0e15495 4f8df475ddbc3646deea06836bbe63fdfab727c67770446f3f2448ef3f2e8807 d49e3a978e39c65619fc7a7a8828c510173cdf89e2b229532dce697496bc4220 a451a61ab75e9929a100577c83e97cee5962692020e1fab7c669bc349838bb6e a271f640a3bfd335f8c035a69096f8cfb9339c0c91295ba2cffba8bbb1ddffc0 5338f980900787dfdde365bf3101bf7e82e88be188e14a146a4b8037abb1cf6e 19448d3aa32ae852ae49b8b3d77f7f7fe972f2aa77255194d510fa41f5d5e2de aa08240621a2e6029d3d0af3cd208e1502e6d5de0b1a743f562baf16b4f17ca0 5b441848c538d3fe6444ff078e95f516f57d44774b359250a5b08a73f9a889e0 5b3d86286128c46743285fcdd1c2e272c1ac3277b2298503e2206ab491f72257 5933577ff549cac90042d4dcf94c0502416036dba256c1e50bf0ed08cc6c380a c6117be1edddf3eb6fbf3264587dd498956dbd248e53bfc0fa385de3f3a099a7 e63de9d54082acaa1a487768b2c7ea7d3c0b82beaff8a63838f84290a4c6a1d1 8db1b9bf7d65f655bef1281bc30287333b4b271c913f9f6f829d54ab5f8b28fd 35e947f231c2c43c9cac0bf1c6f299ce35076ee7bcb0c13097f931b881b80e79 2f1ef3501db46224d4f06c3776a69c24cfe94fe1b1c11086aee53d76e7b9ed1c f8e75e54900dae399414170fa68218eb53cecea287bf70348f472a1e6ac8c7e0 38c1bd2a5e331c7626dc0bfca7817cf9b8221006cb5ef6706b5dd29b60f686b9 d253de65140a594da678539cafb4a7edc96d186618505c992ea62ff42a5f3d07 0a65d330894826b258054d270d689d334e5c9f1c2aa2c74995d7200021154580 a328fa7fb214cf2a3d59982297deb3e170eb824adc66843cabe5c376bdff8dd3 ce8b565dffb6dd6f6d13e631a0851d71b4c710789579307bb32eb83655e67dcc d6f543b91a34d2c6f51013ac9bcf5fd4255e4e8982e0e9b6becddce89e3525f1 323690c5fc0166a2302337e21c600757045e7bb0dc741220fe38206b17c23934 7b467c78aafaaf31bd84f0f04cac7901bc34934f36393586196039a4ec77764c 29cf35b7773f0474f6e6ca385823a495a46d5f440288beeca78f66e0dbcfc60b a24a7c9de69c0b6d0979714cc9ba1a4fd6dd6d304135d2f2ccb2d6293665dc31 4e04f87585f9e5f76fa3ecde972f05fa238515fb9ad18db46b9a408ecbdc8603 ba60304c9bc330bc8df853008c2c26621c375c61d06ac30d5155e73519b6ba03 d0701d7b1234385e9a0370c184cf1cb348699c3709405190fbcaa999d366551c 56c7478bbf3c52c7361bc934d78e68c2fa3ec55d00e35bc21dbe72297fb5c780 5a1c06074b1ae2fe8669e89e4b548ec9c7ec87ca283b2a5f0fb336610d0b0897 443542063ed67d8f10df5576f34d664dbb2f78609ec617e0f1bc9c8ebfc41ceb 2ad53d8deb2fb787766c922105af9e784d51894630fb9e53774de00e20952593 8a6a53036eaec56687faab31ede2876d79a41940bb208c5d23a3428a7e3b7dc1 371595bedd1b3f3cab07b71171062ceb131765a000f5b45d2f1d185162f9c593 3b5b21c7064d3a233ba4a6e3f3315f39a9270470a6051627e7cf42492b4c4f67 a4ef8545e34608502e52544ac1ff69a0382634725dcf422c643893b3e4ab3157 d6d15adfe0971efb9ae575ee6dfe246c53755550b8af064ae1fcd6654ff76677 a1aa527bd964d461df66fe80bf48aaf8ab0bbe72d5c5ded9ca3085e49c65369c 59ac00a7af56f60077ba576ff5f4e7cd69accb1583564b49fa1726d8d4b6a7a8 c8a01a7129538488f2c2b4130660ed0b12794a9e60f57c61cc880705dfd3a662 65e194f0a485236c203be2223b602a3ff0b5ed24e413d67670972312122e0eb5 9e7ab63f43ddac9667b92afaabfe3b0ac19c669f263fe23c4603fe380198b110 68cb1b57144bbe65a99f1385b6c337309e8d0289d729ce954c03991e3e769abc 29f349d5d90714f244545c31f836a2d6b45e384b19c3c456b392ce61f890b3ae 5f075d99b85fb31cd5b8cbe7f94a3d67eb41344425c4b580fbc12e8b59131249 c3e1c271069e1d160877cbaaa79586afa77cb75278672cdc80b1de748a7aee9a 53e1a80c92d0d8e90bae9e06b4f4c2b50cbcfc6546578f937d2200444e69a94e 1f0dccccdd456af5e2b7d3b448e5a8505f919332276c38d71c1a30bf98d36fed 2acaf8e392d328e7220dca0ec0b89cb9d6bf76fb4b121439830cbac9d41d1466 63b002e8e2d9e7c2d6ad572e2c82382f435d562223ba90c908db390b23595142 6368a0e1b0ef95785291f0232f60e9a575cb8c94269c3d7532b1efeb92d1cf46 b2561b47c05cf194acb8cf10a87e0b13a8a93f8cd5ed7627d0d1c655d37b08ef d3ee4825bf238aea36100c7fb41b15253db3846b3f640d35d47ef862cc8762dc 907c60b2bccaba1bdd20af1799d3a9c5c5d24554b5caf7fd4f27cefbf7a5711c ee51109e458c09853f9a71782e5768ee66cc6a54a00f404685c602dd3d8d2295 1278bf718c437697b905a4d7fc96cb7c4255f59c16945d8f3c49ef30948216b1 5a489e26bdd085483e85a49539b8a87f9049e0ce0da919ccb9ecd012a2b42553 2db92f831422eaf94d9867dd06d1d2fd4e25657d2a8fe0e44be2500696faf538 65b4470f2935312ebed508238d1505ee5624be19a840e9c0c0a9db21478fbf2c 5164d0cc50e2241bb58b23dd89645c457cb406a07f13c3eec4a72063d4b110c0 1718cbd094d1768b6f0c7573924350dcd53010b23f77d669634907c680d6e30e 0009e8fd8ba1f8230e29ef71c71e2fdbc95cde980cd10ed3977bf0d16c3c6487 17d471b555a73d7b9771fb9158e3b55cb59dd7bfbae0df010eed42d197b29370 0ed7a381e703bbea3f352175d5c426db74712e705e65d7a6cdf3e663cb173f0d 4a10f47ca743cf3b0a5e10871666d9412fbc92cc698486440cecea48eee04097 a3b3cec69a257d3a2c108c26782e64845c074aab9858def3106589bb1bd89ed9 c7045b8795f821f32bd61ac0e96280a4f2c0a42aa5194e556a2aba8a9a3cd60a df1867f9b2e511a949cd7535af1e43767dc6f609f315e0dad78e93bffdce3353 36b0c9bbe99e1887dc05141d4d24a40abc4f46ebf6492c41e5fe19d88abe1160 360d6bbb6fbe3582f70a7033b0230abc5a1f3a30938ab5e79db06c8c319134a9 6d4212b3350f9becb09f53d4a2a00ad17897726ccaaa6be16168f087daa9a031 31a666cd7e545fa15fea1a45aec7f46cf35d032a3f857e63466a9e95ae24d4d1 12f77b62a8ab01f581e13d238bbe0761c23c74e20ba20d12287f271a76efeaa9 958f571d16ca233366a1e2b4ee03c631688acc669445b52f386d4cb1f0a738cb 04b8001bb95edbd7b1be04424f7034a058e579ca7c828cac191201b00727206d fc4814f69d57d807e252a4285c50ab878eb134a8c701cd1a34acdb3cbbf56931 68284a7dde176bd03fe1894078bbd31b4de1117f277e20b52c36a9694a89cb86 dc146637b87dddfa5590ccfe4d4442ba814c0d321292eada3a6188f9f54e88f5 9e44ccef07079f19374a9cc85b1d9fb253bc6f05f37eedc329a42707512735c3 8713a27200f305306870485438123cef976b87b26027cfda479fffbe0f42e6a2 080bcca3baf819129c9246cd0ce6e05cf386bcf609b5dbf371a96e2b3979d8e8 a0b2737c4dfe1ed705bde14a2cdeb4681df0555a9512f4f2ca967577c22d4083 4f688c3366a9b3c6f69ff3b3b3d796db12ad6e4a6811a15c7b5525921512e675 e6e13358b15f970c767b527e7e7a673dba8a5dc25cd2ee84e581bce4f51c3db7 d2cc5d204e9983217ab7eca57c81f2126f09182d83b3e234acd9dd9e38fa437c b8616aed56cfbb5243506392435ad70e572acd8e96615454b337d74cdb2b9081 cb837b42e55945ceb67a0cf82ab86b7fab9d0fbc0411498c51f7424fa0b68661 4528f3eb081416ec0af4cd2ad5c38f9320b7091bbc9fced9444e375187e9e0b9 88f8cf5212f76ec1e679e7b208602adfee276fb42473d5200069738c160b98ff 111cd3d46f142e5e7189eaafc9ccff902027366c088b4b5b10d1881246be16a5 55394cc8d9a56a7c8102046d9b8a5657144d99c3e40083a022787ffaab4b4389 be5f5efcadcaddc5266ba526073115f2e6d4dbab5af41f19666d5e5fd7e5730f feae4e87f35d1a946fde2be6db8ab9a18051b840c74c03423da0b9e0041ee920 a5ffac3e5d0ac0ca33107cedb40e030c48259434270caf7981e946bb5b8f72d8 d1c5bee389eef583884c65e54500f5d8f39a02a8a6daa5bf21ef2f2abb7ac056 dcb72de20f6ac01d03b62534674af4fac5d594dfaa0d9b87fb3c66ac3694b29a bf2ccfaa319745034297db9915dc294c45d3c01b0ae2d6c072e53829db83053e 1dd306bc238f92cbabf0a819485d73faf4765a51c707332a26ae6122250dc132 82ba79192694bb790715ba735b049de48f937cb777a0d142a38a34e34a30b775 d17ef1b946cd1bc85e8a136a13f2621593a6b760bdcfa30161298a5d0d972085 ff1be763c9592c8eb15dee8140c398c11cb5bea3a810c08876b96c651fe03cf0 a3342568f1580990ce79c3c79d2ba9a87ada139077e6af9e904fb99fce095272 b0b02c9152b5f50703a7bc0e28d49b49ed17fa555ffed3d95565bfbb324346b2 e7d0db7a473ff473d7686de860a122226659aab9700a29096aae93dfb3aa1843 42a9909604d56b6ef0bd8962459de878f7c8b066721e2a1d0c4629d077de90ae f72c4b169cfee18705be0d48ee0c3afff0e511865dceca9c1f9430d0f14b709e f1568c18b07c633de3e330bdcb9597a124786f896e97f8ed72fa4b32e39aff9a 7110381109418868cd913beb753c9713180da491ef6d779b63b4bf199fc7f553 16710e4e28e4afc3799d5fdf33820a192179515b0456edd8e47000edd744943f 63353ca254624768fc94e95c669038852d77c9e7f011d36163b359b7386c17f3 bdccbd8f0b28a767f9d6e9805a1ea48256fa9f5664467e1dc9923cbf361cc027 c2a0e973993837c7ec8ca3b649b6aabe21401665e4393e302f0e386865af3cb0 1bc60fc416cc931eae571b958244189d2c05763c6107b2e59521b448587ded13 b51c99dec74d12c1c69428e0e41f6ce07380dd9ab3aef7fb76abe45aa45b47e8 6b00ab63cebf5ef419b1b3fc29c05ae2858208ce5d83b659abe03018f70f5f47 7763dbcdb8838d66fcb9aabdc76a089730fb7c679b6860145fcf297da4917c8f e85ba830f1468c936301af1a02f6ec26c2f9426c3088450d969294e823de1c0e 70a212e693ef8ce1e2b8e51e5665e908c6687891f3faef721b92bec573111d54 681d64daeb3e20c5aac241a15ab41a077b0d741fcf78688793722f508fe39a90 7d47b102196b9a12d7120f7ed3dbba1945c017a9d987adb33ac7fd7460f10d32 c65d05ddb6c89e0b45ba24ad82f97788cc3b0627094d27abc5db9b6a406b1a1e c7f7ead1b0b6943eca2f8c1f76f08bf5c765d07b7e4fd7e47d7c8e8ae26a06da 174508d08a45d7b569feeb42f9e1e9757b232a26847990bbff79c803c14fcfb1 c030cc288326763937b79b2579738a98285893d51522844baf8cb7cb2104242c f507e371717b6a5d91a394aae137fa994e0ee004cc7b41d766d6a55784180c2c b086838aa57c0d7b8b96e011a9c239f3a17552ed68751eaf9d61339a58114a61 36f8d946e3957d8fc54eb7b529cd196193f2627141af3a252caaf2260771e169 4e8db9b219b0acf79b1203d791106502833ef3410d77edc46b9f01ebcfef9078 5a4a03e182c4f5bab772b5ed01b28d634017c86f0b80d39bc860e84d4befe3fa d0fcda2fdd20ed8a6f1e4b98a227b04986920e0593ce1362fcc550723c09c100 dce4392e6372c3e87c7763cf752bafaedbbf0632105e2b37a4933f43a9b1facd 439436935018cac8879283346c9c71d38b11eaadb4248945d07abfbfcb252109 76fd901852fe345fe03a47d9e671a6445190afbde9a2ec54ce9b9001efe7478d c5617b59750e971c8e05c6e7499627bd2db7f1afabd0d2b70f18bfe6dc8a63a9 9d074065d7d557944df6b0d1792673135044c5ec1501bc312509dde93f125887 82324afc5e7aa5e38ca5278812f58956db995776ef32ad76eb4ffc171668e332 4a74dc51eecff48af4f8cd78506a82418bea4da04b1d6cfe6e26f2f7bd82ee89 aa684dd6fc34114e50d14eea83240d91f77e419a1d7f38a423b02d5fc1db772a 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 false +check_ring_signature 7fc0a8cc6e3f38f9a82606fb99b9e67d4ce106663c4e7fc556c4abd0db995d6b 134279bfeaca7ec8610c3eb1b16803951f0839193c8291828216096ae59955b7 28 1ea62275a7cbcd04bc268eb4869655bd56a530b4dd2ca3d84b3c891495ff425b 29db40f4b6833922e9423d1a9812ee534d1812af54b01af4d5fcfa24a60615a1 62b8fb539b2a40ec288c7f99cf2237bf60e37c915603c87631c42465872f7f57 f73d96eb8956519ddb758076aa0a84cb03d98589bafbe098c50443807326f594 bff711915ac4801bedd270246ee3044d5f6dafaf9d1b59a27d92689b6668baab 8094b85254420dae266d4ff7cdff5bcda798a0886905c6e9ec2ab65343213d61 63969fd178633bc4e0310dde7c74ed91d56945a1d4b1d3c5779fb2f92c943d51 ebd0e9120b17f73f96670501e87629ee8eb1263794c4b7885345e78854adbc2e 49377f01cf5670eb1b827410519818b4e564fc96d7fee26063c467f7489849c9 9300dc14093bd45ca35b734aea49defaceb476c804d6280167bed02f3c2bc0b0 9ecd692714033d9e3b7e6450ca854d4768d9691a127024b4b1a7917c5e8e149e de862bcd7078ca60210d8c9f6b3ef9049bc0cfb08b1c9633cd277136911c8e1d a462a9bd1a079be91c2bc48c93b21215ef73c152e6bf1f3210a33c26fd0a075b 7da373b8e6ff54c3e7e5f226cdfaa3d380446c9a04f9fed63fa5e313bb8f99d6 d156d26ddec24fe09df974a7e14224c680b4eae6cee5bd791627bb0f1cf9a358 e535b61f741701d53f79552fc9857274daefe487dedceb69af569b3ec24190ee 999aa80c7c2fa7d8125ba742bdedd23edf8ef8f4cc25ec8f50c1a535c7fedfb8 14520c05704c6847ca0cc8255a3ba2ff706c0f79f4f27b31e7208c654b91bf4c 941c799796d0ef70bd2d8befa05d6e8702f5e0c6fdcf6499baa3af7ca7acbb20 2f37c3609f6254a385671cc8779e637fe33068a9825c467c8462b92674b1dea5 72f0642f7cec7e66bdcd82fe17b7485283bfcde75e0df2abb6df68f9db50adb1 549dff3a1f4e7017b529101d9fcceba12ab5ba7d055c1b90304e7ae896b947b7 c5dabd11a7be5e353b16ae7e4567b68b7c586955253d397015ba18a72bde5a58 bd4471b92ed015e29bec20d4988da92f8325e811beecbdbf182a813afb9c115e 6aa5de9c09a1c54f2912821de01cb85d3c80584d970dfa631e74886e072233f4 18332465c34023f5670de9abd348dad4c2ffef1c41b96162f9a5044d7e0a6d25 8033cc95f0dee27e6d94370c1b42c0498a93a6eb2c28ed2c97c1abb3cf6e9412 612ca19d21211e8ec90749b26a669c423729333b5880a289f62ddab5aa26e380 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 true +check_ring_signature 0f4d6c55cd59e660dedf8a5410c30580f1d742adab9f92db78b467593db0c59d 5c74ea380cc3ed122404b1e82d7ec9f1ce11be5849cd5ddb0e2a5d41273bd4f6 5 51c52eabf3ad6b07b3b6c1df35e3037485b7cff84ced22cae07dc1fb7535c4ae 71121d3a735233afa1e0ea972efee469daf0ff3a51d2c25e8076bd1f7d577dd9 a6d3e2fab0e1cb395cddcb051c06d59e4d1b12d3695d9b5ab1348267369da31b 465c424123cc94bd90e24183dd3de2e909b832bd3b24762bf7494d051e31e8e2 dd23e153e7270dce79671ca4ec18e22ca6f96582ff3bf88aaee9a6b81064f0e6 2affdab894f9f4be0d91bcb8af3e7d0e354b5ea34c68574462bc4bc494591307a097838b1219c7a15239e8301efa835ef6fdb32bcb3c39a9ae27e77bdecff90317f2de4354bae71c46604cfea2148bb29f8b5f017cbbea794f1be15813e8a901b39c206067d4f249664b6875ecafef314a754dfa6537ec73257807f7991d710b6f67b85f73191a61b237dca3c88dafebe18d60613b9919b1d5f6db417607ac0ddb8bd43015e3c4fdb70d7c39862cab612a2cde0bc7a95ce73f57723f60052c036d498963b136135cbd98eb0f981b43b8a7e6346d48a01428438b2f5ae32ba908916f0782a3ce7b2f863c6e36d4ac5bb92dc946ce177bf30eb570f53a13f2e90ee620bba18fa7db42d78feee6624f1974fc10bbeba0cdc1e216dd8649154b1500abf6af911cc31b64a8e65ebaa090b1e0925d884a95b97691ecf38705e3a9d40e false +check_ring_signature aee6b69423fa9e093ff673f9697d55e74bf4688a432c2838a7cd4d3c09d23f60 e7ad822a8a6d5d4ebddba4e0487022eab1eb5b494175aa93e8f355500cc88bbe 1 f773609ca7b836966fe9b8046c18fd39559537b482ca8d5c461f52714bb9a277 0c7c41fed350e971d2fda43980e322d6ac76c4a2b3fe3d252fb10d9d5672850a9562f226a979ae2930afc9cfa7453ce4764ff76548ba45964a41ea691c2d5d85 false +check_ring_signature f3ead7434713e50108ee74aaf963cca0e7fd029ef566d18a6a8a3809d7fa957a b39dcf66b56682fa8a67fc51e6fb73dae4d86d2093ad43007405bf4f60520b99 38 24dc4b8032da0dcb32d97ffc5cda2d5b76b87c3d9b6e941be2a17ee19c91135f 477fa77b3bce9ee9d1c861adb55d13740de790aa8be7b8b282526f3320adb7d2 9a2f6a090d7e4f2417c389a3829278731fa559d0b71afbd66635c5c9481f8036 1f9eb240e938f4afc35153d8f04bef6eac51cbb8a3315674d56f940ea8801d13 88cd543c6a796e03da48cb50f49aee29445f0aa863504db287946c90f4794821 0d26e1f85e403bc710617aaa7589ebca08932a4ee2200512d0e70c8f64f6d935 c8225943a36d14dea0102f4f6e1aa715af9a4f85ad0177920f7f66157c267440 42495d1f1a44852c266cc6d353259f05cb11a116e43a97a0a0e3319ef3cadb19 2ea34057d3dcae136bc49dc503d4a49a1f8b0b87d68d915a0c9d1ada9487bc5d eb4de9dd260b3eee34e8d3459abb7d5fc62186ec0c9e0f6fcc8e3777fbd1481a 6c0f15262718312696abc86c012dd76af7b9dfa573fe440321989d489c488e41 55f8bf5664a96db6ed28ef2f900195204f8da4920c51775f1a2d03bbd075b8fa b3e278d2fee48a9ba3ff3a55c586f228e1a18d2ddfad94d53def2a8e384e850f a5c57ae417ebaa0070237cfe57fb3e1da3e6a72b4648db4ba71ef9d2591ec148 8e3848a567a97b3de739d74bb0e8ebf54b7d2e07d9bffb8ea7aea273c0f9c41c d2fd0a6c5b6c571b1d88e4ed3c3b4bbd845d2b098be53b2dec3f708626e27eeb dad4623f06437318171c533bb66c83b326c2961e9965de628711c0582a2fb8f5 a3c67a87ca674fa70343deb8313d95a1176f698d01f5608087d3abe7de31c256 07a524431549b67c52e2e115a8534c0a19289a7484d9f81c6141dfb11006e34a a6cf2a924fc8cd306dd349d38bc862e0a20de6d281645297f5fe5baa18bee237 3462f48789c7fa7c28cd0aed901c259338d2d9e9b33265b57abdaad1b70b2da3 3236409f551e9cabb2ee1fc195e4758900165123de03f331ff4e6945a9bc5f65 e13fe5fe7b2e9afc41006fcce954b8ecf0556fb1f1573cd40dbe03f60030a693 b42584b35f94acd085498fa355da433ff27529a4124f0665856f6af7b48003b8 97bbe0dea1bc7fc7bb86073bd564777c5b0c13f533a2e935bc6c2303e3a09ac8 1ec69f4c64f49b16f5b68ae9d9685670c8e4b52354446843f46d9cf7aeac9bcc b0c7587313beef9992c19264dc6840041c90bd6698d546b6ff260adafe843ab4 8658522eb8b0e2483dd4e50a70e48bfaac7a7bb67cc97ab6b6b24dd5fba112bb fda4247fde7997b43105f33628cec19e276bbb7dda30d94627c1f9d034e6bdd9 c344ec67cf2274a2b9b2538bff4e4d3132b23b4902ed7a8df21853afd69a44e0 14d6864e0b4c4319f211b96ebe7dcb0d22e46504d55d612e3be3ab6908451f2e 63b499c9a031929286234c55bd504c144dc76df22088078177ee5262bebb9912 fb7f856d24d454d0da7fdc6fa0b4ed84e5ba3701ad676989ef8b0977f3bbf8fc 2bb82aa5ebe027b0ae19ba69e49ffeff7d7b8ffd71df52a3952669a7f81d8115 0875cc3ae8b833998392a5257ac597f7a47db99f3fcc40c7c30d384e8df9cbff fdea730bfb2fef20c16147315338e6597d0edde3559f5a2e8d181317b3c17d93 a3e69d62a3b5422ac62dbdd3d3377c9a0845842b1532ca9c5fa8d00fcab8b87f bc186f91b01b6a7ff20f417cc3e0df2e5b484b7c160e9da4d58a06d2bba03ddf acec26e356bee60e0f8b658215a633587e1a5208ebb196b468e18a4a022e220e673a213f3e3b69beca7664e439cae6417f0811c282cb404694b958007d0c720e87a58ce7ac4f41b06b1512c33720f5880ac50402bbebf86a6d6ffc706ef233075503bc256bc1972fc9e00e8010c77dc0e1dca07820891f08be11ffc6d4b5d90adb9d138f39a6c3d6a94cb4957ee33566b0c5ffc52bad1c6bf820484d74789f05c38c25bd56af18a6aba55c4f1df9e5fbf643d41cee9dc0b22d5889f6724542035361eb8a55a2b76a828707668cc7cf460efe7c8950788e67cfa8b4c05b1be1058c5767c8d744a225b7f46f88b15e91a6a272e3cfaef22a7072acf433bad39607f604803bf7fbb1e0dc8e85170c038740814ee086cd8c187566a465bda5e72e025f78e280fd45a2de21a9db2960bc758c4d33141b30483172875c1c0438446806240225ff5163fbcd563eeb2ed7d92f4b78a761fbccdfa691579202740508610666e5574a922b9594591f4908354cd4263d5c6af3fe719a4bfdbd9340a11fca0fa48a2351d8bf5f402a2190fa3c9320b4d52421a30cd8c88c6624c4847b23fa051b6bcbfee4f4b58ddb4a7868c20c0ba23f2f08fcacc92237cc106f15cd91a8049bdefe8bf033f1ab1db2e272e4324fd082380d2b2ba37d7d2cbf5bf4c2a1a006f21efcb572da04ede965beed1cfbad25ef0cafc74cf84b5d7c956e0f18cc00061c842192440a5e6ce2bc46bc67920724b95b7ddc3e0e6fbb88db133573bc3c03bc0c432935eb8ecd091e0afd618eb6836931d5a4ceb58a97f523d206d981fc0a5c7282022fee66b0b7b39e2d0eb64914b76b350f2cb38a19954d204e0edfa1048b1bf65366f35875ac9a046678b11b88835b23b385637cadb9ef99139709ad045d70d53b644615aefdb3b95b720013ee4547bb9b43cd3fd5639d5447fde6b60b6699211eab1b58f0a117b18c7d2e31ab69af0f0b5ed02ce12735b1df9cf63606cf0fadede75d67f15b65937c7f9914416c0932ae209a8dbcab031a8331012f04808a64b90193e6ae4f573a742c805c32ec72ecbef56aadf67131b135acb11e037cea8e83adf39b8068795959b46e812abd3ea23dd48d5e0d8e43856425df04096704a365ccf6e2137f627a7c970b25812a1ed555e1a8af0a3df0687df6074b0bcbac4c3bc9ef1058801e4bd311be3f85bd619ae582ce117bf6c038d8b1fa89084bb32f4da195754205ac145bdf86e44ef170bcf8cc7cc5f3ee0bfd642761a80a6809cd592c9986e7eda1e2f685dc79a0d131c636fc4ddd1b3fa3156e5a483c01474ec7d783bdc10f84eec972c13a72be3e70011891cf28d57e91de63aab4a00dc0167f8e86bcf721a899a1bf353f7e8698915bf0e4337f327bd9ffcadd83970cc335782da1289de9dba2206499809a35db07bb153832f88d01aa6314513699013b8c3cad2dfd8d484a519c0e2ce9d6060b2478133348bb4c68f6fd3d3664890f9e17464f6c65aff677501c9099c9fe6a2ecf3bdea49240648ecb9eae0af05d09027faf9f302e6afa41aa0c9ef09d1a5cdce1b774ffc47de4659e3df199abad0c169fba13fe3754f4addb9d2ec8c2fba369a44defda44964e0ff6a7e196e05d085ade00485c308ab8d3cfd447199e0b69d592b8ad392c78bdc6879483cb20e40f12c5c65b2a6e39472d460c160144c56dde8cbf39c1d62a686621f6fe0b2ef809cdcb855d9ef38d89d428fcd154d3e62df0cb04298e7bc9e8f9856b12b671390c5701378f6bdb9ed771d760a88c22452ee945b62cd5a2e04ef38a746b5fd988000fc0d43d837da229490a7389e9487603a4a70ebebc8a06cc9ecb381c44f74400e4dd53fc95b2dee9604a40e615886bdaf7c79cb997bf29fb117c921422f23108b4ad5b54e6db8e499dc6a6ec76072bcdfff4749b9227f87c69463938cb23570243bdc8efc79002c3470f0cea1bc8a3f7adef6987de2e89f114955d208e6637066fbf1a3d6099124c7774f15635a2c802195c3c9012d0f29e90eb853fe5ca700dc5aa4ea40350cd5780d0295b3766431ced586d648dce4bdf9eb0a01811a265073469add6921dd175cb9bccb0ca2bfc1a2c6fbac3943b645ae30486a283bbe10034de73d2c915e1151c5e8bf789e0c1e019b74fb2cebdfaa59fe2858d54d2b206b0586a8ef8ee1eeb10076fbc90ed2d333a25d1eca34ecba95c12a8b2a9ff670f2563c87ce2fe780ad88a470d0ea1a92e58a020df63a335e7491f624cb4f1a70012c5ff36dd13b6bee26353f124780c060a71459adb9e206ab873e99230cb7d069e0ca05566d3aaff5af5a03a08b65ab933a2c852f5fd8191c692ee92baf95a02547337a54633cb3d35b64ff1642efa51c2575b9393ddb1e8ee2365463d28650bf8baa806a435c2b19eca6e1b7d60aef54095935924ad219083390d7ed951760f8f42ffcf340f42d0f8cad1a66fc0d7357820d60771a4c48f614f72bc7fa9ed0776db82bc535c308aff4d8c78f98f649ca573968aa92e88585cba5827660c400edc4e795e988664bfde2679ed01c9753e1a8b60ee71dac41c0b8c292be6239c0190bd1f7e031f5310ddc4bdab787be737125244f528be25c959e681f906e2e2011114944e270ef19912a4d8e2676f1da9b5796bb4ac37d933c2cbf599267c6404b9673870eecb78697ff85c75a2e95fe1bfb30812fdc62ec08d06562cee5d4604a9cd8417481de11b880d21afeea07c3fa23cc969a5c0359ca1d4ebd3f0df40055f964e82f9fc780e1776b571aa421b51518d98abd7fee137d956f763034bab0b2cadbca8bbe6b8a2ea44bd3b390a77fabb6d432664b8443ccaa5010da7988f02dec4861c46009493142af1b5f9f8861282ff3ee39d24024040581c04e95489054a47b6b8181b07c726314a2764408808307ee6a31dafc4c6e09f525f5988a00a223583ce5d2e4358047e40c9040f67427e9dee4cc47e85684f600cb2d8f7310dbad87a33010887755e377a31493628179c7c923e0f7e6d6328d09c5df8f3a205b6000255e23febb47aadd8af71beb4240774630ab68b9ee7e95468e699a87a0de020ce808127acc0e22a53fd234cfae97c22beac29946c151c1d1ef3f66e000620a51ac832ef531341faed2731e4e4f695efb1d7c6dbeb3294cbfc81c5e10800d8c2006b2d841cba7ecbe4f4718b4947f3cf9bf5eb7c2d54df592e12a3c54401dc9b903149400a77e7c7287e22615de231f726db4f336952f374a0ddc1ab09068ae3f9469612c97a9f87302614d1f16257315dbf37b558ce04530a922d32ef091e19b4e8d504b8d71f48be7c70ce62af17e1c26dbc12e008fee4e30492dca40a7abbc347ec031e6de84b90be25e29f86194b65aeef3b238c96dc389bf585b3048f021ae7022f7123b6cd78884c5c536f78dee34e8323644b6e49335bccfe5c0f false +check_ring_signature 28818908147c49b04ee1aef61928e05318330b620246355bdb2aacd7d4e4e3c0 730691a7fb1bd34f64c38e55f6b0ab1823d84260a3bbef27af110037807d86bc 1 c341038519adba0855e7441ad0aef9644943256f9691668e143ddc6b0ae56f63 7f024b9c8800f50da43404ba3c7f4102020620b6f2a2bcccb476fade13077b0f1db69d518d829695303a7ff565d66760a05bc0f237e12dbe43fe2558dabb9b04 true +check_ring_signature 37cdafc01354c1cd282b147e52d7e876f43600c2646aa7b937ce1b88c610e880 983bc5dba2d1fdacb6bdc93d5f2eac7aeefcaa1cf4186b76f61171f7133d0ee4 16 605393dc439acbeea21747da57b72616d892aaf67bcaad6372a28ae4eda865ec fe8bf4716a830ca25813483ccfbdcdc108122dc14bbec78a74337f6037f43534 e5d959cc89aba16b035d39d76bc979c84796ae1f62ecab6362a2bd9fb95dc972 95654e23dca4233957f50f30e8255db3948255145f006a52eec7c9238e42570f a5f607f7196a7cd83b57e3bdd63e396f12b6035d40b8e0e4d20f754997030a2c 8f281010da04af373bb139aae0922822dc1db058ef54c7304434e9e0f25ed02e 4d849e038e33a47a3e5f634ceb5eee29ebd5224275af1ade25c363484ce6995c ec876d73df44cbdf9f455cc08769a7b6e86cf7dc1bf5c2e8730a88fd2529c4d1 4d542f6f593ba7e89a14ea7630c37985a5a4736aff950285039129207f6257e2 ad8930baa7641aac997dd4893015e922b3a9c97168ecb745659242e4ac139490 9cd17a04e3dcff2f84364b60a0bb7f950657aa4baa45ae949e0fdf7539e7cd48 26442d3f31a87dc572f6c7ccde7272b16c13ecc548819dd5ad0fa0bb7b01804c a959d093451f6a3cf514461f9c428b5678dc204d7fdc6a26dbb296e160fd89a5 913d0a0b8a6e64dff45df924b1b6fe87682adb605d36f3c446c163d22615bc82 317eef983ac9edc563a2f82257d305be7ac890a6dedde2323aec12d054aa45b7 91068873b151b4cfd1b57e8befb015e6a7e459f4d4d245febb9592515aaf215a 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 false +check_ring_signature 87a17150fb4f1ae2ceeaaa532f98cb38b8eeac4d9ff36fb622492114ff6f880e f474524cdb811d88bcc40e4af87ea9d187558154758a9788b6cb6329f9fe69bb 10 803067bc3c95b2fee68799fa6cd8638b68e35d766dd2688c95b7a9411c866bac 2b366b4dbf5752e69539103bb6b34bc20067b4499d13431905c3b66f43a1defb b2efe5f062a71af89403c8b4613114bf8555feec379b3767dadb2c9b80408ff8 04677d0d999ede897e8fb0c6bd68e3f1e34c5ab08ad1facb1bb316f34c84175a 10c58f59feb808bd3cc1941c8fd49be026a1ca7ccbab7298d3c86df967c7eab8 66b84e5808416baec0f5a42861fd62b3a9bc667fd275fbe74d8b994cae732734 5e495f3a513f498c306266cd59da87871b189356d91a23816b6b42a934cf3027 4fac6e06fab9a84eef795fe0288666b224d28f15525c9b0ec9a5389081f5d339 9f23fffc6b654b8637c84ce70cb04b7b71c118ad76e7751a0923bc0e75641105 9c3f0a144314ab7cf4cd3a14b5671dd73568f60b6cc9ee4103a2237af50aa4c9 9282e9b0cd05e5e51a959e818f7da6c22787e544f2c3e75c06e2fefa276d370ed6ebcf30c9d74b591fdeee9f94aa94000ddde77403a5384c684a5bdf3e790e0d993a81e2962532d92d8a1ccb832b5db73d863b635370a3a30253ccb10455b80262bab6e2862171d99fa45319ebace25777e1bd5397b90e56859e4e14f3a980093acc721099d591a3d94f8156c7bfde7a2c5a8f49d03c90d9635b4bb57685e90c754f864a33c359e9b346701f83457ba52aad4c7e0b3cf64530da46d10f6565019ce1ac3ee1585aa903a73d4c6298da6feffc34a4541ded6736a5e0420410800d23bb22244e5749373b41b8da22c945b4fb5aa7a5e87483aac2ac226c05c90a09f809bdc996922937b6050a1a66b9cd34aa4263a1fdcb94c3f70865e3bc8a2c029a2c98d1ea3a3c7c7d8a77e6da9fccc1d7f6392398e718714d3917a4b8c7ed0ebdbc50811c1df2387a537cfd7f2666723bb1b4f14769b7c94bf9b751dc8f0c0e658a438e3f6896b1228a164b2d6040836a716a25f1203176ed73d43636758e0d858f4fb7de62b1be9d7d59323174571490e323711a05c0b7c2d6d8e6b0787908fa068cbe4964b833df0a490fa4b343b804962bb26590f5336080bfdb0eb4780ef62c5ed0f8c7f151bbdf3e554aeb72ec37262277d95f13734d380f4c984b8c0f1fb69069834f768bb615a4102d84abee64d679f3d70366e42b04ca97605fa0009e180a549414926f40dcdb589cbbcee8b6e6f86bc8caa5edf5a0699f16825707f7b32a5c7d237dedb38d7113e07bd6ff52e88abce107240a7f54ed51ddde4b0fada07b04414737636548f2a5ffdbf8be98c9e81c756edeaebfbfbb7391f4ea467b7feea1a8759ae82e1f8a3637bc3ca1753f04fc4002a3b914855ad15e0cfd00 false +check_ring_signature 7a8327977e1791d00457b0aeac0e7ba004d00424ee13ec5f0874908dbd651f98 440c2a19c8c49184710d9cfafb0fb4c5a24a08ef38fcdff564a9a7e10d4cda9a 3 7d8b74ac2b49be1e15351a27591777eb0a6926ed0ae20e767ea7221fd1a4c92d d55c0a41903de7027ab07dee3ce7fa99895e5782d08aa51fc65f456db67001dc 4def80d73bde1eedaa910d2effac73ac007d4189f32fabeb33867edfd07e24a8 c3c2192489bb75c268bf48984b2be9069198a30577e1b82295f1f0e76619b1047be75c92734db004b5930137d2d9462f8b25c0a4ae505385333a9f8d81cdc80a2ac101b2f4d52231daa1f3ef55941a61a02fa3b4686273554289243c2de39f0bbacfb1fe1658159cad7bc7c535da6188443aeba45f991134f4132f2e8765380539d7c9214eb21732a46c39896e8d03ea901a29e1c2ee25af6592027644ccb50e8e912ead08e0d89778282434c1123664079c32316275309d83b40a6e6efe0401 true +check_ring_signature 60e364a4b61299bc3ba89d54a66945924cc7000311f204326002894875a9ce1c 8d87427884bd1957f73aa57213794acfd99fabb099fa30e2adab1ff0ed321978 127 93d126e04304e1c4182ec277c435089cfefb0878cffb56c81a4196c6a66984a8 3cffef97901c308b6b9295601536e851ac6ff7d5d339e87153343750e64e39ae 1f20a9955f67e7ce8961c33d0374cb40411e7bd11bc96cf9a7f061b475baf2d7 f7a9d618c6b289f2d61d385c632f8a2de1dbf689ecab70ac64d71fd3a32467c5 65663c8aaecc206d9a7633617221ffbab50962ac789150d0dff09b5e753db75e f0485621d1f2a341549478c0257ec38098dfc774fa995fcacb792d7529ccbc4e 775cf5bd8b9177715ae63fc86369330e87f46720c75110942421f3bd25cd38df 0abab2880a58a9ca2764b4313648e4bffd8c14dbaa8b20ba521a3cffacbc2e71 a2f9d0e12dec12952012e6b098a4e7bfb7482283b5bb5e29daf14af43d1ae5c2 69a70ecd3c108a7be7976e9d88d855e7d4722d8d9507afd8ba058e2d286f0ee8 ea9cff1d3f80808beec0410b4a53433a07834fdf4ee926b4ab224748b0ca1927 11830533053fa13373edea0d0fe4ca8a1958a74d89fd4ace32ff2227f7ace4c5 eec27944ed15cee37d9574d9cb5b769195e287d1304f0e60e352245414121abb a9e65605984285d6cd467de5a07afbae38ed57269d8aaeae4e5fcb0bf744fa7b 547a0c16942c10f7a2398300eb33d267838c01b66358870f330e61d5ef8982f2 a90d1d718cf49ba2e8b7ad219d4343a6fded27db57e7f4ab06b3b6484d81a0d9 a0d7d02647da73d9d490b31e73d4e126eed9a3a918356ac6ab1c26539e1f21a8 dbf658fc41b968cba0f8faa0c6232c4df49c90ea58d3811c574757c14d172cf4 afce1b7f65451196cbade7b251a5c6ba4c2bd5a6a4bf283e60314d2ff98439ad f771484faec41291444d856d693f67b355dca74321ced761518a21f2b9b89de1 b980cc422ae84eed195a95597ee3e1d9b511565eba3efba8aa5dd838e1b26528 da2008762734dbc29a024fee09b399df8baf0b3638ea52cb9fbc7092afad7931 d432af1e21cdf41fce0d2eb8b700166205f361f50717b7e97e2887b7a8903a14 530b268fd23b6c97a006585afbfa0910ce2d3dd907da004aee7196f4522328d5 5e69e4044035815f9d74a4e5afc75df2b2150eaf5920ce4e633a92c20bec62f7 62abf4212fb1121e44e08fd8c7a68724b1690f6c0ab212274c8c54334fbfa722 9136edb42a54882dc9342a141bad88ddca0003494aa4e58c5c0ec3d24b916e35 ef492a78caa7ee47b742e90e26c702363ba133cd0c2a745bdbd260909cc41ae7 d3d4ab7d56768a26794a6b96810ea286d872ba29ffd56f6255bbd6d53c6426ab f7e2c733cbf3d9d624bb63d05418950944fdec890046ff8250800a8c4d979643 df8b0736a4dcb09454a880ad254466978d65a988960fac89e236af39f76c27cd 95237d42fbff64e036c7eca36ce2bcd68f44a2a86c25806dc2fd1b4422115188 d34efbc988dadafcba59c2d3c42b93addfb3f060a30a82a70316edf161091276 05c8f0faaf186170ae7614641b79fdacc7e778e22efafa932f6b696cce934912 50aeee7f9c6ca880435c2fae1169b9d178aadfc5e7d91abe8b55dc9aa5a358d1 5f4c2cd0fa756dac825a9ab22824e3838bd3a71a0130224165d3296413d89305 b721a1d49b193d22d493eb5f7891af12c74cc738a4f2c5868353dd5e7c624886 b4d623f982bbffb326730e45602e64e4be617f0693d5ae99b1a4842b2f30059b 226a3e1286014ab194aaacf6c0a0b9e83081193db209f4401a7037bc6774fcd1 0f3c4fb7530a2235b6d273b0d453c49b57c3488007e227210bda02af46d31879 a4c6a9d384701fc948a3dd266b862cbd08e370a3a11cef563861059851fd2f67 430a47e8ea3fbec1a487a46fd27e2b105c0412bfb60968f5948b29c0fd36dcf7 1c3fa3ef4a50606185b35220418cef33cd03c239f27d01a9e29f1c497ac7a5f2 5d86291891ce73f302322fa18e919c2518958351feb02e7fcd8c19d0848dce9e 8a6f5fa8559177e1f42ed3bc1a3faf4d41b6e4af438dd1195ceba7f459c323ea 029391fba7a4e0e43a4f244288d273a2be3b80a930015cc33b92b7b4585881ba b105e77cc43d2c7c6a16bf78e64efee88a279e1bb52b839903d9d4a31e33ad7d e50737190992609932ae058a30957ab828f25aecf27051d8602f6821ea81d124 ce55fafcd7f7cd0e03f893fe2a1909fb971c4c411225befae17e408a7e754cf4 16880ce1fc9de5c16ddd7746ef2fedd35708cbd36d73a58df7844d6e5736a5c3 ae266e5f6c13bce54ded17f8e8fa13c65a7408584968c9f206d60996ea44a9cb cafe06ac80019c4b0a284ebd658dd23e4acc31ed22f0ee407c7f4cfd2e18d6a9 7f1d433dbf39a599f1019e42c374b8a1b1c52e74a00aa887e25c431de625317e 4dd0cc1c234fe16969d8fbd71ef2a5ab9af5dbf35114953c83052a392d802b9f a2a35ba451c92f719eebf31d66ae73e1943449717edd5dc173654e0aeabac216 a540ec61005e0f32b48bc2f6129c35e967bf07a45d8c4c5ce1c5a1f62b094299 e39721d24d2a127f11a441b506a80fec803f6aeafbd9678a1e2fc77f7e572a8c db5cf41ea3a0a45077e4f34bfb223b56995a5b68597f96c883ad6377f9d2f1e4 9f54b612f1e39deb49c29fa85180952f9fafc06e3022c548ca8502780e32b52d 406d0f9d0bbde264a4f10f3a82ba605026e0dd37c982830c5ab243ccd4084684 a757061fed3b1e9f4267b09a34011cfc8a3ec46fc871dd96526fdf5e1c7a573c c1f68159c649ae31680698d333aa0353396696b0c849ee72c90e9f86d604b63c 94d58d1185aeae03c7f132feda19cae60d7c2ceb8e5bb780759ed760d727ffc1 8734a9288aef7f861ea5c9254ae7712cdaf2e01d6ef441e2646c895486eaa980 095abedd037893223b727dd7aa2f93292bc1ac50bedf7eda41a5a169ad829c08 2715f062d99501ae18d037fc548d01477eb80ece6181a51b4dcda270cd5afc90 20ab953ddafcfee34fd59032db0d781de0af984485488dd54932539b9d99c2c6 43959bfa1a220c82af686cf4c9f3dcc5ef8d24fdfc869b0b943ef661d5e1f9d4 25bae2883e0e3b02603344167c00245bd3c570ebf062edb8407e30407a2147ed f2a1f986650f0edb8d86073e0eae29723e4052a04333c02bfee4d7d83befcc6d 7c5e4289771cab50f4c54ca0d27704eb374c27b959586a26370a12de3a7aae27 e1ff3be1c5fd85fe0b5d4b17f62b58e85533e3a5051b98457559c5226125bd52 a2845d39794c2e9b0789d11154d3636c913f190138ca15059cfde5b7a59757ca a13238a832288aee6fa1faef492a1aab3c67b84af4e70bc66df69340f882b07c 592ab78b5df868d57db1b72a461f9f2314d44d5d03840ff3b481cf5be898b84c dc1c1e435083513e9c8a3905abdcb60aaeb7625490bb8a812882cf9c51b194ce 7937784a96db5494ecbdb04075f910ed364852b6312368b1657bbc9797c5cc02 4758815e5864c586ae080b656d79e053747037a165df898f8615510652eba118 639a055408f7d1392456944262e5e8d9e4907d643be9af777195baa308ef0470 a9574f1bb2735a5df2621b6caf564214e0cfdf0a5436c8002a7a372428d24fc6 42f70c96b65a2e3c55d9f61f6c4024c39cb37313307fe879242e699f3bbae716 92102d646cd6ab8b2165d4fc80d392dff3e6af4ef6988c8d5c0a2c68d7209ba9 ccbdbb8e3c602acfb8e8be6cb64b9141de5efc925d1a70dab73aaf23912cd0be f570ee83edc803c265026e78c19d95d9cabccedcca1f9464167131fddac1f14d ddbfbe5be9756c25c0eb2638ddd5d1d9ec5f8a76e669c148adc2a9aa6f719af4 c9ed0376fc8672ebc1d3a90b28eae5dcd218c72e54dd0f84bc870d81ec74784c ba6c85c1dbb7132db014724d6e87dcb71e563cd229cd5b0d54a3d08b8b14e663 e62772ec2aef33dca0684c75afc307b572d586814063eb7ae0ade293f4adb7fe a2a42b9e1b913fba0cc49f37d30257bff3eabb9b46c1ce5d37042ec293032d1c eb895863bef82900d134f1e065bed11591fbd9b184bc9f0aa4a57b9c87d6b326 92543d4ed9d367e57607d8afdb3d9b3d13251c58ca1a74d001f2aac3a296fcd7 38c03816a806f0c185c6d0e888a6641d5820ba2e67bff1f2437084917eaef26a 6b644ddd5cded2f11465fef7f5a45facce93d59ae005d3cc286c8600175403a8 768eb1815a47381ac170ba77180102bf172b194887608a4cce4480899971db90 31cf405bf813b2b4203246dce697dbadbd9a85d7706e910ed007c203fea5667b b3d2daa0a40a525d79f7d1623113312fcadb26e1c3bb82d1e29b45f06b1e28f2 93195b2d61e8a8b510607ebe3338a02dc4bf68110a801807395ab1d7f72a6726 9f2667df98d0b6d9a2d57a798ef2b90c0576d4532cfb3d02edc0384929c3ea8c 718ec0144a7a04bf02b4cb6e67431f4ca094de3dcbcf599e48776bdaee1de5c6 17855bbbca4c4817e2580aeba35cb9db459b71d32e9a1fbb39ba4913eae99921 d0e2122d8eaa8a1f5b8d6893b0e41a3c7acf3aa5acf41ab754c1fe739f2479b8 c4c8817514176fc16286d9dd69bda38e9e6a3b9a915916d08bf1a78d579cab61 11f93071480341cf71959a06bfd88eaa0e9cc0b1055ce3b4d37c3aa4d74054af 46155c1e54d63c2a493ae1fad722fd0e3aea1cacaafa8eb887eb2f827854e8ea eb0962d3ba453135aa608b36893eaa6a103c7ce0af404e2ebafe6e7b721fc0e4 582a57fe55fa11c0da48e37fa163d5ae551a08ae91dce61a887cdb13ab42efea 70ffee2253e909663fa5aea737d78c7375dc71ead648565f031d792bae84bc07 4c820136d7f5fc28cfa0a294e00efe9fedb2d55a8ab8cb41478556c7a6b4940e f2060372a37f2b69b19eb463b756ec215ceecbed44e389018c170a0c9a65bda6 ae2aa435655c139775eedeb754920def6eb273b03255dfc72cb40c1ed9da4930 710bdcdadf14755939c94983e0755d6975d17d6faedb10a6d89d27f994b8bd7a 5b70873a944eb43c298e01817ec01c7df1ce071200d28a886c3666b541326e7b 3d1d59f882a565afc95ab2ae5b1809d5206a3b39892ef5c28e19029c7a17304d 4d43550a8f9f42b230a203b0f6f4deccaa5c6dd8734fbeba134a8aa45cafb0fd 1b4190d0a9a99e4ee849b266983de30e61109386dab334b742689f9bd280d613 3481777658e5a9b0bfad23fbb5de9c269fc855f4852075c52e39e13f0043fe3f 95c1dd812f9e43aefacb15c669dbc16a8dce4ff372378a6649b2b4d0ce0f64e2 d5a30dc2b94f4674d4995b8e8700d4d5611af3e390d19037c6c1d0d6fb723a50 977129464e44e9cdbf749cc2dd7496d75bc0eea4b17ee0869a4f909108ae3b30 3500f39406d96fe52a7b687df21df996e911bd42b72109d038150d0848070f7a 24cb393d6aada86e738387bf9ea172b79addf71f6b0b35421a48e9c903d07536 4ce7a9edef9d03702de13cdc032a6260817f361cd5bec5e0922c598ee00195d8 5f7a153908f865e88c99972e3befa2d967031dea080fb2a3d1d7b3728fc64647 0bacaa1f22e6b563f5f27ddeff4a84b7d6b9b989cc6c3a92a9e52a1bacac2d52 d91a95118e8012f40079365c107149842ba42cdf8e2b0691e453afba7f24ab95 7cacc0e2389f8f76b11ef3ba000b1373ba5a4e5d2dc6059317d738933c7bc97a 72cc5e9b02c5646a265a0ef468719bab77406c8fd723a94072ab5c6be6da6bd7 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 false +check_ring_signature f00ba4ced939d2adda75cec22df76daf913bb54562cf5609c805628c73ccf224 4d2b017cdd0829b0538f687df94280a88527b41854983e3cde8e1dd43de49def 3 644e786c1bd1ccec24592c74e6eeaa1919c8f7b6694b84cb5899598a19ceb44e b8039cfb297bbc8346918efb0507c5a1f55901cc86ca619fdd2e451c4b7174e9 7128c99947e440a59bbb8ec3b9d32920a34d2522be9667ba3f9f50837dc6479c 80dc5c081eb91a711eed42910a97b464df50acee36a37a9d37422de6239cd007b503f42ee36fd77925fb88c27183ed0ab59d24cadfcd4e946beac71ca22f81062dc2b9fd018c278bf1943c8b67fe677799e35e27a6b61a9d64ccb80ef2129f05ed08d598a92209db95a1aa983897ee9718fafabff5b8195d7840fc5e344125021cfa8a7f5adee78bb4595bb20b45fb5706c4012776ef77b8018354e5eefe0a0d30dfd0e6706f3b1359cb22abb53af67a1a16a7c2ca7f3e21b6b523b04e77b20a false +check_ring_signature a1f99de03d552a1c2d361e222f1a73d008d9e5cf7b40ad1deb58f0bb645cdf35 90b0a5a943a3ce117fd2844deb4764436f4d0ffe67d8c9dcb22bbef7413a65d5 4 f66c56021478c270e6b65b5df3969b3fa1362d307938f8f87787a7ba6393e123 08f0a3a51a4b581b67716c20eff41f69bd27e2af31ee88b871a493ededab5bf9 c82976cd10733e65151e0ff97ebf0e69d4e978dfe54b3bbfe1de3af18361c831 c2945b5ab160b56c729286c7b1c71eec8fd63e7290ee5ec459319946de43c5a9 c000d57e92f078c960413dd3e3a6a7c0e58617603ad5eef75826dc58b222270aa4f09ebbe1d6d6d2a254c1bd26192c273ee0c78e00386eacbeec1d6589ec6303a7f26d9c4541b7e2f85190add351e87db7cba3c24d7bf9fa393409ae0dd15b2b829906e86cbad842b167708f5e06e516b1bbc00a2a0700b745b1869379732821eccf17469c838d9f26535185e85bf32ea88ade18fa44f37dd0f3037ec8c08c0345832aac3ac845c1e3d8acf48a8d3ad7e0242087699067051bfe6ea5176b66079d22cf425f00879ce8a0ba69e5c3bc933ec94b82b6bf942d6bf05c36a9c9fd01247ff78f1202654b9638e32b1b640e14caa9732335c69deb12f48a55b946910f false +check_ring_signature 0b60fcf9ce81d250d5bcdddf8d90e271580e4b4d9813ab5b41696bfe676051eb 5df0462c742cd7ad19c740fc4f1ad93458bdcffb28b9e98ca7f3588953b988cd 2 3710c0113f916a64bd3dbdf135ffac2ca6a69b692c05ba1130adf7cfd754d073 c441b10968733cf1ea69cae75f4cca8d2997fd6292407077320f218300e8436a 4201b10fd7a9e81e47d670304cdd3155cea587d5d4c81f3786bd59d7a5df070c61ad1be9a33501d60c84344bb048e63d7e689396af8576557a2fcb32eb6bc6014d031acc40e04188129692983a10dc05b11a772aeaf44a761546c0b46eec8e053cebb34f025ba477745606be37879a5f987b5ff743dc20c45d4fe5f210f6640d false +check_ring_signature 96adf554d7876ce4d458382b80d3df464f98c6c14360272a1127d047683ff958 73b10c5f3af7d080faadc1847230b62a8281ad007329489302dc1129117b37d4 6 62904f746306be32c609e5109982cae3b8192afe73ed16f5bcf663bd82bf084d 9d59254b1a5e225ad4e93c6a3f696e3f9fdbccc86b472fd3dd9bffb9b3a7ea7e 4cfd412108ce42fbd31f6d07dafb9da1e23ec8023bfeed42bc79d17a9dc6c696 40998afe0f8c7c25e639f1b6d7176e365353692a769e5720138ddc5428676d02 45352c3dd3a3ec8dcc992502734d2f2df27a2f1a3a911a416c04b09bd82395fd be25f8650a8bffacc8bd992423ac98fa2680c2feff1eddb51a20f017cfa80ff2 6bbb82953d1bae7951e2e3dbb820fc01873ce416f35fd6e349d06fcc98f58b0b82c4c5ca0dfea16c217f68f1058561dd653af0010452b45b0ba0ca31afb4670534bcb19b03122fc9fb7eb69e54c00479c7451ea3da6431e0a986f89bfdef4e0946e38cf7fee9762901987821b4e761e3d9c0ceaa91586943072312c469f97d0a9968540d564ca5a251d7667768d93a7810ebf26a2ab6baeda7daf92d52d91402fc54feabb840171a5f4114e1a573287adbfdc9a6b01610ced15e8e4f8b8f540594ae9fb86548fa768e562e0d0bc85aa934987470638ec1064d9ff3b4cb61d309c5b40623e803933228e6109f2491afda66b504f021013ce7b31096d26705b90225a63e5d6d2fba1c5dcdeb45934aeec0f834bcc9050021f7ea869cbcb701a0bf9e8ea5213e6924359fc287cf2d48c781c0f5687adb888a1502c3b22961b89109ec7da6e76cbdecaa05ab1e490c8cc86df7deca0b51b36e30d2ae4ee5a6d2fa04eac04f9eb01f0f9f7383e4873a084a76a517149daabff147bbe3d17752ab4b0f false +check_ring_signature b2589d538feef4e07fbe1bbfd6c002f3dd7d32948776bb52f7e3e823a7e5097e c643dd70efdd8480fb26822e756f575c0e90edf86a94b08916a6a99bbd2ca072 1 41134ba65aaeddc907abd04e42024ca874985f8c27839792d0805c77b2352ef1 bd0f076d86b6f3078892b97a6362e9e0d487efe9c842a207086cb70cb7046373cea31aba1abc6aefd3ff806d70784814aa86dbceb741a5d2f5e49934e96e5def false +check_ring_signature 306d61565b308ad1807387cf424851b619dfc32eeb5e85b4de6cb840bf4823c9 69322cdbcb4e99ad8dd0c2cd405c4bdcf45d7f7f5c43b45e9a4e8ad5f424097d 4 cb9665883851d83c67f411158a1d2dd0b899b0551197b959d34041eb647ebf5d cb862bd4a99d0a8f0af7a689b072fad9cc56bcc39959a95d6a66b58312448eeb 4100359a897faa48719c250304efcdd9d003fc99af7f397064de9e538ce72d10 bea54c6b1a6b2593257fc6c3774c0e7170a40319662a26ba5a31bae0ef74e56b f5f10c56430467996b87a153bd6f1c6a8c35afa5620775fdaa2784442ac607023bd331e2fff146eb1a6bb73dff01586e72f4b0861e94cd362edce43770b8ba09ec583ebe5c4e383ea0669fd3205c4d8f944e6ce368fe640e19c5cb9cd5090a0b39277ea5b558a6487e2eb04814819c8e16ada5187247222a5fc68f84cf4cc205080aa8592260637ce340468c4776dbe509f555a1458fdd314dae51517ac0ed03e665bfc75bf4c098c2b4a9d8eca2b9cf36311d035ed2a519ec82ec167afb0c01342137e82ea66fb1a47c3ca68bd068bb14de11cb7770c433f3c4f9a63615e800bfdb3469d91d476334b8762fe1773376bd9eb464d648af50cc6c899dc4815c0d false +check_ring_signature dbed4e8544cbcf443ca6239bf2e648f3d42684fb6ffcba51351f699b159e17f9 c3511578e521fe002d9f2d52387dccae531f08ab5caa13ae456fc15ef2d6b685 21 969e9e5a5c33814eeba97aae83ea8bcc5156606783ab07a5ab02cb05600240b2 d8801d1a783f6d3fc744de4fba76adfc523b100cdad344a7edbb68c24c3a7b52 fa2c52944abc360e909f24492f063d982c062a13a1d9efaef89854fe2032f669 244732b29c162e1c1df6cbcced1c7214c7a55366381127e5771ded445862ca92 ac9c636cd84486288e90fdf8c64ca093c0bd2d32b2e12bbe3e4568428c6e3604 d6efbe84049c1d2c7fd42287297a073dc411df7a8777ccc3f815a689f1cdacb1 df0b2564cf5ac657493d44c93588beedfa3369f51c4a1f96d289df14621f44fb 7c868b8a008cb4fa4b851049d5fbdd9bb7b44307af4c9da4c959ed5744769b17 2332a21af5912bd7b12a2eeb3796a8309c9513b7d14fa9950a1681a914d40978 1f4c29dd3cae813689c4a6ed57439100336c4c28647eac2cba047baf2ccf55e9 d7831cbf871788bc26f7369cebaaf9ac627df63c0bde0e5297a8643568dcb129 5ff8c6ba34f914ba9ec1dadf46ca2ca59cf308ee708e1abcb3ccdb0dcf3c1883 e228e451416507e8c3a851d11b4f0d287729186ec07a25f746a7f8e310d77043 28cb903a5ccfecb4699003bdfb87d7761495f3534d953cfdfd3a6357a1c5eaca a57d3763ac7fe0af6ca8bc81dade38c8a120d4695b5b8dea647b51a250c05e0e ed2512808b1e469900bb8b76e82d7f69739d7bfec79c39247d502ebd5912a37f 124349558fc7dc5d81c48f7717400838901b65115d05d86914d162f992e57987 59385560d91609d9e740690a1f35e13b88fac4b0cfe89f84128e7dc839cdedbd f49d6a216654a8a80fbc77706501fbf4bc05c48b64144f0b11985c02256ec34a 3cb5a812d53547ff4c8510b503d9cc1c03e4eb82c96bd9e91b5e68dd76be9129 cbfe5485ca576e19d9b3f5df45441117c2e92ad0f030b2b22a754c18cd52619b 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 true +check_ring_signature b12af8644fa4679ec3ffda70f3a1ef45bda79cadf599e7030599e31569ad67cd 5d3b86f0a1c74a94bad67c26dc1efe4124a23dd0f288e892ac94280e9c0a2298 13 14c152999db195ddb85a473f2c81111f6ff367553870858ac7a3e04c2ffbf2db db0c29f942be12be89eacd1b81536cfe9cd7a24c35b6a6931b338957d486f30a cbcd801b2f7d65c74cffe5532eb29275f04fc608238bb0b69d13b147a1e89ce6 6c58d89bfe916c6643e1b8e2cdbad88776a7ecd4011224b77595583f32479544 72d8320049bac65b47de2bd7729a2932c14624a45658d1562e6d4b9c819df85a 7a81be49e05475405bfb21da084f55a0944f561ecf05b9e500cf5b1a37ea0d46 5ccb9a6ede32255e65770fb6defc620ce4134eae6b516005605e78d586329a19 167357b9d305f550d52a881c6809cd393671289d27acf97496ec07e3eb345d55 006ce5beb645d46f2da5016edb7048b0a67780a54375c6678548298c6e498696 8703c3cdb32995dc8fec8cd381cb25a7690392d72f201e0f6ea88a1a2dc26e6e fa6d432c074ce19c76a743541115b2ad5fe79d4937b209a823a24603dd401a07 8c0e64c8cb2ad110df7b3103be57a2ab37e947d2d5779ad9cb3a78648be0bc2e 168f285bb902507adf758d8227f836d814e73ea9d658c0cfe6147d712953c878 270642d4912758fd317b9bad43c99d9154a87e3f6afed31794224464677c3c007eeb28f84838bfb4e8956344c7b9427d8d0d1820146cf219eb27dafb9a562a07c7c7cebd8e498281c567927031cec2ecd42ffc8ae54f76267e495c33b51028050a0c35615f864b083433d438ea37d8ab288dd09ac785684995b27dfeb550950aca64585e6fdd97ea60e154dd9e2922dbbf7e77a62339285f847c1e24917a7d01cf0bfd649a9c98fe1d896d950a07a4530993dbd6eb784427bd8a14d5e1d36f047e8a80f7a1b2f05082e829d2bfa8a1bd04d336002719cf5c6a31c2e93f06c70390a9c7c3468ddae2abe1567e8866eeab5b8ce930b960f4ab518fcf7a80db4301f0b6f91ba7720b868633e1ebed492dbe44d17ceae7f2da9dbe8ea5cf92ec460cdb3a3d872a1f587119c41290ba2b6d042fbcb729c7b9775d700746b37e159c026b4aec47c2461dba77c09b0609a2c29ff414eaeee2ce62b95f3827f56018db07237ed3730571a5d096208260fdc934929b070300d7cf61e374c0b858a465790125edaf5214505ddc23d396e886346dafcc2c9d433f8610037a21e7a518246a0cde049068d30000d90762f16c37b7c833041157127abdbd531fdda8a06231900fb8e24898e434bd4ddd15315e4b76391392b4c5b59bd9cad989a55693ca928306c4ed4f9c9d16f2ba1485f974358ef4e452d895639aa2df83473d6011121ae707d8de201ae2f419e4b85cebacecf3e93fb8cbaec92f423ada07a3af2cdab05905bc24f15fe52117d3d71263c557ab47a8799c9ece97fac4c647fef164c53c1f05f831b5c0f1326e6181e95b40e3b9a9bf85f6258ea226e90b77bd80a881a06c02062d6e44203929b76d6db39fc9d35b94a89ed3d75e2c82e3b950b2869500110409d2c3208f195b8383f4c9837765add16b1de76c3f141a025d1007547ae1630fe82ef8d32965df6fea94fbaffd3942178ca8240a5c597fb94df6086fb4a5fe05fc05f8f34b3f6cfd42732aa7167c6ea4120736581025ae87d58521990447f90934f0db95f2c61bdde2108df19d4775e1b064fb62088dcd4cd7ba5f0a3950cc05d667e3b4f293ac8b62b7d0adcc13eb08eee218d5266bbb6614d295b359eb3f036a71610705e2922f28ca02c6940d72df09cbe784854db9a5be3b6792754dd509 true +check_ring_signature 114f12bd487652d2c2009b2fb6cabf82eb120f3b6e67931c9f26d575a6c98f0a 55453f54cc82ccc50c5ab905296640954fa911bc3428ba19117b46f9ff324f33 1 f20b734c21b8fef3c4234904601d5d8c3fa2bdc65eda49888f5b5e8df5d004ef 85116e52243408a95fad77f1aa91aeb32d78a460961a564437de2be3318db40ae0eebda05727edde3979e9f2ff4bd4c59e9ec56e2b420acaba31fe88e04f1704 true +check_ring_signature a931f47922a8e014f6527de7dc560ed1ea3b419c1cc4b346ea67efa031cdcda4 9f941bc2fa01c4295dac1e89de92603daf2b3028ff7076c189a926e6da785f42 14 530a7ab18ddd6058a96e38677ec15e4b2e6cde428901e93996f8faf06735e0b3 4b660db4cb8a7d540e4e07e2def3f751d568c48399f4e61d8deb82f4470828ba 507627fcebba8cb293aabd4c47073ee368a9b4665b6f31824cfdf761c7733f38 61c4e6ef661a7afd0ac67cc563e9e7630bdb28f16fe41899e671d92554ae9465 5e7b71abd97f0681cc87f2939c9b58dd5eb89db3983e48ae3ec8ebf295dbb196 b126880292dba85b934d422ce849a36d42a55b8e43b3acbb54edc58cb738c2f4 26ea0df805ba9372c111e6c64bdc64fa44bc48f33dff7e8a6b950f40f65f75e5 ca146fda6f8458ad889c53db126a41601d16750d536a3d984f8dd2a5096abc7a ad3ff646496a64feb668ee7e75fd8678a5cb48c9b4d4cf89cc47266d00d555af 59d2faf15db2b0f2e28bdd844f9cd0e51ad733010f24180141648c8be290fa55 72997837ccdb375b227c1d84159f9c54f3d0950c3f2acac395470df6da9ee4e7 4553d8c30d59173f8c6b614f989ff0163dea32f7648a51d776812a5351088156 a5fad48732945085029cc01b12e607e195f471f56780f0be5910ca0d26b2eadf f286064970fd2d7923f6506f8eb9eb4ca0fdca013d044282ad671b5b88cefaf6 2cc938f0271603beb10eaa2fca5683e05376b369c0d25285d3b09061d9dcb80b5c6cca9bd3cd9f2c32ee23159cf8a042c9ee54c6506f4ff15b4bd73fed9b380f17bf34c5e30347a80039a5f8e2cac4a9a4ba390b32dca13eea38c80089a6fa0750dd63daf36e8214c02f00deaaa7bacc2e4f49de5a529a629f44146c2935b90aba67069c58556794b83380db993ecb95a5a0ce6b165b86b781d123d1be718b079cdaab8eed6212639395401e38b1d9d9c41418d2d87b6f7ac538124b49b2ab090d4589d14d13de46fa5a4943af498dd22bfecfea0f709757fe07c7bd9318010da8d5b50df2c6a19380f8f78bf20f484c810501401fbdcfb2a523d3a845818509209f11498878358fb660f9a8d93e81765d8b2de74d81d7c3e61770a38bf85704bfb16d5ea8840fde7691a8908aa4044b35dd9a85519003a359b9882cc19d770a9287a125ca2bff00eff9521979aba76f163d9d0ca510035c9dbea68211669207200f5ff04c023360228e1833fea17b778cd7f3b41755ed8d42b0efaf906b6d03474ade48c3f11df0aec2a4b05ab62f7bd3948d91972f4206421c9ead65edd1066593a546949c26d96e13b55802ececfa40baa155a459c67717439aa3f330000bea2c337febf57826595f1db20341172989ebe2573ba6d1ca73fae045b597e90212faa94ea0d01351ddaf08ae5ebd2dd6bd004f65700edb91a19d18e401cb70eb7c51fee3e67eb17a3b77b5d7a3999b486be7d15b79a16b7d852eb98b97e0e8075b674e23fcdba4cf31d501b8c7ba7e153d0ec85654f4334e5f2c650c1d76030512396e4715f60c2965aa0c497a87f7b42a4769c16f0685e0fc1383e4bdff790cfb3598fde62d2eeba30c91d3805059adccdc82a9597a7d8aff5a45c3a797ad07f99fb6c902b5da8843b633ff57600712e08c08c31f68ac99b0ac335b73290a0f40012a797bbd577631775921f4713ab9d82f2036d376bd40882f7b8cd72ddb070f93e71de08a4784124a8acb230ad8cfb438606bc0373df3ef65bc167a1c520eccb31a0d3884a24e0f13cbe4c08458f27d0a15b94a37a1fc55477e4943591d03ce5fda15f02f75290c782e14ac89b3fd7e45f06012bfbd9740b08fd38629770dac8918d4a5967eaef9e2d4ce2d756d56b376410530712764e9e2b5bec6277f06fcc350ed373f416b676767c5e3c5481e24a229b3ee5e07c70052442c1787110723ef178b27b896f0e5754eb256bbcf51e8f04e98aaa3ac67dde10c625b699c0f false +check_ring_signature ecc95441e55e3bab0d03b55de0d6420221b5779ebe03e8513e2b9c4c8c88603e 90fddd7965a2006a56ad0fb7e4500bc876832b35180d8afff380b651e2498388 2 97947adc73a3a4fa465977e536a150d7e90970d9ae1edde308a0ba28da326593 fc73f04336b2196bf1711a5c9e8a9cd6971a5ed9d3459714ca4604d6464f3cc4 b7656772318cb8fc1820b10007e81bb8a1320349d04b3071a0580602998e858a983e739d4a9306c797e0341659c088bdfcde21a42f7c47f384be48198b59450eb4cbdb895c61120cc471517fffe11bb8d9a8bf663e59a7b62c256a1abe646406c9b3d6a6fb18b54f2391839d1025c9ccc1287f611e6b1fb0587802cd21e687f3 false +check_ring_signature 4e1925166f5c20115b03a053d6c8a81eb367967fbb0c0a7f60381a0dd3b4555c 0b73f223711bf0feaf33ddfe7da34f83a9da7045a0345fa1ecbba19999dabf22 1 94928674d499977dbf98cf462035904ffad93978db30ea24eae8733d1b53c7a5 e22ef265f22ad06bc3d2bb54f1aab60f43032a485baf8cf5b3dab7a8f228440d86d55f14c6dfcb83cf7e6561dcd3fa4bc936d5119fbf1d35f4d1d9c3d8eb5407 false +check_ring_signature 905eb08782db92ac615b2df0ee160eca1fa3caa30fdb677f1562db86202e4499 18232ecf0cc875aa962aca9732c098c12d117855eccf8fcb7b6a7840337e3252 10 9958c50a843392f678b45b7b2c5b5de4f296f5778e3159400223d73fb45f5e34 3076224a0880c15c04dc0b65a163e003fb22711eab1e51896176ccb6164d767d a4b518b33413c98c055b42018dbc2e52dfddbef9224d54b7235f27ee477463ea 5154ca95e0f4a73ececf6f2e1a0b7ca065667f096e9214a074ab3a5c1f53334f 24a11fdb2fd0b7a1c3b4199d286f8e7adada86aed876c06283394ad5b8036c21 4032819387cf5bd5deaf7ea7e4dd55ec4f9dc8245fbb940e0c4f97ab9d1cfcbb 6d247954e95cfb7cd4b8527f3bde3a912210d60a23cc115ef3e01755734f6154 731c7adcdcc4da089af6ae53c796f47c85f926801831db3d78ae5f8fda45af69 acf95db2545d17eb8f5809bcce4df0c3db9eb2fa69418a0c6b3b009950b24ff2 cdf64d88453732f9f47645bd038d8ba2b95a7cb2bafe53ea08f2ba280594c344 9440671eac20b1b5b6f8684d0dc2446017188980a37027664489c5d704e8050648086863c66625da1f3591c643bfb7819bae01bba84729affbbc224bd9b9030c4dd0489d58cd4c6489256d31b2db521d6020e6189621f1bb5a98330f1b7e6e0adb2246965033e372a147e3d1a1afbfb7301aebbf308cb3d8796a84c944d2dd053c2b808249239a8585bb3b4c00ddc759941a23851a52c71a8e9f3d64dfc52305eae5899d003e7b9ff387c255fbc3a6e04cc355c342ccba2a89ccecffba95810ce804016ed0341aad7f62db376aa407831d32cca2e1976396829de3800a7e760f22fa4d92e293c8a1ad48908439a721eb2f8ee278af13026be65668014d2f6c05a98226c603845c25a6724e1982c350740de91ff08032a6709655036aed71bb0aec67b7e332d8abb38af263a691f25c70715a4cef9e67f0bf3f23751aa4beea0b2a14da93aa055717217d8cedff6561f218ba717367fd2d2b2e7f77e88b59c20a515fb99389cc5756014c06348daf317198aebb15c7474a2e53a729fcbf1f00035c9f5ab9e250e9294539bd562eb552e6fb1626b435a29eb9c57ccdc89620b3006f4163d441a36de9f05b1eb42bd7e565ccc8f0bae94a7509101c6acaf8b7320be7fc70a6a61e8d5e51274e8c43d1c7b4ad37a01bd132eb55ffc834b4e8497306ac9257ee8273c5fd8b0d827d35cbe76f21bdba669905b3d10e5fc16189f3860d2fc1f74136489fa49bc966a5a230605dd684594c733e85b48e9117682fe88806499e07bb6e38099a66eb5369d0c34437e93afa73df4b77bc2f79525b6dea7708bb437ea515bc8ec4ce56fd0562e74adfafc30876bc87e56f7b8305b9693a680b08d457002a4f240f9cc4ae1663ebd8d4eb2d39ae9f4cc435a779375717f5b40d true +check_ring_signature eaa2733c355df25475c45c21af3294c644312eba9b85b128e0f0cbceb549470d 28581b9f9bd668e85570b55cd995135b14a6ade5e122c751eebd3a6ca5847660 201 a919c860960f521e17b7761e67fe7c7514930e826af8d1392d5e84d0e72178dc 2557dc9a225488a138841084b93a5e5a1e656204b0a90e51655a062142237df9 cf3e40fd4aef3d0c1c6fa9bf39c03d0b7a553147b9b6ae85fbf8dcf44ce68e3d 15bc8b52a1a9c38fb8b50be63a6a1777f7cfce3c4e69cd209af9b5788a7a0538 57ff54363896c545522c5de9578000825c0a9be9b07f165a0f982e56cfda125d e54c7edf43c1c0d5c695f941e8baa46c25a51605714ffe36d5e25e4f16db17ff f0479c510197ec3fd9a5c889f13d057a5d9d18f8514dfdfbcbdce3d39fc935bd ae105cdae4e1c2239c8fe7973eee8894902fb29df54007851cbf84dc8ee4ff86 0d5e20e321e5235ddf5be11b604778da9d68b40edf7458a16732cbec2e60e040 c20773a5003b2516b20b35a4199686287d3b6c1a8c37ccac969074dcbe76ff2f 7817bc078fe6a43a3aa1b79383a492005fb3a8e36a767067bc0e3dd0331b3a97 0fdd921755fa87ec1c4833b230f4aa53583885940b3af47fc88d4a7d78e33723 f883e83c437bba02e3b903b8183601f0c2fa0cce79dd26cfa432a0f4932cb059 c76c15d1a14a6d9aed285c743da8efbbeb1734943934dc7fc04f090acd47831a de3c48120ac968c3e7db43658cf07c47eacae33f105065b6eaf2c8e65437ffd9 5b566f7ea1c19a61847412b5f1e6099d9518cddfd2f4cc4a10c45033379dba98 e008475150c70226ea7b75c87e5bfd3fda12efb2966acc614527b2e6bbbc7912 8ff6e2552d02a24138f2b51d039d82e097ea768522aeb4d3e174b6dfbdb5130f 2833b5d10133fbdf3b5dd5ff18a5773c9f9a2beb254d0ccf8d102474be3bd48f 39b23081023feb2e5bdf9f6ea4b1497d6d64c7ff7196310f844d54f21cfc24bb 4e9bf5bea6700a562a8fe1435be255da83f8a6120a7a471c05ab22f3cfd89e75 bfe4a19c3d6c4bfa3d011101205d6d907d83d9f13db4ce8c6dcb4ba65ddd221e 2790913dbcd09147a86e19c0de4307fc03c222e5c607bbb3d71ba8f3068f5855 0c528f48d5e195a68ceaf66b2b2186f0217bc98b74b41f3c45302f1fd3833750 171d40eedc3f2227f1c0da814fc4793ea7b13611dbf15085d9dae6a52fc22bf4 6f85fc26aa83c3cb679f72f8eff067862e590aed37fc1b91b655b400f6f7aa75 f3a68e3e48f3b7ee3df6ebb50d0f59c0dfaf4d1606bb98eb305fae45a34b585a 19784de660a2a05e9282763e10abca25cfe9cc1f21ef247ebf4ccf9e6e3d6728 c0738042876adecb376b9b6545b9c3208fdc271b0375ba4972d3e00c937f1112 6bb10d8bb240e3a676b88c495c67fac22a0dd1f2b333b6a0f588e53f7b7f0402 522a1cb6ebb7b0caf42b7dced4a1a393310b26edcf5795024a86e2a372f0e564 55561b67b19cd1919959772b78bf3fee126884e5a820a46750a7353a497cd528 f2b76025a280d953da66e82da48a0cc7c58bc80a233fca134c77c179f9d6cc20 80eb3531651ccd87103619a64c894e3e422e7f983e7e8a5a28fd20ee4ac53545 999802cbe4e4d20aaf2521df51b2cf1094bd1dd45c0436c24caed67820aa9d0b c95bfd8d408d8c5c09141da415ef396abe898484a8ecbad4d759e197595203ff d9fd6533253f2d7730d77e3c212a8a326c6a0f6b4864e37c97cedd2aabe77b09 0186360cbd8cefe5e6953f81def44c9705e40cbeab7aeb222b92d5619fc490c0 fc165b7b4649fca41a0b569321b171781ba701f59fec113052e0a271236b5a46 4a944d24468ac76769ba86392195b7eae0911a5f946609e3c44bd41e04c91f57 47993737aaf2ee87058c67f9ef812a5e9a4208505974af37bee19314245f0b7b 010f2f7a78560b585d09a5d077fcff878bdcbbfcf57b7df418923c9a27482242 b419f31d3b9ea2321d0d492377d56ddd9d770888ecfaf6c430bfb9036f881373 723bddea5c6cf96bc628afe4985bbf8db14c938610011e2531947f7c994731d5 235dd6e7e48e4345bc5c20b21a07c5e63ccab8f93083f9b3cbe3637539ff6615 ed88f1a70f793b8b4f642a0e8ee32a801fe3b5aa02ca7f2dd26e435040ef8c0a d7941d4da0261698e7bc911f21a95b92626a7d49ebda17770a2fa9b3c5a681fc f9577e9cbddf7e13cc73d34cd83d721cdbca6b9a9457e522534afb27d1691ca0 dbf32c2b52616cf41956ccbe497e84a1b85a294bc897c9929e71233184eb1810 75316d2e0b940b50310a2fff51414790dc5f26c00e3afb53b65fc61caaf7ea0c e8b2130ada4929a1c54cd28ffa283f582823c5b5162b1ad522dcb360fa240bd4 0c8ab74625818ad74075a0c2cdca70af7409cd487d43f1290c67c5cc7b772b3e d6fe394e3c18294178b5751efa9f623626dea4d515a7e3fed02f68438a8f118c bba39c307b7988318debce93a66d0fead9264a8913afaa513fa104c6fb80faa2 250aa777c0b9b2a9e240c44d41a0cb890a385067b8b91e52afa584bee66fb279 e8115fefb49013088026cec4dc01b0072c1c7c0a21ac6d836e2a2f29c19c55e4 a97f021b07960dd546acc58466f7fa7aff829bfbf5b22fa731d52266116a9b5f 4e4e7a582ecf47cfed2c73b67658c7cc94c966fe47da709ce9105470df36bccf b28e0d2a81657b9330acc7135f33dea59522365912b562542349471c4e137471 6f161c16f7e1a29e37bc6fe154674a3a7fc953ce6a806321aa39a41a456ac165 665d1a085f25e2c2c2beadafc83cc61bf6045ad07ff63a9b341166a2dfe7f6dc ec4569f663485327f9ba044d3bbad7481cad0663aeba3b1c5a3a9a2812eee9ee 387242370a12946c72c8aa16caed4a1d89a3ff12256eda4048df64bf72477690 b9a0d9858e2d087db321c0edff1662704d1bf83b8ddf7e01470cc3dca0933f56 72ca0c1cf48667d5e4925c17014d738e5dea7c2a7656a785fa3ad99dcef8a623 15ce4dce66a2685f87cce24017bab7e57b50d07be17f8575db72dab55ffd02a9 3d92e2985da85205d7013e95c9be9a430269da22690039997a8549a551975d32 3277560807e0b2cc29eb415f752e5b8fe466e96e77f524aa4064574d818227d9 554200f209a4133aed6355bcbc5b02b91e3e495ec726cb04b4493f99570b7b98 cdafba2a05464ddb624dcd19aed8a42c755ae139f86db58ccf73814b320907a2 5bbdbb0e89f08172906182e8171302a10280136ccd614cb722b3929fe627ceee 62519ec6c0313b08297599af23a751be3a8c0ba51148b6e8291b7355a9a519ad b3400da20d757b0409d6707398da7e29d5d4c0fb4569b1c6579937deccfbab80 dd685d67b95d3422d329d95864b5cd13dc49fa350c9a469f923ecdc59d5a3c01 9de83b502e746185ab1695cc20b36bc014287cfa59a4807d3cbf9baf5c7eb82d 1028962d032284692c14f190d0f9395b52d95fe3be7883b807b50912947b2588 068946f91ebd489ca20fe6db9d94bf5a452edda351ac85b413342d7c2f2222f0 0c73212b82f5c345193602b5f80c9ed89be701c729dca888cbcd59fc0e732df2 64c56c0b182c94e213a9d05a8a700f869398dbaae43eb8fa61ecd73697a17019 ead9d9afa436682bf9b8a9464af4914441339517b6ae8e1a24014f220b6b0e53 d80684336c33f760c1c0ceb98792165fd52653281fe69476fda27862aa56085b e870bff39d6977344902a88fb1f81ccfdd9cc7e9b6d3d620a90622301a922847 0727a88e60ccfdfdd1bf10e7c90e878806f7b88093d6bd05563da394d5a5cd6a 8755a6b8b50320bd3e6e90caa75cd0e976e40193a9546db418b3cd73177daaee 0901b3651127716228e6646a0c2bceb6a28f6d96517abd5aabe1825788f9a2a6 754cfb551abd9e704017efcb3e6fb6699060db94078952edc5e3eadc852de90f 45c2879e233333ef9635125a71f8228a1fea5c29fdb5177f240910df6a5ca4e4 afda2e1b42b7f27a1aca644cb7148018eddc9aae67ff7a927fa2fa6acd8c55e0 9b53b1bd1eb537345bccfb271e294fb1ea15ddd70ef7e07f8e002a6eb344a8f2 9d33b52535e1f380a540cd053a1c2c78a258cd1c1a4dfcb4cd52fdf6692a11ca ff2e215f839ffdea3d511bf5b39fb67bfdc9e85219837126ecbf86a768f740ae ef2a81935ac841766248a2c8a3855372c92eafc1a45aaad8411efadb04343fd1 8fb57c626c2d8ec1878649800f211367bd05781f99c899091d6068c9497756a4 988b73be190a99d1c50d3324441fff152ba7587274ac3e2130555ed414cb86b4 cbc6cdada7cc1cf28cf1d3ffed116cabd01c3d4b1e162c34244d91ec66dd3865 761d3c4c91dd9262f0a9bd3c4d3f42812789cce227e0c513fe0759294d7fd3c3 9a1860839996b8aeadcb2e9d17fea680c1336867b48b91d1d2603a437d566bf9 999082b231976aa0fad97b9dc789b52c503c8b5d95df21986666aee35e0885ad 993e5924ff6697fca024209c385b14e4f4a770473a792c870cf9091b7ba4efc0 e7ae51131a2f17a6f70bc8b9d0a08c755081a0c11911d2b8cfeda8f567891878 0544edfa8673e038c30d43ffb66682f671ed0e72d5cfbb0e344ec2866bc99b2d c64c71a478d2df2b06f792cb33140d453272ec3e578851855c1acfed4cc08cea a3fa237f4acffb8807cd3a94dc4648edb0259765a8605bf2ae140797b68314fe 5eee020c3fa83821698aedb065eea2870aae5c2408e180cf53b62d969732872a 8973b0a4502b1bd1f12e472a310982a94807ba200cd6b2a82d618c9246c0e6b5 10ff845a1dc430a227bb44d1ab9a339a363b00dbaf6ec730015bae50b4e115d1 aad82eea3b08cbeddc637126a028368beaa44624ef50059199df048d66f50d67 642b8a1b5559631d73eb2beb753f46b76fd72021bd77300bc3a57d7464db88a7 88daeaf1b8fc72a455f3737e0621a443e5d09e2bc7565e23db72b4b4e3d7cc3c 1a155787be5f37e8535ec8dedc12bf011258f415216f074715bc1ded072bb204 a4808888ee1f10e2dc8737ffaf19b408e6f7c5647901f1aca8044a12afe84dd4 aaff4cae5ce632ea4b4072fe952a55e248e2ec39fb282e0e4357c9dfa51363fd af6d8452ebb4fdd961673dbf87e4f6fda5d20f7d71344a894eef964594f72744 42a6730f48ecdf4905ef41c2c458753f07728b1d199f6532991251b7b31ec9f7 925bae457bf354d39bbdf38bb09a1731b30ca5cb681c495fd1a49bde95053660 6b9a7f432f3327464068f27b1950e36b0f030a7b6eaec97acf2d05c55e652e64 e1450be37dab873c0c211f477f4c64ccdddd9b3e4aa22adf72e9f5ebfd173451 8bf20a8dd4b2e61b3bea72b0d893386d515a863586500bf0aeef0aa64526fbb1 491e1eaf9807c3a6993bfb2e831b2b4225cb216c3a5bf416e0521afa195f2ec1 f123d12cdcf74d988fc0f900824b00ba5359b5acc52e055d6ef820fe3abd2695 1c741bf84bf9ff24fe7e0bf8c27edd3f48ac50174077951ac7598d18f99f2b28 3a4e1fcb59534071e786a334b034a1cd3907baf2007aacd13a6fbb6825067de7 9a92846595b5d3f0232d8f7786cdfa06b68f52644b28730370279785b8b354d4 ebe1a669731ff372766d93b8f2751460db512136eb62c6f3a3e3a943169b12a1 2f8c26ed08b42cc0b921bbccae79dfaa5fd4ac77bc2525225b5031d70e45c7e0 915785300bb489c045e56833210b70cbcd9268c1625878035292a26a1f33c7ce 3568a0fdfa7537fbae766a821f736a51e87cfe8ebc2db24f4da3da73107ea6e2 c1fb1a6becf6cb88dbb1c2d8040a05402885eda711bd957f0ac44674d7bab859 3214623ae95612052a24e3c6175811bb8fd5aca258470caa9db5f1fe35ef75bc 138e2794c827e3787401d850e1b4753dddb83504da46c617e284fa50678e117b 2525e2dec5dbe97c96d913c33357d4164b5b432395de854bb268dc072ba3b2c5 d8e55493787ba7701375abae86f19ab445c090017efa83b0925a4a8e3e00fc4d c828a723bcc97be501df5d691d95d15597d085ef3cc20cd2a0bb443e06fa34e7 b2135654cd850a398f160ecb5f1b8e8750f718008647db89bd26d2355842a5e5 4d9c6f6f3fe6b6624f46c3cfc99856850dbac659b7839d4f5dfda979e0b9d60d 0fbff11db40253ef96899fc7dbea180170a9eac5e03ca6257e544afa1a09d0cb d44172dddf6c56a7109532d71c623fc9802d002e20335eed9680ea154344f1ec c3503a0bb0d79526c846beeeae7770c64316e86a669d5a63a17963d08ad9bab6 bbc093470fd3eaa200238b8a18f14dee791ab0f02027c125a99e095dcccdf374 2f1dfce373cd5bd4c7e88485ff7c66a5c066e9ec80c7cb7eb333aa873b67f82d 5638fe9c5edd0e23592d887fcb359f95b7a21753cd865624764c6915f3ccff64 b60f8210ec01fc861d4ffcc63ae5a2e52a583619c4730fa86462536bc378a2fc f82074d89d7f0d0474956dbc770531a71151b2a1f8784792e4019ff75c4e7459 c44a58e9a318c8ccfb8b2905091fd7c5528728265bef960e64781aa9ac7fe026 d5e87db6e7c211ae6c5bfd1ab2ace2dc30bea23cd31da0101f2ebad16feac4db c1e5aa9aca928162071486a6809ada565dd5f56b2bfd7cf51dc6c69dbc4d04bb 100e842f29271ba50d207c3759cb7fc10b330ea9536c55399f5d39f2a1cf94fa 5b2f4a4b61d9b73b93e33c31ca84d9619e5a58f78ef3fcc01d6620c80c2cdd8a 2dee250bd0972e7618e122ebd7fafd4c950d85b0202bec429a1cdea8c7c6e2e8 cf225a6489515dd6295cfe594051dcf0b9cbf88de55117b80d3bb485ddaa2399 1e491ee61a2209851f5b3ff27bed8a88e8ba379886690325f8f8a6ad3c6fd7c0 cf3292a13f298cd54df27183d7fc10ca9771d33c66ea88b6120c91aa4d48ec93 2af1f775c6a73b08a05245520ead224896e2c4064a754830b46f03cb7d8d3250 976f112eef4ae31371874865842092519a191850bea8298f80b275a058e0fe83 cdead1c68c7d7645dd2b1d83f21a4da489fa2a7674726b2f0da413467ceba206 de428b930f30494ba3ebd886b83a4cd235b6779db0462836a0652eabfbed54b4 341ccaecff12b0f8350325d9e2e40fe0ad3f5b6061786076f49a40046e86a420 fc0516e14098389fce5da013842fc543cbca58fccd5b044c255116bf34ca236b 40bb66bbcdd81427c253c6785b1e60614b9e903cf524ae5c953d5f7a568f5d1c f32a796b41959bf1f143d75c6716fb7d295881b3bce7097f7a982f21e2b8dcb1 42031e855af1afaee8cde09da80bd81785530ffa3697192ebce357c933413cdc 6dce80641b51034e327dd5dbba9af4386311eeb701a46621a0ab04c1db50049d 972a9d76064a6ba4292ccde8cd547d720b7be8fe7b541901e94cade4da94f365 be87a85da65de3c45330c365a76a9ba0dfad3fefe043f89e9d5a33a08fd278f2 f94a93c59c4558facaa059aaa9301f37f0ed999f00138b74c071b9b861928b27 21a5d6f1d4e296101bf4caa89b7ab6fbfcb02094c442b96d61a050f379a0da1a 051f7474b26c6c28dfc1f6ff4cd7ab9769a7b2337fd80456b4ece73a44171e63 ca894d58c216f50ca17941ebbd6a747e15410e52f68ab9e3a494d7a445864e06 4ee894542101605991fe01ee00471fad3d0822692400e800a7ac3f0b2b5ed52f 59fd018fdc2b384b2c116acc0a705a5287bd6e4b4c0af206389d1f4bd8f2590c 5e25e516fe4d521e863d8efad6fd249262ec2194442ea29da0d1eef93349ca8c bc9884e1a416e65eadfff149c9d0ba5ec08470661ee62fd3722bee1daa680e93 fc38f4240d62860f38c5774ce9c5ed3b634a2828bfe014f336579fdf74359a25 c610a313b244833ddd6ededa27f578b9cabbb4819670e2d971bf385b3c84eb3c d7999e948308dab554ea85d85531a59496c9cfe8accefedb077e70bd63f1394d 904fc4041d9897099616eb1919195bd24845b75bfd10e224aad68901099b6829 cb11201978542730f6cc9866837fd9954301ddd04be719c2644f56f0d2bb9613 173f47717ca93a760e3b69484deabeff21d95032ee7042ea09a4d0599d10b271 7a3c2501ff4af655d4c59510e685fe726c5e4d233239b43efdd5e631256c2db2 5371874fcaf6318fd20596c548d7de354c94f95b137626b28ef50ca8dada44a3 fa2fdf331fb45ab37a62d0f67a1ed91ab28e3a61d96413cb5b819d46a3c4c5ac 787ab1d504ca4833d5bfa3ec3123e96eb1186d6ad5ffa3cba3703c1d464e4b75 063b67dbbb13f59beef009bfe3ec448412074931287a451d5e0ae659aaaa0da2 86a081d595d73496ad15e1cdc5a42cd724b3893938725c4713a771093a2029ce f516ff668a9a18551333153bfd494a9dd452adcf50add757fee9da75af8c24c2 e8ab5b596b7148cfed347c13292e836e7673e768071c45c20acf70513d4da39a c932e891721a344f94b5e17f01365b46a3ff31dce79066fa00bebf4734d1baa8 e874625207c8d7f774b1562a8a0712b9e189ff871ec5bd592d61ca0eecd8fe30 b950c7af647b27aad4566232f21cb5ca28d9bedaa9f9b0eea3e58a6da91827e8 025c2e33bd55fcc4d84f92a315fca2963bb04ab6464b47276f6fffdee432435c d4b7741d247fae8eab7e53121701298299b3575c25e8709bc89102022c3b9256 4a7229305c6998f1994212c543d0a11912f083997295653db291e650faf0ab79 afc48e0167842cde6270836b1119e6780e25611b7a13caec588498a4b579e3a3 0098acfdfea18b655a9f95d8ed3cd824bb880531c44a4373b213a59241d02811 37e9763ce203de0c3db4299a06051781265092d2c8e7b29af8901706873aec7d 10445da3a9f181ff5c7c656820000be22be13e5ee5d12fdc29f440a2219f7135 2d02ef9540d3cfe71a462d4066355b593843aad8d6c210b799945e9d3a52d2eb 75eb3106cb2d30a67029d2c3ef72f8e755f1db1b588d2972fbfbda6b69952ffd 3e308303afcd0dfb24c6e1e0e6b6625c1fbbad171bee85a143c4373ca1941b4c ede3e8865a5048e6959213e60f2df107d183a50605e3ce900ead6dde8e91f141 e709106e6fc2aa00a8f5d3afd957f94b3b043e4ef43ccb0d63cdc3916bace95d 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 true +check_ring_signature 2c90e7fa64e3394b661355d244e487d605a98aa968e773dfcf0300c574495a37 9251e741ee403f7dc7dea8d023248e56a2db5ab05c68c631b2eae5b3806a4498 15 02ed2deadbe1ab714be5d736eedfca6194f536fcc419e87cc0bc9cc872ec546c e261d83cae8f3b3d90e449085ad5e584019b8d3184610e2da83510ac87c137e0 7a3e1f7fbf3e0001bf888e5fd23028b1af07ed1e7e310eb595327f61a7b2a7e1 81840d9936d0cab5b5d27dfe06d9cf16b398b38674659a91d5f3cc5988dc9a14 fde159e2b86a7aded2cd747a05bc78bd8ff5a384f7f8d8237f4076c50edd16ca db3acf38cf38c729e91a0056ff1ca4b38c0a7aecb16555f476a44ab5e6f3308f bfe4886fb5829efe948da535694a95df2b7b01276c913ec45d39cc81e17b530e 3f097a3ca82ba61d21965d560701267c971244b99837ba0a7ffa87f1f7b1eefd f0a3c7483d48232c6a7771014d7de8e4bb23e6fbcc7493605dc0b464a30fcf51 4e957aa365f6ec443b3135986d8a7386f957bfaa443334647550be467092f202 3252bb5a65f9e4597596084bd45d12b94a95ebb1d50a1ee6b6e5da4f4b47c5c1 96c7cc5a84a5e9692939e24fbe01036dd156d46055f35b7e3d93d0e480c4ae30 a3b6a849784f571dbbbe21a59538e8e216490f1d16bb64866762f8b34cfd496a 98120ba24a86016ca522d06f809667264122158b4146716c667210f82f294f9f 168bb8a0c335337706efb1ff80cb75c7e3742de229e61b3b6bbd57c461c1e690 3989439ed9f869700e5e10ef4acdf9bbc75330cbddc66d0dbda27bcbbb46880e2927a985e825e353a6667ab63f817414bc8814b38ba285da4f72d9c01671c10a600905a76842dfdec7c3ef6730995eac8ab1de419743b0f01bdd6fc17dadba0d0c6e5a38eaec33c8dbdd7fc90cd0f58603009b53867ca84e67013d8762e7020f79752994761d49cb44644a6c57b80d659baecb6175bbb3070db2aefc3eb76d0c17201a9aef485ba82f38108be6ef53b5314c740181287dbdf3cb12406bf2b8039d1d5e1b554a393c49f408060c6b95c36dcd76ccc7e4485f285dd663b327b7081a028d1ca4b23922486ed0ff025ea03852646e98b9fc87cd2bf2394f2bd6ec03bd68f45cf4d736492fa64da9b91340237773fe33ec5151ed5c1ed3c9ca8c7901fb38d53f0ff14eea82a9a36f0c01abafa060b40a9ad601718ca4ceb9880ea7084c2420a952ae2ca57851ce247b911875d33a6eee6674f704ed1eec6cd292c30c378d9603749a2899821d00570e608d6ca070ab93a0e05cfe0aebee3b4d8b2003d0aaff6bb9e9367573ce87d7d2d86d12e37d85d774a728c3f927f2a84752600c58f8267ff0a2f9fbd2f29c5302eb4d1bafd342174b037c68b08517f606e09b010109873e3149a07b981251ab07f21ca5cf93fcee3b048aca3de1f2413dfd5307e03e4c38c8564e2f9b7f837ea7952c8f9c26d9ec347bca6358cb37ae8c39c80ef3f02ef276f4fd1fea1e18b889c14464c433908fd66a217197a3a3f2ff52b200755451f326b31ca06aa508bdfffb08407e2a9ab98cb3e671b4ec061980cac207a28c9ce789c7fb925d2d47bb7fd93cece7f403955cc748ae3e9c513b8a0d76049e110f4b0846f514ac85a1460b81b31fed54e4fde430e076781096a8451bbd04914268283425784257e56e5b5bf1225cd93607dbee7aea7b4e48ceda0415c707d6b52332dd2500108233176c3cdf2598366e8d2cb79c9b6b510fe571d0e6b102b8fb68cd36d4dfaa1cdb49ecad1edf315a0940f760b446b1ea5fd47c76695800f10085a8d0ea54530c26fc3f70c9425eccff32b3dd785407dcc1bfaa982f280452963dd4e9d1ebb35c8407ec7b6717268696ce9b0e40bafed20ae6271c83a908dd0a6c8deba1592ca06917b404a15c4cc9389a4b672165b3cf88a940e0cc4507efa4c120c006d9520e407618760d13f61336935d728c7e289763952c78cbff05ed0159b81ad1f0e594fb4e8213ec4f8b46fffd2bed9a6eab49bf3df2503d0f0cb3a6bc9e35ad57201ab9eac3e71beb40c61aa76629e6a54d02f4381b6af77e0546f672f660bfcea2aa67db4b8cc84bb7bfa248167f43aaa8bac8a6782ffca90c true +check_ring_signature cdcfdb5eb36863896efc98b5d018294013410b7f7b2f246afa16458e54838416 559ef8e8590b81fcda4f3313eb8bf3e82c8185217b73f18b857c05e3b27bd947 106 9ed9c8fa58ed0dbf86235629f72875edb6b9355048aa8ba3428107182744e9b5 e7bc43d2924437550423495aab3967d49ff430f9b4ef7f4469957b10f2e478d0 a47f9bdc0250765babd00114e6ae737de289ba4a61f79582b8bdb5d3c66276ec 64d25af001a321ae0c25c1283b21dba5e3b2e4c0ccc7570cd6b9b4ee8272e7f3 b8c02aeef2dbcb8396f9c31df44226da755bac45645b9af5fae6f38800f71355 627f6c43f92d267471f5cc25145436996d4b408c7bcaeae700e07e5feaebf417 0a896a4fcb3d184f592e1fabe39c101d0d464dbc434c83c65ee3dbff378d33dc b8d0f9332afe83bc4307a597922229706d568952ae249bed8182d1d6986a595d 3359ec0384052f5b26f71488c5c1e1afd71ac368e2da45bdb7d2a58c8783543d 7e682e2538470f41d68a4116e692e58336c0236cadd23548e3b765f0b343b8f5 c4e52f0a9b4f05ba42d471ecabf780ce5a093ce62065b033029cca2c45be90fc 97af89ca6484f919c9cd2a45c7da3d221abe4b8f7c576275205ec6aff94c30d0 ba2bfbc9880cdefa36f5e6355dcd11d9b4ce4aadab1535cc303a4d7d76085ff3 dbdc310b2c844e8e9c1d884ef6de8d88d581899a8299fc3b0e6743177b679811 b873a03c6fc1a3aa173263e4a519186b19ecd2b1c2d0ebc71fb6198f234523d3 7b2f53293323aea20aaad1c97f3737607139d419ad76150fad79ea21380ec5b5 50adbf6160eabcfd84e948a4c2d59ddbab5cca97c9fe3832c03db9112892ba94 7366702e3beeaa007fbb87b5ccb4dfd9b31e3f959a451e22426d330c9721e252 cb5a4f4e81356c4f4fe2a535ab30d6ba765c91a3feeda445350d47702139e8a8 ae8a013e0bc133d940c8a99b847bf7865ab1670654fbe8b73674163a6a574134 6578d1f6ce967d727486c32c82dcc24549d88a60376a0f98eda4bec9800ef8fd 8cdf67f8400552fe8d645f012b42b24119ebf6dc83b1d31bf9a8b9e10b7e01ad 2755e9a0b316fcb00c086c2fc138f01451f43b7c7a034b882c438ec46b288c57 538ec2496278be090e3d699879c3baf69ffd437ccf9bf932e671cfb3a14bbec7 56d89a096be320193ad7b63d7dd32ae7feaf41c3633f0f950933f0d268f9040b 058bcdfea84ea161142d6b3d9bf601f719e855f80c80f39c163c844ebbe50ac7 51863c1a31d104982e6645e23ca107e0c519b7e70dcfd561d9d680e3a0fe5f5b b326ebe51565bca048b67c4b755912a19f2d16bdaec3d26219fdb50cd3407e0a cf9eaa70fd005ed71006aa41bf727e026e7b950b8ecef6c1003e4848b01a129b 28e3011f9f629a3aaf425fcd5dda14f29afcfeff9eb41bcdc1e54b9dbd6d61d1 3b8cf7859ea72490a7ebf07edc58a9842bed34a3355b366737212695f72a25df a18a6485fb0019857d6ab543f33b62f965fbb90d8f260e8a87ec33c1f531d50e 630df3ca46b4f7220260b8e7b38cf4ce5ba0f4cacddef1e0db621d6fe8c26cb7 cf7d396a8a413b6f14608e8956b45236f352c295e06601ca7dc448ae578f8b46 c4daee0562496e23f964b12d6e7b4685f1299170ddbb6d45ebf392677c2a1cea d2e85b2311595b2f35e53c1f9b1f883dbd7595458cc8cbfd6b377c6fbe327d67 ad355e8bcf0199ba4ce00e651837c5c07351cc6b0e61a3a585194ddcc54372e2 241fb53830773c3034f407daf654bb5ae7263705066eb479f9a89d9eeb82c698 afa196147b509fb980656a2214555f0a7c2dc97186aeac01aa83ce88a75dcdf4 8abba5d549a1b60b7c249b40517f8f13112897c4715689e3ca0efe2999e8131d cf0b72c49deebdc2c247460da5c272d8049777643ee781ab0eda4134048fd8ca 5a3733455630a9ffe7a5dace6aad97071a0da4bf03aa8660c0f9f2aa39edee1c 98ce5ac494b54780e9c79dfc8d1811ebfa695ab92cb0f6726997a999b78306e2 ff18149f6a4a5811b8293af513fcb7bec9bbcdb1bdde45d4e23e47377cf0fab0 877a43055106b48607deda0fc8a26c46d35afd9534e5ec8db048dfb3273cbb05 9572dec37fcd8a7f2ed87e59448c05d42448d28eccbc3ff6489de32d3299bd3c 1665e49d00c27e1f54f0671ebd92fd658919898db4ec7fcd1f2237a38d8f3d14 a081a13707fe4b57084b9bc9b02cabaf52aa7a7ddd910aae6b79bb2cc221fba5 465c7d76cd07da90e97961b27ab2ee521061005bce4aebc64c517e238bac1fd3 fc51ea9a9752465f8a4fbe6ffafdb49089c233836b2a265012f4afb32edef207 19def2f824b1adcbe606112e64475dc8fa77ce2a7f5e38ade558c62ad3904856 8b0223760fda40f3ddf586aa227d681dca8ce1098910f6cdefcf69e28db4625a 3ff495513f5e08946e5a959ac0dd20801d7f09cd3d4e920cfaefbf1d9411882d a614d24965d83d97e2fca4ca6f2b230bdda94e660ddc1832f9e362d59aa88d57 875c5a2f1ea43c3eee0cf4d85b9aa5c96587ab515f53cd92338ae1a438f0a7ad d0d8af448ceb88417b972e2c976d05de3592474d44c28b8131cbacafc720aceb b996b33a47fd347a27f7b9975a4bc4b0c79e75c99898a836964cb500e6576cd0 4c26dba10e2761ae939ee180748a45c3b0194d714d6b67bb1faba11866472bcc 087ac74e3b2e382ecdccefbe438158ba867b8521f56ee61c2445800da3869942 f1fa5a0e5dd9f9830b1dceb775d7e3559da8343b0547e50d5d2347c562eab837 d35c0ee3d70836e895b9fe134fb74cf89f08414bfc691ec3bca3f0ce6878de22 99e7f270364c5b706e67d2b96add8c71d69b95177d76c4c0dd0335a955d99ce4 d13d8d2580abc7c823c1c8feb44e0157d2d0c88b2647f505dc5016a3f37d2f7d 1440a49d53b1312cf53acc653ef8af1fade7c18f1412ffa0d9b80e082b14e7e5 9a453bb9c2bc69a34275e896c015d1a0ea5757a0f7312d44909da9491f1286b3 4ea631093c2a63cacb7a5c16b4ad291c4365ffb2ee38a552e619c4c20d27ea8a 9f4023aa4f1da54310a904f7f0fb0059b17803dafa67375e6d5ed909de835c22 b0be523a032f0d2c359d139d9c1a78410967ef02bd39c374a208f56e3d14adfe ae2d55d96373500c3b6b5db4a868a0f8b785b7f75e855db17740c066c53e54ab 3cbbcdba7e8c586eccd1ed61b47744fb80ab8e6bf9d040b4c6b963fc8177b016 19e34d0f28f9895d48711e70f7196ee0bf412c4612e850f0179986f3496aa9d6 8aae3a7addc3de1e0b60302c85076c4bd009a684710279e03b84c960c65e502f f6e2e275676e9d623e0d5acf2d0571df70e44dbc6fd42b2c6b5bc1bc7314c4ba 76220bff83a0e12415ed7566ab3db84eda62546d4b0a6a94fe55706a5ac2d0ca b12912750394ec5d0d2924129c4684edbbd0b677e9d1c0d840aef956c8fca02b 729cafe12460725d3c86d81f491e3edc70b3abd19cc74604708ae97425df5f3e ee48177fc038b9ea25b0d7ebb84628857fe87f15e2fca1e79711b5d9af4576fe 484c454b3c3fc4a360311e915c76f18e110427996a0b168637412b6cdd509bb8 8f3799434f9a2cc23ed2a9d01d79ce294b9ec328c8b2ef010549a8bc5455534a a1e2c4b2d171499e28bf4feda715676472e477812ad742f04f42bacee4ee4759 6ce982fc00faca08ab6f120a80d44724f85c6894a6f36d97b7e15029626e13f5 0cb4656158201f7e42f7260c290569ef7abff3538dbaeeb15657dc1081fe828f eb9331e9cf7020b6bc1efa11e229b85b5b5f55198df96302b1894561e85cfa2f 5b3bc0b095164d8e9c852b988254805c39849e936ebc395a5a92d351fd0d9717 751e619dea94523461a032b1a5864c097e9b9ec1f29cf1670ff58bd8f281ca1c c10e088c83587811df782eb4a8a3c79c2e28b87caa63744e5371433c95887e49 b2d6858ba76ad720c879bcd8085b47366a37a27bfb50c9ed030953c101dc5ea3 ebd806a151394a75e164bb87de227231d520e378496d8e29fe02d44053f33d56 ff33459f963d9b5ca2b694721f29e1c4e8aa6ca71e740e1d3129a4c0bcbd468e 46dd0f46306b31ddc190d950a4e65728f6794328602dc08614c25832279cdca1 457a9bf934bd8297f884919d7623268375bf862d6c3e50f309224d7977ac0794 bf7f0acc25df581814ff2624ada93b9c35535e31942df56aaadd76eaa78a211d 3d4e11efe050e8becb903bc01a9c0b68f33cc78e269bb55e09b2da67d9e4c20a 773a9f78bfa57ba3485ac5a615cbcb786d1439e86481ff2b9799714f052808c2 a8f7c939cf35dfd7734fcb4472bb48f49ba08acff58a465c672005ca94676766 7f0a62002813fe991a0ce5a5d6934bfc7583cc2ba1745f3ec061049c9bdf6942 bf40fdf4093ffe5dc826d7fa71a26f86246204727094ac95bd74334ae467b769 70943d95f0830c03d9d0dc4547371589872017d33d977867971650254fbbc6b8 162cd4b91a7db76be8a3066169d2d0e3352a855f950e2834d3e82d764e7ffa80 23dba89e71a9f7895e88efb946b31ebc2647a46334c25c8f51766c49b0716895 80bc55152b115281739d0b6998981c9eb02d510f8fb2358aed1504c89ef4d222 7f0473285da1d6701afc1839979cf6ee0762c8da2160970c93526e1aa226786b 34457d9b32e186927fc7157ba5c9a6104f18e77b499852b23dd94450cc411640 89ae47dd58537d1a3e77cb698d652f42ccb018bfee57664fc048900d0838473f 80245858fe7b04c9e76a0531919046dbc5283f0015c41bfcd8673a821e79386d d655ea8eb7a4d4d95f4ec958df01cb0325866aa2c2fb282656bfc0ace0caea96 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 false +check_ring_signature eb5a0d2fb0759e13cc724cdf0f840cea0ef06c544f76b728b56a32d9a3f888ad 9ca4f8a2166485e62f6f0d8d7b1ffc7c9e39d9b710d33a18a3ca72a6f6101326 76 751b4dd01e166b6ecd5107969934ac990026655a37bdca32ad17c124a610838c 0839f02dab1ab4e5674e8f82e5e9e61d7d25d414aa78b8071acfb08d1e9acf66 cc28590e9ae2f2597442ed990ab92f902170db16fdd91723ded39cdb13e7dbf8 4644e50e0e2e94df5bbf051ae9e1d487d6f4905f86f5b54d98d10e58ff9dbc12 cbdc6c08efe12bdcdc0c9695ebd6bf1b29aa860b38dfaad71198e064b72b2bda 2fb49fd3cf917e312b0b09035a1390f543b3ecf1eeb42c5e8bb24a99fe37a2e8 bd0eeb059f029bb8537030c94114b3dabc9902f5de136214fa87719bb9d8dc91 27864a780b0ea5be7c3c450dc9a2405d7dc68734adfc79d5bb215d96ee5494d9 6ee0a30d0f68bea7270e185d9ee6b51721e5b576f9d1b2d872144daf5e1fbeb0 98845dd51293e0927370d0c237f073a9b5eb893ad27e0e32379d4d1b23b97c39 7b1cc142b933a154379f65a583d173a4fa2567ee44ec987256e2a11c53edff9f 670ee1ec9d01914b08f510198d5b952271b0e2bdd70340a5b1ecb7aa9b178037 1754048b5fef34d2a0ecaaea91e9e47763162884e3e36d5a21fa51236877ee8a 926f5e525d9c2493a0f94560d5be3f0ee10b6a720e0cc88623fc481d1b3cc415 97d165833f4f7a33a2862200dd30ab60ac5442f2adac4976ba0a631980fe9d1b 1cdb7881d4ff3ba4b3f720889f86ef1cd9ac28c5f07336097602c1348b708371 66df1dd88d3748943a0715c09f2ddf3db839a5dbbda63f4dd25f4e39eb64a284 0383d483e548595a90fc86545a34fe9c0a8e3f8b5465435a31416be2c9625402 339ab1b70c94c14d9c8cfe18c7665725dd43751933258105059cd5ad275d28ab 8c1dd965d0efed274535c1fe8ce3963bcf1fad89e9736b7e10d0c46e985d3f40 caa5cdebaabc399862039952e6d7c64a32eb72fe7e58192f7dc7e0e2687e960c 11e29e5feace00a663c89ed4ece8b06c0b01cdd90b050951d5bb5ae08a736a47 f233ad66189b42ce52d25a1741eb8c0014dd6c8d83277c6ad8183628c95bc72c 23dbc06f94cd71d61ca58320362f0c4d90ecf1471d1c6c5884f610aabb564394 476348bf2025aea83796f488aec62756dd6ef571d105197778d45d512b67120b 9d43a9c18b078fe26df6fb0d77346ede46e97074fcda52960160820059aba14e 5c8601bd3147afe58b958a219c05541fbf4241869264d0a4c032e1b95a60a7b7 8207c8ae669521a178baf0276ddb5a4581f1eaa24e5fdd245c0926ddfc6daf78 a5140ec2206b65d7bc28e5200d7017ce122eb8c9201a0a19cf0ef44f8ba1c164 f1f8bb3945cb321b50a5d72eb0a09f5d2dbb6ce7bd76a44c8136d75e0a68a1bd 48f44d17876979b1bc0db8e4b4fbcd5f4b6e2c8b2169002f910047b238562b8c 16d371d3524191c468ea9749e8956cd84137493e4bac710d06b7b1f024cfc54d 5b347c32fa40bb7253f53eceb159873fc5542e79925acd81bbbfe8a7d9db53a0 c575f7613fc952ce210608a5d3710f837f0dc557ead1c266dc02fb4d4e60b5de 859b61de64696b60eb5e7a801e8414aa1f3057c95ac94b880e345587dc004fdf 37cbfe2d6a16ff231b8597012c538014708bd79d1cee18e30aff918b42ab2652 644cc43243533ccf766990db58e64e76dfe48e1b1c038559758911ba89a8c62f 154f95eb55460264817b1a580eb0204a849df613cf3f5e9ea46da546851e8e89 a749c1d4ce1ca6e52b38374c908ab5b2f3539c33b12bc03d7224bb20ec6ca95e 10c4dd0507834004fef2b0cc1c7f5bb120585142cda2061062c66a2694e901e8 014af8691e3f6d6d0ea71d24741ddb3047e524e07cb1528e8dafc20a6e61e732 60ea2445ff21b97bdb503e54d88be7000654a46dace3908e92f90484a2f77e05 0aaa73ade3bfc97a09c9da499fe9fad3445822b808b2e53635fedc39bc74f6bc 0ce94e85413137a099953537884093aeb3b9144ae93556a76e3c3bc5bf199636 9d06e50ec87f127efb1d6880772673b4bb3c2cb3eb55966b0daf67e9dfd446bd 7bc62b284a3865adcd1ddf07ccf5724049dc7bf4ee61a4c7dc79649c66043f98 1d227d0a973dc3de5cc915fa4a8bf37274e4756e645aa81668d33fc7961e0a2a e9336ccf08921864a3747041a439589c90be2ea9b76d68a07c20a2a7452973ca 40918051d4577557c67ba228218f5387f253194616f7ee4cf3c500774cc1e255 5ad2372438ea3a0df0eace2991e4b65938e71055fa534640f0b8e8cf7d3cbefd ee259251205800450353a29fc37db019110124b1a1567591dc81ef59e43abe96 598da5aef6f9afd7d9bda2b7e6174094f6f16541e20958b389f43c815004fef5 31c4b90e93449c6b3e21e36dc579eb9958ccf9322ee91e83fa246efa9842cff8 52949e838321273d8a7cd5d206070987fa4a9ffce5c0df9da849ca0dbe7eb1f3 ad14e4a666a8110e1a526f3f9cd0f893ecf93969322e8197c8ad71d86a7d6386 870e88631350b18cc9b53c4ed9e602dbcbbc9cbddd4ba54dab417ee68720cc1f 4be388cdf0ddbfd96364dae5772f9315892fee86297e6bc517b57e3d8b432bc4 7567d6de2aa43956faea680b155bd360e0de0897f983649fec7298a3f9a0aeb4 06c09f0424484e43d945b665c0c3820da4eb414564cd0d281fe22c20b38b4d33 de9099d964559b3b296ea992de026b45f356400b5c188aea416ab11ca132ce13 03dd0c7a65249f04a42b980a247efb7d745bd4743df9216bf4995a71c4d85f8c fbcb8a210b79daf1f1ef112d8d9f7c7bd4458cf8838bcfbe4c55e872ce689a4e a4463f51a8e39206b0973935bb0b568f59e88e69367c095d5a447c5b12599b59 a9d8f6de17e9af400e7199cc7dc98dd2c85f0b1fcfbc24fcac60895dc9640c0b 0f0c2e0dc92ce977186f14b3726d3e4a844aec7094617c6858f1aa3ff8cd59ae a0303adb10a8f3724b495911e2d25f4cee9a5731ef1545732a06e014f3ae0fd2 0b91f239bbc03b189b884ef281e75cf660371051f5b9f042f0ed1447842def78 ae6a9121474cc2ef9e3195b9bafffc441cc272311385877f6d314c5f1ffc8153 81a67dc84a2ab74c1faae38b120e3ae35cd4077e1671ac65d691ca1b1f5a494d cb9d60c438a839baca36372d1d957ed60691337b62f7f05f751e92d82c98c140 1bbd911b5bc46afb251b215e83007e6cd053a6dc0c5536851e9932d9a97a9c6f 92e5e35e04b06b15e532a87128f039eeb1f2ee477f3741870068d66902688cbc 9cd05a3ca4c1f7c64e8e3e89947847fe714d734b6ed46905542439f02830468c ceab488011b27385945cd44eede1239ca716fb75daeb068bd7f6b35a9b452fad 2414352d05ee0de0ca76df29caf3140ca8d086ebb08d79701f63ebc265e15c29 499b5f5cc0b62f34afa1c3f7102064b8dd12c5467d858f709561f4714fdaa67a 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 true +check_ring_signature b363adf84a09ed46f5f89aedb2a3bb2736a7b9655908452e96ed18b949808917 543c049192d1555ad5682cf8a8d3bc8b4f10f17a239c7fb2cf1c62624be2ca0a 50 a9728eb1965955588445226314fafdbd7595930517303b62561cd65330bb23f5 3a7432a9bca4bebb51c4dfd84d19d6c4bbb960b61121678ae6c1bcc2c8b8de06 2b17d4f11d86fafd11381e9ba93f08d15234738006df0dcbc1056fc3753ba6fd ae5daa8503a41060f2e290634e075aaf680ad9afa7e893dc63e3551346e5ba8b 1256389f1aef20bd0a7e058c6ff8d76d8a59cf8e2a3b9414ca4426fdd0238df2 b842dc5fbefa787d3716a717b34959f9a411e7f829b6dbba3fe2caaa394fb982 6ba2de19f2cc0dd4b6734dc3f130e46fc5e17fd7c15dd0e3970e65add4b2d740 eccfd2e5fb2e1c22ce6b3141d8332ebca586fdec03cf48ec4d9e80f57ecde26d 82d0783a72fd43bb96560edc73c63782203737d615446af0c14020809d20c78d 9fb69d9ef51ebe0e12711f19f65ba85fa4f35cb46a3f24ac0ac72d2b11d9b092 ed1e54c0507022dc454937d0c2217357807e39b19412f61e8e9bcdb985b5af96 59bd9cc06cbe74c97b2d29c56c50b57e76577b2ba8c66596e645d8e98c8cc08a acaedba8c72f06dfa40768538e21679c5a54ef05ddba35572fb13660734ef372 70aa7f26166c25655b0d10f570aa4031653f885adf7d5b1e38eb3c9dda50e2b9 d95c6900a394d4b3267afb73ea5fd7f1855065cfc32609cc87bcfbbd817ae5b9 91955c6e36164f944194be372fd01438deb00f2bd967cb90cb704390d6c34eec 4dfa7e942bf4d209533528ba176ca6b7d4bc0ab674f36987fe8b9699a50df8c1 7a5794dfda5a6734550427ecda9be6f4faf453926e3479d725fcf3bf8e2ab769 2e5efbd3eed3c140aed864a9fc34322129f005cfd61b4263961441b25b6f28bf ec44aa27132c059bfb6618333125bfe3bb63e3c7eaf6825df845f2315b6d3223 470aaf7edaafef96a2ee970a6bce2f3a366a95f1ee3258053ed70295d09f9b2e 27bd01db84a6d8c4e7bfb210cac3bc8cd33c1c3e85f9131b4e79bdf174829de5 70bddaa85e3181a1fe70ef5b27a0221a1d4b1df01279f2d0447f16bfe5b5cfc1 8e9ffd67c6b5fe42fb39d17613eeda72730c4ec750430568c5fa2459037ee266 b3a60e3148ee8a9c33b9c8201f3a943c8bd6e9cadfe05ac957215c256b8b0008 495b9939cf276b47d3786acba8f06a92c2b4cf390837710f23985714c40bbb9c c7ffefcff92c174a33c226546ce2dfca1872ee71f296b95b480225f3d03afe0a 66edb7b45b9e5848c99ee5ff88210db1928a55879beb1b961a90c04e9a79c222 568e7be366bd4906833015a8ef9c579dcb58a24b802f9e4d5a4de1de88f52471 1a3715e10b4babd3b3af54355708a565bbabdd14fccfe3526ce1f2178c456b7d 1593ba399e426894c9384948edf13a8f29c6c1564e947bcac4a15be12120abdf 845c83fdf69d5cbddf9d5f173bd5728222bb82f9c9d122bd275091294752cba6 18f3f851b26aaed482f6adb301c95678be99db2d5f3e6d512dd374a944996c7d 3f654f7ecfc8fe84b4a8266ec1b7d62c7d572b2ddfb0c424a74f6af2b0371bb6 cbe4b7b900414a870ccd8035af89c3b5cc98fc13b7eafffbe5768cd134d9e44f 37a083a2ce44882eaf7871c084d822e7fe446182b212495a48138e794540744b e0b4cae69a4d966add8ab9a15af6220071426866baae8087f89fc2d56c0b2549 1dd98c5d28113fa084cad7d8df9a9a8e1514a6d6eabd72f0d486ecc3c9351738 57321784392d76a1af1fa882a38977fe83d770f92766aaf7adbb84b75c85b7cf c17518930f8a6a417342d4beeb0100dd54ed7e7c0961c5a9c938753164017a23 cf8f8fc30b7cf61b5d46915f7f3a8741a3d55bce03a5f2a90757b1a1baa6b239 46d1714c6e9c5f2bc044a3306a48e4c52d2971cee768d94ffb97dbb5e264d6d9 d7d6c80cfaa7fd789aca7a9cf320287bf5519e7f5c183cebae2edd571835f80c f8e46926dc6f70fda49bb5fee5ebe9afb03c4a4ca1e4523460f43f6b8d814e27 b359df546107ee43507fc051a448a3c58fbf53aa4b4c94ad53f8376396ee9f76 310ed0a5a89bc845d24752e967970d019c8823c81c325ff7d74b718fc6b2d22e 1a937767b2d6357907a92b6261f75d427baba5aa3e0a3c23c05faa5b84f1309e a9d965d9edb2e1c55ba265e1e5ad541a47b678e76f7ddf26b52007107e5056c3 abcd3ebab7ccc77e4420079acae90c5b8e620a44a98f12f71e46c8bb0e284a72 c8005b2459e6767f1c290e68e88ab5daceefc47a6ce25ea996d035f9caf96823 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 false +check_ring_signature 3e076527ef0ab84a83851d8e234766a92f2dd499070c2318dbed207be5dc0573 bae8c0e791490012175a71ec066513849a2d670f1aff716ee2416937e5635c66 3 c2d0146763d8b75ea8fcd7088a8463d3949f57803d84f6a7c8ce530a9aff62e1 f0915d88a2e1aaf057c04d00f05854d3628a03ae15faf62465580408fb2708d0 b72b05dc5361cf06d6bcddc4bcac7b7c76f20d25d45f89def11a4914615a6ab6 91f2a1e72ea751963527a5c3ed4fcfa77073fddda3aaa90250dac6858f972e0d1f5c6f77880f09b55fafb756016d872d31f603ae904832c68821a4209995ad097491a2821c42490d1f05614ea5c4831da28cf4622ceda8a3f31044b039eb77145caf151e150b241846ca658d6e4a535379abf70ccb1976c6630623c87aa96e05003024d0e062f2124059ea708013ae4b17f5a2e00df45a45ed3a11a1907d6209cd519aff3b822b296edc780f6f90d3a75aa899ebf9d24de5843e6fafcaf9a202 false +check_ring_signature 6802c66f91a6cdf9422da4d64ae8693a2c05f73ca93b57e0eda74ec35572c03d 5b21d9c182fb33dc48b88987692728453972352ad659ab605bbb2928578abe19 1 2c27dbc63beb164ccffa9fa9f65ebaa78fa27a12139ddef555948af4177e4a1a 80697696d8e8ce11caf8fc54003ab618112b7ee1d37fe981bd4a77974cf0c624b4d073742901639dddca5a0186c7d28a086fa4aa9af1bb6f3bc342495d99cb05 false +check_ring_signature 2b3a4b1259dec4a2030c639fce817839dbb63266ef9adbfff0d0114057ad0961 524784b1bd8dc029637f58c3a52fa7864a91790a6b40515f1f0631185dd3ef1e 1 29c5b554f7e8971dda73ff863fbe21f48abf704e6bdaef097ee5dffeb8591ae7 01a96a0d4efa7f216e6ddb7979aa65404eb067f1bdd6aa780f794af3db662804ceed55345996b63c60717bc57f7231866220228e3d47eb9a8e05f377787ec16f false +check_ring_signature edabd596e76ab4f3ed255772da4924f1e8bdcc80b156890ce418c610297fa6a4 2365a9b1a96e64bfb53737bccebf694520ed2def59f70ab27a7b6eed594cf557 56 c13b6fcc773663602c5826107fa84fef70016259650bfa2ebcadec00ee27a552 7131ceb9c1605341146e51f2569cebdaa9e068ce6a6889c047c2df19c3504748 5464e4ca3936803e899e0af542a8eec7f2008925acbd19ba19140a64258dd640 1f59df8689f0343baee782b3c9da27cf341e855823bd6c8663d78fe1c2b65e1e e3e55e813f62ff06aa9faaf43022f582981f2f24d14fc919671fc78614c660c4 a3ab4112780cf9fb801e1b808f02e09bf9d4eed55c4816eb9b4dbbaa00833fc0 b074ab1ef7c756e5952fc2fecb7aa6572ef61ab922415724046ad2ae4e12c682 56bd2020e4cfb7fc2a46ee253bf1fc745506432e41eb44777974531dd36fed94 71421d4656ad4206e8d73757205ab6dbd93f9637ab7580bdc0178857690f8f77 862e01d0d874a2038fe192e1690dcb96f7b92a7126338ab98ec255ccbd2b0575 a30a36f63c8fd57091397c60a437c4df468fd4b512fc730c1a8cb0300da3da66 9f95ac73304cb2cf4a5d42f25fe0d178832827d3a948153e79a444d4bfcaf167 cb6577c16ee638fc2a01ceeca7f3439a1d4c847cac6ebba5db47bcd1827064cc f187e631f6973648f5aa0e6f60084323e36205ab4543bf614c02fde7ed4e6b6f 29cb5bad3068d255ed2d1c6175ea8106f579920bca151ec2c9d1425ccddac849 924d34a68d185cbd3f1ddfe3b26adc8d305bdc5f2769fc11816fab3a09e32775 cd80d97404bf93af32a43230b4a4c8a0eee073703629b20c8478a218c36613b3 5b6f12b6364d07a09063985c9c187213e8a2cc13706fdc5b8e83a5c6f07a25bc 0acf47d68ff65c483ae0c9c9222cd3dac7d6e390a77286ed6c5e56f4bc0918d9 0d75509349917df60b20ca3bd8d1dfbc364ea8643bbdf058c4b5f6b831cdab08 5c05ea355bf6dbb49e20f8dfb372962f998df5045fa05f248c6cfc5f7af123a1 3926b23d35c20038ff05310ee6ebf956f1c332922168869f10678e4022f72388 ade549b4bc312327e32757933fce2822b87631c688e815b766e21dfa495accaf 41b12033005b4a28cd15c42bd86af10f1143abb5d746ef5e6dcbb6146bd04891 6c83d7e2070eaff25fe88b364b7beb39baa1ce704be13a771924809d057b6fe7 87e769f8c02286c6530924e3da4e332f0a9eef2bc76fb1b421e751002e8b01c3 7acd62ddbeae2d96379e5d804862a427f508f03aa7b6bc247c6cab4e6296e622 9902d7f29422c2fc1a49e1ada7f39dff9e58e06b2d32f4d865e04c237bef6adb 96252c25ba5cc218c45372d75e98b988fc3f41c05f01fb43beec53a51a859f0b 99cf58906a788d69eb3b640d634117228c2a62d26e070fbaa25a72eadbfd6565 e3424844897221b67f8c5aa47c17799ca5251bc39aa7ccc6558027e2dfe64b01 c578f748fe72d4f0bf510ebf9a2b2362f5f5cd3f5585ddc6a4afb60e32ef96ca a8c64376202c9dfd1065202584d9ca6eb3bed1d702ec76ecc040f6e49994f9e6 24d066e038836d4f6b03678b86f44a8ed2588c744283484ca9fe0cb3da14feb2 12160074f6babdfae5c2719968144f5a3a2522fec0f557e8f7dc4cd1c3648047 cc8305cc149daad6c8e337f29cbcd78a25fdab1ccfb701febe19ad6e9cf37d67 690746c7452f55d7d285e5704b919c239ce042bfab85a2b6cb7deca607d4583b 01d24489cb6ed256347d0615a3fa3b407cf0c3587a82492827e1c061d00dd47d 0a23d52d412e8d7c2a1e9322a281c64b717499660174ffe94c2806b33b7672ac d6214de412b65376dae6eedbd818328f88a4e40747c54127a570b3b0215f6b0a 0ce938ef9025d5837c1f889d9a00209dd398e350604ea85acb36f77e4e3b53ec a6ba28ff734329d80373a718b23e3ba4755487c90c84e8c8791ee966e73eb9bd 05460df347929d4fdb8f3731c7e7c16fb07fee63b43c9e1c3520afc26a04168d 3840820c7ca3f68c111a10ada29fee864e4483dd771c411f38869ab2a71fb009 dd6c66bde28392165a76eb5c7f8e5cef71dea3cb57da8ee9714030a936651f26 a7791946fe06508fe6351e7d28cf0ba29e48dd80652b7451deccfc49618b6b2c 0b062c430ec7686336ae9285f1f8b4313ba7d8b651777bb84445eeffe5cf50bf cc30f77905dabc5c227d106c1b73c6518bfef20b771db2fd3840c8ba5db388a7 a6196c7e0c3c0da8d9ce5369b5a40cf0c8f26b5e04c531a50d6a5ed0cdeda821 7824f83701971f5d204102c9906c8e7172389e590a91e0b7d2cdc6faa48b43f7 0664aba9bef355c88d671e3b47cc12edf14910fe7ccc7c9f9bd1c7e7012257a2 57372ae9ff3a1c07daddeb0747696ded9dc7f10402bee3e11811c546744b0c82 c8422646a6d4db04d4422ef4654accbfa40c228506bd92475f9e6e3691fbe6fe 5617f15d5d0e5ea85bcf5720ee53a2070c88b4b7e2b497cf487c6a6811425312 e30128c9cfafb459a7fb2f117cbd82435a21195895087f9326879fa74fec56f8 40f5d81b17936ae4d9563c14d7ce7031db26d3460ca7afdf6bc2656efe2d5970 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 false +check_ring_signature f83f196da7286b04a03b6b1cb6c915d71bcf39de403eac81d12631848466e3fa f61e71903f65a963961124a3b9197f8cf8884516708196baf94d7628891d098d 14 073749a3b1ac7c4137ac60e0c94886bf201f44ffdf2061adeab8d146e000c64b d3d4ef48899ca1d3e0e3ca44f2aee80dd1df1d51a625214b19f03b43170f464c db9425b8538ac9b6e7ba3f3ede66c288d2e2cc72e62213423606e8932bbd71ca 51274f5223a3d711c11955435ab7e705ab6ef918b28841b35fa8f42e3d9a406a 0b95fa2651eebdcb58f950530798b5ed0697fb6f056366d66774055d1efe5ecf e01d707e9c50b287886eeb7e44e84718a6206d899f1484d74b56a203ce3b92f5 a5f7ab8e6aa7316b1e6d3fe96f72f1b31c78b66c95470f3f3bad05635dc4885a 951b81c6180423e751c12bb0d427fe5d9522d8c3ccab86399cde6ba9955dac36 607fba33b0ec458e342d48c512b47c2063bf098c43e351afa4f640c25fd24c6f 6c5c8eee093dc6d81d7890d452e6f4b622c3308b27da4b0f555f7f6159175184 5be10c59d846a5cf6edb31075b0013766446fbcb0d21ad4f75ad50f1f3728f7a d02aa95870189c94de6dcf5f19cfacc961dd536326b0749dbfced2896ec56465 8d2de4a7cc54212463edf06b28f0b8bfd6f5406c4eb674a427e15e6136ee4aef 15c953aab3ec61663937388386db1a8426e0738453b448f28e10746ca6ee9f17 90740432e39283632c0bc099f6bf3dcc88fc6b1c5966bf095c2de2b9657ef40d02959ebdadc033954679a38b92d66e149f0c18f1217b383c65f96995fd9bbd086d5006e915ce6cfff0c96cc13f44d57ca05a5b48b69e1b1c37d466d66f390e07c1f7db989efed65c43c04ac83bfaa131a0df810404068224e613c636cb0582c8d22d9ab2a010f8ec53d1465a32bfa119d7442fb5504ee087f43161b3c51bb303e9f58808a3b45ed6fba50ac803955ff30beadb5f90cd90c8889c34c9ccec28020cb84f52dfda5c973dd68972b557fa4d771125c5624eb704226b34fec1a84209b243bcc5df7991fb12296ed90058ce0ee9e2017fdd39fc2045a61573f157340acc1da0c24b264862d262b7fd771333acea08bcae82ae62ff1089861c996959051563d00a01f45f986428ec460588a44e07512f3afae79d6bae0a146759224e0338d2a1b722eaf89198d54b8bcee8508acaed8abe41cbd0ed10f325964548e90342858454f36bb15bf5a7c5533be874aef6868392d2660bf4e4587f1463fafa096320c326204fb98e13c8ed91aa5edc44ccf7992a7d51e06816a54ae0bf5078070136d838c62d5668ef896afc914848c0db3022c4e208ecc607c3c0ad1c28e0049f94803c8d3471f7d02b593360f53ac9362bfe1edd0f5cc6de41dddcbd0cb2093fb6c846215b9fbf5636a883fe1d977268be66393f3a265e5eb09a2e9341310a3cb4172748ee880e70ddadf42c3eefdd97a4262b5d57e3f7b1471257c4eb820f6faa2585a7b129808bb6df0ed2fcd98ef2cc296930e576937402bd085a9a8c018517d8ad8b3fcc86c9660e398534264c5ec619c8acb5893b55fc8c11c54371039b3df0afeca0131f124fb651e8949630ea2aeae1ef009c52acfea46c59948c07b5b088d5b462c4d81efd8327813680dad5f2bdff7b469934254b5f38395beb0c1df3682db05052a3c5b580f7f60e1e90223da0fcb1b3fcb73bdf247df47b0809b704da815a422ffafacaf42a0af56789b33be202ae0cbbc2891a94a5b12d7c05753b22750402154b583ab938313a5bfe417339885d284d54c1c1fb4ec3c1d60de714eb05062c8fd10baa17ae1cebf53a1dc194f9986a258444c3b746c6beb508e509e412f27a386ce098a0b844a943c9328b62e25e505765392fc713bad5930f94038fe6f4fb23dfdeb44ba09dbdf20fdbc466c3cae84da6a10557b85b04970122fa028bd9313dbb55dc3fb20ff9133bfee90fc52f363cdd32542ec1e4d53807 false +check_ring_signature de043e91fe973f74bc8ff5925ceea0c0577b2a70df3ba02fe88776cf64e53897 75d5b87ffb4b437bd9a693964b3dd41bcac6d97dd38993943af6e2bc9a9fae76 36 065c08f1cbea34b9f3ee53adf5dbef73333693d3f929a4b8b6b48526d4460535 7f0312cb8ee68eabc5c8b8fef5671dede23e20258e22458abfb0abe7a236e419 5a1b37366c7886d33cce99fa40c5298035453e082f9417fac7062da93f63207a a2e84aa4487ccd7e546ca9c9cba3d9fde836ee46f6233cea824ac2146d343b7d b89d7e3c8c6ffda89bb51269178aaccbc1e43867050793ac876c588de4fd5381 ad74b98047edf46262bd5372c2e10e7679a730a716e9fc25e5a971ac0dc0b1fb c6d5f401001d1be8c7960bf4622a5aa234cf9f47767ba49a886eabffd0564963 90a2aff61c86cc186ce4cff7da50e2d830cc47bdd41b7d99d92543cc33069e0f 166b5fabcf0b4aae6742edafb62e28113f52ed332fd28bf2462ad15be56a3e04 78f6a0b564117e48bcf1233fd947701f3a3a572fd5598a066986fe3726b9d187 e032e312a483068d1f6b1175b4d38f7a5b1d2b4c32eeb0eba8b34d5d6dd2844d 392bb5ed1df4a5bd4b30a22fb610de3122091b92b6bcd038cae6ddfc5e057caf cc3409a788d002cc81768f484db3a35c65e308721c537b7e9f2fd61299329169 1b8822721ca89e98f207ac8d44c65621f1f16fc1835be1c41b04ffc84417f472 7ea9bf66085566c3ad3d9ad11a69038f6327aa8ab7ee7cb04f3f342df3c1571f 32175592d803d0d85adf5ad2e7c5f78640c9830332457fecc373bff9435dd4e0 cc1e7286014b4bdbb7d78d4294b35ec2a5b95139cf3c90ee16ca0db6bcf92c33 02a68c9856a5639ede36104563bee4f4cde39556683c1a9fa48dd226001460e9 238815fae7fd2784d86bbaf22eed64e646b9c97dc186fb73ae1ffe4a9d615e23 be8b0251b5d5757017e94d65fdc8cfca9b9da38b9f6d9874ac998577575fe1b7 3bfbc1103a590e6a8ebe0b1ff20848eb54481d74ece08862f600e9c0d679caf4 44f6b81936291821096154be137fd0a6ede31beed997f515306a05e75babc58c 3a5102b80d0959599bfb4f4cc0e1422fdfa9af9eec3f0e7d6fd1465a03732186 7eb52f01a53cb396888ef78db3434f1612404bf5eca183896d6e007b58986ab7 239c827cb59cbe2b1e5f0822014f3ebf6b8fef692cefa29531b7c1586925c268 997d6491ec6cb6414019ada6bffe8256ea3a3607281af33c8d0e558864ebf1f9 c9264c4ecdbfb7391839e88475e335034aaea55cebe3d93645a8ec1755919401 b9586d01119d99a3576aef9160d38a02cdca79def23497555c0eae4c3a9983d5 8452334ac34a569e15872c3dcd7569caa4976e6fdb049b4771bd8aa9ae0247fb 825817cf153dd81423786c57bbaea0c569556fb547932694c1f19d614a708b98 6c86a24a68975e3b45aeca9851c941ba5077564f7c95d6468f86f52fbe5735cd 53037b41a379cbb3235321b80ddd9fdb0ab3a496303f1907b37346da068898c1 6e3bd2dcbe0a507f7df58d4bdd27e7ffb8d6828dc50c781c6b9de90ef40cc86c 1ef029766fd06fdc3f757ca57f1c0959059ff284004834d75871f5b307d5f559 e9682f032c46d443761796419aaac7b6b4ea05142c930cfec422533391e6f8db 87e1b69699f6e940dd5f5cd67b4213f16c9a272ba38c5c867f39349a7ae967c7 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 false +check_ring_signature 974964dc7310e6f6e66c32e4bcc4daf5a6fc016d7eeedf2ec7579212bbd233c1 3eab301e1c611e8971a7a2d5b2eb5c26cda7935425646fb8e09e14ab3d2b4fbc 109 0ff37c6ea61d4e8dde69939cc9078ac8827ced8935fce3f67cbf1bf3d955c10b 6c164f38e29ce6a9115eafbee567c62b9e037d87ae6ece35254c845d73209d6c ec5aa434a1f063ff68435c98d01e02f0299e643be460f4ce4d401d61bea7ae9b 390c71a7f6b0d1e4af1c843b4930d4605abc12770312227628576adcc6093635 dd575561132b995763e2f765f3bb9894096f1a9e3ffdba801e10ff18e8ae83db 2c3ce4dd03e0284e43555cff9ea67a6f1667945fdedc7afc660981f9a0f36d69 94474f53b6c989e005b95eb949976668500f45b85a9bfd9469a62d0ef57ff7ce ebdf4242fc448ceb4ea83c5eb651b9c8115acd846d3e759a02820f7d76d00b72 1311c5ae11dce952c16df210494857ba10c07729dde823c54724b72eae1743ad 69c5736482a9e733c95f03b12b1493c81699bf8bc0152ceb1a94975fc363e9d1 b0d01959888623f37eeb3e557983b0d2348d7cafdcb0d6de779bcd759691b64a 9c0a62a4be570e92ee124840dc4288f61621e1bf017039c102cf6019582a604f a33061a354abe0b6fc3f5592944b8057e74584133517618ecbeec5f44d9d89bb c442838f34863730b16ef7a9c0b79c8099e1705f998f815e53ff8ae1276abb95 92e85c8d0e40d90db2b09e2c0ae1b3154944879d98cb87c11af307ebd3844026 6f250ab6381bfbc828673355a21283589cae5c43a045b16a303de87acd8ecd68 eb46243748cb36529a7f11824f0377eb3d75dcdae4d71b594c285b5b2a848a68 4b0bcc06c2a62f7e975377a30c849df788838f1975c423670676e7c1018fd799 3dde058364248310c988a5cbfa6ff30f3b905465605c423968570e4e3c709e5d 56027dadbc753b3e07fbcfdac8603ad49c02927ab61bc9a905c5aeaa127ebb39 ea619795a7fd3317e8aa7494f8e1e2db0f72e272630354d5f8f8b0b4338cf4ee ed442611bbe1ef47212d0459d3307bb40da628d61a4ce456d21df090d1a03680 b9ae6b455fdc5ab135f396c3fa9de48d6a0cf1effc29b94e506a1e27d305727f f8b1f555e794562c8ffc333b9b7d0cfa4e905e3693897f7e9d846396ad7ad1b4 0aa2294dfa051cac520e3e54809f70573ce60117b0f53ca5d53268f500a61c31 7b634e5a783a2d0ac8bd015115a6aeb9b6e5535d9f65548b1aabd3fa925a590b 333474f8afbdc9eaa25dca3c2e3c87060aaf1642128723aa9dadac9bf80e1393 2637bc0152fc015bbee3755d58b74afa613f237b7de2e8b9ced67c4a6344be57 6292ce5deb5b3513f755d6ec50a6c6860fe912cf1be253983e07b9598644e96d 2ab4d1cfd2885c63fe4ab9acf431c4be2c975d06277cfa5f695abf6af770793a c52ef5bc392012c98db26cde53d51652536a790e680df86b2d12de24c9041a48 76810cffcd7adfb166514f9c6fd801069a9fa139a990e5c256b8d72f4d035606 11b2bcab4930e67b0eeaf55d2fe6b851c5d23e3d8847f7886c27961d518407a8 1d741b098abbceaeb9ec885f84137950a7e193d57c6896429c1d5e2f9c58545f c5895aeeaebd9e34bb78f0d5f4495ae8bae64f21445f15eb2ac11360b4df6441 cbbc62512772284eb90e3669892176b0a66d147c0aa7f2033fd6638190bf8601 e08c974370db59f1409b38d1278c9d73e18412fe390c2d0efb49a0ab19118163 6c8f46051655236520dcda6ab64f3584cd9c3d34e2230ef11e8bca054ae18113 9fe2c790a8a7d34133138027205f28922d7765af5caced672d4ba312ef9dcb97 f1c79d472fd680c34b898f60870a29803b1b4435405888571194e2fa218335b3 4f13084fa4b109c8567d3812080460841c23fd2670fdcc9ba4bdf4e779fab331 be60cbae5126a93ae9fac47d1c5cc8fe4c69cef7cd724b7e3f7422c1cb5bde5b 54eda64402ef1eacfee1e7ab2c601132f3ff38ca74353f22272bd1c05a75b372 13f51eccdde24958e7b2f889dccaec07ece490b478df7862ec07c30134f8fab5 48112f44d5d1a0d8cb0232554e9c43c1a1ab493724e6fcf72008ca4a10c9074d bec4c2f76771e111bd05e68e9749dce76971ef6931e06d8d3c1dbe1da50cfa9a a4ac31cb1d7cf7704408edab586dc3620ee34db586ec0fa5b0ad3a4de7984769 d3f5a23cc45d767767e99865f208e6d28f7b46a65b749da3838ea0bfe2d45779 4e52c51239f72648524c77c366310f756cc9f9a6244b9d79c891499545af8a5c 42e8e46019c649b44dc011c625f0e68659ee1bb29416695b3397a57739686276 bef6ae11bb38bdb763e5d71d0dfaff6638b6c5c45ba758fbc9c4940d32517820 207fe81b3d417205dce66a1e2e841f88e93ca157d05ed9cc7bda074d3ede4b70 2bcb228bacd218f10720d1afa39262f0366533063e10a865aced4807d61ebab8 f1642fabe3a7f1ca41e2c7c0c04eac985bdc2b8ed95dee00e62d652600f445ac bf847881e8276a1e7017b3bc3ab32681eedfb151117d9ec41e0b8d62dad80a56 32e1826093d2ef6802ec7105a1f822a32b0fee8c600d5fd554e3c93ddd78cabf 7a6caa32bd20aa1b6aeee8ba1e927d6ae43229e2f68a410926c5b3a663bd8fab 4cac1c2c55730f514bd885a0881c7e064efb11c723d666ec549cfaf45958f80c 90e6f7b95eb39fbd9b4b749bfd15baa161cf7a1c0001d9a016cb61db5091c838 5b8efac640b030766236e6c7a431025952a1bfe17b0c1abe9ba63a6fe908d46c a24cc62be6835478722c7c9bfde9c7a06f4355e8ff6c8062ef40642cbd256d31 06641bd3f77e8c158461807c74c3a0182ab897216140d94984b7a06636b08937 9b4929283210bcd3b87b3b806f7069b6aba1b93f389595ee498dcc516cee6ddf 935cb8668aca68f09211e7c9425e7aa9b41e265af5a97f86f9c9a6eccccd7290 9fae5f6a2c68d8b1ec75bbfdc547b978027714740e89881119fa2186a1eb5303 78fefe7666a9b2f54524b68d39003a45a3252df06964bd90be26a80197ca1071 c6f024df3230e2f2d39e96982c5ca559e83757b44b89ce3827ee255f0204a3e5 7b1c31e0a4812d1d09c006fdc65f99ba5b9917ead8061c5ea83cd08dca050039 5a6a4adcbc9f2e8bd1eb6d9d73b466bb3c41ade82776b2419986f065b449c9fb 06f7d38e442fcfc197309fd134b5336002b2fe3c0b13cfc581c3bc461af4647c 63f308e14960e88312e70e03b7b6c795d3fe5951c4d85ea4c9bc66b01626f88e 1b7e6212c93cef0fba3afcdae70b408b0bd6529c16b13b9b55f553a65596da9c f1fa13f7d43759aaa6593c6d9da0f946ef6b0d3f9851c1822b3b346ea473ab5b f0b565b46ecd70522913a3d949fea12903f98468c1b711b92e6320580ace72d6 4681f23a7927a324bbcb849dd39b1009cb6364ba409611e4c92f9d60ab9575e3 8e858a7f25bf9e37feddbe7253a225e2fba88e8227c1e615bdfd18f118478c50 d2703de965283946e6b85eb0b1c75e8b1081cb44019b99e572732960057901ff 81a2bcf21576c18d681d909b885cb2444b5fab20be43501f28f50db957fcb948 119abc437211aec92fe0022202728ef7ad0aa3feacce5b4d91bde66468720c01 65e36d8543186cd748c6a90e15fba9fa071949e535affbf0c9fe894637388ffe b8c9ce7ef43fb7592eedb7b36744945ebc44ab97f356868a94912b6648742cab 462f1742c86a06867225c0f83492d1677d33b26e0104f8c9ef0c649de94829db 5c7a9f2bd7d81e9c02b6778fd72c3d175d95cff8c0458201ce20b70dfff8aa33 aa62bf7c6cc85bc3f1cc5e5cd725635ca36e59d78600ae5a0a8e521085a24a79 408cb93a760193029bbc0dea449588c7fa558aa5671fed8ad65f0657c26a4b7e 766333e855900f8781e76ff7d05defa8a037e63f7caafb8f664ddf1a6aae87d8 3a5f62b1b1b68185869f43ca6e5716df4959811400ba0b2c2be3810a55cc5165 c873dae4c3d84746e933bdf8f1ab97812281f8c810fd7f86612ac0e0a032c56d 077dac47be103cabe3b87fccc767ae3d4e8e20b179299a4bffb6557caed9f753 c9beaf09e66d70f5251878168fd35263dcec046cbcc3ed12192d13cab37309a6 6c514b6230bd6799ebd3bcb28dfec0f12b2f917b9470e54ed8671a3ab31b5129 ba9e39e4449c453b5be1f65c347ebeee15e5f0a7d6632e985a56599adeb5d796 6728a0c323b1a992fb561aba7b6b203f18149600955a2b745c46de930215dcf3 07038d891a47a1db034eb005e0bcf82e52a2d936225b94a5b03706d488ee232d 4eccce206785c02167ab4f7b62407e4d7d87152d72d2e9ed0255e6e43a80381d f85ff72e0f2e58a48da96e22479ba9d0f8614f20ca60e9e00e8c772f3a72bd4d 16fcb6a2b241a2a67a1cbe3e09d78401735c23bd025236ee184d21f6499d4b57 3efc4e785edc6182b258827fa076fc9d505ef2d2dde578918c6bb8f2254976c0 4e5a730da97f65ff881480ebd6274180494579cc86a75d6ddb81eea8ccf51fbd ebb32d29cd97f2bff455d8ebc1279e0338906551ac2fa633f70cbb5d785f0726 cdb6725a9ed940f5b1498f29dbf7e48dc58f9816a290234a66ca940b8d358656 72c517dc3b5033861a2e676ffba3bfacfbc72495459a3537c03b9bbbb47bdc31 deac49dda4b2b6eb469abcbf3e42f33dc07c90395080fe98ac18f2861ea1ed4a a620e99594df3ff475d8527ab9e7a8ad25bde3d6fb2577e2958656c6f31dffaf 4d98eee4fabcafb4cbd95c81f11a8691697416c3ff42396c4406c03ab75611b9 916cf0c34d376c96582579b39265f8acf3ffc0d7fda982a7de6bcf4a7fbb7d39 c2b50e5085be93b4eb18627b979af38cb8496dc375cadc07af8e1822aa5c7e4d c3de29468d675ec4823c173467a1b3e71c2c77a111c8da85797165ce91f4bfad 2dbdaab66020f2945d6ca719c84f7f4a37a10c371b4be15786e049e61705a284 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 true +check_ring_signature f6f64075258b34b65cffedf1124ccd59e42a65909e0900542f67807db93dc1d8 2ab1fce84e9880b0ac8e0d5be9773dec8273f1eb4a4d5c4728a4da4712b9bbac 8 28356197c5c07bc456cb73fe54d85eab83dc2219b2feeed6ad247b03e068ec1d 3d30329e1a86b202d07d98104b3f551a02ad6f2d055c9eacb544788d75731791 3a1bf2c78ab2088b5d114f2ea6353ed0b528d63dd2df6626130dd176a845b34f a5e73961e6252eb8b13b39cbd354371efddfa0105cd2442ce0cfe980365eec1c d19a7c8208a97b09fa7d87edd228b0c54018349eb3f8ea00e9f86f1975e23609 70c572b5d35fc42a5bf2c38462b63ec28a80099d9bde38783812b2c378a05dfc 4b89454ae105cd9d8ec2de3e85bf6640c4f170b6f65e9b748f6034f1941d05a3 72f6d884f1ced4c0fe6c7b61eb0a82867443461adc74955df659eec16f4b42a8 e492a5fb15f48f4cbb40db40b79be2ee2a8d75809acd25f7360178ff31c5f70760afea790494d55e6c24b71e54574ff7aefff458f45bf62d301c07da236b22082a17775648e11b414d1c19575d113b15352de20ad617cd506848769371868d0bffd4367d4a744c9ae58a046af9721e3e35e2380294473fa4dc709e35a5e0e1023c3b0028df5cc0564060ee596b8b581d13a28affd649d24b70bcbb36d724b1002cb2782df82647704f8f07e885968cd33b2b3c5cf7eae7f5b7b9303e56402305487827be332dabf5a60d85001432a70bd734a61f9e26a11f1798c6de01d3aa078e2bebd5ab301ce07edbf47479fc1f02d946c5b44669333923d06124c3a6930e075aa6bc99eb6013783eda5b39164e034f1d01d5b234c1ffde661b2cfef0b00e792de7f8e2c7d741f54114900c53de613166f58a04593328c46299283d2b9e0282ab0dc6acf8d6958d606b2b9fc9c5a2c1fa787d44d51c016f7f25988b8f1f061125c7e4ab585bbc6531681181cdf0780935c2665309ceb7b1152a0a58bd63041b9f478f7f48cc1f2505565cb05a9a333611d7858c57651a75fdd533e4ed2b06ef55a765819ecabfa26c42cf4e1bb8988b93d3ea479943c3f8472547ff4685000d18ac5db76149599a76781dc8a556725280748959bb2a7068905b35ed7ec409bc1449446a4de8f5837b9b53866b6f4dcb1ccd3493c4eb011ca13f8988cf450c false +check_ring_signature aabab27ecaf0bb3b44a9db01ada198b77132a22b25ad109feaaaddaf7da2e0a7 ad27667558b5a1b660f696b7b587bbbe0e35225418b8aaa3f5c5cdf1d7b06534 60 d78652152b7cd38bb05add11d47a04cbe957113db30601fe96768d1b177f7055 eb0a2c8be8d16be78d61bf07994ab39d36cec5d443ceeb614677df4b82db763b 57f6df19a25eacb7c7fe62bcdcc4b25d69494984fa2aa50516027e8f86f27d07 f24da61060260a01e32b1f5ebef3bb97d7f630801154754d88d4ab2426941dbf 45603611961b861bdb406acbf6056e466bc1e6db3d7cefe3b33093b8d70d837f 1811afbe32792074bc9bc3fe448c335572dbb0ecd274456b3c1b14ca9e29c3d3 d64f7c7823f88964482e90d45201c5a282360e68cd79e945fb590fb0e59233c4 348766a8191738c3e3c2b772f0238eb962196a6b8c08465537863fe19f98c0ea f59ad6704dcede914cd3c9245eaf6baff6e8006f08d1db19c2084a3118049cbc 014f0574bf4a9c06d3a19b2e676f357aa2dc03589cfce750c0fa4234d4a67d09 486604a08c9dd0968b0c34a75541095773b26725220597892140d4ce147c3881 c836fab19cb91d7285928136fcb573c2e622a8d15be55733ebb4cd75cac7b26a 4be32cca9c7ab1f3dfbf4b3e60ff00352941605e5b1472a9804137e4795afdd0 c77c1577ba70ece767e14640f858862fbad02cded0567c1d9a38c5a0715da5fe b22cae34dadef124f8a6b975d9723989476d40bd0ce47d40dc1e3a945cf35a9f f735a2e7c344f7f14dcce6c1d53fefc0a2cfd33fa69a0a21d8a8f0f6c4d3b435 f5d0c3f7640103ff6fa7d50d41ca30594554c1141a9adfd9128fba1dac293cfb f4e7d851a6d85c6ad2d0991938bd0959712c18f94d65925ea6c7192ec76aee5e ef6cff64108d7ba117ef0d15c4cf8f7a93ff2b2ccb01a38dad68910641e04409 02c4e0c40d5547027553c36254fefc510bf3b4ef88fa5934d3aaeef456eb8794 c17e9d64fed24bcc97d7769e92cc6c15485a9cbf90275ce1df8f0170961ad5ef 54ad8ada4093f15b4241a82f7e0188262fa92033d120c78f529a6955c765b550 f35f96e87a3755664d229dac43714131eb60a703598bcb9b892e9c0c540a1eac e09b628af1e11fedfc565f1e342ee91920dd90746930d03e5be3a62d39809fd6 d899eef0e864f44937a297d2e6984e0ddec17cf555d6e54918f529e0c9f89a95 f1f8a892127b545801c4ec95a8568c4ce46bfc4a27829c6d5f4e3594237240de e66ebc9b4cf69363b74e60c9edd507e01cec4971df0d3376f23f662320ccc57b 07e5e39d0549dc0370b22ecb03192eec50d3a7f8fdc89babd8522e37674ebf8e 67aba71ff9f103648390288fe7f3b4ddf63bfdea539c9534ceba07aea5400f9b 52130b3c60c920198511b8cc0a70dd15e7269b6a3403f9a6c757db0bdb2f66ab 425705d4f14cf23a2fb2b8dd371c6a7077da211e6bf5efae71c695ab1535073e 2d7dc2bcda6d535f4cfb06e25cb27fe7668f6d4dc66ad04cef77c61f08ca9077 30feb9702dd22fa11d8205eaf1188c56d747a4f1a873249411783adee6bd2847 18a13a7530812d7add7f015e734b1f5876ece89e1be6e363311c06546aebd028 329994162e18b35fa6024f50f9da760a15be0947e31ec2328b4988ff29a8af58 3ee85c672100dd7cbdd3039aff52cee703c5cddde1ced9435c6547cc384232fc bfed5251432b490f6a08d44511a1749fd8574c6a504c55fe1fa160c27faa4046 035d550ec8e3f791dee683e9136bec79ec433df6dfb86ae6232664b37307f11b 25b138da74af984dda60fc34fbb046f7e7d1891172f6dd71a2b7179337331fa3 2bd9ce1db29eefba2ae0f6245d3e87046eed634abd6367912dd2000e60ecf13f 9f7f9ec9c349d2d8fb741705ccb886f336348db7731336559a2c8570e29a4712 42bcedabc959052c84bbc396ddc5412f01e0d86cbc9d35de675ce1a1b96cf34f f17040830292b751d88cf84dd5c536d53b63f0910f8dc8a72760253f6e8461e1 3a908eac4bc72017c1f71bc6a56decf93b6a96a79df1f3f2dcba00f81247449d f473daf5618006b834296d1b2ddba7a55e4efba8d0dc3a042b639b94ba6656ea f17aab9c802a1a8a87d03d2da46c88a65e9d21af5ccdefe7209b3abb5e47a13c 30ca3152a58e93d819ecf2dde5eb084c3f4719f0ec4efe90761ef10a5f723aea 12e849d30e2e4107b42702540b50d151ef5c9281dbf33396b8da8ba2a428e9b0 f1738911fbf66b938121f1b91709ca5b192d67c25e5de6b95910a015b0b2b6ce 9b0634eb9d9cf30cfc6087fbeb73192ad283c2330ac7cd56a514dccff3d3d01d 31648b2318ee551b85d766c80733fc8b1035e403431f7ca66b1c01141aa98331 263d0c109c5fda2f6e455baa94c48fc5da79f0a727e86387f5e7195ffd8317bc 6d6087286bc4c9ba23f799145f20dc8a94aa4fbe51c8ba3387ab22e987df29ea afc268c4a001e9c4d232583d63b19ad084e8ba6bb31c66cc414a6329c8574356 3a3922f82fb19feb66f199480745cf05ae4cd145e8356347a1a7961d3430523d 7aba91b35f2ddfd127e0d13d6745c70b88c952412abe68f537873f8231b0751d 04ed629b819e685d5fc2508752170249633ddc1a1a1f5727b411958c95231750 2b01e3af0896350b449eb4d3ded5c8f8e7c409c760233bf95382f6f40ffdb22e 31086342424dabac53f3d37c79bdfead3fc2dcbce435cc39908e570673139773 9c79093f63f80df0dbffd406ce7b0a7999afb4e5c6ed5c52335c832be8142e4d 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 false +check_ring_signature c2f790e80754164132f49e98638bfbca64c6f492ff863219d4c394cfdc039eb5 768452b696a78425e22488549a0ebd848d2ce944113cc8769e176bf555b9b353 3 9fee8b8b3c5a42db9e0f66e0c5f42ef5a3bee406a4a9ee1799ba335192e319bb 9184c8275b60922440bb5ecd0f6a2d8e9aa72ee3fc1a42bd9aacf0073841f3cd a0de237115b2b62bbea966be21ab254d64f7e96829813009ee965653f648d1bf d095da202d80cd6c65d49663e48201b6321719662004b2d5357b192b89704f0151f0ab969f87b26892496e32c94a214cae45860a9175946f7e0a008649b813008f63303f613721096deff08ec294182f36c5d51b56b858bc2f76fdac74d0bf0fc1e65b7f996545c3adc7db16902a22d2fb6320c75f1a6892c6a1f68e149b2e0e01a65f5e7ab7e0486f6dde05555c4aa349714205b52b10d9951866e81bb0760b0cbfd1526e2ce58bbf4bcc47a14155de6b0d22dc16846c49e9bd706e1eb98309 true +check_ring_signature c8512e63878c10d321eb43f99702a9e8fc744fcd7bac2886a5099970422802b6 d4f60c9096a3de61460f696ee12741d822963868f836f4af26ddda6013760b8f 29 7172b01846554f3c72c5a76e61a59d34922e9273de2b5da52dc98a3b1226bda7 dc2a5bb6b19c37b9c32142086957ed86019a96e5b11e7ad14f672b96269a4779 37635481043a62aef9efcc838fd9e00fb068ed281ba1f1eb0c6a3cf4f0a52057 7f37b77eb2ad35916e93cb817152ff0effe6a723bbeffa60deae63c5816c139e 6c76a2a4ea2709e2e01fdef911d4b32095cd463d1f9c8ee9a9911400ade15330 58e9376c7cd6fd0402a784426219d2160b1e68fa1e66a1380c58cc8114c080b7 957f819f31a208a27283c627ce11ee7daf98745dd5227010da1d4bdb1337b41e 336baf26fb4c866895f75ae58815cbfacdb08259371ba9847ae887361732463c 887e94c9a14ddee422ef5ad1be9a232a4dc8dd410f77365d794f5b83c15a307b 14749e0704bbb580b9c0416dc065236269d2645fabdf3edc6691b98a3faf0f7a ac1c47e401bb41a4e00b81d0f65d319ec8d72a0daef619610827fd964ec4728a cd64b0d9d68b44e32dcf0ac59f40c747b8350b1c9241c9ee4e308b1c3edef2a4 a61d0ac4c48b5961c3571276c997ca765021e69ebf841fd830d668bde5950382 9584b9d1885c06107842059cb97aae1a63036145befdc6574818c841e13fadf4 c578e6c76a18fc9fd47338e60433bcc6b8d6dd23ad717941c0ef8514e8e2a805 4cc1758c78003c20e8eb9bbf608801453e0a8d94e0257ac3f28ac1753649981d 37788a6b9ddb9bb9ef8ebd5776181a47736b0fb94c057234b03936aaf1f714e3 2fc75fb8d0e166610e155fb2f16358d0eedbb576ba0a181a9c96ef9863dc1513 a0bf1b1d696545eafd4641fa14298426e8de3fb5f88821670220d37f03458005 34491fb2917da13249c91e72446c8676cefc1a97c2d1c65012d03fa7380f2376 d1edfe384b7b96bab2ba10e75e6928eecbe5dbd0959a281d86b738d3ed78fb20 b2967aa7f799be8be676ff57de81b65a903985bd95100a42e77a87f33f71b529 db9b9b8e53056dd960ec1b7b30e3a971c2ee0a657054dec1ab9cab59ecd23c92 51dac253fd6c1e7a4a81cc6dfdbc5873a77982a2376049abec3f0929c92bb6c1 6f49ee906dc950219cf9947891b11c8a7b59d9186e5759d837c3e326c5c26d53 3b9bfa927933ebe0d2a6a03b1d7b1277694ddea6d7469cabf20b215105a8e7aa 5e8831769be02f172a3e170e4de98d8a08c76ce13e0e77eef3b589f3c915f111 aef18b17d5bacba6d4cd378b86bef609bc4df67c56cda0e81ac948e7e6d000e6 c2bdb81635933ad1f253c42d6cbd3c12d6cc8a09b47bf23e2c02672b3b6f8716 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 true +check_ring_signature 99241ba57ac233202368fbce828b04b12ced5d628bea7bb2f8a20b05a5dd41ea 45281a9144d2287a0d7c79c7ab13727362951b5dd23fd33d36d03a56f3bc7625 13 55023074a9b1699f134ad4e9a3461b655eac7e9924bb3ae4d59b128fe7543475 b76d64d68f28b977d7cf42a52c5e29a8ba22fd6190ce239f3955760451189191 da5f8719adfea8c04af0172ce19de986ae1bff5a481147a1df11f42381976ea3 fe451b7be4d9c65d0b5170fb44ec19271713877192190fc68832363f1f809f76 8de8dc32db7beb7b7286e89436499ef037bf6eb9cdae214d5811d5adc2df6475 a20c3192fc85511ea7d3474be92b56e83828973eb4dac9b08e4392f2bdd7e9c8 e16d90facb71b8b9fe303855036205a79d5f976d9df79f2a4a427828438f6ab8 8ebdc33bb51637c30ca8fc471ccd17df5218141f9cf13c3cae8af6e497cd6a6d 8a2e2bffbbb341069c90155e58830918fba4b40f98e9c1260cbb7de7a257eb38 c0bf013a2affd71d87be69795b2657e6124fd7bd08a0cc5277d54c3c0ead85be 3ce6e2b2a7fe2b258610aa6a0525afd017075ec942451319af167a0fa921ad33 126c49fcfe35477fc64d2f5ae47ecc043a2ed9f38b3e42e5fa063ccdbb1273d4 3fe9274f3f832b02987fc1299c467303cc7c387b8e06efc743c913ea95f4feff e278d155519f54b332c32d4d7a738733356d424899a3d4f2f05f6285e4696f0f72ee070f6aed2e541845ef2938667c0772d6c6f3da5bdd9d4a564d0ea2f311019e202e52d54a08f841544b28191e907dd6f8ec464e64f1e75034a58951b08c0b26933b5257c3241c2a5bd8d85ab63674c21d3be1ba27fa92f48a6becdf08cb0af2f531f9f974215d842d2ca2ad9ac1e51faa555cb33c71e3fa3fe09de82ea404905a8d3cd360aaeeba3b74cd3834fe4d8df0cf961a41167243514496b2612db817104174863033b6db05a8ab24da0a5ff3e5cb287ce2439eefb376b3d2db520041d2c0c53d8c18b9203ea76f6a49e1a7ce73e6482e21489c4e2e47a7b1667c0f64c876a95c51619acd12e507072583d981dcd9d1a977889d6f475f5140df1d07d294c4ef9969ab9c4da2b98d305a3d05fd4c60912a82b9d43d19baaffacf6a01e3375dad98667d8f8e6cb49597caa7fef6097c3694b2b31a88310bb4b4faab0b4f5abbae3091aec05ad9dec4fba67b38a98b7a1a148764d3b5d9dfabfd7e870f372a4bf62449bc69a3650d022aec74e28a46270289246753e0fdad6a1f13910c9d8b17dc13b6349550973d641bb981d0b01b8bfbb74449887e98c861db84bb0a4f3b3c89f8b577d3b26612f93baa09f189c3750631425edb607241b91cdcc2077f34340574d3a23d46bda0222e7eea1e62f79d70899b8b65e2edba812449030af77db38f5aa089f2a191261b0fc5403aac90498280f2c859d2c99c5bcb81e50b67139917d877f45fb494bda1733b2cb4853f3d47bb8bed73f25c2fc44ce7cd04cba8fe62cad55fc2646bdc9dce7acff28afed2f2ff150f2772bfb27bf18ec20082af3edd6467f4e46ba376d35279df97c629122c003f2231bc5dddb23554848856e60b95cc5ee77a87dd2a77beda83457dcc72737ea2b8b627c9afc8aab27105dec032810cd2c4232fcb1ddfde2148a7a42c5c26307eb1729c69cfee6eeb40002bc1944628fa4b9a9a9a6fc7613756ff97a6bf7bb8ffde4e669a65483c57e8012211c04c56a8d5f1589b10f232197cf8ff694e6a2f817869ca8395b0da15ca005adf70a0364e8e5668d66bf63c011ae0c8c3d46c3a3f5d8c0b70a6b16c43afa18e25a6a5f9308de17e8eaac22c480ff5dc00a5ecafbc5b91b13a20fa89a1d50e false +check_ring_signature 60bf34b9b10bc665b0dfb9d0f02c79443a52114012d4a261922ce240b571ff86 7ba36f941cde4c60fa0da348b24666e36a08e9655427cd5efb38028232ecdc44 215 e3565e7368a493bcb111832244d2fe57924def87b097836325f38f7402eafb53 f32e0a8297629279fe8da10b857e3cc87c8514788816958e8f33a44ede8c67cb e22bfb1b3eebb2a75b360004337d8009ee73ed63678970f688c27c6e38416f9c e0f52f5b299dce7d10108a595179502706dfc1b6246cbc3b1a122802621c79e8 717bff956f2cd663ae3551b943d5294c237b75250a6f8fc26072eed29d48cc3e 68093fa85d11673d941b444e038fcc51ad7c3895fa15e327472ac7fa64454a15 c9d1a8ae15baec7de76349fae244485636bddff1266438883540c02c5867afce 47bc3d6ffe1f0c7808e02f46f0064cb6c127159d55c70cb4ad8ba6cfd68ad9fc fe796a5d43643bdae990e81eb652a4573c6c9c4301f3afcbfac2f00a54c119a0 2214f996c3e8b981e6d0f9be9a4b356ec9e9f11363147985f9fb39a91edccbe9 56e2cea54db5d570f1cbfc8d7d1a3ce08c58f374234e67b3053300f5f0413264 7a7c2035c599764b3c4c084eeb329fced470a7288a48e7e20eeef4fa8bc21fed 9ffb80386938c069691004b6bfe355fd6b0e56b05e15f5afe4de4151a4ff30d4 ab15e971de0d8ae9bf4014981b45c8e2d9bacbe1fe4a2dcfbce429e7aa150d08 dc9e36a085cdfecf3165344e445764c7584224556ea6f3b20620be61e6c98e9b f2d81a6bdd055017d40ace415df24117a143b6bc10480164bf87930056f637d4 78601d07d894a09aa1380c03ce6ea369094463e957e50d9f4c46c4840bfb80e6 1dd66897a38a8cb8690971267eaad86d8f67e357e457a86c1a2af05c87a94954 a8333190900d36f5a87151c3b6eff9f38f9b22448c10d5841b86338953dd987a e327e2c93db8b5a44596686bd379fc4ce363d5f10298a9ea22d76a89f3c282cf b23ad9ef970d6c327893ba0471d9bc7b211eafaf51cc059db07b735ecf0088a2 2cafaa904d846902a5f9582275901f8ba504bb4925f50dfa4ff09264320bc107 1e45d21defa9a3d3fa7ced6d311904a975c0b7cb642220b3e3d8facef315a45c f1b2dd18c264c9cc4ef3735427eb7fcc96baefaee1ce3f880ea52a67a1a2420a ba5ba0f64747a34c3e5bbdff1b50dc8d3843ee427d0fcf41cfda37731b35d28c 954173dc649c82ff88aaf9f7290c50a0455d509c99002f49134cf73cf8cee45d acb606883462453c1cd7b1643bd12ee3fb752b4f0c7816ddf804199e75fc9c5b 89b16a80ac51aec8c7b6575421a72d246fb6803fbc90cf54d74daf2477b7a14a ef7393bc3c254b94fb14271b733a2e887ca4fc9f03ab59a045bd0cc0daecf646 24fea43b38aa47de70a59e097579865921689a701fe7ee2c026ea34cd597a232 5ad9953eecc0d74aa0c71eb17acbe985eaab4063a1c80affa205a682bde5b4b2 720dce3b70a0221f05b156a91ab2dd46b17c900c91c23e4c58c9c1b8ee15d675 fa55091b126848f76d3fdfdfc95145ec8514aa3eca2e9cc2c37f5d44900a1164 112310b07a78d07d3dd605174c353bac3cebace64c1478cafbb2a635fe7d5acb 61ced52b9c610cbf39db039b0b287fa850187f5941b83862c76465e8263f5f91 d1fe609883ea7ee65ae1451480543bfdc66abbb8e1bc49750e7b7291a1672a48 f84ff294879a8763d5c8d6e34b4719e1ef71482b1c42876971559f3fc9f37145 8cff2e8d521cb2273c93b7d73fbd74159bc0ce6c82c99e19a51ec6578aff71d5 1020426d8ed789fcafbcbb2336738a850b268afec6a1ea0a49368b577356b0b0 c799982c335970fe41e8593c407c85d492386f4dbb500dfd14221eac71ec0cad 3194f1c3984bd209533f8ab2349ff13fc06c0e2d2270896752697ed09110a2e6 c65e7174279c84cdb2a230693e40bba151dcf928d1e2f303d8f5295c08c815cb 076cfc984f58cb492672de50f6f9e91980866949dd9be46bcd157a8315730ab3 84a41fa0d974e8bbe5f06ef7450775ae1db39fd5a2f317cd5f3c20f39565ec53 7d2047d911e764da173da7ea18becbe456393b08a03f823448700a62f77d2190 d546246ed191f18074cdeccaed15ebeca08067a52147128e24794628b60dab2a ddcf02a4c514b5376072bb3ca4ebca422f211b8166b9d95a1d3a752e976cf550 c9adc886a027f9b7bec154a597940c583258257c0be973a400d49cdeb1142f99 25c4c5d38509e305e725f7055a9eb805a80b37a16d583fcea8c76df2ec442982 1f2005babfc9ebb1ed1bd39ddc1495c8d3cb366f0b21d8bd1b7c7bf062a66e9d 52e59cf20d4bd0816583471e66e849886cf815cc9c0157c94ff829b76ee72019 22456e561c12832b5678b3ca28bb9f8ce935097b38f16be379577a0c370c7d96 3c844c625ff2d9409fce385dff8d7ba9f8ff436b441d7e81b5f500ae883977e0 dc73d1eb4446e81c302c4921d62d2949ac9522bba172950686e254322ff09d7a aba31761c1391402c2fd7a14ea14e1bdec3dd348e0673ccf668a15d8a361a71b 841ec7af2d31ad5f167994e76c3e54ee87316dd9ed177d7179e44dc16e4c92d2 e8f0632a9504ed38608460aa92c510d316a62f660c46c1895b4c1ee69dd2768e d70fc38f44ca218cfa862e5de8516c241769227b1d74ad4abec6e3fed6fccab5 3bf4a1560aaa9014f45251951753a996ec505f9a58cb39399511a86b19771fec dd7f9bdc13ef2b1aac7234ff41079c1703443909d80eebb5191bda5f7e4e0a59 8b728ec5bd8b71b3e5ab148b94ce88bcbe0ff182d4471d7dad96330368714807 061e5cb0b5af74a3f43b23cf663156102dd70e03c748548bfb17d5a01126b8be e65ec4ebc61d7f66a97e2cef83bc492f3aa2cda7e735bbc2fd97be9ebd36ea06 917a14426debb5b777ca4e580f4e492a896044402674904843d8e73b765b9812 a05a4f39e260d7149f4f592b515a61612ed0cde76fda446c970d5d6368326c52 a50ec9239247b10378d3e9953bba20b3b4d99a2cbc6eddab6baab1a84cf7d7a6 6596bd0960be3df9752cc64db501449d1e45575e67c5641c16e3d1c94b381870 a50420874f7a0f320b217c03878633c1f5eeb942689462b3551b6ecf4749cad1 f55970fb40f37d65a80abe7ed1180a7d0f7ee3208b6d8f1cbb68c6a3e87bff3d 343f514f795de85be5aa7529de01630494e12b123a3347d16fb00b19ac0124cf 4b28a2cd45b66974652b95c775968ea4f4090cd863007ea77ea8e325eab5d082 ef250a1e20091f8f508bb8978bed0fc8b8ff8bf81a04475632c6c42559c5b230 1386761bfc7462df5d9b123149392e63587e9d4321df13acd43bfa3cfbc0a3c0 e4ae62533cf9e6e442953306d605e7445318307e822fdff9262b249cdd700b71 ee23b6cb3cd161c50041c384c95e45b523ec1bdaa4cba031b30988c1c9d8bd7e 619ac0773f0073620a783fa458db34be562e6fc3ae3100011c275d4e76a03fd1 68f43ef4f44d112b1bf21bb24b02f51f70cccd0418e6b86efcde10b1e5cbd4e7 fffb005a0a3924b70f349d477b83ccf85b2f85f05b9145e40bb05ea93a8c296e f930ad8e323293dff6155bc4fd8ab399c275651a259182c9e932e6f97a039c02 2daeb9b386fb46d1da9524503cdadfb7f1dc1a720679718343e7664648922e65 836e9f45f2c91f6871852343d2be6b3ccd5ec2f3eee8f3ae0b6116c5160f2791 f85a70778f75d7bbb42d37f6668c55c58395d2513e9dc3f17233973724e174c0 2a3369483045f25dd4996bfd7ad9bdf801c72e513efbaf03e85c6b9f395c15bf a9d826147f9d386bbc34b917cb04db2caf836abe2991fe274da06102b280d63e 8c27847eba5728f488f9dc5fb1860aca419cb6eaf019ab8b3264e332e5e99cf7 38040518e4ccc916d7ffe7836544dd017780e73f201c29f13a6e6bdcb36e2721 0216b0817c4a2068762600b0dd76d2132f66f5efb506a60f1c37e875ddc56a17 979bef659b60a0e2f2f6f2562ebdb694b79aa93cebd603b36c0bb64f7c03d74f dea307afe00734983d2974fb767138e615f43170e05a62cca693861e8b7e493e 5fe7c2530891daedb91690704d52248258fcf8aa071d8b9fedae1aebb3d3aefe 137c4743540a824598e120873fe0883d642800e08c1429c6d75d76ad8451eb66 4c0cb0ac926b68259502a9213d788b85203bf9096cada80dec0bd4f873805dab 89ad7b5c96383aa2d76a553c8bdf67022164218d0d138650263e059f87f4bf88 7307339426dd034376c1b4dd879a663f0234ac280a2bbd5b4a34aa5a07903e6a 2037b793998e081ebd6a669bcb0a8d4b55a52a4bcd2589f2ce0006b401b3826e 9693e96307ca065634a402097e25e7fbf471e3dd6ce954a9c03f207e65035f59 38070d7f64d8fdc28356a9eabe8e90b652d505877ed640d9298ad0b8b7ba30fd 56d522b4a213da3ea77e069d2daa1e9719b26cee93eedd01a8d059ee485dbfa4 d4c425f8fd725787924d6c503116ee14e21251b486fc3b4819825c0fd39720e5 4e5505181757443dfef73c8e953dd2452d997dcb1f391cf88937bede98a73a50 54c2a4d7da5c8385a7e08572255a585ba6e2a834d1d345b9adb7481db4dca443 def08a7341949b0f621ba48e006872adad1ca514a3f9f0cbc9b48fd081165313 263ece8ab95b2eae878847399e50c27eed2ac9e8f893a152c3f9f53230fcaf55 4efe727bcdf8818064726136e5305e9ddad16b86833da2c270a749d0d7e977bf e3b7732fb24fca2d0da5d4484351d7efbe21315c1d3f07070cd94c0941b3982e c0c8efe5724ca8626565d3f03d4045c83f38c14c19445da524548160206aec0c 91cb1b611ae3eaf1e3e8536a2849e567d473d838fa77069d62ed0eb4685211f1 e33c31d5787c2710f709aaed219f22cf9ca28465a569e3750db2a91543d06c72 44b82406b27119d29cfe5791a4ddeff6c690696a6406fe31c60f52f07a8d1238 af56bac8d1dd22083d8d3fa32676b561d49cd2506111cecf6ed17d0d5ae3f296 98bed9371414a80ac90d5500f3870bbc42037896552efc1ae6ac63aaf4522715 ec1ca0c353f2851da63b71041126f4caa0586ced7f9f05ff438839c914901f24 2c4aba5d6ef5a74d4904e7781de7b75063bd186834246734e658edb5ba375919 cd74c3a74ff0e3999c24349cf837a0c7a036a88f38afb9c677553004ffbb15f6 8f25c86c0009b97b3345ac8eb9b169e11234c7ae0128fc11614a7025e9cae181 d688d5b5b2347699bf7275cb01b57c6b98b28a9f62d665b6881f2ecf101ebf81 c3a95ca5b728722c72c217fc91fc1d7573dc77246552ad4c02937a30ffa88b8f 037da9408287563c81e67a70656cbefa9e2d9d42fe4affaf0d82db5fdee9eb6e 17d4656084d31e3205e41c9e607bfa350da11a4f8225b7d5d54d8a0590f65775 df33421d91661ec5beced35718b5821ec99125d4ba4d2b813b7c6f57bd5c2f2f 8492c2cfe752a2d96d99672730dfb43d78a25017a147fc346205d8fe83486906 b6a3e138202b1b9612a0bfded3252234253dddc2a3f7b52e192e375ac662b053 ff2a024151e8871aabb40a2f491cd52a6d98fafedc13b82eda23e659805eb675 e7ed7daa0dbc87e08ffdb0e23e032767d0ba51f35003ce3a6b302be5cae3f793 d72532af99fffb6fe082b6ba64a704a28180b7a20ccd01f2fd6dc5e8b0fe310a 7f11f422f02d645125a577f6f37410ea77f80c8e5dd5f11eb773931e59ae5f8f 2e6179c03b58bdbeda3b19196fdc23a5cfb93be5c4b4870faa4ec34db3554594 52adf0502c35a9d97ef876baeb45b946759a802216187dbfe5a99bdbf8b54f21 619425972f24b594d9c011337ceabf3e6d1b016fc95b2ca2b9df2989996a39f0 bd5b1ea99617f0e30a156a46321ed6dc4b8311c20439b8bc86681e1e18725578 a168f66430aa1d6f7cd45f8b430d7bb052fcffe746204832bf5b1256a65a2806 7c401ae2137d83aa538c30724a23a41942c47564d6c2b263a4468fbd3a3df0c3 daf932ba2d244fd5d9e88b3b2206984a3fd63c13698c2253a9d51e4059547276 ea21ec331dc70b2c54f5b3ad6f692cc63189490b7d20d87b407a4a1f59cddbe0 dfe09b86f25bbce974fe4e0ca2694b04dc894455d9ae50f2cb7e653d79cd9aa2 0a9513c7ed9df0ad556c1144cb00ad9978aba45c7d76dbfa43b70a30b5add8fc 02cb815fa6b6863592e80c8e96f00b04a016c73bf4da0f9f11625aac44084c4b 14cb4ef10e138f3f0094f392a889cb45709c777bc4c9ecc249eb6aea59894b57 b9e0517fccfb47bba7a9e66f1dc60e6b0662ee75c6e1c7010dcc694ef7514133 6606da7f8bbc4a67d9e828947becea2ae3c886b7f2a17c843f065f092edcff66 ba27b9514b3cea67ae62d64e1909a26ff326c8f662b5734f6c06a4f2a0b487c4 d37216c8c988e2fe78b6d09a8dc240135d653f507c11a75df7944b04a639473e 02e524b9609e1fab314920ee426a573457973711b1b21337af7961d5b9816204 4ecdf3d9f52331a4daa503485037a1823d5ec1234f45baa95e4ec82176f67630 61134b60a245251d3f64146a225f328290e69e1eed17bd1e91208e09ea840083 edd32b4d67a861360312f8d27ad955447525838d55e3cca7522408c07cb827d1 cf9152a239b5b5667e39d931e42b1a72cf7d075d3984425d443276d3f334354a 95ab50fac531b24569eefcb87eb09663848d44ce237b93acf3f0243783d5eb6b c386227928436cdfcc9b0b899099dbcf4e6e1feaf6c860cc6852c18aa0fb45ae ce8314f08bafe663eb426e3a4270d4df713724d34d746045f4ac0c2ed088ae59 1e8875b42af2b58343be3233e83ad1907921c46e55ca4062e137f6068bdb241d 703739282202be5096e2a26b6cc593c8aa225dfd78e56a7efa87ac60d421c78a 69fb89151602f95a931f3e380d138bd941778586c118a2a13f3183e291d99c70 4959a4d03b793efb5ae8683bde57fbdeb5aa7e30b2d4328cf12d8d8db986c5b7 9e69571c013cb4cc718081756fd1151ffd2882dbc66115630fba60dfd6cb63dc cb917c129dc87a571fa1e5b29c3bd633b424c6c91ab140c683b2a21f0a205498 eef2e0f4d5d7109a073017129a1614199cc4849c82a783a7a772f4ea1f08303e c400191db500e9545c65f12f1a617e936f85a502bad9a512dcdacb2f145c09cd d1874693dd27b5e1ace07e32009e4a77e5b11493a172c471cd18ca4437c43b98 3a6d0542204587d81a70b7b3c1cb7bc871aaed02a684d021a40c98449cdf4dbf ee488b701a6e666cd00b390c8b7b86e61862ac80aec07c33e5115963b9a5df9c 3dd78c8f3bbe59e14e2eb6694c81d6770162ea86a2bdfd4aade4a048241192b7 3e4aaca9947b150c6a681731babf181d00ea045f6e11a9c9a1ba9c066f193bd3 844087e62be61c1b261f842ee1ab199890199f572c6510d13e6d13bcf3ec674f 5e106842887396a7a9ebfefa05f19d81b29294340d507ec84aad620d92def77c cc6a51e0c8d9b62f3cbeeb11e16c56cf1c539478eaeb0ca18a7b72c258f2fd34 eb5b9857ff7a848269a964f76e3edf10822c12654b69eda5524ca3cc8747fa0f 0a6eee07564c983f87b9994da254024f07712e1659ad170b3c35e0106aefdb1e 6998b45a864a94d1356a091f4317b27490bd2863fd9bf6b7ede46b42ebaa3703 3dfc2fe1547a58dd9d37a2080124fae7c1c723f41db49b09c1cf2ea824ad988a 79f5e689f799766a1173186bc51e44fa703768ec7e04d996a6383ce3785a166e d7b045685c685a2cd6369e8762dc74531926fdd082a02a3e0255d1b825b9b01c e9a93c60a626d29ab8975e34b4c61c592489751b455c213650cf1a379d1c3244 b2d29bba0b53adaee43a36ebd0c05aad574f5b767910fe761c4fc445694ecc53 e606cd78aa70cf493203d30b23f48a55b6c0f9d246e36fa6b213ff69318e9b79 3fdf3f0f7f09618b088142936f54f3f65b0f734785b221e3beb5a68a9f0b113d 822c31b1d947ce2cfe41601706dbf96290e07fb761d85986a7d960c2954453c6 80307ef4cdcac6e725a415901915ea3faf48278ec1b0d7ccc0d5a5a9a7be1520 e49b84387494245fe8280f98376539765d9ac83e85acffd8af297b925c9c3397 b99bd5378c0880ffcd17c423b2437a1f3ea8938c329c16e79c6b9eb7ca2b2182 2bec864c8af402a09a5133140e4e76a9bdad14fd2df62f7558a61b197da5a851 2ffb3f1a0cbd719c42094d15ed9f7f85f5d7ab93aa234acabc8e3174a640acd7 87a2b6f58667d7fce21c5033c492230f9bc8436c7acc6b9c63748fb6e1bdffb8 a6f6a285be2b16673ad01684dfde3aff272d8a50b21024f13a26046ed1b45b44 6e5fbdfb6d2e5512afc5c79bae92f117da4c6b91be3c6fcc3a352de41208af8a 4c656d8c64119e8542c435be10a6db984bb2e4d6471100507f14771fd4b828b3 a4dff87511cc71ab26b30703ccbad831f57131fd12ec28bd42c45150f3ec42fa 55f0dee0dff415434925c535e42ee6a74886a9502b2f1c79c09468fac8ccb42b a1d4cee3d707fcf9c074b05e890103ad3cbea4b4df687f1c921204e44ddf64bc 21d6a04c18196d452679ad0023d2993b548213fd67b080e303e40d9859c96c2a ca970e5eebb9f1eaa106da404d361936347d0713d25bbe14983867fb54825fea 217dcdb105747d748f5f98f44427c2c6190a68fe6beb5aeac9485fc587c663a8 c4fcb4f7d7533b698a0d7268aae30843f163a0442f988822fc358ffee7e12fed 09bfe3c6b57dc0699dbe4ea4b27bf4714841342b821b55ca43e9a14438bed39a 3674f1e3149f0a6d34918ec91303a94ab3bafd2969f343629df860aac5df3da2 fb4efa7cd374025148d2d5ab9fef1ccb90121efeea76dd1f2fe8591c4dee79e7 a52340838a694ddf04bef80a2840e31fcf16e4f5d1f4e98d140c6d33090272cb 6f8c7c3f1062fc480790555581791f170c5bab76b5527943ccfff9828899ff8f 0654cebe337674dde5c6efd0d3297dad299fa1847f563f8be94a8fb6e53792b2 8936584dd6727cd2dc20cdca377a73b608b84c580c16b95dc6343cb3ac0c2a81 e09c2d7dd0b982bfb5ffaa8c172027f4430693322ddf3a35d4da7660a96f77ee ccaca54aba7647523db86df9396767e721ada59fc1c7f8e489e6d58900ed6079 84a740db5f35616513567071d64548c2f98c1d6a49c3bde302828ce67a838d75 90a81cee2507a5fcc5fe69df7c3f5bf5cf00c9ac270f95c9bac7b799d0bd06c1 d0fc295d77346ab9787e21e5830941eb82a05c454d59b432c3c171ff69931ddd a8425b38a87eacb0f15bcd1bdf767d9c00b9179bc8cfeae87c4ed7679e3f61fc 996a0c2ec1089a573c5538b05c0ce95fef724cbad8c2a8efa0b06eeab4446597 de3c70ee61da2f3da2d002eb5b6701c6ba2452d17f693c36dd87a085f7f93f07 2fab43d3b863660f3831af35b28dfce41a9ea2a0c15fcdf1288a0f074c59376a 6fa0f1531f1e4b90d955dd4f35a208b6a79cf9eb85fffefd31b86319707d2670 e155e1df7a59d3552162748a67b251bc3d6d628f1f8d45d8218f6e90192c9e6d 334a59b71b100d087f2f72723d530ee5f7a13401c6693b458c7a18731f0671b7 e8e3e9ba4a711fec793073146a5157a703a908f1e1277f7f0fcd13eb8af8a37b 399de329f1782136f76c07e187a1d4dd3290137c91d72646a0a1ac41eb0b36fd d966e9433df14c43e3e828e0bee00d99f36406717ae6f6d4d8379e305f901c69 05c7261897869e40be8b7a0e8e445064de0a922ab77482f031ae45fcddd87d018aab65dd915913926c0c605bf2b0c6fcdcc6fd334db580bd0165e7e5bf998e01369a205fd7d66c49df62b3ea8c99080f33b636a62c4c41fe4c27597f961b5307e19b8e13d6d8abd12d16e40a0b7c9f1ea3a35a9de2c3c148e6ca0c101c0fea048073ef60d624a79b3077df0d8efe96c179c73ec610f200af6c65728f91a47205041bc111eb00ba7039b71620342a91e9bb0f01469f5fa77d59e9b62cf122e50d88ea74aef50a2e4695079a58d8adca6f841589c239641e0ef0503684e60c340f9148bcd5ec21a0bcee960ba6e781bf890fe03bdbae09093892ca48f03bf06500ff93ae9b0b749d1f342ff8e5c282c12107e6da17eacfa02ae412331b1c27c50b0cc6198d87ae3231b8f967bc148cd6b6de1c606c1aa42ce20c436cd3adf3f90d0f13adfce3a4101989ca0a48733b80af386cdc2142b034dc1c196c4951082d02b8272fc250e53af78d801399367bd10b8f95d531c3a5bdd9dc66d81ea6d96207a74b1829243284dc885c1ab4f0cc0f1b6cbe6be166bf8a433ebf89c1cd896d05f0b2b74f06919e856e47ccd4a199c2d02e2856920bbdb96cf912e54b79497e0295c8a45d5a2bddd41530dce713978ef0cb07c5cc2d809bacb2845c95a734a30752f7e95b0340c3bd8a19e0bbe27a8d717dd32e19c067acee4646badc74537b0ac6d16a5d52a3f3a1030306e9bde6962791880b360a147ca3714364cb6ccb2e0dffadef4410a7307e0f8984f868786c0800fa48a93fecf79695b741de55565509c1d85afcb61359a96a05c2cabff438740dd1ca390239e82d45c44f967dd344039f188edcda6f2b2eeab4b61c05893f5b95d688280f641cbebd3392f6546fbc061261d274109701325437065b73a3d0ceaefab04232b59262cbda8946d808870148612b282e9a338a1cb7b6990f85cb3c302cf4b0dcfdbcd18613b81a065bd001c381717c49b275de06182d172c6244a1c8e8904930c60a8d0c803c05e3fe1001f54452a22aaaba31f173b477bd0ff503dc3f7c755f3205587e3312838ea219095e78d21dfde258def2ebee51eb21745872feb05673cdf98c3c7166f897174607f784bf0b7c4f92d8c0a56c8d5c7450f9e449d8e2645d1883deb6bcc0e5d5790b7724fb9c7c9696695afd688ce98f0b2b7fde40778890cf408b221a750cc47b0ce8caa68810e5e4d5811ca6886851ea280f9a32664735e5c6479354d311fce201bbb32939ad13e92de2c706891801f85e999df0dbdb781f1da76b3a3533077903737cbec7069362b2a7a43162e3b689606e541d3de0bf66da1be4c59c16465b09e4a631cedb06d3be8cfe161ff566c7d3e88dc0cb9bb110dde25461cfcc5dc7036c5bb19f9a7d3ba689292e8a4baa7266f4cfed8bf62fd7e9ecda9f09c0912e08d2d085d7a8b81211bfe7e89949abc608222c443388f20fb41c1ffe968af7e20362ea148864b00615987ed1b1650063c9e354427e197c3d7aa20d860f8a2cbe0270e1f11dcb935aec964320ec3eefc4ef9975219b54d4e549b0c89843fce75d0f425003535760fcffb59e883a8076978b48562749502913deaeece5baf49ed60981eabbda9b7cf07ede0958d300526afe33a5ca63011acc761fdaabb7afd5c00218b4d0b30e76f68ef948bb968ff200011a232a05fbb7840339e46ddadc9fa70a3754d96ca9e7deaeeb341fc52124c03995fb9ddf66cabc164519896940ea900ed4b620b16f6bb654d48a1595f606eb109b300e66020071590288a3833a804806e3c30356ef40d88379cdf4655ddeb1a00b39ebf08f1362efea76cb0a5a041c0b79e5dfbc7a63c978f7885da30be4f6874518db3d921df557b15821d71622ac0f4d5539215a40560708e27b983ff8673b96d8e9c401b533a6d31a23a876f21a050c251518967127cb829c22e7e52ab53dd658cc301e1fa7722319ea09cf6ee90faee04e07afb2518929649a369cae20d7d3844de4213fd5e053b90c053307b00b86a9399d70f4317b672ec5e62b488a11343902a9a3095ffd4b91a63243756a0a038c9116e6b0a37482787c166f7d1bd4b21c994bdbfd78abf5ca9eb3cffeb90bb05bd8e32be0d5712f310c59b868213c33598857d47832cf667ebd986049630712f6fa9f4ac36a451d7a453782ca604e223a2fd77a823a8da910f39b0ecaa40cfbad4ed7e3212d10aecef10d19f628fc2d04a0a06bfd2d603109191605f705097df0b8e94c1c50ef6842bf50afa4719db8802f073e5d5c6d74fa7bf785b3e40e933bcbd60c302500420522625615805252804ba5c2e9e37b6956f446febab40e180530747c944a491488e2b4a0064ee0598515072690c34c2ef423dece56330256a2ef107b31e46d63823dbfed9de3328b66ef2a4ad640aa4b63ff5bea2ec50f31ada17e5b4a95b49a690d2ce0bf583ca3c0f583a7c0eac7578c151043a62a02254498dc9d43b9adc618aa9e1c630209d7dd2872cdde7fad632832a581719b03f1856874387a0286e360d6bc195ae8430d9b8b4aae048bf2893f9c4b4df4600ebd0df73a278fefc3192807a0cfe7c0ca2e3b253552c7d6855c0f3a5ca789a0057941a3ea48616cb815bca74dac7a396562aaa55bcffd922d44bfdcb98623f70baa1d7c8f509e5fc10a13e94e242fccb619d82bf373e52e657c9d3b804843b402cba428d6110e322c1bf61bc81606370104e9609b2a8f33ec5759f86ba1c988020323ef129381cd631dd4bfdb28e041c8f61b748146223cdb45e3a22487663807363b38126c778dab875c9b11897ac24bd72b5fd726979674ca1afdcbc3f3120e28bbb8def6e387f6a5f2ef5b0946716673af415b1e486911c45e4562fe3ee301195774bf0fad987b79a508d3069123db5a4c94240e795b0869d2779f5811e203fa89f633c3516cdebe8556ad03b6f473d9bae77ecc4fa112ad1fc56d32bf730a0fb01b53f2c4e45789bf3cafa070d135dcd5938cbbff42d21ea85d797bc48c06217f552a03e55085055e62fcbb4591ab44051ab6b176065515326e3fd21398080ad1cb1c772c6cdbe899d1d65f6045dc775d23197a4cb4797c42fd4fbebd9f0cf0e7508257d63b885f9a55ae774ce10d14f58da2ef69812cfaca6173bc57aa06363ad072e2fea0aabaee5dc344b02c2421e7f1b7667c937c404d3903cae7a10793d60bb6d1adb0ce5b8c52bcd897e0920d4fc22b78504c4f394dd4c1ea12a703bec983c1ec6d5796e23ed2b7c97a897cf6685b87134731c8f0991c27fb011e0d624cbb30d27a719ccd4c82e17df093a887b05a80a21fb6499405c343d740f208faba9cc05e39aefa83a146ca13367840dd9a3dd197b80be0f42e5318313893083edbbf38f64db229c04f618ead09692d143a79c9f4a17ae89da44e8dcc795e0b40a7d07ef8549a5109d0d4832dbd2d0e43ff4fc41210c5d4657b429d8982fb0930866f856642b6b4e88c501a37a8a427cfedcc3b6d6866d3dbf21dc80b0b3101c2b128b1ef2015a46f5950e0857357779357bdbfadb2ca17399e68a5186ef603a001793b9f91846ad80dfa36da35bc9c46c2d8801bcbd69a751f2e17a1041500a908fee134d3111d0dce560edad0faf472ec098d865f18c0d1fdb1830c68780530cefea68d71ad288baa25238eaa1d9148c9bc78a3fcbfd1849bfb85602046081163b46335411223208e15e6eedf3ec8f9ca293d36eb143d2ba6320971c6550b33bf85d4551b71055f5bfe2d9e66a5ee0b8c17d8b6369c8df690663e06263b0875fbd700022dde146ee9f703ec14fff43d3540ddc1c01928e02fb79913c96b069258c1a35d2709585509f023f2ebbf96dda936d75454b88a41da2aff5916c109b7326ca14b031adc812627e21b4b1081b6a8c04e98121fa224171a88e53814057d2a0d02cc34fb11a96503761b88a984932b88a3978fbc3391e8dc065ce95c0cf45aec0ae717eb103bab87a8bef3a51bd6cc88d287b4a364b7c815b1694d670429c2b4779ceeb0bf21f52db4b1904168819ece714424da661191e52b5e01c907b3048ff9380812dea345262537f1212000cd31dee2edb5518319ce77cea31c0bc368dc868fb6f574cc9bcfaa277b695ee0da667421c8f113e6c43aab031fd50a37a0c2b81a2dcfb97e1a286d3702efe58049858b032d654abef36c4b7aaab80b51673d17a655dbbb6f5714ade4bf3974312b1e17ca27f910b23435c3d9ca5e05575a35bd14fe5db26bcf948b1ed8cc631c2c7bcc7e6f24d306ca2d0b61365507c5dbf7df82c06852668bd6cbdf9bf4841f6b46fef700c98321c8f22071a620035b27fb56f1e0bccca22447e20c2a267d8da40dce27ed2b0c84e618453c430c05469adaad644e2a39a3575f9e80c2529e7c2e5d5d7b37bc1f33c2f9fa2caa9d08fa9bd5073600073e832ab1508dffde661ae13546cf4f65f68b3de46fd6ec560464bc846f9591dcd560d9cc75e815e5a2955cb6630331bb75ffed3f3c91ccbe05cf9fcf5088de4c3cced1d51c150310e5d429530b9e1539087f874d349e092b046647d850198305156ab2bc164ebd1b3398fafa536b046c7ad3159fade40bb40215b6e5e9f53d2fcc9660d334722a35581b34e6a354c9684178aad3a585529c07ab620a906b808aa1a8cb4acff7106c787a7a8fbdac1b5db1743f39d7019d3803f317a79df7568825f924643caa3179f3fb6e70363a84e6150ee31fd22e120509ffff81f892173f3b6f649b315e7f8fb50a9d3cdc07dc23cf69eb39bef4108d040f1fc3cf8eda62880ccc4dcf17bd1709e012a033d40182a390c450d27412320bf42cabdb084a77509b8819a2576452ef34d790f0fa7ca35559385e722a36ed0701613e09cb07d3314d882b465867047ed7f84c292aa7729273d82eb716ae1d021376f5b39d9cc3399c69a19262cd8d9520db64eb75ba1d40d4c62118b498fb0e69cc4671a067d824df3221053f4e252d6c60fa1815185d61b9b2699a59e9f304b81c0a8f871ae2941ff466eec291f88df3ede3758acee8375f5daebb1055fb007014bf63b886e17e8349db7bff72c86c975af362e3ca2b03425eefd663e71b0113fe86809b416a2e598445b5d6a7b713ffbf714a19390a7d6eec2fc9727de10dc21cf99cbc9e4e54b22f2f961fbdd945f09a9ad33cc1b0be94d0e13bc632d806e4be5b0f25f8a468f2d952698320001ba501acc84d8215afeb887fd1f3118a05cc7b0a89fcee3ce3307eae69e6eb761f3e16ece4e2b22e1fced783b7a9d40e0414d34f969958a1b1d3d488907aa829ad82b2f5576ab31b46d474f5d090b99904a721cdab6d0eaf3cd8bc14cc8f3d3198d516d87a2785ea606b884a20a769310668b7c761288283979b37a482dda2012645eeae4c9f0f23cb07b5594e0c8ce409c414f89379740bc10eefac31b9484f652d63179b1bfed809ccdc726cbd39aa0494ad1d5989d1d69922f66ab3442031b8c4e4e9f5a096749289faca2c56a53009cae87ef17d33ea61f33e4fdcb220506a7654ae90b4aee963ad6b7b4912e7bc09cc37add9a4ff5c806e1985869e26774d9abecde0c0df00e04889858dcc2d0a05e58b7fc04cb5a258fde98ce845c557bc1cc92ce3a61b8595c7f5a4dc2841bf05bd67d6c804cc2cf2482723c02aeb9428d29973b55bf994d36f6bddf1b8140b0d148fc6fb6952f6891224b9ed9af829fbddd62d9d3625adbcba5b337871bd1d0d5ca5afe8066c90f61af83886dc10caa990187bb5e2a8a068945ae5e41f98d00f70c27428be5cad9d0131b8e305895c534cc10e1a3f4d7fb35ea897925045f20302689e871bab4cd0859419ced2fe69150151ade8ceaaad9322b8c7a1c2e1890446382cc07b5029ce3102f947b1af4a940a800451adaa19c64d0789c1035dc3026dfbf896a648eb1325e15851899b88e477fea0e8f5917b3afa50600c63cbe30241bd4e32a80204a281b4787cdb7b015af8459f32ae79e75aeb1d7656a65b440dde4351caf8c3d044ade966f69a98efa7e20a8b81ff5f3d61d0659e744b612e07d2c31f0c738c4d8831817c545beb5e1d8bb64ba680d89269bf109fa1ae22340bd6cdeee55789ded295af32cf63bd3023a741ed1a118480f217e1c347c5f6b207acd9a8445ca42fdf5f61de21fb0eca0f524f849e1286166bb6698f4b84d36000a72f63fc83b3c45968960415bc087ca0adeea7577ec03a6bf65964018b79fc0fbe2c6dcfad6c5b698bddeab08ffd0e7c7ecbd9a57a49b889aca64f28a5479f055b403c70810d7a51b68c5d0e0e2d683ad4420d9d2a4d004eeb17d98f99e34d0de535342b855da3254a3e8c2b68d90610dd38d556b5ebb0b4a63d63191d55400d5e0981f12b4ff1d4c2fbbde6a3e314551733f2de3e62fac9769fb40bd1eb2e0650610caa3a485332be37c588385ce74fc3ff4316702ab1e0955fcccfe6bca20549effe3567d12a02bc047c84afbbbf79eab4cc6499cbdc940123586a0ebd0a0004068d2c52fecb352854f52b175f694c8dafb90c162eca2ef744e3c9142cd40cfb7361903c19a3ce5a07c1d6600d7504445d6d34bcaee574529212fc0d4898089e4574efe548d37b75140f6106db37dca4863d5c360d34df84fe5d8552186c01b67a0b21fcbf40fedf0293c1f3d1882e5bc83f7126050b14a00556111085e50e859bf0503e25b377c7411c5a8b8f156460ad96c29b2d386d85b252ecdf880b032761f3538a8fe1a4f74e21795856c8fdccbb845997639ab4ae0b65966762fd0b628117422aa26238228203237cde688f3828937e09cf013665f76d4cc7e8f3035c4fa11b1c4a4cc4be4bdd06fa79702f24fbb3e4c5cb206a4e3ac0c1c755f2032e62adce018911b60d48265783580787403e998e16838cc47df51ab7e6f70c0ec8ac7e2eb7ac0c91f7a3020e6a89bf964cb84d9b9024df08ec3c6db975b02f0a9b7cb4cb9ffd70bc709ae26385c3b6982c34fd712bd77238d075739e891e670e15a59e83398c834550c14aae1f6b1942c7d7943bceec089242358878c65a470890d79e4417738e796db0dac2f04bf2938c2c63b8f2838ea73aa3d92c8e18f70306a21c217c7c74887c6d6c7041668a3721087621c8347fbb17a8757e876a660129b8ebba0d5b5e14f2667e0d4cc0f8bef1b7d566ac9c2982a5f9f7d1d2530d02cf9f7f7d486a4e333113dbd2c98cee4595d7b75fd71e62c1138b5d9b9db770006604f14677176088dc6b90f9836508a7874e0104d9a7984af282dad0d45f1a065dd29819627d15357b3993064ec767b27544dead1f739b694959c49fbc787f0f9c098dfd9822850e037a596abf1e283b5503e369e1c620396a41e0471418d70b9afaa4e638b20f135103c29fd08d1977d3bbb7be916e780e37452bb379fbec04d6f89c166ff3c8f325f738c29e701f90d033109cc42e10e20f681a69d4e31301e81b5ea5b88d38af32137eaba9cb3efe21d0be4ed6e1d81254c9b008b4a4ea0730ec59ccb9dd09a306033c424eb47aaa6dfd939c9d5687e3f23ad057c9cede074de56dc5906ac7ddeea19c069be08020d78bcef0213442170b20b78718c3da018a18a539944fa50a155395bce4298a447371a5dae3c2f4a8490b323fe1266e0a04bdd74c8788155afcbca72c6333c8778dab4bbbe5caba84ae2ec5d83f5812088f3270dd4f1f1d90694a4cb760d259b4b02d257ce8d5f37983f51abf91f4fd0e6c8d233b79b885614d20dedd61faca3304bec895a0a5c4e500c8fd81035d84090f8bbe839eae741348a20035ffbead2ab4bed63d309c18c07bd6a9fef9d8060b62961d306900512c44d6158def911cf4717e5827f930ac2a310100c5d3f7a10d2698642598ffb94b0374b29c7a4bd066adf9ebe08f8e2da6b23c94fdde76a1014379646d7bf8357882ab854c1408494a536bc24b7a794f1257221c4402cbfc09983b1206d86b44ff54a7f98e0c7a241b116c2f47c9f7421944507f342b215d0cefe0ae738aa10a53b96782f634f6f8da15dae0c1fbfa07e5dad345964155b80f30435cecafcf1ccda67dd1772633db8481557fa2cf64dfd43972dd477291db0c6b9386e96905d6623bcc2fb818bc89dbaa02fcc15a5a98d199ef6097679117076ba10d43b8dba105bfea85f0d1a79e76f6217866154def91a3cd6fb7390c2a0989e45a811a9bb5d7b5761f2e7603733ebcda4d27bc3531952915f2c370b78f0c3a0ccd4d72698bd5bc51b644f9efcbacf127bcfa6c6760bebcb112fd0a03710770bab6a7a7fe559edf2b2e45ecc25f56a3697cbd510bc47b65002a756b6bc20c70357e86c5283a5a2718314e24bbb6bf141ae48802207de775afa4d39b22300e58930412f21df215016b1b269f5149f6af1ee37f065cdb7e421f1dd39a79490b5ec35143cc9039303fa3bbc640616360113fdb493b95c77c75b0ce0c1ceb0f0ad3540fba9305c1f27ce1e301654d7eaf17b4c65b339a89d74914e5e302ca170435caf6f2e3a9300784cb2f3b3886b5d5014f14c92cb58095f670ae7981a6790732fea2f6b8aa21e5211faae6e10d7053a35238e7d17e04bac27d63b75db981096617fe6ef05fdd19786e0d434fbb25de552dd4bd7ee5a1de8cc4cf434e11130c2eff0814d52006e4854f8bb55c1a317e9d243a236c7dc4245f7ad858096c5c0634916c54c814758d8e12d39ec9f0e97e138bbf62e38068f030ecf7fbc6f5a100e7b115048a17be2e455c2eee1fd7fabfd4935bcd2262727f6c1ae5b054a91801ae21ca6a85a165b8680d5361e1f2360f2b8f2b85720d8469bf419db2e8fc190d3310466a68da382f9790cb7fa16e852e205bc9829f9da8bcc42e738e995a3f025b6e566c09db70c1cba5929a37cb6a05f7aa02d6d91815e91e2715166b6cfb06992d89e53204b74c6b1f48238f2f9950523f33f99059df1113d7bf7883c246011866c9c3bcbe06e938386e9b8ec5ffc8875e5ff138433e898e53e7ec11dac60b4cdc3e2919375d16dc5f963fcae7832a0d9d68a02b449a33ccb718be7a67640d455b6be3ffe215a9e9b07b3b7a24a9b26c81fbc0518058861173c5a5b0d5da03ff254ac7f8d3ef45f88bf84467e2f26f5c8575e9d86fddaba06773c2d5b5690aaa5ea817394503cf81ee2d636d05be367a1e0d7a63abe81564d5c12213e6d60a22e627a564cf24f344058ae81a5885d1c8d1461a70a2a639752d76dde672110dc74a85d7f361ceebcf1ed1d3a7be21be7e51ce61ecd576bd3df17315d23e6b0a74eaca61d36c4be978e72009bfe9c6238f663e5ec6887bc7bc3268049b12de08d4c124345a94d7b490e1d67c909c857c0835abe9067f7f5b372665e4c46971034cfcdc2c973b1f7ea2b5db739748b9614b3940659339f865d28be5773c2f6c04cf48f52c6044e04ebcb70d717486a479556e6a5e582c56478cdbde425245eb031c18ab63fc9432e4c81f099893b1a53e786e75daf909551d09ff82aacdbeb107413960e4bd6c3cd4279507eda80793a43639da85d1ea7357a11ae4041dd6300e4294d9493c0d4eb71c01d054b0f118d3eb4ff81590c4495f148fde7b2099d30274b64658a9f56b20e47215bf297cd63707b4e5b74cceddf53ebebf05f9d0f1086fdeb8abfcd9ff768c8cdc684f12ed45e0e5155803536eb98b60304f37295b0a565f1fcdc786d62f022dbb8431f4a5e903b6b73b4f7e3194eebcbfab2c9f95013bde23bfe4e5a2308fa989ff58413fce5f570c84a2814865db37c122fa6e0608ecbdd08626d136b4a37695658ac7429c016bf84b77337a440831a30516d63c05f00df7ac3ff52c1b47de977dfb761c02a56c9895438b3002d8a30d8cd2a0bd0724b4fb8bf5a122093d389854d9a331d684ee1517ad504c6027dc68518831a3011fc3b3592919e0a2a3ae333d393828b69aabfde2ee7c91487a80ae88ed6ec20a2909a1979a9d1bb3802fa536f21571f55b7d89f58a9547f6ae6d38e10cb17e0e911773c20e33a0e9f431938fe51333a3cba8b959ddbb986e468069c0ef44390b99d15cd696ff5aa766a8e55cd2d6c4919607f2423f74986ddc015b5cbcdb000bb81d47e14f8d625b12ddb005c0af6dc33e9d9036286a619f7a3c187712b61f0300801b8479ded9cfa9c27cf5e1c6495f9cce30649aa1a00727020cba01917909a9c2f2dd7d8fbf4c50d2f98f6728b59187e577319b8d4ad29763732cc8a90a0080019aac203c850c0c73b65296fac71ca8674e776c5393ed03524338e082640e06d09d4a1780564aee3417782e4e4d9291b763bff0de6b08e84663db0a29ea031039a13b790b6d0eaa88d351abce46d7b4b6c097d2de2a5e63b5b317f32ff30745cb729f9a34d66d7eba658afc17486eae5ae5ed7ea6c17f3ad71a1ec96373087d805a8a57b661a7ac0efa8092298d1a8b8540c67892d2327d254dd9e1d5980a89233369d04c83623e057c57c9d984ea2287ba09d3edbb0778d4102f2a36fe04307e8509d6867760d121c727bf1f8deac3670cf72d84798c5333b8edfa7e640033ce07b3e3a75d32d62ccbd2c32727f1c767cec9155a637ad34db8ae486c44038f379cc52b5eff00dac76c014eb92a034e1697a92fc35e0ce7c8aa57957c8f033bb2b6f2bf8696a0aff02c5f0adc78752d766e630ad59a6c248b7b684d6c0009bbab250bddf205d052ce7c170fbb036ee7289a03bc4f10c4cac3c60566174f02be72ee55534697a5f2455fb044509b68b7168707e7bf21de5e5c87a71b53d107e3f969dfd54a7836cc690198a8ee7fc6fac5321f22585f3aa8a46f09e482df0cd8a4227450e36e15cf29af64bf480f36f4494d7086ae836ea681f3223da6170c8022ac64c98473ccfbe8ff0cb89ca96722c7884119b60f153010a9afb3b9d10b35d858af65a21c58b78a667eb3df5e75a6122aa3eac4467e492a66f0b0ed2e0051eeec230cd0f7f1dce088283f6e8deabaca0a94d46519b6a209cfe338eb9f0430baae5661318e0c9bf481de32cce6661c5b89f5bee27f3a5c3c0237446973054602eed42ddcf04a1fa0779d0a45a365bdf19e706876d0803fd2e4e869a5910e66ba3f0deb9ea2839fce859f4933743960006e22b65e1974bc471e124b7a730609165b1fddcf3a87f1e15d54389ac97f09668f6e060b5970df82d1f9028083048eb1a971b7302bf73deb283c97385068d5ddff5297ae836bb0b532e0919ebc0349ab86b8eb64c8b0e1540be8d5b5d4493f6d9d93cfbd17bd4f13e139ade9f70f538991661e7c22bdaba20e78f978884ce5ad1a70413b29242bc3ece037213a07f02f41a312bab6ba08ecd267d87ddcf9f67e8a755d9817953fc39abc92c3ad02d6bbb824ba237e0bc54ec5eb755ad18fb9d1b6e43b612f0401c88f897bded509404fc50cd6f563e48ab89856c19e32ce841755e993923b0e44255b38500195085628c4627b689e5c5ca31ebdd0997a1cd5957347aa6572e6617d15f7af15360d1bdffa4397c35000e86a13d97955b235f5dffd69bfeba3122f8875c7e8dc9b0ba82312b46c7d12cc19a6b690818cfc4c712d8c675da9334ab375f9ffe4accb09647fb355068065145639af9235593ab9479f894e1bc3c8ad33cd0d1d4a37a004bc3e54b9089f6a1ee38041837474f57ed99cc34c6d53dc682b4af63d19045100fbd79184be9ffde74ce4ccbbefa8098765e808fdd66a77d6ece9c3c37f4e4108c8fa67ae08168e841991a5d27ae804f91de710f70d6d099f02f58fd6e22ced0ce21dac068b247137da0399012a3f5772bf98974b709761427175408a2103f0099b72c0dc0ef3d47479d054ab8a573defca79ce31bd663ec821b0ee5d37a05900ecf06a6f5ec1afaceda9f445966af100ee627a6073bc84cfbd20380484cc4b0486f777ad13b7f30f3b4e2489188e2262d88452e47ae3c6473e5ff5b727a7b10d63973495e4284e05e55256d34d931873077bacd06f2a43c98714695fb3b21a0a1b90519907904a2946e10faaf08a9af06f4a24db799254a81f5e14447fec2e08bfffe29b1f89fb94826a6d4968314c191406968716e9aaffeed57e5b1c0f4b06dfd88c928ab386eb6b8f883ae0eff94e96d1669bb8ee5a0423f140ea13cb9b06be5ded502cd8dfc89e3923ef469e16a963ce91208a821bd0f5a0af0f0633de0ef4b5d08e1c29fd43f31da2c0ca8fbbb2bd9a8fabbf50134bdd0ae1cde72e880cec89a7ee6a902acf2f0a020dc47ae02be32380af625867f2f2e1f09ab409260cd2bdbbefc1a14ea87a4e17e1815a8f6848ccde7862fe3afc67ca683a4dd7ae09514fe82abab3103899e69f1c99c59c3f4cc4bc760c45b1f2f8ab963ae2f0f0035771b04a1aaea05d02a686f040d9d61b14b7684cb19f245f28ad7c5205df4f036ed0b5c30169baf1375abe7ab5d8a354ee3790f4751c5e75d1ebfbf3a8863c069f79cc705c402c72b9e0ddacc2c9a691be43d04d6834dc42dae74f24c7236609bf7c0d2e3468cab0c037e762ddcbd75371aa65bf3127b4b123b8c0b9872f1501a4b1f939049109d633e6f092c9c78eeb4e47a815c1cf476e1585b4c546922b06d2523040823f01a97df27011c5d7b9ca3d977fc7976c9353e2a2e229e92554043f097979f3362c44ffc43d2192e338220e0cb0dd2bd5d9aa6df6a88e7f88db0e8ed824a9bad54a3ad8bea7b8a2111f56fd520d3c7c7e814f22da135c33d35d061153b5a6192f733cc3022bff92a043426fc54374c8d0d9c131a05aad61fed2080947e28698e741e67bc5ee8df2b6b357bdb06bf53add22c94dff83c478fe2e0d6c4d9308e894179b9f427894feb91627c4aef78c875287842f0cf3cc6239f308f9cfb496556cf1fc54ac8e1991143d740d906ddb5b72c321eab125307f82020ec44c33804ce19f1593baa5e601a658114d8c696c2a7448712eed853ddf9b32071726d110416eb1a79f4ffd2cdfa9b291228697acc7d89c316e8091c10e4eed0ed274cda04e3296c52164a9c46846073f34ffb09ec2c3f64b23d26c919f34ec03a6c69ab00f71db5850d80bdfd3ab39581753c045cf4a034418e6f95d5763190b0c4f48135e49d63665e4ff237e865a726e86715d5dc7526d3f6fed76a5c4ff09ac7500b12eec1011512012f1b6925f32302196ca6992e8325c007fa5b9d73805530bcdb0451f195c7c833c1bbb8265eaac8ab8b00f1ca8b63727716766c7390501b0329124b468af903a490a95538b3b09ca73ea639b05138d129add5a22f607aca781f736ad686e02e527163d4ccc69ccd0986f10825d3ed716cff988dd93030cf64b0bf04f95ce2e2849d6cb0b17d296fdfc3c97fd0dd83d17264ab2851202d9bda70b489c16e1c4e2f3cb32b707a1bf94edccfa068103d95434fb4af7800a4e3d5b49a4d7a34111b29604078c9ebaa3705e43469d440a60ca7f174e68a70c7de4e3edeffdf2ad2eb8640bec011927841d00ce9582b1d5c8055f209d3d3e0ff7bb2b3998c6507286594b67f81a02b1c193198a194bc7df8f2fce5aa50c2e0df55aac55e5509bca51c5f7a4dee3f5211bf359a4845597e9e4edf5b1dce5be023e353313b1f0425f854e9a81992bfbc034c85c97cc96c1f76f2132b9f3731407c8c4ea717854ce40ee4726b9f4069e92671968c9e2ae3c3b92a42b8b220ce903e33b00040b3f9270d7efd0b64daf32219916f7212e2cc3376f0ae04ee73bd00c134cce8598b83359acd5bbe97ff58c6ad1f798b7a1d1c1d5b81a3f71bae9410b4ea9cfe793cf2dba09cbafcaa11c4c7d67eab06a1fa61588b9685d73aeecdc0b40a165791e4003df8c777fd50b2399b897636f3bfa6f48c31cdd4c16f0965a04d275fe07df2ccf161452a0d57d5616b28601d2735c61c22719cab7cb2272ec023142fb46cf5a99ef16c3d5d282bef81316543f150541b630de8859d28ada98062063c004a94f6901ea45b036ad22dd61242fc51943f0596bb77c9467a7b12c0e5bad842562d84b295c0a0e28c9b67da2ac6126a33da2dd769b2551127dcf22017c82a456c3ee28057fca0db867a63f4716fc19538f09017ca01bb4eea89b6104de3fa7b79d62b96b39b7c109edbda2e2fc79232234d51d7e60f356a80a6bcc036539a6fdb40787e3c116bb6ead9deda80a4b0f0f217b6942ea34d544325c4c075908f9cc2787013d1c0fb30c1bf6de8ad255c9ff1b8054b719ed780601acbd00acecb3b6a3b3521e905220d23359a3d60f42ffb55b4a5bb5e67f0f60e94842081d13355b2b5bf330792b1e219c8dc63eb52e02cfcd360849c17118ac2d1a070f7651f9efd17c5b17bd4d9a53c22d760ec29e3836015244542df2c2bea692c90c0e535be9a6a1e9b44538ecee2dadfa45213c41c68833f1df6f42c8a139414d042dabdb55ce95028cc2cb986d88c425c543035d79fe3239057c0f8d0a47557406e50647a91af979c0e0cff767bf32f54d39e8b4194c7a8745b1fcf471b220ce05cca8dde92cbd322d15c09751afc3c4fa0224673cfda513ca34509e299ec5c40b221e1268e802e891657a4c567813546e79571d377ca49f70547ace7213251e0c6cb1077bc4a6263063d1358a14f8e6e1b5ac324a2ca0c007b3332355a9462708598e7ea18e22b65b0d8f93edabb4511b2a470ca02357530d9e89e73faecb3509d7ddb526131c6da0176fbd613d5dadcd1b5e7cb0b29cf477319e274200486c087cf5b4003e28f4e58fafbdca3121d525df8dd301d9c402983b8c098a2b5a8c0af219ded4cf728a3d1d9c2c3721b320ac9f3890e024804b74d63344be15ddb503841e466ad2221e38a09ea648ad1aa3502af8ba064d249dc761e79ea35c47ab0893363b93a254d779f4a7114404090fe3f109bbca73ac0f6d9fc082fe4bd3190f8765b1e61c942a7f4e5e75e113c8acf0e66bc14a81be45e84f820547cb10370e160eac863882bd6eab14c14eba6270cf1ea89fd10d1d0fd866271e9caeca2001740cfa9f84d9880780337e197ab238bd455074c48a01d71dc98f85a0b477cc029da8fea44b8b1d5c7e5b86c3909e177294766283307657673620bdb9b6f51809a84f5074dc85f3cd184b3f5f02cf7a55e29687b9badd424d3cb32c669cd33b02ff484d8abe7fd2a8b4475578deec90e40ebfc80e0afd0a931187adca05ff7b05e92cb88a3d5b040d1e24b6545463809dbc3379c0ee136ca3eed5d65540d480006c9a14fbd61c44db98c6d9f38f22a5e109f39225d749ebe6acbe2df356c5b00cd400595449a68c64ac9297f54323611b46d6af46c84915367ea28f098e3b1409fff26f1c88e3c5651d382f214ad8bb127904ec9206cce797c178150da5963a0ae971d6f2eae6e2ce4f85c28b15e9baa49dbbecfd5ed7717a84c96142b32c3d00114c093a7d21aab54fd00fbbd72d17b8b842a9572e8e1dfff752e5a5cdae2407e1dfbc066051f8a8fbf64cb735d0ef5e7e137ec890debb2744f0ce6f6974380840a653fca5eb58fc9e05769e51b09d296447a830b6dea6e0e0649a9f2efaeb0ec31edef8acfdafe7f8e90bd133af9f47d758abd9c80ead04ffe6490513937402943d82625afdf5a4e24ef5d578140534972e1df735c76d96d0439107fd2cc90fbafcc683121e70d1ae6a3ac267aae2bb6f1b77446a9f6d06b3e8fba1b1fecd0d6b55535bddda928134f6de8a696fda475e5439f20cb4253f4ab2abb133b8a70fa2ea6af056c2b68ad65ccaf13ae7197caeed34284383cdab6159115f534c33092f7bb1d54f0d78249a596761ac668d140384a2a51edd475d10989c31b6ab670739e38f0ac99ff15da74325aa9d7d11fe01c979e532626539c25694243e2bbd01be5ba415608743a8d33eb2a50a08a5ccd729f10a7696696e659f36ccd59a180ea38d6f39eeff584e2a8c8e2d3d97818ba833503a736bd124f0332ba56e90480d63f64d5191430ce08f922f6cd1f9486c650f6a969e6c352a93f4b4666dd7ff00d1a81519bdeaf52e50cf311091bf14d2821063e54f244a17ebb6b1e6c1443408e48465a2bba84c402d92d4f091feb2ee13e2f61c683ddc880b5c3fcd03dae10d6f5f8b488f13d1478829ddb453381c94084df9cc68af3d00b3c2b20dd995b208d5fc54d10a895768f673c8abad552d52ccaa3a78eca5d449265df2bf5e05720a5041d8e2c871d2586e226ffc94a792604d535deeb89727f6eaf9a7df4f99fe055a0ee3f49471e50d917734c6498701877b8f9be436d6c7b92fb8c296d9d441067fc1943bac23c1ff4363416a26c1174edcc7928842060df4d91628b655a47701a981da5a5a2024ba9f5ad601cb1dd1a88123c648e098861c6e6ac004ce023b044d458e73a0d595b6d16f0144370ded7d7b1e022818ab79ef2f106c6abf2bcf0affe5034abbd65e4fdfafa83618bde59aef19888af9afd24b056027f3ae654d03b701b246ca040487b9e517dcb3010865bb33a47d3b0746c97ea259f233107202bc60fbd3f5e274789caedd548c8679ea6b4befcf123fed6b5153bda5e9ef7a0fd06140c85c0b5dbcaef7b3d200d4ee90a8249c9e1cdf8e92d79bb2c85f4b9e08467a89998491163e0238e4445b093c5884224498704003230c660511933f680b8c76508ac5ba16afcb66a0e78de102d3870797fcb0b920bd1c7b8a75a3d16d05b94fee589a49419012c9798e69daf2dc16c13c53845c4e88d85e67fb00ea7c033861a63e5b6ed57be925e9b80db780e795119e63b52e5c140b5fadb52a7694013aa1545b1ba096e01f974aab2d7da58d7932ef10b29f7f0e179a65c37bcab40b04b85395341bac5c9d9f44606094aa31532e14c8502e2b063406e763721cbb031e8f8f89da788f8227b8b8e5f301072cbc97dedd93eb85553f1b7417e53f1a0423bb007fd2fb4cb6d63910c1680dc7bc87167ca983c9a94b48f8c854fb64dd04f271037dd0076497fbec9e7d9c675942f9681c387dfcb527efad025dc2154f0d4e4986297d467556d2251565b8707c2b84ce889da99f11f0f824a29e1dc5560b754ec5c6899649a51c87373b0259d8260d13c3574ac8149d84ec6f249050d605a4332053a58592bdb75603f02070545d47a5d47503e799c5b6947ba1127a9c006b8e2b655bc756afcef946233249aa8005b2910ca286cb573f1f44c0af54c004614e9a0e1ee3797dfb1a8bdccf0975096c5d76ac18d221f677450e18128f9108cfb7d2f119b19e61ba43e84675eab4ef464b6969c3a69c4099b66b609701960a307133c2e69c7cd453c35a374bafbaac58148cfcfc08032a0f92349692808a05481a1dd5b2a3ff9f9b7d83aba158331d106a57fafd3da0dd42f0fb335d6ce808fd042bac3192fe91f1c51d1f7b8672a788367c7331db3f37130b13b5fb03110f19bdfc154625d8924fb8fdd7452dc09da3d15c0f9f51001e6541975dea50ed0a558d87cbe304bce9ded3d7032165880dcfd083a1edc80b78aeefcb5e15f7680a647c6f92f21b4a69b5379924386a9495da6e6575f9913e32f436c7feb5ace3007a27de0c60cb4d4cd95431bb972be52e84b7c7052669fb7e2bebb79d5484d004e215168e399fcf748568c564880049bf6b4011768dc0d8391e61aa4df68788080e26f2de6371da6defe64c9145fd2f2366343515e409f336aca01a1da93c9c041dada41c88d6f32b2869adda485c25676936a67a6ad045f8ad1983979055710c58628d9c8b76b777c3d725df2834dadb47d31daa94f58a754341213f071edc07761eb187d598c63cb131b4c3dfb9e75db5fc18fd1dfccc2c312a763139e1ca09b833dee4b3f56a0183488dbe861a2adf22a6eeb211c90e24c62404a5efbe6208a55e6d89269ff4b8d3340c5de4ba1e356a11f0ccceb30862b5ae7301dd4023078e81a9fec40aaeb33da11ecee01fa5adc6cbba2a3ea60760943e007eafbe9d06e31a6e43450fdea71fdba256b21405f675a2b3e6f2ad01457c8ff4330fd20807f9227e96533967cee1449c45c7e5657efefb8202019721b26729f5801f490705a9f85d727d99b78286135abcc50eac7158500710eee9d6148f360b27c558d10c3da0a7bfeae8e869e4c008000337af5cc7b19cbd803a1f71dcdad538742c960956e5acc9ce75e05736175a01c84935c724ab1584cda97ff557ce9e2f2626760c725e40802b6908051f928ef8e5c84785e763b23bc4daa44dae076d408f289606ce4ed1fb55cce38ef2f3d28190113280384ed4f1cc90dbf65d788ebd4453620c0bed02b6acf8797d3e414b2e74046735a291517de9b3fc7466178a9a15435b0e81c676dc29b80ed4d25062af964c0578ce0e670edf3fdcbf03e4496e2790a7099f9184ad2e07e409ce075089304731ad21cc0f78693e5d0c361f621901e345093cbe2ad4462657fa3c9ccfb9caedced748a476343c7aed7b34e325f5b5e83e0a56ff16ac225f83af502eba542908cc4ee3e138e3f34c6457cfd17cbb5541630fab601425b8692a4e5dba7954c4000d247d0ab6f31016fdb4cb6f5a4e3cd3880931f92bb201ba36e29ac5d5be99a2e3acb4a32a5911f696f03fb441e4cf20850cd53d725a7cc9ed083546e2884acdf82b00cd1bb17274ab27cc6cce5263838c0d4fc16cf7abb5f1eda114b1bca7edb0d1ddaa181f9c9f1a411f53eec8d1ae3007cbbaafe6846705fc7834f68bf4b5a47e922bce6a5d94e1b4fa80f840c654930542b796985b46d8c8de2b36847326bcd9ab32af10b32bcaf66e411cb985d7c503481740e4c26f8da831cc5eadb4600e0d1ab9f9fcce9fb0086115b5658a8e50026d0f86eabbde65250ed6bf70f0e4e00101e812fa83182fdc1b585c21fa700002b24edca4e4c2ac0ec802f43ed649bb876c90a267170895fe8cb48d798754ed09c00b2fbc68e30972e95ff2f51e88baf8fce71db37f7f0e9f9a6794a603d8450d19f535de170f849d953cc87b96836c9b3cc77e5f4377d4675c2ad32c642740061d9a81ab3340d3aab84e8f20ef0c1557e8035f222e440cc01424a1183f03f40e64b4bbf7dd2194b3d034c29a066cfa96951fadfe27b0ccb0647f9376b6e86b00c54b97fcfbcf7118912f4dee6a251cae34510543c4a94cd0d9e4e8cb3542c206168e20027998a1e4f99d71ccfa6429cd24857d3ebc749510a1c0cbc748d30a01fff2023157a48fa8fa072a5d278cefb402c94f5cfcba493a65320d9d13bdcd0fe74d563e4ec494353ee7926238889070be2d5856412ec92101aa406bd596280f62c41e57951d6ebbe2ce2652ec455e01929aa5868a1afdafe62cb7d42600fa0936e5eefd1cf4b96844873f6bb5f2e30f2a6e885f8d06cb64d7e65f73fda458016732ed8c105f8322132ba763a4f1281880816c34f41dea18e7d251605ff94a0615ef2c5afd66888390d2de2f72c95d64c8cc040ba087222754f85f286d903102771df3f40c9a113c78adac396f33a4d045e75fef537faf774497dd0e9eca5005 true +check_ring_signature 611269a13e3c438417e4fbfcb7085ff9bcc84919156a588b70dfc6dafeebede6 fe2ff6e8edf2cac7ff6c439f98ea1995e41f616beb26cee48751f01535274d31 1 55429425979d2e8b010138380f7bc1edc981ea672c6c9cd119ebfd6a3087e6f1 27d370988788301c5d0d9b94e7a03af72f8d21c0fd32d58252d14a9dca0d8c099bdf33a6c6ad897528520ed1a7c7ae4e686e21bbb9be91343089172401163e07 true +check_ring_signature 6c65c8d75d8c28fcb01b86581f314f1e83d6b2bd1446bd5c090c5e982f198cc7 1b67d8768633780de0b1448d84b76ba3f3ad102ba2ee9a7f2bd23cc6da5d8f31 8 7ad8ce9587f72063e1cd2ec5acd93b921e37b283cc0654411b39f96369f21531 4d96aa95e7b82b5b070103ac5cb342f653df3a2b5d074767ca6a9f865884d840 a99c8f2b3122aa8793e16e4a0b7fcdb79f9d81ceac0c3badacd07a6396df1dd9 18143e19c59192c0aef863837eb6a1051b1a5325265fcb9b547a6c591de3af95 d2bd71822a9631edb96e4693959e059e3f37696821dd0422b0f1ed1811f57549 be9a01579ddec9cd77298019b60717fdcc36effa4e65185da1201de32d321a38 8da72e60983c6daba3dfff244c337218b184b53c0017f3a249650e7af9e2c6cd 7955e8e7d29f9d0ccca2565961a1591d5836b01142e9cba4a8f92dc4487b636c 269e56d0979de46a2a89bbf181070745a700f08cf2e9d78d5137fefe64353905c58647f9db6291a38645a17dfbe4938e78dc8d3a1810677f547a09c767374b00707d39eda99cb71746d9137b75564772e2ea82c2db94676906c914d622b73f00fd073d38bd9140790eab8833eef7dedf2ec21a3e4f0e0bcdb8162063e91eb90bb1435735c9091ef62cb0aa988fc608f9c07ca5fe621c6a827509740a90a02b0ca84ac53850a7a14687d396e3f6e689102b14a33d16ef5d828c3d707ed11d940c9f194d21872291cf1094cb6e335de574abb85ff46e6a140665e019b466f8810a535ad88b2325a3d6d717e590aa89e8bf877988c6ff6c4c2a9e632ceffd244f072b00655863392598807df4899cd602e99b2450744b0f05d1851d2f83e893fd0fcc55b3c2b72311d8479a22afca93399abe8d077ecb467ebeedc192c7fb1f310e250c25c16bbef5a377218ef278e94e5baa7a99a471658d9077dfd63a0c5db0050b4896582812cf477c9d4629ae6f97a5ec3b591a4c8ad71370e53572eacd000b764fd602b66bc6deea4090bbdf8bf2697c995ebd0011901c054e0a0fbb1a8e0953b3380a659eb05d62a27c3057f39795f7325de0c61da6bb965e2bb0a0c1c0036882b9cfe6478f3fc28a6c3d720965f2e687d6b7c9172c892d0b0c6183484b05609bc489db92207c99d2a0314c4698b9405f54d7ee375a3fa304cac29f435804 false +check_ring_signature cd5cba83d4c92572fc57ff79dcb127d9986e5e78a1a363a83fde0992162ea2a6 576b576fc87ec4dcbbe6a1c23b8555b166c414eb7e2df53de7353469014bb8ca 2 faab83e3ef5f83be48c66bce02aeb63988da8a5d3821757fcc67c46c46cd4f7c bdf833bedfda892615d8d2bf5a8b8c3a5d8dae8127012c95f114984d948ab87f 6e12a5b505064eea7c23a126ea7614c499682878287181bdfd7cf32d07cb4408b8915180fc04feffe5433a66d65d5272dd69504725fcb2547fc842b6596aa406be36d19a8544903939569ceefa6668e8975ed895061d2ceb732887834f89ab0a48652b4a773adea9c154ecd50d8d7baca5daff070e3ea84a1754f2d91ae57004 false +check_ring_signature 82e2ce6819a21c949f58e9206de72da8009bc77a0d502ec2f82ff79b4e7db2de 01104ea90868e2c7e7a86cd31c89590653122b3fa68d22ba5986c2284efe00c0 3 71b71106e0c8547b36a6803a3559ff5c22df6f6ab92034f4104894a7bad067c6 66f1a86d393edde8847ff60adf646d7857643c24e06b9acb2fa36e419c35c545 e603f58ecd20859292ccdc9c547bf27294537f5379ddc05240b453a4a285589b 254e2a64b348871fa6646e0720b182e582d2527016ed08a8f4dbb4eae6ce6702c76e6dede6c4b9b7b77a1b4692ecf739b59767f94ca976a95b78df4bc9422509d6e535eba8443ce19f79cc1fe169ab3f41286ffbc8050ea1f3b5976a9ec3f30a5b36ed90dea5c1ded19f160848a7765c5ea844c2a38f975999b2901175f3630bef1e56e381c9bf7fe9f75fb32dda2f34d363b5ab61885621cf730e6b43d80d0ce2cd834a97a81566d29f3ccd9fbbd4ff5eb6383cb0d44de18bf187b3ae0bd98b false +check_ring_signature 6777347f9cc593e8677055eae788b28ce3f8f87641edde294d51e8376d904efa 1acb7efbded35e3bba9d24a46fa95b579d33801d76f77e162b1a3d863ee5f276 5 1f3010ab1fd56477399211558137b88226d01f2f65c908b3af578520b709360c 01579f0927fbc3b03bb8dabfd68a4075302af8d96e1fa8a68489a658b4782fd8 197079004d17d4747681d216940ed7a931b5403dfb5bd3f87b4c1c742dd56b1d 254b4caa4180536c52f45a90bf69b6d02046a2305f67ebe6cd236ab89bc53062 50b0be24ee72c866fb9e252153e6de06b67b0eb853a2d87b2ccb7c8776321a41 4c786ad46cb9faf1279958ba2a9cf4c753abc47ebeaea673f748c473e984fa0e3207fb2875350bad4f0c085cb273c976d3b17d19f8d82b75c6b0a925a159ed02183e7aa94930a2d5f3961219b51b51185636a7bdf1e20a24e6bc5fc0a6488d02dc7f8793a15d785e8b541bda49582c06f774c03f5dbb256455c4c98ae9fcad090d81206bcc2b4b8bc40836ab75b25afa1b0c59fa4782ce1d87da96ee22f004f22d1f4785904cdc4baa05db6ed4896fc23ad7755614ea5e2b1925288311a5a80b584314614772f053252c8e181fa7e23314aacaad2d49cc3375d69f2014ea640eaa0c95f02bc4a4923602ff1c3c4851da9019683d941821fdfb3592927f355d0e69b2513874c9555a9a6135d399f9feb9e44a1d431ceef44054192fd491048703af1911cdcec5c861d3b606e80f5ef69aec8f6a8921ad7a284f694c6442b9cb0c false +check_ring_signature b8ca2847f6d59f432ff02af7aa15c9f5cbd610769edc7e0050bb00d2c976cdc6 6011140ac9068f773c3ae5af0ed88184ebbfe3222b1a6b678669f50589f1f68d 1 0d765ed5bf59b20a6662d0137cd7be4ecd177eb0ee9dd74fd1f2345adbde3acf 95d58139c90c06ac380becd874e6dc6cc96a95e2c58b0c363affdd3be3234c056fec0aae91477e274d9e21b93b071d010ad020f67bf1155b236845797b41b602 true +check_ring_signature c7dcd314ad2d63694cc2c2e8598c83322ea13012a2d56bbb09f7ca41dd8e2ed3 769f0fa574d74e288a8b4ae96c55916f9c973a7ebd92f371a68aa7bb74b80ad6 2 f3e0d9084ae542fc89c942c54b2f07d0140e803b076f2f178f1eb2a7343e6b77 57e37ab04e0fc6d7766de31988c6ed10fe5540f60c95129b0f192b5ad89dbd87 f0067eb2e9c3a5613516c316e7142c88ba90dc10a81074afb5a6bb65343ac20e26445d28f68664e48c79414d68a70af0d358bba86dd8fef75a11fdedb2287e030651d033b880858748eba854ca808bec9e9d9688a8e15f5b63d8971a6b081c0461ae44175b9b214d9cad220537645dbef2a92b6ff6a7c8249e643bbb8520790f false +check_ring_signature 5ffed8b1c59afff8e17dad4e0fae2b27c0d42487b75d96d2027eb6e0d4421a46 189993d22cf4c736df5e1a5a7e7aadc51fe4e1b066d1df46d03f9e4e02fad411 2 a25510c0f68028d088fd50f2f2e2cb994be0e6e1e03e9bbeff7e1ef1e01fe55c cbadcb006cbd0ff262f4a06f76ad94d76df5cbcadaf2588205e948644f5e7b52 e5b028334412ea069b43f789b5b65563301c3ddb97de0dc4e7cfb63e52af5b0fa2fb01f038783144b8b41c44a3edf439d7bf51957aa26c46e423676935d0970731d1a551732857e9b7690a67304b8198498e1a9c2457780b2e1f210f9e02c4056c65ece29789a2d8d67c6fe62e1409018ac59151394c67d69fd638941c69dd05 true +check_ring_signature aa004468bab6aa8c3ac4766cc0535d27c1bc277aed7788f74c9f70e03adf4ae7 1d2c91d3d5b8c2972a844ef9d913ce0e3b57eecd7db2c8da4665de61d3e41615 1 0dba60fdb2a9ead456fc94ebcb2c53f0350077e47aee77092843e57caf76e5e1 fb597528c9321144fee6375f6511483ce2c5860fd29343cb8cb10e9e5670b30634ac6dd779eed44a6a0e3053ddc10e8f13aea5ee3c9422aec312ec63fbdf0d0e true +check_ring_signature e64cae40c6f6a78ebd03bfe56b13ad65f610c7c4f968d8979bcd67375df67b91 1c30950c42a1d2c63f11b24472a5768237e8507f26a5296c53309003f91fa876 2 dc41a2f5a4474d4e737f6d0f9b928fcc519085fa30f0238ed9819608479e72c7 5482c7000f5fed27dba1ecdf3ed9403042aa242a8d9893501b6764f2ef5a15e0 1c40a035ad693eda22ddcc875f6120576d4ca5d97875d5771bbb207b16afba90119df8a1f6768ab26f87461f2020fcdbf958a215361f622b7c46ba35b474ed044b3050109c449ffe995efeedfe71942bc0891c5007848e7fb7b5fbaf4934e702b34124c184082bb86cfb610d04020967438b062cf1ff5c6bf704612bffcbb90a false +check_ring_signature 9b42caab5a27f6ad5151876e9465d6091024996fd34b0b7cd65c713a5a3f7b14 eed8dd85fa98289f35f918c7b266f6f10f106e0520656a5c8c23cc19053820be 1 ec69efca4ad5506695058c53be8b54d26275f5b87c1291a0c1bb2cdc2e783c89 5a3aba237520d7297cdb40513f79d64d38bb5495e46f812f1665d794e5d7c804fd54470bc6503fbf60cfbb75932e3a6c1b9e67397333f52083b8d13a71f1a100 false +check_ring_signature 6e01d7be137ab83a0c0983a52d110cdff5acbf15edad0bf681a426fbbe19b6f0 894febffd9b06cf305ab145c0533395491030fa736d53006286ba92ebc086751 123 7057965971bd77adf9c04b1a10ca1cf2f71a8f9e7f3a4d0d378019bbb8f34c6e 4c1162000a384fe274e5aeaa6c619f6c5ea6091c280efddaef0d166b3da1486f 5ccafed9ceb3bc04b94c963d88023b198e770718c1b05a2007f9c59377a6d205 d12cb1ea3d971d403d3fb3926cc19e12ce45f68c3489ced2ca3c23fcb181faf0 9e338a21f5351682112b80dd594d322ce1a374b24205ee2f10f3f292cb2b2338 dbdd677b6af2a777784c8d1a9e63e61a2b3f5e6e756eee7fa72485fa03e0cee4 ea29ad140227eb3c42213d25653dac37b9896be877c0b6eb4e02f061e0d3875d 68dc8cbb87c80459a0d004897ace3f7f602d7b4e367116ddaddf153b66213d57 2d1231ecb21091a35a17d3715b3be8779570a9c5dc6f7dbf7aa9becd4b4608b0 f1e46fc5d30ae8c146b5bc9f1740877159a28dd52495a11ef4f2dd61e65ad1f4 cb8affe12d0b4882a2bb70d3bb5391583ab59a56b7aa3ab2bffa3f1cae75b4e3 ff479a9adea4194dc7fe5f51aafd59a9d095ec53688aa6dbf6a6fa06926671bd 526593ca415ae11b26ae9a0d3495c5e34b2cfbc92f088a41925251ccfa3f29bf 9704618e0265ad55cdf7f50fb3c69ba0302fb9e748d6a018f7c9b29a8a5cbb2a 65a75aab24eebfe3a496c2ef07f45d48b3078dc248be481efc6e87f334c7eb78 3dd17e4188eed6ff50465284d0cbb95337e6fa864dec37396a22bf974d9d63b0 8818023d2537f24b98854a4bbdf32ce557878c5b8a15d98990b8f94d6c15b505 64173b7d7d725b8131f19e1189901358069486cddc2557cf33822bcc0b8093c5 e5439e77b44a8f537e6c712c01ba4b1bd3598eb9bbf7cd4815c23d13fdac0512 544e5dce8125fd9fc314153192e9692affa2843505e33582bbcbd40810121562 462201db93886a8a49407e67182ab6371b379f55f6a603b2dbf7cebe957c1a73 859c5d3da61b4f1598426487f8fcf134c86ceddd73b635eda5e7ff08d54690b0 78d3235c7f546f4dc4787e1f51a6dd081697deee81d12c636e9beb42d32b538b fa6924c1d72685624a839d75a0a6bebdaec813f4574a0fedd7eb3aa23608aeb9 0602b9279dfa32608cf3e0e43b659ac86a5fdb06b23203ee137a8b4bb1af1ed8 67250e697471b18075d38ca88ea12bdba639c1365cbe279b325bbaace20ef64e 939d31e9a7ab0ca1fee54b15cfb7790b13ed3ef32231544e6b0b7e9a4667a52e 893700bb766a9ec2d1f888c77002316cd7d3e7cf8096bd24b05fa702d9d5745e a562bf79e1b7e09563824ce0cf92e1a2ad33a2f108d1caa916de1e1509cc820d aad041982a9050f56ca25245b49ba8ca0ce0ec049cd4fd1ead58602eb1665d36 a50f688cdd5110fe9c2e00903e83837e4cb2696943a12a2f814abd4821b6797b 0173ac617a089c8b91e9b01546e6a999dba058a0e1163c10224879e8b2e6576c a151dd55cba2c17f10b2ea7cf60306d29bd0065798c3a3abe403522f3df4448a 1a0b23db408cd36784418c27e907bc987166f5bd4c05b449d83c2282bd28597b 7e60fca4c1822a4106a47785483afbe0f1ed5c5995f1ebd47745f5cea93ed37a 7db3c96ad57245b5b500ddd3a4b846830c2db9ab901eaaff0ca61643548a38b0 24fa9c8b8e4818d6980b273764e4291082b9eeb7a57a1f808c3399376ffd3478 c5c522b49788a543f59aa83f62df6ef5a3b4b482c542d905a525212f08f65442 5f0ec75cd8884714532b898ad7c8d06d5496003eb76148cb317d3a0b48e956fa 387c177ca35211d77e26619f6b09beeaac33124383051fffccc6d0dafc37918c 88652839cece780ed04bc79f661ed8aad83797a352acc04cfd0cfd8beb8c4e16 03605dbb09ace3b8fb33ffa0f5c7feb382dddfe2dfbe7b307d1beb969b7f07c0 b7da003524a0e85cf5c7ceb6df202f90e0bc09b53876a0657e7165e177d48547 0b2e545f02caf690df30aededdbae03f98b76f9a9180dffe9126e94cced13d01 4f63fbf110a07eee6a0b47b9dea2be45e8d4bd0dd6734bcbb4bd86f837709de1 2225892497f62543fe0626c868a6304739ee984157a5ab0686ce646eff0e346f 03ccd2e1bf09d30fc2d19fd38d1e5332c94fa38e308ca49f23e6723e9b2efd29 c1ad5d39e4b07eace01c7729283b7ad11e62ef7102853c98d7cad671fc4d48c4 37be4e387cacb4e787bf5b8d437c0db6bd225d921eb4d7cd1a6fcf4bf5ad5cac 9ce9985d68d561e3c7c3d66f2389f007da3532d4d1231e92c6f381eeda81f725 686970ec7ae6af92714832f84187785cdc1153895bfd41fa92fcd37bbeaef7dd 399885128a03a8878d9f04e77a7b3625555f49284e3f3587f0cf333f27033572 c5c62c058e02535732c7545dbe08fcecb69af22d6e148c5786e0660c38e44276 4f1ce250fe94551977a9445b280a84abd1e11823b4900d4f931b9911fef23caa ae7b66033bd3bff3ac8b58ad18f867127c2cfad654be4ab8f4d605e488c2dda9 ba184674d5fb99989928e8bc2be80d6984376510acf6c95cc2f95f0f9a5da361 bd4008d3b9024cc302803a3812b7c968bb7804db8d5dea5e3550d22884782077 cd86f9f1ebde2927f949bef724c03fb0d927f269abbb9bd2fbc40449ab95fdc2 a60af536b9c6da13d9c9c1d226b883bc00ce4bcc0851edb0b2f3dc6213329878 3d93c0c28c7a91e5fe9b2126ebe8a292728b10c044e4ad3cdc5e3e1626e99a74 b1a7c3ffe717e82b06d144bd1f5bff985f4b368c405b47d30fe057470e6e122b 3ac67d66c0c18c4f3c74bd96c50b2a1a2dfb845c492e53359cc729bc1c8fd57c 61eee01e5b8979d50e81f9d5bd4c4c224a065e70304f5dfac040c213a52c15d7 a8de3affc224a337bae5e10e9f5c21f650d375e8917b5baf00b6b39d405b9680 a0e5245259bdda95acfed01dfa62e3ce6d60ebeeb77915a4d595c518031a03a7 0769c2fb45ce785b411ad332871e69c5543f08422fe8d50e8bd7043e3b7ebafc 74ca953449b4421059cf914891492b4908193be5590dfd11ba33b4b8d5fea16c 329745bba2b5ba4dafd845578e3a67d427d859170e77b9f9b5378c20ffe43076 6529eab15a325b8791a20515d4604e82ff5489ced12c07f28705b51405a9717c 77d220de93da09379dd13df02e2752f6a7ae48351ee0af3de497169706798e72 7f459880defa25dc35a208b2a00af9ae4a1c303e2f4c5998c36fc3c56cfa7517 e98d073d7c86348b8025aba5b6ae80dd647c985ec01d5da9d482675ed55c0c70 022b6529f38d8b59243616d6fc886e9aa161a09409d4df4c3ed7dadafb035def 57fbfffc15d02e51dd272189cac51e682c841b517ec6dca24e978c0de81a36ca d64a9c6cc52e20db4cb08d2253a104d9eacb6c235d92f86a59bdd640b37c0375 6968896bd4b7733a3d073212ede2f07bebe8c7afb7266e8a85d1d0b917a8791b af4745a349843f284a5d93347b6287ffaeba7f19b75aa310815de9d2fa42ffbc 59fea8c95b8555d3e7134c7587de1b25b243b5146046ed28d8aa53ef363a686e c9ae23826514021a40ca8f1d423d4c0b1af4e3381d2f59b898bedb5725069853 e5323dc780835423053259418862b8a418949bb2fb649f37a9f0f6786aaa48c6 ab1d8cc3279e81441e9957f69c427ac4eaf26cf7802f4192fbf2db7c6ad68cda cf31243fd628b8bb27623e1a4b17f2e4515c62e1a16acd24e17f1677042f3339 79021327dff2256e35bb37562a0ea8ca88fa628f8ebeb94d073db73bd4923438 d427dfd81413938fdd441dc2d24d1b287e6f9f7c0b0d0d1de692ab997afafa63 668c9e8e8f4637689f4c2be351059eefc285e511e7a2a5fc05cb64554204e4a6 e0dda41c8e636052aa9a40c83c3bdd8b85bdf5ed69d4610048dc1c7bba862a18 f01f69b3237706cf4e723ac4c745de17ad1cdba7ba79467adfe222fbbdddbd1c 2d46b6c549e8d085e35d1dd28ba1a5f15df19120dbf974572b9601629dae3c0c 06df3f8c9d76012afa14762b2a811cf2351c2416910f88138016852cf7a2886b 8bfceaa399091e2b635698428f3058ac3f482284d1e8602500139f69cb65e4fe 35f983f6d401020c8e5dca10535deeb1527ab2693dafaba0fcd971636873e612 f83dcf8974b06280d72d22301588271e140fbded622ab210550d0ec9c36094b3 c69b2f73136dd7347aeed352351cac2b866bbb4321aa341c76264a3590750471 05d14c30852c9b147b54dbdf2e871ce377d97167a0c149103eb1ff196b84b866 59695697c66b26511a590abf6d8bfc42a2a7c1dab5c9e43d02398664d7c0c3dc f57536e4f93e6468695978c91e4a8cdc4c42f2a7f7d6cce7c516f44fd94593ba 8f11c02e1790a0a6d2520e24b403f4a04b734756b8a97199028018cb297721b8 977dda918a198395a45abecedc3ad4600179a9e1efb40660f870066138d2d15a 68a5a898b18d3aff5f5bbd26d01077e3ae48b8b8894750c023926546ec49ab4f b60e41cd0dcdb27eb7ba576b27114aa47539990d7d5592f76fdf666e04c39b96 83931de442ee13c9742593577dd92b5752144172cb0ff12f7c80a0d0cb16b2b4 b57224a4e2acdb318e4948b56075d332304704ba9d3d6b5ede5a0a04506437f2 f65d73773eeeea242f5d2830a47776a6794da5bede7d5baa3ed64686508b3d28 219dff7378f07e38f67445e9d4dad39dd3a2cda74b411dcdea9eff2c570833f0 c67974e5f10ece883d5f6427de47a8ba0f091470d952258ce071d7bc1375b532 8535e5bdec3b3d660f9ffba962f5a9cc26ba5e3d4071716635f84ac7bed3b2eb 97da618a7a9b8951f9d42ca284cafe0a5e2793e965520a55b14cf282bf4347eb e2a1fc50a86c22c8125bbd162a0f29e71579ab97b1338e03b4cf3353ad4834b4 7f6e6846184b87ecd7d9dfa462c7f87c857e089d61b2beada190dc0431dcb3e5 ed4b29fcd67dc359854025ea08b9ffc54da7220e0d6c29a4c1c416800cdf9e1c a09402cdddc42f7ebe34df2cefe2b0aaa7ca519fabf055ae217915c1dd4ca9b4 d9d5dcc4374de196e9df29f3a85d514d0ed48062b5f401800e3d4809e164c1e6 2cb77ba8fbd26eb4a44a583889d53bcd38d867a6d7c6ac2d72d6721e6509579e d012e2298e9ba166abb03bad86fba856d37acd4c59453ed71b2cbd591fdfe676 b0862f31cf12d7a7e2692040be9a36359a4123abc899e8ae713edb2d8f9adbd2 76a3309289573c826ff2fd3240f3066431643ae4030eb1043acbc588e358a2af 30bbffd7fa7fd4fdeac715b251f5136ef65487a95e4b775938a37991c332d151 8a098269b4ae71bc0ece3803b0dd406e7e00481872bc2c17a50ed7701019e768 a8a0a44b9bce8b0759bda50f366e4939c44527491860f44d495015c96fbfb279 02e08a3fa93844d427739e550d486a52e4c6bb85f6a79dd20620c3f7b3baf702 e3c23cb8ede1412ae0ebff8bd6aa87e524ac7b7fd762136e6e20ee8589975403 482296ae6455d70fa267a933178dba75a4c42d251b3084716862093c07bb5fcc 685e18ae42b22c40037961ddbcdcb2f6dcbd2298491b9d379aebaf787ebfbbfc 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 true +check_ring_signature 6e8edd8c6f32d9be04ff8f5113a165735b60919452e14983682f39050354e691 1b5b58d6536f528ddb5af7d000a9054f047a0d62006c64b24898620dac50aa46 7 756f730286562b31a90a7043245152dd56c35ac034d6c2a11973d65e531c689f ee7a3e32aa975422019901a8bea3799c6e9f27c2ae58b02f7ef2d1c18065ea19 31a3664845707b5ea9f23fbd3c83b555561582b60889bd8ef3da492f5072c184 67380de7dd67f9dbf916c1d31cc433d5f372e1074ca78126ce62f37087a4ef87 c5fe9958f1703f84f5d59e830b967e72c07d9481025af17e05a85654ec1a780f f83abdd39b1c7aa8d4fbe6efbbcff97a9da46811b55407baa9c796f161b40a01 c205d2d11c681bde56b63d80adec8e34cb982aabec44a5c431783d17930d2582 3cfe1bfc70827363d77853b3d6bacde70e951d52e12e7c8444d38a0debdc0b0e21648983e97dbef1af0f2c5e1ca679d2d6ed7ca29f1888b58fec0c01a86de9004db278db6c573b14c2376fc2ebdac4428efb3795a497ec28199bb2b316ad9f0d521fb3b23a3851f9f81a11acebb2cdf44ae76307d93b3a3a7084dc0a57e35e03d4217ff8f958921153cb18ea9508f9d36fc143a178e738c9457ff55ad26c6102f64a01b3cc5542d725353584df31f775f54c1f58b696e37bea511abdd1e106074e4a5e2853c4081ba2cce544d8a6d8eac2756f2cf7267344c9d6041e77835f08dfe364a313bb916f7da1a60b48f2b739f28e8d14a60c58082eb2508e66028402202c462e00bd60687cc51fef7be7bc117ef6a99a7bbd1b3e7351f8b450e1a608dcdb1c95457bd9d07b719d7d2726dd82cac0d9b91184f109275f742fecf45101ac1f047cc9319128d3ea7a0fc31d7fb5f099d7f21d6b1ab7203d6ac5a07127090ec09b8fe78aa20f5c7f87f40c0702718a56a345e995ade13a2c99a6ed375eaf99fdb976da9af4d87e9494ef24e1f33d82ee69ac7875068ee56eb9a5a4ab419d26d90876077c136aca4b9346b2e9e47b036784d1ecdcb3a853741b26b2fee806 false +check_ring_signature 08fe3dcfae84e332cb3ecb2f8c57dea9f0302fcc44ffbf5bc1ea770dbe36b69f c645a53a812279c592f37862c19838ebe37e87fb32f7cf201a1e7487c1a4c1e8 7 0b0b244e515286dbb3e85db1b6c4c707789e02630c3860c8cfdd034251496bf7 3207e94e0a6d0905841cb751506776b7d0c70f60ee310e9abbe9412dc83e4b48 bfbe3ff6be26426dbf712c90432c44dc7692d6f27abdc39302ae1e60af104815 102387172043a3ceec2bd9699f8db317a8a7a13125345f747659e09f739bc804 e187533ba17dff7518a9eabcf9675fd58ac4e8cb5f571feb9de25d70a16d3691 ac3e7ffaf5cf6c9d882bded1ed868e873580a03b6c3345709e28fce7aded998d 07716034ed30af4979380ecf6560eba8e19ace81146d651f06ee3eb107929f18 3826bb9498602d18fc55717b3e30cf148f48dc8801bd662e9f6bd5dc003618070ee4fe311836847fe66b9c7b7fb80cb273261a728a3d861dfdd1f64fbf8e0f3eb04439f2513b8bfb621f5089309b083ad7ecf1957cf51b2699fb52ed9df8610957ffe7cdf42d8824a6b623e86d756d15c4ad67da8f1efda13c0df8ca681bef0748da651b4728e12f8e34f20df359ef05d4a3861c90e026c8fc7358e1643276019622f9e0ecc85e220f222838d0129e5a2bc88b107a20b098581d892615a51f0ba401ff064a622305c249e0ae10d606d65dfda902ffe662656b70d4c80f439e0eeb10c08b49898cf08d633a703a1b6e268d1973ca5e28b6576ca14251c2fd6c047b279868648077f47b3fd7994d53ec3316cef0970da51c8d4bf8ac3a825f2f0b5080a9725810d362fde2531499eb6b972dad2ea10d31938a9db5eb6368dba800e2330bbe6c72c840b27b01af6e9cfc1056397e7ab418bf637e2c7208730dbd0a7e080c372533674a75efbeeac05ba269bd4ba9460642f3b92afc21dae12b3c0b2e8039d6187c2ee960d036caa3f55edd5b386ff7527749c7fdf85783a42faa0038786e3693b6b7128a3a789479d7619ade3f0470f7393caf7ec6b348f151630c false +check_ring_signature 6284352f952eef235df2dd4837a6f9583ac04a56971d2e0b0f435e4bd719da7a edc291c9921001af9bc973b7c0243e3aa99be6c91eab58f4a3ba0eb96deddecf 8 5e040d0a7e385d73c4d4dee7ca625215f865e62afedaff905509e43c264a5dcf 907285665a46bca85cbfa45f6fe997f9c59d89f131a685c7502be9735bd40854 a11b8a469d6ad8daebb77e944b0c982f5e675755a2f6f7cd920b3eed16befe1a b90d16d8b799874ee6776e810355b6b04fdbecc53952c970d09a374021c9ab3c 3a77d853cf3a5c3acde950c3300a6be2b9b59036bc7723e7a1cb98ecf5dc3530 a1321fe3e5fec1d1a0dc1e4bc1ec92807d078fe41e55c02cb6946121f944de3c 34127cb3cc172498d20352e5427045725e0e215bdaff1dc1a3711d9b692b3fa3 b411fced2957a2770af542133683f85c5c1767a1ebc38c68f77b8efd8d988440 866236f72b1215d3bdeae69dd7c2633cc89de1469dc380a7017f823e83b1c2035249d9cf9dbb0b3e58366c2914464df814b72b0e14898476780dc87253899c0b9aa4e8a03bc67fd93896ddae2a1239f25dabb0e3963c6057e76596f6a7dc3908ce1df7479aa218291eb907f3a091df47c657f05313574a882f0fc66531496305dab918ef443c460bdd12ab79743a4d723dd01ffb3c1d351814493f461448f905a06da9254c691c3cc26f459ce9b3fa55962a20b6113d2bc813ae9b1076aa6a0f27c839aca1355e2985ff1ba1bba60bbd9c07333d908e9b6876a10108f5d63901c544a4426382065d22593fe6db2678c32a585ad996653426baa94ebe4fc01a0f06b8e7a808052e07444421fab762d43c3ed4a344a7225fdf57876403eb4a770ebf37a5400b6a6a069380ee711ed642cc03de7d69c3be08959bb2cf64d847280e607bee40036ad56193af2e0752d6a58f07e1754c95b1d433592315ead6d56000803cbd2d87f5bedcf7878484d4af8c4f4119532cbd423dd92300dca2b4a67403d986dec9cc3437bbd5b9acfee1b2ffe3546e24025a67d07ffe88f06257330d885ea3d6293c8992b540e0489fe1361e6baa326f7fe4dcd32e0ca7fac09825be0a7d6828443652996da4776663ecd65ff157880aa8b481f55fe3ff9f45e5818f2d7c114820052fb4e7458e0d7bee05fd0fdcbc14a50f10936e2fd6165ea096e00c false +check_ring_signature 75d957c00fad4f9e7c115b65ba14b8b5b24c4b43f1822d6d10bdd3e75ed6f9bf 3aec065302cd5592389c6677f899d385e98bb5e8b1c15ed05a2b9b234bf415a7 33 4528c87fef6227faf596fc6b817e1fc9c26f9c63ff1069f8fd293d05ffa2d0c7 5774a7172765357a90dbf8712aa022a31564b262497b2f01771e64025f4a4a81 954f79796f465964f1fcda4963d0a3591684fa2c2b737e28f04bf723bf1ece3a 2765d84f5e2da3902b8f1ede7567d1d52bc2e0c4306c989d3746aa51351fcdf6 f382ee65acdaec04133e9fbab360f066f5537812d4481171ef2e84263f65214c da41efdde540488725869fb6851ef07e2a799633b67a99bedb34db41b09019e8 40fae2a6922f71d95854cc04267ec3c71d2c9f1b6bf838a6f2da5b300ddf8b70 9023775b0d759cadd972174a011a116e744e65ebdf21b864d4d3d7789a77b88e f642815fda4b942e8f3b9eea9830241581840a1c17e0d7b45b7d14764ec1a602 b782d7f3fa6df16ad6bcdd905f041164b0d46fec37180e00944a0874a8340446 2779a6c1505d6805780657da8830db5fc0a3e25d720b3d1ac8ea5ff2392f25bd ae1519c32a685850a32da889557d6fc357ac9262b2e9a64f9cb4691c19acab3a 6ba5d582d2eb5ab6f35869fc093be9341a9bd7db23d840c0ab450189ecccb19c 3e11ceab1e01881fdc68cc6868d2eca1d8b3c2e2af228165336bf10d097f07ac f0ce495a056727b60b26f9f86fe47cf3b434195fd6c4f76a3c5ea74210beee75 e7e9bde3d1f466613a7a4be9c4e82042b5ca996582a60a615c2f69241e2263d8 b1ac94fb567c351d0c9aa295f66c425ade41dc615783aeb14f6604575c90ca43 08ecd2793a9e7677d0900bdcf86afafcab5b350d8a6413c4af92656919f241e3 38e2238abf3606baca956d07a9bb500b2fa2ec63c4f8cd33d2ca1dd30f84659c 89320ecab749d5a9f9fd59241f9300b4e8b36d754e48e3d8526d9c96a2e60b57 efdb2e573fd1f70cee877925c48c4596383c60e193668ca76329352d9bf5e37a a2a5a2095d7f2a0511595db497efcd7a02e19934110f523dce4a415c7e327cd5 d4f07a1a6111efa9bf13f0d12c187cd46a7a4994dd8d91b314ae4cd9a311dae4 275114d547f6906c3d645d03941c12b52d7f3e38099a9b665c71788415258948 b4dcd01c4d39c8a00277f8d13766fb91c735b82b32d3882bf91051ba18078a03 f7c210421fb721485468e13298b18f3d41c42da83ec8f0d2edb216cfd3b075da 9d4d628ff152b53ca92fd941f1c668b6622a2b10999d5f5f72328d0699daf655 22e108858949f0c0bcc15307b63a8a38ba327a6c2f81e5faa29bdaa8ad2d78d5 13cc037aaab54c5828023ad823024f630831b07f7591fb3160b4ec29faf431ca 9fcbe5571b689578711429777f03b8e17a15a5dfb926fa8713e5d78b73c2c325 c11912586b1869391a4fb48aed477fd737695c3c6664df2589c7857e49acec27 206595a4f1c1ecb89265c98c968deecf7ec1c0d049e4a9abdae02dbc7b529276 1e34e2c5342cbaecfed877dd9501a17990ee6e5a4c8f134a3c3ed297cf695da2 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 false +check_ring_signature c63ad92466e019bf27a46055b953c9554187e7a286c29c2b7d183fca23df2235 dfeea439b093c6caa642137987d54423c6e3bec0b85c142c5cde8d241b2f3ffb 8 d09ea529804a7878510c9596c26475bcdb294277f28b51771a800b9b19d0b464 1011ba53b4f1bf703d99533c2403231036dfa464ce020f5cfd0e775da9200f4a 2c6534c6fc812c36fa22d941626c70d26d6c1d7185d13298950a4430ed93f68d 107dcf8bd28f80db3a2825ccca3f259f03737ed19f147903df2aed2407a88abd 35d48ddcc1f6b08b5320e39631d8ee77235c46b7e50837705455c788a19c1378 431a117bd8fc970a5758755a938233a6f734028cb3651ed78d7059e0703455a3 0d7f9d0641ac8280b196c3b54eb308bcf7f7d7eeafb0e3bc5cd429ec38af773c cfabe6982c427c65763f54a50b376aa7503a47e235d91fed12b389e0cddac2cc 43a3fa89c2a929f6a15e3c4b9e4242546e68826a3ac419e9d3dcaf8853e9230b7c542799649437fb87021a3b9c176235e13e268509b06db4833590d4894aa80fb1ee46a9cb719bdf6367672ae3a0b8998c6c08115934cf1f9266045869160c0a8cea09d6ad04c119c0399aa992c1abffbeeaadb27815908a21019a44190e410db9585bb673424d4c7c5629283d876dffe09a287bc4a3bb67fb50c55f223fcf021ed8ba91ab04540364f324066bbd8bd24ee8738e05722a7c3cefd7462d69f90e38211380ad782dfacaf3fa43aea402751ffa3c830dfa8a2b4ae088a61cb2fa090e060ae3374d218b218712f33a43dd40c8f5c78659608f9df597393214d49c066b4da8030e9dd7087466e759c7b73e610177a5805f6b002351c6f1c2bf473401e248884039548276241fc73ed20e8a68c203936af90c12323aeedb5b2ed6f40b537b91d3ed8bc79658717d1e08006721f07975e606124beb6ff4d73a993f0a01062951732672c6c37770ea3bf4347d4759c4b5a61b6278d1eabf0c1656a93e01dc58f2c988406a408db82fc327c55c3053167975f102f7d0f37c6d652d0ce901f7408c4637d145600bdb4dae79d05198ee48e189e8665cf18fa96e42ba61c8080e3cb72b2e21d9c61ff3bd7cb4d3ac3948e460a7a3bb535e04181b86cb391f0e5ab7e1d7788cb9383b898c9913ee46190e13ace2c264c7c9883dbdd487786d04 false +check_ring_signature 5ed03db261fab595dad3eb78fb19d29fc1e86637857eebc7fe52cf97dee02c60 8210d5c0d11a5b6cb2db50d5aeeec428faa2876d078553b1187bb60ee5849414 1 b63c19d1db18df762d4f0302cc505957d923b678af7efc9481c5c94b7b8595d3 85c5bce35f0e0eae361d5fcecc6fd4003ef8d3017eff775cd6333a15577de504ef89030acad85cd85dfef6cb93f263eb778f4b2f4e458eefdfa943d4ce34560b false +check_ring_signature 858ba8efa80317feecd3eea54033ba0cf3737746741143f459deaa558ea08021 27f9f90bfb9fded74081e586c95114c0402530b9aa886b03eb718bc32d5457d8 2 b03aa5162ffd9b28312b1056bbb6bfd79643bdf4d9ee5c6520d5a27165f77ca3 5855a98fa55a983a726d6080066346de699e805045a7a8ab59b38584a1a0b85a ac762c1074bee8d96631461deda7a55440752c6beaa78c7e3cef2505ad3ba00f120ce3e554e691adb4a1fd9d5037d791140ae2994c68f3d43b04fe616cfbc1001cb6e22e18b8e35ac81a330816e5bd5e99ee4496c00bd5e3c713c80a1dc6a48cb41bd6f173863615f282024ed49717cb516b4ffc955da990ea21e8353d0a1705 false +check_ring_signature 2c487d9a5b0e75bb77f1af92c5477a80f6aa9987c6e0052387da4758ed084acc aa428ff062fb41faba0d2088677bddab2f4ccd42d91157e6ef6f4087d2b03434 116 b53edca81d3169fa2fb9aab9cff3f68f50bbea3c664ae300722a20c15ec34717 7f7fc2e3d40a71c0a906254171737884b0650097b8c813c334c92dc0690d11bf a1cbb88aee06e9d3b1519ff3ec0cb4f5e57814dc50510da061283ec2b043f968 df753cc5b9c8bd1830b91ada1b268144e6753631aa5ae4968a4e3e329cfa5250 1e53687703c40ba8a39cb7bd43900d12c08cbb3148f1ff6ef5fba42660d45e9f 05c2a51e4df4294844bc7379e99d3ae2d75ff808b2d9964ba1a46975eab6b2ee 53a1c6be34438d439618175af0731128ae086013fcdbcccfd12a775c2633c843 12540211257b7c61251dcd9cc8beae24a8174160b3d6fa7bea45caecbc8ed6e7 2aa00cc986dc375240e8618ae5cb43d2f7fee28ef7a1fe4b152b0d2dd31fdca4 bcddaf9a88fbff7b03ec31697be61eff742aa1f1704ed4661a611a95ed9a17d7 6443617c319409c8b0b3192a84f04e7e0aba79dc33cfb336ccd9f41fb2357ac0 eccad9bd5f0bb069adaf459dc72bf18f84d38f6f5a15070005b414d42df96473 fc16b772136d7a81eba466758515370eb506acfaf55a4830377df2fa87aba866 719f5ae42b61e13a93b779bfe7bc514e83b1a7347b7829bc4fcccbe2710dfb66 59c31cbf0e17b413e995ffd2e753b2461ba83c97991ceccbc0218483ab7e1ad4 99165d24417504cf6c56cee8ff890476ea065f11d3a769de92b97d4ec7db3acf a5598da857bd5096a62964d87fee6cf7c35395ecc8002ef8912a65fde8b7012e fb2ab2f01897178c29f6907a8ef9e7563f69dbe3cc13287d57fb3f6995edc76d 5a7a397ea20c430f2e39510f67272995f5f05296d3d75c010c433e7b9abe9486 db6e7042a0a198ce998f8bbea3d4d0438f607d74ba3725d3633de1cfe2c183c0 e109334ab385c1c0d5a8d4b353ecf703cf191b9c7f6cde5ce4c069ca0634de2d 0af5112c22c63ff82f9456c66017c5fc4c9112f6f12f6c9e8078693a3278a9e5 a721c40615b71a8544feb158207003a4c1e91650f7ff93e05195bff22667ad07 797fac8235097f87a4e67387164db93bd7a4bbf414fd32f77b26ce51df7ebf2a bb1eebc4452847d4b1ab752593693ba0f0aaee5fd197b829249e63e59ac5d352 140b19a304dda6c2303a8c6ba7b3e7dddb592a8b728722707a56f7ac24119024 c09657edf18f1fa35f2b4bbed7656edccfcc1d74a66ac385a75e678c3cdc1d59 cf1f65cc3f37094103654df523417cbbaee0f367b7697920fa47a42520cd9855 d556a74aa80de9419cda2a302911eee8145621be4564108274079d3c70581aaf 9863ea14a59f0a4871c0e329ae1b9fea37f9bab6d7da0d6a65ab6806be05e63a 4cafc67fbeb6ae47be71332198a96a97a03029125eb297d76697e1a2abe24474 91ba964cdc984eb9e952d6dd766b67b8b977d88c238ccfa7113d9aa0a29e7eec cc8c7b1934ca15ab25fed3b256743917eced71257aa9450e850c353507e3dd55 d8c7c2392d45b867a02edb19adaf90a0e6176bb840418580ec1944c57658bbd7 2507a8e42788b2cc587342153b67af8fdf61731cfeeb5de452a3cab365448a62 74be7e885aa7a51e8cb128bd0a05abe4274d840a578f773526439281088627b8 92acc1090d328d7440f870ffbc17e46c363968d9b837a68fef2adf910e981915 7b66de052229979f815e38453385930f0ad1301db5dc60ece9f958ce86660146 2224499a071efdec8064da5cefa7c3e0029ddaeb2f64a57ac2c13669872c9455 30d9ef253a82d99875e7d7d2da038d901e2a947d16f634dff92df51e85dc51fb d72b9b41718f71edcffc0b59d5f75fcc174cca7c9ec881b71540473a5e2bbb8c 734e7187bf4de6ea48c7391e9a0cc336826aad553325c9c15f5ce5dc28ded4ef 1b8f76901b5dd1c2ca323286ef9d5869b57d858a9cfae8178dc810dfa49240d6 ab53700d4da562b1dec33ca608d070ffafbe2e9d3304aeb158cbd2a9c5312763 bb4458793f4305898f4ab8d6dea792e73755b38e52b61ceb6badd40967f27e95 621ccd9a6393a19f259002b35fd1f11c2fe492a34aea441e8a5b4cc1589e27de 9163337968809feea11cfa4f36d957e28fe79e4407173e402b9e546a23faf8c4 960b878926c429452a353516153c60bbbbe6e5f2be89f664d0dc2fc273284bd4 14bb041a6e8e9314baa7589be7cea9417eca7fd600c35954888ff0130ab9e2cc 0003ae46230b95836a2986d7d73e90ee2726b4cba559fb5dce85eee1407cec7a 45e86f93fc28670979cef736efc72a431622e3d67d2bd0b151ca270478f23e7c 620bc9925b2b487618f7529dd83e74771314290f71bbeefc1c4c569df9d7a614 d74de6590e33d50bff59acf6627a3bb8a3fb4651cbce89a01522748d6b1ebdc9 be55d2c9c9cbb3a46741d8b6d3946a5848ca96f2e974ec69ec7bdd0b12cdf8fc af1babc6ea2601848dd9ff0f5f450c29ddcc3b0e0ee76f8ff6a2221ca116bf78 37e08639d2b5abb323a6247892644deb7f858a57e41d512ea4d205f262352a3a fd9aacfb37b1a0d42c7c8f7ead2388eab30f36015a110b7bc55e849a2618a4af f194dcc3acd648647b0d60b57c433e1eb7e41ad6eef8661bb46e7aeee7aca349 7d2b3343e954308827443e538c3ed67891f544d864c1bda3a448dd4fb8476518 e64c5fe6a26c25ec4cc0147bf04e13d88960174f72a0bea2e00b8253e8ed5fed bcfa1cd8dbcb2b5c4b76dda4d661945093b846b8b935c51f75472dfc4fbedb1f e1a8edb30ef7d7aefd4cd53f2e66af8082f1d35d9dd7e359a10aa070d00ff2fd 9e8afb55edcdd87d191b3812edbd8c7eb1d0d70f293774178f56dd3a04aa416f 8553ba78c5386528a1a02741b193b63807d8df07db30ac379d4b70da2824fcda 576a62ff235976ea435fead8afc7c670efd84f4fc107b40e98c1f3d8e2f8cfa8 56962cc49ee0da7d2eb37cfa82a799a3e166234e9fb51ddc105f72c964b4525b 4110ce727b5ff403fdd8060285f04bbd58867a5caaacf3c5077f2e0588bc4219 845501779022acb50493bccaaadeb844a746529325b868299a3adaec80c4f5fa f2f10531352de583ffedc013bb3caeb22ed698d8669811d5f65bbb2484cf0690 ddc6be9068ec590b5a18e1974b3ac2d0a7f76e513e4d2db9beead37074697c17 bf0e6b48e0471104901ef1b6710d8ecaac3db6fbef56121619b0b62b9898096a 8e9207127c06653fcc18b212c598f986a45f545d97ba1c8f592c61333b93c336 026b75ce9a173e77316cc4d543210c0b3dfac7e61aaab5ee808eeb77943b9e3f f38598103e7b8c0630630a94d55f8c5b7dca38c5d1512f7309a76c206e52291b bd83e3df310c14838c3118cb1c75ee6884b470dd7616df78a03babe5f5f9a127 fa935db7d6546699054862690b8e5a244f22d062f92e5ee049f1bb2660a89d69 8f2cfcfb3455cb76ee7dfc1d19fc4a5c6ec8b0729146e1873a13af8c69dcff06 8b4651168828fec3760a1248b0f67861f5f7162c67c8d6861598af5a3749c4dd 72fc8fe35d5a4e8754e8574561dc9df538f1aaf1c32c5bf174124b95139c7629 39892e97f3e5abdb6ef18ebe7e856eacf54bd73a42c1aed12c4a9346c7fde082 2c4ed349988ace4911db34e4357079d42643ea9ba1a1b65cb6b4d3941a1d9fbd d6205373374cd1187d83f585560885d32e111318d4c2a92d481e074e34ff88f0 8a9c12ff745947312b625ca51d3ed33e1027e006b9576a725d682189764fbbd4 638bb386c00128bc9c546a58d698e6730935f5fda375af7ca5405604c4188d72 dfd82b287bcd2e5a81d29275478d4cf1c5abbb66146103e87bed45d661d4624c 4ab27b10752f6ee68dd134b6ecfeca8cc7eef46f12468824db8d612febf5ebbb a23f099a8288a7a49db314f87637a33290ee4319ecec2cab09fc0e4ec4c03f15 c44599c5a52438655d39876e2bd7129b25ff77db34743ed91842e5bb766a00e6 1f0da9021808942bee18fa0a7a5eb373a490f1aadc2208bcf9865674c873d025 55a6c48a8bf6edd8e975b2dfcc24b1c594b0f3c9501dcae4aeb77bf039f3046d cadefe18d766bd53c9688dd92ba62a9092d0088bb31ab290f1e2df4de3112174 c812c9349c07544d0d8b79bfced49d5c062bee47dea8b18de77744ec18a97752 a3c71983866808422d44315eec3b714f1d326697047138e4b478ef38af09d24f b3151bb7b809b7a9f961982ce7d185fe62d7240d7d0afef2188a49e995cce820 d2d4b95b9101cbc7e0bb2aba863944984bba037ac1a1943b0629d398c61d0a3f db9ac4d706b004d80fa992183f060e4c027d8493432a27c801384a702a8c362a 161c0a1baf58498b1934852ed0e1829f49f9733f2a08724cdccefb79a6eab964 bfb3b0554aa83d794a35ef37d5685e537fe40500a675730ae64f57e130bfda86 e5704fdd7aa9a8b3d9a278b3a9e286e176e1266b7d7f7ce6075c439048ed7b5d 57a20640a8144a91b97e62b08b562a61e508662b6d53ea00c3120901dc972f11 8dec29b217e12051943964ef981160ef7588dede69669a72eb0def70fb5b6f94 42a23898b455094918724ffa8a3aff447a660b5d46692d6bc704d35c4f21d653 79b9180d2cf1fabaa3962e832aec3ecad8e25624501f871d9df41bc8a5c353d3 47da919dcb3c8342b1bddc08037df9ecface7f146bd7fe4df402046a40592c06 af5fa3baf4226257144ef64a0700efb421e31ff3caa5d86085b16f50ff5ed0f9 c9ea3fcf15f77ec8e2192b133615b1e966b103e820a80556b653b34a3511d997 344aa94226e7f1a1f680c51519016ecf126c7ba1dd5c3ce74002066f2c2a9283 8820345516085b5c9f689ec64ce3a91218163b20e9e19f18f33acc43c5e67207 0696a6f4650fcdca497007ed2487ad60813337771020d8524932d53b234077bd cf8103fb6606bea17661620d8cd87964a04b11c57393e352e8c910f7bc735650 380fc2b86711c8de3e10544fb1af7890a23ca5be363f87ce76512af87960126c b115935d5361490e1c451d3489c5aa0f7feeb8fdcfa21af345fcebc5601766f0 e81c0af298f20bc83b0dd8d207b98bb8010a8990fc67bae973dd65d67f4706cf 58595bc751621486a8536c7e701a548a521480cb18eebc83d2f224c8895b9869 7c97fb5e1806a3f87386762fa3255a021106363b32766dc460e4faebae182af8 2ec5463d1659bf1f310706d0d2e69d31d253d352e0d4a59f6ffe403eabbed8cc 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 false +check_ring_signature 2bf07c239c359e0f0393eb09cb320132e67c06d8a6b507e7f30ba83f20a1d7b4 6c8ba957187fbd628f252705c10aefe528a0f74972f8464aeb6d48c2ea08777f 4 bdbb6fe8aafd692f27eaaf24424525fbbcbbedac7a0325b9c838748ee40e76a2 28b6f2a7acb27a116144b3be5004732c8a34f9158b1724d7fd8827e9ca30edc4 b18054068121b208ae0dab9cb19c77dc0a4c1ba31caab71a4d30cb5d2a455e91 e5a723f4834923c71902ca2994fe724aa0be230c78a702158c50dfabb2fe3a44 a637c20f02db03504cf6e3206e8811c08a6b9eab6bc6019ebb0b38e42fc664058911a0b568ec27f96571afc5484693bbce6ccb3f1910fc37ac5c14c0ee38b00912f52365ccc300bc6c7694542f264f8ce35edff0739fdc86fdd07a5986e44a1e639cc1fd40323ebd1e3ee9e9d88118b45a1485d706ac10e817d8882585db9c021c3c865c725d376a4ef3c6580a4269aade1232aa569dd3c9070af03f40ed1500bba5f0f89eba7c43a7dd85284e1d08588451feee2aef30663ae4b7a523a90209a5449cebb56d1ee6b43d1731a21c4de6ac150a9c362b924bf961bf8d2f253e0bffd51488c1b7f7af50ce3c6e3f1297d1fb8f1ba50e4a3b0662e22b0f5f795801 false +check_ring_signature 09f33cb70795fd13838ee9d4041513ca2c1279b247ddec4784ed940c304c03f6 27456b497577b08aae2c088eee3318c6f80aed0aae6c75a16fb3201362295e3a 4 ebead7b85ed93a6dc7b2032a71d696bf7d2d201cc6a83ea8389f601f03bf72a0 c1a7d2d16e42a13e62ac6e82cb1bf3e29f7c0aefce46f2dfc3b8d599156d357d 3e26238b85581705bb1f18244cfe7e3f734f49cb1882b750c9641486c656e307 dd1b40046ad7b5a38e61c435fa40fdd582529b8162385b7eb0be1f33a79ba847 c2718a6bddfbad8c1290589d0fb49b5f7c9862d023acd2060ef27c3709799306683d1cdf0d651f3cf80be6c030ee2c441e0eb1ce076f7786e014f13890590c934d4b699c9d4810e4328de1beca7710b361d7bf99f0a621ed647903e5550fb40a02b58ff23751f72cebed3425b10ec45fbe2d7a0cadb38d895ed31d41cf1c12f91c8d331a98b2301313b770b5a98338a6b290486bf537cd26fb89fcc9afc9550b1d7c4a70ad2346dba87dd39d27c3f67a27deaf681f10852fda6a197331d1dd071725eca90f417d8bb1112c8a2158c6a72c51e18ff2021e470bec92d659d6ae68277f82d9e2e19e71efe6a83e80235288cc297081883faee8726b2ed66170ca00 false +check_ring_signature f0ff9ae6c5030e23836ba09a350fdfd9daf045f3464de486a31b7662987c6498 df4a5f1c0ebadea00188ab5823c6ba51adf867e73680f0b49a6809788b4abb1e 8 f7bf6fc682ec4cbdb1ae15bca39b5c66a82c2a437f17b4bf76be19920bb470a0 533408b75c3cae43456b13304e2d37cffe946a051af28d2113e3bce5af458418 3d01fc1d42784146dad0cf86cba00bd0ea1251a603309d45f9842d06d9517349 9cadc6e76489d5092fe4f672bc6dd2495dab84c350cde25c65d73a62e166e458 1f1e33af7bd48bf8d435f45dcc517bb8fe890b07f952c6d2a075b22cd7ab5f91 7f31e8fb5b97163089c78b8dfa0f341170769ca2780700ff3729a409ae0d4140 ded85764ddf0ac34b77231f74b2ce596644905e6438036f031600797694201c3 2acb3cfb1c6b4f03e481ae45e4a3da879ae469a1fc244258607fb2ff0e622603 91506027fc2a1287712b18a27a165855bba7baf6803e525003b59a0876302f1a7d733ea8c40fd742cf818a53ed3ab4d4c47d415bb661eecbbfa8bfd817dfd90a0ff194726112db48797fa59c1f7011523ba392c9308c8a8b7dccaf252091b60f71085fd6ab98fd3acae5c156e9eaeceab55a8a241eab897064b14502f98cd90e939a762e9a19539e849fd44c43cd1e858ffe802d21be85f218428ca57950bd0c76fb3e35ecd22028dd8b18d260b158fc74b57e5f854e33b1f5a4c5b7bb235c08881a3be3f2eee907d50677e68e22f90951bd0411e95cdda29d8b6011e8b3a90e260e2da4de0d59af8fb3ab6809fc7e3f0436e7077eacd908b48426a8fb156f0dfe4f3cf800aaa61dfa1348f486c290801a0222fffc2bfc7aa5f1b2f1f7a9bc0a809fe63ba1dd784dcd9bf8054d2058c081e21381b5d5fd2a68f3a71f94ba7801c07b379fa7d646bb32eb6b6a86f53ec4b32c89335be476545575c15a9c9eec03fc75a720bf84e6ba45ade8de4848c51b35ffc1e0d44555e5713fcecd54f501093214f23ab4dcd2917732c98ceff72d5b14b4e7732139b89b62b9cb02c4196d0c86d572d06a6ccb0286dc18cf4f9fa6ef6f3ce3275c597c13f06d40f96a0ef105d580b5aeb7b0e68c8a3033eeac40de492fc33fe40f50c0f94ac82c346a6d4c044891f3883be76a8b8b09a5be7de308b3276acd9153d46d7e246dc9c64be90505 false +check_ring_signature 945c28b1e0584642d4a9a4e36087b3d8b95b48bd261dffc70cc642568ba9981f ccb580995b4f3ac3c1670dcae38d06eb88769e7d986b54a67a377c5ebca3c102 2 fcf661c6291f5ea7df8f2237544d3afa23d7e0e4220611d4b5b63dbfe4553a21 b2b768217fdfb94d454fd855c0078849ffecde7c2be0d576b9737bcc54355ffc af37b321b3b12587aac8e3fa8df3264ab1e3861cc80b86d4031f0291eaf0850477f71a7372d09a787c5e1fd0c66342cd02f42eb16a72cd5cb47d0579ef988a011bb58559e70350b4741b5321ca1aac7c888c4ff5e2279ae733f574886609b6055718bb371691a8e9dd92a627799cfdbbd43fed4d695b915018a0f09f43d17c00 false +check_ring_signature cb400138f37ef094a1c9f6d80f2c85c03e8481631b525b4ce4886e84e7ef373b 973cf388cb25a469924c32824716a3b31fd7cf208a4a5eb2ab84b575a532d125 1 4025107ba9054f6e136473b8fed05229ed85d2f15a495ccd094e8a8e447f2dee 5783afb24c6d116f8c2e0cf7ac5a722f8b6a402540a480dbfb748966cbaed407b5088b078516180cb3e33cbb54829d0876ae48e7a88b61e5c6622dfec13a1507 false +check_ring_signature c2b37c956d3fd2182126dddb4cb28c11304f2008c252667179400220aac37ff6 dfeed78e608a514c50b201bfe0cec16190be3b56fb10e5c48d601b4ef0dfd2ff 15 7b6ab6675091e38838cdfa2eb09d67e2a4e5f8fff963269c5e2b3db8c4a5ec64 46e5a17c7e7f6df720ac4354feda5dde1ec32eeb28d5ff7bf57ff9daf350cbb9 b18b565f6552372eb2835f654fa289dddd9159d058ac9c967b31f38af0ed9a54 ee559deadfff02239834cac26f034b2294a0fa1c27c46ec1163105cdff14dc47 dfffbe297a4c5ae5b97e0c7e1181a080cb0bd064712c5cfa63ddba3a621072f4 2ce2023cca67352323eecfa6209f9c41d1dfb5466304847794dda0e3861f4bd5 ba844ab7625d0603623deccbb82145b5b50ae28357eac82ff671c67925bf0da3 479a42a0a609d1e7762e349df7fbfa6256a0efaf569988746fa6e56a12ba0c7d d701cb89a357a3f6298bca25248d8130b58008258fadb3bd345b0f46ac01fbfe 97013d9d1c8fe8cc6746fcbef1546b51cf07143ccb69aebe1b9d853e9ac7975d 4a978732ef9226e630ecacc6d5536a8880128012d71dcb77df19ad13055277af 1dd5a40188cd22aab62f15b0bd6b5200fdd0fc2c710f127fb3bd13b7a6911299 9bbaf33b5b55b8c7d4a4522f7c41f8bfb780bfbedb474ceab6645f5ca663d0d2 a1afd1fbce383e5f72d2093cf153fd96d9239bbb48b930cd68d2a9cfc3978541 afe568b76b12d66a828c4892c1bdda7527148de07fa60f62b1ef678aebca5fb6 4c05bb9ee4cf97630051ae86ccb6cbd120f25dae1276cee26c7d85a477f93309144aad94a597ef332d3d81e6456a192a7ea9c0729b337455c9adf52dec2f1c06f03326f472eacb3ae73a59e2144db6c456c17ab558cf8036443ebb494016840e93e6e6eafd661941edef46ab68e1ad6d33ae145a40f698fa52a2797de861090dc464f9f806ea58637f1aae6e1aef09b833060418424263ea39b3ad901fb09f0f82696b256d768697cf422d3efc134776fedeb2fbdedafa87cc844373f789d70d197ec09f1d60445652000c25a184e93e52ea120f135e2ced80f786746b01d305c8843f460fa3af2b3a4177a0ca7e9a7688024d94d2e5742605b4ec28234744094ed99ff5a938dfee21f2c0edc8bfad80e33927e293819141600855c166b9f60fb0d82347e145cf0ba575d868d122f8a8ef4d66d47fa89221fbdc8cee83a777037419e27201c1b5efa324d0e9dfa27d51ff51226bef324f885d0ee507b03d7b0946d337a2bb20745bd152271bc242459bee635177282026c540d4b1ffb1119007947524a44313c572c792cbff0a4d33c4138a9c74daa36338b253d5389d72010ecc72c898249173d1730efdf04146b948fdee9d5889a1b9fe2eb0c267a746910429816f5612209141594ddc04edd6ae147e926a916d6b449d66904b27b318df0f4b58996fadd1e4c7bd1070c1fb9b5f5dfb36bf9a88f2a10519d4be98399ae701474ed4b6f18a1faf0ca3045cab7b68292485e368158c63482c6921bf80a46b01b9af51b45242553644cb67f8b9fa5c3e9f3be77450c2a4a4a3ac17c508481301f2283a7814774ac83b185443f63ac4078fd25d24c7cdb4d96fd2fdc503c9bb088e767a79f63f10a4f533f056a4364ee4c834943f0c2a6b38be230a2ffff5dd0b137e44c10b05200bf808bbbbc707042ba93bf7c4a1c85ccff66a4b96b5f8e30516f1f343d684361ddf9093ceaaa90ced43bfaed1bce9903b0db6948fb12438002723f7676030fef694545e8dcbaf7ccdfca913578917b9f93bb69c441ca52a0d8b9ba8fefb4c036fe00095ab8d9abced961a21b6611e8bcd9eaf811523cba50f020010e942d3d732e457617dec14989ca8f1980d431792cfabe1e61d5eb727054568df4c1e79d827c814d850ad1328b9c738afc2da11fb5021227f068a5b170809ce3c3faf9bed2a1f5cdfb9c42e849c483ca443aec2edb444fd8302de7c200d159e828c04631d5f85fe3ee3e5c24f78c6246beec6b08d933432c4967737ea05d1257120294f25a1ed96e24afef0f73aa625524b2d57f2cd3ffb9bc334c5ea0044b310d07f4c182caedd3cfb28f5a78132dd00d262649671d6c118dbd5da780d false +check_ring_signature e3b26a6d96d6c2525f40eb3d0c33e36d4a4bcb17f64609a0965dd01103e535c4 515740f6f34a41ecb710b8f6ea6bedb68279b33ae06dae5d556947efbd7b930f 8 ff1300d474e3289e6de2ec26171fd51570aa4c9f06dcfad8ae0a8bcfca1d350a 63ca8ac6a509eb13c6c80cac57712736833c8c43a0a156a3920456dda9eeed9a 31a237f3da8b9295d2b8344ec69342a12cf8b72a165e4254288f109f7f9c3024 16e207b9111e06154c6ea14b8780b4f776f0b7e9d8cdf04e61cb07c56630ee38 172e9655335160e12ecfcc1770360d4050e03084fe67ca1409988109ff755dfe 9a96a577f9efddb51579c9840b18b006a4ddfed4c966785df33022b5e056ba01 5bb40dc0bb278592ea0dec6005fec9cab7c494b6c19d10cec6aa18d839b65843 9c3a7eae1da6a27b972c36571afc2c0dc065632489f8070ae578f5aae9f17e83 3cee9a369adbc618522bea7a51556d7700678b0c8aee6cdfb3f60af3221836026f8d28527cac1a7b7d00c6d4824191f519966260fc8810046cf6145d98f8a7007ded4fdf73d6c74596c6bbb5138f7b080a59301274753c5d5e68fb6a30960d0d2a25ab040eac9e5878ffdf34f1c6903dcaacbdf3d184fdb591c6770951170402c920346c006f2612543a27637414af3d374393ea9f5cc1f623a8a6faf754ee042f001bfd4210d33575f1633593083101dffefe79de44abe56485938d53b20d0423c4eb0b24d32936c720b67cdfe2bacea9af85cc739006abcc2944c2fd03ce05a0a99be60f0143183e93ea1cd8739849726ff429190dfd0ad024cd4c9952f00c1b7018f268a144c00642e9adfc65c44cf89d702ee70255f2dfbcaaaaad60fd01df8042cf19f820a9e423859c78fac476bbf1967dd956d40c6733561a85e3e5039f181da86160a61e5a38ffef4c7675c2f2e0c1f88d8a4505b4603a282a80810044b2ded79e77138d3d9cd96656e386380975d19311871ac7dbfa38bdbdeb3804f4bdf01313a79c733bdb934103f3c84c919dae8bb4e24d96d3d5752f2f54b904d367bcb4e20daceede7e3f83b78b14f4c0f74df532807c1029c7e227312fa80508a5a770b9d328ae393e186c45ce01c6c4ca35c58a24126961a3d83fc2337802c7c735375b7db4c29306a3c42a492d6a26556930b1a0e5a59759bd4c5dfd4908 true +check_ring_signature afea48181f93580aef8521c18b2c0b3ef818021ea36bf975c1055434bc4f30bc 8e66c5ec4c956d67be58edb1a56d1ae2a9d4719b4ece2b3129e58365e8964428 6 7d2760c6c04feb4a81b2655989b64021e477d975dc856b6f0073d5525b666e34 df0914a5f18ac1bca031c723ff75caddfe28afdae855f70831fc2a5cd9711dba 25d65c1cbbc03e83ea7ea244c0c4f10a56db67446b7afb8100d65d0e4ba8fc1c d444dc49f9c8f3a335a7fb1217558744875ae134ce779198d4cc48ce46abf258 b0963f7c94fd96db45cfabdf3e9814746f0701ba7886369bee729c02a6fa1551 724b45705f0eb536e1b21826bd973c0705ef435202744923c404f82725a72569 c47d7c7d518c0a8ef63a7aa8f8420aa69df09f63ac21ce9a3b91f927ea92860d875902e7e063296892aadcd9a7144af5879bdb58f0628fa948748f421bb2f704a7b01528cc2069f85d837c2994e3424d4be8d580c696c337e4291c4939eefe007bd9ad9a211bdc956e08f2d9fb2fe8c5c070c053ff9c848832b85e8807c63509fd4024495c63b62df04d927c6381276cd6473ac88cc4128402ff63716f2f43087ef25c750d7c0cd29888ebf76d97198ad7f768925c0981140d1cbd3c8e746049cd712df82ea032bd9f9b51056b6662bb478e8679686ca6daccc0da98a58572007b8b2bb967d184fc1c20c854a2d506b4145ae992fbef40397f881c34d3356a080a21ee1271d66a3359d002358e2d876ed665795278cecceb05e9803e8a70a70ef15e0cb3b3b48e49f64afdf8bfcb3abc7d211d984c8543da7b0a5819aa19610dcadd4f8741df1b6642a0d8017f7764614300212bfb43af8ee17a8cfa30eef80a8ed654ea5c1c17b29e7c7f33e3acb1f32db39fca025fc130d477ddaa6c4fc708 false +check_ring_signature 77f5477016a17d526f0461989040c1234ebdd59b4c9dfd9b211321d9f30e5a54 d3ee4b3eb7433647ff730ab55796497636cf6a83bceab34e186450c860b0475b 5 8af45ac86cbda7b49f2b1f3c0fbf2c44123dbb803222449368c99ff33228795d 25a0c125e8b93fe00c0f3626b9a4120858cc43339e5091a1bd3719a269287d83 af34c7606a34d91b49c211fd8a8e9a02c536f18c6271cdaad341058d48b5afd1 c7dfd882ee23baa475780a7888eb2617e148c878b5e1e63438dd0023b7866031 b8373137fc5a828ad45045f7c92f6a065b7397bde2376c3be4559deaeadda74e 3c3ed7553a9e8f6cb4537a8442d813451f608ff47bda12763aec982ac612f808971a648327b509f6b5c31c1dc48068e880aacb9e4ea86ac662c1ff8b423c730ecd3a662efa104ac2a9f80d6556f846c8d113f3aed0ae15fd70cff70b3c6a8604a685e2c7f75173963d5c5aef57a4bf9b52a42380093307eeecadd39a4673e80a65ed427a1aae9e5eb9114fd0d16bf56908e7ac5e632d1f25ec2aad9527e3b806f275c081ae4cab77cd93ab00d86beef1548cd5260dfd5ff2224b838bf190f1042c2a612b73f076ac7a441eb428a8fbd050c2ba98882a0d4c240e88c89ac64e090b8c13d9fd3fbf6287b065e40341b4bd1853661d9e8d5bf6e4a107bd79b7120f8db3ff7f6eeba736e7a05b07309f5b5046ba1568dfcb8325a1c09eb3502fac0326a4c4f876e9ba674f54d0bfdbf8fc3b8d48df3b10f155856d852c1c5113c40a false +check_ring_signature 9a50a390ffabd3f7fc14a73a1ce8f79dfade8114155f51998d1fe1e19fceef35 3aa09cd26a0585a2963df81ad80855fd2a33a5300dddefb64302bac13071829d 2 b06609155bbae9c1dd67cb2012a9f7a60db08e55dd0d08547b2c4e600538e597 dd43793433dfc7d6be762ebbbc443fb5ff9f80955c753d38767810a501c79b68 dfafd6e02aeab750bd569885013b877a1e256a3659e1a29db20a447026052805d697a142c279e954c2655311cf5664d333c6ba8a80ae2b8d03e7fb2e6229e90037cd7b7804e7f122333f7f2447788fcdb97c61f92e4028ee3e469c32a2f41e03fcca6a76e72032fdd266d595d20f0bc9b85393159390bdb3ffebaa42725daf0e true +check_ring_signature 3bd7cdfbcf5198e274d37807599472a5aaa4e8e11b0f8bdbf9bf5818e68f4994 45adbee75588c423a42e8ac5e7ed60050fc1eae099b7ea604834c3375ab0f964 4 69b21e5446071420a547426eda9e78390c092ac32cf709598fb6fd5bcfd445fd 74c69a93351faeeb0d035eae8b693861a75e17cff9845786834c1c744a64bb29 106d4d549e251fb375d013f0b750c635b6adcec60d0b1e68d47a0f7650e8b621 5522d0d68c4b5c288667cb0edeb0512fb2f1332a89d4930ceae5d3d979a5158b 4ab558e2755704d57f97973982a630f314f2ecbf0c387a3e8679a2970b18d50a4eea906568f0d9daf7601224bcb412b5c90acfa8b477a695b5c1025ac3b7520e82c7c1aef2a70f6bdcf76c4739338de89a9ddb7c22d8cb73fc47bd102fbdd3022f088d28e67e4ae95ff5e9b8bb9dae6ae80dcf68f72f92a235571a09526875d49b3850280cf997b642afa6c080491512d8a087e24859cb3d2f7fea0ffddd6e0f448f97cd48d8bfdc6f4ece7b81f149cd5332fa65dbdf2635cad2baafd11cc97f924316ca9171dad2bc7b20c86e9aed10e17e8a118da868dbe122131edd990e0cdb7b0b810eb357a315f70a966b2f67f7edac40ac2df6e1d90bbf43802e24e51f false +check_ring_signature ec4898e4ab85e27b99b09bd7e0d6a2d757fd383b395f86ab7c256a72748f34f3 ce730c57a7a476dcec0268a874c0ffc32b8c5361df95e291d159df944f0ebdfb 1 c6e58d2ea6eef733c80977e92c944dc38b5b972b4403560ed23810a67cb1a522 b45c389249cbe1e4c4c4a6a2a948b122f65265f2f4fd689ccd8788c6c5341d488c8fc2d4b85caa18cf0effe584e077268335999f9f84ccd38518a18357c2ae08 false +check_ring_signature 698fe679522b829972541abe830e1e8f147bde539d1476268829e3d5fb6e4e8d 6c7b07d77e0a6ad54a14ad8fb580c842fb83b973aaa7c2b844f911dc1179f25e 15 86c87b6d09d66e3e7fcde5952d6a268f33a9d46aae6604d7bffbe30715a11bf3 09b5537dd65661c642f60ed9c29b7ed639d146cabaa009ec3cfa9082fd3e3b9a 88e87a91418a3a33367fada2cfefd9988a138420b96c1cef4cc01ff76f6d0c58 b0c0c7f79447ac3bb40df2b16a2ce5feb8036ba2e86d431db7d71cbb859e4c9e 3da5f770aca7ac4cf49c6251e4ca2e08406693fc204b1d3c5b3575932af469f1 2387040e88d62c2e9775d480fa136ebd1cec81b27d3855e80f12fd43cedadbb9 aa586eff36b62d931d45d68d4c1e291f39e0d21decc8235b541c2d86d5b4f4f9 8971b9548c2546292416354f81b0b36e6bcd6aca4f5cf3ee86f984226357122f 52fbc969ad1f99e170a015287840852128b5b5234cb65c5462cfe2a0798cb0bb c065d0cc1f53fc5f4ed25ab3351659f5e33a5a6c6fb65c132e4d2c256b7f4d51 cea830820dfb6fb23cefd29b2cd3b27092da6d03377a1c55787f58ef1fdbe7a2 0159fd98627174f0c2fbd9ce4e098ff6d322e56fa571de124eab3e6858701b7d 55a20951969d0cf3befea893c0e46b7b48004457bbcbe5c3af80d027b27c9d7f 2d9843a014559572be4f5e65e03312b043cf4d5e2ab0709a47fc6ed832909014 59573aa1601ebabafe49d36a669c6218428dd02a7a7046f6be5b0dfb405a8051 887b50a8209973b6ce81a89bc8d052e3d096eb53b2ea82d6d1cb56e0f196700c72550e61bc9fb94de152e88b6c4bea0abdcbf9be8051258779fad06496cd050f1a3541c691ee85b44eb4a6417cb379894f81271fd92dbe54878bb2ef18ab450fc5638ff9f0eb39effd41bb8d6a0e8c45b9b57eadfd3fe35276cb10a89cc12a0c95b6e60277df49db6ca5bb8b9bcf251f936d754a9b6d0faf74badd7fc360ca01390e035c6a65a5aac3ada8a5f72a18761b463112d15de0ba20adbd2270b5b0068409595ce1f0274f97a329e5b823388135c6f01a168fda2136ff6ba643efbf0ad8cc8ea2681d2109ab8d7f146e8ff78317e69d06a2594510539be8e00eb6340aa19ecf84d2d89916d03971c4e0d348ab48a2b0fef591ec3a12a6a1b60a8a5509ab57d8c740c214afb5c9899b23b7f5695deafdd11c4e46e2d55cbacebb4c9002207ce4ee0d2ad0c6b001bffc8846e41e1f7512e8b2d24b4a17bfb6c8cad6ef05408be85bf976c72b0717b4ace913db71f2023765594853879e6f1a45ad683a063e4996d01ab36368844586ed0739edc70936a4818b42bc4ff69839245c5f8101863d0e0d3df8446d104ae2e010350e99aca33c3c6eaaae8c453972ad55d4a808d38ad7a56a530f040a04e7f8eb510ed18c5581ddf6a50a247b2d6c2116b2ae0e135d461a6da7beb4bfa2473b20284a72d483cfbe2910f16cd7c3381d683f3307e08c4e8826123e89e8617d1a57bd2b972b6108e64ea5d30336504f29f96c5d03aa93c824ce7003c16522f4d9f2ee6ac2c2fcadbc94ae592a1b54367f8768520630641a3622f18bbc09f00df8e37e53ab489ffe026a85f236ab107c4aed79a905084c550b64bf6f215cd859ccd0349b63f6806af1da25b1d0cbd7cf905c56af056503a1269b39e6e0742fbb06aefeb9b32a10e7b8725be71ddd1247a5e58a410e56e3c051c2ef17b653c92facc6080f5d594b883ee85b215fbd3f513f02487409beb603f678767c7147a977977080071745c085dafeb975be44052d21ddd886077e8e364634b6a9dcfabe404e061e4f2c3ff3a6e4b48f3bf922132a6b5271a7035d2fa62cd79a6902fc117d45b30618250b825871a5d2562a61995a41a74dc2005e81b7e177990425ae69e416c6ae7bfb875c97a7f8b42e7577dc1198899325089db44cf977853341baa859ce2933e18479905d33305b306d1ff1ad1365489d0d4320baaef6bb4659d0e89c2789f314fe4a3f8784b89546e8e5062bd40c01820d24176d546e96bdab552dedb67650f78e7bc87cc37c49debc4fb3b1e08495790f5c6eb2be80ba9efff7f55f2bee165aca494f4207f4c23023c36c09a8e1a0e80f true +check_ring_signature 17813344cdefd6450b37c9029860fac4f93188a98dc49038a0f04c2d3ba685bd 5aa4a8f62e0ff22d3960b77703b87514b9062badaa886ba4d88dac385332fd33 29 5c7188b528a7a8bdf7ba61ae3d4ed37b465d921d39c033ba9b939947d6372c64 13f1bcd7098339bd06cbaa1fff1357e715cba687871c1f5771812bc37124cdf7 ad22549a1e66bd8bb4a1f88c604ed3d9809448c7deb0a975360bad9523c2dce1 0e3b9464bac05c05729eca2d0ae3cde9284e3969f7b89545499cb4fc950fc7e3 0de4581a4095e3101facbc44a82f737c377379e684192c5a1589818cdda43e21 5b6f85b322d6cc6fc326275e313275385f2fa39f7483d02b5dd5a51df4416edb 9652f4932954fd99b7c9a9870a4783689e1736122ff8b85edda01d3bb4de172c 7e49ac0712175e17358335ebada2b9e05558fa793c04bab90c5119cb0ef2776a 66a31b9bd8483dd8cc9c0a8780882955d3b5286810d799a92a8d5695cf80f087 6cc1d2e0347da050f20096034d693eb754d0d013f53047f9ee473c877898a6b1 44023375ea6244fe05031af395c50ae0dd1cf5bcbf5064673c59b1fd3f5461f7 09eaf6fb00cc61f63dbfd7e69934ca1c38161e1999a029b1e561cdaef44aa83c 331bab468338c978598964e8457182653f58d209859e0be9c71464e5afc91e58 097d23adeb28cecb50f72addc9c742271795df7c470b4a72fec8a599fd4742eb 0a392f8796d6a670ee29e5b6ae72c60b3c465a26f2dec2bfb2386a4bde7f05b3 a4d7b341a2ab7c693fadd61d3f7ad1461f1d9c17513a5176c0b2e40fc31b664b a9eaa937920308d1014d823508b9844eece77c8a2f9be8c9652cd139a565daa6 f23a325d2e10b652b5625311d595590a4d6645b5892223e07877d66de070358b e0bedbd7946a9a4e955185023f0d5e82e83795d01db0404c9188da67ab337fcc 9a8752a11135a1a671c653c09af1cc9174a5c37e811b29b0ee5e264cbed1cc29 a9babc07c10204658976fc09b04134239efc337010ccc16d8aeb57c9d3bb518e 8b26b50fee51a5bb04c6bca79edf76cdd7156dfd1245fabc12fa12c82da1bcea dfea33d8c235900be68879c67ae3b493f48c291ddf2dcc9485de5bd9631a8950 ee84566df5238f78111b2c03e35028613224a5036d234c74a77a36e4a3852872 cad07d9e7654919bb5bd9c7def4fc1cbf6cd4cef0000f34045847a72aa5138ee a3720538ab7210a88bd6e6ea798fbe95c1377f1be4e914effaea1f66e3a4bf92 b193b16bbe757392e8de6dfb6cb05f3c649c09cd0f729b89d9dca22e5458bc67 6193e62b0ee80eeec11b7657caff21182ed8487ef6ef07c44620aacff4d8f517 8c89169c4d8351a48779dfc2f98d6bbc3129eecdd4fbaeec7916fdb7566d30f4 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 true +check_ring_signature ffadb6dfa5782b1e0798b703ba5d0286ed7a9bc15dd8daf087a7c3b65442cd22 b25dfd704b1c798309edc0c33c0bdf79546f6ea90d3c8b2e581b9d073c7b4d25 2 10233b334f73bfba8db75dd6e5c866898df8d39b73a670e3f239e1e4c86bd763 4451b0996568047c386a06fa105f7cfb14bd7383be1ac8af0417f89095f474d9 4084de5f5c5df74781806985f0ee08446b3d47a6737421bead4b549c3a6ba104dc6875fb383c5ebe1c3b3c26b2c77f393a7d8dbbae1f127eec0ba609debfd30003854f68f6408594d509c637f828295b39ab651aa3ca49651f88fc8ae234be047f4114c2e74071d26394b9a9aae103be877856e737b7348ca023afd762c79c00 true +check_ring_signature 34fcdbafb9fa17b5433bc91630e2a4ace0312e36c030780bf4a176cfb47f464a 2135bb960824882783e69a54e98469e10676759f4cd3d51c307fd33a9b4dfdf3 25 80f450f692fb852a057663867923689bd1a39b689bc0b6f6d91d223edfd3c10f 4885ddde73aa19ebed9135c04b20554cc2ce5450f4365555a06dd53f34a2b11a 863495c95747ccb091ba7b1912d0d82bd548b394dacd1b24eee4e86019fa5bb0 caedc9120fb1ebfa014a77d6a16a64bcdcb7da583ab7a7cad203b330cb6d923c 4e5ee8acb41e7d8c9c0eb03271d6a3a4129fcc3861b2aa63b9dcaaed3f4c7080 16fb6e7d62ab0f57375e52db91169fda338cc6020e55fa4c7e20fb4eab111dfb 8c454f7f9767a8b550a5912ef625fa323fcaee82f555538a8ead20998bb1f455 74ae5a923e7c694d715fcd2460157f5acdc6f727c3c7a7e6f69565bfb94ace0a 31c4938d5e259a9fc5c2a8003b77543c87e1fd4309b58f457bd28dcdf95187f0 3ea032742a7bf318c6767bfd237c2654afa1ec3ccc5efa3b8adf7ffe2b59e2d4 031dfe6b51197725e0ad351db18865794a034dfdccc0f7bfae22e504f16bd5e1 1ebe35b459909030b35cdc6d2785fbc8dab7f964ef2776d1170c79ba31e48a15 ab35857a4a187fb8a4d90badebc9709d7d29c032c1dd225c004584fd9427ef3b adcd9976feee8074242089acab8159980e65487e9f4e9e2b33bbf37a9e407566 c0a0cb033af6c0237e2cb9b77757b1382babda22a77e8262b8f5ad56d0bdaa1e 716d6ec5119fa6d32cd117a2e3f5ead1b8f2867c1a4e6f4e3fcd10c9fd0481af 448e963dfd3858a5cb5181b04e4b7089640124ed82f26caa360e2a86c9cbd486 de3510bd53d185fb1b01844919fb104925032a24702443fb651deccd7f11a7c1 d58ea929e8482dfb17168ee1ed20a6131d72261527d1d735d9ec4c2cf62e764e 653e2ee6d7b411373ea88a844253bbfec271610e493168adc6aa96ac0fda358e 0d393959373af40f8a0cf2607044a0a360a8a772f0008195ff6699cbc6effc3b 5d9bc98e8ef038313426fe9a849df87e7d4e293dd4647a0b4419ac72e2932290 1c47ddbab6f0cea306b9849d40a853763d1b65a074c34c994ae072f699fc6658 9a9c6c79a54c038364b21411ad9c790a564b93ad4f8eb0fc68053bfdb565d6af 560fd2f811516935645ba863a7b4928a2fa8c7cf2fb5472717873251c322bf6f 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 false +check_ring_signature a66f703058d6cc5d7f7085ffa48db65329c0fa7dc52d47f7ff5770e07d41347b f9f49ecef16b88a3f2622295f6e1fa62d8887027d86f82299f66e155d677ffc4 30 4c6f9e3aa3d5fcb1c851ba1deb30b93f7274425a25efd56a4c07a113a76c9c7c 2ebd84b4f9b9427de7662761f4d84658292bd60aa7e4aed753be807b9dab0c42 de2fa90dd26fb8a2a150e1b10b46f1d1075669c44bd098051fccf8b6bae27ba1 b01241c3ce6310135fa1137069c05f548bb2b25c25ad74bcc7d4ae8cff5a6ee4 471653586b89e490734612ae5e05ddc1802e1a33563ce8a14650f0722a6f0368 06410ba4e91bb6db3219b7f78f08384ff4d05060cd09f25667dddb91c85465d0 fff2a9532d6f357651689fa490c74d53d118fe767d23db6c0346a415500b5487 abbbf79a440e8a244e3265869f68cc38144952666ff040c346ff8ffe96e0b442 f3fb5cc86510d7b773630c7fe7fdb3495d9f5f81e83730c21261e6000d689869 cd441cddb11bd34e80dc2c5c76d576796b4226a79a278aac986f2fe50cc05618 31df5d35c819fb323273ee09445ebd5e24c258af744c786825703c64d802ad69 dd62d156fc040a08d570a9f00d3c40928400d4605eff0481c4604703e75917b0 41486666b799e26df73f0a2229f3c1717bb6ca89932a2ab781ad21b670210b2a 04c688e2f6abedf3502c294f8ba622404c7d548a016014adfb7b769597847e9f 940b20aa745c3ce85b60902aa0a44dfef65e96d29209e51f71a360e1ee7f6f38 108f173f9146f49bca95daba781c80f55c77825bb71a358e8e4329e9554d42b7 dc01e8b2685be7b39ae72390cebc6151baa64719a9ed4b04e531c7caff9c14dc 7ed1c84de48d1a1143611b5aa4f87b3dd018f05f1d4e10a737774e368d10b7da 63aecd048adb38fa421fcda9de6505b44a4ec3c558b4a6b4aaee98683b7ff99e 938119524555125f6422d0b6b81193f06e2fd8814320678c8b32e916f22b89b7 254a721156f6e8b9cc70b44c2406bfe1e64638d360b1da8685288b8f263f745d dd470fd8e82d8de5585ae80474e304066ec3c9eeb96465e585851cadef13a8fc 97219a6aff0d26e486edff0ac55f1dc7fdbdaa4f2e73db2c51b7529fb6a82021 cb629a6df03f71753f727e0a37b473e03b6075883a45d52183d7f29cec7d6440 ef4de38da612cdc39cd24c5a0deb78e78f33fcd8747839f29a08f89eb168c588 c1feb1c058b8e435e57eb5a8f041ad9518445572d726a8697703463398781b05 67967747268dd14b681ce28c6ad2410db2a1dbe3630602a739849e4ce955b774 acbc03eace695fff94add2202ad86a59b142950acab4752162c092695369bcdd b400419349c2e500805a3c1127def83cdf600c7b5caa3e7607e883d636dac77b 2c8620e42d0bd76abf8339effb6a19bc6a93002c3498bae34bf32e6fd485b224 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 false +check_ring_signature fd1213b93bcc191a39ab5bb17ed1b6ce138c359107f9f3acd98372ca86d1c7e2 dd4f8c9616f1ecf93c94dc98086d863376f55866aeb7bc8cbf369f376410c348 25 e0161d298c63720a9f1851e2494f5f8717ad5bc2f6a6aadfbf3be9878e74869b 2b9a1a8ba58a4aed43bd00e2c2eddcde852035581529889761ec5e880a999f6d 0c915fe47e2a82affa1998c302af3a129181f6e2d8099cbd628b50af926eea5c 7cbe02084879f56a1f64b381c2484f5a336e6b001cb571b95eb654facc110300 e5b1c6d26125ea96fd9868f375d01c66df6451fff85106b03cd8979bc0f04db2 8e0f094711967497a9248a8fc5d0e0a688ac780e49cfafefa1dd421133cd6926 99d3edd6f5279fa8ea40cf3bf991ef2aee9c11f4ce164beaddbe2a93dbecad85 de9cafbd89c921a87e13180c6d5cf3da64eb185d3656637dc45586197ab05a61 dfb945c837d89f7bc38256a3b3f188f8d301c6b3a0952c2831f836e06569eab4 c44b2c2ee5e98501c7b5439fd255fc8437edc847d747e004baab7f556b90cc09 123336f07074ba17040fe1177efccda0d1f31486478f320ce28098bdc7fe364a c156d3ea9ec8548400fd244a951e6a4195c486f1605572a1141d82030ef459be 514de4fadd924ea51165d658bba1d752b5216392627b64175356351a0e99f426 ebe028d200dc01e23a9169fbd2b83e49636651cf697aeb155c6eddde47776ba2 ead1271656503ee8d251babedf4b838ab6b0f27bf6294e7ff830814a44892a1f ef708541c041f7d25e17eeac0448b98c60aa966f17a323475ecd301745ed6e0a fa16ab3655f63b0f36262d814393b8daca1572e41c0d3b8eb5e24b740aa09665 964f05011f3cd3f2e84fd8f8d8faefeea13521ecbccdc2972958e9bd3a8f31b3 f9e569e7d8db17c3df8740ee9656f4adca5682cf8eaf97f1d00088e4f358d69b 5a41a2d5f088feecc625daf81d8cc8d38a99867eee13eebbb2646c6f222f4d5b 71ddcb1eed5ad1bbf3e7724f537a5ac7e35fa915055d9b0ea35de6485fa770bd d123266045fdcb5c84f2d120d016c86fc9b2810aebca09a2706619ee09883872 e1a99c837f0dbd016ce3102e6df8b1d6f253b3d575e51df83533d2c87e58b34f aa5cce9f33c18b2c56666d2834f4e55a8ae6bb8c39bb50c4e1971df530bc00c7 eb2a32336b142fd4a52fddf61a8a71cffb3359fe2b0e44642e72f94dd9d8f335 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 true +check_ring_signature 6068b29c8eb4a74e407534e4e3b0dd07c4e1ee631407fbcf56bc9d03d6ab5556 358e45531fc0f6b1049af0d5a5c3d66c1644551b1fb2ba93b9611c868c01532b 105 53f1731f9a7d343453ddc148b92c4747ae9d9af2613cafea51a6733fe470263e ba3edce6ff9330a0353ef26647fb0946a95ae18b9566ea34485be98550ecfb8e 484ba6e0539734a0478334667767cdb12a3f9c449c386056bf83cc65cf627abc 19437f927e230e3717f3a688aae48556be936f10c6a12862b7944a3f83cd21e0 002bd2769dd42622967bbee1eb1f2c259bf7f41baf884b97f24f55c72b1243cd 1bd67bed9358b66c12f72dabd34bd19fb11f07c1b7f4b38fcdcd7151c977d8c7 c844aec88d860c8c2b1fd55c2fd915f4f5b5b57e118725b09664153a42369cd4 9f0f14630d643c6cb9e206d90a17ff1c75fad66d8ac7b06bdabdcd3e54096444 a29f4d202f763e7b4f273aebdd1c6602352a4053d4b3ba1569474aaccf034601 e6fab9446cd5a1e4a69c543718b8eb8c1d0bc368c72ab9448fbfd64eacb41503 631871c4de3d775b510bba85e0dbc1741cf1176c24b22f3c115acb557719f3a6 17f7f11fec7d7760a28120e50009bb2ebb359e8293ed5687d8141ce803f417eb b9a50958d611b257ecf97ad712fbedad2801015af34bd5e478c2f748c1df589d 616de5ac68dc81d7520d3f0c2fdc597f1de61966bc317db2d2764e3e08b1dd68 79332d1091db8606a91a61f9fdf1a38ee306a8f81f54aad13ddcee5cf2eaf690 0f18f4a9bd289f1a27758bd1f90426d392efd0d112965fb58bd5d4e5e1e7a548 971caeaf4592419a0e426a3b03782cf7440654720dc072486b603a65e336a348 b3b09bc691157b8d481f2581461131f5115ce4beca6e74aa6ac005d214b2d801 bfa3a52bb693dacf3977bf6a7fb4dd738dd6a420285c9589c115b7d12477a31e 5de7c2e3225ca7d626daa1ab48fd7911a5735b17947fe467cc1f8dbb795bfe64 c7dd528f6f51fd93b6e9ab4caa8a7aa4c0c970b62a28ed9f26ac80ddddea4df6 264cd1af17d2499019e281078685fad477f00b11a71532f742b520317edfdf63 46baabce639b67ae26a52b99414e51aa34658fdc5c361b4248ab41deb9108275 9105e3c087000c115a8b4eb9a80b05a694c9782dab9762be83b3b580eebf7c51 29483e4f12e10c5f2b90d19725c37890b12f6c239da5b69613399b6cf68f4c03 c79143a100e75a91ca633d1fe6394f52c6f39fc19acf032243045a93d01eade7 4956c0e4e014a7c4462e895edca1b134b7fc49cfeebd7743e7e172008a107e30 72f9d0d674f402f2c47e10633f99117a7f12a0ff0e44b7340e632550d419245e c3cca439e099e3ecd0458bb947332f7f52d7656f3edfc8f6562be98cbb38c1da c1759f147bd4dce01c9bdc550dfa78bbd5dd20c9dcea6004d3b3677a82006be1 da0263096b36e571c1d6fe9d3579c1beeaed674be9022611a9175fc78e97662e 2c693e08b19381778ef0ab55103bae1000991ef3f6a5937233b9fac056f461d8 73ce196b896f12b880b38d5fbcd960ccbdcafd5546ed56629e51ee1fcd076fab 0b057e0cc7434bb0781b3370054bcd17e1f0366c218f542e87118902c767e9be 34d6ba64ac47047aba12d4d41a917bb39c2019b0240583ec3f856927c6498641 68c0dba5c361739ee6292063df752fa7c1d74a8d0d755bc6c498bbcc8010541f 78edef09fcad1dc2ebeb7f97f26635c750387d812e3ed7a4c12bb4c0d4f520b4 d59e9c3dd59458916bbb7f3e0b6e50e7e1322c9f040a9ae20135e48554be77cc a356d6c75faffca622a9318af489ad4e4da89dc0f2a3ba8898d675b457a34fa4 d2a9ce2394960b8c04e8f7735aa9878d572cb85c1e06443ed7eef308d1ffe7fe 527c4f0d21fbcc8e57688ca7dc79844612f0920c39137d097afa2853af4affcf 24f11caca5743957f765199b6f2d58a47bf17ad3ae75b311e1967a7d507fa928 c05557699e9c75be54e3a4843397e9b970d099ddae7e9b440aeb46f7dfc4a277 227931f30a95db6e2d764ac401e648249bc6ae863b31b70a6f47e2c9974cc1e0 483a266fe09d7342ba3fe54ae79624bb6842c76d3721bb1951063fba3f6a3322 f400ed4551a19d4cc3872119e37d0bc384bf9db62a388e5bdb32195db7d9ee54 4e7c9c77ab1b233bd53d4a3786408384dc390435ae18b7fa63e6fd47ccc10c75 1af2bec81adcf441e840e8654b2bebfdb96cf232f7cd454eb806d88e984ab1b3 768d6c36ce5f2d753437149d48bcfa219c910ed8e1c20f6794e1888ae7c7a504 3f78b08354371b2070dc1c29f85d72c489bcc46f9405b5a68d392b8365dd6938 e515aa7999a1ffe066d36430022c1d25f38d54dde69cad1ac74814e8d0b27ad3 b219f204eea7e237dca68b413126d11515ba388894aa2765478538845bbe9585 7eda4c86c0fcf58d920e1091003934c31c806a3e8e291ff8b7b509b3764a583d 59a74834628f61aa85f0ce2c248c76a145d791ee20584b27235190cb7f6da50b f86564ebc9b6e27106a0271913c76c897c5a77eeb8561a7919877b0d29e40da3 c605e41b6823e62fa895664453a6acb08f50ef95b366632c6445a771c41be244 9baff0c2e1a5d524aa715bf6e49018d8026b4d5006e9882a4f1b7bb265a0f2bf 7849d376f54103a610e8259b332442e3ea386a2eda7c95f7b3ead8b427819e76 de1149db681d6e990029c4363c516ad049a300a1923590651ea57d0a2a286989 eda471012927a7de0b57f3dc3675348a2b3622bad3b878bb0204ab8e4413a15a fc85b4ded483a17a130167b6a4025650767e2e4c050a8a9e247e2097292d5616 e1df1a8483e1860d3a49bc3804a4d0fdcc9f1b1acdd5c143e4145854809dfbb3 0249963bdcf0651eefe3270f1b2dcb9be6d1c82e2af3050c42dac73f4c1ed455 5633ce2fdf9250a5ca8d9301e40e76d843a8ee3e5f509db1d8337052c278f9d1 6963dc472a8e3fa9d60077a1b05cb20548b1aa29caa3a10211be336903bf0a3e 82c3453a19ef28870b0b0af20d1cbe206330a7943d86f52887870bb399fa78d0 a4915c6e499e7278264e92fcb9b1e58f95843036fa3a682960b0e4d54ea9dc8b 23380aa3dd78ad21da32e4545029d688a17bed2c5e85e01537e91d32a6d13e8d e4c6169d78b2aef74da3a0df6bc73071f63926d38a5dae2da3b83a2d1c9dd0f1 58b4326b231a8afec43d205eac534e7aa7365ded119bd7bb609e32d907a74495 7e9db076f7d910b88f5ba1283957ab3fb12ae9c1f0dedcba65ccef946d7d3adb ffd6ffcd8be519b10c992ebd3caac37f137f4cccd929283862eb8c82a62c7920 9a78e12b9fccd769ac5ab25eb0a4a645c4907e0d980d1fa4d41e434875b1b42d c3a30981033e5f48202622aa839a8e1986514964d5604a313c49b986163984c0 b8dd74dbdfb6be4f35f2c2f10718c522114f8f62354db5b53e3374d47a3ed14b 700741918a1f2643c6cc858d2cf6f8ca3b4bc98d34ece3cffeef4fc3968d54be 8aeeafb9bd74b45fe956ed0a36c19ec44beedacf415332f1c3e42513850cf471 4a65db8ee06c776515f1c39d04495123c3548eecb8b8df5045ba78a99f9ec6d7 30b4802bf990befee9ad116e2151d309f338d846d371fea0e45043849aad2d02 b25691b18de0b9808955e7e03b65a041922dd3a2decc24f063851f5d9159d67e d12f5f669f26c42fb663a7c81c66eda8a5f94edf0e60739a94bba662a598a987 7380c8e7c9c564a532266b3b055c65112c8400a72ab2afd3e2fe423480e42f12 0faf7e93da40445bae8198d11a7fcd520963174d7b17c140716478aad5a1e59b 4ad41020097e87c572dce4a466791ed5ddea4d56bc686947cffa4681bef559c0 90485844a0151a8ce9980bec28cc211b95bc67d65a4708635d16a1e4815b6abe b1d94e9831eb16709ad13342c1547e9cc8ca8b88c360f56fb955b7653e6a1cf8 d697a9eedff220801b794f905559aa37cd6d73bfc47780a7e16cd59a59d18296 fefcf01ed9219373d9e3c8b1a38cabeb96c74de1f44e21ddf6e0eb5ae94efc4a 2d4d65b4ef8f3c1930647a82b88c98d92038ec98636f1e662a8b89ba41f1d3e4 d7b21123a0769896df394f1c1d02a32733016b7b9be1108f8a97d42859da844c d4df4e8452b05f82b1c47ce167e539f436cde188e8872c32ebdabe158e825860 0a9631a9eb563a0b781a6e97806f6bc3345b20b7a308748c79b6086037788ea2 38170d87bac52016724d7b89604b7c14d76512506988c26d8af72db7c57f6746 542a66e14eac1172cae370da781f6b6c6954defa9ef4a445996d95b7f13098d0 1f2fe8a6214e2925bf1c4a4ca2241398f53f4d9a0bb5c9c9107c7115fc282496 e027cbb4fb5aa605e9d00ffc64896234bf8324d35a780e1bcfa1e62fbb7ce993 6645851394eaf383d174ee3c22943a54bfcefbbfccb4a112d576d68f117df52d 42f3f1c07c54fd8159f15f387b0a148b968dee334751ed49dc7a7488bd183c7d 7feab6d704c83dfc46bcfd60b467c91644e8675e32dae3271a9e9acb04636746 90be3df7b23b87f8ac31437ecf38dedf1be95b2c0bd9b7cc971efd842789b3e4 c7bd5104b1a4579df0b54f95478c943ad12f6936966b03bd2cd0ba3394f868df 8c8a51c03583581c5e9e0657c5e602b93762855309e4153e78b247f94a84fc72 57d8677125ae1e74661970394773eb0e3b31d59d6bd08cbee1a3dfda6470a8ad 209c38668a159a92bdc0b64346bf5fadbbb10a9d45a199b214da4cd1c64546a3 9a1d3b91fb5fa76de826e7093b69a6a4ceff9945bbe3b8932ab73fb63d8877bb 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 false +check_ring_signature bcc6a76d2916ab3315526c96a64a9ac8cb0530adc3551de67bafdc2bff0b66f5 0890dd526014601990d0d127ec0c2544252f7fa083678ee975f2818d8aaa6e2e 1 e78e7a04922ba985e7f1cb410d7552e8d84c65c01bd2337fb96df8df78dcd4a5 0e585dcc79e0c02a9d0f78d9ec1a5d93ae1b1491ff0ed48c68095d63ef8d6d0e7b399a8d7f56479d372d50b75861c7201010e683f9f94cb131268cc978b64ab4 false +check_ring_signature 880a0385cbf56e2495782255bf488315c853d57fb28430e64d3d2f2153697a3b 919227b81c61ce800ef7396a0b2442d10e852d319736214cca5d2adedb033e39 71 0c22efb1d1b8740395489144f123f1c64c3548c025f9dc8d2bdfe7013aa375df b0e357a1bf800fc1a6c573a6d22d1c109f8755bf1f698237e45d1b27f012e66a 8ae4d4781caf3fa7e0b4df6a938efceb0f2fd31f20b0a69cf498d03d2036f075 364114f9a2cec5d450275f492c477dc6718ec4cebc181f8663c5c6e6f02e36d9 8df004bac0e02f28d29cce0097fd1cf8601b9dd6132003dd3f682b944f031300 f7a13b21fb4de8493eb8f99c3b7f789b9bdb4cae1ede2c2b9b7fbb7e6c5a735d c6f9c20f61b774251aebfac477103d1dc755ca227cca3c97f615c5af6a252a1f cea968752c547f754fbcefec02ea2bf4e070a1449208edfac3cb4dd6e135db57 798344f16a9e3ea0272abd725d5ba90329775b49408fa42aae0cad58a83028db a87398fe7f05e3bdc2a4543f5936eefbbfb139104a80587647b86ca4908e7011 84638168da24979d3957360c21cc385ef3dcf3451bba0d5dccc20ee49b5712df 21ea931e7a0137c756e5917aa1b5f79fc2a25dce9b727156d9dfaa32fec8fc33 cab7059c8044af18e02522d0a89c4b12a9020e75fd5c696e1035ccb059e212ba f1b0991dc95b28041ce21a53408e17441fb784dfd3aaacba3abb26fb94fb18f1 263da60f3537687092fee79b24f1ad8ebea7fa89ed11ae69d123252eefc150e3 0177a768ab758c096dffb4ce004a28b99cc936cfbc8137a9dba3a3f00d79de06 0dbb1d8e341c934aa7f11ff9a697a7b8e36da219c3f0d56352c61439d753798b 19e6a4389d239b5634913cab6e2fb7d98cefb7fd67d4f93b465a25a6fc6d7e0d 376b76cd0138e1f04e0bc19177711cc8e26028d581e65a24cbdd83e7b4f786fe 2903f3b0a1b41c4a032b23c274d0d3f729d32749e0c681054b27a5c33ee76db8 0474d925e8f1bfb35fc7d237e57da4f2ad79b4e2d3659ac31e7b7236d11787f9 f2c32f01066fd6a9b5beb2959cfe3c05d65129fa2aea806d1a155ea61b287240 2040f67805840c3f77c6c27c53f086fd9be30952f9f995c4b2f58e8d8142249b 21c08d4de7b03da1c463f7da5b7f75ee764ccf5916b0695c4c9bc507d875a933 f9849864736ae3f73b8729f7bccf7c5bfbe59493c99dd7fd1f649919d4391042 3a9aaf0345ba81de65e1cc3041057fa50183a89d14c63732adf9c57eeb5d6496 1dd3725812d3836529ce040438706d0579a305c80cb8aeb02e21e1b97cf52367 a86cde4018879fa9f783bd0ce71f64aa3f7cb26322a98c8f490bd6dd590f8b8c 3952ec18a283f76d112a604820abf613e8336fd5eb91b0683eb375a563c131d7 eeca8c8deeb5207d4ac2f397ab3eca02aa34b870c1f3b2b6a1cc2d8b5dc89edd 0eedf3aea14dde4d71a81769b38c64420e98aa6e126368ef810daf0853096a89 24d11b11214c45bedb28a9f028adc9c6e04eedfadf18f45e7521096008cbbf9f a1fb82ed921952afc48f9d71fb93a6de941512cf37a4c76ab1dba9d8c246499a 0aee0524cee2205939859a79789b07dca7d0879b75bacdff73521dac832cb22e 53219f44570a6f8bbcdc291caedb82653bb8169f12df4447b59cfc2aea5e8f53 8d4a9c706f03c4390d371a88b395a96cd0b5af0493f18c16732179f475d46012 eae208f1cd48f1f5053e76fc549693adaae5b6d1301dcd629312836aac3de380 51abb05970900bea1a0ca877e22edafc9c9424cc3207855e2ce7d23d476833af 2b975533963223e4ed9e08b36a6b97c54620767d926c292c27ba64c0bc7286f6 6d97ca58c40736e3babd17ba48e0d2d586210151c8597ec3f0b7cd567e6df772 6dbca4bd1b5313a296b752f930fe4dee89aa8693ef6e167b317c8e9cfe081d9c 3b7f3d0f1090831c70b23c7b7320924c9448506984454b14a0e1d38c16b78645 4d48a5f1a0ba6663fe1792f6ddc04b3e3bd8826ec84ea2602c379bd2505adaf7 94351c71aadecbfc8bd3264fa751d45e0a89c79a05e501edb682c398dcc46103 094d5357845cddc0f18ddbf942e2c13061555484daf54caddef77af973cbe9cf 1a23da7d38589ad34c2f75db0b63618473f575d40e5fbe85eb6cbf8c8e4b35e4 50783502f05a926f1f3f0184c640815860c8951c658ac88048428a20bd356a4a 4069963f63f54ff6138ebe69f32b2a5ca5feceae858fc304d5c7ff67d885a292 dfff8f7c751a6363a59681921943fd1c855effc1e535bf7e1e4a9de35ab3f17b 7f3a0d231e4ede5f7050c4a412c9f15b950a5df82608a8cd0ec6aa404c9ebfea 64484f8002ae40c34956ce004b51b56adc8a10ddc15c7a29c125875dbc08e154 f1400142edb98912b16a68d00912e3d45ba6cd55ba4be0e468f8247c6f9798ca 382dc32f08d48cd45c27ffe20a915987fda2b6c3c05513d1bb10e5d52cab02f7 fda7cbeec1ec5f04860f26184b0e28453299c34c31c47a7bcc46ed49cfd6b4b5 deaf204732f45af977e039a42bacd559cfe3fcfb82f2457096ef0bc0bc9beea1 a455d12d490ad95d4e1aff5e9cd49b2a262b94700d5911f92b077c3792f46965 d6f9241309735afd5a1715d90834c7993fc0289c582605ce358e912d4920c563 d33a9d3fc09bd42c5f5ddaf262729478d4059bb26ec3b6d27ac6cb7b51dbe2cc e4794fcd8f625c2c1cbe997c53ceff58eddcbb0cab9d22e13e1de14be5ec05ee 85487fa25adf5208d0c7fdb42fbf113f14f8eba49015bde1f40fb81027923077 b2cc455f9e98383bbf0552bec3f68e34d08361b32185a41182517ddbf070d578 44d83a922a7aeea7ee0fda57e096b1d7d4e7b04df3b78d5df23c980b69b16097 1cf270ca8feca53814a80e1a74a16e3939f5056f725073f934064d5cdc16ab06 34651135fa77537850b50710e5c70c5a6e5624979985323af08f29de3a81b70d c67c45ed0e85db84c96492f0a886ec404afe02996282f50127bf44c8f784821f 3a8c7f55a76908aaec211c47e8e0e2f21b5012c61b7e9b30ba2b75c868e1bb6b b24540c726caa5e3d95e2dfc7a28181f98b383bfaa4d128c66d61de0b6b0e5a5 fa27e4403009fc9f01ceb8b7676739be5a2159367d6fb041fb749a6f7680d649 45933436f363b13052edf120f91fe4bfa56396e62a5b42d4f8284b0a72f9e9da 82fbbccf2d05b9a051c31998f887e0fb95645630948a27970afae4c7356a8850 417528c6cd059e75f0a9d25f45fe9ff2abe1fbce922985e2a4339a2536c0fdca 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 false +check_ring_signature dfccf1df9294c224f387787a9fd1eb5bf7bc3fce87cef79f63e24cce553829e2 89fe78e69345346a9aad7b5696f568780eeedb4452f81c39baa8f58d18fdb5df 1 2e2c83a554b4360685592938b750f455131aec77e39b04b860c65b5e913edf99 2d5f193479dea35f21b0d6bddc87c612a1714d07e41b9a3853730b0ac9a5aa06fc0679b862814bd812b81825eee49418f7167b000cb112d8a76bd83133bff20f false +check_ring_signature 3d81cd490f17b34310366f418a9b1a42393fde06ec7c3e967559031bf6a8d406 87c75101ee3d3f762171f78d67b263d2d8e67d8aeb26fcc66ea42dedc815b27f 1 bcb4a6c1af17b3ea7a16ddae46510bec7d50accbfe94bf5aa48d1687a7dc2239 74f554eb2f9fc31bbf6e74e7cb8c201bc7ee6113a92bbf5b9714aca902aef3019092c7e1f382d6bc962f0b96ad26755b3bfc6327364d307934c2f2789687d30f false +check_ring_signature 5320e3bceadbab2832f82d18ca7b1dafea23acf63c7ba418bdd95bccc79c065b 618c0da43e2d1057382aba87210e99a90194b05946945ba9e69cf7c7ac2f0b92 3 d5ac9133ccd6e93b246e3982ae0dde6d0e7e3d3fbb374d714e4cd077e772b098 abe9ca08c08a72e40cfd334ef19d8f9bb1bfd6981ab24ed5a81a7c1ca6fe2aa7 b5757027ae2e1c772d8e9b672c08d3ee05a1379fa329596813fd5dbe5f123f77 0326fdc11e1ae6a38ec12248c326a7b31c609e6030994adc795fb3dcce57170bbce3299ae1f7a2fadfd8f6d326ad5f63091edee4700f51d6ee08b88a5007503b78ae84a3f40194013e3b7697fff36b39ac2247e10ce40d8a0541bbbd0cd073be0af240ab8aef375888543883d87b1617b4def4198860f632a80949774d9f068ccdef80e05d0c006bacfc32e1c71eb3a07d1bd18b96e9eb1b40c515fea74d48a7823a2501b59c70be79976faff6905065ea30eb85aeadf2d7abd4d245d371800e false +check_ring_signature 1d25abd61124a995852eb9acd502efe3ea9d4e08e2c56a4c7acc7d328f564431 2cb504dcc0937334a0832cb5583acbf752853a0135e18ea7b58f08185b0b9e28 31 9522b22c25b283e42e32890ea957c62a65bb109e4779a14359c638b08f8bf1fa 206afff6b90f24d0896f8a8e7e3307a4f2dca16cfa8c6e41b73a48bbc8c207f2 ed6a8037c004a521acde61ec81d473b1ea4e7b2ba908a590563ffd6319e4a0d0 3ae18e53c485b40720c1a88b07f8267370b669d2250cef7f8f36ad514dab9cd3 ca340206d24e793fdb99c98c462234dd134481b3dd7c326c35afeb52944d57c9 506bcb2b3295bb48e508b48a7b45322ad4afa35b3a07275f665840d779741713 d00fa7cce8e59db1b19b97cdb1ee357f81486fd197a6f9ce32fbf417913895a8 f9c837a48bc0db49499d1cf90ce8003d2ace3cb08b172075cc4d3afe8c943498 a3db896690560fd4f58810afc7811e01d55ef5daab37f91b8cb03c4bf4a18570 b0f781ff7abde074321aaccc2b8ee790fce77b6020fe25b12355c971816e0055 097f614b180d08d4dee44b50d4c50b6c7ba0e1e204b30efb2c1b2d0771e5d981 948bb6b125c4db2819910b42237a04d87c72de3fb71c56555af929aa8d15dca9 bb0f1e938a4d3dad796a6cea7cefafdc4ce350af6ec22516ee675ef672c734e9 e2ff91e5d32eabd6fce8400136bbe20eca8f83ea83718142232239ac7ad90b88 0e11410f60a8ca2c41f008139e2c4a68ae82fabc9cbd54de408226621267ad20 d83ca01ef437d27433b86230802b151caa9f4585ab80c4a6e95e2cf84798982c abb10d26e29b8cf2706dff9c276e77305b82bb9778b0acbb5530d7ef917bf12e 79f192c6c740b2e2934ca8072f761a9dad737b1a3e79ad90763cfb4c0583467c d349f8df36c364a6f0f768d9cdf5720f7be0e598da44926b42fd374443991d1a f3e32943ca9464d49318cf4318f7a3b0b4be57975b6e732c7cf62495f099a525 a7c21e8aea3f2681ca34822f1164ddb7a53f0bc509fd3e10de398ebbc29f6860 39315a7fca67ae21aa4482b807a41f11fbc2b23d289370fc604e3c2da7e3d43a 217b702d19c8f17ba7411602ffceb38a9b6a5eca2e9ddc1581f5a3b7113a02e0 0afd22392ea5d50e203a6f2a379d8d11e87c2c8a4323aaed9f938f80d86032bc 4fddeff015a6b77c1bf88a059c43012f6132a52d16640a20d33d0ac55db6464c a0aaf4ee336da9e2046aee0b98ce6b4baa4f443ea7df41787498bfa1f776a680 14c58f9c93a4674d1b5b848337d115f6756a444b3094ca1772e1e457c17cf488 897224af499cc0eedb8f7f0deba0ba4918b742a144d43a42ff652adf2cdaee78 5dee162b0507fc98a565a8166eefd6506e5ac976f0b99152e72f5a2db558e5db 39c5af7cd8df88ee614d0c80ca2dc011a5852e8cb7fde766381e719cff7db02b 42444f3df8387281b0dfc9d87d33cfa19a38b3b18fcef8866c68d8d44da76f1c 567fcdbda330220f3150eeceff5f731f2fe7769e94f076746518dd04400a240d12aade7ddaddaefe745090bf22e3bb7dec3943753b215237814b2d825e6478058f011c01f1c5c1ec2f573b5ff55ee96067d4305c1011d7be205d6c74b174bc019a84f19141788dd079b2d7a965dd69c2aae288433ab180337465a22f24c80a06081de8cfde105efe2ba8aca58db6fcbd5bcdd036ea61de8de0e54a33eddf650d2fdb70d7ad7fbb25c41447150fe2d6c4915a5dd8c2edbb95c128cf6560a7ce0aa3b21119b30c55ac3599ba5e4c4e5b25cd062fae1e37a7b265d28ea7f059a20a354a89ba4daaad6e1a959437299a0080bd6d4319fea4e95858479def53231a067a3cee91e1db388021ac1df99d9ee118244c8434a8cba95969cff982098fe8008fc86e80adc2a3795e7056baaadf92572d52464e090fdde1562b2c9eb7dc3d095431112dc5372e38c52900d992376bf6ff487bf9e2d44ef986e848dfeda8c400e0cab6c30ea2cd9539bf9ef6578c1be907ec8122b4bc91c7f962517acc9b3c034b05a9298414d581e20749b35f0445ec53e07caf9289d2d5c213cba7ef0d7105d4f67eb72f25ba5bcb0382c84f23d2434064e00d6b47d761005e3512fb42440abf2e1850d503c1ef1a0bba90195c9158b5637b3c38fa082b4a6121afa469f50431dbf9e9cb13c40fc34009540411fca39f9ce8eac8e2f5b594c407e7d178d8090d57ec5f7d76aeb16f4eb23c76eede3f1e606145c96dde83d8e6431209ef300f931d7cff6ce5b55575d7b131393aede83619bd45a5b92eb043477de11434920fc9c90d85306d0aded2bc866ebeb97312f5c65a43843b7e4dd1eafb327fd09609bcafe5a53aee09611c6b2e247c3a6874785a9abdefd199e1d4cec3fd50fc570588e4e59bed423a0299446bdd4cef78ff62d0b0aa698e00e663e09c9c099c180811e5cf175148385ebd735a16439c996fa8fadf1f23c9bbde8e8bff66bdee950aac7ec133b5d8a4415e3ca6ae9a4780a3a62240e99d8a9c46d9b34193ecc10a0fb2d093ac36c5db43ec5b18a834ca51d5b8ddb040bddccbd3d0fbad7a9261eb060d5151c2477bee31f622630e1c35c073f095a2c7954ee5a9af3e3d412fccf80f94fd98fb8dae0837f521560f874feda822595dd1abbc4ffd95b6a66fda49a100e0af0e9cdbfd764de7458d989ebeb29ae8e9554fad132ccee123b5947fd71d06731e282cd964b50d5d1d1fd2b8257306d206f3794751d6c50db44080ad7d590b021887e12ed081f8ae05ae9c93bd043df26c95b27feae0d81361f295e1303102eddaf5e0485271f55ff0fcdbc109b8102020131a21f145ff2021f4ea99b6b0047f6661f413aec3f5036618568df879fe7fe98e6a24e791682c53bb47004d360fa1789cad9dcdb7bc82bedfded416ae51a32c7874e0204e72bade553ff1f50007ba429f8046e4bfbd1ceb6c946e755ff445698aa7c55e7db549bab4c589095a0d69b6e4e406f44256c6f46f0a7565b7583739700fab771254f1d5dd9a29fb4a093a8cd5b2e1ee942054d82cff4540a24349e1fb0ade7944f12b9ed24982640702dbc7746d48cd83d468a57e416468f909bce862cb3743eb892d80dfd49d046d0958aa5b4bfb0a5e5640b1588eda2a1d1155c274fa385bfadd1f6ffa83da3b8f0ccadf0e54b9f3ec935b296852b9d68f5322bbd8aa7754b4d254fff50417125b0525644258035330254f579acc50b570cc8a32c4c10d0cf64fc3170a33118e8705c31dcaf3c1553507abca9dee1ae9006887e1e7988c8e5da5fe87403533c8d805847f800710d902e046f63d57566ac8268e89689777e695f70f3e1a0d27aee70eb59c4d26ecda37cd831c94321bdd4cc61846f709ed0ebac097526a1ea2b2ca050c11b2b96b7eadc8e2cac6f22fa4d6d97549c34952ce35f5cdc7520071ade60fb7866fc44faf6a223ab468cfffa971b4a34e8a74efff3b62f8baa695e28153081149df8f894f550acffbbc94a24ecfbc9a07b573f94e78b7b2e222b2ce82650c2755feaba66c92d49aad0a7851c15b9527f0f4238fddbe34c099ad6ddec8a10d0c33922c7b80a8a08eb03d35e07bf6daa469c47873ec53d084649eeaa9c51c00d49b97943708e31bad3600c006fbe92ba43043124e003ea924443b56af50590444005d1935c32d479cae09ef304845e4157537952e424114859be889d2eca6008fc73e0d48759a677ca7f22585df7173b7f63471b6b71b4c56a916aeeca5e40f7f080e74073d7ae9c712168080f253dadccab5a5ef2de0cb00418df310d69a018c96f086381632383b0f72a9fcbf9332e9d3e1b4dfd785209b354e0e1dbdfa002a9bd6153e619e7e50d42c76b84eba4098f256101214be60fb3de9bd4faea807f30e222c2a13418061cbc4fafc128f86842fa6d4a4a502db66a34e868f2e5c0c47b37eaf298328c65d30ed1bd37cd9dc0363b6e40a2f3d71fabbab88a9a1270bd5fac14b42be4d3a96ce517ecb8f33dafd080ecf05ca90189826cfce80360d0367e3981eea8c557559620241db7ee1e0b170f7d8b4b52153f588a54e68b7370f27ef6adbe62efa160eab5b1ac32191a2ec0a6c2adfb3a2fe97372ed9d945f90756c7c4be50c44666560e104ca58dfefe84170d5b15c797b74424bd6c0e08f20805ac261c16e23a9a2b2344ddbf533c27db7d61edc78cbd2adb805e0e78292e0c41b7c1ca5d2e831352c9bda7b9843d4f82ee19f255cf9c7a6846e637996d160be0da3d6cde90ad734876ad19e52e76cc8c88a1b303c9af49a87cff9d650e6303 false +check_ring_signature 496b29fbc5db2db983592bf01361a0ce21d49f0697746bfcbc4e2345123ac84b 1c65649c98be2e7dda7001ae4cda834522a3f11c1154886521e48cc9852a19d5 7 b99ab8223164481770d0402b2a75746c4184bbc245e239debd4073dafe57aa3e 7954edce13b6f8a0c01c6acb5f0ef3397bd0a4d7f1d1192b7ab8d539a19db1b0 e5edeb86874280e15d28d3d0dece7f6aa18aa689af455c79b5c768e40042a364 8188cf7ba684ae125877d174448fde8fbf9ea251521584cf4e0b74ea00eacb84 dc0e95e25d5840177caabec1f91155b6c3008544cab8f4bf72526a1415215f6e 1d30b0c98a069422506c3a1ddfa5d1535b8c4292c6d43fe7f90b04ea14e14217 88cb2a6ed896d46e5cc95e3db0558fb4a2207ea8ac782593b5613fb6220eb473 aace9a11c0c0f3138e6895408a3227fd4ad14852f399bc237915a06a14e145030bf5d3b302c4544e07e39f28acd69f3509f6264485575d21749f5a490852a60ee5f1c44248f18de43fe9e380fec75303462aeb0899c7f3f5bd01dedca485070044073d523cfb0de609ca6fca71b3a076dbe16b07a4957d6170b611abb20d5f0cda95034bb88665623f3044160fa0160dc1b3fd3eacef98c635f0c170094d9a029ee3b84eb524f858d7a604fbd8d89417c37878d4c37ed594aa86343726dead0a161077848f7ff21b04d6b65a2969ae6e41a325a0e6cce0d21f21c9328c1894a21824c1bc284d5e3ee13f0a68de4bb17fbca324a90a244487ba4a4c91c9fde80e575d2c39049913a798360c4abea558069f51659f5c28646dce5d9f20ec55110e68d93f5f2385885b508a32ef70e8e0538cc0b23a8ca91111f5ca0f07a2ff1f0ee85eb3730469fd6e95e5631a5c11dca98d971638bb5aff69da71b506613c7b0cfcea7112e36a4e78c378d21304a170a49700f51ae2226414abc8da2401d4d805d5997f5c70672ea7a679434c3e23eb99edd040974a264e9f19daac4617745f0191cb9858f8bdb5b6201247f7d87e4d8f69cf105817996fb2f7978b8404524a06 false +check_ring_signature fb97775216b61fa87e00e251ef5138eee6a6bd3bc5ffb3884ebf787248d9cf24 5fa0bd12b055aa70486f223195fb72d71e587132249820b23c29a654cd6d6585 2 3dcb8ea61a6e87b8ada5377c2bb3ce742986d6a2cb035a9eb8944b5e7e92e9d7 ac78220c27b398ba1e3b1252dfe6101da7fdfdd4228efc98f9fc5f68faf2bd66 edc343101cfe9c6fc611f48a6adc18b9f672d41ca3704204dc5ac24ec0739d009a7a01c32395ae3be0357f15f4d27e6bc9735436e43c710daf11f013ec55960eca16c9d5fdd32331343aa689c439950d1600f9c811d65009a0ada5c00686ae0da18b827a1f37a44908eaca4e78f2892cb22a4d881623ddbb33ba51359dd39808 true +check_ring_signature 9f3a1360eb221ddfe5a53da286baccfd8c720d324289a695dbffdfbe48a62379 54c36ac1772603daa61ea21495a010c6b9ac439732e8f35213d6ee08bba09a3c 119 5fc4a4c1abf904044bca230c84949806888a910a1a1407cf67cd523fe0ca7da2 6a4dff66873ea43744211ced5daaa1c7442c44b8e4769ebdba586fafbe201196 bb570efe26d1aad96deaf81183176462deafa3e0840e31c0527b16098b162f6d abe3527b5b5c896528368f22a494deb47fb5ed7ab2334893475dfdc13b36ecb9 c55a02b3f7f22f377b30803e6ad0dd642de808166848736799e29f44e0489d17 28390d964f4250670ba91f4c7356174c8d445e48f2d17ccb1b1f7f513d469a54 025dad9778df02f626f268d2729f5c6b6fc24ea5e09edf38bba7818127d38e07 e15c86936447dd9f12b29022551227ddee55108b5fb9faedb20a89d90b72bf0f 904dcf1662d4d3b27e85a09d256f828428d792f5a047cd6316bf3c11dca55303 c2f65f179e874bfe4033c8ee5a36140fe85e8906836b6f3a425ec72d101fe15b 023cf8405de2eecb090d27c1f19f51d2a69a979a9670387cb36f8c5cc109f2d4 71e335abc420e45eb7b0de8179a81112842652765ffb52e637524654dda5a176 362870c9498ea2616daf24db578199e82f82ef68117c1009d489dc6fbcef2890 19fbc9037ddb7a2b8f1918ba0d9ba873a2971d6dac508cd297970bcbf8f4e7a4 2dfc13148fb55c6249d5420a92e55b87678c0d970b7f5938ae84c18b3f6d4aac cfeef0924fcff5fa8d4b03354d7fb4301339d8ea61e72ba116f1bc9b91c280cc d1d97b2801c12a8218238a02afa8dd41c5c6cc99762a2de0d0ca9fde38a1b390 3e36df9024feb0e8aa48e11debe2862e9bab42e030bb98df4bfbf2b3efa6055b c54038d83c0abc82a54d4a0539ea6d0a39e1cfe2d08677800afa426fcce741db e4886b4a84061c626e4f0001e3d9084a42c628b57eac6f59ee74320cab86b740 dacb3966a35b61f487aa53faaa9d924c12d350916ac4ba49909b71833aac7f5c 27c11f7ea26740df8c52ad6f8def333f4209862e0b18f78a311b845d85c2d916 d1fc8acddea6f9415acc9f3e733cc853f8c3d87e263e565feba670b6d3bf1ad4 6a8f504e70add91f773ac09624447aa795f8bce901b55deb3418aec3edab22ef b1373791466deb9eff31324949469659ad1afe2f402246e4fd489fb5518b61d0 b1179e4d3fe40b4b8f4ae3dfc2cb3965515d3d41c80b76ea841e1230be59c914 bb0bd0aad5576405cbc5a007122b35ed2351945259ecc01b724cf67befb8ca25 d4df5933ecba172eca73c60471ab2853eb0f86c8c70d939567855f89be3d80d8 94e5acaf9131f28188107a4cddef3e0cf22b7b76e583e1e4777ded9fb6b58d05 e3aa848c1cfce8ba99ec6890de46e2cf0cc5ad878501f80205f46c9613f66c76 4787de096376d588de599f1b5905eec11debc10e711839e6e62510995e5cef84 bd10549ca865eb996ae08f3b78653eeb0a6a1fa81341dfda8b6e925d697fc8e8 92f5b17ef67595259cdbb4289188ca7a904d7f03b95eee0dea6179051c6e4929 c7c2b58d44037c774b98ebbfc13d7d3859bbc22389fa3269dabdfe5f4b00defa 324135270e999c2e4898c6d609820c947931fe2bcf096ac567166032f5e99753 c33187919e82a4380eec3769051e4984b4ea1fa41b8877b3d636e27e2ddd4011 0b0c4036e39ff8a158002b1613c84df31dd688095886a1e08d8b547203839ac3 8a61e4c74a34a3067fc648998a00283411ffa7c903a2e0fcc5e1cd4387c92299 c7078fa97e489fe3dedea94871a3f0e46fbe7c811d7b04ae5bb0dd87ac380f5d 59d5cc02af27a551636d492de28211d2cad5bb0acb462106f5a1f2f1ea71641e e9aff282305c2e3971aa4b6867cad5c682e384cd141093e0290d390c82684155 6477f7c167a55d2abff937565d9b66fa55355d6733280e7f5957169f3931086e f3e77fdc6d5c189ef8ff9a5e5ed88159216d44193aa0a1276b5fff2ebc72fde8 2bf5bd3c48f3e1bab2d1caa9e7e219173bdb34f21c67f105c569cc30d7cde469 53c57841962e743a85cdaa7a97ecd6c7302cc3d890556ad4dac7f26d07b62518 fb70f6500ffc20b70e232fa61762bc406f7eec222704e9855a46bccd03e2bc1c f3ae1ec0da1e6c93b2f9e6aca3ba08d2b143dda8b0dc55d91b73d94eb1fde0a1 197332b78efb7ff41e5258b50160ca0863fba3922eecd4494853ce2cc4ce2c99 94f0933a46681a3fca127be5c708a775a069406d138b58c9fc93e2ef6985c6c1 530a38de36e8b481e5d58ccd17374bee49d7a03d1320b1065866064db3155fe6 acfbd742587eaa2e301709ac69f002c2f92f7de9932cae515841fc4e002e2a7e 7b373d5b4ba8022f4890a45549ca5a4fa8c460ee1b2864ee02f8e579adc52ad0 676c98267ef9e1f59fa2065fb0e59a967a33ab9dfbdbc654c6f8430dff0f6fc6 bce26ba0d8062aa7ce97aa8ca7becd810300c497fd14306cd1a6144899e0501a 1293826700f4637c5c3763101699650d6c40df5ef1df17248cc126a4eba904d0 b2fcc97c08f8e9a2bb16cdef26f8ceb70e4b8e9b6d55396f3df186a108d1d6c4 d3367192a1ee434fb605770a886311860d2cb50ee968d276c5e6532e40b3d529 fd04aaa400be9e1c7da36a2821c565b1b96bd19381ae1710d593400a6b2b83e3 337f73db80ab42e863f311a055a1465f25840d07ee4732651867973400e7129b b43f2c8f88d5bd7014e955e1631d5b819b8b755ba703280660723e7587a32819 4df106f6b7c83e271553ccae0468cc285b3c4d6dffde72f63db17c4c16a2c973 1ea5c9c652fb777d631fdaebcf44ac074156fc1c28812d3b4b3e49aba07a80dc 0d43908876391f8106058088f6fd12ac29754c14d2c491423d73e0eb0a10c650 c6d46880f3ece9164ddbebc2498f5bd5977a468cc23fed0101819015a5e2779f eb1a03bb9cbb04bd17800fb818c7205647006111f5f6b5799873d625aa0e66a7 8cfe6042e9c88df5fad794e6f82d7f4eac4249a63ef66ee3a018c7ec263845ea 837836641c27ec575b25bfbebd4c611dda161055a97e00ebaebe6e9b1033bf07 e9a2b0ef89305a027dff55d5617d8e97d2f0dc4edcc318c7495da2b82e96f1a4 c064372bd15b9a5c41b82ffbdb57bdd881c351bfc64c5b27f6d8494d33410009 3554ee93bdddc7a8ba7cf0b5dd2aefa925feaa0972798583381794ef45a7d928 5ee55546c566435f79af3e2732630b5e98a39f0933e87a1d9bbcebe3857af9c2 ecdb0aecfd088eb9ce74a8eb01dcfbd954c1855fa8ac2436a1944aaddf052b37 bd922cb95ebb73062bbb5de25b2aa3452976b8216104a8e1d3132c12c489c87d a6ae845cfa840a1d73f96972f1cec3d1e4a93f310ee0e830f8ae3cde4abef1d9 1143de7666bd63a3e8076661fb804cdb57afdad45e33f8db9fb3847adba978bb e186d1f876743dd6206807eeee34eb3c65adb6560c74199b497eae7c462dcd72 700bdd4a50a03b4fdb927bd281eb0a6cbf3a36bd1ab313e62b4dfdb35c4efd3b 1159b205c0f1c083026166abebd7c207a82c4d9ff179f0529ab4d9829998d1bc 216627d363ed46b0dccb92181ac79ed3817461481157643414cf317ac252562e 60c11213d1c92450e47edf0c4dc2ffd95dd9f2283feccd73de250f39b6756650 177b56761f719e142333384470717fb3ff846ef20ca1c394dc3b74925f83e4d0 1df9ebb1ea88b8e30579b0f4e8ce604fa7b7949d0483ebd34472287ecac4df2f 98303b1463b8c42afd893b69f502ac4552509987e56731e967dcaff43fee728d 349efa8b98fe3a5886769c24442d5ba2fc824d81f12ff654b74ac4acb8d811ae 83fc30e9d57c8c0edb7d1a70d36df03df1c889ef615c37481f92ddcccd8fe2ea 65d82e5eaeae23be588fa2124c955342c8b4b9a9f18383f12b16621a3a98f0cd f978da297f3d6b94f8e2972989600375a82fee1a08a9ae4913b8723e9f8c9e04 bbf080397638b14beadb260eff930accf499c411691abde8de3abe9570906e57 226fc5138b24d78decf5fc241c07a920687c63d785d738b7beba8d6a60fbc4b2 17fafb6294ce4504ce0ebba8d3e1ae207b8acb8b48b83a46f564580e561d99f5 480bbc5eeb56ead8cd85cce1498530097aa80a94343a78a8a9dd8a56d5b4a13d 1a9987c14f3f90a8932f640994955092b3e8dcd8b96c7f1f22810680e5faaaa4 355a819a75027facc2313470632cb539f644dcdb6a8372117da727a40c005c4b d392c7965742dbfe43a6f82c3a035c7823785bfd0f2937fcaa0d8db03141941d 18ef88f2b46ac0ad70e1b403fcdba1872f446e60b38fa33c51880fba0bb06d60 82956d76a48ec0c17fff0d7ce84ac5c3e3e9f1183294eeca32333fec7097f3d0 42e738978c35ea973cd3d37bc7a71c9bc4289aeca8bf643aeed87bdd40f25c92 c6b407d9285b00439ba8eef30136f89d7c879bc3cb91b0f4f186ff96fee7a680 96f1db13d99d9cc69736355f907c7afe57ad4c74ff30ac61f7e749eb01f5c562 27ae835facdfd9d73a1111a4cf26a1ce972cfc5bf582c1de77844385720273a9 bcbe5b82510b9cd9ee0b71ae438b8ecceb877c4730c4e6edc4dae1fd0084a39f 96a8508462004aaa0423f0c642222b99f4c074ce8dd4f11b14aa0c21ab7dd820 a048af5066685d17832bedc0b385d6fd14d392f8374d6c7fac511936657bff4e 2e4a1d1903e13c9ba50b10fe91968543e9c54fd7e832304a25de134f293cdf63 a3aaa61839798859bd9c7e6f5d35fbc482212e5537a6cfa02140799f78aa5055 e144b05334ff81e901c3b007395e0d74a1e49e5e789c0b0f16a8c9cc194ff812 5c089efdc3a21bff7da052dffed709f3d2c8dffb8d4a1e3a6883dd737c0a6a40 328beb2eacdcc2d05c901ecfddb36eaff59de877846ac531941c79b829065571 6168bd16be72697c474c5679e5e081e4872fedcfb05e7c246937553cdb84bb3b 5d840031fc2e2a09fc5ce975c8113f447cc4078bce6e7cc69647a9cf24b4676a cfc6287d906b028fb034d10aa2e8d48ec205f30ff6cbb8c52991d06648cce5a8 ec864285122a065334ef80017d7ae840eb9ac9e79f6a029cedb40a0eec103db6 5523dbe3029a6015f6ccb5d161a369d1c806f2abaad3e4c8d930a8f6f9cb0010 512cfbcb4ca2f2be99947d6b24f933172f1c503212267e3e14513b7623e6eb99 cc8cab57a245a0c944f3d4acdbdd65c93c39d2e2db670096e4603ffa1692a062 34effc0adb2badd88c09241791acb7b59aa63c29ca4ce5521405896a3bd4fbea 0f0f4f05cc0e38c8ce9d5d01c1946a730641fee974d67a92d522bb65671437f8 d351ba9c638a00066be1bafe81a36abe47691ebbd828e0d70bf6209c42aca8c5 392466cabb87fa7a26ab14e305454dbccd4450b1a8ed2d401e1cac5b9572be9b 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 true +check_ring_signature 9c2488b673cc8a4635dcd676518a7d19f9c3eff6908216e6a6d9f8ef6a772144 3639de8d0a368988da62b088d95a6c0e3687d3d1a7ad2e89462687aa58e4299b 2 a22def33307fdf52f7c6c34a671cdde4df5cf006f19ed9ec68d5448f1e9fe828 7c81766464a1abaa5ee46bcfea1a6fcbf859a7cfb41734fc632395feccf9d63f b4b17a29463f6ac3538520f76a3b9fbbf929ed7ce9e97812a01004899e1d7d0342661f28da5120da242b1103e34502cc68cfe611d7219a6aea752ff29c41a10f15d1ee78ca47fec8c9127f558b06e9ae028d99b4c96edfb79723d064def42500dbda4a3df9cd6a9777c1f946b5c2a63d6f4cf511e8ce776a284e47144ec8a003 false +check_ring_signature f2a98c35b3b6ba6c5e86357250c32afc78d6bfe9671b8e6c3453dbe9fcaf66f4 55d367ed34142748897ef9faebe62f90d8c7682c119e1fac8951bb432aef51d5 146 576704f00dec5f3bd729442cd97151e6e733f3235488a1bdc78ee03fb1f4ceac e6e5b3905973e25646b11b1e2be0c7354740f7d439b8f31b6e00cbe41bcb3b52 16562d06858588f1cfd6fb6e928b234a74a3709024af9b9af5ff13644fa42ed3 af2f1ecbdb70b99c1aaf60e39d5dbe58b916361eefc8d11e95f73fd2b1e7339c e065e1478a3f9b3c8c72eabfa1e0b3dc8d5c632aadfe63c9e5f00a50159d4846 d02a5710ad283bd840a1de7919dde60699e8656ff564f4081ad27c523ff65cc7 25a2020f8de33fefcae7a62751bd97db330a1b8b11ef81d17cc7a64ac79d02ff fd5f8560971ab0da247bb336c2398b2cf843a59b9324c1855f0fd44803f7ce51 1ff9a8da19665008583d8619d180d1b77bef737317e630d9743616c61b2eca98 3fdd55b51621f2d41eecaa7de1b9d9e417c6d05d2fa1124727e5bb154583dae3 1ee7ac765aa6ae5b69df70004efd422e8dcdbd2b57a284fdc9deeef031060b90 d6999a926955b03aee94c3aae996adbd2dc0be0377ba35e7c8bfb53adbd1734d 009990aac26814c0f6ee4147eaf14236f106be38120d16529b1f4f959f7fff19 3220ca9f5bfca59305c290841111edf17e28b3cc073211f1bc9de316a36a3f3a 2bdf757e5e9a18e5582f1af37d873a6016e6eeb3e6f56b40c003b9dff31ac1d0 5fb56c413540dd7cfc6c533f07ccdc8be3b8eb9acea5e2633b4d619df8701b9b 9ce25ed2749826869d799b109c1ebcdc4f2bc017de0427b5fad7e62817d09ad4 468c3a93125c2d2a9bda9a9e3affee58d280412279b264f27a86acd3aaa00587 c24c430cfd2c7ab1416c221f0b5e0ca622f512c7275b1cdcb640009a1c096e0d 2139e76d76ab994ff6d4e731dbb5eb15b9a2ec736e6553109dae3747b4845a9b 1032190fd80c41f6ed8572c52e0e7c950c91d0382f6ed433640543d40673f5ff 96226b72e5d133800b82415f4b1ae8a6de4c0f4b4a0166be28a95a8b109c890f f484eda8d865d01c716dfde5b8015c92c3a6c5f1234e33929a44481c88a68b70 6858369d12536bb557a37e526205a3eaa7a0c8df5829ad915a3004b00b3f6eca 6ae1a6d517be9cd74169fcfcb0521298fe3ef0683ba1de007b7b847c49712a68 a2beffa6a419f3549c32d4fbc7eb8e36e1c544f7d7f4364c83948813f756f037 b4ba5d2b4a4796d8e198ea7d6d70bcf5c5024a0e47409249bbe8379e9fa85724 d19e62a896ee7a41d801ef1be1af6f8c3c875e29f9e026e1b3c1355b5404ea32 fa54bdb82cac0d9fa361e45b2315c1a184ce05a85894eada37f0548e88720c6e c25e5cdef4d884e178d58b61527f0db48ddecad3cd35e2c89514a4c8bcf6d1d0 5d7bd5b724a988505e8439c321575d5549aba8bbee72647941a38f50908cb228 c4710837a8427fe5373a10186942f892854b69cb09d1f1efedd104e6666d26eb 9976d58946c542f2c837579b36ff3002aa77673fca6ff2368e6a195e622854bc 30cf978e05eac968a85cbf06ab2ddc8731ebcf154b2f96c429553cbb79f07806 e59303ffd6743b2741e8910a57d50f78972b7106b645d0f0ee4ff4412ef85ac8 0218565eb46ba6eb9162ddba493eeee365a3420532703e4be569aac6cd494762 41a371b40ab4325e6d5b8fe73162a22a2332de108a25f8a267af4fa7ad9c534e a50988990d1c012747d06b43a1f3b59bc1889a07fa170aee8113524c8c2746cc d11b0b35fafdc17ea1ead8009e4bb27cc528662e1f3786b1d284ee6d5415e23c 032ab1a6f5714a499818490693e35fba3cb0431848a46027cc0cec3e6225f14e 972be5fa33186e0d663928eee8a175235b540e93d0114a392ca02af9c124eb1b d50fdb5d394e6c67d8e64bdea034abd7766c0f1c58374e50768ff0cc3416516a 1a695c5a54be7f81331362b304a9376a56e7760e773825abba58b976cfb8cf66 7ea1cb60d3433a85fcab02b95f3a76c9a6040d67e50c1c59a0adcb90f16cccf8 ba00805931d3e10b8fa156e9a9b09affabb9f4d87fbbd5c403c8f93b6daf3e91 5a46a1635f15d802685e809c41a4f50a7da5dab80841020bce8dd50dca4095a3 ef61a6dc56f936045edef864a2ce398d921988e952850b4365708f24e583ed11 f38f1303a67fedfcec09759dff93abb1366d4145dda85757d1f7d58eb5ffc21f 72882e0b0d951d4859540c21fc8c00aeaaa671aeb9f6ff3591dbc98447663681 69d13ba9b9c1cf7898140acb88a2818ea503f8ba97fb311d48ea218273ab357d e2ecd50973ce9cdb1a758eef23194e12fc1b19f2b680c2fc91ba57acf99276d4 145f18dd7737ed9efe44eca3c6f75ad29c60fba0b13f1e53535c315918b0167d b2198cb3e6d646179054ec0b32a68b7a2f3eff0ecbd1ad773065df09f89d97cc af53a8fb1aeacf3a3a2ce130a15677960f91e919cf66bd3f7442fd5e99407437 12dce38ed42f91205c5971225ca75e7ee0ef942520a40289b410db35c12d980a 89eb05dbb8114ddcc6d88d464d551df693f73e44ac07c8d2db5d148b9a6c68df e053ed77d04aa1d3b290a0a40c82c3fd8bf9c3c3929b9b2b2aee5e52c8565b75 7145b38207fdf8c672302b754f67e011483ce43489e6a01376643eb374e38d7c fdda0b7331ea89b8e259a0b507b561b1a6070d2fdaa45bb04ceab8231f8671ec 77d9a219c6cd1e09bccc2bccf5e9846ffd4f1d85cbdaf3a8d5fd98ceb66035c1 28dec253efbc8cd9595f9da23a8bffbacf87e0ab912ebea7f681c0c2aad21aa2 9240309cb68a35381a9e9910f9d86d66409e18ba0e68b4d3ea5eff10fb1608a0 cf15de5f018f86ec6e88470bd06b5517260f75b600606d34be6bf112ff983464 bfa7a8c68d913afcb700dfcae55aede834a5cda77057bca086c0b5708082f760 cce933b466753585706535db771b4ae4729cb021d4052f61d8d6178adbb50015 c981eac71bcb316c3b8df42b893591afafd7e83242ac2b26328798fc0687bbfb 455365b857cd1e974afa64d39d170c14e3eafd98402e8319353c84046bd573b4 36b9a4436585a1ee3a4c0d88c0891b51ae4ba6d1c39ec54f43cb7e1834036e02 805e37434b03d25ea473819253c57ef786129cbeff2f1d872038bc47c6c185ce 806d031c6ce2d8d3596cc56f600e57428fe08422efe5f7acf99b7bcc15b311e4 0e180f1fd51997f290655e399032205e1f44c8f175199148edb78c14bbb50707 2827da8e5b9d3ad00d60f24c0cbe93bff22e877dda130bf6c6351b4412f8f9b0 7ee4a53632ddfaa461ac5dc6de9094634f2ea312ed1a6ca196a709e012a6bc18 6e810f5dcc5dce609bf70e7f399048abc03b4dd0067d37d59a050594c32717ee cbf591752070c9533d7af16b963cab27adddb982d10c87fcef5853be377e1241 6f477a53e555766261e78834b0d5d819967dbfcd91d45be13f0866b2fc23a521 eca0ba59ec4f7317716a3ca1d5ad6a78266969d12cbd80b757c95550d466f333 86bc88cc49e8bc1edc7cd2338f5dd2a0fa7586fdad24ef94467b695e52601f9d d8cc161e4d0fdf0da7f8c71872318647b35e2946ece89166d4a8636768c475d3 c915deee6de97910c9c14857719edcf46689e30256a511dbfb4eee32fdec03ce 23cfe1beac503a413f711e3291368e79fab6a7668a159ab27a414f2e2f3daf4f 777ff69f37c86b70c09c3337f48ab2cc1a1a04969ce00f99613712d0945349a6 d9e8f6f6ba627b5d7654ff77eeb9929923f07bc8b87a4de4a15a918a9cd32b15 d45f101c8d6fbf92eca1b0aa6ed6ae3b996899f217783c26df0573fa9065b07b e934b23800341cbdab821adce45d88a3cb86c6951cc2c29036f2f9a600aee87b 8ac81bd22a92c3f113cf6d17b39ed7dae923831aa44e78bfe38f2429ed5b5edb 41c6fa1683c09dda7f044fc879ce519d23184a230d7b1fca87c0e91294f256d4 86e8d30f81056a5b7bb93f51c984f60d1712034597a49a4e9c252dadb9ceee2b d716e97f49783a329cabb6bb506be11688ed19ba6ed667b3cc23f81ed1c07394 b86d20dd4b5d55eba7ed909fc6b3969f135a61989ef6d6c096b65025842a2774 576d6ba7eaee8d38cf6e7b1d9c32869ed465b7e786d3c489421d77dbea8f0958 f3c5376bb165975247ed2f3335fc4071f01ee46ebd5dc84e1573144ecc86e9ba 1f7e67cb8ff22194cbd87f49b62fb23bb117c6a563eb6abba56270809c132818 d7ff1cdddc984c01d7e15210e891f38d95b54f6404838a54c4ac4ab7b63ac1d9 dded9c3b6d042a82717bebfb090aaa7aea45cdf19ea8eb59fab356b6f2a9c9b6 a196a494d47666e0d518e6ef4aa115a86fb6ab3f3be2549ec48c28cd8649e51a 3b1183e8e52867ee84795ae28db3a4f04a58bb6e59082b222a85bb431b63e1e5 c9cb35f12f9959a9b77bfb5789b47419e1176836a5ca064c7a9bf3c1f25bae8d eb578bdc8b4ac96e8e068aad53b41e82798f72cd696e1905c7483d2f181933b4 17404074f2f9f9a281633f6761f6605ba0d26824df0e15686eafe5ee00231dd3 a958f5c6497ac9f0367017f387ae29d9b05f69d7c25509e616f80e5aa1906435 7393ac017311f21925a0377cf7e1017d6d86308b730295bc6e6058794a4b2537 39991c4955f754b7e6acfa7df06abe4686e98e8f69062ff822865e144281174e 503002017d400ca6f51769c3c0bd7a3f91cff638c7fa2b60baf86af3bb100ced a25e63c117b59a52dee32a90be19f66951480328bc6d7c9be9456b05467b4de2 b9bc497db432e7dba216a870ed482a2e806641631d700c7133dea1ece1264bcf da67a4c4a67a43cbebe24bc7c9157eefbbd264518e81f9b9bf575e78d795705a e690a95282ba80f1a051838c60087a0931290ec32616fc48e8de02392b557ee8 ed24b4e59fb22f774167bce935628410550a3f1432a24892d9ee8c167e1bc5a1 c322e227b46ab376d09ff1731ad61eaf639207dee2a9a68e2efc8095783fbe7f ce04d27cc4317ad33506d1714249be9e64e4f3fa6208a1f0aca62d19bcae0294 81f83a8110fff636fefb0f591eabafac806e48ef3326259dbacbf3b15932ef1b 84311134e3c1ec76af13733908b0cf3844826125592c894e9700d31faf21b325 8fe6a0409ca0d6189a46aa1f95f399b8633bd420c69722f99fac0fcb23b68ee8 5e14d2eee2f8090c874c479666a6cb9a57cc27a02959c1dbfa0af23629d35130 3f2a027f531ca1b67141e7ebad47383db458c94b13045e0a8c19ed382b89604f 8e39b1dcc1419e4bb29d12941d97d024f4f46f6e553f4d46f2eb192d8e041432 fed699263467365c65e3495c19617446b9e021cc035a5c13a0b085520bf9bfea 8916ddb73c2473cfb25293e476f0820ea93af65d94bd8b5317d05303d3812150 0a195a79ddc1ceab1ebc23612378b0fb5d9a3e5881fdb55bce3c64017200fd7f 1e7007825deb193cfeaf763f1293909196419b63a6cd4a6c446051d6e91dc328 e8fdf65588ae607a6aca2510a8ca18051d40a8f0ebde5a042a3aec55ded4e2b9 713482fc47f54a5e9b141a7d5cda3ebaf5b0de15ddc099e2b17841ba40d752f9 d69fb74d3ca28add269687a7d48088deb830fbaa0abcf5c1ad04455c8f4f3615 eac0e9146a8105ee2927f44cd54fa0763457e23dc5b600c2e8d26bbdd9b3a71e 42f2eaf02cd6a026c99153bd2a194329157f1e270c5bbf42c52aa9959706a739 c17559961a76d16bc7e139db2fe79a70284940c2ad0a30ea876acd7d7d4f4622 0abdfc892c06c4f7cfd2a0049aa3365eecafcd04c7c41794732e50aaf7cfd791 c6537aba57b1d44a8f74062f3abd92494268a39a7b22e5e1f07a68f5406c58b7 5fa5368f1f863996b9e88f3577065ae7264961bcf7ad9b30a7bb2fffacb2a967 6e54b981ec7a35df60c7443e788c71bd284c056d3bf7762f1bbca561d48b8669 79aa66eafed2ef9db921d394d5bc2eb6ee99a47d2d90c31bd944d1debc8b6bb3 a37298ebfc30a50becd54c03e205a01b07bbe2ad4d0c94b0a5ba917d82b7aeea c54f925d1dea0657d5fbab7fd7d7f10dcb0458edc8c277ed5c7aac9f57ffcaef cb5d1f806c2908edf6d9daa4736db6b75c08dc9fe8f32189fd935a97eabf43e1 ad59f12b1f3f0ba96dd5dfc5843859939b8460902fa4e7a7408f04d84c85db0b 3dcaf232a02ead95ce1605e7c28a95178347350746583ae21d47523a521b1b17 eeab68496bb0782313d5df3a3b0aecf9aa1ed62f28846281f36d4f8d7498a740 605549e3590e23f4728f0e2416e632cf45743416bdef50239991e1137b8e8b4b d3dbc373232e7198d31c0707c1f87d6370edc4328ea06937fda7296d20033d30 3131c12996d3b1cd478e55fe499790146f6cefabe1cfc867a92de6150cd2e42c 048a0f8003a2301512caab49475d4f027376f8b25f9f92a17d1dfd2eb050c441 d546d5e8a2a66265db9bd7c16d43d2d7302658e21bf91bb6233d4b9647251afd c10d9dd93d5de939905c1c613a3ee05d0bf367d114c36133c59bf3d05069d645 f2016f88b68403d8b551d1bf7909f94a36b3670136045e16433780f437377c6e ff91ae488072fbdaf979bf17942704515618a2d58e3c839e0594d66e141c15fa 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 true +check_ring_signature 71bf293a1925fd492e5ff951c887728cb3d07a36e61254d57efa552ecb2418e6 930abaf4dbec1c734e95cd715a777e57a958592392789fb006b8b215e78cd1df 13 439ce137dec56e8d700dd49cd1a9e85cc7c58b06700cc3bf5e42ec31200b5baf a8590d1ad54f058820e11ac8ea4e59d97f1f5f4d5d3eb768ecc683181a603145 4178c5b63e955bda25404c40f05211c0ea80cd1b0d285589d2cbc590e1534e06 9c3011c5be6a6759337be0a625bd8780f3833b248d9ee3f5a3812e35944cdaae b049ebc63a40e8db88be3d63242da515f980e2d6cd5049fe60b3395d2087ad37 828cfe56ef3ecf540135c736d1c65c42b0bc943bc341ad56342018a6fca64888 85cc8c9196e11d5f5ed60e7ec4bc6be3ae8d4b239621a0ad177ab8ecb2943456 dfd093f5f50c3738e03a2e98c48ce7362bab55fa8eccb654012cb0c5ca99b267 32495961c0613d25fbb456b0046d0f0d866d8e7008fb368b1ffa1a007ca38056 529ab2cbf91b1a9d62b785a29d405234634a8cb31ac20e935468542f3cfe12cc 0f8faeeb08db9a9ed516c99b63a2a946f0e6d289f1bd4491f5087b1df1fc45cb 7087a48aa13354a9c87160791259627af885c7f3f0e4e38a43480409c855c8ed aa63f5fe66ebf8c38a186a153d1ebec9f5d3a2f577f42f3e88f9a5013d7aa989 1ad6a2636a3d9fdb7c3e121f3e925bb8d6d0fe888a8be7bc6a7d5ef0d68808005f91f4d03dfcfc5cba20bfaf3dcdaae11f55865ba30f129262dc58cb0870d1029d5a2ffcc156042db1ce1f8e9a4d889803fef00412d92136df30143f65d16b01c75deaae3e859f0af5b0cd2152cb8a0aaba049148322f62dc6694f7d31632306ae4086b3842c5204ff07761ea19f81015edf7fd88c5fc06dcd2caa345f1b9c00be110ca67838a9825ff69460811ef1fc7603493db3988ded0660748c872cac53c27493301b2336d8bd7d1139b747021d9749a9dc347d82990d2621cb24eaaf0909b6d543f29ce101c6de9c8b23b2b914a927429d525eeb6d267251ea594285062d5894133d516706ffd7afc4f624edc051a5bf4e7fbe8c1f680b2d2e22f0b60c96e78cfcdb293eb9324c9d5d696f80929d0bfbaf05cd6059c7d75e6a6ff2920967cc5470d09ee51be419e945e3c80c380d98e586fd8d5b24755b674339f9452d6b10fd1aa18187a3da0ce54e42dad26233a870578a35996e9aadc8a3562d8608a6c9c99be62a045dd6ce3244cc0dff9dbf110ae912a8f4d2b2c8bfe1c7ee4d0e26384f2a86f624ec1823feb59ec50f9d383fb6321dca1bed1fe32f280e9768028e93aaa96b5f2451c92448c128ebc71a2c04f7a60361a0de2d8d0f95eb0c380cba8376bccee6957652c32123fcd5528082c22b21ca54045b32e8eb2f8b64bb0c49c854e58f2cea4698c23268fc108cfcb3043959b8e2e638a85fcf3031662203594f32d87b20fc97b521614bdc7f2c74a5f7fc065db3e6ab6687763755330d07141e4a081fc7b378c3fdba152185b68219d09b3a3a58fd6971fbd15defca5b0a472d339cdf62089c36ad445021bbd2781e12f90462460f5b725397655fa02707690b42d3c0c76823e87a53ae01c4e32791b2d8199c5210cad00d1fa3bdd2620673b0f3ea4d7a1b8597fcae6b235e5070e81a030cebda195232a44e276d939502031600506053cbddadb44eb3597a38da235c76da0f3b855f3040341b8135470ed89cccac908f51116e5a8ec2832cf10bff86d2b2caa31cdd850477265caa91087403fc371c37639ce1a823db3785b3864b6dd24ee2be8468ea28b44e3fc86c06a5de803bafbe4644569249981b6f653f7482f460d22406588c8377d3e04c3e02 false +check_ring_signature b4c821980b30fad9ecbc63eb168121e97b1ea91cf65bf0a506139fabae5f0c5f 6725c06ce8890fa6f1c0e1d5b7a84274b8293ba47435c274ab00faa57f196387 12 20fc5a0dfc5b9e91333cadf13650211516be9a46f0e519229ca0d97c4bd1c7db 62e090a5a981a524234d3237405fb7ce16324a4011985d54c7d1980a44b94aa6 91ad4c9d120751965f8e8a019e2ec51d51da158ef10c6e6a5a301e4d3eed9711 3cbc866fc6e42a4cc06a598f254666fed09a6c502d93e6273a59ebd18084415a cd78de1d2a2adb29277529aba6f17dba036a2214c5e182d719a11643653e4d48 d417d1fb64440855a02e52be524667c70984876de3f534b3ca1720542ba11f3c 36c2944a4986779d15be326a3605bc44a75ebfba1efcd8bc6b752e536bee2183 08b75a5c54fd1dc9262221bf3fe59cdd8861e988ba55146b1175bf271a165116 ccc52226528282959124514e494c2fb68210683af786515860800dfecdc6efab 07586d009c96911abf3b031c5f517a6d9d78b15e7a0835c85de2f76a4b441b7b c360766466f150fbbdbd41bb1f60e193602ea3effad660d53129222ec3667cb2 e6bcea713bcfa155935a1c9b033d9c7666c5cad0b601aeb043f812a417a068ff 05fb171d324b9fe483feff7b9bf04dfbc5fe72309cb038190fe1010f19b41b07a514149581ce9ac8fd96f474ae9f74f9a4a67ef4ae01e8bbc762502548986e0f6f56c0335c4484608227caf3cb5ca282694967c3eaf6713d1ade4420edd4a5008f35570fd1cde55c431138eaba1eaab4ef0ae43729b90ae16e1061d97bc8970e881f36a3a94bc867c90d61026a8b7bae8c80c546fca4e54a07152400428c8107cbd7fe2246c563fcf836880dd5aa544d850647ec810d92f5814ac2e40044330f31f1f4ca6b726fa21665181c3793b0df6578c221e76ca9fcd206bcdb992bb70b94c3b2cd9be3eaaa57289234ac205f27f015154da810f707590f2af8a99f4707e54bc208bb29fb26d39240a9860b87bdb6e38b5d517e30cd620709e69f75a10fd22a45c7a0b0b3fc5c97437e2f80712da7375e65bc522266ad79c12e9bf16100aebfb51a5e328c84377ef750cdca15b01ca2e8e79f549393b26dbe023c5a3b08d5e9c83062aae8ebe5de2a917bf5e82bb51121d171713e371ffd288659b30905c81631e98b123eb7e1c07c15eb22004ca803f8d571fd621b3b6636c494ca2e0fc85236559921597ffe7e7eaf1b045f0009dfa4d2157263847ebaf8d572a0340c98bbd1fc11b9cf44151538f2de5ed09374e89e45793f4be613dd95c8ffc2540a76f1fe76393b09cb5f5c8d79c87684eff5f326a730d285adeb8847ae19240909e620540a12b9f6f30830aeda50ffdef860d9a83dbcb12c21bd213cb31eeb550e2d75ad2abaea50fc408c524b367bf4cb175a179271233588c11f4d9863b45e04fca1a579c33b0989e8003a9f9618896a27ff8454c1a05f3dfe215ecaf6d0e70f8ef31dbc2baa223936303d8c80c0b8c87de19e48ad3891a5f549006db438190e1d60edaaf141c613af3815b908fb5abe1bfe40f5e48b126750cfb80611f8d60330e485f2b8719cc16acdf0e592cea0b11e920f3ddee40fce0c6a75901ebb300f2209194a6e26ee64f63bdbb325ecdae60de54d676fa8ec94241e27e1f5aa8d0f9a58e46274058b415bf2bcbcad51cb9f2597f7c7feca024fd2e35a6b66aa350a false +check_ring_signature 505b67ff1b217da99325867e0b3b7750d16c52a055864cd2b70006171bf2814f c37d67c39b90dd6a5514ff4fce93caa98255693e6afbc715d98b9aabae4d2eaf 26 0bda1c54657c9ffc701a0993984094625ea74c984e322702fa1753d009437a3a 1df9c0daf7a30f45bf3ad0f8e0a222adeaa5700e1e4b439a4f9f33bbb3c39954 408f86c99b501be50c2324f5fecf0cabe7db755f7afca1dbd470a73754e6cd41 99cead7359d7911b9937b387a594887daf47bd76c75136334802c0089413ced6 a35226d2501d3e7c7271b95e03e0f80fd1b0009c466e97729bf316352bad0308 cc84ff4f2d05316908d2236fb8d83aef6c66217b6c04ecc55d4e5b3781b3cca0 98f42f07f45389729dc516320af1c776772e1aab23be726b0993c52140ed49f2 563c774bd9a10a4772ab8c37c1889d4b40509b46f8ad9351771b24cdb8805e2c a1c905212c379c5e30f24292f135aff4149ebb19dd229341729d35c4d5d2a858 c24f1d181fcdd358c1e9c87d0e489fb88c6ede53a3fdf99f539857983ed37ed8 b252481308b27721e61500d5e04ae72f2e8f4042032ffd0fdfe631e7b47e83ec 54e49d1a3617de291d0303f2442979e8e90b772cf430236d188b1e1d574cff25 2402da91f3a45476466567c8da11a08c8c58362013f9b4be941bc60fc94b8037 adc19b4b12e84a4519561be76a8a6c78b4bf81eaa3b2270263d19872350c6875 e5afff272c55e93a8dd3d66274f27314e77d0b74fe3dfe024bd721a92c3223b8 82f525ff2526d20e547f050af0cb92c9d43fee10b58c9f441b9b963027c402b1 cc26e8c249affc52f3c7cd1b30abcc1adba173f4b83e6138c726465597909eb6 3331681a599ac4bed6e7a792f4658eacf811f178dd13e853df10ccce10220633 9554b886ac0d57c271397c7baa1cbd908802ada3f52d78d832d7d81b147b9ac6 eee8c363d7e9796af2566b6fac42798d1456ce443875bc4d49bfb5d205853a77 f74237b976601d5c0568ccdb36818d72ea6847fb6456e069299044a97f7c23ee b3d59d7485611d16660d18a62b771086f831491c085669415c246c41411175a6 bca4e6ee8ace2f09a2517fcaf05be46ed93722a182612c692fa09f2e93ced4a3 5c52ed41f3d9301b2ba58ef44e19519b40f3a2d08501113d0031a0123577dd23 fd214d69ccfd7f3171d9fd2a500ea8f64ff8eab6bf2986705305b9b1fa310618 5cdc2e370749d96a7d82f368fa02e2a2d07ab3a2694be6c17e04e998075f574f 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 false +check_ring_signature 74f8255d09c0b608955b14992072cdc629248bbd73b5a6c8bec88a53052f2d5d 2f77f83f8450b4936d5e656203e45395ebc552844b5908215c35d414e095c595 15 2e618cb74fe4da196aa60e6730f59efcad6b693e3bdadbc8a612e341e6c7c18a 162c424559679d94a85de220e82a5ae86cd6ee230bc076f846759b3b0ccd7245 1a270f4fbf472df33073b5c54a0547811386ff5d214b286bf1bc728b5cf82481 5bdf6cdb82a443d06fca339e0153770b06c1242d29b9ce6602f2dd842e400fff a2656154976d5da7e1b3b3a89a5db7f455c305c1ef4a30c76d2c9e1837ef1035 2d3df66b55dd7cd343609109a946e1affaa6e8863bff250128610586017b865d b6f74c15cc7b97800e882fba4605147f6095f4ae0a5b195783d1e673140b688c ba2ed386bf63158be1a76ad15bfd9ab58ed41496784fae26531f5251729c9456 1997c70b8b36d6264e24ffe385608068e93befe6d78ca86586dc8b5b68910ea0 517590af1716a7872d59a2a21c3ad7396834c68d28d2987fc5a60b962be8b78e 6b063693fe9a93802d75d3bf2261207665c2f4de0c2e378cbb06d8a94e2a1bc8 477b0ea7ab77df330b89592ab974a9758a2b5922e7b78be53901821b00b390e0 286b0feb37df8d8631db5694572477af9ba401588fcc0aa572612056937f95d0 824fe7a8ccee94dab34dd2d68dacbdef721162bec976c7cc2f0dac319998edf8 3794f9754f1bb7ad09252b3562ab9ede8c2201d4e86db50cb803002ef070964e addf0d57794709ca3a0dcb02d06024a4761e6ef3fd9c1fa39b756bc0cabc5f090f858a71ec098fb1898fa6e77946d1c2774c842feda570ba4e41365208a25709b0450484d8cd0504a61ebfdccbd99f86c5cadf834c04ed3bcaf1c416aa537a0db55a2ea3954f9eff25ad2c5c534e9ce24aa030d28bc10dec9723ce890a3ecf07193351c8e05562fe2c247e3ec8c07db18d11b8e4ac97ed7ba961d279f41ee503171c43a6c1e85c5c17b56cbbe8bb7b6484082d850537ea761b0062966d98260bde15214bc5a73a121a0f334d78a333bc467c738646100132cb3b9badb454b70fcffaf7613b8eff2e6db5c5165d064c2e4a375ff8c473dae8208697f6dc22790968d4dc703eee2c039a95aac96eff91dd10c3b4b540dc9edd1a237895cc7dfd0cb069d33c7c59863c6f5ade87a8b15ab91387d7da4349f86a077c44914ba97a085957e3155a23a398a7f5c4469ed8932ceae5d972d3046d2ea94b98dc5f04f40a470aaeba3b1b321a7a181e1f0e2b74531c6509c10fe17c478c3f1b631d6ef6000907443ae618ce39c0279a19aa0d1cbc7159a0cf07a91a1a55a5162cc663990ee392f093a1bf65a22500b298c5aad2ea2cccfbe00fcdef30396a720516ddac05047f258115be471a55bddfe7a4b74ffdd8e7e911863220f8c06ebfafabfb880cb8c40439560aaea5641b5178d9c42996017b600188322d66028655e6e40521011abaf7b66f8da95c58fa66c79b5390686067f2e0af1438cbb24f704184958f0173762a729b735b61c985da48377498894724c2c6b36267d8030fcb8032d0870955eb9ad275961862f0fb38c5527a9f8b2bb4fb88b24188e28ebff1becfae320868dda7c73a7f10d649400600c009ee0e9375e88895b6b37a35650babaea5ace29dd78e8dcd4b684a79820358b4f8637ea254d7d407187c216d3eb150ef013e044b34db2ea6ce56022abee7d0cc5869fa7d7f13b82f005aa10ddb840fc4ea19027addfef74a6a26e743250708f7753df101361d8bcd67b51fcd3829d6eb70260ce033658ab165e65b05581752cd510515f317222d7b52135ef54a474dcb0911097d29801a9b11d1eeff5fe74077e854243dd23a1a5b8ca7c100e23fe645a0e90e875d9a464ed080f5f831ea8de3bcabe417f33cc8e9ff0f88f2cc7b8a543d370b47aa0023d1dd3fe1022b096199f09953a619c8f3a6e0f2da1e51a99dfcde7507c59fd14b390d511119683e7598e61c03ffcc2a9d4ad2e561f769b5e4e457a5031832a47f72fc3180416df697fe40fd49519d36d2da5552a5a65e8102d89a98051ba053f2935b2efd33edd28ce0d5609e0b725a4a88e2a8c782f272ff39d1ac03 false +check_ring_signature 743b9016959ebdf4af8ab42458a97c82f44e0ad97f010b81fa36dde8217045f1 cd52c1c5c83bc2e5cb014f20b9d7e4af6b2a245f76a56c71a5ecbd7ef047010f 2 60296fdaa9a4fdd6249437eb9a8436748fff00fe8a49d5184f9302ce5e0cccb3 08998cde36988a096def6b2467fd71fca707c55b479a3e8670590df0d850ae37 e2f279cb5cfd645bcde3b6c70abe1a300fc886548047d4ef83b212adaeb18f22e5681546c1c1603820d164e59c8e7ab6b1a9e18ad42db12475bd4c15ab153d0dc7fd513c3bbc9503df4bdbcd1475230ac2f9590a07795e75b126931879c4d6098f8c1a53b271976e4ab4c7c8991006b5c12db0661a8f4faa45b565ecbf75890e false +check_ring_signature beb900f7d9dc330a16629489750320c55ecdf146c2757e5693c335f7bbfd16e4 63703a55175b840a25ee53e57487ed871feddf87798aa0e04e3a4311166910f6 138 b32cf373c744562a57843c76f2e2759fd3694c7ff45c1cf9b2405e4807facd04 4bc85d36804206fd0359c476ead568f0d97ff8e868e47f7e797d7b5d834a3836 4a532f69ad830b92348c04dcddb480f48bc7886322635b0a8849a6c49a344fd2 5c0baa875c057c339a1b48a98ea296bd781620763833a710289cb2bb4411e696 4562960b17c3e4f74616813dce901ccf8af34cff81b26df64f28457594bf1d5e 8832f7282f88caa952d59444402ba3712ca3dfe539bccaccb8de9c02853857c0 de58a64de59078fe512b88818c559ba003722d9fc99d2646cfa6660c34712bc7 f304fc4e968fbf6eb3f59dcad03ac66a3574253eeb5707e8514d7329bd0eac79 3f09db26d785bb1bfd9bc49499699883bf67bfdf82357de40595b61b9729a02a 0674492c6183de9af6bcdef367986c49bc60d5be3006b16fb7dc11b2791335ef d2b5618f0ffb0d1b73ba49309b55898d8726907a5871ed9537b285d4ee8a74d7 aae3a0200e49ddd82016ab4b10fecb8b0e994f49e8a6322e9f1b473b4864001b 8d5edda975ceb3a11aa5f43465b2c90f555e52c3d811b7459a9d8996eb4997b5 cc7c858d652a4f6f9e0ef7612caea21903f348f9f2cc6220038397e6f7d8ed52 01c73e97c0a6715cd2913dce9c7f7fa767d2f087851f1a807e42e85b82a65404 30ac5b3a5ed924a2ddfa07e56cfca5e14c85f842236008bd205993c74e3b7e73 e9e6bd082d9504f349ef329fbea1c5318e36f396a6ddf5c3f3ff3f4435f6e71f 04ddda42e84a800b4f709b5a29accc5012ba8a2b73d7c8645b2680a4d827944f 62c4ddfe89c0a061ce7fe6fd31ecc11843131705c622aefbb47fd27ee9be1b58 c11466c94f30b6a8bad0ad934740c00c725e537b1550913806d1149a99ff09dd 753790343e584794f0fb3ef86da5bb9268bdce82e8dc1e84f496ea4d2329abd8 d775d46dd3e449aef42d1ca18af45bf22397c458b2e80e4375bf31e1008138ae 0e0615ef7aa40260d00a4b03db65a839d9bac476b9e98703ef655014914e20a2 43aad12b5a56cf95fcc3f2093412a54acb9198e22b619147000b90ad53f4dcc6 fcf4fb4e00a089a3dae1c7e033564d4888e9730ea01ee461334e4128e39ffb95 6555191f8f8319934fd5fd7af505026c06b4a24fbb02494ab436b6ea76728db7 df8ef21270fae21f2162515a6dfc4ff21968daf0663182b3469318b24698f958 4f84748c37150951491565da3976d54fc4cee7ed3f5c1c88a3cb2a3e9c1c2bb2 c25092075e66da1b8334a669fa45e0d957ddb758a56963b5a2cf2549f333f3c3 fd489729b14ef0e3260fe67e25754bfc557b4e6199c9688c914a5932b233023d 14b07eee705fe561b5b5709697ec8a0acbfc75abe28f6d7741ccf4ca7bde3d23 e9f3e3d3d6b36173fdae6f450116ac1a820f9d062f8c6d470af4983568f8aaa1 513bd5ab15d27f46211432efbdefa46e373f3bac23ba30eb6c06560286d174cc ef6b486e9649668157d374fb3a0c0487755976af87105f5b4bd6306eb75db156 fc53d610e6d3998fbe120bb23aa6c999ab43913a3eefec5b8a632d430e50e1c2 59a1614c8cb7277db9b05efcb572b974ad72d909776b13cfc39a73a2776b20bf 19b40882d9d781e38d523e1ccdbc7b4a92ce82073ed457dc5b60d604cff116a8 f67c4a348065c57773ae525fd72696440d2efbb1ad38b7b4e61d34cd1742dab6 01c1578ba92a0f68d6ae349b544665371f53bf94bcbd4d1e8fbb6eb716c81f15 2f8346d07747f8271b501b40ec7211988726c38215da822e30d48f3f738f99c0 0073dac19ae2fd04d55f3f5b04677633fa01acd999d4ce146e62f80cf0c0d37b 9f01e6aebe6f414c3ff58ddc2deebcfbdd2816b93404488c9802f9caa9253625 bcc561de4c76c5a272f0efc1f9ba0c2c2381f1b22b775ef5afd33dc0805ca539 d6dd033b75a85ef1c0d5d5aa8305f39e191b4df3d03dab8a4c545c7999990c78 b82b6bfa0598cb8b7e1d4ce780a8bbefd017b29698cddffe24ba7d74a9d520a8 7e80c8e468f95bcad72d6c94b394f4fea4a52653bba795bafa0d8c748221c337 b04bb8907a00565f12ded44b124e902334d68012988414b86cb2b2de16e9d7c7 70e06774d302cd44c9c606353d63fa2f5dd09a111e34e4933a15e3c07057a889 998f17b52606a7ab70fca825dedb3ecc7e5d263172a8512dd2d28a36868750bd 229611ac9d00eb2db19a80f87d8ab77b2d61d010399490a6084c7803fa8debef c082218046715256c771b7e3f6ab93fa5c2cd0b174d581d55efd1db5fd574a12 b39cb069fce9f0d2a6153bfc95118394e216e7c5f2c45b46fcbef9b2bb2b0670 f7b2efe41790c399803acb42275ac36febd7aadf6dcaec27cfb794bb2159328c 4c74bfa98dd2d0615bf68ecbe0f6392da7296b263a5bcb04b880d411c3592a62 a27379bd15a412432a588c71130df553756a8e9d1d7dee7eacd59318cb0b809e bc6f9410a5dd08cf8db6c7d1c51af321cd5926b5192cbe4036f9efc7a57cc079 5b93dce76d204a5f1f18e6fbf3a163c2da0ee81314178f0b36e7c498b2b9f0b5 256e8dfd95b52944b88ba930e657c2e7ecb5865d0a6c9054dc31a2c057253aef a4a21eabcaa66988eaf4e395a148bd3b6b011779b9e9afd2a5b6513befa28b92 dfd0a7ec68539b3dc6aac3c0f18fb9a773c1cc59ab14b54bffed0127c98630f3 5d6de4890f897f66e3f4572793ac3019fcd68c2c30fcae04ad675fd2d0a5b319 b9cec173e1d6f1eca524fa616daa277c04d171c153ecddcfdd77e292e61a23f2 9bc7223765b76dcbbe67967bba74819158ceafbe04f73e801a39e970399008d2 c23e9eec53bf579290513f240116bc25688b69e255c25b1b7ace02698925223c 707bb04f60ac8077085d010ebdce12527b82640831210fedd419bdc566026e12 efe340d43b68a7b23ab1c98dc3250a1be5fb0517d80d8f939a08ffe464911368 ba93985ac32316dfd73f317a1232aed3ef13a3bec888f44bf9abbd142ce7b572 97a22dfefe8d89032b8e9f881b459274c5941b8f21bdf639c9fbfe548e354ad3 28d857c07f039a2be78394873394e014345d4cbd57c861697eb8c7ecc0d79a5e 848120daceed340cac84278e54fa1b68b1458ad15391ca89ecd3a6c3a48af52a 6f1763513a2af5a784dbb53e0694b7d5db384327aa5ad26548db189134c78fbc 4199726964d11d3246543e661f30cc523167abcc6a79d9c643299c1f9bac3800 7e5f769ac9741d5de03f39b0ae88dd1d5d2c4f886e3cd68cacda955410295ffa 492ef7c5a5b5dfea306cc2714eb1c987c7b2f509904051566aeaf12ff62e2fbb a4e39d2ac7912eded77881ccc7bc88a6e27d22e0e77e0239d8a7807e1c22fe5e 8d5ad83f61916d4d34f16b0863474dc35a547dcb65f99f59cc6fcaf256977ff7 7ca41d2ccac5df184f0d79a17f65281b7826d38734b83179a7caa3ebb69064a1 4ae82af13acdb9c8734434ff75dfa68a7506b7ad701dcc5e53b80cb4a97a9f92 2f4f90e0ad5e14056ce001b51b88d6a8153f0a69851115ab0fa209afa6508ae3 0414b304dc67a67c9986b91b4cc37e02aea62da8c3cae214f57e2fe11cb5762d c2a6f00276d0cd0727a4c698ea6ce4bed6125154caa03370fbf8dd81c0c9e502 9eda01724a4a609bac0b26745dc1e78088531ca2c2fd42d76b38e30d8dd13c89 34211d76917176dbb849e47d04978a551c829c53faa1e08667d46b6024338f3b fa2dc37934df30ff297556917121bc60827d03f650b49537f31e0be8b507b759 30ff77cb476405ca882f1ca9a97e9d4f734d6994846348a49d3b4e1056575084 24e05a32326b0567095e7c6b6a85cf39e0f01d5cb096404d4b96d247e99881b4 49db7601f50ef5a34f5f90919a51647b3c9a64111f5cbf9c570baa89564b8350 cdd7353cf6d28ed2cd8ecb6e6f5864d31ad9c7652b8af2bb4213d049cdfa2176 196e68b59df935003e971ca098f0dac7c82ebfe29d6f1c45dbd2edcacab07a48 3af7aeed25ab06b9fea96b9a68683ca1742477f373bb2b808c672f3c5dc89e05 3a9a4009da2f7cf314f0428d3cc73d9adbc29ecb3858a977fe200f73de927a9b 1854f570426399929abbbe8a3078dc405d78dc508682ec5ba3172e4afc203964 5706894b72837422a7ccc3ac07928ebc17fd20ec1bf5596bcfea5be54c60db8d aad7b60951787ec1af3bcf95b02458ce4088d1e5ec1b7b937fae3812b4ba3a00 19c21bb590a224025c914da3adadca50811d31a6411d73da4d0fc2d4eb69c2e4 9aede9399b69c568821d06c7c940f0cad042662af8c5b86323dfc059e81906ee a434e9b7f2fdbe8e33dbda5490ed39003276145993fad43821756f0a2b456491 87a5e3b089225a1206fa61dd51f8bc8d6dff41610d4a3951c83bb1a15b9b5ef5 ce11692958e2fd2fbaea60bf16c4c4aa6be298080dbcf13f572dbab947eea250 e529bef50fc9e4a666e1bbd5e64edd540ac60a63b914a5293c7d0a435f9a7e35 a617922c9b97ca3c467352d97c328edf8eb54d07284d1ab63a51323fee8671f7 d4991f689d67895c7782662eb3cc21913eec7cb8a8c69e45ed5948e580fc91d5 34e3dbe12e21bf70f27aaba99c8030ab04fbda118eacaab99be2398c6f227255 f7ec4cdddaa387b3e091beabff9091fa9b63e618c6fed642b7e5c425c6e0d464 0e48f97a3862685565f72df955e6476724c79b97880204a4726421855c72cdc0 682fbdd969a6c30a7f83de217a9557701b94d81b7a0ed34da9e3c421dda4564d 3702d667768af1f222717c5c00f381d2508f9e4fde76ecc2581bfba145d5ae74 b7a90ab681987ad8c52f35fedab7ef1f72ad3e760fd3b8b0e5d932bdaf505c55 595377b462fc6297e81c6399192d78e4eb5c255f3fb14ca1cfef8801d91e91dc a8b55a83bc84561a047ee2e521f35b628b91f2ed9014b4226d0628f4d158ab57 85f2238273249ad4d7c2b91e999a286b0dbc5ad92b24c1ef6eb23c27e446d465 aa44bcfde9c423fc8aa84c2c31728e4956d810f1e673515aee9569df0442212a fdf8eb966e2ed4039b84afa6a7d138f715f1c916528ea0ed0ef900c1af87c63c b1d4c013b6d7176262fb6b8dc6c9ea119ddb3203ffb521b363e912cd932f1256 d1492710c252f218d791f3e0655c630877fad4c53670df03c95fa3eda529b3d6 fc58284a50a91a212ac1f230b0b6f0527732e8ab2070f588d3b6ef38bd5d5393 e0c220e93aa95199177b714d5ebcb299aa0266ca31ebee655fda50716db11c03 845a897faa350563815bfb47e81da4024148d133669ae5514036cb5a308e7833 b1b37add12e341ecf3e7a69bf4fc249bc80b7f46e17318550abeeaa97d524cd6 c91fb1939777283eddbb9e1a20e54371b7712b12908a9162f9fcbf8130ea0a23 23daa38b5ba26908155f8ca01c1fb59f43fb2c6c5b87c8ad64b3589551cd0dc3 3c49e7458f1db6ae793444d23acf6f2a3479c091a7dbc0276587b2064b14b17b 989a0f534d605bc1b7fabe25098dbf717f6624da175dd49317cfe0842272d7b9 3f9c826058f0cd52e702b21e5321a780e235c4c348a6c56a47ec97a9c4bd611a a5646ea67ae694e8b01208c56ffd28775b44a2a97e01d1e779ee5731b6cb0ad8 a0ca70572453ad8ab6247149e16bf36973a593599c02e5e6f864c494033631d4 83ec049f4dbdd34c3c78acee48136ad99969318e6bdc5b2fb9a6054d80ec543e 35bfbdb34d67e96d7022859ae2b47f826dbb77cb783cdc044ba59eceacdc8c94 8a4efdbb8ec2f90731f268effe25e93b0280855a8687f28a3da7b54b428f230c eb1bcc881089c8dd6a5a64cff6e038a8a2c89d727d75d6985076c98e1b0d829d 019e7d8c8078fb3cf6f978149b282c7f46895fd3fccd835facbc7467fdd864a9 d3a52457e2a96da83854ce006742163d2a417899682108f9c0bdd9cc9f2c0260 89cee9ba195ecef374c49ce914cdcdceada53c090fb83aed39a8598a47c2d7d5 1c329e3c9f66bf1b8d7f68fd83fb20ef98e0863b353e960d2998c9506d5e5660 5e4552f30f50b035ebc0c9623a7f4e67738a89c1f3f442cb07ecb76f2f2f70d4 3ed17573f6bcf71109c30c59c59d742f247628090dfcbc58d64ecbba6f86313a 16fdee58fa6d3d9e383f34b06d3f39b6b5480df70d843c0a5369ac48df6544aa f79e24d569736d912881d3b42572eafb7f3f0099ee71d256b3bac7f90efdfe87 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 true +check_ring_signature d9b378f98ec39f5fbe1b0805b104d338f187c9f87ec526bbd1b360dcb5910ce6 3df1acdf409943c78cdfacc524d786dae1b68a6a918f3f945cd94b498cf2a613 6 e70fff5532a1b5f0fc2ad9692054688146590752300f78ec46cb266534b4449c 7da13b7bef0ff397c3bf1ac4a629dbb68df7b9cb6cc266952e4299302bb96ee5 d8cd62163c49dd0fd017ecad7cc8f2d60adcdc89343a58fe80c3c5168578eceb 8f4e405b89174971c9b1ac15035ec490d56affd36373c7143690e98291f0b3c0 4da97a6be171c59f0a9f65ccbe338c60cc3901cbd84048dc8daaba80162e0431 8d794075830472f1967dad67e8e8b8725347208c7a0be028243308b2a6bd7051 c263845044be04b3df6059b8af15e45426756367447d500466671f6415a47b00704c2bb0c556b2809d1834cd1710adc1bb7e48ed87cd2250df3b0f60cd088601c8720289efb306eccdb524cb6fd951314793b88503183ef8c43088dfa7412103115fe79d9fff4ca2017d21a43ba77e3cd95e27a4c2dff15535642b01d0476a0037da20b397bd4ba949664a300f3aa9b3b21d805a9478e2485c215ff433440604270ca66c2555491202076510470458c671c7be40ee784a5a93c4b9bd6681ad075fd312f236da9d577a35165d9d294499bb9c75c868a790d284b59973472d3a0c08f18e2eefc9165bce78aee7a50925989c691014534a8254b0592c9c37cf110abe3f687f420e6bf7f38650929864853cebbeb1ffe16073f3d97ba538450b4800dabac9354009f5d805045c74fa3664d7098e29549588d924772c28fe6b29980cdeec627c000805cffaa334607782b2ad739d45e24c42164a0fc2b6c74dffec0c725ccf25f26923b03d185a84897371cf4776e4d69c480f42a1c37de21b2eba0b true +check_ring_signature 33e4339cad4154f05ef0d8e6b0f29fa50d1455051231546f474be865b8a64d98 0f443ea5c59dc6133e34999bf48604d1ceb07d5da8f981572eb152846476bb09 7 21542e5ebaea58b2c0564aec4c360163a7dbaf8b506e358310e1c54e7207047a ad57d850281b3667635e74f6ce07de10abafa5baef53ad15ab5e2be80959aec7 68897729a636f3ae80ab8ce6bf356d31a4c4ae3c6be51c684cc4972a6a44e952 38fc391516550b545a4f6491bc877a171ad9a3bbd5510902cc54c2657546e1f6 819d9b8c1c285a5159acb11104b28b0f0abeb120379e5481dc4d3d3909bb6a7b 6afe922c9ed69fd498dc2631dd8937e7fc5ebd24f2b144fc8cd5afd9885110d6 bba7e4262985129a981966530588319282b6341ffe4e5417672be9f77688974c aee76ea1dccd4630b8a7ea1649168fff067aad93236bcfbd77e2160983626406feb16b48e742867600fc6d4bc9810628d5dc53e8a19fedde893a610fe5235604f9b05aee47fb2230fcba8d723c04939d102d28ba2baef55c0b804ffe61f73908521f91c276c41ea99a4307a9d0f56def4cddd6de8d6feb5c5a2e0a71a5a6e5065aea4f2777e7bb2b6677e609b5264ac1edd0f41a881a011ee6d30ac643b4266ae768ec80503370f47754e2ffe6bd62cca88a70632c96204e0f0855b5fa22240783ac5770fea5bd89dda2b8d06e63362d9b427c4aeb9089ce3f1d484e27bec403022a2f6c2d8dc9922ec6735ab59f1db643f090e99a14743051832b262a41240edc4ee4a2fbceacb3792d9eb503a46204c7969608044e4893ee6540953b889b0b22aad80385c091f060323b7e36db03a026de09b66140792ea18914d18ba05c0fe5136289d83368a13d787c6479344404b1553c0e1c88bb6edb7d39bd19f81c60b7922eba59bcdf32e93084887f4c389707db90ea5d2df9f1bbec7ba083e495073179cd9591d8c1193400c69f93c372c425bff07588df1121575cbb1d2a7b8c07b9238707a4c30ddd20607da981ef444077e0d2d013d87463d6c6915d556dd208 false +check_ring_signature 0f6ea1872ecc1b7ef907a5dee621e1b4256df8a1cd9687c842ccab2952ed38ed 5c128f8ed459db263e0b5bd9446cc48dc576af7b0e7aee852ca086a7e4160826 22 cc4af10fd6205dfa4568a57dd3bfb46b6ae4d901d2e68565d3f08f0839fb5114 b0b407c060a4b283eda77ee5131272904eb002819d4af110fae29623be3f6474 a457b8aab594b8d43f52ebb6ca0c4ac9f248cfffda213bd43c50c2e777c1f546 6f1b3ec251308ff83741f6d5c3f1b89d2555fe345a940d75a4ed08fc7f0ee87f 3e807b70baded0adcfe8d90de3aa9d42159006b24c9ee7994289f370dca011ae 94e24f32f1e8c7db1839292791d06ca9741f2b34e9498cc58d30d1301f443501 63ffb73588486e4234c2355dbfe62b1a5f032bb096e510ce8ed2c50248003b96 031e71759e878780f61f216104ad8bf08713fd326183283ddee86fe53685a775 3f3823baa311dc9d4c6a7fc67360c7cee69c80ef6f1e16292fae976506fd0093 ef12420d89a7bc99e31c4be5ce18eafe3afa59331af01334f81efec231d55e51 482e10e35289dd65d3141e09420a38744c19d9b9395c48769829c645f30bb73f 3b04c28cf067b90e4def92370785349aef58efc6055e0dab5db6f8ca40d5bae7 08fe44181284a473ad74f4ed4911799afe3147569ae74bcfd14f1565450653ea 44b4e0a40f7f61f79d20c947080a26d72dddcd03dc777a7ebfaf0ade7f71134d fc0bb5a8fbb541b3543e94767945e9412e45cd0b493c97a58f22c42872f1327c 4529083fad0044d65efd8715e697d6ad34ec9e817f1fb297caaafc6bb4ad9372 703ac5d7eae49e50569e3b5e4211adb837bad1863e5d4cba01ec3cc96af6741c 16ba7bd75c1b67ed059f3574f8ce03399a66a2e56fcefdf81aa01d9dc338c074 0d5903bb98a2ba7709e08663d6ad46225a1f9de87a9f5bd4d04334c6a0a1ac1c e7996065ceeb6f08e56fde49ed8da8d24053ce9a8629882fbe22e7a6f76a7f81 1f9236f13b73d6263d7966346af5f04b359d5edd833f517d20bce7ed72a7fc53 6e9d88ec10792774d15eb9054915229c4f8e455d73f5e64c6af83b62bc49719b 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 true +check_ring_signature 59e3dcf28498e1614e96b6f30f0203169c14cd8106dbc5a63eeea50300c7ecbf 615220bfb5c911b7e41c63421e4d6ff4475a66fe8b905d09fce1c631609dabf4 1 ff70fb1d5f1071a26d389d2401d21122f910daa7a5c4bd7fc13d1e7541579251 398ee72663cd5816dd919e54364344314ae55d7290b8175fbe4736ce93dd6d06c4bf83f1365611971e2137a31e965315a9bb1974816e4df8fecd8d995f4a000d true +check_ring_signature 1f4811f7d9f2a2585ead325d65dea6c8be19c6514c9ed94db973c24dda855bd5 bf53f2505f7296d622cc9747c99874a1fbfd27b30af5fa01f08bf0f4fca1a310 187 a81e3d5d7d6d12a4220d62e4bc64c7699fc8361e942b451f168cca9c265f56fe 58962983f753fcc6c153644962c5d73ad8fd4b30511d90c7ff1314615de542b3 c5ef5cbab07211bca6cbb23cc9eb165af2a3a5c2f076171aec205478849e8084 beb509ae74203595a691aab9dd43f70faedf318f9becaf55b2b71b61b52fae23 065a741d24434e45771a72eff61036f13ad5891703a50043bd19607a6a0e7295 ef78e5c4f3a754b4a67027029b179d9ff7eab92045b747c97be0abda72912c84 d226effcaf2a1cf81115278bd8fad0ace65ec4e2d973e41d5a50892f72e608bb 5cbe891a23cd6e33decf900ff7acfbe61c64c49b096680a4efbb75ef39cf385c 2e5ef1e1011df212b44916d99a4efef39bd4293ea5c53c67498667ddc4e3f2ec 00c62f4115b127709502737f2d12feeceec5c1def263d0a92c1957dcf8948132 abb6dae4e9909b95f95c83359fb92dfee06bd9e671759e677bca243b91b0ee46 143de49552c239637d717410e39bf6ad099dabc1925c48ddb395595a2be069ed a0f67ee6ab9b7124394475cf44d31c8d860e29c9750877fb761320eecfda6689 676c19bfc5311ebadd9d9c964ff252aa622fbd991b0fbc667c7a87ccda0e1c8f 59a75c1700928838785fe9cd0acf85d7325d20d666cdb468500a25e40a8ea268 00ca1fc954fd65c0d6d392673cde025f0e97298780c2c52f73b4459fc7c7854b c2e7b2c3dbded7fd806158dc9e618716fe18efbb158dfda979d55133e2e122c6 dcc8a7d26c4363da933a1471dd07286faa3b12c18096c58928099622a4ec39bf 978cdd1b0415665eb569a0267696ada48ece5e65c7c0eea08aa40e1154ff7aec 1fb46df3c66a6addc83f42bde07d844418fdcb3f9bed782f44a443a58c9bc0de 8f7a5118a45ab3bdc7f2b0ad26fb02ddbd0c7ae47a1a049f742c9192d88c759b dbca6f1236fb2ce0288f10f2bef3300cadb1d959d84718c6e30f842dde542094 88e8f4385a69fc5a74010a066a22be1578330143f2fe732f7ad86288112ee60c 44f2114734c7edac1fe3f32ffb20776a59bbf66fb245f98e07004c5b9b0d2bfe 37e5c8f6de49455e6fa1a73f0b718e54cf963c7a8991faf64f59d6900b5074af ffa2549108696c25eb16cb9e82a584bf86ba37afd9cbbdf252cb60952210a39c 6218b931e839f9abb849640b565c74b0e4343cbea2a49a326464a4a4dbefb1cc 71872e635809e479b9b82e181fa283b98db0faef9fd7b2ee5fd72e46d964241d 6fde1744683df0c1f4cfebe25e1f7e29268b2a0a482c8241e9a8bcba4a9324d3 dd51d845e665ebf6f8b928d3e106cb327108b2a2fa30949b4a7674ecfbe21e5a 27e3498052d7cadc463b5e17e9353fcc9996ef2834b9ef36f6ef137cd4455e64 adb85f7bb7f0f22833bc9895fef7f1ca034b76d7eeb2c21284edb283a9a3fe78 11838bbc2cb3206ba946a07684ebdf95d7913ac654996596206c500bc8cf31f0 4b9038c3ded33ef1f8a6516274d273f2731fe34a9cabefea8894164690da3680 698b1698f2cc543a2929a0a421c028c5d6b82b02305e6798796ea1e2a9745c77 e4b54dafa874fa79e951391737ad7a9e8c7dce11ed491b5b302c611624282d7a 62387b0ef87636ce8baab7d4886577ca744faab80e4f09c623476ea6328a6116 9e208630a7d113c73d124421c7c5454ce9ed0312419e7722d59f3a83187f774b 0acf4c4b6d1f83a44b60a5c9d214358fc7ce9493b83e3eb1a68a7abaacb1d831 12efc1b4c345d2cfcdc6a9e843c4b5b2a0b127e1acdccaf05ceff30a4d97970d bf457b2cc4b61d36b8a74077434db37186893f7180b1e58c496744e62e6bfd2c 1876330beace287b42082da440fb19bd5b52bbd24002ff64880f75e295f17d67 ae57a650d00971a8d87e2d36195a4fa043093c16032c3dff6944698940a516e1 b8bb2fbcc4606ee146c975b566938570ea7217e71a16f1009fdc672274aa8503 32fd85747b4cbd320bf460e1104568e58f15d7a7c60d0866db7b767e6f89c4b7 158d72d34a8b9526a00c920ffdffe5f177ca7377a4f3daf2e99f604df6303b78 0bc115e41ffa925c82aff0d59f5c58d8e50f36cf95ed803a6bd5a54495fd0b64 57a02569cdee5171ed3405930ea001332e5b3d0a5bbd85a6874f5678b6b0a813 471736f90ab2cfd07888e322d51b65daf7cf5e723da7cd0c1ae6c7594b2fdae1 a2c19444af0f260373335eeb50566daefd4e3bf4deb43b64795436c79032220c 641a91c14c5fb9e90f05c3cd4ce9e8758b5d28399887eef4bc7d2ad708c8566b 1672fb1ba356feaebdff9a7f108011b7f6c6cc54e107647c6a35cebb6f5894c8 41330d4d47c110612d253b6ff0b353c4af0af1e5dd6a6eea1a9b968e4a330448 2a439ea8abd33df3f0ba76f82fe50c636e3125e3d76917b8aca7fc8b3cfedd29 8aa09ff826afcde898b46a5f218855fbceafd3e6128ff618f99e7804a842c099 2c87e3a0ccb9e8a80f0fb38a2c5c6a1454e41d40142920a2a27d4923b0ca77db f79dfd6b13a6b29e3d54512a1b412ceb67d7d896a18fba6b319272e8dea048cc 5dd9a071be462707c49bfe33126a1d3e76e2a863afaadca34372e1043347cb5f 498ed7378b3cfd9010651d2d9ac6d06ada8781e8580be41eaf2f8d9c709b25c0 2a0bed203d8386dca7eecc6c18cdaea0f94c67eb450cd8f8e06b2d336bbfb224 c12d2e263c8aaf92acab080e7e3455fe9e324a47bc2d8585022b4b590afbeb64 7f60d2556caa2305ee8b37cc3d5b4fadda71f278cf5dca71107214099017cf85 64ab21d52aa35f1fe21a7177dbb248908f6fa274f148f0c110dd4e292487f98d 493bff46cbcfbe7efe0c404f103e44d030fd832024cbef22a71f27e05d9b7b2b 6107ae6831ed1697f0a4899c56fa1d117059978918dc0fc49ce9ac23ebf0d994 dedce38639ff34073eed209a7ae5716cea934c796754815260418a17680ae7c1 ac000546570ddfaeb903ac2508116f3801caca124d7faa31a6fbfc67c39207b4 4b6f52ca904cf3bdb4023437bf4a58338fe6434374dbda9f43784fa45e91fb4c b11c293494d677e4aec9f56e9da55cd628102a309cc58f46653c9e4c03cf79c5 94be4c04ebbe738286e28e259211e49a949f644396700f24896a8ced469e8f69 076687c8e26c686ac8c0df54037d6a644046bd491d34666a7e6902132b613bfc a118909da9ed5dd3a05b6e331f7b32eb0cf282abad036d936baa639ab4186267 c88c7c109b846f3d444b6245ef128ce10533014bf7a21ec855d921002de4bac3 9d845f90970e8035ca6c063bd6a63eaff2e87713a702fff7cf3d3df8dbe9c8e1 7930580148727ff9ced9d3189e8bc1e158df79216fa515e1b4883f59ffb8d9cb 80232af287fb1fd338a85f3ca7a2f822f55b357976d53dfda8fe0f931ba6ecab 02b8027a3a0a42a1e7683ab0869b1f35d6ccb0268db6eb1e90585c2e8b404671 30aa832f718a13156821c8d0a2d17066454f8b267b5bd9fe08654a7689b98298 7894bb312ee46aa7a3f5d84ae9ee06479993de0d6b4c1efade478908ebd63cf8 e995137a8d05fd04a9eeaf91b257f9684db14556b268b043137acbc99630899a 55a9f9da057626dab6bee33e3915365a390654c225f2cf2d26aeff4a3e31671e 3940719401b6aa30d484715759640074511ae565fcefa29e61e92f1904a32c02 ff74580377f8e6aa800584d0b5eb0617d8ec4c9e14babae34e6ae1d926ff5b89 f8315a1936799fedba28a74aada7ac453058aab9e3e2b5675495ab4fcc83a6fa 47f40a354859a9836b57736b3248cb46f6c01599796487fd4823b73242262ef2 5383a39ce159bfa29cfd04b26a5baddbafb7200eb38d6d7ec8cb4be9f16bd7e1 8c3676e4f47a3c7a81daa9e523efa5e8dc9c746f0733041f7d867ce2e36563c4 f84b7be7915acac1f8c06fb14f9e9190354429c7729c0ae8428178bf7f4e6107 b5221cf0dff1632e4ef69453b995ca53c121d2d7cc553468ad146bd1c9bbea06 50e76331d0a47fe66c1eb92f28676e3b3fa59f7d03eb5819d47a9480c8813c15 1b9eb0c9767f67b96f71c084e36798e3fa5116805a29fbb54f9b6567a778b37c 16e8195152c5346e573b392b3be1b5f306279491740ebcf63a9e950caefe9bb5 bb28375628245578e3b8d444cb21baa712fbe614fc4ecad8041abf3d60ecfc32 fbd6e611c71ba929090f611cb45965c517ad9eb6c6960955d065b1e9bb7f7737 5dc055eb960008f10f6bb8e9f9bb07b157aa5c52bde095518902889965735693 30f5f9cf77bc85fdf853320d4c136e6c6e490358ee36e26cbc60b3b486c29a34 f7d0aaea22f868bad4bb6e4c3fd0bdfd387ba6e63a3d969939c6f1bb6946c5a9 91891e9fe084baf620b64309a0470ab43973e8c1faaaeaf61720c64713b56f7b 42080faf8b7cc1a82e309882354c62c6481bd33d5b5e31946e997bbc953bfd6e 73f98ed1b23262abfbb41dee10f59a1bd0612892f35b3bb065461a8144d0ec2a e0d4f2da81242e2d852fa972322ae2a3957545467f9b841bda6b9b72fcce3906 d0045198cb0a34fcf6ce7993b939df0ea14aa466febfe38cfa0b13c71ae87726 37a46b32888686d4881b59ede91bce31f0a9d6eda17c5037efb39fe0aa1b4c8d 2be2e74cd4109a24f493f6039f0699165d5201fdbf7b57b5cc2766caf39ecf4b fdea9b04e7e32b7275b5e5ec567653054ee30d7183750298808eb5d4ea99e2ca d34a42af563a890c4e5d08fa2f28b3a5931e70f8b72bd6dc380c71b72d21c9af d2d8f4f42f70d3c792606246e83d97982e5da15aaf7c14a0828d817bee1f4dbc 76a3e530abd9c5da99e571dac8f4a9c643ce104762efcd402a25a37b3808446e d599464f22ec75de8b6bd7111dd263ffc92c7ea5de85460ffb09a8bbc9a3385b c618e0729c59ca44088b82e3d57c60fa375b553324d068f528c70d611d3d645c 30df121dc89e9880d0bb716b5e6ad4e865f684825eb59a91d5a5ab05a1890be4 20451d1368ac5d305fdfabd6cf34a4b01d62be4418835910cc320faaad80cf4d fb947300ba362156dbaaa81c2fa4558f4389fb50edb5c3d61ece79db447defb5 4e917ac1e7f9e6f5715dc09b7f586f1cedb7d4ea1bb7eaba6baa4efdae01d5e5 f7b97e964e4fddc89524cf41f6198bf9c54678a377b6646e923150c419b63573 cf4d56f2256c9582f403e75c677fe8e3562a4995ed135b41b6f51ab900fe3f1b ebda9db9737b1068d9e460fd5f80d0803fa513b69fcab7a1c934ffc42a123358 95feffe9fad0637ed98c574d3ddf5e82b6997b0fb7e4f8976c82021cf8447945 2cc8435f867c5edcceb1a511e9b71e1068efb84df489a242c9b4c504ff1d8b20 dd16a066821c4d4ed2ce355e0dc0b8ba4182366b188bcb9df690051ec428cc29 a4e49b864a85be313abb0a3c98a1d327f4f9c4befe902d7283067191eca90744 193b7bae7d994380c87d6c3ce8631fa4cbd0af02977405f17a289a3b127c7490 33ed9015dbaea1f9cf41645b79086b2e7a8ed64665ad160c23c60e929bcebde7 8d5603f8ae840815512e3f911e3a60e360846ee70f389f8545eae5a690a5f711 4bbf1861a273ad04ca19956389d9468251a6fb134e3679bf593f95e28ed5e227 2a25c313a4d8bde0f1cf51db91f47855147cef735fe8ae0ca402b5595621a5a1 fd1073caecf757eb2843b8b6ddfbc104f92a9995e00e238c29e634190adcd385 6da58071a57b68793f8f2d7d8a100df5754a3c999588481bb8bcea505ae7b51f e40082cb23b3cb00293b6ace968e80566e89af38ae5efc0e2e188c0664b52974 1c0d2e82ac56f470e56b2f6c3ed93adf11e09d60e8eb1e04190eb495ac9def3b 4d4bf8fa42fad36cf5f4fa3e6cbc85ce648b575c8e3a71a5149a2214b820182d 9f15df7b757818364914e37dc2334c6d3a890acbe8f09c25c0ea4222864982d9 4f83658cc4751a9804d1fb45d2ceaf92839add8311a3c32f77f46b9f7a36d363 144522c1aad24ceacbf56bb62df164adac321effe9f2d8503922c857bd3ddb86 0b60c005962177b6c6a4c5598fe5af6478376a6e4b2c121378b1a191d234b6ab b00e0d88c3edd6df52ed894968b6ee88e8acf85a6e71b00247df0d0fb95e21ab 69f8dee6d8185bc8883f39af4e9695d194bc8648794edfb788e2d669e464b64d d8c9c3d80941418db537ff66e8565d2c485487e1ced5d37971e8b5bc525fd5c2 ee2600a552dd8dc3dc446b675b432411edbecdc3d7d89e58b29661fec50efb07 bb58d378260584b5d8db3889751d8d5fd1c94afe2c2c5b64e2f22e3fe1566188 a8cfbef5194e1555db2354d49e14e63bd00caa96bbec45bed9b3515a49854a03 5528effcd7205ee73fdc0285cab598a7cc46e56dd5943e4523c8567664d9b577 1a81084425b4f039931ed57cced8678c32f068b4f1355bf10659aad23ba8f7d4 27fd5aed9b16ac1aa93a59708ccb376409ecbe4bfaccb69d2df4bca0c32432f9 8658944635ec3d7f96bacbaaf48c5782a78246a76fdfb8c48f04b24f85554286 49c1f6c14061053c4dd5464ad1839adfd4fc4835d93fe1d770139713741f49ec 91b9e761396f5cfa40aedadaddf48ad262feb0b4a6d20e9138b36abcb9af9604 43164e8d068f62dfe242cf651e5dd4420e1538805704b25a11b59418715c6b16 96883546b23f4e0e61abf504b408f0737d207c96be4e80afeacc86fbbf065081 384a7205b31f966fecabe561a81746d768effc6b330ad0fb5ecbd4753f367d12 72403aa68161df0e9c6c2a27c4d8ab02554ff3e5a0a4e8dde191e78c292eaabe 8e10af199ec9029475752948f7b49f0737a8398ca190f2bcf73d704094ec11c9 2d126eb36a38ab64f3cf84014874fb62711a723ea8ab39bdef529f2372a168b3 57bdcee0c618c5028fa2f4fe349290bb2bd4457c9e42dbe8d75c7dd4b469e1cc 78256417020d017381fe03dce4eda6ff9cef413b53b71d645765ab97703f0e92 6a74b3861bb621860e3876aa34d85777dd4dec6d04ec7c3c6f3191d823e061d8 f7d9638cfbaabe1a44a1d37b809f28aafcb5ad949e3ef898d37a1cee8e80d801 12f11335e31264cbb4b1c2276151fcdb6a06f16c49a58f508f3ae606d3cb9701 fd5516e0707378052cc8aed88c0c43abf0c62b971ca1f1b71eb446d05cda1a6d e343be94cc17e0c548caf20a6a20070f0c259338a91de9b8bbd7610cfb4d65ed f8390adc48a2be7eea498b1060b6d264c11d8c66243594f40eef26aac96e8da1 86f5b2ce25a4e3e639bc8b89788e91e3f7902bab59d5ce18d99aae1b2b4ed952 23257e23b618869b1b6209da4914f884abd0af494a58e8b4899bd0738616197f 330bd335f86968c3e3854c2d0e4e2ca25b449102fbbc98f603f2d1abe1650ce5 9160de498c4cf22ba92967bf655fe2d27b9f5970f45f4648e71826ed35c7b33d 7e8e206890b1ed26afc8d622c06958509bf55f4df14f765732a18944e182ea3f 293af774a40a417acf4b99696c94004fd522d469f15f63e88d2307da54002ee9 595d146fb7ae2ff82112f78b0ef05495b59012b5cdaabf71058a4111d04617b3 501aad7830362ab73d843fcb32be652c56aa6cfe80bd65cab9899fdb2ca31138 f1213011ecc07c4a6a1482ed00ad9ba8fe09ea16522784cd63d7a14927705a93 84aa0bf0d80453bedcc47140e336bfa67956e9fcaa887235fbd5eb41685bc062 7c9415e24cce6eb0a4aec7328914d0f950bdc6314378898d6a52785e0a945ac4 ba152ffd9b4d46f4a7b7a3ca135411174d3d53fbba2a61d2a2af608355ece7ed 802eb9032a81dbf06b4ef4e0adfc730e220020f26d83edc1eb75601fcae61f93 f61f204d5bea2e7be2de392bbe088836cb681149f14fd683dda5a0121e80d339 f4a6fbb4974eb758b7430057e8f8bb344ed9a4e53a44e2a076175d2493349bd3 b15cb31c86a7bf6e14b265c2b194c235a9dc40b1ac205e4d5adff4f04de7a791 a62db04983e50080ff8d55b3735e804470ff682e41b5160b3b87046593197255 4496afc569e0125c18b55b648ac726c90189fb737e1758c9ef787451bf332950 229792ca29b00b7f1d681d1fde90df5b60d8adb28828197c83404a315367c8c5 cc5f0e45265cd20028a439183c7f0d39ed099d181976cdc3dac0781a8d57deec d9841047daafdc460edcb40ec8c79ba83455aa8ba26b2c633049381acb2ab924 c1130e6b24d2b4b0baad27daabc2e00d01a7a613f5ae0b9b38ee95f929e286fd f103657a61d4d0a61dfa370888885630a39244f0ab4b517d51e54c3608cb0701 01f74871357d5d55a650c5a366f7bcdc645bb09188555d27f4af478257ae0a2d 15b0e13b301c6b16cf7ff5580749b1a3ee2c965a0887b4088141fe7840b9a153 7e3aa0764b8114bf53d9004b152c36f19e02da4b11e330add6e1d2b1d2817dfe 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 false +check_ring_signature b3f2caecb6abc30037fb1252f8d2c789b8cdfd96c37f0748bfc094b130ae348c 7c72b31ab3a96a3daa36d9038e2ce280835561447903251611a8767a9dcf6bcf 8 0f8f4cddd684b7b26eb2d682a913e9f952ffd202566df752446324a22b7f5929 6fcc8450d1aa843e26e86ad53c40ced5f560271fa09308e59a38d5ebf3f51e0e ba12bc283153691a60e3cf7edda48e228bf22226b460c2451a31597b0556efef 48dd2f12accb4bffb4a03955ade7e4c3ae2e786dffe193836c60c4a490dc1a9a 371a518670bbec00cbf3bee8e7f54fe5027b90f0d720db5b5f8b2ee615f65e0e 0d0709f1152c48d760bcbded025ce4cf06c8a4c268f45529c9d461ade21fe5b0 a81fda1b46c23c665f2cd94a784fdcd4667a2782f434991db519711fc116653a cfe0123505eccafba5a7b24e70acd4845ee5b16f06d04a255454f8452d05977d e83043ae2b76760ad5f48276d2cb0ba47cdab0f6917a7480dffa3f2b3577c40b4d051d3e6ebedf8f60bfaeeb4ffb4aaba81f6540fe4ee2514d50362e2be1f10cd6d9a38789ef9e2af62592eb730e725dabdc7215ed2b8f75a2af63a75967f50ecc67832906ec92dad26f26638eac01d237a085d846873afa312421e4a1141a0f88a5b87ad66bef5effbd848cdb85f63aefa87949d080f5adfc4099a55533340336b5aa84020a10e3f3613b3e102b36b90bf02275c154add6d7161787a6f16704dc67bb0cab596202305a6e0d9f5f152ac07c8d3ce6ce4976064633e05d0be90e631f1ddc28bd3a31d399b20ec2b3f5ff5305592570b51108bd3c9cc8bb4456022be422914c37ed32ef1d7aa228538a7e60bd872d2ec03c4c6179451f36811c06d27c383e4fe74f7da5ba50ba9735af80ceb20f69fe2062c980c3ef2b3dcac1029b8878e27dac4c34186a6a747cd7877632e5afa41e04ef7a41c1a0b2ad46e8010e41ccb2c2f81616b5a4b0873bb5ec127948141689c961bb8e1b425be4d1700afa0a9e2ed5a9540fbaeb78e80fc4348e2a9922a887279dd86ea12aa27e030604a3660b573d24146a94e82fa20a5030bda2750dd6218582e42bd29f3142efda068c8d9e59ad175e3b0b59c43b37432d16dd211e633fe5188ede7938b87a985300f362b8c6501f363defb4bf8e968554410d9d4f4734cb9f6241721f43f281ca07 false +check_ring_signature 85c8acf4daf26d41126e99594cd8ae6c5052c1db5e875999250a9fe0c9cbfc0e 81aadf32a80bf365586fbfda7ec1b63b49995a03e492e3c43a313f22b4ac198f 1 8ab345ee63cacac45b043210a46b52718a574cf055cb87bd77ee6043f9558bc1 ecaa4141bf22bf839687e76a39acbe4a36b8622ed5d44cd3291933b0a5a5b708da394213a4d45e86a0ee76a9ff4d466661b7334b0d9c44199d539b57a401685d false +check_ring_signature b5684af1884fd704b1d0829a876e7c476bde89e064cc28be12607efd9d859859 7de278c6138b336944b71196c53b8ef0e5a7c28bb6325eb2fd53a0de78f1c915 12 a7a9e866cee16f3158e00a1e65130b488addd54272314715d60ffc351e70c7df b3f44b82a167a8689a87d26e04b0c45c2baf62f3251a662f4d546d9f981fcb9d 82b91331a61cd341cca6eb71b58ddf48bf05b20a9a174481ee10494d9824815d ac02e6831a3e37ed954f097ef8f3e14992b81d09dda1106a169142e140e00f4d 21e54364bc73f1b1779f828c288987bce0253299ffafde66f9ad531ac35a06c5 3bc38510c646e521d90d01e8d59b51d23a155a4fb2819e837b8865bcb4bda85e 3cdeba0d1073e7222d6fad9acd0d0a3734eedfe32bbeebc6e2d2242b2d522f5e 47b719dd54a61f99b33eb9ef4f5cea49a23dc9935d843d3aea1d323570d75773 0c55d6f27ec652fdbdbceb42e1233dc3052702af913ac2685244bcad90917674 ddf901a11ef274b1bfabc4e03e9f31088932bad0f02b162e86842197589a03e6 6c098e8ecb124817004d511d134e42384fe7aee86ca8a09aa303e4dbb940113e c5465baa7194b07c12d6417bedfb0c5b0a68e9389277bcf81df6aee03264e276 a6139163f38772563dcd3b08232455493674126fc29bae0e6ef5a8d294ecdc0450d9b5a3c04a10a0d3a2c272a5f407e6cb5c8e0174353cb913e40bad48eb3108e03e98741410fb7aacb2227e475d4e1abfbf9f34d7533cb1c58df2f85603bb0f4772f130c499a22e9dd9cb07eb70c0e347c24a2330227fe97ce42b43ead0bf0ae67ae8ca4e42b81405b4fab5b396ccbd1e501780b3fe596a2498b353f515640b622cf2aba27e4504433550c8374b5b7671a68996758d0a08217a325bc3235b0a58b36e7713388a249bbbe8eb0fbfaa53fd9d0f82278a79f88be732d4dd28fc01671e231bc2c9019cb00739119ae2ab596cf5fa31ddc94eb5ed69644788edd00a79cf33fb2db76c3c933b5964156721e613b0c780e752217cbfecd4331c90ad071ea607310afd157b8995b3c69de7f950a5e5c7c1bfd5082447bed19951778206aab914414f85be83d307394aae5e60628559ca43b940bf7fb426bda3054b8d08aecbb8fffd557e26c7957be3560d8816fa143ea011b47f6524c0fc65d258ac0d0884460f1acc92eac6945cc7530ed2ad42546752a61539de35354836f6025a059855d2d592c5b47efe640c6da35598443f66286fc1d25402490759f397e6240fcfd7c05f280062c6460c5c254d446836738c6fe38d10ad18ac07a79cd3b77202b5c22e333d2d4aa5c151bcfb2ec214edfb135d775b2917c99e54a08de792ef0e25650d52d1f0110434883975b251167bdfba053650d8d8f7a5dc0ab513d3b70c6ee719bcf806732fd22e5fd718bb59e89d4bae8fa28bd8e4ec9238641e13db086c0163f4e4e77a294a010f477f9cf2af7a2bb7f7118f29d0a0b81b6772cb860e2c6816bb4aaafaa02d27e5f177be189423c2f19b8d3da2183c040ac9c995d80b37b7afe195873aee9e80c8218b9e23dacbb92a46845d12bef08d07f3c3d1a000776df6fa994ddb2e045cbb5ca3b74d5fd53d0f36fcc96ea635d1c789ad170c05748bc89db46b168970f594bedcbb86461cb693ae8b0f8d93f24f7e8ecdff4709c4616634f7efcd02ca4e4b7e94aa92e309f4ee2cd87de8dd85ecb97b1289fd0b false +check_ring_signature ad9702ee554d8405c8159ce21a54cddaa76764c16bc44da26b6cd278deac3145 f3d141eb3b03803723bb8f71b6130628795be958bb32a039e56fd42a68080dec 7 7579b434e187ffc1938d64ded25f50307f38c6c5279b8654d0896668dd865a10 58083a92fdb01e861e5088940118c1a44b93c60d87feb81c4cbb48aff9c56694 18f289d1d328c7098b3a0dc440bd0139d5b265e01327e1a10ea850998505832c d6654bcc38744c81ea256c4f17452f4e4bf5a136afe61324746ebc12839bc055 005ee962110f418965f4bbf670ce409df289a440cd9ff3cbd11c345b8a9621af 0c004ccc27cb3aaf0330b06d05705a351a6d5a15653581bebf38be7244bba30e 344fe7194637cd7ddf3946940eb18f906b8b19044f64d0f3bbf355e6d689f46e 829ee9db5094f04313927f3c4024a85607389f48bb801efa2d34f8656fd62d04455bb2e74405fe7f44ed398e8d607b4eeaecae12846217063f5e8e0db3092202d719baf36b15c6facc82f565a229051ec5c0d437c06dc4b46947689c8e4a3107e5f9c73cd38ae38321eb33ca8c948707948c5f735ae93888da2ee8a5b4a2430071587bb8915d4c5d18beaa004ce30b14e790903be22a7cf827da4b7b225e0c059863fda5f0f67219b8bbb153e5e4ee35d75323de33a9a0da37cccccd79516f04261c4e4a1c4e31b6ef0b7b61409466fe7a0b23ea6b352517b0ac086b5336000f96d58f530c78b325f5f9912146353d04bb93c6d9495649d3c9ba3fe9dff45e03bbc27dd684f3622b92e5006dc08079f2e6edbca121d2b06ea637f3a6342b230ce3a60ed47332fb5dd4863f48cbd3a70eefcae57d3080c2f32d996402802ae30a7dbc23f69e74057228e5a6a98cee60d09955d98bbb2fd742d9ac60bbd98c4e04641d4d27b231be17d8a5a97d17fe5eb2a4c2e0d737e2456c0a661b5aaa695208856c4230114d2fd35ac62759b5562e8e692e096a280766098eef7a8e724a870b5af33193a00b978124c3e580486396db8b015cebe1fb5866c8c886662e97fd0a false +check_ring_signature 7dc7bf04d107025ae3e0404b041292277711778426e28e201064e62dd5b0d68c 7160fdd25917d884b0569587cdea9ac82c4fce8518c554db55a1c31cae1a0a72 93 36c2063844f871307dd3dfdceef8c5a2d442667645c7c44a8a34c01cd81dcfdd 098abd9c8af0ee673f8ab6afdf115d1567e876e84a046422189446fe0634b74f c0942c02a1b6c84f8dd5b7a7b243344c2dcc147fe57a2c2d52db37140eb7c839 381da8e2434b1961f05bff165beed208ac749e4240e94bf1e9613cf4a574b4a3 13ac0fb33143559f978fd03d17054b17d9bd8833e05bb352e60b614eaf16ee13 38ea081a8a26f16f63c1390f15c0cd8c3c9f0f05cd98d30ba238862e609bf2f5 f560f3ebfbaba4a3f6076c29aabb5cd550d2765373ced04f432b5fdf4ccce0e0 6d8be6e488914e11ae229b19a64c8180cf156556aab07caf610f954d67d72c37 80093ea95ce05d5ea920692e07ae7869dfdef5e5c76846d6f30483cb29dd873d f9a945efdc25d099955fe2f3963e529d43183d5d035eee120f363320fba23fad 6a27534325e5099594bd2cd98d7004be7073d30429b539dbfc166b2d09128d8b ebf3b6d61a536f2f5d336140162c2a2d6ab3759cfaa0b65e822cd744542c2796 eb66e1d7e34a530bfd30c6231c5718937baaaa3b50899d0a4219db7118d2da43 51498f3be7fa7654a1e398272e3ddb5eb4d7a3293a169c273b53d9714161ef25 e380051c0571a821f1b29ab8981aa05190b60f1c2c9d959e312974ab35bca085 d099f571f952a545f126a33cf8e36dd7e7b482120d62bbe1d762a24ed2a1f605 d26ecedd243247e71ef996a52d2d5f19731aeec4cd84fa50dbf526ac7e8cd1bf a55dccd0145f4cb75fbf75eb3318ac0332783830e79060a92e188061168de060 1270e431a6b9628dafe96716122e66cd0065bf8d50eb7812fb9c53fcd9c52b1c 4fceb8d5bf61bdb0325dfe7ff626d2dc122afe52e2465c1473ba2e9d1d53f645 a79962309900e491d57e3dec306ed49e02615032249f05c1426694803f72912d d694032bdfa74d23a30525b8e06bf343123f845965f1947cf0855eb2c202992d ef6fbbeae2a90d8703bcadc0204b2a10a86e9720c50c0bf4494cef44b5b4b5aa b93bbf09993a0c87bacdace55a44e80fa559822736d535850c6ce6cd34675adb 2a2596bcadb5401afbd5b88f54de93d03922eed29d4ce9864a77a01da43e3537 91a5e59df92af0e933470d2b1d8fc785def2986033945e3cb97e0a66bc8aec65 447785c070e8c12707b38c5e71f51d65af897b04d42ca909131b6b6602fcc0ff 70e5c6b8271ca694ec950412e75749f312608999b037731c12603feedecf6df7 a5bf35b7b9457ac196f7c0f96f7bd085b5dee354413f726444e3779eee1f7f61 e00952f5488595fdfed73adc42b57a81514ac488e066fb62df685941745c958c b9f45a741ac7c5bafb86104615e153ccd872dfb09226b517b617eba9f97e4f0c 7fca19356e4b8b77e6ecbcccb38356300ba5858a0be0e3516fa3cc91186cabf3 77a2aaec538673e1e33087b69ce98fa3941978356f22217658b7a5c974e53f48 0dccf1118a7854808a74c9872d2551b5b9185eb831c1da6921cf2ba4f3b81fbe fbf264fff16b267de6955d91ac7a3a8146e6044db4d50b1ebae996370850ef4b 0e367dee178caec5e056eac560523b5dde63803db036e5af2b11377493e5ae3d 0b6aabb26f72b40a4837fc5b8e2628e16f13a106fb5b9f1ac59886d162397385 8173c0649b5a945555bbf56b1ca937ef3d3af292a36d9f33c2a66a295f9ab2dd 31345ba05c6915bd00e08367978a89b47978e1b6c1312085efb8d0aff7d7d918 a429fa86bfa95573cbdb9251028b772bb4ec319e75d085b6d582c4ea24a19e15 0223417101af94a4fb0176ecaa1680de48ef95665a5facfbb8ab8b9276bb3b7a 2e1d005d89ebfd4d8831aa842c524bbb655ec7d42fd185458fa865941d4d6b5a 027cec21650b7eedc47e0dbaa40584e639614451d471f3828827982f1a951b00 62286b3d4cb8a25ce2ced1f6888457e9ba81fba4dcc3c83a58a4e2a12bcc294d 65171b4d1e9811650329f07c40dcf6c93d75671d1a3c63e7d8701d3475702f3a afbc3107a8c986029f2e87df94f5ca7ccc00c0caee6af420b614b89b3f2becb2 7e1a9fdf4107613be8a64a79deddd449edb188be4dd5e60c8fc788596b0a0272 8d9759f7eaf4eedaf5ed795e00cbc1e5c9b84a106ff5ca504cbdfd2912bce5b0 c7f969d04eb5c7a476a74d03723685b485532d4c2a0e67a67e114c0ef46a02ec 4abd4f41ca0d4616d4397445611895bfdb3d1779b8914a3e3cc9e6a895e6adc4 69b316df39b188d9195df4dfe4f31194a1f09f8212847d238ef77c471b800cc0 bab05d117f045719758f1c5d709d3c519769f9dfaecadcfb2a278ba6a7bf8c35 38be27cf960fe6ca57a9db82ff420f145ccf01d835e0a2d33dd551cf23d3a964 6477e8190d46c1aee6fd62ea12efd793b58b4fd6c096a90a52d3e66db2b6ecf1 b445c019771a6f467bc43d5653f77047d672585d3ca52d13676cefa30af9837d f17c5d331b87baac43bc20ec7b6a3f746731bcff210e4d94254f9db6ac4c11e2 f97881bc6af359b7879fb4c4fabd603aaa50f3bbd24f742493ef1d05a71391ea c9cdaa0fe3b2b7cf6b9c6e8da19ab0c5462f56fc2045c766ef55b865c279d289 9ab98fe953749823dd12f4b324bc2b7f9a6990ef4b0d93c7a6caae021472198f 28d4657a7f0dd40d1f75bdd21144388d2e4c4d19ed0220e61480d66761c6ae01 a297f1c41c20cb99d1b4dcf9c450e3789bba204435ae4a5d6ba4a906356d5daa aebbfd74b9585bca8b1380c31f5953a0c8c69a315802a88fd37bc5eb5c55daeb 6132a7fca480553cc95819e48dbaaabbf3292981d10c98762e5e2a4da8de5563 2632b0330769236b67bdecaae3bcb7465f02da8bcfd2cad56e2d9745ebf22623 1ba74672e682a7f95e62d40d8b5619b2663b7e52f42cd03e58e3f57b01f94c9d 2810d984612f7a3cda042e6a8314a04e293cfdafe80e45ed0ffd302a6faf1fbe cb345e606ba51fc8dc451eac0cf791dbbd9ef55f1f5fb4efa07b4a89e1d05c60 0973f493594144bafb2ed818ac679a95cb66c75555f54bfb352882e43c94ec5e b67128e36309269c777e961bd31fb1c3d1ab56cc45cbba12201e4dcd260a6634 af0a5d1adffb467ddaddd021d35ac2e77503eff4a6016529b67f424d09ccf1cd 4f846118e6edb1e09de74502a5c925cb3a66934561c2187353634a0ee1582d3c 7d18ea87bd353dec8df027b0ea71dd205255a4e1b8ce8340b2164d50b0e29a9f 67fa253b12438322f774baa667e12c1c6f6c4e1a6b8edc68b8a7e933eb62adb0 ba6b45ef2a087923106070b807e4115c55c02f0b9ac3532fc5c639bec88f013c 9df4ff21a83ec4a852a13fb02ed964dcdbd6d0c9f292ed17195ee3376135c1f5 2f5344830744c2fdc359edf63621dd5a066dd8e6a8ee98096afdfaf49ae503c9 3297e75843c328e3f55e99c080d6f58be95b19a765182e23f584a8419be1f58c 22aaa014c34c223e3ea28c1d454938ac03fb6cdc94e1ce1b507b2b5711fcd9f0 f4805fcd5a0aa383cb1f782f9ce64783bbf9bf98b2e206914f6346924da93974 a4818c1d174100770c4a90e31f2536a2c99987ea7f515a7548e1a9fe2b6de704 748239a378dcaa05cb1e17b5d7ecc3dae8300fa7fd320ce4540124153500bc1f e0cdde02e168269ab6e7d4edf52bb41e084e8a8a4d6b2ba05d9333525e5aa8fa 3909e18b61daaef264eecb2246eacef78c3dfc4666647b62b3d7d3e3b8585f58 33046481ffbc427560358918a7572f7f2054a2504e2931509e304fffb81cfb24 b0a4371e8b19eec15e309d813ad3a8154b7f65eaab6a83c6f63749fb3080be6d cc5dcde1bc875108b2947d6b607187aa098de60ce855ef35d6ee7f3fc0309f68 b17038741dd89fc9dd4b6f5945f13d0cebcb2ae5eb5b99b825f93fde55f7b287 9e26c1a2ea69b60a05ad76807cf23ee2d82a890f796d0740b5e91f01330b29c3 a25ad6e8ba8cb4e0e404fa2717cf989d6e61a1ec65d4e266d57a6436ec357ca7 b1f7a89dbe15cdc2e14a2566f00209ebf44dcf8f802182380a3af74a24aec140 f6f312b9f834ebfd80ac24a979f974e208d37499375d50d90f23cff9114a3faa 3dbe8926a01e17575fb66f2ef1bdf745683ad2eb46ce1186e38b80c4220011a2 d9301b524ecf540d63aed208a89f41e1cee0ca1fe86419f5091ff2f6ae6dbf4a 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 false +check_ring_signature 1e7f3b6d17dd430d3a397c89985a3b0635ccf955a0353579902c07cec0202158 d319ea0255e029fe12e5cd4b89dae49e02881574962b2ce26101954ca712f59e 1 bd5c9dcc32de5a102cfe92c8b313a3a3eb59b111619fac1727d2ddc8df06b03d 8d0ff83602e677d6f27882ba15a3fc60f968754379588aae44c660ed9e94eb0a88fb4416740ff30c1770e9b32ad24086a195fa77047a6439a9dcf28a23d3d80c true +check_ring_signature 2963e0836b18177632b47b4253f81c3903cb6e46348d9502a6e8acc05f8ef389 5340ab106d58fbe6dfe669ffacf012320141c44ee466e5996cf6e868a2ed189d 211 c68512846fe1c64ad23346161adc677320675482d43899dfb03c85802d3dc7a9 00164e9c593c0c778ff35d5c70f7f6a3c941555c010569071d2278e604ecba5f b58c192f03336235839f2777354edc4441c0514451b000585730f8c2c99f6923 bfc4fe11571070b88a86f2b84cfdcbfe94a7dcfcc8dbe33b56e07de81186a69d 220b2841f183e4ee5d4fac9c86d89576b977242a9b4d4a38522402e20ea3d6ec ed8d5e26a4e74924d3c65f4897bb6d8072da246eacb0d9ca8cac3bf167468f8f 886ae84a8ae667cb43873481bdc7a95dac10fe5ac7ffe9eb3f0b36b6a5e5349d c22d86f669df2dcd73f7595513fb9e42cea506e9d4b46c661756e9fa00d30766 e4ed2d11ecd2e909ef1540d87b69ec109b2dd42db090cb8255d61ed52c9eb4f8 08bd2f86d1481fd10a95f2dc101c62a85de0baee43d235fb7fc9f05d3b472ad9 e0fd64a24f6d273c54920467c3cf5afead283616b8f17c533d20f0a7f90d8879 b999e1e410fe51d8440ac65c3d71bd8b742e234384664dc3f2e64da1634d0c39 a0a383bfac4464e1c96fec843e6f55284c1aea368b5a699137673ffd2cc3f421 0af8a0f076686073f4a4d47e0fa3c5efd43c68283cc036536232be060bf1dcd5 061bcce641cf99848a34bf1f961774fadfdbead32f6da2d99f8fb5d8fe4ca26e 90ef2b0bfa3902dce71c53eb98bfbd1bb5f6a7d993c158c5b6a6ceeb7182ad58 c307c7b36ea65bba2879dd4c32504c822999736c487974bc194860a7e622593a e9a1b58daf578876aace024704c6832b29d5c2540c57445a98edae74faab7a61 694b3baafa7f04776ba1afc26332998a64f3c1bf0b7c1536b76e43aadac99234 8525ac0d7521dbd854fd20b7aa8fd0248636fc9b60fb3512c01692d585ad8045 7c9df615253068644e7a4bf84bc6eea903fc9ea5c8c10d7bbd7148395eb93916 0048a717476148387d780f2a3991501985d9e3e79c5a68290ee450a1cb9585a2 c3642475b313d4750ad8c94b0099e4abffc837ec45d41468843bfa163bc10df6 be0879dd045bb96c96fcfb9496858903371a526f790c992434182e3a11807ef4 7a9c0e76524c15e3b53a016bad7110d5f03287e8b7577a43d4329e1c90b88b79 c96a87ce45465485af58bc23c6972b49e77adb8f98f4ef941d48dfa7184bec2e ac5560a5687ac3735578da1ebc81da654b86d526b8c03cb996a677541b0f4a5f 346c7b99563389a20e080729ca720dbc4958cc2abbbef054c1ebbf6256070c04 8da294ce76bcf2ef87ccc4bf40507727feaf24b70861d28147e220a12c774a75 3e42e859049336c7ceebd2d167fb1c4055cdc7f5ead1bc1c1914585fbb280715 a23871d49b80e391da3b55d0a0aa58262bb7fb14b809be3b289cb080c4e02ea9 551d38a76b6dcda8145c82713ae1683aae14e4b354ebeb5a95cb21ccc4ced744 768088d8b1452f7a83855da26e934022a4f238fe352ac35c58fd8eb72397fc91 81141df2e7ca91b284c8857e0556de378de945e92391ec649991d88b3ff6eabf bfe288708f82231e13a051ad0a215fb3b7c149557e9726e6f42eb14b146ea8e3 58e5ab3b4d1c71bde8e7e7284e8d6c15976012f5f7446204b44235ebb10fd135 bbd53e5db76a67caaf0b0cdcc51b24907ac4abed9dcd6581683943f00dd2893b 21f0a68cbb21b9ffdff9224c23ef355cbbe6aef1c1118c307dffec9114eb0241 976329832a11cc072c176d58bad960a62aa692094e2f0e8a49f3a59a375a9419 09a1adefb0e79835ae57c953d9821138f0c6c59ce86401a012b1a5d3add48612 37ad6f8d9d5f91b0fbf086fa87c02e1f110fad1f2b2d388a4d610209bd375e1b f9d38482b80986fff4db15e6e9143dba84cda17a546f2728d638bbd4f9e06863 44875446f3bf8f4b2b36ba5acf8cffc8afc60ff0ea0534c1e3c328f0c0524cdb 762910b2851d96b86c313e153e7ca063d9fc7a3ee64ff777926fc37bf28cbc9a 7059b0aeb0968ff2f9dcfbc249844a9acd620a2f5fd31eaffd45ad038d29a0ad 82cc75d2ac96b17d48800dc9b303de1d9e6b5d17c210cb99aeb34932412f8118 c3ca460cf83380d6583e775c652adff2bb38f2503fbb9736849cce418a2221c1 2f137c6e5dc2ca5319aa20f41b850960513dabc7f924ecfc469bc4c400b19a60 576ba933abf23743ada800e340b38d88d45e413e770032ff0f21fc4734e0c533 0262d2d79cbb87f62497b50d973247bc880410486329b9f7326bdc18d71e90a7 1e46e64adbd4f35eaef0098d7d5adbc7a9c46b2689a3b88539a536ee4e9a45c2 e13b62d101f2e0c5b768c13094720d7766a3442dcdddbef7a94c7ceca5e0dd03 502568317019cdf5f5cc465201a838345f6838032fa084c621031ac9d22c46f3 22536cd298c0f37abb389158659cbc32ebb11c6b53fad6c98caa6bf4fc8b6eb9 6e5d0f28a15d900d5645fc28c5ff2854ce28391dd79cab04e2a48e7d1e197e01 dec2c565467cce4dd3fdad91d2ee8a47ff02a6128f8fcf32ff4e44d52a79bfe1 8db35296114ed07d47dbc48344c3e4e8fa0e811b4adb8e134dcfe400a14e27a7 2f1cb8e8a7ca3b9d3746fc585f2a283f142c6f990b44d5454793d2650ab93d62 9385bfa35ff32d3d5cb2c75ae810d04e221e8b001f4d0ed82c4d18b68a3040d5 8c6b28e4699c83c8b7f55bf1a6077e13b9b32e1c3150b3e983101aad4e30857b 090755cf08df13bc1815afe1acbd2eec9712b63f647fbcf2210194402fb1ac8b 9df57202f377d18da02960bdb32835ddc23e518e9044fb852bba02af7b28c701 7499424a8a15a1e1c7944aee6d21e4adde8ca7ad8eb60e01ed718b7f9663efee b15b9128861dba5493e7d5168a52a3aad8918665eae505c91e1bb061c68a928d 68f2d0d94e535e85622dfdedda4ef5498aa389a05b99122d842edffe9c668b0d 9249ce6228b3f85fda086941a8f83b307a1d9e7b51da2eab009799bbf0c21b82 28b81ba6c8e0bcb5b098f0fe72739361abd219918524cae8615bc680fcc71263 f00428d1993fe6df4c1fa673a8ea65f400a573b492750eb49775f8106528f771 3064993881bf9fdfa4de6673807d4dc94bbc2a4ab1e223efe4c72e1ba365210c 0218efabfa9ebdf564652b4a9b7c6dbefbd5e490e97eee1e97ee3790bef2305d 0c1fb80cdda0e621258171d89c32ed33901e0a6b3677c468a258c0cfde397fef d8faffa942907e1eb1f4d05549981aea55bbf3726c8411472d5df7db2e476e74 ccb431a88d3a4c241bde9f1cca471eb8bd6399226a06e5fa0ee35a0fb260bcd1 0672142b7bb210525ab123266e415d36081122b4f3ee7147865ca927602ca4c3 8ab5f0811d0f498e8b89dc0e5397dc9e820f158a522095266f0114faf715e5b1 9d52321fb5179d08ab8876897f8f288ca7ba3650bf313bf8609541dbec747f28 a0162cd769ac471adfd4a361018d95582e0ee6eaddeda380b567c1be61d1cf37 d98b37bbece38d0d7c4675f06921f955efae0d43b010edaa7029d7a90a5d4cca b84aac404a7f8c3245dd6a8148cef55671cc6177beda8795fd839def6b6be9ab b6fcc84cdc45dbe61df3aa1d15ed32735cc0f540158f5c7e2dbc6f959bee46ca 4beeac3373ccc7fa7be52bda3cce518ac0b965e5da81845eedb1bb886c118a62 c64ec28f58c9be73fe7f2d54cecd57e1b18c6af47376ec1217a0a37febdf1a80 e2c771bc89d4fe8abbd1486b400389548e7db6fe58c0a2a10f10ddeb1764eb5a 7d46ca96ef16d9ec48e2241f5de896d4ad2f0f4d2eb572a933171c85be441aaa 2ee8a57061d0266a9a498656e289202713f0af2d6206fc9c33e8298896bcfeed bfaf7dd5e43a7e89b72cc0b4ad8417cbb92c51bfdbe459c6d32894ce84235107 933082fa83d6a79f18808d32a7b1cb24678d8ad89f6cc95d8a9daf92c7d54a53 ddaa96e97e05e91656dcc31eac2624a49e804f67a9214c0f3d21c198efbdf77e 01428c7f54146a1170e8139aaafc0394425e151842e038555b5a5b05e8b6c0f6 23f561e78a7600d45ae2dc33816b0b14acd98c0d0509dc5b845aba076716a51d ff19074fb5832d3e745f4937af3dafece77e7c73481e0edd94c15ba2038a7c12 79784306b8e3d05b48c9985b9ddccf1595bb038345573b89111fdfbf00890c49 3fbe56afc607dc1c6fb4010ad3999efd9dd4335033387cb379318f9c8f37b82a db267437649cd49cdb3a84d280dcec6cd095d25e19ee9a1940905800d169f79a 69cbcd3c53f47a2c6c90739ae49ae230f8accb521ffd784dc9c5a422f9b488dd 38f84a0518085c641d173e938535d2989a9cd62065e5f179cf2b6e13c3c85da7 8d307f0d2ef6ed714f68bb4bd066f220e7e7697fbc0da4235af8f6aa3b2a69a4 0010552657e75773fabfb9a19010fbce010f37f1acea9ab1bac0758efa776386 62944b63aa71f64dac251bf8d717c9ee01939a8edde74904189d7843173961cc 7cec5895e916edef5a16dceb34302ef46887ae0e45723593b54763cbbb1cc9db 44a2351de86ad4dcafab2086e21fe546e08700d6790435d7bb25433a97e954da 22396a4658c09b90de09fa1084518c65f0e6f09f4968453a0e01b9b135dc393f 7d80c9867caf37b963500da17523f34daa184c91bd36df2e88396e8bc9e3c37d 93d59589e58ce42710642c770412ffe70fba1cdbfddf273f505d199c9fe737d7 1e4957b8b394fd806b0b92515059e4e329c1332079ab8cb492ea776989b731cc 207e4f037b353054b902e01e9b3510df16a34ff00797e46c796ae3ebfe816bbb eab20647a9ad255d4096d900722b5aafb74817b34ab02ef1f29d2f58e549adaf 0262bcb44012dad9691c89b6d6363cfe07393b0962852b682b706e42dd57466b 77c46603cc151a44792861db2cdec00706799602c3dbda36fbdb82aed9beef14 77926ab79ab3d80948a3688fb06573c09f17c1e2b414c05fe598c574d6f7cdb7 99c4b8e10cb5efd8f538d45eb187a9c620ac73172907197ece10b0cd69f62427 049f711a5b8c4d70e39ffaa13af9e4361d4236b40a1ba4509e2f05d55ee315e6 b253045669271ff1757e49f694488ef694d40b4b9c007eed9f8f485f75310613 60ab4607c9bbad250505f43b082e4b03fb823a90564002bea49f43949f3adc22 132e1cb1668488a05f2ddcd821a426e2658236dc5e8d9a4bd4c8c3aa89faebd5 82be79d4d1a32313816e3cfe61dbd916d0bd71eb1ec1ef3a572f92ac3a4dca54 fb506fb508fc93025e1ce001245bf3705b5464c5276eb8e56a7d5081515b1f88 31a7c27eafc70b690e91afd46c1ac7914ea996ebeda68ccf671dd867c9355a9c d114bd0d5aa2c760163fd9718b9f820c23a41c14c7ad02daec2c876c8073b8de 7f2b5445cdc3f5536345ced2cdc6915adb027b9d057ad608c8aac327c29b20ba a1b8a9c5d2f2d116e646771229b551588da08a14f08359437cf7ba34a9a935b3 f42c5551ad4daea25b2954ca744c6d0252fe07ef6d0ac1914c1a498c36cac58b b5a2d7aafb34c21ab5cd22fcec1f25aa8eba2c1d7f5658c71f450c6140e77c58 960999a26b68fac352256a1258d87b153105aa97387c42612af6b6db4158af7d 8d1094b4c9967c8b69337e138541b262b56219e6147845376a30daa9f990a841 487130eb93cced7ddf7cf99a532517877a781bc0b27c5dd861f2515d335a6b52 18d650c8014498134151efbfa89c335980c6f48c9601af495957c5ee29ff8844 722f27dde4045d09f1d713a480e475ecea2b59f08f5765da9aa495309f1a8e4b 735f8c45423bbe7add306cc2a76fcb2d5cfea6aacf33171e880c6e26af1f9750 9c0a52e1fa541300eebfb087429eb57aec996ca339e71786d814270acf8dfe58 b5e4f5c2953a9e6c00ff6ab510336b92851b79c5f1450780793e013a05e57c62 38f0b496927afbb5a7a20784a4972ea0d7ac6241ed198de0e8f75396433a8db9 6b0ae3e67d84a17aa67059acfe35abebb09f85f3aee93f95884c9bd508be3733 a9a5c92ea8bfe5de14ac9aaaa357ce0ac8327e90b742028d75e0e8e83803cc8d 2d99c618d73fcbadb5df31b595b64621fc06444dc6b834e568657eb72fe6d4b7 051eab3505c92406bc8df96652c273e683ddff6a63e2d8f2792ab0e5ae305637 50786d2915b139579fd748aa04fd03607209a2605cf1f774a6c00fe8989b6627 21e2c96c082f755bebd42b6ffc21d3176983bf0b7116a4e46d23d14978afea50 554e3c593a5e7d9f4874782e445aaf83759adf000ad51ef912a64bcd786f1689 eeacd5b1875e105d828fcbbd2680613aa01e2fef11776ef3b2321675cd4e019a 76b12dd5e8dbc20c4ace7d4193b2d7af356b6ac625d6d13d03ecf9cf367cae0e f0398fa23f8ffc121d12616bf40e1976ca7358fb392f4356129de902c835140a 72c7f5a516cb4bee044c9d83fdffc879b6e9c3c0505d287d06e0f8ca44b06017 0c259829ad2333279f55dfebdbdd9adf6c4d496c46994db14012d0bdbb04a727 7ca7c42eca304d9310cdfc53c08b11bf83a0e25f8163cb1f932d43825d8e4c90 429f4bcad8e649a6f004161727d933df0fcf18266dd27f8531259b07d1b96841 1732e63bb13294d7a51819e1ef2fe9bbb61963ab007b0e5d77091bb0e8ecc78e 3d72c48cd23aa69f11077208dafa7973d50da7ab826413d2410f53d49b7d6584 27b3e7b2ee4bca29cf0479d3dc132f458d7975663f84394bdc10cb335b300e11 84fe692152d6e5d859e5684a25f5fe829c40c2bbc8573a2a655fab98a75caa78 46af56d350f1c860693fe1157050d28ce4d01e1b001a581a9d227a87dd9ddd91 2beab7d8199895f64fd8288c2815ff3b0aa5464442a702d32d1228d13ef2bfd5 59c9dd01a24799d56e85f6cbf650ac8d7ef2fec1382f7f4e76ab8d4418cd5adb 778d8f149a9ea7a5b2eb1fa36f45e14e1457980985dcf42d81c655b4e5c1395e 59a6eed4cb8306561522df1455a234f939972afc442d05a2ef1b408fca1d9554 9290969ab1706ec0dbad490958de6e98edf2c1779d36b3420fd7b029b0c14ab5 128d9133df2527d956ca9b24bd5dc976c75647f48bac2752c7bcc4df7ab5a1f8 7841f5096986ca9d8e3571fca8f8a0954d70664600bc8959e8f7e278e09b96e0 d7f55b5e3efe0811afa0721675a9a9a9a65aae6c0969547e000ade661cb098ad 5ff5ad03e8aa093ed283424ba6b4423e91debf42a43770d60be9ed6e608f02d6 79d34d76e5de9ff653ed4e87a356097ba179908c01131fb64fe0f6134e62816b c50afef45c82b63335361776a9911b01b20e9e3090bb307d1f3c841eb5a2671c 0a1ad4f68aacd9d736e2e40ef6647c35d30ab9702f00c83fec0320e061b9e78b 2b8f0d6a249dbfd1f8d6ccbe53a1241e219db1de938993f53c57838625ba9f76 cb3cfb79d40c8b1c2a539430c60f429cc49003834e0571cb0e5da21307ba4f73 b3f9e24a1fb7e750203d3f44140862f564dbed7732a7f40214ea686264045eb2 d2ec10d702c3c999c81739af30581c9920290abce7baefe7932664d53b16df78 fbebd769542ed57acda2ac24894f9f45ecaa9bec897efcac300b7bd3d4ea57aa de76c6eb858db56da75dbd59265644fb4b954e9166fff1f51ad63e0ba82ec79e 70c5ab9757e57c372533fb0d3118442439327ae2d66966d6b59013a170b107df ce6d1701c64b4a94bffc024b46df06a3ae6a103dfe713efa720fc230b99d40f0 9f751a4ccd5d4751727f7138e2223cffb006b76e4bedb03d9d4df22fda92ed2e 32061126f9607b4771f9cbf3430a247f8213e5f62de200655c91afcc11a18fa8 3553a2b32a9cd19debcbd42d1f0ba67d35a9e89dd5e8292e18095439f7ee8d69 b6ba5ff55ade8fe4813ec4fa6722ee1c2bed99678c3754df6c891260e01cf09b a8f5c6382040835164a0670571e83c97398b7ddaa5e84ee34a35dd5fc5e8ed7e 0c29f1c762c90bd16dbadfff7126acfdb372091c7734bf2e8db2bb67625d43c1 32346a80ec165fa1fc8aca8473fa92126f8909d3d41bd9d258af61b78681a1ce e1db6971b7fd3091aa881907ba6ef2bc88ca2a44039082746aaccc23067e375a 61e4ed02b4027eda5bbd667d6edf58447836b2e1b38e75685ce5b382379c2c6d 0fb4facf88ba22765187b28710bcbb0ebdc1d0e25ce13b1a92376c3dc0beb0e9 2429a8798ef30d2082f277337505bec0a92ac839bc18add1c6c7a98fca34b5f4 25a8f12d6696de52a88f645bb3b347c4e27e2f4012b8464f7de9b7f4b694dca4 ddd8dd1db96f8e1086b601416a4950d74d2ac3ba1e3c194bb2d1af1327b93a30 962232cbb8a32582ba4eb6f8a9ccc06c7d765b00e4c5b83e3040cacfb7a1e7a0 1d87c6709e0aab8427c237e8799af20b78c2f8d6bdaad96da0aa974b9fa0f32f 9e8656f7562d17ca7b5175ebbc3116fdc5e7e7a3b0e7e2fb8c27dee1c6e0694f 57242e48d2ec67757ad0e828add3fae8dce1ca8367cab6a1d3224aa316712cea 88cdb53c78f96070f653eb819fe5d485fa1ca519e06ffc3e4fbb526f03f0815a 72ece6c11dc919c8afff4b1958c1eb4629a295ed971c6ba0efc04e3731687ae0 f38373ea4f38e00f791aac3c45b40cd68cc250d78b3a41573138b8b3a2416dac 0f8b14442e021cd63336f38ecff750d5e553be68dc61486ee6a9fb13cbcacbad 1ab5fcfb2eb5fa23a4d190796bcacc1c78bd2ed95889b88fa0b1893a7ae79132 0804139c988ee130d1241a2bf9c95f766114654c7ba1a9641a626928a1e9dbb3 68af95e82b04ace27c9ce9d4011f4012b3d27f0549df209b590f13263d69237b ac4c59711ea0b514fe11de3ae0fd7cf2e8a869da15673599d68fb144c7a8d753 b77b7a8866d636aa85b576fecd1b0486528be5054d1ec31ac00a7291ceffb5b2 bbd00838a9dab4710982b24912473fb1571a4aee0e5d6c694dfe326619bf83cf a2e1b63bd69a0e441705e59502406212a60bcc47fca64b242cd5c9284ddcc13b 1c6d8c9c325932aa78ced7cdaf670374de8f441acc9b9b1bba10cefb9867728c 0466b908913b543270407e866444563dfaaa88a08d2514b1182236b8bb80a3c7 44c3e8527d00a65353654efac072f681765e94db75cb03acca969c675e7bab0b 9bc63baa8a1e7462556536a80ec67b48b5b7f5ebefa8309a8462fd81066bd432 9ce9277545475966292f8e82f14fc725689d25f2c2feb09d745bc57bc5e975a8 743f1127987b0a268b51c31dbd9a4535dc4dc05d5dadff3996f7f233f9fc07a5 3ea1eb9a3c6d6312f2aac9bf78816fcc378d96606e9e04b9e6024db640ea8a1c fb277721c9a2dc44e70ff1aa9ee06c409a9b097c6d8eba8423d59eea0de77b58 cfbc1e2fa6c16a303c983831cbf3e5bbfaa355338900956b56d8e4ae3fb8745c 9a3f89de4cb585b24b64545d3130e51750a4608a42d30f433bc6404802f8424c a49fbbdebcc097915aa669d0eb8a3748d9d3e0b082155624f3799af6d8ff801b ed86dfc1b7516531c8d7a843ae48de314bac0d47b898d9bd4c3a8604075c70fa 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 true +check_ring_signature ecd117b9cba669fa155d07fe42d13bab7c561fcc4c07c89dac85d83a36d4c3bb 5df8263ae413837d52aee51426aeab81d311cc950e50eda0831e479dabc6398c 90 846bc93eb4f19541c306f46ded1f57c4a85935a537a9643b06668c46dc1be6dd 21044116ae2744da80ed1fd9117e3ca68cfacdde262eb156e0a9c507d4056b49 a5d45fb258385ee581a0d66844f5fe1d3eb9d920d9854c00302343ce50256dfa a591e1d1bee4fb0da52440b6788feb3e5311902c4b0fc334a8d2f2e64d2db099 079cf4e82749b5d33e653b62c5ac1560ae5422ac69fb3f853d03f705233ca228 2969ea5b675ee89a0765d481ae48f0fe92e6913ec6a3bc4ecf41825c49c3c862 b13ea0c410ee533f04c2a514e2f20fbf1b85c1faef21ac2d1257df52b4fdd403 1441224516e5abe43949c036f42788b77aa404399d8895a6e22329c94489478a 7129ba11e9b5d4c0f200c7e0c1a9fe336acfbf2f8ecce5651f230c98b64674ef 432545e4cb4013b5e4d0569f3b58790823d6cc1d8dfdc5d025e4af69bb0b431a ca7743c146394bb3965b9aae6ee40ce3e46190d43e9f9b59b87e36e256f901cd 5f4471899f022431230127c00f43e83ecb0f7420bdbccca7e30c98befccae8bf 245e17d7122f167753a7263d355b4b33cd4554b98e7bf7ec70b2405002a484aa 68e83483bc1e3b5ca9d9ccfa8b4077311ac211e096667c0499d45be73d031eca e4afb453b1bd26bb3a3336e3aebf989cb6b08bd430af44978145ad0f6206a786 d556569a4e6a1a63b1c77cb4393f927c5f6c9bbd2180df3d90d9b369d98c23d0 d9b84f3ff98ae90e5b8d8121a8fd4961febe67b9ad4e4abee30979c4056aa5a7 0ff18aa5e71194c92e6fe005f3137d8926f9c8bacb3416b3e669353a83309df7 bd4fcfb7825c51dac364936c12fe6482d71fc6d43707e6864c8eca284cfac333 29a3d5e7966b2efdc51e1b0435875d2c55d90127bf9e07ba9e4eb5f756f4567d e8eb72d257106aad71a25960fcde7d55ccf857101ca17670c3ec67c7047bfcfd cc23a88265cd00c0fd73937ca3c1027d70c4671ad09fb2e780f76a1325a5334c 533bc67f525bab281aa8f5a8147a1f89e349001713f839439d6f70037ea55142 f288381df81b1e5511d0cafe7c1cff07fd5e20e767e4066fd0149929eb8e8e7e fc80b70f26cd53effd66ec84d88b5d66632bbb1903ab3fdd1b7546bb09d7e31f 1e3c239b82d1e7fbfaf1ae75d44b7151ddce9042bb5185eb9d33febdcf223e36 b0a08b4ca97467a8170a9a0bfa556becdca636fa8d012d5e73f16115b2252b85 d7c75cb2e521361a22ffeb7c8282c2457d7ac97319d93e9353e33170dd96aa7f 4db96ed8b1e603c5b67af9afd3b0d78e5fd446eb3b0a2b909dd8b896bd3a5f35 fe15476eeb260f74b284521525e606639028ae8ce5ae4429270ac29081d72a26 3b11acdd15bd3a2f4bedd4859396a7b8ac875037169658e75c2b27d7f94ac61f 5c786bab2da11e7232d7b1990289077f6659140fff9c7c93ad203c5ac68d7706 78ae2498b0116d496436dc6a0bd33b86f1326fc10be7051024cc277cf90a24a3 7059a3b573d478b06e7849dfd1041641d8552ca82d4e39cc3cc4896af6766869 70c016f18d72332b5a1a267166de7bae154cab5489fdd02cb3c226d0da5a3ca6 fb68fa7b9b0fa95bff77d52ed1e54a15bdd53394a9557c02ec749bee6a1b2296 a54226f8f88e0b2d69168339987e9ef56ad7d93af45c9e7edce1c998a9bc6b74 508a4237640a708b88b3e231d6e99960094774a3aaef9aaa381b8a76ee502750 8637b589e9b473bda5c4542f770538b58be15e6c0a3fbc1dbdfe56e997ae5a78 829125f8dd82981e7b9aa7d0ee5a1b1d281e07de78b7f8baf0cc58d42ac198be 2bcbc5a22396960eca2a0af282e60fed0f5acb68673459a0e90af34d94f6f274 dba587ff713ef45a383750d4f79acb840f34ed2f74c6d3344c2d3bccd3ef847b 116715f0f3e843062e68e52017aa0b47ea8413d9129a34af70831fa859b35ee4 bf7c461b93a705ca9b4b257cb1701f10453585b1b86bb776ac0945de65a18b20 670eb6f116e3a44d3ce961d6c75ea2c5e30647cb0132d86367537497ec8e870b 372ccacfa378470d9313c5e9cd160755f24dbc7cacc88d46985dfd5ec1fe6eff 4273e88e488329cc32a98eab80551d0d5a74b70b0996bd6988b321f565fc6f67 f47d632cbc11c0875266951a45ce0f3ae929c9707de247bdaa5b0444ea92207c 7ad7a54a5ad005a9d5d88ce51efde009d6eec0180fbc8f94565ff7bdf568a648 fcff32c154ad24a81b779e9c310e8a2fd7e5cbbf88aa1576e3f4d178e4094dc4 40d90dc913b1bf5a095caf58b21eec6c5279f79b783b7ba2b79a1c670e8a1788 76d8f28b989bbee21d73a9600f6f5015618635b5740a0cf6e301f614e872eafd ade6268c6570cf2ed6cefab774ff2ee9a18a86d48f338b86abb7c7fc3f5ce23b 88b9c8e8795c26aee9150d4997ff4ad62f161c86ce21c51741f32a0590e075d3 06ade0e368f1f8a8e2a25f475cb679ad18b2fd1efcc27857e69dbf543677906d 189e92e598194c23e712f0eb226d6ebd1cbe31e5736c978213d2b8409408c946 3be77dee4958cef85a853d881f7917c24efdc9688eaf146ac1b8b330e333add7 a067e574aff3f5a71d8fbd3b31587a09f959821a38c5910f3a75859e8189c92f cc371b1ec74cce7da1bba4d088b8bcb062b9c8a56df990402a9f0ea74e22fedf 93e57e6f11e38d725c56033dd39df67c91f86e88d4b06aed7eb459a15b4d825e d89d097bf7efe985380f68a04f70893fb9fd63c82a64ca062eca89217acb9b2c 02e07d579f2987faca7adf5e5679919b78856752ebdc13ac8330265fc33a7f91 4072b29c76b1bb1199b20ecca174d1a813f4064eb16fd6467d9ea3d9626c6616 e8f02e69629dbd4ed1e7ea8fb75c1bc577ebd9c46381d5f99092fadc29b97b81 c5813bb6cb2f63650e8e8d6565f4761be7f757ccebc09d9e2a398228e5f1c065 bb47636a3979fd4d7cc6a8701601d1ea70e06a9be32c56fc34355ca8297ae018 993520879730cf16654ba83b266232d13824fbf70b1d752b2a6f93daaee46ccc 5a1ad35e63502701024cb049acfa0045ab146c63f937c0ca3920eb6a816f07fa 711d9e8d1289d2c6170bc4db859971011256e9bc8bddcb42cada46bdaf274d1a ff1f8b7aa4a0edfba8335e614a4c159e376fe854ce46cee35672ba91739721b9 ec2674bcc1960fbbd299b2ca091888acd8db523916e1e422338642e4aa7d5788 baa8c1f9ecffdb817dee08b604041c02b0c6da5be527a9089ee985985557e79f 93c8b51698b9a896e380909d3a50c722a36ecee017250512305f68caf8d75c94 6c4da8687345230a08d257185f69215da1cc251d9de65dc70950922264b7a89c 33409f50ebf18687a91e5ea40cb247c6a1a7602028320bb5ec51871507cb68bc 26da711f063decec18b0e7ef97c69cf7a37ad970c959337c133b729c2dbcd77e c03803f85cc7494281366a65782e13b544c2aab1c724fb4bbd623ce20ca30474 8468a37bbe9a8f965f5192306a0d16e2c124c7bc0cc6b4cee1ba40a19ee95da0 7008476d37e516c71cf0721417fb7128e53895a65ccbfb022b2fb4651019afbe 2a3dc86085179c13f27f60bac0eaf6f65f67e3b49874332bcd86fff82360ff6e 192c6d5f415e17d015e21852674f1f82381fc27c8e2e60ed09bcfdcc835e4877 547f5bac8b71aa5b329a46bfc851301236b7bd8cb8f6e2f746614b6e13fb2027 c0e3c777ba99a4b2499b51efee37ca64f2df63ac08c2a2832d34c0949dc522f4 46aa86ed5904b7555931b103a66962ba8834f698144c1ec7b41e67b015ca693c e848add2aac5752b38ca72020fed13faddeb0533e7669b7a1849a2e03d8a464d 3feb46493e774ac3ecf1807dfb4c83dfdaed14057cc482054baad2549ee1d491 ee35e0189a09da93051b01a1feabfb7240b526e0752e1854e98d5f2f3991fb63 af381d721bc51f8c35312489021cb0fea20162269a874444ac5afeaeadb8f663 e8418cd4a1163eaf102d9ca8c4ed655b28b616f679eb69bc50f32219a6952fd6 3f1f5f135cc6e61d7d046b801eb6ccd2affff072b83361266c14e2fc14cb9eb9 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 true +check_ring_signature 0880d195a58a524741d1c35b863129b114c3fa063b583ca04a8f161b7bfe742a c10bd82bcc50b7075e8ba8b60159bcdf6de919aa12c22f8bbe7cd00fbfd773d3 1 298ec7ec2b1d262ea326b35cb5629318e2829b8046cff0a5e464fe1a81480e24 03622ce0abcb565a040b9a68492cb4621329e0d8246a0e7f0d03513a5c4871002e50750495c75d6fd0885112124112d43105bcdd06801490301bbab4b3c64c0d true +check_ring_signature b3ad516f0a3a646220721ea9d5d34922575accd2ae904c59906c6e20f9aa1abe 167de63b4e3ca6eacad7e7e35a5afacc04c8464b14398f2235df1c95479ccbc3 1 de88a1d66467173d4274a58374cc8ce66a2e3c086ba92a392f7d306e6ef0d8b1 7551988d0535a080185aebc804323c28476184ee5e464e1fddd6d240611d610d88869ad5876e2cf50ec3e1b959c170b7277acd17a288f68da52f6c9dd81f8307 true +check_ring_signature d4dd7016a4024232c288263dbd436dcda483f350c1ca423403b11ca7ba82a9e6 b401d01c826389f312b28808139b1bd244e907b8352cbed25c8f33c06c90eb2a 2 d90a1b0f6dc4f621cf489e86692f4fbbbeefa686171f16a8971839d2e75ff215 336a5ec9fabc91469772187b80d2d7251f73626dd57146792f8be193709d31c0 30159cf46cdfb16227222c3d01187edd66c1f6234ef80d0b647755390257f8997df9abb80ace55d06a91dfcae5aba6fd5c846e2f51da8f637fa2ff8bed5fc6298b1b9c44428bcfbb8897f3d1c71f7a567534aa09879a6007a51fb59b0c351c04def28bc2988dfecd29e4e03f9e13413732f047f99edc2c420b57597f270b3701 false +check_ring_signature 8f4612d7d3061a179cb996f22680212a37e8d5a98637da7554b68e6b901b7473 c2f7c6996a5d29c820331615dfafc4f9a8f52317399af8792203807b4977f099 1 212df9b816ba752b16d4d3644af2a85d8746db5763e331153c709de87b4623ba 0fcb63a98892b4195015d8a774badd1752e261002dd93631fe0011f0892a0b0f39c6d9934305e302b7292e27a86032a4791df55fccef42998e142aa44646ba08 false +check_ring_signature e9ea656f300b1a17dce501def522fdb75dbc6930d59932b749aa9207057076fd 3be7b69aa31afb500bc24b471e0b8ee6ec32e84ce6464cbf45a23415cb2ee5ae 54 1ab8245d7b08cd45241983e02805a119f48b9a2e79d5d6b675202dda8db37f6e 30423cf88e2032a917d1babcd00a47eb474c807154d18d5a4927ce610062e191 3636e745e4fda31a07290034d2564fa8dc6f39127699d478655469d8bfb94988 b4518b5dbcf4029a783c87ecba320cdce82f9921ebffa5a3d873ad77aa177884 8b5cbeff7179af105015ad892a0b2c2ae1dc44c9f1ed4d998cd3a4e79b08ee39 f5933398c199a1eb11bad26c8b78afd53f5c5ba29bf7d824647856214edf493a 1a033c4759a82e08824864df61f14cdafdcceea2e6dd72e468b22325c1e00ba7 ed3723bb0721a5630847dacc47f6e1b99b869e354e9383408373917821ff2106 8533a51e77706eee5d856c3d54a47716856c327d3b4c67d74729f797344799ee 99af97dbb0ee2f1bf6fcdb34d49e23d5ea81c56c1484bffd9edea109488b707d b3d45b7762532725843d7c6d91e36469143e8bbb14154091fc001171293abc62 064c859b05ac09506a5488321501d490663f57804a0e2ced269e2c008c7c12a0 1e4dea3cb194f3fc93b0a90449a71ec692be9b66ec0d2fb0d218de678096db61 e323fca3f73145915999edc4a88b071f4d0553468c03d2d73d1f844de042c9a0 3707eae829714829b98151d026ae19d83c0ab8e1cb152023a03dd4c3981557a0 a4ed8042344af960f1d17ac448eeee49affa8239b0cc3dbcc8cdd7b248b04046 7ea0cb1889f7d80b1240d3e956e04c3134b85be0aedc041d6b8e99eb114532d7 7ef25b6b9019b9c6a9a4d2ee65a71536e5a7cc0ae44878242105c72bb7c97924 72463077774a9f208883514ac8bacdae97901e745f2317afff7497457ed0da7e 7cfbee36d03efece506a05fd76ae6dc7ba8e6cc11ab4447e4ed7c9c8dd8cfbb8 92d2349fce23dc72e5c25b83b802dff162d051057ef243ad7f86ccc548ae6939 d8810a45aa4b71058f0244ec7b3458e1ee855aec52ebb67dfc9faa260d3c0179 53c04ad53ca2d52c950fca9f7c1a56ce1936ea659b52b9bb4f106a6d8ba223f9 00336d88e4300694c4997ab15db22e4e6bf8e2ced1a3c543dc0dfa5bcf8bda9e 52888ed4909f66da45f4784aab5d07b1aacc5caa52af01a79292b2c3eeaf52ae d276a8ab7f69c7a8f00d33825014bcef778ebb3260d308fef89bdbf0878fa957 455a15ed239bedaaa32d1010e84164cf9f496162d3985f6bc212cf712accd960 7bb02b838fd886bf0d401a457c96a25fa8e128b1802eba1f3b6d85f4a86905f7 98f6a9fc190dbbfa976467a1db5a46036955fed2b79df66d13fbce8f8231c8b4 931737008870aaefd0894f9132cc2583e30872c575dd5224bed7966bf263b9ad a85bf1c0c29e59604194dceb26c8873032c816f3568bf6a7543449da3d3024df 4cf366d8be0df62d2fbc1d4e95e8684957c7091d3f8991fe5b7caed1a6ee5601 f5e67501503a6169186eed0cc28d6bc789fddb3fd59473327fd867a2d0aaf205 c79621d7312572bf400c546eb1ba22c5d9d952ff04ad19066dda80048e40d121 9ad6dfda3737d49054b3933fc5146991690af3a4ada863d13ce319aea6d1d4ed 298aa478f692779d8865740c16fe594676b2361301b773484f107bc729ab7895 d9f35dad28553b196903a3826f5a4950d5a793e7ba5ee227b4ecc4a1eb138949 0661d906e29adde8b8af1bb6cfa487f81cf80af0756c4b89d65ca80410a4a834 ac518d7939bb3ecf1562580a0d8a653c73c9390ab56f5840f311384fdfd1cce9 174872b41abec20719607e41a669476ee90476c79746901bede20a2bb212c171 a52c1089a318057f439b4cb67e0729dda02f23426a8355b1e07fa01fa841c90e 5782083dfc0910fd0a3593abe46890843de61886d9f10a7d42e2addad9373d47 bfb486ad268e69690279db8901d1cfe1c08b54a2f8247bbc99976ca296cf31d0 d9a22620f3bf6eb67d772cdad0afcbee5567bbb40de5d1f0be0a66022b80e5fb d1dba29b8918b09afeff1ca48d6c1c34679009ab428c5b183290ea84a2cd9990 7f1acf67dba2aebbc52073af214619b56562e60c4a7a90862ba8491ca41f4dc5 cd132ba4f9da51dce908d069bafdb88dd2766181524d3d1b108d4f43fde35117 0b5dd0381f8e46c831095a02d8b0d64723f33cc7829de750d34459b6f26a9988 70398accca020590f60b199e661f3ffe714ee17042ec70521ca7ab7fc10e8925 1aec3483fad914b214e1c74c76251a2461a510b50d9f336cbe476fe3975e5c45 7b1b51c5b88780ea77407c037fc013b51ec8490f276bedb1c490edfd9460b381 441ddcc419950242deca5d8864b9bc237b7c868e708474990c44c3c46793c5ac 25f53f95c10190e7a607f96e04d807178989ea6f2d91419562b9d5d1baafb6aa d6d1fef85423903f6444eb10a1e9d5a7ad8c979a1b0adee4f9602a74610f242f 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 false +check_ring_signature 5acf67496ffd02cd896fe2923228ab886ef50218d51ba44c63b71fd05e39daa2 9e06a35b6201c699013e26a7b09e7c922417d42768c210f74ee3cede1d8517a7 3 aadbe526967a079d22c1dbf928967006053adf999bee202f5b5c3ef26cf0d1c6 ccf2964a1991f4df48000a9429145c5741a59c0af64419f91b05faaba3319178 9c4176a1c577aec6592c3e2d43841f31df71c688e91c7489dd42c7f4e796c31a 61f5b348a9e81f7d8a45c5791d68a83f83cf0564838fce47da2af604f6c66b03dbfaebcc125fda8f1d0514b40fc7aed920961d119f8c3f6115ddd98e04eb456c62c9721e6e6ed2c81f9fe9c3cff4dae6b4011f15d3255eaf1363fbebee157871174e118337939dcbea52d883db80d4903ee0eb0177cfe85dc1aafc078dfc20096d4ed9e1e08772095b918528ebe8d9b50406bf71cab867fd91fd1ab7bf5ffd0ca98175082f28d464f3f75c47e52e26e582b3406da8b263e672859029dff4540e false +check_ring_signature 8123fb648893e65161711535dd42eea6cf2445f41443cd5de2db689afddc9249 2ca5859ce24e4feca006d62c916a44bd6c1f8bf7e7360c7adcff4bbbd30a89d9 56 7d4d9d5dfb8233232680c5664874733bf028c9e6d190eb8d7b5322ba47bd411a edcfb83f5aaff60e9f8e87677c3ef2db57d987bc1664498747eaa273bc246efe 768b4e34727fea072f6273edab040929eef7311ee946ceb44813c70f6b21fe7c 6fcc495811e378cca2728b5bcd51facfd169cdcee026ec3e50bdec117a2587dc 60b6d1da61bf6ee5f242178aaeaa0f251b6da44e8cbfd8a98be671ad094561b6 64160ab4acec9d8918d27ade93020cd2225532a3220cc591c81be06fecb90774 e474f84b9ff15d8cc1e01653b2ceeb042c4548101b926151b37486eebfa8552a bf4e1ed65781ad39119bb3a83c0304772b05ab0e9c172a67438e8cdb00314dc6 922c51ba0f729ce9fbb8d455dfd05a0f8e119223d28b5abfc48a0b9b4e7b1af8 fc093d79701ff6fdf6754a978187d6dcad9c97bd6f415769bbc50b019a348341 17b880c214d0986552eb4344c70b1a339bca7ad281fc6813f7204b90856994c2 b99a8639c7c26733d2d7a76aee8c7fa0794810a60229718fefc8bca12034d129 5bff27424ca7efa62d87e7acdd1d5e2b4638bfabf4e9de1c34d4769d2e0926c0 fdd85a2801c4ac4e40fccbf2cb4c5a753ad96890bca13a57198b858d2348940c 28a5c014ae5ef40da3194866f4a04fc007ff1be4198bc40c42bcf7f7775eac9d 5eb20fa5293341e2dd28c0d1adf4223a9efe6a73d769f9c4039c06058f2edc5f bce5b1d89bd389a787f552d5363edf8c5e7462399ed2e122b44054b8a6faaf4f 03259d4999a8292f1ffc83a77d2bfa5dd8aad7542114f72857a3c026f152a3bd e6fe3c19518ff019b844f63b6b18fab7f7770c84f21dc8dd5f52d4bdba367352 08c4ac890ebfba25c3f429ef1e11194784c1d57e2aaf6be776c409605b26f9da e256691be2a759a1a97bc649c5e8d9304ced1feb056d985d337fb8c112e6b4d2 2a6228bcb2a09a0e9aac7202b5c3a991bc9dfbbfcd474cd5d3668983ffd854a4 a65fb6055580545e17ac16b157caf846235f8d1c77284627a2ec135d92edc06d f36efa508ffe19e9070c4e21145e755736cae2fd936222d2d74ca19887ddd163 1cbe87f377f7239a2614e46bba7a74c3461ccb33a0da15f5ac81978ccd1464c8 baa6c166d697edf09064da90ce28abe1340307532335819d42d7513e66939c0c 18287664dbfe536a25264d8a63c02a41a8c931d620bc9c4feba6b2cd35d44e4e 8ccd89d9959222546af434fe7ee706a8441ea9fd75006de5d40170b509d85d2e 8e2b1944d46d23759262b6508fb03df2edc126585ee09d818dd17fde7757e909 878d4a2286140072c1f195f05e6aaad343a4e143716551837d6382fd0cfd46ba f903f15beb1dd0be58f44ac67269ad8bf5e83543343ff5b077625569400c4681 e8d49308a88d588036dacad375651c6d886d692a233d42fb2bd9fe788e9984da c8b75879cc10017b7e30102fff9eb77667f0aadb85672c9dcdae005b9ae27d09 90188f52457454492c0ab065f142b9ad46ccecef819af8ad7739a2f7749e2930 5712675b69f8d17ea18b2f837b6731d54bb3a477cfbad92a43e80ecb50dcaef9 e757d1a64f90f80590b577124f2b2bdabc3fb63f8e41d0134d4d6fa2084b3cdb 467140bc2c9f251c6bf586a02e56b3c5cef36e3f33f881d39367040e0fc78ece 664a4aaeac789b93754c0345c51f6182a87330fd8dd6210746b651c665803d56 8d4361d25da61596c40e738b22aad545c8a696601bbc79895cafe30e3f1901e2 547347dfcab2d47bb531c590aafa9161c58389dbc29f0e7745600fe697108cf5 d2e27c122ee1214718a539eedb6d9bb3fed6005a428bdf7a0bee4bc7bf653bdd 683ab487b100c60797524a725e331aa75fdb65bcecd49eff121b21afe22cfe83 393cd7e7bf3a0e12e3ba0e77b8a84cb31226e59e3aeb9ddae033db4063308dc3 e6eecb965c40eeb576e1ac107c4f647e07e3ef6ce8bd46991fa76ff3dee6ac29 1a392e3a808508d9fcb4b370accb496368d72d32efbf43b1e26f65af28f3f73f 6a1a8dcd766d1afb420fb220ef4e1655b500c2347c22e0def70d7e1913c31faf 4d1ae0d1c656a6f9709d224e2356dfbebf779c64c698500487f2ed87a9401655 0f72e71cb72c469c8586bf3b0c7da94ee7547b4623a82925bbeddccdaaeaf096 15ebca6bfea37e4ca6a2bd524bc68e9c1ebd6070268ee6f6a61cb956dd3814c0 c79a1bb59c01a67d5dff256643c03d9296fa7ad381875ada96107340142f6a46 65c5021f03bfd90aa43088eb68d5afcd229038f886ce0e8d273785bf1628994b a1f09843c64b4d89e075acd874c4395badbcf86ce8cd0bae2a607a81c8fa50c1 40b1403b81ac026c6faa8b7e83ad302a03a0ac2dc40329b44b19fad21424eebd 077d340112c95583f703e0d827bd5a27fc73da4288e81c8761be0a5d469b3d19 b5e1788c6db2c75b560278d449452c817720c6c7cfdb56d8165f35713230cadf c11123577a9375922bb82beb625e8be9bbd12e0dd97d4c9d0e66cc612c1c6071 df9d5f5e0ccf5868369a765e84c98b32eb0c5ade9170a8ce90cea507dea9a90d147904f2febb764bf1c1c825bdff6bee392ee292dede52e1810e1bd443606e0a7977e386b79eece5f98fcf412d141afd836d60769665976c100ec4b52792540919766ac8514f865de3fd80972544fa3f467da8bbaf8ec92d23973c31b1824b081b9a1df181c936105f0b3580da4fd5e3f8a20c8bcac68687bc19efee9057d906efcd13bc4b2b0496ec37ae16e18f77909f6b2d46a07e49e62bf4e715fba4a80d98ae7078ae10173bc727a964c8173d89e9474e806017f1a16b89f0d1906fac00d26410ab52953bd301824f25fd0b4c23fe2df8e5396a9ff6ef73ba4b9bbb8003e222e691e871bcb54963f8e50ff97892452960f3e7cd29a0630cb214ab40750e494796b3a1a738cc321f72ae53d5a84788eef9047c1b67a48b21c5fbc0df600c72fc9ec7eea1be666d3ac5274f1ab51d22544ec09f9347df6335b60d186948070393d5d050bf14e2c4765788706fba23099ac16bb0d6804936a62911eb360a0f782e8f99ca6593035ff8b87b73352476e98921bfa15b3457be3b51eaeac5b50de0ff9aaced7076195d7e7e2ddfcb78a1ab0cefec3931a16fb2b3851ab208440c8b470c638eb97ec03b65f5e346c5aa6837c84761b596e6c42c612c2f3451320909edbf74a008a4b664fdd27ed07b10c49ca0d1234661948cc98ed715f071f60e3ffe078d9f949125ed93b476a8b35f25d6570626e4848ee52875f0e7d420d7077788b0d6124c54358c4a5359bc85248a41f3a607771fac51cfa343dcaaf0830777a8eb022363b12759a9f6094b7ba368f8069639ce3308849304c77f9136d705034f40bb5b435bff1059fb3ff6c6fd210f9237005d4e5f4d62b891c90af2ab02f3a9971b6a1052702371d3584ff4d57adb3b222a142ee288cdabce4ed8ef790b4b9d13f348f40b1b2ce9a058edf5b8ffe0714f1044e9834604a2d14a6202830321299de6d9d659f1832bb14cc94a9603725167864bee4c61e4481e3e4264bc04ebb41485f62ab453a8058084e8c92cfaf703a2347c74d90de64dbfcb7fb0d40b5c84f8eb61bcf829abf3d03e92b7e3a0887bd9e258d61309c6eca2af49b91e0237254acecc5a6a11a68fe08dded89f28be48db91a5ae11c440d4443030b7c10f1ed8a6c9fd0c43208fc3f1bd2e0ee2c1b760f3079fb7fdbe51791f2941f32004bc213bef2244676f847f66c047d59fbb32e620ed9fea22ce2ed4222787b200097fc9ef52c194056f8ddb0c917102f02b65be59c4fa3cf60140ebca582ab8240faf34604ff69d0e5a00965ffb72fb677ed04fba93c299b6da8b9eece8473fd200706103b7bdb5d468d1bf1acde8333d4e75e92ba3c0529f9a147143dc0319100c417bb65acbbb1d0d1f1dad58d49dd868052e67526b28a3806dc7695b4ea93006994f36fde3ecbd686d682be2d88aeb164db245d7eb5fb6393bc110c6b8b9c60c459365fd11deca5b92d7e64c419c57d822b6925b64230560460856b9a70ea50703cd3dac3d53b852f979c877edfcd95417166d4212b7e938d2c54d5365e4370053f18815b138080c24c15c7e79684b70750b78be58071df086d0afcf2706620151d221550d07ec3c6e455d48c39d19bf377b24131cc6707badd3deb1c1fb48028b82782ed2d1bb719ec063744703d48c60a60a0f97e06ea806a477d93328e701f984d70c81e2365172176e3148b3a66fb030df625f3ac49ac6baee9d40d81d026906908113efe183f4d56c9838b7a093c37072224bbbbf6c7ba8b97db2d5aa0b830a18ab518e0c165c1d8fe73cc8a7e93a4f87b983b337c3c66c06b35bc672053ba3484a32ba7f8f6c9418b169b04d897825287712e253b9dc260f36fdd42800a19e68d1e0d191660ecf2249306de4938376cf6afa2d9e80bff6011d3039160e0e49962c53a2f44faaf9ae433a358797a3ec0eb7ef8f70cf6acb5fe511a06a0f2d06b5d2b708c71b613e02db478eeb1d0983031ed3c23f894da5826289458d037fde5f6299a289c7b13279cf5efd4a7cfe1fdeb6b9be7c23d6d4f60b8dc81e04d099544e00c884fc58eedaaeebab4bf88fd5ff982f01fa88d9e1ce7afd1cad0f7de52ce7c7d422503659cedbe7287c918b064bdc0df752a3854ef74e52b47409d2fb1e8b2a9e1947e3d15fead444489db5c7db71d39065e141973228439e9d057d6f33fdd5326ee2b1f83764f01a5cae41b6b070dc74626aef8537692a351405651ceedcad642b07c2faf006fc92057a31e3dad5cd9886c8eae1837fdc4f3f0d294fa5d17b786a2c627ad9294c0550909e035bb4e6dd418cb2500f97f5a2fb09249a4142cdfc26190abb7386c5f63d34f0d24dfc42c457c9483eb746e8cd1805bd3021f93553eed1f44263f21c60cbb7fd1ce9efa7debeb3729e0bac38660809b79a3c0edfa979cd629ffb7be577cdd7b76b5fc01b56e189fc4bb29c7e7d8d0a9eed68d2f6eedd8072805844c0e110a80da45933a73275074de19cc8eef14b0ca23e1b5c5a3071a02746a5c44f11cbd7a08b7c3c5be6b803f94c48a88ac7cd09f8f8ac4ae276fd6df5b84750434f04b5dd18617658c3970baaa5d308cbf5ac0f6a2fbbabffa9bb7c48f6a52539c50ae926c4211246a4a494f6e9148e20c20300660636a2dc474c4badb9d295c219eae9fd6c5c05fe06b07891fd518840ca7f0349f8d1ac253ea82be3f9ac3e368be0da1d30e1bfa5c6e0b0a5e885cc55ba780ad3bfc57191202c8500c573345fd50b7d2d6df58b8c82484eb4cd20d7959e740ff4d69923748be151c29a139c95f217d6dc9477404a58a3376dc7246c556844083dc94d4248fa1b7e75a642b44c132b445d6b89288d500ce1dd6a3820f74c3e0a2ab4b9e2e5b9b2aeef171787b8a161c46d1012657ea9ba16497efe1f82f6e406d22585adc8138964e32b44b26a60ddacd3ed95f0bc788c37315168f3fc76ff0250e4d4438b6cb104f23f94b13439f1ec8821d8b32478d258c069e70c0f25ba0da491a599f97f6b95f8e42f357944d319be74d5bdb6eb3029434f1861e67ec40bbc3daff4f95d6172405f31ead3519e0e4e39594cb227c0a75850bbb3918e7e01323481003086afd6e772ecd989da843559b4c8c8a4fc2b701bf33c41da174702de9ebd762f4c5123680280402f4c0b7d10980e64326631b00b65974f1e6bf40f919552985e1363ea282d45935441731cfc016ed907be9b9f01128e22566602089354175fed10c5fc4f68d77c3276eb67680ed8fcf3c5574ccd201b8b41cdc2052e58d9cd5477f72b6a790ad2f1a4d83191cdb4a320dd642edcce947ff420040697b7f083971875a1aab35bc090024f01eed37b329d456731af744c35d4ad5f00820105c8237d2ab5310b025a54c71464c7ad0594f26d8401a0aec2284c1d5106b5cd9064829157e42e235dbc5c886c6a008997b546861afd24c9b4aca7f3db068a234339105cf5d52060c879b47c3092d8a0e53ee8d13d2965282547f68f7a0ba2447762d513fda81c1a2d4ee6ae71c19f839dadca5d3c0de5166bd6aa693903439e208edd24b060c34e84fb707afc567e56c2809c5461575652cffe1b40460db09f745c6728f08985b0950fa43fe9160f70b25253200c0742a00301eb5e330a8b367bfd51221a784b53e87be0220d4405e689dbc74f0704909ad0c31b2ac8088f6de3d51eed6806c086cb6f3178b9953d2c013ffc853a8f6f8064c1f1706801817e0c537f45ce229c139a86fc79b446331bc06c690e16e657b50394179c0b002ef8c888e42ee1a4897927dd18db1c4ab647c00ba8e17d89b6eb46387e36e3012f0bc9aa16c94c6a922b846113ae210f69488ac2e1e31e36fd7114bc14c4450c83363a9d43edc77bceffd61e6f607f8d0b028806b511a3354b78e8a54686950a04cb795e5146f7f3f43265aec89b28e0daa446546a79c4fc9f14975abd1ce40a6a0952543231553b8fe349e56596c733f27c25e9b29f0051828677a953f7e20fcdae8deb6bed3a4b83066168e7fee29e2480081418aab26cd55f554c5392f8014ea4c101f2827918dce71df9fe189c82c79739d591661c44fe2dd353ed8e0c0890348d87799f68482e34b7b0cbf3a8e41a774ad48a9bc03092052ad0b1586b0af8a5c9cfa40d65ecc716dcc9556eb3a4ed737a2ba0eda07956d48d8081a99901c47eac3d771e1eba0b65c2135cde7a1bd4f8d9074a7fa6b9ceee11ebe331ffe2e62c93e38c4b0bf234b2fb80ec3adbe6dbfa6e6fea5d928f253e18e788432e0b6d981f5ec31372c5566ba087c77bab1bb05750da24fdac354f51936506350702f77dd295547bd81d2f3157dde5587ad28f1cdf39d501a330dce8a04021be1e03afb2b3f957056d2ffa612d80a40fe5bf50a5d1bfbce49aa088e00cba527a62095f5b8ad433db5be21c59d154969628061ee3c643a88cd05072096a70ceeee204604297f7f4a6e42ba2920abd6a588e311e6fdf793ae947325d82f4d934c92606d9a23d1c9465e6c084125b3f51086e85a16e9f0030189c26756b6e7200c25f04e392548b319d07329bc10ecd841dee9faa89897756a31c68ed9547917edc940d20d3d5d7682e6d05ab288adcf08388519457623dba98a166837df207fafcc60c4b2037915e29945f01cdb787d0ce4b83718ceb6fe70a29eecf2730f994ffdb02abf3cca4eb05f10f00c3bb2c9eee8d2c6f294708e3051f0334e89ee7954b82095f61ce6f7baddff713565b57e2adeaf35bdc97868da8a8d78293336b1e63fb0d9289f6663207407595986a0c8608f116ee69956c5335a2e4115739809dc41e05cc05c5989b8f6ceb239781505d3631812421693f7ce5c006798472b37eaeec0b4086fa3d31780308c75f02a35c5106f94ca4311fa110e6f939dc09fe4e667f091a09717b348c5cdf32a9f129dddbb31bf24ace4aa39c2433c52a1c2862386d0c11c52daa11237a6c5c91b5cfa9d024497dc0eb731a2350579cc98b000770db0bf77350a5b27a859a06c432645225b1bf5d7faf00e7a5abf0ca8a3a165e9df972 false +check_ring_signature aebbee7ac9ca6710b4b27c08457dfb2d2744f1da5617f7d6205ae9ea6369e6fd 7d68c929b02984ec467132b6275cca745b237d25415a41b744781753db91fbbc 9 95d9cc15407239099e078bdec305573a3fb97dab9d53e36a09fcef68585eebc8 5aa53ef7b4bfa3ac050bc7c31befd286cbfb7cd71f40e6943cafd655c1cd6253 edea39b9d67a557a225d5de0a221c30d35b58c586a58c82445722ab608236161 63f3a053c0c83b4063b915b2db3d962bd9f47ac9b91d1a71b73848f53b0403d4 5f33c75e9e4e2dc65ef0ab756cd45f4b48f2e869c530cc7345ed1f3b58efbd0b e01663c26938c75f5382b16ccab53e64b24d4d038c3494838cc6367b84446db6 644ecb5832ad9dd39767f28c97102498bbc5724d3ff3ba7f2be6a5101ecd7edf 38747f6edb65c6a5c57a4e0cb686a4a93809cee6edfaa55d3565f9de46d91993 3fe31533024ef63ca29cfa7b12db51766983ae9d28d9e00ebb28815c05a7abee 319d51335c0cbd57ef3fdc57cba2768c5ed70dd015bdcb94e5e624b25b32110bf479ff78f9c289282b5560cdec83639c21053f289e018e4ddef1424d50ad4107d90adbe2d832217f92ca2434faff167caaac5b76c5ff455389d65985cfdcbc00cce9cc00b0dfb7d0a0dc219f9233cfdde2439670538b0bb6de33d1c043d58b0fadde0c7b61372f40eae65b5378766049c22fbf0203622ba2550a86e02051150b8cb1f95ed0269d36897236ddfc45394e70e0036a8354af40493e16c6eaeb3e02201cd2fed9c00c4fc7ed17c659068fb414af63c3faa6aaf4b1464f579f818908af429a5dc21b81d7dbcd35e8a3e25595e2ad4107a267aa8d0e88503aecec98053b985a4b72ee89445b992f8af375f0948759c4d733266318b36f07f95f2c830cecac88eef6adf472f3588049dd3cab32f62098535a930fea994d8d9e9a22d10c0b36b7d96047814dec91277e43d83505cb975ed8c6b26ed2cf4839b6d85a050eb2c36ff41e02e3bda82b18578bac0db7e1596044689504b96457fe13564048020d61ae6c9b084309573fb1c76841d7ff56e94c79b0267082ca9ca02350eff507fc0a7c3c8f2386fdeefdcca70a6a9b5eb9ba555bf613f23223c5d564f5b05e0bc57bcddfa3082b65df765563c28aab58bd35b300592227f6aa2d3dc1cb7b0502d351f262b7d5f3851c0a1954107ce2f8cdc98620c7abcb7f058e69ea5385f30a5ccaf9c2a28b9f83c9f57beccdf77062a4c544a0d40ce6ff6d38adfa9305ea03424def07fd0909b4612f5b4f768b51a65336176e5fd4c86c30dc9c336ab85e89 false +check_ring_signature 82ba90dd1122252414485fb3b0072716faae463ca005537ce21e4c701c8a2e27 ce48d2239d85da8b96f2f509345d0b251fc060a93d03d9c042aa44ec3f2dd708 20 21e8c3e3120f2ae88941544cd85970ab16aa9834bc36a0638fcac4703b130162 e1d58926b1c1f614667b5fdb722731f36769a3efaa38b39a18e5c49c70d95d42 596d411d3b45f98f3f35537caee4514623dbc0557eb05e7b5a1ef45377abb99a 0920072cd7779f45ff16917a3e9287cf3f354badfc721e04b239cbb629ec422a df05524b232ab9be9c0ee0992ca288e6f95f00efa670cb1e8d7ec281afae3a36 3c246be46118b3daf99d0956055f0bd6dc6116a4f82c46324b248f1ca519c739 a93d5745acf5147ce63d79b4371bfa629b898fcc7a2ffc7cfc4afaa015e1f156 65e3e9f5ca2ad75b22a797d1a78fa5fc09f6b2617b017795c78b79fabb9229b8 4b852c33080315c933c49be3f4c7f67e3199ecee643adf759ca69e218a154b8f c0b17d627576f67759c523e6b8d6d9b5a24e8a5bbcadf81778642909269d4f0f b5ed5cf79db388b365674eb8f828148b70174f964a9035d248493a48fc8da499 2cfca5274aa5bd9fd6b2424b213abd5835213ed0a6821b66ab70056ba0f52e24 38ceff5973d23b4485b1f2c9f754c677b161d153c54560999b30120dfd865d2c 0e3f77962843f9adaa7b6219f21ffdf9f429fcfc0a699a116228c055a0440e1e 4561da3e06ccffc452eead6fade4dd594734451f0808b1379c614449c7b9d34c e0ac869760dce959613124cf21c542141520bcdc9549da716164c3c4fa1f9758 6e6b5c0b8de9153acc4058f92a33424d0439a0291485242d1dfee760387dc700 7d5a79b116b48bdb626c46663408d7353235789d7e436c5576fabfbbf4d72aa7 9214268496e70d4ecb4f94f29c3ee8810b7e5b32222b96b1892a2bcc1e49189b 651ee98d7af5363c951c54fe034a9345d34dcac4479c9c06e8e66be4bf745bf7 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 false +check_ring_signature 60c423f1480b8ef36712a612168b9f8c5fc2e76107b87a8372e355e2d3932e86 ec679f9891867d9e58e3954cfbda649cc64412b7ec45c6ce2b0708c9d54d85b4 2 cea5a1103a6aa2f7cfb29ae46178b85c2546182027290080f3892dbd3dfbb456 c317a82dff22bfd5efb1e00fb723e4010d3749bbf2cfe75e05db37dec9e075b0 202a76dfb03f26d01fb8c3cb089b509ca6c826fa00c98f674a67a9de1775b6049724ac2c222496013e0713f91c38967223961b428c7077abc34504611dda540206a75ec93a747c9d612492877be8b0384f6e134ce70bb69d9c68c672b2ced8009c68c7efaab7a5e440416b02353f310f1f1174d5852055eebaf527daf75e820a false +check_ring_signature 03dd1e84f4b1bdda480e09bb7ced4a201b7c5ca77c4622805bb044226d8a13e5 3eb665360679822a4c93a7191202e25dc0b7c32dbb457fb64b2faab5ab36591c 2 fad528e97e5867b82dcb68df80fc0cfbf6e60122de6ded0ee7ae762a2188a270 a5ccf747bb18b7055747c72bb6d706eff7868d9758bfc7f4f5632587a4de9710 4b06f6bf2390b89f385916123f63e0efa4f44a6999adcff01ae634db1ceb410a6dc076cabf554cf5954cdd1c1c5c63e65d0f9ebdf607432558b254911a7f990283946c31d7fa7f60d755c8f8beea3bbaf8ee27e19dad82a552bfebf2abc9280b72080ebb5cb66a071b0b7f66064f2c0e5816bcfd50e7f1cb67f8fa6a0ef090ac false +check_ring_signature 537940896fde7c021d1d0648d2042c8c4a16acd349d5f8ff218e0bcffc0ca102 32ed375ec47967e00ea0001f82e33d968180a8729e2e91c635e2569c0d9e05e0 139 0701a905634900b4975b5780cf4a06db948b6d4e5eb0ae947283bc5117470c17 45d1f4a0c4f5df845e5332520d0f6786298a545c7a6dd737dc85373e15050e3e c95ad190d6e1654631209b7a5c3515869f3a9dca90a26bf0deb6cef78e074cb6 2c9cccdbad6457c127489946b6e4ed376b9e51c4a5157fe1a8e4f54a39629861 e6c03101a69f901cdff39dda8b04ec4fc237b6de1cb4aaabcbf67bfb6344431a e41593de1b26448a3ad0cd1cb8560a9356e51fa0dfeacfdd4f7c1c91196c3897 850ba08132cfa7ce3ef2e5587d80cb5ce3566ece4b582ac5a33a37e2ddd4cb30 18dbd470e870425d0311c3e8ececd2547bec076e50ea0fb4338cfb5fb71c147d ca7caf54a54120ea49506a2423cbd5fbc20d048e05c36de13b09436b0cd47c38 a2593e0030114f074fe2e9e87eeece6eaf63bb09fe7e9459968e8b6a829ac132 5578256ccec5d6d3a3045bcd8be2f7a714312795e6e1bb9a90d4b99f29db5d3c 55261aa122220713bff4694375f904d0ab52257cfb337eaf2eba9a07268a1397 7c8060108ccc25be55bce77082e692280719ba04c23f9262520ed9e5d4f917fe 0b2cb7dde703b4f08b30676b91d8bada9477a6503b64fa34288375237ab833b1 714357877203e875d1e6b1496bc56343b61bd3e790203df0b71a25d3f19f82ba d607862354f5a8be3bab4bffeb998ba845c6306b52224abe396d86ac06a047a6 c6d42fd3eb1091b35a62dbf7ef01c408b0c5aaa28f70032a8ea42b6ff735b8eb 5ac573e51236b54b7a8727bcac9b79837a2c468bc983d462131db24805fed2bb 85de8ccd9d88cb9b1b34a5d4ec43cd0b843a79bca8ccd325a9c670e57619b571 8b48ec17615dc2ebac1d8455bff9cc9b5c1f600704a816b164f881ed4ecbc17b f044057e47b745550f640cb386ea201d2358ba97a726cd1aced99ea33bfd6650 17e12912a2c212ec2455b6ef0a6eec2f1993cea32c146bb5eeb0e3d9be6cb3ed 0dddcb172a0cebc7b4dce54ac1a1c1c6017c8002fc4ef6d15f8aa8fa72fe9dbb 6d46ba69055627a15ed32f4a8dfee44d72655635926497110b470443c4ff234a a5b91fb96700891817db85a876c6e58a06393ff2c6c7914ba058a313ac7a38f1 49e2dbfa47d0918e17cd9c4ad178d7d7e6a00b856b260584346f273e53e73224 5f9950b82d9df618b01da8aa51815948ae8c7e82224712a825f7bd21ce55a375 b2ded20c9d57e41b7c304c5dee80fa8a6251543c5e63888a766c16a933f0d309 eac5cd4814bc16c37d59b04a507626e0f4754623dd0473593126bc355eaf4fd1 80b910e96e37912be4a2aa0eb283a63f5a978c66d7aa69986bcc92c456b0c98e 180dc282cc7ca3bf4095c7e57d1fe1a4273282e52d08155a52d2d56512cf75b8 746439e3d956c1b9effd5807413d3b8ee08d8d53fd8d54139780941c9a48ecaf 23204a52abd1092b3eaa9aef35f151be4dc41b77f5d146a16e7a57bed66fb9db d7f7d27f1c8f25c4622d6f9208467eb77a405bb21f29b0569329578c2eaddec2 75426c9688b44f9db0451f70ca23652376c8a3a24d5e4f473c22316c309d1c7b f4d839ecddac4c98c97fed63d75668d0900856e929b27613ff04aaf167899e90 80528b415aacf13406aea64c77f899ba69a5dd6051a0fd6fb2b8b60e72d3c7b4 44ef73f0acf7005f36b52fd7353cda7c7e64735b6331ea8067aa1504bb205ae3 599b47a47767a5d03de9927a8306f65db24bafa7ce59ddacce8ff4c751ff7e8b 33d8ac2f71d39c6947f963d0d3ac353e27f0f3492cdee23f2cf7c860738361ec b416b904953d368f45a90901efe554aa7a31b94af54c9e6bcc73c2550bb68a64 c594356be646cb36d4cb022b89ba370f44d57fed67d8ad75fac364cc42f3d72f 6872cc51f61c55c2157297254a62f2529cde10039b5f4ea26dd0e5cd52a70fcc 8f12ef49fda591fcbe112d6fc8e3298107b155c56593fddd9bac584ff49ff659 351cd596b016a03b4fb3fedabdb640d1960afb8b172fe391d6444af7b8951d7a 3528ecdeeb083eb000a96f645bb8302c5e21e345938ccc39481b2431ed9da4ef b6fbffba64395c64437c907b955b14c665f106b76d90bcb58efde64f19d84103 4485cf4239142956e23570b6c118b59bbb30ef5931a4f6e04b1e7282439c6acc 2aea7d47e5c9b2aa5203a1604457c99412a6da2c3acf1491c5c139f2651fa924 69d915440aa9ae4e192094ab548b67e656d9247268a2857f6a7bd44226f33675 4f443142f659bddc0c66d4b583b912960b5182e03a702c09b62d14a48d6b2dab 1dc258e38e076b68e7438cf2d3d3cae8059d343e2e715b889df46ec49e79aa08 8f3421ab1ddcff7a984955aa52e0b3ef48ff85abe467b44a49a0b107440f9ff9 8388df6cb2d062f583fe71bf1c69796d30e1f8c5e1744009fd88f6157287c331 0914dabbbc006c367b2a4e322a8ed557f27002aff04107397bde3304abf68d54 b54147f5f4a13ce5195ef02ece8230758072b23f87f846825b32188b74cfa9a9 65b5d96cf53663980045298cd7c92b676091660e943b91461ebae39542167c5a 91faf326162df06d57e944acfa52bce64ed115c2f056714ec1ac3f8570d5b879 8ed8e747034b5456ed8b272a1b473015e2ce9951c6a018fba2d95c533f0c5669 97594a51ddcdba0a094caf30a8f77bd7449ae3292e9b233c54b1d756bedc0d77 ff3504220d7489eb9794cb72f6949e18ab105b644d320427719c82190e412f9d 0faaff6fb323f109ba7e6c7ab8cb79192854b5ccdd470ac18da488926c07e88c 669f5e66ee2b461c0d4650eaaad319cde9dfe4c03f810e22965ba11b177303b8 29805fdbec9d2751bf780e23001b1d4b085091df5169240b24c3d3b920c518ec 7b1a0c30f4e9ad9850c38c0e7841306b64dabccd75b8bc4a8d03cedcff8635db 865d48fb340bb766c79c27a6a24a288605f3f0e53dd569dcc1671ed0cc844ff7 9107779494db173f8bbcaf5f4417b13f3d25c3a9c67dfd5d6e554e212e283222 da7d119fbb805b4c4418335af420a6f18863f9071040cfcba4190e9152b4799c facf3a367f48fb8b451a7fb261e9799b432fbab4277533cd4bee9a99f849a274 80698e177371998af05bad4cf4789823b5055a09fd27c25c4bf0c35812cf8aa5 d8a6bf78e82e57c60549e2053c3fa8fc0d87d72cdfab9bb3ca73bb2ed624fc5e 6f217e4ea2e7a81aed33ffd58ae82e9dafb61cd7377c8b8d856e05cba8b1e4e9 0671a0dcd85ffabdc47663e76c4993b917b24a3c479bddce6c60e7f772e07f30 0d007441d4add1b2b1b60312d891556e4cba2374700cb8941831dbdb884980d6 5d60a06559766adcefd77907c6630407b88b22d4d1ed93b8c46c24df29b8280d 8bb0a30000649f6d64f25cf097e7e1be6e0704b4d5b9bbfa3fa2936c2ff6b109 b5c29e8ab1db44b17ce8b55272a528611a8aa7a4114578b83cecb132730242e9 4118461cf6c29250a89ecb561037de9f4d7bde9cb5e895d77499be8507117987 d9ca946b4863a0e37217dce588aa6599a992917a1ee22ad2726274127870ff57 70491abb66432074a33b026072086d51f4e5c50f1dbef26253a95187ede9e7f8 43ea09e1311312824fef31d393add552e820696ba917d4709b5e9b862c0d2d81 84703da65ef5fcd44810d0833976f9f49e15435ba3c39682d5b193fcf6cdb497 f2f35249762a3aab55ca0361195975515797f32567ffedb35a3bfa10a88c647b 679722be2a40776bdf02a784cfa506974b5e992990a6fc8f2c285205ae4b15be 06ec42f6d53cc3071700589a3c6f98d8373bbe4f202e0c8678e0f5a7c32b133f 41738152de5e5fbf3f044e1ca2c68156238f0cfea544b2146d60e7a466840f57 8520c293870afdbf7eee54222e7cfa5bbc05c2c8a13b737e11d872b418321599 cb7998506df52f0513b3880d37ec6449554297d7f56efe9420e31e3083c79cd8 9999c75e637acdf7cf5eabc7c0b11226a91e23f31c856668508dbdbfa325c6cb 183656f3fd1a4a0a5b6624a73f970bb855328ba85860be464bdc069cbd2fdc9e b15fa87ae89655fc0067e04d7c2035e86c96c8ffe97b8f109567de1952fdc89d d06b8da25f6535edcf4fbcdf6409f5a11370754ec33da51d773c7d813503159d 3a8013d8ba5663dcf7a06aac155e8706bd6b06a429f545db77908c43692759be 4c0accf5062c875143a342a53e72d18f32e9df87becd4c71d8d613d1a1d2c56a 8d5f26151a10d9bb0c1a4e3e5a9c4f2a732c16da2ca5e27d9f171baf22033912 54c76c657e3279f127cba82542c1ae5f5ad6dace76fc3c9b0281d009b09c5cb0 307e35074594dbba077f5325bdebd02bc490b4afdd83764a94f00b229e0474c8 5fa6171f68ab606315e6b98e7d2c2b409fbd00901d9794aedb596b2e49d2ec9e e251bd8dbb30d0081e7afb67f3f3e328ee8cb649e3af0b5367f74146c28cd921 e85eff0672d80f37232c91f328efdaa8c9e519c3fe227838529e99384f00f017 c339fd5396bbdd3a90b919015e74152715a3bd2139b9780aa5e650debf584192 6cb140f1b15be93322e38f94ff66dfe0664a2d9943be771ed4616d82ea99d5e3 aa84356bfc4ebc326563234a09aa1d5fec7c5c5e86db8e8b3569b19ff5a38c9c a3fd52cd67e039a6ccce67681a51f1fe95dcb1bb5cb481d5fe2471a875d75d1a 39fb0f18aaa715f4d9a242f97179a271488c54fe9839aaf766362672fc7cc46c da2bb544c444bef3475b05cbf5467ebd43d49f3502ec83a6c38ae8ec903b69ca d9a6eddda5928b87de1f0c85e744f8bd9717d3eede999078fd5a453688098152 5b18e514ead1fad51590945b23f01f8516471397b3675b99e43754a764cbc82d 5de73df961cfa3da339bb63c59da4a42dd0acae78ef9ab7085e958b7c32b4415 5917db87d039b6d33dea98f0269e0bc51e0d24a23edb46e8fec631e6232d0f56 424780b4cb92109a1778b72462b34017a90249d366988891d14bc2e779dfa054 97950c73c2303eec0343284a1a7e1922281016c5a7c13eba820e76648c543b0c 328a475db0ff75cc376de70a80089a071dd449ce72142c7ea2b742e9707915a9 eb46ad04dd794c6482ba03ebfb1de54693f15191c87897195e96f0f56e72c7c4 c7ba20fce7080033a586070f0ac64895338273fb81719cfbc8a7e43c562eb2d7 c906ad954120727c7885c0c594cd4ef28d297b7ed7417f266853fb33baedb03d 0366dbd841701dd1e472c5c66278ba758ff25754971e57f40cd46baface01fbc da9401e213b1050ce1619864e372ac7a1a42f54ebbaceba27a44a4ce11f8fd7d 95da639ac3f27ae0ae2bddf4043962bda8e3ac4e6cd422e89e10a1deeab222b4 91be488977d35e93003827b9a4a059e88448c1b56c97afdbde7592c18d2d344d 0daaa529479417611a5f694c27cc2a49fc578919b1319a191bb5b6017978fbc7 b94da1808b1688fd14cd1b3f5f4725e4943b5b6876aa9223850a4069ed6ed192 7cb0af41a9c57c93d77aedd91502587d996f798b11b3f4d0c8ea221713185569 fda637cc2b7103bb3e572239ce3ed857f83eeb83b889c204b727c4aa7a4e5983 e056da216f649369d1370767437c932e7002fa03b231e459d8af16377e69ae63 4cc0627da5fbfe0f52084ecf6cdec07f77a549ec2f36fa5705223b9ba42fa601 2a64122111a2aaf0d57103331670faa3caa4d46d2000e56e4660d20d47876aa0 80057de649edd14c97a98340383e14a83a62f9bffbaf92c6bf56ce9a5b983299 67c16884c354822bdf05999f3513f0bba9e446b3d324d060c1e2416539f02227 a948cc666746530be00e74f18a9a86f70dfe68da08bd861042ee3b6c43d58a91 548330d9ebd6da1eeb75c011f1708426ec7c070edc4ee383e7289d98f13acff1 0b18747f46cc8c95cefe26c1c60344a18dac0d443efdc95a30e83815985a1005 1e234dc9183cd785e5efb06c92f02078b7dc8a1ad8fe2aaabde5ced9287edba2 3e23ef3051a2513afadeb62e98fdb895ce819d09b1f38cbfa67f331618754070 6262eef572f317b0fd103d2704f59a37dc733b223d78bba72f2050a236db4cf0 06994040e9389358ad36eedaa9faf080d9840a7d0577a5ef801482130233c066 8d0667e17014cad227c3c662e61c7a604152663727d813796ca034e4d84e6a96 9d36d3e4291ae8d73ba85ea9eb2e1b9d0d2d0325791932473de1dc6730609cd6 45a230c3cbc63d3ae5835f25cbfdb56f1ab177ed80b8119632137c711b98fa2c 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 false +check_ring_signature da1fac3555a0dca81cc997c28c8d4acc56050cd612ddc533d1b648e6806a846c 2a19b82d94011db0f8b96fa2622f8e8cb4038cf1814df17160d7bb086d27f55b 1 82fc2cd8b21da114fd872921030660df9c1e36010ba6edc54539c15552905706 d43025c44e909df9f885a1328188baee9add69bf302603219d06ca3a9335000542144dbda7a6de91fa83d681487ff6a59f8c724e67e9b87a6843475b9d9b8e00 false +check_ring_signature d6f0143b793a29614488cd6e2fb788c5224f3f30f1636a0629502d7c36e59766 8863295066ac6613b7152222750bc8ece2ca76f1743f92caa7e89d245cd64930 30 528a165849657fb5e0ff4f51d5076c27667a4e116c65c80873f37fbb3d94f17b cfeb31e6cca35feab40e74bd154619454ddcf2c23aa6a8b449633154d11ad5ba 810e71bf58e6122bdaf30bd4c5b8b5d934ca64826b53b8d649d3f892d984adef c90ab22950ee2a8e5f274524f3c15637e550bc7772baa7d0e17b3132f51a7455 2720ec503a71c5b6e8eab9ea466911270a02dc0db3c7d5f123d36d117495d4c7 565ecda295863bb1109cf63df652867fc6ec9b06058ff5094eb542ec30c57c01 6b48901f42cffdce2f8ec9a22cfe3f2e5942216efbd4312b33eb0a0bbc7990c4 96d1e7ec108ff22785289ea27ef103a91e967b86b0b22f9a047b82db1b3b0fc8 0bdab80595f85be9e761ca3b0cebb92466cf2deb2ecba7eb9b9d1305831bdfb7 f8f50c972019dc0bd9d47562acd0136a1b2379ac96c9476cb97898599bb63c3c d50a4b922cb5032237e7f1725797c06d127f93ee4cc23ff0087111e5c21abbd5 0155f17e15fe3fd4c252f49b150e896eff8a1ca852780e2b7eaa6e329abf2b1b 4d83e80fd3593d9530afbd35aeb40dd72ae62de5367c39343af67a8a2d2a5c8d 6dc27324684c2eb3d669fdeec3c5e7c473ddeda246448f0f056f8020afece161 622552f6e2314e14b3793d9613a16820334184ab23b09d97f872a7bee3d60610 bf3f1c1f45c5e40be64ebc09d7091d3cfc1910b9dd6893cc420f752f44478bbc 320eb7d5ca954364adbab00f58b85efa0745d505c9d1a029747b24be91dedae4 74b68ab7e2e37289f406efed4a357cb55cd437226e8ac36d0583cbfe0375b6e5 a0d37496803130eec4cc597b3c257abee07b1e91205f4058d59ec3b160c5a8a3 be6022ddc2d16594377e2da99446c4a96a3f919ca0e05e1ba8b9cbfc91e29eb3 1057599582001dda431f86284017ac9a96f0ab166a15bcadd325c1e6d48146c2 2d706c3b64f4a32438ee88168df7d941d8c7f84f229aead45c14c935b080fded ad3ce7e7e79aa1a651f404bc4b86940e0b17afab3a7c555d09f56e8081fcb4e9 7c9845a7b482340a22160ef2dbc1ae988ecc88462bad02c12578616a71a384fa 2f2bedcfd8dce0bd4b1466d7e98b55c9c591b3c853bc6f7403f09d8713c5b068 bbd65fc2bc34ad4f34fb289eccf5437d16d7776780190fec25a71d80d6d6e3df ba465fc2a5db440fade5e45811a365b062c89f0032493607cc9089d46f485cc5 f63da2fb4877c2a1153587e08ec34219219df2b79dda446fdc53adfffea9e8d3 542aa5022b44d0395818271410600a3e870e9a17789283db685b6007fa060101 351dbb6288d08e1f3de47846dd8a4e7ddfd8a750f064103e25d6d68835d4dc1b 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 false +check_ring_signature eddea6094d83b53e84b126b16f48b4cdcf203725a1c78ae33679d3961aa611aa 9197b81d1a763851d0b5dff8d7ebe19ead486a9f1215ad82e32fec18f1b6b30f 8 a2c464c8d765cef11e0903fb49798ee411c68c8c852108a0587cf85ae00dfa0c b9a4ab801fd636bc0519a69cf4210d39e3f8c23c7fb79bed7c824bf49ae824af c6589d52b306c99e58e240051c1692827bda60509be8bdac2cea7562cf624235 1830339295aafc556eb31448ff9ddaf20c2e58507ec3d5f16284a2fdd2b6679c a4653be1caecaf18cd95a30fe9207e81ef226bc831ac968a9994805539e0f8aa d527a05fe4e6d87327f7c8a40a0a2525a8d253b8ba4ac32d27e3474fb8f87f50 a2212dfc538f6910c32cbb7e5528b5a5024169b5c33d4316d5980232c852ed16 a9656e4b4e24be66205388f071d497ad982df7d90022c0e992a0974b5326dbfa 3fd96ac4525bfbbc8bb4f1908b55c34d719405d7ce64bd3fe8bf3b8b28f60c0345ccbcb569904ab481029ee1d2788e9c4ae7333e8ccefbebe18edc26f5f0c408c249677a834daf59f4be05eb28d33e5f03d7f8966e5026c487d359989a3e2009be1f098c579a3bea7290dfb1a09f80bb105ffbdd862fd12243b3472ff17b410f6603777c9122c4d15fa1a8917662c84be874ad94c93277d0e1080505eec8c30f14f770408b8378483af2c6c25f49f480f621df01bf16d010cad2e19809c7440f6d2025cac5113e306e94cfbbf8f6d329b2cb0681f59686294ed289abc8b98905062854b5cce0b0349885c6fc719f707a40580a28ce16a127306917a6f2e84b0f57dcfcd21ec51c323d93fe899fb6b78ab83e543c4c0f2db019b92eb1e2e512093f5db385c15f804cb63cfd1e88ef98a110dcb852d6074dcd8c6d37e816b4c4041969e875a91a7651b5470737266be63d42e7fea80b037e1609c7e78b612631073a271e40d85fa250f7868c1297961164a991f76c9439b226a5069f9f06085c04bc09bff4672ccc469a52412f79ca4951b7f0b2dea885bf20f30352f913ea0709b3bc4e82b4801faac7a0828a34cbd444f7409107b11fddeba1dcdcf840ad6b0beee1a7ef3030fba8702d9efdfb56a9ad3020fe2a7b22d93f32733f1681d62403d926c42dbe6f7d660cd2f800a675db60c8114449a0a954ceb25a37f7fab30528 false +check_ring_signature 79fe3cd41f7f15a91e5962214228b6da29fc998910bd8910c0e7af830cd50b3e f2b0846557c45fe434c72243ac351d01b654b1afa29f771d271b4065010500a7 29 39262070c50b513ab3cbfe19a873395e408c27c6e218f6939afbbf3db8f45167 7e088b3173925ff4b1828f215314a291c191289b1f91de344eb5a18bd94dbed6 eb2f64b4a9fc086a3d2fdb74ce1ec9285740df2f4672a2c74f515781cbe7690a b14244c6991357692540482dded0a3b9c3880729b01fcdff21bf1eb602590713 e278a890e6b0a1e440a7162b050060f0b73e0f37c61e5ed88fc7d9e93c3515ef de2ed8e32186342026bce2bf8a7e4adc71c0592bc9b4fef636270401cdfbb2e6 48a92c22a35c97b67b40dc91fdd29f46f459b7b02aaae34cdc5071fd0b9fa291 c4749918992a5d8503044eb7b7a22053c98a8ac246a82b8921cc72e0541751e4 2022d7a8f77be4e0bb2b89e768a53a0956a394cd2e6e722a5bc36e1824bb3298 8dad14ee3a94b39577148c33376c85e10bfdd5de39a5bec7edf340e1489cd108 645833272d16796e69acb34aafd7e596361d41710f43a41e9bcaf4aee541de2e 0cf05ebfd7b6e05d763e8e819597fe48ae2feb521b6878223e40abeb6dd6f49a c4ec7cf0786956718259d3db1466f9b723a74ac9eccdc52327269f11e9f2cdb9 b78fde318effec9f80864476b803a46ab3edea7d7837bd724ce372a6892a0f03 b10bc787880887aec1c9f0851bacb8104115196219e51db601288026efc925ad 0d1ab867fab4724aca396c8164066f152bdc906cd8dd9682caf787752ad18ff5 547cff9516b1dcf56b6149bfec8e3a7c9e5a3c0872ab909dbf06c57358a7fad1 fdd5cafbfb179dcd48b49d2bf0de9dc8796b15515538460c0978294cc7345b6f 76bc27f2b6fa2e4773100d5a7febebf4083af9fa0d21235cd0d14c5349f6f1ec 344ddb5d05f83b0aa2251749d4e5d622c954cceb1367299beccf0218895a5fe1 766ae96b0058f6f6e68ed337d86b7ab8d676449dd420bc7a4498d60297b8dabe ec10f979350c9b9a10213dfbb390abddb169bfbbe08bd7e79861006111a40d5b 19a3b077890f529311be62d1c9004141cd3104e60fe92c1158050f237852fcfe 196190ba41c722827836fa6d693ea24f64b576208722d79fe12ae8c43403ed76 90cda2beff73062166246598fc2572489ff97d1f733cd0dfce43a1a278a65310 36da6ac72ea8a75122a88c36bb0714e0782860054f00ad3bcd3315030f211515 0f9bf503b4dd2d2e2b911b639847828a77e31314cb6c654023f4ab9412d098b1 e37a7334f272385b16fcac7a972d12c2d9fa9b162345ad0ac603f010611499ce 44156c5418656d7008756478bb80f5d9aa4c803e6b13e56ae551c412298365e2 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 true +check_ring_signature 9e44c17e3365ff6f0d2104158903de8e408b06b8747827705028138843cb706b 69450fd5e415813f0816125ad22eb95a2c128485c11109e73eb4c0033727a336 75 f994016b1f2adaa33c98ee39d465d45548612e49e35898afe682206bc780cff8 f371e52d781256a1611a909e38d16f4c4e71255c3525591f4095c3bb6582969c 276b42b754ee475f1dc926b11227f1d211eed83c711c24fffd4a0d81b58d127a 86429ff6125e816902a48f4b0d1b4d75d198f6210c6231e5056e25dc03e9c008 35d7f56b6b34700d47bb9e9102ff48861e381668a57758e53feb621d65634c90 e06afd0024092cdf4eea7b3ab5b87797527bf7204c428e9a5d21eeb9b843e51d e7afde0c85360c877ebb47b51f1db4284dbe2f960235182262eb73cbc1683a26 d65cff48aea6274097143f140fff7647f89f3e0eb4f29ad8d2cd51fe44fcdbee 9a1ea7287a378d24a37a14c3ffceb739dd87ba05fe2afb58b7541aaef300ce98 f6bbc331ecd153e6a9470960c92b54ee118d8a553a59cc147b9e0220990fd974 fe958276fdd3077d99e63f81f000ae98f9c3bc10e7aac54394bf856bcd2ba116 00a7ae663ba271e49428f2772eadaaf517fe7f81187eaf23b6f4196a559cf34a b51b6405bcd2ecd0d42b370815961b0ce9c7cfdd76cba5bc296db898d7eb54f5 ade578afb58e045055e469b2d9d822e712538f1fac330ba956e97905251b476d 8d847e1f6a2ded67bd43b92c9c9a2b3c123b040f2dd686c9aac45a1d32bc7288 649d6f3dac83ffb60b4d000c1c5018e150a3e856f37ba5d56ee66fffda3b7e3d 9f613a0e80282e10e82499e62639f92b32c49ec348cf719e8750974f96e00ab4 4afd88ca1c7af4f48c3e6b70acaa64e30053c1876c652cef7ad1a2c07f97f814 04659495ca28d1576868247fbbd6c529ee8a11debba0c0d96191dcc2be26c693 e330f14808caa6f16db02b8f94348636e945e4cffb57cd010586f2f41ce61335 701d945d8ac1d07c7c8582b1f7ca731c991e727ec767c1a46a197a7587fd86b0 fff49d3d6d59a94417b0b76ba46703af67145f2e91d8c23ebda4a0b29586898a 22f9bd4afdc195a7af88d469672cf6edae3148783b7dd0bc57d0731adb818a7b 6367680a308d69e272f69b23a554af0064b1a31f05d332179ace169fa862ca1c 2b80e2aca93acda60ab61e4219418a2644e2dadd48a1eb215cde96bf29582b58 9ae117879854c954cdd5f08086022ee612a792d73c556479c5e040b88431e3bd 3686dd10782353af22900dc4d3c9775fcfa271401b53c904a5b1fb03888e5191 2fdea503b61727edf05791c96fd7ca31bb2a8c2fda084f7447a3ab0fa84b66c4 9f900d6ae01d720d8c7edffc54e1347551e4f10ec2a8d57da5dfd9370fe3882e 19fa98ff09f7e9cb84e77125bd7d2b421261281aca346478ad388d8087447fdb 0b5c3156e18d7a79bff7772ef2558ad9074f36dc4bf905f0e57618da71cab3b3 306ef6d370002194eda107665f0b23162629ba193840836a77f26026a978292e c30c9df3b01c352ed1096e1c01b97d67563096bc301d4809d31f77c6b8d4c186 57bac8b6828392c2435cc20647bf1594bc545dea7eeb7744b7b80ead0c00bade 5f2a642e96cdc4ccd61c721d5be4be9e91ef155428268928e4331f3ac344677e 53dfff765e13576d2a137219113d7060518da9b65efd7bdd8713ae9f8522b4d3 b8aa9246c45cbd3e579d439423d45287ced3bf1e7b3eadf0bd9dc621e887b8f2 631c8a7bc81ce360c2cd9c1ae2130aa10658611e1bf5fd8c64ae69d91df64b48 5e6b68448b69b8c7247c07b1e16034bf3c05c70fec79c890c8aaa7cae332167f 0eed10bc9e1171c40868e30b321ccf6ad7baaf637bc4510330a93c1816c6af8e d9538eb5cd1280297383a73c4c9a3f784a7d84177889cd5f4ea59e74c3482122 02cba84a58cd7fb5efe4b8708234aa48b6073be6c099359fdfe72813a7f4fb22 a164321840497120ebfcdd83d2d88bb9c1eef20ede5747172841bcd95068d2b6 51a00da1eca80b921ceba75625d404ea154b6d89365a3d231756f779b92d4d91 0fea288dca9c10dfa6dee44b3f42a26c7acf831d8ae4dce781161ad263d9b0d0 d7fe11d56b42736c521184ec8a7b57088ed8a0f30e164bcb9eee097d34f19272 1dcd27e0394dcf03f71412b7b1f098789a55fef9f7fe3575aadbe47b4627b7f0 c57b3ecb129fdfc113cd07316e60ae414b726423363828b4502539d6277b041e 4e095bd7db753d42e3acb0f137b195ea7262ccc4d65c71c85baf920547064e5d 9cd6792695b039f478f4b6435d82f38798423ed0af489121dd4811b284fa2d10 df55d0244f7df64127948a76ed448c533ca6adf209bb615b613de64ac34544a2 5974be4637f7f46b3c54c4462c747d23c0b31c383dead9acb25c7e439a4461f4 3cd952d00941c0c33716735f0d9d0eb8cde6be0d91bad03e609952ca518951aa d4c88bd4f778b8776d5ed058ffa405f4d816f493aad73518190c70feab23df39 0f007e8540f24c3f574aa6cd2a63469d1b4f8f015316c0a2ec4a28e40d289076 cb8250c3a377f5f703d4b0a50faa60ce1238068f0a2d03a1806c606388ca0801 c43ee9525706dfde5e1ad1ac7d04b72fd49ca75b8a21bf7c6846e100ae902349 fe8c2564d7258dfd2042e8058b9913cda9c47f4df3e062bd76f58d7fd5fee2b4 441b2d669d90cc7f1fa441f570825792e12b3ae7e728d84de6f0cf841d7ca1bc 06212940981b5e4ceeded307f481f272e449f13c66577eca9bb513c20441fc1e ba88f50b769c57a19fb3b50926ee58f82cc48e61daed0f4c3da53084ed0e11c7 ea20642a59bb5e1ab43f5701df7f8593858d15cc05fbc16b14540ef827a138b1 469d710eff458df150f8d2cf7d378a51c759ada59947870f4b3a07488b9bb0fc 60a09f808e658a0a549be0dc84bb25a16abb4f52a1f54c3631b3f0c92ee88730 567799b2e8559aafbc1b1e306db90610761b2b15b81633856a565422c7b10195 e59bb7ce95e7ff0add0f181d655d9fb8e9fe540a23b26a0540f424d22d393629 ca65318b21f78050aae60ed58cc0ec4bc926dc9ac683459bb628f3488e163c78 87495927d6f84be3676e810817a9750fc349ff007fd3a757b92cbf26f0cf0218 4348beb3355118349d76ee08f2a817602c8285771e6da42a46c5992e09f136b8 33f45ea8002e551e2058be162bd7bd9b6fa0efdcae11903a57a8f66059b7a0e0 0880b00e6a447069bf02e6e36cf5802c07f05835582d5312892fb0bce09723f5 58791fa2b30bf4a9c2898d4a366e6cf7bc7084c9735bf7833de78f7110e326a5 3c05f1bb047a49e7bfab0349367c683579bb022c9340cf93a19eae8e19addb33 1d51e4bb4646b4b3b37590e4db398cc3b87fd9ce638238b6d53738828b203f7c f59fcd934d6c5bc6786c7ebeb84908233ee5fca56e9e49ad4b771cf95f2dd7a1 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 false +check_ring_signature 768f9bd295407e7c620488bd7169bb81e2b4265811683454d894ee06bfaaa9c8 0d5bbb97e4292a78a2b38e75406451d4f090666e2ca35fb5df181e0d22f6d5e4 14 4032e7a274fceb8aa6cc5d5511f0967bcfe3ccd92ab3717614bbdad8d21fe47a 30e7c5648cc340626154fe7c4a2b37fd15ba012eada7f24fdd678bedf0bf83e3 3b8d1173268ac9c5db7695ceffb1f08f842c2c2e410d386d687dc77900d91622 a7885179b3abff177c41cceb8595eb50a814180ac8c1414722f5513a5747ceaf 7abdb00bf808e4f4149db0a1a2211bb57f38528eb9087d2e54e30bff6834aaae dcc1986fc812eece8a809d5fb2a01a77a73938e25e16d7100767379020ce3a0b 7c62b6be138c30fea287ae375c1f3240628c90f3747115f4a914afcf2058862e bd9bfdd5528be1c99e6e758ade6c011a333cb2992311ce807e6711092a85100d 1d30fe521ae7de90cd9c0dd1cd785ac450afb169da082221fed9556874301272 62a1359189ddcc0b1b659a74c3e93433ccce04af37b83a891345f2495afc9d0c 24bd4ca3c6bb880a87b005013ef41326c8eef4c3084af11af473584d0024ec40 94e6d4a4f5775c4f783b8c313ef8848b5b4d28890c64abc67d7b0b67db16755b 8788eac62628134ae67cd8a4204647a6aa40c96c4c9d9eb64f37ee0a0520b779 da487f260719f5fd1992019aaaafd885550bd0ac0ada573cafa625b937166373 2c072b57741717c843351276102cf3a71dcb9c42f37a03738e2e4d5205ff837b91bac55d765d8b85cb3c5bf23b051532b8139884d590cf2426ea8d6adfc5760a2aeeb2018fb8d3ab311421d9f8a334a66d9d87cd4c789e6962003bf346c0b20d91e0c037406b16950f437cd794a5ed943396972915501de045b319040f08a506b04572c316ce493cdbdcd764c2c792f41d1c99d7150901c6689adf9988c5430a99a1924e507efff3c015851127a00074ba1abf9ef22e8bbc418de801b628a3e4127f2d2bdff9da01f7aa81881af2da58daad8a820ccd8ba967281807a06ace0f5e06eb5758b9a38f2f104caf1fbf04796b85e65ad767e8917d375e491160ba0d555148e916185b006d1c69c839eb9a032ab7961b3eb021b3047dec9a02f8e90c8662588b230d9dd4038858cde7f4b3696121c680bd2c5c733a4a70fb113a680b8a86bcc0d4852bb1a54a133072481e897aecf962eba32f9fc0685a6382646700e1eb56c92aa5561eb72f189793e4744ae7c3d9dbc7e991419c2fd033d7c28904adba1e35f93f1936dd8e454304d37d142a30ff5042ec1e2ebde4f0b3fadca805dfcf6d12f3f82c761a493755e037596d4585e8531158dff712519fb77e55e50c5144e1b4054672c15b51513fef712e13082116b9a163bd5dd07c140a6afbe50c2dc23f01827f847c119359764bf4d74043605053cfcf527cedac39a794ecac0ec3a369a3cacdbaf48c6cdcc62cabbefc1f0737f7165e184ab97e5f1b4817830a80f787d31a0948115af348969cc952933515e69d6a92721fe8df0dd33428e40d97b7ca3e9eb48cebaafab032458178274e1c40d8171068d11ffef87f9b9b6106b2a2581a978576fb6623ce5aa0e7745b121b02aa312b02bd9d3f51314394950da80edd5138ac2f1abaa995bb7aebbb9dd65331c09fef6587a1622ccbd6d9db05472b5043defd93c84a0972b684e556ae334d05507dcd3224ed439d6a387f6c0f341f49cd96888ef25f666f2d593491f3017aa04757dce282975dacc8d8c23905762c4871b52d81158163f4a7363f245c0a7081374373da4816eed771bfacc506b3fe9c69f020775abfb97a6d91ad073c659419bf7f5fdf9c04baa8ff2ad36e0dd186605b7d81aa4b3ca90231b3a3417d0120e844c8df8c53208c8593ed7b8e0ac83c1f5e60e2fec85f705e75a51d480e8d056d87d8c282bc43524402d65d45010242d1f91086a3d5612483a2704caa171e1d4c309f81a098a0f6a4bb210b2506 false +check_ring_signature d4b797b9c63f8572b455bf038c1065babb278290a60addb318432b026872e757 4feb0d53a5744f0790b7b5b2e2290b108bafd1311a5639a065453126ef01125f 1 4cd35ddbee8ae48592c99785d9f68077003d8db6e8cd1a12fdd0c2dacf71e1ca 753af6153735ca73f2141a9ca32b5143fa1f6064f7d64a1772a2addc5b503d032cd5f42a9a8c529f3bb13abe6d7fc9e7b23dc4a02d2e306a5103d1b8f0949403 false +check_ring_signature e9a939952ad4b421cb7c3bdee935d51ce61d7263ff0d2a0622aa65ab44ab294a bda4a8174f3fabdd96e69082a319d06f75442a8892187f968388ca80394e01da 9 3b92165d2fc98dd074ce0da90f67cce4f833f42f9ac1442c9ce24b6c69540f31 bfe8bfaa0612398470656e55bd5137cd3c60ecf69b30894cec2e7cde0ada8c37 94e62d882b0d607a4b986be0517e54a64f04e19555122e3683c890b2e0215216 8585b663263da66aba8cc38dc453aeaba5e764c5d471a9c1e6123426307d3ebe 1181c74575fdd1fee856592c286e027cacaceaeda7acd17f5c783f82b4ac2e17 fea2729d6e67a6ff3721debee04df6653b2687e55bd1eeeb9a41aaba8aa45e26 d0f77dc97d0e7fc37836f3c70d771dda28e9509479eff4727969efe92c28a482 e01d543543e19ca5aaa80cf39dc499abad8d5bb09e56d6de8c0a748db837e943 7e27d8d0ca3f4ec2576e282017189eccb9f91f09bd478c2bded323f81feff2fb f2fb09042220c5eaa4c84a3072239c5df8d487ab1fd6e678d6d42a22b755450dfcd97c05512809459c6971aef36f82818d6b1d4e68b35e2fbb88cd3674cf6a061d3a949c00c293e9219add667a528c000dc993a0eed60ab6d3bd2f597760d2070070d9595db0c7e0e3a9737dfd3a1c1186ad0dfe9ebeabe16e2b25480183d0003970753e9100e7a3240fc92aa66aa0420dfc0c6f5e38481afea4de3f2fc4c70767e84290b632cd28b2c4fecc23799517da92139127f7de82a7f38884ec888605dde7eb8c44066a9202974c4e393e95734ecfdff322418e3867e93259efe2c103b0933c7043933135dd1511befc9b44b6b291fdb1d322d620387efb6ac741230f126873478af78fefd65ac9a2d05c8ef9da271a9d8fa4cccdee98c85221441101126edcbd9ea22fa22e4d60fd1c384e0b8ed6d1ca00c0bb625599d1c3466a57036b810b4dc5f60b9095b4662c010688cd8c5df0fa6b612ef44b31f7ff058df107065fd7738381c4249ff10da025bcefd8d307045089d652a9726f38a48dc44a0ace56ad9e4b747ec5a386714c1ae0869a704d643e1a8227f2544ae5838397230cfc01052b014257ec674cead9299c7dea6334a3e9821133c11cabd39cbcae1c0cae96b0624e0f7a3d198334f9af36c26922e3ef81ac8e0e3a5a3995db34fa6804d3b4f8463db69d82dec399be14a648077259d1b40dbea7706427db6f3634ff03a86e52ed1b419c6635c8f6639433afad56059c3bc67ca3295f1923592c7d8a02162bafbec5a20348d871de1aab6f0eeb04ae96ca0f83592c70ce0919de690c0a false +check_ring_signature 728920b1610e43f7c4aec79245009ed2171c82e9440102e5582c64eb7171a89d b2d7ebe629cbc0dfe01b3ce7a41bd618a7ee2097a0c912aea62feeac9df5bee5 4 167b38a0c54081c050395270390402468bac3031f3a4696bfa9fd62ef579ec87 cadf37e279f0c67cc639bd886430f752f59350640a80d7b6075853b28db08f87 6377d5402ebe27b30fa465e1d4783736a1f9480f5cb029bae2da813cc046510c 22bd331fd92bd184d97d8694b937bd133a75e104c353feb0145288625f585aa6 794e2fe398d7e040a4083949c95364cce2ab24ad382e87e4e842edf614a5a006b276c61a63f4d27ee09c7d2527370028fe5f6a0773dc58c2cf2080725315130825e1db190af69b0edddf73c828efcc7d9b9e6082dd57e1e5be7bf58f17dc4a0699ae811897f08602152ee631888eb6104a47b6d3783d2213fa25d93c53a4910cc0d53fa7ba9228e5efe49974cef1dd57cee1e21994b4187ac6a47be61a89310805e0c6d608f06b3601f9f8be1f05f26647abb1065a0a2fb91a59b348a2a05b01beda6aa995e0257873203f7ff235a113e0603996afb4c223309565686335110e22097b94072f107464f7892f38f972796e95341d4368773e8c6214360bcbf80c true +check_ring_signature acd4dd8537a944a38a652d97bfde716e3e93ed5061907b536f7a3ea51122ddaa 27c714d709bbb77feef1abf330bbf3581ec99d6f6c6b9b760e1d8015a89bf99b 2 2a3036bcc035f01df2ce4887bdf01434220fc7a50aa434e426e0b286930c90ca 162fb3e0c191f7ee7a9986d041c333a7ab1bfdefc3b8185822995d500bb0607e 3f6ff4df9b33df0b90c92398073b3bf6f264200b719512a0268c2c38efe2b10301dd2c1768ebbbb5be33d94b88f6dcd7d49b05645092b7abd46d41973d57c10fee7c9014db076cbd2b2d86d155a78677a08a7f057b6b3aafe888904e7d11510997ab53f62007d7a0c9f33ec0eaf941048ea82d163d3aa16b06cbbd6ff8d721c6 false +check_ring_signature c397b5ceea172995f0a955e68b184de45570b393f330c395c2e0d769e7715c8c 732b431ab01ab3b57bcadb3fd402a8b9b919c64b5fce1cbe5649b5267fc07699 58 2a3ae937fa2f57a28eba7c32b3810b7c65dca6854b7e36a4112488699b8f0aba affd9590d01d7bff9ba12ef509861c2462b78bf29567204bf6bbdc5324dc8d99 38f1ca591ed8827ac06a219ae415c9ae4df5a2e5f780bdfa89bf04792c047339 d707bac733f41e13fc5bdb4c464d0fd907ed253c776807bdc0d3f45c53f439f1 bd777f798afe75394c1ca08d75d572d6008ee5ff4027a78bb6814d22c0c8ffbe b3cd3a81685343234858a9a5fb7a04669ee7e50e2c5adece567b0d5d9cb447b6 746088dc2d2829bce8419963e7eaeafb8a766282d36e07314e6563a234c85864 967cfba782315dbcc21677b001072498f4c52f8afee2c1b2a1116e548afeed16 8495e3b774ae3ab9d8e05f1bb5243f3438a87a0d60bce95583e354e6733381e9 cad098114f196454439220774152dc6c68b09f08e7598b56e08fa03183225a6f 2cbfb14d0f7cf3282b73ec8b021f6594889a05e0172691cedeb7c6c8ee8b2be1 500a3a603b5ce1b402faf25128ecb92c63ac2848d984cdb36214bd95efe8ea91 a49ec87799bcd1e874813998c37651e01e4d1d1ffb12637c0db1fc0a0996a4db 0536de0b44fee68380bcfb71199547a86347cd213982971515c685160fa3f61c 771adfea2951abb04018f064df5b6da1252e213b89087510c4577c03211643cb a820f6103487d55a71da4ffb5ef8377c7cb4936f08576991f8fae8a75b3f4486 9bd4776d533aa2f9f7b55475b978ce5e2155b22521f32e62f0aefb87e329331b 00950afd5eebcdab93108eed16ccdb6fca0ceb854a5cb294f13afc511cc44578 51b9e2fc605aeb36921fba8c64156f287d05960aa4ba4d62578dabc699e191ea cef53f09bc0997438d22bf7ff4134d0893abdcee893c91c14a54c012e9a284c0 f699282b8cd299635af26f6e09c9df77f3209b41e5dbed388f6da5a0fe87defd b6316077dfb6fc5dfb367ab69c282890cfc3129cc3b2d9a2acf79f90f21d5c7b c5aa8d86b18002b58044ce731664d56dc55c3871b3e0362f643ec1f680f81a69 33f75a7ad812f414d744611791718beec4ecbf8f1093ab499ab98e00fd0f1435 8e2a1c962731b9f06a4763507a8feed4423cf37069e21ef5323ff52a3cea2276 648ccc39bc362a56f3086bd4d0a9afadad0953b4f8d76ab127248b4428e3a87a 58e548c386afb168a12697560d572cd37b7d15ea687d3037232898d3bc68cabc be50e56904f317b2ef5f6eab5bb5f46a582d2d9b539a44d62541c2a35fe849fd a490ffc6067fdcba8041600dbe96a6b4be192243e145845585b6d07dd382958b 1bfdec4336b76d64b04555c4d07cfccf998bde8821e70ce6b57d11977b3263fe 7f700d10f92a3bd909e62756677a5bdb05a98e1c1c5ff7b36c61908c67bb1592 c97401f01dd322a95f60fefac96918a7b101e6debd077460f7926cf5f6318a44 4b5098882dc9120534544726b682cae3de119cbe975961c03596184653587e60 bd13e87b4fce559722e43e046db47313d723642935b3d071712e0b2523cf422c 0437c0c0cf7584c205fa864b7e979fc6baba463e42830956e46693c5ae6967f0 17807798037ffd0d343f46831ebcfff041bc2972a922a461ebceaee59b688a1f b8f94eb96515739514908c4b5e05dd9af5b0a685a7d1227f239cd6688ec483ae 21c347ce196b9b032598ddd3f0d8d2642ffb7cb45b0604fbc92989044dcb7f05 aacf766cdca6443f0cc5ffb00963d96d035d67b032f93e8cd268806ca0dc4705 4b99d63959c7b0142eafdb3003562c17cf5881ae31056234e95b4d903826ced2 f0b2fdb55cdbb4e79c676980e2bbd79be80327b56b2bd3c7ed94ff5b20708551 dad31e4f3ba8c86a714d14534f60aa45f529b6ee19711f1e4f2b30208f78dfd0 0a77506c874a2a707642e9d61acdb1b18576a309c8fdd1e86b77de3e97db15c2 8fd90592d9ee34141be819e798aae7134211969d3d69c06b96efad98f2a04d83 de560ff497d7776287d27aff8d4179ea8af09a6ea3a901bb32faeef39ab15541 f82ae2696854c50c101aa4002ec0004aa554cb026ab992806c1cd6745a542356 36ab6712cf615b98d65d0986b4b6f8500d7f9eb94a845f731b1017af4fcd3db5 b3003a6f15f02bf1d5958ea29d5f5019952fcabc837cc848462804ef90c21ea8 4a1f4a7ca5c52ed95c06d635394c560ffc4e3c23f3ae50417d83d171048091c7 868d26496270d892f994eb4e0e9935790b1b7f9e2ff274ef616ea199919aac8c 653ed38da992d9ed05222eeab282800ca003bb5746b96bac004c5f33cc6f9184 1a4937180b27960c4a6584061564da47f755b728724e0b77ff4b27b4a0c2d148 7b370d87a4864ced763df999acb26204aa67b9819a2fb0d7314b7407c6f8c10f a7e4aee9f002eadb3ab757a8fbcb4f7a86507aabb2ed73ee28d7c57589fd6089 4056715cc30d0d673c0f5d8cdad605abe3a6382b506b9929962d3510d2f9ab61 9251664be97efa663c9e9d4f64548e3034cc07ca7c7c92b1470a720ad06148bc 5bc44db086857ea782ad8fd977e7c98be1dc33f5934d10b214f7765d934ac150 0541a41296ace5323a6415e9e91f8ecaa1630390ed3c7fdd74137af1f99aece4 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 true +check_ring_signature 795fa61a2b145dd7742f0d619e7a378c857470239b1f2ff90329019d23d060ef c86ebb618570c7a1080de1b14a9a7f7b53f0dd0987165852521c1bf5259190db 1 ce71df83200fff0cdfd9e39dab5b14f3eaced4c74e99598ff32869edd1d38afa aff55d73f92b11e156e5ff00c6e1fd31d70b1daf9c5bd341298a51e91718e10e1260fbee8185145e07be83be0512a58b64702a5a63432858e28223e57676d70b false +check_ring_signature ec787436518054bf0df0bd3e1bb9542db28dd09fb60a407b1e57881d58ca19dc 96d3a743d45e54d0e7f35b560885107b016ef7d8f58663b81f913e4149b49812 1 90031c55ad78a182d2fcf052a7f6b24ded57cf82f48994731ec9bcfefd83b18e 7b5c75173557917b62c259a1288e09a8b1682070b09d778fa7ce4835a1080309992a1a68fb4fc8d133db23b89b131e6416c734059a6be4687cab30d967265200 true +check_ring_signature b02fbfa5e4f14108561c713a8d60972b21bbd739ddfa7763afa47b3ba69923b7 a32ac790defb9280e8514af441869f6253b5a38aa2b7877e6120078190cb9b57 1 c27a729c2b620fe360d1d4f9f0f0403417ea6f031683709622efaee3a482b32d 33bdf893b8ceca5ed4f79d9c2afcdf8a0e6f4c28420af55af8863c4d91f75201e4d79486a8a5273c4d7c3096e7ed6af25684343bf77f8cee62380a8b5650a4f8 false +check_ring_signature 18d7f068ca522ee0546204fb8eec961b2d7854ef549d8e777ec60e82952ee344 e3c34ed2f790b81a81b5d48ecb6c031ff99438bd225943dba053796507eb9698 4 3772017ebad0b97b25bdf2de75d5e3d732d79a6685c8bc29b62689ddaa8d71c9 c984840c76ff890e0df999035d14c2aac37fae0a4f19fe2c65be8cd38346a890 a93f8a4a6d73c81aab706502212b4d8bb83a2e503ab10b1175b414f19bbc22bd 859f2bfc4eb869c0daf71fb14036447c31213015e7b30b70fd20b1dd2cf1a8b7 c10cb8c2fd7cc4bf378c464c66ad794a36e8dbbdb3acacc7e4e4810d9aa33c0f6e2fa30afc4a0439f3d3ee1d48f4d781c44910486a2a7f3886fa5d19d8ca700b1b3bf75df342883288c41f62a6f256774ff8e989648ed8baab3e7b047469530ad535d120d65c1c87d0e14ea3ddc51c24a9581b187ae5a1e323bbd4fcd508aa031e383010c86ed5f6a02e9e6047bbe1b166700fee44348b7b874cdf910ae1660021d6bc5b8af92f675b5dc7ec97c596e3f50b27268becd58ba59d5b0cea59570b7f03b7a495edfd19e5db4a1464147bf012d361093d8f18527eb5bf0a3eda45f99da1e3233809692e6e528a611206557769a818bb4922ef252c570ec00e5cba03 false +check_ring_signature 511759551f25d100f1f557f0eab32275c6a8fb9125262831f0238198f0c7f2b8 a04385f838dde4ea2fae8bb886be9bb7e243fbbd46008287ec04b4d2c561c842 33 d1a94a8a77446165efce1b68c9b83c7c9e2f3f1f39ffe05e373fe524456f04bb 451626da8f6cf01b259aa7204f13f1f70ac1a21f4190d7581934a08baf53db11 b577942ed8fb17a17631730bed324bbe74bfed388110bef4cadc7846a4723d1c 63271c04fca28d0a34278220627956fd40659a94beda3b69fce8dd9eb68e9954 86f0e610a8651082ac6ca3b0763e33d4dcf07b1f56b4e0a5f2eb1d0483d9d188 3a5fdaa55ba84b9164cfce5210f8521321ffa8addc63b78ad0148b4f2bc2d7ff 3af94e1a170089d2bd27f43b11688895b084a1285ed6250c123cac4ddd1aa952 2c87ce303259943bab64490fc6e7734acec393c06a21b5851464a87e51e3e154 409f507c58cde6546892be0159a45c7c59bd5628ff24691cb54b4330eeaf221a 71970b64a01ebb426948e7eab4c48d50a56d18d988e48e675031d5defbfed813 6c25c4409b7ae0ae135d84bc034ab671aa057f12a96d48b61d9d785827ff457e 1f5d772c0bd54dda2ded3dfdb352ff4dce7697a68549a7f7c378567a86a0ef29 0c833f0b00ba3b96d9007b55b610abfdc54650b607ab5f89d3d242a294bbdca3 1e587f7a389309d8358911da769c33318846a938d75c1cb91956d88c1d157393 2be0a36b52cddd008a1d569f3b6bf6fcecd57cce3212ed074ae0f803b8a54775 3fb9a9687a572e34862fb1f79e484cd2998158144ba7c39726d1946b01a107d4 7444f93bd443b682c991d28c066c1fb3b748b780107bbb61361f8a2398aafc19 7ca000404a61889362b73a4ca594e458ec23f313d2fae644b9a3bf574ce8747c 558d2c405e051c6565b6f2440e62786edb7e8de138899419922cd631c38b42bd f8911f804e054b27949fc28a92044801247bc57597d123969c2bade557fead50 e35a5b0eb400443e09b8dd4751a401338504bf727809aa09f5f77c42f299284c 11a60804faecbcd5b1dd24674cd7f5544b08cba50d9930aa5698a0a0af73eb38 19a3de9c1693a252800f8a20f5184ebe07b125dcb731bbbd3d0f0c2fb9419cbd a9b0d6d052d6ff18e1e2bcb51ceff12151dc431074bed69ce50ac4ed74a60d92 bb88a408f255657291b2f9257d26c5bd3982ae8fd4adc0050eba90a710363d30 ad6a65ed319de7ac4d03c2a3d0b53d3968034754697b9580f99dc6e6e37939de fbeab3f6df372ff2271dd2e77ffdbb5420db5e24b81d5ad31495ad500d815874 039655bd9920743626a4a197b7b03d4c6beba96cee3c3848df8e2ab8a310e3f8 a75719da7465ee2825aca3010be339547fc25c8f3a1b582d850375cd735fa6a2 7e192e1d7a015af3247bc1cd1358b2b8356c24472eda851e224b957d1e250357 4764e60f81dc49dd913496253065156ece29e24d712c1f95ab95ddfe2075235a 321e1ebfee3914614ace179b0666eed064851e59f791ab0fe6076d5b42a3518a 3b7192daa7cf35e3ad61af04b886614f90ea4c5ca63b8657826004086244198b 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 false +check_ring_signature 46a5627d4aaee743ef2918c34a97c0172fe9d9b1573d9847fbe79c42e65365a2 b8effab5f46cca119cb4b5a4ec57c4567b8a1623da3ad0987b20c1b9728d2db0 2 4ce6e0bd756b8cd19e68091ea194207ae4658ec71dfe9439d047215de044c416 0ed014cc3236acf342e88b167d30bd4f93f0acee1589387837b98c652d2ca5fc ff9b71e498ce329ad6ba002016eb1cc6d53418c359f431ce29d6d179f090fe57b2af7e5585de136c4336198646b8a2161c7978f9c0cdd7e9e1443b7dbe09e306db96fc59f746566f9cdf889fae37df2226958a3403846b0db7218b3d49b7d40bae5013b82f3bebfb00a1516f165a85907050861d251e9b31da9304713a48e705 false +check_ring_signature 21d8e4f2aabaa3cad341727182669f64acdf03dc3de787c8dd44e8b123443af0 6af23076fa3755eace13b61bb2544fa6bb93d19c0e7e5bb951a3f5bb5b52446d 1 f62c96bde8e6c26575b144d61509f7e779b1f2f51c698ee01c43bdabef7917d9 d8e2df7a27a136ff0be0ebe3c6ad517777b031456a60956df381f3078e64b90f19a475ebc4e0d8c4ceed2420a1aafe68462a386faaa68256dfe663fa36a1e20e false +check_ring_signature 0fabf192315a212c9b7318d2299ba2a36aaa5797b90b5de52d0e8befe563aac3 1e627ebd7cee1088f33aba3608e9c7b73445cabe54090196dfb9447046fc5ca7 5 b371831f16ae6cf259630c55145b55417f2efa27b85a72f41756a2267a9da1f0 7f9a121f063f934ff9b97caf3f246c1c825299b13f77c560140939f900524146 e7f68c423bf17bfe707e3a689654bb104339940e4ca5ea7e4bc4c28c25a82189 63bc4346c7dd99914e89ff66a48dc9e9265b0cc258824153ae567c7c3281f321 002289c079167ec3349c4c0f4726a0bb6fc027270fd29a0d4662da6673f3053d d22ee0bf5fbfb46b5501ed3b009e469f3b3c9ba936923f0b7f205c5031077d505e378a43f93369045a80951901c47630b8aa6cd55922bf138e0def5b299d420809e86e789f8f4db2756dedc68b5339bfabcdb76860cc937a41f0f707938a8d07b3e222f732a5990ff78166066d1bb00a81ad19d0d0251f6e9d248bb24642ec08cf4b1275bf92573d5bb723ac6be2f74ce827168f4037f81e61c7792e4310ae0d92f26897bf5820da71af31efd9ea2e47bfbc45d2056bfdef84bf4265c24a0c02cdcc49f1683af46a513500960baf9c1ddd25abd1154db8c2e968eb93a5772d0bbc494c9cef382e63fdba61ce07e808a1925871847f5f8fb7c0647a4db04d0a041541c50a99229f1d887b7328e75394c1607898ddc5db0f3b48220a4f23f08d08f006a86ae9c72f4ad045a598dec676bccee7206252d5baedeaa32f0e43fba98a false +check_ring_signature b857a01f60e51b4afe99f1d9eeb40916fe7c05ba15a208f06b9875a01d7a9fae 85e7506ee80795aa9f62ef55ecc2a690a24c3fa70d9c66d9be8ae3fe744a4755 233 47a611a6426a2e5eab07da9255de1dbcf356bce42ec145d2fdc11fd714721815 cc48a205e8d98862a27c94a98911ec3e25b76d4a6b71ab8f201cfd46b270c181 7f45e5fe637b1ddb58c89b61f2e3bf225a306c3d806e8371c71f4228a583632d aa59a0aa8b57403aa58b4546fea89979015f2cc790cc80f78578e38eaf210138 876fedefecf749a1a9318eb9ef6d1b70db63db5d795c2cc60b73b98add46f26a 84180e399925d8b5d260cb1a39aab04cd38eba73279a4c46be63f93e929f9f6a 7b15ca5167cde185bd5bee0131e01140ad05f7d0d42081b69d3539f1c77fc653 53f7b29daec64687804d98d3df6851799b4974f1a9744d282d0bf4584c650a40 f89a95e4280215c6990fb08c0059bebb394cb4f922adac3c45b1f830a6687697 0410ac23d98e46536e556951c590cb321f56f7be9f5981d85568265be99536fd 59e2dd60f3566f5e9fd0778730c073c088c7dc9edc8f5276de69a5163dae6386 74d80c92ec30260a6eb9f62fc0d14957bd5c883c95c1ba21b1e78a8d6c6b3489 1bf5f6c4124dcb8f8dcc3028aab92ef5e92fa31729c1b26d46de4ccbcf73725e 020f4140c10f52ab989d114551a72fee96f044a09f3c00786693e42e36d1470a adc78a1f42faacf11948b07b34ab3d7113f36db52300302912a6d019e4c94db6 79f2ac1eaf0a14957b1878fe1d5df2f402d615c43a2f7ad3ab49027269d82334 4d3083c171abc90a6d3a0024c1e70e6e829b0aeef98ac51ccd7c8b153078205a 3e47a3316d6964e6d0504af908287016c12a819b8c4af6ca652b150296ba0848 5d214582e809bacd99c5dbf351204dc73f74133c8c1669c000cba290e886cc65 6c27971ff97ad0ac8c0cd5a5db1ff2700955adb87fe2507ce0c8a968e3e30601 aaf0ac9058ecef5e9e61a701bccd28090bceb30819caf5ca4a8eb4cbfb9d43d6 be9f862761c2cc981eaeb38186351f47016a6693133c097930ae67682e119fc7 1af85d5d5558a3120cdd2e1d59fa443e9b073a11c427b692de7aee15813d498c 481fe5aeca9cd5bd91872fa0d6eae506d1ed06b14c8a8814e763f02e8c9526d7 21d55e6216e3b12a947b289ef928b12bdfbc5c8ce9a03456957e2df722329ea1 2cfc585d4cfb21672effdf7e3ffce70c001a63bfa2071d31decfaa3f5786a2db f294d5f24c7678ba4285a187267e3cc92a6aa797fbf500e140f1113eaf28b0c3 65256bc6b1a009ae209de92812969028d192976c91aa95938723fb3ce856bdf1 e7ed8e1775bd494e53f234276cc45a59297102c8571ac39b9df4db099dad24d2 39f33248bd50f842a16921d17ce1589b3e46a2ed315934066f24adeb9b5339fb 7a037f4518e4489bed5a4b8f9ddd681d0a815946f0e89346236be54f7d9cad60 742f67ab63270d79a3f27be894c79060f52fce5f20914d243aa74fae0079d1ac c986a0aab259c1f2607cea170574c6d20f0d5aa720a3de395c4262e6c99a75a4 cd482d70129f1d2110b731b8423647fa8bc0511c44ff8975b7c179030aa55762 bd98b3295291f1d8e9c14e0ed9b6361cb1735b00c4d8cfd16a9965ef6e01cfe7 91e88f9071bfb3b09c959f871009b26697fdd5c2c22b1e736444ee94583a62ab 801fe260f00ceffffb62a437eeab8421a1eb445f304d432869aadb008ecd1fc5 15df8fafdd35bd45c51f890963e61181b481ec1dce086a690176d150b5838ed5 fafd9aa939ccf9790315513c6f5e2a2ea3f34ab5ad41fb4f4c0dd03170225941 662f91466b679336e89e6806d66fb0f6e58a3231cf8953d0bd33ccf7c5becd22 fa5660f458fdcf33fde027804c9eee4ed6c90d938ae9f7b23eb1b87359d01c17 902214b99db2adf3f81f2fd3564649879d397087bb7c3e4236deb90b60e41449 7dad6e1586f78353f4fe9121bd3bfb409cb50ddefdeecf288c32dd52801fada3 5f27e29459022bd062c296fdd9677c8ae0b090772fa63af94b4fb3b4a2f50220 6cd1c5ffb3664fcf8674c2dbad3f6b3c2328f15f8f8c2f2b7304ea80b0028a1c c737c69f0d4c2b11428052a56053bd8536fa39b5b4a6a906bf646277e8911455 86802ea70c5a4700e2e15745f62ad902289304c0cb1a759614f294c32b85830b fe94753dc94a349e77b97fe8c6f1fb39882af2d50cc7261aca9f12058baa9d5b 640a9f85beaa9184a96cba300fc14ef5c004b302faeeefe14ae660d9751bfe31 a36c89b2382d218f1cb1554ef63f963b9b9664973e4133c9c32a5fbfc7202663 3757f3b628d8f8963ad216ad404b6adb3224501732a88881bef89cf5fb6c26a4 995fd0ce4581b738c5e1b7884537f2c41f090d6627877404d4bcbb77383dfd80 44aedd7ea16c3e2a250fe91a9e5c126346c3e2f1d74d04ed6a12e73b35b55490 2739e7a8ca07e311f68545158354d227ac3af58162e944302c2e4d4a47c89ced e02f54918b49f62ef7f90823b7ffc85fff9d2b1c0513acf0a139313cd02e3583 f3a2a4dcdb1d483e6fe581c3a820a5622f459e45b707c8f73f0c594f58fc10b0 2cfa986cb296d812f1c8cd7de7a6a2512695acfdcd7ef8bb9e015987f8d94eac d1d42cc1fde01ac81527494445e1bc7bcb7d715ef7fb5d399c222dbe5438b5fb d45e3c3bbb710361a87298947750d875f990e2c737c5bc41ad04c038f3b014ce 686928f1b97693ba924296b600b1a76937a15d5cc7dd133d3a268049f696a918 bef33261284483bbf10111b248d99035ba806bfa91e9486fee3b69f99e9cdd46 e3e7280da12a8bf92bdf3dac89c94c48dea5e05a9bb6cb234b948386c88e3d1d c4ecf85fa90db4010dd92b5ca1e1d25bf410a73368f5618eccc371a0b6bd449f 5da7e05a5b9f46af9dae0c9182950c41aae870e96ed45c39ba08330d83e4089e b3ef49a51c0715fc48cf8553842a647bf9cdf77b680505b8a33b40836fe177b7 bc07d0b063064e2d9ea3b7016b54107a298d6d6905a9aaaa78a8f02af91e78e4 18aed6d9f53becfac93d8bbe476e50fc27fd642088a28a99be9f92204a2e9e60 88947a7507b7ec9fa80e4306c5881dcedbfb928df316c92bffa4cb0b9da6edc2 ba2bae663c655ca8e835d6660e14c4269237b1e3f0b60a4fece5e41ca8c2e227 7dd27269930d29ad3c846f155147a029c875a81fc6d96bd1b88baad3facc1180 33eaea1ba1e1818a92d1c1d22a526604f02cdac8b9ab8be7d5ede91cbdd631e6 28d1d00dafc57872f136c9016394df22718322390bccd3ba17824213d147abc9 096bde5e9be6083e04c914e6c3f5d4a40d6134f0a2dc02a15edf765f794872e2 fbb186734320e772dfbb34b18664b6704083cad48b094637f8c12c8f79293ff0 0370968730ce2858646e49ec4a113c9a9cee2454be7b37a45bdae968400fee73 4031f6016bb734a05d1187684deebf4cfa6b5e65ba3f857dbe77761b4fe0c3d0 c4f236d0cbe16e99a28f80cfdad63be34b2d12a536250acf8c839563709e7de8 28e4eda2cd6dea505d197ad5875fe67d736cad2e4b42fddcee66ed43a5c0b49f aa936ac0541443bc8704a1eeac36d036d319130a145211f77b45ad651e02e622 7e6fb85128d889823febe4c4e7e80537a0284955b7f829378d3640e2147883af fd9323728ae7906865daa4d07a63c7438b5d88e283772ccfe909da3e56ba773f 5df2b543bc815c9a44851e6e136ee55eb1c7d241068cf56a55c2e4a7355dff9c 981e82319753c96e36538c449bc16b4dc24ffb0307932280a35e82245d39bce6 ff5a9d2f304fd4262a0f40082d11465193d87d6428dfdbf0e4d3e9f51cd85fd4 7ee676ad9a8e8c75c22c046391c26bfd50d58524c1e281defe20b935780cc1b8 3410f2dc80e4ad8de1892d37e486df50cae74087a20fb646ef6d039567005175 cf7840e46c14bf07b868d5010981f094b72435d78f4e2b43e3225a7e217f3d06 9895e71b6ba7b156bb71716017f31a8ba42df2db6126e7383651a18fb898f47a 1f805a1f12c81634ced4c156f1b2cf9499543b394b3f53925d2f9ba7047d3193 4b28a7683b90b941b44ca7f7f1ed348f6a7b430b964b3b1870561423750f9e08 1756dfe476bcc96f99f24aac69f79f4bf3d986790ad28228839955a0a09fcbf7 d855da39395f63e3a4f5728e06a940570cf1bdb880e66288cabf17b37a7b3eb4 6607ea38988780cdd389b632e5ca5423eda988097267027807f7ad4a5aba883c 21c52736e4669017af6755920e5af7b669fa659f367e8fc5d54dda5ced47fd68 2a1de25b4e879e886c45aab94aa6e2d959435e17658e9058a8d78125bc5cdf5f 3832e55af1a2c247f57def78173325cc6dc8f0b64816d965bab49d35785acd11 a16e2fd5106d96862801343884cfcbdcfb200c0d52080ccccd74cc1836f2054d 24d1c9a620b0ea6577074bcdab24f15211d742ec32b7b7d4c43d376ec562450d a838627bf4d6838bdf491864459e4f6cfa9988480c05327b106f43e9f00af319 76b98f193dc38f391579d0cad12cd440469057091168da0cbbbaae2590587c2b f306160fc6c6e6d358834eeaf9789bfcfcf652b6b07c091fe58505193c38613f 8fb0ca8772ee8cfd7dab531e4e6b64feb03bd0abc922f8f791f56059c7744cf7 b9e35d62b24c36cb017e8d2ba335da54dbf3fdf83435de204db580dd0b6548a2 faf27bf71f74c38c72a9f69d25d1ea4eaf356a729d0fb86bc770dfd20376b295 1ca338f5d50176a61a70d81da5e0ef729aab45642225cfb899e19d281f80f0d3 6abe397833fe1f5c2b7004aac6a3f71b032199a12b7ed42da227a42def1c42a3 5bb5790b6295d826791681b26b9af0ba5d0fabe2dabe64094d317048d0591389 1de406442685870ffc6a5767ac3dbb7875439012a013e9c4039596ccfe90565c a0a90b25bdcd88d8abb529fdc7af82a217cb2341b8115135e60e2398216acb8f deeec0ec611d562d560f21fcbde9933ccb82d89eafd4d81f3cd2bdddb2103b33 7d0002c5b664c50283887e41d0de0420b5bdb6834b4544d584894a1c7f6ab5e2 f6a75419312092cda8364d36199b4d7b31d38e2ce12e1955bd367684f1079fcb 2fca0547dae1c6f28a7d09f7a929128a013f5129b469b54a0216a47f66547037 d6e907e641dc5ee6e26c22023c331edf385d977d0139e3b8eb24165410041ec0 2a1a461e52cf573cc7991560bab6729d86e8c2d404649a7af1a6571bd0ad876c b790bce71d23089d4450a9c5a7f1c3206d929b553cd96d6dd95acb5bf1c30fb8 5ece39ac9da286f8fc7010253c2e10a9f138d74194f2c379b7bad3ff76fa5429 0add60022b5f631d57c1d7e24ac3921d5a9dfeb09b7bd6cffac0964235c5e305 6d4cd7762363df46c8e07aae06897678d7671b7320f6e65d02688c3e2dd513d0 4c75b9aa562ad5fb6ac897c2a74f718e0e571c73bd5b159e3de723c6f13af62b 28b01ef2d6c4546ba94aea1ee1547b80facf862fefe4c9271ebd7380398630b7 e11abc0e4a626b06081ed7c25addbfde0bc85d6fbd1720741f5d8259f7b0e6bb 23f70bba7ce67b03402e9c11b0ce6f721437691005b6c12d528044f9e2d3f1e4 0a0e90c974c24dfcf51a680826775c1b6a3efb3a28580e272bdbef339a0dbd37 464fbdddb53772745be594b19c4fd9fb47dc1bb7f12cb0dce62b0d15cc37b227 c6b1d78834ad8a567fa2c90229b439be69223327a6994807c4edc234c84c741e 48cb1d83fc456d42abde850fcc92f8a47af80371fe02ba7b065b6f0a157d1e04 d1d4b3e44e04010de6d9e2b5b457cb1d0c0725aa71b3185b49c06e84631dd4e6 ae296a13a786541c3faaf735c27c09be1946f65d371f770b19fdeb9042cbe4a2 7fd58d9d772718d5a5eb4e9789094440ecd51e33e94caabbae67060ad5f5640d c60f0e3c9a87dc1922cb69034839aa01d9f68085b7ca695b6b3b889e92bcf398 ea5c94b9ac1ff87570c5bf8e01357bfb43a9a705b28c3fc0ab4a2c3f67a4d2cc 0a8f23ce40796f5088d781d0d65978995e5569110f7884da4d2efd499a7c6828 11a867dfe7e7cd04de7594a01291eeececb996592a982ede1b3c0a87e0cd880a 7725c90efe76826fd5f0517e692c06ede284deb6e352aca304662e9addb590f9 cf7b7e54f1537e41746a01920d5828026f6ba54799dde8b6e74acce81db6c4f0 99fa6f7144db7850a63522caf2b78e7f115a1ec6a3bf9a676dc9baa9a1ff3b34 a33aa4fae6877252b045dd34729e72a7b40a089c728a48eaf39c185fe179442f 911dfa30e8a3e4b1c5b503645567d88dc0d169d7c0d5f2f3c65cea280c1868e6 e12b7da46d72ef36132c65a1871e0ec3ba1576d62935050bbb078d0025e8cb19 9e5f721fbe2efe62ac2f364d21d233f4670bb07a3dc2aebf1654d339152b5e3d 37ad1886d6ad7e045d16e5227793e60ffe2f0841d193a817c5a1c9c1a29796a4 863d5ae8480255845a7ceb82b6130ab7c11f798878406472d6f15dcd910d9ea3 1dddead2c3f6b40322e683ac185adf32cb4245ce4f38d275db3d103015e75233 30af80384d576a4bdb2563d74f9d784899a0d7e761cbc5e25a88539556c12089 531f93c09413d489d94f7e9a3f443d3c9b7bcfb4200b0bcdb057ee5b1169d085 94febd5b8ed64799ed8193d8b13047410454e60a60099583d5858a0f1617b60e 8db97e130dd3228f60231997387c61ae3b2fe9e92ba97ac4773e3f5460fededd f2750b81324467c44d6acc64f83e3f198f734d15f029066e6a3ed1529966fa55 b7b301aeebdd11c7067ad3bbb79cddca10fb3485a544a772d702d21ded579c40 0dd188b3d20eddd8c5f07184137b1540093d3580fe3d1f6ad897d11b999afd76 ba1b6ae406f751d18f565f2eb48ce8e531c72c35fffdeb329baa89617b296a8f 33f37137f1b5e53b4743d3b9278b81409efa1ef83a544bd0ce69fbf159172fd8 34fa092b4d53a11c7e807578dc1b242c2d48a50378d8e580503019c06ae2c63d be5919a6a91ae0f90de447203c566fcedee31a83653155719f2165161956242b a98d13fbe413ce86cc553efe2f027e68434628bf1912e0a390da7900227216ef 1537e4497d8c909c09bf96e1a5fc0e0a7ed3c1a996adc57946214a2f1db1c68f 364e1be5b8dd92a49543c70a318ecd4eaa684cd225608449867a52bf24eef873 d7bf314dc1c28c86fb3f198d3e379765156b2ed55485098c5263179916426fc3 000a1c7ce53671da3b0b3826ada617fc8e09f6097bfc928ff71fb157e0142c75 dc668622e2e37b5a0a48a84bb8d427d33ee0e3587f563d8452de51ea12f8e12f 23b1ac05fe023799f8d32135e9fdd5d6b97609c636534023930838225b859b81 8751b4081cef7a72c6fd0c0875ebed1af1f7bc9895858db2599b69d0832aa53b aa80c5ec708cb4ee5e8692f45a92d227bc5a2f100443c5c6eb62f93baf32168b e9fba754a36e093b29f250a040220354a0742ea76e6b9c707c9685ed6e8c5846 03b57689ef5ba76a4258da91cfbe758f495be1f57a4fa5843866d7ef9c92635f 8673b278ce6b4f7832bd9d6264bcc5a2facf70f7e8b0d4f0371de07d7d6ecca0 37c0fc987ba6797259ee3f56382ed6fe88ac791c634c905dbb4d3a1946d72514 4f6fd27b6cd9279479fc6bbf45e37b061931fcf0514bfd4c8e40ba96c29703c4 2301787c9ec4f170eda1e4a88eaa4f5f24e048146bf7dafcb39e1f5a1698c549 6e2d8fd0531c6a4199c3902045625934f23f66b8f8996aba31c420d77adc967f 8bdc7554cd1f8ff80647452de2caf511a410bb9f2a9e8445a444c074ce968a4e 95d1e6375a93e9b45751c14a15c1875f9a8b81f4805b6e36f8a67b2f4caaf856 6f14eca0c26fca56d3af3994d12472b86ba828c697b74e79fbf76093497d5b8f 4dc46c52a9516b46f8505af99b97e8b13930407948bc6fb0ba7cb3fb28ce8ac0 d7b726f8fa0864c3fb226af52edd00af0fb0476b493c0a309c440801134297aa aae604c1707ed94ab661275bfe8b4a3810043f50ad8814ea80d81ecfd6d4e8f5 b5ce9e036f980d6bb901b56cb4e593d993e3cc696b73f0144b84b3e68c114f9c 5e904b3ff4a5743640b8afc38e5582f77aea401e89f998b078c75afb9dee98af accdc9b793403fd51df4790fe7b03fc3bc53e4116edd44d8adde5291db14f3a1 bbd9df26c88d8128506b0ee9e25bc4e167066a100188c1bf03e7a789ddac7f6a 3c6736a3992d0aa64a27b1a7f1a24ec3bb4f628ddcd8180d248f149d4151dd8e c12e3eee7b24f68b8240f4bc4395d9eb41ea8717a498fe99660f2dcef9ec4083 3b3165a04eb8dedccf9d6f378c9c16d85c754168f80b7651cedbfd9b0b383d3a 7227cbe1cb2a366062df6ac62f3f0a12a97ace5fe91777c28d765807f7125b9c b0e49523298b43ec4e78006fbf76e421d6e0249014a9401709e3cbb2ed349ee2 68386bf2fcefa90d4248568dbb388eb66a51ae3d538b75e25d186444b9bc4c5f 1396582a0d2b10cb1f7435c30fdd01a24ce2f60b2595259ddee4ae75d78b388d c63e512eeebd78e1e03755c95232ac3bca95545c66f4ee23db50896226afe021 39e1270a96b1a8c503efb196773700b4637ce512aa59115c5133bcf21549959a ef1c189236099b94f04976d19f0bfd4f4b9e4cbd955f1c4e62f3a7b7643edec1 031c78fa9e7b8d233fb35ccc16e82b965cc9bbfe6ff8379c6106f94bc47743b7 5dd45981aa86a2b96f68cb5121d943d57eb3c285a49d3fc11aa8c6f21230ead9 33b0bf1443d1fb07e5b487bd4754a77fd3260c4940365fcff3ba297f73d376cd ab8a5a013e80dd1b85622642bb1f4f2876d6207294b18cecd51bf8168c577370 721e33d4745b026e648b7ee22cbb90f2f39cf7d1caaf31089b3cbb6ede51c9ea 0c09a66983339f9b87eee85c16dcf906f10f743f2ca61a2671bc68382f391dbf 222716e1ce2605bd5863b0d7119a29ba6599c23b495a3f12a46cca0fc3035336 2b4dfbb80935a5658a85b06d955dc3e368e922574ebbd7f8f48526f3ecd63fd0 4e3404172dbcd065c31340ec4f5843e77eaa4f999d7ccbde3551311fbdfd7046 4f64167ab5f019fd31774959cdfddc0a2ef09da3777e1889f820183b1f682666 fbcc2f3fbbfd829ff4c4db0b57d087e33c5ee946f29ed05a77fae354191f6c7b 47649773b9b844176b007d577b1cfce1eff428994d328184af0bbbb1f233bf9e fefdf5d8971c33ae596dbb0105a8ae6c15dce0ba9e5eb6cbcdeced779efa8d6c 5ebb1ae5c3117ca49f1189b59a73dc796cdcbb4c679b350d02a35725d95ec8a3 2444450c91f1798999758ad512faf87390b91c37ba76c62886b95681b7aabeed 3055c822b7590cff058a70fd6202851c1a8e043f1fc4f3f800579dc9ce79067a f9ed452766f1fcac38cd2a090671c62612da3a9f4789ee7bdafed20204bb40cc 81c8192272f4f12f721b0c8949cfce0f0484ac2a0b5f165fe5542b0646cfffa4 b682615ddbd139faa508b8a9ac7b99bde0ee5dce0d7b74320ac101cc228eb884 8587f199e2cdfa44040fece9b0d20e6198477b41293f6e92dc72b82ae8fdf943 84069d72b98c5daf474ff9382b7b2eb198da88a0e12285faac28739f04c2511b 80d7682f27cccb1d153fa504ed97fc5138ff69255c4b049f0495c182c37b7067 58203bc816c935c169fa9c98471b00305e554999139ba7352e16abfd67005aa9 ab47bf1c5df0ed6791af28e2c8a80b954b67c059038f6bbb28f35ae0bad7f3dc be8ce770a60bb5664c0570948ca53554fe06fd222bfd3484cd87ba5a08e02e31 bbd597ed8fa7980dc9cb1e24f4134fc7a8c7889503b9c94dc12a1442a50951b9 ce519eea2474931881489736ce287a284ab71f2bec2e6c706a5284778fe3b7b7 d33ecc1a5b0661d5b4eba84d658671a69431adafcbd080cd7117fcd58b06ff01 630a2129c6ca8967f98dcc195b51de0b4a1afa3168ea0dd38592a5d2e14047a1 67c039247fcf85f6fb465f7d34c3f3a84ea783734af0341c3bcb6dab304f79d5 e1416573c4302af6a43c9817531ac18087a1e45b8b5d0550e5db61c6bb73f9df 7af7a099878a04ad6eb97f31b254908e15774358f7c75dbd58beef233f7bc05d 9457feef5b7ae56624f659c9bc62c67ad81ecbf0eea35b833d639d5ec16ef51f a56d3fe51cc2f68fe2b3bf872009dd068e05ad5af567475a1e6ad78b1e4862be a934f84ae986211d47a39be19a4814d897e6377dd1461332fa1fbfe9ac7e8fdf 10b6355f71fcd036e64d12455e3866c496e453b227e0c9db08a6708a78b7bd07 4251f38a8b32c422266fb9771abff00fe1b046dff12d35aceeff93707bfc0b89 aaafef22b1fbbbda0f5ceeaa873b8eaa9e512b1701668e64630786d659263044 48c0246bb2ab2aeb79f319d3ecfc12a5a9106f46dae41e088e3c5d0b9b7fc5c4 2f06ace0c2df177ef6a7766a99387d3d7e9aee94aedcd73019b6b909cbdf738b 870e7a6fc23f9a8ccd146ed071308144e65096905b0e5c823dc045346b5b18bf 53fef4078c01dcd0f1a72ffcd5ce09b06b42d6f335081c9e95309c441e16112b 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 true +check_ring_signature b02afe8d71a70f12e1ce71e5711c9e51c13ab2dc80f8a7acd5b86ffed3e0d905 2d133ea987e464b499fe2e79bbc90e2c19c1234cc377d290723c18627c5b371a 161 02a3330fbd0965404e000a932b0bead89248e34f239a85cc4c464c8b9e686a04 94b06f86c0132f6872d75699c2996ab0aaeb203d70290a319385356167353a68 972a7dbe7d70a627c7cce81bb47b21d0c755a84576efa35c797c012b8d2f9ddb 8cf8aa23cd064d0945698fef68547c0398dee37ecfb64fa07fb653a1cb77733a a89ac60f29d7ef66842c26e31f1c9c1276f204a71689810d6c5cfb94b0b420d9 00a42d0ae4c87624cc7524eaf9484f9391abeb482d80989b70faffac4c0292fc 6e233305d925c2d74cc983c72bda460ee6dd51e4a2ecfc0ae4a5330b6676238f fadff2caf56c1f1c3df78d1e0cda5f36b433a7e17637456c6cc410c16af8e923 fa817b69c9c9e29ba4af2c9540ed4ff9133818db66356d1204c50e6b1bf0945d e826e44aae9515ed974d6182e5bb1e9956b569befe275fe112f1024a0c16ab98 ddec67c4b6ddc7148a3e85f394b00658bf1d347d3190b2271b5acccfc0561548 6c21675b0a759182c1d866d8cd2f03a730979feb930cb7b9add19744db6096fd d82c3405b4189427d2e3d30a3417fd2317b51bcc176628f097b5019cd832bd59 36413010876558ac1b1ac4beb9512417242568103b9bd70f00b9a526516ebdaa 0e7af257d449dcbb2936f808b5f526124e219106e38977679c6d30ba610f797d 08aaf58e3f5b934dc1aaae7d93f37afe71765148c653c6cb9424d6717f39d2a9 2e066ac0e8f9f466c80bf4a8c9007643dded085404ee135965acd4d9249d964e f41377d4816fea4f2ec7e7c26a3f8ec1aa049f6ea423515196893f113869f7b2 e8cf1c8e47d548338d8cd931cb9020687a74ecfb3c760c6ddf0ebd96027f68f1 001de5ee29c0e74cadfc13bdf3fd9b10e579183443c2a39d00762354972a8023 40b998a79bdcd5a019064b73078fc5b762da8d7b2c83fd82e3de4584da56ee62 2a27417478f16a759e2e10bbc072f0aa083bae16efe2a9b4051cc7cc47e76243 6be2753a0e0c5872705d85d066ffafedb498faee96c2804862c04cbacbea9d99 76312c386b65a8e455a969365df9cabf3cd89f676ee9c5269a74c241d5664f35 51ab6dce8f11ff35820ee2abb65c639480791a9ec484067ac286997d0a35b685 1ce972303dba011bb5539d331f218b7983a4d87982342f1645cc749727641cb4 0546041794bc975d9f3ac24fb464d34678764b65e3b2fc308709f7b3cebf62c5 b5165f09af0f87a1d65d0dac57caed9605eed364e33e148ea76af34b0e87865a 5208b4833e5592042cde7e7c231a506e38717a5291bd5432591b6210541327c8 2481c5b0c42f963971e493959ea21a6b34a8a9a22f59aabd2dd07061db9bd6ae 8407464895c8a54531d22be99f049d6573ab3d38d06fd24639a24be6f5cee377 7c1fe0c02bf90aa03f1ad344ad16fd07b5c8d6aae4408782b39f9cb546eac681 939fb88fa2329e5141740416502fc65dc80216d9e9982f03c664071f15023ef1 7199800a716951ffc7c3cd269fb297d77dbe927b2d48ce4b05e517b333eff630 6709ebce099064e1d521521fee0c2433224f2e90a55e897e487d117ee8be3e57 3d72765dfff800f65e21eb0543804674fbcb0e5aace04dc8b5751974c0cd420f 1e06ad5eb5c2401d6ff5fb4a8431770a213b811bd39f69ff31c9a23196c9b507 a4337d6160be4ec515f80e00a05a355c39742ad34226d9289c915ac8cf53e12e 9423e787158aedd4ae60e6ce1a1110e59afe4f0e89410f9197e08e11414b3e71 f832b7b4c82a681bc9962e9356343b454ababc122ed16e7d7cdbfb86ed1e7b42 7effe2f249e1fcc37012b3d4457f14330f02d2fd660485b1ae7c2b9f0cad15bf 8d6859c30f98fbff5062e3596168c60ee99e4353745dbf78012688c345f6af30 f516f0cf086bc4903e87fb3afb4f9a2b1af58d78c0be85f081c38ce09a6220aa ba9fde69c747d93a6a438d7e82393c3da3ac12633b2fc2b040410ed001bab363 28d944fdba6343f3a8b677fd0a677fb48d558b932952fa370446c33ed00afcdb cf8589adc8fc7cd5f5beb03a9e1156b3efc7a6fd70b84b887d96d754a90a0989 c02ee844965283712628879a467b494f5933162cc5f5009ae864a29506c92951 8103112c705cbd980a743632349a3d0ae0322ae0c66cfb90ff55fd51ee047bc3 5817b5a5396bd77e5134dd3be43d2e9c10e6a3a2ddd15b925e678fa315afda60 d323b8742c3632564fcf96922db8c82bef5909ea17324c88eada6eb105f44d73 497ee66505f249fd1b9924b5a8cc48a6340a3ba42a986919402760928a09159b fe2870032aa8d93b22c68ac7880c413ffbfb8630fe44a2451ced0481cbf433ac 1214e7e74588650a00554f83cadd15e16640044d026fee4e84fcc6abbeaa8a77 cf9f343f7247b00726087c51731c1e7add039eb5b9d16be597f051682b831900 bcc1511d9b283d4413f4462859003f7cad735a56e8ebdfba575b210fdf870c8b 841ad686aead33ff4f65c8c7c58495263b61ff1186d113943b099dad11fe077b d9b474dadfed9ec160dd8eaef3a993e5b19e059d1c424c2fb0486a80aa8a7842 36c44c2435d71b52fce3d3b0485fe91e8896c687c905c9499b039ec24d0f3f06 8c00d0e51003aab8481f482404828425dae8e2b6b729ee4cbe4e389422263707 04e699bcf6668c6824a1f35e0cfc333ca852d6d1a2447307129ecd2ffcaca6b3 adaba25b24f0cdec844d94fa4d8bfd61f07d04117c1dadfed20fe394059fab98 be36052f1b923eb4452f0fe14a2d4633120de7a487ccdd83534e63769cfd9439 6142d7fb1a2cbd9c3ed98cbd6f5bfed863b81557db11c7ac89c7caf8a72ca25a 223d59739bcfe2011673140d088d032259e0fa45e7819f0cf3332b3f27cc6e81 dcd33fd1139ea9626d45cc56704011e3d1575e902ad376c562ffa8a374f1b463 27ac1f5159ed2fde9307034893c79e8ed45073aba44798bf4ea489e83d6d6380 5cf706d185898f989dc396f2b4d4ed13e211017bfce3316cb92397cf29cb0098 5dcf59e59b9bef265473c884698f9df3dbb88856b485159de3181a0fac7b00e8 59dc55380b3a7804cc3d7f8ce949119197e2b5619fc6a4ec54ece899b668e82e 8eb3b030a6c525fb379c80247423c65acad183183a617a480f2a15e622c205fe 59351d9dcd8146acb3db70d25193d9fbf345dee204d1038370c3bf864f858296 f48d8104c7a524cfae71de5dde9b8d49ed4eb0e551ce7c27ed94f80cf38c0d60 88d015ea2386b94c777901ac81491f69a6e600b5ac0ec35d02be90020770d60e 555344507c025c3a1dc0a611512c453aef4870909fe791f22b16337748293a30 4cbebd7f2c339825491eb52d5e05f9f8c035abd1b6d30c452b7de7a8c0bc0269 d3fd1244803052ed2193bf781b3b7bba02488fed36af6454bc0747fb1550e90b 27bfd85f3a8e410f99ba13a97e363d8c600c9b3d5d01e7769267ae4279f66c75 640db3aba34143473b2aa0b7bccc6e76f2bd6cf6eeeb4007736cb4e2d561a626 2ab6415f6ccc257ba42bc5f53279ab10b309907d60f099c4d1b35a7dbd7f2d5f a0086a8a57adf2fecaa8a3a599d0551a34db3ed07f5e8d4a2cbaddacc218ab0d ce4b61c1393e55663084035356a51a6767184b24f2adfd9ccedcec126098b2d1 d6fc5e574eb1e466e618cbc100cc34d4a776a324f91e5b18bd133b936390dd4d baa6f8dcd95c5673cbe19c37a7994ae24458a54324c913b8d9e695662d61f6f5 26b6c801da4731c7622ba007641d5bd69fe549bb998a1cb9b9904f4485287626 bd0c452a27d30668f049f4593b3c6c096b21fdc2f5cdd8e4248bf068e1bf46d1 4127cc5aac7fe711e7051f0b9c900c0b6f722c24fcfb101590fd5c926bb4870d 3cc0fb57b784d243313ec8ab0c0ddccad15d3cae906745d1ce106d86f01b2b9a 7e4cdc6ba93735ce81c5bc1bc764fc3899a8dec0c048243d89c31a99cae4ae61 c951b730100607d16f1bb2f9e769ee1a810e36a4f6ff65a623c8836cbf6526c4 a51f71f473e9f5c4c951f482af54281b4fba6ad4488f93c798f7e76de66ae62d 4e5b441ed8cdf6edd83d066628074b05a5bdd092c8218663d0a60b6f3c5693e3 bffceac3774c4a117095d4714907fe088c34e9e64f7a041b732ad359b29c1d1a 458c479292aa30feb2fa523970af1f6646661f81395cbd0289caf6514c06a5a8 c9d639a1f7a30d9cf57974f052ba9eb7a86ff7c937d212d5cb9bd3cf26cb37e4 94fd2c2d5269ad0dc9910146e0178234937c102c0e1d53b0583cf01b76fd1f28 7bbc897e703a56fa07fd74795121b8de1fcc711af46f02378f3ad78507b26659 0d48a03cf6be56224f1a488aed8dc9df2574477ada56bd1acd2d142dd8ad4847 47e3443a400b411228d44dc9cc29fe91f022b461eaa2cbecfe2d13bd6551fbdc ed8b8d58af6f78e26f5f44e0df148537b5b027fc45748fb9d325f0ca48470069 7d23b305d95d05053ee35ad05e3ac58eac1677c0ccc15a1195cbe6e6d0bb7378 23f6ab5fb433dbfa8d62a493f603175beab7c48ca276d12aa527311120d44945 a3f8b2504b5e56a3413d9c57304500ec999944bfc69ab812d2339276bc1e99d8 3a9829351999d497fa01cf9d8fe21283a53c8b864c4594d55c30d19c452625b8 77e6d796290ffe81ec6914dd93c1a7f32d77c9f4b78c199f21c73ac2f18a65fd 4aeeca1acc1bd2ccdce2dac2368129c5335211e1ad8c97e49cefa07080b2d957 6979073b8710b36e0135563803a7174e4c73a532ad6136cbbabe6261bc8f3646 5494e1ed87ba59c2a0fa9aff8bb2ab3fe14414d98a805249e1b6191be563e1b2 0de4edc7f30a333c8d14d526e5f05557776cb815b601b16c97d42f8fc506643e 7e23fdc6771718a012fe3f693e7d7468a8eb46c69823c13912c0ed7ebbbf4b68 9d06db081cde62d1fb951f60679d63afb696d3b88e654c312bcdae690ec0a431 2de7095a96c9f9a1dd0c2ff7556839f3a3c3222987dc94a5633082b1f75641dc 6f085b15c9ce6eab7b50f13d59139bc2fa3abbce458d75365c36a8c6bc015c3e 7028c0ffa6a1b86174dc46b99554da7e11aa99d7bea6e0f326bac8927b4cfbce dc3dc55d46e73298a8ef81e72be506fd5372d1b68dd3b864046af413715a6422 02ff3d62abc880b49329da084def06335e07c4f518e25199054b151fec84029f 0939ee4d34e9a16799c0da70131215f6cbb1af0099bf43a22fba928a30fdcf2e 153fd51d8a4cc4226ae530f9190767fb8548022f998724049dd28cf6af1a38bd f1e93d7ad707189da33db5a093af7e93ac74db3376470d432b3394251b951307 3cea5ba0a91d8ceed76a8f44983093b18420baa61aed1349e97dcce21be5fb5f b175ceb0f27535120582de0dc9f157745441477d3c910f92161eb882a7e7a678 9cdf19fba139c3a145af3f9fbdb0877cd8d4fa770f49ade66db30784a0a1e0a6 abdb2e461f3a4ef06e5bd7cab1d2437f7405f40f0fb384427b33e973cfa73085 815ecc842dfb28ef692e6e064133538b2d8c6e0b3a4032b95de5afdc9afa5604 fd20f0e7428410379aaefa85cb6d5fb46ebcc5b6a21097900c85094f8c997d3e a258f37cc75b3848cf36a5eddfbaf4f3ee2bf55fe6403f6a2d99a86d2a32ddb5 6f85b8f8cd7c292c2664b630f620cbcd74b4c3d5738a5a9a36d3b5a903617afb 587ac4b9eb000b7ad5284241ed3c9907f739e86237917a31d7300bc605b641b8 ce8b71dc84877b1f103fd56b27eed8a3de40ca1c03c113eae6c6ff7a41061bce 69c04c1a0bc5ee1e3e1f28c15979cc41dff45146b176d034a3d5021d41eb4ea7 721be45fa0d67d94d44b5d13b551833358afa651a6aa144d27a806c09bab4ace c55225cda40b7cad7776a0b9dbb342b6e8f5f55aabf788290ad27060d0689c28 7b066fc1852be120c22197dc6170fef1a6346b266c2c799af2bdc5706a8aa46e ec34b057fe324c9a60bc028b01ef7a79d36c0efaea780e6f9b573bb642282533 8ac23be51ba62043eba5488d08c2ea941ad14810c61c0da670b472bf1e31e0f2 a7c12460355fc020f0e031180c24265fb6f918a1f62bf5088554ce3e84382c53 7b9cdb52aa6a954eb80476ea215d79b531ee957cd9f9727cc7be32f71ced15ce 61ba5866574309dda6c2f722430c1ebf6434674747df28cf4c9bbfd759d7e433 6863070f166574f9e3148730d49b424c4c2534dab98687658d819f40491ae8a6 cd45604ac8cf618da974cc53eb785bf9282a263e9ad0d6033f83dbc673087c49 6c6c3a465eb92830339e8d100c0d36881a61d4f32658cfdf711e75ba2154448c 2cbd47b803aca2f39d1cd537ea3fb44df86f98b0324dbb0f0215d2131908a334 6a451a2d4ac60cc3116cc48b8c2142f58137ce007fa6d0d09b8242760c721123 68d632470a2ece49e37ee1331b890638ebd2d34eca59926f19fada132eb52982 d0596c014e947dfbbce2d2e4aa7389b418c74e02c849b9e252a0081256646e14 66deabbd11ffec53c48760aec569cdddd0dfd468f714f2c6d396087fec2a7a68 9cf3f9192df0e2382a812bcf7fc89be22d4c832dd62f0f5f1717aad5a76d85b2 cc2aa4685427c972bdd49be215232b6b1519302cd5c9e4cc0bbcb0f56befdeb1 3b449296c9a374bbf1f7cb4fcb8abd22e81301a75401dbf4218ba43d7593a454 7983a28f64b26d8d4a51b646bbc1d2075825cfdee1a8afdc279ef208680bbe09 2c1dc00546e2b7c100ca7adf77a01090635bd8d28e5ed0ffdfcfad0efc273ae6 439721aa0976500b6e349509bd7ffb1e2d3dfad2a668f5d4a0515311a08eb5ae 59f25c61d79d4cdb7b8cd3cb7da8443851e57f0027071ad947cd232f41818173 a6c60ce6b00a7c384e767fb6e806ab890a22aaf054c1b1e4afceb79aa203a7cb ff0cc03f73b92529be00db3796c45c7d74566998f67b6cc57530ca18d202b720 987976bafb446185fb1156a66aa2848f4678caf4bdd6fa0e31efe63fa529c4a9 8de1dfe5ca18e414d4931ca5a06df20c9919bc3b09c394399c89423c9252a684 aeb7326ec766d35d223d23bb775f21f44e1232315538c7e39f01152bbd09e1f7 41ad594614f2d947e57123f7124c37668947703266835aa39967616e5a51bc65 8f900fd3bfd9cd69d9ca1ebc9589cdcef5ecfe5d1cfb17f48c428bcaa9230f21 f3b028c37aa9d609cb10ef2c30376a7f4705b35cdbaec08c7deab8fb223f0349 f29aea977cb57a9c7f8f89e4b8e982eac795ea16c224908c70024938ddc9b0eb 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 false +check_ring_signature d8f9ebdad62a4a1936a7402859625fd36b0a0c51515a65ee0bb0b176eb1ea9ca 5022f0518c0d5c23ff02711067fc65b98c8cafeb4a28cb5ca170561deaede8b4 118 196cc80f65340c20d3ddf5d9cb1d198de4c39606db89fa23746bc53500096a51 9d853ac67b1dfedf98a899d3b9368c19d5e3ba7a9f88aef903cd6381eeff45a4 704459bd9c641e717ebd296b01b52de52b47b7c485dd769c22dbadfe5e26e432 23892b44d57d0ce05f9ffabcfa98b157e956a01740a8020facb33215ecc31a6d 24766b33a4c7c4681f140d7def192267a27331dfc1fc102e60b1626aa149fac1 34730ac57141c21542b72f4b6c58eff06841ae666b44d4ca8b25d18500da4626 59ebc1dd08813991accbf28eb3489741e903f33c04dab6f3414ceb85956dd983 8cd2a39d44e5406a219cef2296655779d620dd260b52658dd3643b3c3186e635 51ef48daffc4acd7009d6ac1ddbf1d0d445634c251a0afdc240634bc5365c317 60009fbf934df0d3fca8d64102e257962dfca62f2b108d4cec0b7f8cac332a3a a4e44ac37c38d570d83a8311c5b15411727795924eddffb0905e0e3d412255ac 139fd753067f3f38dda55562039a2460c16fd473c470b05868071a70ef3494bc fa863418929c5bf6b64988cd6b5038ff8ad2bded4a9783aa0631d28bf01c4633 9a5bdac51d3e463116a6eee0dd893f13d94337bb8f8f95f0305ec441f295f76b 354cc44ef767ad6daa6e6a94a1c5329e6b0df84b36125c9019326764d7802eec 9c97e18f7996267b3261a723bcf2e7aa2b0428c13963ba89e856c32ab69e70a5 421fdadb0f6dfdce1da18779ec7e6ef43e8cba2c34571acf4f73ce241933ff60 a3de26a03f2a9ae7d585d2a44365896e36bb42842effe7d8ddd78f4b45038ea7 ce0a3afb4dbf2f08394838292a93075539a4199eccdea1482ecd1432c09aaa64 eb7e9907b3aa9ecf855ad51114a036d932a14473058d1ba743f9a6ba74bd5c0d f2ec74698b7facb9a9260da39602eacc39b52edad536d435d9dd2a0fa3210cdf 9a5ec1c8408f5324dfbb94b9a2c087f74c19a829fc22ec764712483e55f8371b 921d52703cd2dd5c812d2246e2c91580214787726114dd3092e6e4b8d4fbdd47 e3f9a5db65885c5409d8fdb904a5a4eaf76b8020b780f85066cc7c21d258363b eb749b460a69b5177cf203ba287c327fdbbaf4fbf5678aea1cdbbcb86ae69b74 1a7b4e013d42d204338784db0088a856749e932e3c48c99a122fff7cfe3e3cf5 dd473f40a77a37052c81a37c6fe0356f6f960764b406a027fdaf0c1d6c050beb 7e24de16336873785000ea906c8bc10ff22fd1b6335962c84b944d30037f5f5d 899372de3c54a3971dbf47ab5de763810419e5212b13ffcfd0d31220599c9509 511dc0deaf3ba39aa84cda30dc56ae84c63d769038b02b48cccfb2dd9c3f4c38 539be87f22b1a3ccbf4f0116d5c02754ee1842a4b0c664cb96461330ba07106b ff8dda1a0abe2dca35c5862fd945cd3b9de179ef301925c431c6b417b40aff98 69bb7c634d596e5c60955717317fe721b1ed3ac29a9ef682bb09e5a123d2f42b a5b7b2ad4983b4b1ec1c0f6a39184bcbde3bfb66603ee8b12c38783d1723a470 8da2b2f79904a8818739bd80fd70ae6487a5022bf664cbd02c8f93d7682bf4d0 d3ea3f93ac451792a2068a0b41e4b87b8a680c994cc4440eb14e511b0a0871bc 8a69174859ecf55b245c7ba2833f658759014e2c7de2c685625cb860b9eb14ac fa84e14951b08b37964aa30dfb29824d203b675b7bf33a1ee5fb53de5913ba54 6468da5929f640e128409308cf42a6040a0ca07b3536555840b80e2aa40f4845 81da50018b5503110e9d1abdc7ca65ee10ac8973b54fa7a9c14f2735c966759c 2cb6b23b9fadefc28846558beaca989835633f7b265d8735b82ecd56890de6b5 1cb96bd599ef7f4cb75b09f3b72e5e4a878c9ee4b60406f33da225df0cfc2928 ea250fcb59a5ef9f3a75a4eacea5c6e0f440df75a40683a0abae90534c06bbb0 100b9917b4fbfd3869cc01995f5854b72594febfd961c1336eb1fe52af94baba 5f2d34f7e028ce246967a4e7867bb4f41cf72004f4c9dcc734b5b6ac05b86427 3332718b83733040c8ea493b53646285fdb72b0f3a143296b4d6557b144f3f2b ac17e982c416879d0f2a8313f87151ba329973cb0f1644ebd0269dde3d93bad0 b1f7b8df92b3759b3e64b6d72b18fbbcd9b234a1348aa3390e4648cce6895f6a cce07e553af9eb725abc95b4b4e9b31c717b169ab937b219671a43b10394585e b46b3aba6d0bb684661b13d8ba352d9932d2e0fea54b8cfcb847bf8dc5402394 c17eb48b8aedba41edefc11a206396a3d593374a74b75de352ce16bf6fac9479 7fd62945e7f39f60ffe8ea0e09b104596c0985dc7984d9037591e6c2977e868b 187e99fbbbd9d452bee42d6cb98f3f71981186747cb34d19e9c79de9e01c0e4a 770c83c8c7e0fa6d3a592647874bbf7cd1ed5670420099890f8cbdbfc18b9ef9 11c246120ada7d122cfb6ff2b9308b0ee3746c9e30ec893fe5a37633e7db70f8 0ff766ab0133ad6ecfbba1523c22e522530e9ce854b8456b4c7e98a3d265a062 5d0c6601daf000d3e858595a1b3c700ea741ec856d322395cb1172be72e0c628 64d0721465507d660e8102d9fb833e24e3fe8f1f2cef4fadd1554ba892df95c6 99982dc69fb287faabbed8221b1696de7c044e50e45485fdcda35badbde35611 a41493b1b565def20134d96b3acced5ab1c8c8aa63a26f4f119e595046ddcd98 0cf00ccc5bb9ff195a7b187f7f61ea0c2786948d1f0051f615d2f435d2f868de 519cef70517153750c9bdc8928873c10621e5c7d628586b6cbb9f0726d068cc9 bd7a1b65531646c6be87ef8f512d9cbab7ac7e776ac6e8291d808119e094a95c 6bdb74057b258d0a7e64504cf27435a4b6bc4395d839915a9235d34295f86879 3ae32d274a69dffe9a61f2c94332551c16449b49eb8d27059bde92358b56c681 e039396253f8fed43a92d7e740ebc4014172ba7567ac3bec589b759c1b59cb93 3bf502688867d7ceabaf3b3aecb1f7d634dd33dce6a0f35db680386b7f0fd1e7 e0e8a91a657f7d867f1464fb642534bec29eb165ac32a68298f7bf7b4706340a 83bf90cc9ada30701d4b0b9ff19626c4e694e9fcf429c73d0582d0a604c08f67 60448fde199743ad7775ed48bea4ff707de4550ebc383333fee0341ad396d71c fe3ecdcd96cfd29c8974a295c921bc79704bed7db894d3c08c593bfcc353ddb9 edd78e8d49cf6f4b7cba2290746b29304244678d19ee9b314ecc50973e060fa7 db5bb4ddc84603c48b3f973f28d60583e4429699863a685949b0009d220b156a 1cab22b666160f0142589d5e1d46d14ef09c1263e7375d434b9fe656c80f6db8 068baa525b9b3eb83e681fd7729dde0936105adeb6a77ca2b8c93860e2151286 050155a2b86da07fa86a451ef80bb64635bbadf357e1a7fe2be222873d7c85b3 e868ff1a9f85b3b53fcaa0413e68c6c9962ffb9d15e906efa37d089ed82586f7 11cb8df784ed387a548b9d52123c0c2aebd68c7e86d97f5a25057fca3e9399bd c5c038bb49c712302a039c1080342d898d5e2e0ceaa72d1675f3da859514276b c4e6684d8aff08f668a74c7621a16661edc06cb5b5d3af2014d0a8c93a4f7f30 823fde3b825760da1e2483d171041774baf41b19c4c08cf149bb13b4c264ac52 c6f3c5ccbc4b2856376069274d5cac063d9277210f266b2c4b94fa6b0134b824 9ff694c941c6584791dd8bfe79595c21d0c8982774ce2bf8709d39c064e9f886 54a29af7986db1d8a365ba029793dc55026ef4f8812f780b55a364f8d2697f30 07fd7d780e04f83f5811119916210b36b4a37b4f8754ba06313d65e740d531bb 701f12a7f469ea8d03c5dee3c25684e6071e6f1395ebcd8aa22efa7dd2086632 a2e1213c2d5d97ea132b442783e727f1e71ec684b52227e4cecbb67d9eed935e 55de41982aeaf0488fe8b06cdefde436b923d01fafcc028bd508d47d7b4a95e4 d5a04766aaf25330cfadf91bbcad907c5961e0579c0fff56da0de59843e24c99 405fe1a1872822a04a5c2e429942c03a3320e46f4d5635e0d87ad6ac5e0e6870 99b4c3ee509e3ca2c6a8cd317dfe99dd448c4b086b4d9272bced41aea15febee e2f5b4d192f735408f407b9416cba645e7703d626e3a1a286dbd68d5f981c37e 1965b4461b974c354ea09154d7273a1d81b8725b702d06bf1211eea203283173 6c4653330c9576197ff96f827ff4592ceae2577f33e5d29a5e6d0d08f4a3dfe8 51dc7a74403bf5d8e43264f55431fbba67d8344f1cb220f05a23d2db63648529 14cc483e6c433d79ea99a91188280bdcd5462d8f45324a0d9c8320c1a21d0ade 8eafe0b0289a2b80047cdd2f01ac6d84903ebc96422272b195ccbe857ee5a70c 725ee776679303933e16d1ce765d026129156855e49eb5ba39b3e64f186e0bef 16fabdf67614a382bb11e85742f357c8c9c4aecfbefbb3420ede76ed53c143a3 936314c9fd407960546b6d7d0f7dff859c40c9904d938c200998ff3292394915 7b997a305197985fc5a3c7ebbb7da9f515305970c62dd294a3ff8022de1a3411 32e8795ca3dc6b113caa1dc0a2906a0ebb209596ebdc9a68b4534e97530725d0 9f2d40218bfe204798fcbc991e15acdd8157149627bac0635995d78f578be2e2 8c04794e6c42a0fdb8c155d5538324b1e548425f759acebfff8aedefa5d15d98 48345eee35f4deaefbe0e81594495045a93aed2298db607f9b221c96743fbed0 ec51628fc76b53db951087ea0fbe09fdc7b3a07e1cfdb267813fc89821cf2f65 a9faa9bdb02a71292a0e59d314976f5e7fab11b3ef0659408775339d51ae0466 3b1799ab2b07b6a9f36232f37d73dfa131e34ac73faca5ad14af4c69d0624316 d7b8876214ce45e825ae3103e00029b7887d5414eff20dc0c43cb3cfdcc77ccf ecdd90414aa0a004b037851ba42196bc95e13824bb6f13ed21d03529ab988f06 d0b7d93c2b879ed57a30bbec59a3c836f8dda2f6b22ff8bd844cb3ab3dfc8edb 5628f830af0998fdde5e36a5fee15f4bfbbecdbfe1798b1170f76929e29a3249 39771ba107a7909b2942b4093a4746bffc0b3d8b66adb911094ae6ad4516f2a1 8b02e3d22fdebc86caee07fc6c61bb72963bbd6dc54475c08b50e4e3180459a6 348ca02e065750ae7f46c3e02e9c9a3be7472ea547bd6e61d9391a0db33463b1 3b130f1c4e48bd8817fa1fba6f357583e6b4ead331635953bc8dfe5da80a8193 04d08f146199aa1f890e4a094ac0d11f0027042b17a087d2ff29e5941e417721 b2a9a410e7362ad27d64b10338a5e07640a1e8115ae3cf4a9b73e6e0d350f7f9 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 false +check_ring_signature 2907b72f626d471586535042e93b0d3e4c1732a347adf222d6ac80fb594bbc23 256f47ae8f4a891dcc0e7ee901100dfdef07d49d39f0e983ef40223c9403a7a3 2 4aea15c8dd117e401ca0cc7f9ca31925f037d6f03b2b32d115e4baae4ae2008b b5044cc1f58d29bbb70d342b04ead157556f1f6ed88466f7c5f91ab29af74f34 63540c377a45dbe1b1dcb5bf1195f07f6609561ba3415382bb0649c93f103f063291dd681738283a1497958d9ba6cb2d220a17762923f5af27a0d8d6c197e0048ba31fa8b7d30074f4e250d35c4434b8603e0522b8d9e997132617732d23a90ee67bfc3f70fd3ded5872bbb51259608031b984dfa6c0a009db4561eef96b79b0 false +check_ring_signature 73a0b9470d018f10d663ee6a9949dc2b770fdce537bdf7bdf65392f5d8b91953 28b3b382e815907909bb2a9d68bf50c9abd117cba530ec5104dbfd8b6ea40e41 65 c5ad963a5751ddf33586d3f74e07215ceb1ed4b49b52dfa99c806366d531a75d ad85bd40b9c23e65f8fa81d10561f5d470cff0adf3e57cc7e972376c814aa3f4 89b6554ee5195286cf29d818652d9eca46fa01bdd682825913b0d694de28942d e8a1ffbfc9111749221fff83433122de15b84484a8587eb5229f3a112f9bb7bf 4eec49bc577c264669994ccbae8098ce7811a3ff8f92b6cbeadc2e94433ac0a3 904f10d98b5807a75aa706ce5ce9697f80ca286dc648fcd5e14086dec45b31f3 3c24fcd2292966f80c68ff6f7c05880d2ceb53dd4df8bbdb09cd7fe946fb5d67 c89b803062da594b4c31ff01279d4c7058dc2aac3462a0628663d460cd3f12e1 73f5e943d8207a16591b30f01a43d042c898e308554d54971b442a510adbe7aa e78b9961ca1688b568c5443baa6f68fec3c5936883e7e5e369f0616522c2bac6 2898185b2deb82128bd552482c4b71ff688012f3cfdf784d95ddb3ee17341db6 d634fefa73be9ebc78a8de7f9ab3ec6868f36b9ad82cc047aba8b24234d7398e 65f800102ce9f62bf66ca9cc2c8cd5bda337b475dc26ae8e4565c5bcd957f09e 84e9f821ac5d8fc63caa542640e3183fb3e835cf20cfd608a8d6b18a6fc9dfb7 c07169659532033dbf514e34d92a399f859a073a1a6b32c0383e0a03b9960aaf ee7cb8e2a9f05b31ef215635b070506b7254af0a220a9899e9c0f9bbb27ad8b4 d99918ddee40d29bbc0090595d8039bfc1adbddec26665e7d36d5b1cbd29e127 95387693768343e512f89839113fb6e8a1a0eb56f3a460204076ea277cf2a9b4 dd463d3b9c236910dd041a6ede869fee576fd61ead7912f97a46053a0ecc2572 7494202c7dac5f7c3f9a382e69c554563c5634035e58b82e6051c66b618b7e97 0ef40e9dbfa99aa52886ec95d90defbb8708d3b8e44fbf246776a9ec9ebefdaa f28af8fb2d74a547c06ba160aca8883aac23b3a7ff4722efaa89ddf1a10d4e40 05a7263e86abd429f4dd3645fff6e96ce687c88669da024cc2a8f74b6b65bda0 ae0863efe81ea70405d7de90a4c03d7aada727c7fb47d51d365861c74213eb75 dc559c7e70c65480f695e58a41abd50c5c4ffd2c715c52af740982800336152a b977d28d5c502ee3bf61f26be7bb7b2caaee47e421588cff7ac8dd4113fc5346 89dfa11f46c2538753c535ea1f0ef8d57ea16f39bbf56c6d652d25e68e8bce14 e6515aa06451b6be10d0393c536df110beaa7c25fed4d978bfbc744914dd9a87 e67e36993374022faba43200a21b138decee0aa24eee79763c05009ee0883f60 c7bb36eecda00245c122f16cf5b1d0dd7748bd666496f4de525104e8b6826c87 21a83fcfc283326681769350131cd798bef606b334b15ef2892d18cba0d09298 640849cdaef5d0edd348fe3c083271b78fdb3cf2a197d4cbdd575e407d80b4c9 591be6b8bf5cdd8d1e65a182e98600f529edd6d4c0febf7e8e5860f9c03e581f 72476e614ca0ef425f89d1ede02120ea333f808d309ac94bab6cf9ddaf9f39be 1e504eedd6363ac0b0bd70dbce48e43f52d19ab06a867f776500bd48ffd63413 25d0431c271b34463c99a6a557715b07737833ce263feb579fa681f8f5b5abef dfe323473389b2166b09668d087d917a7fe526b75d69b47c80975b85463b4cc4 baa1a22b5c90ccc502c0ae2cb2231dbe11be11d2ed5670c2145e278a1fb9ded5 e411625a2cdab6515f7b7859d3bb023022ebcc0134b91b282834d232115bd140 ddbefa72ddf986159005da1684b7a48915059195514741db798370d655164da5 0f7978370955661411246924fbc307a417e3767ea2501fed7a2e8b358fd808d1 d4de5b072639e330943885e53f6c078e09fd5dd5c6c4ad551360ec695532e495 3e34e345f2bf3be45921b2df5bbfa7832d72d34202717fa25e64b6914b830d64 4ba16bee5f7b9c873e8c3ab6e1f1656e5d7942b3110c66937a34b1a04e9c217f 14fcd6120f77cdcead031a17cb77a3b22a326ed0992c5f0960aeac983991324d 998ca8b7277fa3992a245cecd8f168f8c5329659c789feb29c814cd14bfc6a5f f5885eb8a4c707fe9e81398293d76bf2acc06b270ae1ccf89ba43272c36caaba ba4fc55480afd863fa747945b0d7ee79c3dc0f587f839963ca89d4c24e092787 0f22e4b9304fc3c34c3b304444a7cb1e6598833560293634a44b17580c88acfe 6ae4455d40b84d49de2edc2928030752f66e77e399fff709d854c55b26232afd 21d75217460d4918d83b589f9fcef36c795b4f7d53873315b8dc710a03fa6ec7 af4bdd1025b6eec4966979c764a09e018eee1c23e3a7042f2cbf7c8800f7aa80 4dc2fec967284eb74e25c1ae6bd83c3ffd95ce67b35a322c74a51ef69b9c8109 90e8ad82728c759db4c8e66a14ed8780ccebdf55f3aa1ea9500d602f597c8b13 5e841a79975b17546878966c2317523c628026d78345d4d41cdfd296be5e0305 9a58b7b15c27ac0b4e354c25d48d13c74f7a869c10faec376d52252e11836276 ffe34396bace1cf95b6001d5506f1d775af01ba7cad59b8d0b48b17ee1c8a795 6096e00a46b3fc0dcf7a4c2f701bc95339f709c6c40c7ea1bbe066fc41192d35 932170c8d24ec1739b4b112528167398db6c4cf5318e743af07152cb9dd7f480 836cc039c150ef09ec559b896cba9d81c29cd49b5398028a38fc323293692374 72ed35780d5c7e1b4bbffedae24effb9ca5c755818d7a2ae8b4a87f93aeadf6e 9873e723254925e8e61f7c68d091a7a5df9000030aede66c588addf890b3334e 41fee2b40b31d6691a79feb07c75f12f83895ee5072990e3a2e51b985e229b54 4dc8b258c5f20d7a5addf00bbac2e7c9bde98352dc35514a0a7142b77ee8545e bf006f3d314e44c06a4ed4929cb2415fb5806fcf8b237e0012d1c804c2328a59 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 false +check_ring_signature 628aa2b9ce91d2ab3ed75fb72530c9badb0a2b254139a03b18219d3bd533f000 3318b4ff5a913fc709b4b1f538b6237d7a77e90a31de9c0c052836e2314103d6 12 bc2042d16a5b1428c5d1008014aa64fe3d88228ebe24873bf0f4769493e74869 140e705d7433883469802f370039d080202eb1c5a23134aa1a3fe8374341ab73 87a73a2034531edf41d875ca9740ea52cc41fd57b229a08300ec2a30eebfd560 f83699b2860c1417c4d84ec13782c67056a2b38e0133fc19a0c10a1e4e0db06b 944afe70b7cf50059337b22cc2df2a5dadc30cada1e6904ff571fb439c96134f e2652e868d25cf8016baf4165f4b68a293564a5b715ef7d0ed1c31bb659c1e48 d75cbd4490bbd6774724aa4e8cf24162b2b6327f62e37512b9cba692966ed396 88ee0610f2ae4b9318b3b10ce1aafe867b68aece82d80ee20c6a212a4c239e9c cfda86abd65ad4f8b6c503411fc0a1bfd0a6959c4e8821f6c37b4e9e53b0e42b 6c93189cec87607ce8d164efe52edff46a81c064104675d56088889be8c41613 140263d8ccc165f8fdaee820537359830e5a379ea86e5462cf80189f34d44fa1 daa12014693bc3371b2c3e364fe54d69b6c0513b428ae9f2c4e1fa4cb82d0ad3 360b3459635dff68bb913a9341b4ab89462a78748700a062d95a27b628989c0b0d444e2cd57d951fcc25d259373329d60681e5891ada48f1eb6fbd8d36605cc3c9e94a753f305c525cda103201a82c27b5d7cc74c3ac76740e9df0eea5c2f10b4a0fc97f262cb09654d700f28f5a45fcfbaf603b9398132d5129e22ce37c660df7e6ec87cf122793dba40732d4f1b7898e393c6f3ddcc0f17a9e24f345ff3a0c5af5516d593c4b3b55b728151afeb187acdc049ed5c60a90bc14d0b254c7ce0a89e4c1d50235f64bf5a2d33d1349b7d2a3c2d9515261c653c57c6bcabf4b320dc00a158d836e51a0f89b429a0281b27c6c9facaeed651160bcec793287249a011fa802e56a3153ccbfc3b470d97db80d46c1f1a7b8183f20c223e339220240022456ecbf7dde4a08bc67a2851877d8cd09a5b6ff9781fc6648ff73ccfcbfc609620598e27ba3b86bd5d9a61eca851538a72030f8ee825a321776924570281d00f77f090646866857bd90e05f4d5ad3f4583a7b65f65495569826c5568ac270061b16184e9ae5d772fbde31b3e5cfb87f208651d89744c334ef8302240d7fa2058ec963586029969b672a875dc4e257d2e457adbb040f7e5f3be67f9aca8208078cd910feef4dc012d1e3d9d284e249089850be3e6193581823a5f47214d5c50a1fdb26b7cebfa20f86e4d44cd8089e33613fec1e1f1a0e9f96c2f3ddc92da707ae20d831dcf1fc65f205d85c50d99b35c389377193ef4ae8c0ca631fe91b290e9f0d0ef335f15047a94adbb82e730dc0c245b2498ef8057ff6cc16c4b3e2fa0c88cba7ff8036ca38cbe3150049f7f6bf2ed00dd0e257b57a1ab21c3ead1b95039d739a07061bc1ff29d3ad952d3079eed7246a85513fefe7404ed486816a5d06169f0ff9e89b6801b2d5f14cd48cad4b1069e3480bd54ef0b4ef95bd8d699305cf6d6a21446363657d1a48ea70814e532ba312ad89e8d0558dbe2e0acbd04a03732394d1ca3fb47917e39a0b88a0981d87b406e7146cf3aaf3ef92ef471ec60104dd0eb7f459ffddea4db5a9919d70c24947ae485da26016e215434b3ad09206 false +check_ring_signature 1edcbf4ad5ea88cd579489315342f168dc189aa9dff54eabca169e79ce248f27 128413a4bf01fcfb3d6b28990dd8f48f4c89e4cfca46277bdc513acca55f6a5b 1 9b8ab2f6233f865b947f79f3fa5458fc99967527370c4e3ce59b2c0a28e539ab c91497a0847edc17b6f50bfa947fe2f37523f3d3f9a110cf94a4abf1460ff70c3f234ab464fe6e030430a818a6a0a83d13a33a6b41db663e10d30b0ab4d3f405 false +check_ring_signature 7f30a630f195aa14c7ac8644937c7458550d6fae10176136579e96a780a02056 32a7ca373d61d5da7d4c655ede97454e3b6ee70e2b9e1b70c9eff1c21efa47f1 14 284969bdc8d3b99392ca1a1be24191e6700fe599a8a465e84c884eab81e309cf f37b57204bd99601328d78ef31ab6d4e3cc71ae0f207595f638f59a15b243b21 8307bc0a377593a4cd71bfce28c74dc2b7fe2d72230d1c057ae08b8554b3230c 3037256e8d6552000f1a04598c8e143ac1bdc3779c5621f9bbce6cf191f55228 994209158bce1173fb9d9f83e15952f32dc100c5033aa9060545aa59bcf998cb f221fba7c76d16d550268acf1ca43c6492e1e4600351c93ccc68cbebca551408 cd7f3d9fbb29dee4beaccff2e149e8a84285eb75cb96869388469392084fd623 570ed5e1d711700d4434b32432d240380f9b456002114d7ed20fcdfed6ff247a 8e0af515bfe4c3c78c2524ff417a12b0c3cbfb00d4bf3537c0338ff07ef0fe50 659094825510b412923d838dd2a3402ab51af945890bfc3e8483c596e98f6ec6 953373d430449b09d9aee778f3903a9d2033fde30d0f93062ad78aadd7eba9f7 858728e3902edc306798269b2ac21f27ec15c1ce1b880e8b5973c16d8464d1a3 3843977d2bd0ab24b053b4981439afff7887ecf5b433e8f726c836fae6f9c0a5 ae2e317c29048713a2c284aaa629cffa75263054b20b8b1530ab539876c63cc8 551055e1f46dc32f72f6bc1f4eecb637106e383d15a42912dc44b873c46cb80ad00dc020a7ae90cad83b7ffd1b65c1d355aa3cc2191bec1aef30fd59fef86c027697d9d21ecea0163adfb09e89521b951a22274ca5896aca65bdffa86112b4002d8d6b461ce079742241615d3dde8f79bfe1808c3ae96a8d95c0315877d7d709235a6530047ec990e59d8a1890c204b9dc26b7f54301c16d3e2512d2de992802e0d74b8b578001746b0bb98ec9e44d292ab7ac36f1d5c8b44f9028729589ec0d2d2edf8b3fa10d829f88d0bfe669ce06d2db0026fe2e0f9f98ed5e4e6ed1480a76a185e934be624ae97032d07bb86fed87b4db586d1b91d10f9ab5ef7b64e801fb5b19e39462e506a0d65bedb1ef6c817583fe10e25ad2e99b740226d379510d4ff84b4a85b4db944dfa6315fcbaf607e0c7a9a1bc2c0916a210786407342407664d97f88c66951ff6160dfcb9023046aa212e0dd8f8f701dbaea8696699dc0d21de42e19ae832f807ebabf0dcd64346873c7a66617451b5f06906fd5c9c3f0d896818260a575c3c76b77d0d25b99af133e203226fe27f814875d0e136f9b602ad3d151751374873cf915b3354f42963a910b405d2d58d832e4610af22f009062036da190b41e6f880bf08946bac0cc9c8f121666462c2a271568267bdfea001225139c1ca892c3fc8de2b84d2fb2b8b96a808f9a0d945ddaf9c59fc8cbd980fc9000447048d223d21f7ff61362f0b59e64c774331dd38a97d109993bcd15b0f073ec02c671f78e4ba7902cd8556f7b4038fc64b6bd8d127e767446ed14e5e026f71bae0578225a0a59257bb5c6fb2915df5c5abd382f5650de9e2fb7633980623e39354b8a74055bf5d6d8a78621b6cb465008b50d4889a05d4b155d9f6bd0275f4ae2f0b2c246cb75260cfea13553f14eee9be3678f115dc352d526887220f9fb38643f79e268dfa9ea8b84834d9d48e32c8a223f16f51ffb0538eb88fae01eba23cfb066825c3b0993350c6aae9ca2b71dbdaf1b9f0d08b6e7ed68a2e110e12041d626785c16704f415f2efa030b0bec31ae81599c62e8dae0bec8cb35e050791b84300c2a88f405e9035d85ee431a728ac757c90345062ac693d2811da0a86c0b987fe3b7cda15e3300a3cf55ccbaa550f0b596c8be39821175ac962c90c9e0669af4493fbd2313e6ecaa7dc87082dbf52199519a4463f7c3c7c95ff7d0749456d6e5deeb5cecf0c438b65bc5d734d29fdba657de2f6cd47486a48d0ef09 false +check_ring_signature 01855f8572e67d9db7bc89b5b83c0cb6e69aeac876e7c6ddf7f25c4a4edcb507 d3fca1e687e75e53f2ccc1fa08be4ba0696cddff38299bb8b8ed771db1769dee 61 dc5a106fd99a9f62659a275773abf8720e3ac0ed99a7fb2e0b11cebdd37119e2 3e69811795819455f45d379df7301b1181f20e8a0433310463c391d6dc000716 52ebddde857af9c573cb7f873d3690568c5bac64bfd6a85133ab7cd619a43260 2a640f7a237b612c2084d8677ba813569e6c0fc6bbced5cc11a548c5892690a6 9bc12cbf5694f60564e8f95ddb2a1f5514f7d7d04aa03d5c8a93e7849c80c4d8 5c066be1f5e4751de5398259d14d9da5830f6cca3e5bf32dab3cd2940af6dada 7703c62a05b4175c91f8c9030bfcf7017305385f9dd2e595cee09b1196b36bae 19ae6fc57a81f573a3473a9cfb504e7c9c46a17e8ff75fe905a389ef73c15987 d5f9f69e55ef4279f4e4ba11b44beffd7178c9b8655f9bc37648cb68457c0d7b 0b35099276636f7b18dd8e0a546600c5e967d05d776ee5f82ea92ce3525fcb4e 3a697bd12e46f8dd43b50b3c0adcd7b7c5de67b3a35c77d0251a931226945b42 96e687b76cda7d7f8aa96a0400b3341c23542273ba6c6123d7c78e3ead4fb98f 15c41cbc20ff7bf9c4d05ce73284319e48fa6c819f57e04daf291a221923d460 b76110878c8bbe375c16a1259f55fcf1c9db057a1d0721f8f78d59bd78788615 51af667aa0977d7d2c3355baefdce796bbcc65e19f4584d8fc514064069eba53 854da2721da308221689238cd1b0965e278b85654f367ed3eb059075909f71db 27c1bd3eee306dfed513125a766a3c3072bfc10e2a19bd40a572d63f2a25a6aa 4e5e810756c8ebe9bdca8bb59b056b9122753a94f7e3a89a28db02f484277692 babcf0ec9a23c8e90e54161e1f1628097c4d0d62bf328f1db350a66d50b156c5 33caf93fea090ab925f026cb9b0e7643ac42b43df5efad4a92086f2c1d2efcfd add7476bc735e662de9be1df34ced3f5f3c2a4ae380020e9eefbb29444fcf49e ee42626f0b1fa30474e77e76a2acc8c99755aeede17015441fd14263ef2c2448 b66c05872de1796317dc5c8f478feb245eca2fa24d843771a72ddfe86aad7cb9 023166def14f74c3e53241d8d1b90a02685d36b2cbc2035da8f2b0191782460d 6daeaac747dd7e1c728ac7e5d1fcaef1eca0d0ea85e4c7736de279524d0678f2 c7617dfb9a98b39b48b87bc326120ae3813d0fb6fc94595e8bdca656db26bf08 c6fc7f885c12daf801fa80ccc80abf087a903a2fc20a4381368ed38f214ba340 ff0d4ce81102c4ab3cf2c1a1f6034f09e247dcc288bf192d6b0d6543e302ea0d a7576bd884f705d8cc4825411334c8f34c4c6b9844b11bb3c9df53255352fb95 b0d94020db0ad6195ea7bee23920e078d8431118a32a299887c5e425793aafff 5e68a3d4d6cfec4c750ca3c9e1b15371a125884d501e91c95553ced44e5ae437 c2617d9202811b5603a01f2402a2287b513757fd70c8d24185c82a81cebd0c6f f88aedf44d988a1ffbe7f232e215dec050e6163cb652acf4b00bf56f77b5a5a0 af72fe3845dc68ddb45e8b43dd932fecc5cab9986c9686d6411e0c65cb7f0644 dd92f8a9a1f2e3e80caff5553053596759311f4cd5932a7ffdcca392bb33fb4d 3f052198e404933689ed0f298058e9326a9f2d425c29b7a5e08e345535e6e49e 79b709b4e4a2f16de3f26bf1921d98538a72f0072b4b74b8a054b0e2a2b3a0cb da21f282feb9611e6d46dcdec42a08defc551c6c6878abf29df19e1f771f08d7 368d811125b9557b60af43c4644ed8f74feb05a845cb6285e9ee671141a0336e 035b5932d5663439f768ccc5740ad7f731a4567b133d8b2d47fac25bec54044c 89dc82d1081ce7a7d50246410452cd6912a22f4d5f17f1ad91222e0c2c1cc140 94d555160bcf463bd00f279706858b06def011e6b6a908801e19445f1eb612b8 5901552a5fea15a490f19cb150dda55a04d1e64ea5ecc9acba7cad7bdc679ab4 c30468cdf48e49efcabcedf9b7e8e3d77a920cd2b016bfb4225d45cbe947f602 a29cdc9a9b68387a29174a036e93fe90aac97c0c59648024c070fe3ee38ab853 b18794a43ca2e29565c47e6164cd812651b6e6e88937142269d9b3fbcbe2f24b 4ab4f2a18aab3cffbde0f052f982591490345d3c84c92066a1daa9bf21fd0fb5 5b23736f16697eca32a549e4c7bdebb8647fb509a323f5409cf0c6c34afc40fc 90bfcfa39d65427e0a3d2dbc7db67b6a4e2c1010d4e8f664281d067ec7c4dcad 2a31ba96c470360153e077bab0f5ee1fbdb1446a35ad0993cbb5017d6203ce81 c1d323679c1b0f698f405c41c5273dd9e828b568d382b605ebd7796613a30b50 9d076dbfa4626e8ef7cfab87586da2f288c5a66102fdfd72bbeeb58207a90a44 ca89cef63e3185a292b373d82b9960a15ad862eec450c53802503b86725bf60e f82da4659d9220c7020531ca9c023096b1441833c3a58038bcb3cfa77fcf99b1 7521017d752fc0eb3b97d8948abb99590437bc1bbdb607e5d59c4c62a843420c 806125978b85e2e547540fdf8274cf27db92fabd00e59fb7dadeaf3fee8d0f29 6c1b7ff0449cf80377fee01b77cf672b92127bf549977dd208182728fedb670d 9ada3e5d20ea53864a5666b863585b4b0e0a7443878fb5542ba7c5b4c6bfc2cb da68cefd1a7b2750db6b23c6f64865406b552c421790b1027e1768d48f6d4056 683cfc386a5a0b6dc9adb3b643fde2eedce43cfb7c4dda9e11ec3e103738d900 f6e1ec27146b5233d25dc2d2a078d7440f7647e29361f879558adb71c3510557 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 true +check_ring_signature 538e487233a1beb5907d94861ccc99b024217fdafefeebdb02189a47128fbe8e 67584e155717c4c058d64fb3a3bedae384a45ee9e9d60c76a5b4e1b1b0fa02b8 49 c947efe9590d83f52b874d4b3fa3b2fb75e590012dca859bd0888a3ffb57ea91 c3e7791af20876e23bab33f3faafd1fd0d013f711ffcd585ab68a814751895b3 4fb0d9a097ab9f436cdc1985997347ccbb14ebf7d2dbc69e2b7e104491bd63bd 99b4b93ff87446b605b85af8f089b492b00009f6a127b557df65b3e2105aadc7 27f80aa89688e70e4a21a255207a3004feb4a56eb50b4365bb66d0a60159bf39 6bd6abd9d399217da214fa29b681907233401719b912588c9d7873f163c8c26a d06618b975bb76c96f86bd8fe5da5314ec5661b1e1fd6c5f574527198fc0c662 f532d43d787408097aafaaa61424436f28ffaf2bdc6686d96e484a9df8b8046e 3bf6c5a9b7598b01aa035bcb84e3e5e695dbb1e4e081f976a4c154f5402d70d9 876e3f512eab03fcd17f91983c4eca30b57ab44cfb82f0af5e81741a5e0a9e17 fae9f896093d61f1cda7e5751a4cf3a90ea1d32f8ccf4ab2b62df841843a7202 5ea72819c58e051ae46a49e0715fc3e8c9fcafa20254d296e3e93bb90eeb6d6b c63267be18b62bc2ef27c086600ae23cdc040baae4721d2829d164620e1952aa c02c8012ccd872aa9cd4ccd8ec59c07cbab615e61a17c19d2ae5fa1db228a77c b82300ec3992334712dbc46c8ce5f5edfba98d30208785912d28908be5527446 98d18201c92a0244f5c8e52ff2fdf5a7b9aeecd69034701c2698eef590af92c9 249dfd4e8499e841449a9cf3ac478583b8da53e26b169fa577f006d389a495e3 20fc7c1ef13c55d3987444388756bc2cb2b9b70842874f129fd113fa68d24e59 6c4632d3a85cb1aad1dbaec333300ef30470dd6b239a13d3e6e9bb29ab6fad4f d7bd0d6b66bdb0773da62a208a013c62bdfbd37c5c6d0ebd4b6c8aa34429e44e 91fb976093118ca09603ddac3cc0f4dc61c6ef5cad4ad8a28d7d42fba1b6463c 34fe9dafce6c8cc52d5119560cf6c0eb1433cc7d74598ea2aec3ff20e46b2a89 b878138f014c1e8432c2ffc875e6893ba5d71d3406329857b883ce3e6ad38032 489d18ad128cd0bb4eb6991f840c8645bbfb2323e32e4b9bddbf7398a872d2ec b6d08a9f0b28bb41505191b7c2b4f7d72c64be5d1390c58e19a312ef372ecba2 3f8197dbbbd8038f81c2b4039cbecfd160ed7b15a11f6833b417d1164fa44c28 8fc7cee54d8c605ef00ff6edfab5fc9cca9e9a9b6623d08f13dc212edfc10cb2 1f2eef031750efcd1fc06fb24ebaa1e0016849e24863d8091227ae86c891b9e5 435f45eb1dd2e5d6d5c0ecda67089352966f3c848b7a3e75c2ccfceb218394bb b566e1aad254913d3ab7fb453cdf2c62380984bbcd73e7573667fb2323e268c4 ed0ba7266097314e971351c0c5fda0568a40ac6ee062cc80b966388a6342fefb 1f17164451dfb2f38b9f8529a8746a230dd7e01a6fec467b3037e9348e37816c 07afae0021aaa4e945d27bcd780a0579238773b83f2422b366c4189fccb38567 8f91435223a26bf3ea3c7df0b0911e90b0a5b9ead051624a43a4899d2ddbfbd2 a8193bcb993928b729e598e52309967708584362ed141c7de1d2cead68b011f6 4bc8126ebc392548c201e4a142b29165e7bef4fad542638d6df3e77184ae7a20 859dd96c1c24326164303555abfc022b9a259a3884b7a96a1fe823c695cbb7ca 897182d52bb43e04d6f1d781d20d13dd5dda9813461abb4a703fc20b20114266 805d79246ceb3db1d7bca74cf349a3d204fe38cc8f1d0f7548535d38e08331ce f2689adb2ca9d89d2ca2788f667b4501bf847e57d4fad83ea8aaff508de9c3e3 e20cdf31c19505ddad8326d882846d187994d2a103199e429dbe89c85e0147ca e12db6442b1d1f5b969348a55abc744abdb3cd0be402c05fc63dfa1bdcfef3ba 0c1ecc9eb0519c5b2b2f108ce23c42bdef7a3f4e9552210696d2ab3b38a4531d dc2c1193398f7f08626ac73e08eb39f5b00fa722c371f64977d91606c463fbde a8487a243191d4763df96e82b79b0b674ff2d99756af4b37c714a838022a56b8 01d95fd4850ba5ef134bc600707c384f04b3030b384877f89d1c4a1ccf233070 794fb8ff3a214c07fb6c7c7dd67cde36f2918e0f53c7363d7a13ca879a230576 d8e466e752c28ba80837d26979a1bebc6c6ef553b87fa20cad01a6aef89df947 01578bb6445d532adc6af33c9f88bb969c56644b0a0f9b13fdb0ed84d601ee0f 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 true +check_ring_signature 78aa10dffd27559c5513ac326486fd087c0954d5834e98a7cbc0ef9c297b10d0 db9cd7dbfdc3ac5b01f3fb9453075bbd939937271b935aca5bf819921f37f59d 1 c8c19e8e6b7474303f62f98de75236b526c41edf14219c7140c05906ea8ebef7 dace027796131c489a798aef55cb4e29f8f578af8b2eb25108c2b08b9ac8ec0fe56b11f7dfaa3d5a06e74448cbd9bf2389538b54692715c9c310be300560640b true +check_ring_signature a7a42886e057fb35a0280e940c9fda591276110f6d4a8bfd8d7c1b90e55c7793 47f076ab98ec60ce09c74adcfeff381c2b102e630bf0673c7c090735787b6236 70 3a56729a666a775be7cdb96505617affa1f540e49359f2182983a892501c3f5d c50c06ac3410c0bb90ab4a5f04942b38df1a9118f760d7cac98d45262f62824b f02a267d3953294204c1272ffb9cce0513d99e51a2e86aad2d24dfcb05f99810 af4a5e7c970e2c9b048d676d2b3dcb87e189804bb469e5654dee3dd4972475f7 63b2e30270bdc413f6b902fc7c252ea1a6c5da439324873ac5e32637047400d0 3f5bcbfd00f515b3b6527f4fd7621301cbf46c7739a5abdb7d841dc1f4ba3922 791939e1793ae29895455e9fcfe79ad5804bd4df8c9cecd48882e8bf5fe953da fa9e398b82094581e44eaeffd21aca89ffc837c24ca7d243b621026123ea5414 0e2ceee557ef93598a10016798e08d3d3f5c789251af0bc545d4f2af21544833 0414e4bf8e1a803dfb840e9736d0ae5631d3f2b4701af966a8e4080b9ef8e83a dbd1495c1071abb4872feb27529e92a15c9e0781bad43eb36293d094835a4544 34dc5474f60231541641a637b609ddfb634768cc62518428e3bace654b3d8e2d 604eb346b48a4040f79f6c0956199adf5018bd5a199d5c1dd5aec04025dd5442 8fbed33e6655e523bed4cb6df21de46f64655a823ad0a631a71d74c898e1c5f1 8ded35b96b654920ef5cc547f017fa4bea626d184660e57982fdbf2b1e4a33c9 9404a3d2a4019f91a8a6e296ea336ea7506b27f4fd98c9ca26d0e54d7b6a4357 7c8b7fcc565c126651f091fa9638b66974e844ce22ff7452e560922f8efbff2a e042041bc5a3861d96cf5e013a3a78e1456423659403edea6ba91d89e61629c3 700bccf8232e30015e021409d34651330b81b6ae8d7f3dd11de55babb7ba9349 df00c534616d0dc7fa5179c90a58f1de4be8acf5884e85f4c016a9dc04afe5d0 824beb56a3197995395e9ce7b75f13639ce93f117d0bff4312e94ce3afa70356 4183f5a64e0f7e2b4152a8be58fd44a2c1b0031eae6b60a8e62160c53eea7fc0 7aa12862cde23e101fc0f02e3958b0fa0e4386844ab81e16d67338353719e292 0b09c47f887deb80fd259131bedf3d082db58cb636d2cf00f3d3ad97cd4c1d3d 917064db46d5be487d963d5a75494381731948f0fe8e503094477829ecf5e12c 8eae073ef95e8a7e98d540fa3f83e0c532acb980379ae1cfab2f6af73bc2a4c1 914ccc7537646fe933644506adbe2fb2ef6a162a3af19507abdf93349ded9b32 4fec6270b74cb1ef3d2c8225398273996adc5fe5332a223fb4808fdcd490d2fc 2b7925036156b0f6db8aecd600efc13b1a0cd7ac93a86a0ee3195069629c2f6a 8a8f98a15cbdf680fd878125a32943250f9a55214bbf0e805e488d8e73d927c1 1481405c76cb275afa128f3bc5f63cb6dbf652b2905d0c68f5f37932abe9116c 91dedd4e12a396618b97aa422a78e90f5247a45bfb1bbb6bcc408a50bc4d6b65 c7fcb13458e9b9fa4bbd4b91cc4f32b7bfe846ce2c8e4b19f081bc6cbab469cc e8c30f4399c2a0b8474fe033f545b4b146a33c4c6a6f8798772a69b7171629af 89ef2297f4ce3b4d797a663f86159e0c0b902894abb9381337702a41c7a6e84c 86bbef281692096c8d0b7046fe225299d2ad8f2fdf9db712db3e295556bdb8a0 a0d5d349d0b53ec01e3201d9f35f6bd1d73ae5eeb18c241521f5dfeaf537c048 6df2a8826847aa70ebd4799b45ce6e567476105c02e2a7da910bb4295af44059 97ecf7d836918367f23dee7c5a9e30a8c95ddbf2d644d58ae7d5d6e5fa86d631 ddcab229a85766fb7edeac92e9e5d782856c58fb5af1cd2215918f58b6e47868 42d6a302b5d9755b5513b0ff8a796f1eec20d0d6833fe9ebff9578fb9e238ca4 3bc754eb48b5081393fcabfa7397f9eb8279548ff0f5ef80f23cecb8bd58d2f3 40d81f7e78f0f5dbf89f7fd23a9168f538c2812e3c12458159acb09761b7f2f0 a02ad27fd921c8cac9073a0d1bfbaa360bdb92ca261bce2fb5ba7169891fb2fc 00574cc318b43636f98d0f92cfedac2094bd0937a58bde54e9ab50b0c1234a7e 08c266f0ad2eabdc473bc2eab6396b445afe2662acbce5360aa61ea29a4319cf a1ef9dd10e1e6f27dd604592efd7975dd5879b85d4fedc08e7e6e2552644fe7c de48eda1bf4046879af1feecec61b65f3576dcdf77f3f4b9886dfd96b5445932 92b71e243dfe7a94fe35e2cb469e9c342491f3720eb6c2d478853cd23df78c1e d61ec4833c4d54e70df03fc381f4d865c92ca9ba447c94b3a4c7d195354084aa f909d68efe69830428bf6cf2c0388f05eee12acc91d6fedf0ef4329c3223766b 37f924b1a2ebbdcc2da75210885af2bee95276d733df48db06fac72e7a520469 8d7258d0de50d56bed1f373ec324b67748ed343af896fec99171b796754a3e12 4f595ffc95040b26b485c66737d1d0c639098531af2e29a353fe870b968bd889 ea005c4b06da63a4f338560286f92255aa9c7e812d5ac65a33ad4da08d8d4d3a b1a9a863360bc5dd7f40a3e045e4f9ea722657ad256ced4ce40431645c73e015 22f0e1b715f50e684e315476d6818c3159678f65e8b52c03fb977cce9023cb2d 0dbad0419adfc3fd9b77aa1de7880166f12a89ac20d2474eff970fcd02e5be32 24f9f1225f6eb2182b21b6333d027204a5eff891d122a5f30f379fd37d71a49a 8c753148daa7e78d50ac4fa7b1e7c9451f96ae9755b4906f85bee54db3c22e91 3613cf8a3b4d35f54e268938b984de243402a1fcc05218d340a58664bb897610 c3acd0f406d369ed37af96f5de68a03acf6ad6f74c223113ef3c626e77677171 d38c761ea5a58c73660b379248cd9fae3e98f699f197c58ff1e7b60c1cce1915 47dca9bc971631305734bb71cfe2d1d0cbd9c64c2a253095e83e7b150c964c73 f6110573e1ee9f70822d13b4acce578a1c7911d3e3f21e3f18c1fd64d94a0161 90378795059988f36afc2a53a8dda71ef7c35f4833718f6d361d538cdc9054be 2c4c9108f0e8cc1e409e80c9922ea16dcbba8a49830ae8600288278222e34fa1 4df72819b7d10cb4fa12e03c7efd5b0ee410b08b601423166b412fb2210fdcff 9469b3453df4c6e55bb3c3336b764856e9842e0aa5a22d850e2ec0bde73da247 7e26fbdf019c5e00f3c188cf319da73c7323d6a321ac052a3b153c043aa258b3 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 false +check_ring_signature eaf045b38f9d6bb0886d3ea35719da452755fe7a3a6d11fcf03d44f1f7517816 ab2dbdf977f499a0c1f78b2e54ed80e4514f182e1dda603b6f05cad089e60d05 6 e828f055cdc2b65dfc74620837aa09d84904d4c93056602119721a87592b0d54 758048bf309dff44b77ff576d8689798dc185be24d3aacd0b941631c12c39d7d 5c59df7aa734208be1360df167f64f904f960183ab76d1752de44057e7578076 05785c57dd5c94d7432942b3a77bf5f064d38867ee0590825f8b31b2d48c9ced c0ec67c289067780bd79e11b976ae48af1377c1e9739f3b247aa716acf3ea3ef aa8244a3d9ddb8b067fa79db50a7a4a9e3a34c75efe4db68c7c185a6fa49bc04 8f50f68767f994efc860bacf484e0b700c5c3abf37b8fcdb321def5ad29ff10eb22d8a468e62e896ddf7a85f9ada04075ccf53c9827975914beb217a504dd000fd1ef73671620a276dcb940c976fc002a1aed3462d9d518fd0d9f8c2d96dd30c2db61c82eb9cfdedcee458341d0baa8678c16ef0eec66cdd120722bd6c7ec40ffbef51d4105126bd2d15dde560d04eb64d6218ad1a0f208d977e32ef0c470107481fe723e711b03a9758aea4c718702feae508fe8c115bd5a09418162f35d60460a8cd8fecbd97f96983daadfc62b47abd7ac7d48326c57510f874cbf9874f0a717508c56c1d5269d598579845b041c4dd95e6a799671d429f35d5e551b57b08bc64669472242369e05254e4cd37f09a51f2c8f28396f0766872213305a804029463e768d758886b81befa6c2edecbc9c14026d10dafc748708097c3758d0706cd4ea7718a2c8ea53bf78eb7212b10f024c70b83b4403b14b5d01e489397a70600852faf9afe97d8b3ee520dcd641679b21f67a68729af13408fef07dbf55a01 false +check_ring_signature ddde0086b92184e8371d5fd3d748241257fea0cc6b7950e50dd3a92bc52cba22 ff24226047a92cd42a7bda63967a35ef537f301d90704a5ef59dc5305dd6d0fd 1 51916f6c8ead3ebdd015084b414a5507e6eaa70240e2fc84e1ddf4d575e36ef0 c8438d6ff8a5c89f8fe087ee25747e30b08f1b187bfcfe78e20e58a120dcc60d1da2ea2aa6bceaf3fce251114a9c06ed03efb4a63f3dffe6e53ba2014da4140b false +check_ring_signature 9a92846127a01551d4adffddeb12838a8f441fa1115cca876f07425c4f7c22c5 05576dffe75af10a99ee77433b6cd6c2da63f99acbda733ca4fb5f767f50df5b 7 1b1115a03fc245e39481bc6a9b518c2ef9708f4072cf3bcd0648ff56d6d95262 36627a207b61819ca2a3492b023c3fd73586515f7438331c303ba1e32f496439 a0d579d4ed9545429a9b46d7cae6b0aef8d212b1b601940cc282694c08784eca c632ef0a37784fc81d7fd79093a91d53147721bfaf1019179ffdad26962025da 7da788d026421c5b2bd97d86addac3e020f1e5506c546571d3e4335c3485f234 24a06f46ce6946d56a4800ae4d54b39aacdbebe15db4624ca04560dfb1d88005 ad46a160092f8baa97b97992123ee3249e3d15d635afe98981dbc5d03053326a f26692d0f70bd9c4d352e00ccf827809a1f36de841c07dcc2e8abe2c9d2bb80a0d89817a5d3646d7708332133a028e3577bb6487145aed62460129496175a70f20e735fdde60ba617733cc71d1c6555348c4d10f221e17601f6a97b56b32fa051291115f5fa523bf70431c58f31e1e588d4d73b55b5273257fee201913119501263e3c100378581aadfeeeee938887e6807337dad2a53b90baa3aac5657d04091b2546e1a309cb4cb7f3ee80115710b2369b68fddb9b53f7bec5c893d12b17ec4ff8ec7327fbe5d3cf0e9b663ee00fc20f702b977abc5d5ae716f54f0dbcaa5415b151a62ab9334c4c560b7b4c44c603cdd218493e086c70d16a4b6ad525690bf1cabbfcbf24d6438db686fb84c58f8f6a98e142b4b6f7ba70cc861de4c61009284f7e734f03d769effac2adc6469e268922a9dd2529055341854002711810098c0bebfc19bc7456ddb105fbd68e6e7e31ebb0cc4acaf485f76dd3f2692b3f24fb6cb6d67b3f79d9e88925423ee0a2f87d63c4729d6430bee9e0b959f732f5032feb0ec43ff7f1ca1f2713a94213453ecf490ca278f8002c95a2039d72c57108142ea50f27944fb218d707e1198b739567245da0b8978f0f588030d5895c950f false +check_ring_signature 9275ebaa65ef31590533eea0f478ed810de9c87de8eebefd438658adc00fb595 9a4eb79871ebcb294be6b6cdd0ecf349fee4d4e40d78ed7e660d28af8e6cc0f3 1 2bd93483e22b61dd2dd869c437ed251b61724780978bd49717e6fd6d0cda3bb1 73d7ee0f122d1aa267b87c83f04bcc77ef9eba14148441441c661160448cb3047bb996f4232f8e616b8d6922a975eef8974fc53b99ad46c66a8f0ccf402afbea false +check_ring_signature c3c2cd8cf9b5b80c3cd81d5b8d69ada01d28179afab73ab7d34fd00895c9e784 3155ac4b9e983549c26bcb3eac57e2c6bb4efbad11ba5dd201d8a75bdacbb468 6 49cd023bf3621cc0b5308156b9d8dfbc34279400c4453c516959265ee8a7d4ff f8373fb219423f92e07a65731064ceaf6cc0f122350bf6afe889b3098b881210 f52c80df12523512b3c20320c994e26ad877bc6f9df93911af17d0efa9b11ca8 7d4a7fdc4c1cd9548aad3293f636dfd2023365b2b8ecbf81fd82773d58488720 409ccb7a40114feb9bb23a875dba13516000646b48715a4bf1415e6b72e8112a 6d286ede8fd890249e14d186428154699c74618601ad3c9992b25f2efc9e3ea6 19d1a9548d6b503736aa10b34030ae9793541294daa66cd95759416974a50302fbe59eb274b3b0707fe9989a6ab1d19b2a9aa6ad4ac4b5690a8a426c62ba3d0eb06f308b2a19f6dcd8989b2e4b89a011b05b4694316e59ada3ad8e31f5bd370bec95b53f05b548b1f3f17a9ee4068494b3062b3734706a26f7b20dd63950a60d7ae2162999ff021b02d912c307e9cc536db1cc5a8ec44cda1e10e2b8b62e530166ae09960b2361b00297bb1deabaef6e437e0ed93e405d99c22b908aa804b30418173483647b4242c4bb9bd83ebb588c1a7a933ac799ca9eebd44d5d8a653d091c898e2dd2a7fa5831bdf92a81a884e020ea2b611dce4dbecd4a4bf145f2f70bbd54a13bcb0bdb4fc253a4087b2e632e4dd85b4fb741ddee6a187ae345c4660f15bb1629653a6fa526078177d7c73934494d5d08de39c4e53b1484297d1f640697e7ca5ae25fdd4719364e22f2f2a41aab1595a4ef84cc420717b3cae24ef90850283565d3f756e8a2e6ab1e918cbaae033bd318efb88dd83a64f06688d8fd09 false +check_ring_signature a510b33710d0009d34757d3b4e0103c125ebe9c5095eab8dda237fdc714c71d7 5361d31712cbae14b76cbf86bce296f76df282ac682b2dd7b3f697a1608feb2a 1 37b944ad2d010ed72fd4381c3f7bd3b2db61302500a8ab39b964ed9234a18bba 082ce03cfa6a5a373f0ac1adea870396482c3b76e3321714b5a17bdc00d9777270cbfb4b029c6f8e9723c6dc9085c77bce99a50efdea320939ec24b88f5e8106 false +check_ring_signature 3aa0655533545c823231ad9160094583a8e71e1f5a518edb828f0a9aecdac834 01cebb071eb7c2d65bb1d32d355404cd12cbdeb5d0c8eb2624dee06f126770d8 68 98a7eb8e7c12611a61419bac6dfd0193a645bccfc7267e10d1338c9501bc7292 d86da58b7aede38e7013baed6b1d050826029ad615af194d5eed8647c8f236a0 1111e5648fc53d286030defcd8ff6a60089a60a6117c82e6662a0c7eea7359cc fce8244148ea06c8034b1f77569306d93bf2353f9acabe0f0b347aac63463a6e b038773d36b42d60af9e485fc3dc5e1636334be12be8b3c60434c3c38501e2f8 f81bf266058df0018d15768369fe07f02d01daa8dc34da69ece1c0a58e4d376f b50d966258849a8cd660fb7557cd1bb9108337094c4e43c59a33ec86ea1dd9a7 b2f43374df12591a6cfdfdc487bafae6fa155ba10616ff6a1d2ca57cc44b4ee6 81de4dff455dccb71331cdc4c23329cf6b05cfbff64cf376f66a15276d827a1c fa71c954cdd2a60a6051c17922a7a539712b481c7a667365351f35a68d5e47fc 4ff474e5ff2bd71a5fbff84962ad5a34f3f3842946b5bd4dd999bc584232ea1b f1b52809df680f123d54b65b4db4af2ac33d31c5f8a8d8ad90a1001a4a81e3cb 6160df97c00f60d49743056ba73e8f887463f2f99ea80253a3788bdae5efcaa1 3087dea24f82fc1afd0fbc5c3aa617151946abddb62aeddaa1f26a9cfa4b00a4 96b482d64747d5b35137e8c9d95c324b5aa9f20c424affbc9ea8a60e8b0ec9f4 e15ea974956aa7d81d2913db3509cd33d460698a6a63832be79be2112e18ad55 a7608dc6030ef52ffe83a0aba6ba66eccd8dabfc7503a54cb5a7aed240d41631 eca153bebffbd0d07b0f0730ea86742194728b9a527a2c0d7e67708dd9ca7196 cb1ee98518e201e45ab869d2c1583bd1b4ec80885852bf3a901a20750e3fbc62 f311767e054ce3512e8cfe004f433c5f38feed7e7a95bee5f43c06c584aca650 f0201b4b6b4346b80074f792657f3c5c201650f3f8d61ffed324a98877e57325 9277aa5619b4589d4f66066a371a95d0b6169bcdf6e4ec2e48deb0835b7be4e9 36175914f2c475afb4444d22f1e577713a9d8cf684d5c3f24a308bfaf7dd6dad 2c8fb2146f2511b9265996c4d7e19b42917437ca39f88a716b3890eacd793fb1 12181dced537a1a6de142388b6f4bcb49dee53b80a87e9a083fdfaf5a63d8fe0 9cde7af830d69c6498aa8210561719f4a53130f4d3945969be42b8a43b7b83c8 b14488bc906beaf14c8f9728c94c7d3331d0b493c30bb118695e6a46fb1f7bca 65a9e2c21bc31e3fc94786e9a29ccfd665e924f79429ec13ff34419f3a76f4f3 81e3374c8053ac802409fcca9bd0398e8cdde0fe52dc03d5f238de381841965f d5f1e8f398075ee136217c8b8e419c76b1c72f88f6e467e02b9cf719fba57af4 ad59a999143d0922c381fe5bf0f1a5a1f424f45122cb7094a8be61af365b8cf5 ce610b3ef43660e75a139e2800bb5a904359b69c3e00a69381c2557f03af956d cb22b117935a4c2a09838a71897dbe946b8f3e4b0fd00be947d3db3f9586160d c58d8a87a54e3e0cb2e18156437a4220aa7b34e388acba47d8b922dc8b63d5a3 2ca1727bf6415e17425f7f3fef1c049007d7f83d0d322e0589223e26ed9147a5 30cd22a5401ac3e10e7c74b72eafdc682c16cf88df75e03702b34c3caa4d34d8 84ee267b29bc945dbabc579eaed4a2261594ec3135894493a81af89707d57243 8af410ab8613a3040ea97293ea41d716fbb7b57ae6f010dc6d29af4864b6a889 704859bf6f6a01711330735f3f7dee60c25f0f98ce25190c1f8cc9c0a474d5d3 3f561d6d5ad2d0218d48548ea4a9a9c62c266f6579c2a86ee12657cc0e2ba7aa fac68ecd87acc309ce8fb1166dda6058f3be279c8250a03f04f5a9d92913beac 572de24d62976116463376eaf93dad098910f3357442237a88c89c7b17243733 78f53d1b32a6897a25ceff23dc7da64da030ed76b029799700f060f750a9ca14 680f4fe78e53fbd9466c888cd290b41f34019be561b21a4c7461a9d5d96a0443 546deefe69e5f7c4011205b7af670d035227b4d5e1287a41b45d9890f6a934c1 869f85e332e7c7c2e6725b3a462c63cd513cb83f00e4a536e8ebbf2e26fa8257 372b8c8d67950a90d4e75456b941789395af3454e33502856ab3fe5479369df0 1a711303bfc7fbcadbf453b27b308b4a47360e4d609685d890442bcd28879e3c 92114e7c06e3e560b3035ce34a332778c791dfe96179b6e76b0686ee65613190 9a5956117f247a118b081b04d06a71333562995f87b2a721cadc2b78a469ccae 90dce7ed012756620526c92e65bc6fae5b813db6b59101dd8bacb56fb6b07691 c694f4b6663e31c93c8ce9b2d4d5cd43087d11cfcbf3c3633f381794761cef4b 3e027e4a1c00e81730ee50ac59e40ab14ca8079bee2e7c302d72a42036684848 7c4b1d9cead803a79114ba25c41605939ca1f4a23b21331027354d7c52c39930 cc870cbb77fc39f51aaedc2740ee3938a84f31f04ee497f67a309a41845fcd9a 2e04c8b1ec2f5a4f218ae5e48164074b5abd7c7dc58294342973c2726cfc2956 b1303c0066920e7f38e5f6024a18a757b5756c251a1131b0eb5ab959f80260b8 861355f58083f7025465e57f14c44898676c3f4df1612d8267bcbb723c4e620d 250fe05e46a306ca257366d060867909a4ae6a16cae2bedf296428de9b583566 ff29da43ad37d53d2885e4df4dd44077fe26b0542aa6796f90c7a832ed65e729 24a4c8cc238ae0a941786819568096ddb7c111954df27e2c4e3260f7e5f00bdb 0097658aa2be4c04951459e057d189b20ce242041c08e005919acdf18093ada1 f233c4b0105df5f9f974a42bbb78e838b435fd0442fbdf14365b4c2c262b92c1 321d9c076d9a6909b142b0153e0e3ca1857febfa4db63c8209450f71e57ec42c 12da6367e2bd388d5161be5e6990e9fa8678d935c7d8f15a2f5063709ff2f33b a16bc8fc892ae506d8b6afdba742cec52e1e0b3310cf8aa424953598f5570341 98d9be205b626da584b070b6efd04ddd48a77d4361c5915c25e412cb4dfff538 adcee3d782b4f6022e08d9ff49ffebaeb60baa1a7e18d9d2574dc41e025e895c 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 false +check_ring_signature d671fc2ac72862e5ef3b96afdb38a329e3c159a2968bf231b0276dc2e74465fd 8f01a72095176288bafcca5c269376fec6e6f077730ae0a327a2e2309a4f8baa 3 da41d95e1e256764d8af93c86ef6c4aae4c0c6236464c51553ecee182e350ba5 64b6961581055a972a55388deb364962ff79c06f0f744174e42e720c68470e9d 84e2556716c0940cc02e92082b62e92b3b8cd5a12b413e3aa13b55575ffdbe0b bed7d393070f0e8ee99b67574970a3fa4083b20c7e72f229dd5bf554759cec0b7d3b31d6383c09a19cd3175bd381467613261aae95d3362b98e341af985f440ffc9ea477ba973b6ffe3ff34e9dc41222e01ae4f3ab56cfd390940bcc77e8210d010b5d8981475a6ac1761038df36b6aa60cb9e5737291d8a43f13e0efbe6fd0ad1bad149dd3b50424ea857f978bc4efe267d392d8d5e6ae715c57734aa2081059c2ecdbfdcf8bbec51f04bc44457dba5912a35994921da81cac9191b2eef0c0b true +check_ring_signature 8e3fe2f1c61e15a9788ec809bf018393230907172d7c141a7685b689269d780a 080465fdfc3b98123ea89763eae971bb6f0223281a328bfb54164b5070fbdce7 3 4ce3c774a679669a66433eecb8ae8b4ad0ccf982bf15044e194c4a6d1f78fff3 f3f5f820b74c5291576f35154ab51005a7f1a9bd30a9a2aa686d6e4b062129ef ef9929b57d4fa211b90690e5cd84f928281707c587c37e09b526948d0b0471fb 0b2e0128a45ce7b6467f8e672a17360b210f6d1c837e74a4ab5a81cf177c7602b0f35f888413dfef8d2d5abf667abb4c629d840a908d12571f67635fdca0630dbf9e0ca509589a5e0860abf32e38680f1cdda8a8c5859124f92eead84f88a30f2f50084fb3effb4599319e55868ead5f42704a85a7f3b033cd9fa5099f9982046751983683466356dabd324cfa4a8d21f8eb33fd66b49532a2a4b91cdd353708fc2a6486622bc67aca1643aa036fcc0a1738a18f93d1fdee8cc7a3fbb6f02401 true +check_ring_signature 1a4978cc2de4abfa2fdd74056c9e7f158cbe5c2f206f9da49c0f8839929815a4 1daf2d4b87a71f74549086eaf311fecaf011b26d8216807fbee4b885f66a5742 4 3dde6e4b7fb32f6b1b1f13236221504fda2194b82b788ae204d5abc2ad00edaf b96e751d9a315c2a5ab4146f73363ac564b2ded962e7664b3209acc8031b9629 e1d7eb1e9dda3c47cb3319fa483f431749784c172e344e07ec7b604d01030e00 119ba6d29490fc3807f0ef552a68e662334f3e2b43d791bec7f76c84e85a56db d79a8adcff0aa2c0b6e28b59a36627d6f375e9d17d95392c82aeac5491a7b60b2952631efbbe6868f619b6928c905da02df2e9573580eb86417b4f79afb77506569ddee6cba11c0ee25569436369fa8b971ff6edb3d28ae158c7abf45ae752027fd1097c8e6c0d0ea220ddac14b15349f03686126bac5b878d95a0b8a52d450806f79b692042dbb37e23b33d33f53a00185bc9b864907b09bab316d0e4437a08219b050428997c99360b99affa55ea3ac72265020fd8c4cc48ab874721d3b503938d77e7bd4b3326f6ed8987b239124e80da38a2e4d5dd1676db4583a9fd120286c8725fa01ceb74c7b42193c783986edb7b65660b6703209a589591d63fac0a true +check_ring_signature 656fe200c94f50d436f03a44bb9ea811a1685fc7b34b3e37b29239184a1646e7 0e3122b3ac427e727c4700496fc34e126ab08935a79c0abd2780011c6686b4cb 193 26de92250c825398a02b8427fe648e05e3b9b47ff3aa58be4f483f7a4ccb91f0 1bb523301ad5d5200e0c368483e75492fcfd89b390fe775244ea76b36e3d4243 466ac9227b48c41b6f700f33a339df486daa2315a3c155a6032486c706127b9e 7afee995ceea7c39b0324acd9e5f0998c2d97152c560c1f60e6ed1919a2ed055 145eca4d19d684f6a101788a245d0d62e093a27441066aeaaf0580edd5c5bb63 be958c4e57ed7674cd01d7f03ec1c1a990d641a039edddb59e49075e194af44a 49190b36c7a1d121a8158023fcd8daa927e3286f434b31b82ae2a70a2c23db6f 5477631fc6323698bd26b80a9abc819b758c9c8b3231c076b101903ae40a452d 40d120b50e72acfe90c91b3a21f9f87a21a0c8e1e49359ea95c74aa1488e67d5 9be813c269ff4072f957c7319357a7926beb0d24ae5ba3e56a84c138f9e09baa 4baae017fcc2f511e97f1731a44f48446086f42cb9390f3108f488d1765a47a6 2e20f17c120ea61f3875bfe4621440761307ad4a20c138bd314a4721ab882c4c ffe491a25c31d3192b818a238a3634540ce6b697d28cc25164618fb85a41a4b9 f7b83a648a0593ff66e854947e54332cad793fd6c8c3cc46b2054f59fda97db6 aacabfa7505ca7af6c64ca310fecf375263716ebcd0b214bec194d5001989eb8 cd09fae52695dcd1c8cb450a93db86c0c76b662baf6848a507f184ca393ee864 3e75e0d458a2b4bab7b2441a1cd7519516f035869c80c7dd86b9264cfc257321 c6f5b7ede662504c337fc23c559094bf76dff011066e6315917b07ccce70eba0 5417f8e2bc4916bb3633f140af82601d6dae0396dd774917468eced851cb2b8f b0dbe42f0d82c44a6d07ad2da9df38af5bc08ab28f629779adc3726949471747 b7b5eda13d40c85c05038bba4c964003112631bf4363c139dbeae799ae42f08c 3300fe6b48064c2d51ff44c11cc3cc1fc642b68c5d604aac45e29b22d9e622e3 180017f8eddd46ab68eb522a9e061de6a42ca4ec954a021b7a06501dee9cfed4 840671a3285852709377741867f04e047f24c8a4dea977c9f718150c61dd3937 de0f7d9cd455b3b1522f45590a01b168b4070a1bb5af7bd95828a92792ddf6fd b504e617b95737c1c096dedca5dfb64bc49432aea02ef74bd1b54d7a59351b03 c5bc8e06447d94b7dbf3cf95d343d08f4c5af059225213321f98c25c86022397 550b679287870e8ad38305180a629af8da070c37c0fb21ec2d06e8f51772f873 3e9142a5cc9d627c83effdcd33c5fe0bb2f8f8f15ed66a1a363d4894385db23f a2420b67cffb1a224e2655105fbd550ef7d98d1af7c8c7920571667865f3bf48 912a134524ec987a50bfb41535b1a9abea3950faca175ed06aa85f42abf51c77 d51ebc850ca1d92d0d4216ee9a7c4a88e3884a6b413e066b71ebaf8f75a126df ce35c3232adb7f9d887adad495012fd3991512313f22d134e5b385958424f41c 8894cbe62e10d2b36f6b8d24e3de20c7a843e94134cfb7ba9f2e3d8177379489 a7abeecf90a1296baf8a2ed8097d4fdf8d78e3d97ba1a3198f7373ef2225539e ee80f215914142f52538645c3f6b9c9e707c568ca255e00167a721e0c82b38e0 00e2253bf85100d5cc5f90788928f45f824bd574529d23bb3f49f6f476d45138 2019fc573bd74aed19d8ffeba5795de9c3aa22c9286ec8743226f2745f463470 29d245f73fbff972d3bb4977e4c6f414fd2dbab8970367c900a57893ab6015b6 087d43ebe82ef06a9bc0803140f76a254d180f84539abb6bd8ce29d9e3cca3ea b73398d0863cb8671778439195d8fb10b53981cc9264f3ceedcb25bcb68f4d6c 1401f3fe5c534bef7e28aeb9e13d02c2d4474ce47d325a9c6e0197aa2e269d61 d756e58773e42bb4885944d4d5d71d8f529ef7702fc0c897bd300c3f08cf9b7b 96b05d3c71023aeb8e89a60392a0f8be0ebeb3e635f128ef765919893775467b 7270ef38c386a5f2c2ea909941a612bedfde6f30f30d6475b06d4897972145c1 e9feae63e6a5e5cadaa3664edca80201bcb309f103dc31ce09a3b1184ca69154 b4e5125a89eb96c80caebdc97c9c4f5d9735c0a51109060a4f023f3ebb9354be 7dff36a35cb185d38b1ef67cb977554346f19679101213ce5446cc4e8949902d def62127c2fdcf1cd5d0c1bcc9b515f79ac69f05e52aef024e4e6bb7ece5671a 1e66a44a38ca0f61b930051737114d3ab78d61a17bf23db097995cfc9afc579c 47181125be44621425ec88e083582260928371f7104021878aac3c2e95dc5e66 b7b37004b6307ba4c7403791af9b2fb8b24c1bc828e3c3cbaedd18b78cd15165 3d5f80f28751f1884a2bcb5fc35858cf606d910f8cf66d053fc231c62716c0e3 7e6d0a73f70f4b1fa9b88482337ee30cd6ed18972f77db192cdb3159a15a0da1 abf2184ec78fd284736385fef9a126c1c1dcc589977d25ceeefeefdcd89c0931 9d3f8193e8f07408072394188b0805c735ccb4d6f692039de638f6ddf2613a53 a91ad42e907c7c24ce6a84e45459b8f3c2730240c585c0952e7bf90c997c8341 bdf4c4648ac142bc537384261541c693e25bfaff7d31a33c013a4f159a7f2411 660ebfd2725513481a76442703310484dc304e6abf0fb9e6636ab50743febaa2 5c35a89a1cdf18e743b2bf5f279a48a9c69cd205a14aec9f45872979e0a6eaaa c101d747215367cea4a49d0d9b8f267bd6afcaad77f0594966587f197469b55c ef976c9f9e7aba4814e5c8bf2a1a4f473b07aae2d02f2c9a68010aca98b74f53 c5c6089d9399f4d043a9bfe29e3957edeb22db7ba8227883a64ced3966aab229 e2791e2b410f1dfefca4914b8921571d5e49d96de1410b1bd8303535fda54678 03d2ece9a4bd3015f1f6413cedca1243dc9bd72fb5791b82ef60e15a9a19ffda e7a6989f68c9dadfebb6dddbfb69e66f7c57c7e97c351ceb857fd4b6e9847406 6dab91f204dfa518265c61d7ee473a12efbd5e6c3f08dffca13de96400c66e31 0450b7e01fb4875b544d0647167e572a27d6850d5a05b04f9481a54b70d24288 4c7648d81e81d4eeec9c526591b101cf01b483c77ad9b0c088f92cbe7f2f296a eb023631166331c3960d1a91c4d2c235875fd7569919053e7b4153f9dfb98514 d9e079c76490813a996be1393575b77c490a53604729bad4979054750a1eb18d 0698ee4f8726557ffe6fb1494c08f306060f85665e663d36dceb35ff7ac736ee 4916f2ee3df0950e3b5f621dbf6cea29f89341acca8ff75f2419e65e003e25aa 24d6e82d3ff6b3cbca6457ba476e5ec1b08b92a2d100fb7f98f1aef40eb5789a 45a909919754c4701633a5f248c96d1d3096c83745d1ac31839a504191f8fe4d bdba90e99b4abd02a940b334906b938e1ab05be838446eb4e568bb6df4dfd458 a5f5dade60f562c3c6f8a12dfdb27fba95a9e90dc734da86b6605305b922ab7a fd8cfa3e449e358cfad453476a8102ac06c7e313a04d04891a2374277f774b37 3181dcdc75c62bdd25f2127362f246a4a9b5b0f17da0f7d01597e981a76546cd 7717df26da33817fdb1be7ab79745d725360125a91d2f56eb8af322aad5275ab 80b1896a36e3c6d44c05508d1f0ccabc37c9c0d96503ededf5680bcdf00d9b0f 2a2dc651fab7c7b9e7cde77a1b489087964c30084d08301bc559fec7adab1eb0 d54b4c2666f4b3594cffc1f7a7d0f4630c86a6a502db2da30aace5a92f6e3b94 e4ef7bb2f8cb52bacc347e5e9a9455c3fe102f4f3e2fa583f0c4ab76d69ed964 176988abf776baa09e5af0456ba5fa6c99911ec76d139d0e79afcee18e147100 a35d01b38be28afc33dd02eba518003c61792fe4b3044cb3edb4b12bf131b8de 6fb11c9ce9011c424325ea7317106e9e51a4558e293a18efa30938708ed4855c 72131044eed73d14a80163712637651055a4ed4542fbabff99eadddf249e1eb5 eaf8d06fde250db68a03e922ff532158a3bd6f11b279a185b24205b505d0ddb8 4917756124f490785f8821f1d38e9834a937434fbf90da1cf7d1520cbe9ea122 17b10717eb648dc1d0d5d0b097a1ac059f42f9ed06134b885e5e0471f628939f ec5d1402fd61ee2d1301bf3d6693c2f28170c2ca62ba2815f8f6198e1e56cf4d b4f9f5b94b08224cae9504560ae84b10a688d0a960e59b8b9f3243949e740802 22a008fdba0c757ec702ee9f651c21d3afd6a5c3f9debd2e92b0a18b3819e992 05e28f761a3a228d1de10fb0e9f3153bad293b570ad18bbea5cd3436149fc3bc cdce71a41bdac34970a41af2d7e2bf9201430c0b8e5bf49085e458f8363b54b0 e0d60b1b10f80710c95178e362b5b630d63dcfe50d85f5980420824096232937 e30d9468689868080dc063bf5e1955f3449e8acec61f979ab67bbc87081e10c5 9f5a4710b9f14aa7b4042307116d3f248f402aaadea8ab0e645998675e4c183e 2b4352d1949e998c13b49efccc204bcacd7ab39d0d6cea4c6da7427930ddd773 4923a612dd6f66791ad915b269b7e638c620b339adb8a6543196acec84fab2f5 c396389274aa56d9f987aa2bce6841dea2fa57a2ac2baaeae154fb11ba3d481e 5ca7563dd1dceb0c536b43208f7f95dfd675b71497e3869bcd7ef346a7300273 7e4dc5406629940385aaa978ebb9a59a9575c83c01819ba4d7b8fc4ff4810ee5 86b08fbb10772148d808409276bff84cf57dcfebba5e40e39f32903c39149d49 5c7b3671f75ba96d1728def2d4a55cf426c8dae84e7bf62586ce0f2b11975cf0 3483efaf5383a304c601f49ffc296067c928e58329aa1d8849c810df114a5516 70f59a9c34013c20e104d789d2f9e799f5f5cb7fcf50c5506921a19137263037 3e70d1a3a9d22673b58aad1f2ac7d7ad21644efe88a8d87f08cf799d15c26806 1e99d0ab1647f29439d7046dac709b4cd634a3703356b48dcb9744ca9969f26b 0cd7ea5f5bcfc6e07fdea1aa3e99838f221a926b515d5f23aa4cc211ae8656a7 dfff2b5a820b35732aba452c56d9a47d8e089f71ea2786d4c3d713d8cf97959a 3eae164d7aad8295ec39db9d37d82345dfd11b06fe18247f99e3e0cc2e1539a8 45c9e5a79fb69814669c824c6be6859ddd1bb342e795b67a79862fa588df536d bc26bba17a1a01eed0bef7ab130d1cfaf1a190fc8cff508570698e7bf5540f21 74e2e73157dc4bf737e0203ce99938bf24a266fc5e2d435c9a9b49c1fa64a43a 0ab8575d91015da4008437bdcb86f956e8c49465c0373c6c2c9e5d58ff51b921 59da30127f2f7e2181603db3e85c8acd8c74edd14445392f4acc9e0450a428f7 a6e9e584a4ba690649b00d4f3e30a140e5500e36d782e32314b92ef4442893b1 f55efcd4d19867c4d4dc709790acf5e7bf9540b7f33c42446878ea1cd2d5f539 ece4059cf27e2cff1e02b8904306cb82985de21365d6fa70d934554b33de3306 9afefb39ca0de24fa8694b8e5eddca64c3dccd0b79fffa84d9e919ae04a4a8b5 14c70df7ea80a49dcbc81b6adee6e94331944cbe68c6346d5c543eb8da29dc4a 28a832645820620c2cbb85dfe068bc2df8cd5a1e1640fad517c1324601f702e4 4d3305dcd760736fd70e6f9aacd9a1e11dfe33602ab5702fb4414b050d55d446 f4808e0dab8adf3e326acc2ef5c0bf50c929f1cbb3739b7160a981d484563f07 7467f0e0e7f7acefa8e9d57b53804f1fa6548b6c0154462e5af8734d34846a12 7cec4ed7d3fbb6d962f8afb13216cbd9ce32d61e732c81dd4ab62c48d061604d 3ce2279b56f258447ab0139e8aa77121b6c4cceef37ee5f842732bec5a1f3e7c 82feaf3e16ed7104b66469032a9add01c5003e50fcbc718384a86f1079ee1c24 76fd284c6e24919d99001368148ceb4c437bb7267073ca809bfdc1818352ea96 4d4a98486dbe1cdc81b76f54c2a7b0a913d6527ec402816d075b5b938cab54ed dbb0101edd04015e5e22b115628ad3f367f9d7d1ae0dcec0cb82e99bcef80393 593a14a3128bd057faa61dbb9edd4414824f7e93108d44bbff88c6d6a3c6ba28 5bab43b6465e07092615ae97019e8598370e9ed9d77ca7ca962598f828ade9f8 18683a156d7e70e6c1bda9f1edcbc53ec062d35f6b9fb0e7222728fd2427a9b5 9eb3bc6440067a8d972b1f2c6ef65b1a143d51ace39b44d7f89b12489d21395f 95aef2309b34730ab930c8788ed698d777c9eb09cf5426efc10240b9eb96246f d5281853f7ff2e710543c01cc27a8983e1aba1c9549592f2d11adfdba7144eef 02e8f49e70c4e120f8cf6b7ef8fadea57c861f885cbcab535890257026cdf5a0 13d5e4b72a6fee14f21c7586fdb4a1f026bb92f81e1044ceabf3485bd22d8436 6e08337c7dbe15a67082c64d27b71f7855554c2db6c86ca4eafdd13904e41345 3bf587ac5c7647e2eb526b71772b1fa3b05765715124852336d2726cb756b145 185fe3e46833803eac5ae0ec2707dc305f55856e96ac680451c05c40ad443c2c 8167a2efa46572faa6384c8cfdd6ba48476a6497bccf70eefec19b79095e5a67 4a08899530193530c0925a3186729d9224d5ada91eb29285dc24e6dd37f22613 8a0243363269381509eb77f46611468a2c59bacbd87dfa096737edda19b9e9e2 deb2df03b94322d053a608460b30be85465261c53473c4a01f41293361dae72d c12a6fbd1d67e3904481dc6b31b3897e84252dc5a5604683ba30653ae8454a31 aa2ffb179d9df25ccafcb0315a3cffc03ae519abc94aa2405a3a7677d3689221 727f0ad8aec7fafe0524525951bad6f2a85a8695f4a0a0e0cac5c28833a29a92 f9c2d00d7d913d1c5ca9047604f14dc074bea7184683e27d1749367a82a18fac 252fdd1a0d96b8f3c8abe689caf43c5184e51d9dbd1e0612a4f51858ef672b25 48c59ef7e6e45ca1e08e68b49f8007158e51385029eaaa3a23c470765c05a8b3 ec463482223a994bbac33c6b25a52813a1c60e18304d5e3d98372424fe01603d c00fdaa6dbd775573de56aecc10bb936f1a008aa49c6c10b0615f080a1dd221d 067f8d1a9162c5689a2b74dc868c21eb6827245d6ceb2214c1afcaee62080b49 a2adda7c12f785c189241e9c89f52385189cf17e57cc1f7d8dbfcd58f2700040 75d9ea530bd83a4ee830ef6e83c2167ca005b1c79a5cf0543d62da7ed639a58d 9fa98a963b7950ea3920476a960cd7fb1a728a082075c8849d698249eb848637 86aec24fb6d442ffcae3871f2dd9b7c5a0b1d9e9af25092bc6f21cd32fc32654 f2bb7c9ac048ba51473c65abffb5cf12ad82eac26876d8c68bd7565441ca17f1 6a20e550135ca1e6bfc8f8c58ed29998b2d2f44191a5d2919580f223dabe06b2 ab82503892bceae077e52d0d5919a9e06cf4c707bcdf7c73dc995afadf1f681d 5515d7fe58807c1ec9a64093bd54ef3591a9183adea86fd8a57260b147dd68ea 5e2c237fa7498a08950cfd6551973a3d06230cfeada70e6cb82bbc4cd40d563f ff96544869bf6c20d301d01cb997591cc01c0a265611f4cc89abe0bf65b3c667 839abff435d4a40e97d23cc90df0c187bffe068e2394acb3d0b1aa090385182c 6c4b0754f522cd2b2a78baf8a1c423e3df66f282c1dc43aebf640b391f7da616 6e5ec7ce3d24d7b575c2d4367da50d9efef927ff0796c45906458769872d1993 cce57110bd661bf6274a897a0586e8bb0f09e12e82b9aac109b32cd036717be7 557c95a69ef104b053d0f66eb4c8639a6dc5286742565b94ff1787224e575130 9729aa606d5d29b6b4f1ad7c0a465a02937f6046d71c06d6e42d479f2e5714b7 a20f11ddb89d360354402721f16e4e1e78e4230ac274a3d84f73b1c820c934b3 17aef392d8371c3af37d6671e809ea3901e76d173fdb78131ab355cd7698c2dc 97b38c668df44392b1d660495cbe87cf2ca0e4515e51756a5477c2fa29d238fe 5154c01d96eeb02ec9517df3765df8b0b8ad9b320db914e6b63c325715b1781e bab538cae4ef8f6de860d8531d1a7873acf5e65f06a0872fc98e2034795d624d 994093b7eb00f7355fc8e1f6b61bf22e0b89aff370db167b05d30712a7b8951d ebf90a64ad2201049952e6bdafd401b5b6b8fca3abf1d1836297249d26fbe271 148a9053ba826c8236a5166342cf79f3fbe6e52e2fd5f59b516f61a52d1be206 3d92e6faeeb5e8ebbb8fb2ac668569da71a5ec0d8c257bc8e2d7c6c755d85da4 d48753499e5d5237718b7943e7bfa9b3267b537c2c3bc1c13dde8ffb00eb65f1 acb876a0ac9466070e9d47aea25dd5560c836fe1e502168dbda47678fd5758c4 00bbe7bb690e8a81d1aad9632b2bbfb071fbfed37f32711f19527ab54d8f6f19 ed4826bb5bb7181a166bfb5d3db2d5af71830ac462afbc6fb7c3d0cb4a2335ed dfd72330269d62e329335463f771c6b0e02f0e6ef251e8064e27c320b04079db ed5a2bcb2d5fa08ec1ebcf7d9be7f14d674bcadcf8fa21b042af15f74bf8dcb0 349f9e4a721db05bdaa72a474d05ef69afee98f181726d751ca4aa2e4c6f63d9 f4e41a1afef18af2983292165e214b2e2892dc3afe012bda88695d61ad47ba9c 9cdfc4b6804264529fb7dbd9b25b289ba7cdd438b5e5c77c07552fcd2636b465 2455b0757ac8504621817c5a55362db6a679667915d932a52de2ca402d54017e 6cb23126da2a901a412ec5fe1a320b19a5012a6b17e64869da38511f522750a3 8aad7d7d986f8ce8422c95f5627488d6083f7d9b36065612b4e7eeb168f5a70789f1bf47a53da541f9acb9123c498ba5dce92f611fc7fbc997492e51b162bf0e4a1ea601a26d7fabaaf3e849c54630c861c671b85fe9e3103fee79b234e82701552848cafc03a7c9cc8f68851b5cbc95284506167a51bf5535bc4f4f77aabd025e7403f15a808fd80e7842f80ea5b409d80415ca0edb72bc19d2eacdad8035085c6f22f3589002c4bb50d6330a0a7637773986d2c22b6e2f3c0e4b206a4b7e0e29eefde150b61c816a8cb5672b53e9ae7b2cc971aad6abe44b4e7605741fa907dfaedb80c8d4f799007628c3b8e52877cda41a48c9d0dee76330d312aa10bc05eafdd698fc386848e159940f9103d94800a2a64ab1eb93367f1a78a84274ca0f95dd7261324776960f56bb8c0ff227f37bb698e67b0fa2c285fe87186445430554e3445242668147276af2c49389e70d27d2ed6d3d5470483f08d6af53c618084725a2faade0fd9a18f7edca9b41bcbf000da3efa84d7eaae2cb8391596e110849a8670334aad070b75794a1d5ec9a34b92f2450acb9a2c6a90fceb7dc3618044a17143b525846cb1cc376efc0922e15ba44af69bcefe7751721e7fdf5aa550071244d23beea847bf60907d4f9e2a77aed38e003f5dad3061c27400e4eb912080419cfb56e64f6544b86a6e12ad2fea8dae2a62d8712ba0863f5805e93bc6b0c555d487cf4d857648394b9132f96a099edfbef3300b32de5ffffb9e1105b760b2b55e4535f8c272a733c5b2f75a89a0d6f0ad6b0fc737a6718748937bcc1a204e08db53cfcbce5d2e8d5d1748491edaa7d972577eb03a52ae43d417f2446a809dffae37b0e9bdba48eaddfaee0bec1cb99728bf7bc687b88460fd0f64fd6a20785496e6e83a736e2a3ef5784125e5c058abbf082f4ab7cf55f2f1f7d479cde0c59bb3f1712b21529609c7abdbdc20c8c9329600ab7c3243dfabc9c9670ed600e645f7d54217ac7a54e197b0289e2c65bef2bb180fac4f9fe77ac5dd4b7c91005d102e130e66e0649b8a488c4520c7616345270343cfede08e75e1928afbf3b0dcf08c8b53c2cdaa57000eb5959e332ce702e3bdaad9d0c14f67cff2b39ab4d07300904b51c34e87e88d77d43eb11bcaf98908bd0b89b3752162df6a31b0cb50709581b164008ca8b13f777111bc0d6c7e66f97774d95492973b85ad783d6ce0c6271f003625e1bed27a600ac4a467a51a0ff97d16f84fe1c6d85ed9f0b1d350053b3aa62023538e861f90a3bd82834fdf604a7579a290daa5cf9a99c336e380ca32aa77a2bcf3cad55870729bf23ee3815d2b999b66e48aaecfdc83eba295b010cc673482f3c03e695c528cf6041cdc1db57cf69d29ab406dd46285235af660e9272d9697f12d65ff8d69d7b2da3ee305cf8e07d28153d135ba856fc59b8e402ef36d391d0f096970c7b169bd1832b3245b3bad511960aaaeb9978f73650d005f0c05694bf18de44adba3dafffbd6bdeb84f1d5af57e3bc9925e2a1a1c20a60eedaa891de4dc2956677ef10950fc75922dbd2321ba008ff05402a5819aa2d809ece98e0b28b3e6746b4818ae2367630e9ecefe5ad7a81365b0a812decf04d00058c54b8fdd882d553469daa076ff07b83d1724fea656b57df56d52a5a65dad0441b51d267d24a54b310411c224fdb8949e656d5e59d7deee521a6cfa75faed02bafc5787f461430394c90abd72e37ad83234445d87e6201214bf83ae5515b70daea5e1f089101b3dc6f845805a7aa7c40c793a90c8f0945f86b75c2bbc59640689164f679e7fc7d23a656534815c82b1120abe13e60baed648dabb9f0b98140a08d0c1351ac225192825f230976968c87cbb8bc7395b33a049500be43f0cad09b124bca4f32c18dae87a7e053f1e60a9027442dfe32e882c273ae24e276a320758d94b5a2194a1ffe877da6a97c43d716a4d6359c8381d26c63dac6f9a39320b8970a399cd27a3f845af2325cdb4ecc4c6ca33ad10cf8575a1b2e14a0ff64d027f84d45da00b727a271aa8efd6c7210d5383b1a6a5bf241f5f98514fe83cf2047aaf075e936878a4a4f81823f7ac62e194f89af83166ff4c12af317a0345ac0bde867f1e82bb72ef422e1a497a5916083c0ff6795c960c6b84b1f06a6466a201479bdb29c6547be9eec6560c567acf2b550045dfada9932badcdde9511f720010caaf1c574b3d9d54599e4ba75d4f68e3d2d73a8d641044a862391b22c0f8c0380152511425b8a8bbd2da53fa42213dd94a23cdb75526d91697d49f0926cda0b50f9709a3497a2ed7739cacf26fc1e30ea87253dc93c084b8b61293624a0690bcdcb827c557972749fa6139c9e342b355d20f378955457db1ee6851f3664f70cddf3bc0720f97c9b3f6ab9ff4fbdd8b19b3bb3f9214aa029debb118021554c0965e3c19fa08ff2dbc8f67f6eef97a065ba06d445089c82b595212b1c7b8d360ee4846a781ab6f9d5baf82f8e075405f9005532049fc79a1bdaf002d7f105170028e52e3ff4300c2860cf55467ca99075d4c099821120debfce6e37fbaa974e02c88d43ad83e20efa79a1fb1efc582739ebe7d5bd946d05f7a70bab6ee14869075817d8073eb12d7e95f15b8c571140f037aa7f2e9cb6df76a83e34ce4a91290d269520801a722e8aaf517b34fa158078bb81837bb902ccdad4f37e4609079604fe0d50978cf22d1b4a783e03da307d601b255c815d4fbac4f9ff429b116dfd08f2bb9b0e74b88cc3369113f535ceac5fa83be56208737beadf0991208e6d7d0db6f44469b1c691dbf6d995bf3aec59843ee1e077418cfc16557591024d3c6408a9c2727c93ce181c97481acedc4aae1010a588921fceca8e3c67f74ad0927a047620b165a59367e39700c9a0483714264c63b9f30c1d4fdc805d58b46a7e4201965d1d75ed6150c30d55fb8d0b4a978c08bfa6ebad4642df2b38fb2f0a2c5c0baa16639afd6626c4cdff1942f3b74cbd5fc7db9a5cfe9eddb7d72dc22e8bfc0e6c7da2195e61f80136e2d8fd1f5064a8bf4cd8662c2f3102dac450f683280f092f77eefed7830f1d83207e91a29115dd957fe682ba836e3dc38d17332c0be706f9e096848e37fb870a435fc4836656c549c094ee9a38a42c10cea887114a17090869a9ab4befd818231faf4bceafe3a81ceff42047d758c46903e6cf40d18701814aff7366270a12f3815da91f5be6630846310a772e9615cbe29ae71e99830d3e6396ae723ecabe509e69629e2c58265cb46b655cd1e79f5a8755691e40af0abd1f5d9268bede996cfb7e8aa27541ce2a8ccbc7e6264731b567112e668edc094c53c9e852337bd1ba3371b8d9a759281c10e1023be7a669ac9102129b570804fecdf67ee9af91e64ee746c2b71d9a540ae93bcf058468c837425a8d517dcc03d09aec54dbbe62b865245d6a64ca7dfa2e222a464b1a73d21e9e1673b85cf6094a4c1983055bebd6a58953b656f6ef9920f0f4c2505050e4050809206cef9b0cce326ffc6d4ec189ba719630ef7be5d802d160b9209d80ef963747ccff095002a60d37cccc9773ec99a298fae11a3530d05fb3ef51eab62296298e87d93dd704adce930ffc64f0a75eb369839c51a7d632a3ad72cb81dffecb68b5461cbf3b029004e3cbfc4cf6fa73af4bcc40df6c096c81f52c7961ce3c16b5e8b150ca500d919ad8e87b9d7b8e656d4dd3ea2c82811a16cdf6322780780418c46ebc2ba001975069d015a7b1a350838c727b488c1010f3ef397089c187c8cf6be27c0f300d037c8b69afd4143485dd06b5592db3414f1c98f360678b5d2a7577e541ec050b7ef30229f0e9733e7b6590d5dd997391d270a7f336bce8999b2ce65380138f0d0b56be752f9bbacad0311abe0a75877f3a547a93bd22d0f1cefc373c86a3d5068dc4e5bc15b2b89b69ca9203e3a2d940077f13f8b071c8de8b3a67d2b4443206a0feb8d14d2bda245be39d349047dd601b1ea9dbbe6641c72d4b71635ac5f702d06901c780ac240899cede8182fdb829616644aa7a35fbb4988fdd35da10cc0061d0afbb5def90429cf4cfee8a211dd712a40699027888ab717a27b9c2286e0639ef81b1b99a2740d2632230c97939bf52c96532ee86015c7eff4b7d2c38020cc067195269501e53b120817e8b88cf71c75c9d6d2d07dfd24dfcf5827f28f40a7448648dd3f9cacdd5fad11438f666c674eb0f57964306cfab9f3546e63cec0a91bbd307a0bac79d31fa69dfc3c29a86c1153668971e62e2be63965027a2780a76682489baf222b62b7323b6c04d49836a96403c02411b6f56717bff690eea0fc3589bb424a92647d27a554d53733375088da6e31541aad643e48ff18d06a004a7ccd97f0079b4042f404ce2bcf1032b619908fa145708f49184659b07437803f6f6cbe2900966fa9414d018027ab3bf3f295182d575f2fdbe26457612f30508c01e148b6a7208145dab2b210b95d9673d5f336f9f519c861fbeab6bdd9164059021481a9d25916716a4cee507a163a58149aa3ccf86d37df446741d6249960c12fedaf8be63d95126975f029574c9e85fcc1b52f24b791fb320147d4f65fd0f794fd60b00d9307b00c709c776dc4ee8fd0a3d56715a44c471b1f9080cec22017ece8fd5c5b1bca53d5eb026550061ff6dcdcf7eec212a0d3ed03edd9a55df02ed103ea65e364dbb53bf3a6db2acc83529179691a847998af3b2e58b2ee2c30b458328a3e207291cb1f972caa8a14bb0877df969f8b5c5c86762ba34d8b3010ac5a0b169ff74b4a20516d793bdd5b5342b8950bc6e720acf7e031de7f7da9b050b148b088daa0310f88b1416f843ae2626ef53c9f87d79c1761c1d5f29d51908fc8e219c26b2f3733d124d0664db7ecc0a497f971e60107860bfbfe9c32c3103e22479b0c55ba8c4018f90917959f5251da1484efa6add2e0f2a45ce81e5e801628544056d49ab838c999ef4501dbfecd767602cc4dbab8e526dd22923620503d44758c78d7111b745bbab5dbb74f226f28512cb31ed020719d4b7ba22002609b05af1d31f6725fb953ac5b1161d21719305c86f00e8f42a6dd3091ba5c5ab0e5694bea4a1aeb1aab9b3f0f4b48f22340a862ab11bc6962b33baffd7f342db0464aea79d4a09731dc45c822bafb2a2547db988dae6931cc3bfa0b0356df1f5002825e17b90527767a67a160cc0d142c239d8b1f3ad55a0e942d3db08ae941a0c8585ba381126fe7a538b5acf380671e3a3a7e05ce5f85e97f0d136e97a88240696e9401409840f914ee5628970b904ed9549520ea8e0b9b60d16e9324b01e20456145d0fd04dd5d723a011538d5fa65407bbb3e79e020930f4b0ae13ceee0f03cb0fe8550326223affa4cbf4f3e0ae3a96d43c9918893b53992b0fed6399b1096f7287384659cfd5f82ee7c7767448d67c68a571bba9f966177e0f60b8471f06695fd89f494f4122fde39c73381b315522ea2b01bcf2881eaabc45aebe3edb06dcd4d9bfd9d7164b7d3440bf9fd4c1f70220d3215a194aef7ebcaf848ed2a60bec9d3bad84f467f947760fc1f6b93c69d342a8ba80b194fe1e8bc9268a48130d31cc7bac83cacaeff8223693a85b540ee392c5228c0cd1ccbfed3932dfcb980a0aa8a5aa962b865cf95776aed6bfa4a796c75c595b7d823d86b030a345e2b80ebed6bdd6e644d00ddaa5a730d055e3beae64e055e43921a9e9b723377c195004d5c59aaadc2c8d297c4c2784bd108482f7b2bdb483ce330aad8c6cf08681ac030456becc41b95671bf882a598a90730be06f7bc302daef8125e6b147581bd20dd435394b19e01a75a0153dd3ea02ad5e9b887c4022e07a2d45ac205043def60242bdfdcaf6c3259002887c9365c1ec6601849ac681da08d3cd11c0800df57805c687c39352d14de8c1977e8a5fe3d63e45cbe540b95e079b75a105facc16bf0d0233a26e2bbdcff74f5dbffce5434c8bbd05f37b72e6bd155cd0f39237ebac0bb149b10913b170f4207b683c599dc4a043a4d2b0a567585089a4150093373c0de8dba5d49ab70e1c24dc3aec2d3fc2a10a1b2c6d2bfdd40b8f883a071ad1ac0e3835e7fab7b74a1434ae4489031e6d5131cc6a7cdfbb83d5f7d6022994727f09237e4757068c0ca7256eee05416839e15d89f561f0d2476182c3ce7ddc053200cc23aba761f9626b0cc60f23432104e8860938c6383af135a361f7d726ceb201124e4a8aa2b26bfffcedca9c0c99cb69fd2563ab02f541e5bebc89cc59d9bb07212cfe42941d4a5e4dcebb4f84522fc243062fea19a9da4995151d14818aa80f70bc78770e088dbb407ef8d46e98e99389aa0597d0616eda53d362cbf8daf50a93a64ea0d755b377427861ba41951ce0aa09024cc11e0e19d96a9b0e6f603707837f1c1e0f9e1bf1fe3465ee444e0092b2bcd3271d13fbcc96bad84424b6b20949c38533c260bf0b2a330a1dc6c1948f1ea1067c6e744140681df4ccd975ab0a23b4b38f4bd04a82364aa6d8de29c386c2d822824d297cb2a28d1485e3aaaf060a9403013644c9c1a0eec05531e4c33b78b9da12db24f9d64e6788976dd52d01ab65dc3c5f90fa8b592ff7aa666f4ed11175a31cd2e88f54f864bda0bcdb2d02dc445b9a6feab0060c74b2c94132194adc8346c40936709715de90258d1ef700eb15f3dccd89e75663c66ef25ee820484dca7f673f5db0da2b9ac3506b89900743a554ead2d9b1c0c8becdca0e358a2e7795e48112dd58812a7053570c655400e2a45dc1292889fcd927e0933b9b47e7570f858f2f24f7bef23f01d23d03f60cf415e11366b85f67213e7aa75397404925035da2b0cc47fe517aa79357355103795746faefa3d9aef6b77a3d1bcee5720e82838fae06f920fcf9833fec61cf0659e58c687a622a334a1ea566ab622fc8e54f9cde665d2a3fb6a5b87198dba6055d6727cf57c2d22bce17824186d0d5f0528f7ffea7e8a616afb3c3eeee24420ddc5a68b33a81dd55e54401534f8197d2a5be48ca519efb146e00d2881014540bac93fe6bb4db3328848d835e7d9fbe59ffd9cd83370011827e95df16615bdc0f229fcdcda0254709b53d99ef191490e096a6caf21572d506a8a5bab9c4146f018ea35a53fa0cf551127ccb94313d8bc7e4f125f9bdfcefb6f6d0e16dcd67df0dd2b9c4713838f6eb6f02ab2d1b3dd4a529e6a0875b428d69d7124d2fd35c2608037d6a3ed8b3f4754681a9b7a13f98303c860216b4846a506d29c0aa5713d90a05238894db38d0d36f207d26ef6ea33db7095b0f1355415c158fa90a473982051bcd6918366d9eef008ab867969716679faab84bdae9c128800e3d4a0357db0e7325ba0697c2a11d783962f18e85d69ca75eb2fa7850d5530127f08c9dc8cc01e59ce255bac069bcf67b9ab465e34da50c50260b7a5e736682611b45d48b090407500668b2f55180abe53f7db2a642bf4e9a2c8e8966b7af18709ac0a6917604ef935dbd2c9dba802803d8e5fb8ef0dedc22ecf2eee544f4507d4bfead9cf80b0d94da552694e42def6e77b59613994050eec8d45d205a9115b16042f1f72e046a1aaf087000fa1a6b0bfe59cc68f8d5aee66004b63b694d137deb6ca7051b0c86b357615181415d88c00fdc14e182cb90bc969f2c7428ee8175b6096939ca05a0565188cf86e48112dc76a9cdaca1e4527f756db1a423a81b83cc4dae769c0312b745762a3a4a2017ee238fbd7e738b3bed513343ebb53500651e5653ff1e0970c8697b7982f6aded6f7d2e157d88772e462e2af10cc63b9a07a820050a6e0f33add61162789dba8b34e0be6697c017a62c774e6e4c5c5b03fbf2c540c4f70c0b1d668e777e26173a5751e5184b951b42fd80221be2bab575b630e4e77c3c0700e643f6d96de361ed9b3319566dc339a321fcf605aead42fef7928357d77a02ccc4033254feb67b33611f4e372ef05beaabe30563c410d59136a67dccb4700c212b7457b302fe5c99e5daa31583a26e6923a03c59e19f95bf34f8ad463cfb0b9a8a8b2ce901141ad4b97a77bb575172730e1d8a45b1c02fe8b531c682de5308a11311fe43549007fdf5c744ece14472ee6c59abb32bf279cd533cba40db1d0c73087cf3f5eb52c2744d0424f2e900fdf837fb6af9a499ac7d401b07120d960bbeb1e52a4f9dde23cab5f4d7b91cfe02bc889ad4d63034425bc489d8b849be0188808d56f5de5fddf7bc689c312d0757fbe06eb00200dead944a5be8a13bf0083cd1f25162fc6c7d054ac8b356d1871fa0d72d310773eb9ca112bad4cbadb30d1720f8fcc45357d5488b499f3bcb609db9159d09e80aca0e9eff081d2b08d00000eef91e7dac389ec589e7c6d5d289eb6c45c7289442e0f528c1fa7f58a7b40b538bea9ee89873a8265ae61ec974abef7900b200e7d0038729ec0e013fff7f07cd240b35535e76b5ceaabbae8a77bda80185ab2fa4a452ea0a8508080ef4bc040799298902d6333ee3fa07fb4cd01fac545be2c1dc236e8949f197e7588b9f01812c27ecc9d266ed7ddefed0d70e66ad3c73e03f366b4994acd030c13be2c005c3398f47def0fd3149b523b5103e295e84170962fe21a76e88f878a24af4870d2e5cdf1cf3521af9a8ab6f24881da4e26b9446aeb716acae04d851390c5be2012a63304259db023487e5f753fd8b1ef1496dc5ad73889e7018d6fc99c3992b0d15a61c5d971e4e18d55260da7a617bc1ea22af47386106597057ee56441fda08fb11a71ddcbd77af4c30c02890212483144762d77d680faa8294e8b4122b98018bcbadfb0e291c997ab0b4d8ff60d2d9a6b57832cfc49bcfbe40e22af74e5b085e367770f7a7458f226e1ec7826ef6fc40c893ac9c70f4232474a7831c20360821f3b481d4d98458827b8be5d8be0d016a3b852de7880dcf2d63741036e0590b1f244e16eb2075ac64e2472ae3ec97fce7ebd788de8bc487f88816f09732f00bf685957f1deecb6674ac89992ec7df3c371af65295664ecd52a569683c66400574190c3b224346c29841e0e2a8ae8ee8881a118cd39fcf2f7a97079047af2807279e0e75864e3c09e690f1b170a8de69c23fc3861674ffd3adc18da992486500b5684ca228f086b89b913de885eccbcea8434c5c6ab669bba169d88742dc000861d6da1e6e79d7399410adf3dd53944d68ca8ebc68454040220f92ad6dd89804b9ece70ead929507104e7a6666fbbea2377421f5380c2fb1b530a54199c5880c59600868e95f7a91bf51560019778c47f47dd8d20f9de541409f4e0584445303cc5884ed9d30a11f7e947ceb81b3384207ac5409c1e7ec2f12ffc3649f10480d21a87f39ea33112d88ed1b58d1e3a38ec14466792b1c86da0099ffb0e7f9d9027165415131083ab39a69170439c636b6bfbd93e9f4b533c1e8181b8f1baf6608306e76b96d57f2db60646fcd8e082e92578934d7c197cb0e7e270de1deb6270bbb53c008f4c2d1704d71914117c11aa7aa371edcfaa0d99824aa3a738f51ed0832ea438e3a7b1203de70aa2fbd23b97582a25ba913e677a5be74837a2e39a50588c65b0e0d10a4fdb4acde80ccf9f58a57cc4768c0a6659c8e131293d9ff9c001815db6ad3f53e43dd89b1157fa1e23ccac975136612996c9fe29c8a2d8d080dd39e8fb5ae21941aa749598fb5165dc95a1f5adba33ab6e9d872f4bc81ea2c03694ef9807bd59f38a076eb55a3b444ed8ddd40c64287c3459868ba65f79fb50ae5dd5f4534a07434aebe6033a2742e0316f3ea9295feeda31d949ded4a67e6045e4044e989b32e3a10c5e42f202b27ef1eef7c78b43391f22ede0225e4cd01010d5dfabbfed9bfe334a5cb8e538d6083aaeb46f03ad41d0649df64ee01ff3408ddd575d116be9f30bcd4668ed10888904866de70ed5e71c04b777420ff557a0356ef1e18471eb272323eb19c3b6bea17a098e437d7c8678aeed88acf15571906274b308932162c9760ffe1417a2f209d709354734ea4bfd68183c67431e4b600cf9a1bd583921821c0815f4acb769561b3d706bdd09811c7a6cccb5bb292e205026b3cd97787605d2fed4fef3eaafb20380e43b39e255857c0ae509b18462603c67f433c5f5b309a5181e0599db7680830bb82f7cbe310a7b81ec40b481c4e01532d572e1b93f155ab1ce4be26674ad469b6d3b9c4dde2c6c018bbbc7ca681074a06177f04f3db12bd0f8b3f881f97934f0b5e792afff5239b769bbfacca670dbf883cafae95e566ddf03a60b13f0e30f572e981ac3e003d7267d8f3b2131d0bc5e8650e9bf1c97366f033a9dc72ed9852e111324b876779672cc2ce602c320644f01285d64ed3df948e144f27c911387a0ba5af79c67a51d3f643e1920d6a0d0569bd4603c076ee9f7778bce7929f85ff07238c9cbe7bf66df26ae296d8f90373fc3ff48ec5aa6459ef71d544e8a378f3b22561206b1d4dc6b70b2f7a9c3305b2fb3d923081dcad17aae15a7b774b8c424dc301a986d648b9607ed3fb2afb022e79ab67b39b4025d380be538db3a318f56aa9d7582a211d332e3b73a118a0040421dcf858c5f8aeb3c86f6efeabe98ecbc7610a2933d331b767964e64df80096922385713bd0f74937dd335508d1fa9e3ff97a98536fcb616a7ae3d609f5c09b0861a3ff8118de21c074a584443099d1f177d9c2fb119ccebf1f44ce533370a64390718e0a8fcfc8ea6445179c41ac026f5407d3a59367545db3ed83087e00864a51cf6d953271576962176839205f0b580c6c8708002aead9df65f4d6308085cc808f15848acf36e93b333390b9d45a14892a80b2e120acdaca0c1ff40b104a0dd29f9f70d418c3faf091fae838d261c2a96966d236d16c966836b3750750e12f8ffe1e3a4c4a5712d346adc5f1566aecaf5e0fd47e339d01dcfa6a593bd02831273f0ef6cdb43234dc0c5887eb06a5d026d63e1f7e3c895ebc5b9e1b3a204967a53616c40688479b31eeeee8f67552f3f622563c0bfd4ae4cc8a88affe307346df2ec51f1af54d6d5b596b3820d35916dc5f6512f1455d05479a8afedcb081380dfe41b569491d75673d08dde0649c4e422e6ab31a61cd3fe4b345a848f09717be91da0aec9b03074d4d4b2b0909365def5a3b45e0554a22c0932678b410f47079b6149334209a51bf99af422829d768e480b9859b05c3ca367c5c7d3f3076853d02230da533dfa3a81666c4f713dee7a77e5183a79eb859326a5ef6edf06f5f89cc926ddfff8c4108b9e049bef2ca74d585f233c41a6d41558b4e31b770c39ed285cfa85e7636e9bb4cddf2e23f349ebe276548900e923efbc9783876e04ddf597dd1707bc8fb6c7c3bd4b1936f7cee69aa57913e120be740a8fcd10a20553c78d4b396aed09c2f311f7b3c44d016d1bd72d94d1c3183e903cbf3e66c30782173294237ab12af1fb8532d4e1d9dea46a8c0b6fb478889dfa98f8972ccf09e23ca871c38ccd22096d876bb3a2c11f3cb11cc8cb237c1cac5dd3cf34038e039bbc3c52d0479e8234e987decc95eb69f126d9b7e5f01f35b5c8c7c639f9f60df9acf153fb00aec145b1ac99756d949ae7d9026248d2a156f6a33c127ee3770542ba202d71ab77b2a0e36074aa0bbf49af0577688dc56fad555a877f4f016c0ce3335e7f51eac496b30097e6e7e6fcf6c7b813797ac288bc3b2bfb40fbecd107e18d4f9adc6d8832d5eeca7db7be0884a6d882b6d57d11bd6d575776ae5617080a1b231840e3a3dd7fccada5734c0fdf7b62bc562b057b3e479cc6b4ded1bf05eb72c60abef6145e7d14e78c4ac4f798aa338da59ea4aec51f59cc35a290dd0b271a146185f88b0fc5f76428a1ead8fa49183bdd528529ca6fcb481730c91e0444d7783fbcc55394b41dcb21e4fd0c0781a70f98e7403fceea99102fca1a430552429cf00335e1bdf864cbb1006c0af23c60142959936161623daf08576fa302b0e673623298f396cbd5b3de7cdc94bd2e67a9e225402e0ae5b3282c5b6f1e0b0ad118285eab1975a47bcdd48695e51f140a2ac1461bf15596f816ccfb059e02a5bf5b7bd69475b38561a2afe95521d4efdc178a6bbcf8338b58b9787e86860ba3e0718edfd40960bf82c58308b7965d03c8bf0997e6ee58f0af11f4a0e45f05d84b42b49e15767d72e2ff45be2a5aea25df730bb45823c453d884dcd6a1580570b240dea8ed05ef2b212cc7481697d5eff703622dd1c8942481b30d42b337035169387b9157f051825209998a3e321799146d4533c3592bacd209d9dd999a0dfdd2103296a03ed5bb41064ce16ec884ef320b1293531f97dc6447cebcbeba0bc3f8091b46a562198f10fa26ecd19ff49fe100c934d47e945f69888a33abee002650a743affb76b233582d40693c9d97ac5a81394001e38d47dce30276b73109a575d65b02a6e91d69e3afc1a0bfa6493ac9d932d6c7b932428c3e33acf8570b7a347874268c1046f8e451267f400804b8c65f8dc0b3224d7bb460b0fe858306e1d48de285fe7ff5b70aad383621a11661d43eee8d41cb475e471bbdce91b606a61815dc06bbbe844e0ec03f144868b1d3e4e9a2fc45bb174572521766775d0829f20c1e2653b2e64c37b5ae8c4abaf404a79460c38054e25ce4c1b1148cb20827155a9668403e8acca7865e3107245a3dbf4bc8a9c9776b0292964be42278033065f000c8a39334c2932f0cdbe7c31b880a8fe87e0eec5ed443389c77248002b9f0100a91394eeaad61ceea31733a21904e352bd76c55e0bc8ddf8b7121b90f21f400ee3f78e1ea857672ba803b04985c02f8e21d5f9b4903f45fa76afe510f716df7d6e73a95697665e4a11dd55dc0ffaf3a60e13fb1c9e8ccc0bb2fb87c0c3c59f8b92be4dc5df5d5c817ad1272034b9605805fd11c34252c6fd48605ef00023609a3dd4e02e567c8ce3839122bd0a7b426a49961a49606e6466b96596002a3b7ee534204128fb6a782f59f5c954db7d870d4d1a89b7489dc9c716fcf170c4de256d1cc586d94106ab261cbd5ab403b6e6dc56804073d9d1b9f858493bf099aaf3ced6ed7d5de2a405a08957eaa20554835e11735f87b8a6e15421009230ec63e1155db53d279159e7a8964cd4634ef4559ff4e85ef3db7e6706b79b18200a31ad4606997eec83b6f369c568f84bcb0edff8d4f0ab7d5a7e9d493016cb90e82ab1541861961b00e22e81d497a12744106ac21ad801ddeb72b52d53ff0ae0e021e0d9ca68636f79fe4ccc4619f66c82d09075df44c60ad7159479867062901d676a3bf228408097a7987fa695b8cb789929c37f296a2356da719b598ad090f45d7b42c396a85735c492ccbc224077ea68ccdd14d53614e11313e03e1784d019b57eb41fa6be67c761ef614ca5ba937a033af268be8ed6965d60c1a2daab408db11cb7fdeff6442ed0d59a37f05e56aa58171974855f4bbc826e0f9c8d8770c3a5e8d0fc144f6a0c3ecf843d034da8cc04523f10df7b69036e7109171fdb301e2bedb5aa2aa88ebefc134ac3a7db07f375745ced7977b84305d777bea353700051f522e0200d639aeff598c8540ae5b597dd4ff5cd1327cb7b11f17dbd9b9049424c5945bb62dd457346967f375575fe4c3c455431f8a5905d8a30348cef2043bc3ed7f44f77191e0ec6ec996a764ef966103951188e0dc76b67bf3c540d70129eb889f77328b03297222ff7b7624b0ca64ba4179aec81ec2aa0eb9e0756808e2aeb0694217718da10460a14152a6611969112118c09421d5b8d4d7977c870b135f33c84a4e73e177928be95008f494a0946f63c037735fd6840dccf2d9630a804333f7f745f325579306dac4889b8bf0f19afac0b3dd4e55324a859e9233040dc58f46bbb70a25e302ea7535eb081722c9ef2e016622b2817ba3704e42b309d222c5d95d1aa043dd73c9b320f2021fa32baa80f94cca283e02056cb1b16f008713e392aaf47b0203bb47c67299531851d57eade0007c8657e187a1d8627f0f61eeb9cbfab059cd13e700b369fa74770ddc698383b1fbe0399b270ec99f8c00a6d207f8d22d53a3ba85c8ceae534613fdd048695863867b9182012a638c3e06bfa9bcc58d85b62354310d99d55c539f18437f4c8b062297c542e13861166807447eaf63394e926db7537160995bd5906afa651984cc836640fb5846e3342902b2ed154b18e8905904960b8587de5a711e26f5db83b0165183b32be06d787502103f8c2368c59bd3341c770d5785538f15461c2beb0a2c95082e166b2d480f0a87fbdbb3ccb204d39ab827462f136787ba28063b2cf566f7b23abab46cd1480ec8f0855e83f17b2f95f6aea274cc8fe571257aee700bac53d60a24ef78a3bd0d863a9b930a65dda5199dca85f2ab1fd22d615c97f525cd944262609606920b05c97cf2877175bd42975f1f62abe4b7dab784913f203770cd7bb13f2608ef010e1512794a28c8e33a2eed62dfa3a038cdc3be474b28f8edadd2ff23150e1d4a027081518717f870fcf5efccdf03a5914c5b54a070a9d91ced096560f87c7330052bef43893f1e2a9dc3dead07280c997dce97636ac9718af8d0153fe6a8ad460c06ec58ea0101f34dc9d33e5cc1566e0fd2f96b405eca800911d4a29fea25b80556bf0400cee40336e1032da2b130c45d7bcd0f7e31ae746c7b84bc9e9d1ac8097154ebb85844ed810599c51a811dbb76a6c63c706c3fe2ecd3ebd9acfb5d9707ff750f4ed20ff8b41d265030324c27baaec89003ec2447d20fa6d862e516a90e623c6f543362c163943d982771621311ea3d6ec06245fee9903907975f77d30711e38e1a73fb5426031965bfae3381e8c04f77ca7250316f1b9e77392829b101b1d7adf0b9e5d948c73ce0af90c9932bf9d1b5368890f09a2f36f7be3afbef078472a026466ab595132bcfe61400a05a273b3359f8005208a7b421f2e3f72301a1667d342336445755864ebc096d8fe268c0b92728c564079b7cc92b52e4f00d6c27af3156578a68d6b4e171b41da15d86a64133e9d3265021e3a1de1303c60f87d65b3a5e9fcc46f08ab82f1f3f11a199139ea24591bb09572fdccdb1495308a78da9dff1108bd8114b7c3026d1a6c61f04054342ad1c43b8a6a79762acf100901b9c18bc769c31ebbd39a06231370e518d9fe730bb1bc68308b9f3f88b990fecc8a0c4df5dcac9170da75937c37d4d330df47bcfee7939746f06ebf665fc02b351422b71a5d813f1d8343ea5cbc3e31fa28b887078e7e2ee6a03f195e4fb0e1e7ccc42b1aa2ed450a73bca657349cc68ed819f90e47fa52d95e53ff48cf40190ddd5fe1686b57fdd6dfaacffaf6c005384b3504152fe6e9a1b3ad1eb43c6060fca8114e788d3ab9cdf21e1d7421e534eff639f11d30be52be978df5107370cf8c68e0b89eb5f460e36181704ca04fc03f32578915d279de22e9ebcad7db60336e071042fcc03cd3f194b8c42c0b34b8df17c75cfaa2d2b8d99d1af7207360d87754dd42ec195b567afce6ce95cb8c2086f1cad7279c980ce0ab5b1b4d8c00bcb8f91f55a103b6df9dca3173323293d1a21f652ee0f6eda79f3b6f515eed50b59b511d6306919901dc982d8d84ada53109ebba1481c6958bc467e07fa131c06daac2fd7a521f15612a74b45309e8c481c1e1990efcbb43d25a3d12c225ff40f484304ad31cd776ee4386e91977b14af39426093afda4c04771bd41c85eb4d01febab59327136b6a6f895621c35dd51df657b286dcc4fdde96051a0d610c710e0c81ce07dd5eb1c1ed5f09bcf9228e265448551b97f938ab207ac2e2ebc68c0c1d3870d487e28a85042e6e05708dbff9d06be360b41de13d890792867d431f0a287844a953f330e6870b057b989a5adde64c07141bb1c3b8565b479003712d0d0fa585c2edc6a37639e8137eac47a375d84198f27e5262de650ea3ab323a7b0d158692babb5ccbda978eabf2a597e77c872664f3f1253292f1d46b71838fba06832a060cfc027392a0b8dd55b21f9482998ce453bf8b0828d3efab25d331950f36c0ae33a5bc81d68f4580887dd90aaa80ffb265a60cf9e4afa8bb338390a508e34edb6524dc5466386f14f93f6e15914dd5fd3698b80ce540123f9a69d1960a9e5cbef176a2db35c4d7c8d380e232d4b020747911315acf8ee13ee8c4a2390ad9b7be54ccb986930c77ff64f0f6a249fceb03680ca91be584817bcf5096450b10b430ebe9388a09086c94b6ae8e57b498aca9803309532453ba57329419970b8144f4ee0cd4a1847a7183792ba235a813dab01910f7a4e41c7e4f09a6f342071748d51899b80c85da83e7d55bd9cdb957700471f21f947b5ed44fa45822050698f5f5707fd71eedcea771883bdac60c17e1794de9558cdd4da4197c51cce50f709588d14c48ea910de2680709f1be9956617c39f339909144e5ccfa4baa660b3a1cd69fc734112283ff566bd7481dc5c557697023db225c8c5b0ad44a4396027340d283c74d3f634d0b48e27f5f8a1ce0e974cfa40ca8eda0e55f593690b603617fe51ee5b69cfabe3229dcb6ee573ffa4a8482d5cb2c7db3c811ac3d75f80714717e320c22fe741fb4628cf746b46620d7db8b1d88647358d8739feff04e0adefd2e151250c152437966b1fd16866844101f52d8661347efde33ab4ef19305c34d7497ff5e0ed27eb5d3db1ecb8d33ee6d6a929086c9ca4d43fa44e6a5d001fc22a42f5ac3850f1c1e10b4adc9f2f51814f6cb0e066648202666e77440fd050f1b3cb8387c69323b15b9aaccff4554ac598b7c0a3bb94b28837861a33cd70d809b4be2ef381d0f6ac80856a4d90bfb8f5ff9f6c164bbc1f8a537ad0ee2060eff828751639cd0de0442115de1bfb77e9aea4cf3686b96cd63751003e809df0c33a24597d44bbb4280d119f027321e1a78d536bda502ac9e0d3f99e45fd14e061993bb8ab1879349e5b9606d5da91ae1206d9cc5bb81ee963dc49165ef47be0453cca77587d7928955964be477dbf8b68a9e5fffa0d99c4227f4c59b070a01089a5aafb1e0acf113d7b19d97c3d06b1bf596859abc33e2ddfd54b872e4ce430437d7266f021ac919df88ac558954e53c07577f0984e46a7e827a70dfb11d900da08a881e231d903d3a287cd177993fd2b29a86d502914fa363547fa07b86020e0131efdd5d913163d38e8efb58968e2aa6cf3ca56539066c051975e108d2ab04472b2a532757f2f6ffcfa49e078de783cddae074c1af2822bc709cdf7d34d101189af3948dad00be2e0550453152289b81ce495901a6f31b5fb4a6a28c05360fb025986161dbc1383d1940e699b6f1a52051c42a73fbefe510fa4a82ce0d8d06d91fc397d464970fc91494fd03d1c4cb3ba134a9ad7860f6f4d80d66539c1108b936ad2c837f6a68b1f4329fddf5c684533242fd8e90c24321a4b2b835b8d602 false +check_ring_signature 69c5135ccc22328c45d9c12761348ed017d47d72b4eeafff9a7b8dca13630a54 d62f14c4ebae1f988d5d8b1567153ef33595bb9ed145b31e84f9ae60012ed6a8 56 72c6e20087c78b2997bf5f8ee9cd7b270e3705900c88b3a3793422c75b21fdde 8c8ff80e8485cb50fd67c2169116cf036409e3ef8cb52c92a7aeed2672fc50da f12038ed549a55c651e36c78a9c6bb7c5d2535445c5dc3cf475bdb0ce38e4af3 9a65ddbe5cd8a07f0548518fad7780a9fa719edb04801a40b13889748710d166 d6140c27318c140801df3907537d741ee036a143e2f97830febe31a052f20592 337beb0c7e386deab38e0dd0c604dd3472863b312c70a2d6245a830a6ec73773 a4b10b0274107f0facd711e2fb1666948bcd2fc0e563e6c0908680ee7faf1ff7 8e28b6ca9820a065ced2c72dcf0792988e469eca9d43f9c48c9a83e6644a5d61 358815fa94a8070170491d033ef579c2363607fdac2a659057ec83ea394651a4 3c452ee7479bb697914d9b4af7fa757eb884aa3ffc854d3911bac01fd66cbeb8 652a53b218f16c478867c5df964e1670e3add0733f4ab49bf42b830e1563a83c f225dbaba5f8134c9d08460c57d309dfe048a26674ebc942a0265e749c7a9105 5b1225b39605b97ec710789ac8a571da815e7d0bf1e5da425514a0fbcde68fcf 181c390024197def56113aec79b8a3e0db55d0e6d13e4e08c62e13573fd1ed66 5223700f5ca03f2bb50c9c5c788a9d67790db8ec88a2b0e58412315c31292dfc ac2fed5973fa821a69dd921dbe05c31850e37407edc2580f7de4ee6922777ddc 63c16882c0ae6c9c889f9d1cdffc5cc0003a29215c29f12f83783a8c2d066a8a b91beb1b0b7d9e293cf785329f80a0f86688da6eb88b3f4db349b58c64342a2e 58cee745e70058fadac37cfcb81a096c41fd77f7024e8a2c0907fae2abfed6bf 120d682e24349502b8c2f023f806e970834dfb33ffd1ca9bd688bb332ed76f89 fbac3ae10b2da60192ce11bf253f6ec75a7ccf2bc518b5aeb36c1917aed82ade 2128d767c930586d54ca1d58b9a58d42ba54e090f508882eb0731f0816994e7f 467d0b0cc71526d235c32629cc26538119e29fb0a60a359b907bcb77090e24ae dd60155cd0b047810be3ff7526b948330315644e09ea19b07ae073475789b9c6 2feebeb67c6aceb15cba1c06e9425fa419a4b1338aa5d9dc2a9044c39a78520a ceebbbb657cc8a3fce4638a20b716f1c7d78493d1d61ebbb8353393661488003 8a23a61d565ddbaaf8ee2e30f8df4be29a3bf8f1c1678682c793b8c4d06a0f7d 7aeeec7e44135c2a449707e184df5356a5ca9bba7ff3963fbd8172c8cbaa3514 6ff5cfc1f02eb3c17dea4ce5634055ed061d60515bf46994d8f604e1ec78db0e 139d72abe6c139d46feee000b642a809a722af06e0281e68e506e2c7e2da810d ac49368f91c074363a605e0b61c967dc7eebe5eca6d099ec64c260c09174e3b1 1a4f0b6d1e6e776ef23e49209cc43cae6f9e3988989eccb35d67e103454f8144 1b4006b16939cd1bc5013aecc49c193f56880b460d2b3051f8957376e93e2b85 7e9354d91cff1b894c2fdeee1117f1fe13873ea55d03f7a7bcfa88dcf222c391 bdf6ce303c9e02460bb0fef9b4224d3d1194a131473613c1117a3a3b8831f0d1 a81a135ffc7e58b70844932cbf7cef7d181a9221040ae29808a910e6eb921368 a9b6ce7bddaf8cb268ce0f2544970045148c5f89f51dec609aafc9b26d8e4a21 7af87d4949ed129f7e9d258a12c4b56313966440129559c7be3925d1b547ef29 feea7cec82c998b99bc091967501d7680ee9e19fe5fe30fce0f87a6c34bf964e 48d6f37f72d9e9adff4b0f19f5b263ead908e9642013a6d127b3c4238fc9fbe5 0d25f5bff24398a169f9f98cf8ab6febe0acf72ea4cd6617fcbef1aaf614a8d7 debfedbc758ef510e35437f942fc34a04d6f39bb366a0686d6e98ce2bdfbc94f 8c729e4c0c96ffcb17136d44f557c96d9fb9292ac43059b159f7c69b9e035483 f95c19776446509cddade64ca1f8e4618a308782774708ee276de03d46fa461e 63b9070ae5799503fa14c58a104c955d4e3b77bfa5d50de198c913349e139e01 8e8feab7dbf582b9e6b47a8744a2be8030f582cbc9dd87966abe737cf53bfe4c 8f2661f6a9d934f5057af05ddfa7af38b37932b256a1552ab5a9e64ace1ff348 9ed9e51660a1926f28647774cf15e736cee2ca49b7976339d491447767a7427b ddf004a59becb291a3cfc74e678014f6aa136f8a857d6e765e9c2646d4ebbe83 9a3e808f57347a2a4f23d1f4bd9f4935aa770e2c863a25920ae0ef3f006fc8f5 d1e1be2d3eb645f61532e762934e99ba150ec78f69678090e7c9c4ca09951378 b87c97c6de7831f1c11c4b3d9d6aca17ce853a8ca141fd12f4d064969dd10951 9996d7f5fc1a83165456ed98d4998f300578ec07727538507f8696705cfb3019 6b68cffc2d4f5c178a97c7e343b606584c5313f2d5aba38b68ac6ca8bc013c63 3b705ad4fd51070c906c12efce4b9a05844071a9bdd27998d188eaf1db948f73 6f6b81bb167ea703b71be4b011022cc2e5358a822ebe84b82593a143c835ad22 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 false +check_ring_signature 2c3da563ce7835e0175bd7edeccf241ad75fb7dc74dd321343a19b7114bb5dcd cb5a5442b75000f24bd7fba4445235ba335da1cd129b983cb38f8a994a98cb2c 8 bc3dd78755024b0baf7182df563017a315d362d76255278b5b2bd417e4d58c1b 571c5b81da370a82aee0c632f361f4d9e45637b08757d3e032ac074088fc56c2 71217c80aff69cd486aac07f0ac128283193daa5ea9abb6133fc9c72e144ffe1 0e98dbb2b05f1584721fe7b9164830d7c21141a2633a99f7afaaf3cc4fff760b 6e2947563b47560dc412da992c338e058dc2e4c6f6417e496fb97c24bf2795c9 a2549d69f5456aa43498a1eca55fb603e81e6b5788886499e8db40538ec6eba5 e021d811f9e6a2a7ca89680d441f17b651e874757bda4b792e41ad54ab5853cd a919b8e68a7b554c388a59ece89f72bf15aeb5a706449fc29d802c18178dfe21 db4ece5669f18d21bfc9aed38b7dbb8bb06976dc52fd3c7d4bb44333aa25be06cbd3005c71bc718bf8c9add40c2a61b99badf12adab80908fc053ed11a09450c856b2749ba2674bc4fc06e113e4674a8045737615519f088e32f8f9a43304e0b5bd20e823fb376726b0f1c44ec0c51ed8bc7e9bbb218eb11fed06d77299a530023729f6328ef351830c8f9c8b55219f57e1b4f440460c1e1e2282bb96f43390443425eb8cafed5a515b9f39ad3ba916ef1658b9550f4969d6957adc6c64681000b7dd50bc2b07bf6122b87ff1acdcd2fc95fbd96bcec10872ad6534aa192fb07dd55f6a1e8d4c6411dcf343d7267b08998627dc0380ce130aa02541de4d0ce065ffe3d3899e026d4366a51385c185394a97c6a5dcda58fc869cb402dab11900ec198c3ddaae947d8569f70bcc4f36a45a12d9903fa82735cfecc06b411567a0c8b3c560866db0e42d5c121dc1e19b6c5621e5b6d7db6f74834093686b3971a027c65286c1414d139d00e819cd13589e8df0a783e65de48e1fdbe2ee8488e170a2323e190023eac319e589f3bdb43498e81d342fbe9b5722229d275a839a9db05666daaa15d5a823702d8aa68eb10d2776fa1384ba4e443b0f2fb628bb7174a0a0a1c373feedd5641c1e6cde30271a9948194adb2c74849b8da3680ad6b08de0fa88decadcd30b445f00ec153a3c96445bbc872e1a2f8da702495187f45e23f0d true +check_ring_signature 473c5f8a19ede0fa39dd76a551d8221a1b5c78e3b9c459672669f634a0fe3a8d d6a77b7ed9b2c6cb1a368f0598335bf2abce8c9ff4d3e705bf619d4ebc6f05af 41 fb2d6710c69d1265352392db58dc55556dea90b35d33d2e06de8da38096b38d7 9ecbe854e55a3809c30930f3cde905e39995c777020d7527d31bee0bda265ba5 83edd629967d689ea4459aa152df8b499e9ffbcd9bb69c4d40bc886688c0c8be c895c7274323341290d3fbe7c946db534dff8d8386a88fa4f2131201a9b87957 70421cb9145b9627a826cc251a0483227294d8ef7b17c963fe3096f27d6b82af c097230c800162cca4ba076915cca6f78a8a733284be68eac07206e849d2a0f4 8e171a7dbc409fcb7bf9f37df4edb155cf20a864724643dd72d0c62061f037d5 53cb6576be0cb8174ad0af3812cd53ddb2c413fd843d6dff598732ccce3cce3c 7ed51d9eaf70f3a23986cba8909f2bc74bcd518895457d0fc6af602a34f15191 90ec38193fa25c0116a3a7025a19401dd53c1b22eca7e52467b06040858d82eb b25d722df24639c466cebd9056414955b1673e8ff32021f8c037700e0419121d 478e11fe8ce700c8569f46eb32325cbc6601449011f572e488de78f34421b830 01dd1d591bc77d7d6ab272f1f9df646c291ab683d284d2d9b18714f51f1c1c38 2d35fe8d85413df511dca5965a1ca04050a4cb7edf5010e8a2dac3b02f7ae86c d17154b70bf93771551b6cdce70dfe621da5468e02376a8c4bded258c6473089 ba929c8d8f17633ef8b503a98f163c0ef406a082c0fa9aa451f9fd92e9efec1f 947818d7f04caeeb50c404c3b5f869fa069736040189d3bdd6f704e5731779a2 623c5d205ec4c04f6349008236c95b70c4ade74c08c6abec57856ea179c52537 c913c2c74a85164e15e9aa698c11a959aac17f9203de0141ee78055665dddb86 0536dfc07f9ce1f1ed374690f894cac2b1c7a4b17c07a6a29c281b9459c83e86 db56bf7af91e67511f0c87cc4b698cf9030577d15bf611ec22729e0a894759c5 f869861f3dd0c637bf46c7797b3ee95ba4d0db10c364a55cd18d7fba01141428 26f252b227b95b63ca0c0b5c530a942d561105d44966639816a888a5054b536d 282406d7802c64260e50eb6b5434867f33cb5110b098322e3c001b192b05701b 3ca9842d5475d7a52944b499d56d558142fa52b8c54b19f2f8e5becbc086e5b9 dff42f383b5a988acf2226c24e7ae167b2f327f445440b2cb984a21db053f06b f0c1c7a6fefab6a6aaf1bb76b665549ed435b791114898da516b1f0a957f94cd 43550c4a4bcc54697c643763c10875dd7023b3f0dee12fdc7e62e0f1ac3d9597 490de981c35a43710753466863c3fb8f32413d38a0ede7e28476a4ff4177acfa 1a785360f1a68454484bf7b5bd604d73aa44a9120f0b78e5a596cefb1ff98f5a d9c1285972edb393e5b07408e965d3ed7380f38657d1d364cba51badc1b741af 9ad20e23d71019684b5062ac1099ef070da32838306f88f8cfb24353dfb30e5d 1fc81e27b2aea62b908b8de6a4ff64d9b83faaff4848cc869c7c75a234531f3e 05e6e63e1096b098cf79241a38302558714390bd5ba521f0d6099b503764d2f1 133e8c5d25c5ff83ab50441507b93663b49809dd705f3bcfe00028d6488ee6cd a65db1032d53d0764707d183ab8bbc8550df060b5cb3ee8bee46bc96167a87ec 4bdc9399ce63e92e865864a6375b7a01cd1b3f48d62dcd48d021d31a8324305c 24283672a40af4d547801fbda4d4aa7fa92df85de6b2c3bc757f637ed3d3568f 1776bc08c8d343f0d887090cd455ea894f9ddc14aca230f0d1ab142a52e9c7eb 3822b1d313a6bac7550af4433f7ab0812cb06e96e48cd2e8357f857ebb1082b8 fec8e259057d3ff660a8ec40587fcc4af2f8b3696d41fad45aa6ae23d12b20e5 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 true +check_ring_signature 447439910aabca4192a2ced06c0fa6010cb8ef39be04a419185d18dc28930fb5 8ec2184ed5b9b65514b7fd1268e73f59f8eba1a0be6b00dbeb2a414eee2eb5d1 57 60a3e7ffee43c0c94a31cc2042b94dc7ba14603833d28fc9e4870cf2524c593c 616c745c8db1dca5e54f9a4e4637e49508c35f8c354d6f5d588981cdd1ae34ae a1fb9c4d82305ebc49ecaa5a8bd6dc5ceb8fae70dd7a25c2c7a20b62c81a5aa5 3d07d1f3a912ef59e48bc3f27872c2bf8592f704bc185eb0e737b3981f5c0d04 0eb78c7e7d4536d1a4d892e729f77aa6f7b9346637240125277176022795be09 b634c332d5ac279f2fa26002133cebb0dd54fbc340cda8d1f62dbc654bb10e9d 3b486b851dcf9a8297934996b62d210ce75e3a4940105702f236d4668fbfeeb8 223bc144dadbb7c25c027efb49fabf1147c1fec591c5cb1f9b7cae593b72f897 2a9cb84339a2aca74b1b09b12fbc9ecdb8350dc89dae562ba78a0d351ffb1567 c43e509b04effbc1a09bfc08cf906dfb68d8258e5824f2270ed455f0dfd37586 5eb5780f1afcfaab7140bc8f52d8d6348f7f39b2b6062b685797778d5b1a1bdd 1e10374034cafef0ab5744970df4ca23372d1f8b71ce3a49e0a53c9666c85649 1bf601e36a9ae7dccaf1c5c23e526dc115c75358617f9bcbebfb8bd764efa7fd d3db57ab0aa0b445a81f188eb57d6cbaab8c2890444743f403907d7f998818ea 4fcc49855c784024ef1fbc243711900073a5e794f5414033ae91960871a18f64 908fd31eb48362d427a68907a3862235c7d7d6205ed79323b7b23932fc3fe037 2513af6e7a7ccc96ca83ce6d08a49b5bfb9f39d54472fde4657fcd47ccbccba4 3cd69ef27365ae7cd1030c9e1b7edda6b8aaf02a4b7a3291367554f5031e2869 d425ddd17acc6fc57a1ec1a3afc0d957d8e7656f28f349ae4e8059274ce6833e 28e5430658539dc2f3a3e1ab8408b373f0223887eea391e058d6da9484ee3f59 7ab8e30103d9aef0d0e8a165da0bf5d0d9e9e76fd7fd33ade44b477674899512 1764ac9c9c560c5e717eddb6c97b011be167111624381c2dd698e7a718bd673b baba0ec57b866c797f1f62ef1e596b729895f857a4e72f4c0a7008575e0bebdb 19c13f4e0a1f4ca0f4ddf69522e9483da71bdab49fd76dbdf59aa6adbcdcdbaa 725bfcf0721028f928ce458faa02d9d7f0693e5083754e1d76f22a0c4d2c853a 8b1b9d32f78e7046de65a563469c15eebb65fe7e1d1e378fea76b2ba7862981b 9e0a25ec994e59ec895cac33baa132776a861bc975a71f18de30920c6b2ac0d8 6214bbdb0c360078aebb311b73add6493fd152c7c95c3994b7a4b1a7920e403b 12ea817ded97052d342c757efff0e903d53092e3e634f7628c273d4eee409d71 633895161bade24c05aacfd0e5b41e6c2fa4b462327fc35d21be9a1e3db7bc99 76537de015109e0c8afe0fd916becdc02278ca9961510e1bfe55fd2ed4736988 fc4699e122c92d4145dedeefdb662c1a6ad8b8ce581f666f2f51e4a9f1f866d2 4947384d610b70205012b8c4d4510a782edea35325b3e3f06d80ce0f390e5835 0abfba8dc889d9f9f5a1adeb7dcb5b7be1cad3cd8c937bf9d20a6140a3cd70ae e077c09c1d8cf300de3c26533b7a968e5c22891bb3e696e22da9100ddbc621d2 44140fce46d3149d8fa0b0f462229fcc6799fb372acfe044ef192253cf0c571c 18aadd1e8f93580a71c1450e4e5fe2f2ae07d312e0c59660afb3a9f8c1d35713 d13280c939d88598ecae8948bbb5572e5e7d8d7063e0aa5c9aabcb18204f05b9 dcd6bdf63d06c1bdc9e80bb1744c386f49bcca6cc14e95fc28aff48f616a0ede 38731858ab28144ba079bc515782767bc643368cf463134b73c451dece796a51 d855c8a7210ca4686d60826b50c81b29a38dc6bfd3e9590da4c60f4898550f3b f795b54d65ccdb5378a339c0a639960f4b7d69de2ca47ed13718cf7403b1b7d4 43143f17ec724111938d45116c5ecd6aa1f13aa0ca75c64296b4d41d58d539dc 69982eab099c2f8ff3070f06bd691e8f887e914beb5da85635cf0f7d02cd0937 daf45f2fd321ce8a88e24a4915a99d826ae32ee4d6f5cd251e4447717d4b9483 9d0b6c459d8ddbae5c0c23af9d77eaee367cc6d9c9b48a104b215f2d5c4b86af 606d3b8e6e3a95d8c33506be158129b1aae77968da6fb82951153b8249e1b9ed 6b0e93952049e7646c38ff5fbe18edc88bfd0fe8704e451cfb1df6a076cde27f 52df21101fbb4d1e3bb54b82ca43f309b7535214a316693e095f41477b04aaa6 a2e910451843cc651a29c48a18635e8c0fdfcbf291047a35eba4c3304552c324 aafaece166116a83784e49b83a1ee21365e480f75cd5fbb439c58bc25b0a7b23 e88e41845ed645aacbadf8ea41d6ce2f1b75ab8e87082a8725cb60d8c340bd8e 1bd5cae282a501fa69faddd36bb2ba5665f563c4dffbfbf0b0f0d353125a24c3 87bc737a42e6ddbd4d4cc4abaf1c77d3bb06d49c68ebe488ea58ac1065e05172 1df1cb3d6e523405afe40353008969ec068acb4e3d983967fae3e324595b9172 c275857013a2e23f03c7e35fdcb130bde10cd988a84a18f651b5aabc3f571a07 f2a20c41e2cae1af2b1db7e9f24681e1818fbd297d82c451aa26c30f99eae2f8 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 false +check_ring_signature 1650a9d16006cdd8c6070d89e55e009dd4de5feb043a56d1d17268f5c663f237 4686450a956d79eefc545318c4d947ab9a4878b98abeae5cef2c49990ba2edf4 44 9da3f4923da7c8e56f84352abe5975456bf59e6019478b254b55b4eb2cf24a4d 63fdc293ca4cf2ccbfa8576f02c0b543ff972a3ec5f419e65a0a2f7604a065de c7960c004b4a18f3c286c3e81b3e107609ccb569d7e9cae61ea518f1bae7ca12 06f26d89ffc358e2d47ed00b687c4e0cbf543491b17cc046bacaa5cbd559178d ff989a1a1f4f92a50178debf0a0a805ac6282eda97fc3959eb0374f502f2acbb a48d81068b60171556fbae5e7078a134fb3988af6f89a078b72f20906a03e5fd ed11c00f9a0792b496c40d57853a7a9f5973b714ea8048d7aa18d0c683ecccda 57893a85ae5e9ffeb680622916d770d7103344024e9dcf57f685f0c6e77be3f6 bca9c5f215da950b035d20f10d58cd7aead149736bcf5bb6d508653f0fedfe9e 3cfc0b1a2afd81d9c49b471e85d72e401dca3236c8b73d38ac9d66fcb5517ebc 0bc537e57045a3d1b751ac1d738586ae5e63bd121c7938003589da266ee00e27 7183a6a6ef0ba9d4018b35e2ac408ad4054311670020803e9c4c68dc466ec31a eceb1d62ff7091af6b7c89bdf1485863d04a6b53c98957923334e4c6469789be c9dd77abf05b0b6de8c7c6a2c42ef9f9a6f62d50c73711cdb83d2a1eca91816b 9af17f90eb3685739a82dee0716d64eed75f0b37b5a9f5aacfc388ae5c587f60 33ab0c7d3b7191cd25933e07c368d8c9525bacbebfde2e24de21bb99b8460db3 e40e2c2028e1d3ca33290ce1efae9b6901ca1ac02ed536f396e774b92144df51 e5d04521b2b1ea6f1c194b6d754004ea992334c13cc92e97fb9864295b2d4166 308a16b37d55aa2b164e75339b51e390b0ce26c6fc65521f5c3d8cca510ce054 72e78b72c3b272e6fd3db641a29ac66dd159265d1c8009535d82dc04a4bcf716 7f12617016971d68a779facd7bc883edc08016f8d93294b74cfbb6985aff38b0 e52facc1ca6639fbd43a9881e6885a9a910976f2e82ad589cbb2b229f93bf249 3fd89ee0462a101c50b3c26055ecba13b75d547ba71633fc1927edc7efa86868 4191a1dec9f9758fff7b4edf7e2db5f137bff6e45f22d0ed0153b02d79be45b0 f265ee4416427e6422803ac080f56324f008444e885506ebd6bf4edf35412ad1 d2f541584e55bfe5626be2d0b71b122802b045df80e78b98f7aa591e64b80108 39bbe89f51ec983a0417429116d6d0574731f04f67888d01accb30e50eb71f67 39dff7a977b4c3489a3411c76b56dcdcb2d189513020a617e91be270ea954b77 6c8a5a7698dc587607bb3bb26b8fb233a5e6ae6c076de953743e04bb914d5d23 923968d74a2637131491791dbb6660ba945cf3747541e1b321822cb97b3b7cc1 bccc1c05192984d9e587b5a0a404229d42e54d3877e262a058a73d1d1261ce79 fb31be03446eefcd929c55643678045ca8b50d24e702daa4c5db9bf8a209d0ff 77c500108af5e1aac04e710fabb5fbd9567a0fb862a97f8b463423ddcf8e2a17 0614918891e7b90b25327d00b9b0e1ee78db12183cc2e6a440b75dc0a905aca5 2739771b976fd1d719411ef966d28bc87da51d17c2080a8059b105434f2d3ff4 9c0771b486eab598c0056f540d793a660f01e9ea57f056a86ce6ca6627ed11ad e86e699b54e60a61e96110cb865bb6f2ad28b1838522398cb39a4f38ea78dab3 89efd7929934fd5fde1dc8b2a573e5a354a1a4648aff39332d90ab13f577a49d c12258dc3c7994e1af7c1cfff85fc793a3d7463896ab115a239fb252eda5d7f4 e978f04235f718073fcf6a555e338b70dea251a361bc3dfa96b5f2eecca3cfc4 1613a21dd339f058610073de7c6d08bfe4a47c2151c163535d6c137c6bfea83d 8369a79f59649b11cd9122b7d780fff4414c4bace807c7a7241e9b88fd115ff3 7cdc6daadc98c8f3724eaeabd21b2d361b2648b7f62336e3f15106d191861666 2ae345015eb935114833cb82e14bcdc44995a56b0d4fcb96ea650ce60a4c7ed0 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 true +check_ring_signature 99879252b8f28c01dbc0b517368f447aabf75268451438e6fa8cbcb5a436fb32 40f5c8820c614d0917025c417025623c850d3bf0240ffe51369120bd23b49f1e 5 ece685c823873bae715851a85471b32c773655def4f2e6c169d8d9ed061be4a7 204afc111d79d78718dd8ba2f7be19ac59a28dcfacc7330457f9b0240e761867 323ae91b0906b1ca394a35cf665425592e4efc8e2eb2625cd090de8ef80ca97a 2abda9571783a274f90efe6ba7674e7ed614e1e69dbc9f827b865c35235bb086 58a21a5f226ba1e08ba650e3d12891c3d7944d698ac0f6f0d3830a03a4a9b403 8727220129e2c72cd3dee5d41c881dcbcc101cf3f25745adfa3fffe0876d05042ed0a9110802377394b329f82ea52f1f667363e7496b6d224103b93a5bbc981c9856dcbf9c013dbb485dd726e473d2437c53431d521fca21a78a84864191da0f927a88261f14ba1bb90f8a057f1836be560f704b466246dc81484bfe3e10a503ccb81b432d6ee0668f45fe563418bc43a48b2e1a35f6f2c31242bf3bc9915309dddcda67fcb04b2be8677366e28c25238e7a8df2d23d2b9e59aabf470e923b0541899a3b41520338c4016475b8e6d1f575e04ef9ec36ef0bb06ee0c5825dbf0a6c1aad6b5977616945c202c48009c823c3c26c154309d619ca3286e769ed1b02332eb19003feebbece7d81a08e75f350374ed167f880cd4883acbb75b86fe7085f5612c3939a773da98e3309501b1e1149c5e1484c310fc6c1e67af8ea633a09 false +check_ring_signature 419767a163715b1bbf7125f3d8c4ef55158e25dcffa09b36612304dea9229e4d ba0a3349d4bd093f7dd1b74bfb31bbe55f3cba41bda848c7d06760da421bdfb1 5 79ccbe2d5f04f749175040e877c86bd2affd305fe7109b5f20114d0c58119ac7 86b777c32ca6e6f8087a1bd7102be72a63d2cf70a3c278db40b5b9c5c86c980f d7cc566765238fb296385160cb5816de9955794b38ebe14dbbb61d5e9d358134 21a926ae1c2826d3b4ec5d9f014e8c3f744e55c0302b3792a92f2884e2eb61e2 e71b95c1aecf11c11651c7e72e13315e9bf21b6fb4e50bb3bc29f881c1186786 0a5091e5bb09f83a0dea69c595044a0488728427cc4f075c0b6780883444def5ff33e6049950a08f6d580d75ed42542549c8d0f42f4862d32875c3ce9cc7e901d250b548a6c111154ad87369347c4ddf20a469afd8668e8d5d59f3e2d6a78c0f9962658aa672a22faa8b4cf4ba5c16a02721175baec47dde62da64aaf53d420930366b06dea672a99e73e8afb004749069ab9c0617b677d5e5c80704cf078e007477decaca422d643a707f33f8a5ded2f4b9db2d7ab2693492e73350923b660f96936b1a230a1f40c93319a2564a6df8c41ae49cc839375250e70deee39f2d000501e9997b4873ce01e7141623ddfcb894fc0b39e8b3a5586923bcf4b1f3cb09ad40299622974a2308c8cf3c8559aa452af1bc1ef7c2fdb5057c57f9b51c8d0ff2be334ff3dd8d7caa47d4766c4b9b91989cbc699b497683296233601144820a false +check_ring_signature faecb4266110d43fa8cec3ddf66f7588127ce13e96b4f900298b6f9a7ccd8e0f e176b30714569d4fe5658be178330001eb35ef75f2a4310bb6512318b5ae54f9 178 3b7bd000981f5df1ba807c9b28ca333da30093c5f925745e79897dbd2c4b57c1 18ac8753b8b32f0ccde7c98fef4754579d3cb42c8128bfc2f5e2d97cb4e3c566 239b2914603d0b83255f25a1acf718e06e51c806b7adf3b0b1faf47c87ede7c5 7401035604f21971336ed99943b1d49917779d7bbabca7e9d8dbb48ad86c763a 283d9a7389ff11f7a207952568d922c2e8e4517aefaf38d48df242bcf48b1bbc e6fee2cf5bdcfa300b09ff237c9800d9f709eedd4d9de7c50f87ebc48266fb8e d99873154dbe924ef288d293a8c8c74115cb103cc759bec7633b7989b21bf823 3d8dd64b652c9d3661a7e2e36454eb7099534513e102773836106d2a7e6351bf ab7eee46a0124e20b41ac08367b02689fdef55d41bd59f284ff16533e5958a12 b9e138feeb8680f41e8d343acb4a930f63a1a813ca441b2751d2ab7b13f08c4d aa114b0aae0b32b513262be44706e34f146fa658165c1036fd86e05a5d6bd1f2 d9915c3aba2ee5842b6d5bda50be4471994ad3eec38142cec1b4be4e0557153e ce516e62afeeb7964862d1192071829b82d8eed0ea125a576c8de41f00a07799 43e637dd45d1fd1cb87908c7def3411ca5fd1881ab7d4a278b5cf112ab993eab 2747602a1fd796f7d79c84b91c17d50c9eb0f37e4f1a5ed9c05e89f30090979c 2e31e76adceac2e38f874937941f2d7dde46a64f78f3ea9eb0ac526de40e87b6 23720243a25c82542aac698175d6c875ac7e6e7f342fb3c4323f6554b4212c7c 7596add62302aa272efbb698d20d0856fcd021663fa510d3b90a5decda596844 1c5b6013b0b5e56baf6285f0aa7797f64dbca7b8c93eeb0d2ccbc393cdec354e b639bc0b28b3aba18cfc112bd1c112d262fbdac9728b6d0f9fd12362ee6a0373 ddda43c2fef0798e37604af265ab3416918848845111b55c305b8480910b7605 bbc3727bd349f9d72c48bd6d76b47e70506690929ba454149cb2c4534b5d6b8f dfa2c722ffaea0023a7270546f0e8c4c22ae99c688e92c5d9ebf881d311cacb6 7694845def4b6afead1d5d37ff58c5f48e2d36a9c67fce0c445a7e48134072c6 8a8e77b0cbdabdd4cddbda53b0972336253418177a352150eb4a426f32fbd128 99b285b9206af5a95ccc598ba6f2a17d3e4f740cbdfdb2fcd8d9b779bcb5a20b 94bb9cd010899912a9289e365cdf107ed925b774b2de7243a5d0809dd5adb74f 81375bceb20f1ffcb0b2be8bd3920e54566ededa4d9b31137751bc973b50e41c ce62618107904e3941647e177c888e0dcfb68f7d706d9a5fbdaccba8aa326fc7 5cbc834c34f16e08a43ba425cf54e893bb558e56c505ebe985762d0a86efdd9c 6ae08fa7237e54aac34684a72e7f686c14eb441fc2d217d4311691c3d4a6462f d2cad65416aa08463accdf530cf513cfa246e35fc4176165318c3bb393d1af85 7e3b246617bbe1017a6c711f40f8dc4e68bffc76ea5f89bf2fee1ed3be656d5a 5c1ecf477a32c7f53f64a2cbc7055225e844adbbba4ff73d051f94dcecfa0edd 6206f0ea9562286f0be73cec76cb1f40e8af088f288bb20ce175418ee9fe27ff 0c824f887671329e018167921e9afa4733834ab2cdeb88c31e25b18085694148 82323d8058350fc2ddc115a5327f4b7fa925cefd1fcf9082af10a2083c42183f 57b11af53722b4a299e8accb0d9ff3f7a4c1e1aaca41ff6d949cedf5bca50c3f 7fd632c1ccdc10665d0bf2d7c3a2f1cd2286cfde9630affdef48103cb01f9c9c 6761e7df5fee91a6d39cd52b8681e47bd78b33e509d17a4b8f77cccf02f0b6f6 ef871a87ca93de7c6b91cf4e4b9dc55abb494ecf9d4556392bc0bfa1dff0676e 1cb4cb88f23add01dd8c46e6caa1d51e8e4fb4239e78c559fcbbfb4da5d4426d b8329ed0a3d59c3012d4d0061155922ba4915f08d5a337c4884113cba5697338 b77829ce8a702534144bf01bb1139352ed9572743281f205766c4ec13807f75b 8718b18ce26fef4b49a2de0bab84bb00e2d41a9cf94f4d97182ecae4d68ef759 e306a792e750444a2431efdc10f7d46909bd1f586db4f2c5cb9fdceb3daac12a 0c692dea03e1e82956202ceee95139b151b52df02fa37f480c6cf3dd1d1fa989 adcdf8d1aa100dd1a1f07c28dc03efc1116f9df8c905c1eee3e3206aa60a6565 559622f3302ebd848fbf2bfc20687482490ed117df0476845902314639fa0d36 208770482b28dcd3e2b3bc3ac4fde6ee0a587c20ba11aa341aea87cdb968e344 7590f37689b672a4cb6867a4e23804153016228c2675c98c8795eacb4d9c606b 02a31b6cf2c3a807e97622f89955c55b8e65bed7987e125db0fa5c72795c75d1 a586045cbcdb166a330db1c1b47c828d8e1729c71cc86b138aa4e6adfeb2447a bd1c6863d90b239c737a1ad20faadd8d120f17aa06348f6f39dd021676837f10 c7b0832c8e6b172fff7f6355f4a7e5fba8d52cbf43e9fc6190629b19199d00ea 2b6ddeb8a95ef7d9c0201b3d7a2b596330fc3602cb9eeb46833121edd0c7e2bd 68b9801d12608504f7f23922878d7df2775ee85305970ac7b753908905a9bc19 d902ffa93ee605dc811eca093e3308ec23adac2bfe4d28f87e0df372d468c317 cb17d4f0faf4247b1a6efbdb4580009af37f0d09961287007461479172954b03 15f20f8f4ed5107e214d73e74e8046d3e47cddfadde77b7a413da22a0dea6de7 b8c96a49c8614ce6c3249269852f3f2a2c8c0b7d85224103f969d30ba171b6b3 2ea6adaf7e21eb8a473ed5dbf88e876bcace9aea3fab09e867b46b8672cf9e58 a470bcd2833c4c1dc5648f2f30522eec5a9dbc58967df22e9c088e18ad9cbfda a82396e9a91578027f6693000b957061ab68c46ab0d994a4613845318d3aad12 1354cb5aa006813a0a7bc70af2c1025cfb43cbe54b93199cc503a6002046beb4 2904d7fb09657897651654275c8f755e8ea5b8c0732405d6ead652541c2dcd60 a6e6aae5f687c0bb118a0a943b557f7cc2e8dd272e4a2a6a3af3acf1d447c021 1ce00f21905cc29fcbcfadb315167cbe8cf1f25d01438fb9cb29fb7015b6bc77 d8ea27f42170b0568cf695caf684718a6047c48f9c767666f1eb68897e634eed 4b1cf993bd9b104677b2bcc21e17df9b07fe9b24b7c7db1b8083911f76736b17 726adc26d7e1e07b05ab7a69605f440d3016378579334d2f41a126bd40b778da c3d5f03c6d78493e37aafda9f08c00854e83d7c9b5752dbfe2505ca66cb0cc1f 1c2a2ddd3c8f47a3d53ac3399792e737a5eb273df597b91c51e0980c00271a32 5c1497513b92af9952416f5d6389bf06e878d5b7c74a6be560c0f603e8a895f6 9d7e18494aa0eef02b472fb09dc5bb7e7382832470aa467ca9ef8c35312d5f26 443a2d14d1a80065c9ce7a49719233029ce2645ba38cc297cba3b1646a6344e5 719a47f2b49db1faf3f2004c621bf4882e85fbfeb9532afa46318523cd0a5384 63cdffb15f5d9b38132da9c5098857b8d057be9e93bc560e9f556819f0f44b31 007976cff6e1eeec071b20bfa34aa21c1327b58ea5998a21d89cae43cb16b3f2 e6b8bfbc7474f4eaeaa341c6bd9622dc7b3fc46298136f00364df3bb544d0eb8 2012bf2b166e0b3a4bd168fdb97bdc56250ea8fb46d2ca258a8bd68f764c4714 7d3261e494b882a80f676f26c592019609705ba973bdc96df761ef6c58a50589 0adcb2ec25944725f7ccae90684a72483e5a89136f6c1c35e7dd85408f049c70 d1449754f2ac778cf49fe469f3640b08620d9b0ebcb94cde699e5a7aa8f06927 99518ea793677e958511a5a83aa6abe5a3786bb2b5c6c52ff5cc45c19db52463 5dade6acee2be647056a284cae3929e68e0ca5656d3a765cea01464be980f8b8 c1f0e329bc18ded72fcf6bbe58ba4a20c9f44962da4d9c131fe406336078afe4 85acac8083b663e7bbd67e959aab47bc0233470e6677a0624d2d7a27bf1dc50c 2b941164b648882cc2deea6161654dfe77d795675ce1a2da4b9e3ae3b216882b 31a075ae784b2a251760c65c5c2636004298965c0d4dd83353a6527712e68990 80b4bdc83bab79c6d1c01061675165251921e36b8d348bdce743767256f41b2e 1ed01951754cc1082a6c9d6cc294ee6018362b4d73772c3cac130b419034359d 33e92acbb23316c5a5add50e91b94f19e140ddb490c5a6c308ee4ae4361dd327 c1859434f71ff05e002b05a8358fe182fc65ede36ebe7ebe4d4332abd12abd6f c1f528cf63af809a4b12ac3eb9826bfe0335c36dd3e5eb46cfc2d593e4e3baf3 af6ff8efb1727c509ef5c110f18bc3891b20c395a02743f921da0e96034b84e1 3cad88ae93f860fd8149a58eebf18cef6a809123bd4635500d44916ea0cec7b8 71b5dfa50f8aa7264b711cb2f09e4541e3af03a999e01518ae35122e76a0e53e 3e0d584e03548cff1507c29f42c2fd4b14ed4505b4976a4f2582eb9d48eecce7 c51d26effa49b2017db1a7929e21c689087edb713394454c6b48d3e39bec1524 fe0a302fdcd25f706f05ee98f44aab738d56bc328bbe23efbbd936a44818e0b8 c336bca41b1fccfa1d3e7190b2da2bfe0adc9cb7277e7503e3f882eae8db96a2 ab672b002f1d6ab12afb0cf7269fbed397a193d85ea20a4f0e8d10a7937d7cab 78a1be704a0a31bd80779ec75729f228c20715622b7137b13a465480848a9f91 3d6c057a59b7160b2845e6bab9b59a43aefd3ac825d9e00f150e88b1aebee8de d727fb0673e88ca958c3c20954cb517046d2e5bef4638e49c85593519418adbb e4b8326a9f23c5e0ec6926fdb8ff568302615068cb04be0c49ed24882b994d58 471f61f48610d11c12c4691cfa141262d67b3267c8b1756aa57af631e0e8d413 324c49124e55c3bd1c03c176db8e2d4d32e78487ab91edc3c22685038057de69 0a5b965391a173236da295912676e3b8a0ed4de4ed106c74ea85576c99b8ba68 1e936fbef8bc8d7b437975eefff0029aadf9d9deeaf69a35ff9ba8e0c3168138 b2e2bd865b699c5446da84ac73e2a398d58b8335131dc3e31945b962b2986430 f6e1ea52473351f8025f91599243a4789d4319382399897abf00ab4faa56929a 06cdef814943daf8cb7ee19bcca49f1116768019218e2b77a73f1041b6bb8752 deb834deade6c3d035f3d24c1037004b60cf75bb884d7960ae7545b12335ecf3 2e7f2934ff424f7b8c678a46c74e64cf6f8705243d062f7627258ef606ebe306 e6d3d8765858300f22a60009ad73d67b520451fba6e73acd3f7788af1602276a 3c7f9a0a17eb959d9f3ba0d7531ea45b97837bc5f9d2f8ffc1fd97d54a6c54bd 5a016a882c51883c6ac1ba5fb7fba578d9fd8dca572bb22faf23eb1713e94ed7 30de3d41aea630ca751a6b8ad2e65cebf2a2616f14747be992740c81b483d57f 80c6658a0cf2a3d293a506bc416bff387230b25a94ba1be9363d42ae3ff4afdb da1ce18fcaeeb8f9f01d5881289c959429ad0ba6ef191002ed855394e543de7a 90edde2c2aaca534be02420f3f6f0be42ab065ab7c6e8dfcab02ae0a7522571a c617b6b3577fffa1a9bc9070c08a791f1c04f9c7ae94e672e4753aa51711ce12 b06cf397c842382655d3c8dbdf9d824cdb110012ba5068caa32ba980c340a75f 3f6ffc5c17adab84140d2b8f1cf9a04ca83e84a5a3cffc9d45bab9b767bea964 e4543e2d0c967ad36ba017d67c4757c6adcff671af3c6215b9d38ff2f67288c7 8505beb62a505e5380ccad710755ff19e4a282289a0d13abf039a0df1c50c60a 531cb61693d7c5dc5382954d4e7456db282fc76e1e5598713fe2eb4a06249bd4 8266d0c300443f2a4016036982420fc48aa51f0a77382881b971403faf65e96e 4272c029fb83a33fcdabf3566e7f16ae5b1746ef6a5d02f82e80af7693e4fcc0 5f4eb25e7d78d334ee32195cc636f23a33fa8bb879dd485c1e5b463896e94f57 f03a846c12a554ab625bb1cff18b07c62853db2c3f7bc16cabeeeb4eb3e34269 d348eae2bb0faeb8a8be39877cea71d5b9a2110f337102614ea04271e61f6d12 d340b0f33c597f4d1dab312aedd812e41f34be78dddf4c81ab2e89c3a42174d9 f26b2e93deb83b99dfffd14ca920f5030f4cc409c6c3b518dea73274d53054a0 5f4beb0bd57966caba74fbdd96ab317cfc576bbce25b80904a34ecb66a6037c6 bb85ac7bb06ba7da9b04b0857677ce7d89852e6c8ee73d1afa4b02c7982bdf3b b939343697c1874c8c44b38e3e38c093b11c46fa53b7f6125b6d95791218401e b0aadc338b4fe90aaaf1df60f77f819f78a93f2f98380b757f8a496b4779e751 e53ecbc8fac6065961cc3e52c001cef50a55af18a29d9c2e364a4bcfe7d76c55 66a2b50c8fd2039e7600eb765233e8f10c415111aeb541b13957d69959079984 43a4b3c6268e4925031e2735573cc4b84cb200b1dad3e1402724a55e44b4b1c6 203d0ed9ea8d9bfba1b17b1a1d48685ba8bf9eebf27f773e500b5c155e797709 e662ea7531a3818699643edc4e7564a744d8197760d50e6f1d27aaf2f744fe50 4d781d2c3282926e3c3e5da802b652a85e01b8c09b8cfc968d34677795028e42 c2aaea2852a2d0d17c1bbf22ce6598d84375a9b8ef43b1623a613fe55b0b5830 10fae3b4f62c1d9fade4a07c78f704501bcab000aa6ebac8368346fc56e28442 8a12284a3ed5b9e9bf8240743b7ca62c97217c39074d3a786bdddf72f8c8ea63 d2d54d068be08a3e89d4d1ecefc5c26fc4fbedf6585796ff45534c3c45bf1966 1d074a2cf53bee087f916a5cdf83005125beb0ae93d857ff79ca40a3f9f3000f 0da1ca54515a8ad032ea7cd9f418d2633ecc70358f899e088d675f3c9bfe053d 2fa394a6ab15d042bd437b522d0943c7471d3132adebe6a9ee2af3bca7792ce8 1bf567e698803cba09fcf1644a326a3c372226eed4e224e1ca3d05c13718847a e5e6df62f7d008f69db94ece1195e0aaa977bc3ee6778f076d14ee0b69829eb0 fa9390a889424b18da602555b8f31f9b95e558e74d87007458ced0a08b01da9d 8600ce44d5b0438f26d8daa84e086aa2ba94362a978a014d720beb9aaa69f8cd c8ebf8b641a86ffbff88818f1b555adc5c0914c98c6de59ace34ea044c9ba2a4 a7165c5176759f59f7f20ae74936ab138e7e48e9f825fa89813dd8045750d9ca 242af7c2138dc97b1fbf8af9389b40fd25efa16a34a8a91b225a529f0850ce88 88b24b412a06675b15b030cff19b405efa4e4385e36e55c8db45c9c5034869d2 bfd03759a8802f4da3ace83cde1298b9c2fe35e5404a5923b34aef0558e9a866 2120db40a066b1a05fd049b813630c81604a178cfd789e88574b64504beea2ad e1e71a7485a87aa7f06825cb9b02aeacfacd5267ae116f453d76d3ef57989336 a856604fe37d91401d9e86f04afa89bb6d4e4e859d4d669a98675cab31d7a413 f2762ec47f68e6a59d835fb861b11bf38caf5072fdf72286d6c1a0a62cbf79d9 ec755d3a14e08db0c20da5eba89494e7f5fa2f5d4de8d4da5ea04d9928a2de63 a9f883fbc40bed5b98742833b275bc168cfbdb70b0d55bfe3f9fb359875927b8 bd7c48ef6ec7d2dc20fa203464ff79cf103f6fa0d26e940be2eaa9b8fe5192b3 ffa0a0749bfbd3b1809a5dbd67290fa5d5237fa2664ece8bf71cbb68344ab357 b9a2af0d3d6464cc871bebb7f7ec5d55be375f1225cf2c27a074135447ad4735 f245ff2559f3fe861601b2857597b88c58905f81f039b1ca477a70a82d324e7c d10056f70d78732046df829304072aea79754be04cf65b50a0c77a6536d6ea17 3626e20419d248f8487261d3a1d6d217c55e2a59a611ac9beaead117e668a88f 51f19f560267a65d3fec5a4f224b03b7f79443934ce00db7503d668a3c72c77b 7fbc0322e68beb26ee7804f11cb9d44108aa9b40264518d04afbb4bfbe435535 e4b9dff00050cad9498e425482e48a46492e60050744cd47e236587728fa293c 09c5098601a768d88b1d42670f8b1f2c029a87f097fb75a90105e97650ed717d 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 false +check_ring_signature 5819cddb96c01b4fd4bf3955e5fd943e553ceb2aecae94897d117f08f64be682 790815d4f14b84159b501a68f667a3eaa9b86e3ed347f4c3ab07ab3d9bbc0cc7 27 3a164c960a159b4e3f7ca629b5f3d7c128bee6095b7fe8569387bdfb7b645848 8e336aa18858496b0fa0c223ae36ef9db67560ddcfec33548265f377717bcbc3 412294d2c7b97160338e69e74fbbd89e6cfff474ddb780fa0b2a3b775ef8561d a7e080a1813f19ccf685537649fe2de8f9694ec7b6471a108efea1e37a256311 caf0ad26187206f4536379a9242815a2f9c7cf5d58f6630dfbadc5b31e6d071e 39cc8dc803b19ffdcdf09e3ad41d4956929c64f45da3667188ccfabc5ccf5685 0ed2e4a04eb058b734bc38fba278877749c40c1bab8a4f011932474412fb9217 55063580eb175fdfd15bfeb0f646e8c79b99a59f5b7b3e826ceaaa5881095de1 f5c439328f8f3e673e7e1bf9233d711c1356b6dcc7765e7bd899983e477ddb02 8331dcc0eebd793e9de3e3a5e402fe405c196ce5fd9267a6d1a5579991e2b5ca c8ea9dec275695214fc6bb701ec20cf8016a87b88b7544349b4393d1fd100824 042d6b88c867b7de853c8c50792510e515b38855f7059067386aeba8c4f5e980 892aa44d79e307c18df31ab6b92d59ce475de919feabab9b26e0647eb0267eea d42296dbe1871f316245789cc54af9062a7f7889a8a290bbdcf274fff54e33a4 317d8a31467e93e61e6d184f8c3808633be3bbe37a7c1abb9d6f5945f01a1b7c 5fc5195ac9ca371214aeec335f0c8dd0788b562c6688b717093e8ec24d8f6f80 5818c6a2515febd9a4095eb001c0df305627ae623039be8257cba796e5f68e83 f4f2c133bb09e721b8a6bbc44afab6c0f7878b019269800ca810966d371259b7 72f040c9be8bc41ee6d386b8c2d2b945edd1a3b630565f74e5ec3730aa5c1f67 b507c3cbc05698a60b69d065b736bbaafdb82c99d4df78ff1fbef99026a0d27e 6eb4f4da68e7d6e6d53adce5a43b8ff1d85c23364ed32b5fe57d294cda366a18 3d190b0007fcb495bbf49de00b281fdb0bd598a79eba7ee604714f9f1611697c e5462f8a6e0eba04522df578264e562fbf5dab42a471b2c930ec56d58b5c70fc 0cefa740e55e76a6cde4cbb71c4f2c3683b66b5615c89d094ff72070d36b2102 fb2d72d19171f23cfb7ed8b903a212a5829844419cf08b4663395a5227b456ab 9592859bef90b6f7a49f3e17f61b1cf1eb8ab340d959a39c4ccfae1833adb5e3 d336050909061b378091ab1cc8bf65b5c11c7d27f631bac439a9179ce01fcc06 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 true +check_ring_signature f706daa639e2b3643c4b5224de1b1cf728bad407360dde8c67ab382feac0b54c f66f2fd09239f34536c9c05f8d1cc3721138fdec6e339d39403cdfd9dfc5157e 1 29d81ee6dfb0a38dbd43f74875f7e0795c6acd25efa2faa9e9a8473c78290dc7 6edd9994127ff2fca341b9d39bc36d5cf2049e5f172f8b0e74f2b245dac033fad16092ff2486b8730f2f7d9d3f6c932135cfdca1a4dfb7269db3db9170cb6a01 false +check_ring_signature c618559614fef01613303e814f237c0293abdd5de451e50b59f0ecfca62743c4 9c9b91ae4f599d07e3eb0738e7ea9fe530dde831ec8646e3f69f79dd539e6745 5 1f480cb58338df411f4a34de9aea4c9dc4c3b804ada3f5c46350a45d5af80133 213a96178146389d92080eae0098a1393fca757aab43458754d723d89051c664 6850e0565cadb6eb03f5f9811f8661ff1d53f953e11122a80e6ad642241c69ec aa8cc0e8d272e8ca8845481f014b09450ce2911909313d35d084cde54d58fc37 6a55c59dbb490a32d3a3a4c64bf182fbc41035fd853433fcb7d48516dc57c2f0 3a833fb01a0008919eb711a3d1c03b1947314beb2666e10f420e55e70dd42a03a28d6ed1fd0b5d9db25486c12b23c1fa2e6647374ad8e53c97c4cb8e83ebba0e55cd41f18b139c21ac9585e1b8cd8a0a3788077622bdcebcdbbc724d24772f0c6ea6e87be5ee62cf18f3e2eed6537cddd17c0674d9e8e955837910df922e440451f272ff11ff9d3a348a6ad4711a5f1418a888ca077cedeedfe09425b76a3a0d1aa704328565395ef324b5e7aa97f13229ab00811222687ac781e7e2e0f8fb0a34d4b9b1f1800ef15f041486c35d256a9178031ce5a2acb879b70f11001c5d0f896612c72cc4bc70bdc8b16e98d0228ac3eda3dfc622137fdbf5da9814a2c40bc608976d7aa85a60e4f2d4ed84973ac5a4ef13374fe0dee491a297281f817104435426a4a6999667bdd58b8aecdf8b52d23879349ce9e6bc0597fbdc02a0e90a true +check_ring_signature 67a92df2e29bf516e10056c70f4e05e1e91663415bdd81d4b7a4845ea0f8db42 5351b3cd1f369f5d7b66577e0d88f58cfc479e5215c2fece09e270f0542710e3 4 035bfea7f4240a6c4f70aa0fd755a2cea64267293d2b1ceb86f9e572598ecb8d 1aac18428d7ae7b196448ac461ebeba0e0a834b05f5c178cd94aac1f3c5c027a ae3e0a79a790bc99eeb1932e7764e351a0b92eebbc4fada0b3ec186c6cc0be0c 67624fdf652068bed58e0e7e3c9156a33ee549e2dcb5e19ae60a6132c71648b5 522c2c63627752a5de464f397b63aa0cfb6d47e43b018cb113ff735a712c514d2f5537f3e017d3424c05053bd4fa1eaf85aa8224339a846f48e9dcf90ab4a30fb33902baceafc9691763828635da863d5f560a9573babe842e9281e7c88c6b560a3950a4eb59943f530343e4d761f6dea88c11537c55a821856eefffcecb5d1732e6d9ad5123720ba10d371243c21bcab399d7dcfc71aa61b3fd01722836eb5741a86a838bfb9c2c907698a7ae4cef785872ab5bbd4207d6a9e7ed2b570bf0cf8a52564b098c271970b7e075db1a12d5bb8e37d49886d888f58e04bd80f16a07d4f413e3dc63d6b024564e0ae658f6b2e5bd58ba34d54a21072fc0b7ce9b3753 false +check_ring_signature bbf0234cf0fb4848fbec305e95c0eab794c2465fd9f73667fb95ed123b091121 9113d0bd90c3f6744fb66c3fa14c0c4c299aa5bc4d818afcb9bf3588ec461b3f 1 3929cb44a19f7941e0ceb1d66fa41561d374f9d6dac439f081eb47bb0a40d888 9c6eedd0a246dfd38fd1d312f8d188c57685a91a570f29d2981124d67e00e9d0f8dacd27999e5965ef9cc4ce5b5f45620a0b8e1a95fece1b143bb774e472acc5 false +check_ring_signature 261cbc73c6cba19857a10d239ddf64a541f1ae433fc81de5c62112c30709a228 97372c456fba1f719d7de3c390f30c81e66c996d7615056dfb4a6efd4a9f0f8a 16 1d0f0b8962f636c142f98fbc7e9602ee8d016ec052fe5abbaee053b4c9cedb91 40bab4623ba2de8f86fbfeb96a3b3d075582c06ec1c8f5424123e0f08d81326b 5f149e5594d45df4626f0db574c4cd5dbd3b66256891d89a3805c28c0a45c6c8 9f9369ac33bda6eb403ac199900e5176baee4935c0461a990c85124d37e605b9 ef29db8de8c9bee8c97510d5a2a751f1594787b24239a6496436681c7e88b36d 0d8198567f8d05a851a5de4a97830a57904baf961507d11223be53234cbf5b74 b20fa626efa303686356d4f7d71bc65a7fa9e7f0409e7b0e1d5bee9536d6684b 0b3fbde46fd1d5c916fa70fee273a2bf7e73e4a9ea4bcede79a66bee89c99f06 b327d18d0324200e2799272d1ad85e1761768268502e014a09d3a5004b2d63df c2ec7a0f690f5b3e5db2012828b3a8cba45e030cc7988baa4aa2d5c5c626c3a9 177d634bb214c8143a259b8a6b3747bf55c906f2d81d6bac5e3491422acbf161 f5b065d549208bb48854d9ae9c802ceb8bb988ec7a8405e8de5b2f1117c5396d e2fcbb000e09f1221c8de9b1b1256409fa8c8aeae97799aaf3bb72c7c5511a95 d49e63d214fde403836083d1984180a1448f0456a4f55dca3b8251752649432f 639eb48db5ebd3caa369e9307faa964a0c4bf69a35e387997855b4350e40d02f 6811637022eca172114d4a2102312d0af51250c28b9c0ea40b5b10bdfe3fc246 3a508cab5c586377ec3d78b5d8ef5d9c2012078e61f8f91aee481e5afead16079dcc09b60a0e74c11acfce1bf836dc6e6bab1c492005dae3ff43b2673eeaf30307a3b377d1e0acce7aa5df0522fc89668d71bd183e47cec6585b09d32265bc092c752be0611bbcdcf95c1e1a74fbc9f929e784b93ac30fc9cbc286d8d6418604c1d580bb2f2a3f9e7eb417910630b1de0d57f8399f6bfb19f9903db5b5638907aea96f92045998502247f8ee88fbf25b07273219eb986d6b91a32a37b7419505c3da29a8aca22420655f61c09f38ae3d23694da68f9ee2516a6e758e150ebf0e742309220f38207e052b9887d63ef117acf213dd9c67f6a93ba30ce27d9574097eac6c104adc56db5b6d92397ab9ad936ee30e211a887dc4920a6d8012f370082d229b34ce0b14fe2ffa436aa11c3ddfa1802b307d8cf87ea695619c3f4cd207dcf888f22004c2df74d06f2638605409ad69d2d1203d8788192cf9bd76cd240bcafe31376615e9fafa27802844d2591592f08e48623980ece29b3f5654a679078c7034ec0ca83bc3df6e00f05cea0f01a7d5fedb01c32d6a422a18c4bd241200d6819c9dec6b92036ba7217262e0b97c9628e1f7d8c133f400a0832a85cf6c037199696f3a0d4ba52b29948f01d527378d58ef6daec698139bbad84197ea680d4db0bc577fb6dd58358348cfe6292778c4fdb3beca866fe2bc619a956e4b0103b7e29e7d47d61b417399f8ebe302f97fc1cf80111bc5fe405fdb3fd72051cf05e2a4352199d95795133ef30d2d1b30eb8a9c61ec51b2c66b1cc5723ecc74820542bd3c5bd590b1d98cd3389f749787168604a1cef0c8ed823b0d1842d7507e02664656e9ff3aeefbb1783a3bed49d7bfd815d37f769fb1da71fa4d7f40cacb5649923950a44c3401c0a684603d6fee23e5462fa100feb8bcfb80e16c2abf710df59b325264e01ed31f4c81cfe7031ebe96130c5c614aa17ad804da08cc16350cf37036579f534adf88fb3925fbd8c95533406e32b327d301dfc6c16d30f09a04fad135ee00ea1ae217a86279a6848095ef7489763cfddfb167cc42e4b679ec0529838f63eea1cfefa3e75a2ef88de01505f414f41e89bba3112bb115547f8300e5f040c763afd46425ac9da0ace4eaa6aecfb558ca1218e4b8fafcbacdedd1023709dfe40d589f81bb8b162853f5e82e5d7bbe7505c323428399ab55a64e750f6e31304a71c3254172cf6eb3f227be5cc250131b5dd63a45f93d8fed55b0d60608a19aa38320b590d430c44f374018c1b3aca001468a731df8b254eed8555b0cbc549ef420aecabc53f208823093d91c0b857c4aa2de45e2773eb6a501d64003d7eb04fe6931aa77d9449ed08341b4d61e11fa24ed8fbddd83b1edb1822c9a0a63d3d6250e31970c20fbdfb47072e3fe540bc59acb849c4567469472b6b62f02 false +check_ring_signature 71f8d8daa61524ab76cc418ae84e09a066ff33f00e4e2e309b28658c2f7438ca d50476f5cbc8f7c7b1521791c215ea1769823db65779921178202a1eeeb6726f 48 34af26f740e9cbfd95eadd7dfb95e44d131c705922a2bb16bfd717a2d1006bbf 5481958096fea781ef34ada977b99f55df391dd71a6b08c98f7121a2a9e44f46 2b629e37575b61e54193f01aff8565e1a3ef4cd6c36848b815df025d54497b46 3eaa6431215a7a55c72e1e93d781f52af24806dec1dec0c8ed3b1d518772fa4d 9f968674d6a88adbcad60d75b4825b088158337a820623038642f285d67540f1 9155f6fcabf50db6bf6ab1142faf7b140772103e7206a88e47dcf3c4590fc811 ab14b971929d6997922c77700900f0f4a46135ae7565e26715eaaa6d666a3c58 7e37e757959f52929325f5a1554feca3c46587cfea95729230aca3f8942544f4 26b780254ae0e16287287e3b6171c5b1ee66916a1882ce00f25f82c664853a92 eeb3d2042b2ec79d0df729cdb6cf43d55964ff7ad99ba3b8aa34384b9e6be15f 4ff08f2840f74c659209226d7545b35d8ecc160f6f51ecac97a989731b35bec7 fc2c16f335fafbfa481a50079816bdfcf631d19d3b0d42f2d3e94ac840a5ef82 e25590e67f09c849cd9ad2a9cc7e2abba8b101837ef8d9c315fc9a2dce59d1e3 1172c26b4b5d6774fb8b1bc0fd78b66900a601638c9d3f7f04e297b88887970e 408de52d0f6239990abca7157360198beb3c4335483705e37e912c4aee448370 bdde3ba68463e22383a0c405ae3f3c215f796ec4e9f7c1184347e8f0fad3e729 862147e2a94317233d943af19d866e0b75569bf74b0219aad935b8272d25bd00 381123945ca3e7f832390d18f0e635f945e6525421b54181008ed51a3ea03d96 70a2f34ba9a426d1dacf2149bb834ca64d3f10ac2252d5dde79e9433e6cf3913 4edbdebd7d93c61ae953edafb7e6d6878dbe5b5eec6482db74485675f96ebaee 41b798f2f6ba24cc5e4f76b6f727f387bde343a4a80bc6b48f9ebdca87b77bfe b9d26f4fde1fc9f56b2bbe1da65f34310bbfa787e7a01af300274817a26f0de2 a8dc1ddda6f5e9e404dd6d4951c068a3cf4ac53af8840a8f931c98b4c8c9dc93 fe5bc11ef9c6dbb2a07ea8e8fdacabd955866bec9d1c278466d8da6042e993c6 573621763f784659d6c78e2654a05f6b9f603789f602fc9575e222bf3a6bf0c7 075aa106db00e9e374424dc14bab8f573788e5714ed939e5c82f7c7956627acb 49b9f44dfeab8dfdfa659de8641dfe28a0a17c7d8b90a4ae7cfa4d04c00ba3f1 86575c9c0a367171b548978941c5190f43c175f935cd90f28682f2bdf7258e27 efea497af8b77b603400db7f767d563aa4a710b91787c18f292c6de92f8457bd bedbdfe6118f3d35bb7f6eebd9d32be382de9227e8d97e81fe2998bfacbff9ba 6fdec39a2203439d2d1602f7c92bf1bc2ed2530e9db5afb1ba0634f3e1221580 aca40c7df3015806904c4a250da7f86a35f1199490df92a7b0c94e983bd6ed9d f7c2b84728e0457f13fcbd71bcaa73aa6dd2cbca3017b23ef49a63d5b03dc966 cccaca6b55ccd3c6f4f5b548acc2a2dced427ebed5d460316100b2b33fb8635e a1a30aaacc1c1248c891abfab4109d641095177950c369699a8792b29dd74143 4e47327c10f49b9aaf7939cb90135245e1c47e2454155ddc367fdffff6f5b753 d41382279ff8f3d46c17b89bb8d1a95284649f0ce14e46e264ceff1dd1ea7cbb 475477d3c6433ea55356aed85e6d1b492bce6a0ad2f4e537673a57138d650c0c 2f9511e499a5ae8276632c5df4880c99a180fa6bf72a269d207f233240b0f28f 42045ba8b020c12ed1ef7c8b2c8912aa83f6a22bb4c85731187dd6c66523b519 878bd6f0a07783bed9138bf437649fb3286f033d3a78289a7c45501ef19fdf6d 901e15594230152004fcc76ffa4652d0a5f49e8a9a167266ec98d41bfb1782cc c92c3947ecd83d0a8a79b115c9ff0093abc2126a90b976fa27600565ca66c799 832e0a1e17512ee9c297cd410f55f0e83e5a88a1d6dbba45f548baa104bdc826 26840854e0b705c5772607cc9babe3132f2be3a63fb3f63fdacdd34abec04db6 400f1e17b50a5254416c916bc8f81e701e05424b667b68035cb3be3a0949ec7f 690340499eed4976aecb863d49feaa6e9beea20679b1f8c01067b222fa3bdfc7 6676f22d8da7fa328e12e190152fceaec0ecf5d93f2b32f5b63c61a84aec1289 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 false +check_ring_signature 79017a0ec80d9b7764ae457179b6f9a344fc938611ecbc873da9c3812130532b 8df8311951e459e162c2c471ac1d4ce223839ec12eb290849db63b77c8af1848 1 c863f6e74e3b46671258ee374982d0fa5a8d8de970d51d0ab3693a9ea6288868 0c992da1bde89ac34aa6af197eebe328b536b35898a2a3195cdc617c9b0a020eddc406a2e4211e0916d6b31efca25dc45a7533956b34bf4dffc2cf9aae1ff1db false +check_ring_signature ef1266ea6ff03c6c0ef39de1e69600f16399258b360af377c216c09821913f53 ea82b1d2e4ebe6a323fee628a407d39aab3e21c05689f1746c722f17c879149d 1 91831205833118b71f600ed6b9b47b368115a5fdacb67cabe914ab61de58b33b 4f93fb62b5969720182a013ed47cd03908b8685b186258a733cff6e9bf122f0ca6ad6a91b08c22b3f580e05da1fb5a0ef93d26cdd647b6d9db535371b6aa9e07 false +check_ring_signature e6fab12e615f2aebfe80dd2e4fe9a4771d78a35cb9d399ff7cfa75fe1bbd6ba3 a355cc937e2d88ad3e215f3fe9a40d011d6ed51f8b1fe0c4b74ea70cb5ea305f 60 8cb4f7b8dfb719e34d887aaec0e5f9f52aaf942f2191e580ef115b205dc106c3 7f32bbedd85f6167854cedf749b5cefcfe2b9e672a95b1e9a2a7dc1f1966993d ef90c3258e58df60b5508e22d06c0e8b05668d9307aed15bca02455a322caf62 0d16b271ec1a31e2f95b736dde35cc9f0fe6dc662dfbd5582126e3dc65efe5ab 1742fe5a4d027aa8b3a4b82053216a484bd1e1e56bb8247533bf239cfe5af0d9 eee6b936dfa90c53247321c6e350e5176fcee7e0c8b371c9185a64170c95a9e0 010309f4ea85f8cd8defd23b73bd993fc28463b76c1d5f36b85973efedca7140 8dba7c4bb971c930c3258354dcd7a257d938a4d10d6e993ad2e0c601299260bf 0a6d8919fa5fc9e526acb7bd3e703e4df99a733fd8670312d021c8d8d579e4d6 4cb80d44ea00b2d973624b44afd76ffed2760aa0410e6c17b66c5c7da3b4f3db 5f3a6cf353dd32c76e8ca33da3e6f13ca3ba9676edd5df89777f61f8201a9f11 bdc7b96be937c264b4d2622b1449aa402d3babaa8d67f4344edede0052306dc5 c915b4a084b4c18a4c40b0e8a1c8fed0b392b17cd8865099b4917988a429e0c9 40239aa197de49970438310ff50ef8a4b0ba26af1f59a9be57331a9a110ad12e c2b9a81556e516eb203b7e58990f96103e6a623268998b5af8e0505fc574b2a7 c4d18c940bd8049f2e5e018d81c94512b34c3cad571967deed37bbb9156fc61a 5babba78a66daa6b9a2e71c8323bbf28ee353408f422898882cbccfe7cf15398 9e3dfb7332d0048ab1471d29809ece99d19bade9ad662c5935011505a57594f9 4a701e61f111690451ec789f75004ec9d65df27d73c180817333cc4f682e09b6 eb41c057f779cf07808884fe8051221574fd40ae915225e91ce02d5202b079d6 9fdd5b0511020c28669509adc55bb5d176f5c2e45cfa133d9f0012209f689b0c 8abd86393d7a86bfe3c8332c9e160066c169e034bc4d131d3ab9735a5b00d5b5 bd63f419f07ff0a43da4681006150f4d5f6a0391507656545f0759b6852a5ff2 d6942db20ab5549ca1ec81b5724a46c15ca78830b73915273d4710f6584d33bd e083a47ec2eac15161e95958c8282197fd6a1b79fcf5c400d9865864c7d974ba 89ab288ce443fdd38c55b6ba281cb66e7b505938f02738cd71c32addea90d0e9 ddf1dc57f1fcc7d1b14f498783e0c11fec12b858f875e2aa22fe90d8d232e8a9 672c9e36a384e31d50b90d7e5fa56117dec7ace7963dbbce397391fe7945b0a5 2113a24814bf5ede230df8ee0121bcf3723c1dd02b1fe5a3b7a6e8f767d3476e 55201a7480b4d34f84932a1cdf4a990cb98d1d5c7cad58dd8ca04fbf24e82639 4122c65772d20bfab010c7e1be41c7718c833f5bdb290368e0972ceda8a17cda 61e874fa44f3bd52bb54d932f251ec52bba03a8261ab2aff86888012b718f540 37ec951c64d177c34dcf79013ef00fb4a03bab4d1251840f82311d1ceb145d33 18bea10a61a0f6d5d4bdb944f6e1ab71fb4556d5e31790642a58d36ec5195c71 aa6f3dc72c89f0846e5463be254b98facd8f382651d63c8710370b7aedeeb785 a932e0606acc947a9ea06a0bcd3c6a445e361f9d1e90d3932b4532a1dd71f566 4655a926d7430f56255560984d037a5c4d7b4f1a4ab5c57113451a5ed2974992 041d4c185943c2227ee93e5217fd0db35e08236f7843420fb6e3fecca68f6503 b9ba15b95e5649cb255b13ec3ddec9eab28ae9f4379687f5ea13b79ac83c450e b329bfe1d95c0665f8758d090075706eba901f823bcae526b0e92f3c649568c3 e45b3f6c55e6cf16175a1e5c30dd6c6e02522330be5b3a425caa93a513cc5b3f f354590bda908155c6ce17cef217215498cccc3a0a0c51bade03d856da9578b6 8c67d1f0c1daa1851ffbdeffbae116eeb264d0a8c50653c2507408a73371d748 b3ff1c6a55dc8efc678cef10a94bcebba3824a683a99b4d6838bb3d6f4abc6bb 3c6d298c0c336df77fb8034ebfed15333a6df830324262237c6a4d544f8ec6d1 47ee704a2a39e2f050cfb769b737f547a08ee4c48905e6d5d8d2b0520b402997 c89b5b038d4ac10784290e44c68343a8d5fe3d2a0f4c23f298c02ff8a2fad06a 9cad252ff2231e116722fa489dd3605d87f7cccd4f63c820ac99a0d222ac0771 7bbce1c05b8360adb8bc4dfe8111f698025ebb4a6201039e6a48ae098ca9212b d9bded4fac1568a9d3d797661dc239d68f69f2727e5438bb5a7055855ad7c6fd 8d2f8761042d46339c39d9f2e75e1453bdfcef76828acea67ec9cb80da43496e 7039e11ac2c3cc7460c18abe50f01ecf32489ccefbd91ff2feb6a7c4629576fb dad06ce16f92b2210bfd38b21ad3cb0c763e56011a439c1537ba4b2bf6e7465c 8d611ffd1e3c4fee7f2e1fd8a2a41b38b8eb9fc652bf2a24ee6568c047311628 eda96b6d0eef0166db6173ed6123276796c42105611b8a78a74c7b7078e529f0 d81f2de6a6aa1a69be557f27cc68824ae7a093cafc5c29ee741c4a2b82dc0a38 6c3a9c0faefd76834f1820264254591b76efd7938df8bcb2195c57fc469708f4 d11e4ccd489505938a91e45740ff2b64fdefe4d4550d1c7feb0130ca58ae9269 ecce5856c3e7da77a05f486e96d1ca9306581ff667d34f71c074e0263cfba251 ad4e270ba272f8472bacd4eada0e0b7bc825509d38950950f013febbe1c00340 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 false +check_ring_signature b2f24ad96c026b26acba73487e926327347f2c71a4e747fc6b14d7b71f36aaaa e103fb226169b0a9a685af2c4d2433856617dd431693f51cb4b9622ae36bfe46 1 08c02196024efba6e67aeb8aa9e43856c68051ae5dbf005b59d16d8f96e3384f 1d1e31507e78df39ea6d8e97d729ec51939418a3440f0c03f859a2c26b85f40ad70e09e1431063436c3521af322ff7b23f4db214349076ccbe9fcdcd16e25308 true +check_ring_signature 35c23285c118f596f6a9d051136a637ed28ec94c82fb6a910e19292e5e84f63b acecd555272ca35dc206313562539ca30f4ac1e1271a9deb8dca8dd889787c53 1 acc1e1c9288ff97fc3bd379ca588dc12a058c303ae8706fe544ac293a10426cc 3f338444bd1ee49ee134dd9caec59011904a8b47c72d8c8674af097b4e0a850dc1d236948bac759269d710a10db7416cdb350b37e0ff54f144e1b04e7da70804 false +check_ring_signature 751d593c306818616dbc62fa0bae9e82d8f773f426bfe65b21ab7f54e14a6205 a7772c912707e772f16fe56cbe92f70de613db8243df81adaf36749a83a54235 1 95abbf5d696dcff836e7f217d253b9cc71880c2e4a18f01c66facc288cdc3de7 1e8438aa20f4a3fe4164ea016d535f2a181b1a2d1249e8d7c4af33434f144606f705b942dbf7b470319367e9ac71246522c076965e2b2b277bc2e39fbc8a060a false +check_ring_signature b7b62534ddb996f462247d36c91873405c64bc3f5f264bc7e81cd2c01fbe4031 394e98ecafc817dc1cf2611d81c2d9722780a0a865781b8a768e6ee600b3f3a9 9 914800e2200c42c637b44a83409918e3e25e8ac30fde8b9373ef05ba3c4590c5 84112dac3d135ae2e83431e64654a6ada5ba81451075f5c675090e2ebb990947 055aa3b854b4c2838f1a9e11f3ad6da3bd2e7112c956c9c8191b540efc1148e5 d61c68f0853122d4f3a0d84c01798eb5ac1b6c0dd44f1fa92dd6ae0453a4e47d c12dadb97754764785b64582a81fec700f311fa97eba6865c167f529fd63e8e5 d6c2364a31971b667ac68dbb5d9cb77c47186457242795903561f7d13669ca0d 14c446693a62c51378486e83acfe85791fadb8029b8e62bfe065ea99da51e026 df707143f3c899f6c51dc51fb41f9ae8276540bff724e4448d4c226d7f356bff 2cdf940f615ba6fe37f9da13e096b1581483db7a6a4094aa2b5c9567fedf69cb a33e093d98cad1c68d359680fb6e54e4bf47155fc5028c107902a1213b21610160e1d22f5f24333ed2b6a4b40b09f37b55175bf23821a89a2eb79a8d7498db079488788ca555540f8cbc4b1252840eb4c63f4d9221e400c8242da81cbbfb5c0a53e5f9a181ab3321b243db367fbef755a490d191ec73a9d0c4e9ebe6dbe22803f7b1d5e07734150cbb46197d9600ce7130c04e56bcb70e7730e2575148047705cbdad307804eda156c91f9a3d7f4b8a18b309f4abe2d09281b4d735294348e0f73b1bdf21297bbff7120e7044ee91f68751edb0dbdfcc7fccc6d70f028231a02767fc19ce3a9f44985b34d7f5fa98c8025d0b93de9f35cd9b61e429c85e72807c1ccb12add73c3986e503a08b4c9ca9ac9ec720616a595f3de4143bb1336fe0508c00f2d53d7c58180db24cee6cdbc9397bc47c4e0895abeb4d0ee77be7fc1036ea1b8e6de7b79449ad2898582891e7bcbf10c5c4a61277a82ef540c2b362d0cd828682627112b5fe5047212a7a3585824721cba5ac587a3d46d52879406550bc36831c161613d514ec278264323eeeb9c23693a32ebd2ce0f2731ca55775a0e53ad3a9b27b57e423af973a4772e1f11dfb38a613433c5076c07bfd2d7ee5a0f14f7282165cc1c45aca15491e91a155519be20dd80aef0708046ac9c472cd40268595b18b9f0071351829d7ce8e21937e4ddca1d16fd405f7b75d3a0d2b968033af946750fdf75da59f7e56a222759509d92f1c874ca85545a3fbe55a2329100290f98beb57d96814d64337636ab9ecaf09ee3a91c8dcfe783ba9cb675698707 true +check_ring_signature d9d3ea56e7085eb5aae480d7d4ed10a90c8b9f8d6d29b59fca05d36184f13a15 350e37458e6877fec8215379cd03da7afea19f450f7f3323a6d5e6ae94e60cc7 15 72d138f1ce587c64b85163d5ef917b9248eee7e01dd8593357b2df105e475ca3 97fa5080d95ae1dcc4ff26f87c59008635f24295feb89a4d945d045f6fc4b4c5 5643385f601316e4125dd38c31ebe1040e06da77380a6bc6e59ff04e29e95e1f 246a14f78c9e63dacda1597dff02d64e9e62b86a54672301daa180677c27ee72 84ec89b0fd9fb3f109209e8264f60e11fb2ba57f6b4ca4871ff241794d7805a2 8f7ccf3c9e5977d1b0400ed5980d523252e7c404ffdee1ae0ea817db427e97bc 3ce13485aed3c7393c57a2fd263f486c4222e78ae5848c16ac831b2516d4103b 00637395d5ee9d527b6c23cebeea7a33d792849b39d201f1eeb19b58bde33fbf b2f3037dd89babd02ef2d13b1a896b7bc5abdc281f02af7de8b8cfc52123224c 4cd97d4703033f763dc87b25b0de656770225818fbbc47c5a3a438dee8dcdd4f 3ade2506a99421896fbc8de3ec4ce47b9e4cd75f65ea74f5b69fca3e054f1a3f 41684706772035465f8a3bd62f358ac50d545931a8692e3a275d7ed6d21d5761 ccc747b7d30e5125f464844badd17b65343eb4490c17350887b7cf7bcead9137 b9d496e63c8868662b29829dc00ee314c42456b2b8fdbf44c08d63c25d5a476c f66a11415fcd3b0dae5b984beee3e9dc1494ff19b49db9fe78bb2d0cede00fa6 0d0a5a9d48c6a187cf18678a8f79454994cc424efc8039612f30583bcdb6a2056ca34b7ab2589e521a3194f77edd44e448f083a3570f679062893fbbf18452067721934ca8dbf617ff4245bd15086f5b5b8b5139a70c6cc881fdf390e280460a772bdfa6eeb4aa27fbb53401e04ba38dff3bc55d9c61b0e1ade0d02708d1c402b3ff0aeda56466d69ccf971b1e0553374f3d61c541c22c98ded43ece7b15af074b139e7f7921483fcee4bea1957f61434d4025707802d957846d7413b3308508a89a60283527cf6ee520d96153508ed84507c6eaa45b6e0c942508c1067c1506eff0e21afafa724e263b63341247c18c6b6c2ecaddef090f3828cc83fc0cc10457a9463ced0a2a818be85ce4cd46435b312fa82e421c45ab53c15d2657e6c70cf56f8e50e40e20aa209e67e3c559cdaacb2783d4cd718500f1652f1473c2160472c6e612b0c79106d5f4262b81178a714f6a45636d592ad2adc2b3dc9d16b60b4a2aac36243f95128e5d30c47a4e42f868208f33427a9cf2457015763f4e040909d9e4123b9708899c919600dca0962800ebe9e63a2c1237ad3910fd574c2a06dfd8a8767aaf9ebf1816097bf5e6ecc6ed12d4b8912712ef9b671d2205d4bb07372878561128890b00edbb35047cd2d9fbf236152cca1918913d946a4a570001211c2d38d1f9dbc2ff97892b9388ce9de130d512c1b97eb4fbba5b51ee99f00a4bc58791c70ac3e608d0961ff18dce28d2dc7c3d8f02b71fde4406cd6395bc02efcfd7df42983ba262c1a0fdd8090c7fb2f507d8de1913395c753ac2a2cb4e055143270b306f386900b08b1b550640944152ad27c9a8fd203c4c8ab7e5e91106b8c75b5276919eba21f74f75913d7076839802c53235aa674e3840afea8f7603c7beafe5f3ccd3219aaa2358d6534d3c51c6d4783c869b34e688d0809deb050b2ecaf456e4f2e209a71c99747e5742d1f4e2cbceb338f22b213836e31ad89100cf50c3ed43ed53eff946254510c3a1c05264c5a631268b9c8441577455792900a46b10e825d8922ae3b544d62a01f1b08f347fbe4af76c13af416b9cc4082301b7c2acb511f2172ffcffdf823264a7052d296333907b9447d201220223c04b05bd12933390f96d98e0269a899e8bb5610be20fe95850e7c04a182dc08e765308c5f6c54b5b988222dcec20aae5881f5fc17c174e07071ef9bf33f3e90e3f8900c4e360dd52c0ea1cd1ad6e5dc8ed3ab2e66e6c05926bcb07a08fa7e304880a0fcba31495576524aeee0082949c1c9651643bcbee5d6ed74dae6f5ab422e80d05a4cd6acd375c84a65b0fbde583d280e45cba0c50e390c96d7f2e2226b1a42708 true +check_ring_signature a4ff57efbec08d022e4167fa4245509da3eaf6d245d36b52c710ef88adc9f171 c8f6a5fe6e03d71134fdeafc5b0afd9dc42078968531118b79e113b85964b0ae 1 7cf9408e2c22855fcd4a06d5e48e2370550ba11fd2024adb016f6008069bb64c 0478cf751694133a96b2aceb15d0d7069078e372148f1c10b43378779b50fb0a002e9617655865434d54dae53e348db75559bd38091c338cdbc94567868c3000 true +check_ring_signature 097f7ed37df34c83b3d11e1cc7271bfea0eb2726432115b5400bc329a4db1228 b4abf921aed94913e18bcc27baa08a8420896858de4901058ac929b1171b3b05 4 58004f281f5b96ba21a0a3406bc4b9f03ecfc7529a9aeb33659d38b50910f4e8 76e0915e5aeb013b5f25130ebc434428eb7a0f4c9810d823577e700ec44d3e1f 3e2b9c7296eff4add870826f27fbecc0c891b4cd760944a0ca1f986ebd508d05 e06bd7a644197a106a418838e7028bd055d27669b4f9bd614ce1302086e741e9 f715b921bd2f793a70402acf356b1493c26dfce0c5fa82f531e831ff2678ea027b45a6936031ef7691c3c741e917d6999d5f1758f13fa55f3ec6cebba86942024200599754083b0889a3d8a9839472adec5dba2882fe6778c52b02a670564407851bc3de3994e13462572cf1f59b14ad893c6538b13ba597ffe099c1e4f9bc0603ffd035d3dd7574a1095f0678c3d416ab75a28f133f050aab2495891b0cf80475ba0ee15a39eda141d7f50670b58b93e3c9ae89b2dc05f8cd233143a6cd3203fb68b3f8c309d0cd841a38bce3bc5e0df30eb980e83aa4a4cee229f21b688d044194e1773f977c02ac53fd058730b2263468e10501c179bc1ead43d759fb3b02 false +check_ring_signature c8e125a2803015a0ec54f43d24127dc9138f64f7750b84d7555694bc6af3b59b a07f119b4c6790d6d619b2b2a6d3256eb0569bf9fcc086041695c45eef923af9 15 d790dfa0066405d5c64cbd00534741d9d6b2ef7be6762939b1cec92f7838e509 37c302f8d5bd9e1ff5ce9228159ef51cca7a7d5e141563e53bd9262210aa31c2 9bd435f8c89460f097bb35822a31190f8984657be1bf9edb3ee4836718da272f e548f0cf629d269e8c49c3a80010255de58bc8a12ba645dcf5b842b5640c7695 af8e08152e5a25a7ec6e4de5d01c7b781add77123eec67a88181959f919ae473 09370acf9fafda6d2c7820bcc7940d915e20d6b5844e41a0a38485af8150f6df 86722b839c1e4061594d87bb928c5af561a624045d3ffb807535e1dfa010bcb7 ad24c1a8c2a6576daa033082e9f5c0dc17ee50e8f124bb12aecc7f0e19ba37be 93ff392ce51c2cbcead618247b2b0a69f95dd93ebebbfb12bd98d73875d1c7b5 de5c854856ed021b46bda58cc54ae89c99e4e98a130c77c9df7ef784b76105b2 a22a01b682cba5e28f40ddfcaf2c36e4c3291640b2968c176d54da000681d990 cd66256d1fd4af41160b129350b09dbf6978691352e212f3e122634e5e99e355 4da8786c152dc6e7e01ea81f2f7595f4c56cdceb483c28d2b489c8b3c6cd21a5 3d5b930d797cf6bbec3014f769677ebf7e2476794db3a9e618f9020be1acfb09 019c6e93ca0560dcc0c0e03dc87a4cc3416bf0071ee0512dd697c928dea12732 1e88dddfbaa9c1d3b31e1ebfcb41baf90d793eb6df707c14eb5aa788791f0808dade2b288575deb7a87fc8fad42a588c143ae612155ac209c942d6c3c7a9920d40293f9babe5a66580a0c661111cfeff4cdd325b91d19eb3277e3234f07b2702fa6fded2a53ef06a75e8255aeda94f0349c7591109120fd6bcd405a0608bdf0e0126e4073f148d4c3d1e720241a2cff81310f852f342f19ac2e827ac5f00430868ab59353adfb050c29c05175514b744c00f3a2c479bf3bfb9ca41a9202ff507e821b7d7b29cb187fdfbb66b4c9001d2f29d62f79e7dd966865bc10ebcaff60ea7d29cab5f583a9a643e2d8873566e41cda922a8b9d02848ac554636d67af60920479ccd2928c86517b9f83e0c99ad4ad7f94118301491923a6ec91b13586c06741a69eddac2c0ee44e2ca20815bf47f8e415dfccef1883bbe19782bb3cb470b907146323f7eb45ea7a97462d95812150e56f31b9a0566387e7f1e7a7f59540ae022790516ac84183fe28dd311abfa4f1b5149ed12037f3dab7db7d3a282640a89d63f3b9553e76427922915c6a4967cdafb201de25258c6965b5acffc6f110151f861310b8fa7934789913fdca266447899ba7e5edca65d713764b453672806e6777194da9ac6af35b266ec8ef5076eb8826cd98271d8c637ee83d78fbf9c0fc651aa3c18b2a2950322d52933a71335d5409ef92a91d2f255759da1ccb9140eb604fd260b81e42668a8f0ef9c7dc6214571e2764ac7e11cf80e56a80d88bc05e5155c69b8491595e59de6435c734ba15d994311ec68d892e20bf759b59e7f0d4ac7c2fb9ef07cc849f0d7d83795658861a88852b27aa81455996b393158db0b6e184981f2d032970ed046c41de8855926787176d8e615682c3e9b287369950284040157c3c3ffaf34f65eb22df4b989e4b3fd2272a6a70316dee7a02507bb0097f5dc070ff05311a4507b10c72ded8069813f82512b68c85b11a352c3a9f10097107e2219febf83facc6854f464422488289c1d7b2c6e36c4b1d6832bc08b0dd555b1ed2c8200d5c02d04afb6b74d2829aa1c8034ec8a00556439f3bc7291b74e2a54f321d36fe412ab5b2e7c302385165d2407f2425b769e4e38d165f11d044d121c8a432b0e12bdc5c66265ff758564a15c6e945099610abcec7002509d02db644a74d8859c83d9e2d49f744b760f62a906ca4509159927fd81e2f51a9c055f7c9d2f83e05f89b38628ddcc20086573bb4875ed8094d1bf3c1f19bda84f02e0bd89176c8a177a5b7d4309bd7dfda0f527c63d3043471fc2d5165076942404aea89d530af16b210d49204c8ae1ab692b9976dc0a01a58601703198f5a5ce07 false +check_ring_signature c2026f2cf6d83ab34ff49b50704446e307cdbd0bba26ce77589fa597c75317c0 54f9c165bb53aaf198672bd4bfe1df319678e4583cc3a448b06ddbf424007a99 159 b208445a1de1894f94f09d7e0d5adf8b41c708caffdef1489630f465d8a39650 7c2b57c744e94a6961b7a8cb1f5ba3e02dc0c22a50e4a6767cc39403a2b70f75 8bc05d4ac4b1b5640085dbf9b157d61b40455603395936c9b32904b4102d949e f8f06b64e38d574ec8d78fff766606d145ba16a7aa6c39dd24f83507e38beabf 371025bf0304306132cb507e13b8c8a39e8960c2842f66cbf6a8dac2ecc45c93 87a1df7e107bea5448af05a5e436ed84543265dc8e2a6f3d8484954c9ac7565b 14b81ec06a00058566aab0903690ef94ceb086812d58805b4f606e9481c1d51f 49297bc2b83e1d7de220c7e13317a7d42e5d130120bab8bc037f7f13d30178e1 3ac866e6cd66bccd829f0483670e43d4d80b9638c0577064460648be84b15b3f f233b0053460eb824086d730d77005c4e2c08488fbba510e338183cf72537e5a 9992b7c3086230fc74ca35e901842a81f98afa2a1bc83d006d271945eff61c9c 79d3afef80ffe4a8d17590109d4b795cadee3ab1c52bfce42ca598706bef0a08 2dda3aaaa3e2bda7af3cfa262c8ee949b9eb046e39304ceff1ec0d5f81b3356d 55d52539860885b0a40cef360d35bcb8e646d6458ea0e0e89d1f1c2ab20ffac5 84917723c86e612ae0667dce3e22cbeb8b6fb56e02f0e32de668c58adad2cc54 15e33900665f9bdf03e5c5d9a9429e2d90e6abab254acd302fa141f4da5c4fcf d5a99aac6d8736d131f81a9c160445d090d630e1f3a25a1b397a84ea1a66ad05 38e979654824dd1af302a6fe98463bb127837a8029dcf1613041c5c526efead1 22418653c52aa045162f43a028b263f3ddfc99499ecd9addfa6d8516f8cbfd17 0a0d841c01aa095ea07faaecf24d50f34b59ae4050695e6cc198111a57c5839f f503ceb9a2c671a25f80a41d37440e33f7f2b3319b8b64412aa2d00551ae4373 39fbcc8487f141948ce537b454b6711e5ea22cda89c874f6e007dc85c175df8d bc80d8a475a862f48aabcabb807ffe3c28982e105995c2115958ccf1c76d71e6 b56c85f66559eae18ee3af30185b387e34971267842d35f11b7700a6dfb9b796 448dd3a88dceba1f8dfc1b03f168a2d54f819fff12c31f7c1cf6ac75e93c03ad 2b342dac7296df856513252d484497c9950f14c8161cfb625de02b1fcd0537fe 186bf4075dc04b128206b2785783f5c70e378e944177dece256f7cf5b930b161 2cc33a51fd3c6a981b0214a65fd0f161a65fe07a5cfc596b26b527d70776c874 0c885cee2313a6a17cca237371843064afe5ce70e6a719a46a602a9732f03330 77fdd331d431e2362fe2e725d473072cd1392cd3dd738d6bc5adbd1791788679 6018c510ae50c364f2c636cbbaa34cb13cf265bddf2d650011dedf98f7ec91ba 763953c92409c2af4e51b34b9bda6bdc23572e927f9e8345524b503d33454667 2024fa519a15dd1bd911b8ad6626192b4d7edcc1522dcae05fb8cfe65d6a7ac0 adf740f85004e4b3b13a38facbe22673dad9284aeedd8251b4513a77b10f97bf 4976d92b9ca2251d5bd3d88c7fa0776df8c22c5b165dfb35034df65eb60964dc b301e6e26e79e54f903c17d4ac5a2fe5cccee4152c64fbec5f76e9b7bda7241b 0854a2961b00dd31d0a6c2b2c525fdf3a7a60df4b0d183de23cb42c62b01b7b8 7964c007e946bd205db088b2c7388a56bb116607757c7e17cb2d48bd69032ab1 ba3bb4fe2213f1de956e2ac4ffa2aec483f39a5f19bf72a95e21768d3bbb71be 42d46ecbe76a0e4b16bf0e75aab91ad4719fc88a2a606b417a7d707c67d3f70f c0983224a0dba911c02c6a359e7af4ad983508737db43a2bedf39173170d36f2 c6ea7a1d219c492445d020ebf8ec198b4fb3fc05ecd0e43502c437f7e2a84d76 7c2096534bf97e75a6b7885458b7abf8b3957f101817b057873972728b0c763a 01c01099ebb5f6b7edee71f5425b50b571e8bf4a20674838fb8cec4f94cefc8a 17aaaf04a5eb3139316fdeb66a3f07b8b1c44cb323ed60b046159b8355cb9422 ffae97d5c86c91a6b716e088a1c4ae18649e97cf73ae2d0fc10dc725beac0d87 1a942e643d845a540497605ce28b7b3b2b0c8d4dabd38cc1da71f4c553d34fdc 628697f62de142d13606c6a66b8c4a5806324a5f817aa5886a3d890f55ae2b68 4b295cff0bf9e8f306e70fac79a5686e35b8ccf78a832df81e12b33bd8ee1cae 127d5bd0604912cc3457e3541b677a13199e0a587d79f8e07118c889c350db8f 87648199d6f9448e56a5c79ce7caf9c4fc9af8aae7d7d0c4d6cb58c85babb52d 770c9dd55dae262edd1bbf5378bcc262bc35f775f6b025bac4a97c0cde498028 a7936493c9da6288a0578cb64e3436fbf5553fd9a80708b701212a4cc2507352 5f1e10a2a441d44a9cd7fe2f907b82e276471ef6fd03af7a552fc67ebdfe9ca5 72969fec58ce915bbbb5713e92afb130137549a24514d765a97befcf3fde284e f6eab8ba461805a2cdfa3bcc0329f8833d1d997e733d829eb4fbe2b5a296b58c 72e2435d82d1ef9c329eb68e3d6331dc0b5d2edad747d57826231309dbfbf11a 87f413baeb34869ef7284f520853a02ad22a947900fbc5c4fc8ae528bf67868c 9fdf7456cf670a43642a0263e70ad3ecbca668ef9ef0f0f6ea23961410504a00 f44fbae50bf3f996c51f1cb32b565b66f5fe24d6823d6457c47967ce8bd8517c 194ae1c0dd025f7d672260e9cb59bccd779dc785a55cf98e92df33e53ddb623c e0b76e41f13551bfd158c7e99bcb1330042943a032c8caafc48c0473fa763ab7 cbdd95f9c577ea1cd8129151006a6e7b973464e9d8e05c06498434f784d07255 01c0fa2d6f68a3df93c9e4d4cf1c830a90108078c9741d04d44b8d2c0aac7b87 d104fcbcd129bc8a1194ccf87089c55f7685d79cfa06d1c3b5108f7d1b6d3957 51447feb03c02ada28d7e1009b781a5eacf659200974966f452f7156c8218867 f45b97416ca684d0e0d3c621a651c7ed5309c6b25cb50b5a054def1a6521b244 774df97d8dd0289896b2fad2c9c6dd0955cb0300ab528d8b9a9848eaf82e3079 e20cfbed4971276359b6f175e787665ac8171adcb9c268dd264253c043b9ef75 4519ea31675f888db6e9a1353b4d7aa49b8739c4d1b64f9114ec505eccc8fd51 a5114078f8d81aaee75dd98247600e3c9143a5b1d79fbafc7943ac5f568162fe d0ff873c399e22b5de7f7050c992f58a4fc7ec8f2fa233b64054845e9aa3df0b 6c35762ecff7ca098a78bbc26af0f06638163bf1a783017e1c2f97ddc21d33d6 99507f2b2a285eb5a110b4075682bfaad48789533a16583a1400fe8cd4e49238 8cbdd0750799cafc52972553dee7550e98e129b3fb05fb66854518ce2ae74e5d 011ef6162c15d4067307c738a1dd506c2c1e946a1d3a19ec9a853a858f9241e5 ae1fb0bb370982ed52033a98b7b5a1197eaa32f2de4dd16bdf0aeeb707e37856 9094af6e79dc37192790cfa85716ac6bafe1cb3daf459a5068a31a3a4c7a032b fb86480d8cf841dc1079ae02bf473c2d3c115422db77d1a322eccf4b4384d40b 780ebfd85a51db47ffb682297b38723c1c38fd4858f3d624d896106f05219dfd 195d0abd8174b7ed8ed2691834e82fb3382062b580020c9247399f14aab6fcad 5c15f70db83afe5e810fd7bc1855f402ec3b5add5bdd8fc01be2a2d4b3b4040e d443022fd837bd001f3dfa8ebd88af362bd290bd81782d0de0836d0079369dcd 0d29dbcad4ad15a0b0cbfbe947eb94e11386ff652194fb0ef1f3197588f29536 db172dc50ac9d130f44485b1e62c332f455b3450b7f8532a8d57a7a03936520c a70edecab88f6f020f2a8405aa362cc3860378d4223f8440113199a91a45a92d bf5dca10692fff5b738efa660a367404539f5b78a8d2d47ed81e241d2ea09fe7 1967783a950f676d62a3f1798f80eeaaeb04eb6a1655ffb37ee806ebc1d5a4d7 74166777cd2926431521df77f4d1cd0c02596784dc0f364f7ba313408acf5f55 cd17136683c976829030907622c977f175a2127f1922afed3b23e7e3fcaa3e5e 482cefb5fee0ed7f13e6227d70deede6e9d3dacd7a459badac46dfe1873c7eb4 6c9220ebadb02115a413c523cfa6b3ec5d9d7c2f3ea555aa247b0e8b5572cfc1 3093e21f459e6f8d974e0a8829aa2daf82ab1f8192990af57916a502ba2aa9a4 ff498b8bdfdcb51e4a9a6670d0594fe95dcc9002264553f9f6cfdd3dea2f4b3f 1466582785a4da5bbfd178a3fd930b33f355de2f9eb37fa83a56e50066a187f4 e3a8735b29c5fd2391e153e248fa586750d4e5ae3b12639befc5434ba79328b6 18a092285b90e421a139007bbfffcecbbb57234244b7c6e09c2da24f2ac95a46 fcdf65b015e67cbd5600b70d62da6829d919335862f54a367a947abba7a53a0f da30b43b48dcfc6aa0b35c322cad21e7dcb800071bdfb04cc179a279c3949713 4854da389f38496cc0f6194eeb8bd167b79600508ab704e8c749fa143e31d6f4 09e055e7a06868ee38720f7f814db87069d75f4afea4be78491f9069aaa9fcd9 b614e29e0aa8c41db7ca458df1a9fddaefc1c5df81aad8af97e8b8f1cc41386c 26e856b9050557a5dfd1ec2b251c78a2468008908d1fa1af21e951067c012d7c 61605333e975068a2884ff562d9deb46d6fd2baeda1b67f48f73060733496cb0 d9ef9458041193e8cadf2ebec55771951ea12c669d7dd54ec3bbe4424d8ad2ac 0610b03486c2ab1ba4d7795e6694995a2f3416921fbdc0be1e6f86ae0dfd0515 d747dfcd3c39fd20aa5523a0295007075fca7d9d293dfd1bbe913899e8bf170f 5f1f0729c682b35fc19c97d7062ae5e2acd5b5b4b6bcb58b6b86a31c44ee68a8 d08e2e74920d0aca41fe2b5b9bba639f62b98a064d10b867764a8115afbfd5c0 69680ea431989a87ea87dc3a90b6c8f287de8fb23318e4876136fa94a309adbc a53404826194f06da4a87b6b5b10abfa3ba79a28178178d8a922ab43c376da54 8d540325f9ae45ae9f522bccdc8412ed7ab24da2bd5c1dfdbf71e68a04fd8183 a7c71bd10ab2cb4cb17042db48671fef6fdc9ba6c63f673c3cc0244b4fac63d7 b6760ef922db86836db2a6865ace603e9a980d090941eb0f71eb96f5da7201b2 3c3fb05d3daf2519d4ee4d263a8de7c1c8af4d4818f9a72000fa1fc2be7196c3 6f0ee81964796be9ce8e403214dd4885d82b2f70f46307dac84e7452b8b5c3e5 9d9b89197f9613bdf847e536205666d5798cb15084e8c796ada2598ea6e162a8 72c949ca75a836d88c7c562e9b1b7269d709074077a570ee22bdbf31eabe151f 7d08e3435a79448cb63cc5d557184b8c4683f66a517df4a6c736fc0fc310f6bf a3ed4608d600f6e3db7472239ee3ef7efb8ced352028963a9bab730b8f773624 53f538a3fd3fe1a0fea67ed241836c9f80b61edc6c29b2fdeecfb26cc0ee0695 ab045c013ee9aebc579ac27965b9acbd3c1eb44d11f0dc64ff295d055753155e 1f6a41e55a3381e49e4fad505ef57dd133545e1051bb503435a599dedfbf5e7f 63562b54d6dcd7e549fd9d76e5b13aca368a4ff1349ce663e588535809f14250 94678b1de55c39238dc5ccf08b40f42cdaaf3d60fd6001d32eda98a92fc410d7 5f1273ca58604d06ebb827a157746575c7817eae146cefd94afc796b01b66c6b 243fffe48b3fbc8db2951f2ccdb37a2fb26224e3d8ef9eaf2aeff16df4a5866c ca15c538d451042ed33d772e28dc039e691f479a203a49539c65876167a9388b 4fa32f7876ca3383b8d13052feea7d15ad7ed67f3ddf51b79bee0c942ee38b26 2a7dddc4a77b0696418124f0b99430acdfccbd09a34e448f7cbf8e6413bf62fd bf7553dc4a20a6232f22f860c19eb74add5928523e45049318c55a40d95701c9 173399ad9236e5e4a92b1aacf494a9af7d658f31005107452d5ff5d61b26db0d d7ac9517d617dd6e836e8a53f5202f696f41f864e2d86878455bf6f3d8074431 6eb42682ba1d2f7b40c6b9496b1c447d7b3a7f49f616e1a4358c1acaf5c8bfb0 035bc9bc738c7875da9fbeb350d62421c01decc36aacf21fceb4c95abb116fec 64c0c34ce0060d2863f4b53765f808a2460c0559b69f9aa537d85c7fad97dd2d 6365c0a57470492f75093315cb46555bd3fa4df89fc0dc8459f818086da31252 d3b1e78d8488918682b6174a05eddc818df4bb5be87a2d63e50327bdb585f87b 3ad41c04d0d722774e791e9d694029d707d7be8f06109018cbfea8d05b686032 d374c5b1f4315e92c61389112efc6814a30b3d9340864b78789d411c5c4d9e0b 47479ad5267ad4657d551e6af80748528d490ab7a04d6aa15de41b520e65dc3f dcbc7c6d5c0c1d4e6f87e37748151629e58ef8a9dfbd13cfefb6c7fc8cef6574 0a42002eee4c5502961f6f112ecbc0c31742b93b8f8fd2311121ecdd424ce496 6d7a42dcae69452727a2791122d5ca011c96248f09d18da70681ab750873d838 da71fca55ff83f108a1955039af6a22d0dc9a4283ec6a6ee22bec91f07456408 80fc4514ba6ea17b86005fd550f73ec0c83a28b1bed5e9b31de053ee1e0ec314 9ffb95010591d3dce6f6a5bb50c5efd1f67086cd6af972700444fed3e3bde9cd 6c722cd0051d4e2946d349980de1f492fb3cfbaa3a305055eceafb4ae1a2e20c ce5a16bbf2dbf526b764729267fa0e2bd8b7d4fd2ff1dd52f5c6b7c4b41bac7d 12ba67dd3de09fd1daabd11f0031201a7b0a2d4202977c9c07abcae7c83c7010 b34a30f8b000a68b32d1da29ed85977eaa23cecfd422c671a0f4754cdadb7863 940f627dc218737630dc51e436dea7c871f1dcac4c15b0a093c011102e0c0c16 21b56f40da8b7cbe69ddf1f6576bb9f87bf9b1ff64a3a4c2278ff1e9e557ee5f d5202b5a55541083bf7ea2a4670206f3d9776039e94aaeafb05a3e4164ff313d 99f3a29d0aa324f346fa76dc14aa5afa73491b1a27f4015696def6e3c45c4cb7 209e899e71b13fcdc294a4f3e0ac9b6ed24c2abde5d8fcb2b10937dcabf8d66d e3f7dec0ecdd2aac89e0cd4af951b1cbe9b0d31051d67731dca2d903bc1e5ab3 8bdd24cc79f40d88c85287d94bc3f47aaaaf7ae3e5e9a8db980771310353634d 3d663d6e4c114d16d88278b49cf236db00d81538e0788ab74cf57a9c196832f5 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 false +check_ring_signature 6d57effcf00feadfa3835b1ae9897312646e50b0c78e83fd915fdbf14c0348c9 9a1bf2443bd6fdc2468c50c9d5ca3d6719252db550f3585fbe4eda20f5800fa5 22 64d5280c45d12b1aa1e153839fd1e269dac6bd86e2df96cbfbd05234767741c5 2c991ac86d400bf9b39d4c54f5066683172a4df02f06d7e61037cd5289a0ccc2 3b0537296f38f058d39f939d6a4716ff7c7b11adbdf5722c9b394df63110a867 8e651b6b171723bfd5e065c413531d0ef01975c9968f788e6e4523a7eacc5afe fb75dc1b08ca88d9292bbfe7109c0bb3dc80a49ec63e9b224257ea1db09c90a1 4066d99aa2a29eb51fe56b486bd3cb2a3fadf386af9e1a894e7e2a8bfb85ecd3 cab92653c0461f5b09f001f0717307ec23fb9e270570bb047bc3809ab0aa8b87 78588e289cc2192cc018f2f6b518e0a77dce7e0f77ae19b6b78d6c77b5790873 9996e738f3f92769d369025d246c3cb06ef20c01019be184922d263c87aca7bc 502a33d204b5d5537459b69a249ef1679c687a066e3e3fb1442121ff3f6f78f1 72f5dc2bd6908d046aaf2338f73d8c830c6023918fb00f19500f5ce5dbf4c778 fd4589cf4a12070eb2c2f056d97caf39d9816a70bb0b42a2b5c120e1c2a2498b df4618a7f628c0c1d6add473401619ee98578d232e612389e9418479eb98c05a 58b613430ff8808cb77e48f697620a649b418d241db3bdffa3d92a919cd5df4f 0caa97c925c32243d36ca46a97e5dea2bddac333b30512721a04e6594d6bc039 79dc18a3e9796c954e4850be9119e7e2cb334bdfa06c8360b760bde6ad27a633 dc6e8ac123aea6e4344138f0cb62ca630695e594a9a2a7d5bc6827679b3a7579 6ed7da5e859bbda5473460d901be1d0d225ab08deac5dacf82f7edf1d1b30ccc b53e4c4d77d6718fc07ade62b6b69e655ac4dacc3dbdd0b94907ed84d7bf7eaa e318c52fc6ee5d734a6a6a050687ff5f70ce1be793f08f57324da6a8ec17545d 614763509c978dd6c081fd39c7232d3d2decbd519edaa362fd5c7f8a16f33c51 212ebfde55b6bcb21bd99babf3dfad826413c044b352305d2c5abf61367e4f86 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 true +check_ring_signature 066e91b031013237423595fa5d24341ba7bf0cc41c39b5034817b15e81b276a1 457ce867da6b9caebbd3a1a29fc54cf712741bfe88c3a89eb76e8ad5203dada4 57 ababeb3522b7c7a42e9c7f8babc7cdc61456e811fec10c20a98e1579553e791d 18292e35123e807d412f5a00dada675a08c7754d30283a98996d8b1d96c44b8b cb7fd5d8f467bd0229ae9d74e6dee1cf2c5b3fbd87e36b38b1e82262a228f0f6 28224ec3d75595e5a82c6aa8fb5eb459dce1b08e13fbf913655f301e4bf56b49 4186464af1c14e9b7b406199b09649c683e137b23b26a167afc63e3dc3a4ecdd bd138fe85b1f0369d1f88b6be5257b5ad8fafed484f9e2ee6f14bef105382d72 4ab6a5a494c97106eb4e0e2820203d8997eb006dd7ad6a5b3fab29ede39ba23c cdbc52a1d35433e8c7703726dde984429eb4d38a6c93055bebb1bcb903b89575 50419f75c5e8c9c2f3104ea8356ccf658679eee06dab0a757c72c0ca66249c82 d700e94319b373adb8885c0063b7c19c4f50ef71f848b25a81ee0ae433c98f21 3e39edcf0c0cb9ee37f04fbe874be36f9ca61d5c4f083ded2f3c779565901cfa c85fb53e1830f83ed893fab71af108d523ed4819f7effa953fabbc0e812b24ac e27c71733d73a53ad3f2657e032a7189e28e96e02295e3d43592b9b364461f70 d4490843a53e2607b0c5e3ea24cc8347d2d84373247724df4a345618a2f2666a c4ad6e588d6a3864cc0ba9421ab570eaea7ead0d4893f37a60e56d21c1a87d93 f87f935fcc9da895345504903d0ec4309bbc627edc33b5a3f954952ac55f54b1 15622ba79b396831a19df4ee18defd935680c66f2f2d6ea5feb837abf5a0a180 4423e1776f45f8dee4589054321eda81feb61a4c1c5a318d409e37c9eee71aa7 c23c69a722749e7c5270031348c0e04787249f3057a8e2fcca4ed2dd574e47c7 5954e93f748d425188f3276879c37a3250fbb507eac1eacbe8892a39187f73d3 a5d0bebd71fe0b4d4c60c6aa7bb1beebe20595aa0171925bc5bd4a3e48751eae 3f4a8b00dc61e7fdba2034b08302449d0e8c2e2be17925f167be59b3b2d1fec8 6478fc4d45e8f4bf441109f8f6d9479786f1d687c91efb21b6f866fe010fa054 ad904b46ab7eb76ba25467091984f44c2a2eccf7b0a6517cb0d9c4b00a9a7b2e 4a67f25380397a18f252368f83ff79494e95ae58a1aeac84979929904e69acd2 bf9123aa3f9fd8f6f56b41dd4be55caf876b08eff463a37c220a5fc0cc028cba 86e6e2bedc7cce0e29caee15f7293f0692398bd55640ef027fa7233e3cc320e7 6a09a5034b5f08e84f0928ceb64f858bdeb90704dff47bf45f037dd9effb8912 107f61437510b9a267d1950ba48e068adb62e1a809e94915fbbb3e12afc3c46f d5f1d68e152a737707d784e7089f1aa66a419c931166b2c6106fa9bed05b4ffb 649b7c708c27a8ebfa0bc498072d14f56d28385b5c1a76bc22107699ff150dd2 163ae901b5d5d46e92ae3c0ac030ad83ffa7532c97105979a728171c63dae7bc 50ee816228a1ec477a6378bd9f58222d87bd4efdc350e48e485497001d38050d ad060850fa6553169e543ae23bed0f12af51d19002a6d254f0eb231b4ea72fac 4f2fd25dfbc1cd09f8a96abeb7f2b96acf1fb8c4dc6cb5a256a77759d4029bb2 77fbc2e41fff112f33b3e9ae0be5c7f6086512bb7f2e3cd5f50b3bb8a52667d5 72c9204f6529b8dd5b13c81b9d2b22869f8e4ddf9e5ad4deec83fcd55a3c185c 86ae221f89c839a025b1e773a332e3a5b8a2356bfd305667b9b47947408efe44 d73eb929f6901661c4e66580e2b162cc55d4e18bd520a9e3135724fb41d22790 0822d55cab8e848d9b3bc63f8d1adfbe7c6065eccd08ac97ea31f2f90c82b0ab 52f25f44677fce815c5e9ae860f9ced6e613cda3568dac755e117d2fd86c4e50 59072ee20d2269b571d0741139c629a9643b2827edd2c96956686de48c344a4b c33f71ed53442c4a0e2eb812c1c45e613dd08c2b601b45519745e1d96095ed93 b6cc32a505908d9fa896bdf2914c4e1693feeb2c519cd306f7ca76996e223888 f7e7d62c9a999ba3afbcc96f07922cc267017d077fc8f29e092e528e076cf7d1 9e202ee7ce7ec20e2f90c5bc24500d250134849903a910659e595532b07d5d73 dedcdc9fc43bbb3119d87c9cdd49f11baa40973c234f58ceae1b5111946863b4 2e51d7a4d4ca130bad2f0df988fe15f11cea9f054a33ef9b22e663f79e4d2da3 b56e141962fb203d51328c3669b1227ca4a65240d7c1d0a59977f70d150019bc 6eea2d753663c492d4c55693f5a999e82b54e210e2d1f46df2dbc0ca129b6904 975ee027b1eadaff57a5055e6d98b9054c494d670aba54106bf13f851a422e51 3f112d1a063c25219132175eb217399fff0befae0fc0fe202e2f1041c2d65685 7f0ac7a83fcbc60701a4c93b583e77831f0276beedc3f2d1f6ab096aff4f4826 097593aac3cd85b02fd7047e4e5265fb5bb1ad109e7411c30e9b46392b93a58c b884ba4a21c9d472752ccceb1ce11c0723ec44a205676c78750e4aaecb9c11ab a234bb8aa5c2cdd04faed745d91660a4c8d702660b557f06adf399776b39e478 e16b707685c867a7d3a84aad186572b537eb02c57ac0ea1b50dd56608b3e308f 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 false +check_ring_signature ec1c13f39c1bfdfc57dbedbee0db9e61c7e9d5b077696eeaef90850d08608ba4 79443c10cb66cd74c26fa0a760bcc9d1861bf67abe5099bc93de5d4ace1678fe 67 1f658bdfa721f80be87c84a9790b66b3beb3b846c5c34854bfaa0bd63cbd2f56 a329bab7acb23a00bcdf32fb3ac4b76b88993fa5df5138fe1fe25749a0d7b068 f990568d9565a66a06c1b22946f86955b88356f84286e4dc0e4d48008e141bd4 b8bf39b5a6cdeebad8a21d7382676db81ebe324abf4b8a9276c5071a0a1e31f4 0ef7d0c9e51e2b102c12129920fee25995e1d741657df92453740b1f5295fe73 f774824762971be797c87b8ad26eb62a12a81d2dc40f1e02447dcb496390cf11 4a0fe84e82576d339c1c0a26870ed2c3714079d45f2fa53e3ef806254fe8754c f2ed1b2a3ebc42a4568ab08c42da4d5e06c7143dddbdc3b37871d7221e620ea1 e534265ee7e4b6fc9625d8122784d5e2d0aba33611cb664eb81032a2983401d0 e67a2b8bd4eb3496eea1b6eb7061e71105e52152900e6d4ca72c7a4eec373d6b 146203d9d7b6b1a3cabdaa0ec4be2d40c3302201830351e0a84604edf1b48c6d 2767e9ff96dedbed6c6acba3492a6678364d4af6da5034a0f5f56f69553c26e3 c92566f5de8eb9a6b91c03d029caed381621fa3ec9c21103a151428ef75ea140 357bccb8f4da1174b5349b589be3f2c25169bc2ed2535abec6ffa32680e5b150 4607b6be2ee8bff1719e317adfe838d828e5a77bcd17b67ade5cdc70d0c1d7ab cb64fcf1cddc1966a711c7cd23e3e5b714c9a5a74e7a7bcc83445be016ef4575 90112d711e1bab98ca16b7f8d80070f5c46032ea2dba519d94024541cbf4f623 d491d94cb6dc4ce0188ca7acfe44231c93046883725348a27327e98b8dce6552 305e43fcc17bc4cc8319395355e7e4790d5cf89fe08ba3aeeed7833149225b01 0922eaa052b9f945b192aa5f6558a9d23bed8c3760d5cd8c59526292fe6dce15 c7e831f0c31b69a8a3fc5077f2701be7271f22054d5553263fb0a515abc5a1ad 2d995896e9b65a35d85d7b82baca0ac462c06cfaa5f511869edc32a939d41f49 27c21865d8470960c6b65f400fd29d7b81f679debe63613de07bf50fa1560078 05d8922c5f508777c403a096c3bc4e4504be14d9f8dff0b56d22f14d52dcd1cf 608c7c67000854ce16933908426bd0f1c207205d911d602c10f981ade7c0d083 60cdef78e8bbeb3c7410d7af3aea68d244b81be83e58683f5fb402b0f80671a3 9aa4f41f73832bbc63edc53e66f63747fcdc9dec2951d68a493fba2b1171a189 6a5a19c57478d2ecbc8050a516d1f34ebdf33427b89ad867cba83e516e7fc015 9b8ecaf1c9489bec3e48c3bf866bb768be21a50c9f3a8b1d96bfa85c60cb2a6b 549c13e435998faa2606151b9d5aba201683d5ca02179a4e665916c7c4fd7f17 38a7745171215295d34f7d15641f822a78471d75e519258378de1c7d27b45c01 b3d28d06fd9ac388c20abbb32912a5e8971e44029e185d7623858403aa5263a8 3bdd0cf53c7647c248b2a5ee978de875548c16471498418f33f86e5cb716e67c 7a86eaafeb5066f131514c646e5f8d58fad87a699b6038c3fbd01b20709519c3 a7aabdeefa18a62afdae2eb6bdad81cdeb52c4914d0ad6e468ea33aff783f423 9b570a6d8c4d3f48dd1033375aca2dd92166db4ae35c6c2c8576be249213169e 00634c4b9c927c2d663e3b2b40c2b8b7ef47ee6702bf2f9ef9d21e8a84d02d2e 111cfea95f9456612943445483cc87e9938be779de8a460b4188f6dd18793bcd 075aa192f79a0283c7d9fba88418617ef742828fcf875a5229fe648871468d61 33164ff7a22aa4df2c06561577f89a31a4aef12b27a044f261887e5e97f5c073 8ff2d09ea35fd1f80f5ba8875b344a1991bfaa372ce31203dea4a82dd348098d 261f09d370df0c107089ca88d76ab13cbc1762d85013b8599a3e669b4758d95a f57dc4867238e9bd9200cded08fa4d3346ef9d7884584b556c274a2a95572fef 05bbc6d500913edb491cfb5035c4393bc0f1eac11d278322aec3117785d6ced7 8772290b2ceeefa72e9f39664c87ceac82139ddd7e59cd444af9ccf2e4bbd584 e2dea1dbc2fd0a16d89f393c966ff652444bae2020f2b4cf853914078b730245 354343cb46363f8d8ccc6d274dab10ec143dd54f477a0da2fe23756601415e60 5e8d91fcba76e10f9e6ac134b47567d70b71d9b07bfc6644031bb11d5c0a7fc7 ed301799e433a2db0800344dfabb38813c38c3f567c7195cd6e9ef043925eebd e073d8ada144a5e0eda4e2a34f120c99435f264990cb9203dca673c546fd520b 5fb554b8166d6476e9e92ea7e9fc8a206b638d2ca1115faed8073a7eef42216d f0800cba485f7e49036cbe89a2fa44d0734152830f502448d1ce49517c8e2ae0 3c5840de7bec49a04702d6efaa1d5be4737f38bc83cf3f35838f111d00112df9 1fd08e1cb9560f5ee5ef217cc49409144c0a80871f57ad09341991f55f05319e 812dd0a55de1baef5f339f6b1ba482674f36b7650d2aacda67920e2f8035d723 6b243033cd0537abff615c9049f2f7644fe6436d69631aee767560dd8547e969 9b16536740c86c667ff14a5c396bd37788f0dc84b676b93466f47b43650ce193 bc9fb8eac96763ba7794f43387939b3684c4f8eea209068a27f8eab649440d1e 54a3fbc8c40a0bb0dcfdee045c36fb2e271348ad88a7119bae4192b28a54f7de 1fc23f3baba7352abcf8d6f3e7ce0c7b7124f10d7edee72ac6cacdb3c96f117d ca59622c35c23bbc0f7c5be592566e6554e33c39a0d1ce80ac21ac3aedc5a34c e47a49d7225a22ebc0b28c55d28b39a624c8e3b44bbed44655e96866430c4567 35b841aa68a7b2ae12478bf5e6cbfe9183af1afedcac914d8be8889b249d75a9 d72d55845ce363be8727399afe7faa4377501f156be93266685ac1e9cfbdc978 255784aa53b9b32570e930d3748c7f2235596689435835ceb1938eb695dae023 0cf7978424f6f8fbc85076b230a0573d8d6474dbfc85c76f4c8e87b3ec8efe59 4a1809b69b2505da74e40626f6f59d00d03c13549ac79d2bac458b56ab39b68a df4ee1416d7a952d7dce492686336d81f3ad1c02bdf286e05a6e17c5b1a96a0642e46163eb09f4ea006b25480816ad33cbc72f133198fbfbefe2ddbb8353fc0b235449b3ae2560fe8b91f2bccc64712390be62cfb19a453a26c9eb93ab8a2d026fe7186f57e2e6b15e9ba2ca19cef8beea5a44837a2359c9fa706f89faace008198a69937f5e382ca0f37db06814433ecd7e74673ace6f448a181a25e320a00b47928cbd7f98e888cff3d8eafd897e5e96c6cd903c517c97bb32a393062767019b57cfc2ec72f28f5c70b65b486e3ed48a52a857e9f50e24d1199707883660028ecd7427e772c82d13174b91c0d7a7cfb428351634d72b96a394c898cc68c90bd1dd381a33854b62687ee7522b224cc65879958ca82fa704502adcba32139d07f8b0d1d0aad2e553f3618e45d80d8afc9dd88b9a678fb3bb2333c8c50df6600fd3f9e5be40d921f4e378cef465282d82aafaf9c67cf74fe7754670854d325709a639ae7a54ab84266bf3c3f282ed8fffe8a0cd0dc1d805d21029f838bc02a703b8d81167e1ec5e524ebd8f4797a14c8cedc39759c3c0f7fa8aeb3f68e979e0048ad5efb74215042cd69461f6a2c027f8629e4b64a501b3ff65a014118a4bc308dcacf974f48a97d3e189e167e7c93ec9066196c4b0f34cbfeec761c9febaa10cc05cea57d074d838416bf3dfe18b8919b7b48d9b696721273a25abf001cda10daf5f77ffc4dcc22aec6075ecd74dbad2865f211ffef168b4d34ffbb75e12b00ea608f4245a60d71669698b62a3754e6cff475880162bfc9193c41906b3dc3e074fbaeadbedd40ee9d1ebb42b841c403f7d62a361b766c8d55eac0a7ea0812f098666dc14d88b5de570393f2eece16ee069369dc4ec6bc09a8d95491ec0b0cf09be7d58a81d53e0453b6689f81dd7135aae6f19bc51c148595e1d2dfd097b3e05d333e2f3de2d9837ba3aa8d4dec2ba168a8e3f3c8af54527fc7cf09ad041f00451f6e8a2482f79c983380fab64471564532b61e773f5d77f5e932e001a12ef0a6fc825ee3800be747341e6170256704c3af816a043998455d314c5e0c86c6507ffd62bcb5878e288e73722e22613e2e79f580c9230c6f7ce815247b56d732c04e98fe83585958b6eed8a5fb36a5b8fcbe6319de27ddd3180bdaf4d4be6094d0678915fb329d7a8a244a156435e068a53bb779c6198fe8aa5933c79e93c2520076f8dcc092e6ec4bbfbaaa37a13a055e38143e529190b46512abcd745a3723907cdc01a15ae7f2dcb7acbcb71600ca95631057ba70569b7dd8df1755da127b50dcc76a6335d7c6a9c252a7883adb7d9ee47e63295780e92440e916e95d41c6c078e76aca0f372fbb64ddfabe15e8426ba4dbc2b160d05ca7d256522ee58b896050fc0d1df6d4431a9b9471825ff39b5f6390c884f29b0f70b6bb254919b23a00edb567945b7fd08dbf093f91405822a5a29bdf898289693b110398b959360af0c242c3e8f74319c10bb9de767d5527bf557fb684a4e60efe83f9d84300a30870fd4856d16aad1555f2bae93c043d0d31b8aa374c70168bb29df6fffaf9a683c047a17958a95a47e42488f0a305eac2ae1c4a465e04aa386818c0cc187ca95d506c7b67defd6cc4314826cad03668e9e4182ccfec99f9150de94d4d3f2d84a68034a1ddfa2cf7cf289659b7b868b4de38d521d318b4aac0e0b1c9c4f4efb65390c9696dd35007a9053803dad9bf3476c3b044fd30b4e52ac4705c84129c40b580ef3641945bdbc9d6b68686b18cf0cba9d629ca1d555f9905a0f575d5ed7371a0ec07337f4fc63bb22121cdc72ca1e69cc10f7f7f55960aace0100b5d0f53f9906fa917dfcd1715040c3a59495bf893c7b3deb9619212773571781e9f205985c0804ef69be5d88d04095bd80192c620cd5f35537e9941dcbca8a7ac5811720b3037834a35008857e2c86615bf29423d6ea3261521968ed535425454958b11759099981c84b95498a3b47bb8af77eaf80c9e70b9c83253bc64fc7fd54737f391603c52784653628ecc2b074b47ed317610f99756a4ef928e9a49af30544e78f0207ca4bae961f9536ef4aa18a275b46f7e09f419f906e68f094db78b3601dec9d0f3806a34f35d364f0f430e31a68ed73d4110c4afab16a10de0f249cdeba6a2d03d039351826734031a4652c011972a0f5a04075985d44bb0b565869d1058146094b19d87d6b69fc55acf0fffe6a1ccf2a97c34b88ed5b501f27d698bd3c934401ca9bc8949dd47c006edc4c89f2bfeeb64fdc8e58c5849b34c8a642cef5a68a0edffb69c8b32259bf1fb99c441f23353060bdceacf8e087baf57fa4787eed3a0deacf5ffda78a41a77b6489fd2b7d6989bedce57210d7f2d2782e0ddefb348b05e9d726f26797cf0a6910ecee51d0bc28d487f08dd625063054a53f7b1a87820ce1f3d08fc80e84fc1090b64daa6f96cd42c0e8725703063d7b01b09f3fe89c09bd08c1d871499c51c31d4aa2f6cd84ea0e34b46cad6da62e5bb23a290a6d940d16158105fa87ec845799d6627ebd1fb79b708782ab9e4a0ef4eccb446ac2d805293e96b999ebaa0e20b7d2db572de83edc96030d0b30b80edcf5fe9c1cd7d60180251dc8617dc90c46912f1c3d72fb4f17e5e87de68878816c95568e7711200d72bd5593847948da6ed623e263e7569c45e967643e5d62d4b588eaf52c414d0f40e27cffec3bd532cf939042df9ebd222d2dddf7fc2dfd0743a31c046e397a04947cd9a9071ea7dbff6637d5e9fff0aac8d594fd96cd5d49e70f7e063660f60554920e498302964e4da414b3cbd965f057cf3a887111369e669b19693683ee0092d7ebf60a6983f496ceae3d59e7dff60e9046eb89000955924992d2c6d0440dcaeeddbc1710063d47b41b2ac1115ebb6cf03081ab6cb00204b915705294dd0049eb3363a6a9c53f4c40c373f1fba1f179470997b430616fa1c90665c7e31e0d78d8a5916143ca769493ec091d23e4fa959001587c4ff9006bbb4db9da01830d1d8ac6ce8da9f5199a9278fb4c34ba4165be7822ee793d7d75c05e9b6077180ccca4d1722f6e01e9f678a7bcf1770cb89321d7ddeea5cd6c2debaa979e23da0a5332c2f155e07c2acbc70450fdd8a1d10bae2042ac24fefc1a0c47f42bce930ff8cb45d4b3b441c90688c6de98e587bc08cb10559efd7b649d53415c358bd30ebf408687fb9a0d1b5b494678cb7c367326cb9c28a5b5f1dc8b5ca32d795222065504f3a0913b5d7bc85419f696fc80ece6ed01e5f21a126032b6f46148e813014996932909c0b63bab8868f5cfd50ffd97abb2d709ba833c28c9ff35c88794055b11f24cf4d78d7a0f05578f0623cbe841f173ae9a30a8218e0ca94b4523990258808e3ed8cad95df141ac165ad5991c76b50b4cf99ca145665a3c9dd903a909ccfaa73ced3843397c5d91b6a318718d02bea7ff3a27b9979930eed6706da2063c164e751e2b2126ac3bfdea6c62bba950dbf6123cf5d427051abc64054c68020a2c3029255d2df15ddaf8415f0ebe7b10504d791a5424fcf31684c5b5d26e09627206b9a28381d91372229dd64dcffa93fc5f9eb4ccf1624bc7260fe9772101f37533893e216f0847362fc0f29cbd2e4e060fb5b41448e88fc4f31d6913a9092dea2e7e8ff5efc0a1965fafd0047dfc058c4100e0b614a681d7c402311d7805a16183ce98a3099f7e433942ab34cd48e9eb9c9dfdd3a0a806d444e0a2ce23082ff4bebbfb6779944e8ccbdfb5bf1708eb7cabdf4bef6d92cf46072514b4d005b307fb33a8ad818aa590832d32f4ddba45e1a22078741ce867e1f4615d2f6e051f5f45133b108737d39a2a81250b39a3af7d3dac379c345f7a1972e8a7ecc3d35a9d0714eb2f48f911d2504caf5554d1ebe66d8f5fe42d395ed09eff37485e032d3dd955442a0610ea48df1a098ce50cd6ccd7ec8b0ee6b04ec51649eee64001d56bc8386787cd3c9b1bcacb64dbb20745251dbe21b6bd709c175fdfb8d9e200f87fc076efad51859d921a2b09efa82ecce6e5443bb31a971f47a6234176560d159423ca593dde2aca2b69aff4e5607ef85d269a0735f327684de3c120a75a041acf9f49e5e3a058622593baf54b29fc67605fb9eb3d88b929955f2afe07400fb61e002384b12c1c27722dee00bac896c5f278abebea92c01662884b13725d00a499505969bc2a513cbca668b055e8eafa76e787d90348096d284357685dd302037decf7b1a9bd36e62ea50d5e661fef78042385fe214a6abc396d4eb55e0407c0f137f62fd83b1d2f0d4e36e2b66bb9e78ef16b6b59fb453a9d79afc4b2b501dcf2f6057d0148063d049d344bf6fa9f8c2f5c006b1f7aa973a6f5ca74ae7208ae340e4a424e345625a9f071df364e2488f80305c5c2d25a9b0dd08408db9b0f34efd0d18149ac1a7d4cd9fdd6f6dec4e64c76d5a9ba9036f24b7fcd88727e09b0e2075eea4e4e82d70259e036b45e8120d26e9e2139d57f9321eeb93488b30784ea0f92c151f43cf5da2d78cbe69eff66ce0049d3f994073acb0c26c9b48505abf1b299ef53668a48ee01380048dc369873eaa07ff3d9f76bca08241805120e903039f0b50ccb635b66164f3b9963f77441b2c9303d4aae7571b0c68fd59c03c11ea6840ae4fe78a345ab8627fe52b939a88d8cf64044be7ea8636979b4280982a80f4b3c5cb715a2f2481ae5a458eedb6077259e6df2d6648f05c24f3b2a0826d51c3a05ffbef80ae2ff3e2f28db1a8e224388c4fbfdb80ba50f69f967a1032a07f29c9d74a95e86fd3c47f0694652fecb13d820cf154463aeb6985849d4090c442d9ef0fbb3a5ccc61f0ab48fff641139b8d63077b14bde8a48ac374a9a013b326257da940da705bab0e3ad6eee68c60e05d7f4addb53f13553c47e0414098232a1afd0b28c4c24c5b3aa3750548812b50c9e0fd67ce46bc8ef5c50fccf0c2547656be833202e378ebc76546a366fc90fbba06a6c2c209477b22470881504820b9a68e0eb478b7696eb6e1240be2c067b4e7bc3016c12785367bc1740e10bc6d3e6e9a11b51ddf42d69bad6655d5e910c8a67f0c162916cfec6199520e6043221009a42e0798a31b176c0b104056d1e7da85061c3271995a8712cb6b1260ec1496fc643cfadbbaf78bcf8ec0eeb01735b34cf392a9d5c2e58c57f3fb1d5057209f09d264e19c6420364ec02f4ca3f94a7c1063cff332d36b813a45df9ee3ec0dd3f93ffd51bd72e197d7f2469d119615e24547ada34a24135f2589db692086c9fd0e86b2f51bc3616c74b99434789c3fe671da6c53ca88f7f51017782540711d76c8ab62a16270b033523c278bb2b93897e17b5af26e17d961b0d8b34a908a44715a18bb1e3258ccc7e5ba6ac058258cf265faf13a6b9e3e61db8f725d1066aeaba020444165ebe9718eff6695d0f4f9aa32bcb4c96c9326d3104b5b65f081fbe8f3f0cc0e98f6a0980f443b7a8b1bd848b6f8e9cc717318ff26dadb5ab0ea7ef6b44094e8c58e82cf70f5ee76dd9f1c87a2996739794054b21b3c702ed0529941fc62984e83e2b42014403deeca94af3fdf1015fe2424f2f06d6e3bd1a05697be6c92495a35f9337cd48980fca2dd877851480fa741cf8fbda4341d1fc03d6e28963d16556e570dbb738ae9b7e774888c8906acc03b63ad6a7a2ffaa6e09ed1eb7e4e7b72ea0ef935ec166829a42a8375357f1f2107f84569642e2dc04086a402c43847f642c0770422a62b53f4b5ebe1c8d6c11897e6ca34de9028aac0bd6b92e38db4c033a3b188eee4a5be85ff4e6c493f851e21383ffd0891e1b9101bd78a4979d0f2006dd7916a4d8a47357ee750a7bbe8c50f4585377279019e60a58389e099bdc90e25c104ea7c9beb2ea52e334daa49c1234173b99810bd7e40372823889896c276bd059291df2aee99d0aee2f11a1234205027a8562521630014e6bb98037a68854171302277d8a46d6f868d9c89790a0e0d80b248bcd67e10f3d278d1153ba661c13b68b033892ab0372a58fad7979f0b8928f77cb1a9c5804 false +check_ring_signature 4de68dc68b62e0259230c7c1df3dfa84c41efa785e78f7cd738e8ce403ea9380 0abe3969755cbf7cc59d2a464730b0bae0ffa004ba01920ba7ebd27268f1a684 203 b75b080bc17f2e6acc6944a01dd246b8e7f7ee582828f55f6232a63c205a176c 44c1454134f636b18e27ecdc2154d56b824c3e7de3f8fe865fe3b4e6cd0a1c11 1621a86dde65bae041a8d385c3cdb58d94207f13d692103b59fa7d9a6f061745 53fe90c86706e66180df10cb97baea0215c1e46cc1cb3da6f797931f65214e1d ab0b1cccf15fa70a72f5db67614aca54abb4ae99fb197ed4f001fb09f5246e07 57c5a202a64a32276e6b921d91e588c86ab6ad49b3d4f90e236689d5f50f078e 87a8f0dc48892375615bf2858ddfc472dc66c87588a21b12f19025f484e9cf58 c4fadcefa66433829604733d8d69ec7cdda462dd7f36cd7ad4cde6da00008234 73ffd4e5266df43c12e6bbe84e9aec8d160dab8e5300338ead345fe7ee8bb0ec 1fac5e53ae66a36435e9a4a18a570c584359373d66d0685c1c32c1385db2e2ad 77d6e1d6f21059cec2b1e1ee9596b399a33331ab790e4d12a7ba3fa44d5459f6 8b27a00d519d65ddc78ce8669e3589c3080b17ed6d9e9899655e77bc66586275 3e5a87aad3ccfc65d1c43e9e3d7d76cedabd7e0d9cc58c894ed7b0ed6daa844f 2b56b02f38506856aab01566e17ad19df98a41e0e8fb22a8baabb284514f739f 5c66a56d46811a85f401a700d7eceb8312053ef4106ba9faba4d786e1b8f3cfe 9bb4da14239664ec71c98d8729209de6533cce204fa4617779aec13c321d8c24 767c090674b9c51f90b1924e27e09ff06c4d6c7aafeb2c58fedd6e28d8bb0c15 445b5725d839394dd0b97a62d0c60011313009945caeb134d3a943629dc888c6 0c0daa300ad4145c634e5f3f16d2caf223f7115af41f81df50a037eff6b3c2e5 070eb2c063327874ea6a9cfc840c03b4a240c321746d52e41b4be222c89b624c 2a3879b0fd9e83e37747a262f39ae015a0ba554faca349c1538ef6bb421bbd41 2b7352d7db7fbc7627c9e8349453c5f798156b003606f7109a7708db5ee28e71 7e13842914abbad80f96d842659f7a3babe9bc1f8b7c16a0cc66c05047ece04e 060a9e6de8c39a4a0e1b4739b70869ab49ffcc8531f3b3178973b500fec7b61d 44420559c8357595a8fe47b2feabbcb4a452571e2fdbd747427cff52dd68b13f 1f01289bfdd9e8260a0f4a345e52d1e8d3ff188fa9fdb1a83abc2d2058c3357f 4d6e7d585a56e3f1d8552fb670fd5585fd0900108facffdcfcda0db09666899f 721c0a6b5c056a5e891f6278b6de10f8acb4e373044b4d08f77e66eacdec5bc8 918c50c21e41c2c1c21859fac355b8a70181620e29c671cd93df8bd65b83c19f 6a81a8916eecd15b821e7ae610ef4f4ebe2d985f34b209440e49cbe2966c65ae 39f80f3de7ce7d4c3f07030a07b7efb1736bb71f9868f7ff7f047a97c8bdc7e9 1e41e6e8870d9958389a0d0205483873b845a231ef8475a7829b8a5e1564cddd 71e083d22c216223be418c552aafeda23d9e025b24e43bc0cb8269bd03c5b19b 9f9e842cade277e97f76e3d0cbe939048acc72b9a50463b322032fac4a84284d 63dec2151627f5cbb477b9811ebd038499b35c49402cff6d6aa0b6314dbddc87 a2bb1ec91c54baa5467c4047eabb186b3b01c1dc62ada14d9c81fa229873343c 7a9540aa0fc4c1a8b9763dcb46407906e1c5722ebbdc595eca8e1df8d417f2e5 1ddd2fe8a6339b637c0e081a5e9a75193a95a77b2086fefb15cbc7bdc1b8b132 9a7875d0ccbb8af5ccbf847cdc490a4c3aad70c851d024c8d2ae1e4fe42013e8 56411261e398015d250228deae0a6393bd193c9914aaf813cb1cb79b59f3bc12 bfe20525792007f4615f7b40a52def51045b5eab41d0774cf3e289c8af591b08 cd47cca3cce7b3be1ac8c1c253c3d32fb85fd584f7e1a2c136ebbe0747a5f5b5 bba6d503a104a171ea3a068a33f6888a20e8946050f23580903342a7acf64f5a c8b05bd887eec4a084f86580a2efc5dd23d39b27a70aa68c0a25ac455d434784 3bbb0c45c7afbcf82cf8967c102547f32d80a0fbc087902d0388a84216ac29e4 05e9a844168e6bf3efa137aff223e53d324d74ca09b533be28c9aa381f4f27af c0a28d4d9c98e5ad94a45a15552f4fcfe284b5b7096030298a898d47ce13f2f3 554c5a32a6ecce580bf3f910ed3470215a2c9fd351ce00a2b07986a4580a82ba 58ead4b3b18f1d9eada34bee1e714b776f11b0aefdf2f057b8456857713114ef a99229e7f85bf646f60455082d104a1d49bb287f8c951b86f4413bd4fdea3fdf 2fe251737643028ac9ec5fc713178b97ff295fc2b32b03a62c831596f86db512 98f27d5c7a473a5e8fcf7477212e7b32b15044ba57ad85d92752267b709a21e7 dd4f83cabae4386e8083a3fef74401e6e9c3e162cf26d764d75a48af773bb254 1a42cc8e8802613f9d7fc4b867aa8c7047c7142799f1ef82a4b5adb5be556fb0 4677ce02176416e983fd2386e56b61a90838dc5eeeef8bde15fe671f9f31c5bb 8905c1f8c5a3cc7a7ffee2d088a2d6f1a3a8a60b289f77125d1ba48d04d12949 23a36d4fb8b5d576cb5095c463b91bc485c9878a601adf8e0cf11dcb39ce9866 1ce281e3a987ece4c35cc1e486caccaeab6e2b6b50e98a147df813932821ca35 eecf51b47102810b8726764ca20ed9d1b02a530a7d2922940920ed81facbee2f 955628d12b9ce77a2ae14d2bbb2e97eb9cf159a02d36d1e82462cd8ab84a1e14 0624aa06b88e88f61af58b079ab04ccf9816149a88897e16fb974b985559b045 b3445d6263ae0b754e0c35a45b6ffc9aca81913c7ee43d31e19f5e20b90c85cd 0632590c256f9fc7a08eb49342f0fa217714d571835db34089cedf158df532f7 d1d6d8165ba2954d4ee1468a9a9937d1497c2cfd7b4862bcaa88c46096fff107 f8ca0bfcf60c790933b9f2970b71bdce46437d14615f5a631b1a8ab853390cf1 2613cb752a9cbdc5f9e5c1110b4f8cedce980e4d4d3aa0aac0eac831aef08ec3 fae9c5e8a72a8e676fc5661bef142376f97e35b92befc3ffc45b891bb6c3d73c 874f2b49114541a4fe35a7b26eab20fb732d37a8afecfad3bc7d334377d75928 1b8ab464725831ba71d202884b91b042abb13765f18c4f0253171cd8bf357020 1ab01b94d0dd1dabf8cce62d071ed7290fff9b6f1b2548c4c806e36ea6e18912 afc45472924bb58f187d4f6d5f5f650f74a3e830abc7d78f944df98bcc9bd070 cb1deefb24a16414188200a713665acc183e2114fa704931a3dfe869a6f9a6f0 cea75c542b5e2cdd411d5fed3695fa1de1890d27662fb013ab1e7eb51b0473d0 4af6e342e58a1b6f33e9b054b94d480444369712b1f1b862dfb8d1974071b2c0 1d774f95647b0f696adccc8b5eef1a316739953d4fe88784753f4920fadba82b f82d557d5c15c1b776290354ac30ff2d5e52b755061eca8e6feb4f3dc6e176da c495a01e77a7a105e2202e583e5e2d89d2cea6f6aa3c297f3aee2a05b27694c7 3e3fa1ac436f30046601f1d490999d268b6fb89c1ba34c5ea06df683c89046c7 1b2ce06c5d2945cb08d4e97d8938914dc911735df4d87824f4b380b341c36c72 5cff1bb9c732e112ce0d317d52ed51291b6dbb80b267bb5572b2f7d6e2b91866 3c4d48acbb6d031a59458ae1b37de659b51e772be4e370009d5eee14fc31adda 40e51482b2f4b09d9b5b2d0671cb45be177b3b417a9d3df317bc0b766a10215b 8231b8f9c31855bfa1de3e842049d5de637ed8757560fa347385d5767bc66dc1 ab30916a7080708937c11105b0c68e0265d47d087e5268ece8423303040ff998 43ccb9c14c010660051454de9409a8cfe71a354787f06f8ddd5ccfae9de43295 f83381681c1bc08de7a97ed1428420058ba35c93cd05ff60c40dff0a6576f3d4 25e698ce1371cfaf9041ff7d2a74388ecfea38a44151706f6247ff19c581f105 92f4e3f5b43e87080436202e848d9ab23fd5e113e3cd6bcacfffa7b0d4cb06ee 5a59189ecb983d707b6b998f3b5fa479562da230c4c6908361ec7e50badeab73 25afbd1ed477124ec2defd14433364253facde0ee282a4633b0faf604e48a17f 2b46b396135e4b3a386b90f24d4dd38d336273f101c4d4723e98baca7b1a6699 688e43964d1fab8605d122d2ac20251f5ca2d3771caff8b4d0202190cbdc8fa1 853aceb7754ca2e83db062d82eed64cb1027907fdf93f85a223f66aa08fec7e5 7126f17fde3afd0a833b4c4e44f9dd578b68443e88f4e3e73b941e934a73ccb5 9477998631dea01868827d5aff512b933d7b326d55301c6a9b81a2535ab7f52e 88529316c2c55edb062fab9476ad7b274a7e0647f40f701e2383e47115ab11f6 07f78f0f264ec9073a4149663fadb3a7d474cf747920343f849ca97eeaf538af 1c273ebf8db65cf5fc7635777b96bc9cce426848f8b82861d99e51a064666441 7acd19d50b3d7ffa082647aa8b110db044db709841ea99091a9c876660a2b36e 63f57bdce84a563c656b9b67aa0bd015ef83582c2c9cf4d60301c0d5f5d433f3 9cfce692c8a3d8a0c5f0d293a3114f8c65f0299c9b3934b86deaeb78b58533ec 271c10dd8571adbcc19b06af26fabd5729206f187bd3ff586b2c52fa4b13630a dbd2f96f9673dc0225d048e2651f9d74cc17630f73053736af13c52f954927d6 1604b8ee96ec3633f9bb92dd87d51d1f4696b1e726254fef0556425dc4521ffd ea1194d9748b5ff831dead31af98da05176092f210b1d329d73bde324f3b96c2 6dc0b832771f5c9f4fea806ddaf0efeb5f571240945354e0165f79bcd7712573 0ead41c86ac1b4c9a8e10d90542ef37f4478ed9bbba1b58eabf22e62b41cddba 9cfc8de60bea2675a2413e85974f1ec7f7f507f1ad6fb9454722948678f89ef5 e7de2edceb42f86210f6e94e6af716e897cd5ef214caa6eae4d9df784293e058 25346267cef9105d867eaa0300df874f4f736ad4ec1e4064cf836cebf0e33791 ec5ca8d31c87537cf99e82a7fcba7b71b9f341cc03b3dcd4adfa6bf7b5662463 416219b95cd1a52f3bd10b875ea7f5cf67e6bad5215f17dfc7fe81e1ab0a6724 5db4a45fd899b47d31597655080536c8688f2e4334384358c98a2b3ce4e99cff 7efae90f167967eb3827fb6c967fcae4454c3296ee1943bee07dc920de952a02 68e86ee00e4652cbc11c0ad08396bdf6bf4ed7b5c189772c3e71338bc2fab424 3a391fdd9e43920c67f683359bdc89b4e78f1192f3fb6f4a2385509f348aa320 b85faad7200f1ab40983722e1e3b502fa779ae1aeedc0b2bb601780fa6845a27 9c9f9364542522ca35cf90927bca653e277eb91f40bf33a29cf0a8d23f2f5c99 0d445438300aae18272eb6713d9af42ee81ba67b690e257866954aa89c392022 3498a3884892774faf0743d75adedf305942b0cdea05a1ee97c1e02ebb6a442f 93faebe4ba93f93d53dcfc7a1eacc9a63f682a9c3fef10f8a72038bbdcbc3613 0a321d25cd488426a94cab8744a9eb79c0e3fc376e2ec3633347f1c4b9491ef6 70acb5179a8e14aa856e6fc61514966e186e864b316bda163ba379e9c4075418 ddefaa5f3fbbc6119f8a36cb646238e7528022f247baaa430c18bae098118293 57392fc8400ad69d2386b76c5665fbf30998a36d54d7adfaf7e6eab4498fd71f 013d00c06f110ff8a6ea37fad33a8bcbb2f7427ccd586dd5431a66d275fd998c 59727316c91d7772588aca3e231b14b6918537647f6090d1479df9e8a37d78cb f0f5c2aba2644b6731c5d3640ffeb248269f7b08500b9822b3c8d5a569ff188b cd6fcd8e0a4fc46e00f49d1336ac3ccea78710f02b369554e2bc76de98ca8abb 27a184e515935acde09b3dc5730ee53f2f7ce3a6aa8024b493f2e07b1765e8e3 b536d22154b4b8e4668be3fab8ac073b3928619eabe8f6cc2deed2946918a37d 84cae97b1146c5879200913680048e6777c763079cd838d0bd95a95bfd980f63 b996cd1d8da842dddc7f14fd9bb2a27742905b721bbe72681eaaa98d298703fa 692c6135110fe145a397c358428ec744d6a8bef7b75e30fc4d4dc9c98e8e2a16 f595788cd565b86973f5061f5085f658d4a96dc8999dc6ff4d9eacb934b0ddf6 141ea9aff274c346670a970ec8ade65a5eccb019611ab5559ba3b0ab831a4013 0919ecdb192c20aae0c4f7f7a6d833751b26c29cb65a6f774713d497a59ae4d8 e060e6ec4354df48cba79fff87e7472a4a895d3323fc82ed332aa29f9b69bd37 60f71db1842eba0a5e6748a02683a2221fb7c42feec9a76ba24ab34095b22d76 a4ce09bf692cf74e863af7b06e634f917cd72bc2c24c41e931b15f2cfda49eb8 8eba1f0545344b2e27d8d01ea79489e212ffaff66115ab7bcc822361f98e7dc7 551482f58995e61fa72eab77b26a5ae81257f201c01ba55c8941e7aa6c70d1a7 087938db1ce88b8e59c7c546f457c46eff92c0addd5c64075c5edb789b9a33da 7722857dfa1cb7872634ec395b478ecb4b0376b6063203b82fc761292d2caab5 5a1b6463458a79ae90bb1b795b01e4f0043adf19306e658c297b72368eb8e359 b7a0e91985576bf7fb8a1ee0ee7e0657a9c71637202f022fd36b060966f14fb1 e53f1feaf04801f020f215a3605d337df20167a4bd0bc0398b6ddc2991346119 b29329d9d2bfeb1edb468c59266fd6d68c5b0aa1a19b530d5caf7399ae9095c2 b52622a17d71a62e67b7e30fe3d01a9582fa9547f9cf8710886da16cf70423f5 999c10a970e8d0311cb2b9dca2dbf77201f862a8531287888467472e4bd8ca38 8fed0df31d476eb84063fedb48af6455e3c3ca16a6c37b73432a6a88930b9fde 944142d24bc6c660146b51af73296a98930b320454f6106809270ea1ee79e3f8 41233603565217d2523439b66aa68aa352a035d6869cbf68bd069f5e932ffa3c 77746dd3152e0bcf9a993fad2ce0d47a32317bbaf05ccd486edf9f3bccaae362 e68a6b6c3969d8961b200344d2adb687843d8773db7c3ea78559871e4501a434 7caa9e990dfc46936aec3aa779e82131cd41cc91bf4385a55f55ffb09ce23fef cbc0532c27ceebf68c4e9a6c24b0631cc23fc3a36ced43082d979bbd1c497b72 fdb1b5baa7cf95b2c6a8d4c5a0cae0cf093ef22a1c4b61ad32ffc5a94c8d28e2 4524d5a4abfd6164e3689a3826590fda6c6515ed7f87a685b9e30fb6a70fa2fd a388849e91c8bdc522e3a7b2d23bb21ec484dcfb282bc889c393779ce4fa58ab 75f35ecf1733e81fa74aa5bb79683415304d8946a03efb0402ad2c3b436b603d 72576f0224cee12e95b0948f9ba9c765739eec90448029a3cea9a86a0a657de3 f943a601dc503f89b345438c297dc9623189f5445142fd0c449cbbccf04855f3 38c39d37b9ec2a48140f93549b965e3287941fa0f8450559f53534df80145271 7802ff13e03c58473c649f25a7a94a9a4a2e8ae3f2cafa7f635b7b26f3be25c9 f431dc549f052053e2e713c5457062543a9949c038dd0e6c0b7ffed4693642cc 1b2276b766bda49840967be80f7ddd2a2341e28431158b86518a082056ffd76b 097cda1a595b2e048b8a5191b63451ba79d670310a4a0269646e40339dba42d1 c31dea7907b7d1416c6efa70f378ea395fe3698684bd3d0754fddd5a164f74ec 5b92571917b9aba5d8381212bf8fa5d21ac93e37a32f2532f7d4ba883408174d 1d59f7149994f0fca7a752d737bcafe9d01fc3f591c6d3898ee82adacf9bf6f1 22edb6e7522941607d4476c97f0af6524efebbac90d724211def1c55c37574af ee00848f29b8491bb6780eb22ba32a7996e251dd66c7a776f5a491798b014b16 e99146974c729ed79801e2518b438238e03fb1937c40a801ebbb31dbd8a9892f bf7226ec930da40f41e8a3d8c784865bf7cd2d696dab79e140ff8ed18f1545ca a83b98b9cfe9434ec32ee248759891416d7376a06b9381d1e54aa2d1b6154c67 14025c19a8d54897d33da8574f7ece8ff89bfda5893052454bcc60168a00e24f 8cfef54fd04042c4dc8ebf16776b5982e299cb585c8f1bba37131c823749c414 88dd029def6e9d26934e4d56d6270d013078785ca4b33f73d100bb826339d43c 052a5ea8689e58640a6a20668a4e9581ab06247273d9e752a369aa97bf0607af 0a4ad5721b54289a337baacbd884d2eb7567f8e982bd7675c912142b065f8845 b489c42ad89b42375408ff9f783adfaeb38f4e60f5c55c56952970c25b507913 dedb8df6393a86711a5e366b3e2a52149d882a9114bc99542dd84539e786bc29 26287902c7c8132f0ebb70b9930243d05a5b6b216b1bf7385e7e3c624407bfb8 9968ae84842b9b432742cb68ba8118551564824de13b53d0cb44d30ad499529c d4048ad10bf8252896f2a5d34b2813d9aa2f133d371e86c8feab312393564c6e 067e259657ef513a55cbd8c1d19cd4d932c9e39ff04d20453e6fee5c6c3a7f70 2ed46f192283b8751950c90d94edf6da6610e419421f8bb1b523a89f7a0fac5d bdd287e8a065b74e9a8767c1f20e017a8341c1a549baf8586367ebda0b3be75a 705e1a597978e295343ce64e3435638d7b0d11c0f5726adc683255955d1f1f4f 0980d18e06cbc9478816148c54cf21150419ec604d695d90574064919ea30706 ea9de06e428dff51f31e8c87e27c8a02ce3a239b14c37d9acc565704605c84ca d84875d102e95c8a2f7deaaaa167925f537f3da7ead75de12deac06028e5772e 244f4512ac28c867d1915d7457563ac01c696b7807667b0c9fca84546f774bcf 1445414e0faa568fcc8e4251e085468843e27b35682e96e7423d9532cd4bc946 8400785d5fa3815f39bea05f4cf34f0f9bdc1574215c90a58462a1d437a4dd4f 9bc65afa168db715b2e0ad116cb0dea3b4946fde3e5d5ac77119fa33f0a5a29b 3baef1ce60504769ca6e32a85b565df8c50e998d9cd35e3e1eb71bd564c0c211 8be3b6d6b929748607d8ff0b90e745e10e87f1a8689865ab45019ad5ab7fb73d 1bcb39f613a0566f8c57f01fdbf0cc9e016b3e1791483229d60c4614e715cf17 31880b2fd51ad6cf58580634ee400eee76bdaf9655a913c438d5a2d5e1353651 43452147bec295b25dfc466630d04e05522fbddf3dc4365e2a151dfba15ce263 c9ab5d3b0cf25a0993789b65ea0d8bdb7fc5ed0e75fb957808584cd867d61e05 653d427ca8dfcbcf40f70260a6b20f53d7a17d28d314ab33d1604100583a6102e321f8ec96842c6b2dc96b1facfc5aa763f27b4acb0af67441d2b51a90dc21025fa2b691db9068ff989136f4597f62448c1aa88d8f892a0f9c9d52b952d1700fa0b09d2186a394b840a0603943d8b9b716f516c662d694a6ba876026b4e6e509a38ddc71b0c561fc98db8ed5badd542ac65572b8b4ff7171e91e2a39dbe83c0a4c36653c8cfe9ab02f0d1808c95fc3ff6e416de260def85d60f0b7beb927730033d832a1dbc26ad6b340c0d8a45ebeac240ae6b266315159bbcad5d5ff7d1f064418ce5504a622db9d15481680a8e6d65c4050e062723b99a761e197ffa4fe04d368f7ed0d287323d8d05ebd32a87ac308d960b32e07da6f0904604ae410fc0b5496192f5aa9ac4f0d488b69e8d2ad0ac16295cad84bb16a48c5b390382c69089c32953d4670478f5dc28984aba1e9a53730cec6af659621915c4ad69b9a2400f19d183aa8b45b6f2c9fb18f20e8efbf8fe4b9d0d45e5957efce334257bfbc0a13c3fc7f40282c6c6683df5915c7b7cfd919b63440b3a949e4aea32ddf0e8401a4d2f6aad8a114308cb8c4e34295e71ae6df034b54e4f891018405bfb4318e0f10bb00e5a8b7fe9550c83e439dcc41b9c34df31e4c63dcd4eedca4d2efac77075abf45e13cd1318b685a6f919a154e2cc7be2dc458edf1427d36ddb8f8161d01c4e0db6dfbc20fc11c31870476cf8c2c6a94a7a384c4bb3f836d1e0baff07a0ff4649b5a524232a5237fcba4405fd695ba25d604dd32d65c41eb43b7825e630d304618400e964bf3570a5d44ae9929e10bd5dae418dbd9cbc1bc169b316cb90bae88ceb5e698a239eca84a8df4d79049c10160755f7fea9b5c854c292bb00c080af42cc44957f921731f21aa1008a50d0e53100bdef938bac022e7a51438800bf79c5ef8804059fd37bda923aa900452c0e1a3bb52ad0f8c6ef5ea150a167c01299f89ab0e79836ed364b1dd5cbec1b907e979a5ecb532b4e22b211b13bb3505ffcae9dfdda8cfb5aeece5d33b2a8be3c44115313c40087b318a087933a5ae06133f725fdc348a3ad6804394241b93cb4efeea60a26a5b7bab16d1797f8a2e028c3153cdb774c1b1d9283fef38c59d04837bee07db0fb2995e8cb0850823e40a27d5cdf09e3c9f846b990f8514a1e12a2484d68947c852799d39e1f5df949004a730a49a6a5c5941d24c1f714b5e5a9fb9ec5ef30e2d1b2faa26b6ad2c74280e93c16fc24a109b0b2f706c8ae439c874bc760c76d57fbe0193a618419f1d3a03a633de7084532260aa32d294d3d5c1a3c89bf3265e5172bb103b67b5b991890f67d8b88164f87cad09a7612ac23020867f352b2afdcb34aab5ad1dd27abe4e0178416ab28c93a8e3360dac0b1f808ad3e97ec76e4d73e66ae22f8e4f99bc840ac4841a9ae2f9ab81eec038f5503093d86be627c87d9fb2f29687b541fda90a0f8ce4aa1ce19b911f43ff1f2746da1cb8ddc43e26244558c711fe8cb0618937000c90f0015181ae5ab63539e691dde458ed70aaec59a7a861cb86a368ed64f206ac997a40f833876cb17ded245e599fbc788a327fd0ffa29cffe53f0973b8f60dd4f684ab63d1286c1f0116b3fa02d4048ce33e9cc0fc924a8d531d3d22a799045549cf3e07b1adb0810c1a18a0e52f5350542740cddd26e254d38b88b317260b77caf9ed93556d6d005e12a0a1818db103a394cc035a9e13f724e91835b1f4072a59e7246d6c9b279e4690f80d9fd5f442e761ae745dcf4723fe45b556c7c9087b2e2442652ae73aa274f88045796e223815c269ef25118e624a095bc46ece057f43a2df87c96363f48e627a33c89d2c832fe2db01081b548795cf6d24d588065ae4fb2fd3db39dfc7a1f9bb0dbc31627d72030f632130fdfdd12cf6efe7674531cf5dcbb45a35c51c34e29af4ccf79187aec320c452bd517488b454f34c8e09b418fd6c87cf0a7a339c2b5cc886cdf46d45f1059d6df6338797ba97a1526807f11986c6a14f6b344ac0e91b8f35169053050e5959bea0a1a0e3777100af4609b3750f965205505e8e9d891841c1c24d7b9b450016b38c470dfb55066affb400927f8e0bdd4f20839f2adc8a1175858465b91d8339f43fb65c6b38f1e760bf05d5fd03c8d220c908e00e0730a0519a7292c1b73dbd57bb700fa9e759117ad10f5d5d96c6b016076c5c090cf0bf73ae00ef8b9f84996bc48a7186ff92eedf3c0f132cd959610a7fb8cdff67708619bd5911f71241dbda860c1f6b922336630903a4dbb54372c30ed3330f8be79d458e3771f71f863cae23162e4764cb5de3e900d982d64324b8ca295551859600870c36d93787b6de1f3644009d16b7a9dcfa037a8fa3c49b0a24bfd0e1437e3ea6b8e9e099f3a7d7b57f6140cdb2055746670aa9e83c6ac515f863f3d0f99b1939a143b90ae1c4763c6a85e1300e9c360394fea63a508f7283503642053dfb99d82312aa51d83ae7cc4a54c308b3ed526689069d9b6c67ad0e4b472580a82f35016fcfc1b1aebf276873b5dafdd55ac4040b092e9011923f6c3449c8819a147df8b93885e16a4cde53d5a5b5f03e6f3436f80a876a3ef7d6613035e3958582cde7cce92c3e0d110218ce501350316b44c14708d3bebcd515d43a4d5cb0179b42a5496151c7ade93efccc25fa96a9846f1d850cd0b69b4acc2634d25e992a80c93fbcfc06595de3bef683c5c3866dff134e090eb60c3fdc22bbc99d279300e1bccf388e607255f8a6f29a6685c6cdbadeabf00820308154bee6c3357127f165b0d736d087ed6360cc325cb50f3f317fb300390271c40630e31a333f1e5a41a25cee9c246fc231eab48b2ba6573c107b8924fc0863797b0ada77203857d081906e1dbb1dd144508a2a240144e9f44d8f985fd30399768e58637cd14e0beb299d23cca53f5949e8bd13750f0625a5a0f8d6137a0dc6ff3606ddfb347b8d210190ca436ba723c0a86dfb278f47d171f9f483eb820af0f0b809f1a7d01d731f5d8ca479c712164d83c0f06bcf6902f4969c2d909a0c10ec53bde84f2ecc86e15762004ca703a7d0c36854b4e29419aff623a360e003820641f2e8a59cea9194f2e1cc4c9ed8a07462b13636149cb18a8c6fd13ac20b550048d5740ed4e8eba5fa8113d85fe5436f1a35b2dfd8433dae8fe2ae8c39074c0ab24c846dcab79d621326705c1296072f7ca4abae7f582447b88b66859d03e64e37e012866f88475aa868ad955d07662b5611b8c0277d1439be72bd8aea078d2336535468e93bb3ea9163853f2316c592821c9188aa7111a5dfbf166be705600f20a61b08478d3fdbc33e69bf344de80911af92cdff07ebed22869343100ea6704fe63d7ea2dd52b6389b2d5d5d64a9a986ee61d3438faea7eb9948cd8b0bf5fadab4b9cb39c230017c98ad8a4dd114c0a6eb71e2267f737475d02362ba0b41b904632be67a589ea906122d7757f8a25c6b8d2e5c4e894abac460756ca209bc43c78fbf8b6d4ce0928e3438ba24854c2124a089de603dc8107b59a2429b0295169d8b4071f46583cd4f8defd8073fa1db04307c4bee16a3ae1a6de4ae1e055e69c2210ae3202d169f96b34c786ed938fd9db7f8583991d2addfc6180fdd0086e24c0f8c5505d5608b51a6a7bdeaa8196bd51050bbaf86d467d2159bc6bf07c418de84b3813b6d8f897a071436ae7cb4bfe37fe196b55966b482b651c9b30ef19d4461e60490259bcc546c2de8eb8d028511935a5b3c1bb2495c946fc1380e0c01905ca23b99ed811b3dfc40cd15b0bc072baf9ddf2c18b25ba6dccd01b90ef519a96d4292ada97a0a738175a24f33c21315049473e21ca17f523ad9173e0ef94d08a12caf6d2967f0f60cd16937bf2cf54f15753b547481220b129cb77908841782c7d1229f2a6ab5c415a6d46bb7cfe894f28904f03e8d2133a3b97be509287872cbe0e0a634ef78cfb7b1ccd303866a97f5ebe8e707eb28a3e1fbce870c4e970e6ac8b2d05cfae0df869125e688c590ee46c3f6d4879afa05ff88e211078391d44b2c5d0561481e06b1cb7b6c6ec853cea2b2e33f97166dc3f9e7a7f3030c01d443e88b0400ae68b3ba395d9e027041baddd0639452c3f7485c6e4cdb056f7d0109c52deebeb59502e24309cf610ce32c21bd788fb5822219f6c5b0010416b72d38d01ef16bc433f7683516309d10b67e39f7afb407069a7b8bc06d1c00bd4e5fb94ee009a9f22a8345aba487ee625b7436a9b82cc32440c6fd71c967055ba367f0f63b4739641f70f535eb2e7de80299826597be687b276c7661c7cb028a4d7b52e42d7d2b8de56c8c9093df2b34532bcf0d0be34a22fd650019d6fd083e52c1d89b9d0443b9eee677d1c5ce7365d48862f35fd6bf7477ff18ded3c104a19a528b6010ffb7aaf7b1012caa02f767ed1c104670433ea21b52cbe434aa01d216c955ac5abdb8a9e0567dc464d16d57b77201b832694d18ffccfa3dff800481e8e2187b761f82eb9138cd29249352c723d7255131b9910d979b73bbeca407bae44aa132589314bdf784760b9304fdf8fe09bb982504f9741818c2784eeb035e77323b031152f304de67a41272512e0b27a641024e66d55a136c072dca8101bfc57d37569a5a7920ebc0152822aa30facbda6bf98e7fa505438ae12d01fc00d56349553f3c886990309c0fb81ffce45b55c36565639d8149634379eb30c702e8b532c5212c4bd01a472e73a3ed8e1acd91cc006e2223ab9f0446b22affb806d2c732e39e3b4294988e22d18de1d20e883265ee3f30710a95896b695532e5041ef754d97038cb993170df1da9205249b6340be91497c65000c909f1658c7c006ac2be26530829f2a6e212736d2d9930cc129aa990a827c19d8a26798a3b6907924805a7be40f157058fb56ae352a46948153cfcb56fca8b2498d68a29bd290d64946de6fa58aab0a48c2a1f935a8e8399017f631dd26585d3011fe67017490eef81545971c09bc539badb6584e1c3eb348dfbebcdf0c985ce1d033e0ccad3089c4c68590d09931078a3578131ba60bc99ba9f97ccb126f09a1f4e830da46e08463c73779e7825a262f58485ef1f4b646480917554c918e01883746a9bf01304f5166f960e1f9f526090062ba014409daa902df0bda3117348d41367473347005509d37d8e76ca9b584d1a891df3ffdc15a9af42642e50af7facc7e05051f503f854aca0adfa47e0e577cad58f7e4d1b832b9758a271431d288177f98a4f7e01f7b7b38fa5ca364711c3fd6afa821ce30d7b7904dadd7eba097a1c45388af109074bc49a37bf052d0159fe6d387a5f189e9e80a1e8a427e3fbea43d9e3a63109978de548f730de936aa4bf6523b8f3f5813db40bd50307f9c01217211ccea906b75c6b9ece3f21dff2743a64e43a4e8761ea7441c9ccb84f690ac28bbbf9330a97c2292eb0f4e93fd23ae4d80e411173a8852fa8777a7686a6a7b36dc4a1ba0c8b47d49ab1fdd441e7f11ff55ac69a0100ed5f3c2620ad424e8dd2e8d904cf09abca480a521327402441f13218c261d203dcf749306bcb8d2ba5964868b6f40c9eadf2b1293708141555f344e2ca6cc9d70da41a436d50146939932113b0d80278ee91d52594ed70ac2941635e5de065f80d3c36a9454c43880021d2b7acb00cb25642d2e96220fc5c55dd0538f2d99cd4f016af5b3d9fb66a1f036dd35e680d0f1be30a82278aa1c31e2d1c2030fcabe09bd4ae74968bb090ab9ca456e318020fa04f52ccb7029a001f7dfafcbd78bdb4f13df1af294cf1aa6b47995c3c2709bb3d25004b830a2301f35883489edf68f66692dfc67d9a31c7d7bd95aa49e5089a68e3c858581963ba06696f385b757df19a75ccc3ae4d9052ffaa082e507c0ea0ed36dd1d636891d4c52d15121ec425699d38397429efa5879d24d773880801eef6a2f1840446e32c4e802b94bf5d06f2c1531a969a9d8b2a27cb781637130bd8abeae7667325fb549bcbe3c5f7f8c04895da17743e3a59eb9a17cf5361460a1fa250d6a2b1f59b849f878d62c4d6a415b78183c4779cb75793d62cabbc3107533dfd11666d749174184240c7fe866348defd6ad74285017bd88f56bcf3d301fe58d8f1cc3e79e2fa79d525e018b7314eeba6aced67b6ca3ce2957f86a16c0b8856e860a3192d04f8d0051f462f10bf92303dda65992247b9e5169b9dc4b600b73c6ff4d0cb40dbfac67a172f432ab291dbf93935528f97e7e156b6ed75c80fa971088d66e9d4be33ffa68c69f3a18c9734ccaba7774b2772a5c6ebad0008094813e6c1580f6da36c8622ab0075ee569d060c4e1dc5a6406dd2ce7ca3a7340f8fa990be208626fb0ddc17599457959fc114c9f438da2656517b8f80842ca10a4ba67ecc7e375f6097ab5e8163828585729f14c5d4736f7873c8f15aa621a10366d64e83babb0d1386c08258ca9466d92603d092042cd5aab3dce296e2af7506e32f51c070bd02813fb3df63f6f4a9528610e4a3220db692e2d19593324adf0dd3b9bd0895ab9debc5c7f137fe2047ccd8b787d2336f0666157dcdb2ba80360a1ceac615d003532b960f0310bdf8140c26d4f43711e1b07d498a6f9ca5fc280bdbdf8ee6046023ea914f73c99d21bcb2011070ea45894aa9f0c16489f3ecca0d4f9afceea617ce63a823de7a3c89766d00f6f8617de9b5e29834b9f3601b4d030beb2df0ffe8e35e58d8f3eabba139cc0f55b95cb52684387c6bc70afcbd300d606295f43bf5cc0d5ab3a13a586941012c618c1516c1356c3dba5a95359836082c3d5e8f67f10899b6b272a09c32fa53fd4dc6992b1f466f0698f4a2e0e2ca09bf9b17dfbbc87e6ce816df803949128e06af1701a6f7a3751719820a015c5e06189c26187f8e0eafcc99682b4521647ba0cd59330f6ee4d40612400f4a74ef0f3e56259d9460fc733321956f051c6c0001df6d66eb61f0955379fe835b220f0c7d8b7d86d30b09993b83b08325ea1d2e8c15c09adaa672da7514afb5cb8ca107326bd69f3af5ea9c7c7b94e1fc71b338914df206f133945f89e82d14dea0970a13f3e6e47bb2d8a7e2713b062a770f0d628779eea0a06ac2efa766cfb08bfa0bcbc052729652a37c5be3126882dce753c359dc8e259c50086653fb4a74e7bb0ee1337437526c57ff4fc3d3b8933168ce0545a1c310f3a255d7f2e0a8dae8d0061c1ea7082e925530617db21e2ca6d8a849bf1376715c2d6cfb15d3310037df0b761b1986ac578a22ef12aed1382c5d4c5df21a3f2acdf23abfa969526b020601506f52b020582af4c68e6e28554b50117f30a8e12ce995183d95ff6d39436f0c5032ffd8c68780b73e7355f9ab1669b6d411be65c59117c4510d7e86e7decf050913380037b4d37d12bd6f064a754d6fbb70658dc5ddced808f975f949e201067ac60759870bce1f2abdfe0afa01821e9e4d33524af346ca33dd83887b9e8b0afdbf177851a9af9d1a0069f14f9f1ba872c157f350356040d44833dc373a3203eb8406692d5faff6c4c6a5a284c93307855835f99066f7e2b9199d1b2decb908e349e92c810a3f8ba2c09b6d9b2bb4ef3c127892fe7ef224acdee1b0f6f24b0ea43df5af11f743496a2144aff5d684c06f4b7db0dce6214836f3a34a4f820703acb601f832271af4cbfac331e53a76137dbb27647dc68a07b40f3c9bc5efdb06fa0ff652dc4a672d499a064267eb2509924b0d32daaa194683de9e8e88d24009011396fd3f340dd5441b28884fc1b884577f4425d0e34e44e4965626df314607fa22b0458a8a1c30ecdacd8f2b945435c70ad98bce72e1bad19230b3bf11370a328282a0a27c21ffaf5c6efc1cc67c2cee9c82d47de0a4c695b9f9a9ff686b02eb657b035f3e667d4854e193faa8be2d9fe7dd8af4cfe8e0295158184a6fbd097edea93c5b08d32f78af9949bd04bfa81ee751b26d9d5ef3d05e3ffcb92bcb004ad171501fff98a096afb3362dd2a5da9ab49008f70b0982d33ac1f146151201789deb3901e8a893060b4257235ff0af44c19096538c65a26339eee26fdca908cd4d6984f7ce2a55736d1447f87b8ad7e4ddf090e0121459012178d058194109805869f3663bff7ec96c3e6d82b3578ff7d034ef90e0df09bed1b98bc4ef440e48da9a20057613badd801e5d171b5dd63376ca7dfccce8624fecbd2127c4cd0ca7f6e233e6cb82ff60c7df350e93913200bd38d790a3a96917621c9f7909fd03cb31b0ed286f507943e61f335d94520403da1dec6001417c28aa8ec4851f320385512da3f4b365e8d099c79a3863063ddee8a7dd031df2a9a16fcbc10aea500de691fe6aaebffc75ca6cfaf154d82c703651cbb7cdb3f49d1bd13780cea4420da99f576492ab2fc2b19486dea1efb8b9827f20d4653c16ae805db5045995350226bc02642980fa4bce81034f2ac0f1136b2bc4361311a76afa46b6b05f5ea80ef72801c73b8fa9285d3f017cc0d73196caf1ca12cd739fa1165d91551628f0058c19c4be27aa6c2f11353325d84b8bc52b7f7441fba4f7de0252493dca111f02037bd02c0ede74c46f95bcbd46a350bb6b182b02f073ad5d9423cd52f8d2be04814ddb688f26343e5c1a26e15bbd3fa2999fb8f7b71a04b7ab32873751fd550c2c836de2c08b33041c6c573ad07f8e892150f7cfea1aad09ce94bf7c9247aa07bde6cfec771b72a6ec8de0bf34150358b9baa70d9dd8e21ab2e52b8b4c2f2d03c6b73eed34b8bc7fba784ac945bb60f8bccdd0701f080565df8a6a5809e1bb0eb59ad6ef694394a201ee15a52e4e0467f32a1132335a6cada4afa022edd1c90da58872ef0d308f23e34e759a38e3bc89589b039a4d834acbdd1db0ef7b560407953e4b4e0393598b324e4fa1309aeb5ecdd627bd99fba74a118be64693a6f7051097109e9106213b7d1d2b81e4bd0f3f3a7580f192504315610f78aec364280d127d1072c2f36d82d86c525ed4eee57eb82ec72ad55b411a40d5a947918fd00309078941b3141d0e91da75978fcd315b23067afa27a653b8767ba9f621df2903bd49c9c39d1fc496cfa1e04e255c1dd8fb2048bdf9b0b2279f3cd888378fea0e756340bd3e05a7b5efffd61b23644f60e74d81db64b0d65c3062d386e2606a003b2074281236064d1e1c4e8789d7415101e94ff4fbfe07af612131337feb4100d3376c4da40f3dbce96b2556b214a6fc41e3a1bbadd56ec7dd9a64bdbc6e0d0a182993b1eef921982b0d646a07148f6fc9bfc1521533de376803de69c1f9200fdfc0347fbe52babefed8768c51810f62bdc73608fc748f4555208887acbed20a7f01ebe555ad7e1912a6d5b5873f86d698f1d2c88616143bfd6c1b4cb26a6b0639e5e4ee7713cdd1ff56e5af720a707af43b6c6feae9a6e6a90ed5694ea85207e64f8f02adaacd3ad35d57c352c2a845b68a2a79fd589d1fba701d9d4068ea06a9b80bd604373ceffc04298ba0cab2712711e017c78eb4852d0f7f18c7658304abddf9170054872257e463958ea0a956bd3784b3e8b94380b9b6eabe8610ae0f02d1e25724c69561a2767c585acf832237fd883b80faa3a033f11e35fc70ac07c00969f7e3decf94567de3cae901b8cf206a8c5c2c644529c6c1322ec09c680c328390cd0db82aa329aa58f696798ce968367efbf5c3771839c57cccbecdca038959c5d32e68dec1d03d2a1f61cdcc2f1e9b6e93cad0ea0653490bdab3030b0ff6602c4e1e5599927b7b6cd4c29a2e5861a247f6f4cf492cf3ea147e3f7ba60d54670eb3ad5f3075eeb0d66a925f9fb45c75d1fd4a0f7b431ca2530ee83f1b021469b3f52083ca2c38ef1fa82b4ecf1001947d1faf9485c537fae73cc125dd0a43bece5cba59101a7e91a5f56665a251c9276fc5f60575c1bc70cb3394f7780e9f4617ccc73176cecac344a998a00c13b5f6442a6fe813a549a6529a7e1be9049385ec0b23040cb37b06951f1dc79b1abb726765d1c2e2d96615e7ebe8ffc40e066e16222ecf1f2c0537a3f07ac27b45bd910fb84abc3564ae0957e9bef654042a674692bef3f71fbce8b97ea9cf4ba6527033038da372ffbd973e25e9481f0f9e7215f37546521dc0e7a1453e0a412e44325999d5d8e41c7ffb0662aadcaf0ddf7646b72eeb7617fdadb7ef66984b2f905266b0b856a69f31d864bc3a2b3e0861db396f4624a05c13b79dbb53f604c2dca13e9c995fb278c84ee28fd7e79d0990e25a4a94bd02fa5bba97bcdfc494b3b0b01c1434f5f1101b7eb9ae36af9f09676890a824cb595a77e9d923aa8c85e7f596d2400c7c21d95e4eac852890a10c16b49895722aefa3449d221e32ef63eb9df497d440f7437fcda6ec955840cd01a81812f0f5236bfb36214f03c4214ed4a617d2b77430fd1c3d8f2fb5b190750e13a68f80cf2ff293e684b53b1518c8ec3ffc2fde84d0313b35fed4b5ddd61204bd6d0a690ba2eb9c9a1eeb3384e5683db6413836dbf8180949494f82a1a28808ce4ae9476697d8396d5a46a134b972664e9e9931d235ecab00900ccd8e7a2400453b9bb47eae1387623f5117a2833cb112ead35044b3b59df7e149b0ea6fd10b2c096f1b054afbc389b7b6819434651ddcc59dd82426fd753790715485410106d9e67be0155345d926b134463529dab9d56f6e62ce3761d5d6a38e0d1b1ca40e6ce677ccff063b231ea9d716c55b948259448ff7bf71d32d87927fa146bae20ec7c6896dc3fcd3b009cf77e49a3ae99d6e7595bf6d2ed8581b19f04c9088080adc28ea2f7897fa89739141812628ae4ee19bf8d9b94ba0866881e20d9ab39b0126a230f8ce41a12a60a928a6f2f8a1239c495b07f7ae0b50a55f1a863c518a008f47c2248570720c7773f69ce538a419ee748e5a52db687ed55cb1b3aa5d8a001baf20830ab642bea17700fa09d2e78cce62f67834b9e2600f5d8e4fa4b5100c5eb84e0a49e31db355af53ef186609d770f32d689485b7e83127256f0ce545043ed3ccda06de21a78de04e8ddeb0587e59b349df9d012783c56798d5fd47f4093bc32a078654bbdae7704f4e1656585289f806ec311b985db81b2c24826737086078c347fb5402d842116c16db3910c8664dfab4b745b6752bf4f37c24699e045c0e2027d39f2686a0827a5eaec5fed6716ff1b579e0359b63f5290871a636041816e257e0224d92f892178a568ec2aecb13baf7dd76a72e80d8cd4360228d0a256672ad3f92c9c3d7b283c13563b987565ddee16637f42ee1719b4913c6b40def2dff40e6db8e4766f7991737c4bda6ac073b6ae71d238bbb588abbc47c3402d5c3155ebbf68eaa5d9c3113c83849f16f6b717ac7fd1428cdcf872bcab21402c8e2f869421a91003aa01ffc714aa0b5761bd1acbba2ab7162ce195e548f4006bb8121f873a5d788124cc544fe2dc9c6af36ef5c58dfe2fe3719c802f04a610a0d14d2ca564c5a19219eea89dfa86971dbeb7e285b56f2979767b1c1676e760df129ef3ee0ee07c6833586dfa1ba87b10145fa71cd9bd4eb350b566df2728e0004f4e04341aecd0a13c8e867d0ee36654bba598ec159c574eafb2cc0430144092cad78504dc2bc537740df4487df5867d5f0eadb277503e698523ebf8e831b0ad3543bf99a58393e38502931a2b09ff090b4ac839ce5ebf43efd914d15c16208dbc6f3c08b68f45746c58a801ad8137bf4200a4e33e345d3eb0f732395e8210c250d90a0727d65b861a0b305b5b1ce363551f263cb1493f38f1f7bbf32f75203f04554100d01d2320b71f40adffe6d3c81d183a0cc1c5027aa72eda1296cfd002bdf55276c083a4a2a7992d78eaf44eebc833d9a50a8ccad7114dff61aa1b304ee4b31b7a0849d44486e2b4bb230988d673145ee9c44a47a14d846dfbd91160b08864c7e427b5b685814b5761b0f18606f58efdefc770b5b04dc275f0b18820901e0822be8fbcca957a837ae2551d9d31f76fef69d6de2f02bc62dfe85dc7d02cd96cc231f6e84a75f25cab604af30055088596ae0012967191f77309389eb0154bee63a985bf91a1c8dc35d61a049e742ab84c74233a75571d04bfe707ea20d0a4019e66b80828bb62f6b19ae2432c5ca9e8a5536cbd786637a3662091df70c2251ce5472ece9e4e969bb94307a0c935ef0a76aad894100b5acbd1a5b458f01e63dfbf03afc4483bc36dbe83f171204b54745988d85068e2f6b03be20be1d0e6e1ff71778967bda7ddf9ef9532ab5375eb597ad0ea8ef66182f96b2b53d7c054a3fffaa57f76ec2685930dbbb04e43ce5cc7ec9d9b94fd1ab948bf1ad9efe0f7666873e17f0c716059dd9e7552dd709a19df5deb88f9c48942844b650c12804c323f193b2818dec05f1b20caf9a0ed33a4e233ef485bbf42cbaa61d05c5e30f8d6d99bb15f98acdf03e21f83acaf2876ed7aedadd6078700f309ec14ad37d0e85ecd77834062c03ced5988c0cde6c728079994ce206aee5efacfa98cbc91b0de9a2f461eb24a0b4f48d1ab247f91e124c2ff5210e1e9116684389f7305c690d2f4fa4424b5687c689b794b3ed6c6447b231f58cc78359cf9787654a0f7d400de87b1085c892d1c3c638d7e2a913e729fce10b3f3fac26bfafc36285bc19f20d336eadb95c3855debeffd37893871ed2f9b3badf4f907cec4e725506920ea20793364b225fe0a4efbd7b3b4c653aed090719be2e2ce2da2bcf32aeb8eb3539094341d57458ccc8d02809195f2eb26fd357eba685a273196d93be7a40fc5b5e0bb71305cd514116038fba23a6d5b4af5e3f8ea4749bc4e98e571d4c245623500f6b891e1dcb43d98e686baa2812ce1e3df8171eda0d7edf598896113de968fb0e2cc3dbacc3b11f2a8a0c51f9027c42d5413d7224a43aa743d86eb68eb5570702829b6e781808fa974ddde76308cb52fb468c95395631e4aa77756fac7e728009ee83cb4b32184debdb081ef686fc5be197436af6895f68547ed4310c4bffef01217611a49f4dfbb6558bc921b2104b93d6f9dc6eccb857efaae17c6857d6c002cdf69e9638c3a3d39d7eac417601e184af59276eba78393e3694a51e88af2b0b71c65dd68ead6e1781ad934966c49ba397d5b2e29af1750a49e78f52b927ad06948d0d50f41f6826919f381181320c93d40b116af14915627252402d5c142d0c04f1ff883d1c8d038f81671bcfe6c2d8dfa421e650e08bb693fe8c74ed7aa40f725c6598ff7adfa607cb54633837a42b5630789cec4ff96265245a4c17fe1604313d21a1b2014f97b6715d49aea09db9fc72b9779676946cf548713119731d00ffe61731f274baa4b64c917262fc989ba18e2ad56d2cce7dd5f9bbb687bcea0fe2ca5208b9d411a278da2ce1e7b7be02010d2eea3359793112cf85bfd3e9bd011033c1cbab13c93446130dd96963af5adef736c92ea48e670d2b83e964db8c0e91d75087462bffb0c9bb07bc9866657c58b3e435e067624b3c76a4b7eacdc4045f3d5b1eeca6fe8e79a69be8def414f69a64e027037adfbdb9ffa047eaa6d00cc8e019c93e586c1d49aae48448fe4615c94a4a87f133b485f3c2944cd5ccf30c8db78170bec9bf9d735c9c01c7448b59284db2edeced56662d1bc47ce447b209e0cd5ef5c485f95750989faa775cbf7502d7f1366ea174773fbedd1add67ef007d607827ce56314674fdd343bfc479829378ec85d74f81b3f6bb96a937c10505938d31fa798ef0c4cdde3bc45441f86a3ea8aba63b306f71a7883ecac510c40290f969359906dd6e1da470a40657c3e5d6be1a4412778b98a6b23f6e71006d04be8e6c0e5f1e58b4b65e226ad68d9232492d242c79cbd011480c7f363c225a0425ea3d411dd90356e7a501de70ac66dbf54080ce7e9780dd96092dfd1f7fcf0b4036f1f16b37a6a0714ce169b85e5d4c63ef9aec9070614edf0689b09cd8ad074a1625c02ff6c6e0bc5ec584f8b0400ccb8cd00c886b6a00321e3ff8945a8605eacf9576dd04fc7e9c4e5a668bea8bf9345fc721efd5cbf955e563d983418e09cd27ba375275b6a59bd5089b4ead9d9a832b27574e19183648865967354293002352ca8b1154bcebbeae7ea7d6735d0a89b86b7c13766f25e4fb779a6114f4069149550982b9672c3fc2f3b6d2f34fe98f3dee730f08885c06a6e2259dc98c0f8c6edeee1fda2cf82147f69fb16074a590b2f687025ef5fa3a18d84c60548009b14be88d4f02909bdcea592bdf333be5498c0a3b80a9a8c81125447787058600523b3ce98cabe427651926bcc360cce67a6d3801afdf42ecc81d4b775521ac0cf40b7420996926fc4dbde204e2e3e817c5b21ebe51fb136ced553feacb1a310c9902a058e2bcb4d8f95479d03870a7c57a612b34f51e1854ec0b9e08bcafe10623d0295c45d6ea0f3b2ba25d6353e85970947d6ff9dc59db086d9c7a835e21023196948e468e84c66c0d739764d129afc88546de80b1fe25e8dd918f39495b0fbe8b695a33e456a5d42b53173657d19b3e915dbc2b4bea4bcdbacb68fef249071f211627d2bd59b2ff728e23c9c155887ba4599ab8e9dcb42e9c93b83e4a1e094a46baa7a488a02f08dd49f704bb0be385a143f5ae16d98be3df2ca969ebc8031e8cee1c2284366cd16ae856677017066c65ae3df55edf43c78724bde7223b0862b7b987529c659a5c77986c7c695f2d7a6c5360ef32019f3fb7bdcae141850da0e4b60bbf9690f3ab38a1b1d080630b2f412755aa0067af9db16bc2ef772b0d5e76749e44487071b0bf5a38dad463a7e667eda89d49a44239022b030afcda08ae94fe5782f0bf3b2b13bd802cf0d8436f77d758b4e85e24aa176ea6a843c40635dca6ea99b2819db3be78b5b51a086f7df513ede30b8f87b7a74d0eff730e06183915a7595218b804d43c860a00fb1163f43cf6856927fe5340b14737f011085765d064de3eaab2f9f2008875e2bab7650724974c1a3e25fb17583f0c0e480888fb6ad90ba8ecdf7de017fd0872ad7081be6d0578454594fcd6a357b375670c2eeb9045f3b6c41749d07092f82398b6352f421ba8f001b20d8f56010f1801058363109e1176d3a52e5bf39a90d410909d104348c07992ddf710d0c6c37aff069538579928b2fad61bf6547ba9a4f76e97484c098837d13521ae9a28cb7c950eeb8da6eae290a3807d0225ae6eeaeeaa5fb92b4f8cdd7f58cd997dd413d0ac019d3c3ac81999adc15b2f3f477f697f9a10725910a272aae169ffb6e66cf9f0036b8bc2f6ddc00a9dd7fdb195e04ff82b607277061551cf7b9d9608660dec920214631a4633a6c7172fac759bcada8062fe049b069a11907d7ad245ca60af38052d8a1562e566216bcf0aa0c3101b10fb755373a902d0019e13662aa64dee1003e5e187af39eb45a503dccba6523b377b4037c881ef1683f7a0701d5aa65eac07eca2f8928a0247229203a193006099d0916efe35d537c96690e1e74277b9dc0f7a2f243145b5a19aea7f94baecd1e6a9ed45345b7dac7dc45a7080849a3ccc07e8b5149d6d9eda453c2c5e4a6fc28f02371529a4bd08a7625a92edf5f72dbd0a4495849d925f4c5c230a04b93c404e97bbd727ea4bad28fcec45c57ea07b1207323642bf00300642a13d614b079348459c1b55dad50b33ba50788a0fa2d85c077d6994a5e37d9df974476f6a87dfc9b815ac278fa56f93ec55adb71edcac530b1b3f906d612911686874377d9b21c7bc2ccb177f059e7e681b158dd70368cf042fed2098ef224527a36c08da0efeec96b75fb0fd5abbb26a400b2e1a05decb0e80dca881b5892ab27cf119d66b46ce39a46d8faf38dcb8409cca5a64ede91605393f409913546c6be6b02faf1df09dae9fa50c745fa37a88dff98fc1916c5a06706111febfe51bbb18a27385fed2af8c4dab29d3165cc8efd8d786b44cf352057af67c11d0e0bb38cfaac45deb03f82aaee26fff01b0c84c5c07ed9240fbcd05f5b431a3a6e49c5397de0b1b9ff9f8d7ac52bf68b0227f71832a7bf24b62960eaeacc7c7a74bd5ef3aae2663be2c96e97ba6ebf1b0d59104b8b450804b86b00052b321f4b05dcffa8ae6ad5fa28ed7e4a55e9724b1dd8ad5e234d24ee45d2d025e7a5153df09ab8dd4db0754ceb1ddd6b9b0d442149b64f40debe1b2b2fca403e9e19fa2b6a073b197235f4785d0eb642afe54019c20aebf3c012d257aa5b2024845a3cddc30a0551cc355d5b95b0797f607c2d0ca87d6a1cdf55ee216ebcb0b11ecc328d5dc268f7d427d718a171a468c09e58413008b885f449e9d09036b0b5260489da9872f0fd20984c95ca31630ab5ce8ad4dd9660986f841df7d775905cac8298f1827b57c8afe889818c4b7f149e6a1d470ce6b4b98835c5a2368e30e1eff8f5857f6fc965c3a39992ef36b685c9c7d7fbf031fbf96c18ffaaaef2800749bef99e4252d8c7b0a54c4c3c9a62d8f4273fe0c20424a094ef86b2ac2340e7a9c23e63f6f504c57c3853cd23d8baba31c46af8db0b0d914f7d1bd86df36094725758920d134d6f08cc1dfbf1af57c3134edb14aa3896ae61a71f25fb70b09ccfc895e726e2fca22223522d31b3568ca528d7a2186ece2e925abc2ab82000adffe11eddbc7ff6e41de5f3c017f1bbfe6dcbde1a86f18eff496e9c7c6da8e04bd1b278a0853578357812f9bd6f7a6c9afa51978eb52f2d4b47dabb6ef5d950c6679eeca48606673e39a28c934a9ae81b45126e9a1ba087258b873689516e40ac1b658269f20085bd9eecb9a2a98ce10dc4fe9a415da3d79574b1355837fbb01bf7697b02bd83e73ca0fd8b0f8099aafca372f1f24a0ea0abf14edeb9955dd07acef72619beac0f988a6eae3d31f73444504e8ab4c99f76a5abad30dea1b9300bb00c08e7adac621a4c7e22e22c27d204dc376bb1e1aa22eb0b109e68d9d490cb391b6951e70f927b3f21954c60e355c53f02043f962f353cedc7df93e975c06ad74d864ef0f9a51c0f2ec40d556428395e9093b4202e3153c8494734caec40ef37ab4935397810a02b2c74190076600fb9625c6659656ef614d09a85b294b0c46264950573dfc85220148e8850831465e07b7f7977f2e4bbe22c4ed7dfe5500f6fa2e040a0b64150b73c309ff3b173280b3cc483ec3e0119190b082d27a7404b91a315570fa3b7ff11ca5fce457981bd2cb94ebd4cabaa400312fc52921ad04afc00335b2308ac511d175fe06135666d78b92f3e9626ddd6cadca00483dba0c4d05e2f5aebf6ac791d32c5053ad86e333b4e658b821f6b3e21931dcdb826b06a44bb0871e13ed113e0e85bec04ff2d0c8e04ff5f88f7cd8cdc8358ef05595000ee54f23593efa4274066737dc3217ff3dc5136b2c1297f1370f09a156c8c70cc40d6229257898aaa1f58748a6213f0b129a49c22055f2603cb1340505c8370db63cd38f0989d750cc6246e455b8cfae20d61e2c7a23e16fc0f57ca79fdb610d90dcf14485338bbfa34095d30b371062d4e3d16386e3e67bd2630f4c4c6a6706d7759dc6ff470712698a5221e2a6ec65bfc5d402fe80757932871b4f6985670fbcbfdadb9679734422abd06d7a3cbce5b9cc7ea742a20a70aba43f4708525e06aadeea955a5766f9e2f12e73fe41f2d2f8fe7d226f7ea5fda710ec40f505f20dddac3b286875376e9a85b922fe6538e0c5a8d74968be2362ec9593ca1e663803493abf4910c6c125efe63723d547407b72532855928574b9936d43c737e8e60557be2c442536e687b47586f4de00c0008fad967fe2e215ca4f82a3b226064702a7d97f702a41d46ec8d0c1a1a78f9a64825286c10f78be2a63e8948465fdf4087d2651ba98c8ea02c65d118cbf42ed463adb57e4ef6c72e4161c277b90862f0be4efab72419902c897a2be6f1acbb7168e1de4cb608f8ed0dddc160514067901510ff35c6eb5be79c435fb61d980d11c536cdf1486877c8683227a1a1c77eb0a89ada8db579fdb8d510b55772ebde709f0f4e3fd2f0a2dfbcaec60736429380175fbaf363cc1da4e0e41b2a8411a0582060a319c0e380ed9ec16f44ad0a0a5005b0daee73b4023792e95b371bbfe18934a0c60eaf7a855fb19c671ca11e2240e461a23985e865131ec5a53a64674d851f0c4da77fdefd83ba3b1150ea2215f041ad4cd6bdf0c7475b833dd6ce418040c72dd10db25962e8dcd488ecf7c143d0219c48d85902a1f2f4bde81768db0ccd94c48e070dd5ad46594eda7efe5395b0e700681a35dfbb90f8f8876c97acd53ea2cc7004127e616788ee07942e00d2c0cfbba3ddc0a0686cfecfd5f825ac29ff98c042f5e4455be11e690a9a56cf53b01 false +check_ring_signature 9d6104b274f820f1b92f67104ca896d57e6c270b4ae1e481b5411a1c66a26e30 ef2aa9292397f05d749110faa3a4eff6ef24d9ba83355f5b3ec889ca0835e734 21 7afac15970f637c02ff1a4df0f30370f9abeced418a4ede5cd749bb639177187 ff418f12c0341173d7a3d3badfc8d73b2bb674571afda1c5509eede52e23d0b4 8a1082e2b21ec2aca3081ac724e7ea52549e74fdde09f9b71f6a796cdb152398 714ce9150647fa5ea47185f5ad7c0ed7238b759c1f7823fcb7800bf83b598502 456c3070462bcc42bf9a3fc93fd367a8d4302bb7997ee4d93843cbb8efe0bcff 3b2b1cfb4770065c8b76990a6dac9abe259492314715df543a2fcbcbcedd99df 9bb622cbd7ff35214e3b8abbc25d01c089db7a42dbd62d69a3564d26cb9f0d55 d551a239b3944c2a3a277c039afad1be8ed9aa9ece970323e50262d522b23142 87f2d120bfd7c989e81fb53ddf288f845a6643aca5710a03b5f60dea432c41ba db78036eabce37f47f20a00bc7e657b55513f997fa7b600ea2504fc09798f883 1cc7ab351fc36c3f71748828bbb062df9cf38e3b096f4bbf6073a48e3c87a46e 73dfc0594c3b43770b2f68f1ec8d12d9c3b3da89144fd9814d09dc606064d322 34b1331598d215607d7f715a0fd7a9f351d31c937ba1e8c481a37d9805375d90 eb74c4dc38eba5380a57b2039bd6c34749975ec9986c95cd4b65e27e7e682898 0c115c4bff4c604163a191c5c48097c42e91896dca2f33a8d2f0e6931f43fbd4 e217dd7c45b67d82d272c6bd73c1bf25ecabd13c1de987e2e2dfe7c6146f0d48 c96bb617bfbbb3dad8cfce4c7dfc92a1c74de2e83cc6cbd83bc6967e8e906df5 6dc779cf8d2cbb00197efc30b7293d26ed23265c0da73b0b7718e6b484414a71 fa2b4ccd43e8887f343d8189b241879498a75b1082716027b0bfdfd5d07906ba 97e1045c7698ff582442c44901db6c5343ad4a658dcc6473d206c02f72903ac0 4e0829bfe9503470c6f2e1ffd282a6ec45b1d06421b7be7bf360720301f1ac8a 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 true +check_ring_signature d978426023000a18e46a7fea1de5ce88b101951b5c77c55851fd88eca4a7f8fc 3e8105536d561a0b0d0f624cf5d148bcce6093f89601a5fdd7d7189ff21884ae 2 7cc259238dfa4b3d10c9d756f615679581a5d3cb78a2fcacaa18e95586058fb4 7af506dc07b507b79d29936e1a1e7590e8487e5e505187f0621dc390111af72e 2e6bfe68264cfcac935dda52eb71a85f933ad93eecb514615691c97c9147b0098be7ca921fc87255acd77d0e4db9a0c0f525923e02bbd3f7ef46e4380c5f3901bbfb2873800f5403f31f1f955f37a927a2d08d781956091add83c11f6e8da509504f7c23674839d5df464def9d127df6ed48b8c0b634afa02a276a4bc95eb70a false +check_ring_signature a2affc7b38d0bdac368bc43ec4890b7897ae979e06c47f9cb0fee835b80f17b6 941ddf030084ca8c6e7e5f82a8dfba10df42b913848fb94fb84e145f5fad2bb9 1 62008968e26414676ba91c2bb58de00ecae3dca15fda5411f26396b158314c0c d025dda47d55571de30ceb483af6a3cdc82ce3901abf95031e2c79d4b0bf6806a585cc50f7552fa9d21d4c56075f9a384c5a4d4f9ca09f93d4944d12cedc3e02 true +check_ring_signature c907a24644f1f30905f62bfc54c6bc2fdac09a60b7bf5f7fdab86f7ee845cdcb 58a0ed1cba230a59152967a26263d9940f7fea8e2371ac5ca6163a6e65d7be4c 3 d1880852612c340edcad20ac5ed1ef95a6397e6b4ffaaeef8ac7d3962a8f54e2 96e44054f2130f85503f4e660294c3ee11e7d5e895b069bc135ba8359b525ed4 d0b58a291b73eceac3977ad206e1cb1bf1b3a7b0694becb98a6b8700c11f6bbf 5bb8480e32770d09c7f4309c31c9ef563f9fd526bda8aab70781d9980272b807f6fbd299ad1a235f5984ed027f5457f16d8de3b66a1fb0e6a96d11739932990bb765dbbb37669c179633d8de4de20973e57df069c56182e5118510afd8a2bc019d41e8cdf824890698a8726f4c93a380795afd2b5e5c7c3249b9c6fe080d8b0d83769f1fd3b0003d3538ffdb3ea85e680882b2711a13d3056972a03f8dfa080bd7bdd105fec4643f3d149752011002e390cb6a0aad94c33487858fb368f82609 true +check_ring_signature 9f3c100b7178c342631ba324e262e513fe418caff15c78773750658ef106fc80 f14b87673b43e16540d66fb7c021b4700f3bae0a46b9b7124dd2802a4350fd3b 41 ea22a1c2e1fdc3f1a8e1c729853196efeaba58ffa8b86216f69f41f1406386df eeb99474f478324240d09899c27607fb151f8c3d9d351981408268e337085b07 1a157eff031cb14bab69787c6c831e5a0494915193e342677af754f0ce85beff ed9e46f657582991d363adae6c44bad72fde0cc7aeecfd5c12e998a7816f6302 97c10d0ea2eecc6f52e3c2b5c09671d29a9a20e34e801b41b3ac6473c907112d 6c625cd80cc488e55cbefaac76536e0ebf10c5c7e2bcee727951f932e6ae8a1f c2bd4303890aa531fbe9459d1718ce98fbfb2512878cff3682da4ff8726ab302 552bb30775ea3dd6f164300bc0f3aa948873204152f737619f17a9bb18df268d 6ec3c1cae9c2a7428c60ff7bab06452a753f2591f4673bacfc6a1ae2159c3ce8 9623608bb24137da9a99ad243f294b30cd664ab1b08eae8cb28b3c840df404be b6f2d634dd0185f0d7d99c7030c130833a853ba7f2f23ab9f7feb50a71a0486c eaf2ba47497f904b3b6e03a90d7adcc03acf3d0333ac6a0b95a0d4dea8796a26 ca3a3426d6e5e3517a28a6eebd1330471624235f9cedbd57bd61fc311cf6f912 9de8366691ce98095932704a8fbfd232c49468d8352df49d35b2d83addfeb5b5 0082de5c6a825290197a93a20b6a92f2a34344155822ea910cc3ec511a718ddd 83092700eb016a72452026e64790b823b839a185448d3292939be0daddeda4f4 d42a296c4259762652c5e35f85badcf7f0d15c2b55df769302372e3c92a0b0b1 4d1de3855183ad073c3d8074462810c971027fc6495e16522fbde46a44cba9f9 0d5f63d2446fcf4033338475158345bd0f82198d42c3d2df6c44194308c979f6 ea7ce557ee64d243d89201b5872cb0df0388819f9219bf727347b7d55b5d5823 8731e3a4eb3d0253966dc749e93b58f96dcc6e902ae1b3b6b824f62da60a8bbd 8b5c7815155caf9007fd3a334d038732fb280f4ef3aadde2d6cd156f7256ef36 3b84823ec3547d86b09a2e3a48956f60cebbb17b5431e34707f18cd0c3835b61 bc5e9041136091bca4bc4c73b22a9282ecdbb7e003454f88cb5c54b98a26a7a4 eb7e1007e966da4950f5a56983066f6c9f727b3482068800cfa5710140e9a5a0 fcfafb2f277c66973c09c643d927003a565623b2f4f8228cf94ec377a2e5c363 083334f776386c62a9979af91ee9da6ee0473848c0087857583a7887bb0f8054 260fa1cca3e52434a7121643f880427adcb9e7bb9fe69b918cebe2f8c75128a4 7d91c759d81ff6682039c9a23df1b68c4ef5209ac128120688b07acd1f42d2b6 b2582129a084a6441e2b0bb386afc548dc1bf4a56894819b06d26eb45b48f9ec e794fce7e0ed0f344a41f95d47486ef0adf7f213cfd5cd1fb232c000e21c2c9c bfed0e0fe60a78cb76c87d9db29caa0136e156aab4cafeed8324818c5f5d4d57 1620e1b66b898feeddf43d5d929b5e6980f92ecd6c473ee8abf63ce0efdb8d69 869d18ef5019760f0edcb2af4b7303068faf9c870d54e678bf01c50810935470 7bbc678f366ee5e55b1d1335910f9aa0da15f7272e32f60b86d0d507486028c4 aa68ce5c0de747c18535f11d668d55cf52c3f02e69f4cf18168baa66111daf96 762b0b7526c27b2a5033439a2c5a70c5de02768c7a378da50e939964a6a03f91 598d77034407f6720ac1ed6161de5a2a11b953038eaf65d0b3fd4660e8c05f0b 9a1d45f7bc58998aa036b131d4de9fb308e07321583e764daec72595de0cf346 1628431428a5562d3470bdad7df1fcf2a362e354ed8bd28b85772fa57288e875 685c47fd5c1e8d1eac525b95ca44c8e530f3ddb1b7672a41f2b0a72ef4c778c0 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 false +check_ring_signature 91c6e6539650dbf1339b84385e7a6115fef07da86ab8ef12c75ebd31b060ff89 a7cdeb0f7d5864652677af743dd3450d351c6ecf11a9c599b98242c14f298481 213 34e986d77959c68b9b47371bc2d3b358d5abce006184748564e779ff0da1df8c ce43ecf0310dc3ceb95ee816f4f5b4b3bd161df00f982dafb53e49693ab62564 890fe8c05c6950c9e43c67940e635f5f1f9d2fd87cb9c0c43094f06f82a1e4a2 3f38bc87dab0615578f271df3499b50163720254e25808936b11c985e1696f66 31b8add7deababd3d042cdcde427acfd770953388280ff7f6d01ce7dec689afd 79a8b10d394ff19c03323294f6deeccdd54da0da1bc05e968f76f13859393071 7f76ee86e34c11449eb994668cffec36a2062d3a4d848988c48b81aa354899ba 8ebb0d6ccfdabb7c279298027640f9afa428400a511683216c29a5bfe1d91aab 3ef0493e6807cf1ae566bdc3fa8b2be67badc7617ba55e36d87bd9be16719d62 b87630e2bb87928fcbd0553bbed6180a56bab597813d04ceb9d20f05027e2437 898cc50015d47c50dd19feac0c4bdd347069d9e9a23c5c1eebcbd8e472d08a95 a405c187eed28f626b641bdeff25c39f842734b18a337a0f230759c005253a76 bec7f59b107eb87f60697e697e129ac9f835ae8f512f787dbbe003cabd7d0183 f74624b429fcbc6046dc0e62d16be7ea77ad442a6df7066589b749f3178a0448 02a50f2e3c706ea8747e4b1eebded246c27545622905227b039268c7529b9a1b 89840033349daade3e6d7363170455e7dbb4bfa05ee4e50b427398e428754c7d c317f8fac48e069eed9b2f5cff5b491d484b8df92c1fad6b0776e7a90c4c82d1 55b49326fa362c0eed59f56acdd1d6cd96b0683a5168344e300d7f430d3752c0 7d3040d4f6e7a100b68a9cc781710ceaa1baff367373a1d0bc69ef6da65996c8 7e8665d620b4bb4dfd05085c4d1b0279c6eb8af2275d1ecaf7e663dcb433bba9 fb0650b8116b9112eb3dbda47cf4538b70f5e503504936d57a994c35acb9784e c8839b63e395eb7f4cfd2c454269576924e8d90ae3283662594196ffa7b99df3 488a4afbad2c28d9bc17a0634a64c415ea60ab6db3c304ac50b1444185983da4 2bcf64befe4c46d86888ec6a2e01fc1ffcf35370e0d6856713c03bcbecab4322 ab092bdb3d26c035c2676de771bbb02c45801f20240eb9dd24452d17022a9d8a 3d0883e8a19061cd0ee9dfb80618e1b5d176085786eca13303d3cb55706061e1 6164b7c7e331b137e3bfac58023e39b5a18aabcaf90a622b70aab681972cc516 ec0a18082ab1370de6dcc63aea2352e6ad8fd613f3f42af5e2f6c4b8206fce2b 206311ea09da21ee292bd221acf54c824895edf71dc7204804f8ac117c49024b 715c09c5d12523264d804b858ecda38ee27ace7244f1478a3cbb5464a451fc25 d5d29379666c4f2bfb3ad916737e0470d7898411eaf60dcb2d859d48ce62c611 689d8556eacaf33050581aea04f6199ee1e4f24f85808502b0c82e99d50fc124 8e5b0fae66ed83779e4b79fff0a218d5967dcc483fb273e9ac005ec4651a73a4 60687fab1d18389f22a1154d448dfd8d52533401faf6ff0319290b2edcd8eeb9 c42ef98fe3cf3337a270dcdea9fde6d93d98ce7e08ea4b3775f9c09d0dafd1ff e1720a4bb31aa3bafe2e7308c1e265abd20c1f8376adbd4d4da4255bd8b7ca18 fff4c2bcaf52673dc7dba8a5ad59a08c95166243a72ee5dac33ff496df62a20c a12385b88790ede4cf696a072a3400078d92de1eb8efaf33e69ebdeb9ec6e3e3 544949797a87eac97181cae70270e235005bbb7c48388b573b0f6e8d381a52bc de84f0e0aa73993e4eb9e709d0a8f4c6f89d8294ab240268be0e8f01e804eb7e 33ab88403fd8e471a6cb809998334d8507b1966f2cee0a2cc61808d2d63f80a7 180787f77a4e87ac2999934e613c060539af81b08bae4a92f8331c09b4c77b92 4e7861750ddf9cd8f9100bf94de8f8e8b5e7dfc3a5352bbe0cac8154570327b9 a803e80f8ec38f8eb5d443cf8322f0002f423fde7f82534bdb25aa428a6b1c49 869c3e49a8b747dc0a930ff6b2793f1a4d694701b7db39f40a75de4d6b7d0fa8 26454b91bcf83ddc7ca6155cd086e42145681e2c9ae179a58bfb6b6f2308916d 120ecd3ad7db97092a4631dfe1d3ef2e8214d75e9c76e358e4afd2da5eb510e4 c87fcbc8c52acc66efca1877ec539096065bc83c5aecdab5ec61d8ed3c5226fd c41801ad74b47391541e01f9df8ccef7f889e4bb330561c07471abc9c535ff5c 19f530730d87be8bdb0bef901f056efba0c741a4b7516904a3fe0cf0a6e3e858 172a9e1af91e050d0baa376098f0c03b43bb31faec46d6c351f7b87c337ce808 d81e0afef679a67fc11166d069b978571d4e5c4a477e3623f312096b38ea7197 b52ffeb78c1c1c97b465cdeef5ea7f1c760a1892b5749ab94e628e43a3850ebf 85b05a3857ca995e63fd8acb6a8796d39d567d9136acd80dae4ea5830ceff5aa 2f7c9e105d2942152342efdf3a8c9a8ccdc2cc2dc56811cf6a7024a5c9ffc634 bba76dbdb3b2fe970f02f4f3b054d0b6cec19e30e29c8a627fb146ecd11da08d 719617ed13af90b7421bc9827c288b4c8676fdb17d2b11c332760e401f438312 196ee89f2129c74e5375ef2dd218b7ca4d364f5a6fe94ef7d477b345bd982cd1 564d9a5fd835361fe302d80d41daf6be5740dc10a25528a9ddf664d6ebe74234 15ec5d61ef0d00c9f8acd1fb1f3cd95ba317485b475e69a7f352480c103ecc72 844989979e7be24807d97fd60d9967eea07add02ef6140df6d598d608b1ea042 ecf4eb609b97ef4c8c596b01b52d7add09cb3c31edd875eae39ed1058b3b0a3b 5afb00793ca580fec57a0a230a6ac60046baf94d83e48e950ab75b5901d93d5d b66912262c7d42fc777c947b4b797bad912bca073bfccf90334016342b183148 86734aae67782b54c7f3b0c7cabd25df4141ca0c3c12d5626ecd3cc4dcb54be0 752e93a149039c58eac3ff4e84d1daf439f9c54a3984590d47a3a3e5ec147f77 f132719a087b534118bb7ebb3e7e2560571aa7fd8d55c0fb0dc711bb98ec4f66 9928b5f32bd682fc8df0e9e873c261ea3c34aedddfd693b4b9bad72814fcc6e1 256e13b3ea8e020df465ad0b4334fbe36bc6f158e8a4c9ea6cde79cfeea7a963 faf7c2c4fd18bf1389c8145f5eb16ed2c99c006997491450ac801be9fbeea032 eb7042885e554198ff2aa47e935e02528867fa5c3ff0c60084589c1b0de5db5e d53ef4bd2340f64798b65d95dbd7b7539a21550dbf0d49c66619f708a12bc3e6 d92fd78895ed2d9d6b376ba14548af89659536a4bc81c5c414e5bdc6aa987680 851754dacdeea213274dfa061c31b1d8fb925e6f45a16b2e5336fe5d4ed095c1 a236ba657a6be4ba872e05d422f77aad17f85afd74bc6b6681b857adb4aba4b1 56b9dde7e521b14f110f868b80eda805fc92c2ff58ea4d694f63b7b1db66788d c26ca3d93d34c2ce19bc03206b674bb0ec277b03481b6bd2f6d4c8cdc5400aeb 3805a75e3d1acb904fd1c47a697483d000d016d8c3bf56b02797b1652514bd89 078bda77a8e3b1c7caea0690e0b3f55cf05eadfa4fba5da3ff0c0910fe514475 fb56e79864f8ecfefb2ee5830a828c01fd563ad0ad5edd6f391048abd0bc1276 04cbc96eb4d359210d8199d124ddc52e6b74c1a619d0c1d063c12613d59b7521 1d52268cb6d9ba9cbac6f6c6ae07e08d3e5cc1c350b48a8ab5ec4d935fb2d531 f30698c6f8f477c707d7fc4226cf5b3d4e883bb93ff2f226955aea1570e07c49 3b1aa97bd92de4eb76d715a486153e7772195ad3c613fcde4e531214e2e27d2a 5d3431e2480821a0e42ce532f0847a669b083a322d12c16b053ce534f2053565 77317d5939ff631a25476e5758178b03d9076a91be58c6185779ba64d12e6057 da082a14008e1ea1b18ee431842746eef76c83698008a5d01b345b09d221d78c 2da601f934dc94eba7f16f1a8401db1dbd0e7d86c8564d7930d7e79731e1943e 11a3c885c61db45da1d635fb0bdf4eed36292be25d76a4f33114b7e7b06a2b4e d9830c7546dd2ea96c6eb9da39fb9b87e8373c75abdf468d72af5ad2b0888f46 336c1030f13c8f64f1404b6576bd7de30d757c39e6d287c86bfb758004dd3279 3211d2770d1c459384d98cfcc2cd06e71790ac9ece4c27a90472ec95bc92517f c59d40958a3586bd39846eee9cb3b4c6e63d31048d329fd8ad25429607bc66ae 7dd3e9d787195a015261bdec28dd103504d7b8432189eb3ed1ccddcca47f7c57 861567ce9e932b7f71e5b17860b07b197666018960b92aa12c292409d72bed4d 45575ab63746296c5a318336b4fff222a090e74baca47d8d2235fee69b63b48f a550e636972038437d58d660476689e843a6aa561d259cbd9d82b52c180734de 2960e2a30a4ccf407d1fbea51217407db089faf4087418171cf79ae65d64b713 528dfda5c1b98080e8fd2f912f30b7720c52ab680ce3757c32704b511a022167 a744a0d92584218b5e927a33b8e0909f0464c8169a9760030eec5ed97c1a7ebe bca0fc9680b54a3cebd9ce62e79b9cc886e0b983725f71e9666a4b71f1f8a0d9 feae1ba266c4fca81075c37df2810e7cef6a6aa27391016a3c6ea910dcc26172 039f053497464d964cfd83897896a4ac9fcf75ad4773357f6fb1879c93252b61 3bd5778910009d03ad855cc01dd92431b5dfb01c0c3e5722edd34c88b271edb4 ff0901f32931467d6ba42b07cd9155e5f40df99260f04718ad3aac693a5d7965 44228dd14649f6471b8b6925a919d11306f26ba24a8e2cfd6536b051e7a1707f 9c714457259fa5ad18b5ecca5327b082d99a138ca22a80f14b6e3688067c62ef c9f000d42f1907f2cecac873edcc2ae8c85f20c88dc5dc6ff415a8517a7e7538 300ea29e48ec3e87c4624f648fd4d0a79246a21161583622f2b74286715e15ba c3b1ac285b35ba3bd10cdc3e6cce747fd2d18f10f80f3d8e66c12f3fc13e9d10 97fb4052b1df4532c220239a2d945993189ed6b24d73059e5684733cfffdda4b 66ea9f9b3fa47c65c9860a00bab242cf33c9b4728975e6e851c30521e21d2ccc 62bde8539a5a7c2ba322430d270540e1e5b02ff5d6eb3d1bc112440557d3cfe4 488128499ed67275941c37ee1f84aec3281c0214a93d7681be71775b04ad6aad 543a4f4605e3056472f99553d3fcacbf4f17b7950e4018ead97c5a31b324d053 43667e33a70c87322bab49653805f5774cb3723dbe38c1bc988ba33425095dc8 9067acd7b0ee821e76b11bad7d66f8a4afad461c47fa78e47e1624ee5fbed87d b8448bc34972d670a1d8857a59aa7f90a6349a6c0397f9a3a296295958839c06 3debf6b475a8467e07608ef05207026bd374f15a2ddf7fea1dc93709bffc75c7 d19fc2ba42fe87c2238caa515d1297ee9e0c55e95c5bf38b3324efd73c55a2b2 8e66921bddb9b7faf7fbd0f1463dfc6e7c3a20469e11419487db99c516a0b964 3d9fe18e95fb9c58236963dee32b088f56bfe1c66718c19ba2393b19b970b807 af3cd440efe07cc99d55cc4273436da39567dd30132871a5212eaa0da79e7edb de123bdb95e3e6ce3b01b38f38da17a3a10faf1bf46d2df0499d4f2e5e6298b5 2557decc2aff38c54d91288c36be8ec78f941b832645f2e5beba13e2d194b9e6 c42cffca0b7f74527464ae2868206f70c46fb6d145445182dc31254f4d7b5ac0 972a7f39947d4b7f9eb6d4ed3ba8e56a8e12f4f4d163872b1b77eac6a1f5a16f 6a528abdad05639f228295f4a5a7da3c4ab0a16dc8cc3b17e1b4025cbb2fc7cd d4ec84b00dfcd49ddff6f660b94ab0aa9d86b415a73676ca8408112ab8e5f9ba 114920e19d56d605c1ffa838ac15c7c39bf2f3d2a3f5c8ba12803a82d6c5bbe2 ecd13a64136df28dad65de1c07347c95a27b2dcb88b1bc3946dee47bc0364992 a80a99b706a56e93916bea5305abc4b4e4a335a5b7364cb86d2ed5145c697a19 c885e3be51e519e940b54a27abe66efd6d9e91e1b6eebdfe3149b136f000e183 1b2a2a8fdeb294c2139a997377a1ebc6bb2d3ae2df77bf437f4cede66ed2dfb3 14d8e828006c82139c9cd0fb4d8514e2c032cffc002ac6660c78023bde58c248 64bf32bb6c0b230dc5b60d40ecba7d4a002342d54b078194675c7e97abb23a04 f4e15842c1b021bb7d8de5f6eb19c886cf2892b0a65c190029e3b59c4a385b8e 295dfe7419f1af9a050333f2f33335b0c5dc788a7e3c62f3ab6be4d5a4276bc2 934d8d450daf60fafee19723fee3fe39f68128dd2a223541800919eb5129bc14 3ce9cc408b3e5fa1be33f81c4ed02e7b382e51d06cbaa7b471fe062673b1d37e 82f4e5a1923302b60ef5096a876b7ad56d59cd801fb9bedee0828bce68b78159 3fb3ae690f1018e87dcf922f39b2562f4050af4c480be441105cdcbcd2716acc b2f7ca1dcc5ad5169bb43235598ab360308c97b8fe65c9e32c834a72ae2eb9b4 4798074a51e05574bc6aab1a8d39a6ed696f87138f5769a9d6f42256a5ee4f4b 3364e1d7c9db162c17e83d164da90dc97c76719f35b6fe5bf40cae966c21d1fe 606afa6039fd08cd9304632b0dfa8714bc614ffb3129325938a5e8d10d8838df 9d652bd9e4350a67a077763bf4b1f16003cc60cec38a8a4d3e29bb6738adf50b 6b676fb7a8599952bcb0b7e6dc5d58b4050d1126ce2af3da5efb945f1cfd2c94 667b57119caa83119272dfddb503e5f5f02d7de8372aa7de71111a74ef5e2e60 95e5671e113ebabeadafe6b76273be1c0befbf6873736f32b0c2ba06c6c2923e f0d10bc494bc90521135eb5aa0e5a3d5b3a8dbade4e9f6ff3f2b2068f3740a2b 7fd8a918da0ddd5c0a6996a884221d3a87bebf87180e42ace95eb0b08aedc169 14acba58a7463f1183c958d8585837d51a17faa0e9c3e10fe47b81f457dfd18c 1574433739dd481dc2566766370833324d088da0d366f44deadb93a91ef67517 91507082a1acb56a11f6a47584209b3347f391590b505a3b6ea4f633567c108d 55f8da9252ff9b89ec3ea357b1699a79cbb457c0f788d53f24256b042f72d334 d4c333434acb242dd0c02e6d2d0256d700fdf21ea3e369235dfdce8f5f01eda1 26fefab2cc676e27474112530a01bfe66ac26b0fd1ae9b0b1af158383579fb91 66e3754d1b9a3753641fe8d713534d17e3757b93af8a61639619b4bb1bf35d8c 5bf2ec44259fb6a86f7542e24831d92aad28ef9196725ea65081b99b5ade6c96 9666b2e7df6f11b6d667d699ae879b1f6515cb65be5d2c421f7e0e006c964580 85d50aabeb1eb771c6acebc65df434ba538060e5ca7510666012b8be339191ae 86bd9dbdc18ad822624ff81fee9f8aa4e2a67cbbe6baaa776362c09f5345c53e 25e5d2312112fad46920e2d58ea6268fca18c380382b5021df8358ac0b4b6339 0c6c46efeee83be0e06c250a4f855b8031c3b87337ee9b35c2ebfb1464ef4e93 e5c7e48339a212e064708751ebb2610b92a90da555361c12503c1ba2b94f773b c532bbfa5ac8debb63e4f829ae4425d47290b25e9f8e535327a6896cd8ed8c11 a174154871e9032c25a20e755763ea0b7d30d48d4a742a451667862059c1ae00 7fa286cd3e004de47b64321267e483db374447e61f0d744cb135f87b05d4acca 1e68cec5a91a996971e96bda295445c6ac4c2a45676fdfa0b7656e3de5613a8c 258bd5a7f86ccd162bced20518d6801c078922e0a07331fff0410a6b03b42fdb 8e9a21ce9025eea1548a80a65457619fc1f754fbb61ef38fc1a6632ac3e6aa44 104295ac862ff8d59726746374deb516cd6ca8dbfac1743316ab839559294922 14bf9587ab5574183d825eaa6517c2fd10d2aaa754195d4b8f194f862bd1df96 f01b0853a90b32c3687e44857c8424532072100e8f5dc3a446369eb333b96966 da5ed5761e8203f3a3710dcf8141a3504ae78bea0ccc10fcb8af9712760bdf4b 86e442f6de922262310a0c5c6e66ad12a81e9886d9c2d44c6a769bb38ea6c542 c93c54d5737677dfc366cb4f0cba5b896f181412701bc06c38f854b9e72da88d c8a8056feb3e7e740b16cd36ca3389b76c791cebc0f8c89a07629c3559b3b1c7 624bbf542b00e979c47b0a5d42ee218762e74b69bf6a87127a7fef56891d4e29 ca098955eb1c82695eef2e33fe27abd54363a741f79a326a18624a59fae461f2 c35f574285183daf962f7ead5376e6b29e4f075d446b7c24144274eba52df0ba a261e3db11ee1b980c2410ebff269d73bc917ec2f488ffe68abde46ad244ba48 b06418693cd448500bbcec2009e508a81582aea9aaf4b43e1b8432bea8958c6b 14c3ab44093d18929e2d9f8c8a69c3ae0eeeea3560e16fe6bb2ecb9787a542ac 7105569d9955001b4b555e7f260909b460aac6b7d8766eb9e5eac970504a8bcd 7569bfab44b5fd6e4be0daacd0f6408eb71bffb223b5b2cb3fc8094e4d9d934f 1d37a3767f5aef69c068cf1e6b770c82a2f757b1a0231c25f2f855937ef5c616 20cdfc81ece21a0736e53b7a114a2b8d245355436dec806e07c027ef5e2a3e00 9daa4cd2c338e3c36b651c9820ba4d932b058b29184c4ba2f3dbd599a4befaa7 6f94000a6d3ca7e59ff1c0d654c394b006a80b9a940907875bdc5ebe4874da93 7d1438cc49457d22b33af5c8a253364864a053bf75c1658861552b3e407bb846 3622f3de3ef055ec9ca91129d4a19580880e4dc528120d0306e3c1b944ea5d14 340425c36a9f3a07f09ca5e5db80be53d1dfa72370542fac9470be5926e7be61 5b4138ba4f1bbd297b882834bc0d438888b93c11eaf7b273a8b0a665b51e745b 3932ff0fc14cae57a354bb438908c127902f5699e9331257afe27b20a5ee917c 700de789c2ac3265e395713eb5a84b8a50d614c1faac713b6f039a4c128d3b46 0f4607e43bb366b8eb649b084982c7b74a7003d8d01ace55c6f0ae5b141b5b68 9bebfb7e19d63b6b2214582e67e50b88011e52a2c67dc1bfbaba98484ee0043f 85c70ebd5862a5e0c764b80c6ef0fc164db266508006a21fc8c2b056f2d4f568 d86915c321a29d6999cbbc58181bec05b1f08add80ec1141b96a951c696bd5ad 5f09537bb43a919e908cf3e0c2da6a9bff5444fd5eb9b61cc3c243df8c52f26f cb010236cf55484a94cf7110e9e50e3a70e6e44a781b7ebba754b4abf4f67c7e 5b4d1cca3cfbbd257d636de3779129da239f270cfbce4740774524ebd76cdf34 4630b49c3274a059485c01a93c535c957b7acf28395a5699013a81222ef4a6d6 598f624607edf7d34e2f95ebd08c36f7d82a441011e9aa57a0ed16eb1d2e166f 6039008f442ba4ed4fc015d360b13c16e1ab4d779d9bc50c1717c0ca6ddf8a4c b53d5340896cf020142ffa7958bc3956074cf1c13b388d467953b58bd4b85f59 0fe7b691e8e1aded6922ac70166d221b2981e1dec67affca36bc4a9daa912cf0 e4fe1b0138085f27bb385820733072dd9d1e72a28a1690dd7a924ec47247d25f 1271e12651a36cc677e246a8a3db9acc4297e338cf931d7cd15ec2a8e999d930 319514a32fcb94e24e77e46828af845c061fa0c6da698baa6f8ceb14519ab1b2 d78f4dc2ee3f6cadd9d3a7eea8d13e7cd3833dba695754b1ac7d6fc2d71dcd7e 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 false +check_ring_signature f44c8ece36fc8fb77bdcf35c9857c47bbd755742b769aa623493ffc5a23d93a9 6665763260dd429829ed7a7b737e4d0e84d7a12dffcbbe5aec6a964345473d71 1 d93c185315cfe23ba703308a48dcbafe8f2e5a23a27d87a61082f74ead702596 007fb7c2c258b7a7bf96c557a2a78ca198bd39d625525c174233af16b617ff05574372af64ee5d6698f2c4e2b6f75645a0200b6e8cc9d6d2f4d1793198f6a908 true +check_ring_signature cebd41abfd2e2cddf8ada7e0e09821fbca1b777fc2ed947efe75d9363d60e913 460e64c9cf65d37f53cb3e0dbc6a7c6b775c0588b19891d12c0ae10b260906b9 54 7b95dafb49215eee664789e745e2f03e59ec683a45e2dffc796115a9bac71204 6d593b0789fa3042bdfc525334daf95f7bfd26f6db0182709595e688f445c109 6f1cf00930f36c2a69c50ee5be22d36cc2db3d9b1b714350d531568c024c3214 230ff5d6b543c2dc272b83cac41f45a416b1420592f890a2e3b6e80aa4619513 ecb2053f94f7fe59135c93893881025c5d2257d73c85d3fc8c56aa22562bd0e1 e1ee16c650ab3babc82aacad4ea940ff35aa7cef4867c1ff47a4602c7d00a64a c0ede4586578a2f88eecb911cea9c59c1cef7689db441cbf2d73f702f81d8903 a9139cac9fc6809e367d2c2b82112ef67257a44effc821339ab9c5cf05c8cc97 a1c3e63492ceedc6d411447a4b6fc3a9b03a0f4a8fea8553de2a65a8c1749ac1 2a347f4f1569c1f53f41159cd7cd9969e18154bb6d9accba1282b366b07353bd c2cf8e0d26851d571d503b1da6516d806946508fe3cd79bd9255774be0d1edd8 42eb8c67c267234777b4db7f09c771caf31a9a8899ab7cdb98781ac6c8b50e54 8dc49ec2050e4873486996289a908da507c0d94ea629bba61490eb444f31bdd3 59922ab00b6a1dea1ea58dfa9ad55250a272085400b2a47c937e8f5e6d1944b0 875a5c4a68ebdcbea8b4aeaafb9aaaa240479004e09c851d37f84e927c25ca79 76726d10fa76aabcefe1606ce986da136cf4edc5b0415e570e3a818e0227323d 7ccdcdb52c08132220b4cacd4cb07d7f081b53048f7e12d9a4d00b9d99ed3812 1d6e234b81f46a94ab24413d370afd08e582564bc711affe579e7f5a4d7c6dc1 769cdca43d601c886593ad6292813051d9290956fb452204773488a8967932c0 76123e37b3c65ccf573c7693148242370d6ba48c1d79d9d2ac730c65228548ca 53da66849d6d083d34dbeabd45f25cddaa3227281443b7af599ff5cb97c18cb2 a928b7d5d69ea908cde99d05b0c470848ec9a77226e7adbe5296ddc72c25d64f 9dbfe6264045502d1ce03517444313e4fe8518c57af71efe39ad3b080f9fb578 654735312db84b3e9c80da3dd2824f41b1f443681126c3f7d5f1afd02b444f23 01450a21bb3ad859e0bf7e1f726f9016a7b218cdea3e9ba5b2cc947fb7e3e705 81e191fa0a5290702e6368c678bcab21f42a21c3d9b9e726a0431ce893592d88 5896bdfbddc842942a70d82e3534f4fac9eb7d8fe778e1ec6feb2ed3a671fecb ab1cf5d7ba8ad428897815e782aafa16b76dc2f6d46b888fc56910d50889578e 7089efe5451b8129fc7626707f7c28e762a500d7ef73ef7a439b7723c1f41774 339581f84220094e03ad93908572cfe231ac07844b6740a6120d5b4c86e832d0 0c5005993b5082fe9b848668f52fd81fb778ee3dd7952ea1b1c6a10e50df35ce c485b7cc1ca991312ac2cf9e2955bf6699802d4dcdd0cdde715891623ef3c60c 2ceccc8b2c83af7527e4176feca1817e62833fc4cb9259c1f1f870176e9714bc 9d77d0c32e0fb1e55bedb2f799ece6a7ed816ba34172f77afbf5b51b3abf24cc ee8ff3706da02a6c4fa25143105d814352a3a460291866433a1149b127d7f22f e51c1632cb862b4df083d0cbe5ba5b2781752b713d56e03e577d9abeab97077e c9416a4f5497a0a4fb6eb35546c43228d1d9f4b35989080f4ea68a2d89ab2bb7 a39a3b66de75d0a3d7fde73d6ffe57b0d8de290f6ab3d2ecd3913ae4865f0963 9c85df951c5a87c9dedff57b77cd87af9c345b16708578090295443d706645a8 9d95ab81dc89b5ecd35394bfea0555638e34bb4e79b1fc5a97c4a481bdc21cac a82ca8e2e2877f340d4c4842ac444adf249a8f1293dda09a83efb5425eda1ba0 0bd24f21f5b4fd9f5a2ea436c4158b8f3ab7686813ffddf6a1e8225cac12b45e 85cfa257b0302431c613a6747710aac7447d7d6e2e67b22da509d68ac14b9e0b 6e731b20799b3af21a2d312edce74b86a9fa846cd4ea85ccb905a0a7c9b6c12c 07cb11c4cf200e0cfe1172e89c5feb5a494ae2938def00c5b3b3eabdc062c0fd ccd6523d8e0685ccff6dc45795e8216e09d25b28744a207b1307746177689361 448b3cc1828f33f97f545609b8b1c5658028af68ac69e5a3b942e0a6b1619bfe 694bc5bfbdccbbf04af7060a24f34a38435c22d608d42a2f63d746f331b06f02 2fd5e57504921719a88c5412ba998aa861fe4453d60715c6136e0ab8b9ab2a35 0b368ede61c51cedb750ba4df2badb65e1fa2825ee147078d502474041a992e1 98c6d1b8210784b01e1215027e828350f0c3f62b10993a585a71361b0c2f9166 59c329ed2862ac6ae90e8ede944c6967ad80c297c6334781d503f54e8caef5f3 bed54b5af765e20a3382757846de701ebcb727cd5238233ab416618630f6f04d ec97388a0f5eb6cdd158af340df07e1f3397cf137aaf3ca423f3b8022ce7440b 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 false +check_ring_signature 383b72ba66bd7872cbcdbdcd457d42c0e7e53be351f319f54f39b373dcf24724 494ae741cc018ebb61ffe610fbaafbdeacd4a43776757d42946af85c007e4f2b 2 d3039b165f2a20850c9c562e8cab735c5adfc19b2e3c2f4db4fc580c47a9a4c6 d846329c0e2ecbdb44af6b4a9d54de31cd059675c80123f8a47b828e138fb660 4b8925f2f5fcaf280e61f94bdbd5661c02b791732328decdd4dd84700747b702905e9f832b1ffdd9b8a05f702541df0db266b9d420bb5742bc4bf6dd5eef7200fb084fb89274b7c9db2284f7614bb4c83970ea2935bfa04d5bd72c18ea4e7604651392768eecd6b1acccfc34414daa12ac6c65401134089012cb3e8899ab650a true +check_ring_signature 399b69e3090864140800c7d300fbde5236420367bb6d16cb5509e82ea650628d 254cdaa5173aa49d68a872b3a85fccce29d80f97a9d2a685d38baf1cae3a48cf 3 a4f76b6915b5c7b4371a9a6ffc9279935ba0e2fc73ea33cb7346195beba45597 b5757f9ccaaa4d3dafc36cea62658f68a8f89d86a57fb7028a91c5f6a1374450 64d1e13aa62be2337256eed75e53a82cccd7489bf2eadf86f967711943253ab0 611c4894c9247dfaa2547bd2edf8439ba599c7c7d97d4343c4a85ddf87e0170f6974dc36b29f80eff8261f5118199cc05a78a77c02f322b8e729f3e1df039b05c6b9ddc35b74ba2c9840bb2e1b6ec843ba329297d6182eac60bd8e7acfa67202a24d432b6278fb5c11b72a713e1dffb702c3d4bde69591ac1ac2da5168636803fc4f66c0d7fde47648204cf01acf002e7ac0eb53847f00f873193ed2ea926f029997fe7050fec471b2db85a31727e6416dc78664995ef39c8d3adf299b65b503 true +check_ring_signature c5ac742c6968a3b89f17a49cd42003a06b3821781357e36878158b4c7296a30e 178f086db2ddec420679c9187bd192d2e55aaf08b08b5d3793cead7c8af60153 219 231aaebea7ebc36defe8d283edbd2793b00ec9264d7dd7f425c908d6f89cdb87 59d3065fa58aed0f53ebf5f9784fe3a05143b421bb2eb740ffd7069892589cd2 98eca907988e7762ea7376c0d658b8a94267e26d77d42d4e88ea015b332fac44 e6a7dba7a4b836d44284e90ce8e8fd8d121256bd29f00affb3cdf2307f0ea898 743ef3d1f277eb9d8af4f423028abde54918d1bafc99d36ff0bf44c2e797a362 7e0f9b7d3185b4ec37f1219285c710ff4dd6487b5b6003827fa2543cca3172cb 51ed4aca2c419ecfe252204c171527d282785f15ad2ec9ed42296f1fbfc92187 94926c511d68821c9597fc3ec71ca351a69cb29dbcae94e7cf9a230f47394a20 a940e45cd687f932abbe72e9de6662d75b67cd725ab14305336c6f74ebc4f689 2900cc703007f17fe8c8162efeb1e91065c9f8bda545dec1f94e3998ab394b79 dedd33e86913c3a4a42ae63d9bd6ff5fe478e066073f4d35322a1cd52915022f 5993dd7efcef933ae014c82b8869f2384bcdcd839cb4a67c61f9dda6622d3f46 a4afd67e8e3f12af1165e256159a22de4097a462d1756089a089378c8ceee8e9 552b832d09fd03b8466135f445949d25165bdf432781a6ecd2f579fc7f2a456e 543761a8de540081fe650e82f2ea44f328465be6d6b23ddae21c8f692af3dbf6 15aa0f052eb5e1e41d12aa189137ace56af59502f7c5a1841b1f9f76168d83ee 6d9ec3f764408067318313bbc4041214e1685f03638764f6ed59c22b6ddba72b ad1ad820a0386b0535b54b1e6beb079f7053ceac1e88d22acb4731cd0373e603 ada29e4ff9f455259bb8c23f82eb24ca80ce08bb96e36d27ce086ee5e7f4e98a 312f6b10c6b9915d116e1d2c699b0ddd95bbb3cc5c24e33201e1969197e49455 bcdf347971928aa9773f817d7d9d99672fe3697e51fc1894283fbadef128a879 aecadfefd9720b85f72a634b08887c48bbc0c59dc87a9be6da0e6b8879b6100c 350c96ab6ef3209d2cdbf305960e0334931a68a3708ad463d1a38d8cb7c12513 0c67d635b8abb4cf0644609105626de85be2cc83c9ad66a91d1f452243443aca abcbd3657fd4a951fb64883ecbb4d5086a0255582655f329fa3e3864b6eaebb7 dd9f8967a4dd1523985e6ab43ce81f1038a94f1e142e54bd214b03b8adced1b9 b0e5607797beef4b4516b92ce9e688238c2c1a7cc54282672284b4d251eac28e e0e757986d2b486a1340c762e6ea19f70130d6003d81837dfafd6e830f8282fa c7af1ba2c0f3da720e56f1b6dff7f46f911a12b9a2ade598cbb070f9b7e4dbc6 843a8e2bd7bf801adcf9a8c3cc5c5bf9e12febea557e70f695296a0f9fd6d813 ce5042232b2b921579425fee7960de012c360e39adef0869d2005b8754723400 aa7e6f91bda21d9500c30bd1cb15b4d032ecb2499cf65b658d650ef6fd99bc12 30040d0a5aa592001cfa7534c3c0a0ea30bb299e5ccf37b59140b3c6efd2239f 92b0b04d377e996f345ebc11269e9b2020a0c6546074f2a12fe08f1df00e6963 599bbb01ca7184a2c01a5a7b0e5b520c5813b1e6d5d0b928d4d4cf8802a5dc36 1b18add0b3a8bd698cc052553dda5e35a25bf4d716fa5641add98317f5f2a054 fd824e86356d0285765524c7245503b3051832e1d49ad8f4babfce84366b133d 7d62df3cfdb723e3749c0e71ce8b4abdf4dc642254ddee5e710a6b8f3ec03fec a4dddc0e288c09a635dc01a1af132d0da9624b5762e9f598717bf9fcf30c3bcb ae37b212b822793460112292422ad485c7a0a3e68c073668755bda80dfc3ed2c 0926115b10ea6bc35b0c3e99e100dde105450db65a1c13cd72bbc6dcac5d87af 3b9154caaf2fd18f44c29f6442aefca19d264c461583d1e6023ce0ef8932bf51 73d9b87675fa9fa091677d6ab94a4b4b70007b0f9dde3e39e8872e26aa45728f 4df0c76750ab765544c299a9c2709a742e25b5a14cf752028c213c9e52e0e196 44784df61b7a5eb439aa83c451730f17a5b57cfedf53df9503b88dd5f2331d29 20ee06829df8aee2b1888fa6b33cda080d39be55288a81e3d460f25ce4c80a6c b598c88bbcbc8fbc9911031ba83d986a738939e940513eceaaf6601bdc9b4a80 6d1eb3f67893409e2371091384214177001252635d03db7edfd26f16b99d40eb 871b65ad28984e3fd9e90f9c5635857b4fec55a80356fe0c2f39865eb2da7ec1 5fffce42eb12c5475c31dcecbbe441b767ef0aeca9fd803a7b6237957c51ed34 dab311fc769661afc3919a65d16356cb064667af3b618edd499aad3fbff337cd 614f983f017483b196e374e6adec6441be9e1a5a0bdd332460052d3c9ea89104 de7a6852e925ff89b7f61ac765f8d8309b5d632b16fd172935bd8adc1e2cf005 81fe900d98a0b11d0aa8ccbd80b13c81791e7f57cee394800ecbe07db1e06ff6 fc49bf59cc01263454b048baf0df3f83d8c7add94dcba83382ed8a64df99bb90 cfc6bd3ddb55a4287d4f1f828651d7b7b8ef7a43bd6cfb5accb7e058d538746d 007c063805f4059c97a09fc3a678a356e70debf62c33785831213fea85f92866 ff52b7782b7117ecd9becc8c65ee745f1e76077a23691d99da2ee8d8e4a6b297 84710897b8cb2050c1c66f484b006bd75a90df9cc5043befccd122568413b7aa 6e1f93313570e61e314d09e9ae84032598edcee3fd623df1045cfb89e309afa2 34551eae9a1a836ac3e84928ee06beb00e21835ba54c9d4bb2cdc276732e0d96 1d48931290fb5df0d8eb7969c69a3de75af5e7e03d505d4b25966dc14471733b 6c646ba3c38cbaad0709f253644cb61c689184c501e90ecdecb20f8da3ad7754 03cbded6880367523cd72d4dd457cda3f2b99ce8bb5f67aadc660e00d42526a3 e16273e7fb72b85f3740c3461d4674bb6b2f58a1f9c8c8046e8def700541a6d4 22b0302ccd9ccf6897a31c22abb46638a3e8e300568cbd6cecb00ee6ada7a155 5479bc10355d3f3baf47d276d341afa6ec84f084a7d58015576ec0f6aeab40e1 fe65062283a55e4e3e7ce41f7b7bc0ecdafd9d67936732e2448b8d6dcfca1e86 00f63397bc8063fccfaf8e0c684f3692d20c3de02abf76823f2d9ab748cb61c6 3569c0f98c8b1277bb90ed864c7b46e9e9fad108cf22f5bb6ea449d041bd7d71 85bcfa0861dfceb9c31abf57a239d810ee086b940b99a7fb37ec012b88cc33eb a088e4c7ce225a1dd346a97ef7a3c0586bfe272eb5681b8d6bdadccf476dc25f a0baa8ba3eb3f400c4a10cd44ebb5f640c2b0ebafd385d0209bd594a98473b0c 8fc0212db8221a465dfe71511b2afb1f35be5abccb6b0ada065a52c92a0f2b37 a3e468c3c57d53530df622b72576d55fc2a5c329d4a60e110379c2e228d63acf a94e63577ab74ca07b92b582b74fe04f4b7c81dfd9c339c080c552cdb511eafd 5f6ac243ab6105d98e7a51cc01cea5cee68cecd015e9f61bee355942678254ff 4b799d372809bbcd9b4a8c9765a3bcbede3bcb598655b6e9daa7f4ceaada3ab8 c1ee82a920d2c5e64b2f3469b56dde3cce5dd334f137b81c15c5e2d979b7a8e1 3c0ee3744fa5659f10f7bbeef5bad8076fede6d191b6158a334c6896c5a7d1e9 f0091ac70f7f58064c76ed7400a88601a860e09f4c1806a26a08f2e9aae40ce8 4696dc0e6dfd2ea5249436bfb8bd3495f2c6e2e1170e38f9ceb4235f5ff4a64f d3d1ac4434980c3f35d02f016c8a7334628da375ecf9923e257ebdf49bc0b62d 85cad285d719283f8b2df817aa49aeeab40bdf1f058b2f4fff33aa901414ef32 48be9329e52f0fabfb88fd9eaac9b705239bc0559d59f3a25a22f437ba5cea7b 6ef8cc1759690bec9c54a015b02ce1f860e314f2efa84bc2a58a4340bf2a859b 12ae2b17bd4c607328559aee3312a7fceb11c3f28497f8a90b0c9bf18843ec71 c881efaca0865554c1fccf5c2af91b2b3f99140d74406883e5c9006577748ddc cdd334e907c6fd8500d6b402a956441933e598f9073f2742d773a53929e58b11 39177d3f3ef0a8fc8881105918798dcabb9c3dfb4197b555481175ced3720d3f 48f46c684db10ef67e428dd0ad0048c9824bef73cef432e43abbce589151b84f 029894e23a655dfe17857df68b85819b8af1223eaae7d078a3ca4e155c92c58d d9554c0c0f2748caacee7b7b3d9b0872af5b6fff044128dc8e9582bc7940d982 ed5efd5b8a1b121e5ab53266849a617abb1173cff289c0ebc133a4f59ff28e44 c0fc5308e969004a04097b10d2783d3221721b7088b2bc4d45d8db7ce0e6205b dd6e3cdb6281b67d9d8e8437979521fd6e0433957210b2756c69ee2768505e56 6f66554e111ece74a3dc35be365efb4d7d5a95a82f1d4429d6a3c2ab2cc9834b d24eab5eff7270cb40fdc620dbc3a224c26575c70b039fa7042729737ca17c0e 8d3c6bc9bf9e96bbb06320779049a633ddb42ce331c45e38339ef21a67fc460f 8190d3a3c90a1c7244f691c8fe506b05cd0e85dc3bb16cf19bbd9be0e099bb6a 22787098161c1d4fb63cacd59f0c538637436f52648906e95b5faa2010553584 d5624b548acf6c6c88c69584b6a4734f83883fc3e78d6f3fefe9179cb1811213 c234c08da070769be293583c638f04eda2111d4cdf0a3b6f616220b11b405a34 0b40259fb4ef668b61739cdf721e7617c4358be60e93018ff5b01163b64ca1a8 42176dee65bde9bde033ab96c0cfa7a649910c72d2b7f5dde71231a1071004d9 9b137bf55ad77652dad0e14ce1477ae7107bdbbc687e75382a556c2b9bb8b913 6f559d5b4e4071e7b88df397f689f0aab62f0bb3e9ccdf7730d68ed9db281553 a54872394a874eb4f80e1b28e639cf7c8bd59293a278ac791a748022aff05e23 a59a8705174031faeea0cbe6ab6ab83d6d5c54cf521669f79d89bc580d78f514 c3ff24679361f8d6b37ed7867085de611475a48af92aebc92569b6b594ede367 88200bb4ee76a18bd2065dfe0a632c451b35dded391828e018f501c453165376 3019aca47de15ba578cc27a735d51e59c4c55deb34cfe0c0b761947595424c18 eb907474cbf1f587cdcde446bda1bab430e267cf83534fe78d5747867bd595b7 95bdb12925342824d09ce53b9bfb5316d9710554e48ad880256e59659785368f 2c1a03141f8e2fea2596c2263a7d927da6918231d99c12d228bb9e3740f2af12 bc384fc2cc815271db4221425edce7dfcc78330de86db13a1fdca4ba5a274102 36d1bd93e872e7c594d5a0736a1a9e7d8261a9d31d77d6167683880b6b0e3121 5b56b6cb78e27bee22542a2829c249b34bb814f4cc5372373819f904cef359bc 40621c1d141609ca4e8a425f180f56c004783f5dde5713dd2903b6539eea5f27 92c81270a8b1fd324c47075dd651abc314d099fd55bdf9154d8861346456bb90 1002f94bbf0552fc17f760bd2718740e9d6b0579f99454dc8f5efed7ff87463b e8450c509f5ce17007f444a852a0c837ce9f9ea01169fa961cfd827af5443344 a217a4a1d65528cb593d9d4db5af430d67af4801be879dbe68e322adfb329642 2665a02190b283f33827644a277ca9da1ba4a6d825b1e1d1e0908d1ff842b175 8a2b7079e8b674a016d948d571b34f455c3b7f4e47e019aef6b670eaa9ae036e aeddf32334d4f85532369419b6543088e897a878dff4e9ae780f024858437dee 317c7bf738951941f67603e3eb35761ae0e30d1ca87e98ab56054ffd2da5f33f e1b7fb6c2ec6bbc8be35cc3897bf60cc20efd550ee418270744c67377b49a5b3 614e793f5d9c3510c64376ac06db249dd9f364ec045a2c0bb24ea080f037bb70 0471a8d88c102f73aebc52658c447475289d3c582a1582e4dc9847f6757570f7 cd8c95055ef12335d8906da6f478a9feb7ddd56ac0fb40861d24b9c3330f3c53 9d9360bbe89d41b4a01882286c8ba51a7cb3f8ebb3149216ead48253f783bbea cce599487d3fcb91c109fc6fc52c9938e4a72af58484b515ace408ff399db082 b576423526130d770fd58de7321cdd3803b55689bb972c96eea00cc6ff9b9a7f 658d14fef9929d576dce7492df7a569cf135347cd977c9864f1e40afbf92f2ca f27cfa892cea4ae5ae44b8c5ca52aa4ca6373de9817dab3d0ac38465b07eb68d 9ee14c4680ddc9775547eaf36a807dbda0b2a9a1fad7cd5a2919f03edeeaa5ea 423ad0e2bbab601259a31d1eeea1e449c71282663444965ed4b88bcdcc06e84a 77f1a7e4ac8ed916db9ac731f9b281012ea56c1026c6e805bb40eda4530ea10a 2da8667e97c8ab9e8911b6bedff0654e808f68106ddd88a27554e25e1a81c4be 2235d6c8e7e18c8e346198ba7f89a4560ad5f01e013182aa6a87c23be37fda42 be8369117d0e0daaf24eacbf3ae56ff41ab208347a6a5b6705733a922283c86e bfa2686dd9439068a977d763b712c0326a75d6bb93622e529cc993454e3cf31e c7d9937bffdbc9504dac5703834cd56cf7445035c7695ce846b8b301077a6de2 77959bbf05d541b81a617a1730411f1d1a391ea385976e87ea2e8d0934d69527 4b150b587138840da201e9f856c9ad21d231fe89fc86561fb3cd5d0208b43362 93f1ed08cea8c2bc1252b05dcbee139e4f021ab3b924dfaa882b9ef2a8239b31 010f0ca38a69129fe4c70eaa91aa1bbcafcd1c75c4ca75369a39834abeba12ea f74eb6f37dcf1f6080ea2f203e013b674e2cfba1fcb30a08a9bc44173398e856 da72ca2931e0e1cd452f607353a094dbb282f6fd2119f2dd7cb050afdce3609f d5ef50130c4c8435a65754d2e876294ad8dda44c0b2d8693dda61bcd43317f14 14472f9cfdc3a4b118722a1ea504e7fcdda3f220c53a52715ab77adb561e496d 3eed3e8fdb79ac013045ddbda6f80b3ffffaa3e492c5f55093427c2410feb6af 2275a92d24f4e8d5f25f757b1d6666984d35e886b577905b1a64963400dda32b d4e7fb2d327a7693e358ddad0334e9ef285766a207295a8832f953a01c8beffd c8ae37d7cabe165d238ba955820bd4a5b62a9cf0727e5a949c964663df3c086b 8baa6fdf1503f942a1177550aa2d4bca5f40d8872a022535d92b1868d36eec96 cf608c664cbaa6ba583e9eba2afee7e0885ea7eb3a5c700bd576288d6169b150 8fd58215e6bc0f573c69deebe830a6c5a078db95aa3e775bdcd74166b4fdc7e3 92dc54cea090309f075739f731b7d22eb8d7cbc2d863e2ed754adc5cbc0117f0 75b2d6c24e852258b3ba81673e98193de875779359fa5c94538ef8d19f771979 7fd2d37aff341d098cc6cc1721e671c6463a99c3ec14ab976ff817f76ebf7265 153cd3b6b8468d930c7acc1fec7a1b1422c10e1e1e51e57ba81064fb41674604 965ea235e8820148b4e67951c8c9cd002200f53c8547dfa3781717284e1dc7fc 9aa0c042c64c5039e609bcf7c1a33d0e163c61718d5542e8765db6cd9ad62c5c a56b66ffb04b6de482e0b5371495beab59c8d9dc9b76cbbe93cf2ac32d70b682 fe36af8c0f0853ca10781754730e4348479684c4d68036e540482585cfa2504e d55af413a247d527f1573bd8b247e083242c7a07f88181c72cb070b3a080927e 482f5c744eda3afc5e1642e53d9ee661eb2a4dc75bf8e1c63c90505c5be7fa55 960c4c38aeda8714548b1c9d901934efd968dde9014fcd6b0da5a7121ad90d3e b0c81379ca8d12843ac1ba556a6ff7258139f9d4b203d3a0e1b96db64461e6a6 8d248a27a189356baa1022161153672005b0b74cc74070e27d23d4deb01e468a 4ec2e909a7e7f64c451cd002052c7de618a27ed3057342380285ff9a2382c6f5 530f3c1fd5368ae1051e8d97df1a2d1345c7017a181889560195a90921b88127 4937d542a8ca65e8371231cd7e4e13c7a71bbde3a54a934a3fcc9316a39d94e5 3a664ab2a85e15299670a8141280ca1e5c97eac65e4b0518994648053fe1e79b 7ad426cb116b8a95ec4c8c8416b71b10d9073ee20d28bd6fbcfdd557faae13d2 6e93595c319ec3f2efd8396f6f6644709fc069d3bd013d1bf3af6963198675d8 ae227b7f4495f4a2a2261afb434c5907295badcbff867e16e59e5284b0cbf9e6 f163e65cb546244bcdf2e271ab0ee62cf94ce4480de8fcc274224dd68dfb3165 8567bb12ab6772890adac0b2efc83d3626ce1e92342121c6dffc2bcf1b695109 e2315f1693e5d449ba3725ab203298c5d1248da8ca61ff53c5ca3e65be9097f1 92007b3811851eedf14e04c33bd5f399d17db2ae0aeb63b1b4c66665ccb59ab4 f7b79c944cca90f6ed2f4f677fe05a9a83b556a82a6dd55b8b6bbe047f9e9e4d 512f5d1d5b4f5e9809f0838c0beba560b39dba4335deeb9a674363b373aeff2c 9087f096cba590c70d7f48396c4e9f615b74ba0ad032ff3fe4033f6e736717da 934f3739060324e1e3e0113815ff101f6b30393c8f07844913c816e4410bdb6f 364e764c2b7b8e954bdc010c701242acd055a47ab23e3d67795b4efaca8207af 13a15b6039d4afd9fcb15be5067529e9066907a9d2d925c02760ee116ecb3268 1cc4a558343d19973ed254398259b7b4a53b98d6856061681797e132d4de8e79 3d38d83c9b782dda16f87e6301cf7ffcbd43d1a95c45a542a0f58747e801643a d5c680813e6e61579981bf995007e8b3580bf77fd75cd4047a1cca466e22edd3 d93dce8d6748951167ce0a0377898257bd8eaf7443ff2d91f6e2e26f36c9926d 15f76cc9b74e8e595a5d2d536743fd2ec9154298c99dd92d751d2f51563d3619 a03a9f76205d2ff3450b34df6ef4322667689ddf97f3440570bbf53e1d7419bf 1eee7678708adf6a5ccf25be3bb9e778fc8430c2ed9c2d6b9dc4e1423032a0df 795ca0bf075ea02c1705c1e50e164518754c412a87d3be2e8d200a00c8606f9e 4893fcea2888a5846da225d3d5ed42d5b7c7bbdd09f2a547ed47b384c6fcac2e 84debf4c6d48757415d878ff79b2b2d6eee891985aaf3192ebcd8b74bb73664c c9d867ab2e1852c3689c23b0cae130b694f5f1a6e96fb26ae8d1f1ea633cbce7 11050af3125002ca70d8dda2441309687323e1e7e9aee34cececb1a3db828454 d9664869b0e75830904457adcee41c90b667a2ecdc628b54489d52d94d33bca5 4aee0b499912363e58f14eb6d91d59105e2a271cb480e97f4a2a8f7c3a9542ff 7eb101945064adf0277c8d51d1eea97306b011f6fef8bc91a90e7b8c683a5a14 0cf939cf22b264a0b2f9f955b2ae33e2a91747c9152d97948053fc5c4d5e6362 655f319a53bc6c797af4780bffad6fafa19c52bb9bba9ec5cbd91b2a48893795 ab82b35588bdeab76ee638e934936a45d1bfd47e3d815acce299d1626f245cd0 97f7d109f5ddf0bab8cba6eaea5d25eec44971356eb1ea32af6afcbbdc43b4a9 3a04386821da1ac8fdead5c53cc8e54af65bd3cbdc5b3f0713a2e800c47f2e24 99fc9eb7c216d29214c43ba4250d01264456f2c1d4e482c01779af8ee7a67da4 e61b71ca0199e549f6d8651f6eb9a992f35efe04b8d70029e31b263dee31ece4 8ff9b8eaed947388063c0733323e38d6228ddcbe4688a9b736ae8a6121df6224 1a6349072c27e30aae97349ae822ba5559c67c4c43b34659ef41f97976017c8e c0eb81d2431375a89ba49e5c10b6c45cc5b2cf1d3e318e8ebfebf4b434fcf1e9 8f6718f5bbc029f3dae46282fe2bc97316fb2149dd6a15b928df8f5141a3a560 8ed69c47fcf3fca40679ca5946400fb0c3fcbd615e84b075a3a020858340ca9d dc5f0bf7261ef61f2399b1ec4c96963f6ddfb1407672508bbb91259c975a818d 14ec4622fd5f76efefa7bfeb070ced98c7c8528ddb2d50e9b3209f1943c81770 6de5b17dec6d7ef44e127c2851d03bfb20f7591cafaba2c3a3ddb1de1cdca4af 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 false +check_ring_signature 520171b909a4f1ffd9cdb140f8bb70e5db3e4411628c0e2b67329ce6219719ab 064732c259361b0f49a77a081f6497618a3aa6e2a22a92cfa422996d7fbd79b4 178 039d36febfcf54fee67a92963cdd9a320fd43887866b17eb240508c3ffefd896 3203549442b267250a05c6686e12e924723d0680f62039acc2dbb440772645b8 fb70c156a2096383396426a718ed215f9382ee13c56c14b46c352a1eb13a95b8 883eb9b00bd1208da587e8f1f5dbcb797ac671d5520d05187d9bacc421fca3b4 166db1e199c0b78dafd4442c04ba3d5d6093b53efd8356e5b3d8a182b2eb7ab6 4b035d7097898013ddabaf64a935e685940d5049743c2846d5815a624da7ef87 006aaa5d57c9a29ba2b3155240039a69bf4828ea0242007318ffd218ab836d2b afdae1d73c62b49b5a4ed5aceaa2571e6ef98d2f48b217385b5e2cdbb9947fec b2090ca2c67d370b4d6e5c7a1125f6ebdead04d03666650abe91a0265ad270b9 af78b3c858ef2617cc805904039f0678db8a36f1910a7f1a5d0ea9c03a7304f6 f704e3c583284ce65938d019e7da9d3b2abe33370a16b566675e5e048745f7fc 64f2cd1202272f45a0f208800f549014c250b098d048279eefa8b8490fb64e30 dbe17de2ad4b0718ae37950f52fa622340eee8184139c2682732a5b58fde7ff5 78b07cd1550e9e82a5dff61536cdc9c98c921eefb68fb8e8af613fa77d1d45a8 febaffd535d872cb4c55c77b0780dea164cde1d04099fee2be1fbe889730a3c5 019210b304785cce66a2faa78ec0072b24baad9f0e5ad21c02de87a17b2c0378 8393676ba43a61b5f3fdfdc6755ef8078b923585fda50de9c3ce43489abc6cd8 fca788765b638b9d44cb85e0e56ab2eed61af795ca16195fdc26f7becc6ada65 1bdb6d49fa3adaf2d962704d6fe82513db2a5851da516a928883d429804acf3c cb8f038b36a2e681128e036b1d426b355bd57ad88d9e566a2af53b237556cebc f175052fa977dac291ed5419a8f7a957607519ff37adaf723df790fe082e6072 dcdbf162e3cf6ca6173bdea93df752b21664775c5261327bc985bad5e97970d2 ef639ae2ae165e0fdfb854b88f5d72efc00cd59d6c0f4eef0dc8e8f171104114 f803da8a754a68fb46a2ea203983f4c006e8aaa27526b15958397a8d459da491 3f3f0842b9ce3dd30ebd3059800873871fce588a8b5d57fa47be08491a9b72aa 9ef8c4f987748a21a6f08c737db7f1af46534eb35063374888e89e632c615761 58a56dd7602b9f74a551a25a0cc411d0064990f5a8290a0e3a6c0c2f5a2c6c0d ace76a7d7d2f67e55a43a645b340773eb63fb1568747bf387d0d6947b7ce1dbb 43c789e3346d94e0b7b9e6fecd46ad3a18fd9b26938fdcaff1ef2c7d3c6dfc06 28633c76535be6abcc8e1467be812d077791ee2d23118c0e737941e721a2d2f9 deea8a8fb342687df661ccb4a4b5a206ecaa8ce4ee2adbec318b8a8ba554cb5a 82cf69c62c874fe2fea8c14d7deb153f604cf96a8a8492bf9c09e61b2b142c08 b5fff3a8b1bae2732d73c9646fe51d8f527bc35301d126ba374dda2d3732bace f1ae0b5f23fc87a0b494e54acd5fc4aefee8544596624d0e8e3a92b5d44c8438 9afd72b1da617ae3087dcba77dc5c9c48fa2cebe01867435ee2bf2596f427182 b0359a03163bc7e003f16a82735b7ba10ebf9523b37d7449d5e90f5c292495ff 0eecfd2bf9a6fa6ac5bd75a45abbca0374fa2e7d056b9cfd237cbcf2dd35b7c0 f20a7a534118a0e0b84ab5a15c35ac8988bee3fd6058218848759608306597aa 601c5f225a69cf3a693630a74b491d4df2f0c76254922c66e3b3279dcafce0d2 c59dd25672dfd2b4a473e679d5a3fb6da716f249aac7b88fe47c58de2d07ea7e 5b34de888fa72c21f623c2c3c6916e566b6c33cfa5e8891591cea78ab6f30bc0 4a3fc2fa42fe307ca6c248f48ec294bf490996506bd9ed5e11806d3356bb7d70 346d28aabb88fc957fa31be24ac43e3c6463e4afe7a4af3d6e15ccfc99c0db42 ce6a159af406a01937f35740dc0b36c236a1aa0f37e2d3a4e175288836dd7cfc 90d6c15e734f4586a9a0c5f9ac978d7a10001916154e2c1af7674b850c5dbc1a 387269426b85359ac9e34bf688a1e3a92a07d1a74bdc437161d520b4636c4c6d f273954d59b42e16933ab44d8b69b16bca7e92b917d8d6f3579cd7796820780c 815dd871d5b16322580e455826e4eb4704d8a82782ec4b88ac9542c193a679cb 60caa48ac773bab851ae598af796b0d5ba116ed225c63e6fd0b6deb4a8d35d8e fa7a2b0fc1004f8dd2a5d2463bdb7098084710604199962f9e0a6fcb950243b4 3f0477f3307f3505814c5ca9efd0d92348a73d7beae53a11e69fe486f2a7e6bd f9efed3e25dd2f21cc1dea7eaaef104721c3b143c02fde3b0f59462c4029bacd 46fc6f6a32b7fa9954de59a615f839c6fb7671888dd4043f92dda93642f35964 cb392b3f05903408cd3c68a60f6f5ea6e8d69694da0cc2cf7e6db4407f170c29 b3f5aa092f63d7312c72d9506551f60df6ea3bc1234474c539c09eb9f8567338 03b2d66acc27664ba101d449c02478cd2da154735fca5e3a61a44269942e5f25 0bd4d607e581888cd7cb6c421b5d0dca1073bfb49ff27b34e06df960e0720acb 5d45c804dc0770a41c9436c775cebaf114c7db682b5b82f758f3780ce7def83d ee673d27f7f8d34995ca261e2e4305bfb1409a31b2e40f8113557bd4af142ce5 2ab05284492989b36fb12cfd6c2e3439de2be5dfc10a1838c1386acf97c447cf f87ab5ff7fce6d94285d69ce3a974f233b42b28b4a2bc5f3d1cfe2c90afc024b 54b237b7b9c0e779c832dc98d5d8ebf57e17991598947e786921b8712198b927 b3341af450e500dd71d1ac337bd50cfba8f40dd058d9f3a7f3d10dff76452169 886aa1bdbbfe0111b7809c15e6337e050da7cd9df997b4b88591ff6c1c5f2056 d745b84a76a9e9f13325b0d290b467673d0ef3b1ac6e5887580172eaf1a553db ef5e52cee08b8f0db7076b21b6bd4cdd58ae1736fab0a60661368131aff5f51c b85a890d77c9b050cf7605215f439ea87bbb12010a49f65cda05a89512d6eee2 708fbccc801e500f7b614e283bbee3da270cf0e73477f33289bfb240031509cc cfd925f51ce103faf9b99f6bb0f5aeab5b92e405f46a55297ad3720271b7a813 48b8e7b4699d247aa1cff2ace54de06fcb17dffd754397fbd8455b2d74fd2b1b 372f35573bdfb5d233549fff1a5df10294ad4c506f37655d487078b2f8a4712d b8bfcd9312e76c27de58adb14dc8b47385a2ff53b5415e116773bcd723812bbc 642084bef8e98651c13824133875a650e12af50c36a000e1a24e74f1e52a9307 6f07b4a0360937f1e6ef1dac02f1593c4de6f9b866b5d99e3dbd40f81575d542 cccb3ae812a9cb8cc50d54a51af04fd6edce372049e3aa9616c3d2fac21413e1 a44458722996ccb02c59311c5b457f099de025f5e0f3f7484acbd4986552b64f 0c3580b087589a1e524f3c17be57385a7e7b40b77ba4945641b550d14806c870 e9c5bd2428caebd09d48e4c1a57b076e33233883eaecb1313711e85ba33ec4b1 3b079e840908699ffea287c932855dc35dac3cf8ead627ff1ca731c7fc6e580a a8b59f0ebd00a2fc8f81ecf8578b39719b9d1f87ca1bb8da2faeca3a1db68cb4 706b80e53d1c47942a8ad866c350786a6d8163772835f7b077e4ef947251fc44 50157c2444a432bf5fa9d00c845f8ff7f2f8cdc0223164066ca5ee1b8ddd2fd7 d0ad17cb51d35997c82270c2e61c475b253a2a3020e4558793c4335b92e32cd9 eca4f4227de617896c4c58b7ba524b5c0653546fd46bcafb3897811139fb8219 ff57b73c1933772bcbe877b250496e7987d685064561fa0f73b766980caafb9d 65614f7462b1505cf9f1963ba77d0321a3a6667253dd5750ac276c1583ea4596 efe3487b7138b956014eda81eee9bb268a0068f0c49a0b8435d90d83fd7f1fdf 6437cf11c294578535198dbf595116492fc47e8c6874de7470dab2af26925036 4bab746a010a03e9a98dfbca2c721a56aed6ded924868485c162bf9df761c619 4de9e0d247a7e921b21fec3fac5826db088dfd20a69e4f1b7b06ccb07568b6e5 1824f31d869d461fec04d9152819cf904f15194975f0490bc34a4fe1dddcd171 86a155b280b2c101e950974cae0aae6919312f1fca4fc8af906ef54c90849f39 a368e2e5f6c87d2bec273f39727123aff3b4249adaf019ef153139b36cd6062b c69b3369a488d39c28e16ad5405043515dfc05d2c366fcc222c71c79d9470f19 7fc4829338b79bbe7bc6007246d0e58aa7865b00a7a983ff42ec5eddbc306b8a 8d34030e195451e87778598ce027c669d9d70bd86958e00c9ba8f56bf48aa5ae e621eac1258640a97ffa740f92ce6e22c45ae0f14ea34c1190dc39e27dfd5d19 352143c669423735e9885f12112b4e5e0ebf1036b0a514fb13a5a489666ea528 2fd95cdeb53699e3a9029f5b386ebf3af71a93374b4ba10dc0c84249e276d8bf e00e5e0a8162b48b8b2a88008a22ad95ea5f899388b6ec1635c26059558d9d62 88255b8e8d14c1d176438c88d948f7a97c9bb967eac93af63383469011c27138 eacf288d4ca29655f869dcce3ae6afdd8848fb64921ebdc5bf633dad50080d3c 181b987fcd8869af35e5d882f926042bc9f20007aa3c764b5a682638a1da4f81 dc547b5bbeca9441edcf5812ab74cb1eed150f67793477003eb77a74a81180bb 1cef33c396759aace8ab372d4d5625990cad0030e695a3acde6098813e697d82 186bed7bb1c55f82c39a301a1176ac4d64ccb754db9380846c1bcdd13ff47dc5 4844698d4f19e755a0011d188da0a4e0a3ef280a2e0946cc37b5d0f444a4b6a6 18761e8cfb0d2ae0e29d5ee0188035ab89ce4f63507b544e07476f64e0c4d3b8 e2ebc69255dac8590fd50ce1e9988856496358608f81e120ee8c44cd8781add7 fc8f54cbad2789134635836aecd42cd0fcf9e7790c1a8c75e6eaa531dfa788c9 9f77c175ae99acfb658fbbd8328a4806b3c2bbbd0f42b3bd70b3f5ddec440345 92ef7a02fb9e8ebfc1c75ef8f8ef5b50a8dffb8f7703f8da7101a1fda478724c 41fefdc4781b0393a78133440dacc5482f42e211409fd38088673bf76a5edf96 a3e97cac36cdc6b89f3e86ba3d7b8afaeba6cfede66652f97eb35ea36fbaae4c 8649440ae4be400b7b346665f2d9bd3f2dfec48926b21d64fcd40d3d0e4f20fb 65f41f1fd0e54208c797bbc8587b48ee14d234d3eba168e4de5eaea0f1cff2b3 461126d46b1804f8f1bd21962627c84907c2835f3aa610beac2e1898f5406eba ae835317f122311632b6c2e5d7b197294ed962b14f1cbb9d282c0f520bb210d0 2b19de6e6c87ce4f0ef958e093e2898f09f2ffec2d35ae3e5936465febc2724e 3eedc1e05c73e630cdd2b40d6d8c28f06773b674f0bb5b21ae136f609cb9a6a4 2fbc22b35f615e77eb79af1e8f4bb385afe97d2b598f006cda80c14f72ad03c7 4d2f5f12a212ff7050bef4f9c3ba30a9c36ac868b6b9ecd3dec32953781ad119 f832d46c9df5638dee7b0475291e7e77e1c0af33e6ebb34a162e3dbad2f88390 2920f172cc581958795c15f3dd19802d80c6f71ee4215452146695a75dbd959a cecd48260e5721ff0ca75a9c795eb36dda610ccd281a8ef4863e3f4a22231339 5db769880f615c6ea4892aa46173e6b50bd0cf6f8c092966b36d8bbaa00e32d5 2b6925c58b5e87fb0b7e639b6c3848380989f83bc6d212882fced8ca42ba35ec 0c3f95bd75cb6852fc3e9e3451759847bb07d52f09128377a12e579c0d9f98f7 b0e0ce098584bf6fafef871e2f2208696a17b9ea70bfbd75b7b8a88230025982 6bdb048b480e299ce78e84d1d7d7fe1724550a4e9b415b5dfa5f6d975134be56 5b063ebfa63c48e76ccf94f65438e436fa12577b1df7892b2f9a07a54b9711b5 fb7dda4a4857ce88ceefece7003e89723d4a1835c12362d43fab19854fdbf20b eb683841683f6bec33dc97ce92b7d2610da7461b421f62714f95ca69d5c664cf 824afe07bba7cfa2952e42f1394d05cc71e185b5cd968e7ad410625122a3cb3e 6f29222d0d2992040b06da0ac816668f6af601333bebb38ddc85800ada994f30 3142ecfe688474ea315255be72e7d1f89facfccd20be0652f64bb16e3dbc3178 f076721ffb66f9940563e33bed9aa26348e388dc9bb868c553f279c88c25ee6e e8a3d3d043f4ef5a2101149150a6eeaf58405da4464dd392a85b68bd13514d5f 6511755d6d1994f2cbb4d3ada8addd8cece01d118e0a88b63020f6cd973b432d c13a476bbab45b25bc3fbbb2da1ad1591e55a169c8f4cd5160ada1bc6e07ad35 e009fa2095e5fa7e2299bc7c060096d14b2ffc735881b5b698ae0f5385a71178 bb70f20bd4963117c81eb2b1eff23c06db4ffe8ac420a409112778e14fd086e9 31e2608e9fc12468b0b60431955adc54b613c5f22a7e75adcf27774d1bc52057 71b7d0e969d4cb4efad803991bc3e879588d92782d03b0d4a2f63d5ef61f8cc1 a0f5e3f346433d02d8898a2b58cf76300106e738439855a7dae44d7b5ef028d2 d5cd921a184a1bb153e311fc8f04d6b9213961c66b87dc53a3a0e81d6053d5b1 3a4c4b6f1d754c723e38288c9f40a7656a34549ca441e750927c37f532baee43 9cd39a34bcfd84843858f6ee1700d40dfb06e3ba1d22547dd08e03c26e3d3984 d43fb358431b7c2ca44f15061125e7db57ea4b6b44fb1ad7d0b0a0beb0921c5a bf600661ef3f8b14e691ba2fbbf1d36e8cd3a9e32753f1a62f4db8b357e8b06a f307e8fb75f6bf2211bd0d764805589b11119edae9f350520b9a7793fd2ce78a 8bc26d6d3021e7a4db5c3039003f30e8faca443f9b55bdfde87f0583045dab85 8d9c7dfc56ac0eb0d2638efd7c1bb46496d2e07deecfb74876ba19e81e5d88e2 205102455e2f9f5d68ab39ec281ea8d952e20e5f0899553ba4bc5b18cbf08816 184d8cbfc9e57c097e17f8b64c36339fb81209f1ff630d42845d196b24548b79 c90cc3b2119d2f45e367b817f691648427125743415e232ad11aae4ef169dbb9 ec392a4afa99fdc80a9ada5913b087ed412ffac5a46c20681bc2d03e44c462b8 06e20195d0bbb2b76c603b130c17ba0872ff4bd15c8e965b58e373dfc474536a 004272919acd27caea14bb505c6ed5497efae064df6d1272654aa8c129a6d841 9eb811dab600777e4c304447675951efca0e30cb963a19f9623f82aae4247004 ce5c8adb6c2c37bdada997667b2ea3a0772fe7738ef697a9538ce20d00136353 e3ada26b0a1645fcf113907b69400ef4a3105af761debaffe7e1629668d64b80 5dc071fe44dfaa9ef769ebbda25167d884625048a4a57092d9bc9c8c4ff6ad3c 27170a827b301df3f9acf3b65e060c6e6c6662f3c57b4e208616f6de64be5501 184cbaae911ff3ef62a435bee9fe8271e142804d4d9aab5c395dedb74109eced e1a58f19eb2512676263ae6a3da2b1d0d3952b51e0f7833efc1a165f2bb3a750 f1708644fba2fe87658180aced370e95836faca952fc72b6ced8dfe23c4d49d5 1cfd5cef9589f9c6171b69d0386ce53548833742c3c45148f4b26cc7e1184b42 c9d921a095cc9264d9e8874b702ba1e1bbfbad9a7b5ebd6a8837b012116ce13e ca0116966afab32666a9e1a8c12764bcd8ae7f893ba832250f6688dff6980673 f5841909da0b6706dbea187b578be3beb4858647a0448895aaf6ef3fd6562666 b094b407663660889379eaac5328dec07dc6698b58a7baf36fb7c03aa8ea444d 58678b05c4074f0b107ad8970ce088274f070f9b70d969d9c8f4d309b4c3c0f0 124b6a7e0aaa95b3e6704a51dfdba6abe8ee2ef6d58ab1b6e56007731e3f6a31 23811181cc59bfce47708258d4af4c8a12be344851a86da134cf5e6b327384f9 7b0857e29b97b16855614363620b1b522e9badec5cec229365150ee56b60ec7b 8c4fcf9f27bd07b3573bddfc83760e1cd7ffa2a157821129e881b6b036b83f30 322fc0bc124b4b06667baeeae69df8e234a871f5b2c8337d339826fe555d935d 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 false +check_ring_signature 08c1a1e9dcb1868d9f2b2893d910bad5f9209cd12a816bed7546afd83d53f313 0f1ca4c18e93e0b5ebe2b47b0954b081620a98e510b8bc114385fafae7f9fc38 2 d9156926535b2e93f11b45b1d13c6767cd8102d59f2c6570f38a70fca8b68cf0 7a71b232f0cab46fb8dbf184b91e6c4ee5066b81f8fda89fec869d1b7739018a 16897b1fa157c3e8be91e304ac5ee07e36d08d2e4c75ae38968bbd819b9dd1eb41dd2c6fa961f962655e923c166548b59aab437bab19c4349fea0fedce00a89ad15b6f97f6f72f686d49050ea7c1e564adc607afc38a13ea3d529bbe6a33680efe6a28d710934857a871fb1a8d246edd7de3e6ee8ea1f9ed6d6b6eef6571160e false +check_ring_signature 851ae2133f5d5c3aa5650eb65d3154d74102801992af82a33decb96760e8a44e bf428475316acce11f1dcfe5b25e416ad1c740ae8122c971ab92538f76c2c5ff 11 ae01898c4d200e7a0de47fbbdd4a647daa83ec88b308e7d2edc2ce0ff0e48e3d 3e012d2b2e3d1ea493a4a95da8d21e42c70f818079edd2357e3bca7111c7425a fed155d339c7aa61786a329dde49735845033b4c1abfededbd58ddb1eb88db03 957f97204c09961060437221ccebf4c361216dbb427a149589ebe3a317ec20e1 c4f944b04072c0f48468aa0788e9b15f2df36c563dd445b582a7b36b4d731c23 d375283255eb2b68c3ece8b56d1fd91150c5eef4fa0db300a4f37fc9f4f01446 f28753a6f8e1428ac1ce418bb8d4f44f49cfe1540c12637fff2c6bb5c5ec6faa 0f80af95238c8a1a90b867c586c66a27f2b349ef7e7a63eb644b60f13708fa78 34eb620e6ec9ed5bae1a2b1b08564125dc04d1ad2586510bace8b5498f9c6c5f de0b85b1066398c786be1d15c9867d1815bac9f5567fccdbf3c853bfce6cbcee 8d8a93277f1ad365246bc4930736605b1068d3205bf7a415cb29ce673ce7c134 dcef624abdafa8d8e14a0fca57345eceb2aebaf27d3432096479f034982d220f7d1059d616e7e65cdb25f90c634ca4dee0d71ac22750f0641b6e9c6b6f5a9907d7c9ba49d63cddf8602f6170154e5580b80b2eccf1a4e68a7dfeec21a9686804f1fb4478ab0ab7aa5db12a4d40b5a24e6a4412a34c013c0a73163b4a143e9900bc988880e2675c299d72e31c3c0263236c98d67c6aa5956bb0350819e46d550c4cd7f135a319b45634a4182e320525666c67f89f4fe31f20b25e419c7d16850dd3340febddbae68b2b3849aa964c4436f473f293d2e6649f6953b2e2d3f5ae0bb5b8e3c1452cb06a6612e88710b5badbdb086b1d182dd6b57d6fbe33fa6a2e017e605e3e0d35490025cd50c16d8d2f5e3da1a96541688225ea5db933e6d4ff07ea5464eaceb9b743ad9932b6765155f1f989967e68ac917e2ef9c151b866ac0f788c761a101d2b2cf85ac03d323aa4fd2453b60bfc26002d64260659f3df8b01126f5189616c30947766bd870982f4b52d64f8aab5cbf496c02ed863c676ee5e969946f48b35d5a5f69ca855cb90d0fb8216999495266184a1a239a256911101e688f6cbcea5c3698cd8c0dc6c91939ac920ad879a2be753804c42dd299ee7048ed594a63c9f131bac77c257c24b161f12bd2fa2298fda9eae55d43236eb8c0a603640c8c208c0409a7c5a8d8fe8593146fd43f47063bd33e483aa190c19be0633954e6821a83ada6d5ea0eeb88278bb90d5997dd7d4f42edc83fb85c181b3057d857623d8750b16b5f526febf440e729355527daaf4102f093557afed7c2007f9d5c8e60240da97892f7238f530efd8d6593e882788a6a04c732b3fe19dde0864e6be18e80b34b73c129d395923c2a0f5d4ca7a25d617937d70a84d67cfc909d13977351a728b5654a716a9f1852ac4e9835849b693604f062b2bd4a6a020098e649a8cdd6f96042e57cba884b1347c8ac7f330cd5d7c1d2b417c23562a7c0e false +check_ring_signature ec82f600d3fd192a3591adbf58b6ce681982e97e0e4362c658d1c99cdba3872c 787fc47e17fb87ac653d3b3470e7fcd7407122f84d49f56e2a9f610079a34bbb 1 8871f30ee70e3eb128b04dfab422c1ba12f89bad9f926426bd7cce4efc8276fd e73c79137e8c5447cdb13a94f1a2a45a3b7097a54854b44505723c08125e6007c0bb9aa87968b16752000fdf1e6c06b30c5d75e2abbb6af1436a84f8f22c2202 true +check_ring_signature 1ef775524dee0986f1699979f5ed0a7fc31135d511f3c1db9b33352a60341ab2 c8fa887eec47d60da619c2b688bd0e8c69a645d21c7209e8941ea75f63b2e175 27 9ab6d54fca10e28c3b57ae94a3e3a1672ba875a87fbb424b99fd9de12a897b7a 989a0f54c800cd01fbe11d9e763990e56d4e0181971e1ec6293cedae57261bbe 42b838f920cc2fdeeb34fc730910a7389474c1599c92bb502ea7026315370079 8580e475f0d0f635da3275d1798744e3772cfdc1519b94621a01c9eaf1768b7d 68c9fc9908d62a0b2719487c1fa8b2653511aa3d31cbabbaf171a52875c950bf e0cb1f0c7ecae7c5620483b99b06b507fd1ff0c6f1e2bbbbef196a22b5741512 1cfb0dd29e439342fe268180b52ee613101e200838c9bdec8da0e0ec8e55b5f2 e7fa79bc9feef6edd0610c91bf503a2b0bd4f2d246e0abc10f175c713bf2f984 fb902216dcb5b5a16cd3954d9ac8c04aa5f8935cbcbf33ac18344a7d124a8606 08fabed3f2479921979dfa9a4eadfacc93a85638c50899ef8659a9c6d425ae3b 58754fcc86caabba9a1fdae367c4c5045f4e32a059d35493b08e255f146cc3af 3c095e7a9a4353c83a0d21db0efd077a348cef7bd48ba6890d29e801bdeff924 d8b88be1917500306b9cc7d82648de935094b50d36fa6697da71a34a77ae7e96 93272a3eb6acc5d6c600461bbd0082b1c660a0a67b776ab9af62be03bd2a9e7e ea7c672e8db2a62d48c1638535c4958cfb4f556bb775f3db0a4c2d4570a18f47 ded4cc29ab55285dbdefb2e4749d3df7d6381ad3b481528bb43a76d6c3bd5365 56330ce1688a4f3ef564493371b8cf212c32809a864ed76bdffa1ebe0ba9c7ac 61fd2c348c73583d78f203d4ee978b34920618e88e1f913f02c9d8bf743f67e3 9df1533256dcc505d7c343d34fbf5aaa4291bbce99b15ad8647237f05beb3507 22f9dee094040f7f5cd850933aa253209b1e5efe4f61e30b537ab9062a166ebf bb1aac221109c19bbfb8ff69395071e34d483ed353e953eb6a0a4c27662dd30f daa0a9477d4ac2d252753cc4e0254f184fae92324f51d5235c0d7fb8b3def0fb c6c8e4b26796c2aba6fd2826273825721233bf3131c2ca83607e35de875e8bbe f27082af0f8a4fcf1f5c10fdf6d7572a3a4437ba3f05e0a3988f7301bfb193ee 58a1fc00e34fc2a2ce4ee693452ff38490844ea18c537003f50e8260643d62ea 884b82a2dbb781a46426dfeab3d8f0c646302622dc8e7680d6011ddd41d8eabc 93fb28e09e0a6e3c662f01c8927581e3c748f51d3508d1e5657436623311acd4 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 false +check_ring_signature fd26862d02ef1cc4191e686a39c09642cecc3a34d134c07d55a23f6336c7c216 6ef14dd0ba2d32b934f412240d739c0b146d0e5be0d9936d9da38727306356b0 25 777f0e853f4a153a54539aafbcd31b0e9d73be480eadef6fbdd19b599ac57d98 32280ddb6aeb7ff981ecad14f4977d1574ebc995081071440c1f514fad3db52b 6276d6004b4b2b76044625d9799af1b762675c061992e71f0fe2f79f643409f6 cbb7969899c584832cbc60102ccb22c1f2744fe5444a93106319c36ef28e2b3a ec3e90879d3871d657325719c716c30e6edf8af46dfb81b3bc214de1404fd9da 493cd99833f66d8d4ae1622d5cab509d0c6113b150fbb2575168671392d58327 b579485cf45ece8f08ee2177f146e15169e0b7ca13c522d0ce8139e95619e346 527f7718d330acb16bcece078b56867472b7a4756090a98083f5aae6dc9ebb04 2f9b4d2e19983d89d1078adf1d1a1fb1b6feaac542fa6238607e7fa606c19f84 f19be184fe21cd1d9c5e44109cee8ff09ac075f4ce80601043117def3a122d8b 4ab51a91f25f39d7af2a62129517f2048b207bcdb2e839a084846a159ac0a2de 132d32438257c3e1784fd18baf5d955d91895cc5624acb3a582181ee092393d1 a185387ba561b38b76be2acdaac90856a5637261620f281fa37e856f65a88635 4bd147abd02efb8ffee3d05ff3ec80527c75dbe69245b7e63bd9e7fd630f746f 3170460ae215c577123e73233d9e76695ce213b241fd81f175e69623c86b2c95 5e00870926f45e48578272ce228c4a7342aea826975850e6fd71052488041cf0 20c4c4009a0f20fe62a8ab997505f9b8a4372886fab70a98b91ebc30095f3b65 969697d27638f73a3b6762bdeba8847547593d1bb2a09677fe558e180217fcd2 7dfe192ae823e2dbe9362d636c857116c279d4a021ea4939ae780d1c847d97bd 6667895143587ec1f566d31e1c1838e4e67b5852fdc86d4347326efb2e7a4de9 47f114828d7a1048da6ceb4ad277f794b6d31e328513f7075269e70bb4d7271e 387d486c62e07a51d6fe29bc1cb21d00ab2903cecbb9a94c9da281222cf82455 3ad0ea1c091ee5f2504da699835832cca18f77cc35397a6efc658e67b213e4d0 fd4c9eab311376f58997689c4257efb968119a56b7dd1fd2971af81b8d9f196d 531d0f594b7e065b63bd658a09042ccf9842e2566c41815c6b7e798443506402 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 false +check_ring_signature 90d25b9a4a017cf0aa768956214170a85cae648a5ce6983abb94427742837b36 13bbc4d5b7324dd2867d6c8233fc35486193b864ed8c79227dc74111a5c8e439 4 0274b9dac9aba74323b752727903e0bb0534a35ab2388a0a67337047bf50e161 397fe13dde690f5862f061615cacc430e1767747d8eeab822f0daf31d1cef5db 75988c2ea447a9f1dfbe1ed6fb2829aef5c01981496fa081cb6b45972d4f47cf 4755119f31b8b3e0cfae86c3d969199ab180a8fb5b46f47e20902ce2cc9093ec f8ea95f4d501376866fdce321bb1985618859b32fa6b813c6c43eb41a5913801804406f0fbeb417a415fd6cdf38b4c4a21265f4ff72f59ef3a7226f30e3ae3002fcd65fdd98f341140423e7c287e6646f3d88aeb1ad9a6be0a9dfc2cc8f758d3c7a8f8fd6d52ef38a9da46de47078b2b6c4856808b8bf5db505375d1b859870e97307160ce678228c6efe766acf8428ebcd2fe41d1752dcb8d8d31d3189640016426d0f542bced454031a1d22b7f8ff6b01db99cdf445d76b5a226a7cfb4f60986e05b3af724d0d2127d7a524b3f0eebed5bb095824fbc777dd158bab174bb08f566079d58faed3afe3c0beb2e45b7c376e04d74f84ba5ea65570bba024d7b0e false +check_ring_signature e158c719111bea4bf991ae3cd9026c71a2a00916b128fdcee2ce6ebe5e0aa132 3048ceb92dfdc34eeabd14f5254ff3ec93e7c69b52a55f5f40f619c7d58f6d49 4 9ce90ed16e539c8e12df474f423008963a809f5041329d36385e19e3b1b2df20 124754e9cec96cadba170b5f7ef069bce77317d77de37e0cc6c401115cb22269 22d8e119d9b8fc45cc05edaf8d6f934c2ded3827acbd40d339bc096bf577f070 0073e0739d5398f920e96eabd21200e98407440989805affb370814e4eb3ed5a d32bc7c858c63ddf15c0cdfa82e908c7ec77c90e18b149d08d339c88e0a0e0063aab5ef30bbe6888d5aa77418b89f8822257345acafbb2d201a00559dbfcd10a9622e19e634e0cacc813040c1b34d515b41ae3503d6c47cf26eb19b9dcbe9c061dadcf146b7d88c49a049386a43adb8dba1a08b96ed26010c91be9ad1e208d0b01ed0fb577ccaddc19dcd541d94ac342d4e592955876e9fcc6a164ef2fbb740518d463e23f2c2ef625d849ebd4ed0d02ddd51e872a06948562b0afe6f143f103cb63b3bcc026a46820de30e7007027b3259b9c97c4644c23b8d5171710441e0997df1701827929b5bedca6fb4c3db818fa41edec64e08c3ae663dde4f8c73407 false +check_ring_signature 6e02e7ca484aa78a1ce69620adb6b197f373375cc0aa618cfff0a2bd20490651 06a95d6a9945e9c8d1ff0fa1542722074b4ea6697944aef0818f5f8d01617d40 1 eb59fa8031ee57ab421a45e1bf90ff33c19371a6f525dcddb2c08b98d3f1b207 0ea3cb7964060fe784a34e30a0b5f27b3fc0e8cacff15da3b4356ccb0051a50e8e034b7b3f2f3bb4c4283a19be690cda73a3d0ee7f686716b3c91742e7801b02 false +check_ring_signature ba7c2f279a014016e39b33c08303d749abc4348ac67ecf4fed9597a60dbdfc59 26844d293a07909403f0c735b02c973cb49257ce5422599c7d6503ed4535ec38 1 94bee0729a7721833122adc19a53340cad6b490c070bafef4967a575556e2096 cdf095bfa922bb2ff5481c8412462fbe0ad16f734adddbf8384f2e830c4505737005c7cc1072eda449eff3519edce5a65820d2a15e615872f17abb20993e720d false +check_ring_signature 4966d4871e23ea3b6f6fa9988c35c1f5b07067e4439c384d593e7ef4670e691c 489c327d6b071788c9fa8abfd9d31e5f8356e280a6bccd0d2ee55e6b94482a84 1 58a2d874b8f094bc1dbd9fda7e63d0e76668202a1aa4aa0b8e836d119b74da44 5c79bc9c47532459764d2d2fba542652134911806c2e91a10cb0f24a6231d50144bc010d88b58bb25227f091a0ff0049c9e0b27a1316e107acf3f9c387845001 true +check_ring_signature a80d534a83451d2e321ddbf87124e951657439e7d832769d8c0c4a582cb1ec11 83d90dcacefe4b4f3114ac37e99b187285846f24a1fd953aa528ee7e6f62c7d8 2 73c57a5c695353a6d008b3de691818f9ba7cb41c3b950aa6247c09f982f4e452 a71a40b0df06f164b5f4d81a4272f05df1bc32b0460009f1372a2dbccccadc66 a8f9c3d49742e744f46a0a99b6a8469af9d389c4edf2201ff6f6e698e216bd0795cf778d9f7d9f3ab49a05da89ae8f9c56c98cdf3e8fdda839a747fa29aaf70c450039fe24dfe203982804c26b0200a8a2da06a1ca910feef7d8ecbcbbe4920909c111370638354ef0cca6eea6e4fc3660eb1e44f99c052083e3522654c166d8 false +check_ring_signature f40f4c7787b02ad24777d52e440a564e1daa42d41cd929ae2577fa9569767501 7b95237e6b1bafa84d643410090ef1f80a9490e660f0f42a7238daf87c781262 9 1ffd3738fabc1ddf04a81ce5b89b936da26a0e87bee7ee3c1a89bc4d50d8e27c ce5ec306657df5553e6a5774e0d28268724c21942dbd8e0daa2d9d7b5b1696d6 6ee09c92ce713f96305de9af2c6514773576d2ea8bd5299880e807264c67729c 09ce25359d881200bba71114e3ac13569928501fdea849fe26c7110555b4d06b f60d3a3082136789787f9b2fb89885421a1458c8a7be1a1c79df7e55d41e8040 3b0a023a6b9cf059e890f9d0d5f58c6152f0bcbab4a3d0c9cca0a9a8999f1036 ef22ace07f175ad12c98124c86b80e73e3751eecd2d919b3dc2c14b332094b88 e1d280ab4d0dca5c43011ec6a364125e1ce011732e3daaf48fc9d013ad22a926 9ed692d571566bf75a7e9ac4fec948431793e07d76da8897c459ec938955ece7 1da48477c9e94526cf6dfc7d27323567e29ab06b7b8f66ca494c33e1ef48940ae7d524a3ba0c06918db1adde124378975bf96521bb0df5c3cd16cfac37a98a00dffb2e181fed2c2cfb041a7a31de99a918273e280dd37c25c4ef7dda2fd95a0b3390134a8849eacc3f6543f9ee567c8a0d146674dc01b1ac812063269867810de16ea0a6c22d558ade2028ce6151021e6f7fec6b3cbc49fddc75def949aafb09766b3c6de49311612d623a06724c7e81b01a62d68588cf78168d0c8ec65897008953d085ffdf993a05251e58aa66e819eaef76ba7d4157d69c377e5b50d6df0f1cdb6eccad56cbd68f21a8433399f0247512df1d0fa8979b7ff54c44bc49f10d96376d4b393a25b4971a635ae42f9246913e5b94d2cb7094578a45826d3b6b0c9075b9029a601f0dd8a52d6937e4fe5865e33d798f4a4d62ac044c5958d28b012d1d1dda1c13c887d976c75fa026ddad8e71564d157351dcdd7a0c7446d3a604c3e488827f93aa9d50af61e077f8b622c2ab69b46ea1ff615cedf62dcb5c280adefa71bbb568102135423d43ee79ece47e149d9788456d45d3aacaefc095a700c41f2bf76df792f24992269b1b8141c7c171086e3025e8dc3e20a93a06f63206c499e3458f386e88d4d141f1b7833cfb8435f4281cc8aacb14ffcae29a7ebf0ee5f6249ecf1134139d08188c34d0848b40e3667c9e90bdfee03abf2dec49240e8b99e0545704c65a65753f8333627f95614fce8aa37fa92e39c376935b59310011c04d863a48081729b6185857dba887687aa0b2789ae7dd5af41a45e56eaa09 true +check_ring_signature b2af2f85b6968903516d7deaf2702f94c0678a8aaf3c908e27816f59219e0823 cb424bf1cd2881b1a245c3629fb075f7f98f7ac9dfdaa0ab812f8dda129aa0d8 38 311069e46e6e03a1359831787b0508749270e6afa5aa557d2c91d43a69e38b66 42b5b0fd44657bc475495afe8c920f1e1d0dc72e41e3cc79e208675cb4692ec7 8ec63623006381f135edf90b5ba32bb279704b45619e0cf1a179efb1c8eb7633 8fe05dcc8ffba82d930a7050a8c6e32b27f441b0429573d9820e14fabe8d1e0c 98211d303847f5c72307f7522b470b58b832fc3175795f2b5c88add2191b889b ec329c5b5affa409e2ef18a7efe729acce8996a4b752b1280c855d46f03f2f4c 5e460496a191ba4f7d8efdaf1ea18d3b10abf923fd3b27ad571cbb5b2d1daa3b 1e3890b6c8adb22b6090fb82ae807b114ca345e761bdb6bd34729be97721a8d7 fadb01c17e0233ccd004c61168cd4b4e9df6a0d106bdd5c53a9d074fae78e42a 4ce058c2cef15db6e4fbfb2a5dd4d7454016a12dd1518d73a8e11b0adfb450ed e97ce2d0434c1d3aa97abfa9e68b28f2aa0acae16ebfed499eabb06b9bccdc28 25423e97d6029b99a7ff8347ea1b423a67c0004c29d2ada0e500f2865e0e1ee8 329208abae261abdc158df781ae90be780498c9a262e32c756df1d6664e3e926 dc0162a35a1fb60b358dace342405111b9641bd9cbf079d9cbd60c36b94cace5 7131fee6a14ec2edf4f60529ac58dcbacf28fa04838161d3b9d6777a42e2ad85 efcf8ab5eeaa9b41e771131c3e8c1d05b70a638d0801cff44396459080f42030 18ff4f2a22736798bd0aac90c487df66a98285b53146447a56bc2a6afcad0e34 0cd8977a1899950bf24ba87561af0522f74b33672b08e28fdc5306d013971e57 6e982ea1fb2563e51b4ff07e0ffcac6b769b0b615de0d29de7345741d9da4595 6ff727b7384d7b4482ec33c223c466c653704b7b44ef244b9b3cd4aab049b4b3 7531660f0fd1d12895fd4b0ff8f6df12493c10a0356fae03c1b3b42c84064e48 d5298b342dfc622468c20b5d568b07ce4aee6f3f065e8f53e454fa09541eafd6 0c2ff02e03a07af89c0ec99aa4280734edda002154c580d5c9670ef3f16fb197 61795ac256a711a7e6cbbf52ad2eb5b3b773f101ec66f6c0b24fcaa033df95da e63331e88eb306bde6f88b7c38d6d583570775d67cfc42647e5e58a44a85b2a6 ff8fec6a31766a86001d21a673b7fd16328f68854145a14339c0f8ab3bac5852 3a4bf9eef3a4742a569c7dcacce419cbd7147c7d80b8f468e86a1ccfa26a7fa6 92ce13389dd1c65aa5c45827d44eadf1995e1225f2033f089a1496de67b50b44 9a9fe31e9ba1d112f03cbdd8838f6e2f1f112652c9e062deaa0347e4cc21d10f 65ca3fc6725bd7d525967721a9aee349815636ff119087e1176a769d630f513c a8bee595a858ac47f37acdf91f6858fafa2525621eca6d398ac25263a1b26337 eb4085066c15286618b0bb2a488b21668d3164cf0cdd324887964f266359d376 3e01284cd8279e64edee87ecfb7ed59a520097cc84a4d8531246dbb526e93e65 052b41a2c7e62f29300b3134d2cb1614c6e192b65704601db148a49749ac1e45 cf867f74ab92dd71a90ca04458aaed176971b0e24f898b106491746a6270500c 2e405cfeddc20532f875f477308634b0d2e90a56e68bb2bb4b07bc3289d42dee 1d4854bbbf7688ba1df837eb1d287f1528fbd0eee697621bfa8585222faab926 fa2c909bfbca451e0e955f807d7bb83439109dface5337f7dffc78950def6b9b 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 false +check_ring_signature 1856c129fb7aaf86ab7c892c77ecce44eafe2a65b3f4e37ef9380335f959ae1c eb0b3385d2306ffccd3ba570dc95441f8fac3f7e4e31fdf42d3ec43958b8a450 3 58f5e18baf4e13726b4f774c5aea3a2e9a06670f43c1c9a0171cddc88e10c63a a5b0d8838310c01c6caf0247e2c4b3c24b684b2a3f2c30192af3fa891cab7b9b b237090d98078eba9eec13177dc4cc7bcfaf15ea0bee668e25e0ecc11cd444fd 1d633fa9a0d2e90af816ef7658cfae9852c3eab07f700940b8641de389a5800e17a6ec08175e51df5eadfea76166bc1e2afa28182b2b2d2c55e9c7a06bb48807aeb57852750ee5a5f9cb7b0458738efd42a9844e3004ee54d6a25705f1496908e45e02d2c4b0fe73b5fc450bc6e6dc180ab586998b55adef3b8d3b3ba60fa4064424397b8a8e8ad8de1a46a77b2c255c978fd850684bad05fbffb6fec7d4760d10fa69d26b5bd25376e61c98b5f0230b8987c4000307d510d5b836b951ff2b0c true +check_ring_signature 9aa62f7f8d790f40bbbb33f0ecab2e9287527bcbdec19357a39aeff65bd03e5d de5826b427c3b4fbd78e2e2791d80543959ed03eef89eaf59943b30562a08b5c 4 8983b2d199a4d3c5cd861b64f71802127b0142fe0ab3c31f6152d61d3b57b27a 54ef4b6c945a6f9f8859b4ac711263ae3368ad245b255eebbac4d3b68c04f62a be7e9ec76ee2289158cba8e2450d1ab2e27185e426af12587a6a256357b42d9d 641869758584959720f02aa7bcf8d8677cb24593b0efa615f1bcb4b900bddb9a 40b3b5cfa8662b0e841464fc7c324add1575aec20367ced95ccb88fc5b72a30b469e900e8241fc8a3d2c9d23eadc21ade7fdcde070866005c356285f4f791c033e2bd408610448958ef090f2cac7a42c593059b59306925080779410e976a5b4434b1f7ba075e6fce1a6242c2c1a16e241bee12f9c532d0b2880b947b1b767069ed613892889398b68ca4d21c08f0a73a97a5537960cd5fcb96bd8b59c05800d8a24cc6e04340ee2a21d8ff52cb42845a976ebd396976f61caf5c8c07c4aaa828b9653bd44982370fc86ac2adc97f06b0a3f41275c7fd6df3e5af6a725a2a20e9ea24c6bc52931b6c513c6a7d5bf5136c3794d64ff661c4f88c3127def552303 false +check_ring_signature 8fa92088028e148abbdb2682fb3b70938c04ff75bbd6c9b14bf24fc61e997e3d e5c1116083bba417f471a5f611197dc9367591fd79edb49c320544acac08bb11 31 ec2693d884fadba69ff8a5e0cf9b11c9eeb459946d51ac0c0843f15609b76720 153158589f48811b03e767572c4e05fc639a85139f2f4599c74b8f3151c926e5 b60998abddd4135722c931f08418f1846d361c185907c5ebe07f53ea83bb86a5 582ba2eea9ef933828faf99d60602f22806cd23b54d5e8308dbca893b0fcc292 e855a61ff5175df7f40cdeaec0620658ec673c7b4c10b4a62cf05b7fe37e270c c60bf89586317b563ff70903cc3ae59fa4cf36d2b47599f04d453050cb44a587 98563be0a418afb0aa5936d233bd835daf004a70cbea052dcf0fb47ad1ef1acc a9aee55703ed5f45618baccc4fe6fcc185d8c872cf8b033771a7409e9cfa3677 6415a75de488a1bb69722e0cced481d440849f7f07496592f2db66c6d5991a93 0beab77ceb88c661040dfcac456cc8d34f3f96a99a5a6a02206c9751da6a89e9 e0c47c08b65fd25b50c83f316ad40148c68c539d982e67f801f82ff87632a915 befd29898672b8efcf7180eb133b1bddd08c92ca94f17462bdcba49ba25536a8 201b4776e9160f352c8376e095e13bab910b24f0ddb6e6dfc45c9673e0d59270 e5dccf25f76bd3e0806b41211a4a73f49b51aa539eeacad5c9917b861bf52aad d0726fc4df358a1ccd2477ded55f28a1c8bbeb6b5fe82d920b083dbd541095ee 4c23acefd931356701444c7d6bdef37f5217f6fc097f45811b712c9257c905e5 61ff6dd7cb4a25b180ff0625c6dffb1086885d0aeb5cf6e73c5603004d46db05 8c8aa2413112a7f0ca42006c676f102d380424117c6525206429a7fd16e69930 382b68a7867486a59f9677af8141a58363e2304d5c88b2fcefca76500ca6318e 7b410b916ace4dd42778f61d4386a764396daff37a292d5ce44f1d828c90cc0b 7a95e28a482b2b4e77eab221de0b21692ec149b5868bb5783ee059a47929e7c0 3341de3ef250e386e4b1fe5271fc219c96496f3b0fe1ec90953ce551e77854be 73d193286fc1238c6c079319945df31cbc20b4caab0b65e1ea6812948a2b1083 a61db7787cb637ecbdf5b7238c352a355f78aeedbf168484feee22d098348730 b224ca5a3407ce6f2ab5ac282c589ebb81f33dbb53dd1a3ad673f11b77b2359f 94bd5c6b3fcbd15ef96dc3a792c820c3b7847a6704e2e5e1e5a8a7da1675bde5 25718cf84045e1ca40ab2e286e93e23c9b9417e9dd7eae042e334533621a4bb7 b8dd83e79c492cb08a80ebc52f09de77e752defbe63fba8db6a7468c8765e167 f6833fb80af2fbcd3e6e614d0c2d24f8d20d6f3c8f1c68badd26d037c21e7974 a1dba227e90506ae1254775478227ce59f5318009b7a351d8337c9c22cba76d3 6a38f2c3dea4211a871fb7034bc58721094b24ae2225e05dc8c065ef8f831560 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 false +check_ring_signature 304466589f3a147a0f19423c78d70e46d3cb41891ed470ae6600408561c49f32 02d88c71300367404a7830c57d3f75da70fe741744b9b2b661c038e9b6f72cd0 57 9514cef6ea80dba88af5a0a3603c0bc1f9e9be656e2bf42e2ae28758f5ef9c97 5561a2e2241b83de4ad4bdfb9d73df254b2f6c498a1b468ae64d39fe1e5748be e0be8255113cd3d504f7026f9795c6f2a7ac5202d564a0f96c3fe01ea9f88c60 b057576916ac9a9fa61a2e1633a990d9b1d1076ca17995ea16ce1479d2d1032d c378eb8b42d675a6472c7f4131f8ce3faa88fda464ea79d82fe63a5f90679ec3 381228eacbaee2efa89e73172c3449c695fe8e6b87b42b28d38de5009b748194 ee462bb52976f4f11015e669ac8f84c32352b5c02adce8e0b725a4cc3d5788f6 1b18503045bf82b5ecb551c474a681208140c4b86f92e61e728bdbccab6d2184 40f8788e182c8f3ad4d9a6df02685032191d63e09b6a3e75a381267582a8e763 5ee1704dc7d4ceb4c166ee17c8f5b041bb0440fddb8150b69bcdc498e3c84b92 e3b4753056c153850abb3a1ec730c35886d44df8bdde1475000c29016d9efa13 7ac56c546efb2a236f5420c4ec8011998fa93ed7ba72c505783f57b179349b42 40d75520c3eded85ddcb43b36b1c88e80ba6df3b5daf3098291bb90fb912e815 37f9eb984134959c3dce54adfec4793d28f5eb68247b88551f8c0ba38b087506 b4540e87f99e3e61c4c66b868ce079a431664f614c0b6776c626ed47192b541a a07ab886accb6e67a75b979b29be7157bd856c2f1288f8862a57a3cc86ffe8bc 21341f537a8407a4545f015e8341064a6095a404bc1ea88bdede2681f2bf433b a377439d73f35b53298fea7536db78a943d2932015545c4f6055d7fc1d2df07e 43af19a633aea11835067fc8b9e6a13fa0ec96d2f6f38345ec2bb7e45d15d894 a7ae35fd3ebb2efa6f37c092aae3213dab39ab44c5be4c3d2b54d7cdff078998 a4debf8a9560b98755edc3bcbb1debd5d5718850e4a268487f0534b3b9cce36e 87560ee04beb47e2865d1eb6c31d1c3154eccf0c3573c94fe29898af91bf50a3 dacdd8ebbe66f8f12ff3884b308735429682e54448cc946ff2401954a6d97f19 b8909fe575f412848629388ec18a18f23c91a738261250736ac3de2c438f0b45 460543011f75ec3234b80ff0c08b4aecafd5044b02acd09e4f07e146bbcd2455 b19ead66d7344e7794179ea18a9cb72defc484967c562dc3c1abf79cb3f1d4c7 5dbd0c444310c9ad7f54b0ce9e0f22f4d4a3e7ccaf52a4489ae13de42a28d1de 095bfe84045d378bb64bc5fda5b4e424ed8bc992e1ea8f2721820a1fd1430dcd 147b2b820502e6fcd3fa9126e5419291801db02a0c09e2f3e7894fe3d0d2b880 d8035759ec3dd1cad90ce4d8a1cdebdfe9aeef48435221dc9d462b9a24cbe98a e523aa0b066bd930f3037aee7edd64a4a61b85599d423f5303d95acc87c02186 a9f58aefa7d9a7c8cce4c8fd01d9a3f79c3d2f69329e883ff6ebae295dda0085 c62b1fb01d6742bd19427ce3f27bcae49f32ede7b7610bae52ea942c427c9b18 8d8b43d82a10f139d8d2ccb41af6cacb8fd6248399149053d70ffb89899fd9bd e594b6a10fa3a836eeae2a07e91e44f43841fea424027d8d8dedb6c64e4afa15 1b3d8240c6923100483d0fda877a70b906d83daa6ccc0506acc91fb00c27fc2a 8164155e515a0dcff9c94defc6dd9215e6c0f028b6df74074d5659dc86333542 23403200656742dbc34be27a8c39a0e88fdfbe2cf6b3ab198d26b7221c04dad1 07fc55234ebdd230db04b34ef9f62880b955504af5cf6e1cf47278a167c60c49 2aa9da0e489030abead8f36d56c88c860213899e29e395565dcec37623d704d4 ebd06e1a41c9928b6ddf333331ffbb3906eb7ca9c67334b9501806ddb38e6a26 01d97750556d0ecbcb68afe5679e249df429b7cb8d659954baabc0cb3f763bf9 08fc3fb271d28428d304b4df0978a55924a0a0f4407ad3e16d869b30610de4b6 d18a40fa7d314674b3feb1ce5b986d06ec86d9f2e9159f4fd7ee19dbcc6c6051 539630e696f4b68fdfb323942c5a17d30cdc96e24462c86cb2dc97964d7e4a58 4a190a875280e8cde8ec67c2235430e179bad8e1ee8ed8ea2654f60a5b44b742 bc33d5aa04e727958f681757421800b9998711149e6269ae8d834923d06043f3 ff277cea08a1eb7bf1dd4e77ee3bf4eddddb2eeed0ffa035418683b26300f35b 9fc2f984a716d133691970251ff4df3c028b0be9a87e10c9663db6bfed8eb7ef b8817c7dc6f135c381dbd01a9902c244a719a96d1ecf878e593c90c2114581b9 ba9229463018229a3e7f42a1e68031bf1e6793b59cc4e565499b9cb9a438d8f2 aa0a5957aa69102e9dd26e7214ffd7c19cc0c6e3925818afcb2317d7dcfbb216 f0e73c5550d7194c0fc204fab223f622baecd538fa43f3384cc9eb026ba808e3 d6aa2217e8549a417742eb1fd25005171a3f6da7589a794f1adc9e645902e96d db8441cdaffd2122ccaf9a7220a0bdeb81db5c9289303f77461782d81385dd54 8e8fd0d97b5d59cc2b38f4845f37daeaf3462298eff5eec0bc77debe809a0371 8b007be8f1c084908435c98c280d79531f13e9072e263228c997fc742b51e414 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 false +check_ring_signature 935bb65750f98bc8599fa9b85553b252648af5b320f6ff02dfdcf4379f527d84 1cb0d0770fa859327eef709b22703b125940b0bb406708d37d70bf9b74435ce8 1 0a4db2f3df96920be87b4b6269e32c4d2916d99cb275062ed4da62398c1569e0 367f3a39b73cc6eace72ea5ef1f0c20942dd98da625b83c62d238aa1d5def509e55ef0b7b7004767528a7b6d5e7b85ee8ecd4569fdbba78fdf3493dddeda080a true +check_ring_signature b16be7b6bc89b9b1fa2229ddab3100129ce3cea28b3a6ea0a0eb61e718b83ccf 2005c8fb10bed64ec7fcc2acdafbd48e96ff073ce84791cb937994455aff1a1f 2 e6ba1fd0a1089bc8ec11e4182be3eecd7aa590d4b02436d717e69173a96afaf6 51fca5f4b94b293e418e807ada2d70bf7df87ee6c935eb0fc2c12cf8eca3464a 9bc65c66aecc17df955cb735caca4c734dc5a89c8c766377c1f5345c656b250d54083fc9b0b8358622b0d14412dcd0ec9b1d929a1e022a804de8a3a866a4a2a6b7569ff0c1c8a938f5f8cf2daa7a042c194d0d6af029ab424b88ce5faa7d21080e3e1c4677ae1027aa614616edb433df4232bdab067263326fd3a674b7d48408 false +check_ring_signature 7a962f221a1e70fde9a62dd05617bfa3b8e40c760a19ed878baf62e788b370bf 145010554077e14b6d2c45e377a8b0fd3be623935a5a7617d8a406dbb9df5a1c 4 856648e5f06812a16094d7f765ce6a5c548c40a1989d93d32d58519b8cafbc13 eddfcee250a1f1d90f61d134a5f25f0329d4146ec13cfafb6b790ec236efb2d5 fc3a4164aeb60d983495ce926dee2136b0af9f5114a373c04ebb0cad12e6fbfb 7ee33da7bfc7314e89338b7680a43b20627d89931cd6bb4f4061d456c4955f92 1848f1e095ca5c5e72cb4ea8774e21ee650fa47eca706978e14b8df7dc5e8807930d781d11780b61edb3aa8ab576b816108596bb07ce8b1b040a46cbc6a68d0e130e560d38b2fea21eca04c244758506d832ca6c7b616ccc67a7bbb7a6e6110e69a8b9641960a7df3efa653a7ba75a91ec99dd4e56665363d298d01ee1063805d58837334508e435d24870420450b0a07377e3cca85288f68ccbcd7ac4e4830f8656beae4245ba875610b743d10831231e2ca9292d1b9929889a3f3ade79d60ed4d46b3224d4293a28231f294650528f11bca024d2aed531ea8691cea964d203d87c6ce32885ee2a8b9c96e8aff7f44bdd481d53a21fc3240d6c660685674a0a true +check_ring_signature c28aa4088bf60d5aa7d5f45d85bfe57d0d0949042602bab63cc9848d23a74371 88535d0fcf45db8f200681f1c390a02aa5a4cf849642eb36612fe1336ebc069b 50 57efe91c1b0bc1605eb5e82016a0246a5968a418002f63779d6122cf507d4ace b2669c272b35e4b88eb9d9ae636f62fba676f838a98e5ad80786a3441402280f 8b6ce03b081e010b0d19063940acf68fc3964bf7a092149e91da1ec0ebaf26d9 4e224c29fb18a3114e54bc22e4a9d6377658afc2afc7628f056981242ae15df9 0c6f0beddfa0b35464d6506fe749b61faeee0ffd60e62a3187cbcfb0362a5ec4 3c15ed5e82d5851ce1d8215d938cf564e6cf944b96cca22803372737379b71cc d2e9ee4e7ddce90ba1e4d94bdb5a60be0950af44a87e16b2c6070e53b7296571 ed89464722db6aa1a0f9f668c147c3edb5c99302b78af1a0622214f9781594af 4b9930a13ca41c28b11c42c7c755cb2abab76cb5f64719600819e73478748603 e41c50f979493bea67a9bea654b3c040972d776026675487fea3fd80c7b8085d 48d61260bccba707c357344c82935da57c94b21268ffa8c7bc96970b98438f8d 502bc8ab81ebac530e53fc5b67343b18ff1befde1df6e742cc7c936fcebff712 81dd829425621f62f7cac8e527ed104e4baa34794dee8b3c2a5b60e1760c2a47 390f6dd060d7c3890fdc6def37e1330a7c1b1eca2fe32d3158b8f16ecdb74812 631cd42685ba268a035dad07f315724cd14a40a1004cf3dd4a5b5f150f98a447 7ee8e9822e8beb5442ae9ffad73a389e499aa62cd2060c52131346b488e82c5b 916f3cd61a24d4b2583a61c0eb7acb24974a22e471f0066b2432619ad85dd051 0f22d42bbbee98e715de15e857a10982e1a13d5ce3955666ad57ae4cef75b6fa fb67fb5bf5d1e9b8b6c5980e16611bdbfb4ba4dd08259162883f41cf35a06122 4604a768fcfae7afddb012e66f4986823023054e1c1c61294c55924131d335be f675d78cd4cb559a6ddae02fbb9483421229b7af92595c8225f06bb5b28412c9 1d823b32b5eb6f3f9413ec599fb2564162a2f7729569bc33976f4e7294326a2a 411dd33bc5741f5622c2f38b1bdbe7a8bb053d44ea41262b7cb9b0e2d70d2122 d9ff9ccc3691d0260e7f2b932e94e975a3a019b0623eb86b48aa846067e6dc28 d59506d88c2adc765d3bd8951273c02e6269d44aedc02ada858e841f39b6747b 8425e0985a16a6f398d35e9b4f0dac9730556fe1362a73aacaf32e93ba2711ab 70a9fae175fe7020724019c51b7ee8aa51d1f499061ad120dbbb47830c919ed7 f3adf77877e214569555d29a774258e9d82884f4257addb25925c6d81a2c566a 2db29e3263bbc8e511fcf1d710713b05035b37d2bdab441c7e47e7d63c2bf193 f9e15dee2b3fc98a12800b8e209006038982291c958b127794e8514b6aa6c2f4 19568fdc98cbaaf7fbcd84f3a9811dac656e294ac13ddad1abc94b514eb318ae 190928e09c16e6c1e3ce8d912438c7878b7f3b8473742d7c742267a22f064688 e6028e18e991da65ca2cd4f2ca7b27158687d54f199f964bfb2ddb1fc71e671a a08ce70912fa114fb87b7c6bf176bbf3c11b7021afc6b70833c05428ad50647c c05dca1c4f99e439b0d0be7e5a78d32989036088db24c66217de53870cdbe53c d1f7334d110e2c48d05e15118a03ec2be44d1721f5c6da138874de641eb830a8 d572779c680f7d3001902345f558ccae1e6524c955c524abce50c7e59f70f26c 960e411354f5c12eaa9237c1f68f858ecaf8f866f53e3c114d31fbc75004dc8a 899d77bd7eca669d5359e27399609392bf4fb62d799393ef291693125288fcbe f9bcc1fdfbf33a4d79ce71adf882236a721c5dcabdaabbc020e6132ae8fa06c7 75d04f787228606c1588d68dd2c9c072640bc9aa31aa7f84b6734b7f8f161e21 08745211cb7f6b99a273eb975fb8a20bb39ace7e5bdc8e873ded38a2c76ddabe 3f08eca67dd097cc91efd169f3b4966aabf1f29aa59bbca0b246205596d056b1 23614c16b68f86664d7eb9db35adc42e84436d971f321920a88ea4458057a9de e8b400811bcda68458c9ba84392924c8652b0f1f49cd083f7bea49d432fef97c 8047929ce71319f33d770d73bd91ebc6c155f7634b8fb0eaaa0d7c17c53d5f09 388c982c4ade58a9644a058f9b10f2b708650209bd21e4593f7bfd7736a3ae63 6281f19259fbc137f61b2c118bd21201bf40e892aec5a3707c76629e187914dc 7a88198b7621fc37dc4905dfc1d81df3778854da17038eada4e8a2cf25e4671d ef85daaf57d66dfc9dd6a0c15d2537ef048a831316b69a1e203507c88bcf935f 59d4c75c42886b1143fef40008f4bbfff483e3a361bd9de916996cb19c893e0b3c190b7c3ce51f14e16d57f9720d1d060187fa4cbb2bc4e2e3dec57b254c580f756ef8ee5074087df882b8372a8ae910b5ece2d4289b9cc1d448d405ad0bc9076de246c3483536b72f3178ee935bf2087567ee701271e145c6108a8b54f15902de571f290185c91d4da024c86738646d4c6b68386866173d6f327f8245fb9902d6eb9a41b86f35fac97434a2f376aa3548c150ca8bfe319ec58b3a795ad5e90cf4ef0f9a72ad468a03a2bab6d26687ae885a6a7f3d33d4b8c3ee8c3043b99a02f9643f635238cbfcb037ea4c0ecf32584c30b3e77acb594d9a2728a847e6a005656a5c99e988bd3e47ebf7f811203752ed3861318771573721dbbb103ee9b004322583df17484d50d92b3705bb4e856b5d6cb8c826f63e2f2f146e583cb9bc08cf20aee06d7de242f78654248ceb04258e7a89f2c39f9f12b3bee0815336a10fa231103945a2d0e98a5ee7d43bbdc5b753035166fc539a4d82179d1809e07b066e97ee90d5a404ecaf2e1782395a39877171e0d1b87853dbfe549bb947c8e80126a02d68a20dcba06643758b8d261013daa5e1cdfa7421e413b3cc3de222080299fcb396c2f8b876888f931080a398ac5f518391ae9c6527532ec935b2f3ef0182ac28b9e1fd882728a3fbc9db9e982b87b627082eca54cd20c6d54a374abf07a04a68e8beeae095524c4a3854e05eb5474ce86fa69d32f9e850e7eeadf0f503b5916cc793d05d31761118c7ed6c50eaf6fac224f79c3a9163d963bb12c9300d73e8f6972d96d7cb30a948a2ef6b91f0d9a6ccb946a51a5bf759c565a42bc80944528e15cd32f5adf1492a6fd791806cd2b319ff5c83cad507e1ff716794830998e15aa7a661f4e5ba4107ddee3d6558cf6f9f19ae5cf8a0f72d416521ed0f095e4020cda97b40a7b40049624845f304c0e6fe682773112609dee5adc0c81a0064e83abc7817b285d3ec20e9cec84d2503d7527dd0c0606c37b88c655aa32a0dc637c1438aefb76dd319a68c3ac965a3939d7f52853276b6c734be5bb7ef4a00abc49acfec57237acd044b8d1bebae9c9cb9c868c433cae172de9b5864dba3084b52bfc6eec720debb1e88b03c3a292d5fef61ffeb84f39a50cc7ca0b028bb091764466b628ee4119549a41d42a222a108d2c57e72b09d7485b769584f999f08719c5416e533bb0c44a110b9cc6c89e5daa39b4a1521c2c363406465ce5f820231a012abc8b6774bc2dfd72a0424e96382ca95a30b38a1306aaf5bcf7b6ee0063c66c7783e4f558427dfeabe78a39ea8f05203be146ebf183181d19eb7d8b10e445f5a8860426ed4dd8231699854e5de970dab1f5b0f4645756f98919ca5e2044daa0fc0d38fe06f0953209e5b5922c2f313fd0de247f65d66c61c1a4fdf6901fc815fbafebc4bb5f15be58f3c8f51273e33c8b7c389909b5d09a6d12444b100cbdbfb93522b83c352e36ddbd51e7b15d7bb24e27cda26a19915e9dd9cf9af062fb2afa9007629e72a2d400a73e2c29321ba39627891b5f853af802da083c50dfd11b01dfd60b1c23cf6662abef6d5b22e8a3c180ebb78a1e9d15af347f867081567cbebfc29f42b3de9542dab3de39ba75a204bf6fd6fa4236319327470fa0c9bb730efe77d4d04eb9fd93888daf3ea09ea9ec71bec5415fc9aaec85811a1009cf5747b887b2a27e00be04a83a0433dee04d2b1432e4b31da44004b37948d02f6a158af3b7e209ab14e6fd3b03f4a65e6ca1e84127580804667fe80b3c86c061c2235c3cb06c721b99ce7f376c7642ef6135d0921af1679bf7fa4f6c1cb590fb0fa4e34c3718a114c1c84013d8ba820a2df724333e87f71edec351374b52b057d91b526f467b4524c34f818511e326fc3430e637f74ddd6b12d90fc711f850bc39eb9e362b79b32c07ca4a24c565c15bfc0ec3cbb32258ebdff57f341cd090e53d839eaace0ce3446d796b48713c51df732b6a36cb1e0d23ff36477fb84300dd1c107aace2b82478468b8045b2654da7696f3cca6cc86613c40929d13f2fa05ab590f510004f5b649c2057f40b84745ea75964774e11e648f8c0f1663c8ad07ade51b3aeb2e0f8b79016e74b36b3989473c701202fdf4097943e015c1a1e507815d5729b2617bc17ca9dc785c1a6b623eeff2e36ebcaa519b7d7a7438c85507041e7af135a4562682db07f06fe97080812fa6c8429d203d5c40d1901044e00c9ed7a1751b848b9ed9fab5765247e1d42fcffd95ac99c9b04bdbe585c5846407b29cfc49f7185f0f165c26deb84c757ce4e6a24fe9e979e5432cc6c4eaa638080bd4be7086e1227f5bd43d65b5e99542ff4d7e6c773814c973ffabcbdd53b607209f83c277af6161d04303621cdee23bf9d7742bc554dc14ff97740f13b03a068fe0f4afdc85872b6d9c2d39f5215381d6c0993a3471cb696b85f17f024ecd0431773192ba98652806dba4776b789c40911c575da16dee8f446d11cf770ca90d9d1fd40677a954a5c73afce53951d17e03a420c55db88a16fc0f43c0a1fc690fd1226ad5440d79b3c907b166411518354db22b08d1d5ff2351987e185b124d005a5cdceee1d1edc54610224cd356ff312b8f4a1fc298cc8e8e2253ed37273509292c21d45bb6d362350bf60b73d2e22edc29ab5f917886e87b28c28c9dfb500a61e9950252c700ef8de9b60c5a078f03f85b68f1235e01a276ad439225c6e1048f2cb0273ceaa4b8a1b27fff5360db125940be687219045acbbe789fed5fc20c4fcfc190d072eabbd137761291515d05f766f699da3ec829fb15a9fb5c2b6300f86068ec5ead6cc8ad8fa46284222ec3d7271039b73d25246bb31f65892b110d5f02fa88f94b5df6ba0b343c1f2ff73814a0dd79b063afbb412cc4a029b8650ed2e06049098ed39e3647966d704c5fd354cc1d3c51053bae976707b1767829008c16e60e40ad101c38e381f7e10fc3bdfc63bd0178cceb4fc8f9c0dd4be6f4011494b2d225bf3c8a4e4190a5cc488b6a2098ce1e940ff29eea71d7bef0155c01b76bfa7789481a4b6529f44677b165c72b7b09f95c7ccac4befccac7a8b3cf0906cd6356a1892c167e2befd4d3ca593fee3d88a525748434e50f386e19f2e10569a186b30d649ea5d3798dffec713915753bb84034c60edab2bf69e63b184f07afa33c22dd03c2b214c8e0e5b67d69fe71f611bbf422a186efcc21bdbbba7782e71aa8f06eb55bc2ca9ae817e100218ee3b7db57091c694677183fa61077f40083afbaf12888f865d6544c5f8d4dac1d2a53b232ea9cb87b57f9460810d5c30f140d92434c329d29d26960d274616e198dbfb5ed514db1b1aee4e00d37b27e04c45ae48b4812d08e915890111f7275eb9ab6690a28e0e74d4457320396f9a20f40680fd7a9955bb6c9f7444cbc8c63cadef0f4150d8158f5f6f0d26818b7f20fa1dbfa5df87e2853a02b6a764fd39bb429a9811af8169de80cb344f4bea9d108496cc818b3757b21b3de1ac639b5100c2f3bd6b720dd4cf8173f92935e668506a4c36b039a7e7ddc8c57852876bc96903c20973353fd88fbc6f41777143a1e0e4c65e32481ba7c30cea59f3b717881c74ff576b86563b5861d470a67f34bda00af8ccd2c6d48c7fe6d05f4cd43a5c99f401267a37a12fdac48a2cad5f215fc00730b13f054bf36dc60c7616ef9485435b3fbc7aa2964926e2e60b067f73bbd0e44757367cb4a793328951aea95babfb2fb80d12975f5459ef8ed0ce7965d9905de875e70012567fbfca7339f85e7ca01fda375eb3f57c1ae00d703fd774be9078e61ecb5c13e265c9f30a0b3ac310c43b56eebabfb7e8d02a8496fdc8c4bcd0ccf8716d9365dd14282613b1244c9f47f4143dbc6b3583136924d7d50d5055207d180fc1cadd2af61072f48e771386ce0f24d154735717bd6471629701a489005376da4a55491c4e13595f151452a2dbf31c0914416662a530ad65af9cf4e4f045a0341a81d718724b69668e2a8b532e7c141bc3dd97837778190691835eb5e032fdff479be6c9ab86d1fcf54648eff8f0703aa33affb5a688ca5d70e5d2f720c1fbeb01ccef0a4814fa6874b063083bfd3bfa0785a9b28fa771af2d144a53601664f4b4bee2d8b5cb6603527f7820be9f4b21c4f6659be783dd2019e94c72002fd3773ab5970ea0c3a7d0a4dbcc7cd2f663e3bf2245bc007bd6e7a4e61a154062d8a8de08194844437514274be05e19da042787ce2ce221c911d7d20c384df0d344c5c4a69f4a7b7b4d606b22563112fc6e3351df979cea39d1b9fb71949600c16647c7df3e0e0b06b7fa7cf691a7e6f45148164eb4e906887270410bda31105b783deb92172c63ff55e6988deb2b472ee16f1ef484cd70c11b2e41edaf714010e1cb0a268f1ae6e0d65974efdd47947b572d8fd527888a612e0efa68f26be0bfab5754023ca8ca48b1da18fc740bf44a86168a59dba90f35739fdf619be1107 false +check_ring_signature 8beb4f687f290b1bbf5e16b899ec1b0812dd704846b3f91cbbcacabd1b2e9d80 4804c730d5297adcfb4afd4f555bd972bc90b4a5b836b6d4ba2ac4e85e0ad902 1 ca814a280a4e3bc1e6353fccbffb35eee41d4cc0ad878163333c8c38e87a0431 02b98557516bebf7044b6667f57f2e0c216b8bfd3c8f0ac76879972d76b3e20b09f263cd105533a10ab4d3f547a01e08d2c979b44d3937105fbb7380cd58d30d false +check_ring_signature 164088d00e9a0a9796ef06d24da3fe7acd1c99950d7b93c55ddd507735e2e36b 6659910e00973429b4684b01636ae1b2a106c9495b2d5779ae91d9e53dc5aad4 1 1ee95758de4274a0864e926559c044248f97711a442e8fdd54d474ffa6769ca6 2876bfd59057b62de7b70c4fe463dba8d379a7426bcad6662c1b61b5c7cdfa073ef46e34f364e352db87518a4551a649baf1de90c5cce144eb10f1b117033c6c false +check_ring_signature 7432f74bd684938de1609fb48eaaae049b21f053a433b0ac1f3b3bc87cf3a57d 1c435712256e9c219b72d8c2b3f0711d5d3a26b94b4e8c512d337f2cd0ae5cc4 248 e477b39e6c332608a2016ce9fb35e3654a1de4b9a319a5171b700913f9a15258 0ccf361758fb2c19b92a1f4da4e215347d129ea56d52b501ebeca8c40dd54e1e 2275966692aca85f11c9f8924f9089ed756e3afbecfe39f8727617a8ba6c4f16 4e9394ada7e4b42e81a0ba6c2ffb5feffa804e221c185978a7bd4a684c0aadcf 7a7ac23187c35563ed3088a1347165bea44e59023f437346d2fad34644ebbae9 b37ee8b02dea3a54e4a22a7f922e68f0774001cea66869108c73c0982b5a5953 df9781cbc4fb37518445b217b8e7d612533b9bab7eb12f8a362a54c68736788e 697cc2deec1d0ff7b24fd08cb7ed77abd125a1db9d16c534c3c669835833dd8a 7afe9498acf21808798271e8ad41b98370db93870868da073201506a82d0141c d57732fe5ebd927b3bfabeaf1dcb48eeeb2466b5b2a047105cabb6bc2191d60f 6c52d7850cab5828968e6e686ccc2fffecd10fb5ac032b599d8d5d23a673a993 71a6bd92d1e819769661e54b368889a559a3d4e49427e9ad3a99915a8cd9db6c 5f317089bcc9dbcd4abe9e45afc598ae4697570190bcff4483f718cdbafb78b6 4bd104336b2cf7248635efcf73e6593ab80796f2343dd53c30e0e95fb48149a2 209211a7159d14dad0b6aabd94ef690a3aa766b55589878e8e5d22a6768c4e4f 37b8ec0c0821198e2335975d2b561cf9b8ae090a94ee05180983ebe930a26536 3fb7876cb7136892ec7d0a6b0a89547865e425d1cff62b74d865bc316db8497d 46c0ff429b7c1b5d4b75ba6984c5ba7c776629b082e7fd888ae8c8c6c048fe5b 30238073e013ff87e1967941748028527f8220dad0547cda900d5f18addcac5a 47f4b7a6a64dd839736ec2215cd2a1fc2357cf66f7f236ed18789c8177f5eff4 c03baf3e86bfe54627e328529b50764cef3c7165f9c71eb2aaa5b44408689608 1864eb175b2a7e64114000e44e05970b9a4b9423cc347024863b082227ebe908 a0088d067bd4c74591221b8d4b07e7b3b26806b026514907acac5fa6e8c81dac 00361790a393b3ac41313ade4865bbb641c79108767879f42f42e66c6128709b efbc74c6cb1a7b5571f37a9c33c1559ad50b107f680ea086a970078e2d2dd7fe 9bd279bfcb403ee4fd53226ca01174aed392fa6198a7ef4da3e99c236f2eb856 898366747b3586ab2e36491795d1e145375d230c2381d4d95d4dca5df690050f c2e7c432d5ec701251fd5482bff0c39cf1b29523ddaae04ee317382c5984770e 5c94382917c0a0c0578887c9587413d7935b734da1caa01e213893ad59b46ff3 7f9d0fd25de8e8a05598e219658ede5e28829e7d9bcdc7edf338fe1ebdf09c55 b4a3533afcf0f2e4606e56f87ece91834ed98cec55c48994f2f6b4b336e3a81f 317a6208a5bcb87875861a606798e5db11ed37d5d010c95a4841eefa32ddd15e f4a30a8f40d358367a0374d656e40dd7258a4c51545beaa7ba5bc40843f4d97c 89407c57cbd95b10d3d75ce16398323a5d51e1286b7d80432804d718a3109d2c 6ef4cadcaee6822108aa36396166ab0d55195c5fc4030f22292383c1ff2982bf 994eff3256447f7f8d202c9bdbeb218f0989fbfcac1717dfb20b8c42f2c76945 ea63342589c173067eb5c36c04b7ce8ba9c176a28c91dc46d6025059388e5d70 ab22b20dfc1821a15c27c7c85beddf86f9666e5f8cef1225711b4abeaf54178c 55957a603b02d53fb6bc82ead879b3cf72cee7a9092c31856ba7d28fd6db95d3 10d17133b76abf511f25e9905ca39f15a028768b598a370cc5321cf4fa32dc62 391e8e3a7cdfa7479c32c0e1710b669752afa59e5228a32de4ea24f864c7f4df e5703d4be4d503fcdc464a5082903024f161097eb9804e1492ac45816c48f472 d29fac769c6051a19f2867b53127ac2a535b2a26b1f17a243b9cb9d75012817a 41ef1a339773eb62b932e16c619e1f3388f767b391474da5696894c7552e415a 2504e40d837e5e431365f2c4cdabe369e62d8d4ac7903685e2371257b89b76a2 c392bcde6d3488327ba55ddffb7720217a8eec15a65832946443367813494af4 0bf21bea92ca116a420e197720fd86a960fe5c8bcd54fc8b576dffe3527f86c8 5c74ea4a72400081c0118aba027cc299a8c73f384a4ced45348ec1325758707b 5a6a77430995dbd92ac7c5bf97b039dc2e6115a50cbb2808cdbcd8c159675ae3 0783c4c72669b833c2bba3be8fd6ee771bca45a8b0f635b7cf7f2f24002fce68 a476a88e027f8b65a5dd8c6b534bd05b741725268df24c86d27a6d43012c3946 edc0e9fed82164020c8966acaffd51cb754eca6e6df781f33f82f7d167c15a5e 08cda4306129e304dbe5eecd707203482adc18ecdbcc7e523232dd970a0bc24e 73969c6672980d68c7d6f5b2a372b940fffc1ba60041dedee538cca005172ee3 b97f1badbf61d0cb0da9b8ba68fa6b4417e47ead8fe73d44bc31073b19ea43fb 1017ab7daf29f09788e24ade7dcb517f89d158100dddfcc9ba3735dc027caa77 6bc605d01d1a43dc237f02925a185ccb14d789aa7f8e402d25ca8b22f8250b74 cf33a2db8516b2eed2a55ba6a370a5fdf7a26285e72032234922ed23312a03e0 1024d9a5f83000f47db5ebf8d82e85f007325925793efb597b90f376e1732813 3fd5cbd5d05511334c780de73912b308043b5837b66cc57138422d1bb6789b64 dc4a977a035cfe42799d8bcd1dd8bd404c3accc48f1540d8a984c72125b8dd3c 39bd4e19c0cb74199e2af1022c46a1a4e5562a71833e702da8c0254a3aae83c3 1a752f07885ce480039b574c24a8036bcffbc8bd1add5538fa9cc21c052cf837 0fea1e73c434f62b3c46fae30a93a3d4887d7187ab8443dfdde59c1772958556 0bccb71665dc47429a3a97abb2ac9ee1fd9bc73bf021ef03c49936a961365ee6 16efd7dc0d38534038f0673feb6936193ea3852c11abdbb56163dfd4422d2544 28511074480a27d04db13fbdc68f5c48579a702a0aa32dcc3331a1f9fb7d0331 4e65d8f5d6f1e4a27853468cbe6db4ffadfe41dca8cc27afdee453561b7ace3c a2f293ec982b1563064f23a213100ef8a2cfff842495ad7be6aa5e866bcfb056 512167717f0affd85f08dc0ab84d8b267871a92304d43753d4a18ea2bd98778c 6838e2e57adc0957df325752af62b53435e48fcf1c4eaca24a5c1ead63f137f4 e7a13c4898d4352e8726497c2ad06a21c6288c0947e753145f9a44de46f2e600 ffe17f554c6f880ff5c96d7bf042498220bfa15553b90e7d5e5e51f48fb9dde8 e19ebd95dbc197f883dc1892bb203dd2158c9ac97ce133da3a7799bdab7f9f3d 809aba9f0f30cfe13d897537d49f210429c208bfddabea34e08a1c61ace71423 e95bf074b90d2851c41e88977b47f93944d71a3979145eb7b221a4bfbad4dab1 89049cc137e3a91d9af5c02d9e324cb17e809a5e149969f814559dd1a9bd8587 ba4234900371b9c5f2214bb7e5bd739dde0d95b499706f71d7b163e3ad315408 bc42c1a91c86515aae9e381314f9520837ec5c1fb2c84d6e33d5de66aae99136 418002a65fb6926e9485aaabdac379f56b04b65373033b95a957d7bf217e3e66 c48459714205baccc8c9e3536bcc03b8460b09e4b94bd8e15199be78d8644ac5 23455a2cf6cedc715340f7e6ea376c01b9070b486f76c5ca25b5ffdfb63009b8 aeb174162c21e92ac59a65a69a9b5a85112a9e52ed5fc69a80eb7c3be91dbe83 a1dafc41da5c01f04c0ac36ec7eb93cff83912e06f1521fb07e3444e0b596158 4d49a3a4b16234b6ce8bfead50800ee69504f527994a65451e4241c544bc3c0b 9fb9ca85e0886ce8651d9353fab99028d51f96ecfb0e041d0449e50bb85aa040 b410a51f791276de8390c0aa7f0cf52e46c2260d302a6d2ca029db18ab0f0878 db3a8f642d12f7b65c8be5ec76b9fe9065b1d764d1073c5f0e023018e356713e 0df18d1b9b603b91991114646a6c52b49ec8f453221e21b614c27fc4277a9915 042906b046b69e45bf79f724ec31a5e04a4803ccf067a79131fe6ba823ca8169 1cd1c63a5c21ee0f9934ccddf21db36d5180b98bdfefd3355bd054c17fb827fc bfddc484ce99aceef7cf7ae38bc5eaa595db620f3e49b6ba503a63492ec100a5 6ac92d417660ed3cf26ca157c723317e1ea3cd80b0414589ba4565e2686f482b 72a829177be8dfcbb5cb74f19963405231e139f0ff68f7d0ceb4265856c6c8d1 a0d4cdeec417d55ca10e433803a47c6ab37fcb0e63321a2c004fbbd512221650 155550aa3a53484662a4000cba58f56c38e0f863a4f0928472a9c0d31d35bcbf 17717feed5fe37d081d8fa8a3600e73b4e2f14b42f9f1fe2dbe6b1d63cba5a70 4dbe7ad7d1cc012bacd62cf8859329d46ca943d8acd49dcd08338facdcf23339 ac3ec33ec7947d10556ef1bad569a67a2d6dcfa01dacea95ad59c45e083e736a 79538f809ec15936244d88bcf9646abab048f62899a200c2a29b0fcf94481c82 fd3d834a3131c9188693681bbeb955b2f7f48aacb03323904083d74df806a8de 24c5b9621dfd8f77af2f0e38eed7786042e0033b457ffdb9e9a39ce0d32723df 7cb0da7adf7056e8a1b92a2cde7055da50b62bba6bdd7eea111cfa873a39dccc a42bb1002a1c988c20d3b26a2d195d471686cdba2e5bdc68473c528b2c2086ae 715d6602b0b366dfe3608fcfa0d7347cc10d6339c13ed365218043c152630220 889377c3f4bb16c0a42ea53344dd9f830279c76058761ab0f577dd41392b722c f07e51893794d0d981242e3f237d12b1c6404330f0354959dc47158a831d2d01 3e268da5717ade97b239e1216020a5933f5b7446581577410413c71552a3da30 a7ac844daad31fe8b73f7e276fac6c661058c423dbcc198dc2b419d03ea42b5e 66334ade25e426d3cb8bd092e1627a8536735b364f3883e4d45d42c2e3165332 9302d2262a101707c971440490f1aaaa7b522690562822513504e9dcefd14e24 f0fa79c55e77f0032deff757e434436e66eb96a05abc87e872037dfcad105185 1ad0807ce9c08dd4fd166236f5cd56c7bf815f2aa2d87ac692610f8a8cdad505 6c84e2e9bcde2f9bb30f8295a1a5019f918832a6984b078bcd4a099eca42b01e 02b7a89551f121d61d6e8ba9bc462511b2f4796d20ff589fbf2f67ded6d84db6 de126ea11e32599695b7835ab8ceeccaf6128260b90153ec9511397315faf209 f6090902ba44cc3c5cb92e24be0f9b16967352bb07aa04a7c6f4065ddeacb95d 95808db2e2217c2f07ee235371ad4a7db5c756abe8c7e4e04d379d693379d34e 3d349654b2fcbd836a5f46d0853d746301be9a689278dbead3bb9db423f79ecb d45e159859b1690e96e88648fbe2b250f5864272e1ef74675a8fdde5065836ed ae53e619ea95220e26b433e89b2103841b772597d49537355f9c515a0dd2c80b 76c01dbe7931e3c617c32680b50960e0fab94c4ac35708f431569f0845f4774c db8c7eb7253d70f4384a17641581db65b1374e9dfe11ee13ae21a8d4886c97ff 6fc49b060a3c55f4783d24deef066d78d01940fb1f8f53331458751910fce7a6 e1d2b0d3db3a06048d73abac3399a914b6dea67a8465afdbc84eebaaa87f7279 6b31f38c7e4f199673f406c817a7e8cc879cdbbad124e2acafbdb65ff2521eb6 2c37aa39fa15bbbbd853b89d8c2a5d9385288c8f228372ed77ac7ce327798472 a46e69c2dfe11c9791c7b4f947e004d2e982a0b76bf455d9eca416462f2120df 47cc553296a74e7a60ed46426c6f32520b8e682b8c8ba68407e435a2230d76f0 169b67903b42cf39d7217fcf80b704d5a37c4985edb964aa2ed12111c27929e6 227d4a9687a936752ead10244d5d933ad817c1ffc0b3413f44286b1401e90b86 9e283bfe44b7393b3a2001d06ba9f73f29ace7e34f7d1373acf117c4205c7145 a39edf76bb8ce9dd3ebfd7bbfaba9da4e961d8b87886893f9b317ad950220057 28240899d96af46cb76ebc19c74f21b149e41af768855dff9d68fad736a159ff 15c2b4b33e98457349463bc4f363ea7136592a5d1e61e5944437fc2995496c9b f7758e14ef9933903929c8f3f164373c209da8e47bd2a77c11205aaa33a48d2a 078eb63eb31fa429817631ec2f2455330131318a71e43e6f388115650db7c1dd b1914da5f3e861076aa106427ab624cf8074d1ecff2f652f8425258fb4c13268 4cb74c2d2d0c8d45305a1d666257d59747f99f56565d03b704e4111c8638f995 b5ecd1209aa6470ed2c3deb9b49fa9a4893c9df9bb25a39e22225c864836fa4a a2b942130e48dc09dab529251bd00a568db53c65652230b2d88c8af95135744e 751b7d695a2d7826b97aa4be62fd98351c35a09fe76b3068f3cfadefd0e4842e fb36d9432e9926f53577adc0fda23a90b24e21825e93f01e6510c358cc6dd9ac 71defdbbe88b14326c80d596ba53b66abfd262a0e8dccb56fc5ae7546f6ee0b2 f6615c68d9d75c4101785cb0e494b98cead4a6b543b81b71f7a1be2d2896a2c1 b29d964059aa59b3686e585384c09ef87d3b7f9e2cbbf1759f707ad945269781 671f04a077d8be18f9fd91d10a5e8b3586e909aeffc239acc76e5c0007615793 2757a653435bc1d91673f823f0cdd3a9cb4b086956cf8c6bf34f5af66bf320dd 18cfb58d90324f4dcb9c617cba7c0be0861cc7975a0c0307264de35f91de78cf 4504a9d1159dbb8c32cbc945fb5cb4580894c7c6f09563ad87f582daebe1cbc6 dbd3a6c832a8d340a6b5f114f7af9180184c424ff99c242b7eca8d79b8334785 d8dcaffb55b9074bb45af1a5b0265d1b89f2316482ad2ee73e39301979e6ff00 53e1e451dc28e60e168a85b52bca764a7e6afd055b863fad8b8670a493d654a3 96684d116c72bc80440ee8808685309b772d127814c5de76774abb4a5842a4f5 da52a621abb93f8e58f27abd707b5e4b6a14720300a95fb60d0e6533e42dbc18 2e6c84e94018cd31fc36c1d5f23b7f72b6d2394723d09f87a6770ebc0bdd212f 53038548bcceccfb14e03c0bd25a8ec946cffc78d85db8340b1765eb0054b912 f0d0d8edcf329f89f770191e8debee6c71a564b33a0358ad027925b8cd5205cf 139ccb3ab74f797ddc856a958d46c8debf779217aceefbafe464501dcfc2fa1a 6dd79d71131a6ce22a10ddb8c0b60bb2c140e58139d7aed696c92a528d4284eb 54856532594f11ea7910dc102556bab5e19141360363a3a1d51df91ecebe3790 4c45248644a4780883ba69574a6bac2ad7a4610d58279bc1e1befe537982324f 2c767dc1e24bed280379d88785f68b7cc4a10a0fa1e0aaa6c547238914247ea5 e8190d6eacae2b325ceb0e46e2175c84c052b1cd50d270efb1731e47d1f071e5 fb1b57890b6855f044519120464eb0782e05927bbcaaf793669debe69d2e7616 f11a9a6ea73c6cca86211e2d49538ba552f4b543a70dccb9f556e91643d6fd5e 55626f435b2f62c97d5a0225b24d6f953507cc8fc1693a45fcb3b0d3a6882d94 6f3774bd5477ca11213022c7146495002badbb9ebf80fdc548bf9f6473d6bf12 b065da7f24a8a421a09579117c55218a56f1fbf6ae39b83595b4d7da1e798818 d6de8394447ebd655daa9323464ef5bc15e5a3bd4fa240a28eda03653d629b3f a8b259ba6c83e3c5fb9618876d3adbf3c8eb22c619383d9176e6def5772867ad ea2529c7e919e6d567460a7a1430a41cf68056c5cb297b6bc9395625d77862df 091408d5b68c89363adb889a30b701bd442f9fded54173eafc3fce6cd37d796f 4ecc7f9fb33c7013149c093937922935d4d7bbfb1dfaa8dd2e62cbd2bb8389d0 c3ec0e9538814e7a48854d4939c3ad2b313d17cb9bb81d82ffa1d07294c0bfa4 cc6f75cefc5683050d439a723315aab72f16d1f75bb94d9d7813a0ae76cdd137 6e93bdb697a6f29bcd4b18b8d761707fa510c7c6c7ce3bcc61b43e2d2e8b2f00 dfe20ffa77cc643e88b5fd0b5429fd0e594316beb3d4bc7a5642fb967bd3c970 def51cfc7b8c8f243b7c9a85a0fcaab1d23520f81becc77b3a0d2c715fb73e32 7bea16877f2fb9dee2074b39a802779e1c0df74f4f157245abad33d8b295694b 5afaab6e0083abf555d537dc1e7fac53b31f24f2dcbc8d19e22d5dea2fd691e4 8d8a89d6d99a7b8dff48ef7b0c58c4d118fc3b11bfece5dee299bf1a039afe83 887a95144a49dbe8e9ac7ebf6b694d79ed70ece99bf257158c64437ea812d6c4 507068919e0b55050cf42bf754836453f68ce59ef333ed43715b24cdab623b49 687f6e775e5cfbf8c38f3320fe7510d5431e917f41a3b4140be760789f53271a 12430ce372410fcae348f50f9de4ce84c7de7b122ad0ebbec305e3e8e1205d74 8cac3795fa1fbec69a6ae71dd1f0877e7b26ca80d9781bb57bc33d7ffd96a3cd 5217717d5ee6b930f849f7e3cddacf9cd511b9fcb3da99ba5885754778fbf0ec de8fd7e9ee1badd6d9b98a10c7a1fc25cea56d43af611f3e7beed54242b141fd b51fafd6c4f503749184f6bb10aec30af8e6ca3faca8c2ddf88a3edff5b37f5a 93d6cea9ea7ebfbc9cab8305eecf2253498f27f8941580cf69df35de69b71ab8 910ede97ebd107d15759b47cb34f6664a94fe48199e1c6f488e9064a4db32b5d f0d22ea3bdbcc583cecce4f32a00a15ea829db74716c8122c210da0a32edc926 df709a0f77b6c10d0c13ce7ec7bfd931b19ba8ff4ae0de19d14d9edd7d804f45 f3b92d264e5fba1361c6baed4c0763680be2541f0241189a37752fedbd703d2b 7495a79495d3bca0a0703716b5f5b9855c575e3252bd367d16aaf18418738a79 04d0a745dd0d32673049b4ff1b511b26405298ac39474f941fef345aec9b7f54 af5c6c826b699097be5896a701ec7e95c055393166863d69aa643a4d0f3ec785 0208d675aef95d514a847da96c4f61ed2e0315e29c43a664b801aa43301a6035 25a4e0464fde6599cdb84ff1412a34a417ac211ac34a01477fea626a2a76894c f9ce11c96f1d9d747cbd9cb050261bbfa1d371a40287566c8cc5f9b62ca9055f b390ef3ee27d3df17377f0d7072c567ceb0b7113ddfa4e03a9da34c7960f4f08 5a7c23ef1b1f68b3d7ed62afbfa467d74f2eb8f877768801f6229caf6200c254 d88184f9d53e18d422ce3c5d5eb4e9d6a561a372eeef93051f87d313528efb05 5eccbc2d83110d490d37b7394f7e63ec4615aeb89095f2468639d22bba169430 d2ed73682d1a62f774ac871b6650c49d5a0efcdaee4445a8d2a283dd624704a7 659f4582095fb5b2bd83afec18ec0c1b5edf1d6083361a2be98a8af115166e0a ffc757c691fff23e825f99292e2cb01ebe82ab2f2c03b04df99005fab7de9b99 861287c64712c3c61ee0dcbe9e2ea0a6299d946237cfccefbb66d3dfd6cf94fa 9eb8706b51bca5e1afc3e07e7664852a1daea60fbc7c01fc0ff3f27f212d627a c0346e3de2c40bf0ce81ccb2fd3a8618285fc705bf242da74e7f2b0eb8b81ac3 29e44d634408a919254f31b76c89788f4052b11858349417782be572c8d36138 e9fd5b9d4dbfff5ddacc908f3b5f11453a1ce597d009bd2a15803b783cddb2de 438ddad3b0c7933f8bc2cf0a6a3f4cf74c08af43de6a4aa0242629f5f85961c3 b06f70c26237da649e265bf79425a40de56755420bd1b23aa631eb01ef0fa622 9ead836f0777be16394e4e0777cd0bdd3ef607946065ce47f29b7580c59d91a3 2ce2b06f1f7b48388930d49d512967cde1abc274c20a7c533f1c1542135228ba 6f2304cadffaf093db90132de13311448d143249bf04f54bb2ecb0f9f4722a52 3ba605ce239474ec5ce4d94b4c72a67c232db8c3614b9b6c0ec4a78418e91cc2 fb2050b7164ea00d158550d7cc4ae17c131124ab759a86a7d6e2821619ac90e4 e3809490b963a9dd37da385f4536fae54b7983ab80a45cb33112f78efa2f4a96 1c771fb6ecc10cd8236cdc4f58d6a2db0cc545123cdd19d976e0812c02984617 db1d552b6e8c30348bf1f413dd65a8ebab063e911f213ea25484b4006204c359 c2b60917e91eecbc3858dff1818abf8d030b4172531d8ccf317a8449d5c40791 d3cf3351bc70c0c5c63d05caa866fb86da42090b615442b6b70fc168e9291bb8 f4c22f7d248954ff9655d729e69378594148bade8e9df2c8048ee82e0c59f623 c825a13246f745284822eadda2511adbab8809b10ae2213f473eb710b9950b20 f6098ea86f59bef9e6c576b1da8dd8dfe4cbd2211a8ace19a2998a98b7ac1b7f 9443ae55552d920e801e217c04acfdd593962f3f334df3a91bb9ceffb29e4ea9 1ce61b423a89716d59dd4ebcee6d9a14f92f0f5bc694f77e429295f2986916f4 730a6dad589ac48c1b4720487240394a7faecaa95c0b17556087a1a1d1df7568 94c781f41226b5eedc4a231bf054b3345111a33a7a381a8bb951f81ea1e2e0f1 c67d29cc39d9459d7178e0ad5c40a4ce0a0a54f56b7bb3154f00ffc8e5518a4b d67352ef7dad03a9f40abb2a59a6409d21959698bef896b680b585224379a57e 2746d36722bab3b82c2d4027cf6b3e19a3305622dee733981f30a83c547e2633 0aec4fd74a92bc4d3420896a66aaa22a19efe9c7792248cf0db62a6b3037796e 986e4e19b9fd3512a4573cb196a8f5c19f40aa3d168f2128786a6dfec0a665d3 2a41d832bdb2ef8406e4740dc2fa9f82fcd9444501ec36d5f7cf8d87d2976005 9cd46bf969cf4247869fdf4b8c6def9b941985148c397566b8177c70c33d6334 adfec1d5fd4e8ac8cc79c61048c9105b3af38aeb388d563f8c13097c8b99bc8a b4ea2c2162da325352ee7d9ce99289ded362c9a1200de4fb5ab1caabdfc2560c f39410d51d137850e169660fb816977698f1f9d9b075f01f169416266fc7e7d0 7727492732fa3b975446bc52ae5f3b1ff1d802a792a5a71e0aa8ac6efd81b52b fe8c2e5f02a1bbb8736ae79b97b41a4d36ecce2f268243b9cb6c7a959e4deb64 74fcde13b8edc5cc3e85401828eff191dcacbd1d415adc2f7128f903ec08bde7 988fde45f8b76cfb13fc8ad1ad9f2eb5dbd67a117058577ac5abe6cba553e585 84cb23d58ae64b3cbe88fd7486b215e6572101fc759ae52fd961287d4abcd4ad d3bae829d00ae447b0ff0e5a219758f796436ac5c46100b8e539f293bbaf1b62 580d37aeb1743d494c71d50ad8bcc44de1940a4728d7cf8ea489ba09fc305c0a7a80cfa669677922d967cc62d543e074e42be6a381fccecbba4f347f6ddc7a0fd09abb0cb35cf604f14a4bf11d027d1b21a384591fcde844d5de6a82d5d4450834edcb26f67d009892641c70f0a36d3889b55bef9d3b3b324dc2431da5ca460fa57d9cc100c3b45bb600cf053420cb494b92cbe4c886511a28fb2a62a3af3502a957b82bf2d7ee1c0ea27af560c2402e0d430c7bd3d5bfaf6b0d1e38322bdd05f55727cfd00ecffd6560f72d14089a6e37544a50a45c3e857ed8b127d47f430288decec2be146e50efed54431f4640822038864b06727e2059bc0f4db2bb5a03ec48ef79d113eb3a09395407d5635f4d9fb7f0c59ccaee374821e5801d3d13082a5c6a94704f52bc043882d8b483dfeca26c6f8da06f2f8ebf760afa4f638b052251f7112acd15e9993dd90a6334216b7a2f76a30fd26e252ee124a5af719a0d61204d2f3d44362742e4f8e60f868d9b11e38250d7238821717bfa14f10b9401c19925222b7f07b98fe7129cf9cc11f92783732b8a962bff36236f0af7ca8604de272cc54c35638730e070ba10f8766f45e8ef503a8fec77a9c57e01732fc00ba60648e026d86f98e5c192a6a0c293f2a9a354d7720b8376c62ea33e2248b705d70cdf6033cca1fbc5d2e627fbe59a4be807b6649eaf8ac539e9903e1ede4505a1104d9932d5f70a2f5d2e09f27eb94814f33d55447413286f71532999a8410e61acb3df19c8074994fc880dcb680e7ff6616b83c7bc185cdb00fdc296dbc10cb51289343f3dbbb1243aa8bd9d8576ca55996517c88e4f142045dd8cc8039a05b924ceccdc6da37790b8dc3c31efc140fcce8a2b0b5c8c775bb06fc4b496ab011893b273b6abd362e1ddbf3414859c1bfa395ceb19b684386ff2729bc1824408d7a93c8219ccfc2a2d77382a6067c42fc3e3ca210afe7a050119ea6db9be5f055d174d7f19d11ed5b08beffe997d4dc0071c30783b54b7f6e15e6bb5f5a4e904b50a2e9f1ec7ccb73fd2101e84cfbaa9446307596c9451a474f5c17aac2be90b7f242fc40180e69e571dd30ccaf69fc464c09e0dff2119840a42dadeca1643012b4c6374ca8446a8e1ed730bbf6615b0cf13e49147f7c3033cc107594b85830fa1a239d476402ef7e38d8c17f61f46c463a36ddb313296c5d9e31c595e89180fefe4b78574b5fcda94d26b923ee570a427d32a0bcde07b96fe9141766c402d08d8c130f1b1a5a3903dd0bc3f25de12ab176cae9b456e7f18b289d386e9658500c2f0f0fb7d0c7ff3f14ef326785a53a2bd252f40a248de97a7e0db351672a7010f8568d159663f9f46f19246f6235a54ebe78e425cac14c9f85c397cb6266d05c4546ae1611e3f6f775e9d95cf156467f06c132814be11d15724752a95aac80b20a129445e1c23bfc5e7bfd4a9f9b10ee27278e9de73f272176d4f9ef4fad109077eaed33cc62aacf970d74d44155c762da25cb7af811fb77b420f1b76f13908d2ca5cc03f2251f798b318c0a4685bf26d64637ea8f954fca4fc37ed04c5030b80738f50ed9b8dd471ca90224a6dd1a17312d7cbe00b37147abf677fa2950f0b239d17074965c97ae5bd15e706ab518d1b55a6b77fa873154b7f3ea8d5d5c000d301e5555e78243fd709b7c20c3ca9ca7891be0e5d2cd69a973fcfe098b00e007a35ecc06d5e3a11173f18919d98463f7328069a258074cbc69966c6b6543d08c9c96c0d1c87884fb5d49a2793104d30209b7dd392178b8fdd43391da8ec8d0f20910f2b4cbaf7d184e7e0a30f88a13cb18af33804eed2aae7dec51a99471d0fff244010ebb2009ae47b8651d57c8e2269c13c954829ccae83e42ed1606eb80992e2608ac011d54ba68b77d2d70ef8b93253229404982729d96cf9f5c66a350dc149ea993f8ee2bf1cdc44e5de97db27df74112d16b24105fcdaa547eaed020763e1aa0e10b8282d5a203b5062fa18233e9305a3d70a80b1e8b9c38c2b3ca90c94d3b5e4ee0c38a34fa6e238bb12a1403d93599e1b23575a2f8c69d046b5640de7bf9beee2631e0b075ebfba8b59a02ba86c8098c59bb6b1b1c7a7d299327503b77a392d66e6cbbb2b3e0ec0c460e97a09bc34ea74a62da9074ce39f9b220f0cfbdcf087e9446bee7fe96e507a5dcd71154d0a3331957812f38d5384832b4908c43fec286322fc1fd20dd456f6d7de27cc4a2ed7b5ccdab684dee9deb3424e06d50b58d202b7e548533be42e3d201d92eae7b61662565412cc67b8c504646205e1879ac05ab856a373b20fa578229aafbe9452b496ea89fbb9f8be0e1f0afd0fc9ae4de64e4e215fc550d3037b836302a86b443f2cc7863cf5ee0a3653206f0f17f210a276f2eba7a8f2cd1eec10ec28cbdaa3f1ad94c07030d627bf53795905330afdeb96e1d9a730a053ec6683744d98343bc3a4c66099c7c451517cb12c0f6ea99f19b38560a2029a7c417af43980488621514748021b3fe3bffa94f43e04f7397fc7dc27c72f51c209739956b5bab30d717eaa5cfd3f54c9ef521ca5da0ed9ffcda38706a0c8de58c704b36bc49b73718ce446216b0db58939bfba710b0700a59c20d5b30a5eef16cb6a93402a0fe79aafded3604a963d0503f5f88c830b6c49a2aabbf2539808c11d9592bbd22ae8325e3df92d877792d98c23d3d2d403c4d8c546f4e5ad7f068ebfb17eb5b1017dc28d3cb124b48b6b57f82732785b0d66739f9df89f50e65db0978d2fc56c434b5d58ecc6ca42ed95a6818722072f0126b95abd68b33a4899300bcd2ca0be04a04e092dc89df896c0aa7a59766ea80d679171b161d2891b222ba09f9aea0bf427177d474b1665f1577ddf9364b6bf0d721e0adefc47be29d12d28cb1c272377b112a91e1b1ee23723fb729a4eaba30d7f9fb19b2c5c5b4f74a3a19d116e4311b53328c888f8ef45bf3b7120d594360ec2ca649ebc72301c3147b7b237ab17d728df6ee61626d774f3b2dc44b13c6a0e409c32935812a2365088988c162cca1d18efcbe29a497b26d8d0dae62a38610342aa96942162c7786dce1bd29f43730553f026bc19d2e00fef63e92132946b063a3641adf87d8b2daee2f3a626a5c8152d50fd733646720466a0f85e6f64b4046676d5ac058aac2d92c4351b06f7b41cb02e668a53c57e061bc2bb7730b3330a0727392fcc8b0911e9991ac1e5f34371a6e80ba739c7020e35d3861bce765e088da76fe0834efec965e6af4690e004936a04540cc5cd5006992425203d807f01a02c22f4de3583b5e20ef4e53380b6be88e04bb8eef9d0a24146a2eb34263c0b298d27acd1d4de5b9265f702e508127c2c31509b5260a0be70b0bf779f8167047d0199e179439b4245c66e776f1247a521e9dd592e074c3ccdb71d14f19a590ca19ad22d78ec469d7b71ac8d8d035d3c91909ec29a95fa063548da339e8024033b9a75a5f696f8db614de5fc41c52fed5866ed690766ef435a8b3cbb83fa880453f71790b704092f7c58d9709fd99120e5c8b0c7c9dd76a1f8cf79402994ad091f1101b2815a2bd5c3bf3c2009e50a5f462416bf750c0262a23346e1f2afd8038f839d72a22d2d76707818acdb82fe5328fd9925499cfdf3a63237a685b6b70182ee7d35b73ad990b78b4078e79234718436f59214054bf48b557e5d6015590919b1e3a102f3353764adbe56fd6f2c741c1cf4545cc00019bc676c234195440289454a0c237548ea16c93c44fbe882ebcb09a9fc12830a8d2ea6a41cec4ff503d2293b46c0059473d70938337e1c33d6a31560288f1799b94d40d456c966c206dead33c8f5a22bc2bfaf151d449cf50fcd6b656cd109102c0325e3797360b405dd31b499ad2918e57b3cbd71cfed3cb3bfb6672ecbaa7f1bff4503e861f4150710604a4c2e338f1be21d23329b98109c2ce28a8870e1f894ef66d7b9ef41350149b0333978b282c827ed95ab1a3699b80eafdf02c24d01dac01e9d3eb4fb7a043bd0d95152cfadfc6a2905e0b34cba5eb7acdbfbc29b6e87d4633536a3b47c067fdc2fbad6155dc5e673d930b3e5a1e5adf0871b8ccb2696c11dee1effc3a205db753a8c1cc0030f8c6f32a5bfce2f8a8f5970c0a06226ef092a126f94a0620644a2a27db8ba2c975e573654bd02f90ac3228764c3d2fc7802c58fd929a6170fe44c196be3dd62c51f354d4616dcda6b81f3b60b0588b3e3c9e011f81314210ea73f825201647a818f172f4a7f68a515fa23696132ddbac91d74b53c61eaf40512f2b30af9be819a01922cc8cfe17cdf2b6e6a6ce819b832fbd01d7b1265bd0e27c9aa03eb2a2e144c4a3a10caa1e49ba2cd50a53b926804f0a685295354710c57eb057870aaa024801c816626b8023dccdc1e769806662d813e96c0a9df9b06537b8472e2fde6f0e73e5ec53b5fe900a5f158f16d470f108bb595e761452c05156cebdcfb7345ca14ccd4acb799087f82cb64d8e1d754b290e8d8305a63700d53aeb36eb5ad9048fee8e1dea1c99572c5f24918b829157ab0ded3a329391f077675a2f6ca7b7cdd59c705742868eafb408d19f307343746506b40245c94d700498f7d8138b7e2a716ce509078b74d0c0b4c6e53a9e1743657dbc4b50e0cec087420c8475126abeae77b116d4a7c2ab980599a1671550392f2c3ce9b9f18990ef566326009f88980dd85810d845e87faad29d297d84aeb2358cdfc215e55c80fe346b027bd0c4cd14a9c38512831bc050653a3b0c8d0c6c67e421703545c1e0fd828a142f9f398041b1e7274a1b2136513d1d2095d1e474b6a6bdbe9ebbfcb0845b2c761d665af9cb1eec1816247cac19fea6847a703d0ff07b1f63debede20ff6d20468f7131c1e551ee0dd8dda00ca95000d343f8afff03f199da7a04ccb0ac4a47d9126a00063a1b613acd23d718efd7a36577135efc8420e96861c0a5b04749346ed9b6fef363fbb5e7b215db89b54ace79787117aa87f68109c628be703d79d3d12cae5ed54b5b5406bcf528cdfa24f21089a86a229e76d76a60414b20b9c71ffb60d890a2af34e2eb41ee33865cdf515371c8251f66c848c71b250bf02c7f13766e9d2d5f36642724bb43c04cd80686c21de5d590b7528fb55b9ace10cfa44d7a0a282960081ab3dae6778ebf660940dd0132f81182f74acee59ba3a02e4b0e28399d3bf67d29f0248857f440edc49a586503278e031262699e523ad02e547720a9cf62d9dbeeca8101a023a5cdf2db8b122100968e57249329d61bb09500b49dc4339468469172ff41f540d8ca328b2a6eefb7e97294dfe7bbb52b00809279a0460c5ba0a6fea131c7331caebfe1aae083e5bd2682fdeb7f3c16d0b0fce314f5b35d52302fe420e70448f149ec645cbf3b5aa69b30165fb9f550e100f88129f2f3be89a5f0ef0fa79b89ace98887cc30da59df2f532369fab4784910b159a6313291a04fe26097c2e140ca92c5a3108276dbe1cfb11562a6f6418a8098a3507607475385745c71700ac19ab6e3fd374d412698c0cf1cdc1b676fdd2060529bb6361b42d752431859fb2400dbb84cefbc3e39473b21cc5a49fd16598048bf4c8dbc6081ea439d83a526d6765616e0424a75b7ec26a650593b2d86c54084bbf5c8231c579999e2b623b9da43a1e286ce379acda2e4bcb082508ba61d505e88bfa1a41259c3dd05132c7ac7d050275f502de522193ccd367df677b95620c44fed895ab84a8fc01add0431103b08dcf12aebbdf3d7b1326335d5e0740a4065694dcf4ff7c45c9462496d457de38694eae6992d4a3d22251204239a1f10a038642b395ac95d0309d43b229bd71bde433354569ccc62c7fdb3947885f54c203b8d2b18b8857c0a8fa18709b39a6cb796f400f293d9108f2cbe199e92f8a8d06949b9dc77f2b5dfe31dd1d422c35072e6cf8ac3dc18bab612663bd0b0829ed07e11472dd8548b18d56346371b1228d39b859f1fa810fd3584bd3813ec751a302f9b7ce78ddbbd620e79c56c973b2820a65a2f59a0a781453dccf1ad77a2a240bcd8afee44effe2f4e8f47df1c272c4820698c5af99a2ec8acc11c7f41375a50f0a9157879e7a9ffe41e53e6ec28761bf27eed9918fc7ff6c49bda55967ae8607b0bfc5e8f2ee73d278df904f0475c9fa509d33cfdac31863b9441a31bda9aa0a3683556e9ae942199b539cb0162ae922caeaf54c728b01b85b3eb74db24bee086cb39bce7eb976e0d535dcee72b73b1201fbfcbcd288737372642c08106c980e66f337cf1ff4b98fb90886117f2258301d8898139663193f92713d79db73bd0fdef151354f0017883253e4dd4e49a1a3a13e254f416e2766ed64bb794c9c9206d0dee94976dbcc97cfcd15c4a1ebc8dcca025371607b3b5a8496ffa4bc5f750808ea656d960d0e62da6602ff3152d69ec4d5fdd528c4eed215d240129d378a04f0ff8fa946b0660ae2bb08d305c9b67f45111fc5ff76c80fb7f8128bdddf7a0ab2089591b08e143b981a076a19a8aea00328dff8ab96d57fe3bec75d429292036a24fd858429fcceee4f3ba75a8ef0d88e0a98acdbed09323e1291c146320602ef48a7dea6cf172d950b91912dfa005dc55b0456b2288dccfba6204f0b660502576c46012612638894ca739fea9772ab1df850e234f3e9906168c99e353dd00b1bd516fd8ee6e6f1c391e5c4c9769986fe8065954c9e2e3209d8ac2915e5a706caa3670ec0e17d64f05a4bfb192d1543bbbe99e988ac54060458b236a97d490513fdba5d5b6ee2fcae45558cc0fe2e42e38110022ec4300a951d679e8d43e6047b95165cdd81586ccf4b21e2f2ef234a46c1caef5942b34728effcac90ebac07513a305b0e8ff7230ee5ad20333aed7ecdffc499deee5e39b7ff2ed841b7010669cc2a41a3c4e7af69cdb95153975fdce72718b2e63cca6f316fb41ecb8fd40336f2783bccb72428ea626034febb2fbd1083cd4d36be4ba0a6b6d9b3eae96c0cadd672d9aea395c6168474387fa36d67094a36884688de626a3844c3e4ff1300210ed41eafcb2edee9731adda2df4bc3ebbd8c6c13d216c8d0ca4f7d7d314601c6863e45665de971f951c667d391513c4c1c6e292a593787ba3413d58d846002f245b1b93872edd2b67b3d3178a931f3c9c9a1ea51e5d65cfc695d43fe09bb09a86d33bd58cd40c818751db74b5398882bd5e222c6dbb1fc77464c54297eb2018eaa7daed06efcde806f8a63d811a69dc34b79a071278aa39202090daccaf10a12352074a88a1537a7301f446882137f21c195b8b97bc01af68b1e759479cd0a4b254ffa38755ae3ac7897d0f0b759bcb72cb89893fb02b1cdc6910aa903c30e17abe24a81c4ed9685cc65bd865e42993fad567b91feb103dae5a14b76fee50930d03e18957d1f9b88382f97fb10dd169f6f35d9d428576e1c82be4c52c276047d2bdc0481ae0f5b442b18aa897d857c7dcffe0dd59c558314fe688ef680c8072a99a7389021fa9972a0a43842d0c8ac1afd2a90c5d8ef7d76421c178a41a10e784df3d755213e619b9e336c3a2b567edcfa93c955162865ffc073b380d09c0ba9e89a8eb7b0531f345f27302dd22c46dc2bdaec5a4e0b3217b496a585f59e0e63d9b1f230a8ba81eca37be7d8dc51334af166123ac65527dab7fd2e0b6a8101d3eeeb4e85ef15dc137baa6bb65b8da4b4c19e48267da4df646ef7e2db9b4f04dc14b73b30da1f28f2cedcbe45e02291fd926c02feeeb484a91786306530120dcaaace7946699217d22a840a578380203bd53eef97cf38f54c755d2f1990870279eed656ad40a45d310b9e5e18b6e9adfd08c8eba5ce7ed72191a38d9667620a910431fffa4f65424ea6752be88beaf70bdd0d5a1976bcbb1f533681d0dba3069b08ae0a507e7fa9bbdb1b2bb9b5fff214182ef1dbb806295ea1bcf49b54cb0fd60c09335cf514cf54a7e42fab855ea5b9625f2499adfde5dd84e381ef0c030cabb6ea5b9a5402bf81bb54f0e686744b5f3496416f0ff9de884a7c51613654096cb98d93f3c2779d9941d10203cb030b085041cccc95f3efa0ba4561f7011a04dba4d622d9992c1dd477e88f2cbf14e697fcb5c9c8cdf0b3a8a2375f7a3696017ffa268081736394ce55e07e5dac27c82c167f78c670e90af3674265bcce46045eff17ce18e7a58f2b06f3192da486202a28fa413c4611f2dac56d7720ce330d9c6a679adacd366a97752036faf2e267507a7967a328d723ddac872d78706f0fada9dfdcd1c5c9dea541807bdc62c83304c9158242a1ffbfe6073b139357db0328febd7cedae287e30ca1a6458a1babb50cb68ee9809c8ed465bb82f173b080ca0c8310273eae82860cb3de2c80c11d1ab3d54a9eda8ca5b4432e983341c7c0236fd310e29252c67d4bf90787c6de5a72892b0b4543d13d98b42d4d3fe96f006c7ab20f57bb965b73276d713364c7ef0f6dfce22ce3405685ca028c59d96320162fe9542f69c0e5e1c764207f13748211de98bdb45dc2c1c58f4dd4032536d04d852327cb0eedc646c53bd911941cdf36ba60a09ab845fe47307524999d13005aa0d22eba605a918b1ea5eadb83ba457ae88988c9082f944599bdad6501fbb096702a167bb8049b57995f7a6e27ea00c5128e6ac4cea6b2c17b49db4a0605b07a799b65ceab58d1bbd5b698998d3bcfa2f7c68c4a3dada1ff17ccf5015b62e0d02286f4a32764fec810e635a19fb4b708a30eced8a93e0a16ea55b5dfab2b505cd1b962dc9589cfb1e91a0569dd25f900b3fbf84111608021493fe37a62c4e083ddad92ae2b9c89a8a0080b30cca81ac98a6cb59880b7dc2c52101305d65e3050c27ae06103014f71e5dad215356824c792e0daf9fa6699d407e6aa6ac55090b1ddeb7ec945f43b75e3238ad5cb6ebcbd6c32386e41c21ad64b903d535ab640c01f8b5f6e1c86e4b0dd650b4419958c947a4d65b2f6e106803b383c68b41f80c5c94106bc20e16598cdef540b86d5474e3eb557fbfb988398f0794174b04db0e9e2605eed8800cc788699a5a38ff48249eee8f0a9370007b69b426c72366ab0385f246a78799bcd061e477adfad597013ba3a7449b4c1388eab02a71bf230302b7869c3153bc7f295cc22ac3c08f2c724de8c44ed083b42e82e6e6f8fc95d605544bbb917adcb019b4dabc0ac96e9948204682ad68a21e0eadfcd8c78b4b910366e3655ee51f0120a4a08956e06c7ac480ba777eff2c2c59a8e68e278ad10b0ab997033b863d6f98e1d60e5f45b82a0a3d55f96946c5e4fbd29902078889860fcf3b1dccfa2b12e2d76e2a36ef1564d60ae7300088036871df99e129d971ee07c9dd74c09a5862154c5aba33100177743ff5500ae299df4099fd814ab3788e053839f97f5c71eda5564014ab35451bc78726cbfe586470e7ff9dad5e543ccd078066f4beb820061be19f3b90a2c28f1cfaf7fa2a768e10164d8286b40eb6200c07ef7d54fe1b9d01a5b13ed5603c23bbf0d231d1842fe721c220037b8ed035032b24b6150fc4b08a84dfdd6b33e3553c2c5f4ea272804dca65844f0763213a0d9e58f6e5c4f2ea5db0b01cbbb69fac65ffd948c79a680cb83c32f0042ac19005a7c8691f70215bc0fb66256b12f35030b6974ebf7ec4776e0dbf31b57e7357095fd12357999b66a163f0d13c518335aed1269c2233bf4b31cab1a99e62abe207e12df61a84c0dc7eb6033827fa723a44092d139497bb5d45296e6fd0ea66f20bd72fa2d10b2d0593240dab8e7e6ce8a3399f31713ecf4f3739ff7ef3818f97089c86c875ac467aa2e692c80083668936d57ce917a450182e7e23716d8e26a400f8d15d9dc687699dbb609f6bcd1d7d3fbf464724d312a7cadc8da361532d0d02ca4fb8cafc9f12368d921fe8f5f00046958afc5498cf2ffe677bc469996a5b0a473cb745eb78ef67e9535a137b4e9edc56de812969bdc4f8638c17db9670d10d01bedd69f58f134ea25a3bd1b5914ba7e8a1f75f1ceb47453f18cc39cc433a0393719e136ae6730af0f5eee4402089e539ee6bf9aa48d4d8c8cac263283b59034df229bab947555f92448934bdcd7dd973b1e3c8961e96729d93bb8c04c8eb042e9f66b951dd7a812ebbe071ea82e051ae270599ea660a53f914c0bf17a8d30ecf2185a9ecd4b5c5c4c33ed4ab11f933b58b8b6ba8725ed0c41634d5aeff4103ddfa4e8ccddd72891699346777182d64c388bd62ba2e70a22f99bf2ea3fdc803922180bacb525e4defe4df820f7560d4a1b401a68bbefe903edfb6606ba4ed0b4d72114b2b2880109a0f34acdbcff4406fc2a6960494f3e426e7e3f125ecbb06bcb17e0a773d3c7ab186608aaf8010a4ba2386888449ffcab6f5a78b572a300c0e38c3ccb879ec90e1748ef1f0afbb9005458ff79f79181db3bc4b2e5a2dff071fd48cd29e8ae7e1b9a9c79cd0940b2ab8cc4dfbabe1f69a25f45197fa8c3a0b98f158cfba48e06c32e96287535a4d986ebbda74cbf5f74e892b5923946eaa07634d6eb1964b7b0fc9dcf04748d99803f49ee0af93f6a182f6e727701d612809484337a270cbcfbb2a461b37fa6d6f2778425cd9348048830d5f824867e713062c67e3952809939dbfcc1cf5476b982f2f942c7b552b65a6b871d6e314ecec034fd0f187f342090d344162d7d052fe909f63a8183061e7bf116d0b24e6f98401f8459888305f8998f0540a9e657e731e9f43ba4e23f031fbea4edaa3c9e103097e2b9423c5fa55b55e25f572dd0b40895462c814b1424f5ce26b59755c1327036bc3bc996a4296cbec827f157409b5fd4abe66b4cda575a6665e3875b4761d0f6ee8af83097fbd2b26cea731771823a7c0f76bd88bfb3822a8c16c350db4eb02fa85578a31236c931da8f10127eff88305850b05a64464aa9d223f88a1ac68089d6fec6b89bc09b3464565badeb10be8c0f3359cf495e7b38c2b7f08cd734c03b7695f72f3969a9d43ba557770d711c53293150ac68b489f5164204e9df3770fabf10e751fbe5fd91944cc5f2723d4abd3db735a4b64754cc76df8a0a4811b0a00806393b551c96e8aef089a346f781befba276e70069645241b9d4fc69066073b7a0282a0b67671e3dae01a8dead62ca7057e97d7dab0bd4812366364f2cb0cf022f529bc624643a1bf02fa0d3ddeb7c7323e8b25116a43b8d6f69466431607620f3edc8de442e08b3f57f422f17268ee73fb4e015b39ce3e0a0f6b13b5770a331991df03e301f8f57ebfbad1e4c544816bcbafba7d48c6f0cd1cb9d71818022c466cb42e2063a8503770fac5d2cff6a17f68bd689815d4e64ac81f53f4140847732f8f267b00a7249a3ff0b150bd5a6e500005fbc664fdbcedd5b7990981004e43de4444fa256679090971ce91f62553765bd64dcaef79bc08867c567ed204e3b21d508c3603eacd92a832ee10271c67f0c1649dffc855af2c93edad31cc0485ccd49fe91d3995f60693a9182c90cabd13340f8111e848e528cef40796ff001e0cd0581fb511b3b97bf4bca28ede4d007a83ddabf5318821e6c0c62621310a9b1bf9e22b681139935348c12953b97c6b3ed8b41ea1b153829e3ecdf2d73304a628634972dac09571f8f86f3f4362f22a38a832d1a5fc2c6d0eb862c506650db2e8720bfa3586b226ad66d30d9376688c06c6cb8ff80a0db4873a85eb586801151bff58033992022c9a6e6585dc5f5097036720e9c3f42c669c9d8d3e260f020ee9788ea4af7ae0d6144a32f905c0e3b5a0fca0172b9f4a4abbafa6ff406e0946a6c763293b97959617f3b4bf1e680b9332a244e2c745c42532fc251490c407ba16ba7b63ce74f7dd72896b74e24b9ca4f2374442dac3916e830bccd32e9e059fa2a3629e3192864eba2fef486e9915b9f590d607c8d16ec1d31b66344484043404dfa239f7a6f8f10c659e4ccbdf991a6497ba891ee8c0066a4ce023a7880a464aea545fd55287a55f07390125d23566bdd811450dce6606e348d69c954a08d63856aaac3e08a1225f85d4f68bffdbcf36a7d79f1a49c31e36144d9e20a002e821aae0f48104e2fc369274b5e07d8a522200725a00ea77f39a7a6b07afd606b794af46ff0b4b459aa4b6515418591607ba0c10eb7dd6d0df569e94ec571c04cb2cee3591fae0702bbeb0d98453755a3a8281218f3114c6501c64bf13af3908f149dc89e427f7f8c793db07056459ee6bcb4dfdf9a18572f1b2033fdd04c9066671c25dc115f87d562ba433606906e80de44e0826eb07e740d21bbf4dd97e05cbf4985f40693e23c0d1211e47dbacee3a1967c16f5f3328efbe4db9924ae40bed6b9bec39851b5a28683599f935df322f2a851fa00fdefbebc4f4458de24304543b074df7bac5b0f0905e87ebe425f597b7b9ef231346f0d5570a3068c9370949dc854ed77514729ed20c1ac1e9a4bd0c6a1c1a9ae2dbd91fa461b375b1af0e7f78835ed6deea673d30c7387eabf7ba1c005aefc7da43147dc9efa491dfee0e4746784f8b888f464ab086ab7083b7133431f3feeca14ab23f1104d276252f0b89a8b030e3d0d9522497cccb756ca9f9c4366843c5c17cb38d334a84cc027d028aead4b4e589cbf4bb108fd84d9a55af240b706b9e72f015d56d278d6183a14addf907c3f3a779d2425e56b587a85157c70cffe32373ab6a2c63fb3ac3fdab0cb7658bfb9316cea6fbd63561a7625b1f372b939c07c53e1aed23a7ba92daae098e4e25e9ad12562f5a3793d5a7e3da02076fe56e933cc326de2a5672c83d840b42b9b249a73aca01f850c920b15ac80007b37937e2cbfc477665b043c332940192c221d62585be4a259fb514a3f06ff8795e515784016a196790ba492b7a380d0a4bfeef0a5377a393f499852e631ff15b8cb3848037f6de53c5880fe10eba0cb49603ca50a8c7915b68ae85ff8f08c3de6bc880f63a6af1624d51d72ef1590c17ce2b9b051c438c6a164cd07ff4ecd1d8c4eb1b7faf386139623b85bd38a60277a5b2771494712c020bf38a491d52b7796e74c037d9180ec6847a38dd8efc000fe6c5e22fae7e77e9505e342af245638657bb6ead043a5574b5b2cba8bad7056a353cdb13d9a39cbf254597f0008c39f6eade95b11c3093eb294db0f458714f62149b2ea5e45f47d3788dad6bde98391292c325869ce6d83a56ef4c9128990a6dd241899a18b5318143f339aaf44c68f03a7c23b66050932bccc51cba004f038db195f36a735297c5e6db4c1da289ac38859282a13e1a1f46f3e90cceb1c70e208201df01df87d891ecfd17fa987c40cd5f95d02518954bc23ad74fc8dd8b0c2ef5553f4eaf2c2fe5dc9a05542fb4238e8c57109a8cfdac527d1af17508f600e5e6aa45357a0527df93ebfdb2af0795c54b902a934812436ffdd816c6444e06cc1c1758a2cfe0a62e9a56f6f5a80e55f3536d60348422605b4c463670c04d0358d6d305eedd16d1dbeb072a65a0460fe09faacc2f68049ba55167d8f5453d0ca53d79497d0f2066e268307a86aff46860ddb7e8dca9a3c6c1b8c74a3a266f0b16d158cbd644fb570c7be41161d577425ceb6ed4a46b1c1408f8abfb8a84fe01112ba839cc863302d37b7cca5964993f127b9e2ef231c8e0aae339e01583ab03bfd8caab4b0c246cb25e65f68fe0ff17bdf72aef4747eccdc5cbbbb015d2ad0a35f356006fa1aca61a820b6dbcb2096486ab3edba8eb2930d11dfc0759ecb101218ae639904dc19bd1fce83cf594fc86adaa13b3b37d24567f615e5e8731a104158a83c65cf2b6da28e0e15d3e35c8827f6d6be1e09543c80fc38bfdd47c8b0e02c4529fe4d2e110836f432ecff65f846513bcf9f3312759c451426bde3085053afa5af4176a8f3ab6216f763482b6ce9afefb0c802552ca4ee83a8ab448660462e5fd11be375703edb6347e55c7cc703dc202bdcddc0ac71969bc04376ef208dfd865b1d0762e6c76af6afd4927c476c2334e0de4eb0aedd547286466a8e80725521bc0faa6fb3e487f27e41eba7c615117de989d4c1214ef7e1b77d7135307e963fa30afc877485950676df82d54dff6aa63bb2aa7e7be0638f12520042b028bc86782b021ba433e2203ea80477a8278cf1eadaabb6b13e41a3d66b7b61f0ac65c56024ee9b46a0405270bd1e35a3ac393ad6d72fa17efd515ed92c5ba47023a56be89425c39c0aa0e3ee9c3c4f4655984c00bc061583a3006682e98045a07bbb71e8e119451f5ba9a2aeeefe0163e69a6dd0dbd81f438c70e9291bb308002c7b103bf699b5ccc538e38316a165a0ce4f0b14c33024d4c705c3607fed7a1066c015ff5700ae1ef09a19ffa5c3617180827a5fa0c2b075e42b748270d18cc0b9180ce798842640f40401f86d2ec7511bf22db151cd98d12c6ddf8dd9d7cf1046ecfbc688eed7b138ef91259e8ec2d06c6226049aed286055677f9c2d2b9100ad2aa2f7a597e1eb884ce5ec761fe37ca3483e259c7d8b159121de8db67d243081d8ec06cbb011631829be5f27dc90c1845458b2434472419e0a7a04347c51d0dfeca95e5ab5ed96b456f75e312d1c5d590586324d19c7eb75ac0e2386e544907b9434dddd086d7383b562018774beae195cada8c3f50b7ef6c33e678f91e3209b056bdeac760f80db65f082e8a485c3d11f0f04affe07220647c87452e3834003917be321662e10cbfd098ed644ca654b7e8af1640bd87ea8fe94cd884671b04257fe717a5a317ba447fa2302cf2e3795e5f4037109cf542b9f40d04b166a3046b6c46ee5d363b6a864df7dc5105ec9faf08171ba440006c5c7265fcfe196408a31fd95ae13d7fa4e03057a337afdccd7aa573e290fce023b5c558b53b386409a263e32fda17289c832e3bcb40d3557fa59eae9131954726080509216b2c820c3e9400ac4d482a8b390ce13bef58582ce82f207d41bfe57dc766f2ed136bae08c063ceed2b0205f11fea72d1f84eadbde27586d01d11436b3c48e75bbc982b06d536862e4979745b6c751e725e0bb32521994d75cf051feeb1d47e03d0c26b049a2627f7548b77b06a1a562c4c96fde5fd94d8d533c79dc495a21ec051536e0a5f17926d9184a34b6162b70fb5ffafba77f5113bd9fe4d04187186e03a57ec012fa85c364cc406261cd05189ae6497ae200bae5b520008e5ddbe7dab7b371005a195faf4fcf3418247a8845cdb9daefb4abb9cd41b6c2afd75861067c0ff9b08354ebae212ba5ada2a9dfa85df1865200119f415871cafee7c22c54de7c6d10782d27da4f9c13ac03b2dd91eeda425cee41598dafa836c8b940f6232f19dff046898969f12695a402d769da658f5c9bbe7b6069e58b7fb294c1d86c0383c000b91909960e84144ef00224f459240c3d8171b013094f56e88e55f173214367f06b730c7f5196b80242ffd58f84b5e2e294f9d09c9cd82e9f10b9050cdf22ca909c88bf412cea1530c7e2976c1ad4be8cd80e6d8836f9ac514a3ef86bb93ccbb07484908aa9a099cd8744afa12b815d7b9a648437151a1c0a77885dd50879f51087eac64e76f95700b193d11fa2a3b52232a4db0b0d9ce667c148461dd4034d1085e902b66d297496f8261a22627eae4c64e3f75c0db620b8b5570e8a6b79336032d0029ded17eaa7c03fba906b172b28f4de15a423fabb9b9fcef28ac8a7fab06d9507999f4630b05eff7d26953dbbb4c7300cf0840504bb58a0d28b1472ec903ff17584511b6bead73a90acaaab5e0372b7932a7aa021ec0182dbb1c1f409c0715c6920d4232706c53c1b61140e5d88617c3f6ce4ec68a0d765267e70c76be0385aa24be9866ec4dd1acce0787d5336ffc99e8af8e91158488dc0e200a20e70aabe55999db2c1b954f8f476edce999a80ee167339bce2fd218396d77aad4df0ac6f805c5710c128fa0fda26614ab87aeb6408e435a9bcc38d56ce2577ea19a0c6fdf37dd2f78508e6b14a88f1551df53554ed1d8213ca3cea0fb2d07918d860c688dd62daaf49168ed6ae4e8eb4afab0c3d3d07e0c640cb7eb4fcfa5de7fe7015ab8e74b020c5f685ee939bcb06064f47ccb1d2a628d82f73ee7f0d1269143040a2b7c3b0d7948e490b1870cff983059f7a8c93da9bf3b2c7ada601b2ffa310dfb84db7e3a846e02493514ed900e9ad93f7e042d8cfc3eaec15ec67a76d1480ed16e8667cb70e418b6f8757536c5f8139cd47ec6a7ed1a935e66b0105b64920987993dee0086b59569a4add7a0fcac795371f463d6531342a7dccb34a14aa703e261530cff35b2b88c9e0f97bc49dd804b514b146e0e0d033baac90c524c4903cb4973abaff133fa3609ca92e388892b26085b62845a5fd01ee2d9f11681e209b1fce0bc5c69569ea8279736e03e98d363e09a527a4e3cb8e89f2b9dda88500a8363aa56289d1e1be4e4425445a8b458ff22a799f179e4aca40f16a9812e560c8e7244ecc3cb321aa68ee84870bde6e85aa78cbc756530a59ad70fe1141aa307aebe94f6de3afc3cf1a0f222013ab00c6d58ca2968bf905241e53a215339be051750ce2469f3984df0c57e8df4490b34fbfdd695a46f9ec3125cda1d52fd846300c25b7efe334b1c4658ce9167ce1d7eda841b2d31637145cff36be007fa440b3bd21da2edeeb02dba8697e119c64072ef0d7c7282df292bb39be3423532180ccaed81b7692c760938bd47b886b92b79856b8d458c768f0259a92d98c7937a0f42440b0e3554c06fdaae28ffa40364746defaa2310ea1abbb7981370b433f10e0a0bf8770b589bfac3706b59389321f1a8fdf6a8b7abc3e950f3e4c36c00e504ee55278afed0edae6a9386aec771a1802705315cd0d59b2b0b0be42d7e9efc09e9bfc79c2f6f6c6b3ac6def83e9dbfbbf87712d317c3b2679f796cfa2d9266036b3f23a4fee5a2c84e8da81d2a41da94fada28b2a482091bcb4d789a5037910300ed2386cf45c658b459f7937b66d3b3e6e384797a4b882fbc42d488969fc007cc70a183828649d6832c4a63e782eded802f2b9541d6818aa97ba4ea7383f0028972ad184f699f828eee4add58648632d44aa24a1958c7996e14d6fa1a56180ee3ae76cb9856d0e883def0879f3782bff41e27a0f6f075673514319afc9a380fa3a131ea7dfe0ffac8ae05f362b75225a96672e39448f2adbbfde907e189b70191cc25dde2e9e9369fd7847602304fad54106391090dfea779e15170a449a8087efa5533f05766e83ffa70771cfdc041646dbd4069fddd48e82ea7b9c3316a0d0f40a91b6839567bb5e8758697133e9712d44f6efc02cbfab48fd7dabd6bfe0e0cb5c8f25c30149c75b708c7ff236e02ad8048e01ce42e019bcfb55fc174e50e9337fe6f29561254a5ad40ab8601fb21af5b0dc2992ceb867e5401e4a605b60e053730115305f55735913c6e5d1d0b60758ca7e00661c92a78eff3332a28a00e00064d7df5e4b118510f75d9b3f2408bf9c4564d1e81ea82df032d0cff63660a3dba8b51f8b82fe96a0849e4bbfcfb2da4a139b016c15797937476b7bd03a401662d327d82f364d3c392da110ee822754e9170c4ddd786987143430221370e0c1e11f615137e5631bb1634fdbfe0f1ee819dfecf45f7e62b4ec6f4083b255302bcc1effd7f0b7c0bb1dc9cf4e9b7df9ccb358f8c6ee5b96f6ad1d3157a86d901d8a09078cd4f3e3c7e902c8e3e2e0fa7797ee1459b97d65b910c5d5aae742e0c7551d1d9ea79dd7556904adb836f7192a823998454cb167344b7f98aba99ad0b2d3ee0cc1dfb74b3bfef40ba102ec3bf1c5997c9c6f7e1c57d4c8cf7010e2806567b50c536bf602bbddcad53115ba26f68f9553f2d5a5e8846675ab9f3619e09ab694db4956538e3033b8987e414deff692b93a7e35edb3ce4674929521bfb0e8b28460c23babeca55dcb44ad477faece2b85837c4259a601651145cb769d501fb91dabb276707afcecd2a3f0fdcf957e70fe2f7827f862d4b436f5a4a14e407d7c8c4dee9e7eebc4cd21da47ec780318524e11bbff77b9ac914866deea78d09d66e80cecc197c0d77b0ff66a9fe197074b7cb28a3085556dff755cb7586de0e18edf965f0b6fc6950c1e026bad6aec6105332f0051426080ec4bf71e4da06056de0fe1f1990152c335f5d5df3501810ebbe4a5b1a8a440edd80024501b2a102a0de054fb29d476416f1b36f921e616ef2b6db3009d09c2fdaec41b157c1d10ccb1753386db1a6f3242c58a3134f5e171257efb4c43029e2043a61d5aeb84e0b67b7d82de63c4810be2af3004d01867ecdd5c3f96da4739d7ec5099c4174060975d2500678d89392da960466af18282924574db9f92200516ecd7734bd76c40608eaa326d10017c9b0984e222f4ea612446779816ab1b54268cd44e42b38720aeb49df59417aa1f61e51e5e8b3a72f62f23cba84ad2c3d5e02026d8ae5655c0d6d3617c1b6575193d26c1fb3cc37c99be9c8ad2735ef1c86078b1f6fbdc16e0c427f52b91f0d3bd65f90b56195df9d7429969b4b30553eb49a9fb1a1feb5750e5024895a129c4da56f1b455b0baac80ab15ea7673b8c138779f5c31be637aa0bfa49a44f73b69ecad77d3540ae6b5ed27173e7ee27b433769951b0b654fb3906c816bb7878600fef36bb947ffaf3fa7786c81b19dbdb7a0a94983ec31e20d00658263a56222c75025571d92c42f25179393755eb8111d22dc9e868e89d30300d0afbabaed70bf4608c1bc51cbc280a1a423032c248120098c68b8fe4a1ab4d0bc504a2f7473987ac0cd32724d4ccaff1d31c7abff0eea41875080faf14e7c208755146cb63cc3bcdb8706e51b2923bf0a36e20e748fa0fee91c08cd894a52102f1be86f0487f471d7565094851cd08db6d87ed117abcdee928cf05752f4c590284ca88fd4f714e614230b4f87769b17f13f0c3f2ebeaf720f13563750706e00efec753c3e0d4eeaed3c283f7986aefb99426ea269358c3ab9f9e6dcefd751c0a28bb9b2152d5d909ee92dd5b8b168894a19655867bb78b3c4d6d7dd684f91504f525bb4b0345737dec1b4977fd0b16b1948d1bbaa7b6578c12d20d845f8a9003411ec3a3b8354fa300e95608afa8cf0ff83110f3bed6272e9da5a2c1d0366a053f171e927d85fbb82b29683793a32a97a05d06f1d87cbe4552d588ce08682904558ed8590ecb8c83c06cf6a3268f31a934cfb6a2b5692bc5c2d0b2d3d0e4a903d2e90776f85473fb7346369ecaf9cf3ccd887d4fdd335ca9c47818aedfbdbb0cd744e78b96c6d8be845022f5fa00df0f414b1f17b24c6d4c29385d6e37ca7a09c7ababfb226483ee4fa47cc2d76a0d08d072c3536de062de8ee0c391ea908d062b5114501649c58c7625d174e25f73ac43ddfefedd31bb1adc3bbf9e9679b40cfc294c7b35ceca3b127c1a92d5f567dcad9edf8f2ba6f4fe9ef3cf0bdfd782009904de7d1dd087d76dab27322ddc6d9c93b1485487c05cda9ca83120142a1e02de07cd39173b4a8a866ffd8a315b963fcbc5a9765c9c8d8c3c33d5238424d20ea908ffa889c92a25be4d4ae5005e820b967fddbe882a16fdb0698644f1dc7208b39933c590ec318fa129e19a35a6e437424aba404dd30d56bce0f9f659a7bd062df9a0d680af8be39de0f68294839f3c7b5cf8052b9e492af136e78cae102a02d9c1daa7bc74a928c1158aa4bff5c0340b72cd3fa9fafc5b58c4c2bd3d727c08a77db5bb0c302ded72a041b115d5e31943ea4771134f07217a96ef60bcc4bc08e5f2699a8ad3fd1dcac74d5e22d9f597cd1769ba9ebab19b3ca9167ed60b770cc96647d4bc717cf461bb2d438127b8c2ffbcfa2b2d846c10d6a66a197ccc7d018aec1a271b9121663eb9adeb2d3868a8000c1cc0f2e47e7469e14c2f9693d509effb86af07324ec05725ae573336e763566491849a90741ba1e25c95eb079d048118a2c0fc5ace9ff19d86e0fbdb306e6901e37dbbb56c64c7f894a8ab3dd609fcc030eea8cdd4c1dac53353efdaefa2ec10a4e4b3c01289eab163549ab51c00cd66077340c93efe517921bb0176b87a40e5b59ecb0e6af08adaf06c9b479708869f833da6164e40dbee4379bfc90a79475575a6e740eccc4fe4ff9fd50dd00ba4ddf58012827a941c1e999466b5aa2bb2b0128cad7d533b0c555742dca24a0801700a264bed9cd85c96fac12d3b196d54937a9fe6550969de8f6fe89f6a30039fb0b12fe0522003fc8f9fe9fa1cd2dd8374e1cfb5929d07da3a2c683a02b001ffb6a056e88fc302d64a4bce1368da0d8164c851fbd4c2126604e278146de303d8e8cad3b4580b26a1729dfa0de6b759517ca0305b9db9194c25fa7a1005ff0ddc2d2fcb42c55ab9457e8f9cd69702de5a032186800bc6b302f0697f191e6500abc1316a2aec200a8cf43474310d1209b9e2a77a8fc41b92f5e66f31251dc90a3031c337798e91fa43e7e7aac5402512cd7a72b99941d32075a808bdfb3d2b02060011a8c9a6637e48e7663f4f0cddde58a41477971703109c77b3456439a00fcca43a6115d24117989b6daafe6d9db2e47568eaac904b24a9fc78b6693fad009cf1de9e621c17ebe947ac6b6d22c1dc4a9ebd2f5296c58eb66626f8521d9b081477ae5356c56f38d7bf81acc3a74d1013671f37e83c669ae83759dc99dc3d0e72c516ecfe5da0ea1321a762d804684b85760ea99d1bf3152f68aa757a1a870faad123106708e7302cc4dbbf46a92ace74d42727b2decfb5e707a7699b7a180b66c026d9efa39629380c7b8610d602484ce343a774d93d473882a9009bec440c64f598a0fd9141bbd9a5c6d33fbb881dbb206de87f11beddd5f7ca7d24c11b076df3bdb018b6193817be37df4895c3ddfe5c6f2feb320f5963b9796e08ccc10ef13791db59d6fcc74ef33bb13aad8bf86f6ebdea1b475b47d976a742f1277e05d5e6ea19aaa92d49a6f3c065cdbffadf8c5d418e8cfd09e95ae9da55a3b7c001847fcfd394b13938e9891cb6380ee6b55817b8d1b036204b1692c159e84aa709a73cdf8b44086b472ca9b8039d17cc50bd456d3fed5c3b81a55fc7191ac70e04479337df38f4b59af505d386bc1510655538507cc24be0c55273dbf9aaf0c401ab45d372331f4aea4a19e81c3ce1176d37f14ac1f2fb8985a71485ee70252204c573dfb1aeef5bddce825eba8c1bebff907b2bc31f0437b9f60442de809c1303dd956f54e33886d85e1c32048d41a670c82a5bd60934a8acc8267478d111050ce081e0c4f56e47db9a002a9b083f562b3ca30b232e00676cb7341f49849fe90d0556033191a5e7744ebfa7796cd1dbdc070e18b1c001236936d3d4e3ab34a40f026ca382a0724f1fc6a95b862b64c86659a7a69b1343b6d322adc13fa5dd40058a28e11681986eba14314020415f08106c1b050a8de8200ebd9ed0f8dccbdc00dc07bc0ac30a8e5323dc79b7ca0351fff248aee1081b1ff8a7ab7f5c8acbe208096d658b55cf4fb5e251f4127d8311ee0958fbec0ca480dabf87a0d722b89d0ba8036625b6ede04229a06acae5595abbb0c5021c4e616c897754dc53c255ca02f0f146ea74643c6fd3b08ca7828e967970ebd3947bfd11d4d47a661c5a2035043b2289d14be2551b6801b3629159201cbe3d486669c39ff779b7cf3c44d57e01df988d607d02b83b3cf85c10a22b8a9cf3c24c339681796ce6619d14dbc49b05d83a54300d70cbe9e9cc5911f2052a757fe0ef97817850bbfc16fc9bab7a6000b029c38aa84cb4c79ec0d33577ce30434d0fa92884bc56ccb21ef67401ad120a5b0da02ecd25400c3b5cc346d1874f294c391603f17cce878a80469abf29ad01b5d929920a893c3c547030810e9c4d24395f41bae6ec8a16dd1549d0c459fc038b0f125e652d5d5cd94f43e02ff9de74c2755c44bf7692c35c0ca39444be180c73abd465a7ac02d23c4707e8c62ec1e30c4bcd2105eff2b097d85f4a236f660e078f7826f00a687023888083ec179f7eec9aff8dd02a74bf491ce22f8341df065ff91f45acf7235bcb9b183b269e2515ce5d880b45edbed5710e1dfad27e0a01cb7c594dac5f296f02e06605f65f57826b54493dfc5e77b8d2fca904e69a1b04030dd7179777496bf2e0ff75c2b0f257707310e8b4bf3e49e109f0f0d844300ebeb659749ebec82443b087400c10124723fd2671efe566866ab2d0527d21c50b187d243cbebcc1abaae3a996b5e1070014fe36b7fa7212eaa98913d98a0bcd043ed1dc050d4fb754c66d08099dc826c1fd633effcd36567f896f474f1ccdb00c237d2815a0405e19e7d90496cfd5c9408908959407e88fd7341d03b6aeaa4b05d1bdd678fcc2fcfb8c5e77386ec349a3c90f4cb58b6a345bcf3ce6a10affe6054ab18c3033d0a41f27f9cfbf41c74012c54796e54639862bb50b883e40558e0d false +check_ring_signature 3804e3ce64eb4f58b5facf8f375a748e0d35dd2e9185d42b90f731b82e8ce1c6 195e4b7ce681e7e21c4603a9bbadc15408b9f965d7270519dabdd563a67d0fa0 29 71bbda634cf7b538d726660fba110396267882fa940ad2f6c4b94690852b8a3f 207a0efe9719ec436e68f714448984369ce497e1548ce488f07946bf229dd0b2 387e4c722aaba0e4db2b3405160ef430f028ff87027ed9ad1c14048ed6cb588f c0c6a911be68886a521dd28ad44617ebe57ebd7bf5bfa60db098b8a13cf8e470 a72536c759a5661fa5b4a164f46301d460490cd5a85fa1dd0239a33c7216b5d6 f942d45f258a204109848e6a314941a03cebe9489e5fc89cae8eabceb0fd7586 a671719b289a2d52b872bb9b2c1fe372399e5cbd76fb4a31c7801880d224e0b7 20487a630f755b34010987328f96931acd7d07937319850d540ade86d2c81e9f 229e84418c0061421ace44a385565f4f0ac5e6f3f96be5e2e1053dd2d6366005 33c0255e4f1598858cc87782470cfb9fde9eaec3980f0982b2c82bcf345c9278 c841e7cfb1c094adac56771b1ee15f2f5f1029cbc57c3cc558a13d571bffe0a0 4da51e519649c6b8f9bd3bb788fbbdb374534c9243c9c3f9d0fb61562c4ef2c1 7c58398abe4da8f286a294aad4d0b704da3facc37c15515c478850edba9a2f06 4402adb3b4c420a38e20a2bf6fb2c8f330d6994642cdf3a9b36389213e1b4244 e0481dfc836faee67c461d86e6de1f3a0fa08cc018519dc83ce9f2510c99ee20 a13c0af7f527d5352a68053b2510a228ce355bf02d578cf77a148dd0c24c6d50 77ee8703b5d71295ce3e93c4da0da34d50aa0e5057abb46b61f2d411564e5cde c8e5b1efb802c7ab87fed78ca4adb41f42bbdf674354123ca9cab8200f166244 1b8c0d358c8f6343b3b59d4a333bfcc62eec6de73fdd343421234b04c50855f2 d7cef5c26c9a12461f56dec6cbbed3b6ab24f959409dbeb100ea432e9695744c d61155a9b6b525d0ea8fb431996c19be0e7e2078d8751ae4301d1e82d943536b b4e2ee9e337394bf5e411d5233a47815299370abb3b015d477213c13924cddc4 6d57bdaf87bbc3d675842677d682da1a5e9ddca389104801f1068a827ce73aab a70e5ce351e45b605545d2397a0bb1a9a6ff0172804218c220a4ca21683119e7 6890483c8e68ccfc0f4cd13a0db75c62b4f04a49197f689d59a8bced03f29a69 526cee9210b1f327b319bf488fc6433bbe47e9817624f66861f01d99e5848960 ac07c601f4e5b92dbcaafb70e85c5412cdf4770247e7f6022ad5bbb2d847b051 c59111dcb145a224822fde8edbcb005887e8e0d52beb0fd9c6f5918c1cf0cf72 2e8cd6379008717db437786f38c2a2606c6b79116d6b1414bbc4c39b24429e01 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 false +check_ring_signature af2e9ad3bd2aeffc6ac58a648662b3aeb5ddc61e5abd770e08ca61716466eb23 433e62715a35c25551939e8cee7a69e88bd8d96d60556225244010f085ae7798 5 5151a9ec3a7dcf8a805ea7cb6c3edd64e65a2c64ffc7a699c180f0df340e592e efed2585560c1d04acf587163d2e2c7c98e397f51b095f67503c17f3c4872b96 5ea18d3c7c6a30fa07db81a9abaf5235f0cf5bde9107c8f2d3ff7f357ab6187d 84e99a523d08a57cf7acf57167249e61122b9abe316fe253b12bcde49b8d5093 ba4e4a8c07c4b330f5b33611a7401a60cbbe1bcac56cb981c7c16fb5f02c979a 6152e0b0ec233982cd2e4c3eb7bcbab0f0fc2d4c51a95be53f237d375c2c6b0af4df55bcb882bc3e35d73889f786682ccc8488bcc730a95bd5da4fe824e0525c6e007d0361ecb6d741ba8fafa14b8e00cd1bb2d47d00cc513badb64daa507b081601f8a9b9df3b9bfd34475976bdf3c774679cf899b7bd7001a6db640197be08d77bd2ec57e0a5447ea2745ed65af07a13f7e69b56d2b639eb5fa27803dd88762b6d95be4cd59bcffe8eed827c3afcffb9bf7e57980054923190f1ed3cd1ed05a18b4e34e6610e64fa56e2f6c157b6b510618390ffd39622377c3cf7b24772ee78da4f0cb75b8d78ffdabee3e706f41a21e76fc88789e4755c4a695bd393c9019c9722a0e42a7c3594cd7a8a4626dd42386b9813786ec601fbef93d01148df079fa5548bbd88f2a1782bee60dc66919c6401aae0f404b2010b2d43021abeac06 false +check_ring_signature a75eb160fc276c70f60d236908b9c8e0067a08df5c722a38010e047ab7196a1e 156e4fb8de040c3b5c0e5fa2817ad2eaf4af27b97d207caa5d446e4581d6260e 60 53b0e89a52129c04adcd6956ab360c8bc844c082926a85f3defb59ef8c02bb63 c6b3e0a60cbfb307a5c10e0a2b059ff5ce48ceef49a9bc5d4ecd83eee5fb1bb1 5bd9deb979db6c4d3be05c5225871e8054bc8a28986fd066afecedfe3367ca85 acd1518c2c5e5d9fbd3e74744639df1d917cd2efc93e8b2e83d634312af9e410 2d4e97d673b28115311fe530fa2b6cfab76fc5a1354817406441854b4c5f859f 4c1c87efab6663b76f26725aba2f80993a6f80398e77872e32e7c88bc94278ea d0dd3fe51d87edc1672b2f382e71d9ec34929ee4b80dd556cb44860954815738 794bcb37fbb489cc14a87af0f0cb1bcd045f9439e4d2eb76ad3ebee0c1c847fa 0b5f1f6ca588df86cd6abb5c9247ae57fbf2d7d8b5b118c58e3a57f60df8e308 c3c5348ae574e176236258281638e45485bb2bafec287abe40a84e8a528b9292 c0f62a8f92b8fa5c74224571de7d0f67dc8eec1c43e6fd94810deff46e5961e1 53b8170327a7addb0655fa6f1d7300c5c46e1ad46c418f4d2622a91ec0b86ff6 1163a31a8ef738dd748725596cab127093d1cdcfbe0c2892c4ba79f545dfa187 912389d8c9afecfdecc21ed4a1e2f08c8f74f08cd5acdfc5ef66693db73328b7 b2bae3cd2e1a3adb11b9c01bac990d50d7ec9619f3be3ce6f2681f57c193d3a0 d6dcf976b7138c4108040412d397a8dcad97b05140ab54cbd6744887d2fa2291 b9ab43cd88eb8675fcd54ff1d902782df47afbed2d93a247dfd59ab29bccf5ca c29df281ddf809fec2bb6431e2a785bc4691ae91ffd86903cdb731ee10873742 d83a3168ab6580720a21593ac82dba8cf8caa46e90c48f24d50f5d0d5d89b9bc c523bf72843c7211592264cbdcc6ef5db0380429c5a387abfaaa8a5f18245b65 0bdd52cb617f4f8b145987e1efb0b464dabaafd910980db6ede238af9b2c5399 5bdf2221245792ef50bb7fae5a61c0f81e823117b20884fb7ed073f61ba8beeb ad758e0d90301b068d5199c9fb88153148dd3fb37e2ffd564c80a9be581f85b2 253931b7b621d6995d870a5526e77989b26a1c29f3f0fd47a5c9c8c91b65071a 158cae11092d4e849388b96b7d065ab96d760b1e466f8b77095fd1c4f0004100 11be599e351aa2f47479bde33b75d72c8f74c89f977641b4550090fe504b2797 c3a69c21725504b87bf66428d32845e21782e44c4c6677b895d0a8e50576374a 13f8ea5c44026efd1b5e250aeeb3c6c8dfaae337696dc95117ab316661ebd957 8d2acab9f3e7d6810821f693efe9800b17dcb80e5f078485568ccb3e795c773d 9bdfafd8e061f8bf20e4ebcc2f14144c208fb17ecb25942fbb317193d1c8eb6c ae06af3e4fd74ecd95ec03ef9be42a22a0d72d9d258e5e0d14d54d07e4313b04 40a498f7ef05547debf613790f686cbdaee4bda1eddab45df009ebe0c05334c4 aea2c0da7f562e05364b8f1983dabe35803eae0a4bcecb1e004a1acc89dd1cf0 a853e2ad8902cd2bcbb97e6420f539d9382f51590e58bc4ed4f3fdc3871952c6 9a93d1bf87368bfa9d0e5f620a09856ac0b7dc1a066ca373e7f42ae4f377c6a8 38f14ce961bd77b5b581c4b71c13b1d39f1f489b5d3ac6ad02241c54a264d9ec 1c32a0c428464e80bb64f8ef8fba9fdc1f44263d3bdfd25195d8df8a0e502f95 a87c70ef8b05569db14e53c663b8b6c750f37406db6459d1921fda2caad11baa 30da86cfeee5ae7a94982d63ac6e97888459ba64e2952533bd571b7b8296371a 70bec255729b4566433a45f62927d5e1d89758c6329cefeee80f7592a6b1db97 e4d422bab66f2e8c0ebc3227b5de65db36e05f6c94dd7850f5dc937dd4e55f35 433bd72d7f0442c39a19c7a5eebe0ea8bcbbdc2876788ab9c32e0ad2f7a75cf3 0dc71cae949803e5a3419eb307a24bbbe7fd6155d423b1e0e6ccad3048fa063c 1c59203043246735154fcd1d5ccdc30210169dbef0fcf894713869f3d54b5359 564fbee60b9b3197458cf48e5b0f14f0ce99d5a984b8e0dfd3f4a115b5c4b69f 0903a0f14017670b22ec8468853809d9304daa5477b8d4d59b51673109271a5d 911aebca824070bfe53aeb4a9c86462e59e81e1cbfccf45a9b4520facfd2c3e1 b6ea4e0d690495091a7d69f703a02ce5d5e782b477cfd2db21cfb045185b85b6 6d68450c6308362476c870bd54070d4878362882ee97e44725488e1a5502b976 8bc364e1e3bceafab76f2a75b614aae210869f65b5930bcd42ab03814d51ad8b 4a29c937a942bae6f485c69db009087bc5af6076870c937ec692af6d6d846f7e dba65a71d7a17f14d02275f5341f613e47dea5920e596ace5796fc3a0fceba65 13f012e3e3c430fe358ea0488c260003f06d3ae733220c90f716e805ff4bafa3 937cd790897473507dadc8b3d0e9bfee291eb15b8219806030a8dec8c4a0b364 89ae25780e1a78d22a6dc4b510a9002ac006eb5a4ce47ba965e092f0df69bcff c28b099eef44aba22b4bc828ba0179c54781023028beec283b9d44a6ec5a25c5 85bea60de9e90819bcad123b4298c00b6a313064805760f669da67853ca8ddc1 c24cd57846f1446fc6d025bb68ffa63fca4251e881354df6f4f9e56e0b47af70 5e55e5f957f4fb9ce456e19538f4866c6bf0aa0652d326b129d21af4ba129019 d192855402e32d8e3a7f01cd33d1a772fc58bca4770901ff53ebe87e98cdd79a bbe473bd16e1321812938de82be86b8295ae3573fa9f9b5939202a7df53acb03d6fe5e7310081b13aab7baef4bd9eb38f77f5e62d42c7e949e660403c77cdf0095bae45813048a4c31a78728a9fb15cfaf3fd4f003b808e19c52e77fabc0a40757201cfd853f6b76793dfedaeb4e832b28c66b36f81c54782875e6a812122f08a1668250a57828987674a10f273d0cd247fc2a72b6838cc2564ca7277634350a6472b0b78312f2ed5ba5114035707e702439ef9f6b2dd466a264822c1ca0e6050fcf1da20932f59dd15f747a668e00c275a828821f140e8dbf45ccd645567e04e8028c248ea852f83b292f9cfa87b00a2a8bc112001b1cbb0fd89bf604e3a20e591e420a9d9877e29bed5b8f6294b37fb05bc718242a92f5175ac319e8f822023189451cb31807654a0c2e39b674735607085c27980b4bdb79501c3df18bb9030f4bd5274ccc533bacc21b0191c64d4d0646f0c29a7b443b2d1a809aad3b9d0dbdd61732cb94fb240e6215c01091381d687fe36b1d9f1952854cbe6ab62f50075d86740600be32f09e2a8a502237258e9cf79ff12c82be1cd56eb04cdf7cbf0c71afcbfe244993f73b472cf634034b3fe8800677ed2259a4a57debe6f3d1590d921e12e9133207efd093fb7ed75a12e18f2e02a94f683063121c58f16d9c6b087c2bd5b24feebd034cd9d1156e25c3703b36cc97a2ad362f8926f891f8e0d108d61002ad60fb39cb8c529e46bd4c854b6b62e4334e0f11f50d31049aeddded0a6a0544a849493dfdb17a0908de82cdfad5220e6e1d45b8f81ccb45b5514e2b05be8590c021b92339f9ae4868be243973abf6830dc7aefae42a44a09208b2050a96d6ac2ce754c9e60b158a820bde259e879ee4d571d3f93d3c63060cd5d2960e77f0fedd79bf143c70afa71fbf36098dbe09cf74889e576b9db6781208f3180085fb58afa12818432ba23b0b5e37c4c5dd4447cf33a2c8f5ae49fbbc0d0ff10d086ecc5f8c74b1d4ef65837d2f7660cf069e205485acbc312bf8de838b9c57031c9ab4d29d769f5ac3a66f0d13cea3d883834deae3d635ce2a83b63ace242604982ce17d823fc1168d19bd42367a24957251f5fe3747ed14651309a89f2aa2025322d64e1651f1ebb406e4afe65f6492c02f612d67d23c34bae114ace1e57e09d44cff4bcddc01acab4206f397b7f7e29063f26195eef0d6511aa87526631d0f23266f9bfb579a95d979971924ef4b858237cac834c6c1c7ca1c6d24fea8bd05961ef6fb6ff474bc785ea93d3486232f46a06d88e6783def850019f21e2cf20eb12653bc482ea9604d101b278059cae00d99efaf2d4a76bf546d42b9c8e68a0379d1f91c87df0be8bb3c48d76df3825ed2d8f99eb9b677d6adb2b5d0b7328d0609541ba8807ed24379e9d2841b8c2ef51ed0e2af833d99e67fb01b0f40276a072de5abdba55dfd00987f0f65e9d41bd61ba4951aa296f45a1f682e2826cdd60e8c00bc26a84fe870a44a847b27fc092b15deb1ec058f9b40301ba64a47887109ba9724f952fd3125d804b4351906f8ac8b745c6d3655fd3d8a91cc4d38fc1e02c341ed23e91e8584eea12ad661beb32b9afa5b648ac052777f33d9002c70a80cd87d5d61560da056e029522a92c233f2283b38f2d1fbaf9b38b7c162c08f2d03ceb58424d5e58d17caa57bce752409d4756d7617afd9d753c474b0736b72690acf197e8bc8d8a7c137d5b3462dbc7f3b5831fda62fb03049efbd918da2c2f1016df029af3597948694414748ed9e7e7493d80526e05aa56a77e1b876d1da760e411966774f3b74056238f2fb5ce250fd74184c5d94b118305625b5436748aa0d33ceef9841491605e37a7c49f195f2f317128961f5a9e345190dd009a4ab20051c6d1aaca533060edb11ae4a11f629ab1e3adcb9b429fa18cd26e11d4709b40e4ce6d2bc71a52e2420432369a063f04f3247283ae1f8830cbb477e5659cf5f077d5f6f6a0d07d774cffb6f5746c91f2686311de46267a8f44200a23c938e9304119e2e5a5c757fb6ebb4313b8f879d8799ea67c27772e010121782edeecaf705c50dac0bae627e732e96e86674f146ca816649e0f52564caffdac6b6a41707093ebb9fcf25774b50a185bd45f492609dbbe772cad1dbef8cc93bf13178eaef09546696405f8f4f0e470e932e08c857ce10a9fc82ef760ea4f910d769d715b50fd9a822278d9567628e9c5480b71308745e922b76a94a29dd0c0349cba4051a0ad414e353de6350280ea233377daa5d9db05696f8cfdbf804b23c94bdd63b540c3d97ec29f7f0383b07d366947923e9f6bb8956cab686ca8b7791b6151ace23092b6c414c902ca0a628ee00106939cba354d8c02a76c72a203bf12611dc4e1c0be801001745b5b0e6a17aae7c6b44201ba4b3916edec7a1fb70cc4b79f0772f0d32856af6d625b650f5e3de4526b6407e7295fd0555c91e2a9ae44b4534050701cab27bdb49f392cac2bf35a9a7c27d60d91eaee9d83c69d301ddaabbb185d90b9aa66daebdce281c0843360f19e74310e8f9c2ed39eccf3b043b226c6e22d505ca4b1c22a9c05231cff788a23f12a3e715d363d96cd7eed57e6aebef6cadfd056c48fad099c0a464e1a491c0f5a369602d7e01ef88ca9594101d0e948ab4bb04e8e2d5e2369f37591ab49c9bf8068c47136a970d3d5581753feae53d31bdc90e3fb46fbd91e4e227be2ac606f536a1dcd493b9491082e2c46b11bc50c51fa006c701927e0d47bde61de4482c5189bd78716e1fc48869b5a291b5231a2dbbf10ef066768ee7a817bb743f4de89b52d1432ee6da15b4493b764a97314141103d0d691617ced074afae83c61432914703ec255033e5fb9b5eae14bdd1fd28df2e012694cf1c25a4be4b4fa91fcc2702685081e74502e9b77cbd54eddf88db50ca094d6f80f9896894c057b06ddd1fce5e7eff2aec24c29a7e5af904a79d9689de0edad099c87708d08cde65d13a429723fd7756a5be47ae8b87313b0af272c24b0223d8db323b04aebb4dabace8f93b52b4ca01b0abd0ca708f6be90bee9f013a09cf855d8a96b8f3a9a23ece256f28b5dcb9ed598d7127d8cd256699ff11e02f060ec3eb2d9f78cb8abb667d96ea473ae46845e211991da21bf3297ae46d41550e2058867373a9c22e22c3733c5728f6998fead312c168b0c3a00f9460fa36c70465020668d57b550ace30caeb46d07b5dd979a87bf22255a4fa997905ff642c062c16b46c9d47879cb049a88584145315621fa98a406c86b8dfc2e22cb28cde099cc80fd742c373f248cd0725102e7aebe962b7bfca3b27eb8c0ac00dbf7f580e0a87503838aca375ae19040d7ea6fae71ec37b7ecb8ffaf9b1beeed536ed730bb32c63f9de37e761b0a8e4e21e6c15643ce6631ebedf48f6bc3d0aca0a7498072287bbffea67d787f150a2f627a6807c2823bfafae65b069a43cd01edddfc90bbe1d9fda447727e5e7ab34ede539ae9e3fe130d5e4e5bfe6eb6260adc6737d00ad198019b38fd336b9a6bad879ac4623108af858a631af963bdf96c3683d830b88a1fc4efc45c2e4e96931201e883183f6168b1a8c90be29dc4ff5259d18200092c21a5b1250cb2c409f42fa6663f99e9fcd20df96a6123902ddd8c7f85d2d0af1b1ba43b9b768bba88dea0738b82d8ec7759bcef56930f6c367a7f0282b300e628566683fca934695858d51f77f80a047a5ebd8cbae3f2fdfe3f0f73da01f03c09eb59e7cd62b3f8d797f44c51d1305391b6054f5f7eda6ca723aa33a1d4406a0bd31d71ccd1d789f9172848582e5dec9d48198708d3e4865c2dd573ed9810ba57682569750b8778c0f3b92d105e40de40b3dbb57535a1ad7c22ac4737a90036f2c3308fcc3640bfbba533452bec2f0e0389baacd6f5e8097deed3ca5ee9d01b0e8c4d8a500a64b5b642df95e56d803c97295981068394d98454d98efe03201df5957c293a3aaf7c98f6c1ebf5b09c4a698050e0968e6e5ac10de2844f0f40e7870873a773c16a496ae2e4ab7bfccbc24e286c6f921a58b230622893552ed0333c0b8e43f66e8cc7e0fd15582b51d3e8336d06163b96b7f4bb427eb5ed9f705b3ecdbc45ff6250a39bd972df16f8f00ca07706c4683decc14a91aa2a03dfa0f70af012fa5b8183df57b7dc4928fa42f0cff401cce57e63ae7f56e52c41d20010888a25b614d1222a8a5c76bf5e23a87fde0cd716be387030f4aa56e5679980a0c9f42e680e94f43e741c1be3aadf27799922384e2ca410d46a58aa2b1b64700a62039d03c012a246f3ea49331cce7f0e456b6a384eb62a6f35044192b4c9f0b7420972a2d024c2901763c3269a3979fa6fe3ffa23552c6f83de45a6c3deec0ddd2f72c2642f7cda366b6c3d9fdfd419e730be2d35014119ce2ba2614499010b8cfb1d44794e33b3d985eb1103adc7bb9f2ea09d1dd498dc90fd42c416d49d02a71a4320da3cf03b005973a7586728322afd0469feb1857dbcb94c1e15402d0cae4f4e19e5c6ef18d0ad36e920a042d213eefeb9db67775a3abbcfe32c395608fe348fb346f10eeddd4663988c58a56f695745d652841719a843bfc877a99700e7d07325ae46a4509c1216383c865f325e3cd54fc2537b7368462023e956e6055d90fd4f0446da6fc36ab547cd614864d488fa828eb62335c4f63275871e260f65f6dbf3aeeee8f1cb3dcc9769625a2250eae429eeee2cf31a4cc80ed103ea0f60e0dc11cbc2487dc11f109e22dc3a1ce287d32281bb5391e4ed5695fc46c90596d5bc4c5f12535bba396c592d003108a1e477e929efba763f823b73d7e4860c810eaced498d7606913386eab047c2927cc369367ade474cf3a419abd07aa507d70b10c4722485a7e356e805c61d913be73919e2b968dc4a7290bb317b42710d1054c54017a81023046bd7cd1950c44e84a4218552c64fda9caead073e011506a1271b19f24f627e0f7e6b9f56c284c895158d6f21499b6ba15ef04d21644f0df10519550ef3ba450889977b6a47ee5d1982458d5f929bab4d232e179f85a80daa3cc966487c14ab572dfdd6779b7ed0b7892d75246be7a682051b0ecb6a8200b22cfab023d5c9b4a64c59dd9208ad1df1524b32d60a5202621827b326f3210d08dc82acc4cd5190982dc2c2991b37fe4c6be99d6545fb488df21cedc55b880702b17594ca217ee56aac9c17c68baf78af529c74460d641ce225e23503c2cb01c6c04ac3f8d1f2beb90e499cbb1b385a35860dc8567421f4d350da3b57f99b0dedbcaff2310221142f88f36e1bb4d51992f5cf9e5cb379933265b62b7c83e10c71ee116a5ecb6b1abbd6affde2fca22e3cc7aaf3df95e4ddd2993050df305c0cf73404b4d36d9d1f039b9a37097c94bb7d75a84bf045485f9591f50f44011c09 true +check_ring_signature 1bc1e34953b1a5c0fa5a876747ad2d10bcd4bffc346481bd7251adce6fbfe9ff 1dbbd67159a4d55467bda62994af30c2e32c330e8e23f3b87cfe4f39f86d981f 24 d7848287898f786f9f757daaf53b9a8685dd09da9973a4b9e478148833cc884b 419d66d4b1a68feb261543645dd893b4a1266a9fe680e3e5d47ab85bdfa42eff e2e6c11c5533d569757a9c4a8e5c3b1600936822adae48d0da2bef3e73a8fa89 ea384d93a185dd63a46911bef2d61bef8083c4028801a10999ca1849a6443809 73236a53ba24ef2312b57b93550cf852de97742f21b5fad9e015b70b8c0f8ad3 b62001595fbd462532c60fcfea26b6ebefcb2fe67572eba334dd92ce7fcae3d5 ba7ed48bb4dcf39054241c219555ae79b3f8859bcd385e30eef66b7f14818a25 9f025b02c57a912213945f72d14b4c93a0dc01ff4e23367506ab2ac6a4f7f252 c33fa2823b9872dc70c37300ceffe176805b55842897b71230cc4432825a8525 cb1ef070b1af3efcbc33925f9b5c8fa213a1c61b3b8e0c65477160b2ab6f17f7 617b6c4782faed81027b2168b03c0ae55c3f3e6801fce54ce47220cf82c40068 bb1483bbbf4b17549992e1061ecca913681ec6ea16ccb12d5cd7187d12511c76 18ec9d21b99a5a681c3cc9309fe954ae0ea5556a47fa99148475ec24395c6a34 49365d7fca7af2b6a2b74b31e867e4f10d8d94b580e08d93e560304042d4c2fc f6b3dbeaa1a8c043204ca265f56b7f04ebd9f19611ec9c02e60dbd2012b337e3 f21c483d88a9a3af793219a877bd0626ffde3e959e50a2e571d5b913fc5d6994 4256a991e9a94353758add618e55a752c25d56f5af80f70354ccb913031242a5 00b7952b1d040c4ddb465fa627564b0be0b56073e4f1fd1a740c463f53e07795 4c8f3034e5fc6cf756da1b3b232d1a6ec8d0dcea3b8ac53cf897b49a1f297417 e76770c539a9eba7158e822925644218aba3b9e175a34ec1fd195a75d62a95e7 f039a29b773501fc7be0b1b2231e79d2177b08c79d700967ce690255e2891fd5 d6ce39e46abe71bbd7eb7e45b0282b3ec5cbab753cd7f5cf458f3d43fe2aef60 d002a87d7d1d09bf994e735e2901551770e31a3d24ce9dec005a3091fdd19ce8 a37a44f7214027ab29fe7d197669d06e575d094bd4e86bf86304444559c4c1b3 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 false +check_ring_signature 922c1005f7c9608767ccde50356845d02011aa329ce895b801197ddace05b92c 84e95bad4f57a2c52ba540ecfc59abb91aa6a3fd9822033296fa35ba4edfa074 1 9467f44505ca04ee7b059497b21035bfb83b8dde89f4e1a618f9a99af6d6f5cf d65c57097f54db6f3f4c950c99f0e6c9aaa5f4c8dd3556db0856139303d19100a6b67bffd0d02a2ed2759a703684ce00b15e66bba3d8f2aedc6b216508c1ba09 true +check_ring_signature e23bfe56483ea7a3b4dddd34100a4e0c7d0c41599c2fb73e402d05d6f06b00ac 8a95ed61d724682793efbe92c223398aea04d360902902c8d42565e3ea10c6d8 1 25e4259548c4033d66124ca8bc3ffd22df8b691c574cddbe6162266eb4d4bb52 12882ad8dad52763bd7a256946b3b8ce4b5be1669ae43fa4e8915092c9e76a9694e1291c43a406ad1d70f0dacbb4a5e811d0d5c71f7b9100274f30b262c77222 false +check_ring_signature 74fc7ced9c49e39a978630fe09c8ba103207be81e1f5436998693879bb4fdf7a 4c1797ea2172c2e77dc1a7407dba97f8c59f519e6c98b27398ff1ab0304cb5db 2 ecdb7a473c54a65c05ce26155a09ceb2dc5d9418b7795ee8d81b5a6ef6c71a21 da95433c5754feff66112d1839c492a47eaaa16954c59483c33d8dc9a83ffef0 4f0db9ef9be2d1e16ae3f555e80978b93892a7657312631080aee4835a9ece03b2c399041b142fd929c80156e1784aa3511df49485c7a55915fafbafbc28983653bde6075697fac9e21a7cc916f89a2d08f1e4e6de9f8849df8774c10fb62270d931e77ef29869b0f3ed03e9479424789f45fa35bc47611705097972b4ab42a2 false +check_ring_signature 8cd5cc3d0cf4b2ee24e61036d43d2ca81e7b11cce60fc503ec9ba371361393a2 6b3415c30ceccf0a75a52b70b5a8e280f8bfaab6ebcc45f25cf877706fe3e561 5 6e1673c408e012893487a8b6ce9fa6b610c4dfd068eb45182964dec2559930fa a6868ae9740e66d9a9e959b18f9876096dd0c46ce5cfa949e37d49252a361f35 1787a7fa974d42a1bd7b4135f5ba6745947eaf1273b449d6e2b6fa15099c89d0 794745e63c881f4797ca7c4017e8214419a3a424988cb2f1b66648a3b638e57e 198497f75a8123cf4b6975696e8d8b4aed43823e18097a7d064397c6dd7b0d70 a3e4d6663f5d9f43c4d21acead4f32f7a6a52d697e2ebe62935ef9efd6689e09777d208f900fa053b3a1cbd03562b41e58315e7c33aa58d22e4b8a22eb68b70d0022d14e033ed8305c112723fcb61dcce26466136f488557fddc8cc0be711206d1a6570e9fe1b21d11f826a9b97c876593eaac58a1cf46bef08e76f3280c7707ee5674bb21aac36945e360440b5595f0b6f922e4e14c28776dc26b93d29ff202ef1db1df45cec0ebf3391fc40458a33398ebf96dbea4d54f6418a10ae261ac0c015df754b8cdd6c61314ad6f658a7f00befde96d2a071b0e7d59d950052ac10bc36fdb280892ba24679da65907d42d1fc4c354e0d6d1df285e5de2d7541a890f40aac5839d4cc057815264242081be67efa14dda156d0e6d90ba3b8befab9c019797f614c07f0c2e5db6dadd987a000c171686b9e134a9b0b68fc447d805bc09 true +check_ring_signature 2b96105d783472f03274f060a7762f45a962f44d234022dc73928e9a4c6017b2 7a92b7a4998e446c3e8e2e97d406aed5c06c732de2986219614bdae91651ee95 1 5fd6bc5c24414c29b21b01591e6ac03f8b57ab9c0f2bf08f351c2a3086451528 5a04836171183ca9c59c64c89d4136ca9be321bde2c7dc352d9e90abdf5b13aecdb22ba12c174aac6935afc792cff65ca5f991239110b38ad0b57aa0c5249f0e false +check_ring_signature 8427e7179050bc38d5c25e68f70c2c98990042388e326d6bebd5674ca8d34840 5680400f955da51e5b6c09685f18bcceda482c34b4b17b375b7340845ac486b9 7 250a755ae6c51559860d77e7e029e7619f3216a657cb2bc0f7e4faca8e890b51 649be8fc8a9a5bb7d159ebdd2457e7ab16f7c5d82d91dc276fdc802b761a4e53 852a270ead33900547349658566b553356e17230ecd94c8cfa79a8244b4ab271 11ff283f14fcbd714ca4f453dc361cc77ce3e639f9ee206b1c923548e2feaefc fa73655a834b064343b4f2b1ef9a3a8b853f525d7b9ab3a3f952363652954655 c2c5804558610f4b5b1d50389cededf481c7c7f39b009b1535111e71963fe702 32f44c3e26156a75e661d9e707b7cdccb95ac714a5b2017d2c707827be504dcb eacd6cf828cf27cd1d8da461c3c9630a0a696b1ea92dde4cc22423b68420790201a7fa68060ad3ad8ed81e554bc00ce7f641ff0963576018ab7834bd4935a20de3b18e0abe94e77cb6aa0e67e204988beb3275947f9bf99db589fd62ca3b410cf0fc6e297e228ca15f19fb4aacb2a2ffcb4ec7f8ebdb1b26e156c6b0a191890aeaeb35592d4ef0bdf9322e6b0dc3c0edd29f447d22378809a14b88b9ceab0d029e48fc1fae0e932c86c4c0d6ae45669a8daf3426adb70850574206f041497f0b485af0906bc0cf415fff05b0d0c438edba594fb66f0c0de0843dbccd81432d03743c9bb9cbdd4055b6f3ad584ef2330bacd73406961a76fa8cf1a9ace4d0d30c181fd164b105be70d161dc08dc0b8735d23e3eda3e10b946d3547b555578cf0b5619879e79d179d3710ce8cd9c1e32a0a363670b362a78a453def7ab21e37d0eb58a7cc7f03a6e0ea9df9b75cb1848e405e81fcf38d18eeb6553f62124e4ce0b0762b25c6ba5befebad857194696508e3829ed5e8e449284d795a3d05100690bc72126a83afcffd33a9e7a9d3289f6218b9680682d0c2855ab7015f3998fba0295a05f2f8c255ff420c5e13b427ac836507edcd1ac34ebd59515d783450c500f true +check_ring_signature f3d2b5b25d663325acca133163bbf3219f1b22fea6bd6d6e3194db8bc30dc6fa 448071ee63780f0fcfe35245353e4fd28f5c5362d9a5f3d74e5bd6685986729f 6 fb706555f8358ac3db60d9a52eb4981f91d28cc4d518c1a5c988ce94c7051379 e07dbe16cee565a221af2353c4761cdb7c7fab5880372b0e46d49ab4842d3b4c 05db3f4b53f17fe0525e2b5002664d9b0d5680c10146640cbbf23a118d6d88fb a446a6e907f653e0db5888927971d0dfd5c854d2b04f02367e18b02378271b11 72ce0ff9a80faaf2ea826cfe8244cc2d345a7c887143e481ffe826b8630b6f93 d17c0b9ba4aeb04ddb8288222a0d5d22abe327981786f790cf8b9ee8831090a7 8a11ee60dd8470e1bd447f472b60723d8a30ac8a84fb4bd98580b2f3ddfc32027193f368c87e02deb9219eb50e0a9b2d9d43bab27c14ac4be23640a1fca01a0dd12337332fdfe9f3aef0235281614f3e94cf7902486b8a5b76444e9a56e21a09beab12ff902fdc05b16a2ad417d92711107bcf7a554cf82fa069e9432874680dce00e8a862e417b2efaa66cb9e4693e00b7d6cd1c452fc71630473799fdc7603080d006b562aafe0e75e456e6e09f1a655dcc40e296f0f3083c5f58c75e9dd03c61115f05d75c65e04f2d02c6232c72c99a32e9f8c851b23219e2dbcdbd6190de6c9ae374530c0f268758611fffac7dbb8f16d8c71a0da950ae12603d942b808146f9131049a75364f45cc606ab4d6882a137999c163312c87fb3d8e78ef3406b97dbd90bbdd20a8025d4ba438491ff0923da5055b7c3ee446b7ddac341f350056efeaa3f706fa2ac8a6d02d5f2a4cd5644af7f9a48a699801469d33601667081fa0971b1b6dc3c86d539197a531a76ebe611fc967d26067f2c2f0d879ef0309 false +check_ring_signature 07a23b78f73ca487ec5ab0f4d7725d7ffb547543ae4f96e30df871c2241489ca 2073d5a5ccb03402ded68c31d3de658f7c5be2265bec656a12212c83e2499a75 9 ce3fe390c5309c0aa6c0a1e4dc29ef63fdf55ad2fef737b775bae9857c666966 08088bfe1f076131d82458ef08e0a6d8003d26d824360033895e62409fceadba 4faffacfacc069e09f80a0249daf97a40b53a64ab870c62dfd08998d382dba52 386e435138fba8c063966d8308927f8c8788782a3a263500133325c9c82d38a3 efd955c96135d72fee34c765998cf714f37365af8f77cae145ba5d126f1fe914 60dbea373e81c0276c4fbb83ca1fcbb647e2fa11a8bbc62c8e56d4d147b39bd5 1495004110d8e2fe1774ba6eb9492b1bbc54f674ed2082401cd6eab71ad9dc40 7a2af9f6dad76479c5f3345ffd250f55b234682b4fd51d3ee9ae8da2e5a35cb2 02548abda0688fc63cc485b956fd4303bf0dfc43a581e01c59c62243461ea348 e784e4e19099667803c6f08fd0877e85937bec50ab02f75b6f2e3dd61876b40510bf63faa2346e3b35b0ade96bfef145dd17b92ebdb1cf96899e10e3442aaf0d782eafc8be306390ffcda93025f6832a2d4c4e4d1c2b56add53550b3b512b71af959bc1b5902a7b628eae1d16d242c099fb4ce33a4bee12af49a41aab958940910b0d0ef596b753688f228a7184e38e7df8644cbecfa658d721736ed2882e20f9a2fb61818c0060b3fd4b2ced7984bb17b10381efde2330bbb1de208655e080cd33d9e5d5d853a8875623195ed30e2c2e475ebe4ac97e3c5216520b0a201a608b6c6013266ab0e63a461dae171af4c3a14a5fa8c4c33ca25b84540e32efcf302b18e610545ff35d45dae4116ba6d51ac9125cdb7f681739744237827e768bb0487b6b0a1d9e8d5ce809b9e17a6c32df9ef77a26af987b2348c748cba73e917034e21609b0d92a5b7106d39c8de2f057013bd347be67e553e608cbb70683f2e04ca7ed84ed7f4c671efac5deb3db17498f23170cc8deb4596d1ea958caa7e4e06204833104aed36ee0b7808dba1194cc374c193e4e926832ac171d03f3abe6607803d6b33a1350ec428afc88977eb411505bcb54113da91f63fdd2bb85a08140cbc040fadb23ba1c92fd3bad8c4930f36d37403f8e9d4b87bf3636ccffc53c30cc4eeb9945214f9d8e288edbfa1d7546baae6860f9f56af7d79f9349c104579064d404a3d7a893d64fbcca32c5d4e6158d92cd87c8a78bb3a61eb55ec92a7ee0aaabe59d33af5534ae258f48bca9d5459e0708ebf9289d9bb22acb540b0f39003 false +check_ring_signature 0e6194f7b3ec1594e6b727b990c6bf65a2b1eb1a9b73ea00d18a709ffdee1276 f931b871addf92f407f087ae176804734ba35fd65086f6c3e07d9d7b001be265 51 8daf0c2e434171ef0e31f1fd17307a30690639fc7fef1a85a9a7858868924c1d 93edf23dcd46477698f2e4795ab9e4e75ef04c8ca561670c22d0a379f7cc9d12 5fb23ddfd7bc6db6798d0dfadc6accc8c7fd75adb090ecb6bad2021bc3bac5da d093463f76e271597f6cddc74b5685b0c4d4ab6b6f6bae4b0217c7097ced9bb6 1504b6cab3b2454a066fe9462be135eda844480da85ad3baf67fbf39679cdbf0 e812fa7c7f0b6e11dd0d87fd88767a768f9e89f2c54396a9a53d443d0edafdcf 6570828a5e056a4e035b1042b80007a872c71545ea225feb982d24eea14373f0 a3adddfa513dca877eca62e12255c981b148a605c998458c6786aba6aaf1207a 43f3fb57f9a0c90200a940217893685296537f34041fd9586586937386f8d33d 9ff696ea156a4468e1d0d32590fcc865f491d821254594535c1694d7eb0102c2 3f0245304a5047ce42fb0b36544220d7df36c919aa2321bf39e83fa71c4de21c 01c527e626c1b5c928058d7ea772cda93833ba111792da212a5eae0041ccae51 61a79b26403f88acf0d4a7bf86efff4bd9f32e05e9a900e7d890ce36ab8abbef be302d5d4b83cd447536c08dfe66a32fab021889d9eb7a8621e59a6e3756b14a 693a9d20a1d12828a94d01a2bdc856f3499745e4c5830cda407962d2b6953784 62438ad0ca1dc718def66c97d8a4b2a1c4e61322c7cb8c3b904177cc8d8fbcaf 88dbaf2eab9896bac05f93c953c548de45c032d40b7c7e452c17ac73606b942b 894905861e3c952ab0e350b12900b454b3870ce3e9b590f94203ce2bbc41f944 cbf933f67076f66793bf06f2a5008bd01b36b6aa094483269da52bbba7465580 557046df81dbcfe18c65e1364448c8d94c710cd1fbf8a3c10550254d97afcdf7 7b24c0ee3a7836c1bef02956b81358d8f698da40f0ccd706daf3038cb0b28793 28ddf7553a328fe5ef8c8a6abd52ba6d725240f1511665884cb68c96d46d92d5 ffd267319c8ed9e424371ef74e5301102997c26265a2044bbbe05ee291f5bcc9 d467502be7c3753d9e4d2a147d3a40d1d817a865184030870bf97ef6f1610da7 b1ec5f6565cc19a6d015696594ada55b5fbe82108fcec0d54fb11b05bfd37408 19e7e65cdd957ab0d25dfc9e4e1449b1d4283d2561754fc147adb51e057dc7ba c5d4274eef9f5d92e7a8dda59de38f5728d60350d8e98871968765925d18ed09 a44814c8f2912d13c09242b0b75dad90a6357b844e021dc96668c45e311b64b3 cd88baa50640c7409a98921e0ad1e7f2496b39a3b07544eeef2455fc5018b17e 9ab6f34f081bccc8d8b29513851a402759c96b8d95d836db977e24e595deb2fa 56123960591257a70a334628d9868505176533debe06cdfc24f906ec8a997efd a37b03d5446abb9a3fb7aee94d6740d85f984fb363a9e78a9d363d5882cd2823 bd9607c5e6c167f5eb6a289be620592c7e850590393787d01acd958fd717b0c2 d0d69b420c93d9b1b8eee6796db2c7cc2110dc78b624396e144c135fe69c812d b6a2ee98807a00bcff0fa5403102c9a628948d3478234cdde85e5effbefcf204 e183a5d8daabdea01f7cd7f0960b75566aec78874cc933f5acc3dce0512ab335 ea7f86e49af2a4883e11b3362127dfdb14f0f517170ddb4338a5a38d2c92566a 4ea9d24ebb852962e745d4ec30679bed40f581d1ccf6825e80ddb38759025ac7 d0c887ff472e65d7fcb502988dfb0c919c8d23c2897d49b8c8de90d725604ea8 0177735a5271e254705979ef38a0737897f608aa144f4c4ed97e220dcb32f1af fc49aac2eaf95de87156c0348381d78d9b468a1da3eae6cc25bb398563b0bdad 84a98d5f20b608d31af41925052dfd378f0252e1bf7c13cf9b773e0cd4b95a52 8fd6df156a95abf7ca37fa1d65e820b56f2498c9ada0a4027f0dbc285b9a9b86 f7bcadf3751cdc85db850619a857288d1291c2f403732d79daec6eb774fd26cb c87e4373dadc7a65f53df413d22b3370f7a8c47a929ded626f3f71f3b249eb4d 02398630b92a7f782dd0153d39a56123ec7ea8d5a0fde77aebd302e641de2a54 f655dea86af87ed4d93ea10c2ffd5e52aff83a6fb5fab65a1ab67a02cfae6523 990747d3687fcc37ba0fe4845f9b247ebddd0d0a5a61f2637bb498f0b05e9fb3 38050abbc28c5847708f0142d8e89d44dad6d0ee8bd60b5771bd03d590a7ff85 867b6cdc08dbecaf1b6f9ee2add2d2c9dfe18474a805a028533b619f52abf6b3 0bda8ca264a6747f18195bbf56fafe96c9a0c8e6557f1b17c50eec71ae52fb50 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 false diff --git a/tests/cryptolib.pl b/tests/cryptolib.pl new file mode 100644 index 000000000..170a03732 --- /dev/null +++ b/tests/cryptolib.pl @@ -0,0 +1,231 @@ +use Math::BigInt only => 'GMP'; +use Digest::Keccak qw(keccak_256); + +my $p = Math::BigInt->new(2)->bpow(255)->bsub(19); #F_p +my $l = Math::BigInt->new(2)->bpow(252)->badd('27742317777372353535851937790883648493'); +#my $d = Math::BigInt->new(486662); #motgomery: y^2 = x^3 + 486662x^2 + x +my $d = Math::BigInt->new(-121665)->bmul(minv(121666))->bmod($p); #twisted edwards: -x^2 +y^2 = 1 + d*x^2*y^2 +my $x0 = Math::BigInt->new('15112221349535400772501151409588531511454012693041857206046113283949847762202'); +my $y0 = Math::BigInt->new('46316835694926478169428394003475163141307993866256225615783033603165251855960'); #y0 = 4/5 +my $m = Math::BigInt->new('7237005577332262213973186563042994240829374041602535252466099000494570602493'); #p = 8m+5 +my $ps = $p->copy()->bdec->bdiv(4); +my $pl = $p->copy()->bdec->bdiv(2); +my $ii = Math::BigInt->new(2)->bmodpow($ps,$p); #sqrt(-1) + +sub ec_rec { + my $y = Math::BigInt->new($_[0]); + my $xx = $y->copy()->bpow(2)->bdec()->bmul(minv($y->copy()->bpow(2)->bmul($d)->binc))->bmod($p); + return 0 if !($xx->copy()->bmodpow($pl,$p)->binc->bmod($p)); + my $p2 = $p->copy()->badd(3)->bdiv(8); + my $x = $xx->copy()->bmodpow($p2, $p); + if ($x->copy()->bpow(2)->bsub($xx)->bmod($p)) {$x->bmul($ii)->bmod($p)} + if ($x->is_odd) {$x = $p->copy()->bsub($x)}; + return $x; + } + +sub h2i { + return Math::BigInt->new('0x'.(unpack 'H*', (reverse pack 'H*', shift)));; + } + +sub i2h { + my $t = substr(Math::BigInt->new(shift)->as_hex(),2,64); + if (length($t)%2 == 1) {$t = '0'.$t} + return unpack 'H*', (reverse pack 'H*', $t); + } + + +sub random { + return keccak_256(rand(2**20)); + #return keccak_256(3); #I swear that's random! + } + +sub ec_pack { + my $x = Math::BigInt->new($_[0]); + my $y = Math::BigInt->new($_[1]); + my $or = Math::BigInt->new(2)->bpow(255); + $y |= $or if ($x->is_odd()); + return unpack 'H*', (reverse pack 'H*', substr($y->as_hex(),2,64)); + } + +sub ec_unpack { + my $y = Math::BigInt->new(h2i(shift)); + my $b = $y >> 255; + my $and = Math::BigInt->new(2)->bpow(255)->bdec(); + $y &= $and; + my $x = ec_rec($y); + return (0,0) if $x==0; + ($b==0) || ($x = $p->copy()->bsub($x)); + return ($x,$y); + } + + +sub minv { + my $x = Math::BigInt->new(shift); + $x->bmodpow($p-2,$p); + return $x; + } + + +sub ec_doub { + my $x = Math::BigInt->new($_[0]); + my $y = Math::BigInt->new($_[1]); + + #$t = $x->copy()->bpow(2)->bmul(3)->badd($x->copy()->bmul($d)->bmul(2))->binc()->bmul(minv($y->copy()->bmul(2))); #montgomery + #$x2 = $t->copy()->bpow(2)->bsub($d)->bsub($x)->bsub($x)->bmod($p); #montgomery + #$y2 = $x->copy()->bmul(2)->badd($x)->badd($d)->bmul($t)->bsub($t->copy()->bpow(3))->bsub($y)->bmod($p); #montgomery + $t = $x->copy()->bmul($x)->bmul($y)->bmul($y)->bmul($d)->bmod($p); + $x3 = $x->copy()->bmul($y)->bmul(2)->bmul(minv($t+1))->bmod($p); + $y3 = $y->copy()->bpow(2)->badd($x->copy()->bpow(2))->bmul(minv(1-$t))->bmod($p); + return ($x3,$y3); + } +sub ec_add { + my $x1 = Math::BigInt->new($_[0]); + my $y1 = Math::BigInt->new($_[1]); + my $x2 = Math::BigInt->new($_[2]); + my $y2 = Math::BigInt->new($_[3]); + + #$t = $y2->copy()->bsub($y1)->bmul(minv($x2->copy()->bsub($x1))); + #$x3 = $t->copy()->bpow(2)->bsub($d)->bsub($x1)->bsub($x2)->bmod($p); + #$y3 = $x1->copy()->bmul(2)->badd($x2)->badd($d)->bmul($t)->bsub($t->copy()->bpow(3))->bsub($y1)->bmod($p); + $t = $x1->copy->bmul($x2)->bmul($y1)->bmul($y2)->bmul($d)->bmod($p); + $x3 = $x1->copy()->bmul($y2)->badd($y1->copy()->bmul($x2))->bmul(minv($t+1))->bmod($p); + $y3 = $y1->copy()->bmul($y2)->badd($x1->copy()->bmul($x2))->bmul(minv(1-$t))->bmod($p); + + + return ($x3,$y3); + } + +sub ec_mul { + my $n = Math::BigInt->new($_[0]); + my $x = Math::BigInt->new($_[1]); + my $y = Math::BigInt->new($_[2]); + + if ($n->is_one()) { + return ($x,$y); + last; + } + elsif ($n->is_even()) { + $n->bdiv(2); + return ec_mul($n,&ec_doub($x,$y)); + } + else { + $n->bdec()->bdiv(2); + return ec_add($x,$y,ec_mul($n,&ec_doub($x,$y))); + } + } + +sub pkeygen { + my $key = Math::BigInt->new(h2i(shift))->bmod($l); + return ec_pack(ec_mul($key,$x0,$y0)); + } + +sub ec_hash { + my $h = pack 'H*', shift; + my $h = Math::BigInt->new('0x'.(unpack 'H*', reverse keccak_256($h))); + my ($x,$y) = (0,0); + while ($x == 0) { + ($x,$y) = ec_unpack(i2h($h)); + $h->binc(); + } + return ec_mul(8,$x,$y); + } + +sub im_gen { + my ($x,$y) = ec_hash(shift); + my $k = Math::BigInt->new(h2i(shift))->bmod($l); + return ec_pack(ec_mul($k,$x,$y)); + } + + +sub sign { + my ($m,$sec_key) = @_; + my $sec_key = Math::BigInt->new(h2i($sec_key)); + my ($x,$y) = ec_mul($sec_key,$x0,$y0); + my $k = Math::BigInt->new('0x'.(unpack 'H*', random()))->bmod($l); + #my $k = Math::BigInt->new('5267557024171956683337957876581522196748200715787296882078421399301151717969'); + my $e = unpack 'H*', keccak_256($m.(pack 'H*', ec_pack(ec_mul($k,$x0,$y0)))); + my $s = i2h(Math::BigInt->new(h2i($e))->bmul($sec_key)->bneg()->badd($k)->bmod($l)); + $e = i2h(Math::BigInt->new(h2i($e))->bmod($l)); + return ($s,$e); + } + +sub check_s { + my ($m,$pt,$s1,$e1) = @_; + my ($x,$y) = ec_unpack($pt); + my $s = Math::BigInt->new(h2i($s1))->bmod($l); + my $e = Math::BigInt->new(h2i($e1))->bmod($l); + my ($x1,$y1) = ec_add(ec_mul($s,$x0,$y0),ec_mul($e,$x,$y)); + $m = $m.(pack 'H*', ec_pack($x1,$y1)); + my $ev = Math::BigInt->new(h2i(unpack 'H*', keccak_256($m)))->bmod($l); + + return !$ev->bcmp($e); + } + +sub r_sign { + my ($m,$image,$sec_key,$index,@pkeys) = @_; + my ($ix,$iy) = ec_unpack($image); + my $n = @pkeys; + my $data = $m; + my $w = $a = $b = $hx = $hy = $px = $py = 0; + my @zc = (); + my $sum = Math::BigInt->new(); + #print "begin signing ($n keys)\n"; + for $i (0..$n-1) { + ($hx, $hy) = ec_hash(@pkeys[$i]); + ($px,$py) = ec_unpack(@pkeys[$i]); + if ($i == $index) { + $w = Math::BigInt->new('0x'.(unpack 'H*', random()))->bmod($l); + $a = pack 'H*', ec_pack(ec_mul($w,$x0,$y0)); + $b = pack 'H*', ec_pack(ec_mul($w,$hx,$hy)); + push @zc,0,0; + } + else { + $z = Math::BigInt->new('0x'.(unpack 'H*', random()))->bmod($l); + $c = Math::BigInt->new('0x'.(unpack 'H*', random()))->bmod($l); + $sum->badd($c); + $a = pack 'H*', ec_pack(ec_add(ec_mul($z,$x0,$y0),ec_mul($c,$px,$py))); + $b = pack 'H*', ec_pack(ec_add(ec_mul($z,$hx,$hy),ec_mul($c,$ix,$iy))); + push @zc,i2h($z),i2h($c); + } + $data = $data.$a.$b; + #print "key number $i done\n"; + } + #print "generating ringsig..\n"; + my $h = unpack 'H*', keccak_256($data); + my $cy = Math::BigInt->new(h2i($h))->bsub($sum)->bmod($l); + my $zy = $cy->copy()->bmul(h2i($sec_key))->bneg()->badd($w)->bmod($l); + @zc[2*$index] = i2h($zy); + @zc[2*$index+1] = i2h($cy); + return @zc; + } + +sub r_check_s { + my ($m,$image,@zc) = @_; + my $n = @zc/3; + for $j (0..$n-1) { + @pkeys[$j] = shift @zc; + } + my $data = $m; + my ($ix,$iy) = ec_unpack($image); + my $a = $b = $hx = $hy = $px = $py = $z = $c = 0; + my $sum = Math::BigInt->new(); + #print "\nBegin checking ($n keys)\n"; + for $i (0..$n-1) { + $z = Math::BigInt->new(h2i(shift @zc))->bmod($l); + $c = Math::BigInt->new(h2i(shift @zc))->bmod($l); + $sum->badd($c)->bmod($l); + ($px,$py) = ec_unpack(@pkeys[$i]); + $a = pack 'H*', ec_pack(ec_add(ec_mul($z,$x0,$y0),ec_mul($c,$px,$py))); + ($hx, $hy) = ec_hash(@pkeys[$i]); + $b = pack 'H*', ec_pack(ec_add(ec_mul($z,$hx,$hy),ec_mul($c,$ix,$iy))); + $data = $data.$a.$b; + #print "key number $i done\n"; + } + my $h = Math::BigInt->new(h2i(unpack 'H*', keccak_256($data)))->bmod($l); + + return !$h->bcmp($sum); + } + + + + diff --git a/tests/cryptotest.pl b/tests/cryptotest.pl new file mode 100644 index 000000000..c075e9671 --- /dev/null +++ b/tests/cryptotest.pl @@ -0,0 +1,28 @@ +require 'cryptolib.pl'; + +$key = 'fc7557a2595788aea7205ffd801b8a157dc9c698adb2c598ba543eaa67cb700e'; +$pt = '664422cf6f4100dc6b3298e41ca53b173a98918fc9cb50fc2d590b7d1285f4ab'; +$m = keccak_256(pack 'H*', 'c8fedd380dbae40ffb52'); + + +$s = '26a9589121e569ee0ac2e8ac7a7ea331d348f9a0fa8d28926d27c7506759e406'; +$e = '780be966ad89ba526cc7adf4b771adbdaa0568038e6a30e776839a81e57dee0c'; + +print " self SIG -- OK\n" if check_s($m,$pt,sign($m,$key)); +print " test SIG -- OK\n" if check_s($m,$pt,$s,$e); + +@aa = r_sign($m,im_gen($pt,$key),$key,1,ec_pack(ec_mul(111,$x0,$y0)),$pt,ec_pack(ec_mul(47,$x0,$y0))); +print " self RSIG -- OK\n" if r_check_s($m,im_gen($pt,$key),ec_pack(ec_mul(111,$x0,$y0)),$pt,ec_pack(ec_mul(47,$x0,$y0)),@aa); + +$k1 = '6a7a81a52ba91b9785b484d761bfb3ad9a473c147e17b7fbbc3992e8c97108d7'; +$sk1 = '3ce3eb784016a53fa915053d24f55dc8fbc7af3fabc915701adb67e61a25f50f'; +$k2 = '0f3fe9c20b24a11bf4d6d1acd335c6a80543f1f0380590d7323caf1390c78e88'; +$sk2 = '4967a2bfa0c8a0afc0df238d068b6c7182577afd0781c9d3720bb7a6cf71630c'; #main key +$m = keccak_256(pack 'H*', '5020c4d530b6ec6cb4d9'); +@sig = ('b7903a4a3aca7253bb98be335014bebb33683aedca0bc46e288e229ecfccbe0e', + '2c15e4de88ff38d655e2deef0e06a7ca4541a7754c37e7b20875cce791754508', + '6acae497177b2eeaf658b813eaf50e1e06f3d1107694beff9b520c65ee624f05', + '026c8d9801f7330aa82426adf5bacf4546d83df0cc12321ede90df8c0d9aa800'); + + +print " test RSIG -- OK" if r_check_s($m,im_gen($k2,$sk2),$k1, $k2, @sig); diff --git a/tests/daemon_tests/CMakeLists.txt b/tests/daemon_tests/CMakeLists.txt new file mode 100644 index 000000000..68ca3a87e --- /dev/null +++ b/tests/daemon_tests/CMakeLists.txt @@ -0,0 +1,5 @@ +add_executable(transfers transfers.cpp) +target_link_libraries(transfers useragent rpc cryptonote_core crypto common epee gtest_main ${Boost_LIBRARIES}) + +file(MAKE_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/test_transfers) +add_custom_target(test_transfers COMMAND transfers WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/test_transfers) diff --git a/tests/daemon_tests/transfers.cpp b/tests/daemon_tests/transfers.cpp new file mode 100644 index 000000000..23b8b8335 --- /dev/null +++ b/tests/daemon_tests/transfers.cpp @@ -0,0 +1,77 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include "gtest/gtest.h" +#include <sstream> +#include "wallet/wallet.h" +#include "rpc/core_rpc_server.h" +#include "cryptonote_core/account.h" +#include "net/http_client_abstract_invoke.h" +using namespace std; +using namespace epee::misc_utils; +using namespace cryptonote; + +string daemon_address = "http://localhost:23400"; + +#define ACCS 5 + +TEST(Transfers, Transfers) +{ + log_space::get_set_log_detalisation_level(true, LOG_LEVEL_3); + log_space::log_singletone::add_logger(LOGGER_CONSOLE, NULL, NULL); + + cout << "TESTING: transfers" << endl; + + net_utils::http::http_simple_client http_client; + wallet miner, accs[100], receiver; + miner.generate(); + ASSERT_TRUE(miner.init()); + ASSERT_TRUE(miner.store("miner.b2wallet")); + cout << "miner: " << miner.get_account().get_public_address_str() << endl; + + for (int i = 0; i < ACCS; i++) { + ostringstream s; + s << "acc" << setw(2) << setfill('0') << i << ".b2wallet"; + accs[i].generate(); + assert(accs[i].init()); + assert(accs[i].store(s.str())); + } + receiver.generate(); + assert(receiver.init()); + receiver.store("receiver.b2wallet"); + + { + COMMAND_RPC_START_MINE::request req; + req.miner_address = miner.get_account().get_public_address_str(); + req.threads_count = 1; + COMMAND_RPC_START_MINE::response res; + bool r = net_utils::http::invoke_http_json_remote_command(daemon_address + "/start_mine", req, res, http_client); + ASSERT_TRUE(r); + } + + string s; + //getline(cin, s); + sleep_no_w(1000); + ASSERT_TRUE(miner.refresh()); + cout << "miner balance: " << miner.balance() << endl; + + vector<pair<account_public_address, uint64_t>> d_accs; + for (int i = 0; i < ACCS; i++) + d_accs.push_back(make_pair(accs[i].get_account().get_keys().m_account_address, 1)); + ASSERT_TRUE(miner.transfer(d_accs)); + + //getline(cin, s); + sleep_no_w(1000); + for (int i = 0; i < ACCS; i++) { + ASSERT_TRUE(accs[i].refresh()); + ASSERT_TRUE(accs[i].transfer(receiver.get_account().get_keys().m_account_address, 1)); + } + + //getline(cin, s); + cout << "wait for block" << endl; + sleep_no_w(10000); + receiver.refresh(); + ASSERT_TRUE(receiver.balance() == ACCS); + cout << "OK" << endl; +} diff --git a/tests/data/account-002bee2f8e16f5de4db0d3b8ce9227c8c0b7f9688348b028e022cb43f210968b40a69cdc8531fd4a2e7c9e144eec48bb477733d70ce5f9b85338a07cb10b849ad8fb b/tests/data/account-002bee2f8e16f5de4db0d3b8ce9227c8c0b7f9688348b028e022cb43f210968b40a69cdc8531fd4a2e7c9e144eec48bb477733d70ce5f9b85338a07cb10b849ad8fb Binary files differnew file mode 100644 index 000000000..11927ecca --- /dev/null +++ b/tests/data/account-002bee2f8e16f5de4db0d3b8ce9227c8c0b7f9688348b028e022cb43f210968b40a69cdc8531fd4a2e7c9e144eec48bb477733d70ce5f9b85338a07cb10b849ad8fb diff --git a/tests/data/account-007af2d7c5ffd8f69005debae820207820805e28c7d7a16714591143f56fb51e2b91ad0c1a535567e6292b321773df5e5aaace00fe767c4f09de452838575357ca9f b/tests/data/account-007af2d7c5ffd8f69005debae820207820805e28c7d7a16714591143f56fb51e2b91ad0c1a535567e6292b321773df5e5aaace00fe767c4f09de452838575357ca9f Binary files differnew file mode 100644 index 000000000..12f4a0f10 --- /dev/null +++ b/tests/data/account-007af2d7c5ffd8f69005debae820207820805e28c7d7a16714591143f56fb51e2b91ad0c1a535567e6292b321773df5e5aaace00fe767c4f09de452838575357ca9f diff --git a/tests/data/account-009b82d66dfaaba55a581913fa09d6c5bebe179cd73731781265c96e9e630dcd27fd5d20e7f1d0fa42619de9ca8fe4c0659f6959b2bebb15079cdaed07a442a78486 b/tests/data/account-009b82d66dfaaba55a581913fa09d6c5bebe179cd73731781265c96e9e630dcd27fd5d20e7f1d0fa42619de9ca8fe4c0659f6959b2bebb15079cdaed07a442a78486 Binary files differnew file mode 100644 index 000000000..bee40fa54 --- /dev/null +++ b/tests/data/account-009b82d66dfaaba55a581913fa09d6c5bebe179cd73731781265c96e9e630dcd27fd5d20e7f1d0fa42619de9ca8fe4c0659f6959b2bebb15079cdaed07a442a78486 diff --git a/tests/data/account-00aff84db50d6a54dd56051379f6c336fdd330d1cb11e7523bbf71f30b1ae760fa47ace8679b6486f79429980fd2331715a631f5729db284eb1fc6f108aeb7a7f4fe b/tests/data/account-00aff84db50d6a54dd56051379f6c336fdd330d1cb11e7523bbf71f30b1ae760fa47ace8679b6486f79429980fd2331715a631f5729db284eb1fc6f108aeb7a7f4fe Binary files differnew file mode 100644 index 000000000..54122832c --- /dev/null +++ b/tests/data/account-00aff84db50d6a54dd56051379f6c336fdd330d1cb11e7523bbf71f30b1ae760fa47ace8679b6486f79429980fd2331715a631f5729db284eb1fc6f108aeb7a7f4fe diff --git a/tests/difficulty/data.txt b/tests/difficulty/data.txt new file mode 100644 index 000000000..17c48025e --- /dev/null +++ b/tests/difficulty/data.txt @@ -0,0 +1,1000 @@ +996 1 +985 1 +978 11 +1001 80 +1040 480 +1196 1108 +1109 925 +1241 1434 +1243 1843 +986 2664 +920 3870 +2213 4613 +2472 1581 +2592 1439 +2712 1439 +3056 1439 +3392 1289 +3723 1176 +3937 1088 +4219 1054 +4447 1002 +4681 971 +4702 942 +4683 967 +4942 997 +4958 968 +5126 993 +5188 981 +5322 995 +5545 991 +5531 969 +5792 994 +5831 969 +6020 985 +5943 971 +6179 994 +6409 987 +6587 967 +6736 957 +7027 952 +7293 926 +7494 905 +7747 893 +7805 876 +7911 884 +7923 886 +7996 899 +8149 905 +8101 901 +8258 916 +8395 918 +8295 915 +8430 930 +8719 941 +8698 920 +8819 934 +8788 937 +8804 951 +8797 966 +8857 980 +8848 990 +8981 1005 +8896 1005 +9012 1020 +9104 1031 +9295 1035 +9312 1026 +9432 1038 +9731 1038 +9991 1017 +10291 1002 +10510 982 +10607 972 +10563 975 +10669 987 +10567 993 +10813 1005 +11075 1002 +11045 988 +11253 1000 +11321 994 +11492 999 +11721 995 +11839 984 +11855 985 +12017 994 +12104 990 +12062 993 +12162 1004 +12075 1009 +12211 1020 +12345 1027 +12257 1025 +12155 1036 +12326 1047 +12620 1058 +12772 1044 +12993 1041 +13173 1032 +13081 1027 +13079 1037 +13082 1048 +13072 1058 +13078 1068 +13069 1079 +13060 1089 +13056 1100 +13057 1111 +13062 1122 +13056 1133 +13060 1144 +13052 1155 +13057 1166 +13049 1178 +13041 1189 +13042 1201 +13036 1213 +13041 1224 +13036 1236 +13034 1249 +13031 1261 +13029 1273 +13025 1286 +13030 1298 +13020 1311 +13026 1324 +13021 1337 +13028 1350 +13038 1363 +13037 1376 +13026 1390 +13024 1403 +13014 1417 +13011 1431 +13011 1445 +13004 1459 +13000 1474 +12992 1488 +13000 1503 +13003 1517 +13004 1532 +12995 1547 +12987 1562 +12983 1578 +12992 1593 +12993 1609 +12983 1624 +12973 1640 +12967 1656 +12961 1673 +12960 1689 +12963 1705 +12971 1722 +12968 1739 +12973 1756 +12968 1773 +12965 1791 +12966 1808 +12958 1826 +12949 1844 +12957 1862 +12947 1880 +12957 1898 +12958 1917 +12967 1936 +12975 1955 +12973 1974 +12965 1993 +12974 2013 +12975 2033 +12979 2052 +12978 2073 +12968 2093 +12965 2113 +12975 2134 +12966 2155 +12962 2176 +12955 2197 +12960 2219 +12969 2241 +12965 2263 +12973 2285 +12962 2307 +12956 2330 +12947 2352 +12948 2376 +12944 2399 +12950 2422 +12949 2446 +12942 2470 +12942 2494 +12945 2519 +12934 2543 +12932 2568 +12932 2593 +12939 2619 +12940 2644 +12931 2670 +12930 2696 +12922 2723 +12920 2749 +12925 2776 +12916 2804 +12922 2831 +12923 2859 +12922 2887 +12924 2915 +12927 2944 +12932 2972 +12925 3001 +12924 3031 +12933 3061 +12942 3091 +12934 3121 +12925 3151 +12930 3182 +12927 3213 +12935 3245 +12931 3277 +12938 3309 +12931 3341 +12933 3374 +12940 3407 +12935 3440 +12944 3474 +12943 3508 +12954 3542 +12952 3577 +12956 3612 +12959 3647 +12968 3683 +12975 3719 +12976 3756 +12979 3792 +12988 3830 +12993 3867 +12986 3905 +12979 3943 +12980 3982 +12974 4021 +12972 4060 +12978 4100 +12980 4140 +12989 4181 +12997 4222 +12988 4263 +12996 4305 +13001 4347 +12998 4389 +12996 4432 +13001 4476 +12995 4520 +12991 4564 +12984 4609 +12993 4654 +12991 4699 +12983 4745 +12987 4792 +12978 4839 +12982 4886 +12973 4934 +12964 4982 +12961 5031 +12970 5080 +12981 5130 +12974 5180 +12972 5231 +12962 5282 +12970 5334 +12969 5386 +12973 5439 +12971 5492 +12964 5546 +12975 5600 +12985 5655 +12977 5711 +12971 5767 +12964 5823 +12974 5880 +12982 5938 +12991 5996 +12993 6055 +13002 6114 +12991 6174 +12988 6234 +12987 6295 +12995 6357 +12986 6419 +12993 6482 +13000 6545 +13005 6610 +13002 6674 +12997 6740 +12998 6806 +12999 6872 +13009 6940 +13004 7008 +13006 7076 +12996 7146 +13002 7216 +13014 7286 +13026 7358 +13024 7430 +13029 7502 +13033 7576 +13037 7650 +13045 7725 +13047 7801 +13058 7877 +13058 7954 +13062 8032 +13052 8111 +13049 8190 +13056 8270 +13057 8351 +13047 8433 +13039 8516 +13031 8599 +13038 8683 +13029 8768 +13019 8854 +13010 8941 +13005 9029 +12995 9117 +12988 9206 +12999 9296 +12998 9387 +12991 9479 +12997 9572 +13002 9666 +12993 9761 +13004 9856 +13005 9953 +13013 10050 +13006 10149 +13000 10248 +12995 10348 +12996 10450 +12996 10552 +12995 10655 +12998 10760 +12993 10865 +12998 10972 +12989 11079 +12998 11188 +12991 11297 +13003 11408 +13008 11519 +12997 11632 +13005 11746 +13009 11861 +13009 11977 +13005 12095 +13000 12213 +12998 12333 +12993 12454 +12986 12575 +12994 12699 +12996 12823 +13004 12949 +13008 13075 +13008 13203 +13007 13333 +13002 13463 +13013 13595 +13013 13728 +13009 13863 +13023 13999 +13027 14136 +13027 14274 +13028 14414 +13025 14555 +13015 14698 +13020 14842 +13020 14987 +13023 15134 +13013 15282 +13023 15432 +13023 15583 +13037 15735 +13048 15889 +13061 16045 +13050 16202 +13063 16361 +13061 16521 +13049 16683 +13059 16846 +13059 17011 +13060 17178 +13075 17346 +13071 17516 +13073 17687 +13082 17861 +13091 18036 +13083 18212 +13090 18391 +13078 18571 +13084 18753 +13092 18936 +13085 19122 +13077 19309 +13067 19498 +13078 19689 +13093 19882 +13090 20077 +13094 20273 +13098 20472 +13114 20672 +13108 20875 +13117 21079 +13112 21286 +13102 21494 +13109 21705 +13122 21917 +13121 22132 +13129 22348 +13122 22567 +13115 22788 +13113 23012 +13121 23237 +13114 23464 +13103 23694 +13093 23926 +13098 24161 +13099 24397 +13092 24636 +13102 24877 +13104 25121 +13092 25367 +13103 25616 +13099 25866 +13089 26120 +13093 26376 +13101 26634 +13113 26895 +13121 27158 +13128 27424 +13138 27693 +13140 27964 +13157 28238 +13157 28514 +13144 28794 +13155 29076 +13156 29360 +13173 29648 +13163 29938 +13180 30231 +13188 30510 +13191 30789 +13177 31082 +13174 31386 +13164 31693 +13168 32003 +13173 32316 +13167 32632 +13177 32951 +13188 33273 +13201 33599 +13209 33900 +13220 34209 +13211 34512 +13208 34848 +13194 35188 +13181 35532 +13198 35878 +13192 36228 +13201 36582 +13208 36939 +13197 37299 +13197 37663 +13196 38030 +13208 38401 +13215 38776 +13226 39154 +13215 39517 +13231 39902 +13244 40275 +13254 40625 +13253 40987 +13241 41386 +13241 41789 +13235 42195 +13237 42606 +13239 43020 +13243 43439 +13233 43861 +13241 44288 +13231 44719 +13252 45154 +13263 45593 +13251 46003 +13261 46451 +13277 46902 +13290 47305 +13280 47714 +13291 48177 +13293 48640 +13284 49104 +13278 49580 +13281 50061 +13277 50547 +13284 51037 +13294 51532 +13286 52027 +13285 52532 +13292 53041 +13283 53556 +13291 54075 +13281 54600 +13278 55129 +13267 55664 +13269 56203 +13279 56749 +13269 57299 +13270 57855 +13278 58416 +13283 58982 +13282 59554 +13278 60132 +13272 60715 +13275 61304 +13278 61898 +13286 62498 +13285 63104 +13291 63716 +13295 64334 +13305 64953 +13311 65530 +13310 66133 +13314 66773 +13323 67404 +13316 68007 +13324 68665 +13322 69323 +13330 69994 +13322 70637 +13315 71320 +13322 72010 +13332 72706 +13333 73397 +13337 74101 +13337 74793 +13339 75516 +13340 76234 +13347 76964 +13351 77664 +13353 78389 +13349 79132 +13357 79896 +13347 80641 +13347 81420 +13336 82205 +13330 82998 +13325 83799 +13324 84608 +13315 85424 +13316 86248 +13325 87080 +13321 87921 +13327 88769 +13320 89625 +13313 90490 +13322 91363 +13327 92245 +13318 93135 +13313 94033 +13304 94941 +13298 95857 +13301 96782 +13294 97716 +13284 98658 +13291 99610 +13287 100571 +13296 101542 +13296 102521 +13299 103511 +13303 104509 +13312 105518 +13313 106536 +13315 107564 +13307 108602 +13299 109649 +13289 110707 +13297 111776 +13289 112854 +13295 113943 +13304 115042 +13296 116152 +13296 117273 +13301 118405 +13292 119547 +13301 120701 +13305 121865 +13294 123041 +13301 124228 +13308 125427 +13315 126637 +13309 127859 +13316 129092 +13322 130338 +13324 131596 +13330 133488 +13328 133531 +13328 134902 +13335 134923 +13334 136229 +13328 136252 +13328 137668 +13330 137690 +13336 139046 +13328 139046 +13317 140806 +13324 140806 +13316 142922 +13317 143004 +13326 145371 +13330 145383 +13332 147263 +13332 147287 +13327 148653 +13324 148653 +13323 163065 +13314 163080 +13323 168505 +13322 168505 +13327 171944 +13331 171960 +13336 175501 +13343 175501 +13336 183009 +13341 183009 +13334 190931 +13338 190931 +13337 199306 +13329 199306 +13333 205710 +13338 205710 +13335 213997 +13330 213997 +13329 221480 +13322 221505 +13326 229542 +13325 229542 +13324 231843 +13331 231870 +13329 234634 +13326 234634 +13332 243740 +13339 243769 +13328 246606 +13332 246635 +13325 254183 +13332 254183 +13335 258637 +13325 258637 +13330 265577 +13321 265611 +13315 275411 +13319 275411 +13309 278711 +13303 278711 +13313 290738 +13310 290738 +13305 295289 +13294 295289 +13293 302850 +13288 302850 +13285 309294 +13280 309336 +13288 319541 +13295 319541 +13304 333707 +13309 333755 +13301 346209 +13293 346209 +13301 357909 +13304 357909 +13310 378490 +13309 378490 +13310 399550 +13302 399550 +13313 417848 +13313 417848 +13324 441697 +13315 441697 +13319 451301 +13311 451382 +13317 465329 +13314 465329 +13318 471489 +13322 471489 +13313 483202 +13311 483293 +13300 498367 +13302 498367 +13296 508613 +13290 508613 +13280 525295 +13278 525295 +13280 535015 +13288 535015 +13288 551838 +13285 551838 +13292 561986 +13303 562101 +13300 601209 +13290 601209 +13293 610660 +13292 610660 +13296 626756 +13297 626756 +13294 635012 +13305 635152 +13299 643158 +13299 643158 +13300 652606 +13304 652606 +13296 664186 +13287 664335 +13296 673132 +13301 673132 +13301 673132 +13310 673132 +13307 673132 +13303 673132 +13302 673132 +13296 673132 +13293 673132 +13305 673132 +13294 673132 +13297 673132 +13288 673132 +13294 673132 +13296 673132 +13304 673132 +13297 673132 +13306 686583 +13296 708022 +13302 721171 +13301 745255 +13293 789338 +13288 801708 +13294 835723 +13295 915543 +13291 998038 +13298 1109322 +13302 1209204 +13312 1246864 +13314 1263152 +13320 1296983 +13325 1342856 +13324 1436884 +13320 1601878 +13325 1643370 +13324 1806409 +13334 1891570 +13330 2094126 +13319 2424286 +13319 2650457 +13325 2715282 +13311 3092010 +13318 3244961 +13306 3321946 +13321 3446480 +13328 3644333 +13334 3714812 +13328 3928889 +13313 4152287 +13324 4497011 +13324 4645094 +13325 6541658 +13339 8449869 +13337 11545575 +13316 11814280 +13302 12028489 +13324 12187097 +13349 12345701 +13354 12540339 +13396 12735943 +13396 12903378 +13425 13103440 +13461 13283023 +13509 13429115 +13499 13679122 +13521 13861980 +13523 14155832 +13530 14344931 +13518 14573230 +13511 14765343 +13547 14959879 +13528 15192777 +13579 15390669 +13611 15588557 +13644 15789960 +13676 15991403 +13708 16236622 +13753 16441249 +13812 16688228 +13787 16893368 +13812 17230031 +13793 17481566 +13811 17688803 +13792 17896037 +13830 18196823 +13819 18357684 +13834 18565439 +13870 18821700 +13859 19079284 +13897 19288103 +13883 19547559 +13908 19860081 +13963 20070522 +14012 20285173 +14080 20560219 +14140 20732016 +14148 21019918 +14162 21379326 +14150 21746458 +14130 22069652 +14183 22420034 +14219 22677730 +14213 23091563 +14260 23414683 +14276 23874363 +14274 24276963 +14318 24756195 +14390 25185364 +14462 25644616 +14544 26226598 +14557 26681976 +14554 27332346 +14521 27938692 +14602 28610024 +14588 29308918 +14613 30156474 +14580 31024769 +14543 32013610 +14577 32963488 +14676 34023072 +14675 35029231 +14691 36188609 +14767 37370414 +14885 38518184 +14878 39730624 +14974 40937806 +15008 41959660 +15009 43997972 +15039 46631045 +15039 49969426 +15147 53632107 +15180 57066286 +15368 60514005 +15379 64138256 +15356 67460179 +15403 64918929 +15560 68486057 +15590 67591981 +15580 65909365 +15514 64245787 +15641 66071664 +15587 68860387 +15537 71048137 +15710 73745734 +15627 76599571 +15618 79052834 +15739 81934490 +15985 82669438 +15981 81374711 +16103 80244245 +16349 79139295 +16328 78279627 +16544 77533151 +16615 75616132 +16616 74926817 +16593 76917472 +16584 79312606 +16665 80101567 +16634 82504177 +16867 85030276 +16971 86883326 +16895 88319800 +16965 90469139 +16950 90465262 +16877 91890415 +17117 93106091 +17238 94321256 +17441 95846287 +17491 92979967 +17446 90954994 +17394 87623370 +17542 85999264 +17681 87412539 +17819 88988409 +17725 91038329 +17943 92336744 +17991 93029082 +18031 92973033 +17970 94737578 +18141 93980118 +18320 95237016 +18545 97391127 +18712 96561416 +18849 93797276 +19074 91336444 +19161 89892725 +19148 90669712 +19232 92693040 +19181 94222209 +19254 96265222 +19423 97254840 +19535 99319736 +19760 101190729 +19980 102676323 +20185 104459744 +20111 103054687 +20358 105521248 +20374 107126438 +20374 105088747 +20372 101446709 +20283 103568593 +20594 101467587 +20811 102246714 +20967 104790689 +21208 106029191 +21371 108934133 +21676 106529418 +21593 108090230 +21829 103189197 +22124 105891192 +22244 108822755 +22548 110958877 +22829 109385192 +23059 111573148 +23240 113687895 +23411 115823707 +23340 118555853 +23628 121634310 +23764 123624077 +24150 126599053 +24048 129441066 +23992 129644548 +24056 131850076 +23959 124550087 +24027 127640855 +24241 125937704 +24583 120297009 +24504 122340050 +24487 118247531 +24522 119488591 +24540 121684801 +24460 123559998 +24412 126151243 +24638 128166276 +24577 129779407 +24541 125648210 +24616 128007653 +24872 130198716 +24743 131132412 +24629 133370101 +24483 135940710 +24513 133837081 +24476 132688318 +24687 130598203 +25045 131756130 +25247 134089716 +25356 135086151 +25531 135840432 +25757 134049326 +25820 135059817 +25838 134720446 +25847 133583240 +25722 135102319 +25599 136767738 +25942 137938928 +25959 137181584 +26362 134741089 +26356 131382998 +26249 129571190 +26193 128461060 +26203 125528898 +26296 125772324 +26356 127272308 +26510 128659463 +26803 129420466 +26965 130811709 +27050 129187186 +27343 128796859 +27408 126306858 +27344 124109316 +27400 123585673 +27354 124051058 +27479 124120333 +27752 124602137 +27936 126110194 +28045 127727168 +28334 129412894 +28508 127266450 +28641 125300988 +28748 124441135 +29000 122351487 diff --git a/tests/difficulty/difficulty.cpp b/tests/difficulty/difficulty.cpp new file mode 100644 index 000000000..85c469391 --- /dev/null +++ b/tests/difficulty/difficulty.cpp @@ -0,0 +1,55 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include <cstddef> +#include <cstdint> +#include <fstream> +#include <iostream> +#include <vector> + +#include "cryptonote_config.h" +#include "cryptonote_core/difficulty.h" + +using namespace std; + +#define DEFAULT_TEST_DIFFICULTY_TARGET 120 + +int main(int argc, char *argv[]) { + if (argc != 2) { + cerr << "Wrong arguments" << endl; + return 1; + } + vector<uint64_t> timestamps, cumulative_difficulties; + fstream data(argv[1], fstream::in); + data.exceptions(fstream::badbit); + data.clear(data.rdstate()); + uint64_t timestamp, difficulty, cumulative_difficulty = 0; + size_t n = 0; + while (data >> timestamp >> difficulty) { + size_t begin, end; + if (n < DIFFICULTY_WINDOW + DIFFICULTY_LAG) { + begin = 0; + end = min(n, (size_t) DIFFICULTY_WINDOW); + } else { + end = n - DIFFICULTY_LAG; + begin = end - DIFFICULTY_WINDOW; + } + uint64_t res = cryptonote::next_difficulty( + vector<uint64_t>(timestamps.begin() + begin, timestamps.begin() + end), + vector<uint64_t>(cumulative_difficulties.begin() + begin, cumulative_difficulties.begin() + end), DEFAULT_TEST_DIFFICULTY_TARGET); + if (res != difficulty) { + cerr << "Wrong difficulty for block " << n << endl + << "Expected: " << difficulty << endl + << "Found: " << res << endl; + return 1; + } + timestamps.push_back(timestamp); + cumulative_difficulties.push_back(cumulative_difficulty += difficulty); + ++n; + } + if (!data.eof()) { + data.clear(fstream::badbit); + } + return 0; +} diff --git a/tests/difficulty/generate-data b/tests/difficulty/generate-data new file mode 100755 index 000000000..77d384bbc --- /dev/null +++ b/tests/difficulty/generate-data @@ -0,0 +1,52 @@ +#!/usr/bin/python3 + +from random import randint + +DIFFICULTY_TARGET = 120 +DIFFICULTY_WINDOW = 720 +DIFFICULTY_LAG = 15 +DIFFICULTY_CUT = 60 + +UINT_MAX = (1 << 64) - 1 + +def difficulty(): + times = [] + diffs = [] + while True: + if len(times) <= 1: + diff = 1 + else: + begin = max(len(times) - DIFFICULTY_WINDOW - DIFFICULTY_LAG, 0) + end = min(begin + DIFFICULTY_WINDOW, len(times)) + length = end - begin + assert length >= 2 + if length <= DIFFICULTY_WINDOW - 2 * DIFFICULTY_CUT: + cut_begin = 0 + cut_end = length + else: + excess = length - (DIFFICULTY_WINDOW - 2 * DIFFICULTY_CUT) + cut_begin = (excess + 1) // 2 + cut_end = length - excess // 2 + assert cut_begin + 2 <= cut_end + wnd = times[begin:end] + wnd.sort() + dtime = wnd[cut_end - 1] - wnd[cut_begin] + assert 0 <= dtime <= UINT_MAX + dtime = max(dtime, 1) + ddiff = sum(diffs[begin + cut_begin + 1:begin + cut_end]) + assert 0 < ddiff <= UINT_MAX + assert dtime <= ddiff * DIFFICULTY_TARGET + dtime - 1 <= UINT_MAX + diff = (ddiff * DIFFICULTY_TARGET + dtime - 1) // dtime + assert 0 < diff <= UINT_MAX + times.append((yield diff)) + diffs.append(diff) + +time = 1000 +gen = difficulty() +diff = next(gen) +for i in range(1000): + power = 10 if i < 100 else 10000 if i < 500 else 1000000 + time += randint(-diff // power - 10, 3 * diff // power + 10) + assert 0 <= time <= UINT_MAX + print(time, diff) + diff = gen.send(time)
\ No newline at end of file diff --git a/tests/functional_tests/main.cpp b/tests/functional_tests/main.cpp new file mode 100644 index 000000000..330e7ef2f --- /dev/null +++ b/tests/functional_tests/main.cpp @@ -0,0 +1,112 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include <boost/program_options.hpp> + +#include "include_base_utils.h" +using namespace epee; + +#include "common/command_line.h" +#include "transactions_flow_test.h" + +namespace po = boost::program_options; + +namespace +{ + const command_line::arg_descriptor<bool> arg_test_transactions_flow = {"test_transactions_flow", ""}; + + const command_line::arg_descriptor<std::string> arg_working_folder = {"working-folder", "", "."}; + const command_line::arg_descriptor<std::string> arg_source_wallet = {"source-wallet", "", "", true}; + const command_line::arg_descriptor<std::string> arg_dest_wallet = {"dest-wallet", "", "", true}; + const command_line::arg_descriptor<std::string> arg_daemon_addr_a = {"daemon-addr-a", "", "127.0.0.1:8080"}; + const command_line::arg_descriptor<std::string> arg_daemon_addr_b = {"daemon-addr-b", "", "127.0.0.1:8082"}; + + const command_line::arg_descriptor<uint64_t> arg_transfer_amount = {"transfer_amount", "", 60000000000000}; + const command_line::arg_descriptor<size_t> arg_mix_in_factor = {"mix-in-factor", "", 10}; + const command_line::arg_descriptor<size_t> arg_tx_count = {"tx-count", "", 100}; + const command_line::arg_descriptor<size_t> arg_tx_per_second = {"tx-per-second", "", 20}; + const command_line::arg_descriptor<size_t> arg_test_repeat_count = {"test_repeat_count", "", 1}; +} + +int main(int argc, char* argv[]) +{ + TRY_ENTRY(); + string_tools::set_module_name_and_folder(argv[0]); + + //set up logging options + log_space::get_set_log_detalisation_level(true, LOG_LEVEL_3); + log_space::log_singletone::add_logger(LOGGER_CONSOLE, NULL, NULL, LOG_LEVEL_2); + log_space::log_singletone::add_logger(LOGGER_FILE, + log_space::log_singletone::get_default_log_file().c_str(), + log_space::log_singletone::get_default_log_folder().c_str()); + + po::options_description desc_options("Allowed options"); + command_line::add_arg(desc_options, command_line::arg_help); + + command_line::add_arg(desc_options, arg_test_transactions_flow); + + command_line::add_arg(desc_options, arg_working_folder); + command_line::add_arg(desc_options, arg_source_wallet); + command_line::add_arg(desc_options, arg_dest_wallet); + command_line::add_arg(desc_options, arg_daemon_addr_a); + command_line::add_arg(desc_options, arg_daemon_addr_b); + + command_line::add_arg(desc_options, arg_transfer_amount); + command_line::add_arg(desc_options, arg_mix_in_factor); + command_line::add_arg(desc_options, arg_tx_count); + command_line::add_arg(desc_options, arg_tx_per_second); + command_line::add_arg(desc_options, arg_test_repeat_count); + + po::variables_map vm; + bool r = command_line::handle_error_helper(desc_options, [&]() + { + po::store(po::parse_command_line(argc, argv, desc_options), vm); + po::notify(vm); + return true; + }); + if (!r) + return 1; + + if (command_line::get_arg(vm, command_line::arg_help)) + { + std::cout << desc_options << std::endl; + return 0; + } + + if (command_line::get_arg(vm, arg_test_transactions_flow)) + { + std::string working_folder = command_line::get_arg(vm, arg_working_folder); + std::string path_source_wallet, path_target_wallet; + if(command_line::has_arg(vm, arg_source_wallet)) + path_source_wallet = command_line::get_arg(vm, arg_source_wallet); + if(command_line::has_arg(vm, arg_dest_wallet)) + path_target_wallet = command_line::get_arg(vm, arg_dest_wallet); + + std::string daemon_addr_a = command_line::get_arg(vm, arg_daemon_addr_a); + std::string daemon_addr_b = command_line::get_arg(vm, arg_daemon_addr_b); + uint64_t amount_to_transfer = command_line::get_arg(vm, arg_transfer_amount); + size_t mix_in_factor = command_line::get_arg(vm, arg_mix_in_factor); + size_t transactions_count = command_line::get_arg(vm, arg_tx_count); + size_t transactions_per_second = command_line::get_arg(vm, arg_tx_per_second); + size_t repeat_count = command_line::get_arg(vm, arg_test_repeat_count); + + for(size_t i = 0; i != repeat_count; i++) + if(!transactions_flow_test(working_folder, path_source_wallet, path_target_wallet, daemon_addr_a, daemon_addr_b, amount_to_transfer, mix_in_factor, transactions_count, transactions_per_second)) + break; + + std::string s; + std::cin >> s; + + return 1; + } + else + { + std::cout << desc_options << std::endl; + return 1; + } + + CATCH_ENTRY_L0("main", 1); + + return 0; +} diff --git a/tests/functional_tests/transactions_flow_test.cpp b/tests/functional_tests/transactions_flow_test.cpp new file mode 100644 index 000000000..af42f06a5 --- /dev/null +++ b/tests/functional_tests/transactions_flow_test.cpp @@ -0,0 +1,269 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include <boost/uuid/uuid.hpp> +#include <boost/uuid/random_generator.hpp> +#include <unordered_map> + +#include "include_base_utils.h" +using namespace epee; +#include "wallet/wallet2.h" +using namespace cryptonote; + +std::string generate_random_wallet_name() +{ + std::stringstream ss; + ss << boost::uuids::random_generator()(); + return ss.str(); +} + +inline uint64_t random(const uint64_t max_value) { + return (uint64_t(rand()) ^ + (uint64_t(rand())<<16) ^ + (uint64_t(rand())<<32) ^ + (uint64_t(rand())<<48)) % max_value; +} + +bool do_send_money(tools::wallet2& w1, tools::wallet2& w2, size_t mix_in_factor, uint64_t amount_to_transfer, transaction& tx, size_t parts=1) +{ + CHECK_AND_ASSERT_MES(parts > 0, false, "parts must be > 0"); + + std::vector<cryptonote::tx_destination_entry> dsts; + dsts.reserve(parts); + uint64_t amount_used = 0; + uint64_t max_part = amount_to_transfer / parts; + + for (size_t i = 0; i < parts; ++i) + { + cryptonote::tx_destination_entry de; + de.addr = w2.get_account().get_keys().m_account_address; + + if (i < parts - 1) + de.amount = random(max_part); + else + de.amount = amount_to_transfer - amount_used; + amount_used += de.amount; + + //std::cout << "PARTS (" << amount_to_transfer << ") " << amount_used << " " << de.amount << std::endl; + + dsts.push_back(de); + } + + return w1.transfer(dsts, mix_in_factor, 0, DEFAULT_FEE, tools::detail::null_split_strategy, tools::wallet2::tx_dust_policy(DEFAULT_FEE), tx); +} + +uint64_t get_money_in_first_transfers(const tools::wallet2::transfer_container& incoming_transfers, size_t n_transfers) +{ + uint64_t summ = 0; + size_t count = 0; + BOOST_FOREACH(const tools::wallet2::transfer_details& td, incoming_transfers) + { + summ += td.m_tx.vout[td.m_internal_output_index].amount; + if(++count >= n_transfers) + return summ; + } + return summ; +} + +#define FIRST_N_TRANSFERS 10*10 + +bool transactions_flow_test(std::string& working_folder, + std::string path_source_wallet, + std::string path_terget_wallet, + std::string& daemon_addr_a, + std::string& daemon_addr_b, + uint64_t amount_to_transfer, size_t mix_in_factor, size_t transactions_count, size_t transactions_per_second) +{ + LOG_PRINT_L0("-----------------------STARTING TRANSACTIONS FLOW TEST-----------------------"); + tools::wallet2 w1, w2; + if(path_source_wallet.empty()) + path_source_wallet = generate_random_wallet_name(); + + if(path_terget_wallet.empty()) + path_terget_wallet = generate_random_wallet_name(); + + + if(!w1.generate(working_folder + "/" + path_source_wallet, "")) + { + LOG_ERROR("failed to load source wallet from " << path_source_wallet); + return false; + } + + if(!w2.generate(working_folder + "/" + path_terget_wallet, "")) + { + LOG_ERROR( "failed to generate target load wallet from " << path_source_wallet ); + return false; + } + + if(!w1.init(daemon_addr_a)) + { + LOG_ERROR("failed to init source wallet from " << daemon_addr_a ); + return false; + } + size_t blocks_fetched = 0; + if(!w1.refresh(blocks_fetched)) + { + LOG_ERROR( "failed to refresh source wallet from " << daemon_addr_a ); + return false; + } + + if(!w2.init(daemon_addr_b)) + { + LOG_ERROR( "failed to init target wallet from " << daemon_addr_b ); + return false; + } + LOG_PRINT_GREEN("Using wallets: " << ENDL + << "Source: " << w1.get_account().get_public_address_str() << ENDL << "Path: " << working_folder + "/" + path_source_wallet << ENDL + << "Target: " << w2.get_account().get_public_address_str() << ENDL << "Path: " << working_folder + "/" + path_terget_wallet, LOG_LEVEL_1); + + //lets do some money + epee::net_utils::http::http_simple_client http_client; + COMMAND_RPC_STOP_MINING::request daemon1_req = AUTO_VAL_INIT(daemon1_req); + COMMAND_RPC_STOP_MINING::response daemon1_rsp = AUTO_VAL_INIT(daemon1_rsp); + bool r = net_utils::invoke_http_json_remote_command2(daemon_addr_a + "/stop_mine", daemon1_req, daemon1_rsp, http_client, 10000); + CHECK_AND_ASSERT_MES(r, false, "failed to stop mining"); + + + COMMAND_RPC_START_MINING::request daemon_req = AUTO_VAL_INIT(daemon_req); + COMMAND_RPC_START_MINING::response daemon_rsp = AUTO_VAL_INIT(daemon_rsp); + daemon_req.miner_address = w1.get_account().get_public_address_str(); + daemon_req.threads_count = 9; + r = net_utils::invoke_http_json_remote_command2(daemon_addr_a + "/start_mining", daemon_req, daemon_rsp, http_client, 10000); + CHECK_AND_ASSERT_MES(r, false, "failed to get getrandom_outs"); + CHECK_AND_ASSERT_MES(daemon_rsp.status == CORE_RPC_STATUS_OK, false, "failed to getrandom_outs.bin"); + + //wait for money, until balance will have enough money + w1.refresh(blocks_fetched); + while(w1.unlocked_balance() < amount_to_transfer) + { + misc_utils::sleep_no_w(1000); + w1.refresh(blocks_fetched); + } + + //lets make a lot of small outs to ourselves + //since it is not possible to start from transaction that bigger than 20Kb, we gonna make transactions + //with 500 outs (about 18kb), and we have to wait appropriate count blocks, mined for test wallet + while(true) + { + tools::wallet2::transfer_container incoming_transfers; + w1.get_transfers(incoming_transfers); + if(incoming_transfers.size() > FIRST_N_TRANSFERS && get_money_in_first_transfers(incoming_transfers, FIRST_N_TRANSFERS) < w1.unlocked_balance() ) + { + //lets go! + size_t count = 0; + BOOST_FOREACH(tools::wallet2::transfer_details& td, incoming_transfers) + { + cryptonote::transaction tx_s; + bool r = do_send_money(w1, w1, 0, td.m_tx.vout[td.m_internal_output_index].amount - DEFAULT_FEE, tx_s, 50); + CHECK_AND_ASSERT_MES(r, false, "Failed to send starter tx " << get_transaction_hash(tx_s)); + LOG_PRINT_GREEN("Starter transaction sent " << get_transaction_hash(tx_s), LOG_LEVEL_0); + if(++count >= FIRST_N_TRANSFERS) + break; + } + break; + }else + { + misc_utils::sleep_no_w(1000); + w1.refresh(); + } + } + //do actual transfer + uint64_t transfered_money = 0; + uint64_t transfer_size = amount_to_transfer/transactions_count; + size_t i = 0; + struct tx_test_entry + { + transaction tx; + size_t m_received_count; + uint64_t amount_transfered; + }; + crypto::key_image lst_sent_ki = AUTO_VAL_INIT(lst_sent_ki); + std::unordered_map<crypto::hash, tx_test_entry> txs; + for(i = 0; i != transactions_count; i++) + { + uint64_t amount_to_tx = (amount_to_transfer - transfered_money) > transfer_size ? transfer_size: (amount_to_transfer - transfered_money); + while(w1.unlocked_balance() < amount_to_tx + DEFAULT_FEE) + { + misc_utils::sleep_no_w(1000); + LOG_PRINT_L0("not enough money, waiting for cashback or mining"); + w1.refresh(blocks_fetched); + } + + transaction tx; + /*size_t n_attempts = 0; + while (!do_send_money(w1, w2, mix_in_factor, amount_to_tx, tx)) { + n_attempts++; + std::cout << "failed to transfer money, refresh and try again (attempts=" << n_attempts << ")" << std::endl; + w1.refresh(); + }*/ + + + if(!do_send_money(w1, w2, mix_in_factor, amount_to_tx, tx)) + { + LOG_PRINT_L0("failed to transfer money, tx: " << get_transaction_hash(tx) << ", refresh and try again" ); + w1.refresh(blocks_fetched); + if(!do_send_money(w1, w2, mix_in_factor, amount_to_tx, tx)) + { + LOG_PRINT_L0( "failed to transfer money, second chance. tx: " << get_transaction_hash(tx) << ", exit" ); + LOCAL_ASSERT(false); + return false; + } + } + lst_sent_ki = boost::get<txin_to_key>(tx.vin[0]).k_image; + + transfered_money += amount_to_tx; + + LOG_PRINT_L0("transferred " << amount_to_tx << ", i=" << i ); + tx_test_entry& ent = txs[get_transaction_hash(tx)] = boost::value_initialized<tx_test_entry>(); + ent.amount_transfered = amount_to_tx; + ent.tx = tx; + //if(i % transactions_per_second) + // misc_utils::sleep_no_w(1000); + } + + + LOG_PRINT_L0( "waiting some new blocks..."); + misc_utils::sleep_no_w(DIFFICULTY_BLOCKS_ESTIMATE_TIMESPAN*20*1000);//wait two blocks before sync on another wallet on another daemon + LOG_PRINT_L0( "refreshing..."); + bool recvd_money = false; + while(w2.refresh(blocks_fetched, recvd_money) && ( (blocks_fetched && recvd_money) || !blocks_fetched ) ) + { + misc_utils::sleep_no_w(DIFFICULTY_BLOCKS_ESTIMATE_TIMESPAN*1000);//wait two blocks before sync on another wallet on another daemon + } + + uint64_t money_2 = w2.balance(); + if(money_2 == transfered_money) + { + LOG_PRINT_GREEN("-----------------------FINISHING TRANSACTIONS FLOW TEST OK-----------------------", LOG_LEVEL_0); + LOG_PRINT_GREEN("transferred " << print_money(transfered_money) << " via " << i << " transactions" , LOG_LEVEL_0); + return true; + }else + { + tools::wallet2::transfer_container tc; + w2.get_transfers(tc); + BOOST_FOREACH(tools::wallet2::transfer_details& td, tc) + { + auto it = txs.find(get_transaction_hash(td.m_tx)); + CHECK_AND_ASSERT_MES(it != txs.end(), false, "transaction not found in local cache"); + it->second.m_received_count += 1; + } + + BOOST_FOREACH(auto& tx_pair, txs) + { + if(tx_pair.second.m_received_count != 1) + { + LOG_PRINT_RED_L0("Transaction lost: " << get_transaction_hash(tx_pair.second.tx)); + } + + } + + LOG_PRINT_RED_L0("-----------------------FINISHING TRANSACTIONS FLOW TEST FAILED-----------------------" ); + LOG_PRINT_RED_L0("income " << print_money(money_2) << " via " << i << " transactions, expected money = " << print_money(transfered_money) ); + LOCAL_ASSERT(false); + return false; + } + + return true; +} + diff --git a/tests/functional_tests/transactions_flow_test.h b/tests/functional_tests/transactions_flow_test.h new file mode 100644 index 000000000..8f9061b92 --- /dev/null +++ b/tests/functional_tests/transactions_flow_test.h @@ -0,0 +1,12 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + + + +bool transactions_flow_test(std::string& working_folder, + std::string path_source_wallet, + std::string path_terget_wallet, + std::string& daemon_addr_a, + std::string& daemon_addr_b, + uint64_t amount_to_transfer, size_t mix_in_factor, size_t transactions_count, size_t transactions_per_second); diff --git a/tests/functional_tests/transactions_generation_from_blockchain.cpp b/tests/functional_tests/transactions_generation_from_blockchain.cpp new file mode 100644 index 000000000..de2ef541f --- /dev/null +++ b/tests/functional_tests/transactions_generation_from_blockchain.cpp @@ -0,0 +1,128 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include "include_base_utils.h" +using namespace epee; +#include "wallet/wallet2.h" +#include "cryptonote_core/blockchain_storage.h" + +using namespace cryptonote; + +/* +bool transactions_generation_from_blockchain(std::string& blockchain_folder_path) +{ + string_tools::parse_hexstr_to_binbuff() + tx_memory_pool pool; + blockchain_storage bchs(pool); + bool r = bchs.init(blockchain_folder_path); + CHECK_AND_ASSERT_MES(r, false, "failed to load blockchain"); + + //amount = 3000000000000 + //key_offsets = 1,2,3,4,5,10,12,27,31,33,34 + // +} + +tx_source_entry::output_entry make_outptu_entr_for_gindex(size_t i, std::map<crypto::hash, transaction>& txs, std::vector<std::pair<crypto::hash, size_t> >& v) +{ + tx_source_entry::output_entry oe; + oe = i; + oe.second = txs[v[i].first].boost::get<txout_to_key>(vout[v[i].second].target).key; + return oe; +} + +bool make_tx(blockchain_storage& bch) +{ + std::map<crypto::hash, transaction> txs; + std::vector<std::pair<crypto::hash, size_t> > v; + bch.get_outs_for_amounts(3000000000000, v); + + std::vector<tx_source_entry> sources(11); + sources[0].amount = 3000000000000; + sources[0].outputs.push_back(make_outptu_entr_for_gindex(1, txs, v)); + sources[0].outputs.push_back(make_outptu_entr_for_gindex(2, txs, v)); + sources[0].outputs.push_back(make_outptu_entr_for_gindex(3, txs, v)); + sources[0].outputs.push_back(make_outptu_entr_for_gindex(4, txs, v)); + sources[0].outputs.push_back(make_outptu_entr_for_gindex(5, txs, v)); + sources[0].outputs.push_back(make_outptu_entr_for_gindex(10, txs, v)); + sources[0].outputs.push_back(make_outptu_entr_for_gindex(12, txs, v)); + sources[0].outputs.push_back(make_outptu_entr_for_gindex(27, txs, v)); + sources[0].outputs.push_back(make_outptu_entr_for_gindex(31, txs, v)); + sources[0].outputs.push_back(make_outptu_entr_for_gindex(33, txs, v)); + sources[0].outputs.push_back(make_outptu_entr_for_gindex(34, txs, v)); + sources[0].real_out_tx_key = + + BOOST_FOREACH(transfer_container::iterator it, selected_transfers) + { + sources.resize(sources.size()+1); + cryptonote::tx_source_entry& src = sources.back(); + transfer_details& td = *it; + src.amount = td.m_tx.vout[td.m_internal_output_index].amount; + //paste mixin transaction + if(daemon_resp.outs.size()) + { + daemon_resp.outs[i].outs.sort([](const out_entry& a, const out_entry& b){return a.global_amount_index < b.global_amount_index;}); + BOOST_FOREACH(out_entry& daemon_oe, daemon_resp.outs[i].outs) + { + if(td.m_global_output_index == daemon_oe.global_amount_index) + continue; + tx_output_entry oe; + oe.first = daemon_oe.global_amount_index; + oe.second = daemon_oe.out_key; + src.outputs.push_back(oe); + if(src.outputs.size() >= fake_outputs_count) + break; + } + } + + //paste real transaction to the random index + auto it_to_insert = std::find_if(src.outputs.begin(), src.outputs.end(), [&](const tx_output_entry& a) + { + return a.first >= td.m_global_output_index; + }); + //size_t real_index = src.outputs.size() ? (rand() % src.outputs.size() ):0; + tx_output_entry real_oe; + real_oe.first = td.m_global_output_index; + real_oe.second = boost::get<txout_to_key>(td.m_tx.vout[td.m_internal_output_index].target).key; + auto interted_it = src.outputs.insert(it_to_insert, real_oe); + src.real_out_tx_key = td.m_tx.tx_pub_key; + src.real_output = interted_it - src.outputs.begin(); + src.real_output_in_tx_index = td.m_internal_output_index; + ++i; + } + + + if(found_money != needed_money) + { + //lets make last output to odd money + dsts.resize(dsts.size()+1); + cryptonote::tx_destination_entry& destination = dsts.back(); + CHECK_AND_ASSERT_MES(found_money > needed_money, false, "internal error found_money=" << found_money << " !> needed_money=" << needed_money); + destination.amount = found_money - needed_money; + } + + + transaction tx; + bool r = cryptonote::construct_tx(m_account.get_keys(), sources, dsts, tx, unlock_time); + if(!r) + { + std::cout << "transaction construction failed" << std::endl; + } + + COMMAND_RPC_SEND_RAW_TX::request req; + req.tx_as_hex = epee::string_tools::buff_to_hex_nodelimer(tx_to_blob(tx)); + COMMAND_RPC_SEND_RAW_TX::response daemon_send_resp; + r = net_utils::http::invoke_http_json_remote_command(m_daemon_address + "/sendrawtransaction", req, daemon_send_resp, m_http_client); + CHECK_AND_ASSERT_MES(r, false, "failed to send transaction"); + if(daemon_send_resp.status != CORE_RPC_STATUS_OK) + { + std::cout << "daemon failed to accept generated transaction" << ENDL; + return false; + } + + std::cout << "transaction generated ok and sent to daemon" << std::endl; + BOOST_FOREACH(transfer_container::iterator it, selected_transfers) + it->m_spent = true; + + return true; +}*/ diff --git a/tests/functional_tests/transactions_generation_from_blockchain.h b/tests/functional_tests/transactions_generation_from_blockchain.h new file mode 100644 index 000000000..64438488c --- /dev/null +++ b/tests/functional_tests/transactions_generation_from_blockchain.h @@ -0,0 +1,7 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + + + +bool transactions_generation_from_blockchain(std::string& blockchain_path); diff --git a/tests/gtest/CMakeLists.txt b/tests/gtest/CMakeLists.txt new file mode 100644 index 000000000..0fe26540b --- /dev/null +++ b/tests/gtest/CMakeLists.txt @@ -0,0 +1,240 @@ +######################################################################## +# CMake build script for Google Test. +# +# To run the tests for Google Test itself on Linux, use 'make test' or +# ctest. You can select which tests to run using 'ctest -R regex'. +# For more options, run 'ctest --help'. + +# BUILD_SHARED_LIBS is a standard CMake variable, but we declare it here to +# make it prominent in the GUI. +option(BUILD_SHARED_LIBS "Build shared libraries (DLLs)." OFF) + +# When other libraries are using a shared version of runtime libraries, +# Google Test also has to use one. +option( + gtest_force_shared_crt + "Use shared (DLL) run-time lib even when Google Test is built as static lib." + OFF) + +option(gtest_build_tests "Build all of gtest's own tests." OFF) + +option(gtest_build_samples "Build gtest's sample programs." OFF) + +option(gtest_disable_pthreads "Disable uses of pthreads in gtest." OFF) + +# Defines pre_project_set_up_hermetic_build() and set_up_hermetic_build(). +include(cmake/hermetic_build.cmake OPTIONAL) + +if (COMMAND pre_project_set_up_hermetic_build) + pre_project_set_up_hermetic_build() +endif() + +######################################################################## +# +# Project-wide settings + +# Name of the project. +# +# CMake files in this project can refer to the root source directory +# as ${gtest_SOURCE_DIR} and to the root binary directory as +# ${gtest_BINARY_DIR}. +# Language "C" is required for find_package(Threads). +project(gtest CXX C) +cmake_minimum_required(VERSION 2.6.2) + +if (COMMAND set_up_hermetic_build) + set_up_hermetic_build() +endif() + +# Define helper functions and macros used by Google Test. +include(cmake/internal_utils.cmake) + +config_compiler_and_linker() # Defined in internal_utils.cmake. + +# Where Google Test's .h files can be found. +include_directories( + ${gtest_SOURCE_DIR}/include + ${gtest_SOURCE_DIR}) + +# Where Google Test's libraries can be found. +link_directories(${gtest_BINARY_DIR}/src) + +######################################################################## +# +# Defines the gtest & gtest_main libraries. User tests should link +# with one of them. + +# Google Test libraries. We build them using more strict warnings than what +# are used for other targets, to ensure that gtest can be compiled by a user +# aggressive about warnings. +cxx_library(gtest "${cxx_strict}" src/gtest-all.cc) +cxx_library(gtest_main "${cxx_strict}" src/gtest_main.cc) +target_link_libraries(gtest_main gtest) + +######################################################################## +# +# Samples on how to link user tests with gtest or gtest_main. +# +# They are not built by default. To build them, set the +# gtest_build_samples option to ON. You can do it by running ccmake +# or specifying the -Dbuild_gtest_samples=ON flag when running cmake. + +if (gtest_build_samples) + cxx_executable(sample1_unittest samples gtest_main samples/sample1.cc) + cxx_executable(sample2_unittest samples gtest_main samples/sample2.cc) + cxx_executable(sample3_unittest samples gtest_main) + cxx_executable(sample4_unittest samples gtest_main samples/sample4.cc) + cxx_executable(sample5_unittest samples gtest_main samples/sample1.cc) + cxx_executable(sample6_unittest samples gtest_main) + cxx_executable(sample7_unittest samples gtest_main) + cxx_executable(sample8_unittest samples gtest_main) + cxx_executable(sample9_unittest samples gtest) + cxx_executable(sample10_unittest samples gtest) +endif() + +######################################################################## +# +# Google Test's own tests. +# +# You can skip this section if you aren't interested in testing +# Google Test itself. +# +# The tests are not built by default. To build them, set the +# gtest_build_tests option to ON. You can do it by running ccmake +# or specifying the -Dgtest_build_tests=ON flag when running cmake. + +if (gtest_build_tests) + # This must be set in the root directory for the tests to be run by + # 'make test' or ctest. + enable_testing() + + ############################################################ + # C++ tests built with standard compiler flags. + + cxx_test(gtest-death-test_test gtest_main) + cxx_test(gtest_environment_test gtest) + cxx_test(gtest-filepath_test gtest_main) + cxx_test(gtest-linked_ptr_test gtest_main) + cxx_test(gtest-listener_test gtest_main) + cxx_test(gtest_main_unittest gtest_main) + cxx_test(gtest-message_test gtest_main) + cxx_test(gtest_no_test_unittest gtest) + cxx_test(gtest-options_test gtest_main) + cxx_test(gtest-param-test_test gtest + test/gtest-param-test2_test.cc) + cxx_test(gtest-port_test gtest_main) + cxx_test(gtest_pred_impl_unittest gtest_main) + cxx_test(gtest-printers_test gtest_main) + cxx_test(gtest_prod_test gtest_main + test/production.cc) + cxx_test(gtest_repeat_test gtest) + cxx_test(gtest_sole_header_test gtest_main) + cxx_test(gtest_stress_test gtest) + cxx_test(gtest-test-part_test gtest_main) + cxx_test(gtest_throw_on_failure_ex_test gtest) + cxx_test(gtest-typed-test_test gtest_main + test/gtest-typed-test2_test.cc) + cxx_test(gtest_unittest gtest_main) + cxx_test(gtest-unittest-api_test gtest) + + ############################################################ + # C++ tests built with non-standard compiler flags. + + cxx_library(gtest_no_exception "${cxx_no_exception}" + src/gtest-all.cc) + cxx_library(gtest_main_no_exception "${cxx_no_exception}" + src/gtest-all.cc src/gtest_main.cc) + cxx_library(gtest_main_no_rtti "${cxx_no_rtti}" + src/gtest-all.cc src/gtest_main.cc) + + cxx_test_with_flags(gtest-death-test_ex_nocatch_test + "${cxx_exception} -DGTEST_ENABLE_CATCH_EXCEPTIONS_=0" + gtest test/gtest-death-test_ex_test.cc) + cxx_test_with_flags(gtest-death-test_ex_catch_test + "${cxx_exception} -DGTEST_ENABLE_CATCH_EXCEPTIONS_=1" + gtest test/gtest-death-test_ex_test.cc) + + cxx_test_with_flags(gtest_no_rtti_unittest "${cxx_no_rtti}" + gtest_main_no_rtti test/gtest_unittest.cc) + + cxx_shared_library(gtest_dll "${cxx_default}" + src/gtest-all.cc src/gtest_main.cc) + + cxx_executable_with_flags(gtest_dll_test_ "${cxx_default}" + gtest_dll test/gtest_all_test.cc) + set_target_properties(gtest_dll_test_ + PROPERTIES + COMPILE_DEFINITIONS "GTEST_LINKED_AS_SHARED_LIBRARY=1") + + if (NOT MSVC OR NOT MSVC_VERSION EQUAL 1600) + # The C++ Standard specifies tuple_element<int, class>. + # Yet MSVC 10's <utility> declares tuple_element<size_t, class>. + # That declaration conflicts with our own standard-conforming + # tuple implementation. Therefore using our own tuple with + # MSVC 10 doesn't compile. + cxx_library(gtest_main_use_own_tuple "${cxx_use_own_tuple}" + src/gtest-all.cc src/gtest_main.cc) + + cxx_test_with_flags(gtest-tuple_test "${cxx_use_own_tuple}" + gtest_main_use_own_tuple test/gtest-tuple_test.cc) + + cxx_test_with_flags(gtest_use_own_tuple_test "${cxx_use_own_tuple}" + gtest_main_use_own_tuple + test/gtest-param-test_test.cc test/gtest-param-test2_test.cc) + endif() + + ############################################################ + # Python tests. + + cxx_executable(gtest_break_on_failure_unittest_ test gtest) + py_test(gtest_break_on_failure_unittest) + + cxx_executable_with_flags( + gtest_catch_exceptions_no_ex_test_ + "${cxx_no_exception}" + gtest_main_no_exception + test/gtest_catch_exceptions_test_.cc) + cxx_executable_with_flags( + gtest_catch_exceptions_ex_test_ + "${cxx_exception}" + gtest_main + test/gtest_catch_exceptions_test_.cc) + py_test(gtest_catch_exceptions_test) + + cxx_executable(gtest_color_test_ test gtest) + py_test(gtest_color_test) + + cxx_executable(gtest_env_var_test_ test gtest) + py_test(gtest_env_var_test) + + cxx_executable(gtest_filter_unittest_ test gtest) + py_test(gtest_filter_unittest) + + cxx_executable(gtest_help_test_ test gtest_main) + py_test(gtest_help_test) + + cxx_executable(gtest_list_tests_unittest_ test gtest) + py_test(gtest_list_tests_unittest) + + cxx_executable(gtest_output_test_ test gtest) + py_test(gtest_output_test) + + cxx_executable(gtest_shuffle_test_ test gtest) + py_test(gtest_shuffle_test) + + cxx_executable(gtest_throw_on_failure_test_ test gtest_no_exception) + set_target_properties(gtest_throw_on_failure_test_ + PROPERTIES + COMPILE_FLAGS "${cxx_no_exception}") + py_test(gtest_throw_on_failure_test) + + cxx_executable(gtest_uninitialized_test_ test gtest) + py_test(gtest_uninitialized_test) + + cxx_executable(gtest_xml_outfile1_test_ test gtest_main) + cxx_executable(gtest_xml_outfile2_test_ test gtest_main) + py_test(gtest_xml_outfiles_test) + + cxx_executable(gtest_xml_output_unittest_ test gtest) + py_test(gtest_xml_output_unittest) +endif() diff --git a/tests/gtest/cmake/internal_utils.cmake b/tests/gtest/cmake/internal_utils.cmake new file mode 100644 index 000000000..7efc2ac79 --- /dev/null +++ b/tests/gtest/cmake/internal_utils.cmake @@ -0,0 +1,216 @@ +# Defines functions and macros useful for building Google Test and +# Google Mock. +# +# Note: +# +# - This file will be run twice when building Google Mock (once via +# Google Test's CMakeLists.txt, and once via Google Mock's). +# Therefore it shouldn't have any side effects other than defining +# the functions and macros. +# +# - The functions/macros defined in this file may depend on Google +# Test and Google Mock's option() definitions, and thus must be +# called *after* the options have been defined. + +# Tweaks CMake's default compiler/linker settings to suit Google Test's needs. +# +# This must be a macro(), as inside a function string() can only +# update variables in the function scope. +macro(fix_default_compiler_settings_) + if (MSVC) + # For MSVC, CMake sets certain flags to defaults we want to override. + # This replacement code is taken from sample in the CMake Wiki at + # http://www.cmake.org/Wiki/CMake_FAQ#Dynamic_Replace. + foreach (flag_var + CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE + CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO) + if (NOT BUILD_SHARED_LIBS AND NOT gtest_force_shared_crt) + # When Google Test is built as a shared library, it should also use + # shared runtime libraries. Otherwise, it may end up with multiple + # copies of runtime library data in different modules, resulting in + # hard-to-find crashes. When it is built as a static library, it is + # preferable to use CRT as static libraries, as we don't have to rely + # on CRT DLLs being available. CMake always defaults to using shared + # CRT libraries, so we override that default here. + string(REPLACE "/MD" "-MT" ${flag_var} "${${flag_var}}") + endif() + + # We prefer more strict warning checking for building Google Test. + # Replaces /W3 with /W4 in defaults. + string(REPLACE "/W3" "-W4" ${flag_var} "${${flag_var}}") + endforeach() + endif() +endmacro() + +# Defines the compiler/linker flags used to build Google Test and +# Google Mock. You can tweak these definitions to suit your need. A +# variable's value is empty before it's explicitly assigned to. +macro(config_compiler_and_linker) + if (NOT gtest_disable_pthreads) + # Defines CMAKE_USE_PTHREADS_INIT and CMAKE_THREAD_LIBS_INIT. + find_package(Threads) + endif() + + fix_default_compiler_settings_() + if (MSVC) + # Newlines inside flags variables break CMake's NMake generator. + # TODO(vladl@google.com): Add -RTCs and -RTCu to debug builds. + set(cxx_base_flags "-GS -W4 -WX -wd4127 -wd4251 -wd4275 -nologo -J -Zi") + set(cxx_base_flags "${cxx_base_flags} -D_UNICODE -DUNICODE -DWIN32 -D_WIN32") + set(cxx_base_flags "${cxx_base_flags} -DSTRICT -DWIN32_LEAN_AND_MEAN") + set(cxx_exception_flags "-EHsc -D_HAS_EXCEPTIONS=1") + set(cxx_no_exception_flags "-D_HAS_EXCEPTIONS=0") + set(cxx_no_rtti_flags "-GR-") + elseif (CMAKE_COMPILER_IS_GNUCXX) + set(cxx_base_flags "-Wall -Wshadow") + set(cxx_exception_flags "-fexceptions") + set(cxx_no_exception_flags "-fno-exceptions") + # Until version 4.3.2, GCC doesn't define a macro to indicate + # whether RTTI is enabled. Therefore we define GTEST_HAS_RTTI + # explicitly. + set(cxx_no_rtti_flags "-fno-rtti -DGTEST_HAS_RTTI=0") + set(cxx_strict_flags "-Wextra") + elseif (CMAKE_CXX_COMPILER_ID STREQUAL "SunPro") + set(cxx_exception_flags "-features=except") + # Sun Pro doesn't provide macros to indicate whether exceptions and + # RTTI are enabled, so we define GTEST_HAS_* explicitly. + set(cxx_no_exception_flags "-features=no%except -DGTEST_HAS_EXCEPTIONS=0") + set(cxx_no_rtti_flags "-features=no%rtti -DGTEST_HAS_RTTI=0") + elseif (CMAKE_CXX_COMPILER_ID STREQUAL "VisualAge" OR + CMAKE_CXX_COMPILER_ID STREQUAL "XL") + # CMake 2.8 changes Visual Age's compiler ID to "XL". + set(cxx_exception_flags "-qeh") + set(cxx_no_exception_flags "-qnoeh") + # Until version 9.0, Visual Age doesn't define a macro to indicate + # whether RTTI is enabled. Therefore we define GTEST_HAS_RTTI + # explicitly. + set(cxx_no_rtti_flags "-qnortti -DGTEST_HAS_RTTI=0") + elseif (CMAKE_CXX_COMPILER_ID STREQUAL "HP") + set(cxx_base_flags "-AA -mt") + set(cxx_exception_flags "-DGTEST_HAS_EXCEPTIONS=1") + set(cxx_no_exception_flags "+noeh -DGTEST_HAS_EXCEPTIONS=0") + # RTTI can not be disabled in HP aCC compiler. + set(cxx_no_rtti_flags "") + endif() + + if (CMAKE_USE_PTHREADS_INIT) # The pthreads library is available and allowed. + set(cxx_base_flags "${cxx_base_flags} -DGTEST_HAS_PTHREAD=1") + else() + set(cxx_base_flags "${cxx_base_flags} -DGTEST_HAS_PTHREAD=0") + endif() + + # For building gtest's own tests and samples. + set(cxx_exception "${CMAKE_CXX_FLAGS} ${cxx_base_flags} ${cxx_exception_flags}") + set(cxx_no_exception + "${CMAKE_CXX_FLAGS} ${cxx_base_flags} ${cxx_no_exception_flags}") + set(cxx_default "${cxx_exception}") + set(cxx_no_rtti "${cxx_default} ${cxx_no_rtti_flags}") + set(cxx_use_own_tuple "${cxx_default} -DGTEST_USE_OWN_TR1_TUPLE=1") + + # For building the gtest libraries. + set(cxx_strict "${cxx_default} ${cxx_strict_flags}") +endmacro() + +# Defines the gtest & gtest_main libraries. User tests should link +# with one of them. +function(cxx_library_with_type name type cxx_flags) + # type can be either STATIC or SHARED to denote a static or shared library. + # ARGN refers to additional arguments after 'cxx_flags'. + add_library(${name} ${type} ${ARGN}) + set_target_properties(${name} + PROPERTIES + COMPILE_FLAGS "${cxx_flags}") + if (BUILD_SHARED_LIBS OR type STREQUAL "SHARED") + set_target_properties(${name} + PROPERTIES + COMPILE_DEFINITIONS "GTEST_CREATE_SHARED_LIBRARY=1") + endif() + if (CMAKE_USE_PTHREADS_INIT) + target_link_libraries(${name} ${CMAKE_THREAD_LIBS_INIT}) + endif() +endfunction() + +######################################################################## +# +# Helper functions for creating build targets. + +function(cxx_shared_library name cxx_flags) + cxx_library_with_type(${name} SHARED "${cxx_flags}" ${ARGN}) +endfunction() + +function(cxx_library name cxx_flags) + cxx_library_with_type(${name} "" "${cxx_flags}" ${ARGN}) +endfunction() + +# cxx_executable_with_flags(name cxx_flags libs srcs...) +# +# creates a named C++ executable that depends on the given libraries and +# is built from the given source files with the given compiler flags. +function(cxx_executable_with_flags name cxx_flags libs) + add_executable(${name} ${ARGN}) + if (cxx_flags) + set_target_properties(${name} + PROPERTIES + COMPILE_FLAGS "${cxx_flags}") + endif() + if (BUILD_SHARED_LIBS) + set_target_properties(${name} + PROPERTIES + COMPILE_DEFINITIONS "GTEST_LINKED_AS_SHARED_LIBRARY=1") + endif() + # To support mixing linking in static and dynamic libraries, link each + # library in with an extra call to target_link_libraries. + foreach (lib "${libs}") + target_link_libraries(${name} ${lib}) + endforeach() +endfunction() + +# cxx_executable(name dir lib srcs...) +# +# creates a named target that depends on the given libs and is built +# from the given source files. dir/name.cc is implicitly included in +# the source file list. +function(cxx_executable name dir libs) + cxx_executable_with_flags( + ${name} "${cxx_default}" "${libs}" "${dir}/${name}.cc" ${ARGN}) +endfunction() + +# Sets PYTHONINTERP_FOUND and PYTHON_EXECUTABLE. +find_package(PythonInterp) + +# cxx_test_with_flags(name cxx_flags libs srcs...) +# +# creates a named C++ test that depends on the given libs and is built +# from the given source files with the given compiler flags. +function(cxx_test_with_flags name cxx_flags libs) + cxx_executable_with_flags(${name} "${cxx_flags}" "${libs}" ${ARGN}) + add_test(${name} ${name}) +endfunction() + +# cxx_test(name libs srcs...) +# +# creates a named test target that depends on the given libs and is +# built from the given source files. Unlike cxx_test_with_flags, +# test/name.cc is already implicitly included in the source file list. +function(cxx_test name libs) + cxx_test_with_flags("${name}" "${cxx_default}" "${libs}" + "test/${name}.cc" ${ARGN}) +endfunction() + +# py_test(name) +# +# creates a Python test with the given name whose main module is in +# test/name.py. It does nothing if Python is not installed. +function(py_test name) + # We are not supporting Python tests on Linux yet as they consider + # all Linux environments to be google3 and try to use google3 features. + if (PYTHONINTERP_FOUND) + # ${CMAKE_BINARY_DIR} is known at configuration time, so we can + # directly bind it from cmake. ${CTEST_CONFIGURATION_TYPE} is known + # only at ctest runtime (by calling ctest -c <Configuration>), so + # we have to escape $ to delay variable substitution here. + add_test(${name} + ${PYTHON_EXECUTABLE} ${CMAKE_CURRENT_SOURCE_DIR}/test/${name}.py + --build_dir=${CMAKE_CURRENT_BINARY_DIR}/\${CTEST_CONFIGURATION_TYPE}) + endif() +endfunction() diff --git a/tests/gtest/include/gtest/gtest-death-test.h b/tests/gtest/include/gtest/gtest-death-test.h new file mode 100644 index 000000000..a27883f0a --- /dev/null +++ b/tests/gtest/include/gtest/gtest-death-test.h @@ -0,0 +1,283 @@ +// Copyright 2005, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Author: wan@google.com (Zhanyong Wan) +// +// The Google C++ Testing Framework (Google Test) +// +// This header file defines the public API for death tests. It is +// #included by gtest.h so a user doesn't need to include this +// directly. + +#ifndef GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_ +#define GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_ + +#include "gtest/internal/gtest-death-test-internal.h" + +namespace testing { + +// This flag controls the style of death tests. Valid values are "threadsafe", +// meaning that the death test child process will re-execute the test binary +// from the start, running only a single death test, or "fast", +// meaning that the child process will execute the test logic immediately +// after forking. +GTEST_DECLARE_string_(death_test_style); + +#if GTEST_HAS_DEATH_TEST + +// The following macros are useful for writing death tests. + +// Here's what happens when an ASSERT_DEATH* or EXPECT_DEATH* is +// executed: +// +// 1. It generates a warning if there is more than one active +// thread. This is because it's safe to fork() or clone() only +// when there is a single thread. +// +// 2. The parent process clone()s a sub-process and runs the death +// test in it; the sub-process exits with code 0 at the end of the +// death test, if it hasn't exited already. +// +// 3. The parent process waits for the sub-process to terminate. +// +// 4. The parent process checks the exit code and error message of +// the sub-process. +// +// Examples: +// +// ASSERT_DEATH(server.SendMessage(56, "Hello"), "Invalid port number"); +// for (int i = 0; i < 5; i++) { +// EXPECT_DEATH(server.ProcessRequest(i), +// "Invalid request .* in ProcessRequest()") +// << "Failed to die on request " << i); +// } +// +// ASSERT_EXIT(server.ExitNow(), ::testing::ExitedWithCode(0), "Exiting"); +// +// bool KilledBySIGHUP(int exit_code) { +// return WIFSIGNALED(exit_code) && WTERMSIG(exit_code) == SIGHUP; +// } +// +// ASSERT_EXIT(client.HangUpServer(), KilledBySIGHUP, "Hanging up!"); +// +// On the regular expressions used in death tests: +// +// On POSIX-compliant systems (*nix), we use the <regex.h> library, +// which uses the POSIX extended regex syntax. +// +// On other platforms (e.g. Windows), we only support a simple regex +// syntax implemented as part of Google Test. This limited +// implementation should be enough most of the time when writing +// death tests; though it lacks many features you can find in PCRE +// or POSIX extended regex syntax. For example, we don't support +// union ("x|y"), grouping ("(xy)"), brackets ("[xy]"), and +// repetition count ("x{5,7}"), among others. +// +// Below is the syntax that we do support. We chose it to be a +// subset of both PCRE and POSIX extended regex, so it's easy to +// learn wherever you come from. In the following: 'A' denotes a +// literal character, period (.), or a single \\ escape sequence; +// 'x' and 'y' denote regular expressions; 'm' and 'n' are for +// natural numbers. +// +// c matches any literal character c +// \\d matches any decimal digit +// \\D matches any character that's not a decimal digit +// \\f matches \f +// \\n matches \n +// \\r matches \r +// \\s matches any ASCII whitespace, including \n +// \\S matches any character that's not a whitespace +// \\t matches \t +// \\v matches \v +// \\w matches any letter, _, or decimal digit +// \\W matches any character that \\w doesn't match +// \\c matches any literal character c, which must be a punctuation +// . matches any single character except \n +// A? matches 0 or 1 occurrences of A +// A* matches 0 or many occurrences of A +// A+ matches 1 or many occurrences of A +// ^ matches the beginning of a string (not that of each line) +// $ matches the end of a string (not that of each line) +// xy matches x followed by y +// +// If you accidentally use PCRE or POSIX extended regex features +// not implemented by us, you will get a run-time failure. In that +// case, please try to rewrite your regular expression within the +// above syntax. +// +// This implementation is *not* meant to be as highly tuned or robust +// as a compiled regex library, but should perform well enough for a +// death test, which already incurs significant overhead by launching +// a child process. +// +// Known caveats: +// +// A "threadsafe" style death test obtains the path to the test +// program from argv[0] and re-executes it in the sub-process. For +// simplicity, the current implementation doesn't search the PATH +// when launching the sub-process. This means that the user must +// invoke the test program via a path that contains at least one +// path separator (e.g. path/to/foo_test and +// /absolute/path/to/bar_test are fine, but foo_test is not). This +// is rarely a problem as people usually don't put the test binary +// directory in PATH. +// +// TODO(wan@google.com): make thread-safe death tests search the PATH. + +// Asserts that a given statement causes the program to exit, with an +// integer exit status that satisfies predicate, and emitting error output +// that matches regex. +# define ASSERT_EXIT(statement, predicate, regex) \ + GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_FATAL_FAILURE_) + +// Like ASSERT_EXIT, but continues on to successive tests in the +// test case, if any: +# define EXPECT_EXIT(statement, predicate, regex) \ + GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_NONFATAL_FAILURE_) + +// Asserts that a given statement causes the program to exit, either by +// explicitly exiting with a nonzero exit code or being killed by a +// signal, and emitting error output that matches regex. +# define ASSERT_DEATH(statement, regex) \ + ASSERT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex) + +// Like ASSERT_DEATH, but continues on to successive tests in the +// test case, if any: +# define EXPECT_DEATH(statement, regex) \ + EXPECT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex) + +// Two predicate classes that can be used in {ASSERT,EXPECT}_EXIT*: + +// Tests that an exit code describes a normal exit with a given exit code. +class GTEST_API_ ExitedWithCode { + public: + explicit ExitedWithCode(int exit_code); + bool operator()(int exit_status) const; + private: + // No implementation - assignment is unsupported. + void operator=(const ExitedWithCode& other); + + const int exit_code_; +}; + +# if !GTEST_OS_WINDOWS +// Tests that an exit code describes an exit due to termination by a +// given signal. +class GTEST_API_ KilledBySignal { + public: + explicit KilledBySignal(int signum); + bool operator()(int exit_status) const; + private: + const int signum_; +}; +# endif // !GTEST_OS_WINDOWS + +// EXPECT_DEBUG_DEATH asserts that the given statements die in debug mode. +// The death testing framework causes this to have interesting semantics, +// since the sideeffects of the call are only visible in opt mode, and not +// in debug mode. +// +// In practice, this can be used to test functions that utilize the +// LOG(DFATAL) macro using the following style: +// +// int DieInDebugOr12(int* sideeffect) { +// if (sideeffect) { +// *sideeffect = 12; +// } +// LOG(DFATAL) << "death"; +// return 12; +// } +// +// TEST(TestCase, TestDieOr12WorksInDgbAndOpt) { +// int sideeffect = 0; +// // Only asserts in dbg. +// EXPECT_DEBUG_DEATH(DieInDebugOr12(&sideeffect), "death"); +// +// #ifdef NDEBUG +// // opt-mode has sideeffect visible. +// EXPECT_EQ(12, sideeffect); +// #else +// // dbg-mode no visible sideeffect. +// EXPECT_EQ(0, sideeffect); +// #endif +// } +// +// This will assert that DieInDebugReturn12InOpt() crashes in debug +// mode, usually due to a DCHECK or LOG(DFATAL), but returns the +// appropriate fallback value (12 in this case) in opt mode. If you +// need to test that a function has appropriate side-effects in opt +// mode, include assertions against the side-effects. A general +// pattern for this is: +// +// EXPECT_DEBUG_DEATH({ +// // Side-effects here will have an effect after this statement in +// // opt mode, but none in debug mode. +// EXPECT_EQ(12, DieInDebugOr12(&sideeffect)); +// }, "death"); +// +# ifdef NDEBUG + +# define EXPECT_DEBUG_DEATH(statement, regex) \ + do { statement; } while (::testing::internal::AlwaysFalse()) + +# define ASSERT_DEBUG_DEATH(statement, regex) \ + do { statement; } while (::testing::internal::AlwaysFalse()) + +# else + +# define EXPECT_DEBUG_DEATH(statement, regex) \ + EXPECT_DEATH(statement, regex) + +# define ASSERT_DEBUG_DEATH(statement, regex) \ + ASSERT_DEATH(statement, regex) + +# endif // NDEBUG for EXPECT_DEBUG_DEATH +#endif // GTEST_HAS_DEATH_TEST + +// EXPECT_DEATH_IF_SUPPORTED(statement, regex) and +// ASSERT_DEATH_IF_SUPPORTED(statement, regex) expand to real death tests if +// death tests are supported; otherwise they just issue a warning. This is +// useful when you are combining death test assertions with normal test +// assertions in one test. +#if GTEST_HAS_DEATH_TEST +# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \ + EXPECT_DEATH(statement, regex) +# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \ + ASSERT_DEATH(statement, regex) +#else +# define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \ + GTEST_UNSUPPORTED_DEATH_TEST_(statement, regex, ) +# define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \ + GTEST_UNSUPPORTED_DEATH_TEST_(statement, regex, return) +#endif + +} // namespace testing + +#endif // GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_ diff --git a/tests/gtest/include/gtest/gtest-message.h b/tests/gtest/include/gtest/gtest-message.h new file mode 100644 index 000000000..9b7142f32 --- /dev/null +++ b/tests/gtest/include/gtest/gtest-message.h @@ -0,0 +1,230 @@ +// Copyright 2005, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Author: wan@google.com (Zhanyong Wan) +// +// The Google C++ Testing Framework (Google Test) +// +// This header file defines the Message class. +// +// IMPORTANT NOTE: Due to limitation of the C++ language, we have to +// leave some internal implementation details in this header file. +// They are clearly marked by comments like this: +// +// // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. +// +// Such code is NOT meant to be used by a user directly, and is subject +// to CHANGE WITHOUT NOTICE. Therefore DO NOT DEPEND ON IT in a user +// program! + +#ifndef GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_ +#define GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_ + +#include <limits> + +#include "gtest/internal/gtest-string.h" +#include "gtest/internal/gtest-internal.h" + +namespace testing { + +// The Message class works like an ostream repeater. +// +// Typical usage: +// +// 1. You stream a bunch of values to a Message object. +// It will remember the text in a stringstream. +// 2. Then you stream the Message object to an ostream. +// This causes the text in the Message to be streamed +// to the ostream. +// +// For example; +// +// testing::Message foo; +// foo << 1 << " != " << 2; +// std::cout << foo; +// +// will print "1 != 2". +// +// Message is not intended to be inherited from. In particular, its +// destructor is not virtual. +// +// Note that stringstream behaves differently in gcc and in MSVC. You +// can stream a NULL char pointer to it in the former, but not in the +// latter (it causes an access violation if you do). The Message +// class hides this difference by treating a NULL char pointer as +// "(null)". +class GTEST_API_ Message { + private: + // The type of basic IO manipulators (endl, ends, and flush) for + // narrow streams. + typedef std::ostream& (*BasicNarrowIoManip)(std::ostream&); + + public: + // Constructs an empty Message. + // We allocate the stringstream separately because otherwise each use of + // ASSERT/EXPECT in a procedure adds over 200 bytes to the procedure's + // stack frame leading to huge stack frames in some cases; gcc does not reuse + // the stack space. + Message() : ss_(new ::std::stringstream) { + // By default, we want there to be enough precision when printing + // a double to a Message. + *ss_ << std::setprecision(std::numeric_limits<double>::digits10 + 2); + } + + // Copy constructor. + Message(const Message& msg) : ss_(new ::std::stringstream) { // NOLINT + *ss_ << msg.GetString(); + } + + // Constructs a Message from a C-string. + explicit Message(const char* str) : ss_(new ::std::stringstream) { + *ss_ << str; + } + +#if GTEST_OS_SYMBIAN + // Streams a value (either a pointer or not) to this object. + template <typename T> + inline Message& operator <<(const T& value) { + StreamHelper(typename internal::is_pointer<T>::type(), value); + return *this; + } +#else + // Streams a non-pointer value to this object. + template <typename T> + inline Message& operator <<(const T& val) { + ::GTestStreamToHelper(ss_.get(), val); + return *this; + } + + // Streams a pointer value to this object. + // + // This function is an overload of the previous one. When you + // stream a pointer to a Message, this definition will be used as it + // is more specialized. (The C++ Standard, section + // [temp.func.order].) If you stream a non-pointer, then the + // previous definition will be used. + // + // The reason for this overload is that streaming a NULL pointer to + // ostream is undefined behavior. Depending on the compiler, you + // may get "0", "(nil)", "(null)", or an access violation. To + // ensure consistent result across compilers, we always treat NULL + // as "(null)". + template <typename T> + inline Message& operator <<(T* const& pointer) { // NOLINT + if (pointer == NULL) { + *ss_ << "(null)"; + } else { + ::GTestStreamToHelper(ss_.get(), pointer); + } + return *this; + } +#endif // GTEST_OS_SYMBIAN + + // Since the basic IO manipulators are overloaded for both narrow + // and wide streams, we have to provide this specialized definition + // of operator <<, even though its body is the same as the + // templatized version above. Without this definition, streaming + // endl or other basic IO manipulators to Message will confuse the + // compiler. + Message& operator <<(BasicNarrowIoManip val) { + *ss_ << val; + return *this; + } + + // Instead of 1/0, we want to see true/false for bool values. + Message& operator <<(bool b) { + return *this << (b ? "true" : "false"); + } + + // These two overloads allow streaming a wide C string to a Message + // using the UTF-8 encoding. + Message& operator <<(const wchar_t* wide_c_str) { + return *this << internal::String::ShowWideCString(wide_c_str); + } + Message& operator <<(wchar_t* wide_c_str) { + return *this << internal::String::ShowWideCString(wide_c_str); + } + +#if GTEST_HAS_STD_WSTRING + // Converts the given wide string to a narrow string using the UTF-8 + // encoding, and streams the result to this Message object. + Message& operator <<(const ::std::wstring& wstr); +#endif // GTEST_HAS_STD_WSTRING + +#if GTEST_HAS_GLOBAL_WSTRING + // Converts the given wide string to a narrow string using the UTF-8 + // encoding, and streams the result to this Message object. + Message& operator <<(const ::wstring& wstr); +#endif // GTEST_HAS_GLOBAL_WSTRING + + // Gets the text streamed to this object so far as a String. + // Each '\0' character in the buffer is replaced with "\\0". + // + // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. + internal::String GetString() const { + return internal::StringStreamToString(ss_.get()); + } + + private: + +#if GTEST_OS_SYMBIAN + // These are needed as the Nokia Symbian Compiler cannot decide between + // const T& and const T* in a function template. The Nokia compiler _can_ + // decide between class template specializations for T and T*, so a + // tr1::type_traits-like is_pointer works, and we can overload on that. + template <typename T> + inline void StreamHelper(internal::true_type /*dummy*/, T* pointer) { + if (pointer == NULL) { + *ss_ << "(null)"; + } else { + ::GTestStreamToHelper(ss_.get(), pointer); + } + } + template <typename T> + inline void StreamHelper(internal::false_type /*dummy*/, const T& value) { + ::GTestStreamToHelper(ss_.get(), value); + } +#endif // GTEST_OS_SYMBIAN + + // We'll hold the text streamed to this object here. + const internal::scoped_ptr< ::std::stringstream> ss_; + + // We declare (but don't implement) this to prevent the compiler + // from implementing the assignment operator. + void operator=(const Message&); +}; + +// Streams a Message to an ostream. +inline std::ostream& operator <<(std::ostream& os, const Message& sb) { + return os << sb.GetString(); +} + +} // namespace testing + +#endif // GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_ diff --git a/tests/gtest/include/gtest/gtest-param-test.h b/tests/gtest/include/gtest/gtest-param-test.h new file mode 100644 index 000000000..6407cfd68 --- /dev/null +++ b/tests/gtest/include/gtest/gtest-param-test.h @@ -0,0 +1,1421 @@ +// This file was GENERATED by command: +// pump.py gtest-param-test.h.pump +// DO NOT EDIT BY HAND!!! + +// Copyright 2008, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Authors: vladl@google.com (Vlad Losev) +// +// Macros and functions for implementing parameterized tests +// in Google C++ Testing Framework (Google Test) +// +// This file is generated by a SCRIPT. DO NOT EDIT BY HAND! +// +#ifndef GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_ +#define GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_ + + +// Value-parameterized tests allow you to test your code with different +// parameters without writing multiple copies of the same test. +// +// Here is how you use value-parameterized tests: + +#if 0 + +// To write value-parameterized tests, first you should define a fixture +// class. It is usually derived from testing::TestWithParam<T> (see below for +// another inheritance scheme that's sometimes useful in more complicated +// class hierarchies), where the type of your parameter values. +// TestWithParam<T> is itself derived from testing::Test. T can be any +// copyable type. If it's a raw pointer, you are responsible for managing the +// lifespan of the pointed values. + +class FooTest : public ::testing::TestWithParam<const char*> { + // You can implement all the usual class fixture members here. +}; + +// Then, use the TEST_P macro to define as many parameterized tests +// for this fixture as you want. The _P suffix is for "parameterized" +// or "pattern", whichever you prefer to think. + +TEST_P(FooTest, DoesBlah) { + // Inside a test, access the test parameter with the GetParam() method + // of the TestWithParam<T> class: + EXPECT_TRUE(foo.Blah(GetParam())); + ... +} + +TEST_P(FooTest, HasBlahBlah) { + ... +} + +// Finally, you can use INSTANTIATE_TEST_CASE_P to instantiate the test +// case with any set of parameters you want. Google Test defines a number +// of functions for generating test parameters. They return what we call +// (surprise!) parameter generators. Here is a summary of them, which +// are all in the testing namespace: +// +// +// Range(begin, end [, step]) - Yields values {begin, begin+step, +// begin+step+step, ...}. The values do not +// include end. step defaults to 1. +// Values(v1, v2, ..., vN) - Yields values {v1, v2, ..., vN}. +// ValuesIn(container) - Yields values from a C-style array, an STL +// ValuesIn(begin,end) container, or an iterator range [begin, end). +// Bool() - Yields sequence {false, true}. +// Combine(g1, g2, ..., gN) - Yields all combinations (the Cartesian product +// for the math savvy) of the values generated +// by the N generators. +// +// For more details, see comments at the definitions of these functions below +// in this file. +// +// The following statement will instantiate tests from the FooTest test case +// each with parameter values "meeny", "miny", and "moe". + +INSTANTIATE_TEST_CASE_P(InstantiationName, + FooTest, + Values("meeny", "miny", "moe")); + +// To distinguish different instances of the pattern, (yes, you +// can instantiate it more then once) the first argument to the +// INSTANTIATE_TEST_CASE_P macro is a prefix that will be added to the +// actual test case name. Remember to pick unique prefixes for different +// instantiations. The tests from the instantiation above will have +// these names: +// +// * InstantiationName/FooTest.DoesBlah/0 for "meeny" +// * InstantiationName/FooTest.DoesBlah/1 for "miny" +// * InstantiationName/FooTest.DoesBlah/2 for "moe" +// * InstantiationName/FooTest.HasBlahBlah/0 for "meeny" +// * InstantiationName/FooTest.HasBlahBlah/1 for "miny" +// * InstantiationName/FooTest.HasBlahBlah/2 for "moe" +// +// You can use these names in --gtest_filter. +// +// This statement will instantiate all tests from FooTest again, each +// with parameter values "cat" and "dog": + +const char* pets[] = {"cat", "dog"}; +INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest, ValuesIn(pets)); + +// The tests from the instantiation above will have these names: +// +// * AnotherInstantiationName/FooTest.DoesBlah/0 for "cat" +// * AnotherInstantiationName/FooTest.DoesBlah/1 for "dog" +// * AnotherInstantiationName/FooTest.HasBlahBlah/0 for "cat" +// * AnotherInstantiationName/FooTest.HasBlahBlah/1 for "dog" +// +// Please note that INSTANTIATE_TEST_CASE_P will instantiate all tests +// in the given test case, whether their definitions come before or +// AFTER the INSTANTIATE_TEST_CASE_P statement. +// +// Please also note that generator expressions (including parameters to the +// generators) are evaluated in InitGoogleTest(), after main() has started. +// This allows the user on one hand, to adjust generator parameters in order +// to dynamically determine a set of tests to run and on the other hand, +// give the user a chance to inspect the generated tests with Google Test +// reflection API before RUN_ALL_TESTS() is executed. +// +// You can see samples/sample7_unittest.cc and samples/sample8_unittest.cc +// for more examples. +// +// In the future, we plan to publish the API for defining new parameter +// generators. But for now this interface remains part of the internal +// implementation and is subject to change. +// +// +// A parameterized test fixture must be derived from testing::Test and from +// testing::WithParamInterface<T>, where T is the type of the parameter +// values. Inheriting from TestWithParam<T> satisfies that requirement because +// TestWithParam<T> inherits from both Test and WithParamInterface. In more +// complicated hierarchies, however, it is occasionally useful to inherit +// separately from Test and WithParamInterface. For example: + +class BaseTest : public ::testing::Test { + // You can inherit all the usual members for a non-parameterized test + // fixture here. +}; + +class DerivedTest : public BaseTest, public ::testing::WithParamInterface<int> { + // The usual test fixture members go here too. +}; + +TEST_F(BaseTest, HasFoo) { + // This is an ordinary non-parameterized test. +} + +TEST_P(DerivedTest, DoesBlah) { + // GetParam works just the same here as if you inherit from TestWithParam. + EXPECT_TRUE(foo.Blah(GetParam())); +} + +#endif // 0 + +#include "gtest/internal/gtest-port.h" + +#if !GTEST_OS_SYMBIAN +# include <utility> +#endif + +// scripts/fuse_gtest.py depends on gtest's own header being #included +// *unconditionally*. Therefore these #includes cannot be moved +// inside #if GTEST_HAS_PARAM_TEST. +#include "gtest/internal/gtest-internal.h" +#include "gtest/internal/gtest-param-util.h" +#include "gtest/internal/gtest-param-util-generated.h" + +#if GTEST_HAS_PARAM_TEST + +namespace testing { + +// Functions producing parameter generators. +// +// Google Test uses these generators to produce parameters for value- +// parameterized tests. When a parameterized test case is instantiated +// with a particular generator, Google Test creates and runs tests +// for each element in the sequence produced by the generator. +// +// In the following sample, tests from test case FooTest are instantiated +// each three times with parameter values 3, 5, and 8: +// +// class FooTest : public TestWithParam<int> { ... }; +// +// TEST_P(FooTest, TestThis) { +// } +// TEST_P(FooTest, TestThat) { +// } +// INSTANTIATE_TEST_CASE_P(TestSequence, FooTest, Values(3, 5, 8)); +// + +// Range() returns generators providing sequences of values in a range. +// +// Synopsis: +// Range(start, end) +// - returns a generator producing a sequence of values {start, start+1, +// start+2, ..., }. +// Range(start, end, step) +// - returns a generator producing a sequence of values {start, start+step, +// start+step+step, ..., }. +// Notes: +// * The generated sequences never include end. For example, Range(1, 5) +// returns a generator producing a sequence {1, 2, 3, 4}. Range(1, 9, 2) +// returns a generator producing {1, 3, 5, 7}. +// * start and end must have the same type. That type may be any integral or +// floating-point type or a user defined type satisfying these conditions: +// * It must be assignable (have operator=() defined). +// * It must have operator+() (operator+(int-compatible type) for +// two-operand version). +// * It must have operator<() defined. +// Elements in the resulting sequences will also have that type. +// * Condition start < end must be satisfied in order for resulting sequences +// to contain any elements. +// +template <typename T, typename IncrementT> +internal::ParamGenerator<T> Range(T start, T end, IncrementT step) { + return internal::ParamGenerator<T>( + new internal::RangeGenerator<T, IncrementT>(start, end, step)); +} + +template <typename T> +internal::ParamGenerator<T> Range(T start, T end) { + return Range(start, end, 1); +} + +// ValuesIn() function allows generation of tests with parameters coming from +// a container. +// +// Synopsis: +// ValuesIn(const T (&array)[N]) +// - returns a generator producing sequences with elements from +// a C-style array. +// ValuesIn(const Container& container) +// - returns a generator producing sequences with elements from +// an STL-style container. +// ValuesIn(Iterator begin, Iterator end) +// - returns a generator producing sequences with elements from +// a range [begin, end) defined by a pair of STL-style iterators. These +// iterators can also be plain C pointers. +// +// Please note that ValuesIn copies the values from the containers +// passed in and keeps them to generate tests in RUN_ALL_TESTS(). +// +// Examples: +// +// This instantiates tests from test case StringTest +// each with C-string values of "foo", "bar", and "baz": +// +// const char* strings[] = {"foo", "bar", "baz"}; +// INSTANTIATE_TEST_CASE_P(StringSequence, SrtingTest, ValuesIn(strings)); +// +// This instantiates tests from test case StlStringTest +// each with STL strings with values "a" and "b": +// +// ::std::vector< ::std::string> GetParameterStrings() { +// ::std::vector< ::std::string> v; +// v.push_back("a"); +// v.push_back("b"); +// return v; +// } +// +// INSTANTIATE_TEST_CASE_P(CharSequence, +// StlStringTest, +// ValuesIn(GetParameterStrings())); +// +// +// This will also instantiate tests from CharTest +// each with parameter values 'a' and 'b': +// +// ::std::list<char> GetParameterChars() { +// ::std::list<char> list; +// list.push_back('a'); +// list.push_back('b'); +// return list; +// } +// ::std::list<char> l = GetParameterChars(); +// INSTANTIATE_TEST_CASE_P(CharSequence2, +// CharTest, +// ValuesIn(l.begin(), l.end())); +// +template <typename ForwardIterator> +internal::ParamGenerator< + typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type> +ValuesIn(ForwardIterator begin, ForwardIterator end) { + typedef typename ::testing::internal::IteratorTraits<ForwardIterator> + ::value_type ParamType; + return internal::ParamGenerator<ParamType>( + new internal::ValuesInIteratorRangeGenerator<ParamType>(begin, end)); +} + +template <typename T, size_t N> +internal::ParamGenerator<T> ValuesIn(const T (&array)[N]) { + return ValuesIn(array, array + N); +} + +template <class Container> +internal::ParamGenerator<typename Container::value_type> ValuesIn( + const Container& container) { + return ValuesIn(container.begin(), container.end()); +} + +// Values() allows generating tests from explicitly specified list of +// parameters. +// +// Synopsis: +// Values(T v1, T v2, ..., T vN) +// - returns a generator producing sequences with elements v1, v2, ..., vN. +// +// For example, this instantiates tests from test case BarTest each +// with values "one", "two", and "three": +// +// INSTANTIATE_TEST_CASE_P(NumSequence, BarTest, Values("one", "two", "three")); +// +// This instantiates tests from test case BazTest each with values 1, 2, 3.5. +// The exact type of values will depend on the type of parameter in BazTest. +// +// INSTANTIATE_TEST_CASE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5)); +// +// Currently, Values() supports from 1 to 50 parameters. +// +template <typename T1> +internal::ValueArray1<T1> Values(T1 v1) { + return internal::ValueArray1<T1>(v1); +} + +template <typename T1, typename T2> +internal::ValueArray2<T1, T2> Values(T1 v1, T2 v2) { + return internal::ValueArray2<T1, T2>(v1, v2); +} + +template <typename T1, typename T2, typename T3> +internal::ValueArray3<T1, T2, T3> Values(T1 v1, T2 v2, T3 v3) { + return internal::ValueArray3<T1, T2, T3>(v1, v2, v3); +} + +template <typename T1, typename T2, typename T3, typename T4> +internal::ValueArray4<T1, T2, T3, T4> Values(T1 v1, T2 v2, T3 v3, T4 v4) { + return internal::ValueArray4<T1, T2, T3, T4>(v1, v2, v3, v4); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5> +internal::ValueArray5<T1, T2, T3, T4, T5> Values(T1 v1, T2 v2, T3 v3, T4 v4, + T5 v5) { + return internal::ValueArray5<T1, T2, T3, T4, T5>(v1, v2, v3, v4, v5); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6> +internal::ValueArray6<T1, T2, T3, T4, T5, T6> Values(T1 v1, T2 v2, T3 v3, + T4 v4, T5 v5, T6 v6) { + return internal::ValueArray6<T1, T2, T3, T4, T5, T6>(v1, v2, v3, v4, v5, v6); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7> +internal::ValueArray7<T1, T2, T3, T4, T5, T6, T7> Values(T1 v1, T2 v2, T3 v3, + T4 v4, T5 v5, T6 v6, T7 v7) { + return internal::ValueArray7<T1, T2, T3, T4, T5, T6, T7>(v1, v2, v3, v4, v5, + v6, v7); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8> +internal::ValueArray8<T1, T2, T3, T4, T5, T6, T7, T8> Values(T1 v1, T2 v2, + T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8) { + return internal::ValueArray8<T1, T2, T3, T4, T5, T6, T7, T8>(v1, v2, v3, v4, + v5, v6, v7, v8); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9> +internal::ValueArray9<T1, T2, T3, T4, T5, T6, T7, T8, T9> Values(T1 v1, T2 v2, + T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9) { + return internal::ValueArray9<T1, T2, T3, T4, T5, T6, T7, T8, T9>(v1, v2, v3, + v4, v5, v6, v7, v8, v9); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10> +internal::ValueArray10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Values(T1 v1, + T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10) { + return internal::ValueArray10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(v1, + v2, v3, v4, v5, v6, v7, v8, v9, v10); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11> +internal::ValueArray11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, + T11> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11) { + return internal::ValueArray11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, + T11>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12> +internal::ValueArray12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12) { + return internal::ValueArray12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13> +internal::ValueArray13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13) { + return internal::ValueArray13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14> +internal::ValueArray14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14) { + return internal::ValueArray14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, + v14); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15> +internal::ValueArray15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, + T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15) { + return internal::ValueArray15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, + v13, v14, v15); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16> +internal::ValueArray16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, + T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, + T16 v16) { + return internal::ValueArray16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, + v12, v13, v14, v15, v16); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17> +internal::ValueArray17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, + T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, + T16 v16, T17 v17) { + return internal::ValueArray17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, + v11, v12, v13, v14, v15, v16, v17); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18> +internal::ValueArray18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, + T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, + T16 v16, T17 v17, T18 v18) { + return internal::ValueArray18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18>(v1, v2, v3, v4, v5, v6, v7, v8, v9, + v10, v11, v12, v13, v14, v15, v16, v17, v18); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19> +internal::ValueArray19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, + T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, + T15 v15, T16 v16, T17 v17, T18 v18, T19 v19) { + return internal::ValueArray19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19>(v1, v2, v3, v4, v5, v6, v7, v8, + v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20> +internal::ValueArray20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20> Values(T1 v1, T2 v2, T3 v3, T4 v4, + T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, + T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20) { + return internal::ValueArray20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20>(v1, v2, v3, v4, v5, v6, v7, + v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21> +internal::ValueArray21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21> Values(T1 v1, T2 v2, T3 v3, T4 v4, + T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, + T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21) { + return internal::ValueArray21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>(v1, v2, v3, v4, v5, v6, + v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22> +internal::ValueArray22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22> Values(T1 v1, T2 v2, T3 v3, + T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, + T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, + T21 v21, T22 v22) { + return internal::ValueArray22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>(v1, v2, v3, v4, + v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, + v20, v21, v22); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23> +internal::ValueArray23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> Values(T1 v1, T2 v2, + T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, + T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, + T21 v21, T22 v22, T23 v23) { + return internal::ValueArray23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>(v1, v2, v3, + v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, + v20, v21, v22, v23); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24> +internal::ValueArray24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Values(T1 v1, T2 v2, + T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, + T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, + T21 v21, T22 v22, T23 v23, T24 v24) { + return internal::ValueArray24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>(v1, v2, + v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, + v19, v20, v21, v22, v23, v24); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25> +internal::ValueArray25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Values(T1 v1, + T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, + T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, + T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25) { + return internal::ValueArray25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>(v1, + v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, + v18, v19, v20, v21, v22, v23, v24, v25); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26> +internal::ValueArray26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, + T26> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26) { + return internal::ValueArray26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, + T26>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, + v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27> +internal::ValueArray27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, + T27> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27) { + return internal::ValueArray27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, + T26, T27>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, + v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28> +internal::ValueArray28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, + T28> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28) { + return internal::ValueArray28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, + T26, T27, T28>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, + v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, + v28); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29> +internal::ValueArray29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29) { + return internal::ValueArray29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, + T26, T27, T28, T29>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, + v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, + v27, v28, v29); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30> +internal::ValueArray30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, + T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, + T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, + T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30) { + return internal::ValueArray30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, + T26, T27, T28, T29, T30>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, + v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, + v26, v27, v28, v29, v30); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31> +internal::ValueArray31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, + T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, + T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, + T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31) { + return internal::ValueArray31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, + T26, T27, T28, T29, T30, T31>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, + v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, + v25, v26, v27, v28, v29, v30, v31); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32> +internal::ValueArray32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, + T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, + T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, + T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, + T32 v32) { + return internal::ValueArray32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, + T26, T27, T28, T29, T30, T31, T32>(v1, v2, v3, v4, v5, v6, v7, v8, v9, + v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, + v24, v25, v26, v27, v28, v29, v30, v31, v32); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33> +internal::ValueArray33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, + T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, + T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, + T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, + T32 v32, T33 v33) { + return internal::ValueArray33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, + T26, T27, T28, T29, T30, T31, T32, T33>(v1, v2, v3, v4, v5, v6, v7, v8, + v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, + v24, v25, v26, v27, v28, v29, v30, v31, v32, v33); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34> +internal::ValueArray34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, + T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, + T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, + T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, + T31 v31, T32 v32, T33 v33, T34 v34) { + return internal::ValueArray34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, + T26, T27, T28, T29, T30, T31, T32, T33, T34>(v1, v2, v3, v4, v5, v6, v7, + v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, + v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35> +internal::ValueArray35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35> Values(T1 v1, T2 v2, T3 v3, T4 v4, + T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, + T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, + T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, + T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35) { + return internal::ValueArray35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, + T26, T27, T28, T29, T30, T31, T32, T33, T34, T35>(v1, v2, v3, v4, v5, v6, + v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, + v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36> +internal::ValueArray36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36> Values(T1 v1, T2 v2, T3 v3, T4 v4, + T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, + T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, + T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, + T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36) { + return internal::ValueArray36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, + T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36>(v1, v2, v3, v4, + v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, + v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, + v34, v35, v36); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37> +internal::ValueArray37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36, T37> Values(T1 v1, T2 v2, T3 v3, + T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, + T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, + T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, + T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, + T37 v37) { + return internal::ValueArray37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, + T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37>(v1, v2, v3, + v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, + v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, + v34, v35, v36, v37); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38> +internal::ValueArray38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> Values(T1 v1, T2 v2, + T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, + T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, + T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, + T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, + T37 v37, T38 v38) { + return internal::ValueArray38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, + T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38>(v1, v2, + v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, + v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, + v33, v34, v35, v36, v37, v38); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39> +internal::ValueArray39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> Values(T1 v1, T2 v2, + T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, + T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, + T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, + T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, + T37 v37, T38 v38, T39 v39) { + return internal::ValueArray39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, + T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39>(v1, + v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, + v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, + v32, v33, v34, v35, v36, v37, v38, v39); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40> +internal::ValueArray40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> Values(T1 v1, + T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, + T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, + T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, + T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, + T36 v36, T37 v37, T38 v38, T39 v39, T40 v40) { + return internal::ValueArray40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, + T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, + T40>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, + v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, + v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41> +internal::ValueArray41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, + T41> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41) { + return internal::ValueArray41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, + T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, + T40, T41>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, + v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, + v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42> +internal::ValueArray42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, + T42> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, + T42 v42) { + return internal::ValueArray42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, + T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, + T40, T41, T42>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, + v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, + v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, + v42); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43> +internal::ValueArray43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, + T43> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, + T42 v42, T43 v43) { + return internal::ValueArray43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, + T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, + T40, T41, T42, T43>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, + v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, + v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, + v41, v42, v43); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43, typename T44> +internal::ValueArray44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, + T44> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, + T42 v42, T43 v43, T44 v44) { + return internal::ValueArray44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, + T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, + T40, T41, T42, T43, T44>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, + v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, + v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, + v40, v41, v42, v43, v44); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43, typename T44, typename T45> +internal::ValueArray45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, + T44, T45> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, + T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, + T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, + T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, + T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, + T41 v41, T42 v42, T43 v43, T44 v44, T45 v45) { + return internal::ValueArray45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, + T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, + T40, T41, T42, T43, T44, T45>(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, + v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, + v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, + v39, v40, v41, v42, v43, v44, v45); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43, typename T44, typename T45, + typename T46> +internal::ValueArray46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, + T44, T45, T46> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, + T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, + T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, + T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, + T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, + T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46) { + return internal::ValueArray46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, + T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, + T40, T41, T42, T43, T44, T45, T46>(v1, v2, v3, v4, v5, v6, v7, v8, v9, + v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, + v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, + v38, v39, v40, v41, v42, v43, v44, v45, v46); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43, typename T44, typename T45, + typename T46, typename T47> +internal::ValueArray47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, + T44, T45, T46, T47> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, + T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, + T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, + T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, + T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, + T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47) { + return internal::ValueArray47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, + T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, + T40, T41, T42, T43, T44, T45, T46, T47>(v1, v2, v3, v4, v5, v6, v7, v8, + v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, + v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, + v38, v39, v40, v41, v42, v43, v44, v45, v46, v47); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43, typename T44, typename T45, + typename T46, typename T47, typename T48> +internal::ValueArray48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, + T44, T45, T46, T47, T48> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, + T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, + T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, + T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, + T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, + T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, + T48 v48) { + return internal::ValueArray48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, + T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, + T40, T41, T42, T43, T44, T45, T46, T47, T48>(v1, v2, v3, v4, v5, v6, v7, + v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, + v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, + v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43, typename T44, typename T45, + typename T46, typename T47, typename T48, typename T49> +internal::ValueArray49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, + T44, T45, T46, T47, T48, T49> Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, + T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, + T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, + T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, + T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, + T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, + T47 v47, T48 v48, T49 v49) { + return internal::ValueArray49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, + T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, + T40, T41, T42, T43, T44, T45, T46, T47, T48, T49>(v1, v2, v3, v4, v5, v6, + v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, + v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, + v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43, typename T44, typename T45, + typename T46, typename T47, typename T48, typename T49, typename T50> +internal::ValueArray50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, + T44, T45, T46, T47, T48, T49, T50> Values(T1 v1, T2 v2, T3 v3, T4 v4, + T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, + T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, + T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, + T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, + T38 v38, T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, + T46 v46, T47 v47, T48 v48, T49 v49, T50 v50) { + return internal::ValueArray50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, + T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, + T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50>(v1, v2, v3, v4, + v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, + v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, + v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, + v48, v49, v50); +} + +// Bool() allows generating tests with parameters in a set of (false, true). +// +// Synopsis: +// Bool() +// - returns a generator producing sequences with elements {false, true}. +// +// It is useful when testing code that depends on Boolean flags. Combinations +// of multiple flags can be tested when several Bool()'s are combined using +// Combine() function. +// +// In the following example all tests in the test case FlagDependentTest +// will be instantiated twice with parameters false and true. +// +// class FlagDependentTest : public testing::TestWithParam<bool> { +// virtual void SetUp() { +// external_flag = GetParam(); +// } +// } +// INSTANTIATE_TEST_CASE_P(BoolSequence, FlagDependentTest, Bool()); +// +inline internal::ParamGenerator<bool> Bool() { + return Values(false, true); +} + +# if GTEST_HAS_COMBINE +// Combine() allows the user to combine two or more sequences to produce +// values of a Cartesian product of those sequences' elements. +// +// Synopsis: +// Combine(gen1, gen2, ..., genN) +// - returns a generator producing sequences with elements coming from +// the Cartesian product of elements from the sequences generated by +// gen1, gen2, ..., genN. The sequence elements will have a type of +// tuple<T1, T2, ..., TN> where T1, T2, ..., TN are the types +// of elements from sequences produces by gen1, gen2, ..., genN. +// +// Combine can have up to 10 arguments. This number is currently limited +// by the maximum number of elements in the tuple implementation used by Google +// Test. +// +// Example: +// +// This will instantiate tests in test case AnimalTest each one with +// the parameter values tuple("cat", BLACK), tuple("cat", WHITE), +// tuple("dog", BLACK), and tuple("dog", WHITE): +// +// enum Color { BLACK, GRAY, WHITE }; +// class AnimalTest +// : public testing::TestWithParam<tuple<const char*, Color> > {...}; +// +// TEST_P(AnimalTest, AnimalLooksNice) {...} +// +// INSTANTIATE_TEST_CASE_P(AnimalVariations, AnimalTest, +// Combine(Values("cat", "dog"), +// Values(BLACK, WHITE))); +// +// This will instantiate tests in FlagDependentTest with all variations of two +// Boolean flags: +// +// class FlagDependentTest +// : public testing::TestWithParam<tuple(bool, bool)> > { +// virtual void SetUp() { +// // Assigns external_flag_1 and external_flag_2 values from the tuple. +// tie(external_flag_1, external_flag_2) = GetParam(); +// } +// }; +// +// TEST_P(FlagDependentTest, TestFeature1) { +// // Test your code using external_flag_1 and external_flag_2 here. +// } +// INSTANTIATE_TEST_CASE_P(TwoBoolSequence, FlagDependentTest, +// Combine(Bool(), Bool())); +// +template <typename Generator1, typename Generator2> +internal::CartesianProductHolder2<Generator1, Generator2> Combine( + const Generator1& g1, const Generator2& g2) { + return internal::CartesianProductHolder2<Generator1, Generator2>( + g1, g2); +} + +template <typename Generator1, typename Generator2, typename Generator3> +internal::CartesianProductHolder3<Generator1, Generator2, Generator3> Combine( + const Generator1& g1, const Generator2& g2, const Generator3& g3) { + return internal::CartesianProductHolder3<Generator1, Generator2, Generator3>( + g1, g2, g3); +} + +template <typename Generator1, typename Generator2, typename Generator3, + typename Generator4> +internal::CartesianProductHolder4<Generator1, Generator2, Generator3, + Generator4> Combine( + const Generator1& g1, const Generator2& g2, const Generator3& g3, + const Generator4& g4) { + return internal::CartesianProductHolder4<Generator1, Generator2, Generator3, + Generator4>( + g1, g2, g3, g4); +} + +template <typename Generator1, typename Generator2, typename Generator3, + typename Generator4, typename Generator5> +internal::CartesianProductHolder5<Generator1, Generator2, Generator3, + Generator4, Generator5> Combine( + const Generator1& g1, const Generator2& g2, const Generator3& g3, + const Generator4& g4, const Generator5& g5) { + return internal::CartesianProductHolder5<Generator1, Generator2, Generator3, + Generator4, Generator5>( + g1, g2, g3, g4, g5); +} + +template <typename Generator1, typename Generator2, typename Generator3, + typename Generator4, typename Generator5, typename Generator6> +internal::CartesianProductHolder6<Generator1, Generator2, Generator3, + Generator4, Generator5, Generator6> Combine( + const Generator1& g1, const Generator2& g2, const Generator3& g3, + const Generator4& g4, const Generator5& g5, const Generator6& g6) { + return internal::CartesianProductHolder6<Generator1, Generator2, Generator3, + Generator4, Generator5, Generator6>( + g1, g2, g3, g4, g5, g6); +} + +template <typename Generator1, typename Generator2, typename Generator3, + typename Generator4, typename Generator5, typename Generator6, + typename Generator7> +internal::CartesianProductHolder7<Generator1, Generator2, Generator3, + Generator4, Generator5, Generator6, Generator7> Combine( + const Generator1& g1, const Generator2& g2, const Generator3& g3, + const Generator4& g4, const Generator5& g5, const Generator6& g6, + const Generator7& g7) { + return internal::CartesianProductHolder7<Generator1, Generator2, Generator3, + Generator4, Generator5, Generator6, Generator7>( + g1, g2, g3, g4, g5, g6, g7); +} + +template <typename Generator1, typename Generator2, typename Generator3, + typename Generator4, typename Generator5, typename Generator6, + typename Generator7, typename Generator8> +internal::CartesianProductHolder8<Generator1, Generator2, Generator3, + Generator4, Generator5, Generator6, Generator7, Generator8> Combine( + const Generator1& g1, const Generator2& g2, const Generator3& g3, + const Generator4& g4, const Generator5& g5, const Generator6& g6, + const Generator7& g7, const Generator8& g8) { + return internal::CartesianProductHolder8<Generator1, Generator2, Generator3, + Generator4, Generator5, Generator6, Generator7, Generator8>( + g1, g2, g3, g4, g5, g6, g7, g8); +} + +template <typename Generator1, typename Generator2, typename Generator3, + typename Generator4, typename Generator5, typename Generator6, + typename Generator7, typename Generator8, typename Generator9> +internal::CartesianProductHolder9<Generator1, Generator2, Generator3, + Generator4, Generator5, Generator6, Generator7, Generator8, + Generator9> Combine( + const Generator1& g1, const Generator2& g2, const Generator3& g3, + const Generator4& g4, const Generator5& g5, const Generator6& g6, + const Generator7& g7, const Generator8& g8, const Generator9& g9) { + return internal::CartesianProductHolder9<Generator1, Generator2, Generator3, + Generator4, Generator5, Generator6, Generator7, Generator8, Generator9>( + g1, g2, g3, g4, g5, g6, g7, g8, g9); +} + +template <typename Generator1, typename Generator2, typename Generator3, + typename Generator4, typename Generator5, typename Generator6, + typename Generator7, typename Generator8, typename Generator9, + typename Generator10> +internal::CartesianProductHolder10<Generator1, Generator2, Generator3, + Generator4, Generator5, Generator6, Generator7, Generator8, Generator9, + Generator10> Combine( + const Generator1& g1, const Generator2& g2, const Generator3& g3, + const Generator4& g4, const Generator5& g5, const Generator6& g6, + const Generator7& g7, const Generator8& g8, const Generator9& g9, + const Generator10& g10) { + return internal::CartesianProductHolder10<Generator1, Generator2, Generator3, + Generator4, Generator5, Generator6, Generator7, Generator8, Generator9, + Generator10>( + g1, g2, g3, g4, g5, g6, g7, g8, g9, g10); +} +# endif // GTEST_HAS_COMBINE + + + +# define TEST_P(test_case_name, test_name) \ + class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \ + : public test_case_name { \ + public: \ + GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {} \ + virtual void TestBody(); \ + private: \ + static int AddToRegistry() { \ + ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \ + GetTestCasePatternHolder<test_case_name>(\ + #test_case_name, __FILE__, __LINE__)->AddTestPattern(\ + #test_case_name, \ + #test_name, \ + new ::testing::internal::TestMetaFactory< \ + GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>()); \ + return 0; \ + } \ + static int gtest_registering_dummy_; \ + GTEST_DISALLOW_COPY_AND_ASSIGN_(\ + GTEST_TEST_CLASS_NAME_(test_case_name, test_name)); \ + }; \ + int GTEST_TEST_CLASS_NAME_(test_case_name, \ + test_name)::gtest_registering_dummy_ = \ + GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::AddToRegistry(); \ + void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody() + +# define INSTANTIATE_TEST_CASE_P(prefix, test_case_name, generator) \ + ::testing::internal::ParamGenerator<test_case_name::ParamType> \ + gtest_##prefix##test_case_name##_EvalGenerator_() { return generator; } \ + int gtest_##prefix##test_case_name##_dummy_ = \ + ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \ + GetTestCasePatternHolder<test_case_name>(\ + #test_case_name, __FILE__, __LINE__)->AddTestCaseInstantiation(\ + #prefix, \ + >est_##prefix##test_case_name##_EvalGenerator_, \ + __FILE__, __LINE__) + +} // namespace testing + +#endif // GTEST_HAS_PARAM_TEST + +#endif // GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_ diff --git a/tests/gtest/include/gtest/gtest-param-test.h.pump b/tests/gtest/include/gtest/gtest-param-test.h.pump new file mode 100644 index 000000000..401cb513a --- /dev/null +++ b/tests/gtest/include/gtest/gtest-param-test.h.pump @@ -0,0 +1,487 @@ +$$ -*- mode: c++; -*- +$var n = 50 $$ Maximum length of Values arguments we want to support. +$var maxtuple = 10 $$ Maximum number of Combine arguments we want to support. +// Copyright 2008, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Authors: vladl@google.com (Vlad Losev) +// +// Macros and functions for implementing parameterized tests +// in Google C++ Testing Framework (Google Test) +// +// This file is generated by a SCRIPT. DO NOT EDIT BY HAND! +// +#ifndef GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_ +#define GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_ + + +// Value-parameterized tests allow you to test your code with different +// parameters without writing multiple copies of the same test. +// +// Here is how you use value-parameterized tests: + +#if 0 + +// To write value-parameterized tests, first you should define a fixture +// class. It is usually derived from testing::TestWithParam<T> (see below for +// another inheritance scheme that's sometimes useful in more complicated +// class hierarchies), where the type of your parameter values. +// TestWithParam<T> is itself derived from testing::Test. T can be any +// copyable type. If it's a raw pointer, you are responsible for managing the +// lifespan of the pointed values. + +class FooTest : public ::testing::TestWithParam<const char*> { + // You can implement all the usual class fixture members here. +}; + +// Then, use the TEST_P macro to define as many parameterized tests +// for this fixture as you want. The _P suffix is for "parameterized" +// or "pattern", whichever you prefer to think. + +TEST_P(FooTest, DoesBlah) { + // Inside a test, access the test parameter with the GetParam() method + // of the TestWithParam<T> class: + EXPECT_TRUE(foo.Blah(GetParam())); + ... +} + +TEST_P(FooTest, HasBlahBlah) { + ... +} + +// Finally, you can use INSTANTIATE_TEST_CASE_P to instantiate the test +// case with any set of parameters you want. Google Test defines a number +// of functions for generating test parameters. They return what we call +// (surprise!) parameter generators. Here is a summary of them, which +// are all in the testing namespace: +// +// +// Range(begin, end [, step]) - Yields values {begin, begin+step, +// begin+step+step, ...}. The values do not +// include end. step defaults to 1. +// Values(v1, v2, ..., vN) - Yields values {v1, v2, ..., vN}. +// ValuesIn(container) - Yields values from a C-style array, an STL +// ValuesIn(begin,end) container, or an iterator range [begin, end). +// Bool() - Yields sequence {false, true}. +// Combine(g1, g2, ..., gN) - Yields all combinations (the Cartesian product +// for the math savvy) of the values generated +// by the N generators. +// +// For more details, see comments at the definitions of these functions below +// in this file. +// +// The following statement will instantiate tests from the FooTest test case +// each with parameter values "meeny", "miny", and "moe". + +INSTANTIATE_TEST_CASE_P(InstantiationName, + FooTest, + Values("meeny", "miny", "moe")); + +// To distinguish different instances of the pattern, (yes, you +// can instantiate it more then once) the first argument to the +// INSTANTIATE_TEST_CASE_P macro is a prefix that will be added to the +// actual test case name. Remember to pick unique prefixes for different +// instantiations. The tests from the instantiation above will have +// these names: +// +// * InstantiationName/FooTest.DoesBlah/0 for "meeny" +// * InstantiationName/FooTest.DoesBlah/1 for "miny" +// * InstantiationName/FooTest.DoesBlah/2 for "moe" +// * InstantiationName/FooTest.HasBlahBlah/0 for "meeny" +// * InstantiationName/FooTest.HasBlahBlah/1 for "miny" +// * InstantiationName/FooTest.HasBlahBlah/2 for "moe" +// +// You can use these names in --gtest_filter. +// +// This statement will instantiate all tests from FooTest again, each +// with parameter values "cat" and "dog": + +const char* pets[] = {"cat", "dog"}; +INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest, ValuesIn(pets)); + +// The tests from the instantiation above will have these names: +// +// * AnotherInstantiationName/FooTest.DoesBlah/0 for "cat" +// * AnotherInstantiationName/FooTest.DoesBlah/1 for "dog" +// * AnotherInstantiationName/FooTest.HasBlahBlah/0 for "cat" +// * AnotherInstantiationName/FooTest.HasBlahBlah/1 for "dog" +// +// Please note that INSTANTIATE_TEST_CASE_P will instantiate all tests +// in the given test case, whether their definitions come before or +// AFTER the INSTANTIATE_TEST_CASE_P statement. +// +// Please also note that generator expressions (including parameters to the +// generators) are evaluated in InitGoogleTest(), after main() has started. +// This allows the user on one hand, to adjust generator parameters in order +// to dynamically determine a set of tests to run and on the other hand, +// give the user a chance to inspect the generated tests with Google Test +// reflection API before RUN_ALL_TESTS() is executed. +// +// You can see samples/sample7_unittest.cc and samples/sample8_unittest.cc +// for more examples. +// +// In the future, we plan to publish the API for defining new parameter +// generators. But for now this interface remains part of the internal +// implementation and is subject to change. +// +// +// A parameterized test fixture must be derived from testing::Test and from +// testing::WithParamInterface<T>, where T is the type of the parameter +// values. Inheriting from TestWithParam<T> satisfies that requirement because +// TestWithParam<T> inherits from both Test and WithParamInterface. In more +// complicated hierarchies, however, it is occasionally useful to inherit +// separately from Test and WithParamInterface. For example: + +class BaseTest : public ::testing::Test { + // You can inherit all the usual members for a non-parameterized test + // fixture here. +}; + +class DerivedTest : public BaseTest, public ::testing::WithParamInterface<int> { + // The usual test fixture members go here too. +}; + +TEST_F(BaseTest, HasFoo) { + // This is an ordinary non-parameterized test. +} + +TEST_P(DerivedTest, DoesBlah) { + // GetParam works just the same here as if you inherit from TestWithParam. + EXPECT_TRUE(foo.Blah(GetParam())); +} + +#endif // 0 + +#include "gtest/internal/gtest-port.h" + +#if !GTEST_OS_SYMBIAN +# include <utility> +#endif + +// scripts/fuse_gtest.py depends on gtest's own header being #included +// *unconditionally*. Therefore these #includes cannot be moved +// inside #if GTEST_HAS_PARAM_TEST. +#include "gtest/internal/gtest-internal.h" +#include "gtest/internal/gtest-param-util.h" +#include "gtest/internal/gtest-param-util-generated.h" + +#if GTEST_HAS_PARAM_TEST + +namespace testing { + +// Functions producing parameter generators. +// +// Google Test uses these generators to produce parameters for value- +// parameterized tests. When a parameterized test case is instantiated +// with a particular generator, Google Test creates and runs tests +// for each element in the sequence produced by the generator. +// +// In the following sample, tests from test case FooTest are instantiated +// each three times with parameter values 3, 5, and 8: +// +// class FooTest : public TestWithParam<int> { ... }; +// +// TEST_P(FooTest, TestThis) { +// } +// TEST_P(FooTest, TestThat) { +// } +// INSTANTIATE_TEST_CASE_P(TestSequence, FooTest, Values(3, 5, 8)); +// + +// Range() returns generators providing sequences of values in a range. +// +// Synopsis: +// Range(start, end) +// - returns a generator producing a sequence of values {start, start+1, +// start+2, ..., }. +// Range(start, end, step) +// - returns a generator producing a sequence of values {start, start+step, +// start+step+step, ..., }. +// Notes: +// * The generated sequences never include end. For example, Range(1, 5) +// returns a generator producing a sequence {1, 2, 3, 4}. Range(1, 9, 2) +// returns a generator producing {1, 3, 5, 7}. +// * start and end must have the same type. That type may be any integral or +// floating-point type or a user defined type satisfying these conditions: +// * It must be assignable (have operator=() defined). +// * It must have operator+() (operator+(int-compatible type) for +// two-operand version). +// * It must have operator<() defined. +// Elements in the resulting sequences will also have that type. +// * Condition start < end must be satisfied in order for resulting sequences +// to contain any elements. +// +template <typename T, typename IncrementT> +internal::ParamGenerator<T> Range(T start, T end, IncrementT step) { + return internal::ParamGenerator<T>( + new internal::RangeGenerator<T, IncrementT>(start, end, step)); +} + +template <typename T> +internal::ParamGenerator<T> Range(T start, T end) { + return Range(start, end, 1); +} + +// ValuesIn() function allows generation of tests with parameters coming from +// a container. +// +// Synopsis: +// ValuesIn(const T (&array)[N]) +// - returns a generator producing sequences with elements from +// a C-style array. +// ValuesIn(const Container& container) +// - returns a generator producing sequences with elements from +// an STL-style container. +// ValuesIn(Iterator begin, Iterator end) +// - returns a generator producing sequences with elements from +// a range [begin, end) defined by a pair of STL-style iterators. These +// iterators can also be plain C pointers. +// +// Please note that ValuesIn copies the values from the containers +// passed in and keeps them to generate tests in RUN_ALL_TESTS(). +// +// Examples: +// +// This instantiates tests from test case StringTest +// each with C-string values of "foo", "bar", and "baz": +// +// const char* strings[] = {"foo", "bar", "baz"}; +// INSTANTIATE_TEST_CASE_P(StringSequence, SrtingTest, ValuesIn(strings)); +// +// This instantiates tests from test case StlStringTest +// each with STL strings with values "a" and "b": +// +// ::std::vector< ::std::string> GetParameterStrings() { +// ::std::vector< ::std::string> v; +// v.push_back("a"); +// v.push_back("b"); +// return v; +// } +// +// INSTANTIATE_TEST_CASE_P(CharSequence, +// StlStringTest, +// ValuesIn(GetParameterStrings())); +// +// +// This will also instantiate tests from CharTest +// each with parameter values 'a' and 'b': +// +// ::std::list<char> GetParameterChars() { +// ::std::list<char> list; +// list.push_back('a'); +// list.push_back('b'); +// return list; +// } +// ::std::list<char> l = GetParameterChars(); +// INSTANTIATE_TEST_CASE_P(CharSequence2, +// CharTest, +// ValuesIn(l.begin(), l.end())); +// +template <typename ForwardIterator> +internal::ParamGenerator< + typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type> +ValuesIn(ForwardIterator begin, ForwardIterator end) { + typedef typename ::testing::internal::IteratorTraits<ForwardIterator> + ::value_type ParamType; + return internal::ParamGenerator<ParamType>( + new internal::ValuesInIteratorRangeGenerator<ParamType>(begin, end)); +} + +template <typename T, size_t N> +internal::ParamGenerator<T> ValuesIn(const T (&array)[N]) { + return ValuesIn(array, array + N); +} + +template <class Container> +internal::ParamGenerator<typename Container::value_type> ValuesIn( + const Container& container) { + return ValuesIn(container.begin(), container.end()); +} + +// Values() allows generating tests from explicitly specified list of +// parameters. +// +// Synopsis: +// Values(T v1, T v2, ..., T vN) +// - returns a generator producing sequences with elements v1, v2, ..., vN. +// +// For example, this instantiates tests from test case BarTest each +// with values "one", "two", and "three": +// +// INSTANTIATE_TEST_CASE_P(NumSequence, BarTest, Values("one", "two", "three")); +// +// This instantiates tests from test case BazTest each with values 1, 2, 3.5. +// The exact type of values will depend on the type of parameter in BazTest. +// +// INSTANTIATE_TEST_CASE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5)); +// +// Currently, Values() supports from 1 to $n parameters. +// +$range i 1..n +$for i [[ +$range j 1..i + +template <$for j, [[typename T$j]]> +internal::ValueArray$i<$for j, [[T$j]]> Values($for j, [[T$j v$j]]) { + return internal::ValueArray$i<$for j, [[T$j]]>($for j, [[v$j]]); +} + +]] + +// Bool() allows generating tests with parameters in a set of (false, true). +// +// Synopsis: +// Bool() +// - returns a generator producing sequences with elements {false, true}. +// +// It is useful when testing code that depends on Boolean flags. Combinations +// of multiple flags can be tested when several Bool()'s are combined using +// Combine() function. +// +// In the following example all tests in the test case FlagDependentTest +// will be instantiated twice with parameters false and true. +// +// class FlagDependentTest : public testing::TestWithParam<bool> { +// virtual void SetUp() { +// external_flag = GetParam(); +// } +// } +// INSTANTIATE_TEST_CASE_P(BoolSequence, FlagDependentTest, Bool()); +// +inline internal::ParamGenerator<bool> Bool() { + return Values(false, true); +} + +# if GTEST_HAS_COMBINE +// Combine() allows the user to combine two or more sequences to produce +// values of a Cartesian product of those sequences' elements. +// +// Synopsis: +// Combine(gen1, gen2, ..., genN) +// - returns a generator producing sequences with elements coming from +// the Cartesian product of elements from the sequences generated by +// gen1, gen2, ..., genN. The sequence elements will have a type of +// tuple<T1, T2, ..., TN> where T1, T2, ..., TN are the types +// of elements from sequences produces by gen1, gen2, ..., genN. +// +// Combine can have up to $maxtuple arguments. This number is currently limited +// by the maximum number of elements in the tuple implementation used by Google +// Test. +// +// Example: +// +// This will instantiate tests in test case AnimalTest each one with +// the parameter values tuple("cat", BLACK), tuple("cat", WHITE), +// tuple("dog", BLACK), and tuple("dog", WHITE): +// +// enum Color { BLACK, GRAY, WHITE }; +// class AnimalTest +// : public testing::TestWithParam<tuple<const char*, Color> > {...}; +// +// TEST_P(AnimalTest, AnimalLooksNice) {...} +// +// INSTANTIATE_TEST_CASE_P(AnimalVariations, AnimalTest, +// Combine(Values("cat", "dog"), +// Values(BLACK, WHITE))); +// +// This will instantiate tests in FlagDependentTest with all variations of two +// Boolean flags: +// +// class FlagDependentTest +// : public testing::TestWithParam<tuple(bool, bool)> > { +// virtual void SetUp() { +// // Assigns external_flag_1 and external_flag_2 values from the tuple. +// tie(external_flag_1, external_flag_2) = GetParam(); +// } +// }; +// +// TEST_P(FlagDependentTest, TestFeature1) { +// // Test your code using external_flag_1 and external_flag_2 here. +// } +// INSTANTIATE_TEST_CASE_P(TwoBoolSequence, FlagDependentTest, +// Combine(Bool(), Bool())); +// +$range i 2..maxtuple +$for i [[ +$range j 1..i + +template <$for j, [[typename Generator$j]]> +internal::CartesianProductHolder$i<$for j, [[Generator$j]]> Combine( + $for j, [[const Generator$j& g$j]]) { + return internal::CartesianProductHolder$i<$for j, [[Generator$j]]>( + $for j, [[g$j]]); +} + +]] +# endif // GTEST_HAS_COMBINE + + + +# define TEST_P(test_case_name, test_name) \ + class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \ + : public test_case_name { \ + public: \ + GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {} \ + virtual void TestBody(); \ + private: \ + static int AddToRegistry() { \ + ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \ + GetTestCasePatternHolder<test_case_name>(\ + #test_case_name, __FILE__, __LINE__)->AddTestPattern(\ + #test_case_name, \ + #test_name, \ + new ::testing::internal::TestMetaFactory< \ + GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>()); \ + return 0; \ + } \ + static int gtest_registering_dummy_; \ + GTEST_DISALLOW_COPY_AND_ASSIGN_(\ + GTEST_TEST_CLASS_NAME_(test_case_name, test_name)); \ + }; \ + int GTEST_TEST_CLASS_NAME_(test_case_name, \ + test_name)::gtest_registering_dummy_ = \ + GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::AddToRegistry(); \ + void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody() + +# define INSTANTIATE_TEST_CASE_P(prefix, test_case_name, generator) \ + ::testing::internal::ParamGenerator<test_case_name::ParamType> \ + gtest_##prefix##test_case_name##_EvalGenerator_() { return generator; } \ + int gtest_##prefix##test_case_name##_dummy_ = \ + ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \ + GetTestCasePatternHolder<test_case_name>(\ + #test_case_name, __FILE__, __LINE__)->AddTestCaseInstantiation(\ + #prefix, \ + >est_##prefix##test_case_name##_EvalGenerator_, \ + __FILE__, __LINE__) + +} // namespace testing + +#endif // GTEST_HAS_PARAM_TEST + +#endif // GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_ diff --git a/tests/gtest/include/gtest/gtest-printers.h b/tests/gtest/include/gtest/gtest-printers.h new file mode 100644 index 000000000..9cbab3ff4 --- /dev/null +++ b/tests/gtest/include/gtest/gtest-printers.h @@ -0,0 +1,796 @@ +// Copyright 2007, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Author: wan@google.com (Zhanyong Wan) + +// Google Test - The Google C++ Testing Framework +// +// This file implements a universal value printer that can print a +// value of any type T: +// +// void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr); +// +// A user can teach this function how to print a class type T by +// defining either operator<<() or PrintTo() in the namespace that +// defines T. More specifically, the FIRST defined function in the +// following list will be used (assuming T is defined in namespace +// foo): +// +// 1. foo::PrintTo(const T&, ostream*) +// 2. operator<<(ostream&, const T&) defined in either foo or the +// global namespace. +// +// If none of the above is defined, it will print the debug string of +// the value if it is a protocol buffer, or print the raw bytes in the +// value otherwise. +// +// To aid debugging: when T is a reference type, the address of the +// value is also printed; when T is a (const) char pointer, both the +// pointer value and the NUL-terminated string it points to are +// printed. +// +// We also provide some convenient wrappers: +// +// // Prints a value to a string. For a (const or not) char +// // pointer, the NUL-terminated string (but not the pointer) is +// // printed. +// std::string ::testing::PrintToString(const T& value); +// +// // Prints a value tersely: for a reference type, the referenced +// // value (but not the address) is printed; for a (const or not) char +// // pointer, the NUL-terminated string (but not the pointer) is +// // printed. +// void ::testing::internal::UniversalTersePrint(const T& value, ostream*); +// +// // Prints value using the type inferred by the compiler. The difference +// // from UniversalTersePrint() is that this function prints both the +// // pointer and the NUL-terminated string for a (const or not) char pointer. +// void ::testing::internal::UniversalPrint(const T& value, ostream*); +// +// // Prints the fields of a tuple tersely to a string vector, one +// // element for each field. Tuple support must be enabled in +// // gtest-port.h. +// std::vector<string> UniversalTersePrintTupleFieldsToStrings( +// const Tuple& value); +// +// Known limitation: +// +// The print primitives print the elements of an STL-style container +// using the compiler-inferred type of *iter where iter is a +// const_iterator of the container. When const_iterator is an input +// iterator but not a forward iterator, this inferred type may not +// match value_type, and the print output may be incorrect. In +// practice, this is rarely a problem as for most containers +// const_iterator is a forward iterator. We'll fix this if there's an +// actual need for it. Note that this fix cannot rely on value_type +// being defined as many user-defined container types don't have +// value_type. + +#ifndef GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_ +#define GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_ + +#include <ostream> // NOLINT +#include <sstream> +#include <string> +#include <utility> +#include <vector> +#include "gtest/internal/gtest-port.h" +#include "gtest/internal/gtest-internal.h" + +namespace testing { + +// Definitions in the 'internal' and 'internal2' name spaces are +// subject to change without notice. DO NOT USE THEM IN USER CODE! +namespace internal2 { + +// Prints the given number of bytes in the given object to the given +// ostream. +GTEST_API_ void PrintBytesInObjectTo(const unsigned char* obj_bytes, + size_t count, + ::std::ostream* os); + +// For selecting which printer to use when a given type has neither << +// nor PrintTo(). +enum TypeKind { + kProtobuf, // a protobuf type + kConvertibleToInteger, // a type implicitly convertible to BiggestInt + // (e.g. a named or unnamed enum type) + kOtherType // anything else +}; + +// TypeWithoutFormatter<T, kTypeKind>::PrintValue(value, os) is called +// by the universal printer to print a value of type T when neither +// operator<< nor PrintTo() is defined for T, where kTypeKind is the +// "kind" of T as defined by enum TypeKind. +template <typename T, TypeKind kTypeKind> +class TypeWithoutFormatter { + public: + // This default version is called when kTypeKind is kOtherType. + static void PrintValue(const T& value, ::std::ostream* os) { + PrintBytesInObjectTo(reinterpret_cast<const unsigned char*>(&value), + sizeof(value), os); + } +}; + +// We print a protobuf using its ShortDebugString() when the string +// doesn't exceed this many characters; otherwise we print it using +// DebugString() for better readability. +const size_t kProtobufOneLinerMaxLength = 50; + +template <typename T> +class TypeWithoutFormatter<T, kProtobuf> { + public: + static void PrintValue(const T& value, ::std::ostream* os) { + const ::testing::internal::string short_str = value.ShortDebugString(); + const ::testing::internal::string pretty_str = + short_str.length() <= kProtobufOneLinerMaxLength ? + short_str : ("\n" + value.DebugString()); + *os << ("<" + pretty_str + ">"); + } +}; + +template <typename T> +class TypeWithoutFormatter<T, kConvertibleToInteger> { + public: + // Since T has no << operator or PrintTo() but can be implicitly + // converted to BiggestInt, we print it as a BiggestInt. + // + // Most likely T is an enum type (either named or unnamed), in which + // case printing it as an integer is the desired behavior. In case + // T is not an enum, printing it as an integer is the best we can do + // given that it has no user-defined printer. + static void PrintValue(const T& value, ::std::ostream* os) { + const internal::BiggestInt kBigInt = value; + *os << kBigInt; + } +}; + +// Prints the given value to the given ostream. If the value is a +// protocol message, its debug string is printed; if it's an enum or +// of a type implicitly convertible to BiggestInt, it's printed as an +// integer; otherwise the bytes in the value are printed. This is +// what UniversalPrinter<T>::Print() does when it knows nothing about +// type T and T has neither << operator nor PrintTo(). +// +// A user can override this behavior for a class type Foo by defining +// a << operator in the namespace where Foo is defined. +// +// We put this operator in namespace 'internal2' instead of 'internal' +// to simplify the implementation, as much code in 'internal' needs to +// use << in STL, which would conflict with our own << were it defined +// in 'internal'. +// +// Note that this operator<< takes a generic std::basic_ostream<Char, +// CharTraits> type instead of the more restricted std::ostream. If +// we define it to take an std::ostream instead, we'll get an +// "ambiguous overloads" compiler error when trying to print a type +// Foo that supports streaming to std::basic_ostream<Char, +// CharTraits>, as the compiler cannot tell whether +// operator<<(std::ostream&, const T&) or +// operator<<(std::basic_stream<Char, CharTraits>, const Foo&) is more +// specific. +template <typename Char, typename CharTraits, typename T> +::std::basic_ostream<Char, CharTraits>& operator<<( + ::std::basic_ostream<Char, CharTraits>& os, const T& x) { + TypeWithoutFormatter<T, + (internal::IsAProtocolMessage<T>::value ? kProtobuf : + internal::ImplicitlyConvertible<const T&, internal::BiggestInt>::value ? + kConvertibleToInteger : kOtherType)>::PrintValue(x, &os); + return os; +} + +} // namespace internal2 +} // namespace testing + +// This namespace MUST NOT BE NESTED IN ::testing, or the name look-up +// magic needed for implementing UniversalPrinter won't work. +namespace testing_internal { + +// Used to print a value that is not an STL-style container when the +// user doesn't define PrintTo() for it. +template <typename T> +void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) { + // With the following statement, during unqualified name lookup, + // testing::internal2::operator<< appears as if it was declared in + // the nearest enclosing namespace that contains both + // ::testing_internal and ::testing::internal2, i.e. the global + // namespace. For more details, refer to the C++ Standard section + // 7.3.4-1 [namespace.udir]. This allows us to fall back onto + // testing::internal2::operator<< in case T doesn't come with a << + // operator. + // + // We cannot write 'using ::testing::internal2::operator<<;', which + // gcc 3.3 fails to compile due to a compiler bug. + using namespace ::testing::internal2; // NOLINT + + // Assuming T is defined in namespace foo, in the next statement, + // the compiler will consider all of: + // + // 1. foo::operator<< (thanks to Koenig look-up), + // 2. ::operator<< (as the current namespace is enclosed in ::), + // 3. testing::internal2::operator<< (thanks to the using statement above). + // + // The operator<< whose type matches T best will be picked. + // + // We deliberately allow #2 to be a candidate, as sometimes it's + // impossible to define #1 (e.g. when foo is ::std, defining + // anything in it is undefined behavior unless you are a compiler + // vendor.). + *os << value; +} + +} // namespace testing_internal + +namespace testing { +namespace internal { + +// UniversalPrinter<T>::Print(value, ostream_ptr) prints the given +// value to the given ostream. The caller must ensure that +// 'ostream_ptr' is not NULL, or the behavior is undefined. +// +// We define UniversalPrinter as a class template (as opposed to a +// function template), as we need to partially specialize it for +// reference types, which cannot be done with function templates. +template <typename T> +class UniversalPrinter; + +template <typename T> +void UniversalPrint(const T& value, ::std::ostream* os); + +// Used to print an STL-style container when the user doesn't define +// a PrintTo() for it. +template <typename C> +void DefaultPrintTo(IsContainer /* dummy */, + false_type /* is not a pointer */, + const C& container, ::std::ostream* os) { + const size_t kMaxCount = 32; // The maximum number of elements to print. + *os << '{'; + size_t count = 0; + for (typename C::const_iterator it = container.begin(); + it != container.end(); ++it, ++count) { + if (count > 0) { + *os << ','; + if (count == kMaxCount) { // Enough has been printed. + *os << " ..."; + break; + } + } + *os << ' '; + // We cannot call PrintTo(*it, os) here as PrintTo() doesn't + // handle *it being a native array. + internal::UniversalPrint(*it, os); + } + + if (count > 0) { + *os << ' '; + } + *os << '}'; +} + +// Used to print a pointer that is neither a char pointer nor a member +// pointer, when the user doesn't define PrintTo() for it. (A member +// variable pointer or member function pointer doesn't really point to +// a location in the address space. Their representation is +// implementation-defined. Therefore they will be printed as raw +// bytes.) +template <typename T> +void DefaultPrintTo(IsNotContainer /* dummy */, + true_type /* is a pointer */, + T* p, ::std::ostream* os) { + if (p == NULL) { + *os << "NULL"; + } else { + // C++ doesn't allow casting from a function pointer to any object + // pointer. + // + // IsTrue() silences warnings: "Condition is always true", + // "unreachable code". + if (IsTrue(ImplicitlyConvertible<T*, const void*>::value)) { + // T is not a function type. We just call << to print p, + // relying on ADL to pick up user-defined << for their pointer + // types, if any. + *os << p; + } else { + // T is a function type, so '*os << p' doesn't do what we want + // (it just prints p as bool). We want to print p as a const + // void*. However, we cannot cast it to const void* directly, + // even using reinterpret_cast, as earlier versions of gcc + // (e.g. 3.4.5) cannot compile the cast when p is a function + // pointer. Casting to UInt64 first solves the problem. + *os << reinterpret_cast<const void*>( + reinterpret_cast<internal::UInt64>(p)); + } + } +} + +// Used to print a non-container, non-pointer value when the user +// doesn't define PrintTo() for it. +template <typename T> +void DefaultPrintTo(IsNotContainer /* dummy */, + false_type /* is not a pointer */, + const T& value, ::std::ostream* os) { + ::testing_internal::DefaultPrintNonContainerTo(value, os); +} + +// Prints the given value using the << operator if it has one; +// otherwise prints the bytes in it. This is what +// UniversalPrinter<T>::Print() does when PrintTo() is not specialized +// or overloaded for type T. +// +// A user can override this behavior for a class type Foo by defining +// an overload of PrintTo() in the namespace where Foo is defined. We +// give the user this option as sometimes defining a << operator for +// Foo is not desirable (e.g. the coding style may prevent doing it, +// or there is already a << operator but it doesn't do what the user +// wants). +template <typename T> +void PrintTo(const T& value, ::std::ostream* os) { + // DefaultPrintTo() is overloaded. The type of its first two + // arguments determine which version will be picked. If T is an + // STL-style container, the version for container will be called; if + // T is a pointer, the pointer version will be called; otherwise the + // generic version will be called. + // + // Note that we check for container types here, prior to we check + // for protocol message types in our operator<<. The rationale is: + // + // For protocol messages, we want to give people a chance to + // override Google Mock's format by defining a PrintTo() or + // operator<<. For STL containers, other formats can be + // incompatible with Google Mock's format for the container + // elements; therefore we check for container types here to ensure + // that our format is used. + // + // The second argument of DefaultPrintTo() is needed to bypass a bug + // in Symbian's C++ compiler that prevents it from picking the right + // overload between: + // + // PrintTo(const T& x, ...); + // PrintTo(T* x, ...); + DefaultPrintTo(IsContainerTest<T>(0), is_pointer<T>(), value, os); +} + +// The following list of PrintTo() overloads tells +// UniversalPrinter<T>::Print() how to print standard types (built-in +// types, strings, plain arrays, and pointers). + +// Overloads for various char types. +GTEST_API_ void PrintTo(unsigned char c, ::std::ostream* os); +GTEST_API_ void PrintTo(signed char c, ::std::ostream* os); +inline void PrintTo(char c, ::std::ostream* os) { + // When printing a plain char, we always treat it as unsigned. This + // way, the output won't be affected by whether the compiler thinks + // char is signed or not. + PrintTo(static_cast<unsigned char>(c), os); +} + +// Overloads for other simple built-in types. +inline void PrintTo(bool x, ::std::ostream* os) { + *os << (x ? "true" : "false"); +} + +// Overload for wchar_t type. +// Prints a wchar_t as a symbol if it is printable or as its internal +// code otherwise and also as its decimal code (except for L'\0'). +// The L'\0' char is printed as "L'\\0'". The decimal code is printed +// as signed integer when wchar_t is implemented by the compiler +// as a signed type and is printed as an unsigned integer when wchar_t +// is implemented as an unsigned type. +GTEST_API_ void PrintTo(wchar_t wc, ::std::ostream* os); + +// Overloads for C strings. +GTEST_API_ void PrintTo(const char* s, ::std::ostream* os); +inline void PrintTo(char* s, ::std::ostream* os) { + PrintTo(ImplicitCast_<const char*>(s), os); +} + +// signed/unsigned char is often used for representing binary data, so +// we print pointers to it as void* to be safe. +inline void PrintTo(const signed char* s, ::std::ostream* os) { + PrintTo(ImplicitCast_<const void*>(s), os); +} +inline void PrintTo(signed char* s, ::std::ostream* os) { + PrintTo(ImplicitCast_<const void*>(s), os); +} +inline void PrintTo(const unsigned char* s, ::std::ostream* os) { + PrintTo(ImplicitCast_<const void*>(s), os); +} +inline void PrintTo(unsigned char* s, ::std::ostream* os) { + PrintTo(ImplicitCast_<const void*>(s), os); +} + +// MSVC can be configured to define wchar_t as a typedef of unsigned +// short. It defines _NATIVE_WCHAR_T_DEFINED when wchar_t is a native +// type. When wchar_t is a typedef, defining an overload for const +// wchar_t* would cause unsigned short* be printed as a wide string, +// possibly causing invalid memory accesses. +#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED) +// Overloads for wide C strings +GTEST_API_ void PrintTo(const wchar_t* s, ::std::ostream* os); +inline void PrintTo(wchar_t* s, ::std::ostream* os) { + PrintTo(ImplicitCast_<const wchar_t*>(s), os); +} +#endif + +// Overload for C arrays. Multi-dimensional arrays are printed +// properly. + +// Prints the given number of elements in an array, without printing +// the curly braces. +template <typename T> +void PrintRawArrayTo(const T a[], size_t count, ::std::ostream* os) { + UniversalPrint(a[0], os); + for (size_t i = 1; i != count; i++) { + *os << ", "; + UniversalPrint(a[i], os); + } +} + +// Overloads for ::string and ::std::string. +#if GTEST_HAS_GLOBAL_STRING +GTEST_API_ void PrintStringTo(const ::string&s, ::std::ostream* os); +inline void PrintTo(const ::string& s, ::std::ostream* os) { + PrintStringTo(s, os); +} +#endif // GTEST_HAS_GLOBAL_STRING + +GTEST_API_ void PrintStringTo(const ::std::string&s, ::std::ostream* os); +inline void PrintTo(const ::std::string& s, ::std::ostream* os) { + PrintStringTo(s, os); +} + +// Overloads for ::wstring and ::std::wstring. +#if GTEST_HAS_GLOBAL_WSTRING +GTEST_API_ void PrintWideStringTo(const ::wstring&s, ::std::ostream* os); +inline void PrintTo(const ::wstring& s, ::std::ostream* os) { + PrintWideStringTo(s, os); +} +#endif // GTEST_HAS_GLOBAL_WSTRING + +#if GTEST_HAS_STD_WSTRING +GTEST_API_ void PrintWideStringTo(const ::std::wstring&s, ::std::ostream* os); +inline void PrintTo(const ::std::wstring& s, ::std::ostream* os) { + PrintWideStringTo(s, os); +} +#endif // GTEST_HAS_STD_WSTRING + +#if GTEST_HAS_TR1_TUPLE +// Overload for ::std::tr1::tuple. Needed for printing function arguments, +// which are packed as tuples. + +// Helper function for printing a tuple. T must be instantiated with +// a tuple type. +template <typename T> +void PrintTupleTo(const T& t, ::std::ostream* os); + +// Overloaded PrintTo() for tuples of various arities. We support +// tuples of up-to 10 fields. The following implementation works +// regardless of whether tr1::tuple is implemented using the +// non-standard variadic template feature or not. + +inline void PrintTo(const ::std::tr1::tuple<>& t, ::std::ostream* os) { + PrintTupleTo(t, os); +} + +template <typename T1> +void PrintTo(const ::std::tr1::tuple<T1>& t, ::std::ostream* os) { + PrintTupleTo(t, os); +} + +template <typename T1, typename T2> +void PrintTo(const ::std::tr1::tuple<T1, T2>& t, ::std::ostream* os) { + PrintTupleTo(t, os); +} + +template <typename T1, typename T2, typename T3> +void PrintTo(const ::std::tr1::tuple<T1, T2, T3>& t, ::std::ostream* os) { + PrintTupleTo(t, os); +} + +template <typename T1, typename T2, typename T3, typename T4> +void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4>& t, ::std::ostream* os) { + PrintTupleTo(t, os); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5> +void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5>& t, + ::std::ostream* os) { + PrintTupleTo(t, os); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6> +void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6>& t, + ::std::ostream* os) { + PrintTupleTo(t, os); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7> +void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7>& t, + ::std::ostream* os) { + PrintTupleTo(t, os); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8> +void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8>& t, + ::std::ostream* os) { + PrintTupleTo(t, os); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9> +void PrintTo(const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>& t, + ::std::ostream* os) { + PrintTupleTo(t, os); +} + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10> +void PrintTo( + const ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>& t, + ::std::ostream* os) { + PrintTupleTo(t, os); +} +#endif // GTEST_HAS_TR1_TUPLE + +// Overload for std::pair. +template <typename T1, typename T2> +void PrintTo(const ::std::pair<T1, T2>& value, ::std::ostream* os) { + *os << '('; + // We cannot use UniversalPrint(value.first, os) here, as T1 may be + // a reference type. The same for printing value.second. + UniversalPrinter<T1>::Print(value.first, os); + *os << ", "; + UniversalPrinter<T2>::Print(value.second, os); + *os << ')'; +} + +// Implements printing a non-reference type T by letting the compiler +// pick the right overload of PrintTo() for T. +template <typename T> +class UniversalPrinter { + public: + // MSVC warns about adding const to a function type, so we want to + // disable the warning. +#ifdef _MSC_VER +# pragma warning(push) // Saves the current warning state. +# pragma warning(disable:4180) // Temporarily disables warning 4180. +#endif // _MSC_VER + + // Note: we deliberately don't call this PrintTo(), as that name + // conflicts with ::testing::internal::PrintTo in the body of the + // function. + static void Print(const T& value, ::std::ostream* os) { + // By default, ::testing::internal::PrintTo() is used for printing + // the value. + // + // Thanks to Koenig look-up, if T is a class and has its own + // PrintTo() function defined in its namespace, that function will + // be visible here. Since it is more specific than the generic ones + // in ::testing::internal, it will be picked by the compiler in the + // following statement - exactly what we want. + PrintTo(value, os); + } + +#ifdef _MSC_VER +# pragma warning(pop) // Restores the warning state. +#endif // _MSC_VER +}; + +// UniversalPrintArray(begin, len, os) prints an array of 'len' +// elements, starting at address 'begin'. +template <typename T> +void UniversalPrintArray(const T* begin, size_t len, ::std::ostream* os) { + if (len == 0) { + *os << "{}"; + } else { + *os << "{ "; + const size_t kThreshold = 18; + const size_t kChunkSize = 8; + // If the array has more than kThreshold elements, we'll have to + // omit some details by printing only the first and the last + // kChunkSize elements. + // TODO(wan@google.com): let the user control the threshold using a flag. + if (len <= kThreshold) { + PrintRawArrayTo(begin, len, os); + } else { + PrintRawArrayTo(begin, kChunkSize, os); + *os << ", ..., "; + PrintRawArrayTo(begin + len - kChunkSize, kChunkSize, os); + } + *os << " }"; + } +} +// This overload prints a (const) char array compactly. +GTEST_API_ void UniversalPrintArray(const char* begin, + size_t len, + ::std::ostream* os); + +// Implements printing an array type T[N]. +template <typename T, size_t N> +class UniversalPrinter<T[N]> { + public: + // Prints the given array, omitting some elements when there are too + // many. + static void Print(const T (&a)[N], ::std::ostream* os) { + UniversalPrintArray(a, N, os); + } +}; + +// Implements printing a reference type T&. +template <typename T> +class UniversalPrinter<T&> { + public: + // MSVC warns about adding const to a function type, so we want to + // disable the warning. +#ifdef _MSC_VER +# pragma warning(push) // Saves the current warning state. +# pragma warning(disable:4180) // Temporarily disables warning 4180. +#endif // _MSC_VER + + static void Print(const T& value, ::std::ostream* os) { + // Prints the address of the value. We use reinterpret_cast here + // as static_cast doesn't compile when T is a function type. + *os << "@" << reinterpret_cast<const void*>(&value) << " "; + + // Then prints the value itself. + UniversalPrint(value, os); + } + +#ifdef _MSC_VER +# pragma warning(pop) // Restores the warning state. +#endif // _MSC_VER +}; + +// Prints a value tersely: for a reference type, the referenced value +// (but not the address) is printed; for a (const) char pointer, the +// NUL-terminated string (but not the pointer) is printed. +template <typename T> +void UniversalTersePrint(const T& value, ::std::ostream* os) { + UniversalPrint(value, os); +} +inline void UniversalTersePrint(const char* str, ::std::ostream* os) { + if (str == NULL) { + *os << "NULL"; + } else { + UniversalPrint(string(str), os); + } +} +inline void UniversalTersePrint(char* str, ::std::ostream* os) { + UniversalTersePrint(static_cast<const char*>(str), os); +} + +// Prints a value using the type inferred by the compiler. The +// difference between this and UniversalTersePrint() is that for a +// (const) char pointer, this prints both the pointer and the +// NUL-terminated string. +template <typename T> +void UniversalPrint(const T& value, ::std::ostream* os) { + UniversalPrinter<T>::Print(value, os); +} + +#if GTEST_HAS_TR1_TUPLE +typedef ::std::vector<string> Strings; + +// This helper template allows PrintTo() for tuples and +// UniversalTersePrintTupleFieldsToStrings() to be defined by +// induction on the number of tuple fields. The idea is that +// TuplePrefixPrinter<N>::PrintPrefixTo(t, os) prints the first N +// fields in tuple t, and can be defined in terms of +// TuplePrefixPrinter<N - 1>. + +// The inductive case. +template <size_t N> +struct TuplePrefixPrinter { + // Prints the first N fields of a tuple. + template <typename Tuple> + static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) { + TuplePrefixPrinter<N - 1>::PrintPrefixTo(t, os); + *os << ", "; + UniversalPrinter<typename ::std::tr1::tuple_element<N - 1, Tuple>::type> + ::Print(::std::tr1::get<N - 1>(t), os); + } + + // Tersely prints the first N fields of a tuple to a string vector, + // one element for each field. + template <typename Tuple> + static void TersePrintPrefixToStrings(const Tuple& t, Strings* strings) { + TuplePrefixPrinter<N - 1>::TersePrintPrefixToStrings(t, strings); + ::std::stringstream ss; + UniversalTersePrint(::std::tr1::get<N - 1>(t), &ss); + strings->push_back(ss.str()); + } +}; + +// Base cases. +template <> +struct TuplePrefixPrinter<0> { + template <typename Tuple> + static void PrintPrefixTo(const Tuple&, ::std::ostream*) {} + + template <typename Tuple> + static void TersePrintPrefixToStrings(const Tuple&, Strings*) {} +}; +// We have to specialize the entire TuplePrefixPrinter<> class +// template here, even though the definition of +// TersePrintPrefixToStrings() is the same as the generic version, as +// Embarcadero (formerly CodeGear, formerly Borland) C++ doesn't +// support specializing a method template of a class template. +template <> +struct TuplePrefixPrinter<1> { + template <typename Tuple> + static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) { + UniversalPrinter<typename ::std::tr1::tuple_element<0, Tuple>::type>:: + Print(::std::tr1::get<0>(t), os); + } + + template <typename Tuple> + static void TersePrintPrefixToStrings(const Tuple& t, Strings* strings) { + ::std::stringstream ss; + UniversalTersePrint(::std::tr1::get<0>(t), &ss); + strings->push_back(ss.str()); + } +}; + +// Helper function for printing a tuple. T must be instantiated with +// a tuple type. +template <typename T> +void PrintTupleTo(const T& t, ::std::ostream* os) { + *os << "("; + TuplePrefixPrinter< ::std::tr1::tuple_size<T>::value>:: + PrintPrefixTo(t, os); + *os << ")"; +} + +// Prints the fields of a tuple tersely to a string vector, one +// element for each field. See the comment before +// UniversalTersePrint() for how we define "tersely". +template <typename Tuple> +Strings UniversalTersePrintTupleFieldsToStrings(const Tuple& value) { + Strings result; + TuplePrefixPrinter< ::std::tr1::tuple_size<Tuple>::value>:: + TersePrintPrefixToStrings(value, &result); + return result; +} +#endif // GTEST_HAS_TR1_TUPLE + +} // namespace internal + +template <typename T> +::std::string PrintToString(const T& value) { + ::std::stringstream ss; + internal::UniversalTersePrint(value, &ss); + return ss.str(); +} + +} // namespace testing + +#endif // GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_ diff --git a/tests/gtest/include/gtest/gtest-spi.h b/tests/gtest/include/gtest/gtest-spi.h new file mode 100644 index 000000000..b226e5504 --- /dev/null +++ b/tests/gtest/include/gtest/gtest-spi.h @@ -0,0 +1,232 @@ +// Copyright 2007, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Author: wan@google.com (Zhanyong Wan) +// +// Utilities for testing Google Test itself and code that uses Google Test +// (e.g. frameworks built on top of Google Test). + +#ifndef GTEST_INCLUDE_GTEST_GTEST_SPI_H_ +#define GTEST_INCLUDE_GTEST_GTEST_SPI_H_ + +#include "gtest/gtest.h" + +namespace testing { + +// This helper class can be used to mock out Google Test failure reporting +// so that we can test Google Test or code that builds on Google Test. +// +// An object of this class appends a TestPartResult object to the +// TestPartResultArray object given in the constructor whenever a Google Test +// failure is reported. It can either intercept only failures that are +// generated in the same thread that created this object or it can intercept +// all generated failures. The scope of this mock object can be controlled with +// the second argument to the two arguments constructor. +class GTEST_API_ ScopedFakeTestPartResultReporter + : public TestPartResultReporterInterface { + public: + // The two possible mocking modes of this object. + enum InterceptMode { + INTERCEPT_ONLY_CURRENT_THREAD, // Intercepts only thread local failures. + INTERCEPT_ALL_THREADS // Intercepts all failures. + }; + + // The c'tor sets this object as the test part result reporter used + // by Google Test. The 'result' parameter specifies where to report the + // results. This reporter will only catch failures generated in the current + // thread. DEPRECATED + explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result); + + // Same as above, but you can choose the interception scope of this object. + ScopedFakeTestPartResultReporter(InterceptMode intercept_mode, + TestPartResultArray* result); + + // The d'tor restores the previous test part result reporter. + virtual ~ScopedFakeTestPartResultReporter(); + + // Appends the TestPartResult object to the TestPartResultArray + // received in the constructor. + // + // This method is from the TestPartResultReporterInterface + // interface. + virtual void ReportTestPartResult(const TestPartResult& result); + private: + void Init(); + + const InterceptMode intercept_mode_; + TestPartResultReporterInterface* old_reporter_; + TestPartResultArray* const result_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter); +}; + +namespace internal { + +// A helper class for implementing EXPECT_FATAL_FAILURE() and +// EXPECT_NONFATAL_FAILURE(). Its destructor verifies that the given +// TestPartResultArray contains exactly one failure that has the given +// type and contains the given substring. If that's not the case, a +// non-fatal failure will be generated. +class GTEST_API_ SingleFailureChecker { + public: + // The constructor remembers the arguments. + SingleFailureChecker(const TestPartResultArray* results, + TestPartResult::Type type, + const string& substr); + ~SingleFailureChecker(); + private: + const TestPartResultArray* const results_; + const TestPartResult::Type type_; + const string substr_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker); +}; + +} // namespace internal + +} // namespace testing + +// A set of macros for testing Google Test assertions or code that's expected +// to generate Google Test fatal failures. It verifies that the given +// statement will cause exactly one fatal Google Test failure with 'substr' +// being part of the failure message. +// +// There are two different versions of this macro. EXPECT_FATAL_FAILURE only +// affects and considers failures generated in the current thread and +// EXPECT_FATAL_FAILURE_ON_ALL_THREADS does the same but for all threads. +// +// The verification of the assertion is done correctly even when the statement +// throws an exception or aborts the current function. +// +// Known restrictions: +// - 'statement' cannot reference local non-static variables or +// non-static members of the current object. +// - 'statement' cannot return a value. +// - You cannot stream a failure message to this macro. +// +// Note that even though the implementations of the following two +// macros are much alike, we cannot refactor them to use a common +// helper macro, due to some peculiarity in how the preprocessor +// works. The AcceptsMacroThatExpandsToUnprotectedComma test in +// gtest_unittest.cc will fail to compile if we do that. +#define EXPECT_FATAL_FAILURE(statement, substr) \ + do { \ + class GTestExpectFatalFailureHelper {\ + public:\ + static void Execute() { statement; }\ + };\ + ::testing::TestPartResultArray gtest_failures;\ + ::testing::internal::SingleFailureChecker gtest_checker(\ + >est_failures, ::testing::TestPartResult::kFatalFailure, (substr));\ + {\ + ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ + ::testing::ScopedFakeTestPartResultReporter:: \ + INTERCEPT_ONLY_CURRENT_THREAD, >est_failures);\ + GTestExpectFatalFailureHelper::Execute();\ + }\ + } while (::testing::internal::AlwaysFalse()) + +#define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \ + do { \ + class GTestExpectFatalFailureHelper {\ + public:\ + static void Execute() { statement; }\ + };\ + ::testing::TestPartResultArray gtest_failures;\ + ::testing::internal::SingleFailureChecker gtest_checker(\ + >est_failures, ::testing::TestPartResult::kFatalFailure, (substr));\ + {\ + ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ + ::testing::ScopedFakeTestPartResultReporter:: \ + INTERCEPT_ALL_THREADS, >est_failures);\ + GTestExpectFatalFailureHelper::Execute();\ + }\ + } while (::testing::internal::AlwaysFalse()) + +// A macro for testing Google Test assertions or code that's expected to +// generate Google Test non-fatal failures. It asserts that the given +// statement will cause exactly one non-fatal Google Test failure with 'substr' +// being part of the failure message. +// +// There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only +// affects and considers failures generated in the current thread and +// EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all threads. +// +// 'statement' is allowed to reference local variables and members of +// the current object. +// +// The verification of the assertion is done correctly even when the statement +// throws an exception or aborts the current function. +// +// Known restrictions: +// - You cannot stream a failure message to this macro. +// +// Note that even though the implementations of the following two +// macros are much alike, we cannot refactor them to use a common +// helper macro, due to some peculiarity in how the preprocessor +// works. If we do that, the code won't compile when the user gives +// EXPECT_NONFATAL_FAILURE() a statement that contains a macro that +// expands to code containing an unprotected comma. The +// AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc +// catches that. +// +// For the same reason, we have to write +// if (::testing::internal::AlwaysTrue()) { statement; } +// instead of +// GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) +// to avoid an MSVC warning on unreachable code. +#define EXPECT_NONFATAL_FAILURE(statement, substr) \ + do {\ + ::testing::TestPartResultArray gtest_failures;\ + ::testing::internal::SingleFailureChecker gtest_checker(\ + >est_failures, ::testing::TestPartResult::kNonFatalFailure, \ + (substr));\ + {\ + ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ + ::testing::ScopedFakeTestPartResultReporter:: \ + INTERCEPT_ONLY_CURRENT_THREAD, >est_failures);\ + if (::testing::internal::AlwaysTrue()) { statement; }\ + }\ + } while (::testing::internal::AlwaysFalse()) + +#define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \ + do {\ + ::testing::TestPartResultArray gtest_failures;\ + ::testing::internal::SingleFailureChecker gtest_checker(\ + >est_failures, ::testing::TestPartResult::kNonFatalFailure, \ + (substr));\ + {\ + ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ + ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS,\ + >est_failures);\ + if (::testing::internal::AlwaysTrue()) { statement; }\ + }\ + } while (::testing::internal::AlwaysFalse()) + +#endif // GTEST_INCLUDE_GTEST_GTEST_SPI_H_ diff --git a/tests/gtest/include/gtest/gtest-test-part.h b/tests/gtest/include/gtest/gtest-test-part.h new file mode 100644 index 000000000..8aeea1498 --- /dev/null +++ b/tests/gtest/include/gtest/gtest-test-part.h @@ -0,0 +1,176 @@ +// Copyright 2008, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Author: mheule@google.com (Markus Heule) +// + +#ifndef GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_ +#define GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_ + +#include <iosfwd> +#include <vector> +#include "gtest/internal/gtest-internal.h" +#include "gtest/internal/gtest-string.h" + +namespace testing { + +// A copyable object representing the result of a test part (i.e. an +// assertion or an explicit FAIL(), ADD_FAILURE(), or SUCCESS()). +// +// Don't inherit from TestPartResult as its destructor is not virtual. +class GTEST_API_ TestPartResult { + public: + // The possible outcomes of a test part (i.e. an assertion or an + // explicit SUCCEED(), FAIL(), or ADD_FAILURE()). + enum Type { + kSuccess, // Succeeded. + kNonFatalFailure, // Failed but the test can continue. + kFatalFailure // Failed and the test should be terminated. + }; + + // C'tor. TestPartResult does NOT have a default constructor. + // Always use this constructor (with parameters) to create a + // TestPartResult object. + TestPartResult(Type a_type, + const char* a_file_name, + int a_line_number, + const char* a_message) + : type_(a_type), + file_name_(a_file_name), + line_number_(a_line_number), + summary_(ExtractSummary(a_message)), + message_(a_message) { + } + + // Gets the outcome of the test part. + Type type() const { return type_; } + + // Gets the name of the source file where the test part took place, or + // NULL if it's unknown. + const char* file_name() const { return file_name_.c_str(); } + + // Gets the line in the source file where the test part took place, + // or -1 if it's unknown. + int line_number() const { return line_number_; } + + // Gets the summary of the failure message. + const char* summary() const { return summary_.c_str(); } + + // Gets the message associated with the test part. + const char* message() const { return message_.c_str(); } + + // Returns true iff the test part passed. + bool passed() const { return type_ == kSuccess; } + + // Returns true iff the test part failed. + bool failed() const { return type_ != kSuccess; } + + // Returns true iff the test part non-fatally failed. + bool nonfatally_failed() const { return type_ == kNonFatalFailure; } + + // Returns true iff the test part fatally failed. + bool fatally_failed() const { return type_ == kFatalFailure; } + private: + Type type_; + + // Gets the summary of the failure message by omitting the stack + // trace in it. + static internal::String ExtractSummary(const char* message); + + // The name of the source file where the test part took place, or + // NULL if the source file is unknown. + internal::String file_name_; + // The line in the source file where the test part took place, or -1 + // if the line number is unknown. + int line_number_; + internal::String summary_; // The test failure summary. + internal::String message_; // The test failure message. +}; + +// Prints a TestPartResult object. +std::ostream& operator<<(std::ostream& os, const TestPartResult& result); + +// An array of TestPartResult objects. +// +// Don't inherit from TestPartResultArray as its destructor is not +// virtual. +class GTEST_API_ TestPartResultArray { + public: + TestPartResultArray() {} + + // Appends the given TestPartResult to the array. + void Append(const TestPartResult& result); + + // Returns the TestPartResult at the given index (0-based). + const TestPartResult& GetTestPartResult(int index) const; + + // Returns the number of TestPartResult objects in the array. + int size() const; + + private: + std::vector<TestPartResult> array_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(TestPartResultArray); +}; + +// This interface knows how to report a test part result. +class TestPartResultReporterInterface { + public: + virtual ~TestPartResultReporterInterface() {} + + virtual void ReportTestPartResult(const TestPartResult& result) = 0; +}; + +namespace internal { + +// This helper class is used by {ASSERT|EXPECT}_NO_FATAL_FAILURE to check if a +// statement generates new fatal failures. To do so it registers itself as the +// current test part result reporter. Besides checking if fatal failures were +// reported, it only delegates the reporting to the former result reporter. +// The original result reporter is restored in the destructor. +// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. +class GTEST_API_ HasNewFatalFailureHelper + : public TestPartResultReporterInterface { + public: + HasNewFatalFailureHelper(); + virtual ~HasNewFatalFailureHelper(); + virtual void ReportTestPartResult(const TestPartResult& result); + bool has_new_fatal_failure() const { return has_new_fatal_failure_; } + private: + bool has_new_fatal_failure_; + TestPartResultReporterInterface* original_reporter_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(HasNewFatalFailureHelper); +}; + +} // namespace internal + +} // namespace testing + +#endif // GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_ diff --git a/tests/gtest/include/gtest/gtest-typed-test.h b/tests/gtest/include/gtest/gtest-typed-test.h new file mode 100644 index 000000000..fe1e83b27 --- /dev/null +++ b/tests/gtest/include/gtest/gtest-typed-test.h @@ -0,0 +1,259 @@ +// Copyright 2008 Google Inc. +// All Rights Reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Author: wan@google.com (Zhanyong Wan) + +#ifndef GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_ +#define GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_ + +// This header implements typed tests and type-parameterized tests. + +// Typed (aka type-driven) tests repeat the same test for types in a +// list. You must know which types you want to test with when writing +// typed tests. Here's how you do it: + +#if 0 + +// First, define a fixture class template. It should be parameterized +// by a type. Remember to derive it from testing::Test. +template <typename T> +class FooTest : public testing::Test { + public: + ... + typedef std::list<T> List; + static T shared_; + T value_; +}; + +// Next, associate a list of types with the test case, which will be +// repeated for each type in the list. The typedef is necessary for +// the macro to parse correctly. +typedef testing::Types<char, int, unsigned int> MyTypes; +TYPED_TEST_CASE(FooTest, MyTypes); + +// If the type list contains only one type, you can write that type +// directly without Types<...>: +// TYPED_TEST_CASE(FooTest, int); + +// Then, use TYPED_TEST() instead of TEST_F() to define as many typed +// tests for this test case as you want. +TYPED_TEST(FooTest, DoesBlah) { + // Inside a test, refer to TypeParam to get the type parameter. + // Since we are inside a derived class template, C++ requires use to + // visit the members of FooTest via 'this'. + TypeParam n = this->value_; + + // To visit static members of the fixture, add the TestFixture:: + // prefix. + n += TestFixture::shared_; + + // To refer to typedefs in the fixture, add the "typename + // TestFixture::" prefix. + typename TestFixture::List values; + values.push_back(n); + ... +} + +TYPED_TEST(FooTest, HasPropertyA) { ... } + +#endif // 0 + +// Type-parameterized tests are abstract test patterns parameterized +// by a type. Compared with typed tests, type-parameterized tests +// allow you to define the test pattern without knowing what the type +// parameters are. The defined pattern can be instantiated with +// different types any number of times, in any number of translation +// units. +// +// If you are designing an interface or concept, you can define a +// suite of type-parameterized tests to verify properties that any +// valid implementation of the interface/concept should have. Then, +// each implementation can easily instantiate the test suite to verify +// that it conforms to the requirements, without having to write +// similar tests repeatedly. Here's an example: + +#if 0 + +// First, define a fixture class template. It should be parameterized +// by a type. Remember to derive it from testing::Test. +template <typename T> +class FooTest : public testing::Test { + ... +}; + +// Next, declare that you will define a type-parameterized test case +// (the _P suffix is for "parameterized" or "pattern", whichever you +// prefer): +TYPED_TEST_CASE_P(FooTest); + +// Then, use TYPED_TEST_P() to define as many type-parameterized tests +// for this type-parameterized test case as you want. +TYPED_TEST_P(FooTest, DoesBlah) { + // Inside a test, refer to TypeParam to get the type parameter. + TypeParam n = 0; + ... +} + +TYPED_TEST_P(FooTest, HasPropertyA) { ... } + +// Now the tricky part: you need to register all test patterns before +// you can instantiate them. The first argument of the macro is the +// test case name; the rest are the names of the tests in this test +// case. +REGISTER_TYPED_TEST_CASE_P(FooTest, + DoesBlah, HasPropertyA); + +// Finally, you are free to instantiate the pattern with the types you +// want. If you put the above code in a header file, you can #include +// it in multiple C++ source files and instantiate it multiple times. +// +// To distinguish different instances of the pattern, the first +// argument to the INSTANTIATE_* macro is a prefix that will be added +// to the actual test case name. Remember to pick unique prefixes for +// different instances. +typedef testing::Types<char, int, unsigned int> MyTypes; +INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes); + +// If the type list contains only one type, you can write that type +// directly without Types<...>: +// INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, int); + +#endif // 0 + +#include "gtest/internal/gtest-port.h" +#include "gtest/internal/gtest-type-util.h" + +// Implements typed tests. + +#if GTEST_HAS_TYPED_TEST + +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// +// Expands to the name of the typedef for the type parameters of the +// given test case. +# define GTEST_TYPE_PARAMS_(TestCaseName) gtest_type_params_##TestCaseName##_ + +// The 'Types' template argument below must have spaces around it +// since some compilers may choke on '>>' when passing a template +// instance (e.g. Types<int>) +# define TYPED_TEST_CASE(CaseName, Types) \ + typedef ::testing::internal::TypeList< Types >::type \ + GTEST_TYPE_PARAMS_(CaseName) + +# define TYPED_TEST(CaseName, TestName) \ + template <typename gtest_TypeParam_> \ + class GTEST_TEST_CLASS_NAME_(CaseName, TestName) \ + : public CaseName<gtest_TypeParam_> { \ + private: \ + typedef CaseName<gtest_TypeParam_> TestFixture; \ + typedef gtest_TypeParam_ TypeParam; \ + virtual void TestBody(); \ + }; \ + bool gtest_##CaseName##_##TestName##_registered_ GTEST_ATTRIBUTE_UNUSED_ = \ + ::testing::internal::TypeParameterizedTest< \ + CaseName, \ + ::testing::internal::TemplateSel< \ + GTEST_TEST_CLASS_NAME_(CaseName, TestName)>, \ + GTEST_TYPE_PARAMS_(CaseName)>::Register(\ + "", #CaseName, #TestName, 0); \ + template <typename gtest_TypeParam_> \ + void GTEST_TEST_CLASS_NAME_(CaseName, TestName)<gtest_TypeParam_>::TestBody() + +#endif // GTEST_HAS_TYPED_TEST + +// Implements type-parameterized tests. + +#if GTEST_HAS_TYPED_TEST_P + +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// +// Expands to the namespace name that the type-parameterized tests for +// the given type-parameterized test case are defined in. The exact +// name of the namespace is subject to change without notice. +# define GTEST_CASE_NAMESPACE_(TestCaseName) \ + gtest_case_##TestCaseName##_ + +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// +// Expands to the name of the variable used to remember the names of +// the defined tests in the given test case. +# define GTEST_TYPED_TEST_CASE_P_STATE_(TestCaseName) \ + gtest_typed_test_case_p_state_##TestCaseName##_ + +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE DIRECTLY. +// +// Expands to the name of the variable used to remember the names of +// the registered tests in the given test case. +# define GTEST_REGISTERED_TEST_NAMES_(TestCaseName) \ + gtest_registered_test_names_##TestCaseName##_ + +// The variables defined in the type-parameterized test macros are +// static as typically these macros are used in a .h file that can be +// #included in multiple translation units linked together. +# define TYPED_TEST_CASE_P(CaseName) \ + static ::testing::internal::TypedTestCasePState \ + GTEST_TYPED_TEST_CASE_P_STATE_(CaseName) + +# define TYPED_TEST_P(CaseName, TestName) \ + namespace GTEST_CASE_NAMESPACE_(CaseName) { \ + template <typename gtest_TypeParam_> \ + class TestName : public CaseName<gtest_TypeParam_> { \ + private: \ + typedef CaseName<gtest_TypeParam_> TestFixture; \ + typedef gtest_TypeParam_ TypeParam; \ + virtual void TestBody(); \ + }; \ + static bool gtest_##TestName##_defined_ GTEST_ATTRIBUTE_UNUSED_ = \ + GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).AddTestName(\ + __FILE__, __LINE__, #CaseName, #TestName); \ + } \ + template <typename gtest_TypeParam_> \ + void GTEST_CASE_NAMESPACE_(CaseName)::TestName<gtest_TypeParam_>::TestBody() + +# define REGISTER_TYPED_TEST_CASE_P(CaseName, ...) \ + namespace GTEST_CASE_NAMESPACE_(CaseName) { \ + typedef ::testing::internal::Templates<__VA_ARGS__>::type gtest_AllTests_; \ + } \ + static const char* const GTEST_REGISTERED_TEST_NAMES_(CaseName) = \ + GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).VerifyRegisteredTestNames(\ + __FILE__, __LINE__, #__VA_ARGS__) + +// The 'Types' template argument below must have spaces around it +// since some compilers may choke on '>>' when passing a template +// instance (e.g. Types<int>) +# define INSTANTIATE_TYPED_TEST_CASE_P(Prefix, CaseName, Types) \ + bool gtest_##Prefix##_##CaseName GTEST_ATTRIBUTE_UNUSED_ = \ + ::testing::internal::TypeParameterizedTestCase<CaseName, \ + GTEST_CASE_NAMESPACE_(CaseName)::gtest_AllTests_, \ + ::testing::internal::TypeList< Types >::type>::Register(\ + #Prefix, #CaseName, GTEST_REGISTERED_TEST_NAMES_(CaseName)) + +#endif // GTEST_HAS_TYPED_TEST_P + +#endif // GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_ diff --git a/tests/gtest/include/gtest/gtest.h b/tests/gtest/include/gtest/gtest.h new file mode 100644 index 000000000..1e5154715 --- /dev/null +++ b/tests/gtest/include/gtest/gtest.h @@ -0,0 +1,2164 @@ +// Copyright 2005, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Author: wan@google.com (Zhanyong Wan) +// +// The Google C++ Testing Framework (Google Test) +// +// This header file defines the public API for Google Test. It should be +// included by any test program that uses Google Test. +// +// IMPORTANT NOTE: Due to limitation of the C++ language, we have to +// leave some internal implementation details in this header file. +// They are clearly marked by comments like this: +// +// // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. +// +// Such code is NOT meant to be used by a user directly, and is subject +// to CHANGE WITHOUT NOTICE. Therefore DO NOT DEPEND ON IT in a user +// program! +// +// Acknowledgment: Google Test borrowed the idea of automatic test +// registration from Barthelemy Dagenais' (barthelemy@prologique.com) +// easyUnit framework. + +#ifndef GTEST_INCLUDE_GTEST_GTEST_H_ +#define GTEST_INCLUDE_GTEST_GTEST_H_ + +#include <limits> +#include <vector> + +#include "gtest/internal/gtest-internal.h" +#include "gtest/internal/gtest-string.h" +#include "gtest/gtest-death-test.h" +#include "gtest/gtest-message.h" +#include "gtest/gtest-param-test.h" +#include "gtest/gtest-printers.h" +#include "gtest/gtest_prod.h" +#include "gtest/gtest-test-part.h" +#include "gtest/gtest-typed-test.h" + +// Depending on the platform, different string classes are available. +// On Linux, in addition to ::std::string, Google also makes use of +// class ::string, which has the same interface as ::std::string, but +// has a different implementation. +// +// The user can define GTEST_HAS_GLOBAL_STRING to 1 to indicate that +// ::string is available AND is a distinct type to ::std::string, or +// define it to 0 to indicate otherwise. +// +// If the user's ::std::string and ::string are the same class due to +// aliasing, he should define GTEST_HAS_GLOBAL_STRING to 0. +// +// If the user doesn't define GTEST_HAS_GLOBAL_STRING, it is defined +// heuristically. + +namespace testing { + +// Declares the flags. + +// This flag temporary enables the disabled tests. +GTEST_DECLARE_bool_(also_run_disabled_tests); + +// This flag brings the debugger on an assertion failure. +GTEST_DECLARE_bool_(break_on_failure); + +// This flag controls whether Google Test catches all test-thrown exceptions +// and logs them as failures. +GTEST_DECLARE_bool_(catch_exceptions); + +// This flag enables using colors in terminal output. Available values are +// "yes" to enable colors, "no" (disable colors), or "auto" (the default) +// to let Google Test decide. +GTEST_DECLARE_string_(color); + +// This flag sets up the filter to select by name using a glob pattern +// the tests to run. If the filter is not given all tests are executed. +GTEST_DECLARE_string_(filter); + +// This flag causes the Google Test to list tests. None of the tests listed +// are actually run if the flag is provided. +GTEST_DECLARE_bool_(list_tests); + +// This flag controls whether Google Test emits a detailed XML report to a file +// in addition to its normal textual output. +GTEST_DECLARE_string_(output); + +// This flags control whether Google Test prints the elapsed time for each +// test. +GTEST_DECLARE_bool_(print_time); + +// This flag specifies the random number seed. +GTEST_DECLARE_int32_(random_seed); + +// This flag sets how many times the tests are repeated. The default value +// is 1. If the value is -1 the tests are repeating forever. +GTEST_DECLARE_int32_(repeat); + +// This flag controls whether Google Test includes Google Test internal +// stack frames in failure stack traces. +GTEST_DECLARE_bool_(show_internal_stack_frames); + +// When this flag is specified, tests' order is randomized on every iteration. +GTEST_DECLARE_bool_(shuffle); + +// This flag specifies the maximum number of stack frames to be +// printed in a failure message. +GTEST_DECLARE_int32_(stack_trace_depth); + +// When this flag is specified, a failed assertion will throw an +// exception if exceptions are enabled, or exit the program with a +// non-zero code otherwise. +GTEST_DECLARE_bool_(throw_on_failure); + +// When this flag is set with a "host:port" string, on supported +// platforms test results are streamed to the specified port on +// the specified host machine. +GTEST_DECLARE_string_(stream_result_to); + +// The upper limit for valid stack trace depths. +const int kMaxStackTraceDepth = 100; + +namespace internal { + +class AssertHelper; +class DefaultGlobalTestPartResultReporter; +class ExecDeathTest; +class NoExecDeathTest; +class FinalSuccessChecker; +class GTestFlagSaver; +class TestResultAccessor; +class TestEventListenersAccessor; +class TestEventRepeater; +class WindowsDeathTest; +class UnitTestImpl* GetUnitTestImpl(); +void ReportFailureInUnknownLocation(TestPartResult::Type result_type, + const String& message); + +// Converts a streamable value to a String. A NULL pointer is +// converted to "(null)". When the input value is a ::string, +// ::std::string, ::wstring, or ::std::wstring object, each NUL +// character in it is replaced with "\\0". +// Declared in gtest-internal.h but defined here, so that it has access +// to the definition of the Message class, required by the ARM +// compiler. +template <typename T> +String StreamableToString(const T& streamable) { + return (Message() << streamable).GetString(); +} + +} // namespace internal + +// The friend relationship of some of these classes is cyclic. +// If we don't forward declare them the compiler might confuse the classes +// in friendship clauses with same named classes on the scope. +class Test; +class TestCase; +class TestInfo; +class UnitTest; + +// A class for indicating whether an assertion was successful. When +// the assertion wasn't successful, the AssertionResult object +// remembers a non-empty message that describes how it failed. +// +// To create an instance of this class, use one of the factory functions +// (AssertionSuccess() and AssertionFailure()). +// +// This class is useful for two purposes: +// 1. Defining predicate functions to be used with Boolean test assertions +// EXPECT_TRUE/EXPECT_FALSE and their ASSERT_ counterparts +// 2. Defining predicate-format functions to be +// used with predicate assertions (ASSERT_PRED_FORMAT*, etc). +// +// For example, if you define IsEven predicate: +// +// testing::AssertionResult IsEven(int n) { +// if ((n % 2) == 0) +// return testing::AssertionSuccess(); +// else +// return testing::AssertionFailure() << n << " is odd"; +// } +// +// Then the failed expectation EXPECT_TRUE(IsEven(Fib(5))) +// will print the message +// +// Value of: IsEven(Fib(5)) +// Actual: false (5 is odd) +// Expected: true +// +// instead of a more opaque +// +// Value of: IsEven(Fib(5)) +// Actual: false +// Expected: true +// +// in case IsEven is a simple Boolean predicate. +// +// If you expect your predicate to be reused and want to support informative +// messages in EXPECT_FALSE and ASSERT_FALSE (negative assertions show up +// about half as often as positive ones in our tests), supply messages for +// both success and failure cases: +// +// testing::AssertionResult IsEven(int n) { +// if ((n % 2) == 0) +// return testing::AssertionSuccess() << n << " is even"; +// else +// return testing::AssertionFailure() << n << " is odd"; +// } +// +// Then a statement EXPECT_FALSE(IsEven(Fib(6))) will print +// +// Value of: IsEven(Fib(6)) +// Actual: true (8 is even) +// Expected: false +// +// NB: Predicates that support negative Boolean assertions have reduced +// performance in positive ones so be careful not to use them in tests +// that have lots (tens of thousands) of positive Boolean assertions. +// +// To use this class with EXPECT_PRED_FORMAT assertions such as: +// +// // Verifies that Foo() returns an even number. +// EXPECT_PRED_FORMAT1(IsEven, Foo()); +// +// you need to define: +// +// testing::AssertionResult IsEven(const char* expr, int n) { +// if ((n % 2) == 0) +// return testing::AssertionSuccess(); +// else +// return testing::AssertionFailure() +// << "Expected: " << expr << " is even\n Actual: it's " << n; +// } +// +// If Foo() returns 5, you will see the following message: +// +// Expected: Foo() is even +// Actual: it's 5 +// +class GTEST_API_ AssertionResult { + public: + // Copy constructor. + // Used in EXPECT_TRUE/FALSE(assertion_result). + AssertionResult(const AssertionResult& other); + // Used in the EXPECT_TRUE/FALSE(bool_expression). + explicit AssertionResult(bool success) : success_(success) {} + + // Returns true iff the assertion succeeded. + operator bool() const { return success_; } // NOLINT + + // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE. + AssertionResult operator!() const; + + // Returns the text streamed into this AssertionResult. Test assertions + // use it when they fail (i.e., the predicate's outcome doesn't match the + // assertion's expectation). When nothing has been streamed into the + // object, returns an empty string. + const char* message() const { + return message_.get() != NULL ? message_->c_str() : ""; + } + // TODO(vladl@google.com): Remove this after making sure no clients use it. + // Deprecated; please use message() instead. + const char* failure_message() const { return message(); } + + // Streams a custom failure message into this object. + template <typename T> AssertionResult& operator<<(const T& value) { + AppendMessage(Message() << value); + return *this; + } + + // Allows streaming basic output manipulators such as endl or flush into + // this object. + AssertionResult& operator<<( + ::std::ostream& (*basic_manipulator)(::std::ostream& stream)) { + AppendMessage(Message() << basic_manipulator); + return *this; + } + + private: + // Appends the contents of message to message_. + void AppendMessage(const Message& a_message) { + if (message_.get() == NULL) + message_.reset(new ::std::string); + message_->append(a_message.GetString().c_str()); + } + + // Stores result of the assertion predicate. + bool success_; + // Stores the message describing the condition in case the expectation + // construct is not satisfied with the predicate's outcome. + // Referenced via a pointer to avoid taking too much stack frame space + // with test assertions. + internal::scoped_ptr< ::std::string> message_; + + GTEST_DISALLOW_ASSIGN_(AssertionResult); +}; + +// Makes a successful assertion result. +GTEST_API_ AssertionResult AssertionSuccess(); + +// Makes a failed assertion result. +GTEST_API_ AssertionResult AssertionFailure(); + +// Makes a failed assertion result with the given failure message. +// Deprecated; use AssertionFailure() << msg. +GTEST_API_ AssertionResult AssertionFailure(const Message& msg); + +// The abstract class that all tests inherit from. +// +// In Google Test, a unit test program contains one or many TestCases, and +// each TestCase contains one or many Tests. +// +// When you define a test using the TEST macro, you don't need to +// explicitly derive from Test - the TEST macro automatically does +// this for you. +// +// The only time you derive from Test is when defining a test fixture +// to be used a TEST_F. For example: +// +// class FooTest : public testing::Test { +// protected: +// virtual void SetUp() { ... } +// virtual void TearDown() { ... } +// ... +// }; +// +// TEST_F(FooTest, Bar) { ... } +// TEST_F(FooTest, Baz) { ... } +// +// Test is not copyable. +class GTEST_API_ Test { + public: + friend class TestInfo; + + // Defines types for pointers to functions that set up and tear down + // a test case. + typedef internal::SetUpTestCaseFunc SetUpTestCaseFunc; + typedef internal::TearDownTestCaseFunc TearDownTestCaseFunc; + + // The d'tor is virtual as we intend to inherit from Test. + virtual ~Test(); + + // Sets up the stuff shared by all tests in this test case. + // + // Google Test will call Foo::SetUpTestCase() before running the first + // test in test case Foo. Hence a sub-class can define its own + // SetUpTestCase() method to shadow the one defined in the super + // class. + static void SetUpTestCase() {} + + // Tears down the stuff shared by all tests in this test case. + // + // Google Test will call Foo::TearDownTestCase() after running the last + // test in test case Foo. Hence a sub-class can define its own + // TearDownTestCase() method to shadow the one defined in the super + // class. + static void TearDownTestCase() {} + + // Returns true iff the current test has a fatal failure. + static bool HasFatalFailure(); + + // Returns true iff the current test has a non-fatal failure. + static bool HasNonfatalFailure(); + + // Returns true iff the current test has a (either fatal or + // non-fatal) failure. + static bool HasFailure() { return HasFatalFailure() || HasNonfatalFailure(); } + + // Logs a property for the current test. Only the last value for a given + // key is remembered. + // These are public static so they can be called from utility functions + // that are not members of the test fixture. + // The arguments are const char* instead strings, as Google Test is used + // on platforms where string doesn't compile. + // + // Note that a driving consideration for these RecordProperty methods + // was to produce xml output suited to the Greenspan charting utility, + // which at present will only chart values that fit in a 32-bit int. It + // is the user's responsibility to restrict their values to 32-bit ints + // if they intend them to be used with Greenspan. + static void RecordProperty(const char* key, const char* value); + static void RecordProperty(const char* key, int value); + + protected: + // Creates a Test object. + Test(); + + // Sets up the test fixture. + virtual void SetUp(); + + // Tears down the test fixture. + virtual void TearDown(); + + private: + // Returns true iff the current test has the same fixture class as + // the first test in the current test case. + static bool HasSameFixtureClass(); + + // Runs the test after the test fixture has been set up. + // + // A sub-class must implement this to define the test logic. + // + // DO NOT OVERRIDE THIS FUNCTION DIRECTLY IN A USER PROGRAM. + // Instead, use the TEST or TEST_F macro. + virtual void TestBody() = 0; + + // Sets up, executes, and tears down the test. + void Run(); + + // Deletes self. We deliberately pick an unusual name for this + // internal method to avoid clashing with names used in user TESTs. + void DeleteSelf_() { delete this; } + + // Uses a GTestFlagSaver to save and restore all Google Test flags. + const internal::GTestFlagSaver* const gtest_flag_saver_; + + // Often a user mis-spells SetUp() as Setup() and spends a long time + // wondering why it is never called by Google Test. The declaration of + // the following method is solely for catching such an error at + // compile time: + // + // - The return type is deliberately chosen to be not void, so it + // will be a conflict if a user declares void Setup() in his test + // fixture. + // + // - This method is private, so it will be another compiler error + // if a user calls it from his test fixture. + // + // DO NOT OVERRIDE THIS FUNCTION. + // + // If you see an error about overriding the following function or + // about it being private, you have mis-spelled SetUp() as Setup(). + struct Setup_should_be_spelled_SetUp {}; + virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; } + + // We disallow copying Tests. + GTEST_DISALLOW_COPY_AND_ASSIGN_(Test); +}; + +typedef internal::TimeInMillis TimeInMillis; + +// A copyable object representing a user specified test property which can be +// output as a key/value string pair. +// +// Don't inherit from TestProperty as its destructor is not virtual. +class TestProperty { + public: + // C'tor. TestProperty does NOT have a default constructor. + // Always use this constructor (with parameters) to create a + // TestProperty object. + TestProperty(const char* a_key, const char* a_value) : + key_(a_key), value_(a_value) { + } + + // Gets the user supplied key. + const char* key() const { + return key_.c_str(); + } + + // Gets the user supplied value. + const char* value() const { + return value_.c_str(); + } + + // Sets a new value, overriding the one supplied in the constructor. + void SetValue(const char* new_value) { + value_ = new_value; + } + + private: + // The key supplied by the user. + internal::String key_; + // The value supplied by the user. + internal::String value_; +}; + +// The result of a single Test. This includes a list of +// TestPartResults, a list of TestProperties, a count of how many +// death tests there are in the Test, and how much time it took to run +// the Test. +// +// TestResult is not copyable. +class GTEST_API_ TestResult { + public: + // Creates an empty TestResult. + TestResult(); + + // D'tor. Do not inherit from TestResult. + ~TestResult(); + + // Gets the number of all test parts. This is the sum of the number + // of successful test parts and the number of failed test parts. + int total_part_count() const; + + // Returns the number of the test properties. + int test_property_count() const; + + // Returns true iff the test passed (i.e. no test part failed). + bool Passed() const { return !Failed(); } + + // Returns true iff the test failed. + bool Failed() const; + + // Returns true iff the test fatally failed. + bool HasFatalFailure() const; + + // Returns true iff the test has a non-fatal failure. + bool HasNonfatalFailure() const; + + // Returns the elapsed time, in milliseconds. + TimeInMillis elapsed_time() const { return elapsed_time_; } + + // Returns the i-th test part result among all the results. i can range + // from 0 to test_property_count() - 1. If i is not in that range, aborts + // the program. + const TestPartResult& GetTestPartResult(int i) const; + + // Returns the i-th test property. i can range from 0 to + // test_property_count() - 1. If i is not in that range, aborts the + // program. + const TestProperty& GetTestProperty(int i) const; + + private: + friend class TestInfo; + friend class UnitTest; + friend class internal::DefaultGlobalTestPartResultReporter; + friend class internal::ExecDeathTest; + friend class internal::TestResultAccessor; + friend class internal::UnitTestImpl; + friend class internal::WindowsDeathTest; + + // Gets the vector of TestPartResults. + const std::vector<TestPartResult>& test_part_results() const { + return test_part_results_; + } + + // Gets the vector of TestProperties. + const std::vector<TestProperty>& test_properties() const { + return test_properties_; + } + + // Sets the elapsed time. + void set_elapsed_time(TimeInMillis elapsed) { elapsed_time_ = elapsed; } + + // Adds a test property to the list. The property is validated and may add + // a non-fatal failure if invalid (e.g., if it conflicts with reserved + // key names). If a property is already recorded for the same key, the + // value will be updated, rather than storing multiple values for the same + // key. + void RecordProperty(const TestProperty& test_property); + + // Adds a failure if the key is a reserved attribute of Google Test + // testcase tags. Returns true if the property is valid. + // TODO(russr): Validate attribute names are legal and human readable. + static bool ValidateTestProperty(const TestProperty& test_property); + + // Adds a test part result to the list. + void AddTestPartResult(const TestPartResult& test_part_result); + + // Returns the death test count. + int death_test_count() const { return death_test_count_; } + + // Increments the death test count, returning the new count. + int increment_death_test_count() { return ++death_test_count_; } + + // Clears the test part results. + void ClearTestPartResults(); + + // Clears the object. + void Clear(); + + // Protects mutable state of the property vector and of owned + // properties, whose values may be updated. + internal::Mutex test_properites_mutex_; + + // The vector of TestPartResults + std::vector<TestPartResult> test_part_results_; + // The vector of TestProperties + std::vector<TestProperty> test_properties_; + // Running count of death tests. + int death_test_count_; + // The elapsed time, in milliseconds. + TimeInMillis elapsed_time_; + + // We disallow copying TestResult. + GTEST_DISALLOW_COPY_AND_ASSIGN_(TestResult); +}; // class TestResult + +// A TestInfo object stores the following information about a test: +// +// Test case name +// Test name +// Whether the test should be run +// A function pointer that creates the test object when invoked +// Test result +// +// The constructor of TestInfo registers itself with the UnitTest +// singleton such that the RUN_ALL_TESTS() macro knows which tests to +// run. +class GTEST_API_ TestInfo { + public: + // Destructs a TestInfo object. This function is not virtual, so + // don't inherit from TestInfo. + ~TestInfo(); + + // Returns the test case name. + const char* test_case_name() const { return test_case_name_.c_str(); } + + // Returns the test name. + const char* name() const { return name_.c_str(); } + + // Returns the name of the parameter type, or NULL if this is not a typed + // or a type-parameterized test. + const char* type_param() const { + if (type_param_.get() != NULL) + return type_param_->c_str(); + return NULL; + } + + // Returns the text representation of the value parameter, or NULL if this + // is not a value-parameterized test. + const char* value_param() const { + if (value_param_.get() != NULL) + return value_param_->c_str(); + return NULL; + } + + // Returns true if this test should run, that is if the test is not disabled + // (or it is disabled but the also_run_disabled_tests flag has been specified) + // and its full name matches the user-specified filter. + // + // Google Test allows the user to filter the tests by their full names. + // The full name of a test Bar in test case Foo is defined as + // "Foo.Bar". Only the tests that match the filter will run. + // + // A filter is a colon-separated list of glob (not regex) patterns, + // optionally followed by a '-' and a colon-separated list of + // negative patterns (tests to exclude). A test is run if it + // matches one of the positive patterns and does not match any of + // the negative patterns. + // + // For example, *A*:Foo.* is a filter that matches any string that + // contains the character 'A' or starts with "Foo.". + bool should_run() const { return should_run_; } + + // Returns true if the test was filtered out by --gtest_filter + bool filtered_out() const { return !matches_filter_; } + + // Returns the result of the test. + const TestResult* result() const { return &result_; } + + private: + +#if GTEST_HAS_DEATH_TEST + friend class internal::DefaultDeathTestFactory; +#endif // GTEST_HAS_DEATH_TEST + friend class Test; + friend class TestCase; + friend class internal::UnitTestImpl; + friend TestInfo* internal::MakeAndRegisterTestInfo( + const char* test_case_name, const char* name, + const char* type_param, + const char* value_param, + internal::TypeId fixture_class_id, + Test::SetUpTestCaseFunc set_up_tc, + Test::TearDownTestCaseFunc tear_down_tc, + internal::TestFactoryBase* factory); + + // Constructs a TestInfo object. The newly constructed instance assumes + // ownership of the factory object. + TestInfo(const char* test_case_name, const char* name, + const char* a_type_param, + const char* a_value_param, + internal::TypeId fixture_class_id, + internal::TestFactoryBase* factory); + + // Increments the number of death tests encountered in this test so + // far. + int increment_death_test_count() { + return result_.increment_death_test_count(); + } + + // Creates the test object, runs it, records its result, and then + // deletes it. + void Run(); + + static void ClearTestResult(TestInfo* test_info) { + test_info->result_.Clear(); + } + + // These fields are immutable properties of the test. + const std::string test_case_name_; // Test case name + const std::string name_; // Test name + // Name of the parameter type, or NULL if this is not a typed or a + // type-parameterized test. + const internal::scoped_ptr<const ::std::string> type_param_; + // Text representation of the value parameter, or NULL if this is not a + // value-parameterized test. + const internal::scoped_ptr<const ::std::string> value_param_; + const internal::TypeId fixture_class_id_; // ID of the test fixture class + bool should_run_; // True iff this test should run + bool is_disabled_; // True iff this test is disabled + bool matches_filter_; // True if this test matches the + // user-specified filter. + internal::TestFactoryBase* const factory_; // The factory that creates + // the test object + + // This field is mutable and needs to be reset before running the + // test for the second time. + TestResult result_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(TestInfo); +}; + +// A test case, which consists of a vector of TestInfos. +// +// TestCase is not copyable. +class GTEST_API_ TestCase { + public: + // Creates a TestCase with the given name. + // + // TestCase does NOT have a default constructor. Always use this + // constructor to create a TestCase object. + // + // Arguments: + // + // name: name of the test case + // a_type_param: the name of the test's type parameter, or NULL if + // this is not a type-parameterized test. + // set_up_tc: pointer to the function that sets up the test case + // tear_down_tc: pointer to the function that tears down the test case + TestCase(const char* name, const char* a_type_param, + Test::SetUpTestCaseFunc set_up_tc, + Test::TearDownTestCaseFunc tear_down_tc); + + // Destructor of TestCase. + virtual ~TestCase(); + + // Gets the name of the TestCase. + const char* name() const { return name_.c_str(); } + + // Returns the name of the parameter type, or NULL if this is not a + // type-parameterized test case. + const char* type_param() const { + if (type_param_.get() != NULL) + return type_param_->c_str(); + return NULL; + } + + // Returns true if any test in this test case should run. + bool should_run() const { return should_run_; } + + // Returns true if this test case should be skipped in the report. + bool should_skip_report() const { return should_skip_report_; } + + // Gets the number of successful tests in this test case. + int successful_test_count() const; + + // Gets the number of failed tests in this test case. + int failed_test_count() const; + + // Gets the number of disabled tests in this test case. + int disabled_test_count() const; + + // Get the number of tests in this test case that should run. + int test_to_run_count() const; + + // Gets the number of all tests in this test case. + int total_test_count() const; + + // Returns true iff the test case passed. + bool Passed() const { return !Failed(); } + + // Returns true iff the test case failed. + bool Failed() const { return failed_test_count() > 0; } + + // Returns the elapsed time, in milliseconds. + TimeInMillis elapsed_time() const { return elapsed_time_; } + + // Returns the i-th test among all the tests. i can range from 0 to + // total_test_count() - 1. If i is not in that range, returns NULL. + const TestInfo* GetTestInfo(int i) const; + + private: + friend class Test; + friend class internal::UnitTestImpl; + + // Gets the (mutable) vector of TestInfos in this TestCase. + std::vector<TestInfo*>& test_info_list() { return test_info_list_; } + + // Gets the (immutable) vector of TestInfos in this TestCase. + const std::vector<TestInfo*>& test_info_list() const { + return test_info_list_; + } + + // Returns the i-th test among all the tests. i can range from 0 to + // total_test_count() - 1. If i is not in that range, returns NULL. + TestInfo* GetMutableTestInfo(int i); + + // Sets the should_run member. + void set_should_run(bool should) { should_run_ = should; } + void set_should_skip_report(bool should) { should_skip_report_ = should; } + + // Adds a TestInfo to this test case. Will delete the TestInfo upon + // destruction of the TestCase object. + void AddTestInfo(TestInfo * test_info); + + // Clears the results of all tests in this test case. + void ClearResult(); + + // Clears the results of all tests in the given test case. + static void ClearTestCaseResult(TestCase* test_case) { + test_case->ClearResult(); + } + + // Runs every test in this TestCase. + void Run(); + + // Runs SetUpTestCase() for this TestCase. This wrapper is needed + // for catching exceptions thrown from SetUpTestCase(). + void RunSetUpTestCase() { (*set_up_tc_)(); } + + // Runs TearDownTestCase() for this TestCase. This wrapper is + // needed for catching exceptions thrown from TearDownTestCase(). + void RunTearDownTestCase() { (*tear_down_tc_)(); } + + // Returns true iff test passed. + static bool TestPassed(const TestInfo* test_info) { + return test_info->should_run() && test_info->result()->Passed(); + } + + // Returns true iff test failed. + static bool TestFailed(const TestInfo* test_info) { + return test_info->should_run() && test_info->result()->Failed(); + } + + // Returns true iff test is disabled. + static bool TestDisabled(const TestInfo* test_info) { + return test_info->is_disabled_; + } + + // Returns true if the given test should run. + static bool ShouldRunTest(const TestInfo* test_info) { + return test_info->should_run(); + } + + // Shuffles the tests in this test case. + void ShuffleTests(internal::Random* random); + + // Restores the test order to before the first shuffle. + void UnshuffleTests(); + + // Name of the test case. + internal::String name_; + // Name of the parameter type, or NULL if this is not a typed or a + // type-parameterized test. + const internal::scoped_ptr<const ::std::string> type_param_; + // The vector of TestInfos in their original order. It owns the + // elements in the vector. + std::vector<TestInfo*> test_info_list_; + // Provides a level of indirection for the test list to allow easy + // shuffling and restoring the test order. The i-th element in this + // vector is the index of the i-th test in the shuffled test list. + std::vector<int> test_indices_; + // Pointer to the function that sets up the test case. + Test::SetUpTestCaseFunc set_up_tc_; + // Pointer to the function that tears down the test case. + Test::TearDownTestCaseFunc tear_down_tc_; + // True iff any test in this test case should run. + bool should_run_; + // True if this test case should not be reported + bool should_skip_report_; + // Elapsed time, in milliseconds. + TimeInMillis elapsed_time_; + + // We disallow copying TestCases. + GTEST_DISALLOW_COPY_AND_ASSIGN_(TestCase); +}; + +// An Environment object is capable of setting up and tearing down an +// environment. The user should subclass this to define his own +// environment(s). +// +// An Environment object does the set-up and tear-down in virtual +// methods SetUp() and TearDown() instead of the constructor and the +// destructor, as: +// +// 1. You cannot safely throw from a destructor. This is a problem +// as in some cases Google Test is used where exceptions are enabled, and +// we may want to implement ASSERT_* using exceptions where they are +// available. +// 2. You cannot use ASSERT_* directly in a constructor or +// destructor. +class Environment { + public: + // The d'tor is virtual as we need to subclass Environment. + virtual ~Environment() {} + + // Override this to define how to set up the environment. + virtual void SetUp() {} + + // Override this to define how to tear down the environment. + virtual void TearDown() {} + private: + // If you see an error about overriding the following function or + // about it being private, you have mis-spelled SetUp() as Setup(). + struct Setup_should_be_spelled_SetUp {}; + virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; } +}; + +// The interface for tracing execution of tests. The methods are organized in +// the order the corresponding events are fired. +class TestEventListener { + public: + virtual ~TestEventListener() {} + + // Fired before any test activity starts. + virtual void OnTestProgramStart(const UnitTest& unit_test) = 0; + + // Fired before each iteration of tests starts. There may be more than + // one iteration if GTEST_FLAG(repeat) is set. iteration is the iteration + // index, starting from 0. + virtual void OnTestIterationStart(const UnitTest& unit_test, + int iteration) = 0; + + // Fired before environment set-up for each iteration of tests starts. + virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test) = 0; + + // Fired after environment set-up for each iteration of tests ends. + virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) = 0; + + // Fired before the test case starts. + virtual void OnTestCaseStart(const TestCase& test_case) = 0; + + // Fired before the test starts. + virtual void OnTestStart(const TestInfo& test_info) = 0; + + // Fired after a failed assertion or a SUCCEED() invocation. + virtual void OnTestPartResult(const TestPartResult& test_part_result) = 0; + + // Fired after the test ends. + virtual void OnTestEnd(const TestInfo& test_info) = 0; + + // Fired after the test case ends. + virtual void OnTestCaseEnd(const TestCase& test_case) = 0; + + // Fired before environment tear-down for each iteration of tests starts. + virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test) = 0; + + // Fired after environment tear-down for each iteration of tests ends. + virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) = 0; + + // Fired after each iteration of tests finishes. + virtual void OnTestIterationEnd(const UnitTest& unit_test, + int iteration) = 0; + + // Fired after all test activities have ended. + virtual void OnTestProgramEnd(const UnitTest& unit_test) = 0; +}; + +// The convenience class for users who need to override just one or two +// methods and are not concerned that a possible change to a signature of +// the methods they override will not be caught during the build. For +// comments about each method please see the definition of TestEventListener +// above. +class EmptyTestEventListener : public TestEventListener { + public: + virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {} + virtual void OnTestIterationStart(const UnitTest& /*unit_test*/, + int /*iteration*/) {} + virtual void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) {} + virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {} + virtual void OnTestCaseStart(const TestCase& /*test_case*/) {} + virtual void OnTestStart(const TestInfo& /*test_info*/) {} + virtual void OnTestPartResult(const TestPartResult& /*test_part_result*/) {} + virtual void OnTestEnd(const TestInfo& /*test_info*/) {} + virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {} + virtual void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) {} + virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {} + virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/, + int /*iteration*/) {} + virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {} +}; + +// TestEventListeners lets users add listeners to track events in Google Test. +class GTEST_API_ TestEventListeners { + public: + TestEventListeners(); + ~TestEventListeners(); + + // Appends an event listener to the end of the list. Google Test assumes + // the ownership of the listener (i.e. it will delete the listener when + // the test program finishes). + void Append(TestEventListener* listener); + + // Removes the given event listener from the list and returns it. It then + // becomes the caller's responsibility to delete the listener. Returns + // NULL if the listener is not found in the list. + TestEventListener* Release(TestEventListener* listener); + + // Returns the standard listener responsible for the default console + // output. Can be removed from the listeners list to shut down default + // console output. Note that removing this object from the listener list + // with Release transfers its ownership to the caller and makes this + // function return NULL the next time. + TestEventListener* default_result_printer() const { + return default_result_printer_; + } + + // Returns the standard listener responsible for the default XML output + // controlled by the --gtest_output=xml flag. Can be removed from the + // listeners list by users who want to shut down the default XML output + // controlled by this flag and substitute it with custom one. Note that + // removing this object from the listener list with Release transfers its + // ownership to the caller and makes this function return NULL the next + // time. + TestEventListener* default_xml_generator() const { + return default_xml_generator_; + } + + private: + friend class TestCase; + friend class TestInfo; + friend class internal::DefaultGlobalTestPartResultReporter; + friend class internal::NoExecDeathTest; + friend class internal::TestEventListenersAccessor; + friend class internal::UnitTestImpl; + + // Returns repeater that broadcasts the TestEventListener events to all + // subscribers. + TestEventListener* repeater(); + + // Sets the default_result_printer attribute to the provided listener. + // The listener is also added to the listener list and previous + // default_result_printer is removed from it and deleted. The listener can + // also be NULL in which case it will not be added to the list. Does + // nothing if the previous and the current listener objects are the same. + void SetDefaultResultPrinter(TestEventListener* listener); + + // Sets the default_xml_generator attribute to the provided listener. The + // listener is also added to the listener list and previous + // default_xml_generator is removed from it and deleted. The listener can + // also be NULL in which case it will not be added to the list. Does + // nothing if the previous and the current listener objects are the same. + void SetDefaultXmlGenerator(TestEventListener* listener); + + // Controls whether events will be forwarded by the repeater to the + // listeners in the list. + bool EventForwardingEnabled() const; + void SuppressEventForwarding(); + + // The actual list of listeners. + internal::TestEventRepeater* repeater_; + // Listener responsible for the standard result output. + TestEventListener* default_result_printer_; + // Listener responsible for the creation of the XML output file. + TestEventListener* default_xml_generator_; + + // We disallow copying TestEventListeners. + GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventListeners); +}; + +// A UnitTest consists of a vector of TestCases. +// +// This is a singleton class. The only instance of UnitTest is +// created when UnitTest::GetInstance() is first called. This +// instance is never deleted. +// +// UnitTest is not copyable. +// +// This class is thread-safe as long as the methods are called +// according to their specification. +class GTEST_API_ UnitTest { + public: + // Gets the singleton UnitTest object. The first time this method + // is called, a UnitTest object is constructed and returned. + // Consecutive calls will return the same object. + static UnitTest* GetInstance(); + + // Runs all tests in this UnitTest object and prints the result. + // Returns 0 if successful, or 1 otherwise. + // + // This method can only be called from the main thread. + // + // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. + int Run() GTEST_MUST_USE_RESULT_; + + // Returns the working directory when the first TEST() or TEST_F() + // was executed. The UnitTest object owns the string. + const char* original_working_dir() const; + + // Returns the TestCase object for the test that's currently running, + // or NULL if no test is running. + const TestCase* current_test_case() const; + + // Returns the TestInfo object for the test that's currently running, + // or NULL if no test is running. + const TestInfo* current_test_info() const; + + // Returns the random seed used at the start of the current test run. + int random_seed() const; + +#if GTEST_HAS_PARAM_TEST + // Returns the ParameterizedTestCaseRegistry object used to keep track of + // value-parameterized tests and instantiate and register them. + // + // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. + internal::ParameterizedTestCaseRegistry& parameterized_test_registry(); +#endif // GTEST_HAS_PARAM_TEST + + // Gets the number of successful test cases. + int successful_test_case_count() const; + + // Gets the number of failed test cases. + int failed_test_case_count() const; + + // Gets the number of all test cases. + int total_test_case_count() const; + + // Gets the number of all test cases that contain at least one test + // that should run. + int test_case_to_run_count() const; + + // Gets the number of successful tests. + int successful_test_count() const; + + // Gets the number of failed tests. + int failed_test_count() const; + + // Gets the number of disabled tests. + int disabled_test_count() const; + + // Gets the number of all tests. + int total_test_count() const; + + // Gets the number of tests that should run. + int test_to_run_count() const; + + // Gets the elapsed time, in milliseconds. + TimeInMillis elapsed_time() const; + + // Returns true iff the unit test passed (i.e. all test cases passed). + bool Passed() const; + + // Returns true iff the unit test failed (i.e. some test case failed + // or something outside of all tests failed). + bool Failed() const; + + // Gets the i-th test case among all the test cases. i can range from 0 to + // total_test_case_count() - 1. If i is not in that range, returns NULL. + const TestCase* GetTestCase(int i) const; + + // Returns the list of event listeners that can be used to track events + // inside Google Test. + TestEventListeners& listeners(); + + private: + // Registers and returns a global test environment. When a test + // program is run, all global test environments will be set-up in + // the order they were registered. After all tests in the program + // have finished, all global test environments will be torn-down in + // the *reverse* order they were registered. + // + // The UnitTest object takes ownership of the given environment. + // + // This method can only be called from the main thread. + Environment* AddEnvironment(Environment* env); + + // Adds a TestPartResult to the current TestResult object. All + // Google Test assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) + // eventually call this to report their results. The user code + // should use the assertion macros instead of calling this directly. + void AddTestPartResult(TestPartResult::Type result_type, + const char* file_name, + int line_number, + const internal::String& message, + const internal::String& os_stack_trace); + + // Adds a TestProperty to the current TestResult object. If the result already + // contains a property with the same key, the value will be updated. + void RecordPropertyForCurrentTest(const char* key, const char* value); + + // Gets the i-th test case among all the test cases. i can range from 0 to + // total_test_case_count() - 1. If i is not in that range, returns NULL. + TestCase* GetMutableTestCase(int i); + + // Accessors for the implementation object. + internal::UnitTestImpl* impl() { return impl_; } + const internal::UnitTestImpl* impl() const { return impl_; } + + // These classes and funcions are friends as they need to access private + // members of UnitTest. + friend class Test; + friend class internal::AssertHelper; + friend class internal::ScopedTrace; + friend Environment* AddGlobalTestEnvironment(Environment* env); + friend internal::UnitTestImpl* internal::GetUnitTestImpl(); + friend void internal::ReportFailureInUnknownLocation( + TestPartResult::Type result_type, + const internal::String& message); + + // Creates an empty UnitTest. + UnitTest(); + + // D'tor + virtual ~UnitTest(); + + // Pushes a trace defined by SCOPED_TRACE() on to the per-thread + // Google Test trace stack. + void PushGTestTrace(const internal::TraceInfo& trace); + + // Pops a trace from the per-thread Google Test trace stack. + void PopGTestTrace(); + + // Protects mutable state in *impl_. This is mutable as some const + // methods need to lock it too. + mutable internal::Mutex mutex_; + + // Opaque implementation object. This field is never changed once + // the object is constructed. We don't mark it as const here, as + // doing so will cause a warning in the constructor of UnitTest. + // Mutable state in *impl_ is protected by mutex_. + internal::UnitTestImpl* impl_; + + // We disallow copying UnitTest. + GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTest); +}; + +// A convenient wrapper for adding an environment for the test +// program. +// +// You should call this before RUN_ALL_TESTS() is called, probably in +// main(). If you use gtest_main, you need to call this before main() +// starts for it to take effect. For example, you can define a global +// variable like this: +// +// testing::Environment* const foo_env = +// testing::AddGlobalTestEnvironment(new FooEnvironment); +// +// However, we strongly recommend you to write your own main() and +// call AddGlobalTestEnvironment() there, as relying on initialization +// of global variables makes the code harder to read and may cause +// problems when you register multiple environments from different +// translation units and the environments have dependencies among them +// (remember that the compiler doesn't guarantee the order in which +// global variables from different translation units are initialized). +inline Environment* AddGlobalTestEnvironment(Environment* env) { + return UnitTest::GetInstance()->AddEnvironment(env); +} + +// Initializes Google Test. This must be called before calling +// RUN_ALL_TESTS(). In particular, it parses a command line for the +// flags that Google Test recognizes. Whenever a Google Test flag is +// seen, it is removed from argv, and *argc is decremented. +// +// No value is returned. Instead, the Google Test flag variables are +// updated. +// +// Calling the function for the second time has no user-visible effect. +GTEST_API_ void InitGoogleTest(int* argc, char** argv); + +// This overloaded version can be used in Windows programs compiled in +// UNICODE mode. +GTEST_API_ void InitGoogleTest(int* argc, wchar_t** argv); + +namespace internal { + +// Formats a comparison assertion (e.g. ASSERT_EQ, EXPECT_LT, and etc) +// operand to be used in a failure message. The type (but not value) +// of the other operand may affect the format. This allows us to +// print a char* as a raw pointer when it is compared against another +// char*, and print it as a C string when it is compared against an +// std::string object, for example. +// +// The default implementation ignores the type of the other operand. +// Some specialized versions are used to handle formatting wide or +// narrow C strings. +// +// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. +template <typename T1, typename T2> +String FormatForComparisonFailureMessage(const T1& value, + const T2& /* other_operand */) { + // C++Builder compiles this incorrectly if the namespace isn't explicitly + // given. + return ::testing::PrintToString(value); +} + +// The helper function for {ASSERT|EXPECT}_EQ. +template <typename T1, typename T2> +AssertionResult CmpHelperEQ(const char* expected_expression, + const char* actual_expression, + const T1& expected, + const T2& actual) { +#ifdef _MSC_VER +# pragma warning(push) // Saves the current warning state. +# pragma warning(disable:4389) // Temporarily disables warning on + // signed/unsigned mismatch. +#endif + + if (expected == actual) { + return AssertionSuccess(); + } + +#ifdef _MSC_VER +# pragma warning(pop) // Restores the warning state. +#endif + + return EqFailure(expected_expression, + actual_expression, + FormatForComparisonFailureMessage(expected, actual), + FormatForComparisonFailureMessage(actual, expected), + false); +} + +// With this overloaded version, we allow anonymous enums to be used +// in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous enums +// can be implicitly cast to BiggestInt. +GTEST_API_ AssertionResult CmpHelperEQ(const char* expected_expression, + const char* actual_expression, + BiggestInt expected, + BiggestInt actual); + +// The helper class for {ASSERT|EXPECT}_EQ. The template argument +// lhs_is_null_literal is true iff the first argument to ASSERT_EQ() +// is a null pointer literal. The following default implementation is +// for lhs_is_null_literal being false. +template <bool lhs_is_null_literal> +class EqHelper { + public: + // This templatized version is for the general case. + template <typename T1, typename T2> + static AssertionResult Compare(const char* expected_expression, + const char* actual_expression, + const T1& expected, + const T2& actual) { + return CmpHelperEQ(expected_expression, actual_expression, expected, + actual); + } + + // With this overloaded version, we allow anonymous enums to be used + // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous + // enums can be implicitly cast to BiggestInt. + // + // Even though its body looks the same as the above version, we + // cannot merge the two, as it will make anonymous enums unhappy. + static AssertionResult Compare(const char* expected_expression, + const char* actual_expression, + BiggestInt expected, + BiggestInt actual) { + return CmpHelperEQ(expected_expression, actual_expression, expected, + actual); + } +}; + +// This specialization is used when the first argument to ASSERT_EQ() +// is a null pointer literal, like NULL, false, or 0. +template <> +class EqHelper<true> { + public: + // We define two overloaded versions of Compare(). The first + // version will be picked when the second argument to ASSERT_EQ() is + // NOT a pointer, e.g. ASSERT_EQ(0, AnIntFunction()) or + // EXPECT_EQ(false, a_bool). + template <typename T1, typename T2> + static AssertionResult Compare( + const char* expected_expression, + const char* actual_expression, + const T1& expected, + const T2& actual, + // The following line prevents this overload from being considered if T2 + // is not a pointer type. We need this because ASSERT_EQ(NULL, my_ptr) + // expands to Compare("", "", NULL, my_ptr), which requires a conversion + // to match the Secret* in the other overload, which would otherwise make + // this template match better. + typename EnableIf<!is_pointer<T2>::value>::type* = 0) { + return CmpHelperEQ(expected_expression, actual_expression, expected, + actual); + } + + // This version will be picked when the second argument to ASSERT_EQ() is a + // pointer, e.g. ASSERT_EQ(NULL, a_pointer). + template <typename T> + static AssertionResult Compare( + const char* expected_expression, + const char* actual_expression, + // We used to have a second template parameter instead of Secret*. That + // template parameter would deduce to 'long', making this a better match + // than the first overload even without the first overload's EnableIf. + // Unfortunately, gcc with -Wconversion-null warns when "passing NULL to + // non-pointer argument" (even a deduced integral argument), so the old + // implementation caused warnings in user code. + Secret* /* expected (NULL) */, + T* actual) { + // We already know that 'expected' is a null pointer. + return CmpHelperEQ(expected_expression, actual_expression, + static_cast<T*>(NULL), actual); + } +}; + +// A macro for implementing the helper functions needed to implement +// ASSERT_?? and EXPECT_??. It is here just to avoid copy-and-paste +// of similar code. +// +// For each templatized helper function, we also define an overloaded +// version for BiggestInt in order to reduce code bloat and allow +// anonymous enums to be used with {ASSERT|EXPECT}_?? when compiled +// with gcc 4. +// +// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. +#define GTEST_IMPL_CMP_HELPER_(op_name, op)\ +template <typename T1, typename T2>\ +AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \ + const T1& val1, const T2& val2) {\ + if (val1 op val2) {\ + return AssertionSuccess();\ + } else {\ + return AssertionFailure() \ + << "Expected: (" << expr1 << ") " #op " (" << expr2\ + << "), actual: " << FormatForComparisonFailureMessage(val1, val2)\ + << " vs " << FormatForComparisonFailureMessage(val2, val1);\ + }\ +}\ +GTEST_API_ AssertionResult CmpHelper##op_name(\ + const char* expr1, const char* expr2, BiggestInt val1, BiggestInt val2) + +// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. + +// Implements the helper function for {ASSERT|EXPECT}_NE +GTEST_IMPL_CMP_HELPER_(NE, !=); +// Implements the helper function for {ASSERT|EXPECT}_LE +GTEST_IMPL_CMP_HELPER_(LE, <=); +// Implements the helper function for {ASSERT|EXPECT}_LT +GTEST_IMPL_CMP_HELPER_(LT, < ); +// Implements the helper function for {ASSERT|EXPECT}_GE +GTEST_IMPL_CMP_HELPER_(GE, >=); +// Implements the helper function for {ASSERT|EXPECT}_GT +GTEST_IMPL_CMP_HELPER_(GT, > ); + +#undef GTEST_IMPL_CMP_HELPER_ + +// The helper function for {ASSERT|EXPECT}_STREQ. +// +// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. +GTEST_API_ AssertionResult CmpHelperSTREQ(const char* expected_expression, + const char* actual_expression, + const char* expected, + const char* actual); + +// The helper function for {ASSERT|EXPECT}_STRCASEEQ. +// +// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. +GTEST_API_ AssertionResult CmpHelperSTRCASEEQ(const char* expected_expression, + const char* actual_expression, + const char* expected, + const char* actual); + +// The helper function for {ASSERT|EXPECT}_STRNE. +// +// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. +GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression, + const char* s2_expression, + const char* s1, + const char* s2); + +// The helper function for {ASSERT|EXPECT}_STRCASENE. +// +// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. +GTEST_API_ AssertionResult CmpHelperSTRCASENE(const char* s1_expression, + const char* s2_expression, + const char* s1, + const char* s2); + + +// Helper function for *_STREQ on wide strings. +// +// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. +GTEST_API_ AssertionResult CmpHelperSTREQ(const char* expected_expression, + const char* actual_expression, + const wchar_t* expected, + const wchar_t* actual); + +// Helper function for *_STRNE on wide strings. +// +// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. +GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression, + const char* s2_expression, + const wchar_t* s1, + const wchar_t* s2); + +} // namespace internal + +// IsSubstring() and IsNotSubstring() are intended to be used as the +// first argument to {EXPECT,ASSERT}_PRED_FORMAT2(), not by +// themselves. They check whether needle is a substring of haystack +// (NULL is considered a substring of itself only), and return an +// appropriate error message when they fail. +// +// The {needle,haystack}_expr arguments are the stringified +// expressions that generated the two real arguments. +GTEST_API_ AssertionResult IsSubstring( + const char* needle_expr, const char* haystack_expr, + const char* needle, const char* haystack); +GTEST_API_ AssertionResult IsSubstring( + const char* needle_expr, const char* haystack_expr, + const wchar_t* needle, const wchar_t* haystack); +GTEST_API_ AssertionResult IsNotSubstring( + const char* needle_expr, const char* haystack_expr, + const char* needle, const char* haystack); +GTEST_API_ AssertionResult IsNotSubstring( + const char* needle_expr, const char* haystack_expr, + const wchar_t* needle, const wchar_t* haystack); +GTEST_API_ AssertionResult IsSubstring( + const char* needle_expr, const char* haystack_expr, + const ::std::string& needle, const ::std::string& haystack); +GTEST_API_ AssertionResult IsNotSubstring( + const char* needle_expr, const char* haystack_expr, + const ::std::string& needle, const ::std::string& haystack); + +#if GTEST_HAS_STD_WSTRING +GTEST_API_ AssertionResult IsSubstring( + const char* needle_expr, const char* haystack_expr, + const ::std::wstring& needle, const ::std::wstring& haystack); +GTEST_API_ AssertionResult IsNotSubstring( + const char* needle_expr, const char* haystack_expr, + const ::std::wstring& needle, const ::std::wstring& haystack); +#endif // GTEST_HAS_STD_WSTRING + +namespace internal { + +// Helper template function for comparing floating-points. +// +// Template parameter: +// +// RawType: the raw floating-point type (either float or double) +// +// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. +template <typename RawType> +AssertionResult CmpHelperFloatingPointEQ(const char* expected_expression, + const char* actual_expression, + RawType expected, + RawType actual) { + const FloatingPoint<RawType> lhs(expected), rhs(actual); + + if (lhs.AlmostEquals(rhs)) { + return AssertionSuccess(); + } + + ::std::stringstream expected_ss; + expected_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2) + << expected; + + ::std::stringstream actual_ss; + actual_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2) + << actual; + + return EqFailure(expected_expression, + actual_expression, + StringStreamToString(&expected_ss), + StringStreamToString(&actual_ss), + false); +} + +// Helper function for implementing ASSERT_NEAR. +// +// INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. +GTEST_API_ AssertionResult DoubleNearPredFormat(const char* expr1, + const char* expr2, + const char* abs_error_expr, + double val1, + double val2, + double abs_error); + +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// A class that enables one to stream messages to assertion macros +class GTEST_API_ AssertHelper { + public: + // Constructor. + AssertHelper(TestPartResult::Type type, + const char* file, + int line, + const char* message); + ~AssertHelper(); + + // Message assignment is a semantic trick to enable assertion + // streaming; see the GTEST_MESSAGE_ macro below. + void operator=(const Message& message) const; + + private: + // We put our data in a struct so that the size of the AssertHelper class can + // be as small as possible. This is important because gcc is incapable of + // re-using stack space even for temporary variables, so every EXPECT_EQ + // reserves stack space for another AssertHelper. + struct AssertHelperData { + AssertHelperData(TestPartResult::Type t, + const char* srcfile, + int line_num, + const char* msg) + : type(t), file(srcfile), line(line_num), message(msg) { } + + TestPartResult::Type const type; + const char* const file; + int const line; + String const message; + + private: + GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelperData); + }; + + AssertHelperData* const data_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelper); +}; + +} // namespace internal + +#if GTEST_HAS_PARAM_TEST +// The pure interface class that all value-parameterized tests inherit from. +// A value-parameterized class must inherit from both ::testing::Test and +// ::testing::WithParamInterface. In most cases that just means inheriting +// from ::testing::TestWithParam, but more complicated test hierarchies +// may need to inherit from Test and WithParamInterface at different levels. +// +// This interface has support for accessing the test parameter value via +// the GetParam() method. +// +// Use it with one of the parameter generator defining functions, like Range(), +// Values(), ValuesIn(), Bool(), and Combine(). +// +// class FooTest : public ::testing::TestWithParam<int> { +// protected: +// FooTest() { +// // Can use GetParam() here. +// } +// virtual ~FooTest() { +// // Can use GetParam() here. +// } +// virtual void SetUp() { +// // Can use GetParam() here. +// } +// virtual void TearDown { +// // Can use GetParam() here. +// } +// }; +// TEST_P(FooTest, DoesBar) { +// // Can use GetParam() method here. +// Foo foo; +// ASSERT_TRUE(foo.DoesBar(GetParam())); +// } +// INSTANTIATE_TEST_CASE_P(OneToTenRange, FooTest, ::testing::Range(1, 10)); + +template <typename T> +class WithParamInterface { + public: + typedef T ParamType; + virtual ~WithParamInterface() {} + + // The current parameter value. Is also available in the test fixture's + // constructor. This member function is non-static, even though it only + // references static data, to reduce the opportunity for incorrect uses + // like writing 'WithParamInterface<bool>::GetParam()' for a test that + // uses a fixture whose parameter type is int. + const ParamType& GetParam() const { return *parameter_; } + + private: + // Sets parameter value. The caller is responsible for making sure the value + // remains alive and unchanged throughout the current test. + static void SetParam(const ParamType* parameter) { + parameter_ = parameter; + } + + // Static value used for accessing parameter during a test lifetime. + static const ParamType* parameter_; + + // TestClass must be a subclass of WithParamInterface<T> and Test. + template <class TestClass> friend class internal::ParameterizedTestFactory; +}; + +template <typename T> +const T* WithParamInterface<T>::parameter_ = NULL; + +// Most value-parameterized classes can ignore the existence of +// WithParamInterface, and can just inherit from ::testing::TestWithParam. + +template <typename T> +class TestWithParam : public Test, public WithParamInterface<T> { +}; + +#endif // GTEST_HAS_PARAM_TEST + +// Macros for indicating success/failure in test code. + +// ADD_FAILURE unconditionally adds a failure to the current test. +// SUCCEED generates a success - it doesn't automatically make the +// current test successful, as a test is only successful when it has +// no failure. +// +// EXPECT_* verifies that a certain condition is satisfied. If not, +// it behaves like ADD_FAILURE. In particular: +// +// EXPECT_TRUE verifies that a Boolean condition is true. +// EXPECT_FALSE verifies that a Boolean condition is false. +// +// FAIL and ASSERT_* are similar to ADD_FAILURE and EXPECT_*, except +// that they will also abort the current function on failure. People +// usually want the fail-fast behavior of FAIL and ASSERT_*, but those +// writing data-driven tests often find themselves using ADD_FAILURE +// and EXPECT_* more. +// +// Examples: +// +// EXPECT_TRUE(server.StatusIsOK()); +// ASSERT_FALSE(server.HasPendingRequest(port)) +// << "There are still pending requests " << "on port " << port; + +// Generates a nonfatal failure with a generic message. +#define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed") + +// Generates a nonfatal failure at the given source file location with +// a generic message. +#define ADD_FAILURE_AT(file, line) \ + GTEST_MESSAGE_AT_(file, line, "Failed", \ + ::testing::TestPartResult::kNonFatalFailure) + +// Generates a fatal failure with a generic message. +#define GTEST_FAIL() GTEST_FATAL_FAILURE_("Failed") + +// Define this macro to 1 to omit the definition of FAIL(), which is a +// generic name and clashes with some other libraries. +#if !GTEST_DONT_DEFINE_FAIL +# define FAIL() GTEST_FAIL() +#endif + +// Generates a success with a generic message. +#define GTEST_SUCCEED() GTEST_SUCCESS_("Succeeded") + +// Define this macro to 1 to omit the definition of SUCCEED(), which +// is a generic name and clashes with some other libraries. +#if !GTEST_DONT_DEFINE_SUCCEED +# define SUCCEED() GTEST_SUCCEED() +#endif + +// Macros for testing exceptions. +// +// * {ASSERT|EXPECT}_THROW(statement, expected_exception): +// Tests that the statement throws the expected exception. +// * {ASSERT|EXPECT}_NO_THROW(statement): +// Tests that the statement doesn't throw any exception. +// * {ASSERT|EXPECT}_ANY_THROW(statement): +// Tests that the statement throws an exception. + +#define EXPECT_THROW(statement, expected_exception) \ + GTEST_TEST_THROW_(statement, expected_exception, GTEST_NONFATAL_FAILURE_) +#define EXPECT_NO_THROW(statement) \ + GTEST_TEST_NO_THROW_(statement, GTEST_NONFATAL_FAILURE_) +#define EXPECT_ANY_THROW(statement) \ + GTEST_TEST_ANY_THROW_(statement, GTEST_NONFATAL_FAILURE_) +#define ASSERT_THROW(statement, expected_exception) \ + GTEST_TEST_THROW_(statement, expected_exception, GTEST_FATAL_FAILURE_) +#define ASSERT_NO_THROW(statement) \ + GTEST_TEST_NO_THROW_(statement, GTEST_FATAL_FAILURE_) +#define ASSERT_ANY_THROW(statement) \ + GTEST_TEST_ANY_THROW_(statement, GTEST_FATAL_FAILURE_) + +// Boolean assertions. Condition can be either a Boolean expression or an +// AssertionResult. For more information on how to use AssertionResult with +// these macros see comments on that class. +#define EXPECT_TRUE(condition) \ + GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \ + GTEST_NONFATAL_FAILURE_) +#define EXPECT_FALSE(condition) \ + GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \ + GTEST_NONFATAL_FAILURE_) +#define ASSERT_TRUE(condition) \ + GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \ + GTEST_FATAL_FAILURE_) +#define ASSERT_FALSE(condition) \ + GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \ + GTEST_FATAL_FAILURE_) + +// Includes the auto-generated header that implements a family of +// generic predicate assertion macros. +#include "gtest/gtest_pred_impl.h" + +// Macros for testing equalities and inequalities. +// +// * {ASSERT|EXPECT}_EQ(expected, actual): Tests that expected == actual +// * {ASSERT|EXPECT}_NE(v1, v2): Tests that v1 != v2 +// * {ASSERT|EXPECT}_LT(v1, v2): Tests that v1 < v2 +// * {ASSERT|EXPECT}_LE(v1, v2): Tests that v1 <= v2 +// * {ASSERT|EXPECT}_GT(v1, v2): Tests that v1 > v2 +// * {ASSERT|EXPECT}_GE(v1, v2): Tests that v1 >= v2 +// +// When they are not, Google Test prints both the tested expressions and +// their actual values. The values must be compatible built-in types, +// or you will get a compiler error. By "compatible" we mean that the +// values can be compared by the respective operator. +// +// Note: +// +// 1. It is possible to make a user-defined type work with +// {ASSERT|EXPECT}_??(), but that requires overloading the +// comparison operators and is thus discouraged by the Google C++ +// Usage Guide. Therefore, you are advised to use the +// {ASSERT|EXPECT}_TRUE() macro to assert that two objects are +// equal. +// +// 2. The {ASSERT|EXPECT}_??() macros do pointer comparisons on +// pointers (in particular, C strings). Therefore, if you use it +// with two C strings, you are testing how their locations in memory +// are related, not how their content is related. To compare two C +// strings by content, use {ASSERT|EXPECT}_STR*(). +// +// 3. {ASSERT|EXPECT}_EQ(expected, actual) is preferred to +// {ASSERT|EXPECT}_TRUE(expected == actual), as the former tells you +// what the actual value is when it fails, and similarly for the +// other comparisons. +// +// 4. Do not depend on the order in which {ASSERT|EXPECT}_??() +// evaluate their arguments, which is undefined. +// +// 5. These macros evaluate their arguments exactly once. +// +// Examples: +// +// EXPECT_NE(5, Foo()); +// EXPECT_EQ(NULL, a_pointer); +// ASSERT_LT(i, array_size); +// ASSERT_GT(records.size(), 0) << "There is no record left."; + +#define EXPECT_EQ(expected, actual) \ + EXPECT_PRED_FORMAT2(::testing::internal:: \ + EqHelper<GTEST_IS_NULL_LITERAL_(expected)>::Compare, \ + expected, actual) +#define EXPECT_NE(expected, actual) \ + EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, expected, actual) +#define EXPECT_LE(val1, val2) \ + EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2) +#define EXPECT_LT(val1, val2) \ + EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2) +#define EXPECT_GE(val1, val2) \ + EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2) +#define EXPECT_GT(val1, val2) \ + EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2) + +#define GTEST_ASSERT_EQ(expected, actual) \ + ASSERT_PRED_FORMAT2(::testing::internal:: \ + EqHelper<GTEST_IS_NULL_LITERAL_(expected)>::Compare, \ + expected, actual) +#define GTEST_ASSERT_NE(val1, val2) \ + ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2) +#define GTEST_ASSERT_LE(val1, val2) \ + ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2) +#define GTEST_ASSERT_LT(val1, val2) \ + ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2) +#define GTEST_ASSERT_GE(val1, val2) \ + ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2) +#define GTEST_ASSERT_GT(val1, val2) \ + ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2) + +// Define macro GTEST_DONT_DEFINE_ASSERT_XY to 1 to omit the definition of +// ASSERT_XY(), which clashes with some users' own code. + +#if !GTEST_DONT_DEFINE_ASSERT_EQ +# define ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2) +#endif + +#if !GTEST_DONT_DEFINE_ASSERT_NE +# define ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2) +#endif + +#if !GTEST_DONT_DEFINE_ASSERT_LE +# define ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2) +#endif + +#if !GTEST_DONT_DEFINE_ASSERT_LT +# define ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2) +#endif + +#if !GTEST_DONT_DEFINE_ASSERT_GE +# define ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2) +#endif + +#if !GTEST_DONT_DEFINE_ASSERT_GT +# define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2) +#endif + +// C String Comparisons. All tests treat NULL and any non-NULL string +// as different. Two NULLs are equal. +// +// * {ASSERT|EXPECT}_STREQ(s1, s2): Tests that s1 == s2 +// * {ASSERT|EXPECT}_STRNE(s1, s2): Tests that s1 != s2 +// * {ASSERT|EXPECT}_STRCASEEQ(s1, s2): Tests that s1 == s2, ignoring case +// * {ASSERT|EXPECT}_STRCASENE(s1, s2): Tests that s1 != s2, ignoring case +// +// For wide or narrow string objects, you can use the +// {ASSERT|EXPECT}_??() macros. +// +// Don't depend on the order in which the arguments are evaluated, +// which is undefined. +// +// These macros evaluate their arguments exactly once. + +#define EXPECT_STREQ(expected, actual) \ + EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, expected, actual) +#define EXPECT_STRNE(s1, s2) \ + EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2) +#define EXPECT_STRCASEEQ(expected, actual) \ + EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, expected, actual) +#define EXPECT_STRCASENE(s1, s2)\ + EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2) + +#define ASSERT_STREQ(expected, actual) \ + ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, expected, actual) +#define ASSERT_STRNE(s1, s2) \ + ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2) +#define ASSERT_STRCASEEQ(expected, actual) \ + ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, expected, actual) +#define ASSERT_STRCASENE(s1, s2)\ + ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2) + +// Macros for comparing floating-point numbers. +// +// * {ASSERT|EXPECT}_FLOAT_EQ(expected, actual): +// Tests that two float values are almost equal. +// * {ASSERT|EXPECT}_DOUBLE_EQ(expected, actual): +// Tests that two double values are almost equal. +// * {ASSERT|EXPECT}_NEAR(v1, v2, abs_error): +// Tests that v1 and v2 are within the given distance to each other. +// +// Google Test uses ULP-based comparison to automatically pick a default +// error bound that is appropriate for the operands. See the +// FloatingPoint template class in gtest-internal.h if you are +// interested in the implementation details. + +#define EXPECT_FLOAT_EQ(expected, actual)\ + EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \ + expected, actual) + +#define EXPECT_DOUBLE_EQ(expected, actual)\ + EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \ + expected, actual) + +#define ASSERT_FLOAT_EQ(expected, actual)\ + ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<float>, \ + expected, actual) + +#define ASSERT_DOUBLE_EQ(expected, actual)\ + ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ<double>, \ + expected, actual) + +#define EXPECT_NEAR(val1, val2, abs_error)\ + EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \ + val1, val2, abs_error) + +#define ASSERT_NEAR(val1, val2, abs_error)\ + ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \ + val1, val2, abs_error) + +// These predicate format functions work on floating-point values, and +// can be used in {ASSERT|EXPECT}_PRED_FORMAT2*(), e.g. +// +// EXPECT_PRED_FORMAT2(testing::DoubleLE, Foo(), 5.0); + +// Asserts that val1 is less than, or almost equal to, val2. Fails +// otherwise. In particular, it fails if either val1 or val2 is NaN. +GTEST_API_ AssertionResult FloatLE(const char* expr1, const char* expr2, + float val1, float val2); +GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2, + double val1, double val2); + + +#if GTEST_OS_WINDOWS + +// Macros that test for HRESULT failure and success, these are only useful +// on Windows, and rely on Windows SDK macros and APIs to compile. +// +// * {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}(expr) +// +// When expr unexpectedly fails or succeeds, Google Test prints the +// expected result and the actual result with both a human-readable +// string representation of the error, if available, as well as the +// hex result code. +# define EXPECT_HRESULT_SUCCEEDED(expr) \ + EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr)) + +# define ASSERT_HRESULT_SUCCEEDED(expr) \ + ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr)) + +# define EXPECT_HRESULT_FAILED(expr) \ + EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr)) + +# define ASSERT_HRESULT_FAILED(expr) \ + ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr)) + +#endif // GTEST_OS_WINDOWS + +// Macros that execute statement and check that it doesn't generate new fatal +// failures in the current thread. +// +// * {ASSERT|EXPECT}_NO_FATAL_FAILURE(statement); +// +// Examples: +// +// EXPECT_NO_FATAL_FAILURE(Process()); +// ASSERT_NO_FATAL_FAILURE(Process()) << "Process() failed"; +// +#define ASSERT_NO_FATAL_FAILURE(statement) \ + GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_) +#define EXPECT_NO_FATAL_FAILURE(statement) \ + GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_) + +// Causes a trace (including the source file path, the current line +// number, and the given message) to be included in every test failure +// message generated by code in the current scope. The effect is +// undone when the control leaves the current scope. +// +// The message argument can be anything streamable to std::ostream. +// +// In the implementation, we include the current line number as part +// of the dummy variable name, thus allowing multiple SCOPED_TRACE()s +// to appear in the same block - as long as they are on different +// lines. +#define SCOPED_TRACE(message) \ + ::testing::internal::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\ + __FILE__, __LINE__, ::testing::Message() << (message)) + +// Compile-time assertion for type equality. +// StaticAssertTypeEq<type1, type2>() compiles iff type1 and type2 are +// the same type. The value it returns is not interesting. +// +// Instead of making StaticAssertTypeEq a class template, we make it a +// function template that invokes a helper class template. This +// prevents a user from misusing StaticAssertTypeEq<T1, T2> by +// defining objects of that type. +// +// CAVEAT: +// +// When used inside a method of a class template, +// StaticAssertTypeEq<T1, T2>() is effective ONLY IF the method is +// instantiated. For example, given: +// +// template <typename T> class Foo { +// public: +// void Bar() { testing::StaticAssertTypeEq<int, T>(); } +// }; +// +// the code: +// +// void Test1() { Foo<bool> foo; } +// +// will NOT generate a compiler error, as Foo<bool>::Bar() is never +// actually instantiated. Instead, you need: +// +// void Test2() { Foo<bool> foo; foo.Bar(); } +// +// to cause a compiler error. +template <typename T1, typename T2> +bool StaticAssertTypeEq() { + (void)internal::StaticAssertTypeEqHelper<T1, T2>(); + return true; +} + +// Defines a test. +// +// The first parameter is the name of the test case, and the second +// parameter is the name of the test within the test case. +// +// The convention is to end the test case name with "Test". For +// example, a test case for the Foo class can be named FooTest. +// +// The user should put his test code between braces after using this +// macro. Example: +// +// TEST(FooTest, InitializesCorrectly) { +// Foo foo; +// EXPECT_TRUE(foo.StatusIsOK()); +// } + +// Note that we call GetTestTypeId() instead of GetTypeId< +// ::testing::Test>() here to get the type ID of testing::Test. This +// is to work around a suspected linker bug when using Google Test as +// a framework on Mac OS X. The bug causes GetTypeId< +// ::testing::Test>() to return different values depending on whether +// the call is from the Google Test framework itself or from user test +// code. GetTestTypeId() is guaranteed to always return the same +// value, as it always calls GetTypeId<>() from the Google Test +// framework. +#define GTEST_TEST(test_case_name, test_name)\ + GTEST_TEST_(test_case_name, test_name, \ + ::testing::Test, ::testing::internal::GetTestTypeId()) + +// Define this macro to 1 to omit the definition of TEST(), which +// is a generic name and clashes with some other libraries. +#if !GTEST_DONT_DEFINE_TEST +# define TEST(test_case_name, test_name) GTEST_TEST(test_case_name, test_name) +#endif + +// Defines a test that uses a test fixture. +// +// The first parameter is the name of the test fixture class, which +// also doubles as the test case name. The second parameter is the +// name of the test within the test case. +// +// A test fixture class must be declared earlier. The user should put +// his test code between braces after using this macro. Example: +// +// class FooTest : public testing::Test { +// protected: +// virtual void SetUp() { b_.AddElement(3); } +// +// Foo a_; +// Foo b_; +// }; +// +// TEST_F(FooTest, InitializesCorrectly) { +// EXPECT_TRUE(a_.StatusIsOK()); +// } +// +// TEST_F(FooTest, ReturnsElementCountCorrectly) { +// EXPECT_EQ(0, a_.size()); +// EXPECT_EQ(1, b_.size()); +// } + +#define TEST_F(test_fixture, test_name)\ + GTEST_TEST_(test_fixture, test_name, test_fixture, \ + ::testing::internal::GetTypeId<test_fixture>()) + +// Use this macro in main() to run all tests. It returns 0 if all +// tests are successful, or 1 otherwise. +// +// RUN_ALL_TESTS() should be invoked after the command line has been +// parsed by InitGoogleTest(). + +#define RUN_ALL_TESTS()\ + (::testing::UnitTest::GetInstance()->Run()) + +} // namespace testing + +#endif // GTEST_INCLUDE_GTEST_GTEST_H_ diff --git a/tests/gtest/include/gtest/gtest_pred_impl.h b/tests/gtest/include/gtest/gtest_pred_impl.h new file mode 100644 index 000000000..3805f85bd --- /dev/null +++ b/tests/gtest/include/gtest/gtest_pred_impl.h @@ -0,0 +1,358 @@ +// Copyright 2006, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// This file is AUTOMATICALLY GENERATED on 09/24/2010 by command +// 'gen_gtest_pred_impl.py 5'. DO NOT EDIT BY HAND! +// +// Implements a family of generic predicate assertion macros. + +#ifndef GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_ +#define GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_ + +// Makes sure this header is not included before gtest.h. +#ifndef GTEST_INCLUDE_GTEST_GTEST_H_ +# error Do not include gtest_pred_impl.h directly. Include gtest.h instead. +#endif // GTEST_INCLUDE_GTEST_GTEST_H_ + +// This header implements a family of generic predicate assertion +// macros: +// +// ASSERT_PRED_FORMAT1(pred_format, v1) +// ASSERT_PRED_FORMAT2(pred_format, v1, v2) +// ... +// +// where pred_format is a function or functor that takes n (in the +// case of ASSERT_PRED_FORMATn) values and their source expression +// text, and returns a testing::AssertionResult. See the definition +// of ASSERT_EQ in gtest.h for an example. +// +// If you don't care about formatting, you can use the more +// restrictive version: +// +// ASSERT_PRED1(pred, v1) +// ASSERT_PRED2(pred, v1, v2) +// ... +// +// where pred is an n-ary function or functor that returns bool, +// and the values v1, v2, ..., must support the << operator for +// streaming to std::ostream. +// +// We also define the EXPECT_* variations. +// +// For now we only support predicates whose arity is at most 5. +// Please email googletestframework@googlegroups.com if you need +// support for higher arities. + +// GTEST_ASSERT_ is the basic statement to which all of the assertions +// in this file reduce. Don't use this in your code. + +#define GTEST_ASSERT_(expression, on_failure) \ + GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ + if (const ::testing::AssertionResult gtest_ar = (expression)) \ + ; \ + else \ + on_failure(gtest_ar.failure_message()) + + +// Helper function for implementing {EXPECT|ASSERT}_PRED1. Don't use +// this in your code. +template <typename Pred, + typename T1> +AssertionResult AssertPred1Helper(const char* pred_text, + const char* e1, + Pred pred, + const T1& v1) { + if (pred(v1)) return AssertionSuccess(); + + return AssertionFailure() << pred_text << "(" + << e1 << ") evaluates to false, where" + << "\n" << e1 << " evaluates to " << v1; +} + +// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT1. +// Don't use this in your code. +#define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure)\ + GTEST_ASSERT_(pred_format(#v1, v1),\ + on_failure) + +// Internal macro for implementing {EXPECT|ASSERT}_PRED1. Don't use +// this in your code. +#define GTEST_PRED1_(pred, v1, on_failure)\ + GTEST_ASSERT_(::testing::AssertPred1Helper(#pred, \ + #v1, \ + pred, \ + v1), on_failure) + +// Unary predicate assertion macros. +#define EXPECT_PRED_FORMAT1(pred_format, v1) \ + GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_NONFATAL_FAILURE_) +#define EXPECT_PRED1(pred, v1) \ + GTEST_PRED1_(pred, v1, GTEST_NONFATAL_FAILURE_) +#define ASSERT_PRED_FORMAT1(pred_format, v1) \ + GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_FATAL_FAILURE_) +#define ASSERT_PRED1(pred, v1) \ + GTEST_PRED1_(pred, v1, GTEST_FATAL_FAILURE_) + + + +// Helper function for implementing {EXPECT|ASSERT}_PRED2. Don't use +// this in your code. +template <typename Pred, + typename T1, + typename T2> +AssertionResult AssertPred2Helper(const char* pred_text, + const char* e1, + const char* e2, + Pred pred, + const T1& v1, + const T2& v2) { + if (pred(v1, v2)) return AssertionSuccess(); + + return AssertionFailure() << pred_text << "(" + << e1 << ", " + << e2 << ") evaluates to false, where" + << "\n" << e1 << " evaluates to " << v1 + << "\n" << e2 << " evaluates to " << v2; +} + +// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT2. +// Don't use this in your code. +#define GTEST_PRED_FORMAT2_(pred_format, v1, v2, on_failure)\ + GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2),\ + on_failure) + +// Internal macro for implementing {EXPECT|ASSERT}_PRED2. Don't use +// this in your code. +#define GTEST_PRED2_(pred, v1, v2, on_failure)\ + GTEST_ASSERT_(::testing::AssertPred2Helper(#pred, \ + #v1, \ + #v2, \ + pred, \ + v1, \ + v2), on_failure) + +// Binary predicate assertion macros. +#define EXPECT_PRED_FORMAT2(pred_format, v1, v2) \ + GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_NONFATAL_FAILURE_) +#define EXPECT_PRED2(pred, v1, v2) \ + GTEST_PRED2_(pred, v1, v2, GTEST_NONFATAL_FAILURE_) +#define ASSERT_PRED_FORMAT2(pred_format, v1, v2) \ + GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_FATAL_FAILURE_) +#define ASSERT_PRED2(pred, v1, v2) \ + GTEST_PRED2_(pred, v1, v2, GTEST_FATAL_FAILURE_) + + + +// Helper function for implementing {EXPECT|ASSERT}_PRED3. Don't use +// this in your code. +template <typename Pred, + typename T1, + typename T2, + typename T3> +AssertionResult AssertPred3Helper(const char* pred_text, + const char* e1, + const char* e2, + const char* e3, + Pred pred, + const T1& v1, + const T2& v2, + const T3& v3) { + if (pred(v1, v2, v3)) return AssertionSuccess(); + + return AssertionFailure() << pred_text << "(" + << e1 << ", " + << e2 << ", " + << e3 << ") evaluates to false, where" + << "\n" << e1 << " evaluates to " << v1 + << "\n" << e2 << " evaluates to " << v2 + << "\n" << e3 << " evaluates to " << v3; +} + +// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT3. +// Don't use this in your code. +#define GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, on_failure)\ + GTEST_ASSERT_(pred_format(#v1, #v2, #v3, v1, v2, v3),\ + on_failure) + +// Internal macro for implementing {EXPECT|ASSERT}_PRED3. Don't use +// this in your code. +#define GTEST_PRED3_(pred, v1, v2, v3, on_failure)\ + GTEST_ASSERT_(::testing::AssertPred3Helper(#pred, \ + #v1, \ + #v2, \ + #v3, \ + pred, \ + v1, \ + v2, \ + v3), on_failure) + +// Ternary predicate assertion macros. +#define EXPECT_PRED_FORMAT3(pred_format, v1, v2, v3) \ + GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_NONFATAL_FAILURE_) +#define EXPECT_PRED3(pred, v1, v2, v3) \ + GTEST_PRED3_(pred, v1, v2, v3, GTEST_NONFATAL_FAILURE_) +#define ASSERT_PRED_FORMAT3(pred_format, v1, v2, v3) \ + GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_FATAL_FAILURE_) +#define ASSERT_PRED3(pred, v1, v2, v3) \ + GTEST_PRED3_(pred, v1, v2, v3, GTEST_FATAL_FAILURE_) + + + +// Helper function for implementing {EXPECT|ASSERT}_PRED4. Don't use +// this in your code. +template <typename Pred, + typename T1, + typename T2, + typename T3, + typename T4> +AssertionResult AssertPred4Helper(const char* pred_text, + const char* e1, + const char* e2, + const char* e3, + const char* e4, + Pred pred, + const T1& v1, + const T2& v2, + const T3& v3, + const T4& v4) { + if (pred(v1, v2, v3, v4)) return AssertionSuccess(); + + return AssertionFailure() << pred_text << "(" + << e1 << ", " + << e2 << ", " + << e3 << ", " + << e4 << ") evaluates to false, where" + << "\n" << e1 << " evaluates to " << v1 + << "\n" << e2 << " evaluates to " << v2 + << "\n" << e3 << " evaluates to " << v3 + << "\n" << e4 << " evaluates to " << v4; +} + +// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT4. +// Don't use this in your code. +#define GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, on_failure)\ + GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, v1, v2, v3, v4),\ + on_failure) + +// Internal macro for implementing {EXPECT|ASSERT}_PRED4. Don't use +// this in your code. +#define GTEST_PRED4_(pred, v1, v2, v3, v4, on_failure)\ + GTEST_ASSERT_(::testing::AssertPred4Helper(#pred, \ + #v1, \ + #v2, \ + #v3, \ + #v4, \ + pred, \ + v1, \ + v2, \ + v3, \ + v4), on_failure) + +// 4-ary predicate assertion macros. +#define EXPECT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \ + GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_) +#define EXPECT_PRED4(pred, v1, v2, v3, v4) \ + GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_) +#define ASSERT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \ + GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_FATAL_FAILURE_) +#define ASSERT_PRED4(pred, v1, v2, v3, v4) \ + GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_FATAL_FAILURE_) + + + +// Helper function for implementing {EXPECT|ASSERT}_PRED5. Don't use +// this in your code. +template <typename Pred, + typename T1, + typename T2, + typename T3, + typename T4, + typename T5> +AssertionResult AssertPred5Helper(const char* pred_text, + const char* e1, + const char* e2, + const char* e3, + const char* e4, + const char* e5, + Pred pred, + const T1& v1, + const T2& v2, + const T3& v3, + const T4& v4, + const T5& v5) { + if (pred(v1, v2, v3, v4, v5)) return AssertionSuccess(); + + return AssertionFailure() << pred_text << "(" + << e1 << ", " + << e2 << ", " + << e3 << ", " + << e4 << ", " + << e5 << ") evaluates to false, where" + << "\n" << e1 << " evaluates to " << v1 + << "\n" << e2 << " evaluates to " << v2 + << "\n" << e3 << " evaluates to " << v3 + << "\n" << e4 << " evaluates to " << v4 + << "\n" << e5 << " evaluates to " << v5; +} + +// Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT5. +// Don't use this in your code. +#define GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, on_failure)\ + GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, #v5, v1, v2, v3, v4, v5),\ + on_failure) + +// Internal macro for implementing {EXPECT|ASSERT}_PRED5. Don't use +// this in your code. +#define GTEST_PRED5_(pred, v1, v2, v3, v4, v5, on_failure)\ + GTEST_ASSERT_(::testing::AssertPred5Helper(#pred, \ + #v1, \ + #v2, \ + #v3, \ + #v4, \ + #v5, \ + pred, \ + v1, \ + v2, \ + v3, \ + v4, \ + v5), on_failure) + +// 5-ary predicate assertion macros. +#define EXPECT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \ + GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_) +#define EXPECT_PRED5(pred, v1, v2, v3, v4, v5) \ + GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_) +#define ASSERT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \ + GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_) +#define ASSERT_PRED5(pred, v1, v2, v3, v4, v5) \ + GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_) + + + +#endif // GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_ diff --git a/tests/gtest/include/gtest/gtest_prod.h b/tests/gtest/include/gtest/gtest_prod.h new file mode 100644 index 000000000..da80ddc6c --- /dev/null +++ b/tests/gtest/include/gtest/gtest_prod.h @@ -0,0 +1,58 @@ +// Copyright 2006, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Author: wan@google.com (Zhanyong Wan) +// +// Google C++ Testing Framework definitions useful in production code. + +#ifndef GTEST_INCLUDE_GTEST_GTEST_PROD_H_ +#define GTEST_INCLUDE_GTEST_GTEST_PROD_H_ + +// When you need to test the private or protected members of a class, +// use the FRIEND_TEST macro to declare your tests as friends of the +// class. For example: +// +// class MyClass { +// private: +// void MyMethod(); +// FRIEND_TEST(MyClassTest, MyMethod); +// }; +// +// class MyClassTest : public testing::Test { +// // ... +// }; +// +// TEST_F(MyClassTest, MyMethod) { +// // Can call MyClass::MyMethod() here. +// } + +#define FRIEND_TEST(test_case_name, test_name)\ +friend class test_case_name##_##test_name##_Test + +#endif // GTEST_INCLUDE_GTEST_GTEST_PROD_H_ diff --git a/tests/gtest/include/gtest/internal/gtest-death-test-internal.h b/tests/gtest/include/gtest/internal/gtest-death-test-internal.h new file mode 100644 index 000000000..1d9f83b65 --- /dev/null +++ b/tests/gtest/include/gtest/internal/gtest-death-test-internal.h @@ -0,0 +1,308 @@ +// Copyright 2005, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee) +// +// The Google C++ Testing Framework (Google Test) +// +// This header file defines internal utilities needed for implementing +// death tests. They are subject to change without notice. + +#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_ +#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_ + +#include "gtest/internal/gtest-internal.h" + +#include <stdio.h> + +namespace testing { +namespace internal { + +GTEST_DECLARE_string_(internal_run_death_test); + +// Names of the flags (needed for parsing Google Test flags). +const char kDeathTestStyleFlag[] = "death_test_style"; +const char kDeathTestUseFork[] = "death_test_use_fork"; +const char kInternalRunDeathTestFlag[] = "internal_run_death_test"; + +#if GTEST_HAS_DEATH_TEST + +// DeathTest is a class that hides much of the complexity of the +// GTEST_DEATH_TEST_ macro. It is abstract; its static Create method +// returns a concrete class that depends on the prevailing death test +// style, as defined by the --gtest_death_test_style and/or +// --gtest_internal_run_death_test flags. + +// In describing the results of death tests, these terms are used with +// the corresponding definitions: +// +// exit status: The integer exit information in the format specified +// by wait(2) +// exit code: The integer code passed to exit(3), _exit(2), or +// returned from main() +class GTEST_API_ DeathTest { + public: + // Create returns false if there was an error determining the + // appropriate action to take for the current death test; for example, + // if the gtest_death_test_style flag is set to an invalid value. + // The LastMessage method will return a more detailed message in that + // case. Otherwise, the DeathTest pointer pointed to by the "test" + // argument is set. If the death test should be skipped, the pointer + // is set to NULL; otherwise, it is set to the address of a new concrete + // DeathTest object that controls the execution of the current test. + static bool Create(const char* statement, const RE* regex, + const char* file, int line, DeathTest** test); + DeathTest(); + virtual ~DeathTest() { } + + // A helper class that aborts a death test when it's deleted. + class ReturnSentinel { + public: + explicit ReturnSentinel(DeathTest* test) : test_(test) { } + ~ReturnSentinel() { test_->Abort(TEST_ENCOUNTERED_RETURN_STATEMENT); } + private: + DeathTest* const test_; + GTEST_DISALLOW_COPY_AND_ASSIGN_(ReturnSentinel); + } GTEST_ATTRIBUTE_UNUSED_; + + // An enumeration of possible roles that may be taken when a death + // test is encountered. EXECUTE means that the death test logic should + // be executed immediately. OVERSEE means that the program should prepare + // the appropriate environment for a child process to execute the death + // test, then wait for it to complete. + enum TestRole { OVERSEE_TEST, EXECUTE_TEST }; + + // An enumeration of the three reasons that a test might be aborted. + enum AbortReason { + TEST_ENCOUNTERED_RETURN_STATEMENT, + TEST_THREW_EXCEPTION, + TEST_DID_NOT_DIE + }; + + // Assumes one of the above roles. + virtual TestRole AssumeRole() = 0; + + // Waits for the death test to finish and returns its status. + virtual int Wait() = 0; + + // Returns true if the death test passed; that is, the test process + // exited during the test, its exit status matches a user-supplied + // predicate, and its stderr output matches a user-supplied regular + // expression. + // The user-supplied predicate may be a macro expression rather + // than a function pointer or functor, or else Wait and Passed could + // be combined. + virtual bool Passed(bool exit_status_ok) = 0; + + // Signals that the death test did not die as expected. + virtual void Abort(AbortReason reason) = 0; + + // Returns a human-readable outcome message regarding the outcome of + // the last death test. + static const char* LastMessage(); + + static void set_last_death_test_message(const String& message); + + private: + // A string containing a description of the outcome of the last death test. + static String last_death_test_message_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(DeathTest); +}; + +// Factory interface for death tests. May be mocked out for testing. +class DeathTestFactory { + public: + virtual ~DeathTestFactory() { } + virtual bool Create(const char* statement, const RE* regex, + const char* file, int line, DeathTest** test) = 0; +}; + +// A concrete DeathTestFactory implementation for normal use. +class DefaultDeathTestFactory : public DeathTestFactory { + public: + virtual bool Create(const char* statement, const RE* regex, + const char* file, int line, DeathTest** test); +}; + +// Returns true if exit_status describes a process that was terminated +// by a signal, or exited normally with a nonzero exit code. +GTEST_API_ bool ExitedUnsuccessfully(int exit_status); + +// Traps C++ exceptions escaping statement and reports them as test +// failures. Note that trapping SEH exceptions is not implemented here. +# if GTEST_HAS_EXCEPTIONS +# define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \ + try { \ + GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ + } catch (const ::std::exception& gtest_exception) { \ + fprintf(\ + stderr, \ + "\n%s: Caught std::exception-derived exception escaping the " \ + "death test statement. Exception message: %s\n", \ + ::testing::internal::FormatFileLocation(__FILE__, __LINE__).c_str(), \ + gtest_exception.what()); \ + fflush(stderr); \ + death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \ + } catch (...) { \ + death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \ + } + +# else +# define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \ + GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) + +# endif + +// This macro is for implementing ASSERT_DEATH*, EXPECT_DEATH*, +// ASSERT_EXIT*, and EXPECT_EXIT*. +# define GTEST_DEATH_TEST_(statement, predicate, regex, fail) \ + GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ + if (::testing::internal::AlwaysTrue()) { \ + const ::testing::internal::RE& gtest_regex = (regex); \ + ::testing::internal::DeathTest* gtest_dt; \ + if (!::testing::internal::DeathTest::Create(#statement, >est_regex, \ + __FILE__, __LINE__, >est_dt)) { \ + goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__); \ + } \ + if (gtest_dt != NULL) { \ + ::testing::internal::scoped_ptr< ::testing::internal::DeathTest> \ + gtest_dt_ptr(gtest_dt); \ + switch (gtest_dt->AssumeRole()) { \ + case ::testing::internal::DeathTest::OVERSEE_TEST: \ + if (!gtest_dt->Passed(predicate(gtest_dt->Wait()))) { \ + goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__); \ + } \ + break; \ + case ::testing::internal::DeathTest::EXECUTE_TEST: { \ + ::testing::internal::DeathTest::ReturnSentinel \ + gtest_sentinel(gtest_dt); \ + GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, gtest_dt); \ + gtest_dt->Abort(::testing::internal::DeathTest::TEST_DID_NOT_DIE); \ + break; \ + } \ + default: \ + break; \ + } \ + } \ + } else \ + GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__): \ + fail(::testing::internal::DeathTest::LastMessage()) +// The symbol "fail" here expands to something into which a message +// can be streamed. + +// A class representing the parsed contents of the +// --gtest_internal_run_death_test flag, as it existed when +// RUN_ALL_TESTS was called. +class InternalRunDeathTestFlag { + public: + InternalRunDeathTestFlag(const String& a_file, + int a_line, + int an_index, + int a_write_fd) + : file_(a_file), line_(a_line), index_(an_index), + write_fd_(a_write_fd) {} + + ~InternalRunDeathTestFlag() { + if (write_fd_ >= 0) + posix::Close(write_fd_); + } + + String file() const { return file_; } + int line() const { return line_; } + int index() const { return index_; } + int write_fd() const { return write_fd_; } + + private: + String file_; + int line_; + int index_; + int write_fd_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(InternalRunDeathTestFlag); +}; + +// Returns a newly created InternalRunDeathTestFlag object with fields +// initialized from the GTEST_FLAG(internal_run_death_test) flag if +// the flag is specified; otherwise returns NULL. +InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag(); + +#else // GTEST_HAS_DEATH_TEST + +// This macro is used for implementing macros such as +// EXPECT_DEATH_IF_SUPPORTED and ASSERT_DEATH_IF_SUPPORTED on systems where +// death tests are not supported. Those macros must compile on such systems +// iff EXPECT_DEATH and ASSERT_DEATH compile with the same parameters on +// systems that support death tests. This allows one to write such a macro +// on a system that does not support death tests and be sure that it will +// compile on a death-test supporting system. +// +// Parameters: +// statement - A statement that a macro such as EXPECT_DEATH would test +// for program termination. This macro has to make sure this +// statement is compiled but not executed, to ensure that +// EXPECT_DEATH_IF_SUPPORTED compiles with a certain +// parameter iff EXPECT_DEATH compiles with it. +// regex - A regex that a macro such as EXPECT_DEATH would use to test +// the output of statement. This parameter has to be +// compiled but not evaluated by this macro, to ensure that +// this macro only accepts expressions that a macro such as +// EXPECT_DEATH would accept. +// terminator - Must be an empty statement for EXPECT_DEATH_IF_SUPPORTED +// and a return statement for ASSERT_DEATH_IF_SUPPORTED. +// This ensures that ASSERT_DEATH_IF_SUPPORTED will not +// compile inside functions where ASSERT_DEATH doesn't +// compile. +// +// The branch that has an always false condition is used to ensure that +// statement and regex are compiled (and thus syntactically correct) but +// never executed. The unreachable code macro protects the terminator +// statement from generating an 'unreachable code' warning in case +// statement unconditionally returns or throws. The Message constructor at +// the end allows the syntax of streaming additional messages into the +// macro, for compilational compatibility with EXPECT_DEATH/ASSERT_DEATH. +# define GTEST_UNSUPPORTED_DEATH_TEST_(statement, regex, terminator) \ + GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ + if (::testing::internal::AlwaysTrue()) { \ + GTEST_LOG_(WARNING) \ + << "Death tests are not supported on this platform.\n" \ + << "Statement '" #statement "' cannot be verified."; \ + } else if (::testing::internal::AlwaysFalse()) { \ + ::testing::internal::RE::PartialMatch(".*", (regex)); \ + GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ + terminator; \ + } else \ + ::testing::Message() + +#endif // GTEST_HAS_DEATH_TEST + +} // namespace internal +} // namespace testing + +#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_ diff --git a/tests/gtest/include/gtest/internal/gtest-filepath.h b/tests/gtest/include/gtest/internal/gtest-filepath.h new file mode 100644 index 000000000..b36b3cf21 --- /dev/null +++ b/tests/gtest/include/gtest/internal/gtest-filepath.h @@ -0,0 +1,210 @@ +// Copyright 2008, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Author: keith.ray@gmail.com (Keith Ray) +// +// Google Test filepath utilities +// +// This header file declares classes and functions used internally by +// Google Test. They are subject to change without notice. +// +// This file is #included in <gtest/internal/gtest-internal.h>. +// Do not include this header file separately! + +#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_ +#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_ + +#include "gtest/internal/gtest-string.h" + +namespace testing { +namespace internal { + +// FilePath - a class for file and directory pathname manipulation which +// handles platform-specific conventions (like the pathname separator). +// Used for helper functions for naming files in a directory for xml output. +// Except for Set methods, all methods are const or static, which provides an +// "immutable value object" -- useful for peace of mind. +// A FilePath with a value ending in a path separator ("like/this/") represents +// a directory, otherwise it is assumed to represent a file. In either case, +// it may or may not represent an actual file or directory in the file system. +// Names are NOT checked for syntax correctness -- no checking for illegal +// characters, malformed paths, etc. + +class GTEST_API_ FilePath { + public: + FilePath() : pathname_("") { } + FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) { } + + explicit FilePath(const char* pathname) : pathname_(pathname) { + Normalize(); + } + + explicit FilePath(const String& pathname) : pathname_(pathname) { + Normalize(); + } + + FilePath& operator=(const FilePath& rhs) { + Set(rhs); + return *this; + } + + void Set(const FilePath& rhs) { + pathname_ = rhs.pathname_; + } + + String ToString() const { return pathname_; } + const char* c_str() const { return pathname_.c_str(); } + + // Returns the current working directory, or "" if unsuccessful. + static FilePath GetCurrentDir(); + + // Given directory = "dir", base_name = "test", number = 0, + // extension = "xml", returns "dir/test.xml". If number is greater + // than zero (e.g., 12), returns "dir/test_12.xml". + // On Windows platform, uses \ as the separator rather than /. + static FilePath MakeFileName(const FilePath& directory, + const FilePath& base_name, + int number, + const char* extension); + + // Given directory = "dir", relative_path = "test.xml", + // returns "dir/test.xml". + // On Windows, uses \ as the separator rather than /. + static FilePath ConcatPaths(const FilePath& directory, + const FilePath& relative_path); + + // Returns a pathname for a file that does not currently exist. The pathname + // will be directory/base_name.extension or + // directory/base_name_<number>.extension if directory/base_name.extension + // already exists. The number will be incremented until a pathname is found + // that does not already exist. + // Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'. + // There could be a race condition if two or more processes are calling this + // function at the same time -- they could both pick the same filename. + static FilePath GenerateUniqueFileName(const FilePath& directory, + const FilePath& base_name, + const char* extension); + + // Returns true iff the path is NULL or "". + bool IsEmpty() const { return c_str() == NULL || *c_str() == '\0'; } + + // If input name has a trailing separator character, removes it and returns + // the name, otherwise return the name string unmodified. + // On Windows platform, uses \ as the separator, other platforms use /. + FilePath RemoveTrailingPathSeparator() const; + + // Returns a copy of the FilePath with the directory part removed. + // Example: FilePath("path/to/file").RemoveDirectoryName() returns + // FilePath("file"). If there is no directory part ("just_a_file"), it returns + // the FilePath unmodified. If there is no file part ("just_a_dir/") it + // returns an empty FilePath (""). + // On Windows platform, '\' is the path separator, otherwise it is '/'. + FilePath RemoveDirectoryName() const; + + // RemoveFileName returns the directory path with the filename removed. + // Example: FilePath("path/to/file").RemoveFileName() returns "path/to/". + // If the FilePath is "a_file" or "/a_file", RemoveFileName returns + // FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does + // not have a file, like "just/a/dir/", it returns the FilePath unmodified. + // On Windows platform, '\' is the path separator, otherwise it is '/'. + FilePath RemoveFileName() const; + + // Returns a copy of the FilePath with the case-insensitive extension removed. + // Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns + // FilePath("dir/file"). If a case-insensitive extension is not + // found, returns a copy of the original FilePath. + FilePath RemoveExtension(const char* extension) const; + + // Creates directories so that path exists. Returns true if successful or if + // the directories already exist; returns false if unable to create + // directories for any reason. Will also return false if the FilePath does + // not represent a directory (that is, it doesn't end with a path separator). + bool CreateDirectoriesRecursively() const; + + // Create the directory so that path exists. Returns true if successful or + // if the directory already exists; returns false if unable to create the + // directory for any reason, including if the parent directory does not + // exist. Not named "CreateDirectory" because that's a macro on Windows. + bool CreateFolder() const; + + // Returns true if FilePath describes something in the file-system, + // either a file, directory, or whatever, and that something exists. + bool FileOrDirectoryExists() const; + + // Returns true if pathname describes a directory in the file-system + // that exists. + bool DirectoryExists() const; + + // Returns true if FilePath ends with a path separator, which indicates that + // it is intended to represent a directory. Returns false otherwise. + // This does NOT check that a directory (or file) actually exists. + bool IsDirectory() const; + + // Returns true if pathname describes a root directory. (Windows has one + // root directory per disk drive.) + bool IsRootDirectory() const; + + // Returns true if pathname describes an absolute path. + bool IsAbsolutePath() const; + + private: + // Replaces multiple consecutive separators with a single separator. + // For example, "bar///foo" becomes "bar/foo". Does not eliminate other + // redundancies that might be in a pathname involving "." or "..". + // + // A pathname with multiple consecutive separators may occur either through + // user error or as a result of some scripts or APIs that generate a pathname + // with a trailing separator. On other platforms the same API or script + // may NOT generate a pathname with a trailing "/". Then elsewhere that + // pathname may have another "/" and pathname components added to it, + // without checking for the separator already being there. + // The script language and operating system may allow paths like "foo//bar" + // but some of the functions in FilePath will not handle that correctly. In + // particular, RemoveTrailingPathSeparator() only removes one separator, and + // it is called in CreateDirectoriesRecursively() assuming that it will change + // a pathname from directory syntax (trailing separator) to filename syntax. + // + // On Windows this method also replaces the alternate path separator '/' with + // the primary path separator '\\', so that for example "bar\\/\\foo" becomes + // "bar\\foo". + + void Normalize(); + + // Returns a pointer to the last occurence of a valid path separator in + // the FilePath. On Windows, for example, both '/' and '\' are valid path + // separators. Returns NULL if no path separator was found. + const char* FindLastPathSeparator() const; + + String pathname_; +}; // class FilePath + +} // namespace internal +} // namespace testing + +#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_ diff --git a/tests/gtest/include/gtest/internal/gtest-internal.h b/tests/gtest/include/gtest/internal/gtest-internal.h new file mode 100644 index 000000000..7aa1197f1 --- /dev/null +++ b/tests/gtest/include/gtest/internal/gtest-internal.h @@ -0,0 +1,1226 @@ +// Copyright 2005, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee) +// +// The Google C++ Testing Framework (Google Test) +// +// This header file declares functions and macros used internally by +// Google Test. They are subject to change without notice. + +#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_ +#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_ + +#include "gtest/internal/gtest-port.h" + +#if GTEST_OS_LINUX +# include <stdlib.h> +# include <sys/types.h> +# include <sys/wait.h> +# include <unistd.h> +#endif // GTEST_OS_LINUX + +#include <ctype.h> +#include <string.h> +#include <iomanip> +#include <limits> +#include <set> + +#include "gtest/internal/gtest-string.h" +#include "gtest/internal/gtest-filepath.h" +#include "gtest/internal/gtest-type-util.h" + +// Due to C++ preprocessor weirdness, we need double indirection to +// concatenate two tokens when one of them is __LINE__. Writing +// +// foo ## __LINE__ +// +// will result in the token foo__LINE__, instead of foo followed by +// the current line number. For more details, see +// http://www.parashift.com/c++-faq-lite/misc-technical-issues.html#faq-39.6 +#define GTEST_CONCAT_TOKEN_(foo, bar) GTEST_CONCAT_TOKEN_IMPL_(foo, bar) +#define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo ## bar + +// Google Test defines the testing::Message class to allow construction of +// test messages via the << operator. The idea is that anything +// streamable to std::ostream can be streamed to a testing::Message. +// This allows a user to use his own types in Google Test assertions by +// overloading the << operator. +// +// util/gtl/stl_logging-inl.h overloads << for STL containers. These +// overloads cannot be defined in the std namespace, as that will be +// undefined behavior. Therefore, they are defined in the global +// namespace instead. +// +// C++'s symbol lookup rule (i.e. Koenig lookup) says that these +// overloads are visible in either the std namespace or the global +// namespace, but not other namespaces, including the testing +// namespace which Google Test's Message class is in. +// +// To allow STL containers (and other types that has a << operator +// defined in the global namespace) to be used in Google Test assertions, +// testing::Message must access the custom << operator from the global +// namespace. Hence this helper function. +// +// Note: Jeffrey Yasskin suggested an alternative fix by "using +// ::operator<<;" in the definition of Message's operator<<. That fix +// doesn't require a helper function, but unfortunately doesn't +// compile with MSVC. +template <typename T> +inline void GTestStreamToHelper(std::ostream* os, const T& val) { + *os << val; +} + +class ProtocolMessage; +namespace proto2 { class Message; } + +namespace testing { + +// Forward declarations. + +class AssertionResult; // Result of an assertion. +class Message; // Represents a failure message. +class Test; // Represents a test. +class TestInfo; // Information about a test. +class TestPartResult; // Result of a test part. +class UnitTest; // A collection of test cases. + +template <typename T> +::std::string PrintToString(const T& value); + +namespace internal { + +struct TraceInfo; // Information about a trace point. +class ScopedTrace; // Implements scoped trace. +class TestInfoImpl; // Opaque implementation of TestInfo +class UnitTestImpl; // Opaque implementation of UnitTest + +// How many times InitGoogleTest() has been called. +extern int g_init_gtest_count; + +// The text used in failure messages to indicate the start of the +// stack trace. +GTEST_API_ extern const char kStackTraceMarker[]; + +// A secret type that Google Test users don't know about. It has no +// definition on purpose. Therefore it's impossible to create a +// Secret object, which is what we want. +class Secret; + +// Two overloaded helpers for checking at compile time whether an +// expression is a null pointer literal (i.e. NULL or any 0-valued +// compile-time integral constant). Their return values have +// different sizes, so we can use sizeof() to test which version is +// picked by the compiler. These helpers have no implementations, as +// we only need their signatures. +// +// Given IsNullLiteralHelper(x), the compiler will pick the first +// version if x can be implicitly converted to Secret*, and pick the +// second version otherwise. Since Secret is a secret and incomplete +// type, the only expression a user can write that has type Secret* is +// a null pointer literal. Therefore, we know that x is a null +// pointer literal if and only if the first version is picked by the +// compiler. +char IsNullLiteralHelper(Secret* p); +char (&IsNullLiteralHelper(...))[2]; // NOLINT + +// A compile-time bool constant that is true if and only if x is a +// null pointer literal (i.e. NULL or any 0-valued compile-time +// integral constant). +#ifdef GTEST_ELLIPSIS_NEEDS_POD_ +// We lose support for NULL detection where the compiler doesn't like +// passing non-POD classes through ellipsis (...). +# define GTEST_IS_NULL_LITERAL_(x) false +#else +# define GTEST_IS_NULL_LITERAL_(x) \ + (sizeof(::testing::internal::IsNullLiteralHelper(x)) == 1) +#endif // GTEST_ELLIPSIS_NEEDS_POD_ + +// Appends the user-supplied message to the Google-Test-generated message. +GTEST_API_ String AppendUserMessage(const String& gtest_msg, + const Message& user_msg); + +// A helper class for creating scoped traces in user programs. +class GTEST_API_ ScopedTrace { + public: + // The c'tor pushes the given source file location and message onto + // a trace stack maintained by Google Test. + ScopedTrace(const char* file, int line, const Message& message); + + // The d'tor pops the info pushed by the c'tor. + // + // Note that the d'tor is not virtual in order to be efficient. + // Don't inherit from ScopedTrace! + ~ScopedTrace(); + + private: + GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedTrace); +} GTEST_ATTRIBUTE_UNUSED_; // A ScopedTrace object does its job in its + // c'tor and d'tor. Therefore it doesn't + // need to be used otherwise. + +// Converts a streamable value to a String. A NULL pointer is +// converted to "(null)". When the input value is a ::string, +// ::std::string, ::wstring, or ::std::wstring object, each NUL +// character in it is replaced with "\\0". +// Declared here but defined in gtest.h, so that it has access +// to the definition of the Message class, required by the ARM +// compiler. +template <typename T> +String StreamableToString(const T& streamable); + +// The Symbian compiler has a bug that prevents it from selecting the +// correct overload of FormatForComparisonFailureMessage (see below) +// unless we pass the first argument by reference. If we do that, +// however, Visual Age C++ 10.1 generates a compiler error. Therefore +// we only apply the work-around for Symbian. +#if defined(__SYMBIAN32__) +# define GTEST_CREF_WORKAROUND_ const& +#else +# define GTEST_CREF_WORKAROUND_ +#endif + +// When this operand is a const char* or char*, if the other operand +// is a ::std::string or ::string, we print this operand as a C string +// rather than a pointer (we do the same for wide strings); otherwise +// we print it as a pointer to be safe. + +// This internal macro is used to avoid duplicated code. +#define GTEST_FORMAT_IMPL_(operand2_type, operand1_printer)\ +inline String FormatForComparisonFailureMessage(\ + operand2_type::value_type* GTEST_CREF_WORKAROUND_ str, \ + const operand2_type& /*operand2*/) {\ + return operand1_printer(str);\ +}\ +inline String FormatForComparisonFailureMessage(\ + const operand2_type::value_type* GTEST_CREF_WORKAROUND_ str, \ + const operand2_type& /*operand2*/) {\ + return operand1_printer(str);\ +} + +GTEST_FORMAT_IMPL_(::std::string, String::ShowCStringQuoted) +#if GTEST_HAS_STD_WSTRING +GTEST_FORMAT_IMPL_(::std::wstring, String::ShowWideCStringQuoted) +#endif // GTEST_HAS_STD_WSTRING + +#if GTEST_HAS_GLOBAL_STRING +GTEST_FORMAT_IMPL_(::string, String::ShowCStringQuoted) +#endif // GTEST_HAS_GLOBAL_STRING +#if GTEST_HAS_GLOBAL_WSTRING +GTEST_FORMAT_IMPL_(::wstring, String::ShowWideCStringQuoted) +#endif // GTEST_HAS_GLOBAL_WSTRING + +#undef GTEST_FORMAT_IMPL_ + +// The next four overloads handle the case where the operand being +// printed is a char/wchar_t pointer and the other operand is not a +// string/wstring object. In such cases, we just print the operand as +// a pointer to be safe. +#define GTEST_FORMAT_CHAR_PTR_IMPL_(CharType) \ + template <typename T> \ + String FormatForComparisonFailureMessage(CharType* GTEST_CREF_WORKAROUND_ p, \ + const T&) { \ + return PrintToString(static_cast<const void*>(p)); \ + } + +GTEST_FORMAT_CHAR_PTR_IMPL_(char) +GTEST_FORMAT_CHAR_PTR_IMPL_(const char) +GTEST_FORMAT_CHAR_PTR_IMPL_(wchar_t) +GTEST_FORMAT_CHAR_PTR_IMPL_(const wchar_t) + +#undef GTEST_FORMAT_CHAR_PTR_IMPL_ + +// Constructs and returns the message for an equality assertion +// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure. +// +// The first four parameters are the expressions used in the assertion +// and their values, as strings. For example, for ASSERT_EQ(foo, bar) +// where foo is 5 and bar is 6, we have: +// +// expected_expression: "foo" +// actual_expression: "bar" +// expected_value: "5" +// actual_value: "6" +// +// The ignoring_case parameter is true iff the assertion is a +// *_STRCASEEQ*. When it's true, the string " (ignoring case)" will +// be inserted into the message. +GTEST_API_ AssertionResult EqFailure(const char* expected_expression, + const char* actual_expression, + const String& expected_value, + const String& actual_value, + bool ignoring_case); + +// Constructs a failure message for Boolean assertions such as EXPECT_TRUE. +GTEST_API_ String GetBoolAssertionFailureMessage( + const AssertionResult& assertion_result, + const char* expression_text, + const char* actual_predicate_value, + const char* expected_predicate_value); + +// This template class represents an IEEE floating-point number +// (either single-precision or double-precision, depending on the +// template parameters). +// +// The purpose of this class is to do more sophisticated number +// comparison. (Due to round-off error, etc, it's very unlikely that +// two floating-points will be equal exactly. Hence a naive +// comparison by the == operation often doesn't work.) +// +// Format of IEEE floating-point: +// +// The most-significant bit being the leftmost, an IEEE +// floating-point looks like +// +// sign_bit exponent_bits fraction_bits +// +// Here, sign_bit is a single bit that designates the sign of the +// number. +// +// For float, there are 8 exponent bits and 23 fraction bits. +// +// For double, there are 11 exponent bits and 52 fraction bits. +// +// More details can be found at +// http://en.wikipedia.org/wiki/IEEE_floating-point_standard. +// +// Template parameter: +// +// RawType: the raw floating-point type (either float or double) +template <typename RawType> +class FloatingPoint { + public: + // Defines the unsigned integer type that has the same size as the + // floating point number. + typedef typename TypeWithSize<sizeof(RawType)>::UInt Bits; + + // Constants. + + // # of bits in a number. + static const size_t kBitCount = 8*sizeof(RawType); + + // # of fraction bits in a number. + static const size_t kFractionBitCount = + std::numeric_limits<RawType>::digits - 1; + + // # of exponent bits in a number. + static const size_t kExponentBitCount = kBitCount - 1 - kFractionBitCount; + + // The mask for the sign bit. + static const Bits kSignBitMask = static_cast<Bits>(1) << (kBitCount - 1); + + // The mask for the fraction bits. + static const Bits kFractionBitMask = + ~static_cast<Bits>(0) >> (kExponentBitCount + 1); + + // The mask for the exponent bits. + static const Bits kExponentBitMask = ~(kSignBitMask | kFractionBitMask); + + // How many ULP's (Units in the Last Place) we want to tolerate when + // comparing two numbers. The larger the value, the more error we + // allow. A 0 value means that two numbers must be exactly the same + // to be considered equal. + // + // The maximum error of a single floating-point operation is 0.5 + // units in the last place. On Intel CPU's, all floating-point + // calculations are done with 80-bit precision, while double has 64 + // bits. Therefore, 4 should be enough for ordinary use. + // + // See the following article for more details on ULP: + // http://www.cygnus-software.com/papers/comparingfloats/comparingfloats.htm. + static const size_t kMaxUlps = 4; + + // Constructs a FloatingPoint from a raw floating-point number. + // + // On an Intel CPU, passing a non-normalized NAN (Not a Number) + // around may change its bits, although the new value is guaranteed + // to be also a NAN. Therefore, don't expect this constructor to + // preserve the bits in x when x is a NAN. + explicit FloatingPoint(const RawType& x) { u_.value_ = x; } + + // Static methods + + // Reinterprets a bit pattern as a floating-point number. + // + // This function is needed to test the AlmostEquals() method. + static RawType ReinterpretBits(const Bits bits) { + FloatingPoint fp(0); + fp.u_.bits_ = bits; + return fp.u_.value_; + } + + // Returns the floating-point number that represent positive infinity. + static RawType Infinity() { + return ReinterpretBits(kExponentBitMask); + } + + // Non-static methods + + // Returns the bits that represents this number. + const Bits &bits() const { return u_.bits_; } + + // Returns the exponent bits of this number. + Bits exponent_bits() const { return kExponentBitMask & u_.bits_; } + + // Returns the fraction bits of this number. + Bits fraction_bits() const { return kFractionBitMask & u_.bits_; } + + // Returns the sign bit of this number. + Bits sign_bit() const { return kSignBitMask & u_.bits_; } + + // Returns true iff this is NAN (not a number). + bool is_nan() const { + // It's a NAN if the exponent bits are all ones and the fraction + // bits are not entirely zeros. + return (exponent_bits() == kExponentBitMask) && (fraction_bits() != 0); + } + + // Returns true iff this number is at most kMaxUlps ULP's away from + // rhs. In particular, this function: + // + // - returns false if either number is (or both are) NAN. + // - treats really large numbers as almost equal to infinity. + // - thinks +0.0 and -0.0 are 0 DLP's apart. + bool AlmostEquals(const FloatingPoint& rhs) const { + // The IEEE standard says that any comparison operation involving + // a NAN must return false. + if (is_nan() || rhs.is_nan()) return false; + + return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_) + <= kMaxUlps; + } + + private: + // The data type used to store the actual floating-point number. + union FloatingPointUnion { + RawType value_; // The raw floating-point number. + Bits bits_; // The bits that represent the number. + }; + + // Converts an integer from the sign-and-magnitude representation to + // the biased representation. More precisely, let N be 2 to the + // power of (kBitCount - 1), an integer x is represented by the + // unsigned number x + N. + // + // For instance, + // + // -N + 1 (the most negative number representable using + // sign-and-magnitude) is represented by 1; + // 0 is represented by N; and + // N - 1 (the biggest number representable using + // sign-and-magnitude) is represented by 2N - 1. + // + // Read http://en.wikipedia.org/wiki/Signed_number_representations + // for more details on signed number representations. + static Bits SignAndMagnitudeToBiased(const Bits &sam) { + if (kSignBitMask & sam) { + // sam represents a negative number. + return ~sam + 1; + } else { + // sam represents a positive number. + return kSignBitMask | sam; + } + } + + // Given two numbers in the sign-and-magnitude representation, + // returns the distance between them as an unsigned number. + static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits &sam1, + const Bits &sam2) { + const Bits biased1 = SignAndMagnitudeToBiased(sam1); + const Bits biased2 = SignAndMagnitudeToBiased(sam2); + return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1); + } + + FloatingPointUnion u_; +}; + +// Typedefs the instances of the FloatingPoint template class that we +// care to use. +typedef FloatingPoint<float> Float; +typedef FloatingPoint<double> Double; + +// In order to catch the mistake of putting tests that use different +// test fixture classes in the same test case, we need to assign +// unique IDs to fixture classes and compare them. The TypeId type is +// used to hold such IDs. The user should treat TypeId as an opaque +// type: the only operation allowed on TypeId values is to compare +// them for equality using the == operator. +typedef const void* TypeId; + +template <typename T> +class TypeIdHelper { + public: + // dummy_ must not have a const type. Otherwise an overly eager + // compiler (e.g. MSVC 7.1 & 8.0) may try to merge + // TypeIdHelper<T>::dummy_ for different Ts as an "optimization". + static bool dummy_; +}; + +template <typename T> +bool TypeIdHelper<T>::dummy_ = false; + +// GetTypeId<T>() returns the ID of type T. Different values will be +// returned for different types. Calling the function twice with the +// same type argument is guaranteed to return the same ID. +template <typename T> +TypeId GetTypeId() { + // The compiler is required to allocate a different + // TypeIdHelper<T>::dummy_ variable for each T used to instantiate + // the template. Therefore, the address of dummy_ is guaranteed to + // be unique. + return &(TypeIdHelper<T>::dummy_); +} + +// Returns the type ID of ::testing::Test. Always call this instead +// of GetTypeId< ::testing::Test>() to get the type ID of +// ::testing::Test, as the latter may give the wrong result due to a +// suspected linker bug when compiling Google Test as a Mac OS X +// framework. +GTEST_API_ TypeId GetTestTypeId(); + +// Defines the abstract factory interface that creates instances +// of a Test object. +class TestFactoryBase { + public: + virtual ~TestFactoryBase() {} + + // Creates a test instance to run. The instance is both created and destroyed + // within TestInfoImpl::Run() + virtual Test* CreateTest() = 0; + + protected: + TestFactoryBase() {} + + private: + GTEST_DISALLOW_COPY_AND_ASSIGN_(TestFactoryBase); +}; + +// This class provides implementation of TeastFactoryBase interface. +// It is used in TEST and TEST_F macros. +template <class TestClass> +class TestFactoryImpl : public TestFactoryBase { + public: + virtual Test* CreateTest() { return new TestClass; } +}; + +#if GTEST_OS_WINDOWS + +// Predicate-formatters for implementing the HRESULT checking macros +// {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED} +// We pass a long instead of HRESULT to avoid causing an +// include dependency for the HRESULT type. +GTEST_API_ AssertionResult IsHRESULTSuccess(const char* expr, + long hr); // NOLINT +GTEST_API_ AssertionResult IsHRESULTFailure(const char* expr, + long hr); // NOLINT + +#endif // GTEST_OS_WINDOWS + +// Types of SetUpTestCase() and TearDownTestCase() functions. +typedef void (*SetUpTestCaseFunc)(); +typedef void (*TearDownTestCaseFunc)(); + +// Creates a new TestInfo object and registers it with Google Test; +// returns the created object. +// +// Arguments: +// +// test_case_name: name of the test case +// name: name of the test +// type_param the name of the test's type parameter, or NULL if +// this is not a typed or a type-parameterized test. +// value_param text representation of the test's value parameter, +// or NULL if this is not a type-parameterized test. +// fixture_class_id: ID of the test fixture class +// set_up_tc: pointer to the function that sets up the test case +// tear_down_tc: pointer to the function that tears down the test case +// factory: pointer to the factory that creates a test object. +// The newly created TestInfo instance will assume +// ownership of the factory object. +GTEST_API_ TestInfo* MakeAndRegisterTestInfo( + const char* test_case_name, const char* name, + const char* type_param, + const char* value_param, + TypeId fixture_class_id, + SetUpTestCaseFunc set_up_tc, + TearDownTestCaseFunc tear_down_tc, + TestFactoryBase* factory); + +// If *pstr starts with the given prefix, modifies *pstr to be right +// past the prefix and returns true; otherwise leaves *pstr unchanged +// and returns false. None of pstr, *pstr, and prefix can be NULL. +GTEST_API_ bool SkipPrefix(const char* prefix, const char** pstr); + +#if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P + +// State of the definition of a type-parameterized test case. +class GTEST_API_ TypedTestCasePState { + public: + TypedTestCasePState() : registered_(false) {} + + // Adds the given test name to defined_test_names_ and return true + // if the test case hasn't been registered; otherwise aborts the + // program. + bool AddTestName(const char* file, int line, const char* case_name, + const char* test_name) { + if (registered_) { + fprintf(stderr, "%s Test %s must be defined before " + "REGISTER_TYPED_TEST_CASE_P(%s, ...).\n", + FormatFileLocation(file, line).c_str(), test_name, case_name); + fflush(stderr); + posix::Abort(); + } + defined_test_names_.insert(test_name); + return true; + } + + // Verifies that registered_tests match the test names in + // defined_test_names_; returns registered_tests if successful, or + // aborts the program otherwise. + const char* VerifyRegisteredTestNames( + const char* file, int line, const char* registered_tests); + + private: + bool registered_; + ::std::set<const char*> defined_test_names_; +}; + +// Skips to the first non-space char after the first comma in 'str'; +// returns NULL if no comma is found in 'str'. +inline const char* SkipComma(const char* str) { + const char* comma = strchr(str, ','); + if (comma == NULL) { + return NULL; + } + while (IsSpace(*(++comma))) {} + return comma; +} + +// Returns the prefix of 'str' before the first comma in it; returns +// the entire string if it contains no comma. +inline String GetPrefixUntilComma(const char* str) { + const char* comma = strchr(str, ','); + return comma == NULL ? String(str) : String(str, comma - str); +} + +// TypeParameterizedTest<Fixture, TestSel, Types>::Register() +// registers a list of type-parameterized tests with Google Test. The +// return value is insignificant - we just need to return something +// such that we can call this function in a namespace scope. +// +// Implementation note: The GTEST_TEMPLATE_ macro declares a template +// template parameter. It's defined in gtest-type-util.h. +template <GTEST_TEMPLATE_ Fixture, class TestSel, typename Types> +class TypeParameterizedTest { + public: + // 'index' is the index of the test in the type list 'Types' + // specified in INSTANTIATE_TYPED_TEST_CASE_P(Prefix, TestCase, + // Types). Valid values for 'index' are [0, N - 1] where N is the + // length of Types. + static bool Register(const char* prefix, const char* case_name, + const char* test_names, int index) { + typedef typename Types::Head Type; + typedef Fixture<Type> FixtureClass; + typedef typename GTEST_BIND_(TestSel, Type) TestClass; + + // First, registers the first type-parameterized test in the type + // list. + MakeAndRegisterTestInfo( + String::Format("%s%s%s/%d", prefix, prefix[0] == '\0' ? "" : "/", + case_name, index).c_str(), + GetPrefixUntilComma(test_names).c_str(), + GetTypeName<Type>().c_str(), + NULL, // No value parameter. + GetTypeId<FixtureClass>(), + TestClass::SetUpTestCase, + TestClass::TearDownTestCase, + new TestFactoryImpl<TestClass>); + + // Next, recurses (at compile time) with the tail of the type list. + return TypeParameterizedTest<Fixture, TestSel, typename Types::Tail> + ::Register(prefix, case_name, test_names, index + 1); + } +}; + +// The base case for the compile time recursion. +template <GTEST_TEMPLATE_ Fixture, class TestSel> +class TypeParameterizedTest<Fixture, TestSel, Types0> { + public: + static bool Register(const char* /*prefix*/, const char* /*case_name*/, + const char* /*test_names*/, int /*index*/) { + return true; + } +}; + +// TypeParameterizedTestCase<Fixture, Tests, Types>::Register() +// registers *all combinations* of 'Tests' and 'Types' with Google +// Test. The return value is insignificant - we just need to return +// something such that we can call this function in a namespace scope. +template <GTEST_TEMPLATE_ Fixture, typename Tests, typename Types> +class TypeParameterizedTestCase { + public: + static bool Register(const char* prefix, const char* case_name, + const char* test_names) { + typedef typename Tests::Head Head; + + // First, register the first test in 'Test' for each type in 'Types'. + TypeParameterizedTest<Fixture, Head, Types>::Register( + prefix, case_name, test_names, 0); + + // Next, recurses (at compile time) with the tail of the test list. + return TypeParameterizedTestCase<Fixture, typename Tests::Tail, Types> + ::Register(prefix, case_name, SkipComma(test_names)); + } +}; + +// The base case for the compile time recursion. +template <GTEST_TEMPLATE_ Fixture, typename Types> +class TypeParameterizedTestCase<Fixture, Templates0, Types> { + public: + static bool Register(const char* /*prefix*/, const char* /*case_name*/, + const char* /*test_names*/) { + return true; + } +}; + +#endif // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P + +// Returns the current OS stack trace as a String. +// +// The maximum number of stack frames to be included is specified by +// the gtest_stack_trace_depth flag. The skip_count parameter +// specifies the number of top frames to be skipped, which doesn't +// count against the number of frames to be included. +// +// For example, if Foo() calls Bar(), which in turn calls +// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in +// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't. +GTEST_API_ String GetCurrentOsStackTraceExceptTop(UnitTest* unit_test, + int skip_count); + +// Helpers for suppressing warnings on unreachable code or constant +// condition. + +// Always returns true. +GTEST_API_ bool AlwaysTrue(); + +// Always returns false. +inline bool AlwaysFalse() { return !AlwaysTrue(); } + +// Helper for suppressing false warning from Clang on a const char* +// variable declared in a conditional expression always being NULL in +// the else branch. +struct GTEST_API_ ConstCharPtr { + ConstCharPtr(const char* str) : value(str) {} + operator bool() const { return true; } + const char* value; +}; + +// A simple Linear Congruential Generator for generating random +// numbers with a uniform distribution. Unlike rand() and srand(), it +// doesn't use global state (and therefore can't interfere with user +// code). Unlike rand_r(), it's portable. An LCG isn't very random, +// but it's good enough for our purposes. +class GTEST_API_ Random { + public: + static const UInt32 kMaxRange = 1u << 31; + + explicit Random(UInt32 seed) : state_(seed) {} + + void Reseed(UInt32 seed) { state_ = seed; } + + // Generates a random number from [0, range). Crashes if 'range' is + // 0 or greater than kMaxRange. + UInt32 Generate(UInt32 range); + + private: + UInt32 state_; + GTEST_DISALLOW_COPY_AND_ASSIGN_(Random); +}; + +// Defining a variable of type CompileAssertTypesEqual<T1, T2> will cause a +// compiler error iff T1 and T2 are different types. +template <typename T1, typename T2> +struct CompileAssertTypesEqual; + +template <typename T> +struct CompileAssertTypesEqual<T, T> { +}; + +// Removes the reference from a type if it is a reference type, +// otherwise leaves it unchanged. This is the same as +// tr1::remove_reference, which is not widely available yet. +template <typename T> +struct RemoveReference { typedef T type; }; // NOLINT +template <typename T> +struct RemoveReference<T&> { typedef T type; }; // NOLINT + +// A handy wrapper around RemoveReference that works when the argument +// T depends on template parameters. +#define GTEST_REMOVE_REFERENCE_(T) \ + typename ::testing::internal::RemoveReference<T>::type + +// Removes const from a type if it is a const type, otherwise leaves +// it unchanged. This is the same as tr1::remove_const, which is not +// widely available yet. +template <typename T> +struct RemoveConst { typedef T type; }; // NOLINT +template <typename T> +struct RemoveConst<const T> { typedef T type; }; // NOLINT + +// MSVC 8.0, Sun C++, and IBM XL C++ have a bug which causes the above +// definition to fail to remove the const in 'const int[3]' and 'const +// char[3][4]'. The following specialization works around the bug. +// However, it causes trouble with GCC and thus needs to be +// conditionally compiled. +#if defined(_MSC_VER) || defined(__SUNPRO_CC) || defined(__IBMCPP__) +template <typename T, size_t N> +struct RemoveConst<const T[N]> { + typedef typename RemoveConst<T>::type type[N]; +}; +#endif + +// A handy wrapper around RemoveConst that works when the argument +// T depends on template parameters. +#define GTEST_REMOVE_CONST_(T) \ + typename ::testing::internal::RemoveConst<T>::type + +// Turns const U&, U&, const U, and U all into U. +#define GTEST_REMOVE_REFERENCE_AND_CONST_(T) \ + GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(T)) + +// Adds reference to a type if it is not a reference type, +// otherwise leaves it unchanged. This is the same as +// tr1::add_reference, which is not widely available yet. +template <typename T> +struct AddReference { typedef T& type; }; // NOLINT +template <typename T> +struct AddReference<T&> { typedef T& type; }; // NOLINT + +// A handy wrapper around AddReference that works when the argument T +// depends on template parameters. +#define GTEST_ADD_REFERENCE_(T) \ + typename ::testing::internal::AddReference<T>::type + +// Adds a reference to const on top of T as necessary. For example, +// it transforms +// +// char ==> const char& +// const char ==> const char& +// char& ==> const char& +// const char& ==> const char& +// +// The argument T must depend on some template parameters. +#define GTEST_REFERENCE_TO_CONST_(T) \ + GTEST_ADD_REFERENCE_(const GTEST_REMOVE_REFERENCE_(T)) + +// ImplicitlyConvertible<From, To>::value is a compile-time bool +// constant that's true iff type From can be implicitly converted to +// type To. +template <typename From, typename To> +class ImplicitlyConvertible { + private: + // We need the following helper functions only for their types. + // They have no implementations. + + // MakeFrom() is an expression whose type is From. We cannot simply + // use From(), as the type From may not have a public default + // constructor. + static From MakeFrom(); + + // These two functions are overloaded. Given an expression + // Helper(x), the compiler will pick the first version if x can be + // implicitly converted to type To; otherwise it will pick the + // second version. + // + // The first version returns a value of size 1, and the second + // version returns a value of size 2. Therefore, by checking the + // size of Helper(x), which can be done at compile time, we can tell + // which version of Helper() is used, and hence whether x can be + // implicitly converted to type To. + static char Helper(To); + static char (&Helper(...))[2]; // NOLINT + + // We have to put the 'public' section after the 'private' section, + // or MSVC refuses to compile the code. + public: + // MSVC warns about implicitly converting from double to int for + // possible loss of data, so we need to temporarily disable the + // warning. +#ifdef _MSC_VER +# pragma warning(push) // Saves the current warning state. +# pragma warning(disable:4244) // Temporarily disables warning 4244. + + static const bool value = + sizeof(Helper(ImplicitlyConvertible::MakeFrom())) == 1; +# pragma warning(pop) // Restores the warning state. +#elif defined(__BORLANDC__) + // C++Builder cannot use member overload resolution during template + // instantiation. The simplest workaround is to use its C++0x type traits + // functions (C++Builder 2009 and above only). + static const bool value = __is_convertible(From, To); +#else + static const bool value = + sizeof(Helper(ImplicitlyConvertible::MakeFrom())) == 1; +#endif // _MSV_VER +}; +template <typename From, typename To> +const bool ImplicitlyConvertible<From, To>::value; + +// IsAProtocolMessage<T>::value is a compile-time bool constant that's +// true iff T is type ProtocolMessage, proto2::Message, or a subclass +// of those. +template <typename T> +struct IsAProtocolMessage + : public bool_constant< + ImplicitlyConvertible<const T*, const ::ProtocolMessage*>::value || + ImplicitlyConvertible<const T*, const ::proto2::Message*>::value> { +}; + +// When the compiler sees expression IsContainerTest<C>(0), if C is an +// STL-style container class, the first overload of IsContainerTest +// will be viable (since both C::iterator* and C::const_iterator* are +// valid types and NULL can be implicitly converted to them). It will +// be picked over the second overload as 'int' is a perfect match for +// the type of argument 0. If C::iterator or C::const_iterator is not +// a valid type, the first overload is not viable, and the second +// overload will be picked. Therefore, we can determine whether C is +// a container class by checking the type of IsContainerTest<C>(0). +// The value of the expression is insignificant. +// +// Note that we look for both C::iterator and C::const_iterator. The +// reason is that C++ injects the name of a class as a member of the +// class itself (e.g. you can refer to class iterator as either +// 'iterator' or 'iterator::iterator'). If we look for C::iterator +// only, for example, we would mistakenly think that a class named +// iterator is an STL container. +// +// Also note that the simpler approach of overloading +// IsContainerTest(typename C::const_iterator*) and +// IsContainerTest(...) doesn't work with Visual Age C++ and Sun C++. +typedef int IsContainer; +template <class C> +IsContainer IsContainerTest(int /* dummy */, + typename C::iterator* /* it */ = NULL, + typename C::const_iterator* /* const_it */ = NULL) { + return 0; +} + +typedef char IsNotContainer; +template <class C> +IsNotContainer IsContainerTest(long /* dummy */) { return '\0'; } + +// EnableIf<condition>::type is void when 'Cond' is true, and +// undefined when 'Cond' is false. To use SFINAE to make a function +// overload only apply when a particular expression is true, add +// "typename EnableIf<expression>::type* = 0" as the last parameter. +template<bool> struct EnableIf; +template<> struct EnableIf<true> { typedef void type; }; // NOLINT + +// Utilities for native arrays. + +// ArrayEq() compares two k-dimensional native arrays using the +// elements' operator==, where k can be any integer >= 0. When k is +// 0, ArrayEq() degenerates into comparing a single pair of values. + +template <typename T, typename U> +bool ArrayEq(const T* lhs, size_t size, const U* rhs); + +// This generic version is used when k is 0. +template <typename T, typename U> +inline bool ArrayEq(const T& lhs, const U& rhs) { return lhs == rhs; } + +// This overload is used when k >= 1. +template <typename T, typename U, size_t N> +inline bool ArrayEq(const T(&lhs)[N], const U(&rhs)[N]) { + return internal::ArrayEq(lhs, N, rhs); +} + +// This helper reduces code bloat. If we instead put its logic inside +// the previous ArrayEq() function, arrays with different sizes would +// lead to different copies of the template code. +template <typename T, typename U> +bool ArrayEq(const T* lhs, size_t size, const U* rhs) { + for (size_t i = 0; i != size; i++) { + if (!internal::ArrayEq(lhs[i], rhs[i])) + return false; + } + return true; +} + +// Finds the first element in the iterator range [begin, end) that +// equals elem. Element may be a native array type itself. +template <typename Iter, typename Element> +Iter ArrayAwareFind(Iter begin, Iter end, const Element& elem) { + for (Iter it = begin; it != end; ++it) { + if (internal::ArrayEq(*it, elem)) + return it; + } + return end; +} + +// CopyArray() copies a k-dimensional native array using the elements' +// operator=, where k can be any integer >= 0. When k is 0, +// CopyArray() degenerates into copying a single value. + +template <typename T, typename U> +void CopyArray(const T* from, size_t size, U* to); + +// This generic version is used when k is 0. +template <typename T, typename U> +inline void CopyArray(const T& from, U* to) { *to = from; } + +// This overload is used when k >= 1. +template <typename T, typename U, size_t N> +inline void CopyArray(const T(&from)[N], U(*to)[N]) { + internal::CopyArray(from, N, *to); +} + +// This helper reduces code bloat. If we instead put its logic inside +// the previous CopyArray() function, arrays with different sizes +// would lead to different copies of the template code. +template <typename T, typename U> +void CopyArray(const T* from, size_t size, U* to) { + for (size_t i = 0; i != size; i++) { + internal::CopyArray(from[i], to + i); + } +} + +// The relation between an NativeArray object (see below) and the +// native array it represents. +enum RelationToSource { + kReference, // The NativeArray references the native array. + kCopy // The NativeArray makes a copy of the native array and + // owns the copy. +}; + +// Adapts a native array to a read-only STL-style container. Instead +// of the complete STL container concept, this adaptor only implements +// members useful for Google Mock's container matchers. New members +// should be added as needed. To simplify the implementation, we only +// support Element being a raw type (i.e. having no top-level const or +// reference modifier). It's the client's responsibility to satisfy +// this requirement. Element can be an array type itself (hence +// multi-dimensional arrays are supported). +template <typename Element> +class NativeArray { + public: + // STL-style container typedefs. + typedef Element value_type; + typedef Element* iterator; + typedef const Element* const_iterator; + + // Constructs from a native array. + NativeArray(const Element* array, size_t count, RelationToSource relation) { + Init(array, count, relation); + } + + // Copy constructor. + NativeArray(const NativeArray& rhs) { + Init(rhs.array_, rhs.size_, rhs.relation_to_source_); + } + + ~NativeArray() { + // Ensures that the user doesn't instantiate NativeArray with a + // const or reference type. + static_cast<void>(StaticAssertTypeEqHelper<Element, + GTEST_REMOVE_REFERENCE_AND_CONST_(Element)>()); + if (relation_to_source_ == kCopy) + delete[] array_; + } + + // STL-style container methods. + size_t size() const { return size_; } + const_iterator begin() const { return array_; } + const_iterator end() const { return array_ + size_; } + bool operator==(const NativeArray& rhs) const { + return size() == rhs.size() && + ArrayEq(begin(), size(), rhs.begin()); + } + + private: + // Initializes this object; makes a copy of the input array if + // 'relation' is kCopy. + void Init(const Element* array, size_t a_size, RelationToSource relation) { + if (relation == kReference) { + array_ = array; + } else { + Element* const copy = new Element[a_size]; + CopyArray(array, a_size, copy); + array_ = copy; + } + size_ = a_size; + relation_to_source_ = relation; + } + + const Element* array_; + size_t size_; + RelationToSource relation_to_source_; + + GTEST_DISALLOW_ASSIGN_(NativeArray); +}; + +} // namespace internal +} // namespace testing + +#define GTEST_MESSAGE_AT_(file, line, message, result_type) \ + ::testing::internal::AssertHelper(result_type, file, line, message) \ + = ::testing::Message() + +#define GTEST_MESSAGE_(message, result_type) \ + GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type) + +#define GTEST_FATAL_FAILURE_(message) \ + return GTEST_MESSAGE_(message, ::testing::TestPartResult::kFatalFailure) + +#define GTEST_NONFATAL_FAILURE_(message) \ + GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure) + +#define GTEST_SUCCESS_(message) \ + GTEST_MESSAGE_(message, ::testing::TestPartResult::kSuccess) + +// Suppresses MSVC warnings 4072 (unreachable code) for the code following +// statement if it returns or throws (or doesn't return or throw in some +// situations). +#define GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) \ + if (::testing::internal::AlwaysTrue()) { statement; } + +#define GTEST_TEST_THROW_(statement, expected_exception, fail) \ + GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ + if (::testing::internal::ConstCharPtr gtest_msg = "") { \ + bool gtest_caught_expected = false; \ + try { \ + GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ + } \ + catch (expected_exception const&) { \ + gtest_caught_expected = true; \ + } \ + catch (...) { \ + gtest_msg.value = \ + "Expected: " #statement " throws an exception of type " \ + #expected_exception ".\n Actual: it throws a different type."; \ + goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \ + } \ + if (!gtest_caught_expected) { \ + gtest_msg.value = \ + "Expected: " #statement " throws an exception of type " \ + #expected_exception ".\n Actual: it throws nothing."; \ + goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \ + } \ + } else \ + GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__): \ + fail(gtest_msg.value) + +#define GTEST_TEST_NO_THROW_(statement, fail) \ + GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ + if (::testing::internal::AlwaysTrue()) { \ + try { \ + GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ + } \ + catch (...) { \ + goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \ + } \ + } else \ + GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__): \ + fail("Expected: " #statement " doesn't throw an exception.\n" \ + " Actual: it throws.") + +#define GTEST_TEST_ANY_THROW_(statement, fail) \ + GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ + if (::testing::internal::AlwaysTrue()) { \ + bool gtest_caught_any = false; \ + try { \ + GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ + } \ + catch (...) { \ + gtest_caught_any = true; \ + } \ + if (!gtest_caught_any) { \ + goto GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__); \ + } \ + } else \ + GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__): \ + fail("Expected: " #statement " throws an exception.\n" \ + " Actual: it doesn't.") + + +// Implements Boolean test assertions such as EXPECT_TRUE. expression can be +// either a boolean expression or an AssertionResult. text is a textual +// represenation of expression as it was passed into the EXPECT_TRUE. +#define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \ + GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ + if (const ::testing::AssertionResult gtest_ar_ = \ + ::testing::AssertionResult(expression)) \ + ; \ + else \ + fail(::testing::internal::GetBoolAssertionFailureMessage(\ + gtest_ar_, text, #actual, #expected).c_str()) + +#define GTEST_TEST_NO_FATAL_FAILURE_(statement, fail) \ + GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ + if (::testing::internal::AlwaysTrue()) { \ + ::testing::internal::HasNewFatalFailureHelper gtest_fatal_failure_checker; \ + GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ + if (gtest_fatal_failure_checker.has_new_fatal_failure()) { \ + goto GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__); \ + } \ + } else \ + GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__): \ + fail("Expected: " #statement " doesn't generate new fatal " \ + "failures in the current thread.\n" \ + " Actual: it does.") + +// Expands to the name of the class that implements the given test. +#define GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \ + test_case_name##_##test_name##_Test + +// Helper macro for defining tests. +#define GTEST_TEST_(test_case_name, test_name, parent_class, parent_id)\ +class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) : public parent_class {\ + public:\ + GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {}\ + private:\ + virtual void TestBody();\ + static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;\ + GTEST_DISALLOW_COPY_AND_ASSIGN_(\ + GTEST_TEST_CLASS_NAME_(test_case_name, test_name));\ +};\ +\ +::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_case_name, test_name)\ + ::test_info_ =\ + ::testing::internal::MakeAndRegisterTestInfo(\ + #test_case_name, #test_name, NULL, NULL, \ + (parent_id), \ + parent_class::SetUpTestCase, \ + parent_class::TearDownTestCase, \ + new ::testing::internal::TestFactoryImpl<\ + GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>);\ +void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody() + +#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_ diff --git a/tests/gtest/include/gtest/internal/gtest-linked_ptr.h b/tests/gtest/include/gtest/internal/gtest-linked_ptr.h new file mode 100644 index 000000000..57147b4e8 --- /dev/null +++ b/tests/gtest/include/gtest/internal/gtest-linked_ptr.h @@ -0,0 +1,233 @@ +// Copyright 2003 Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Authors: Dan Egnor (egnor@google.com) +// +// A "smart" pointer type with reference tracking. Every pointer to a +// particular object is kept on a circular linked list. When the last pointer +// to an object is destroyed or reassigned, the object is deleted. +// +// Used properly, this deletes the object when the last reference goes away. +// There are several caveats: +// - Like all reference counting schemes, cycles lead to leaks. +// - Each smart pointer is actually two pointers (8 bytes instead of 4). +// - Every time a pointer is assigned, the entire list of pointers to that +// object is traversed. This class is therefore NOT SUITABLE when there +// will often be more than two or three pointers to a particular object. +// - References are only tracked as long as linked_ptr<> objects are copied. +// If a linked_ptr<> is converted to a raw pointer and back, BAD THINGS +// will happen (double deletion). +// +// A good use of this class is storing object references in STL containers. +// You can safely put linked_ptr<> in a vector<>. +// Other uses may not be as good. +// +// Note: If you use an incomplete type with linked_ptr<>, the class +// *containing* linked_ptr<> must have a constructor and destructor (even +// if they do nothing!). +// +// Bill Gibbons suggested we use something like this. +// +// Thread Safety: +// Unlike other linked_ptr implementations, in this implementation +// a linked_ptr object is thread-safe in the sense that: +// - it's safe to copy linked_ptr objects concurrently, +// - it's safe to copy *from* a linked_ptr and read its underlying +// raw pointer (e.g. via get()) concurrently, and +// - it's safe to write to two linked_ptrs that point to the same +// shared object concurrently. +// TODO(wan@google.com): rename this to safe_linked_ptr to avoid +// confusion with normal linked_ptr. + +#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_ +#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_ + +#include <stdlib.h> +#include <assert.h> + +#include "gtest/internal/gtest-port.h" + +namespace testing { +namespace internal { + +// Protects copying of all linked_ptr objects. +GTEST_API_ GTEST_DECLARE_STATIC_MUTEX_(g_linked_ptr_mutex); + +// This is used internally by all instances of linked_ptr<>. It needs to be +// a non-template class because different types of linked_ptr<> can refer to +// the same object (linked_ptr<Superclass>(obj) vs linked_ptr<Subclass>(obj)). +// So, it needs to be possible for different types of linked_ptr to participate +// in the same circular linked list, so we need a single class type here. +// +// DO NOT USE THIS CLASS DIRECTLY YOURSELF. Use linked_ptr<T>. +class linked_ptr_internal { + public: + // Create a new circle that includes only this instance. + void join_new() { + next_ = this; + } + + // Many linked_ptr operations may change p.link_ for some linked_ptr + // variable p in the same circle as this object. Therefore we need + // to prevent two such operations from occurring concurrently. + // + // Note that different types of linked_ptr objects can coexist in a + // circle (e.g. linked_ptr<Base>, linked_ptr<Derived1>, and + // linked_ptr<Derived2>). Therefore we must use a single mutex to + // protect all linked_ptr objects. This can create serious + // contention in production code, but is acceptable in a testing + // framework. + + // Join an existing circle. + // L < g_linked_ptr_mutex + void join(linked_ptr_internal const* ptr) { + MutexLock lock(&g_linked_ptr_mutex); + + linked_ptr_internal const* p = ptr; + while (p->next_ != ptr) p = p->next_; + p->next_ = this; + next_ = ptr; + } + + // Leave whatever circle we're part of. Returns true if we were the + // last member of the circle. Once this is done, you can join() another. + // L < g_linked_ptr_mutex + bool depart() { + MutexLock lock(&g_linked_ptr_mutex); + + if (next_ == this) return true; + linked_ptr_internal const* p = next_; + while (p->next_ != this) p = p->next_; + p->next_ = next_; + return false; + } + + private: + mutable linked_ptr_internal const* next_; +}; + +template <typename T> +class linked_ptr { + public: + typedef T element_type; + + // Take over ownership of a raw pointer. This should happen as soon as + // possible after the object is created. + explicit linked_ptr(T* ptr = NULL) { capture(ptr); } + ~linked_ptr() { depart(); } + + // Copy an existing linked_ptr<>, adding ourselves to the list of references. + template <typename U> linked_ptr(linked_ptr<U> const& ptr) { copy(&ptr); } + linked_ptr(linked_ptr const& ptr) { // NOLINT + assert(&ptr != this); + copy(&ptr); + } + + // Assignment releases the old value and acquires the new. + template <typename U> linked_ptr& operator=(linked_ptr<U> const& ptr) { + depart(); + copy(&ptr); + return *this; + } + + linked_ptr& operator=(linked_ptr const& ptr) { + if (&ptr != this) { + depart(); + copy(&ptr); + } + return *this; + } + + // Smart pointer members. + void reset(T* ptr = NULL) { + depart(); + capture(ptr); + } + T* get() const { return value_; } + T* operator->() const { return value_; } + T& operator*() const { return *value_; } + + bool operator==(T* p) const { return value_ == p; } + bool operator!=(T* p) const { return value_ != p; } + template <typename U> + bool operator==(linked_ptr<U> const& ptr) const { + return value_ == ptr.get(); + } + template <typename U> + bool operator!=(linked_ptr<U> const& ptr) const { + return value_ != ptr.get(); + } + + private: + template <typename U> + friend class linked_ptr; + + T* value_; + linked_ptr_internal link_; + + void depart() { + if (link_.depart()) delete value_; + } + + void capture(T* ptr) { + value_ = ptr; + link_.join_new(); + } + + template <typename U> void copy(linked_ptr<U> const* ptr) { + value_ = ptr->get(); + if (value_) + link_.join(&ptr->link_); + else + link_.join_new(); + } +}; + +template<typename T> inline +bool operator==(T* ptr, const linked_ptr<T>& x) { + return ptr == x.get(); +} + +template<typename T> inline +bool operator!=(T* ptr, const linked_ptr<T>& x) { + return ptr != x.get(); +} + +// A function to convert T* into linked_ptr<T> +// Doing e.g. make_linked_ptr(new FooBarBaz<type>(arg)) is a shorter notation +// for linked_ptr<FooBarBaz<type> >(new FooBarBaz<type>(arg)) +template <typename T> +linked_ptr<T> make_linked_ptr(T* ptr) { + return linked_ptr<T>(ptr); +} + +} // namespace internal +} // namespace testing + +#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_ diff --git a/tests/gtest/include/gtest/internal/gtest-param-util-generated.h b/tests/gtest/include/gtest/internal/gtest-param-util-generated.h new file mode 100644 index 000000000..258267500 --- /dev/null +++ b/tests/gtest/include/gtest/internal/gtest-param-util-generated.h @@ -0,0 +1,4822 @@ +// This file was GENERATED by command: +// pump.py gtest-param-util-generated.h.pump +// DO NOT EDIT BY HAND!!! + +// Copyright 2008 Google Inc. +// All Rights Reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Author: vladl@google.com (Vlad Losev) + +// Type and function utilities for implementing parameterized tests. +// This file is generated by a SCRIPT. DO NOT EDIT BY HAND! +// +// Currently Google Test supports at most 50 arguments in Values, +// and at most 10 arguments in Combine. Please contact +// googletestframework@googlegroups.com if you need more. +// Please note that the number of arguments to Combine is limited +// by the maximum arity of the implementation of tr1::tuple which is +// currently set at 10. + +#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_ +#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_ + +// scripts/fuse_gtest.py depends on gtest's own header being #included +// *unconditionally*. Therefore these #includes cannot be moved +// inside #if GTEST_HAS_PARAM_TEST. +#include "gtest/internal/gtest-param-util.h" +#include "gtest/internal/gtest-port.h" + +#if GTEST_HAS_PARAM_TEST + +namespace testing { + +// Forward declarations of ValuesIn(), which is implemented in +// include/gtest/gtest-param-test.h. +template <typename ForwardIterator> +internal::ParamGenerator< + typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type> +ValuesIn(ForwardIterator begin, ForwardIterator end); + +template <typename T, size_t N> +internal::ParamGenerator<T> ValuesIn(const T (&array)[N]); + +template <class Container> +internal::ParamGenerator<typename Container::value_type> ValuesIn( + const Container& container); + +namespace internal { + +// Used in the Values() function to provide polymorphic capabilities. +template <typename T1> +class ValueArray1 { + public: + explicit ValueArray1(T1 v1) : v1_(v1) {} + + template <typename T> + operator ParamGenerator<T>() const { return ValuesIn(&v1_, &v1_ + 1); } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray1& other); + + const T1 v1_; +}; + +template <typename T1, typename T2> +class ValueArray2 { + public: + ValueArray2(T1 v1, T2 v2) : v1_(v1), v2_(v2) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray2& other); + + const T1 v1_; + const T2 v2_; +}; + +template <typename T1, typename T2, typename T3> +class ValueArray3 { + public: + ValueArray3(T1 v1, T2 v2, T3 v3) : v1_(v1), v2_(v2), v3_(v3) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray3& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; +}; + +template <typename T1, typename T2, typename T3, typename T4> +class ValueArray4 { + public: + ValueArray4(T1 v1, T2 v2, T3 v3, T4 v4) : v1_(v1), v2_(v2), v3_(v3), + v4_(v4) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray4& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5> +class ValueArray5 { + public: + ValueArray5(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) : v1_(v1), v2_(v2), v3_(v3), + v4_(v4), v5_(v5) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray5& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6> +class ValueArray6 { + public: + ValueArray6(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6) : v1_(v1), v2_(v2), + v3_(v3), v4_(v4), v5_(v5), v6_(v6) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray6& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7> +class ValueArray7 { + public: + ValueArray7(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7) : v1_(v1), + v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray7& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8> +class ValueArray8 { + public: + ValueArray8(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, + T8 v8) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), + v8_(v8) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray8& other); + + const T1 v1_; + const T2 v2_; + const T3 v3_; + const T4 v4_; + const T5 v5_; + const T6 v6_; + const T7 v7_; + const T8 v8_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9> +class ValueArray9 { + public: + ValueArray9(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, + T9 v9) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), + v8_(v8), v9_(v9) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray9& other); + + 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_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10> +class ValueArray10 { + public: + ValueArray10(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), + v8_(v8), v9_(v9), v10_(v10) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray10& other); + + 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_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11> +class ValueArray11 { + public: + ValueArray11(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), + v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray11& other); + + 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_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12> +class ValueArray12 { + public: + ValueArray12(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), + v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray12& other); + + 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_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13> +class ValueArray13 { + public: + ValueArray13(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), + v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), + v12_(v12), v13_(v13) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray13& other); + + 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_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14> +class ValueArray14 { + public: + ValueArray14(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14) : v1_(v1), v2_(v2), v3_(v3), + v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), + v11_(v11), v12_(v12), v13_(v13), v14_(v14) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray14& other); + + 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_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15> +class ValueArray15 { + public: + ValueArray15(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15) : v1_(v1), v2_(v2), + v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), + v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray15& other); + + 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_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16> +class ValueArray16 { + public: + ValueArray16(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16) : v1_(v1), + v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), + v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), + v16_(v16) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray16& other); + + 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_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17> +class ValueArray17 { + public: + ValueArray17(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, + T17 v17) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), + v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), + v15_(v15), v16_(v16), v17_(v17) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray17& other); + + 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_; + const T17 v17_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18> +class ValueArray18 { + public: + ValueArray18(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), + v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), + v15_(v15), v16_(v16), v17_(v17), v18_(v18) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray18& other); + + 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_; + const T17 v17_; + const T18 v18_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19> +class ValueArray19 { + public: + ValueArray19(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), + v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), + v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray19& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20> +class ValueArray20 { + public: + ValueArray20(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), + v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), + v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), + v19_(v19), v20_(v20) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray20& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21> +class ValueArray21 { + public: + ValueArray21(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), + v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), + v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), + v18_(v18), v19_(v19), v20_(v20), v21_(v21) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray21& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22> +class ValueArray22 { + public: + ValueArray22(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22) : v1_(v1), v2_(v2), v3_(v3), + v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), + v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), + v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray22& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23> +class ValueArray23 { + public: + ValueArray23(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23) : v1_(v1), v2_(v2), + v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), + v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), + v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), + v23_(v23) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, + v23_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray23& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24> +class ValueArray24 { + public: + ValueArray24(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24) : v1_(v1), + v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), + v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), + v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), + v22_(v22), v23_(v23), v24_(v24) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_, + v24_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray24& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25> +class ValueArray25 { + public: + ValueArray25(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, + T25 v25) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), + v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), + v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), + v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_, + v24_, v25_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray25& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26> +class ValueArray26 { + public: + ValueArray26(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), + v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), + v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), + v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_, + v24_, v25_, v26_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray26& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27> +class ValueArray27 { + public: + ValueArray27(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), + v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), + v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), + v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), + v26_(v26), v27_(v27) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_, + v24_, v25_, v26_, v27_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray27& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28> +class ValueArray28 { + public: + ValueArray28(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), + v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), + v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), + v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), + v25_(v25), v26_(v26), v27_(v27), v28_(v28) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_, + v24_, v25_, v26_, v27_, v28_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray28& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29> +class ValueArray29 { + public: + ValueArray29(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), + v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), + v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), + v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), + v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_, + v24_, v25_, v26_, v27_, v28_, v29_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray29& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30> +class ValueArray30 { + public: + ValueArray30(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30) : v1_(v1), v2_(v2), v3_(v3), + v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), + v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), + v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), + v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), + v29_(v29), v30_(v30) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_, + v24_, v25_, v26_, v27_, v28_, v29_, v30_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray30& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31> +class ValueArray31 { + public: + ValueArray31(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31) : v1_(v1), v2_(v2), + v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), + v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), + v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), + v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), + v29_(v29), v30_(v30), v31_(v31) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_, + v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray31& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32> +class ValueArray32 { + public: + ValueArray32(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32) : v1_(v1), + v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), + v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), + v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), + v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), + v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_, + v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray32& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33> +class ValueArray33 { + public: + ValueArray33(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, + T33 v33) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), + v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), + v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), + v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), + v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), + v33_(v33) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_, + v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray33& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34> +class ValueArray34 { + public: + ValueArray34(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), + v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), + v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), + v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), + v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), + v33_(v33), v34_(v34) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_, + v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray34& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35> +class ValueArray35 { + public: + ValueArray35(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), + v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), + v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), + v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), + v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), + v32_(v32), v33_(v33), v34_(v34), v35_(v35) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_, + v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, + v35_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray35& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36> +class ValueArray36 { + public: + ValueArray36(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), + v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), + v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), + v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), + v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), + v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_, + v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_, + v36_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray36& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; + const T36 v36_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37> +class ValueArray37 { + public: + ValueArray37(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), + v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), + v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), + v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), + v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), + v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), + v36_(v36), v37_(v37) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_, + v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_, + v36_, v37_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray37& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; + const T36 v36_; + const T37 v37_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38> +class ValueArray38 { + public: + ValueArray38(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38) : v1_(v1), v2_(v2), v3_(v3), + v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), + v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), + v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), + v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), + v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), + v35_(v35), v36_(v36), v37_(v37), v38_(v38) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_, + v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_, + v36_, v37_, v38_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray38& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; + const T36 v36_; + const T37 v37_; + const T38 v38_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39> +class ValueArray39 { + public: + ValueArray39(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39) : v1_(v1), v2_(v2), + v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), + v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), + v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), + v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), + v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), + v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_, + v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_, + v36_, v37_, v38_, v39_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray39& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; + const T36 v36_; + const T37 v37_; + const T38 v38_; + const T39 v39_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40> +class ValueArray40 { + public: + ValueArray40(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40) : v1_(v1), + v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), + v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), + v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), + v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), + v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), + v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), + v40_(v40) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_, + v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_, + v36_, v37_, v38_, v39_, v40_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray40& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; + const T36 v36_; + const T37 v37_; + const T38 v38_; + const T39 v39_; + const T40 v40_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41> +class ValueArray41 { + public: + ValueArray41(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, + T41 v41) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), + v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), + v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), + v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), + v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), + v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), + v39_(v39), v40_(v40), v41_(v41) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_, + v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_, + v36_, v37_, v38_, v39_, v40_, v41_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray41& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; + const T36 v36_; + const T37 v37_; + const T38 v38_; + const T39 v39_; + const T40 v40_; + const T41 v41_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42> +class ValueArray42 { + public: + ValueArray42(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, + T42 v42) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), + v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), + v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), + v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), + v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), + v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), + v39_(v39), v40_(v40), v41_(v41), v42_(v42) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_, + v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_, + v36_, v37_, v38_, v39_, v40_, v41_, v42_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray42& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; + const T36 v36_; + const T37 v37_; + const T38 v38_; + const T39 v39_; + const T40 v40_; + const T41 v41_; + const T42 v42_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43> +class ValueArray43 { + public: + ValueArray43(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, + T42 v42, T43 v43) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), + v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), + v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), + v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), + v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), + v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), + v38_(v38), v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_, + v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_, + v36_, v37_, v38_, v39_, v40_, v41_, v42_, v43_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray43& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; + const T36 v36_; + const T37 v37_; + const T38 v38_; + const T39 v39_; + const T40 v40_; + const T41 v41_; + const T42 v42_; + const T43 v43_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43, typename T44> +class ValueArray44 { + public: + ValueArray44(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, + T42 v42, T43 v43, T44 v44) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), + v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), + v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), + v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), + v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), + v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36), + v37_(v37), v38_(v38), v39_(v39), v40_(v40), v41_(v41), v42_(v42), + v43_(v43), v44_(v44) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_, + v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_, + v36_, v37_, v38_, v39_, v40_, v41_, v42_, v43_, v44_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray44& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; + const T36 v36_; + const T37 v37_; + const T38 v38_; + const T39 v39_; + const T40 v40_; + const T41 v41_; + const T42 v42_; + const T43 v43_; + const T44 v44_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43, typename T44, typename T45> +class ValueArray45 { + public: + ValueArray45(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, + T42 v42, T43 v43, T44 v44, T45 v45) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), + v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), + v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), + v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), + v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), + v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), + v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40), v41_(v41), + v42_(v42), v43_(v43), v44_(v44), v45_(v45) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_, + v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_, + v36_, v37_, v38_, v39_, v40_, v41_, v42_, v43_, v44_, v45_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray45& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; + const T36 v36_; + const T37 v37_; + const T38 v38_; + const T39 v39_; + const T40 v40_; + const T41 v41_; + const T42 v42_; + const T43 v43_; + const T44 v44_; + const T45 v45_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43, typename T44, typename T45, + typename T46> +class ValueArray46 { + public: + ValueArray46(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, + T42 v42, T43 v43, T44 v44, T45 v45, T46 v46) : v1_(v1), v2_(v2), v3_(v3), + v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), + v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), + v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), + v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), + v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), + v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40), + v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45), v46_(v46) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_, + v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_, + v36_, v37_, v38_, v39_, v40_, v41_, v42_, v43_, v44_, v45_, v46_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray46& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; + const T36 v36_; + const T37 v37_; + const T38 v38_; + const T39 v39_; + const T40 v40_; + const T41 v41_; + const T42 v42_; + const T43 v43_; + const T44 v44_; + const T45 v45_; + const T46 v46_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43, typename T44, typename T45, + typename T46, typename T47> +class ValueArray47 { + public: + ValueArray47(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, + T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47) : v1_(v1), v2_(v2), + v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), + v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), + v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), + v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), + v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), + v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40), + v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45), v46_(v46), + v47_(v47) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_, + v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_, + v36_, v37_, v38_, v39_, v40_, v41_, v42_, v43_, v44_, v45_, v46_, + v47_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray47& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; + const T36 v36_; + const T37 v37_; + const T38 v38_; + const T39 v39_; + const T40 v40_; + const T41 v41_; + const T42 v42_; + const T43 v43_; + const T44 v44_; + const T45 v45_; + const T46 v46_; + const T47 v47_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43, typename T44, typename T45, + typename T46, typename T47, typename T48> +class ValueArray48 { + public: + ValueArray48(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, + T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48) : v1_(v1), + v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), + v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), + v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), + v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), + v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), + v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), + v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45), + v46_(v46), v47_(v47), v48_(v48) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_, + v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_, + v36_, v37_, v38_, v39_, v40_, v41_, v42_, v43_, v44_, v45_, v46_, v47_, + v48_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray48& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; + const T36 v36_; + const T37 v37_; + const T38 v38_; + const T39 v39_; + const T40 v40_; + const T41 v41_; + const T42 v42_; + const T43 v43_; + const T44 v44_; + const T45 v45_; + const T46 v46_; + const T47 v47_; + const T48 v48_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43, typename T44, typename T45, + typename T46, typename T47, typename T48, typename T49> +class ValueArray49 { + public: + ValueArray49(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, + T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48, + T49 v49) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), + v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), + v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), + v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), + v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), + v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), + v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44), + v45_(v45), v46_(v46), v47_(v47), v48_(v48), v49_(v49) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_, + v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_, + v36_, v37_, v38_, v39_, v40_, v41_, v42_, v43_, v44_, v45_, v46_, v47_, + v48_, v49_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray49& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; + const T36 v36_; + const T37 v37_; + const T38 v38_; + const T39 v39_; + const T40 v40_; + const T41 v41_; + const T42 v42_; + const T43 v43_; + const T44 v44_; + const T45 v45_; + const T46 v46_; + const T47 v47_; + const T48 v48_; + const T49 v49_; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43, typename T44, typename T45, + typename T46, typename T47, typename T48, typename T49, typename T50> +class ValueArray50 { + public: + ValueArray50(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, + T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, + T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, + T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, + T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, + T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48, T49 v49, + T50 v50) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), + v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), + v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), + v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), + v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), + v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), + v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44), + v45_(v45), v46_(v46), v47_(v47), v48_(v48), v49_(v49), v50_(v50) {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {v1_, v2_, v3_, v4_, v5_, v6_, v7_, v8_, v9_, v10_, v11_, + v12_, v13_, v14_, v15_, v16_, v17_, v18_, v19_, v20_, v21_, v22_, v23_, + v24_, v25_, v26_, v27_, v28_, v29_, v30_, v31_, v32_, v33_, v34_, v35_, + v36_, v37_, v38_, v39_, v40_, v41_, v42_, v43_, v44_, v45_, v46_, v47_, + v48_, v49_, v50_}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray50& other); + + 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_; + const T17 v17_; + const T18 v18_; + const T19 v19_; + const T20 v20_; + const T21 v21_; + const T22 v22_; + const T23 v23_; + const T24 v24_; + const T25 v25_; + const T26 v26_; + const T27 v27_; + const T28 v28_; + const T29 v29_; + const T30 v30_; + const T31 v31_; + const T32 v32_; + const T33 v33_; + const T34 v34_; + const T35 v35_; + const T36 v36_; + const T37 v37_; + const T38 v38_; + const T39 v39_; + const T40 v40_; + const T41 v41_; + const T42 v42_; + const T43 v43_; + const T44 v44_; + const T45 v45_; + const T46 v46_; + const T47 v47_; + const T48 v48_; + const T49 v49_; + const T50 v50_; +}; + +# if GTEST_HAS_COMBINE +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// +// Generates values from the Cartesian product of values produced +// by the argument generators. +// +template <typename T1, typename T2> +class CartesianProductGenerator2 + : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2> > { + public: + typedef ::std::tr1::tuple<T1, T2> ParamType; + + CartesianProductGenerator2(const ParamGenerator<T1>& g1, + const ParamGenerator<T2>& g2) + : g1_(g1), g2_(g2) {} + virtual ~CartesianProductGenerator2() {} + + virtual ParamIteratorInterface<ParamType>* Begin() const { + return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin()); + } + virtual ParamIteratorInterface<ParamType>* End() const { + return new Iterator(this, g1_, g1_.end(), g2_, g2_.end()); + } + + private: + class Iterator : public ParamIteratorInterface<ParamType> { + public: + Iterator(const ParamGeneratorInterface<ParamType>* base, + const ParamGenerator<T1>& g1, + const typename ParamGenerator<T1>::iterator& current1, + const ParamGenerator<T2>& g2, + const typename ParamGenerator<T2>::iterator& current2) + : base_(base), + begin1_(g1.begin()), end1_(g1.end()), current1_(current1), + begin2_(g2.begin()), end2_(g2.end()), current2_(current2) { + ComputeCurrentValue(); + } + virtual ~Iterator() {} + + virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const { + return base_; + } + // Advance should not be called on beyond-of-range iterators + // so no component iterators must be beyond end of range, either. + virtual void Advance() { + assert(!AtEnd()); + ++current2_; + if (current2_ == end2_) { + current2_ = begin2_; + ++current1_; + } + ComputeCurrentValue(); + } + virtual ParamIteratorInterface<ParamType>* Clone() const { + return new Iterator(*this); + } + virtual const ParamType* Current() const { return ¤t_value_; } + virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const { + // Having the same base generator guarantees that the other + // iterator is of the same type and we can downcast. + GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) + << "The program attempted to compare iterators " + << "from different generators." << std::endl; + const Iterator* typed_other = + CheckedDowncastToActualType<const Iterator>(&other); + // We must report iterators equal if they both point beyond their + // respective ranges. That can happen in a variety of fashions, + // so we have to consult AtEnd(). + return (AtEnd() && typed_other->AtEnd()) || + ( + current1_ == typed_other->current1_ && + current2_ == typed_other->current2_); + } + + private: + Iterator(const Iterator& other) + : base_(other.base_), + begin1_(other.begin1_), + end1_(other.end1_), + current1_(other.current1_), + begin2_(other.begin2_), + end2_(other.end2_), + current2_(other.current2_) { + ComputeCurrentValue(); + } + + void ComputeCurrentValue() { + if (!AtEnd()) + current_value_ = ParamType(*current1_, *current2_); + } + bool AtEnd() const { + // We must report iterator past the end of the range when either of the + // component iterators has reached the end of its range. + return + current1_ == end1_ || + current2_ == end2_; + } + + // No implementation - assignment is unsupported. + void operator=(const Iterator& other); + + const ParamGeneratorInterface<ParamType>* const base_; + // begin[i]_ and end[i]_ define the i-th range that Iterator traverses. + // current[i]_ is the actual traversing iterator. + const typename ParamGenerator<T1>::iterator begin1_; + const typename ParamGenerator<T1>::iterator end1_; + typename ParamGenerator<T1>::iterator current1_; + const typename ParamGenerator<T2>::iterator begin2_; + const typename ParamGenerator<T2>::iterator end2_; + typename ParamGenerator<T2>::iterator current2_; + ParamType current_value_; + }; // class CartesianProductGenerator2::Iterator + + // No implementation - assignment is unsupported. + void operator=(const CartesianProductGenerator2& other); + + const ParamGenerator<T1> g1_; + const ParamGenerator<T2> g2_; +}; // class CartesianProductGenerator2 + + +template <typename T1, typename T2, typename T3> +class CartesianProductGenerator3 + : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3> > { + public: + typedef ::std::tr1::tuple<T1, T2, T3> ParamType; + + CartesianProductGenerator3(const ParamGenerator<T1>& g1, + const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3) + : g1_(g1), g2_(g2), g3_(g3) {} + virtual ~CartesianProductGenerator3() {} + + virtual ParamIteratorInterface<ParamType>* Begin() const { + return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_, + g3_.begin()); + } + virtual ParamIteratorInterface<ParamType>* End() const { + return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end()); + } + + private: + class Iterator : public ParamIteratorInterface<ParamType> { + public: + Iterator(const ParamGeneratorInterface<ParamType>* base, + const ParamGenerator<T1>& g1, + const typename ParamGenerator<T1>::iterator& current1, + const ParamGenerator<T2>& g2, + const typename ParamGenerator<T2>::iterator& current2, + const ParamGenerator<T3>& g3, + const typename ParamGenerator<T3>::iterator& current3) + : base_(base), + begin1_(g1.begin()), end1_(g1.end()), current1_(current1), + begin2_(g2.begin()), end2_(g2.end()), current2_(current2), + begin3_(g3.begin()), end3_(g3.end()), current3_(current3) { + ComputeCurrentValue(); + } + virtual ~Iterator() {} + + virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const { + return base_; + } + // Advance should not be called on beyond-of-range iterators + // so no component iterators must be beyond end of range, either. + virtual void Advance() { + assert(!AtEnd()); + ++current3_; + if (current3_ == end3_) { + current3_ = begin3_; + ++current2_; + } + if (current2_ == end2_) { + current2_ = begin2_; + ++current1_; + } + ComputeCurrentValue(); + } + virtual ParamIteratorInterface<ParamType>* Clone() const { + return new Iterator(*this); + } + virtual const ParamType* Current() const { return ¤t_value_; } + virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const { + // Having the same base generator guarantees that the other + // iterator is of the same type and we can downcast. + GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) + << "The program attempted to compare iterators " + << "from different generators." << std::endl; + const Iterator* typed_other = + CheckedDowncastToActualType<const Iterator>(&other); + // We must report iterators equal if they both point beyond their + // respective ranges. That can happen in a variety of fashions, + // so we have to consult AtEnd(). + return (AtEnd() && typed_other->AtEnd()) || + ( + current1_ == typed_other->current1_ && + current2_ == typed_other->current2_ && + current3_ == typed_other->current3_); + } + + private: + Iterator(const Iterator& other) + : base_(other.base_), + begin1_(other.begin1_), + end1_(other.end1_), + current1_(other.current1_), + begin2_(other.begin2_), + end2_(other.end2_), + current2_(other.current2_), + begin3_(other.begin3_), + end3_(other.end3_), + current3_(other.current3_) { + ComputeCurrentValue(); + } + + void ComputeCurrentValue() { + if (!AtEnd()) + current_value_ = ParamType(*current1_, *current2_, *current3_); + } + bool AtEnd() const { + // We must report iterator past the end of the range when either of the + // component iterators has reached the end of its range. + return + current1_ == end1_ || + current2_ == end2_ || + current3_ == end3_; + } + + // No implementation - assignment is unsupported. + void operator=(const Iterator& other); + + const ParamGeneratorInterface<ParamType>* const base_; + // begin[i]_ and end[i]_ define the i-th range that Iterator traverses. + // current[i]_ is the actual traversing iterator. + const typename ParamGenerator<T1>::iterator begin1_; + const typename ParamGenerator<T1>::iterator end1_; + typename ParamGenerator<T1>::iterator current1_; + const typename ParamGenerator<T2>::iterator begin2_; + const typename ParamGenerator<T2>::iterator end2_; + typename ParamGenerator<T2>::iterator current2_; + const typename ParamGenerator<T3>::iterator begin3_; + const typename ParamGenerator<T3>::iterator end3_; + typename ParamGenerator<T3>::iterator current3_; + ParamType current_value_; + }; // class CartesianProductGenerator3::Iterator + + // No implementation - assignment is unsupported. + void operator=(const CartesianProductGenerator3& other); + + const ParamGenerator<T1> g1_; + const ParamGenerator<T2> g2_; + const ParamGenerator<T3> g3_; +}; // class CartesianProductGenerator3 + + +template <typename T1, typename T2, typename T3, typename T4> +class CartesianProductGenerator4 + : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4> > { + public: + typedef ::std::tr1::tuple<T1, T2, T3, T4> ParamType; + + CartesianProductGenerator4(const ParamGenerator<T1>& g1, + const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3, + const ParamGenerator<T4>& g4) + : g1_(g1), g2_(g2), g3_(g3), g4_(g4) {} + virtual ~CartesianProductGenerator4() {} + + virtual ParamIteratorInterface<ParamType>* Begin() const { + return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_, + g3_.begin(), g4_, g4_.begin()); + } + virtual ParamIteratorInterface<ParamType>* End() const { + return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(), + g4_, g4_.end()); + } + + private: + class Iterator : public ParamIteratorInterface<ParamType> { + public: + Iterator(const ParamGeneratorInterface<ParamType>* base, + const ParamGenerator<T1>& g1, + const typename ParamGenerator<T1>::iterator& current1, + const ParamGenerator<T2>& g2, + const typename ParamGenerator<T2>::iterator& current2, + const ParamGenerator<T3>& g3, + const typename ParamGenerator<T3>::iterator& current3, + const ParamGenerator<T4>& g4, + const typename ParamGenerator<T4>::iterator& current4) + : base_(base), + begin1_(g1.begin()), end1_(g1.end()), current1_(current1), + begin2_(g2.begin()), end2_(g2.end()), current2_(current2), + begin3_(g3.begin()), end3_(g3.end()), current3_(current3), + begin4_(g4.begin()), end4_(g4.end()), current4_(current4) { + ComputeCurrentValue(); + } + virtual ~Iterator() {} + + virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const { + return base_; + } + // Advance should not be called on beyond-of-range iterators + // so no component iterators must be beyond end of range, either. + virtual void Advance() { + assert(!AtEnd()); + ++current4_; + if (current4_ == end4_) { + current4_ = begin4_; + ++current3_; + } + if (current3_ == end3_) { + current3_ = begin3_; + ++current2_; + } + if (current2_ == end2_) { + current2_ = begin2_; + ++current1_; + } + ComputeCurrentValue(); + } + virtual ParamIteratorInterface<ParamType>* Clone() const { + return new Iterator(*this); + } + virtual const ParamType* Current() const { return ¤t_value_; } + virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const { + // Having the same base generator guarantees that the other + // iterator is of the same type and we can downcast. + GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) + << "The program attempted to compare iterators " + << "from different generators." << std::endl; + const Iterator* typed_other = + CheckedDowncastToActualType<const Iterator>(&other); + // We must report iterators equal if they both point beyond their + // respective ranges. That can happen in a variety of fashions, + // so we have to consult AtEnd(). + return (AtEnd() && typed_other->AtEnd()) || + ( + current1_ == typed_other->current1_ && + current2_ == typed_other->current2_ && + current3_ == typed_other->current3_ && + current4_ == typed_other->current4_); + } + + private: + Iterator(const Iterator& other) + : base_(other.base_), + begin1_(other.begin1_), + end1_(other.end1_), + current1_(other.current1_), + begin2_(other.begin2_), + end2_(other.end2_), + current2_(other.current2_), + begin3_(other.begin3_), + end3_(other.end3_), + current3_(other.current3_), + begin4_(other.begin4_), + end4_(other.end4_), + current4_(other.current4_) { + ComputeCurrentValue(); + } + + void ComputeCurrentValue() { + if (!AtEnd()) + current_value_ = ParamType(*current1_, *current2_, *current3_, + *current4_); + } + bool AtEnd() const { + // We must report iterator past the end of the range when either of the + // component iterators has reached the end of its range. + return + current1_ == end1_ || + current2_ == end2_ || + current3_ == end3_ || + current4_ == end4_; + } + + // No implementation - assignment is unsupported. + void operator=(const Iterator& other); + + const ParamGeneratorInterface<ParamType>* const base_; + // begin[i]_ and end[i]_ define the i-th range that Iterator traverses. + // current[i]_ is the actual traversing iterator. + const typename ParamGenerator<T1>::iterator begin1_; + const typename ParamGenerator<T1>::iterator end1_; + typename ParamGenerator<T1>::iterator current1_; + const typename ParamGenerator<T2>::iterator begin2_; + const typename ParamGenerator<T2>::iterator end2_; + typename ParamGenerator<T2>::iterator current2_; + const typename ParamGenerator<T3>::iterator begin3_; + const typename ParamGenerator<T3>::iterator end3_; + typename ParamGenerator<T3>::iterator current3_; + const typename ParamGenerator<T4>::iterator begin4_; + const typename ParamGenerator<T4>::iterator end4_; + typename ParamGenerator<T4>::iterator current4_; + ParamType current_value_; + }; // class CartesianProductGenerator4::Iterator + + // No implementation - assignment is unsupported. + void operator=(const CartesianProductGenerator4& other); + + const ParamGenerator<T1> g1_; + const ParamGenerator<T2> g2_; + const ParamGenerator<T3> g3_; + const ParamGenerator<T4> g4_; +}; // class CartesianProductGenerator4 + + +template <typename T1, typename T2, typename T3, typename T4, typename T5> +class CartesianProductGenerator5 + : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5> > { + public: + typedef ::std::tr1::tuple<T1, T2, T3, T4, T5> ParamType; + + CartesianProductGenerator5(const ParamGenerator<T1>& g1, + const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3, + const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5) + : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5) {} + virtual ~CartesianProductGenerator5() {} + + virtual ParamIteratorInterface<ParamType>* Begin() const { + return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_, + g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin()); + } + virtual ParamIteratorInterface<ParamType>* End() const { + return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(), + g4_, g4_.end(), g5_, g5_.end()); + } + + private: + class Iterator : public ParamIteratorInterface<ParamType> { + public: + Iterator(const ParamGeneratorInterface<ParamType>* base, + const ParamGenerator<T1>& g1, + const typename ParamGenerator<T1>::iterator& current1, + const ParamGenerator<T2>& g2, + const typename ParamGenerator<T2>::iterator& current2, + const ParamGenerator<T3>& g3, + const typename ParamGenerator<T3>::iterator& current3, + const ParamGenerator<T4>& g4, + const typename ParamGenerator<T4>::iterator& current4, + const ParamGenerator<T5>& g5, + const typename ParamGenerator<T5>::iterator& current5) + : base_(base), + begin1_(g1.begin()), end1_(g1.end()), current1_(current1), + begin2_(g2.begin()), end2_(g2.end()), current2_(current2), + begin3_(g3.begin()), end3_(g3.end()), current3_(current3), + begin4_(g4.begin()), end4_(g4.end()), current4_(current4), + begin5_(g5.begin()), end5_(g5.end()), current5_(current5) { + ComputeCurrentValue(); + } + virtual ~Iterator() {} + + virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const { + return base_; + } + // Advance should not be called on beyond-of-range iterators + // so no component iterators must be beyond end of range, either. + virtual void Advance() { + assert(!AtEnd()); + ++current5_; + if (current5_ == end5_) { + current5_ = begin5_; + ++current4_; + } + if (current4_ == end4_) { + current4_ = begin4_; + ++current3_; + } + if (current3_ == end3_) { + current3_ = begin3_; + ++current2_; + } + if (current2_ == end2_) { + current2_ = begin2_; + ++current1_; + } + ComputeCurrentValue(); + } + virtual ParamIteratorInterface<ParamType>* Clone() const { + return new Iterator(*this); + } + virtual const ParamType* Current() const { return ¤t_value_; } + virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const { + // Having the same base generator guarantees that the other + // iterator is of the same type and we can downcast. + GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) + << "The program attempted to compare iterators " + << "from different generators." << std::endl; + const Iterator* typed_other = + CheckedDowncastToActualType<const Iterator>(&other); + // We must report iterators equal if they both point beyond their + // respective ranges. That can happen in a variety of fashions, + // so we have to consult AtEnd(). + return (AtEnd() && typed_other->AtEnd()) || + ( + current1_ == typed_other->current1_ && + current2_ == typed_other->current2_ && + current3_ == typed_other->current3_ && + current4_ == typed_other->current4_ && + current5_ == typed_other->current5_); + } + + private: + Iterator(const Iterator& other) + : base_(other.base_), + begin1_(other.begin1_), + end1_(other.end1_), + current1_(other.current1_), + begin2_(other.begin2_), + end2_(other.end2_), + current2_(other.current2_), + begin3_(other.begin3_), + end3_(other.end3_), + current3_(other.current3_), + begin4_(other.begin4_), + end4_(other.end4_), + current4_(other.current4_), + begin5_(other.begin5_), + end5_(other.end5_), + current5_(other.current5_) { + ComputeCurrentValue(); + } + + void ComputeCurrentValue() { + if (!AtEnd()) + current_value_ = ParamType(*current1_, *current2_, *current3_, + *current4_, *current5_); + } + bool AtEnd() const { + // We must report iterator past the end of the range when either of the + // component iterators has reached the end of its range. + return + current1_ == end1_ || + current2_ == end2_ || + current3_ == end3_ || + current4_ == end4_ || + current5_ == end5_; + } + + // No implementation - assignment is unsupported. + void operator=(const Iterator& other); + + const ParamGeneratorInterface<ParamType>* const base_; + // begin[i]_ and end[i]_ define the i-th range that Iterator traverses. + // current[i]_ is the actual traversing iterator. + const typename ParamGenerator<T1>::iterator begin1_; + const typename ParamGenerator<T1>::iterator end1_; + typename ParamGenerator<T1>::iterator current1_; + const typename ParamGenerator<T2>::iterator begin2_; + const typename ParamGenerator<T2>::iterator end2_; + typename ParamGenerator<T2>::iterator current2_; + const typename ParamGenerator<T3>::iterator begin3_; + const typename ParamGenerator<T3>::iterator end3_; + typename ParamGenerator<T3>::iterator current3_; + const typename ParamGenerator<T4>::iterator begin4_; + const typename ParamGenerator<T4>::iterator end4_; + typename ParamGenerator<T4>::iterator current4_; + const typename ParamGenerator<T5>::iterator begin5_; + const typename ParamGenerator<T5>::iterator end5_; + typename ParamGenerator<T5>::iterator current5_; + ParamType current_value_; + }; // class CartesianProductGenerator5::Iterator + + // No implementation - assignment is unsupported. + void operator=(const CartesianProductGenerator5& other); + + const ParamGenerator<T1> g1_; + const ParamGenerator<T2> g2_; + const ParamGenerator<T3> g3_; + const ParamGenerator<T4> g4_; + const ParamGenerator<T5> g5_; +}; // class CartesianProductGenerator5 + + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6> +class CartesianProductGenerator6 + : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5, + T6> > { + public: + typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6> ParamType; + + CartesianProductGenerator6(const ParamGenerator<T1>& g1, + const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3, + const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5, + const ParamGenerator<T6>& g6) + : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6) {} + virtual ~CartesianProductGenerator6() {} + + virtual ParamIteratorInterface<ParamType>* Begin() const { + return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_, + g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin()); + } + virtual ParamIteratorInterface<ParamType>* End() const { + return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(), + g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end()); + } + + private: + class Iterator : public ParamIteratorInterface<ParamType> { + public: + Iterator(const ParamGeneratorInterface<ParamType>* base, + const ParamGenerator<T1>& g1, + const typename ParamGenerator<T1>::iterator& current1, + const ParamGenerator<T2>& g2, + const typename ParamGenerator<T2>::iterator& current2, + const ParamGenerator<T3>& g3, + const typename ParamGenerator<T3>::iterator& current3, + const ParamGenerator<T4>& g4, + const typename ParamGenerator<T4>::iterator& current4, + const ParamGenerator<T5>& g5, + const typename ParamGenerator<T5>::iterator& current5, + const ParamGenerator<T6>& g6, + const typename ParamGenerator<T6>::iterator& current6) + : base_(base), + begin1_(g1.begin()), end1_(g1.end()), current1_(current1), + begin2_(g2.begin()), end2_(g2.end()), current2_(current2), + begin3_(g3.begin()), end3_(g3.end()), current3_(current3), + begin4_(g4.begin()), end4_(g4.end()), current4_(current4), + begin5_(g5.begin()), end5_(g5.end()), current5_(current5), + begin6_(g6.begin()), end6_(g6.end()), current6_(current6) { + ComputeCurrentValue(); + } + virtual ~Iterator() {} + + virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const { + return base_; + } + // Advance should not be called on beyond-of-range iterators + // so no component iterators must be beyond end of range, either. + virtual void Advance() { + assert(!AtEnd()); + ++current6_; + if (current6_ == end6_) { + current6_ = begin6_; + ++current5_; + } + if (current5_ == end5_) { + current5_ = begin5_; + ++current4_; + } + if (current4_ == end4_) { + current4_ = begin4_; + ++current3_; + } + if (current3_ == end3_) { + current3_ = begin3_; + ++current2_; + } + if (current2_ == end2_) { + current2_ = begin2_; + ++current1_; + } + ComputeCurrentValue(); + } + virtual ParamIteratorInterface<ParamType>* Clone() const { + return new Iterator(*this); + } + virtual const ParamType* Current() const { return ¤t_value_; } + virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const { + // Having the same base generator guarantees that the other + // iterator is of the same type and we can downcast. + GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) + << "The program attempted to compare iterators " + << "from different generators." << std::endl; + const Iterator* typed_other = + CheckedDowncastToActualType<const Iterator>(&other); + // We must report iterators equal if they both point beyond their + // respective ranges. That can happen in a variety of fashions, + // so we have to consult AtEnd(). + return (AtEnd() && typed_other->AtEnd()) || + ( + current1_ == typed_other->current1_ && + current2_ == typed_other->current2_ && + current3_ == typed_other->current3_ && + current4_ == typed_other->current4_ && + current5_ == typed_other->current5_ && + current6_ == typed_other->current6_); + } + + private: + Iterator(const Iterator& other) + : base_(other.base_), + begin1_(other.begin1_), + end1_(other.end1_), + current1_(other.current1_), + begin2_(other.begin2_), + end2_(other.end2_), + current2_(other.current2_), + begin3_(other.begin3_), + end3_(other.end3_), + current3_(other.current3_), + begin4_(other.begin4_), + end4_(other.end4_), + current4_(other.current4_), + begin5_(other.begin5_), + end5_(other.end5_), + current5_(other.current5_), + begin6_(other.begin6_), + end6_(other.end6_), + current6_(other.current6_) { + ComputeCurrentValue(); + } + + void ComputeCurrentValue() { + if (!AtEnd()) + current_value_ = ParamType(*current1_, *current2_, *current3_, + *current4_, *current5_, *current6_); + } + bool AtEnd() const { + // We must report iterator past the end of the range when either of the + // component iterators has reached the end of its range. + return + current1_ == end1_ || + current2_ == end2_ || + current3_ == end3_ || + current4_ == end4_ || + current5_ == end5_ || + current6_ == end6_; + } + + // No implementation - assignment is unsupported. + void operator=(const Iterator& other); + + const ParamGeneratorInterface<ParamType>* const base_; + // begin[i]_ and end[i]_ define the i-th range that Iterator traverses. + // current[i]_ is the actual traversing iterator. + const typename ParamGenerator<T1>::iterator begin1_; + const typename ParamGenerator<T1>::iterator end1_; + typename ParamGenerator<T1>::iterator current1_; + const typename ParamGenerator<T2>::iterator begin2_; + const typename ParamGenerator<T2>::iterator end2_; + typename ParamGenerator<T2>::iterator current2_; + const typename ParamGenerator<T3>::iterator begin3_; + const typename ParamGenerator<T3>::iterator end3_; + typename ParamGenerator<T3>::iterator current3_; + const typename ParamGenerator<T4>::iterator begin4_; + const typename ParamGenerator<T4>::iterator end4_; + typename ParamGenerator<T4>::iterator current4_; + const typename ParamGenerator<T5>::iterator begin5_; + const typename ParamGenerator<T5>::iterator end5_; + typename ParamGenerator<T5>::iterator current5_; + const typename ParamGenerator<T6>::iterator begin6_; + const typename ParamGenerator<T6>::iterator end6_; + typename ParamGenerator<T6>::iterator current6_; + ParamType current_value_; + }; // class CartesianProductGenerator6::Iterator + + // No implementation - assignment is unsupported. + void operator=(const CartesianProductGenerator6& other); + + const ParamGenerator<T1> g1_; + const ParamGenerator<T2> g2_; + const ParamGenerator<T3> g3_; + const ParamGenerator<T4> g4_; + const ParamGenerator<T5> g5_; + const ParamGenerator<T6> g6_; +}; // class CartesianProductGenerator6 + + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7> +class CartesianProductGenerator7 + : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, + T7> > { + public: + typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7> ParamType; + + CartesianProductGenerator7(const ParamGenerator<T1>& g1, + const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3, + const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5, + const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7) + : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7) {} + virtual ~CartesianProductGenerator7() {} + + virtual ParamIteratorInterface<ParamType>* Begin() const { + return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_, + g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_, + g7_.begin()); + } + virtual ParamIteratorInterface<ParamType>* End() const { + return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(), + g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end()); + } + + private: + class Iterator : public ParamIteratorInterface<ParamType> { + public: + Iterator(const ParamGeneratorInterface<ParamType>* base, + const ParamGenerator<T1>& g1, + const typename ParamGenerator<T1>::iterator& current1, + const ParamGenerator<T2>& g2, + const typename ParamGenerator<T2>::iterator& current2, + const ParamGenerator<T3>& g3, + const typename ParamGenerator<T3>::iterator& current3, + const ParamGenerator<T4>& g4, + const typename ParamGenerator<T4>::iterator& current4, + const ParamGenerator<T5>& g5, + const typename ParamGenerator<T5>::iterator& current5, + const ParamGenerator<T6>& g6, + const typename ParamGenerator<T6>::iterator& current6, + const ParamGenerator<T7>& g7, + const typename ParamGenerator<T7>::iterator& current7) + : base_(base), + begin1_(g1.begin()), end1_(g1.end()), current1_(current1), + begin2_(g2.begin()), end2_(g2.end()), current2_(current2), + begin3_(g3.begin()), end3_(g3.end()), current3_(current3), + begin4_(g4.begin()), end4_(g4.end()), current4_(current4), + begin5_(g5.begin()), end5_(g5.end()), current5_(current5), + begin6_(g6.begin()), end6_(g6.end()), current6_(current6), + begin7_(g7.begin()), end7_(g7.end()), current7_(current7) { + ComputeCurrentValue(); + } + virtual ~Iterator() {} + + virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const { + return base_; + } + // Advance should not be called on beyond-of-range iterators + // so no component iterators must be beyond end of range, either. + virtual void Advance() { + assert(!AtEnd()); + ++current7_; + if (current7_ == end7_) { + current7_ = begin7_; + ++current6_; + } + if (current6_ == end6_) { + current6_ = begin6_; + ++current5_; + } + if (current5_ == end5_) { + current5_ = begin5_; + ++current4_; + } + if (current4_ == end4_) { + current4_ = begin4_; + ++current3_; + } + if (current3_ == end3_) { + current3_ = begin3_; + ++current2_; + } + if (current2_ == end2_) { + current2_ = begin2_; + ++current1_; + } + ComputeCurrentValue(); + } + virtual ParamIteratorInterface<ParamType>* Clone() const { + return new Iterator(*this); + } + virtual const ParamType* Current() const { return ¤t_value_; } + virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const { + // Having the same base generator guarantees that the other + // iterator is of the same type and we can downcast. + GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) + << "The program attempted to compare iterators " + << "from different generators." << std::endl; + const Iterator* typed_other = + CheckedDowncastToActualType<const Iterator>(&other); + // We must report iterators equal if they both point beyond their + // respective ranges. That can happen in a variety of fashions, + // so we have to consult AtEnd(). + return (AtEnd() && typed_other->AtEnd()) || + ( + current1_ == typed_other->current1_ && + current2_ == typed_other->current2_ && + current3_ == typed_other->current3_ && + current4_ == typed_other->current4_ && + current5_ == typed_other->current5_ && + current6_ == typed_other->current6_ && + current7_ == typed_other->current7_); + } + + private: + Iterator(const Iterator& other) + : base_(other.base_), + begin1_(other.begin1_), + end1_(other.end1_), + current1_(other.current1_), + begin2_(other.begin2_), + end2_(other.end2_), + current2_(other.current2_), + begin3_(other.begin3_), + end3_(other.end3_), + current3_(other.current3_), + begin4_(other.begin4_), + end4_(other.end4_), + current4_(other.current4_), + begin5_(other.begin5_), + end5_(other.end5_), + current5_(other.current5_), + begin6_(other.begin6_), + end6_(other.end6_), + current6_(other.current6_), + begin7_(other.begin7_), + end7_(other.end7_), + current7_(other.current7_) { + ComputeCurrentValue(); + } + + void ComputeCurrentValue() { + if (!AtEnd()) + current_value_ = ParamType(*current1_, *current2_, *current3_, + *current4_, *current5_, *current6_, *current7_); + } + bool AtEnd() const { + // We must report iterator past the end of the range when either of the + // component iterators has reached the end of its range. + return + current1_ == end1_ || + current2_ == end2_ || + current3_ == end3_ || + current4_ == end4_ || + current5_ == end5_ || + current6_ == end6_ || + current7_ == end7_; + } + + // No implementation - assignment is unsupported. + void operator=(const Iterator& other); + + const ParamGeneratorInterface<ParamType>* const base_; + // begin[i]_ and end[i]_ define the i-th range that Iterator traverses. + // current[i]_ is the actual traversing iterator. + const typename ParamGenerator<T1>::iterator begin1_; + const typename ParamGenerator<T1>::iterator end1_; + typename ParamGenerator<T1>::iterator current1_; + const typename ParamGenerator<T2>::iterator begin2_; + const typename ParamGenerator<T2>::iterator end2_; + typename ParamGenerator<T2>::iterator current2_; + const typename ParamGenerator<T3>::iterator begin3_; + const typename ParamGenerator<T3>::iterator end3_; + typename ParamGenerator<T3>::iterator current3_; + const typename ParamGenerator<T4>::iterator begin4_; + const typename ParamGenerator<T4>::iterator end4_; + typename ParamGenerator<T4>::iterator current4_; + const typename ParamGenerator<T5>::iterator begin5_; + const typename ParamGenerator<T5>::iterator end5_; + typename ParamGenerator<T5>::iterator current5_; + const typename ParamGenerator<T6>::iterator begin6_; + const typename ParamGenerator<T6>::iterator end6_; + typename ParamGenerator<T6>::iterator current6_; + const typename ParamGenerator<T7>::iterator begin7_; + const typename ParamGenerator<T7>::iterator end7_; + typename ParamGenerator<T7>::iterator current7_; + ParamType current_value_; + }; // class CartesianProductGenerator7::Iterator + + // No implementation - assignment is unsupported. + void operator=(const CartesianProductGenerator7& other); + + const ParamGenerator<T1> g1_; + const ParamGenerator<T2> g2_; + const ParamGenerator<T3> g3_; + const ParamGenerator<T4> g4_; + const ParamGenerator<T5> g5_; + const ParamGenerator<T6> g6_; + const ParamGenerator<T7> g7_; +}; // class CartesianProductGenerator7 + + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8> +class CartesianProductGenerator8 + : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, + T7, T8> > { + public: + typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8> ParamType; + + CartesianProductGenerator8(const ParamGenerator<T1>& g1, + const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3, + const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5, + const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7, + const ParamGenerator<T8>& g8) + : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), + g8_(g8) {} + virtual ~CartesianProductGenerator8() {} + + virtual ParamIteratorInterface<ParamType>* Begin() const { + return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_, + g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_, + g7_.begin(), g8_, g8_.begin()); + } + virtual ParamIteratorInterface<ParamType>* End() const { + return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(), + g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(), g8_, + g8_.end()); + } + + private: + class Iterator : public ParamIteratorInterface<ParamType> { + public: + Iterator(const ParamGeneratorInterface<ParamType>* base, + const ParamGenerator<T1>& g1, + const typename ParamGenerator<T1>::iterator& current1, + const ParamGenerator<T2>& g2, + const typename ParamGenerator<T2>::iterator& current2, + const ParamGenerator<T3>& g3, + const typename ParamGenerator<T3>::iterator& current3, + const ParamGenerator<T4>& g4, + const typename ParamGenerator<T4>::iterator& current4, + const ParamGenerator<T5>& g5, + const typename ParamGenerator<T5>::iterator& current5, + const ParamGenerator<T6>& g6, + const typename ParamGenerator<T6>::iterator& current6, + const ParamGenerator<T7>& g7, + const typename ParamGenerator<T7>::iterator& current7, + const ParamGenerator<T8>& g8, + const typename ParamGenerator<T8>::iterator& current8) + : base_(base), + begin1_(g1.begin()), end1_(g1.end()), current1_(current1), + begin2_(g2.begin()), end2_(g2.end()), current2_(current2), + begin3_(g3.begin()), end3_(g3.end()), current3_(current3), + begin4_(g4.begin()), end4_(g4.end()), current4_(current4), + begin5_(g5.begin()), end5_(g5.end()), current5_(current5), + begin6_(g6.begin()), end6_(g6.end()), current6_(current6), + begin7_(g7.begin()), end7_(g7.end()), current7_(current7), + begin8_(g8.begin()), end8_(g8.end()), current8_(current8) { + ComputeCurrentValue(); + } + virtual ~Iterator() {} + + virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const { + return base_; + } + // Advance should not be called on beyond-of-range iterators + // so no component iterators must be beyond end of range, either. + virtual void Advance() { + assert(!AtEnd()); + ++current8_; + if (current8_ == end8_) { + current8_ = begin8_; + ++current7_; + } + if (current7_ == end7_) { + current7_ = begin7_; + ++current6_; + } + if (current6_ == end6_) { + current6_ = begin6_; + ++current5_; + } + if (current5_ == end5_) { + current5_ = begin5_; + ++current4_; + } + if (current4_ == end4_) { + current4_ = begin4_; + ++current3_; + } + if (current3_ == end3_) { + current3_ = begin3_; + ++current2_; + } + if (current2_ == end2_) { + current2_ = begin2_; + ++current1_; + } + ComputeCurrentValue(); + } + virtual ParamIteratorInterface<ParamType>* Clone() const { + return new Iterator(*this); + } + virtual const ParamType* Current() const { return ¤t_value_; } + virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const { + // Having the same base generator guarantees that the other + // iterator is of the same type and we can downcast. + GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) + << "The program attempted to compare iterators " + << "from different generators." << std::endl; + const Iterator* typed_other = + CheckedDowncastToActualType<const Iterator>(&other); + // We must report iterators equal if they both point beyond their + // respective ranges. That can happen in a variety of fashions, + // so we have to consult AtEnd(). + return (AtEnd() && typed_other->AtEnd()) || + ( + current1_ == typed_other->current1_ && + current2_ == typed_other->current2_ && + current3_ == typed_other->current3_ && + current4_ == typed_other->current4_ && + current5_ == typed_other->current5_ && + current6_ == typed_other->current6_ && + current7_ == typed_other->current7_ && + current8_ == typed_other->current8_); + } + + private: + Iterator(const Iterator& other) + : base_(other.base_), + begin1_(other.begin1_), + end1_(other.end1_), + current1_(other.current1_), + begin2_(other.begin2_), + end2_(other.end2_), + current2_(other.current2_), + begin3_(other.begin3_), + end3_(other.end3_), + current3_(other.current3_), + begin4_(other.begin4_), + end4_(other.end4_), + current4_(other.current4_), + begin5_(other.begin5_), + end5_(other.end5_), + current5_(other.current5_), + begin6_(other.begin6_), + end6_(other.end6_), + current6_(other.current6_), + begin7_(other.begin7_), + end7_(other.end7_), + current7_(other.current7_), + begin8_(other.begin8_), + end8_(other.end8_), + current8_(other.current8_) { + ComputeCurrentValue(); + } + + void ComputeCurrentValue() { + if (!AtEnd()) + current_value_ = ParamType(*current1_, *current2_, *current3_, + *current4_, *current5_, *current6_, *current7_, *current8_); + } + bool AtEnd() const { + // We must report iterator past the end of the range when either of the + // component iterators has reached the end of its range. + return + current1_ == end1_ || + current2_ == end2_ || + current3_ == end3_ || + current4_ == end4_ || + current5_ == end5_ || + current6_ == end6_ || + current7_ == end7_ || + current8_ == end8_; + } + + // No implementation - assignment is unsupported. + void operator=(const Iterator& other); + + const ParamGeneratorInterface<ParamType>* const base_; + // begin[i]_ and end[i]_ define the i-th range that Iterator traverses. + // current[i]_ is the actual traversing iterator. + const typename ParamGenerator<T1>::iterator begin1_; + const typename ParamGenerator<T1>::iterator end1_; + typename ParamGenerator<T1>::iterator current1_; + const typename ParamGenerator<T2>::iterator begin2_; + const typename ParamGenerator<T2>::iterator end2_; + typename ParamGenerator<T2>::iterator current2_; + const typename ParamGenerator<T3>::iterator begin3_; + const typename ParamGenerator<T3>::iterator end3_; + typename ParamGenerator<T3>::iterator current3_; + const typename ParamGenerator<T4>::iterator begin4_; + const typename ParamGenerator<T4>::iterator end4_; + typename ParamGenerator<T4>::iterator current4_; + const typename ParamGenerator<T5>::iterator begin5_; + const typename ParamGenerator<T5>::iterator end5_; + typename ParamGenerator<T5>::iterator current5_; + const typename ParamGenerator<T6>::iterator begin6_; + const typename ParamGenerator<T6>::iterator end6_; + typename ParamGenerator<T6>::iterator current6_; + const typename ParamGenerator<T7>::iterator begin7_; + const typename ParamGenerator<T7>::iterator end7_; + typename ParamGenerator<T7>::iterator current7_; + const typename ParamGenerator<T8>::iterator begin8_; + const typename ParamGenerator<T8>::iterator end8_; + typename ParamGenerator<T8>::iterator current8_; + ParamType current_value_; + }; // class CartesianProductGenerator8::Iterator + + // No implementation - assignment is unsupported. + void operator=(const CartesianProductGenerator8& other); + + const ParamGenerator<T1> g1_; + const ParamGenerator<T2> g2_; + const ParamGenerator<T3> g3_; + const ParamGenerator<T4> g4_; + const ParamGenerator<T5> g5_; + const ParamGenerator<T6> g6_; + const ParamGenerator<T7> g7_; + const ParamGenerator<T8> g8_; +}; // class CartesianProductGenerator8 + + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9> +class CartesianProductGenerator9 + : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, + T7, T8, T9> > { + public: + typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9> ParamType; + + CartesianProductGenerator9(const ParamGenerator<T1>& g1, + const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3, + const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5, + const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7, + const ParamGenerator<T8>& g8, const ParamGenerator<T9>& g9) + : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8), + g9_(g9) {} + virtual ~CartesianProductGenerator9() {} + + virtual ParamIteratorInterface<ParamType>* Begin() const { + return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_, + g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_, + g7_.begin(), g8_, g8_.begin(), g9_, g9_.begin()); + } + virtual ParamIteratorInterface<ParamType>* End() const { + return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(), + g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(), g8_, + g8_.end(), g9_, g9_.end()); + } + + private: + class Iterator : public ParamIteratorInterface<ParamType> { + public: + Iterator(const ParamGeneratorInterface<ParamType>* base, + const ParamGenerator<T1>& g1, + const typename ParamGenerator<T1>::iterator& current1, + const ParamGenerator<T2>& g2, + const typename ParamGenerator<T2>::iterator& current2, + const ParamGenerator<T3>& g3, + const typename ParamGenerator<T3>::iterator& current3, + const ParamGenerator<T4>& g4, + const typename ParamGenerator<T4>::iterator& current4, + const ParamGenerator<T5>& g5, + const typename ParamGenerator<T5>::iterator& current5, + const ParamGenerator<T6>& g6, + const typename ParamGenerator<T6>::iterator& current6, + const ParamGenerator<T7>& g7, + const typename ParamGenerator<T7>::iterator& current7, + const ParamGenerator<T8>& g8, + const typename ParamGenerator<T8>::iterator& current8, + const ParamGenerator<T9>& g9, + const typename ParamGenerator<T9>::iterator& current9) + : base_(base), + begin1_(g1.begin()), end1_(g1.end()), current1_(current1), + begin2_(g2.begin()), end2_(g2.end()), current2_(current2), + begin3_(g3.begin()), end3_(g3.end()), current3_(current3), + begin4_(g4.begin()), end4_(g4.end()), current4_(current4), + begin5_(g5.begin()), end5_(g5.end()), current5_(current5), + begin6_(g6.begin()), end6_(g6.end()), current6_(current6), + begin7_(g7.begin()), end7_(g7.end()), current7_(current7), + begin8_(g8.begin()), end8_(g8.end()), current8_(current8), + begin9_(g9.begin()), end9_(g9.end()), current9_(current9) { + ComputeCurrentValue(); + } + virtual ~Iterator() {} + + virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const { + return base_; + } + // Advance should not be called on beyond-of-range iterators + // so no component iterators must be beyond end of range, either. + virtual void Advance() { + assert(!AtEnd()); + ++current9_; + if (current9_ == end9_) { + current9_ = begin9_; + ++current8_; + } + if (current8_ == end8_) { + current8_ = begin8_; + ++current7_; + } + if (current7_ == end7_) { + current7_ = begin7_; + ++current6_; + } + if (current6_ == end6_) { + current6_ = begin6_; + ++current5_; + } + if (current5_ == end5_) { + current5_ = begin5_; + ++current4_; + } + if (current4_ == end4_) { + current4_ = begin4_; + ++current3_; + } + if (current3_ == end3_) { + current3_ = begin3_; + ++current2_; + } + if (current2_ == end2_) { + current2_ = begin2_; + ++current1_; + } + ComputeCurrentValue(); + } + virtual ParamIteratorInterface<ParamType>* Clone() const { + return new Iterator(*this); + } + virtual const ParamType* Current() const { return ¤t_value_; } + virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const { + // Having the same base generator guarantees that the other + // iterator is of the same type and we can downcast. + GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) + << "The program attempted to compare iterators " + << "from different generators." << std::endl; + const Iterator* typed_other = + CheckedDowncastToActualType<const Iterator>(&other); + // We must report iterators equal if they both point beyond their + // respective ranges. That can happen in a variety of fashions, + // so we have to consult AtEnd(). + return (AtEnd() && typed_other->AtEnd()) || + ( + current1_ == typed_other->current1_ && + current2_ == typed_other->current2_ && + current3_ == typed_other->current3_ && + current4_ == typed_other->current4_ && + current5_ == typed_other->current5_ && + current6_ == typed_other->current6_ && + current7_ == typed_other->current7_ && + current8_ == typed_other->current8_ && + current9_ == typed_other->current9_); + } + + private: + Iterator(const Iterator& other) + : base_(other.base_), + begin1_(other.begin1_), + end1_(other.end1_), + current1_(other.current1_), + begin2_(other.begin2_), + end2_(other.end2_), + current2_(other.current2_), + begin3_(other.begin3_), + end3_(other.end3_), + current3_(other.current3_), + begin4_(other.begin4_), + end4_(other.end4_), + current4_(other.current4_), + begin5_(other.begin5_), + end5_(other.end5_), + current5_(other.current5_), + begin6_(other.begin6_), + end6_(other.end6_), + current6_(other.current6_), + begin7_(other.begin7_), + end7_(other.end7_), + current7_(other.current7_), + begin8_(other.begin8_), + end8_(other.end8_), + current8_(other.current8_), + begin9_(other.begin9_), + end9_(other.end9_), + current9_(other.current9_) { + ComputeCurrentValue(); + } + + void ComputeCurrentValue() { + if (!AtEnd()) + current_value_ = ParamType(*current1_, *current2_, *current3_, + *current4_, *current5_, *current6_, *current7_, *current8_, + *current9_); + } + bool AtEnd() const { + // We must report iterator past the end of the range when either of the + // component iterators has reached the end of its range. + return + current1_ == end1_ || + current2_ == end2_ || + current3_ == end3_ || + current4_ == end4_ || + current5_ == end5_ || + current6_ == end6_ || + current7_ == end7_ || + current8_ == end8_ || + current9_ == end9_; + } + + // No implementation - assignment is unsupported. + void operator=(const Iterator& other); + + const ParamGeneratorInterface<ParamType>* const base_; + // begin[i]_ and end[i]_ define the i-th range that Iterator traverses. + // current[i]_ is the actual traversing iterator. + const typename ParamGenerator<T1>::iterator begin1_; + const typename ParamGenerator<T1>::iterator end1_; + typename ParamGenerator<T1>::iterator current1_; + const typename ParamGenerator<T2>::iterator begin2_; + const typename ParamGenerator<T2>::iterator end2_; + typename ParamGenerator<T2>::iterator current2_; + const typename ParamGenerator<T3>::iterator begin3_; + const typename ParamGenerator<T3>::iterator end3_; + typename ParamGenerator<T3>::iterator current3_; + const typename ParamGenerator<T4>::iterator begin4_; + const typename ParamGenerator<T4>::iterator end4_; + typename ParamGenerator<T4>::iterator current4_; + const typename ParamGenerator<T5>::iterator begin5_; + const typename ParamGenerator<T5>::iterator end5_; + typename ParamGenerator<T5>::iterator current5_; + const typename ParamGenerator<T6>::iterator begin6_; + const typename ParamGenerator<T6>::iterator end6_; + typename ParamGenerator<T6>::iterator current6_; + const typename ParamGenerator<T7>::iterator begin7_; + const typename ParamGenerator<T7>::iterator end7_; + typename ParamGenerator<T7>::iterator current7_; + const typename ParamGenerator<T8>::iterator begin8_; + const typename ParamGenerator<T8>::iterator end8_; + typename ParamGenerator<T8>::iterator current8_; + const typename ParamGenerator<T9>::iterator begin9_; + const typename ParamGenerator<T9>::iterator end9_; + typename ParamGenerator<T9>::iterator current9_; + ParamType current_value_; + }; // class CartesianProductGenerator9::Iterator + + // No implementation - assignment is unsupported. + void operator=(const CartesianProductGenerator9& other); + + const ParamGenerator<T1> g1_; + const ParamGenerator<T2> g2_; + const ParamGenerator<T3> g3_; + const ParamGenerator<T4> g4_; + const ParamGenerator<T5> g5_; + const ParamGenerator<T6> g6_; + const ParamGenerator<T7> g7_; + const ParamGenerator<T8> g8_; + const ParamGenerator<T9> g9_; +}; // class CartesianProductGenerator9 + + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10> +class CartesianProductGenerator10 + : public ParamGeneratorInterface< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, + T7, T8, T9, T10> > { + public: + typedef ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> ParamType; + + CartesianProductGenerator10(const ParamGenerator<T1>& g1, + const ParamGenerator<T2>& g2, const ParamGenerator<T3>& g3, + const ParamGenerator<T4>& g4, const ParamGenerator<T5>& g5, + const ParamGenerator<T6>& g6, const ParamGenerator<T7>& g7, + const ParamGenerator<T8>& g8, const ParamGenerator<T9>& g9, + const ParamGenerator<T10>& g10) + : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8), + g9_(g9), g10_(g10) {} + virtual ~CartesianProductGenerator10() {} + + virtual ParamIteratorInterface<ParamType>* Begin() const { + return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_, + g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_, + g7_.begin(), g8_, g8_.begin(), g9_, g9_.begin(), g10_, g10_.begin()); + } + virtual ParamIteratorInterface<ParamType>* End() const { + return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(), + g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(), g8_, + g8_.end(), g9_, g9_.end(), g10_, g10_.end()); + } + + private: + class Iterator : public ParamIteratorInterface<ParamType> { + public: + Iterator(const ParamGeneratorInterface<ParamType>* base, + const ParamGenerator<T1>& g1, + const typename ParamGenerator<T1>::iterator& current1, + const ParamGenerator<T2>& g2, + const typename ParamGenerator<T2>::iterator& current2, + const ParamGenerator<T3>& g3, + const typename ParamGenerator<T3>::iterator& current3, + const ParamGenerator<T4>& g4, + const typename ParamGenerator<T4>::iterator& current4, + const ParamGenerator<T5>& g5, + const typename ParamGenerator<T5>::iterator& current5, + const ParamGenerator<T6>& g6, + const typename ParamGenerator<T6>::iterator& current6, + const ParamGenerator<T7>& g7, + const typename ParamGenerator<T7>::iterator& current7, + const ParamGenerator<T8>& g8, + const typename ParamGenerator<T8>::iterator& current8, + const ParamGenerator<T9>& g9, + const typename ParamGenerator<T9>::iterator& current9, + const ParamGenerator<T10>& g10, + const typename ParamGenerator<T10>::iterator& current10) + : base_(base), + begin1_(g1.begin()), end1_(g1.end()), current1_(current1), + begin2_(g2.begin()), end2_(g2.end()), current2_(current2), + begin3_(g3.begin()), end3_(g3.end()), current3_(current3), + begin4_(g4.begin()), end4_(g4.end()), current4_(current4), + begin5_(g5.begin()), end5_(g5.end()), current5_(current5), + begin6_(g6.begin()), end6_(g6.end()), current6_(current6), + begin7_(g7.begin()), end7_(g7.end()), current7_(current7), + begin8_(g8.begin()), end8_(g8.end()), current8_(current8), + begin9_(g9.begin()), end9_(g9.end()), current9_(current9), + begin10_(g10.begin()), end10_(g10.end()), current10_(current10) { + ComputeCurrentValue(); + } + virtual ~Iterator() {} + + virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const { + return base_; + } + // Advance should not be called on beyond-of-range iterators + // so no component iterators must be beyond end of range, either. + virtual void Advance() { + assert(!AtEnd()); + ++current10_; + if (current10_ == end10_) { + current10_ = begin10_; + ++current9_; + } + if (current9_ == end9_) { + current9_ = begin9_; + ++current8_; + } + if (current8_ == end8_) { + current8_ = begin8_; + ++current7_; + } + if (current7_ == end7_) { + current7_ = begin7_; + ++current6_; + } + if (current6_ == end6_) { + current6_ = begin6_; + ++current5_; + } + if (current5_ == end5_) { + current5_ = begin5_; + ++current4_; + } + if (current4_ == end4_) { + current4_ = begin4_; + ++current3_; + } + if (current3_ == end3_) { + current3_ = begin3_; + ++current2_; + } + if (current2_ == end2_) { + current2_ = begin2_; + ++current1_; + } + ComputeCurrentValue(); + } + virtual ParamIteratorInterface<ParamType>* Clone() const { + return new Iterator(*this); + } + virtual const ParamType* Current() const { return ¤t_value_; } + virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const { + // Having the same base generator guarantees that the other + // iterator is of the same type and we can downcast. + GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) + << "The program attempted to compare iterators " + << "from different generators." << std::endl; + const Iterator* typed_other = + CheckedDowncastToActualType<const Iterator>(&other); + // We must report iterators equal if they both point beyond their + // respective ranges. That can happen in a variety of fashions, + // so we have to consult AtEnd(). + return (AtEnd() && typed_other->AtEnd()) || + ( + current1_ == typed_other->current1_ && + current2_ == typed_other->current2_ && + current3_ == typed_other->current3_ && + current4_ == typed_other->current4_ && + current5_ == typed_other->current5_ && + current6_ == typed_other->current6_ && + current7_ == typed_other->current7_ && + current8_ == typed_other->current8_ && + current9_ == typed_other->current9_ && + current10_ == typed_other->current10_); + } + + private: + Iterator(const Iterator& other) + : base_(other.base_), + begin1_(other.begin1_), + end1_(other.end1_), + current1_(other.current1_), + begin2_(other.begin2_), + end2_(other.end2_), + current2_(other.current2_), + begin3_(other.begin3_), + end3_(other.end3_), + current3_(other.current3_), + begin4_(other.begin4_), + end4_(other.end4_), + current4_(other.current4_), + begin5_(other.begin5_), + end5_(other.end5_), + current5_(other.current5_), + begin6_(other.begin6_), + end6_(other.end6_), + current6_(other.current6_), + begin7_(other.begin7_), + end7_(other.end7_), + current7_(other.current7_), + begin8_(other.begin8_), + end8_(other.end8_), + current8_(other.current8_), + begin9_(other.begin9_), + end9_(other.end9_), + current9_(other.current9_), + begin10_(other.begin10_), + end10_(other.end10_), + current10_(other.current10_) { + ComputeCurrentValue(); + } + + void ComputeCurrentValue() { + if (!AtEnd()) + current_value_ = ParamType(*current1_, *current2_, *current3_, + *current4_, *current5_, *current6_, *current7_, *current8_, + *current9_, *current10_); + } + bool AtEnd() const { + // We must report iterator past the end of the range when either of the + // component iterators has reached the end of its range. + return + current1_ == end1_ || + current2_ == end2_ || + current3_ == end3_ || + current4_ == end4_ || + current5_ == end5_ || + current6_ == end6_ || + current7_ == end7_ || + current8_ == end8_ || + current9_ == end9_ || + current10_ == end10_; + } + + // No implementation - assignment is unsupported. + void operator=(const Iterator& other); + + const ParamGeneratorInterface<ParamType>* const base_; + // begin[i]_ and end[i]_ define the i-th range that Iterator traverses. + // current[i]_ is the actual traversing iterator. + const typename ParamGenerator<T1>::iterator begin1_; + const typename ParamGenerator<T1>::iterator end1_; + typename ParamGenerator<T1>::iterator current1_; + const typename ParamGenerator<T2>::iterator begin2_; + const typename ParamGenerator<T2>::iterator end2_; + typename ParamGenerator<T2>::iterator current2_; + const typename ParamGenerator<T3>::iterator begin3_; + const typename ParamGenerator<T3>::iterator end3_; + typename ParamGenerator<T3>::iterator current3_; + const typename ParamGenerator<T4>::iterator begin4_; + const typename ParamGenerator<T4>::iterator end4_; + typename ParamGenerator<T4>::iterator current4_; + const typename ParamGenerator<T5>::iterator begin5_; + const typename ParamGenerator<T5>::iterator end5_; + typename ParamGenerator<T5>::iterator current5_; + const typename ParamGenerator<T6>::iterator begin6_; + const typename ParamGenerator<T6>::iterator end6_; + typename ParamGenerator<T6>::iterator current6_; + const typename ParamGenerator<T7>::iterator begin7_; + const typename ParamGenerator<T7>::iterator end7_; + typename ParamGenerator<T7>::iterator current7_; + const typename ParamGenerator<T8>::iterator begin8_; + const typename ParamGenerator<T8>::iterator end8_; + typename ParamGenerator<T8>::iterator current8_; + const typename ParamGenerator<T9>::iterator begin9_; + const typename ParamGenerator<T9>::iterator end9_; + typename ParamGenerator<T9>::iterator current9_; + const typename ParamGenerator<T10>::iterator begin10_; + const typename ParamGenerator<T10>::iterator end10_; + typename ParamGenerator<T10>::iterator current10_; + ParamType current_value_; + }; // class CartesianProductGenerator10::Iterator + + // No implementation - assignment is unsupported. + void operator=(const CartesianProductGenerator10& other); + + const ParamGenerator<T1> g1_; + const ParamGenerator<T2> g2_; + const ParamGenerator<T3> g3_; + const ParamGenerator<T4> g4_; + const ParamGenerator<T5> g5_; + const ParamGenerator<T6> g6_; + const ParamGenerator<T7> g7_; + const ParamGenerator<T8> g8_; + const ParamGenerator<T9> g9_; + const ParamGenerator<T10> g10_; +}; // class CartesianProductGenerator10 + + +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// +// Helper classes providing Combine() with polymorphic features. They allow +// casting CartesianProductGeneratorN<T> to ParamGenerator<U> if T is +// convertible to U. +// +template <class Generator1, class Generator2> +class CartesianProductHolder2 { + public: +CartesianProductHolder2(const Generator1& g1, const Generator2& g2) + : g1_(g1), g2_(g2) {} + template <typename T1, typename T2> + operator ParamGenerator< ::std::tr1::tuple<T1, T2> >() const { + return ParamGenerator< ::std::tr1::tuple<T1, T2> >( + new CartesianProductGenerator2<T1, T2>( + static_cast<ParamGenerator<T1> >(g1_), + static_cast<ParamGenerator<T2> >(g2_))); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const CartesianProductHolder2& other); + + const Generator1 g1_; + const Generator2 g2_; +}; // class CartesianProductHolder2 + +template <class Generator1, class Generator2, class Generator3> +class CartesianProductHolder3 { + public: +CartesianProductHolder3(const Generator1& g1, const Generator2& g2, + const Generator3& g3) + : g1_(g1), g2_(g2), g3_(g3) {} + template <typename T1, typename T2, typename T3> + operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3> >() const { + return ParamGenerator< ::std::tr1::tuple<T1, T2, T3> >( + new CartesianProductGenerator3<T1, T2, T3>( + static_cast<ParamGenerator<T1> >(g1_), + static_cast<ParamGenerator<T2> >(g2_), + static_cast<ParamGenerator<T3> >(g3_))); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const CartesianProductHolder3& other); + + const Generator1 g1_; + const Generator2 g2_; + const Generator3 g3_; +}; // class CartesianProductHolder3 + +template <class Generator1, class Generator2, class Generator3, + class Generator4> +class CartesianProductHolder4 { + public: +CartesianProductHolder4(const Generator1& g1, const Generator2& g2, + const Generator3& g3, const Generator4& g4) + : g1_(g1), g2_(g2), g3_(g3), g4_(g4) {} + template <typename T1, typename T2, typename T3, typename T4> + operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4> >() const { + return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4> >( + new CartesianProductGenerator4<T1, T2, T3, T4>( + static_cast<ParamGenerator<T1> >(g1_), + static_cast<ParamGenerator<T2> >(g2_), + static_cast<ParamGenerator<T3> >(g3_), + static_cast<ParamGenerator<T4> >(g4_))); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const CartesianProductHolder4& other); + + const Generator1 g1_; + const Generator2 g2_; + const Generator3 g3_; + const Generator4 g4_; +}; // class CartesianProductHolder4 + +template <class Generator1, class Generator2, class Generator3, + class Generator4, class Generator5> +class CartesianProductHolder5 { + public: +CartesianProductHolder5(const Generator1& g1, const Generator2& g2, + const Generator3& g3, const Generator4& g4, const Generator5& g5) + : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5) {} + template <typename T1, typename T2, typename T3, typename T4, typename T5> + operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5> >() const { + return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5> >( + new CartesianProductGenerator5<T1, T2, T3, T4, T5>( + static_cast<ParamGenerator<T1> >(g1_), + static_cast<ParamGenerator<T2> >(g2_), + static_cast<ParamGenerator<T3> >(g3_), + static_cast<ParamGenerator<T4> >(g4_), + static_cast<ParamGenerator<T5> >(g5_))); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const CartesianProductHolder5& other); + + const Generator1 g1_; + const Generator2 g2_; + const Generator3 g3_; + const Generator4 g4_; + const Generator5 g5_; +}; // class CartesianProductHolder5 + +template <class Generator1, class Generator2, class Generator3, + class Generator4, class Generator5, class Generator6> +class CartesianProductHolder6 { + public: +CartesianProductHolder6(const Generator1& g1, const Generator2& g2, + const Generator3& g3, const Generator4& g4, const Generator5& g5, + const Generator6& g6) + : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6) {} + template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6> + operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6> >() const { + return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6> >( + new CartesianProductGenerator6<T1, T2, T3, T4, T5, T6>( + static_cast<ParamGenerator<T1> >(g1_), + static_cast<ParamGenerator<T2> >(g2_), + static_cast<ParamGenerator<T3> >(g3_), + static_cast<ParamGenerator<T4> >(g4_), + static_cast<ParamGenerator<T5> >(g5_), + static_cast<ParamGenerator<T6> >(g6_))); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const CartesianProductHolder6& other); + + const Generator1 g1_; + const Generator2 g2_; + const Generator3 g3_; + const Generator4 g4_; + const Generator5 g5_; + const Generator6 g6_; +}; // class CartesianProductHolder6 + +template <class Generator1, class Generator2, class Generator3, + class Generator4, class Generator5, class Generator6, class Generator7> +class CartesianProductHolder7 { + public: +CartesianProductHolder7(const Generator1& g1, const Generator2& g2, + const Generator3& g3, const Generator4& g4, const Generator5& g5, + const Generator6& g6, const Generator7& g7) + : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7) {} + template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7> + operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, + T7> >() const { + return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7> >( + new CartesianProductGenerator7<T1, T2, T3, T4, T5, T6, T7>( + static_cast<ParamGenerator<T1> >(g1_), + static_cast<ParamGenerator<T2> >(g2_), + static_cast<ParamGenerator<T3> >(g3_), + static_cast<ParamGenerator<T4> >(g4_), + static_cast<ParamGenerator<T5> >(g5_), + static_cast<ParamGenerator<T6> >(g6_), + static_cast<ParamGenerator<T7> >(g7_))); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const CartesianProductHolder7& other); + + const Generator1 g1_; + const Generator2 g2_; + const Generator3 g3_; + const Generator4 g4_; + const Generator5 g5_; + const Generator6 g6_; + const Generator7 g7_; +}; // class CartesianProductHolder7 + +template <class Generator1, class Generator2, class Generator3, + class Generator4, class Generator5, class Generator6, class Generator7, + class Generator8> +class CartesianProductHolder8 { + public: +CartesianProductHolder8(const Generator1& g1, const Generator2& g2, + const Generator3& g3, const Generator4& g4, const Generator5& g5, + const Generator6& g6, const Generator7& g7, const Generator8& g8) + : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), + g8_(g8) {} + template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8> + operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, + T8> >() const { + return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8> >( + new CartesianProductGenerator8<T1, T2, T3, T4, T5, T6, T7, T8>( + static_cast<ParamGenerator<T1> >(g1_), + static_cast<ParamGenerator<T2> >(g2_), + static_cast<ParamGenerator<T3> >(g3_), + static_cast<ParamGenerator<T4> >(g4_), + static_cast<ParamGenerator<T5> >(g5_), + static_cast<ParamGenerator<T6> >(g6_), + static_cast<ParamGenerator<T7> >(g7_), + static_cast<ParamGenerator<T8> >(g8_))); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const CartesianProductHolder8& other); + + const Generator1 g1_; + const Generator2 g2_; + const Generator3 g3_; + const Generator4 g4_; + const Generator5 g5_; + const Generator6 g6_; + const Generator7 g7_; + const Generator8 g8_; +}; // class CartesianProductHolder8 + +template <class Generator1, class Generator2, class Generator3, + class Generator4, class Generator5, class Generator6, class Generator7, + class Generator8, class Generator9> +class CartesianProductHolder9 { + public: +CartesianProductHolder9(const Generator1& g1, const Generator2& g2, + const Generator3& g3, const Generator4& g4, const Generator5& g5, + const Generator6& g6, const Generator7& g7, const Generator8& g8, + const Generator9& g9) + : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8), + g9_(g9) {} + template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9> + operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, + T9> >() const { + return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, + T9> >( + new CartesianProductGenerator9<T1, T2, T3, T4, T5, T6, T7, T8, T9>( + static_cast<ParamGenerator<T1> >(g1_), + static_cast<ParamGenerator<T2> >(g2_), + static_cast<ParamGenerator<T3> >(g3_), + static_cast<ParamGenerator<T4> >(g4_), + static_cast<ParamGenerator<T5> >(g5_), + static_cast<ParamGenerator<T6> >(g6_), + static_cast<ParamGenerator<T7> >(g7_), + static_cast<ParamGenerator<T8> >(g8_), + static_cast<ParamGenerator<T9> >(g9_))); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const CartesianProductHolder9& other); + + const Generator1 g1_; + const Generator2 g2_; + const Generator3 g3_; + const Generator4 g4_; + const Generator5 g5_; + const Generator6 g6_; + const Generator7 g7_; + const Generator8 g8_; + const Generator9 g9_; +}; // class CartesianProductHolder9 + +template <class Generator1, class Generator2, class Generator3, + class Generator4, class Generator5, class Generator6, class Generator7, + class Generator8, class Generator9, class Generator10> +class CartesianProductHolder10 { + public: +CartesianProductHolder10(const Generator1& g1, const Generator2& g2, + const Generator3& g3, const Generator4& g4, const Generator5& g5, + const Generator6& g6, const Generator7& g7, const Generator8& g8, + const Generator9& g9, const Generator10& g10) + : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8), + g9_(g9), g10_(g10) {} + template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10> + operator ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, + T9, T10> >() const { + return ParamGenerator< ::std::tr1::tuple<T1, T2, T3, T4, T5, T6, T7, T8, + T9, T10> >( + new CartesianProductGenerator10<T1, T2, T3, T4, T5, T6, T7, T8, T9, + T10>( + static_cast<ParamGenerator<T1> >(g1_), + static_cast<ParamGenerator<T2> >(g2_), + static_cast<ParamGenerator<T3> >(g3_), + static_cast<ParamGenerator<T4> >(g4_), + static_cast<ParamGenerator<T5> >(g5_), + static_cast<ParamGenerator<T6> >(g6_), + static_cast<ParamGenerator<T7> >(g7_), + static_cast<ParamGenerator<T8> >(g8_), + static_cast<ParamGenerator<T9> >(g9_), + static_cast<ParamGenerator<T10> >(g10_))); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const CartesianProductHolder10& other); + + const Generator1 g1_; + const Generator2 g2_; + const Generator3 g3_; + const Generator4 g4_; + const Generator5 g5_; + const Generator6 g6_; + const Generator7 g7_; + const Generator8 g8_; + const Generator9 g9_; + const Generator10 g10_; +}; // class CartesianProductHolder10 + +# endif // GTEST_HAS_COMBINE + +} // namespace internal +} // namespace testing + +#endif // GTEST_HAS_PARAM_TEST + +#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_ diff --git a/tests/gtest/include/gtest/internal/gtest-param-util-generated.h.pump b/tests/gtest/include/gtest/internal/gtest-param-util-generated.h.pump new file mode 100644 index 000000000..dbe938630 --- /dev/null +++ b/tests/gtest/include/gtest/internal/gtest-param-util-generated.h.pump @@ -0,0 +1,301 @@ +$$ -*- mode: c++; -*- +$var n = 50 $$ Maximum length of Values arguments we want to support. +$var maxtuple = 10 $$ Maximum number of Combine arguments we want to support. +// Copyright 2008 Google Inc. +// All Rights Reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Author: vladl@google.com (Vlad Losev) + +// Type and function utilities for implementing parameterized tests. +// This file is generated by a SCRIPT. DO NOT EDIT BY HAND! +// +// Currently Google Test supports at most $n arguments in Values, +// and at most $maxtuple arguments in Combine. Please contact +// googletestframework@googlegroups.com if you need more. +// Please note that the number of arguments to Combine is limited +// by the maximum arity of the implementation of tr1::tuple which is +// currently set at $maxtuple. + +#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_ +#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_ + +// scripts/fuse_gtest.py depends on gtest's own header being #included +// *unconditionally*. Therefore these #includes cannot be moved +// inside #if GTEST_HAS_PARAM_TEST. +#include "gtest/internal/gtest-param-util.h" +#include "gtest/internal/gtest-port.h" + +#if GTEST_HAS_PARAM_TEST + +namespace testing { + +// Forward declarations of ValuesIn(), which is implemented in +// include/gtest/gtest-param-test.h. +template <typename ForwardIterator> +internal::ParamGenerator< + typename ::testing::internal::IteratorTraits<ForwardIterator>::value_type> +ValuesIn(ForwardIterator begin, ForwardIterator end); + +template <typename T, size_t N> +internal::ParamGenerator<T> ValuesIn(const T (&array)[N]); + +template <class Container> +internal::ParamGenerator<typename Container::value_type> ValuesIn( + const Container& container); + +namespace internal { + +// Used in the Values() function to provide polymorphic capabilities. +template <typename T1> +class ValueArray1 { + public: + explicit ValueArray1(T1 v1) : v1_(v1) {} + + template <typename T> + operator ParamGenerator<T>() const { return ValuesIn(&v1_, &v1_ + 1); } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray1& other); + + const T1 v1_; +}; + +$range i 2..n +$for i [[ +$range j 1..i + +template <$for j, [[typename T$j]]> +class ValueArray$i { + public: + ValueArray$i($for j, [[T$j v$j]]) : $for j, [[v$(j)_(v$j)]] {} + + template <typename T> + operator ParamGenerator<T>() const { + const T array[] = {$for j, [[v$(j)_]]}; + return ValuesIn(array); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const ValueArray$i& other); + +$for j [[ + + const T$j v$(j)_; +]] + +}; + +]] + +# if GTEST_HAS_COMBINE +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// +// Generates values from the Cartesian product of values produced +// by the argument generators. +// +$range i 2..maxtuple +$for i [[ +$range j 1..i +$range k 2..i + +template <$for j, [[typename T$j]]> +class CartesianProductGenerator$i + : public ParamGeneratorInterface< ::std::tr1::tuple<$for j, [[T$j]]> > { + public: + typedef ::std::tr1::tuple<$for j, [[T$j]]> ParamType; + + CartesianProductGenerator$i($for j, [[const ParamGenerator<T$j>& g$j]]) + : $for j, [[g$(j)_(g$j)]] {} + virtual ~CartesianProductGenerator$i() {} + + virtual ParamIteratorInterface<ParamType>* Begin() const { + return new Iterator(this, $for j, [[g$(j)_, g$(j)_.begin()]]); + } + virtual ParamIteratorInterface<ParamType>* End() const { + return new Iterator(this, $for j, [[g$(j)_, g$(j)_.end()]]); + } + + private: + class Iterator : public ParamIteratorInterface<ParamType> { + public: + Iterator(const ParamGeneratorInterface<ParamType>* base, $for j, [[ + + const ParamGenerator<T$j>& g$j, + const typename ParamGenerator<T$j>::iterator& current$(j)]]) + : base_(base), +$for j, [[ + + begin$(j)_(g$j.begin()), end$(j)_(g$j.end()), current$(j)_(current$j) +]] { + ComputeCurrentValue(); + } + virtual ~Iterator() {} + + virtual const ParamGeneratorInterface<ParamType>* BaseGenerator() const { + return base_; + } + // Advance should not be called on beyond-of-range iterators + // so no component iterators must be beyond end of range, either. + virtual void Advance() { + assert(!AtEnd()); + ++current$(i)_; + +$for k [[ + if (current$(i+2-k)_ == end$(i+2-k)_) { + current$(i+2-k)_ = begin$(i+2-k)_; + ++current$(i+2-k-1)_; + } + +]] + ComputeCurrentValue(); + } + virtual ParamIteratorInterface<ParamType>* Clone() const { + return new Iterator(*this); + } + virtual const ParamType* Current() const { return ¤t_value_; } + virtual bool Equals(const ParamIteratorInterface<ParamType>& other) const { + // Having the same base generator guarantees that the other + // iterator is of the same type and we can downcast. + GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) + << "The program attempted to compare iterators " + << "from different generators." << std::endl; + const Iterator* typed_other = + CheckedDowncastToActualType<const Iterator>(&other); + // We must report iterators equal if they both point beyond their + // respective ranges. That can happen in a variety of fashions, + // so we have to consult AtEnd(). + return (AtEnd() && typed_other->AtEnd()) || + ($for j && [[ + + current$(j)_ == typed_other->current$(j)_ +]]); + } + + private: + Iterator(const Iterator& other) + : base_(other.base_), $for j, [[ + + begin$(j)_(other.begin$(j)_), + end$(j)_(other.end$(j)_), + current$(j)_(other.current$(j)_) +]] { + ComputeCurrentValue(); + } + + void ComputeCurrentValue() { + if (!AtEnd()) + current_value_ = ParamType($for j, [[*current$(j)_]]); + } + bool AtEnd() const { + // We must report iterator past the end of the range when either of the + // component iterators has reached the end of its range. + return +$for j || [[ + + current$(j)_ == end$(j)_ +]]; + } + + // No implementation - assignment is unsupported. + void operator=(const Iterator& other); + + const ParamGeneratorInterface<ParamType>* const base_; + // begin[i]_ and end[i]_ define the i-th range that Iterator traverses. + // current[i]_ is the actual traversing iterator. +$for j [[ + + const typename ParamGenerator<T$j>::iterator begin$(j)_; + const typename ParamGenerator<T$j>::iterator end$(j)_; + typename ParamGenerator<T$j>::iterator current$(j)_; +]] + + ParamType current_value_; + }; // class CartesianProductGenerator$i::Iterator + + // No implementation - assignment is unsupported. + void operator=(const CartesianProductGenerator$i& other); + + +$for j [[ + const ParamGenerator<T$j> g$(j)_; + +]] +}; // class CartesianProductGenerator$i + + +]] + +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// +// Helper classes providing Combine() with polymorphic features. They allow +// casting CartesianProductGeneratorN<T> to ParamGenerator<U> if T is +// convertible to U. +// +$range i 2..maxtuple +$for i [[ +$range j 1..i + +template <$for j, [[class Generator$j]]> +class CartesianProductHolder$i { + public: +CartesianProductHolder$i($for j, [[const Generator$j& g$j]]) + : $for j, [[g$(j)_(g$j)]] {} + template <$for j, [[typename T$j]]> + operator ParamGenerator< ::std::tr1::tuple<$for j, [[T$j]]> >() const { + return ParamGenerator< ::std::tr1::tuple<$for j, [[T$j]]> >( + new CartesianProductGenerator$i<$for j, [[T$j]]>( +$for j,[[ + + static_cast<ParamGenerator<T$j> >(g$(j)_) +]])); + } + + private: + // No implementation - assignment is unsupported. + void operator=(const CartesianProductHolder$i& other); + + +$for j [[ + const Generator$j g$(j)_; + +]] +}; // class CartesianProductHolder$i + +]] + +# endif // GTEST_HAS_COMBINE + +} // namespace internal +} // namespace testing + +#endif // GTEST_HAS_PARAM_TEST + +#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_ diff --git a/tests/gtest/include/gtest/internal/gtest-param-util.h b/tests/gtest/include/gtest/internal/gtest-param-util.h new file mode 100644 index 000000000..0ef9718cf --- /dev/null +++ b/tests/gtest/include/gtest/internal/gtest-param-util.h @@ -0,0 +1,619 @@ +// Copyright 2008 Google Inc. +// All Rights Reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Author: vladl@google.com (Vlad Losev) + +// Type and function utilities for implementing parameterized tests. + +#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_ +#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_ + +#include <iterator> +#include <utility> +#include <vector> + +// scripts/fuse_gtest.py depends on gtest's own header being #included +// *unconditionally*. Therefore these #includes cannot be moved +// inside #if GTEST_HAS_PARAM_TEST. +#include "gtest/internal/gtest-internal.h" +#include "gtest/internal/gtest-linked_ptr.h" +#include "gtest/internal/gtest-port.h" +#include "gtest/gtest-printers.h" + +#if GTEST_HAS_PARAM_TEST + +namespace testing { +namespace internal { + +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// +// Outputs a message explaining invalid registration of different +// fixture class for the same test case. This may happen when +// TEST_P macro is used to define two tests with the same name +// but in different namespaces. +GTEST_API_ void ReportInvalidTestCaseType(const char* test_case_name, + const char* file, int line); + +template <typename> class ParamGeneratorInterface; +template <typename> class ParamGenerator; + +// Interface for iterating over elements provided by an implementation +// of ParamGeneratorInterface<T>. +template <typename T> +class ParamIteratorInterface { + public: + virtual ~ParamIteratorInterface() {} + // A pointer to the base generator instance. + // Used only for the purposes of iterator comparison + // to make sure that two iterators belong to the same generator. + virtual const ParamGeneratorInterface<T>* BaseGenerator() const = 0; + // Advances iterator to point to the next element + // provided by the generator. The caller is responsible + // for not calling Advance() on an iterator equal to + // BaseGenerator()->End(). + virtual void Advance() = 0; + // Clones the iterator object. Used for implementing copy semantics + // of ParamIterator<T>. + virtual ParamIteratorInterface* Clone() const = 0; + // Dereferences the current iterator and provides (read-only) access + // to the pointed value. It is the caller's responsibility not to call + // Current() on an iterator equal to BaseGenerator()->End(). + // Used for implementing ParamGenerator<T>::operator*(). + virtual const T* Current() const = 0; + // Determines whether the given iterator and other point to the same + // element in the sequence generated by the generator. + // Used for implementing ParamGenerator<T>::operator==(). + virtual bool Equals(const ParamIteratorInterface& other) const = 0; +}; + +// Class iterating over elements provided by an implementation of +// ParamGeneratorInterface<T>. It wraps ParamIteratorInterface<T> +// and implements the const forward iterator concept. +template <typename T> +class ParamIterator { + public: + typedef T value_type; + typedef const T& reference; + typedef ptrdiff_t difference_type; + + // ParamIterator assumes ownership of the impl_ pointer. + ParamIterator(const ParamIterator& other) : impl_(other.impl_->Clone()) {} + ParamIterator& operator=(const ParamIterator& other) { + if (this != &other) + impl_.reset(other.impl_->Clone()); + return *this; + } + + const T& operator*() const { return *impl_->Current(); } + const T* operator->() const { return impl_->Current(); } + // Prefix version of operator++. + ParamIterator& operator++() { + impl_->Advance(); + return *this; + } + // Postfix version of operator++. + ParamIterator operator++(int /*unused*/) { + ParamIteratorInterface<T>* clone = impl_->Clone(); + impl_->Advance(); + return ParamIterator(clone); + } + bool operator==(const ParamIterator& other) const { + return impl_.get() == other.impl_.get() || impl_->Equals(*other.impl_); + } + bool operator!=(const ParamIterator& other) const { + return !(*this == other); + } + + private: + friend class ParamGenerator<T>; + explicit ParamIterator(ParamIteratorInterface<T>* impl) : impl_(impl) {} + scoped_ptr<ParamIteratorInterface<T> > impl_; +}; + +// ParamGeneratorInterface<T> is the binary interface to access generators +// defined in other translation units. +template <typename T> +class ParamGeneratorInterface { + public: + typedef T ParamType; + + virtual ~ParamGeneratorInterface() {} + + // Generator interface definition + virtual ParamIteratorInterface<T>* Begin() const = 0; + virtual ParamIteratorInterface<T>* End() const = 0; +}; + +// Wraps ParamGeneratorInterface<T> and provides general generator syntax +// compatible with the STL Container concept. +// This class implements copy initialization semantics and the contained +// ParamGeneratorInterface<T> instance is shared among all copies +// of the original object. This is possible because that instance is immutable. +template<typename T> +class ParamGenerator { + public: + typedef ParamIterator<T> iterator; + + explicit ParamGenerator(ParamGeneratorInterface<T>* impl) : impl_(impl) {} + ParamGenerator(const ParamGenerator& other) : impl_(other.impl_) {} + + ParamGenerator& operator=(const ParamGenerator& other) { + impl_ = other.impl_; + return *this; + } + + iterator begin() const { return iterator(impl_->Begin()); } + iterator end() const { return iterator(impl_->End()); } + + private: + linked_ptr<const ParamGeneratorInterface<T> > impl_; +}; + +// Generates values from a range of two comparable values. Can be used to +// generate sequences of user-defined types that implement operator+() and +// operator<(). +// This class is used in the Range() function. +template <typename T, typename IncrementT> +class RangeGenerator : public ParamGeneratorInterface<T> { + public: + RangeGenerator(T begin, T end, IncrementT step) + : begin_(begin), end_(end), + step_(step), end_index_(CalculateEndIndex(begin, end, step)) {} + virtual ~RangeGenerator() {} + + virtual ParamIteratorInterface<T>* Begin() const { + return new Iterator(this, begin_, 0, step_); + } + virtual ParamIteratorInterface<T>* End() const { + return new Iterator(this, end_, end_index_, step_); + } + + private: + class Iterator : public ParamIteratorInterface<T> { + public: + Iterator(const ParamGeneratorInterface<T>* base, T value, int index, + IncrementT step) + : base_(base), value_(value), index_(index), step_(step) {} + virtual ~Iterator() {} + + virtual const ParamGeneratorInterface<T>* BaseGenerator() const { + return base_; + } + virtual void Advance() { + value_ = value_ + step_; + index_++; + } + virtual ParamIteratorInterface<T>* Clone() const { + return new Iterator(*this); + } + virtual const T* Current() const { return &value_; } + virtual bool Equals(const ParamIteratorInterface<T>& other) const { + // Having the same base generator guarantees that the other + // iterator is of the same type and we can downcast. + GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) + << "The program attempted to compare iterators " + << "from different generators." << std::endl; + const int other_index = + CheckedDowncastToActualType<const Iterator>(&other)->index_; + return index_ == other_index; + } + + private: + Iterator(const Iterator& other) + : ParamIteratorInterface<T>(), + base_(other.base_), value_(other.value_), index_(other.index_), + step_(other.step_) {} + + // No implementation - assignment is unsupported. + void operator=(const Iterator& other); + + const ParamGeneratorInterface<T>* const base_; + T value_; + int index_; + const IncrementT step_; + }; // class RangeGenerator::Iterator + + static int CalculateEndIndex(const T& begin, + const T& end, + const IncrementT& step) { + int end_index = 0; + for (T i = begin; i < end; i = i + step) + end_index++; + return end_index; + } + + // No implementation - assignment is unsupported. + void operator=(const RangeGenerator& other); + + const T begin_; + const T end_; + const IncrementT step_; + // The index for the end() iterator. All the elements in the generated + // sequence are indexed (0-based) to aid iterator comparison. + const int end_index_; +}; // class RangeGenerator + + +// Generates values from a pair of STL-style iterators. Used in the +// ValuesIn() function. The elements are copied from the source range +// since the source can be located on the stack, and the generator +// is likely to persist beyond that stack frame. +template <typename T> +class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface<T> { + public: + template <typename ForwardIterator> + ValuesInIteratorRangeGenerator(ForwardIterator begin, ForwardIterator end) + : container_(begin, end) {} + virtual ~ValuesInIteratorRangeGenerator() {} + + virtual ParamIteratorInterface<T>* Begin() const { + return new Iterator(this, container_.begin()); + } + virtual ParamIteratorInterface<T>* End() const { + return new Iterator(this, container_.end()); + } + + private: + typedef typename ::std::vector<T> ContainerType; + + class Iterator : public ParamIteratorInterface<T> { + public: + Iterator(const ParamGeneratorInterface<T>* base, + typename ContainerType::const_iterator iterator) + : base_(base), iterator_(iterator) {} + virtual ~Iterator() {} + + virtual const ParamGeneratorInterface<T>* BaseGenerator() const { + return base_; + } + virtual void Advance() { + ++iterator_; + value_.reset(); + } + virtual ParamIteratorInterface<T>* Clone() const { + return new Iterator(*this); + } + // We need to use cached value referenced by iterator_ because *iterator_ + // can return a temporary object (and of type other then T), so just + // having "return &*iterator_;" doesn't work. + // value_ is updated here and not in Advance() because Advance() + // can advance iterator_ beyond the end of the range, and we cannot + // detect that fact. The client code, on the other hand, is + // responsible for not calling Current() on an out-of-range iterator. + virtual const T* Current() const { + if (value_.get() == NULL) + value_.reset(new T(*iterator_)); + return value_.get(); + } + virtual bool Equals(const ParamIteratorInterface<T>& other) const { + // Having the same base generator guarantees that the other + // iterator is of the same type and we can downcast. + GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) + << "The program attempted to compare iterators " + << "from different generators." << std::endl; + return iterator_ == + CheckedDowncastToActualType<const Iterator>(&other)->iterator_; + } + + private: + Iterator(const Iterator& other) + // The explicit constructor call suppresses a false warning + // emitted by gcc when supplied with the -Wextra option. + : ParamIteratorInterface<T>(), + base_(other.base_), + iterator_(other.iterator_) {} + + const ParamGeneratorInterface<T>* const base_; + typename ContainerType::const_iterator iterator_; + // A cached value of *iterator_. We keep it here to allow access by + // pointer in the wrapping iterator's operator->(). + // value_ needs to be mutable to be accessed in Current(). + // Use of scoped_ptr helps manage cached value's lifetime, + // which is bound by the lifespan of the iterator itself. + mutable scoped_ptr<const T> value_; + }; // class ValuesInIteratorRangeGenerator::Iterator + + // No implementation - assignment is unsupported. + void operator=(const ValuesInIteratorRangeGenerator& other); + + const ContainerType container_; +}; // class ValuesInIteratorRangeGenerator + +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// +// Stores a parameter value and later creates tests parameterized with that +// value. +template <class TestClass> +class ParameterizedTestFactory : public TestFactoryBase { + public: + typedef typename TestClass::ParamType ParamType; + explicit ParameterizedTestFactory(ParamType parameter) : + parameter_(parameter) {} + virtual Test* CreateTest() { + TestClass::SetParam(¶meter_); + return new TestClass(); + } + + private: + const ParamType parameter_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestFactory); +}; + +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// +// TestMetaFactoryBase is a base class for meta-factories that create +// test factories for passing into MakeAndRegisterTestInfo function. +template <class ParamType> +class TestMetaFactoryBase { + public: + virtual ~TestMetaFactoryBase() {} + + virtual TestFactoryBase* CreateTestFactory(ParamType parameter) = 0; +}; + +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// +// TestMetaFactory creates test factories for passing into +// MakeAndRegisterTestInfo function. Since MakeAndRegisterTestInfo receives +// ownership of test factory pointer, same factory object cannot be passed +// into that method twice. But ParameterizedTestCaseInfo is going to call +// it for each Test/Parameter value combination. Thus it needs meta factory +// creator class. +template <class TestCase> +class TestMetaFactory + : public TestMetaFactoryBase<typename TestCase::ParamType> { + public: + typedef typename TestCase::ParamType ParamType; + + TestMetaFactory() {} + + virtual TestFactoryBase* CreateTestFactory(ParamType parameter) { + return new ParameterizedTestFactory<TestCase>(parameter); + } + + private: + GTEST_DISALLOW_COPY_AND_ASSIGN_(TestMetaFactory); +}; + +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// +// ParameterizedTestCaseInfoBase is a generic interface +// to ParameterizedTestCaseInfo classes. ParameterizedTestCaseInfoBase +// accumulates test information provided by TEST_P macro invocations +// and generators provided by INSTANTIATE_TEST_CASE_P macro invocations +// and uses that information to register all resulting test instances +// in RegisterTests method. The ParameterizeTestCaseRegistry class holds +// a collection of pointers to the ParameterizedTestCaseInfo objects +// and calls RegisterTests() on each of them when asked. +class ParameterizedTestCaseInfoBase { + public: + virtual ~ParameterizedTestCaseInfoBase() {} + + // Base part of test case name for display purposes. + virtual const string& GetTestCaseName() const = 0; + // Test case id to verify identity. + virtual TypeId GetTestCaseTypeId() const = 0; + // UnitTest class invokes this method to register tests in this + // test case right before running them in RUN_ALL_TESTS macro. + // This method should not be called more then once on any single + // instance of a ParameterizedTestCaseInfoBase derived class. + virtual void RegisterTests() = 0; + + protected: + ParameterizedTestCaseInfoBase() {} + + private: + GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfoBase); +}; + +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// +// ParameterizedTestCaseInfo accumulates tests obtained from TEST_P +// macro invocations for a particular test case and generators +// obtained from INSTANTIATE_TEST_CASE_P macro invocations for that +// test case. It registers tests with all values generated by all +// generators when asked. +template <class TestCase> +class ParameterizedTestCaseInfo : public ParameterizedTestCaseInfoBase { + public: + // ParamType and GeneratorCreationFunc are private types but are required + // for declarations of public methods AddTestPattern() and + // AddTestCaseInstantiation(). + typedef typename TestCase::ParamType ParamType; + // A function that returns an instance of appropriate generator type. + typedef ParamGenerator<ParamType>(GeneratorCreationFunc)(); + + explicit ParameterizedTestCaseInfo(const char* name) + : test_case_name_(name) {} + + // Test case base name for display purposes. + virtual const string& GetTestCaseName() const { return test_case_name_; } + // Test case id to verify identity. + virtual TypeId GetTestCaseTypeId() const { return GetTypeId<TestCase>(); } + // TEST_P macro uses AddTestPattern() to record information + // about a single test in a LocalTestInfo structure. + // test_case_name is the base name of the test case (without invocation + // prefix). test_base_name is the name of an individual test without + // parameter index. For the test SequenceA/FooTest.DoBar/1 FooTest is + // test case base name and DoBar is test base name. + void AddTestPattern(const char* test_case_name, + const char* test_base_name, + TestMetaFactoryBase<ParamType>* meta_factory) { + tests_.push_back(linked_ptr<TestInfo>(new TestInfo(test_case_name, + test_base_name, + meta_factory))); + } + // INSTANTIATE_TEST_CASE_P macro uses AddGenerator() to record information + // about a generator. + int AddTestCaseInstantiation(const string& instantiation_name, + GeneratorCreationFunc* func, + const char* /* file */, + int /* line */) { + instantiations_.push_back(::std::make_pair(instantiation_name, func)); + return 0; // Return value used only to run this method in namespace scope. + } + // UnitTest class invokes this method to register tests in this test case + // test cases right before running tests in RUN_ALL_TESTS macro. + // This method should not be called more then once on any single + // instance of a ParameterizedTestCaseInfoBase derived class. + // UnitTest has a guard to prevent from calling this method more then once. + virtual void RegisterTests() { + for (typename TestInfoContainer::iterator test_it = tests_.begin(); + test_it != tests_.end(); ++test_it) { + linked_ptr<TestInfo> test_info = *test_it; + for (typename InstantiationContainer::iterator gen_it = + instantiations_.begin(); gen_it != instantiations_.end(); + ++gen_it) { + const string& instantiation_name = gen_it->first; + ParamGenerator<ParamType> generator((*gen_it->second)()); + + Message test_case_name_stream; + if ( !instantiation_name.empty() ) + test_case_name_stream << instantiation_name << "/"; + test_case_name_stream << test_info->test_case_base_name; + + int i = 0; + for (typename ParamGenerator<ParamType>::iterator param_it = + generator.begin(); + param_it != generator.end(); ++param_it, ++i) { + Message test_name_stream; + test_name_stream << test_info->test_base_name << "/" << i; + MakeAndRegisterTestInfo( + test_case_name_stream.GetString().c_str(), + test_name_stream.GetString().c_str(), + NULL, // No type parameter. + PrintToString(*param_it).c_str(), + GetTestCaseTypeId(), + TestCase::SetUpTestCase, + TestCase::TearDownTestCase, + test_info->test_meta_factory->CreateTestFactory(*param_it)); + } // for param_it + } // for gen_it + } // for test_it + } // RegisterTests + + private: + // LocalTestInfo structure keeps information about a single test registered + // with TEST_P macro. + struct TestInfo { + TestInfo(const char* a_test_case_base_name, + const char* a_test_base_name, + TestMetaFactoryBase<ParamType>* a_test_meta_factory) : + test_case_base_name(a_test_case_base_name), + test_base_name(a_test_base_name), + test_meta_factory(a_test_meta_factory) {} + + const string test_case_base_name; + const string test_base_name; + const scoped_ptr<TestMetaFactoryBase<ParamType> > test_meta_factory; + }; + typedef ::std::vector<linked_ptr<TestInfo> > TestInfoContainer; + // Keeps pairs of <Instantiation name, Sequence generator creation function> + // received from INSTANTIATE_TEST_CASE_P macros. + typedef ::std::vector<std::pair<string, GeneratorCreationFunc*> > + InstantiationContainer; + + const string test_case_name_; + TestInfoContainer tests_; + InstantiationContainer instantiations_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfo); +}; // class ParameterizedTestCaseInfo + +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// +// ParameterizedTestCaseRegistry contains a map of ParameterizedTestCaseInfoBase +// classes accessed by test case names. TEST_P and INSTANTIATE_TEST_CASE_P +// macros use it to locate their corresponding ParameterizedTestCaseInfo +// descriptors. +class ParameterizedTestCaseRegistry { + public: + ParameterizedTestCaseRegistry() {} + ~ParameterizedTestCaseRegistry() { + for (TestCaseInfoContainer::iterator it = test_case_infos_.begin(); + it != test_case_infos_.end(); ++it) { + delete *it; + } + } + + // Looks up or creates and returns a structure containing information about + // tests and instantiations of a particular test case. + template <class TestCase> + ParameterizedTestCaseInfo<TestCase>* GetTestCasePatternHolder( + const char* test_case_name, + const char* file, + int line) { + ParameterizedTestCaseInfo<TestCase>* typed_test_info = NULL; + for (TestCaseInfoContainer::iterator it = test_case_infos_.begin(); + it != test_case_infos_.end(); ++it) { + if ((*it)->GetTestCaseName() == test_case_name) { + if ((*it)->GetTestCaseTypeId() != GetTypeId<TestCase>()) { + // Complain about incorrect usage of Google Test facilities + // and terminate the program since we cannot guaranty correct + // test case setup and tear-down in this case. + ReportInvalidTestCaseType(test_case_name, file, line); + posix::Abort(); + } else { + // At this point we are sure that the object we found is of the same + // type we are looking for, so we downcast it to that type + // without further checks. + typed_test_info = CheckedDowncastToActualType< + ParameterizedTestCaseInfo<TestCase> >(*it); + } + break; + } + } + if (typed_test_info == NULL) { + typed_test_info = new ParameterizedTestCaseInfo<TestCase>(test_case_name); + test_case_infos_.push_back(typed_test_info); + } + return typed_test_info; + } + void RegisterTests() { + for (TestCaseInfoContainer::iterator it = test_case_infos_.begin(); + it != test_case_infos_.end(); ++it) { + (*it)->RegisterTests(); + } + } + + private: + typedef ::std::vector<ParameterizedTestCaseInfoBase*> TestCaseInfoContainer; + + TestCaseInfoContainer test_case_infos_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseRegistry); +}; + +} // namespace internal +} // namespace testing + +#endif // GTEST_HAS_PARAM_TEST + +#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_ diff --git a/tests/gtest/include/gtest/internal/gtest-port.h b/tests/gtest/include/gtest/internal/gtest-port.h new file mode 100644 index 000000000..157b47f86 --- /dev/null +++ b/tests/gtest/include/gtest/internal/gtest-port.h @@ -0,0 +1,1775 @@ +// Copyright 2005, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Authors: wan@google.com (Zhanyong Wan) +// +// Low-level types and utilities for porting Google Test to various +// platforms. They are subject to change without notice. DO NOT USE +// THEM IN USER CODE. + +#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ +#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ + +// The user can define the following macros in the build script to +// control Google Test's behavior. If the user doesn't define a macro +// in this list, Google Test will define it. +// +// GTEST_HAS_CLONE - Define it to 1/0 to indicate that clone(2) +// is/isn't available. +// GTEST_HAS_EXCEPTIONS - Define it to 1/0 to indicate that exceptions +// are enabled. +// GTEST_HAS_GLOBAL_STRING - Define it to 1/0 to indicate that ::string +// is/isn't available (some systems define +// ::string, which is different to std::string). +// GTEST_HAS_GLOBAL_WSTRING - Define it to 1/0 to indicate that ::string +// is/isn't available (some systems define +// ::wstring, which is different to std::wstring). +// GTEST_HAS_POSIX_RE - Define it to 1/0 to indicate that POSIX regular +// expressions are/aren't available. +// GTEST_HAS_PTHREAD - Define it to 1/0 to indicate that <pthread.h> +// is/isn't available. +// GTEST_HAS_RTTI - Define it to 1/0 to indicate that RTTI is/isn't +// enabled. +// GTEST_HAS_STD_WSTRING - Define it to 1/0 to indicate that +// std::wstring does/doesn't work (Google Test can +// be used where std::wstring is unavailable). +// GTEST_HAS_TR1_TUPLE - Define it to 1/0 to indicate tr1::tuple +// is/isn't available. +// GTEST_HAS_SEH - Define it to 1/0 to indicate whether the +// compiler supports Microsoft's "Structured +// Exception Handling". +// GTEST_HAS_STREAM_REDIRECTION +// - Define it to 1/0 to indicate whether the +// platform supports I/O stream redirection using +// dup() and dup2(). +// GTEST_USE_OWN_TR1_TUPLE - Define it to 1/0 to indicate whether Google +// Test's own tr1 tuple implementation should be +// used. Unused when the user sets +// GTEST_HAS_TR1_TUPLE to 0. +// GTEST_LINKED_AS_SHARED_LIBRARY +// - Define to 1 when compiling tests that use +// Google Test as a shared library (known as +// DLL on Windows). +// GTEST_CREATE_SHARED_LIBRARY +// - Define to 1 when compiling Google Test itself +// as a shared library. + +// This header defines the following utilities: +// +// Macros indicating the current platform (defined to 1 if compiled on +// the given platform; otherwise undefined): +// GTEST_OS_AIX - IBM AIX +// GTEST_OS_CYGWIN - Cygwin +// GTEST_OS_HPUX - HP-UX +// GTEST_OS_LINUX - Linux +// GTEST_OS_LINUX_ANDROID - Google Android +// GTEST_OS_MAC - Mac OS X +// GTEST_OS_NACL - Google Native Client (NaCl) +// GTEST_OS_SOLARIS - Sun Solaris +// GTEST_OS_SYMBIAN - Symbian +// GTEST_OS_WINDOWS - Windows (Desktop, MinGW, or Mobile) +// GTEST_OS_WINDOWS_DESKTOP - Windows Desktop +// GTEST_OS_WINDOWS_MINGW - MinGW +// GTEST_OS_WINDOWS_MOBILE - Windows Mobile +// GTEST_OS_ZOS - z/OS +// +// Among the platforms, Cygwin, Linux, Max OS X, and Windows have the +// most stable support. Since core members of the Google Test project +// don't have access to other platforms, support for them may be less +// stable. If you notice any problems on your platform, please notify +// googletestframework@googlegroups.com (patches for fixing them are +// even more welcome!). +// +// Note that it is possible that none of the GTEST_OS_* macros are defined. +// +// Macros indicating available Google Test features (defined to 1 if +// the corresponding feature is supported; otherwise undefined): +// GTEST_HAS_COMBINE - the Combine() function (for value-parameterized +// tests) +// GTEST_HAS_DEATH_TEST - death tests +// GTEST_HAS_PARAM_TEST - value-parameterized tests +// GTEST_HAS_TYPED_TEST - typed tests +// GTEST_HAS_TYPED_TEST_P - type-parameterized tests +// GTEST_USES_POSIX_RE - enhanced POSIX regex is used. Do not confuse with +// GTEST_HAS_POSIX_RE (see above) which users can +// define themselves. +// GTEST_USES_SIMPLE_RE - our own simple regex is used; +// the above two are mutually exclusive. +// GTEST_CAN_COMPARE_NULL - accepts untyped NULL in EXPECT_EQ(). +// +// Macros for basic C++ coding: +// GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning. +// GTEST_ATTRIBUTE_UNUSED_ - declares that a class' instances or a +// variable don't have to be used. +// GTEST_DISALLOW_ASSIGN_ - disables operator=. +// GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=. +// GTEST_MUST_USE_RESULT_ - declares that a function's result must be used. +// +// Synchronization: +// Mutex, MutexLock, ThreadLocal, GetThreadCount() +// - synchronization primitives. +// GTEST_IS_THREADSAFE - defined to 1 to indicate that the above +// synchronization primitives have real implementations +// and Google Test is thread-safe; or 0 otherwise. +// +// Template meta programming: +// is_pointer - as in TR1; needed on Symbian and IBM XL C/C++ only. +// IteratorTraits - partial implementation of std::iterator_traits, which +// is not available in libCstd when compiled with Sun C++. +// +// Smart pointers: +// scoped_ptr - as in TR2. +// +// Regular expressions: +// RE - a simple regular expression class using the POSIX +// Extended Regular Expression syntax on UNIX-like +// platforms, or a reduced regular exception syntax on +// other platforms, including Windows. +// +// Logging: +// GTEST_LOG_() - logs messages at the specified severity level. +// LogToStderr() - directs all log messages to stderr. +// FlushInfoLog() - flushes informational log messages. +// +// Stdout and stderr capturing: +// CaptureStdout() - starts capturing stdout. +// GetCapturedStdout() - stops capturing stdout and returns the captured +// string. +// CaptureStderr() - starts capturing stderr. +// GetCapturedStderr() - stops capturing stderr and returns the captured +// string. +// +// Integer types: +// TypeWithSize - maps an integer to a int type. +// Int32, UInt32, Int64, UInt64, TimeInMillis +// - integers of known sizes. +// BiggestInt - the biggest signed integer type. +// +// Command-line utilities: +// GTEST_FLAG() - references a flag. +// GTEST_DECLARE_*() - declares a flag. +// GTEST_DEFINE_*() - defines a flag. +// GetArgvs() - returns the command line as a vector of strings. +// +// Environment variable utilities: +// GetEnv() - gets the value of an environment variable. +// BoolFromGTestEnv() - parses a bool environment variable. +// Int32FromGTestEnv() - parses an Int32 environment variable. +// StringFromGTestEnv() - parses a string environment variable. + +#include <ctype.h> // for isspace, etc +#include <stddef.h> // for ptrdiff_t +#include <stdlib.h> +#include <stdio.h> +#include <string.h> +#ifndef _WIN32_WCE +# include <sys/types.h> +# include <sys/stat.h> +#endif // !_WIN32_WCE + +#include <iostream> // NOLINT +#include <sstream> // NOLINT +#include <string> // NOLINT + +#define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com" +#define GTEST_FLAG_PREFIX_ "gtest_" +#define GTEST_FLAG_PREFIX_DASH_ "gtest-" +#define GTEST_FLAG_PREFIX_UPPER_ "GTEST_" +#define GTEST_NAME_ "Google Test" +#define GTEST_PROJECT_URL_ "http://code.google.com/p/googletest/" + +// Determines the version of gcc that is used to compile this. +#ifdef __GNUC__ +// 40302 means version 4.3.2. +# define GTEST_GCC_VER_ \ + (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__) +#endif // __GNUC__ + +// Determines the platform on which Google Test is compiled. +#ifdef __CYGWIN__ +# define GTEST_OS_CYGWIN 1 +#elif defined __SYMBIAN32__ +# define GTEST_OS_SYMBIAN 1 +#elif defined _WIN32 +# define GTEST_OS_WINDOWS 1 +# ifdef _WIN32_WCE +# define GTEST_OS_WINDOWS_MOBILE 1 +# elif defined(__MINGW__) || defined(__MINGW32__) +# define GTEST_OS_WINDOWS_MINGW 1 +# else +# define GTEST_OS_WINDOWS_DESKTOP 1 +# endif // _WIN32_WCE +#elif defined __APPLE__ +# define GTEST_OS_MAC 1 +#elif defined __linux__ +# define GTEST_OS_LINUX 1 +# ifdef ANDROID +# define GTEST_OS_LINUX_ANDROID 1 +# endif // ANDROID +#elif defined __MVS__ +# define GTEST_OS_ZOS 1 +#elif defined(__sun) && defined(__SVR4) +# define GTEST_OS_SOLARIS 1 +#elif defined(_AIX) +# define GTEST_OS_AIX 1 +#elif defined(__hpux) +# define GTEST_OS_HPUX 1 +#elif defined __native_client__ +# define GTEST_OS_NACL 1 +#endif // __CYGWIN__ + +// Brings in definitions for functions used in the testing::internal::posix +// namespace (read, write, close, chdir, isatty, stat). We do not currently +// use them on Windows Mobile. +#if !GTEST_OS_WINDOWS +// This assumes that non-Windows OSes provide unistd.h. For OSes where this +// is not the case, we need to include headers that provide the functions +// mentioned above. +# include <unistd.h> +# if !GTEST_OS_NACL +// TODO(vladl@google.com): Remove this condition when Native Client SDK adds +// strings.h (tracked in +// http://code.google.com/p/nativeclient/issues/detail?id=1175). +# include <strings.h> // Native Client doesn't provide strings.h. +# endif +#elif !GTEST_OS_WINDOWS_MOBILE +# include <direct.h> +# include <io.h> +#endif + +// Defines this to true iff Google Test can use POSIX regular expressions. +#ifndef GTEST_HAS_POSIX_RE +# define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS) +#endif + +#if GTEST_HAS_POSIX_RE + +// On some platforms, <regex.h> needs someone to define size_t, and +// won't compile otherwise. We can #include it here as we already +// included <stdlib.h>, which is guaranteed to define size_t through +// <stddef.h>. +# include <regex.h> // NOLINT + +# define GTEST_USES_POSIX_RE 1 + +#elif GTEST_OS_WINDOWS + +// <regex.h> is not available on Windows. Use our own simple regex +// implementation instead. +# define GTEST_USES_SIMPLE_RE 1 + +#else + +// <regex.h> may not be available on this platform. Use our own +// simple regex implementation instead. +# define GTEST_USES_SIMPLE_RE 1 + +#endif // GTEST_HAS_POSIX_RE + +#ifndef GTEST_HAS_EXCEPTIONS +// The user didn't tell us whether exceptions are enabled, so we need +// to figure it out. +# if defined(_MSC_VER) || defined(__BORLANDC__) +// MSVC's and C++Builder's implementations of the STL use the _HAS_EXCEPTIONS +// macro to enable exceptions, so we'll do the same. +// Assumes that exceptions are enabled by default. +# ifndef _HAS_EXCEPTIONS +# define _HAS_EXCEPTIONS 1 +# endif // _HAS_EXCEPTIONS +# define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS +# elif defined(__GNUC__) && __EXCEPTIONS +// gcc defines __EXCEPTIONS to 1 iff exceptions are enabled. +# define GTEST_HAS_EXCEPTIONS 1 +# elif defined(__SUNPRO_CC) +// Sun Pro CC supports exceptions. However, there is no compile-time way of +// detecting whether they are enabled or not. Therefore, we assume that +// they are enabled unless the user tells us otherwise. +# define GTEST_HAS_EXCEPTIONS 1 +# elif defined(__IBMCPP__) && __EXCEPTIONS +// xlC defines __EXCEPTIONS to 1 iff exceptions are enabled. +# define GTEST_HAS_EXCEPTIONS 1 +# elif defined(__HP_aCC) +// Exception handling is in effect by default in HP aCC compiler. It has to +// be turned of by +noeh compiler option if desired. +# define GTEST_HAS_EXCEPTIONS 1 +# else +// For other compilers, we assume exceptions are disabled to be +// conservative. +# define GTEST_HAS_EXCEPTIONS 0 +# endif // defined(_MSC_VER) || defined(__BORLANDC__) +#endif // GTEST_HAS_EXCEPTIONS + +#if !defined(GTEST_HAS_STD_STRING) +// Even though we don't use this macro any longer, we keep it in case +// some clients still depend on it. +# define GTEST_HAS_STD_STRING 1 +#elif !GTEST_HAS_STD_STRING +// The user told us that ::std::string isn't available. +# error "Google Test cannot be used where ::std::string isn't available." +#endif // !defined(GTEST_HAS_STD_STRING) + +#ifndef GTEST_HAS_GLOBAL_STRING +// The user didn't tell us whether ::string is available, so we need +// to figure it out. + +# define GTEST_HAS_GLOBAL_STRING 0 + +#endif // GTEST_HAS_GLOBAL_STRING + +#ifndef GTEST_HAS_STD_WSTRING +// The user didn't tell us whether ::std::wstring is available, so we need +// to figure it out. +// TODO(wan@google.com): uses autoconf to detect whether ::std::wstring +// is available. + +// Cygwin 1.7 and below doesn't support ::std::wstring. +// Solaris' libc++ doesn't support it either. Android has +// no support for it at least as recent as Froyo (2.2). +# define GTEST_HAS_STD_WSTRING \ + (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS)) + +#endif // GTEST_HAS_STD_WSTRING + +#ifndef GTEST_HAS_GLOBAL_WSTRING +// The user didn't tell us whether ::wstring is available, so we need +// to figure it out. +# define GTEST_HAS_GLOBAL_WSTRING \ + (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING) +#endif // GTEST_HAS_GLOBAL_WSTRING + +// Determines whether RTTI is available. +#ifndef GTEST_HAS_RTTI +// The user didn't tell us whether RTTI is enabled, so we need to +// figure it out. + +# ifdef _MSC_VER + +# ifdef _CPPRTTI // MSVC defines this macro iff RTTI is enabled. +# define GTEST_HAS_RTTI 1 +# else +# define GTEST_HAS_RTTI 0 +# endif + +// Starting with version 4.3.2, gcc defines __GXX_RTTI iff RTTI is enabled. +# elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40302) + +# ifdef __GXX_RTTI +# define GTEST_HAS_RTTI 1 +# else +# define GTEST_HAS_RTTI 0 +# endif // __GXX_RTTI + +// Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if +// both the typeid and dynamic_cast features are present. +# elif defined(__IBMCPP__) && (__IBMCPP__ >= 900) + +# ifdef __RTTI_ALL__ +# define GTEST_HAS_RTTI 1 +# else +# define GTEST_HAS_RTTI 0 +# endif + +# else + +// For all other compilers, we assume RTTI is enabled. +# define GTEST_HAS_RTTI 1 + +# endif // _MSC_VER + +#endif // GTEST_HAS_RTTI + +// It's this header's responsibility to #include <typeinfo> when RTTI +// is enabled. +#if GTEST_HAS_RTTI +# include <typeinfo> +#endif + +// Determines whether Google Test can use the pthreads library. +#ifndef GTEST_HAS_PTHREAD +// The user didn't tell us explicitly, so we assume pthreads support is +// available on Linux and Mac. +// +// To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0 +// to your compiler flags. +# define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX) +#endif // GTEST_HAS_PTHREAD + +#if GTEST_HAS_PTHREAD +// gtest-port.h guarantees to #include <pthread.h> when GTEST_HAS_PTHREAD is +// true. +# include <pthread.h> // NOLINT + +// For timespec and nanosleep, used below. +# include <time.h> // NOLINT +#endif + +// Determines whether Google Test can use tr1/tuple. You can define +// this macro to 0 to prevent Google Test from using tuple (any +// feature depending on tuple with be disabled in this mode). +#ifndef GTEST_HAS_TR1_TUPLE +// The user didn't tell us not to do it, so we assume it's OK. +# define GTEST_HAS_TR1_TUPLE 1 +#endif // GTEST_HAS_TR1_TUPLE + +// Determines whether Google Test's own tr1 tuple implementation +// should be used. +#ifndef GTEST_USE_OWN_TR1_TUPLE +// The user didn't tell us, so we need to figure it out. + +// We use our own TR1 tuple if we aren't sure the user has an +// implementation of it already. At this time, GCC 4.0.0+ and MSVC +// 2010 are the only mainstream compilers that come with a TR1 tuple +// implementation. NVIDIA's CUDA NVCC compiler pretends to be GCC by +// defining __GNUC__ and friends, but cannot compile GCC's tuple +// implementation. MSVC 2008 (9.0) provides TR1 tuple in a 323 MB +// Feature Pack download, which we cannot assume the user has. +# if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000)) \ + || _MSC_VER >= 1600 +# define GTEST_USE_OWN_TR1_TUPLE 0 +# else +# define GTEST_USE_OWN_TR1_TUPLE 1 +# endif + +#endif // GTEST_USE_OWN_TR1_TUPLE + +// To avoid conditional compilation everywhere, we make it +// gtest-port.h's responsibility to #include the header implementing +// tr1/tuple. +#if GTEST_HAS_TR1_TUPLE + +# if GTEST_USE_OWN_TR1_TUPLE +# include "gtest/internal/gtest-tuple.h" +# elif GTEST_OS_SYMBIAN + +// On Symbian, BOOST_HAS_TR1_TUPLE causes Boost's TR1 tuple library to +// use STLport's tuple implementation, which unfortunately doesn't +// work as the copy of STLport distributed with Symbian is incomplete. +// By making sure BOOST_HAS_TR1_TUPLE is undefined, we force Boost to +// use its own tuple implementation. +# ifdef BOOST_HAS_TR1_TUPLE +# undef BOOST_HAS_TR1_TUPLE +# endif // BOOST_HAS_TR1_TUPLE + +// This prevents <boost/tr1/detail/config.hpp>, which defines +// BOOST_HAS_TR1_TUPLE, from being #included by Boost's <tuple>. +# define BOOST_TR1_DETAIL_CONFIG_HPP_INCLUDED +# include <tuple> + +# elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000) +// GCC 4.0+ implements tr1/tuple in the <tr1/tuple> header. This does +// not conform to the TR1 spec, which requires the header to be <tuple>. + +# if !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302 +// Until version 4.3.2, gcc has a bug that causes <tr1/functional>, +// which is #included by <tr1/tuple>, to not compile when RTTI is +// disabled. _TR1_FUNCTIONAL is the header guard for +// <tr1/functional>. Hence the following #define is a hack to prevent +// <tr1/functional> from being included. +# define _TR1_FUNCTIONAL 1 +# include <tr1/tuple> +# undef _TR1_FUNCTIONAL // Allows the user to #include + // <tr1/functional> if he chooses to. +# else +# include <tr1/tuple> // NOLINT +# endif // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302 + +# else +// If the compiler is not GCC 4.0+, we assume the user is using a +// spec-conforming TR1 implementation. +# include <tuple> // NOLINT +# endif // GTEST_USE_OWN_TR1_TUPLE + +#endif // GTEST_HAS_TR1_TUPLE + +// Determines whether clone(2) is supported. +// Usually it will only be available on Linux, excluding +// Linux on the Itanium architecture. +// Also see http://linux.die.net/man/2/clone. +#ifndef GTEST_HAS_CLONE +// The user didn't tell us, so we need to figure it out. + +# if GTEST_OS_LINUX && !defined(__ia64__) +# define GTEST_HAS_CLONE 1 +# else +# define GTEST_HAS_CLONE 0 +# endif // GTEST_OS_LINUX && !defined(__ia64__) + +#endif // GTEST_HAS_CLONE + +// Determines whether to support stream redirection. This is used to test +// output correctness and to implement death tests. +#ifndef GTEST_HAS_STREAM_REDIRECTION +// By default, we assume that stream redirection is supported on all +// platforms except known mobile ones. +# if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN +# define GTEST_HAS_STREAM_REDIRECTION 0 +# else +# define GTEST_HAS_STREAM_REDIRECTION 1 +# endif // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_SYMBIAN +#endif // GTEST_HAS_STREAM_REDIRECTION + +// Determines whether to support death tests. +// Google Test does not support death tests for VC 7.1 and earlier as +// abort() in a VC 7.1 application compiled as GUI in debug config +// pops up a dialog window that cannot be suppressed programmatically. +#if (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \ + (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || \ + GTEST_OS_WINDOWS_MINGW || GTEST_OS_AIX || GTEST_OS_HPUX) +# define GTEST_HAS_DEATH_TEST 1 +# include <vector> // NOLINT +#endif + +// We don't support MSVC 7.1 with exceptions disabled now. Therefore +// all the compilers we care about are adequate for supporting +// value-parameterized tests. +#define GTEST_HAS_PARAM_TEST 1 + +// Determines whether to support type-driven tests. + +// Typed tests need <typeinfo> and variadic macros, which GCC, VC++ 8.0, +// Sun Pro CC, IBM Visual Age, and HP aCC support. +#if defined(__GNUC__) || (_MSC_VER >= 1400) || defined(__SUNPRO_CC) || \ + defined(__IBMCPP__) || defined(__HP_aCC) +# define GTEST_HAS_TYPED_TEST 1 +# define GTEST_HAS_TYPED_TEST_P 1 +#endif + +// Determines whether to support Combine(). This only makes sense when +// value-parameterized tests are enabled. The implementation doesn't +// work on Sun Studio since it doesn't understand templated conversion +// operators. +#if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE && !defined(__SUNPRO_CC) +# define GTEST_HAS_COMBINE 1 +#endif + +// Determines whether the system compiler uses UTF-16 for encoding wide strings. +#define GTEST_WIDE_STRING_USES_UTF16_ \ + (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN || GTEST_OS_AIX) + +// Determines whether test results can be streamed to a socket. +#if GTEST_OS_LINUX +# define GTEST_CAN_STREAM_RESULTS_ 1 +#endif + +// Defines some utility macros. + +// The GNU compiler emits a warning if nested "if" statements are followed by +// an "else" statement and braces are not used to explicitly disambiguate the +// "else" binding. This leads to problems with code like: +// +// if (gate) +// ASSERT_*(condition) << "Some message"; +// +// The "switch (0) case 0:" idiom is used to suppress this. +#ifdef __INTEL_COMPILER +# define GTEST_AMBIGUOUS_ELSE_BLOCKER_ +#else +# define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: default: // NOLINT +#endif + +// Use this annotation at the end of a struct/class definition to +// prevent the compiler from optimizing away instances that are never +// used. This is useful when all interesting logic happens inside the +// c'tor and / or d'tor. Example: +// +// struct Foo { +// Foo() { ... } +// } GTEST_ATTRIBUTE_UNUSED_; +// +// Also use it after a variable or parameter declaration to tell the +// compiler the variable/parameter does not have to be used. +#if defined(__GNUC__) && !defined(COMPILER_ICC) +# define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused)) +#else +# define GTEST_ATTRIBUTE_UNUSED_ +#endif + +// A macro to disallow operator= +// This should be used in the private: declarations for a class. +#define GTEST_DISALLOW_ASSIGN_(type)\ + void operator=(type const &) + +// A macro to disallow copy constructor and operator= +// This should be used in the private: declarations for a class. +#define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\ + type(type const &);\ + GTEST_DISALLOW_ASSIGN_(type) + +// Tell the compiler to warn about unused return values for functions declared +// with this macro. The macro should be used on function declarations +// following the argument list: +// +// Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_; +#if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC) +# define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result)) +#else +# define GTEST_MUST_USE_RESULT_ +#endif // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC + +// Determine whether the compiler supports Microsoft's Structured Exception +// Handling. This is supported by several Windows compilers but generally +// does not exist on any other system. +#ifndef GTEST_HAS_SEH +// The user didn't tell us, so we need to figure it out. + +# if defined(_MSC_VER) || defined(__BORLANDC__) +// These two compilers are known to support SEH. +# define GTEST_HAS_SEH 1 +# else +// Assume no SEH. +# define GTEST_HAS_SEH 0 +# endif + +#endif // GTEST_HAS_SEH + +#ifdef _MSC_VER + +# if GTEST_LINKED_AS_SHARED_LIBRARY +# define GTEST_API_ __declspec(dllimport) +# elif GTEST_CREATE_SHARED_LIBRARY +# define GTEST_API_ __declspec(dllexport) +# endif + +#endif // _MSC_VER + +#ifndef GTEST_API_ +# define GTEST_API_ +#endif + +#ifdef __GNUC__ +// Ask the compiler to never inline a given function. +# define GTEST_NO_INLINE_ __attribute__((noinline)) +#else +# define GTEST_NO_INLINE_ +#endif + +namespace testing { + +class Message; + +namespace internal { + +class String; + +// The GTEST_COMPILE_ASSERT_ macro can be used to verify that a compile time +// expression is true. For example, you could use it to verify the +// size of a static array: +// +// GTEST_COMPILE_ASSERT_(ARRAYSIZE(content_type_names) == CONTENT_NUM_TYPES, +// content_type_names_incorrect_size); +// +// or to make sure a struct is smaller than a certain size: +// +// GTEST_COMPILE_ASSERT_(sizeof(foo) < 128, foo_too_large); +// +// The second argument to the macro is the name of the variable. If +// the expression is false, most compilers will issue a warning/error +// containing the name of the variable. + +template <bool> +struct CompileAssert { +}; + +#define GTEST_COMPILE_ASSERT_(expr, msg) \ + typedef ::testing::internal::CompileAssert<(bool(expr))> \ + msg[bool(expr) ? 1 : -1] + +// Implementation details of GTEST_COMPILE_ASSERT_: +// +// - GTEST_COMPILE_ASSERT_ works by defining an array type that has -1 +// elements (and thus is invalid) when the expression is false. +// +// - The simpler definition +// +// #define GTEST_COMPILE_ASSERT_(expr, msg) typedef char msg[(expr) ? 1 : -1] +// +// does not work, as gcc supports variable-length arrays whose sizes +// are determined at run-time (this is gcc's extension and not part +// of the C++ standard). As a result, gcc fails to reject the +// following code with the simple definition: +// +// int foo; +// GTEST_COMPILE_ASSERT_(foo, msg); // not supposed to compile as foo is +// // not a compile-time constant. +// +// - By using the type CompileAssert<(bool(expr))>, we ensures that +// expr is a compile-time constant. (Template arguments must be +// determined at compile-time.) +// +// - The outter parentheses in CompileAssert<(bool(expr))> are necessary +// to work around a bug in gcc 3.4.4 and 4.0.1. If we had written +// +// CompileAssert<bool(expr)> +// +// instead, these compilers will refuse to compile +// +// GTEST_COMPILE_ASSERT_(5 > 0, some_message); +// +// (They seem to think the ">" in "5 > 0" marks the end of the +// template argument list.) +// +// - The array size is (bool(expr) ? 1 : -1), instead of simply +// +// ((expr) ? 1 : -1). +// +// This is to avoid running into a bug in MS VC 7.1, which +// causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1. + +// StaticAssertTypeEqHelper is used by StaticAssertTypeEq defined in gtest.h. +// +// This template is declared, but intentionally undefined. +template <typename T1, typename T2> +struct StaticAssertTypeEqHelper; + +template <typename T> +struct StaticAssertTypeEqHelper<T, T> {}; + +#if GTEST_HAS_GLOBAL_STRING +typedef ::string string; +#else +typedef ::std::string string; +#endif // GTEST_HAS_GLOBAL_STRING + +#if GTEST_HAS_GLOBAL_WSTRING +typedef ::wstring wstring; +#elif GTEST_HAS_STD_WSTRING +typedef ::std::wstring wstring; +#endif // GTEST_HAS_GLOBAL_WSTRING + +// A helper for suppressing warnings on constant condition. It just +// returns 'condition'. +GTEST_API_ bool IsTrue(bool condition); + +// Defines scoped_ptr. + +// This implementation of scoped_ptr is PARTIAL - it only contains +// enough stuff to satisfy Google Test's need. +template <typename T> +class scoped_ptr { + public: + typedef T element_type; + + explicit scoped_ptr(T* p = NULL) : ptr_(p) {} + ~scoped_ptr() { reset(); } + + T& operator*() const { return *ptr_; } + T* operator->() const { return ptr_; } + T* get() const { return ptr_; } + + T* release() { + T* const ptr = ptr_; + ptr_ = NULL; + return ptr; + } + + void reset(T* p = NULL) { + if (p != ptr_) { + if (IsTrue(sizeof(T) > 0)) { // Makes sure T is a complete type. + delete ptr_; + } + ptr_ = p; + } + } + private: + T* ptr_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr); +}; + +// Defines RE. + +// A simple C++ wrapper for <regex.h>. It uses the POSIX Extended +// Regular Expression syntax. +class GTEST_API_ RE { + public: + // A copy constructor is required by the Standard to initialize object + // references from r-values. + RE(const RE& other) { Init(other.pattern()); } + + // Constructs an RE from a string. + RE(const ::std::string& regex) { Init(regex.c_str()); } // NOLINT + +#if GTEST_HAS_GLOBAL_STRING + + RE(const ::string& regex) { Init(regex.c_str()); } // NOLINT + +#endif // GTEST_HAS_GLOBAL_STRING + + RE(const char* regex) { Init(regex); } // NOLINT + ~RE(); + + // Returns the string representation of the regex. + const char* pattern() const { return pattern_; } + + // FullMatch(str, re) returns true iff regular expression re matches + // the entire str. + // PartialMatch(str, re) returns true iff regular expression re + // matches a substring of str (including str itself). + // + // TODO(wan@google.com): make FullMatch() and PartialMatch() work + // when str contains NUL characters. + static bool FullMatch(const ::std::string& str, const RE& re) { + return FullMatch(str.c_str(), re); + } + static bool PartialMatch(const ::std::string& str, const RE& re) { + return PartialMatch(str.c_str(), re); + } + +#if GTEST_HAS_GLOBAL_STRING + + static bool FullMatch(const ::string& str, const RE& re) { + return FullMatch(str.c_str(), re); + } + static bool PartialMatch(const ::string& str, const RE& re) { + return PartialMatch(str.c_str(), re); + } + +#endif // GTEST_HAS_GLOBAL_STRING + + static bool FullMatch(const char* str, const RE& re); + static bool PartialMatch(const char* str, const RE& re); + + private: + void Init(const char* regex); + + // We use a const char* instead of a string, as Google Test may be used + // where string is not available. We also do not use Google Test's own + // String type here, in order to simplify dependencies between the + // files. + const char* pattern_; + bool is_valid_; + +#if GTEST_USES_POSIX_RE + + regex_t full_regex_; // For FullMatch(). + regex_t partial_regex_; // For PartialMatch(). + +#else // GTEST_USES_SIMPLE_RE + + const char* full_pattern_; // For FullMatch(); + +#endif + + GTEST_DISALLOW_ASSIGN_(RE); +}; + +// Formats a source file path and a line number as they would appear +// in an error message from the compiler used to compile this code. +GTEST_API_ ::std::string FormatFileLocation(const char* file, int line); + +// Formats a file location for compiler-independent XML output. +// Although this function is not platform dependent, we put it next to +// FormatFileLocation in order to contrast the two functions. +GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file, + int line); + +// Defines logging utilities: +// GTEST_LOG_(severity) - logs messages at the specified severity level. The +// message itself is streamed into the macro. +// LogToStderr() - directs all log messages to stderr. +// FlushInfoLog() - flushes informational log messages. + +enum GTestLogSeverity { + GTEST_INFO, + GTEST_WARNING, + GTEST_ERROR, + GTEST_FATAL +}; + +// Formats log entry severity, provides a stream object for streaming the +// log message, and terminates the message with a newline when going out of +// scope. +class GTEST_API_ GTestLog { + public: + GTestLog(GTestLogSeverity severity, const char* file, int line); + + // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program. + ~GTestLog(); + + ::std::ostream& GetStream() { return ::std::cerr; } + + private: + const GTestLogSeverity severity_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog); +}; + +#define GTEST_LOG_(severity) \ + ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \ + __FILE__, __LINE__).GetStream() + +inline void LogToStderr() {} +inline void FlushInfoLog() { fflush(NULL); } + +// INTERNAL IMPLEMENTATION - DO NOT USE. +// +// GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition +// is not satisfied. +// Synopsys: +// GTEST_CHECK_(boolean_condition); +// or +// GTEST_CHECK_(boolean_condition) << "Additional message"; +// +// This checks the condition and if the condition is not satisfied +// it prints message about the condition violation, including the +// condition itself, plus additional message streamed into it, if any, +// and then it aborts the program. It aborts the program irrespective of +// whether it is built in the debug mode or not. +#define GTEST_CHECK_(condition) \ + GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ + if (::testing::internal::IsTrue(condition)) \ + ; \ + else \ + GTEST_LOG_(FATAL) << "Condition " #condition " failed. " + +// An all-mode assert to verify that the given POSIX-style function +// call returns 0 (indicating success). Known limitation: this +// doesn't expand to a balanced 'if' statement, so enclose the macro +// in {} if you need to use it as the only statement in an 'if' +// branch. +#define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \ + if (const int gtest_error = (posix_call)) \ + GTEST_LOG_(FATAL) << #posix_call << "failed with error " \ + << gtest_error + +// INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. +// +// Use ImplicitCast_ as a safe version of static_cast for upcasting in +// the type hierarchy (e.g. casting a Foo* to a SuperclassOfFoo* or a +// const Foo*). When you use ImplicitCast_, the compiler checks that +// the cast is safe. Such explicit ImplicitCast_s are necessary in +// surprisingly many situations where C++ demands an exact type match +// instead of an argument type convertable to a target type. +// +// The syntax for using ImplicitCast_ is the same as for static_cast: +// +// ImplicitCast_<ToType>(expr) +// +// ImplicitCast_ would have been part of the C++ standard library, +// but the proposal was submitted too late. It will probably make +// its way into the language in the future. +// +// This relatively ugly name is intentional. It prevents clashes with +// similar functions users may have (e.g., implicit_cast). The internal +// namespace alone is not enough because the function can be found by ADL. +template<typename To> +inline To ImplicitCast_(To x) { return x; } + +// When you upcast (that is, cast a pointer from type Foo to type +// SuperclassOfFoo), it's fine to use ImplicitCast_<>, since upcasts +// always succeed. When you downcast (that is, cast a pointer from +// type Foo to type SubclassOfFoo), static_cast<> isn't safe, because +// how do you know the pointer is really of type SubclassOfFoo? It +// could be a bare Foo, or of type DifferentSubclassOfFoo. Thus, +// when you downcast, you should use this macro. In debug mode, we +// use dynamic_cast<> to double-check the downcast is legal (we die +// if it's not). In normal mode, we do the efficient static_cast<> +// instead. Thus, it's important to test in debug mode to make sure +// the cast is legal! +// This is the only place in the code we should use dynamic_cast<>. +// In particular, you SHOULDN'T be using dynamic_cast<> in order to +// do RTTI (eg code like this: +// if (dynamic_cast<Subclass1>(foo)) HandleASubclass1Object(foo); +// if (dynamic_cast<Subclass2>(foo)) HandleASubclass2Object(foo); +// You should design the code some other way not to need this. +// +// This relatively ugly name is intentional. It prevents clashes with +// similar functions users may have (e.g., down_cast). The internal +// namespace alone is not enough because the function can be found by ADL. +template<typename To, typename From> // use like this: DownCast_<T*>(foo); +inline To DownCast_(From* f) { // so we only accept pointers + // Ensures that To is a sub-type of From *. This test is here only + // for compile-time type checking, and has no overhead in an + // optimized build at run-time, as it will be optimized away + // completely. + if (false) { + const To to = NULL; + ::testing::internal::ImplicitCast_<From*>(to); + } + +#if GTEST_HAS_RTTI + // RTTI: debug mode only! + GTEST_CHECK_(f == NULL || dynamic_cast<To>(f) != NULL); +#endif + return static_cast<To>(f); +} + +// Downcasts the pointer of type Base to Derived. +// Derived must be a subclass of Base. The parameter MUST +// point to a class of type Derived, not any subclass of it. +// When RTTI is available, the function performs a runtime +// check to enforce this. +template <class Derived, class Base> +Derived* CheckedDowncastToActualType(Base* base) { +#if GTEST_HAS_RTTI + GTEST_CHECK_(typeid(*base) == typeid(Derived)); + return dynamic_cast<Derived*>(base); // NOLINT +#else + return static_cast<Derived*>(base); // Poor man's downcast. +#endif +} + +#if GTEST_HAS_STREAM_REDIRECTION + +// Defines the stderr capturer: +// CaptureStdout - starts capturing stdout. +// GetCapturedStdout - stops capturing stdout and returns the captured string. +// CaptureStderr - starts capturing stderr. +// GetCapturedStderr - stops capturing stderr and returns the captured string. +// +GTEST_API_ void CaptureStdout(); +GTEST_API_ String GetCapturedStdout(); +GTEST_API_ void CaptureStderr(); +GTEST_API_ String GetCapturedStderr(); + +#endif // GTEST_HAS_STREAM_REDIRECTION + + +#if GTEST_HAS_DEATH_TEST + +// A copy of all command line arguments. Set by InitGoogleTest(). +extern ::std::vector<String> g_argvs; + +// GTEST_HAS_DEATH_TEST implies we have ::std::string. +const ::std::vector<String>& GetArgvs(); + +#endif // GTEST_HAS_DEATH_TEST + +// Defines synchronization primitives. + +#if GTEST_HAS_PTHREAD + +// Sleeps for (roughly) n milli-seconds. This function is only for +// testing Google Test's own constructs. Don't use it in user tests, +// either directly or indirectly. +inline void SleepMilliseconds(int n) { + const timespec time = { + 0, // 0 seconds. + n * 1000L * 1000L, // And n ms. + }; + nanosleep(&time, NULL); +} + +// Allows a controller thread to pause execution of newly created +// threads until notified. Instances of this class must be created +// and destroyed in the controller thread. +// +// This class is only for testing Google Test's own constructs. Do not +// use it in user tests, either directly or indirectly. +class Notification { + public: + Notification() : notified_(false) {} + + // Notifies all threads created with this notification to start. Must + // be called from the controller thread. + void Notify() { notified_ = true; } + + // Blocks until the controller thread notifies. Must be called from a test + // thread. + void WaitForNotification() { + while(!notified_) { + SleepMilliseconds(10); + } + } + + private: + volatile bool notified_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification); +}; + +// As a C-function, ThreadFuncWithCLinkage cannot be templated itself. +// Consequently, it cannot select a correct instantiation of ThreadWithParam +// in order to call its Run(). Introducing ThreadWithParamBase as a +// non-templated base class for ThreadWithParam allows us to bypass this +// problem. +class ThreadWithParamBase { + public: + virtual ~ThreadWithParamBase() {} + virtual void Run() = 0; +}; + +// pthread_create() accepts a pointer to a function type with the C linkage. +// According to the Standard (7.5/1), function types with different linkages +// are different even if they are otherwise identical. Some compilers (for +// example, SunStudio) treat them as different types. Since class methods +// cannot be defined with C-linkage we need to define a free C-function to +// pass into pthread_create(). +extern "C" inline void* ThreadFuncWithCLinkage(void* thread) { + static_cast<ThreadWithParamBase*>(thread)->Run(); + return NULL; +} + +// Helper class for testing Google Test's multi-threading constructs. +// To use it, write: +// +// void ThreadFunc(int param) { /* Do things with param */ } +// Notification thread_can_start; +// ... +// // The thread_can_start parameter is optional; you can supply NULL. +// ThreadWithParam<int> thread(&ThreadFunc, 5, &thread_can_start); +// thread_can_start.Notify(); +// +// These classes are only for testing Google Test's own constructs. Do +// not use them in user tests, either directly or indirectly. +template <typename T> +class ThreadWithParam : public ThreadWithParamBase { + public: + typedef void (*UserThreadFunc)(T); + + ThreadWithParam( + UserThreadFunc func, T param, Notification* thread_can_start) + : func_(func), + param_(param), + thread_can_start_(thread_can_start), + finished_(false) { + ThreadWithParamBase* const base = this; + // The thread can be created only after all fields except thread_ + // have been initialized. + GTEST_CHECK_POSIX_SUCCESS_( + pthread_create(&thread_, 0, &ThreadFuncWithCLinkage, base)); + } + ~ThreadWithParam() { Join(); } + + void Join() { + if (!finished_) { + GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, 0)); + finished_ = true; + } + } + + virtual void Run() { + if (thread_can_start_ != NULL) + thread_can_start_->WaitForNotification(); + func_(param_); + } + + private: + const UserThreadFunc func_; // User-supplied thread function. + const T param_; // User-supplied parameter to the thread function. + // When non-NULL, used to block execution until the controller thread + // notifies. + Notification* const thread_can_start_; + bool finished_; // true iff we know that the thread function has finished. + pthread_t thread_; // The native thread object. + + GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam); +}; + +// MutexBase and Mutex implement mutex on pthreads-based platforms. They +// are used in conjunction with class MutexLock: +// +// Mutex mutex; +// ... +// MutexLock lock(&mutex); // Acquires the mutex and releases it at the end +// // of the current scope. +// +// MutexBase implements behavior for both statically and dynamically +// allocated mutexes. Do not use MutexBase directly. Instead, write +// the following to define a static mutex: +// +// GTEST_DEFINE_STATIC_MUTEX_(g_some_mutex); +// +// You can forward declare a static mutex like this: +// +// GTEST_DECLARE_STATIC_MUTEX_(g_some_mutex); +// +// To create a dynamic mutex, just define an object of type Mutex. +class MutexBase { + public: + // Acquires this mutex. + void Lock() { + GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_)); + owner_ = pthread_self(); + } + + // Releases this mutex. + void Unlock() { + // We don't protect writing to owner_ here, as it's the caller's + // responsibility to ensure that the current thread holds the + // mutex when this is called. + owner_ = 0; + GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_)); + } + + // Does nothing if the current thread holds the mutex. Otherwise, crashes + // with high probability. + void AssertHeld() const { + GTEST_CHECK_(owner_ == pthread_self()) + << "The current thread is not holding the mutex @" << this; + } + + // A static mutex may be used before main() is entered. It may even + // be used before the dynamic initialization stage. Therefore we + // must be able to initialize a static mutex object at link time. + // This means MutexBase has to be a POD and its member variables + // have to be public. + public: + pthread_mutex_t mutex_; // The underlying pthread mutex. + pthread_t owner_; // The thread holding the mutex; 0 means no one holds it. +}; + +// Forward-declares a static mutex. +# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ + extern ::testing::internal::MutexBase mutex + +// Defines and statically (i.e. at link time) initializes a static mutex. +# define GTEST_DEFINE_STATIC_MUTEX_(mutex) \ + ::testing::internal::MutexBase mutex = { PTHREAD_MUTEX_INITIALIZER, 0 } + +// The Mutex class can only be used for mutexes created at runtime. It +// shares its API with MutexBase otherwise. +class Mutex : public MutexBase { + public: + Mutex() { + GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL)); + owner_ = 0; + } + ~Mutex() { + GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_)); + } + + private: + GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex); +}; + +// We cannot name this class MutexLock as the ctor declaration would +// conflict with a macro named MutexLock, which is defined on some +// platforms. Hence the typedef trick below. +class GTestMutexLock { + public: + explicit GTestMutexLock(MutexBase* mutex) + : mutex_(mutex) { mutex_->Lock(); } + + ~GTestMutexLock() { mutex_->Unlock(); } + + private: + MutexBase* const mutex_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock); +}; + +typedef GTestMutexLock MutexLock; + +// Helpers for ThreadLocal. + +// pthread_key_create() requires DeleteThreadLocalValue() to have +// C-linkage. Therefore it cannot be templatized to access +// ThreadLocal<T>. Hence the need for class +// ThreadLocalValueHolderBase. +class ThreadLocalValueHolderBase { + public: + virtual ~ThreadLocalValueHolderBase() {} +}; + +// Called by pthread to delete thread-local data stored by +// pthread_setspecific(). +extern "C" inline void DeleteThreadLocalValue(void* value_holder) { + delete static_cast<ThreadLocalValueHolderBase*>(value_holder); +} + +// Implements thread-local storage on pthreads-based systems. +// +// // Thread 1 +// ThreadLocal<int> tl(100); // 100 is the default value for each thread. +// +// // Thread 2 +// tl.set(150); // Changes the value for thread 2 only. +// EXPECT_EQ(150, tl.get()); +// +// // Thread 1 +// EXPECT_EQ(100, tl.get()); // In thread 1, tl has the original value. +// tl.set(200); +// EXPECT_EQ(200, tl.get()); +// +// The template type argument T must have a public copy constructor. +// In addition, the default ThreadLocal constructor requires T to have +// a public default constructor. +// +// An object managed for a thread by a ThreadLocal instance is deleted +// when the thread exits. Or, if the ThreadLocal instance dies in +// that thread, when the ThreadLocal dies. It's the user's +// responsibility to ensure that all other threads using a ThreadLocal +// have exited when it dies, or the per-thread objects for those +// threads will not be deleted. +// +// Google Test only uses global ThreadLocal objects. That means they +// will die after main() has returned. Therefore, no per-thread +// object managed by Google Test will be leaked as long as all threads +// using Google Test have exited when main() returns. +template <typename T> +class ThreadLocal { + public: + ThreadLocal() : key_(CreateKey()), + default_() {} + explicit ThreadLocal(const T& value) : key_(CreateKey()), + default_(value) {} + + ~ThreadLocal() { + // Destroys the managed object for the current thread, if any. + DeleteThreadLocalValue(pthread_getspecific(key_)); + + // Releases resources associated with the key. This will *not* + // delete managed objects for other threads. + GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_)); + } + + T* pointer() { return GetOrCreateValue(); } + const T* pointer() const { return GetOrCreateValue(); } + const T& get() const { return *pointer(); } + void set(const T& value) { *pointer() = value; } + + private: + // Holds a value of type T. + class ValueHolder : public ThreadLocalValueHolderBase { + public: + explicit ValueHolder(const T& value) : value_(value) {} + + T* pointer() { return &value_; } + + private: + T value_; + GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder); + }; + + static pthread_key_t CreateKey() { + pthread_key_t key; + // When a thread exits, DeleteThreadLocalValue() will be called on + // the object managed for that thread. + GTEST_CHECK_POSIX_SUCCESS_( + pthread_key_create(&key, &DeleteThreadLocalValue)); + return key; + } + + T* GetOrCreateValue() const { + ThreadLocalValueHolderBase* const holder = + static_cast<ThreadLocalValueHolderBase*>(pthread_getspecific(key_)); + if (holder != NULL) { + return CheckedDowncastToActualType<ValueHolder>(holder)->pointer(); + } + + ValueHolder* const new_holder = new ValueHolder(default_); + ThreadLocalValueHolderBase* const holder_base = new_holder; + GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base)); + return new_holder->pointer(); + } + + // A key pthreads uses for looking up per-thread values. + const pthread_key_t key_; + const T default_; // The default value for each thread. + + GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal); +}; + +# define GTEST_IS_THREADSAFE 1 + +#else // GTEST_HAS_PTHREAD + +// A dummy implementation of synchronization primitives (mutex, lock, +// and thread-local variable). Necessary for compiling Google Test where +// mutex is not supported - using Google Test in multiple threads is not +// supported on such platforms. + +class Mutex { + public: + Mutex() {} + void AssertHeld() const {} +}; + +# define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ + extern ::testing::internal::Mutex mutex + +# define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex + +class GTestMutexLock { + public: + explicit GTestMutexLock(Mutex*) {} // NOLINT +}; + +typedef GTestMutexLock MutexLock; + +template <typename T> +class ThreadLocal { + public: + ThreadLocal() : value_() {} + explicit ThreadLocal(const T& value) : value_(value) {} + T* pointer() { return &value_; } + const T* pointer() const { return &value_; } + const T& get() const { return value_; } + void set(const T& value) { value_ = value; } + private: + T value_; +}; + +// The above synchronization primitives have dummy implementations. +// Therefore Google Test is not thread-safe. +# define GTEST_IS_THREADSAFE 0 + +#endif // GTEST_HAS_PTHREAD + +// Returns the number of threads running in the process, or 0 to indicate that +// we cannot detect it. +GTEST_API_ size_t GetThreadCount(); + +// Passing non-POD classes through ellipsis (...) crashes the ARM +// compiler and generates a warning in Sun Studio. The Nokia Symbian +// and the IBM XL C/C++ compiler try to instantiate a copy constructor +// for objects passed through ellipsis (...), failing for uncopyable +// objects. We define this to ensure that only POD is passed through +// ellipsis on these systems. +#if defined(__SYMBIAN32__) || defined(__IBMCPP__) || defined(__SUNPRO_CC) +// We lose support for NULL detection where the compiler doesn't like +// passing non-POD classes through ellipsis (...). +# define GTEST_ELLIPSIS_NEEDS_POD_ 1 +#else +# define GTEST_CAN_COMPARE_NULL 1 +#endif + +// The Nokia Symbian and IBM XL C/C++ compilers cannot decide between +// const T& and const T* in a function template. These compilers +// _can_ decide between class template specializations for T and T*, +// so a tr1::type_traits-like is_pointer works. +#if defined(__SYMBIAN32__) || defined(__IBMCPP__) +# define GTEST_NEEDS_IS_POINTER_ 1 +#endif + +template <bool bool_value> +struct bool_constant { + typedef bool_constant<bool_value> type; + static const bool value = bool_value; +}; +template <bool bool_value> const bool bool_constant<bool_value>::value; + +typedef bool_constant<false> false_type; +typedef bool_constant<true> true_type; + +template <typename T> +struct is_pointer : public false_type {}; + +template <typename T> +struct is_pointer<T*> : public true_type {}; + +template <typename Iterator> +struct IteratorTraits { + typedef typename Iterator::value_type value_type; +}; + +template <typename T> +struct IteratorTraits<T*> { + typedef T value_type; +}; + +template <typename T> +struct IteratorTraits<const T*> { + typedef T value_type; +}; + +#if GTEST_OS_WINDOWS +# define GTEST_PATH_SEP_ "\\" +# define GTEST_HAS_ALT_PATH_SEP_ 1 +// The biggest signed integer type the compiler supports. +typedef __int64 BiggestInt; +#else +# define GTEST_PATH_SEP_ "/" +# define GTEST_HAS_ALT_PATH_SEP_ 0 +typedef long long BiggestInt; // NOLINT +#endif // GTEST_OS_WINDOWS + +// Utilities for char. + +// isspace(int ch) and friends accept an unsigned char or EOF. char +// may be signed, depending on the compiler (or compiler flags). +// Therefore we need to cast a char to unsigned char before calling +// isspace(), etc. + +inline bool IsAlpha(char ch) { + return isalpha(static_cast<unsigned char>(ch)) != 0; +} +inline bool IsAlNum(char ch) { + return isalnum(static_cast<unsigned char>(ch)) != 0; +} +inline bool IsDigit(char ch) { + return isdigit(static_cast<unsigned char>(ch)) != 0; +} +inline bool IsLower(char ch) { + return islower(static_cast<unsigned char>(ch)) != 0; +} +inline bool IsSpace(char ch) { + return isspace(static_cast<unsigned char>(ch)) != 0; +} +inline bool IsUpper(char ch) { + return isupper(static_cast<unsigned char>(ch)) != 0; +} +inline bool IsXDigit(char ch) { + return isxdigit(static_cast<unsigned char>(ch)) != 0; +} + +inline char ToLower(char ch) { + return static_cast<char>(tolower(static_cast<unsigned char>(ch))); +} +inline char ToUpper(char ch) { + return static_cast<char>(toupper(static_cast<unsigned char>(ch))); +} + +// The testing::internal::posix namespace holds wrappers for common +// POSIX functions. These wrappers hide the differences between +// Windows/MSVC and POSIX systems. Since some compilers define these +// standard functions as macros, the wrapper cannot have the same name +// as the wrapped function. + +namespace posix { + +// Functions with a different name on Windows. + +#if GTEST_OS_WINDOWS + +typedef struct _stat StatStruct; + +# ifdef __BORLANDC__ +inline int IsATTY(int fd) { return isatty(fd); } +inline int StrCaseCmp(const char* s1, const char* s2) { + return stricmp(s1, s2); +} +inline char* StrDup(const char* src) { return strdup(src); } +# else // !__BORLANDC__ +# if GTEST_OS_WINDOWS_MOBILE +inline int IsATTY(int /* fd */) { return 0; } +# else +inline int IsATTY(int fd) { return _isatty(fd); } +# endif // GTEST_OS_WINDOWS_MOBILE +inline int StrCaseCmp(const char* s1, const char* s2) { + return _stricmp(s1, s2); +} +inline char* StrDup(const char* src) { return _strdup(src); } +# endif // __BORLANDC__ + +# if GTEST_OS_WINDOWS_MOBILE +inline int FileNo(FILE* file) { return reinterpret_cast<int>(_fileno(file)); } +// Stat(), RmDir(), and IsDir() are not needed on Windows CE at this +// time and thus not defined there. +# else +inline int FileNo(FILE* file) { return _fileno(file); } +inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); } +inline int RmDir(const char* dir) { return _rmdir(dir); } +inline bool IsDir(const StatStruct& st) { + return (_S_IFDIR & st.st_mode) != 0; +} +# endif // GTEST_OS_WINDOWS_MOBILE + +#else + +typedef struct stat StatStruct; + +inline int FileNo(FILE* file) { return fileno(file); } +inline int IsATTY(int fd) { return isatty(fd); } +inline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); } +inline int StrCaseCmp(const char* s1, const char* s2) { + return strcasecmp(s1, s2); +} +inline char* StrDup(const char* src) { return strdup(src); } +inline int RmDir(const char* dir) { return rmdir(dir); } +inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); } + +#endif // GTEST_OS_WINDOWS + +// Functions deprecated by MSVC 8.0. + +#ifdef _MSC_VER +// Temporarily disable warning 4996 (deprecated function). +# pragma warning(push) +# pragma warning(disable:4996) +#endif + +inline const char* StrNCpy(char* dest, const char* src, size_t n) { + return strncpy(dest, src, n); +} + +// ChDir(), FReopen(), FDOpen(), Read(), Write(), Close(), and +// StrError() aren't needed on Windows CE at this time and thus not +// defined there. + +#if !GTEST_OS_WINDOWS_MOBILE +inline int ChDir(const char* dir) { return chdir(dir); } +#endif +inline FILE* FOpen(const char* path, const char* mode) { + return fopen(path, mode); +} +#if !GTEST_OS_WINDOWS_MOBILE +inline FILE *FReopen(const char* path, const char* mode, FILE* stream) { + return freopen(path, mode, stream); +} +inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); } +#endif +inline int FClose(FILE* fp) { return fclose(fp); } +#if !GTEST_OS_WINDOWS_MOBILE +inline int Read(int fd, void* buf, unsigned int count) { + return static_cast<int>(read(fd, buf, count)); +} +inline int Write(int fd, const void* buf, unsigned int count) { + return static_cast<int>(write(fd, buf, count)); +} +inline int Close(int fd) { return close(fd); } +inline const char* StrError(int errnum) { return strerror(errnum); } +#endif +inline const char* GetEnv(const char* name) { +#if GTEST_OS_WINDOWS_MOBILE + // We are on Windows CE, which has no environment variables. + return NULL; +#elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9) + // Environment variables which we programmatically clear will be set to the + // empty string rather than unset (NULL). Handle that case. + const char* const env = getenv(name); + return (env != NULL && env[0] != '\0') ? env : NULL; +#else + return getenv(name); +#endif +} + +#ifdef _MSC_VER +# pragma warning(pop) // Restores the warning state. +#endif + +#if GTEST_OS_WINDOWS_MOBILE +// Windows CE has no C library. The abort() function is used in +// several places in Google Test. This implementation provides a reasonable +// imitation of standard behaviour. +void Abort(); +#else +inline void Abort() { abort(); } +#endif // GTEST_OS_WINDOWS_MOBILE + +} // namespace posix + +// The maximum number a BiggestInt can represent. This definition +// works no matter BiggestInt is represented in one's complement or +// two's complement. +// +// We cannot rely on numeric_limits in STL, as __int64 and long long +// are not part of standard C++ and numeric_limits doesn't need to be +// defined for them. +const BiggestInt kMaxBiggestInt = + ~(static_cast<BiggestInt>(1) << (8*sizeof(BiggestInt) - 1)); + +// This template class serves as a compile-time function from size to +// type. It maps a size in bytes to a primitive type with that +// size. e.g. +// +// TypeWithSize<4>::UInt +// +// is typedef-ed to be unsigned int (unsigned integer made up of 4 +// bytes). +// +// Such functionality should belong to STL, but I cannot find it +// there. +// +// Google Test uses this class in the implementation of floating-point +// comparison. +// +// For now it only handles UInt (unsigned int) as that's all Google Test +// needs. Other types can be easily added in the future if need +// arises. +template <size_t size> +class TypeWithSize { + public: + // This prevents the user from using TypeWithSize<N> with incorrect + // values of N. + typedef void UInt; +}; + +// The specialization for size 4. +template <> +class TypeWithSize<4> { + public: + // unsigned int has size 4 in both gcc and MSVC. + // + // As base/basictypes.h doesn't compile on Windows, we cannot use + // uint32, uint64, and etc here. + typedef int Int; + typedef unsigned int UInt; +}; + +// The specialization for size 8. +template <> +class TypeWithSize<8> { + public: + +#if GTEST_OS_WINDOWS + typedef __int64 Int; + typedef unsigned __int64 UInt; +#else + typedef long long Int; // NOLINT + typedef unsigned long long UInt; // NOLINT +#endif // GTEST_OS_WINDOWS +}; + +// Integer types of known sizes. +typedef TypeWithSize<4>::Int Int32; +typedef TypeWithSize<4>::UInt UInt32; +typedef TypeWithSize<8>::Int Int64; +typedef TypeWithSize<8>::UInt UInt64; +typedef TypeWithSize<8>::Int TimeInMillis; // Represents time in milliseconds. + +// Utilities for command line flags and environment variables. + +// Macro for referencing flags. +#define GTEST_FLAG(name) FLAGS_gtest_##name + +// Macros for declaring flags. +#define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name) +#define GTEST_DECLARE_int32_(name) \ + GTEST_API_ extern ::testing::internal::Int32 GTEST_FLAG(name) +#define GTEST_DECLARE_string_(name) \ + GTEST_API_ extern ::testing::internal::String GTEST_FLAG(name) + +// Macros for defining flags. +#define GTEST_DEFINE_bool_(name, default_val, doc) \ + GTEST_API_ bool GTEST_FLAG(name) = (default_val) +#define GTEST_DEFINE_int32_(name, default_val, doc) \ + GTEST_API_ ::testing::internal::Int32 GTEST_FLAG(name) = (default_val) +#define GTEST_DEFINE_string_(name, default_val, doc) \ + GTEST_API_ ::testing::internal::String GTEST_FLAG(name) = (default_val) + +// Parses 'str' for a 32-bit signed integer. If successful, writes the result +// to *value and returns true; otherwise leaves *value unchanged and returns +// false. +// TODO(chandlerc): Find a better way to refactor flag and environment parsing +// out of both gtest-port.cc and gtest.cc to avoid exporting this utility +// function. +bool ParseInt32(const Message& src_text, const char* str, Int32* value); + +// Parses a bool/Int32/string from the environment variable +// corresponding to the given Google Test flag. +bool BoolFromGTestEnv(const char* flag, bool default_val); +GTEST_API_ Int32 Int32FromGTestEnv(const char* flag, Int32 default_val); +const char* StringFromGTestEnv(const char* flag, const char* default_val); + +} // namespace internal +} // namespace testing + +#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ diff --git a/tests/gtest/include/gtest/internal/gtest-string.h b/tests/gtest/include/gtest/internal/gtest-string.h new file mode 100644 index 000000000..dc3a07be8 --- /dev/null +++ b/tests/gtest/include/gtest/internal/gtest-string.h @@ -0,0 +1,350 @@ +// Copyright 2005, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee) +// +// The Google C++ Testing Framework (Google Test) +// +// This header file declares the String class and functions used internally by +// Google Test. They are subject to change without notice. They should not used +// by code external to Google Test. +// +// This header file is #included by <gtest/internal/gtest-internal.h>. +// It should not be #included by other files. + +#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_ +#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_ + +#ifdef __BORLANDC__ +// string.h is not guaranteed to provide strcpy on C++ Builder. +# include <mem.h> +#endif + +#include <string.h> +#include "gtest/internal/gtest-port.h" + +#include <string> + +namespace testing { +namespace internal { + +// String - a UTF-8 string class. +// +// For historic reasons, we don't use std::string. +// +// TODO(wan@google.com): replace this class with std::string or +// implement it in terms of the latter. +// +// Note that String can represent both NULL and the empty string, +// while std::string cannot represent NULL. +// +// NULL and the empty string are considered different. NULL is less +// than anything (including the empty string) except itself. +// +// This class only provides minimum functionality necessary for +// implementing Google Test. We do not intend to implement a full-fledged +// string class here. +// +// Since the purpose of this class is to provide a substitute for +// std::string on platforms where it cannot be used, we define a copy +// constructor and assignment operators such that we don't need +// conditional compilation in a lot of places. +// +// In order to make the representation efficient, the d'tor of String +// is not virtual. Therefore DO NOT INHERIT FROM String. +class GTEST_API_ String { + public: + // Static utility methods + + // Returns the input enclosed in double quotes if it's not NULL; + // otherwise returns "(null)". For example, "\"Hello\"" is returned + // for input "Hello". + // + // This is useful for printing a C string in the syntax of a literal. + // + // Known issue: escape sequences are not handled yet. + static String ShowCStringQuoted(const char* c_str); + + // Clones a 0-terminated C string, allocating memory using new. The + // caller is responsible for deleting the return value using + // delete[]. Returns the cloned string, or NULL if the input is + // NULL. + // + // This is different from strdup() in string.h, which allocates + // memory using malloc(). + static const char* CloneCString(const char* c_str); + +#if GTEST_OS_WINDOWS_MOBILE + // Windows CE does not have the 'ANSI' versions of Win32 APIs. To be + // able to pass strings to Win32 APIs on CE we need to convert them + // to 'Unicode', UTF-16. + + // Creates a UTF-16 wide string from the given ANSI string, allocating + // memory using new. The caller is responsible for deleting the return + // value using delete[]. Returns the wide string, or NULL if the + // input is NULL. + // + // The wide string is created using the ANSI codepage (CP_ACP) to + // match the behaviour of the ANSI versions of Win32 calls and the + // C runtime. + static LPCWSTR AnsiToUtf16(const char* c_str); + + // Creates an ANSI string from the given wide string, allocating + // memory using new. The caller is responsible for deleting the return + // value using delete[]. Returns the ANSI string, or NULL if the + // input is NULL. + // + // The returned string is created using the ANSI codepage (CP_ACP) to + // match the behaviour of the ANSI versions of Win32 calls and the + // C runtime. + static const char* Utf16ToAnsi(LPCWSTR utf16_str); +#endif + + // Compares two C strings. Returns true iff they have the same content. + // + // Unlike strcmp(), this function can handle NULL argument(s). A + // NULL C string is considered different to any non-NULL C string, + // including the empty string. + static bool CStringEquals(const char* lhs, const char* rhs); + + // Converts a wide C string to a String using the UTF-8 encoding. + // NULL will be converted to "(null)". If an error occurred during + // the conversion, "(failed to convert from wide string)" is + // returned. + static String ShowWideCString(const wchar_t* wide_c_str); + + // Similar to ShowWideCString(), except that this function encloses + // the converted string in double quotes. + static String ShowWideCStringQuoted(const wchar_t* wide_c_str); + + // Compares two wide C strings. Returns true iff they have the same + // content. + // + // Unlike wcscmp(), this function can handle NULL argument(s). A + // NULL C string is considered different to any non-NULL C string, + // including the empty string. + static bool WideCStringEquals(const wchar_t* lhs, const wchar_t* rhs); + + // Compares two C strings, ignoring case. Returns true iff they + // have the same content. + // + // Unlike strcasecmp(), this function can handle NULL argument(s). + // A NULL C string is considered different to any non-NULL C string, + // including the empty string. + static bool CaseInsensitiveCStringEquals(const char* lhs, + const char* rhs); + + // Compares two wide C strings, ignoring case. Returns true iff they + // have the same content. + // + // Unlike wcscasecmp(), this function can handle NULL argument(s). + // A NULL C string is considered different to any non-NULL wide C string, + // including the empty string. + // NB: The implementations on different platforms slightly differ. + // On windows, this method uses _wcsicmp which compares according to LC_CTYPE + // environment variable. On GNU platform this method uses wcscasecmp + // which compares according to LC_CTYPE category of the current locale. + // On MacOS X, it uses towlower, which also uses LC_CTYPE category of the + // current locale. + static bool CaseInsensitiveWideCStringEquals(const wchar_t* lhs, + const wchar_t* rhs); + + // Formats a list of arguments to a String, using the same format + // spec string as for printf. + // + // We do not use the StringPrintf class as it is not universally + // available. + // + // The result is limited to 4096 characters (including the tailing + // 0). If 4096 characters are not enough to format the input, + // "<buffer exceeded>" is returned. + static String Format(const char* format, ...); + + // C'tors + + // The default c'tor constructs a NULL string. + String() : c_str_(NULL), length_(0) {} + + // Constructs a String by cloning a 0-terminated C string. + String(const char* a_c_str) { // NOLINT + if (a_c_str == NULL) { + c_str_ = NULL; + length_ = 0; + } else { + ConstructNonNull(a_c_str, strlen(a_c_str)); + } + } + + // Constructs a String by copying a given number of chars from a + // buffer. E.g. String("hello", 3) creates the string "hel", + // String("a\0bcd", 4) creates "a\0bc", String(NULL, 0) creates "", + // and String(NULL, 1) results in access violation. + String(const char* buffer, size_t a_length) { + ConstructNonNull(buffer, a_length); + } + + // The copy c'tor creates a new copy of the string. The two + // String objects do not share content. + String(const String& str) : c_str_(NULL), length_(0) { *this = str; } + + // D'tor. String is intended to be a final class, so the d'tor + // doesn't need to be virtual. + ~String() { delete[] c_str_; } + + // Allows a String to be implicitly converted to an ::std::string or + // ::string, and vice versa. Converting a String containing a NULL + // pointer to ::std::string or ::string is undefined behavior. + // Converting a ::std::string or ::string containing an embedded NUL + // character to a String will result in the prefix up to the first + // NUL character. + String(const ::std::string& str) { + ConstructNonNull(str.c_str(), str.length()); + } + + operator ::std::string() const { return ::std::string(c_str(), length()); } + +#if GTEST_HAS_GLOBAL_STRING + String(const ::string& str) { + ConstructNonNull(str.c_str(), str.length()); + } + + operator ::string() const { return ::string(c_str(), length()); } +#endif // GTEST_HAS_GLOBAL_STRING + + // Returns true iff this is an empty string (i.e. ""). + bool empty() const { return (c_str() != NULL) && (length() == 0); } + + // Compares this with another String. + // Returns < 0 if this is less than rhs, 0 if this is equal to rhs, or > 0 + // if this is greater than rhs. + int Compare(const String& rhs) const; + + // Returns true iff this String equals the given C string. A NULL + // string and a non-NULL string are considered not equal. + bool operator==(const char* a_c_str) const { return Compare(a_c_str) == 0; } + + // Returns true iff this String is less than the given String. A + // NULL string is considered less than "". + bool operator<(const String& rhs) const { return Compare(rhs) < 0; } + + // Returns true iff this String doesn't equal the given C string. A NULL + // string and a non-NULL string are considered not equal. + bool operator!=(const char* a_c_str) const { return !(*this == a_c_str); } + + // Returns true iff this String ends with the given suffix. *Any* + // String is considered to end with a NULL or empty suffix. + bool EndsWith(const char* suffix) const; + + // Returns true iff this String ends with the given suffix, not considering + // case. Any String is considered to end with a NULL or empty suffix. + bool EndsWithCaseInsensitive(const char* suffix) const; + + // Returns the length of the encapsulated string, or 0 if the + // string is NULL. + size_t length() const { return length_; } + + // Gets the 0-terminated C string this String object represents. + // The String object still owns the string. Therefore the caller + // should NOT delete the return value. + const char* c_str() const { return c_str_; } + + // Assigns a C string to this object. Self-assignment works. + const String& operator=(const char* a_c_str) { + return *this = String(a_c_str); + } + + // Assigns a String object to this object. Self-assignment works. + const String& operator=(const String& rhs) { + if (this != &rhs) { + delete[] c_str_; + if (rhs.c_str() == NULL) { + c_str_ = NULL; + length_ = 0; + } else { + ConstructNonNull(rhs.c_str(), rhs.length()); + } + } + + return *this; + } + + private: + // Constructs a non-NULL String from the given content. This + // function can only be called when c_str_ has not been allocated. + // ConstructNonNull(NULL, 0) results in an empty string (""). + // ConstructNonNull(NULL, non_zero) is undefined behavior. + void ConstructNonNull(const char* buffer, size_t a_length) { + char* const str = new char[a_length + 1]; + memcpy(str, buffer, a_length); + str[a_length] = '\0'; + c_str_ = str; + length_ = a_length; + } + + const char* c_str_; + size_t length_; +}; // class String + +// Streams a String to an ostream. Each '\0' character in the String +// is replaced with "\\0". +inline ::std::ostream& operator<<(::std::ostream& os, const String& str) { + if (str.c_str() == NULL) { + os << "(null)"; + } else { + const char* const c_str = str.c_str(); + for (size_t i = 0; i != str.length(); i++) { + if (c_str[i] == '\0') { + os << "\\0"; + } else { + os << c_str[i]; + } + } + } + return os; +} + +// Gets the content of the stringstream's buffer as a String. Each '\0' +// character in the buffer is replaced with "\\0". +GTEST_API_ String StringStreamToString(::std::stringstream* stream); + +// Converts a streamable value to a String. A NULL pointer is +// converted to "(null)". When the input value is a ::string, +// ::std::string, ::wstring, or ::std::wstring object, each NUL +// character in it is replaced with "\\0". + +// Declared here but defined in gtest.h, so that it has access +// to the definition of the Message class, required by the ARM +// compiler. +template <typename T> +String StreamableToString(const T& streamable); + +} // namespace internal +} // namespace testing + +#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_ diff --git a/tests/gtest/include/gtest/internal/gtest-tuple.h b/tests/gtest/include/gtest/internal/gtest-tuple.h new file mode 100644 index 000000000..d1af50e18 --- /dev/null +++ b/tests/gtest/include/gtest/internal/gtest-tuple.h @@ -0,0 +1,968 @@ +// This file was GENERATED by a script. DO NOT EDIT BY HAND!!! + +// Copyright 2009 Google Inc. +// All Rights Reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Author: wan@google.com (Zhanyong Wan) + +// Implements a subset of TR1 tuple needed by Google Test and Google Mock. + +#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_ +#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_ + +#include <utility> // For ::std::pair. + +// The compiler used in Symbian has a bug that prevents us from declaring the +// tuple template as a friend (it complains that tuple is redefined). This +// hack bypasses the bug by declaring the members that should otherwise be +// private as public. +// Sun Studio versions < 12 also have the above bug. +#if defined(__SYMBIAN32__) || (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590) +# define GTEST_DECLARE_TUPLE_AS_FRIEND_ public: +#else +# define GTEST_DECLARE_TUPLE_AS_FRIEND_ \ + template <GTEST_10_TYPENAMES_(U)> friend class tuple; \ + private: +#endif + +// GTEST_n_TUPLE_(T) is the type of an n-tuple. +#define GTEST_0_TUPLE_(T) tuple<> +#define GTEST_1_TUPLE_(T) tuple<T##0, void, void, void, void, void, void, \ + void, void, void> +#define GTEST_2_TUPLE_(T) tuple<T##0, T##1, void, void, void, void, void, \ + void, void, void> +#define GTEST_3_TUPLE_(T) tuple<T##0, T##1, T##2, void, void, void, void, \ + void, void, void> +#define GTEST_4_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, void, void, void, \ + void, void, void> +#define GTEST_5_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, void, void, \ + void, void, void> +#define GTEST_6_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, void, \ + void, void, void> +#define GTEST_7_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \ + void, void, void> +#define GTEST_8_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \ + T##7, void, void> +#define GTEST_9_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \ + T##7, T##8, void> +#define GTEST_10_TUPLE_(T) tuple<T##0, T##1, T##2, T##3, T##4, T##5, T##6, \ + T##7, T##8, T##9> + +// GTEST_n_TYPENAMES_(T) declares a list of n typenames. +#define GTEST_0_TYPENAMES_(T) +#define GTEST_1_TYPENAMES_(T) typename T##0 +#define GTEST_2_TYPENAMES_(T) typename T##0, typename T##1 +#define GTEST_3_TYPENAMES_(T) typename T##0, typename T##1, typename T##2 +#define GTEST_4_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ + typename T##3 +#define GTEST_5_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ + typename T##3, typename T##4 +#define GTEST_6_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ + typename T##3, typename T##4, typename T##5 +#define GTEST_7_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ + typename T##3, typename T##4, typename T##5, typename T##6 +#define GTEST_8_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ + typename T##3, typename T##4, typename T##5, typename T##6, typename T##7 +#define GTEST_9_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ + typename T##3, typename T##4, typename T##5, typename T##6, \ + typename T##7, typename T##8 +#define GTEST_10_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ + typename T##3, typename T##4, typename T##5, typename T##6, \ + typename T##7, typename T##8, typename T##9 + +// In theory, defining stuff in the ::std namespace is undefined +// behavior. We can do this as we are playing the role of a standard +// library vendor. +namespace std { +namespace tr1 { + +template <typename T0 = void, typename T1 = void, typename T2 = void, + typename T3 = void, typename T4 = void, typename T5 = void, + typename T6 = void, typename T7 = void, typename T8 = void, + typename T9 = void> +class tuple; + +// Anything in namespace gtest_internal is Google Test's INTERNAL +// IMPLEMENTATION DETAIL and MUST NOT BE USED DIRECTLY in user code. +namespace gtest_internal { + +// ByRef<T>::type is T if T is a reference; otherwise it's const T&. +template <typename T> +struct ByRef { typedef const T& type; }; // NOLINT +template <typename T> +struct ByRef<T&> { typedef T& type; }; // NOLINT + +// A handy wrapper for ByRef. +#define GTEST_BY_REF_(T) typename ::std::tr1::gtest_internal::ByRef<T>::type + +// AddRef<T>::type is T if T is a reference; otherwise it's T&. This +// is the same as tr1::add_reference<T>::type. +template <typename T> +struct AddRef { typedef T& type; }; // NOLINT +template <typename T> +struct AddRef<T&> { typedef T& type; }; // NOLINT + +// A handy wrapper for AddRef. +#define GTEST_ADD_REF_(T) typename ::std::tr1::gtest_internal::AddRef<T>::type + +// A helper for implementing get<k>(). +template <int k> class Get; + +// A helper for implementing tuple_element<k, T>. kIndexValid is true +// iff k < the number of fields in tuple type T. +template <bool kIndexValid, int kIndex, class Tuple> +struct TupleElement; + +template <GTEST_10_TYPENAMES_(T)> +struct TupleElement<true, 0, GTEST_10_TUPLE_(T)> { typedef T0 type; }; + +template <GTEST_10_TYPENAMES_(T)> +struct TupleElement<true, 1, GTEST_10_TUPLE_(T)> { typedef T1 type; }; + +template <GTEST_10_TYPENAMES_(T)> +struct TupleElement<true, 2, GTEST_10_TUPLE_(T)> { typedef T2 type; }; + +template <GTEST_10_TYPENAMES_(T)> +struct TupleElement<true, 3, GTEST_10_TUPLE_(T)> { typedef T3 type; }; + +template <GTEST_10_TYPENAMES_(T)> +struct TupleElement<true, 4, GTEST_10_TUPLE_(T)> { typedef T4 type; }; + +template <GTEST_10_TYPENAMES_(T)> +struct TupleElement<true, 5, GTEST_10_TUPLE_(T)> { typedef T5 type; }; + +template <GTEST_10_TYPENAMES_(T)> +struct TupleElement<true, 6, GTEST_10_TUPLE_(T)> { typedef T6 type; }; + +template <GTEST_10_TYPENAMES_(T)> +struct TupleElement<true, 7, GTEST_10_TUPLE_(T)> { typedef T7 type; }; + +template <GTEST_10_TYPENAMES_(T)> +struct TupleElement<true, 8, GTEST_10_TUPLE_(T)> { typedef T8 type; }; + +template <GTEST_10_TYPENAMES_(T)> +struct TupleElement<true, 9, GTEST_10_TUPLE_(T)> { typedef T9 type; }; + +} // namespace gtest_internal + +template <> +class tuple<> { + public: + tuple() {} + tuple(const tuple& /* t */) {} + tuple& operator=(const tuple& /* t */) { return *this; } +}; + +template <GTEST_1_TYPENAMES_(T)> +class GTEST_1_TUPLE_(T) { + public: + template <int k> friend class gtest_internal::Get; + + tuple() : f0_() {} + + explicit tuple(GTEST_BY_REF_(T0) f0) : f0_(f0) {} + + tuple(const tuple& t) : f0_(t.f0_) {} + + template <GTEST_1_TYPENAMES_(U)> + tuple(const GTEST_1_TUPLE_(U)& t) : f0_(t.f0_) {} + + tuple& operator=(const tuple& t) { return CopyFrom(t); } + + template <GTEST_1_TYPENAMES_(U)> + tuple& operator=(const GTEST_1_TUPLE_(U)& t) { + return CopyFrom(t); + } + + GTEST_DECLARE_TUPLE_AS_FRIEND_ + + template <GTEST_1_TYPENAMES_(U)> + tuple& CopyFrom(const GTEST_1_TUPLE_(U)& t) { + f0_ = t.f0_; + return *this; + } + + T0 f0_; +}; + +template <GTEST_2_TYPENAMES_(T)> +class GTEST_2_TUPLE_(T) { + public: + template <int k> friend class gtest_internal::Get; + + tuple() : f0_(), f1_() {} + + explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1) : f0_(f0), + f1_(f1) {} + + tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_) {} + + template <GTEST_2_TYPENAMES_(U)> + tuple(const GTEST_2_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_) {} + template <typename U0, typename U1> + tuple(const ::std::pair<U0, U1>& p) : f0_(p.first), f1_(p.second) {} + + tuple& operator=(const tuple& t) { return CopyFrom(t); } + + template <GTEST_2_TYPENAMES_(U)> + tuple& operator=(const GTEST_2_TUPLE_(U)& t) { + return CopyFrom(t); + } + template <typename U0, typename U1> + tuple& operator=(const ::std::pair<U0, U1>& p) { + f0_ = p.first; + f1_ = p.second; + return *this; + } + + GTEST_DECLARE_TUPLE_AS_FRIEND_ + + template <GTEST_2_TYPENAMES_(U)> + tuple& CopyFrom(const GTEST_2_TUPLE_(U)& t) { + f0_ = t.f0_; + f1_ = t.f1_; + return *this; + } + + T0 f0_; + T1 f1_; +}; + +template <GTEST_3_TYPENAMES_(T)> +class GTEST_3_TUPLE_(T) { + public: + template <int k> friend class gtest_internal::Get; + + tuple() : f0_(), f1_(), f2_() {} + + explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, + GTEST_BY_REF_(T2) f2) : f0_(f0), f1_(f1), f2_(f2) {} + + tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {} + + template <GTEST_3_TYPENAMES_(U)> + tuple(const GTEST_3_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {} + + tuple& operator=(const tuple& t) { return CopyFrom(t); } + + template <GTEST_3_TYPENAMES_(U)> + tuple& operator=(const GTEST_3_TUPLE_(U)& t) { + return CopyFrom(t); + } + + GTEST_DECLARE_TUPLE_AS_FRIEND_ + + template <GTEST_3_TYPENAMES_(U)> + tuple& CopyFrom(const GTEST_3_TUPLE_(U)& t) { + f0_ = t.f0_; + f1_ = t.f1_; + f2_ = t.f2_; + return *this; + } + + T0 f0_; + T1 f1_; + T2 f2_; +}; + +template <GTEST_4_TYPENAMES_(T)> +class GTEST_4_TUPLE_(T) { + public: + template <int k> friend class gtest_internal::Get; + + tuple() : f0_(), f1_(), f2_(), f3_() {} + + explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, + GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3) : f0_(f0), f1_(f1), f2_(f2), + f3_(f3) {} + + tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_) {} + + template <GTEST_4_TYPENAMES_(U)> + tuple(const GTEST_4_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), + f3_(t.f3_) {} + + tuple& operator=(const tuple& t) { return CopyFrom(t); } + + template <GTEST_4_TYPENAMES_(U)> + tuple& operator=(const GTEST_4_TUPLE_(U)& t) { + return CopyFrom(t); + } + + GTEST_DECLARE_TUPLE_AS_FRIEND_ + + template <GTEST_4_TYPENAMES_(U)> + tuple& CopyFrom(const GTEST_4_TUPLE_(U)& t) { + f0_ = t.f0_; + f1_ = t.f1_; + f2_ = t.f2_; + f3_ = t.f3_; + return *this; + } + + T0 f0_; + T1 f1_; + T2 f2_; + T3 f3_; +}; + +template <GTEST_5_TYPENAMES_(T)> +class GTEST_5_TUPLE_(T) { + public: + template <int k> friend class gtest_internal::Get; + + tuple() : f0_(), f1_(), f2_(), f3_(), f4_() {} + + explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, + GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, + GTEST_BY_REF_(T4) f4) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4) {} + + tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), + f4_(t.f4_) {} + + template <GTEST_5_TYPENAMES_(U)> + tuple(const GTEST_5_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), + f3_(t.f3_), f4_(t.f4_) {} + + tuple& operator=(const tuple& t) { return CopyFrom(t); } + + template <GTEST_5_TYPENAMES_(U)> + tuple& operator=(const GTEST_5_TUPLE_(U)& t) { + return CopyFrom(t); + } + + GTEST_DECLARE_TUPLE_AS_FRIEND_ + + template <GTEST_5_TYPENAMES_(U)> + tuple& CopyFrom(const GTEST_5_TUPLE_(U)& t) { + f0_ = t.f0_; + f1_ = t.f1_; + f2_ = t.f2_; + f3_ = t.f3_; + f4_ = t.f4_; + return *this; + } + + T0 f0_; + T1 f1_; + T2 f2_; + T3 f3_; + T4 f4_; +}; + +template <GTEST_6_TYPENAMES_(T)> +class GTEST_6_TUPLE_(T) { + public: + template <int k> friend class gtest_internal::Get; + + tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_() {} + + explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, + GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, + GTEST_BY_REF_(T5) f5) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4), + f5_(f5) {} + + tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), + f4_(t.f4_), f5_(t.f5_) {} + + template <GTEST_6_TYPENAMES_(U)> + tuple(const GTEST_6_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), + f3_(t.f3_), f4_(t.f4_), f5_(t.f5_) {} + + tuple& operator=(const tuple& t) { return CopyFrom(t); } + + template <GTEST_6_TYPENAMES_(U)> + tuple& operator=(const GTEST_6_TUPLE_(U)& t) { + return CopyFrom(t); + } + + GTEST_DECLARE_TUPLE_AS_FRIEND_ + + template <GTEST_6_TYPENAMES_(U)> + tuple& CopyFrom(const GTEST_6_TUPLE_(U)& t) { + f0_ = t.f0_; + f1_ = t.f1_; + f2_ = t.f2_; + f3_ = t.f3_; + f4_ = t.f4_; + f5_ = t.f5_; + return *this; + } + + T0 f0_; + T1 f1_; + T2 f2_; + T3 f3_; + T4 f4_; + T5 f5_; +}; + +template <GTEST_7_TYPENAMES_(T)> +class GTEST_7_TUPLE_(T) { + public: + template <int k> friend class gtest_internal::Get; + + tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_() {} + + explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, + GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, + GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6) : f0_(f0), f1_(f1), f2_(f2), + f3_(f3), f4_(f4), f5_(f5), f6_(f6) {} + + tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), + f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {} + + template <GTEST_7_TYPENAMES_(U)> + tuple(const GTEST_7_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), + f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {} + + tuple& operator=(const tuple& t) { return CopyFrom(t); } + + template <GTEST_7_TYPENAMES_(U)> + tuple& operator=(const GTEST_7_TUPLE_(U)& t) { + return CopyFrom(t); + } + + GTEST_DECLARE_TUPLE_AS_FRIEND_ + + template <GTEST_7_TYPENAMES_(U)> + tuple& CopyFrom(const GTEST_7_TUPLE_(U)& t) { + f0_ = t.f0_; + f1_ = t.f1_; + f2_ = t.f2_; + f3_ = t.f3_; + f4_ = t.f4_; + f5_ = t.f5_; + f6_ = t.f6_; + return *this; + } + + T0 f0_; + T1 f1_; + T2 f2_; + T3 f3_; + T4 f4_; + T5 f5_; + T6 f6_; +}; + +template <GTEST_8_TYPENAMES_(T)> +class GTEST_8_TUPLE_(T) { + public: + template <int k> friend class gtest_internal::Get; + + tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_() {} + + explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, + GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, + GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, + GTEST_BY_REF_(T7) f7) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4), + f5_(f5), f6_(f6), f7_(f7) {} + + tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), + f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {} + + template <GTEST_8_TYPENAMES_(U)> + tuple(const GTEST_8_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), + f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {} + + tuple& operator=(const tuple& t) { return CopyFrom(t); } + + template <GTEST_8_TYPENAMES_(U)> + tuple& operator=(const GTEST_8_TUPLE_(U)& t) { + return CopyFrom(t); + } + + GTEST_DECLARE_TUPLE_AS_FRIEND_ + + template <GTEST_8_TYPENAMES_(U)> + tuple& CopyFrom(const GTEST_8_TUPLE_(U)& t) { + f0_ = t.f0_; + f1_ = t.f1_; + f2_ = t.f2_; + f3_ = t.f3_; + f4_ = t.f4_; + f5_ = t.f5_; + f6_ = t.f6_; + f7_ = t.f7_; + return *this; + } + + T0 f0_; + T1 f1_; + T2 f2_; + T3 f3_; + T4 f4_; + T5 f5_; + T6 f6_; + T7 f7_; +}; + +template <GTEST_9_TYPENAMES_(T)> +class GTEST_9_TUPLE_(T) { + public: + template <int k> friend class gtest_internal::Get; + + tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_() {} + + explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, + GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, + GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7, + GTEST_BY_REF_(T8) f8) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4), + f5_(f5), f6_(f6), f7_(f7), f8_(f8) {} + + tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), + f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {} + + template <GTEST_9_TYPENAMES_(U)> + tuple(const GTEST_9_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), + f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {} + + tuple& operator=(const tuple& t) { return CopyFrom(t); } + + template <GTEST_9_TYPENAMES_(U)> + tuple& operator=(const GTEST_9_TUPLE_(U)& t) { + return CopyFrom(t); + } + + GTEST_DECLARE_TUPLE_AS_FRIEND_ + + template <GTEST_9_TYPENAMES_(U)> + tuple& CopyFrom(const GTEST_9_TUPLE_(U)& t) { + f0_ = t.f0_; + f1_ = t.f1_; + f2_ = t.f2_; + f3_ = t.f3_; + f4_ = t.f4_; + f5_ = t.f5_; + f6_ = t.f6_; + f7_ = t.f7_; + f8_ = t.f8_; + return *this; + } + + T0 f0_; + T1 f1_; + T2 f2_; + T3 f3_; + T4 f4_; + T5 f5_; + T6 f6_; + T7 f7_; + T8 f8_; +}; + +template <GTEST_10_TYPENAMES_(T)> +class tuple { + public: + template <int k> friend class gtest_internal::Get; + + tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_(), + f9_() {} + + explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, + GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, + GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7, + GTEST_BY_REF_(T8) f8, GTEST_BY_REF_(T9) f9) : f0_(f0), f1_(f1), f2_(f2), + f3_(f3), f4_(f4), f5_(f5), f6_(f6), f7_(f7), f8_(f8), f9_(f9) {} + + tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), + f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_), f9_(t.f9_) {} + + template <GTEST_10_TYPENAMES_(U)> + tuple(const GTEST_10_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), + f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_), + f9_(t.f9_) {} + + tuple& operator=(const tuple& t) { return CopyFrom(t); } + + template <GTEST_10_TYPENAMES_(U)> + tuple& operator=(const GTEST_10_TUPLE_(U)& t) { + return CopyFrom(t); + } + + GTEST_DECLARE_TUPLE_AS_FRIEND_ + + template <GTEST_10_TYPENAMES_(U)> + tuple& CopyFrom(const GTEST_10_TUPLE_(U)& t) { + f0_ = t.f0_; + f1_ = t.f1_; + f2_ = t.f2_; + f3_ = t.f3_; + f4_ = t.f4_; + f5_ = t.f5_; + f6_ = t.f6_; + f7_ = t.f7_; + f8_ = t.f8_; + f9_ = t.f9_; + return *this; + } + + T0 f0_; + T1 f1_; + T2 f2_; + T3 f3_; + T4 f4_; + T5 f5_; + T6 f6_; + T7 f7_; + T8 f8_; + T9 f9_; +}; + +// 6.1.3.2 Tuple creation functions. + +// Known limitations: we don't support passing an +// std::tr1::reference_wrapper<T> to make_tuple(). And we don't +// implement tie(). + +inline tuple<> make_tuple() { return tuple<>(); } + +template <GTEST_1_TYPENAMES_(T)> +inline GTEST_1_TUPLE_(T) make_tuple(const T0& f0) { + return GTEST_1_TUPLE_(T)(f0); +} + +template <GTEST_2_TYPENAMES_(T)> +inline GTEST_2_TUPLE_(T) make_tuple(const T0& f0, const T1& f1) { + return GTEST_2_TUPLE_(T)(f0, f1); +} + +template <GTEST_3_TYPENAMES_(T)> +inline GTEST_3_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2) { + return GTEST_3_TUPLE_(T)(f0, f1, f2); +} + +template <GTEST_4_TYPENAMES_(T)> +inline GTEST_4_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, + const T3& f3) { + return GTEST_4_TUPLE_(T)(f0, f1, f2, f3); +} + +template <GTEST_5_TYPENAMES_(T)> +inline GTEST_5_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, + const T3& f3, const T4& f4) { + return GTEST_5_TUPLE_(T)(f0, f1, f2, f3, f4); +} + +template <GTEST_6_TYPENAMES_(T)> +inline GTEST_6_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, + const T3& f3, const T4& f4, const T5& f5) { + return GTEST_6_TUPLE_(T)(f0, f1, f2, f3, f4, f5); +} + +template <GTEST_7_TYPENAMES_(T)> +inline GTEST_7_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, + const T3& f3, const T4& f4, const T5& f5, const T6& f6) { + return GTEST_7_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6); +} + +template <GTEST_8_TYPENAMES_(T)> +inline GTEST_8_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, + const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7) { + return GTEST_8_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7); +} + +template <GTEST_9_TYPENAMES_(T)> +inline GTEST_9_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, + const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7, + const T8& f8) { + return GTEST_9_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8); +} + +template <GTEST_10_TYPENAMES_(T)> +inline GTEST_10_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, + const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7, + const T8& f8, const T9& f9) { + return GTEST_10_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9); +} + +// 6.1.3.3 Tuple helper classes. + +template <typename Tuple> struct tuple_size; + +template <GTEST_0_TYPENAMES_(T)> +struct tuple_size<GTEST_0_TUPLE_(T)> { static const int value = 0; }; + +template <GTEST_1_TYPENAMES_(T)> +struct tuple_size<GTEST_1_TUPLE_(T)> { static const int value = 1; }; + +template <GTEST_2_TYPENAMES_(T)> +struct tuple_size<GTEST_2_TUPLE_(T)> { static const int value = 2; }; + +template <GTEST_3_TYPENAMES_(T)> +struct tuple_size<GTEST_3_TUPLE_(T)> { static const int value = 3; }; + +template <GTEST_4_TYPENAMES_(T)> +struct tuple_size<GTEST_4_TUPLE_(T)> { static const int value = 4; }; + +template <GTEST_5_TYPENAMES_(T)> +struct tuple_size<GTEST_5_TUPLE_(T)> { static const int value = 5; }; + +template <GTEST_6_TYPENAMES_(T)> +struct tuple_size<GTEST_6_TUPLE_(T)> { static const int value = 6; }; + +template <GTEST_7_TYPENAMES_(T)> +struct tuple_size<GTEST_7_TUPLE_(T)> { static const int value = 7; }; + +template <GTEST_8_TYPENAMES_(T)> +struct tuple_size<GTEST_8_TUPLE_(T)> { static const int value = 8; }; + +template <GTEST_9_TYPENAMES_(T)> +struct tuple_size<GTEST_9_TUPLE_(T)> { static const int value = 9; }; + +template <GTEST_10_TYPENAMES_(T)> +struct tuple_size<GTEST_10_TUPLE_(T)> { static const int value = 10; }; + +template <int k, class Tuple> +struct tuple_element { + typedef typename gtest_internal::TupleElement< + k < (tuple_size<Tuple>::value), k, Tuple>::type type; +}; + +#define GTEST_TUPLE_ELEMENT_(k, Tuple) typename tuple_element<k, Tuple >::type + +// 6.1.3.4 Element access. + +namespace gtest_internal { + +template <> +class Get<0> { + public: + template <class Tuple> + static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple)) + Field(Tuple& t) { return t.f0_; } // NOLINT + + template <class Tuple> + static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple)) + ConstField(const Tuple& t) { return t.f0_; } +}; + +template <> +class Get<1> { + public: + template <class Tuple> + static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple)) + Field(Tuple& t) { return t.f1_; } // NOLINT + + template <class Tuple> + static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple)) + ConstField(const Tuple& t) { return t.f1_; } +}; + +template <> +class Get<2> { + public: + template <class Tuple> + static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple)) + Field(Tuple& t) { return t.f2_; } // NOLINT + + template <class Tuple> + static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple)) + ConstField(const Tuple& t) { return t.f2_; } +}; + +template <> +class Get<3> { + public: + template <class Tuple> + static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple)) + Field(Tuple& t) { return t.f3_; } // NOLINT + + template <class Tuple> + static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple)) + ConstField(const Tuple& t) { return t.f3_; } +}; + +template <> +class Get<4> { + public: + template <class Tuple> + static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple)) + Field(Tuple& t) { return t.f4_; } // NOLINT + + template <class Tuple> + static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple)) + ConstField(const Tuple& t) { return t.f4_; } +}; + +template <> +class Get<5> { + public: + template <class Tuple> + static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple)) + Field(Tuple& t) { return t.f5_; } // NOLINT + + template <class Tuple> + static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple)) + ConstField(const Tuple& t) { return t.f5_; } +}; + +template <> +class Get<6> { + public: + template <class Tuple> + static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple)) + Field(Tuple& t) { return t.f6_; } // NOLINT + + template <class Tuple> + static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple)) + ConstField(const Tuple& t) { return t.f6_; } +}; + +template <> +class Get<7> { + public: + template <class Tuple> + static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple)) + Field(Tuple& t) { return t.f7_; } // NOLINT + + template <class Tuple> + static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple)) + ConstField(const Tuple& t) { return t.f7_; } +}; + +template <> +class Get<8> { + public: + template <class Tuple> + static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple)) + Field(Tuple& t) { return t.f8_; } // NOLINT + + template <class Tuple> + static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple)) + ConstField(const Tuple& t) { return t.f8_; } +}; + +template <> +class Get<9> { + public: + template <class Tuple> + static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple)) + Field(Tuple& t) { return t.f9_; } // NOLINT + + template <class Tuple> + static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple)) + ConstField(const Tuple& t) { return t.f9_; } +}; + +} // namespace gtest_internal + +template <int k, GTEST_10_TYPENAMES_(T)> +GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T))) +get(GTEST_10_TUPLE_(T)& t) { + return gtest_internal::Get<k>::Field(t); +} + +template <int k, GTEST_10_TYPENAMES_(T)> +GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T))) +get(const GTEST_10_TUPLE_(T)& t) { + return gtest_internal::Get<k>::ConstField(t); +} + +// 6.1.3.5 Relational operators + +// We only implement == and !=, as we don't have a need for the rest yet. + +namespace gtest_internal { + +// SameSizeTuplePrefixComparator<k, k>::Eq(t1, t2) returns true if the +// first k fields of t1 equals the first k fields of t2. +// SameSizeTuplePrefixComparator(k1, k2) would be a compiler error if +// k1 != k2. +template <int kSize1, int kSize2> +struct SameSizeTuplePrefixComparator; + +template <> +struct SameSizeTuplePrefixComparator<0, 0> { + template <class Tuple1, class Tuple2> + static bool Eq(const Tuple1& /* t1 */, const Tuple2& /* t2 */) { + return true; + } +}; + +template <int k> +struct SameSizeTuplePrefixComparator<k, k> { + template <class Tuple1, class Tuple2> + static bool Eq(const Tuple1& t1, const Tuple2& t2) { + return SameSizeTuplePrefixComparator<k - 1, k - 1>::Eq(t1, t2) && + ::std::tr1::get<k - 1>(t1) == ::std::tr1::get<k - 1>(t2); + } +}; + +} // namespace gtest_internal + +template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)> +inline bool operator==(const GTEST_10_TUPLE_(T)& t, + const GTEST_10_TUPLE_(U)& u) { + return gtest_internal::SameSizeTuplePrefixComparator< + tuple_size<GTEST_10_TUPLE_(T)>::value, + tuple_size<GTEST_10_TUPLE_(U)>::value>::Eq(t, u); +} + +template <GTEST_10_TYPENAMES_(T), GTEST_10_TYPENAMES_(U)> +inline bool operator!=(const GTEST_10_TUPLE_(T)& t, + const GTEST_10_TUPLE_(U)& u) { return !(t == u); } + +// 6.1.4 Pairs. +// Unimplemented. + +} // namespace tr1 +} // namespace std + +#undef GTEST_0_TUPLE_ +#undef GTEST_1_TUPLE_ +#undef GTEST_2_TUPLE_ +#undef GTEST_3_TUPLE_ +#undef GTEST_4_TUPLE_ +#undef GTEST_5_TUPLE_ +#undef GTEST_6_TUPLE_ +#undef GTEST_7_TUPLE_ +#undef GTEST_8_TUPLE_ +#undef GTEST_9_TUPLE_ +#undef GTEST_10_TUPLE_ + +#undef GTEST_0_TYPENAMES_ +#undef GTEST_1_TYPENAMES_ +#undef GTEST_2_TYPENAMES_ +#undef GTEST_3_TYPENAMES_ +#undef GTEST_4_TYPENAMES_ +#undef GTEST_5_TYPENAMES_ +#undef GTEST_6_TYPENAMES_ +#undef GTEST_7_TYPENAMES_ +#undef GTEST_8_TYPENAMES_ +#undef GTEST_9_TYPENAMES_ +#undef GTEST_10_TYPENAMES_ + +#undef GTEST_DECLARE_TUPLE_AS_FRIEND_ +#undef GTEST_BY_REF_ +#undef GTEST_ADD_REF_ +#undef GTEST_TUPLE_ELEMENT_ + +#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_ diff --git a/tests/gtest/include/gtest/internal/gtest-tuple.h.pump b/tests/gtest/include/gtest/internal/gtest-tuple.h.pump new file mode 100644 index 000000000..ef519094a --- /dev/null +++ b/tests/gtest/include/gtest/internal/gtest-tuple.h.pump @@ -0,0 +1,336 @@ +$$ -*- mode: c++; -*- +$var n = 10 $$ Maximum number of tuple fields we want to support. +$$ This meta comment fixes auto-indentation in Emacs. }} +// Copyright 2009 Google Inc. +// All Rights Reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Author: wan@google.com (Zhanyong Wan) + +// Implements a subset of TR1 tuple needed by Google Test and Google Mock. + +#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_ +#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_ + +#include <utility> // For ::std::pair. + +// The compiler used in Symbian has a bug that prevents us from declaring the +// tuple template as a friend (it complains that tuple is redefined). This +// hack bypasses the bug by declaring the members that should otherwise be +// private as public. +// Sun Studio versions < 12 also have the above bug. +#if defined(__SYMBIAN32__) || (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590) +# define GTEST_DECLARE_TUPLE_AS_FRIEND_ public: +#else +# define GTEST_DECLARE_TUPLE_AS_FRIEND_ \ + template <GTEST_$(n)_TYPENAMES_(U)> friend class tuple; \ + private: +#endif + + +$range i 0..n-1 +$range j 0..n +$range k 1..n +// GTEST_n_TUPLE_(T) is the type of an n-tuple. +#define GTEST_0_TUPLE_(T) tuple<> + +$for k [[ +$range m 0..k-1 +$range m2 k..n-1 +#define GTEST_$(k)_TUPLE_(T) tuple<$for m, [[T##$m]]$for m2 [[, void]]> + +]] + +// GTEST_n_TYPENAMES_(T) declares a list of n typenames. + +$for j [[ +$range m 0..j-1 +#define GTEST_$(j)_TYPENAMES_(T) $for m, [[typename T##$m]] + + +]] + +// In theory, defining stuff in the ::std namespace is undefined +// behavior. We can do this as we are playing the role of a standard +// library vendor. +namespace std { +namespace tr1 { + +template <$for i, [[typename T$i = void]]> +class tuple; + +// Anything in namespace gtest_internal is Google Test's INTERNAL +// IMPLEMENTATION DETAIL and MUST NOT BE USED DIRECTLY in user code. +namespace gtest_internal { + +// ByRef<T>::type is T if T is a reference; otherwise it's const T&. +template <typename T> +struct ByRef { typedef const T& type; }; // NOLINT +template <typename T> +struct ByRef<T&> { typedef T& type; }; // NOLINT + +// A handy wrapper for ByRef. +#define GTEST_BY_REF_(T) typename ::std::tr1::gtest_internal::ByRef<T>::type + +// AddRef<T>::type is T if T is a reference; otherwise it's T&. This +// is the same as tr1::add_reference<T>::type. +template <typename T> +struct AddRef { typedef T& type; }; // NOLINT +template <typename T> +struct AddRef<T&> { typedef T& type; }; // NOLINT + +// A handy wrapper for AddRef. +#define GTEST_ADD_REF_(T) typename ::std::tr1::gtest_internal::AddRef<T>::type + +// A helper for implementing get<k>(). +template <int k> class Get; + +// A helper for implementing tuple_element<k, T>. kIndexValid is true +// iff k < the number of fields in tuple type T. +template <bool kIndexValid, int kIndex, class Tuple> +struct TupleElement; + + +$for i [[ +template <GTEST_$(n)_TYPENAMES_(T)> +struct TupleElement<true, $i, GTEST_$(n)_TUPLE_(T)> [[]] +{ typedef T$i type; }; + + +]] +} // namespace gtest_internal + +template <> +class tuple<> { + public: + tuple() {} + tuple(const tuple& /* t */) {} + tuple& operator=(const tuple& /* t */) { return *this; } +}; + + +$for k [[ +$range m 0..k-1 +template <GTEST_$(k)_TYPENAMES_(T)> +class $if k < n [[GTEST_$(k)_TUPLE_(T)]] $else [[tuple]] { + public: + template <int k> friend class gtest_internal::Get; + + tuple() : $for m, [[f$(m)_()]] {} + + explicit tuple($for m, [[GTEST_BY_REF_(T$m) f$m]]) : [[]] +$for m, [[f$(m)_(f$m)]] {} + + tuple(const tuple& t) : $for m, [[f$(m)_(t.f$(m)_)]] {} + + template <GTEST_$(k)_TYPENAMES_(U)> + tuple(const GTEST_$(k)_TUPLE_(U)& t) : $for m, [[f$(m)_(t.f$(m)_)]] {} + +$if k == 2 [[ + template <typename U0, typename U1> + tuple(const ::std::pair<U0, U1>& p) : f0_(p.first), f1_(p.second) {} + +]] + + tuple& operator=(const tuple& t) { return CopyFrom(t); } + + template <GTEST_$(k)_TYPENAMES_(U)> + tuple& operator=(const GTEST_$(k)_TUPLE_(U)& t) { + return CopyFrom(t); + } + +$if k == 2 [[ + template <typename U0, typename U1> + tuple& operator=(const ::std::pair<U0, U1>& p) { + f0_ = p.first; + f1_ = p.second; + return *this; + } + +]] + + GTEST_DECLARE_TUPLE_AS_FRIEND_ + + template <GTEST_$(k)_TYPENAMES_(U)> + tuple& CopyFrom(const GTEST_$(k)_TUPLE_(U)& t) { + +$for m [[ + f$(m)_ = t.f$(m)_; + +]] + return *this; + } + + +$for m [[ + T$m f$(m)_; + +]] +}; + + +]] +// 6.1.3.2 Tuple creation functions. + +// Known limitations: we don't support passing an +// std::tr1::reference_wrapper<T> to make_tuple(). And we don't +// implement tie(). + +inline tuple<> make_tuple() { return tuple<>(); } + +$for k [[ +$range m 0..k-1 + +template <GTEST_$(k)_TYPENAMES_(T)> +inline GTEST_$(k)_TUPLE_(T) make_tuple($for m, [[const T$m& f$m]]) { + return GTEST_$(k)_TUPLE_(T)($for m, [[f$m]]); +} + +]] + +// 6.1.3.3 Tuple helper classes. + +template <typename Tuple> struct tuple_size; + + +$for j [[ +template <GTEST_$(j)_TYPENAMES_(T)> +struct tuple_size<GTEST_$(j)_TUPLE_(T)> { static const int value = $j; }; + + +]] +template <int k, class Tuple> +struct tuple_element { + typedef typename gtest_internal::TupleElement< + k < (tuple_size<Tuple>::value), k, Tuple>::type type; +}; + +#define GTEST_TUPLE_ELEMENT_(k, Tuple) typename tuple_element<k, Tuple >::type + +// 6.1.3.4 Element access. + +namespace gtest_internal { + + +$for i [[ +template <> +class Get<$i> { + public: + template <class Tuple> + static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_($i, Tuple)) + Field(Tuple& t) { return t.f$(i)_; } // NOLINT + + template <class Tuple> + static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_($i, Tuple)) + ConstField(const Tuple& t) { return t.f$(i)_; } +}; + + +]] +} // namespace gtest_internal + +template <int k, GTEST_$(n)_TYPENAMES_(T)> +GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_$(n)_TUPLE_(T))) +get(GTEST_$(n)_TUPLE_(T)& t) { + return gtest_internal::Get<k>::Field(t); +} + +template <int k, GTEST_$(n)_TYPENAMES_(T)> +GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_$(n)_TUPLE_(T))) +get(const GTEST_$(n)_TUPLE_(T)& t) { + return gtest_internal::Get<k>::ConstField(t); +} + +// 6.1.3.5 Relational operators + +// We only implement == and !=, as we don't have a need for the rest yet. + +namespace gtest_internal { + +// SameSizeTuplePrefixComparator<k, k>::Eq(t1, t2) returns true if the +// first k fields of t1 equals the first k fields of t2. +// SameSizeTuplePrefixComparator(k1, k2) would be a compiler error if +// k1 != k2. +template <int kSize1, int kSize2> +struct SameSizeTuplePrefixComparator; + +template <> +struct SameSizeTuplePrefixComparator<0, 0> { + template <class Tuple1, class Tuple2> + static bool Eq(const Tuple1& /* t1 */, const Tuple2& /* t2 */) { + return true; + } +}; + +template <int k> +struct SameSizeTuplePrefixComparator<k, k> { + template <class Tuple1, class Tuple2> + static bool Eq(const Tuple1& t1, const Tuple2& t2) { + return SameSizeTuplePrefixComparator<k - 1, k - 1>::Eq(t1, t2) && + ::std::tr1::get<k - 1>(t1) == ::std::tr1::get<k - 1>(t2); + } +}; + +} // namespace gtest_internal + +template <GTEST_$(n)_TYPENAMES_(T), GTEST_$(n)_TYPENAMES_(U)> +inline bool operator==(const GTEST_$(n)_TUPLE_(T)& t, + const GTEST_$(n)_TUPLE_(U)& u) { + return gtest_internal::SameSizeTuplePrefixComparator< + tuple_size<GTEST_$(n)_TUPLE_(T)>::value, + tuple_size<GTEST_$(n)_TUPLE_(U)>::value>::Eq(t, u); +} + +template <GTEST_$(n)_TYPENAMES_(T), GTEST_$(n)_TYPENAMES_(U)> +inline bool operator!=(const GTEST_$(n)_TUPLE_(T)& t, + const GTEST_$(n)_TUPLE_(U)& u) { return !(t == u); } + +// 6.1.4 Pairs. +// Unimplemented. + +} // namespace tr1 +} // namespace std + + +$for j [[ +#undef GTEST_$(j)_TUPLE_ + +]] + + +$for j [[ +#undef GTEST_$(j)_TYPENAMES_ + +]] + +#undef GTEST_DECLARE_TUPLE_AS_FRIEND_ +#undef GTEST_BY_REF_ +#undef GTEST_ADD_REF_ +#undef GTEST_TUPLE_ELEMENT_ + +#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_ diff --git a/tests/gtest/include/gtest/internal/gtest-type-util.h b/tests/gtest/include/gtest/internal/gtest-type-util.h new file mode 100644 index 000000000..b7b01b094 --- /dev/null +++ b/tests/gtest/include/gtest/internal/gtest-type-util.h @@ -0,0 +1,3330 @@ +// This file was GENERATED by command: +// pump.py gtest-type-util.h.pump +// DO NOT EDIT BY HAND!!! + +// Copyright 2008 Google Inc. +// All Rights Reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Author: wan@google.com (Zhanyong Wan) + +// Type utilities needed for implementing typed and type-parameterized +// tests. This file is generated by a SCRIPT. DO NOT EDIT BY HAND! +// +// Currently we support at most 50 types in a list, and at most 50 +// type-parameterized tests in one type-parameterized test case. +// Please contact googletestframework@googlegroups.com if you need +// more. + +#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_ +#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_ + +#include "gtest/internal/gtest-port.h" +#include "gtest/internal/gtest-string.h" + +// #ifdef __GNUC__ is too general here. It is possible to use gcc without using +// libstdc++ (which is where cxxabi.h comes from). +# ifdef __GLIBCXX__ +# include <cxxabi.h> +# elif defined(__HP_aCC) +# include <acxx_demangle.h> +# endif // __GLIBCXX__ + +namespace testing { +namespace internal { + +// GetTypeName<T>() returns a human-readable name of type T. +// NB: This function is also used in Google Mock, so don't move it inside of +// the typed-test-only section below. +template <typename T> +String GetTypeName() { +# if GTEST_HAS_RTTI + + const char* const name = typeid(T).name(); +# if defined(__GLIBCXX__) || defined(__HP_aCC) + int status = 0; + // gcc's implementation of typeid(T).name() mangles the type name, + // so we have to demangle it. +# ifdef __GLIBCXX__ + using abi::__cxa_demangle; +# endif // __GLIBCXX__ + char* const readable_name = __cxa_demangle(name, 0, 0, &status); + const String name_str(status == 0 ? readable_name : name); + free(readable_name); + return name_str; +# else + return name; +# endif // __GLIBCXX__ || __HP_aCC + +# else + + return "<type>"; + +# endif // GTEST_HAS_RTTI +} + +#if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P + +// AssertyTypeEq<T1, T2>::type is defined iff T1 and T2 are the same +// type. This can be used as a compile-time assertion to ensure that +// two types are equal. + +template <typename T1, typename T2> +struct AssertTypeEq; + +template <typename T> +struct AssertTypeEq<T, T> { + typedef bool type; +}; + +// A unique type used as the default value for the arguments of class +// template Types. This allows us to simulate variadic templates +// (e.g. Types<int>, Type<int, double>, and etc), which C++ doesn't +// support directly. +struct None {}; + +// The following family of struct and struct templates are used to +// represent type lists. In particular, TypesN<T1, T2, ..., TN> +// represents a type list with N types (T1, T2, ..., and TN) in it. +// Except for Types0, every struct in the family has two member types: +// Head for the first type in the list, and Tail for the rest of the +// list. + +// The empty type list. +struct Types0 {}; + +// Type lists of length 1, 2, 3, and so on. + +template <typename T1> +struct Types1 { + typedef T1 Head; + typedef Types0 Tail; +}; +template <typename T1, typename T2> +struct Types2 { + typedef T1 Head; + typedef Types1<T2> Tail; +}; + +template <typename T1, typename T2, typename T3> +struct Types3 { + typedef T1 Head; + typedef Types2<T2, T3> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4> +struct Types4 { + typedef T1 Head; + typedef Types3<T2, T3, T4> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5> +struct Types5 { + typedef T1 Head; + typedef Types4<T2, T3, T4, T5> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6> +struct Types6 { + typedef T1 Head; + typedef Types5<T2, T3, T4, T5, T6> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7> +struct Types7 { + typedef T1 Head; + typedef Types6<T2, T3, T4, T5, T6, T7> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8> +struct Types8 { + typedef T1 Head; + typedef Types7<T2, T3, T4, T5, T6, T7, T8> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9> +struct Types9 { + typedef T1 Head; + typedef Types8<T2, T3, T4, T5, T6, T7, T8, T9> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10> +struct Types10 { + typedef T1 Head; + typedef Types9<T2, T3, T4, T5, T6, T7, T8, T9, T10> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11> +struct Types11 { + typedef T1 Head; + typedef Types10<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12> +struct Types12 { + typedef T1 Head; + typedef Types11<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13> +struct Types13 { + typedef T1 Head; + typedef Types12<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14> +struct Types14 { + typedef T1 Head; + typedef Types13<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15> +struct Types15 { + typedef T1 Head; + typedef Types14<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16> +struct Types16 { + typedef T1 Head; + typedef Types15<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17> +struct Types17 { + typedef T1 Head; + typedef Types16<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18> +struct Types18 { + typedef T1 Head; + typedef Types17<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19> +struct Types19 { + typedef T1 Head; + typedef Types18<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20> +struct Types20 { + typedef T1 Head; + typedef Types19<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21> +struct Types21 { + typedef T1 Head; + typedef Types20<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22> +struct Types22 { + typedef T1 Head; + typedef Types21<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23> +struct Types23 { + typedef T1 Head; + typedef Types22<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24> +struct Types24 { + typedef T1 Head; + typedef Types23<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25> +struct Types25 { + typedef T1 Head; + typedef Types24<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26> +struct Types26 { + typedef T1 Head; + typedef Types25<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27> +struct Types27 { + typedef T1 Head; + typedef Types26<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28> +struct Types28 { + typedef T1 Head; + typedef Types27<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29> +struct Types29 { + typedef T1 Head; + typedef Types28<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30> +struct Types30 { + typedef T1 Head; + typedef Types29<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31> +struct Types31 { + typedef T1 Head; + typedef Types30<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32> +struct Types32 { + typedef T1 Head; + typedef Types31<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33> +struct Types33 { + typedef T1 Head; + typedef Types32<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34> +struct Types34 { + typedef T1 Head; + typedef Types33<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35> +struct Types35 { + typedef T1 Head; + typedef Types34<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36> +struct Types36 { + typedef T1 Head; + typedef Types35<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35, T36> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37> +struct Types37 { + typedef T1 Head; + typedef Types36<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35, T36, T37> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38> +struct Types38 { + typedef T1 Head; + typedef Types37<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35, T36, T37, T38> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39> +struct Types39 { + typedef T1 Head; + typedef Types38<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40> +struct Types40 { + typedef T1 Head; + typedef Types39<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41> +struct Types41 { + typedef T1 Head; + typedef Types40<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42> +struct Types42 { + typedef T1 Head; + typedef Types41<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43> +struct Types43 { + typedef T1 Head; + typedef Types42<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, + T43> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43, typename T44> +struct Types44 { + typedef T1 Head; + typedef Types43<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, + T44> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43, typename T44, typename T45> +struct Types45 { + typedef T1 Head; + typedef Types44<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, + T44, T45> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43, typename T44, typename T45, + typename T46> +struct Types46 { + typedef T1 Head; + typedef Types45<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, + T44, T45, T46> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43, typename T44, typename T45, + typename T46, typename T47> +struct Types47 { + typedef T1 Head; + typedef Types46<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, + T44, T45, T46, T47> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43, typename T44, typename T45, + typename T46, typename T47, typename T48> +struct Types48 { + typedef T1 Head; + typedef Types47<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, + T44, T45, T46, T47, T48> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43, typename T44, typename T45, + typename T46, typename T47, typename T48, typename T49> +struct Types49 { + typedef T1 Head; + typedef Types48<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, + T44, T45, T46, T47, T48, T49> Tail; +}; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43, typename T44, typename T45, + typename T46, typename T47, typename T48, typename T49, typename T50> +struct Types50 { + typedef T1 Head; + typedef Types49<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, + T44, T45, T46, T47, T48, T49, T50> Tail; +}; + + +} // namespace internal + +// We don't want to require the users to write TypesN<...> directly, +// as that would require them to count the length. Types<...> is much +// easier to write, but generates horrible messages when there is a +// compiler error, as gcc insists on printing out each template +// argument, even if it has the default value (this means Types<int> +// will appear as Types<int, None, None, ..., None> in the compiler +// errors). +// +// Our solution is to combine the best part of the two approaches: a +// user would write Types<T1, ..., TN>, and Google Test will translate +// that to TypesN<T1, ..., TN> internally to make error messages +// readable. The translation is done by the 'type' member of the +// Types template. +template <typename T1 = internal::None, typename T2 = internal::None, + typename T3 = internal::None, typename T4 = internal::None, + typename T5 = internal::None, typename T6 = internal::None, + typename T7 = internal::None, typename T8 = internal::None, + typename T9 = internal::None, typename T10 = internal::None, + typename T11 = internal::None, typename T12 = internal::None, + typename T13 = internal::None, typename T14 = internal::None, + typename T15 = internal::None, typename T16 = internal::None, + typename T17 = internal::None, typename T18 = internal::None, + typename T19 = internal::None, typename T20 = internal::None, + typename T21 = internal::None, typename T22 = internal::None, + typename T23 = internal::None, typename T24 = internal::None, + typename T25 = internal::None, typename T26 = internal::None, + typename T27 = internal::None, typename T28 = internal::None, + typename T29 = internal::None, typename T30 = internal::None, + typename T31 = internal::None, typename T32 = internal::None, + typename T33 = internal::None, typename T34 = internal::None, + typename T35 = internal::None, typename T36 = internal::None, + typename T37 = internal::None, typename T38 = internal::None, + typename T39 = internal::None, typename T40 = internal::None, + typename T41 = internal::None, typename T42 = internal::None, + typename T43 = internal::None, typename T44 = internal::None, + typename T45 = internal::None, typename T46 = internal::None, + typename T47 = internal::None, typename T48 = internal::None, + typename T49 = internal::None, typename T50 = internal::None> +struct Types { + typedef internal::Types50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, + T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, + T41, T42, T43, T44, T45, T46, T47, T48, T49, T50> type; +}; + +template <> +struct Types<internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None> { + typedef internal::Types0 type; +}; +template <typename T1> +struct Types<T1, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None> { + typedef internal::Types1<T1> type; +}; +template <typename T1, typename T2> +struct Types<T1, T2, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None> { + typedef internal::Types2<T1, T2> type; +}; +template <typename T1, typename T2, typename T3> +struct Types<T1, T2, T3, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None> { + typedef internal::Types3<T1, T2, T3> type; +}; +template <typename T1, typename T2, typename T3, typename T4> +struct Types<T1, T2, T3, T4, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None> { + typedef internal::Types4<T1, T2, T3, T4> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5> +struct Types<T1, T2, T3, T4, T5, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None> { + typedef internal::Types5<T1, T2, T3, T4, T5> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6> +struct Types<T1, T2, T3, T4, T5, T6, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None> { + typedef internal::Types6<T1, T2, T3, T4, T5, T6> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7> +struct Types<T1, T2, T3, T4, T5, T6, T7, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None> { + typedef internal::Types7<T1, T2, T3, T4, T5, T6, T7> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None> { + typedef internal::Types8<T1, T2, T3, T4, T5, T6, T7, T8> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None> { + typedef internal::Types9<T1, T2, T3, T4, T5, T6, T7, T8, T9> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None> { + typedef internal::Types10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None> { + typedef internal::Types11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None> { + typedef internal::Types12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, + T12> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None> { + typedef internal::Types13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None> { + typedef internal::Types14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None> { + typedef internal::Types15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None> { + typedef internal::Types16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None> { + typedef internal::Types17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None> { + typedef internal::Types18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None> { + typedef internal::Types19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None> { + typedef internal::Types20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None> { + typedef internal::Types21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None> { + typedef internal::Types22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None> { + typedef internal::Types23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None> { + typedef internal::Types24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None> { + typedef internal::Types25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None> { + typedef internal::Types26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, + T26> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None> { + typedef internal::Types27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, + T27> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None> { + typedef internal::Types28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, + T27, T28> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None> { + typedef internal::Types29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, + T27, T28, T29> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None> { + typedef internal::Types30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, + T27, T28, T29, T30> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, + T31, internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None> { + typedef internal::Types31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, + T27, T28, T29, T30, T31> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, + T31, T32, internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None> { + typedef internal::Types32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, + T27, T28, T29, T30, T31, T32> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, + T31, T32, T33, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None> { + typedef internal::Types33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, + T27, T28, T29, T30, T31, T32, T33> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, + T31, T32, T33, T34, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None> { + typedef internal::Types34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, + T27, T28, T29, T30, T31, T32, T33, T34> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, + T31, T32, T33, T34, T35, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None> { + typedef internal::Types35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, + T27, T28, T29, T30, T31, T32, T33, T34, T35> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, + T31, T32, T33, T34, T35, T36, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None> { + typedef internal::Types36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, + T27, T28, T29, T30, T31, T32, T33, T34, T35, T36> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, + T31, T32, T33, T34, T35, T36, T37, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None> { + typedef internal::Types37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, + T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, + T31, T32, T33, T34, T35, T36, T37, T38, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None> { + typedef internal::Types38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, + T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, + T31, T32, T33, T34, T35, T36, T37, T38, T39, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None> { + typedef internal::Types39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, + T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None> { + typedef internal::Types40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, + T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, + T40> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None, internal::None> { + typedef internal::Types41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, + T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, + T41> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, internal::None, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None> { + typedef internal::Types42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, + T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, + T41, T42> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None, internal::None> { + typedef internal::Types43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, + T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, + T41, T42, T43> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43, typename T44> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, + internal::None, internal::None, internal::None, internal::None, + internal::None, internal::None> { + typedef internal::Types44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, + T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, + T41, T42, T43, T44> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43, typename T44, typename T45> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, + internal::None, internal::None, internal::None, internal::None, + internal::None> { + typedef internal::Types45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, + T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, + T41, T42, T43, T44, T45> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43, typename T44, typename T45, + typename T46> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, + T46, internal::None, internal::None, internal::None, internal::None> { + typedef internal::Types46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, + T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, + T41, T42, T43, T44, T45, T46> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43, typename T44, typename T45, + typename T46, typename T47> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, + T46, T47, internal::None, internal::None, internal::None> { + typedef internal::Types47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, + T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, + T41, T42, T43, T44, T45, T46, T47> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43, typename T44, typename T45, + typename T46, typename T47, typename T48> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, + T46, T47, T48, internal::None, internal::None> { + typedef internal::Types48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, + T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, + T41, T42, T43, T44, T45, T46, T47, T48> type; +}; +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43, typename T44, typename T45, + typename T46, typename T47, typename T48, typename T49> +struct Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, + T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, + T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, + T46, T47, T48, T49, internal::None> { + typedef internal::Types49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, + T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, + T41, T42, T43, T44, T45, T46, T47, T48, T49> type; +}; + +namespace internal { + +# define GTEST_TEMPLATE_ template <typename T> class + +// The template "selector" struct TemplateSel<Tmpl> is used to +// represent Tmpl, which must be a class template with one type +// parameter, as a type. TemplateSel<Tmpl>::Bind<T>::type is defined +// as the type Tmpl<T>. This allows us to actually instantiate the +// template "selected" by TemplateSel<Tmpl>. +// +// This trick is necessary for simulating typedef for class templates, +// which C++ doesn't support directly. +template <GTEST_TEMPLATE_ Tmpl> +struct TemplateSel { + template <typename T> + struct Bind { + typedef Tmpl<T> type; + }; +}; + +# define GTEST_BIND_(TmplSel, T) \ + TmplSel::template Bind<T>::type + +// A unique struct template used as the default value for the +// arguments of class template Templates. This allows us to simulate +// variadic templates (e.g. Templates<int>, Templates<int, double>, +// and etc), which C++ doesn't support directly. +template <typename T> +struct NoneT {}; + +// The following family of struct and struct templates are used to +// represent template lists. In particular, TemplatesN<T1, T2, ..., +// TN> represents a list of N templates (T1, T2, ..., and TN). Except +// for Templates0, every struct in the family has two member types: +// Head for the selector of the first template in the list, and Tail +// for the rest of the list. + +// The empty template list. +struct Templates0 {}; + +// Template lists of length 1, 2, 3, and so on. + +template <GTEST_TEMPLATE_ T1> +struct Templates1 { + typedef TemplateSel<T1> Head; + typedef Templates0 Tail; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2> +struct Templates2 { + typedef TemplateSel<T1> Head; + typedef Templates1<T2> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3> +struct Templates3 { + typedef TemplateSel<T1> Head; + typedef Templates2<T2, T3> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4> +struct Templates4 { + typedef TemplateSel<T1> Head; + typedef Templates3<T2, T3, T4> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5> +struct Templates5 { + typedef TemplateSel<T1> Head; + typedef Templates4<T2, T3, T4, T5> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6> +struct Templates6 { + typedef TemplateSel<T1> Head; + typedef Templates5<T2, T3, T4, T5, T6> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7> +struct Templates7 { + typedef TemplateSel<T1> Head; + typedef Templates6<T2, T3, T4, T5, T6, T7> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8> +struct Templates8 { + typedef TemplateSel<T1> Head; + typedef Templates7<T2, T3, T4, T5, T6, T7, T8> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9> +struct Templates9 { + typedef TemplateSel<T1> Head; + typedef Templates8<T2, T3, T4, T5, T6, T7, T8, T9> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10> +struct Templates10 { + typedef TemplateSel<T1> Head; + typedef Templates9<T2, T3, T4, T5, T6, T7, T8, T9, T10> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11> +struct Templates11 { + typedef TemplateSel<T1> Head; + typedef Templates10<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12> +struct Templates12 { + typedef TemplateSel<T1> Head; + typedef Templates11<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13> +struct Templates13 { + typedef TemplateSel<T1> Head; + typedef Templates12<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14> +struct Templates14 { + typedef TemplateSel<T1> Head; + typedef Templates13<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15> +struct Templates15 { + typedef TemplateSel<T1> Head; + typedef Templates14<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16> +struct Templates16 { + typedef TemplateSel<T1> Head; + typedef Templates15<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17> +struct Templates17 { + typedef TemplateSel<T1> Head; + typedef Templates16<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18> +struct Templates18 { + typedef TemplateSel<T1> Head; + typedef Templates17<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19> +struct Templates19 { + typedef TemplateSel<T1> Head; + typedef Templates18<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20> +struct Templates20 { + typedef TemplateSel<T1> Head; + typedef Templates19<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21> +struct Templates21 { + typedef TemplateSel<T1> Head; + typedef Templates20<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22> +struct Templates22 { + typedef TemplateSel<T1> Head; + typedef Templates21<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23> +struct Templates23 { + typedef TemplateSel<T1> Head; + typedef Templates22<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24> +struct Templates24 { + typedef TemplateSel<T1> Head; + typedef Templates23<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25> +struct Templates25 { + typedef TemplateSel<T1> Head; + typedef Templates24<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26> +struct Templates26 { + typedef TemplateSel<T1> Head; + typedef Templates25<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27> +struct Templates27 { + typedef TemplateSel<T1> Head; + typedef Templates26<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28> +struct Templates28 { + typedef TemplateSel<T1> Head; + typedef Templates27<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, + T28> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29> +struct Templates29 { + typedef TemplateSel<T1> Head; + typedef Templates28<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30> +struct Templates30 { + typedef TemplateSel<T1> Head; + typedef Templates29<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31> +struct Templates31 { + typedef TemplateSel<T1> Head; + typedef Templates30<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32> +struct Templates32 { + typedef TemplateSel<T1> Head; + typedef Templates31<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33> +struct Templates33 { + typedef TemplateSel<T1> Head; + typedef Templates32<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34> +struct Templates34 { + typedef TemplateSel<T1> Head; + typedef Templates33<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35> +struct Templates35 { + typedef TemplateSel<T1> Head; + typedef Templates34<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36> +struct Templates36 { + typedef TemplateSel<T1> Head; + typedef Templates35<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36, + GTEST_TEMPLATE_ T37> +struct Templates37 { + typedef TemplateSel<T1> Head; + typedef Templates36<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36, T37> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36, + GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38> +struct Templates38 { + typedef TemplateSel<T1> Head; + typedef Templates37<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36, + GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39> +struct Templates39 { + typedef TemplateSel<T1> Head; + typedef Templates38<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36, + GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39, + GTEST_TEMPLATE_ T40> +struct Templates40 { + typedef TemplateSel<T1> Head; + typedef Templates39<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36, + GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39, + GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41> +struct Templates41 { + typedef TemplateSel<T1> Head; + typedef Templates40<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36, + GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39, + GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42> +struct Templates42 { + typedef TemplateSel<T1> Head; + typedef Templates41<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, + T42> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36, + GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39, + GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42, + GTEST_TEMPLATE_ T43> +struct Templates43 { + typedef TemplateSel<T1> Head; + typedef Templates42<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, + T43> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36, + GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39, + GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42, + GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44> +struct Templates44 { + typedef TemplateSel<T1> Head; + typedef Templates43<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, + T43, T44> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36, + GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39, + GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42, + GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45> +struct Templates45 { + typedef TemplateSel<T1> Head; + typedef Templates44<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, + T43, T44, T45> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36, + GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39, + GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42, + GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45, + GTEST_TEMPLATE_ T46> +struct Templates46 { + typedef TemplateSel<T1> Head; + typedef Templates45<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, + T43, T44, T45, T46> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36, + GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39, + GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42, + GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45, + GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47> +struct Templates47 { + typedef TemplateSel<T1> Head; + typedef Templates46<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, + T43, T44, T45, T46, T47> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36, + GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39, + GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42, + GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45, + GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48> +struct Templates48 { + typedef TemplateSel<T1> Head; + typedef Templates47<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, + T43, T44, T45, T46, T47, T48> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36, + GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39, + GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42, + GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45, + GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48, + GTEST_TEMPLATE_ T49> +struct Templates49 { + typedef TemplateSel<T1> Head; + typedef Templates48<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, + T43, T44, T45, T46, T47, T48, T49> Tail; +}; + +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36, + GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39, + GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42, + GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45, + GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48, + GTEST_TEMPLATE_ T49, GTEST_TEMPLATE_ T50> +struct Templates50 { + typedef TemplateSel<T1> Head; + typedef Templates49<T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, + T43, T44, T45, T46, T47, T48, T49, T50> Tail; +}; + + +// We don't want to require the users to write TemplatesN<...> directly, +// as that would require them to count the length. Templates<...> is much +// easier to write, but generates horrible messages when there is a +// compiler error, as gcc insists on printing out each template +// argument, even if it has the default value (this means Templates<list> +// will appear as Templates<list, NoneT, NoneT, ..., NoneT> in the compiler +// errors). +// +// Our solution is to combine the best part of the two approaches: a +// user would write Templates<T1, ..., TN>, and Google Test will translate +// that to TemplatesN<T1, ..., TN> internally to make error messages +// readable. The translation is done by the 'type' member of the +// Templates template. +template <GTEST_TEMPLATE_ T1 = NoneT, GTEST_TEMPLATE_ T2 = NoneT, + GTEST_TEMPLATE_ T3 = NoneT, GTEST_TEMPLATE_ T4 = NoneT, + GTEST_TEMPLATE_ T5 = NoneT, GTEST_TEMPLATE_ T6 = NoneT, + GTEST_TEMPLATE_ T7 = NoneT, GTEST_TEMPLATE_ T8 = NoneT, + GTEST_TEMPLATE_ T9 = NoneT, GTEST_TEMPLATE_ T10 = NoneT, + GTEST_TEMPLATE_ T11 = NoneT, GTEST_TEMPLATE_ T12 = NoneT, + GTEST_TEMPLATE_ T13 = NoneT, GTEST_TEMPLATE_ T14 = NoneT, + GTEST_TEMPLATE_ T15 = NoneT, GTEST_TEMPLATE_ T16 = NoneT, + GTEST_TEMPLATE_ T17 = NoneT, GTEST_TEMPLATE_ T18 = NoneT, + GTEST_TEMPLATE_ T19 = NoneT, GTEST_TEMPLATE_ T20 = NoneT, + GTEST_TEMPLATE_ T21 = NoneT, GTEST_TEMPLATE_ T22 = NoneT, + GTEST_TEMPLATE_ T23 = NoneT, GTEST_TEMPLATE_ T24 = NoneT, + GTEST_TEMPLATE_ T25 = NoneT, GTEST_TEMPLATE_ T26 = NoneT, + GTEST_TEMPLATE_ T27 = NoneT, GTEST_TEMPLATE_ T28 = NoneT, + GTEST_TEMPLATE_ T29 = NoneT, GTEST_TEMPLATE_ T30 = NoneT, + GTEST_TEMPLATE_ T31 = NoneT, GTEST_TEMPLATE_ T32 = NoneT, + GTEST_TEMPLATE_ T33 = NoneT, GTEST_TEMPLATE_ T34 = NoneT, + GTEST_TEMPLATE_ T35 = NoneT, GTEST_TEMPLATE_ T36 = NoneT, + GTEST_TEMPLATE_ T37 = NoneT, GTEST_TEMPLATE_ T38 = NoneT, + GTEST_TEMPLATE_ T39 = NoneT, GTEST_TEMPLATE_ T40 = NoneT, + GTEST_TEMPLATE_ T41 = NoneT, GTEST_TEMPLATE_ T42 = NoneT, + GTEST_TEMPLATE_ T43 = NoneT, GTEST_TEMPLATE_ T44 = NoneT, + GTEST_TEMPLATE_ T45 = NoneT, GTEST_TEMPLATE_ T46 = NoneT, + GTEST_TEMPLATE_ T47 = NoneT, GTEST_TEMPLATE_ T48 = NoneT, + GTEST_TEMPLATE_ T49 = NoneT, GTEST_TEMPLATE_ T50 = NoneT> +struct Templates { + typedef Templates50<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, + T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, + T42, T43, T44, T45, T46, T47, T48, T49, T50> type; +}; + +template <> +struct Templates<NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT> { + typedef Templates0 type; +}; +template <GTEST_TEMPLATE_ T1> +struct Templates<T1, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT> { + typedef Templates1<T1> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2> +struct Templates<T1, T2, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT> { + typedef Templates2<T1, T2> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3> +struct Templates<T1, T2, T3, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates3<T1, T2, T3> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4> +struct Templates<T1, T2, T3, T4, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates4<T1, T2, T3, T4> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5> +struct Templates<T1, T2, T3, T4, T5, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates5<T1, T2, T3, T4, T5> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6> +struct Templates<T1, T2, T3, T4, T5, T6, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates6<T1, T2, T3, T4, T5, T6> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7> +struct Templates<T1, T2, T3, T4, T5, T6, T7, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates7<T1, T2, T3, T4, T5, T6, T7> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates8<T1, T2, T3, T4, T5, T6, T7, T8> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates9<T1, T2, T3, T4, T5, T6, T7, T8, T9> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates10<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates11<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates12<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates13<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates14<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates15<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates16<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates17<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT> { + typedef Templates18<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT> { + typedef Templates19<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT> { + typedef Templates20<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT> { + typedef Templates21<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT> { + typedef Templates22<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT> { + typedef Templates23<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT> { + typedef Templates24<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT> { + typedef Templates25<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT> { + typedef Templates26<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT> { + typedef Templates27<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, + T27> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT> { + typedef Templates28<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, + T28> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT> { + typedef Templates29<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, + T28, T29> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates30<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, + T28, T29, T30> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates31<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, + T28, T29, T30, T31> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates32<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, + T28, T29, T30, T31, T32> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates33<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, + T28, T29, T30, T31, T32, T33> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates34<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, + T28, T29, T30, T31, T32, T33, T34> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates35<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, + T28, T29, T30, T31, T32, T33, T34, T35> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35, T36, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates36<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, + T28, T29, T30, T31, T32, T33, T34, T35, T36> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36, + GTEST_TEMPLATE_ T37> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35, T36, T37, NoneT, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates37<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, + T28, T29, T30, T31, T32, T33, T34, T35, T36, T37> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36, + GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35, T36, T37, T38, NoneT, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates38<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, + T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36, + GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates39<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, + T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36, + GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39, + GTEST_TEMPLATE_ T40> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, NoneT, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates40<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, + T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36, + GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39, + GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, NoneT, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates41<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, + T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, + T41> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36, + GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39, + GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, NoneT, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates42<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, + T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, + T42> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36, + GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39, + GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42, + GTEST_TEMPLATE_ T43> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates43<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, + T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, + T42, T43> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36, + GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39, + GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42, + GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, + NoneT, NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates44<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, + T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, + T42, T43, T44> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36, + GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39, + GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42, + GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, + T45, NoneT, NoneT, NoneT, NoneT, NoneT> { + typedef Templates45<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, + T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, + T42, T43, T44, T45> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36, + GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39, + GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42, + GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45, + GTEST_TEMPLATE_ T46> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, + T45, T46, NoneT, NoneT, NoneT, NoneT> { + typedef Templates46<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, + T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, + T42, T43, T44, T45, T46> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36, + GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39, + GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42, + GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45, + GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, + T45, T46, T47, NoneT, NoneT, NoneT> { + typedef Templates47<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, + T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, + T42, T43, T44, T45, T46, T47> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36, + GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39, + GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42, + GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45, + GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, + T45, T46, T47, T48, NoneT, NoneT> { + typedef Templates48<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, + T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, + T42, T43, T44, T45, T46, T47, T48> type; +}; +template <GTEST_TEMPLATE_ T1, GTEST_TEMPLATE_ T2, GTEST_TEMPLATE_ T3, + GTEST_TEMPLATE_ T4, GTEST_TEMPLATE_ T5, GTEST_TEMPLATE_ T6, + GTEST_TEMPLATE_ T7, GTEST_TEMPLATE_ T8, GTEST_TEMPLATE_ T9, + GTEST_TEMPLATE_ T10, GTEST_TEMPLATE_ T11, GTEST_TEMPLATE_ T12, + GTEST_TEMPLATE_ T13, GTEST_TEMPLATE_ T14, GTEST_TEMPLATE_ T15, + GTEST_TEMPLATE_ T16, GTEST_TEMPLATE_ T17, GTEST_TEMPLATE_ T18, + GTEST_TEMPLATE_ T19, GTEST_TEMPLATE_ T20, GTEST_TEMPLATE_ T21, + GTEST_TEMPLATE_ T22, GTEST_TEMPLATE_ T23, GTEST_TEMPLATE_ T24, + GTEST_TEMPLATE_ T25, GTEST_TEMPLATE_ T26, GTEST_TEMPLATE_ T27, + GTEST_TEMPLATE_ T28, GTEST_TEMPLATE_ T29, GTEST_TEMPLATE_ T30, + GTEST_TEMPLATE_ T31, GTEST_TEMPLATE_ T32, GTEST_TEMPLATE_ T33, + GTEST_TEMPLATE_ T34, GTEST_TEMPLATE_ T35, GTEST_TEMPLATE_ T36, + GTEST_TEMPLATE_ T37, GTEST_TEMPLATE_ T38, GTEST_TEMPLATE_ T39, + GTEST_TEMPLATE_ T40, GTEST_TEMPLATE_ T41, GTEST_TEMPLATE_ T42, + GTEST_TEMPLATE_ T43, GTEST_TEMPLATE_ T44, GTEST_TEMPLATE_ T45, + GTEST_TEMPLATE_ T46, GTEST_TEMPLATE_ T47, GTEST_TEMPLATE_ T48, + GTEST_TEMPLATE_ T49> +struct Templates<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, + T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, + T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, + T45, T46, T47, T48, T49, NoneT> { + typedef Templates49<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, + T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, + T42, T43, T44, T45, T46, T47, T48, T49> type; +}; + +// The TypeList template makes it possible to use either a single type +// or a Types<...> list in TYPED_TEST_CASE() and +// INSTANTIATE_TYPED_TEST_CASE_P(). + +template <typename T> +struct TypeList { typedef Types1<T> type; }; + +template <typename T1, typename T2, typename T3, typename T4, typename T5, + typename T6, typename T7, typename T8, typename T9, typename T10, + typename T11, typename T12, typename T13, typename T14, typename T15, + typename T16, typename T17, typename T18, typename T19, typename T20, + typename T21, typename T22, typename T23, typename T24, typename T25, + typename T26, typename T27, typename T28, typename T29, typename T30, + typename T31, typename T32, typename T33, typename T34, typename T35, + typename T36, typename T37, typename T38, typename T39, typename T40, + typename T41, typename T42, typename T43, typename T44, typename T45, + typename T46, typename T47, typename T48, typename T49, typename T50> +struct TypeList<Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, + T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, + T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, + T44, T45, T46, T47, T48, T49, T50> > { + typedef typename Types<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, + T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, + T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, + T41, T42, T43, T44, T45, T46, T47, T48, T49, T50>::type type; +}; + +#endif // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P + +} // namespace internal +} // namespace testing + +#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_ diff --git a/tests/gtest/include/gtest/internal/gtest-type-util.h.pump b/tests/gtest/include/gtest/internal/gtest-type-util.h.pump new file mode 100644 index 000000000..27f331dea --- /dev/null +++ b/tests/gtest/include/gtest/internal/gtest-type-util.h.pump @@ -0,0 +1,296 @@ +$$ -*- mode: c++; -*- +$var n = 50 $$ Maximum length of type lists we want to support. +// Copyright 2008 Google Inc. +// All Rights Reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Author: wan@google.com (Zhanyong Wan) + +// Type utilities needed for implementing typed and type-parameterized +// tests. This file is generated by a SCRIPT. DO NOT EDIT BY HAND! +// +// Currently we support at most $n types in a list, and at most $n +// type-parameterized tests in one type-parameterized test case. +// Please contact googletestframework@googlegroups.com if you need +// more. + +#ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_ +#define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_ + +#include "gtest/internal/gtest-port.h" +#include "gtest/internal/gtest-string.h" + +// #ifdef __GNUC__ is too general here. It is possible to use gcc without using +// libstdc++ (which is where cxxabi.h comes from). +# ifdef __GLIBCXX__ +# include <cxxabi.h> +# elif defined(__HP_aCC) +# include <acxx_demangle.h> +# endif // __GLIBCXX__ + +namespace testing { +namespace internal { + +// GetTypeName<T>() returns a human-readable name of type T. +// NB: This function is also used in Google Mock, so don't move it inside of +// the typed-test-only section below. +template <typename T> +String GetTypeName() { +# if GTEST_HAS_RTTI + + const char* const name = typeid(T).name(); +# if defined(__GLIBCXX__) || defined(__HP_aCC) + int status = 0; + // gcc's implementation of typeid(T).name() mangles the type name, + // so we have to demangle it. +# ifdef __GLIBCXX__ + using abi::__cxa_demangle; +# endif // __GLIBCXX__ + char* const readable_name = __cxa_demangle(name, 0, 0, &status); + const String name_str(status == 0 ? readable_name : name); + free(readable_name); + return name_str; +# else + return name; +# endif // __GLIBCXX__ || __HP_aCC + +# else + + return "<type>"; + +# endif // GTEST_HAS_RTTI +} + +#if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P + +// AssertyTypeEq<T1, T2>::type is defined iff T1 and T2 are the same +// type. This can be used as a compile-time assertion to ensure that +// two types are equal. + +template <typename T1, typename T2> +struct AssertTypeEq; + +template <typename T> +struct AssertTypeEq<T, T> { + typedef bool type; +}; + +// A unique type used as the default value for the arguments of class +// template Types. This allows us to simulate variadic templates +// (e.g. Types<int>, Type<int, double>, and etc), which C++ doesn't +// support directly. +struct None {}; + +// The following family of struct and struct templates are used to +// represent type lists. In particular, TypesN<T1, T2, ..., TN> +// represents a type list with N types (T1, T2, ..., and TN) in it. +// Except for Types0, every struct in the family has two member types: +// Head for the first type in the list, and Tail for the rest of the +// list. + +// The empty type list. +struct Types0 {}; + +// Type lists of length 1, 2, 3, and so on. + +template <typename T1> +struct Types1 { + typedef T1 Head; + typedef Types0 Tail; +}; + +$range i 2..n + +$for i [[ +$range j 1..i +$range k 2..i +template <$for j, [[typename T$j]]> +struct Types$i { + typedef T1 Head; + typedef Types$(i-1)<$for k, [[T$k]]> Tail; +}; + + +]] + +} // namespace internal + +// We don't want to require the users to write TypesN<...> directly, +// as that would require them to count the length. Types<...> is much +// easier to write, but generates horrible messages when there is a +// compiler error, as gcc insists on printing out each template +// argument, even if it has the default value (this means Types<int> +// will appear as Types<int, None, None, ..., None> in the compiler +// errors). +// +// Our solution is to combine the best part of the two approaches: a +// user would write Types<T1, ..., TN>, and Google Test will translate +// that to TypesN<T1, ..., TN> internally to make error messages +// readable. The translation is done by the 'type' member of the +// Types template. + +$range i 1..n +template <$for i, [[typename T$i = internal::None]]> +struct Types { + typedef internal::Types$n<$for i, [[T$i]]> type; +}; + +template <> +struct Types<$for i, [[internal::None]]> { + typedef internal::Types0 type; +}; + +$range i 1..n-1 +$for i [[ +$range j 1..i +$range k i+1..n +template <$for j, [[typename T$j]]> +struct Types<$for j, [[T$j]]$for k[[, internal::None]]> { + typedef internal::Types$i<$for j, [[T$j]]> type; +}; + +]] + +namespace internal { + +# define GTEST_TEMPLATE_ template <typename T> class + +// The template "selector" struct TemplateSel<Tmpl> is used to +// represent Tmpl, which must be a class template with one type +// parameter, as a type. TemplateSel<Tmpl>::Bind<T>::type is defined +// as the type Tmpl<T>. This allows us to actually instantiate the +// template "selected" by TemplateSel<Tmpl>. +// +// This trick is necessary for simulating typedef for class templates, +// which C++ doesn't support directly. +template <GTEST_TEMPLATE_ Tmpl> +struct TemplateSel { + template <typename T> + struct Bind { + typedef Tmpl<T> type; + }; +}; + +# define GTEST_BIND_(TmplSel, T) \ + TmplSel::template Bind<T>::type + +// A unique struct template used as the default value for the +// arguments of class template Templates. This allows us to simulate +// variadic templates (e.g. Templates<int>, Templates<int, double>, +// and etc), which C++ doesn't support directly. +template <typename T> +struct NoneT {}; + +// The following family of struct and struct templates are used to +// represent template lists. In particular, TemplatesN<T1, T2, ..., +// TN> represents a list of N templates (T1, T2, ..., and TN). Except +// for Templates0, every struct in the family has two member types: +// Head for the selector of the first template in the list, and Tail +// for the rest of the list. + +// The empty template list. +struct Templates0 {}; + +// Template lists of length 1, 2, 3, and so on. + +template <GTEST_TEMPLATE_ T1> +struct Templates1 { + typedef TemplateSel<T1> Head; + typedef Templates0 Tail; +}; + +$range i 2..n + +$for i [[ +$range j 1..i +$range k 2..i +template <$for j, [[GTEST_TEMPLATE_ T$j]]> +struct Templates$i { + typedef TemplateSel<T1> Head; + typedef Templates$(i-1)<$for k, [[T$k]]> Tail; +}; + + +]] + +// We don't want to require the users to write TemplatesN<...> directly, +// as that would require them to count the length. Templates<...> is much +// easier to write, but generates horrible messages when there is a +// compiler error, as gcc insists on printing out each template +// argument, even if it has the default value (this means Templates<list> +// will appear as Templates<list, NoneT, NoneT, ..., NoneT> in the compiler +// errors). +// +// Our solution is to combine the best part of the two approaches: a +// user would write Templates<T1, ..., TN>, and Google Test will translate +// that to TemplatesN<T1, ..., TN> internally to make error messages +// readable. The translation is done by the 'type' member of the +// Templates template. + +$range i 1..n +template <$for i, [[GTEST_TEMPLATE_ T$i = NoneT]]> +struct Templates { + typedef Templates$n<$for i, [[T$i]]> type; +}; + +template <> +struct Templates<$for i, [[NoneT]]> { + typedef Templates0 type; +}; + +$range i 1..n-1 +$for i [[ +$range j 1..i +$range k i+1..n +template <$for j, [[GTEST_TEMPLATE_ T$j]]> +struct Templates<$for j, [[T$j]]$for k[[, NoneT]]> { + typedef Templates$i<$for j, [[T$j]]> type; +}; + +]] + +// The TypeList template makes it possible to use either a single type +// or a Types<...> list in TYPED_TEST_CASE() and +// INSTANTIATE_TYPED_TEST_CASE_P(). + +template <typename T> +struct TypeList { typedef Types1<T> type; }; + + +$range i 1..n +template <$for i, [[typename T$i]]> +struct TypeList<Types<$for i, [[T$i]]> > { + typedef typename Types<$for i, [[T$i]]>::type type; +}; + +#endif // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P + +} // namespace internal +} // namespace testing + +#endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_ diff --git a/tests/gtest/src/gtest-all.cc b/tests/gtest/src/gtest-all.cc new file mode 100644 index 000000000..0a9cee522 --- /dev/null +++ b/tests/gtest/src/gtest-all.cc @@ -0,0 +1,48 @@ +// Copyright 2008, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Author: mheule@google.com (Markus Heule) +// +// Google C++ Testing Framework (Google Test) +// +// Sometimes it's desirable to build Google Test by compiling a single file. +// This file serves this purpose. + +// This line ensures that gtest.h can be compiled on its own, even +// when it's fused. +#include "gtest/gtest.h" + +// The following lines pull in the real gtest *.cc files. +#include "src/gtest.cc" +#include "src/gtest-death-test.cc" +#include "src/gtest-filepath.cc" +#include "src/gtest-port.cc" +#include "src/gtest-printers.cc" +#include "src/gtest-test-part.cc" +#include "src/gtest-typed-test.cc" diff --git a/tests/gtest/src/gtest-death-test.cc b/tests/gtest/src/gtest-death-test.cc new file mode 100644 index 000000000..8b2e4131c --- /dev/null +++ b/tests/gtest/src/gtest-death-test.cc @@ -0,0 +1,1234 @@ +// Copyright 2005, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Author: wan@google.com (Zhanyong Wan), vladl@google.com (Vlad Losev) +// +// This file implements death tests. + +#include "gtest/gtest-death-test.h" +#include "gtest/internal/gtest-port.h" + +#if GTEST_HAS_DEATH_TEST + +# if GTEST_OS_MAC +# include <crt_externs.h> +# endif // GTEST_OS_MAC + +# include <errno.h> +# include <fcntl.h> +# include <limits.h> +# include <stdarg.h> + +# if GTEST_OS_WINDOWS +# include <windows.h> +# else +# include <sys/mman.h> +# include <sys/wait.h> +# endif // GTEST_OS_WINDOWS + +#endif // GTEST_HAS_DEATH_TEST + +#include "gtest/gtest-message.h" +#include "gtest/internal/gtest-string.h" + +// Indicates that this translation unit is part of Google Test's +// implementation. It must come before gtest-internal-inl.h is +// included, or there will be a compiler error. This trick is to +// prevent a user from accidentally including gtest-internal-inl.h in +// his code. +#define GTEST_IMPLEMENTATION_ 1 +#include "src/gtest-internal-inl.h" +#undef GTEST_IMPLEMENTATION_ + +namespace testing { + +// Constants. + +// The default death test style. +static const char kDefaultDeathTestStyle[] = "fast"; + +GTEST_DEFINE_string_( + death_test_style, + internal::StringFromGTestEnv("death_test_style", kDefaultDeathTestStyle), + "Indicates how to run a death test in a forked child process: " + "\"threadsafe\" (child process re-executes the test binary " + "from the beginning, running only the specific death test) or " + "\"fast\" (child process runs the death test immediately " + "after forking)."); + +GTEST_DEFINE_bool_( + death_test_use_fork, + internal::BoolFromGTestEnv("death_test_use_fork", false), + "Instructs to use fork()/_exit() instead of clone() in death tests. " + "Ignored and always uses fork() on POSIX systems where clone() is not " + "implemented. Useful when running under valgrind or similar tools if " + "those do not support clone(). Valgrind 3.3.1 will just fail if " + "it sees an unsupported combination of clone() flags. " + "It is not recommended to use this flag w/o valgrind though it will " + "work in 99% of the cases. Once valgrind is fixed, this flag will " + "most likely be removed."); + +namespace internal { +GTEST_DEFINE_string_( + internal_run_death_test, "", + "Indicates the file, line number, temporal index of " + "the single death test to run, and a file descriptor to " + "which a success code may be sent, all separated by " + "colons. This flag is specified if and only if the current " + "process is a sub-process launched for running a thread-safe " + "death test. FOR INTERNAL USE ONLY."); +} // namespace internal + +#if GTEST_HAS_DEATH_TEST + +// ExitedWithCode constructor. +ExitedWithCode::ExitedWithCode(int exit_code) : exit_code_(exit_code) { +} + +// ExitedWithCode function-call operator. +bool ExitedWithCode::operator()(int exit_status) const { +# if GTEST_OS_WINDOWS + + return exit_status == exit_code_; + +# else + + return WIFEXITED(exit_status) && WEXITSTATUS(exit_status) == exit_code_; + +# endif // GTEST_OS_WINDOWS +} + +# if !GTEST_OS_WINDOWS +// KilledBySignal constructor. +KilledBySignal::KilledBySignal(int signum) : signum_(signum) { +} + +// KilledBySignal function-call operator. +bool KilledBySignal::operator()(int exit_status) const { + return WIFSIGNALED(exit_status) && WTERMSIG(exit_status) == signum_; +} +# endif // !GTEST_OS_WINDOWS + +namespace internal { + +// Utilities needed for death tests. + +// Generates a textual description of a given exit code, in the format +// specified by wait(2). +static String ExitSummary(int exit_code) { + Message m; + +# if GTEST_OS_WINDOWS + + m << "Exited with exit status " << exit_code; + +# else + + if (WIFEXITED(exit_code)) { + m << "Exited with exit status " << WEXITSTATUS(exit_code); + } else if (WIFSIGNALED(exit_code)) { + m << "Terminated by signal " << WTERMSIG(exit_code); + } +# ifdef WCOREDUMP + if (WCOREDUMP(exit_code)) { + m << " (core dumped)"; + } +# endif +# endif // GTEST_OS_WINDOWS + + return m.GetString(); +} + +// Returns true if exit_status describes a process that was terminated +// by a signal, or exited normally with a nonzero exit code. +bool ExitedUnsuccessfully(int exit_status) { + return !ExitedWithCode(0)(exit_status); +} + +# if !GTEST_OS_WINDOWS +// Generates a textual failure message when a death test finds more than +// one thread running, or cannot determine the number of threads, prior +// to executing the given statement. It is the responsibility of the +// caller not to pass a thread_count of 1. +static String DeathTestThreadWarning(size_t thread_count) { + Message msg; + msg << "Death tests use fork(), which is unsafe particularly" + << " in a threaded context. For this test, " << GTEST_NAME_ << " "; + if (thread_count == 0) + msg << "couldn't detect the number of threads."; + else + msg << "detected " << thread_count << " threads."; + return msg.GetString(); +} +# endif // !GTEST_OS_WINDOWS + +// Flag characters for reporting a death test that did not die. +static const char kDeathTestLived = 'L'; +static const char kDeathTestReturned = 'R'; +static const char kDeathTestThrew = 'T'; +static const char kDeathTestInternalError = 'I'; + +// An enumeration describing all of the possible ways that a death test can +// conclude. DIED means that the process died while executing the test +// code; LIVED means that process lived beyond the end of the test code; +// RETURNED means that the test statement attempted to execute a return +// statement, which is not allowed; THREW means that the test statement +// returned control by throwing an exception. IN_PROGRESS means the test +// has not yet concluded. +// TODO(vladl@google.com): Unify names and possibly values for +// AbortReason, DeathTestOutcome, and flag characters above. +enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }; + +// Routine for aborting the program which is safe to call from an +// exec-style death test child process, in which case the error +// message is propagated back to the parent process. Otherwise, the +// message is simply printed to stderr. In either case, the program +// then exits with status 1. +void DeathTestAbort(const String& message) { + // On a POSIX system, this function may be called from a threadsafe-style + // death test child process, which operates on a very small stack. Use + // the heap for any additional non-minuscule memory requirements. + const InternalRunDeathTestFlag* const flag = + GetUnitTestImpl()->internal_run_death_test_flag(); + if (flag != NULL) { + FILE* parent = posix::FDOpen(flag->write_fd(), "w"); + fputc(kDeathTestInternalError, parent); + fprintf(parent, "%s", message.c_str()); + fflush(parent); + _exit(1); + } else { + fprintf(stderr, "%s", message.c_str()); + fflush(stderr); + posix::Abort(); + } +} + +// A replacement for CHECK that calls DeathTestAbort if the assertion +// fails. +# define GTEST_DEATH_TEST_CHECK_(expression) \ + do { \ + if (!::testing::internal::IsTrue(expression)) { \ + DeathTestAbort(::testing::internal::String::Format( \ + "CHECK failed: File %s, line %d: %s", \ + __FILE__, __LINE__, #expression)); \ + } \ + } while (::testing::internal::AlwaysFalse()) + +// This macro is similar to GTEST_DEATH_TEST_CHECK_, but it is meant for +// evaluating any system call that fulfills two conditions: it must return +// -1 on failure, and set errno to EINTR when it is interrupted and +// should be tried again. The macro expands to a loop that repeatedly +// evaluates the expression as long as it evaluates to -1 and sets +// errno to EINTR. If the expression evaluates to -1 but errno is +// something other than EINTR, DeathTestAbort is called. +# define GTEST_DEATH_TEST_CHECK_SYSCALL_(expression) \ + do { \ + int gtest_retval; \ + do { \ + gtest_retval = (expression); \ + } while (gtest_retval == -1 && errno == EINTR); \ + if (gtest_retval == -1) { \ + DeathTestAbort(::testing::internal::String::Format( \ + "CHECK failed: File %s, line %d: %s != -1", \ + __FILE__, __LINE__, #expression)); \ + } \ + } while (::testing::internal::AlwaysFalse()) + +// Returns the message describing the last system error in errno. +String GetLastErrnoDescription() { + return String(errno == 0 ? "" : posix::StrError(errno)); +} + +// This is called from a death test parent process to read a failure +// message from the death test child process and log it with the FATAL +// severity. On Windows, the message is read from a pipe handle. On other +// platforms, it is read from a file descriptor. +static void FailFromInternalError(int fd) { + Message error; + char buffer[256]; + int num_read; + + do { + while ((num_read = posix::Read(fd, buffer, 255)) > 0) { + buffer[num_read] = '\0'; + error << buffer; + } + } while (num_read == -1 && errno == EINTR); + + if (num_read == 0) { + GTEST_LOG_(FATAL) << error.GetString(); + } else { + const int last_error = errno; + GTEST_LOG_(FATAL) << "Error while reading death test internal: " + << GetLastErrnoDescription() << " [" << last_error << "]"; + } +} + +// Death test constructor. Increments the running death test count +// for the current test. +DeathTest::DeathTest() { + TestInfo* const info = GetUnitTestImpl()->current_test_info(); + if (info == NULL) { + DeathTestAbort("Cannot run a death test outside of a TEST or " + "TEST_F construct"); + } +} + +// Creates and returns a death test by dispatching to the current +// death test factory. +bool DeathTest::Create(const char* statement, const RE* regex, + const char* file, int line, DeathTest** test) { + return GetUnitTestImpl()->death_test_factory()->Create( + statement, regex, file, line, test); +} + +const char* DeathTest::LastMessage() { + return last_death_test_message_.c_str(); +} + +void DeathTest::set_last_death_test_message(const String& message) { + last_death_test_message_ = message; +} + +String DeathTest::last_death_test_message_; + +// Provides cross platform implementation for some death functionality. +class DeathTestImpl : public DeathTest { + protected: + DeathTestImpl(const char* a_statement, const RE* a_regex) + : statement_(a_statement), + regex_(a_regex), + spawned_(false), + status_(-1), + outcome_(IN_PROGRESS), + read_fd_(-1), + write_fd_(-1) {} + + // read_fd_ is expected to be closed and cleared by a derived class. + ~DeathTestImpl() { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); } + + void Abort(AbortReason reason); + virtual bool Passed(bool status_ok); + + const char* statement() const { return statement_; } + const RE* regex() const { return regex_; } + bool spawned() const { return spawned_; } + void set_spawned(bool is_spawned) { spawned_ = is_spawned; } + int status() const { return status_; } + void set_status(int a_status) { status_ = a_status; } + DeathTestOutcome outcome() const { return outcome_; } + void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outcome; } + int read_fd() const { return read_fd_; } + void set_read_fd(int fd) { read_fd_ = fd; } + int write_fd() const { return write_fd_; } + void set_write_fd(int fd) { write_fd_ = fd; } + + // Called in the parent process only. Reads the result code of the death + // test child process via a pipe, interprets it to set the outcome_ + // member, and closes read_fd_. Outputs diagnostics and terminates in + // case of unexpected codes. + void ReadAndInterpretStatusByte(); + + private: + // The textual content of the code this object is testing. This class + // doesn't own this string and should not attempt to delete it. + const char* const statement_; + // The regular expression which test output must match. DeathTestImpl + // doesn't own this object and should not attempt to delete it. + const RE* const regex_; + // True if the death test child process has been successfully spawned. + bool spawned_; + // The exit status of the child process. + int status_; + // How the death test concluded. + DeathTestOutcome outcome_; + // Descriptor to the read end of the pipe to the child process. It is + // always -1 in the child process. The child keeps its write end of the + // pipe in write_fd_. + int read_fd_; + // Descriptor to the child's write end of the pipe to the parent process. + // It is always -1 in the parent process. The parent keeps its end of the + // pipe in read_fd_. + int write_fd_; +}; + +// Called in the parent process only. Reads the result code of the death +// test child process via a pipe, interprets it to set the outcome_ +// member, and closes read_fd_. Outputs diagnostics and terminates in +// case of unexpected codes. +void DeathTestImpl::ReadAndInterpretStatusByte() { + char flag; + int bytes_read; + + // The read() here blocks until data is available (signifying the + // failure of the death test) or until the pipe is closed (signifying + // its success), so it's okay to call this in the parent before + // the child process has exited. + do { + bytes_read = posix::Read(read_fd(), &flag, 1); + } while (bytes_read == -1 && errno == EINTR); + + if (bytes_read == 0) { + set_outcome(DIED); + } else if (bytes_read == 1) { + switch (flag) { + case kDeathTestReturned: + set_outcome(RETURNED); + break; + case kDeathTestThrew: + set_outcome(THREW); + break; + case kDeathTestLived: + set_outcome(LIVED); + break; + case kDeathTestInternalError: + FailFromInternalError(read_fd()); // Does not return. + break; + default: + GTEST_LOG_(FATAL) << "Death test child process reported " + << "unexpected status byte (" + << static_cast<unsigned int>(flag) << ")"; + } + } else { + GTEST_LOG_(FATAL) << "Read from death test child process failed: " + << GetLastErrnoDescription(); + } + GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Close(read_fd())); + set_read_fd(-1); +} + +// Signals that the death test code which should have exited, didn't. +// Should be called only in a death test child process. +// Writes a status byte to the child's status file descriptor, then +// calls _exit(1). +void DeathTestImpl::Abort(AbortReason reason) { + // The parent process considers the death test to be a failure if + // it finds any data in our pipe. So, here we write a single flag byte + // to the pipe, then exit. + const char status_ch = + reason == TEST_DID_NOT_DIE ? kDeathTestLived : + reason == TEST_THREW_EXCEPTION ? kDeathTestThrew : kDeathTestReturned; + + GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Write(write_fd(), &status_ch, 1)); + // We are leaking the descriptor here because on some platforms (i.e., + // when built as Windows DLL), destructors of global objects will still + // run after calling _exit(). On such systems, write_fd_ will be + // indirectly closed from the destructor of UnitTestImpl, causing double + // close if it is also closed here. On debug configurations, double close + // may assert. As there are no in-process buffers to flush here, we are + // relying on the OS to close the descriptor after the process terminates + // when the destructors are not run. + _exit(1); // Exits w/o any normal exit hooks (we were supposed to crash) +} + +// Returns an indented copy of stderr output for a death test. +// This makes distinguishing death test output lines from regular log lines +// much easier. +static ::std::string FormatDeathTestOutput(const ::std::string& output) { + ::std::string ret; + for (size_t at = 0; ; ) { + const size_t line_end = output.find('\n', at); + ret += "[ DEATH ] "; + if (line_end == ::std::string::npos) { + ret += output.substr(at); + break; + } + ret += output.substr(at, line_end + 1 - at); + at = line_end + 1; + } + return ret; +} + +// Assesses the success or failure of a death test, using both private +// members which have previously been set, and one argument: +// +// Private data members: +// outcome: An enumeration describing how the death test +// concluded: DIED, LIVED, THREW, or RETURNED. The death test +// fails in the latter three cases. +// status: The exit status of the child process. On *nix, it is in the +// in the format specified by wait(2). On Windows, this is the +// value supplied to the ExitProcess() API or a numeric code +// of the exception that terminated the program. +// regex: A regular expression object to be applied to +// the test's captured standard error output; the death test +// fails if it does not match. +// +// Argument: +// status_ok: true if exit_status is acceptable in the context of +// this particular death test, which fails if it is false +// +// Returns true iff all of the above conditions are met. Otherwise, the +// first failing condition, in the order given above, is the one that is +// reported. Also sets the last death test message string. +bool DeathTestImpl::Passed(bool status_ok) { + if (!spawned()) + return false; + + const String error_message = GetCapturedStderr(); + + bool success = false; + Message buffer; + + buffer << "Death test: " << statement() << "\n"; + switch (outcome()) { + case LIVED: + buffer << " Result: failed to die.\n" + << " Error msg:\n" << FormatDeathTestOutput(error_message); + break; + case THREW: + buffer << " Result: threw an exception.\n" + << " Error msg:\n" << FormatDeathTestOutput(error_message); + break; + case RETURNED: + buffer << " Result: illegal return in test statement.\n" + << " Error msg:\n" << FormatDeathTestOutput(error_message); + break; + case DIED: + if (status_ok) { + const bool matched = RE::PartialMatch(error_message.c_str(), *regex()); + if (matched) { + success = true; + } else { + buffer << " Result: died but not with expected error.\n" + << " Expected: " << regex()->pattern() << "\n" + << "Actual msg:\n" << FormatDeathTestOutput(error_message); + } + } else { + buffer << " Result: died but not with expected exit code:\n" + << " " << ExitSummary(status()) << "\n" + << "Actual msg:\n" << FormatDeathTestOutput(error_message); + } + break; + case IN_PROGRESS: + default: + GTEST_LOG_(FATAL) + << "DeathTest::Passed somehow called before conclusion of test"; + } + + DeathTest::set_last_death_test_message(buffer.GetString()); + return success; +} + +# if GTEST_OS_WINDOWS +// WindowsDeathTest implements death tests on Windows. Due to the +// specifics of starting new processes on Windows, death tests there are +// always threadsafe, and Google Test considers the +// --gtest_death_test_style=fast setting to be equivalent to +// --gtest_death_test_style=threadsafe there. +// +// A few implementation notes: Like the Linux version, the Windows +// implementation uses pipes for child-to-parent communication. But due to +// the specifics of pipes on Windows, some extra steps are required: +// +// 1. The parent creates a communication pipe and stores handles to both +// ends of it. +// 2. The parent starts the child and provides it with the information +// necessary to acquire the handle to the write end of the pipe. +// 3. The child acquires the write end of the pipe and signals the parent +// using a Windows event. +// 4. Now the parent can release the write end of the pipe on its side. If +// this is done before step 3, the object's reference count goes down to +// 0 and it is destroyed, preventing the child from acquiring it. The +// parent now has to release it, or read operations on the read end of +// the pipe will not return when the child terminates. +// 5. The parent reads child's output through the pipe (outcome code and +// any possible error messages) from the pipe, and its stderr and then +// determines whether to fail the test. +// +// Note: to distinguish Win32 API calls from the local method and function +// calls, the former are explicitly resolved in the global namespace. +// +class WindowsDeathTest : public DeathTestImpl { + public: + WindowsDeathTest(const char* a_statement, + const RE* a_regex, + const char* file, + int line) + : DeathTestImpl(a_statement, a_regex), file_(file), line_(line) {} + + // All of these virtual functions are inherited from DeathTest. + virtual int Wait(); + virtual TestRole AssumeRole(); + + private: + // The name of the file in which the death test is located. + const char* const file_; + // The line number on which the death test is located. + const int line_; + // Handle to the write end of the pipe to the child process. + AutoHandle write_handle_; + // Child process handle. + AutoHandle child_handle_; + // Event the child process uses to signal the parent that it has + // acquired the handle to the write end of the pipe. After seeing this + // event the parent can release its own handles to make sure its + // ReadFile() calls return when the child terminates. + AutoHandle event_handle_; +}; + +// Waits for the child in a death test to exit, returning its exit +// status, or 0 if no child process exists. As a side effect, sets the +// outcome data member. +int WindowsDeathTest::Wait() { + if (!spawned()) + return 0; + + // Wait until the child either signals that it has acquired the write end + // of the pipe or it dies. + const HANDLE wait_handles[2] = { child_handle_.Get(), event_handle_.Get() }; + switch (::WaitForMultipleObjects(2, + wait_handles, + FALSE, // Waits for any of the handles. + INFINITE)) { + case WAIT_OBJECT_0: + case WAIT_OBJECT_0 + 1: + break; + default: + GTEST_DEATH_TEST_CHECK_(false); // Should not get here. + } + + // The child has acquired the write end of the pipe or exited. + // We release the handle on our side and continue. + write_handle_.Reset(); + event_handle_.Reset(); + + ReadAndInterpretStatusByte(); + + // Waits for the child process to exit if it haven't already. This + // returns immediately if the child has already exited, regardless of + // whether previous calls to WaitForMultipleObjects synchronized on this + // handle or not. + GTEST_DEATH_TEST_CHECK_( + WAIT_OBJECT_0 == ::WaitForSingleObject(child_handle_.Get(), + INFINITE)); + DWORD status_code; + GTEST_DEATH_TEST_CHECK_( + ::GetExitCodeProcess(child_handle_.Get(), &status_code) != FALSE); + child_handle_.Reset(); + set_status(static_cast<int>(status_code)); + return status(); +} + +// The AssumeRole process for a Windows death test. It creates a child +// process with the same executable as the current process to run the +// death test. The child process is given the --gtest_filter and +// --gtest_internal_run_death_test flags such that it knows to run the +// current death test only. +DeathTest::TestRole WindowsDeathTest::AssumeRole() { + const UnitTestImpl* const impl = GetUnitTestImpl(); + const InternalRunDeathTestFlag* const flag = + impl->internal_run_death_test_flag(); + const TestInfo* const info = impl->current_test_info(); + const int death_test_index = info->result()->death_test_count(); + + if (flag != NULL) { + // ParseInternalRunDeathTestFlag() has performed all the necessary + // processing. + set_write_fd(flag->write_fd()); + return EXECUTE_TEST; + } + + // WindowsDeathTest uses an anonymous pipe to communicate results of + // a death test. + SECURITY_ATTRIBUTES handles_are_inheritable = { + sizeof(SECURITY_ATTRIBUTES), NULL, TRUE }; + HANDLE read_handle, write_handle; + GTEST_DEATH_TEST_CHECK_( + ::CreatePipe(&read_handle, &write_handle, &handles_are_inheritable, + 0) // Default buffer size. + != FALSE); + set_read_fd(::_open_osfhandle(reinterpret_cast<intptr_t>(read_handle), + O_RDONLY)); + write_handle_.Reset(write_handle); + event_handle_.Reset(::CreateEvent( + &handles_are_inheritable, + TRUE, // The event will automatically reset to non-signaled state. + FALSE, // The initial state is non-signalled. + NULL)); // The even is unnamed. + GTEST_DEATH_TEST_CHECK_(event_handle_.Get() != NULL); + const String filter_flag = String::Format("--%s%s=%s.%s", + GTEST_FLAG_PREFIX_, kFilterFlag, + info->test_case_name(), + info->name()); + const String internal_flag = String::Format( + "--%s%s=%s|%d|%d|%u|%Iu|%Iu", + GTEST_FLAG_PREFIX_, + kInternalRunDeathTestFlag, + file_, line_, + death_test_index, + static_cast<unsigned int>(::GetCurrentProcessId()), + // size_t has the same with as pointers on both 32-bit and 64-bit + // Windows platforms. + // See http://msdn.microsoft.com/en-us/library/tcxf1dw6.aspx. + reinterpret_cast<size_t>(write_handle), + reinterpret_cast<size_t>(event_handle_.Get())); + + char executable_path[_MAX_PATH + 1]; // NOLINT + GTEST_DEATH_TEST_CHECK_( + _MAX_PATH + 1 != ::GetModuleFileNameA(NULL, + executable_path, + _MAX_PATH)); + + String command_line = String::Format("%s %s \"%s\"", + ::GetCommandLineA(), + filter_flag.c_str(), + internal_flag.c_str()); + + DeathTest::set_last_death_test_message(""); + + CaptureStderr(); + // Flush the log buffers since the log streams are shared with the child. + FlushInfoLog(); + + // The child process will share the standard handles with the parent. + STARTUPINFOA startup_info; + memset(&startup_info, 0, sizeof(STARTUPINFO)); + startup_info.dwFlags = STARTF_USESTDHANDLES; + startup_info.hStdInput = ::GetStdHandle(STD_INPUT_HANDLE); + startup_info.hStdOutput = ::GetStdHandle(STD_OUTPUT_HANDLE); + startup_info.hStdError = ::GetStdHandle(STD_ERROR_HANDLE); + + PROCESS_INFORMATION process_info; + GTEST_DEATH_TEST_CHECK_(::CreateProcessA( + executable_path, + const_cast<char*>(command_line.c_str()), + NULL, // Retuned process handle is not inheritable. + NULL, // Retuned thread handle is not inheritable. + TRUE, // Child inherits all inheritable handles (for write_handle_). + 0x0, // Default creation flags. + NULL, // Inherit the parent's environment. + UnitTest::GetInstance()->original_working_dir(), + &startup_info, + &process_info) != FALSE); + child_handle_.Reset(process_info.hProcess); + ::CloseHandle(process_info.hThread); + set_spawned(true); + return OVERSEE_TEST; +} +# else // We are not on Windows. + +// ForkingDeathTest provides implementations for most of the abstract +// methods of the DeathTest interface. Only the AssumeRole method is +// left undefined. +class ForkingDeathTest : public DeathTestImpl { + public: + ForkingDeathTest(const char* statement, const RE* regex); + + // All of these virtual functions are inherited from DeathTest. + virtual int Wait(); + + protected: + void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; } + + private: + // PID of child process during death test; 0 in the child process itself. + pid_t child_pid_; +}; + +// Constructs a ForkingDeathTest. +ForkingDeathTest::ForkingDeathTest(const char* a_statement, const RE* a_regex) + : DeathTestImpl(a_statement, a_regex), + child_pid_(-1) {} + +// Waits for the child in a death test to exit, returning its exit +// status, or 0 if no child process exists. As a side effect, sets the +// outcome data member. +int ForkingDeathTest::Wait() { + if (!spawned()) + return 0; + + ReadAndInterpretStatusByte(); + + int status_value; + GTEST_DEATH_TEST_CHECK_SYSCALL_(waitpid(child_pid_, &status_value, 0)); + set_status(status_value); + return status_value; +} + +// A concrete death test class that forks, then immediately runs the test +// in the child process. +class NoExecDeathTest : public ForkingDeathTest { + public: + NoExecDeathTest(const char* a_statement, const RE* a_regex) : + ForkingDeathTest(a_statement, a_regex) { } + virtual TestRole AssumeRole(); +}; + +// The AssumeRole process for a fork-and-run death test. It implements a +// straightforward fork, with a simple pipe to transmit the status byte. +DeathTest::TestRole NoExecDeathTest::AssumeRole() { + const size_t thread_count = GetThreadCount(); + if (thread_count != 1) { + GTEST_LOG_(WARNING) << DeathTestThreadWarning(thread_count); + } + + int pipe_fd[2]; + GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1); + + DeathTest::set_last_death_test_message(""); + CaptureStderr(); + // When we fork the process below, the log file buffers are copied, but the + // file descriptors are shared. We flush all log files here so that closing + // the file descriptors in the child process doesn't throw off the + // synchronization between descriptors and buffers in the parent process. + // This is as close to the fork as possible to avoid a race condition in case + // there are multiple threads running before the death test, and another + // thread writes to the log file. + FlushInfoLog(); + + const pid_t child_pid = fork(); + GTEST_DEATH_TEST_CHECK_(child_pid != -1); + set_child_pid(child_pid); + if (child_pid == 0) { + GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[0])); + set_write_fd(pipe_fd[1]); + // Redirects all logging to stderr in the child process to prevent + // concurrent writes to the log files. We capture stderr in the parent + // process and append the child process' output to a log. + LogToStderr(); + // Event forwarding to the listeners of event listener API mush be shut + // down in death test subprocesses. + GetUnitTestImpl()->listeners()->SuppressEventForwarding(); + return EXECUTE_TEST; + } else { + GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1])); + set_read_fd(pipe_fd[0]); + set_spawned(true); + return OVERSEE_TEST; + } +} + +// A concrete death test class that forks and re-executes the main +// program from the beginning, with command-line flags set that cause +// only this specific death test to be run. +class ExecDeathTest : public ForkingDeathTest { + public: + ExecDeathTest(const char* a_statement, const RE* a_regex, + const char* file, int line) : + ForkingDeathTest(a_statement, a_regex), file_(file), line_(line) { } + virtual TestRole AssumeRole(); + private: + // The name of the file in which the death test is located. + const char* const file_; + // The line number on which the death test is located. + const int line_; +}; + +// Utility class for accumulating command-line arguments. +class Arguments { + public: + Arguments() { + args_.push_back(NULL); + } + + ~Arguments() { + for (std::vector<char*>::iterator i = args_.begin(); i != args_.end(); + ++i) { + free(*i); + } + } + void AddArgument(const char* argument) { + args_.insert(args_.end() - 1, posix::StrDup(argument)); + } + + template <typename Str> + void AddArguments(const ::std::vector<Str>& arguments) { + for (typename ::std::vector<Str>::const_iterator i = arguments.begin(); + i != arguments.end(); + ++i) { + args_.insert(args_.end() - 1, posix::StrDup(i->c_str())); + } + } + char* const* Argv() { + return &args_[0]; + } + private: + std::vector<char*> args_; +}; + +// A struct that encompasses the arguments to the child process of a +// threadsafe-style death test process. +struct ExecDeathTestArgs { + char* const* argv; // Command-line arguments for the child's call to exec + int close_fd; // File descriptor to close; the read end of a pipe +}; + +# if GTEST_OS_MAC +inline char** GetEnviron() { + // When Google Test is built as a framework on MacOS X, the environ variable + // is unavailable. Apple's documentation (man environ) recommends using + // _NSGetEnviron() instead. + return *_NSGetEnviron(); +} +# else +// Some POSIX platforms expect you to declare environ. extern "C" makes +// it reside in the global namespace. +extern "C" char** environ; +inline char** GetEnviron() { return environ; } +# endif // GTEST_OS_MAC + +// The main function for a threadsafe-style death test child process. +// This function is called in a clone()-ed process and thus must avoid +// any potentially unsafe operations like malloc or libc functions. +static int ExecDeathTestChildMain(void* child_arg) { + ExecDeathTestArgs* const args = static_cast<ExecDeathTestArgs*>(child_arg); + GTEST_DEATH_TEST_CHECK_SYSCALL_(close(args->close_fd)); + + // We need to execute the test program in the same environment where + // it was originally invoked. Therefore we change to the original + // working directory first. + const char* const original_dir = + UnitTest::GetInstance()->original_working_dir(); + // We can safely call chdir() as it's a direct system call. + if (chdir(original_dir) != 0) { + DeathTestAbort(String::Format("chdir(\"%s\") failed: %s", + original_dir, + GetLastErrnoDescription().c_str())); + return EXIT_FAILURE; + } + + // We can safely call execve() as it's a direct system call. We + // cannot use execvp() as it's a libc function and thus potentially + // unsafe. Since execve() doesn't search the PATH, the user must + // invoke the test program via a valid path that contains at least + // one path separator. + execve(args->argv[0], args->argv, GetEnviron()); + DeathTestAbort(String::Format("execve(%s, ...) in %s failed: %s", + args->argv[0], + original_dir, + GetLastErrnoDescription().c_str())); + return EXIT_FAILURE; +} + +// Two utility routines that together determine the direction the stack +// grows. +// This could be accomplished more elegantly by a single recursive +// function, but we want to guard against the unlikely possibility of +// a smart compiler optimizing the recursion away. +// +// GTEST_NO_INLINE_ is required to prevent GCC 4.6 from inlining +// StackLowerThanAddress into StackGrowsDown, which then doesn't give +// correct answer. +bool StackLowerThanAddress(const void* ptr) GTEST_NO_INLINE_; +bool StackLowerThanAddress(const void* ptr) { + int dummy; + return &dummy < ptr; +} + +bool StackGrowsDown() { + int dummy; + return StackLowerThanAddress(&dummy); +} + +// A threadsafe implementation of fork(2) for threadsafe-style death tests +// that uses clone(2). It dies with an error message if anything goes +// wrong. +static pid_t ExecDeathTestFork(char* const* argv, int close_fd) { + ExecDeathTestArgs args = { argv, close_fd }; + pid_t child_pid = -1; + +# if GTEST_HAS_CLONE + const bool use_fork = GTEST_FLAG(death_test_use_fork); + + if (!use_fork) { + static const bool stack_grows_down = StackGrowsDown(); + const size_t stack_size = getpagesize(); + // MMAP_ANONYMOUS is not defined on Mac, so we use MAP_ANON instead. + void* const stack = mmap(NULL, stack_size, PROT_READ | PROT_WRITE, + MAP_ANON | MAP_PRIVATE, -1, 0); + GTEST_DEATH_TEST_CHECK_(stack != MAP_FAILED); + void* const stack_top = + static_cast<char*>(stack) + (stack_grows_down ? stack_size : 0); + + child_pid = clone(&ExecDeathTestChildMain, stack_top, SIGCHLD, &args); + + GTEST_DEATH_TEST_CHECK_(munmap(stack, stack_size) != -1); + } +# else + const bool use_fork = true; +# endif // GTEST_HAS_CLONE + + if (use_fork && (child_pid = fork()) == 0) { + ExecDeathTestChildMain(&args); + _exit(0); + } + + GTEST_DEATH_TEST_CHECK_(child_pid != -1); + return child_pid; +} + +// The AssumeRole process for a fork-and-exec death test. It re-executes the +// main program from the beginning, setting the --gtest_filter +// and --gtest_internal_run_death_test flags to cause only the current +// death test to be re-run. +DeathTest::TestRole ExecDeathTest::AssumeRole() { + const UnitTestImpl* const impl = GetUnitTestImpl(); + const InternalRunDeathTestFlag* const flag = + impl->internal_run_death_test_flag(); + const TestInfo* const info = impl->current_test_info(); + const int death_test_index = info->result()->death_test_count(); + + if (flag != NULL) { + set_write_fd(flag->write_fd()); + return EXECUTE_TEST; + } + + int pipe_fd[2]; + GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1); + // Clear the close-on-exec flag on the write end of the pipe, lest + // it be closed when the child process does an exec: + GTEST_DEATH_TEST_CHECK_(fcntl(pipe_fd[1], F_SETFD, 0) != -1); + + const String filter_flag = + String::Format("--%s%s=%s.%s", + GTEST_FLAG_PREFIX_, kFilterFlag, + info->test_case_name(), info->name()); + const String internal_flag = + String::Format("--%s%s=%s|%d|%d|%d", + GTEST_FLAG_PREFIX_, kInternalRunDeathTestFlag, + file_, line_, death_test_index, pipe_fd[1]); + Arguments args; + args.AddArguments(GetArgvs()); + args.AddArgument(filter_flag.c_str()); + args.AddArgument(internal_flag.c_str()); + + DeathTest::set_last_death_test_message(""); + + CaptureStderr(); + // See the comment in NoExecDeathTest::AssumeRole for why the next line + // is necessary. + FlushInfoLog(); + + const pid_t child_pid = ExecDeathTestFork(args.Argv(), pipe_fd[0]); + GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1])); + set_child_pid(child_pid); + set_read_fd(pipe_fd[0]); + set_spawned(true); + return OVERSEE_TEST; +} + +# endif // !GTEST_OS_WINDOWS + +// Creates a concrete DeathTest-derived class that depends on the +// --gtest_death_test_style flag, and sets the pointer pointed to +// by the "test" argument to its address. If the test should be +// skipped, sets that pointer to NULL. Returns true, unless the +// flag is set to an invalid value. +bool DefaultDeathTestFactory::Create(const char* statement, const RE* regex, + const char* file, int line, + DeathTest** test) { + UnitTestImpl* const impl = GetUnitTestImpl(); + const InternalRunDeathTestFlag* const flag = + impl->internal_run_death_test_flag(); + const int death_test_index = impl->current_test_info() + ->increment_death_test_count(); + + if (flag != NULL) { + if (death_test_index > flag->index()) { + DeathTest::set_last_death_test_message(String::Format( + "Death test count (%d) somehow exceeded expected maximum (%d)", + death_test_index, flag->index())); + return false; + } + + if (!(flag->file() == file && flag->line() == line && + flag->index() == death_test_index)) { + *test = NULL; + return true; + } + } + +# if GTEST_OS_WINDOWS + + if (GTEST_FLAG(death_test_style) == "threadsafe" || + GTEST_FLAG(death_test_style) == "fast") { + *test = new WindowsDeathTest(statement, regex, file, line); + } + +# else + + if (GTEST_FLAG(death_test_style) == "threadsafe") { + *test = new ExecDeathTest(statement, regex, file, line); + } else if (GTEST_FLAG(death_test_style) == "fast") { + *test = new NoExecDeathTest(statement, regex); + } + +# endif // GTEST_OS_WINDOWS + + else { // NOLINT - this is more readable than unbalanced brackets inside #if. + DeathTest::set_last_death_test_message(String::Format( + "Unknown death test style \"%s\" encountered", + GTEST_FLAG(death_test_style).c_str())); + return false; + } + + return true; +} + +// Splits a given string on a given delimiter, populating a given +// vector with the fields. GTEST_HAS_DEATH_TEST implies that we have +// ::std::string, so we can use it here. +static void SplitString(const ::std::string& str, char delimiter, + ::std::vector< ::std::string>* dest) { + ::std::vector< ::std::string> parsed; + ::std::string::size_type pos = 0; + while (::testing::internal::AlwaysTrue()) { + const ::std::string::size_type colon = str.find(delimiter, pos); + if (colon == ::std::string::npos) { + parsed.push_back(str.substr(pos)); + break; + } else { + parsed.push_back(str.substr(pos, colon - pos)); + pos = colon + 1; + } + } + dest->swap(parsed); +} + +# if GTEST_OS_WINDOWS +// Recreates the pipe and event handles from the provided parameters, +// signals the event, and returns a file descriptor wrapped around the pipe +// handle. This function is called in the child process only. +int GetStatusFileDescriptor(unsigned int parent_process_id, + size_t write_handle_as_size_t, + size_t event_handle_as_size_t) { + AutoHandle parent_process_handle(::OpenProcess(PROCESS_DUP_HANDLE, + FALSE, // Non-inheritable. + parent_process_id)); + if (parent_process_handle.Get() == INVALID_HANDLE_VALUE) { + DeathTestAbort(String::Format("Unable to open parent process %u", + parent_process_id)); + } + + // TODO(vladl@google.com): Replace the following check with a + // compile-time assertion when available. + GTEST_CHECK_(sizeof(HANDLE) <= sizeof(size_t)); + + const HANDLE write_handle = + reinterpret_cast<HANDLE>(write_handle_as_size_t); + HANDLE dup_write_handle; + + // The newly initialized handle is accessible only in in the parent + // process. To obtain one accessible within the child, we need to use + // DuplicateHandle. + if (!::DuplicateHandle(parent_process_handle.Get(), write_handle, + ::GetCurrentProcess(), &dup_write_handle, + 0x0, // Requested privileges ignored since + // DUPLICATE_SAME_ACCESS is used. + FALSE, // Request non-inheritable handler. + DUPLICATE_SAME_ACCESS)) { + DeathTestAbort(String::Format( + "Unable to duplicate the pipe handle %Iu from the parent process %u", + write_handle_as_size_t, parent_process_id)); + } + + const HANDLE event_handle = reinterpret_cast<HANDLE>(event_handle_as_size_t); + HANDLE dup_event_handle; + + if (!::DuplicateHandle(parent_process_handle.Get(), event_handle, + ::GetCurrentProcess(), &dup_event_handle, + 0x0, + FALSE, + DUPLICATE_SAME_ACCESS)) { + DeathTestAbort(String::Format( + "Unable to duplicate the event handle %Iu from the parent process %u", + event_handle_as_size_t, parent_process_id)); + } + + const int write_fd = + ::_open_osfhandle(reinterpret_cast<intptr_t>(dup_write_handle), O_APPEND); + if (write_fd == -1) { + DeathTestAbort(String::Format( + "Unable to convert pipe handle %Iu to a file descriptor", + write_handle_as_size_t)); + } + + // Signals the parent that the write end of the pipe has been acquired + // so the parent can release its own write end. + ::SetEvent(dup_event_handle); + + return write_fd; +} +# endif // GTEST_OS_WINDOWS + +// Returns a newly created InternalRunDeathTestFlag object with fields +// initialized from the GTEST_FLAG(internal_run_death_test) flag if +// the flag is specified; otherwise returns NULL. +InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() { + if (GTEST_FLAG(internal_run_death_test) == "") return NULL; + + // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we + // can use it here. + int line = -1; + int index = -1; + ::std::vector< ::std::string> fields; + SplitString(GTEST_FLAG(internal_run_death_test).c_str(), '|', &fields); + int write_fd = -1; + +# if GTEST_OS_WINDOWS + + unsigned int parent_process_id = 0; + size_t write_handle_as_size_t = 0; + size_t event_handle_as_size_t = 0; + + if (fields.size() != 6 + || !ParseNaturalNumber(fields[1], &line) + || !ParseNaturalNumber(fields[2], &index) + || !ParseNaturalNumber(fields[3], &parent_process_id) + || !ParseNaturalNumber(fields[4], &write_handle_as_size_t) + || !ParseNaturalNumber(fields[5], &event_handle_as_size_t)) { + DeathTestAbort(String::Format( + "Bad --gtest_internal_run_death_test flag: %s", + GTEST_FLAG(internal_run_death_test).c_str())); + } + write_fd = GetStatusFileDescriptor(parent_process_id, + write_handle_as_size_t, + event_handle_as_size_t); +# else + + if (fields.size() != 4 + || !ParseNaturalNumber(fields[1], &line) + || !ParseNaturalNumber(fields[2], &index) + || !ParseNaturalNumber(fields[3], &write_fd)) { + DeathTestAbort(String::Format( + "Bad --gtest_internal_run_death_test flag: %s", + GTEST_FLAG(internal_run_death_test).c_str())); + } + +# endif // GTEST_OS_WINDOWS + + return new InternalRunDeathTestFlag(fields[0], line, index, write_fd); +} + +} // namespace internal + +#endif // GTEST_HAS_DEATH_TEST + +} // namespace testing diff --git a/tests/gtest/src/gtest-filepath.cc b/tests/gtest/src/gtest-filepath.cc new file mode 100644 index 000000000..91b257138 --- /dev/null +++ b/tests/gtest/src/gtest-filepath.cc @@ -0,0 +1,380 @@ +// Copyright 2008, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Authors: keith.ray@gmail.com (Keith Ray) + +#include "gtest/internal/gtest-filepath.h" +#include "gtest/internal/gtest-port.h" + +#include <stdlib.h> + +#if GTEST_OS_WINDOWS_MOBILE +# include <windows.h> +#elif GTEST_OS_WINDOWS +# include <direct.h> +# include <io.h> +#elif GTEST_OS_SYMBIAN || GTEST_OS_NACL +// Symbian OpenC and NaCl have PATH_MAX in sys/syslimits.h +# include <sys/syslimits.h> +#else +# include <limits.h> +# include <climits> // Some Linux distributions define PATH_MAX here. +#endif // GTEST_OS_WINDOWS_MOBILE + +#if GTEST_OS_WINDOWS +# define GTEST_PATH_MAX_ _MAX_PATH +#elif defined(PATH_MAX) +# define GTEST_PATH_MAX_ PATH_MAX +#elif defined(_XOPEN_PATH_MAX) +# define GTEST_PATH_MAX_ _XOPEN_PATH_MAX +#else +# define GTEST_PATH_MAX_ _POSIX_PATH_MAX +#endif // GTEST_OS_WINDOWS + +#include "gtest/internal/gtest-string.h" + +namespace testing { +namespace internal { + +#if GTEST_OS_WINDOWS +// On Windows, '\\' is the standard path separator, but many tools and the +// Windows API also accept '/' as an alternate path separator. Unless otherwise +// noted, a file path can contain either kind of path separators, or a mixture +// of them. +const char kPathSeparator = '\\'; +const char kAlternatePathSeparator = '/'; +const char kPathSeparatorString[] = "\\"; +const char kAlternatePathSeparatorString[] = "/"; +# if GTEST_OS_WINDOWS_MOBILE +// Windows CE doesn't have a current directory. You should not use +// the current directory in tests on Windows CE, but this at least +// provides a reasonable fallback. +const char kCurrentDirectoryString[] = "\\"; +// Windows CE doesn't define INVALID_FILE_ATTRIBUTES +const DWORD kInvalidFileAttributes = 0xffffffff; +# else +const char kCurrentDirectoryString[] = ".\\"; +# endif // GTEST_OS_WINDOWS_MOBILE +#else +const char kPathSeparator = '/'; +const char kPathSeparatorString[] = "/"; +const char kCurrentDirectoryString[] = "./"; +#endif // GTEST_OS_WINDOWS + +// Returns whether the given character is a valid path separator. +static bool IsPathSeparator(char c) { +#if GTEST_HAS_ALT_PATH_SEP_ + return (c == kPathSeparator) || (c == kAlternatePathSeparator); +#else + return c == kPathSeparator; +#endif +} + +// Returns the current working directory, or "" if unsuccessful. +FilePath FilePath::GetCurrentDir() { +#if GTEST_OS_WINDOWS_MOBILE + // Windows CE doesn't have a current directory, so we just return + // something reasonable. + return FilePath(kCurrentDirectoryString); +#elif GTEST_OS_WINDOWS + char cwd[GTEST_PATH_MAX_ + 1] = { '\0' }; + return FilePath(_getcwd(cwd, sizeof(cwd)) == NULL ? "" : cwd); +#else + char cwd[GTEST_PATH_MAX_ + 1] = { '\0' }; + return FilePath(getcwd(cwd, sizeof(cwd)) == NULL ? "" : cwd); +#endif // GTEST_OS_WINDOWS_MOBILE +} + +// Returns a copy of the FilePath with the case-insensitive extension removed. +// Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns +// FilePath("dir/file"). If a case-insensitive extension is not +// found, returns a copy of the original FilePath. +FilePath FilePath::RemoveExtension(const char* extension) const { + String dot_extension(String::Format(".%s", extension)); + if (pathname_.EndsWithCaseInsensitive(dot_extension.c_str())) { + return FilePath(String(pathname_.c_str(), pathname_.length() - 4)); + } + return *this; +} + +// Returns a pointer to the last occurence of a valid path separator in +// the FilePath. On Windows, for example, both '/' and '\' are valid path +// separators. Returns NULL if no path separator was found. +const char* FilePath::FindLastPathSeparator() const { + const char* const last_sep = strrchr(c_str(), kPathSeparator); +#if GTEST_HAS_ALT_PATH_SEP_ + const char* const last_alt_sep = strrchr(c_str(), kAlternatePathSeparator); + // Comparing two pointers of which only one is NULL is undefined. + if (last_alt_sep != NULL && + (last_sep == NULL || last_alt_sep > last_sep)) { + return last_alt_sep; + } +#endif + return last_sep; +} + +// Returns a copy of the FilePath with the directory part removed. +// Example: FilePath("path/to/file").RemoveDirectoryName() returns +// FilePath("file"). If there is no directory part ("just_a_file"), it returns +// the FilePath unmodified. If there is no file part ("just_a_dir/") it +// returns an empty FilePath (""). +// On Windows platform, '\' is the path separator, otherwise it is '/'. +FilePath FilePath::RemoveDirectoryName() const { + const char* const last_sep = FindLastPathSeparator(); + return last_sep ? FilePath(String(last_sep + 1)) : *this; +} + +// RemoveFileName returns the directory path with the filename removed. +// Example: FilePath("path/to/file").RemoveFileName() returns "path/to/". +// If the FilePath is "a_file" or "/a_file", RemoveFileName returns +// FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does +// not have a file, like "just/a/dir/", it returns the FilePath unmodified. +// On Windows platform, '\' is the path separator, otherwise it is '/'. +FilePath FilePath::RemoveFileName() const { + const char* const last_sep = FindLastPathSeparator(); + String dir; + if (last_sep) { + dir = String(c_str(), last_sep + 1 - c_str()); + } else { + dir = kCurrentDirectoryString; + } + return FilePath(dir); +} + +// Helper functions for naming files in a directory for xml output. + +// Given directory = "dir", base_name = "test", number = 0, +// extension = "xml", returns "dir/test.xml". If number is greater +// than zero (e.g., 12), returns "dir/test_12.xml". +// On Windows platform, uses \ as the separator rather than /. +FilePath FilePath::MakeFileName(const FilePath& directory, + const FilePath& base_name, + int number, + const char* extension) { + String file; + if (number == 0) { + file = String::Format("%s.%s", base_name.c_str(), extension); + } else { + file = String::Format("%s_%d.%s", base_name.c_str(), number, extension); + } + return ConcatPaths(directory, FilePath(file)); +} + +// Given directory = "dir", relative_path = "test.xml", returns "dir/test.xml". +// On Windows, uses \ as the separator rather than /. +FilePath FilePath::ConcatPaths(const FilePath& directory, + const FilePath& relative_path) { + if (directory.IsEmpty()) + return relative_path; + const FilePath dir(directory.RemoveTrailingPathSeparator()); + return FilePath(String::Format("%s%c%s", dir.c_str(), kPathSeparator, + relative_path.c_str())); +} + +// Returns true if pathname describes something findable in the file-system, +// either a file, directory, or whatever. +bool FilePath::FileOrDirectoryExists() const { +#if GTEST_OS_WINDOWS_MOBILE + LPCWSTR unicode = String::AnsiToUtf16(pathname_.c_str()); + const DWORD attributes = GetFileAttributes(unicode); + delete [] unicode; + return attributes != kInvalidFileAttributes; +#else + posix::StatStruct file_stat; + return posix::Stat(pathname_.c_str(), &file_stat) == 0; +#endif // GTEST_OS_WINDOWS_MOBILE +} + +// Returns true if pathname describes a directory in the file-system +// that exists. +bool FilePath::DirectoryExists() const { + bool result = false; +#if GTEST_OS_WINDOWS + // Don't strip off trailing separator if path is a root directory on + // Windows (like "C:\\"). + const FilePath& path(IsRootDirectory() ? *this : + RemoveTrailingPathSeparator()); +#else + const FilePath& path(*this); +#endif + +#if GTEST_OS_WINDOWS_MOBILE + LPCWSTR unicode = String::AnsiToUtf16(path.c_str()); + const DWORD attributes = GetFileAttributes(unicode); + delete [] unicode; + if ((attributes != kInvalidFileAttributes) && + (attributes & FILE_ATTRIBUTE_DIRECTORY)) { + result = true; + } +#else + posix::StatStruct file_stat; + result = posix::Stat(path.c_str(), &file_stat) == 0 && + posix::IsDir(file_stat); +#endif // GTEST_OS_WINDOWS_MOBILE + + return result; +} + +// Returns true if pathname describes a root directory. (Windows has one +// root directory per disk drive.) +bool FilePath::IsRootDirectory() const { +#if GTEST_OS_WINDOWS + // TODO(wan@google.com): on Windows a network share like + // \\server\share can be a root directory, although it cannot be the + // current directory. Handle this properly. + return pathname_.length() == 3 && IsAbsolutePath(); +#else + return pathname_.length() == 1 && IsPathSeparator(pathname_.c_str()[0]); +#endif +} + +// Returns true if pathname describes an absolute path. +bool FilePath::IsAbsolutePath() const { + const char* const name = pathname_.c_str(); +#if GTEST_OS_WINDOWS + return pathname_.length() >= 3 && + ((name[0] >= 'a' && name[0] <= 'z') || + (name[0] >= 'A' && name[0] <= 'Z')) && + name[1] == ':' && + IsPathSeparator(name[2]); +#else + return IsPathSeparator(name[0]); +#endif +} + +// Returns a pathname for a file that does not currently exist. The pathname +// will be directory/base_name.extension or +// directory/base_name_<number>.extension if directory/base_name.extension +// already exists. The number will be incremented until a pathname is found +// that does not already exist. +// Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'. +// There could be a race condition if two or more processes are calling this +// function at the same time -- they could both pick the same filename. +FilePath FilePath::GenerateUniqueFileName(const FilePath& directory, + const FilePath& base_name, + const char* extension) { + FilePath full_pathname; + int number = 0; + do { + full_pathname.Set(MakeFileName(directory, base_name, number++, extension)); + } while (full_pathname.FileOrDirectoryExists()); + return full_pathname; +} + +// Returns true if FilePath ends with a path separator, which indicates that +// it is intended to represent a directory. Returns false otherwise. +// This does NOT check that a directory (or file) actually exists. +bool FilePath::IsDirectory() const { + return !pathname_.empty() && + IsPathSeparator(pathname_.c_str()[pathname_.length() - 1]); +} + +// Create directories so that path exists. Returns true if successful or if +// the directories already exist; returns false if unable to create directories +// for any reason. +bool FilePath::CreateDirectoriesRecursively() const { + if (!this->IsDirectory()) { + return false; + } + + if (pathname_.length() == 0 || this->DirectoryExists()) { + return true; + } + + const FilePath parent(this->RemoveTrailingPathSeparator().RemoveFileName()); + return parent.CreateDirectoriesRecursively() && this->CreateFolder(); +} + +// Create the directory so that path exists. Returns true if successful or +// if the directory already exists; returns false if unable to create the +// directory for any reason, including if the parent directory does not +// exist. Not named "CreateDirectory" because that's a macro on Windows. +bool FilePath::CreateFolder() const { +#if GTEST_OS_WINDOWS_MOBILE + FilePath removed_sep(this->RemoveTrailingPathSeparator()); + LPCWSTR unicode = String::AnsiToUtf16(removed_sep.c_str()); + int result = CreateDirectory(unicode, NULL) ? 0 : -1; + delete [] unicode; +#elif GTEST_OS_WINDOWS + int result = _mkdir(pathname_.c_str()); +#else + int result = mkdir(pathname_.c_str(), 0777); +#endif // GTEST_OS_WINDOWS_MOBILE + + if (result == -1) { + return this->DirectoryExists(); // An error is OK if the directory exists. + } + return true; // No error. +} + +// If input name has a trailing separator character, remove it and return the +// name, otherwise return the name string unmodified. +// On Windows platform, uses \ as the separator, other platforms use /. +FilePath FilePath::RemoveTrailingPathSeparator() const { + return IsDirectory() + ? FilePath(String(pathname_.c_str(), pathname_.length() - 1)) + : *this; +} + +// Removes any redundant separators that might be in the pathname. +// For example, "bar///foo" becomes "bar/foo". Does not eliminate other +// redundancies that might be in a pathname involving "." or "..". +// TODO(wan@google.com): handle Windows network shares (e.g. \\server\share). +void FilePath::Normalize() { + if (pathname_.c_str() == NULL) { + pathname_ = ""; + return; + } + const char* src = pathname_.c_str(); + char* const dest = new char[pathname_.length() + 1]; + char* dest_ptr = dest; + memset(dest_ptr, 0, pathname_.length() + 1); + + while (*src != '\0') { + *dest_ptr = *src; + if (!IsPathSeparator(*src)) { + src++; + } else { +#if GTEST_HAS_ALT_PATH_SEP_ + if (*dest_ptr == kAlternatePathSeparator) { + *dest_ptr = kPathSeparator; + } +#endif + while (IsPathSeparator(*src)) + src++; + } + dest_ptr++; + } + *dest_ptr = '\0'; + pathname_ = dest; + delete[] dest; +} + +} // namespace internal +} // namespace testing diff --git a/tests/gtest/src/gtest-internal-inl.h b/tests/gtest/src/gtest-internal-inl.h new file mode 100644 index 000000000..65a2101a4 --- /dev/null +++ b/tests/gtest/src/gtest-internal-inl.h @@ -0,0 +1,1038 @@ +// Copyright 2005, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +// Utility functions and classes used by the Google C++ testing framework. +// +// Author: wan@google.com (Zhanyong Wan) +// +// This file contains purely Google Test's internal implementation. Please +// DO NOT #INCLUDE IT IN A USER PROGRAM. + +#ifndef GTEST_SRC_GTEST_INTERNAL_INL_H_ +#define GTEST_SRC_GTEST_INTERNAL_INL_H_ + +// GTEST_IMPLEMENTATION_ is defined to 1 iff the current translation unit is +// part of Google Test's implementation; otherwise it's undefined. +#if !GTEST_IMPLEMENTATION_ +// A user is trying to include this from his code - just say no. +# error "gtest-internal-inl.h is part of Google Test's internal implementation." +# error "It must not be included except by Google Test itself." +#endif // GTEST_IMPLEMENTATION_ + +#ifndef _WIN32_WCE +# include <errno.h> +#endif // !_WIN32_WCE +#include <stddef.h> +#include <stdlib.h> // For strtoll/_strtoul64/malloc/free. +#include <string.h> // For memmove. + +#include <algorithm> +#include <string> +#include <vector> + +#include "gtest/internal/gtest-port.h" + +#if GTEST_OS_WINDOWS +# include <windows.h> // NOLINT +#endif // GTEST_OS_WINDOWS + +#include "gtest/gtest.h" // NOLINT +#include "gtest/gtest-spi.h" + +namespace testing { + +// Declares the flags. +// +// We don't want the users to modify this flag in the code, but want +// Google Test's own unit tests to be able to access it. Therefore we +// declare it here as opposed to in gtest.h. +GTEST_DECLARE_bool_(death_test_use_fork); + +namespace internal { + +// The value of GetTestTypeId() as seen from within the Google Test +// library. This is solely for testing GetTestTypeId(). +GTEST_API_ extern const TypeId kTestTypeIdInGoogleTest; + +// Names of the flags (needed for parsing Google Test flags). +const char kAlsoRunDisabledTestsFlag[] = "also_run_disabled_tests"; +const char kBreakOnFailureFlag[] = "break_on_failure"; +const char kCatchExceptionsFlag[] = "catch_exceptions"; +const char kColorFlag[] = "color"; +const char kFilterFlag[] = "filter"; +const char kListTestsFlag[] = "list_tests"; +const char kOutputFlag[] = "output"; +const char kPrintTimeFlag[] = "print_time"; +const char kRandomSeedFlag[] = "random_seed"; +const char kRepeatFlag[] = "repeat"; +const char kShuffleFlag[] = "shuffle"; +const char kStackTraceDepthFlag[] = "stack_trace_depth"; +const char kStreamResultToFlag[] = "stream_result_to"; +const char kThrowOnFailureFlag[] = "throw_on_failure"; + +// A valid random seed must be in [1, kMaxRandomSeed]. +const int kMaxRandomSeed = 99999; + +// g_help_flag is true iff the --help flag or an equivalent form is +// specified on the command line. +GTEST_API_ extern bool g_help_flag; + +// Returns the current time in milliseconds. +GTEST_API_ TimeInMillis GetTimeInMillis(); + +// Returns true iff Google Test should use colors in the output. +GTEST_API_ bool ShouldUseColor(bool stdout_is_tty); + +// Formats the given time in milliseconds as seconds. +GTEST_API_ std::string FormatTimeInMillisAsSeconds(TimeInMillis ms); + +// Parses a string for an Int32 flag, in the form of "--flag=value". +// +// On success, stores the value of the flag in *value, and returns +// true. On failure, returns false without changing *value. +GTEST_API_ bool ParseInt32Flag( + const char* str, const char* flag, Int32* value); + +// Returns a random seed in range [1, kMaxRandomSeed] based on the +// given --gtest_random_seed flag value. +inline int GetRandomSeedFromFlag(Int32 random_seed_flag) { + const unsigned int raw_seed = (random_seed_flag == 0) ? + static_cast<unsigned int>(GetTimeInMillis()) : + static_cast<unsigned int>(random_seed_flag); + + // Normalizes the actual seed to range [1, kMaxRandomSeed] such that + // it's easy to type. + const int normalized_seed = + static_cast<int>((raw_seed - 1U) % + static_cast<unsigned int>(kMaxRandomSeed)) + 1; + return normalized_seed; +} + +// Returns the first valid random seed after 'seed'. The behavior is +// undefined if 'seed' is invalid. The seed after kMaxRandomSeed is +// considered to be 1. +inline int GetNextRandomSeed(int seed) { + GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed) + << "Invalid random seed " << seed << " - must be in [1, " + << kMaxRandomSeed << "]."; + const int next_seed = seed + 1; + return (next_seed > kMaxRandomSeed) ? 1 : next_seed; +} + +// This class saves the values of all Google Test flags in its c'tor, and +// restores them in its d'tor. +class GTestFlagSaver { + public: + // The c'tor. + GTestFlagSaver() { + also_run_disabled_tests_ = GTEST_FLAG(also_run_disabled_tests); + break_on_failure_ = GTEST_FLAG(break_on_failure); + catch_exceptions_ = GTEST_FLAG(catch_exceptions); + color_ = GTEST_FLAG(color); + death_test_style_ = GTEST_FLAG(death_test_style); + death_test_use_fork_ = GTEST_FLAG(death_test_use_fork); + filter_ = GTEST_FLAG(filter); + internal_run_death_test_ = GTEST_FLAG(internal_run_death_test); + list_tests_ = GTEST_FLAG(list_tests); + output_ = GTEST_FLAG(output); + print_time_ = GTEST_FLAG(print_time); + random_seed_ = GTEST_FLAG(random_seed); + repeat_ = GTEST_FLAG(repeat); + shuffle_ = GTEST_FLAG(shuffle); + stack_trace_depth_ = GTEST_FLAG(stack_trace_depth); + stream_result_to_ = GTEST_FLAG(stream_result_to); + throw_on_failure_ = GTEST_FLAG(throw_on_failure); + } + + // The d'tor is not virtual. DO NOT INHERIT FROM THIS CLASS. + ~GTestFlagSaver() { + GTEST_FLAG(also_run_disabled_tests) = also_run_disabled_tests_; + GTEST_FLAG(break_on_failure) = break_on_failure_; + GTEST_FLAG(catch_exceptions) = catch_exceptions_; + GTEST_FLAG(color) = color_; + GTEST_FLAG(death_test_style) = death_test_style_; + GTEST_FLAG(death_test_use_fork) = death_test_use_fork_; + GTEST_FLAG(filter) = filter_; + GTEST_FLAG(internal_run_death_test) = internal_run_death_test_; + GTEST_FLAG(list_tests) = list_tests_; + GTEST_FLAG(output) = output_; + GTEST_FLAG(print_time) = print_time_; + GTEST_FLAG(random_seed) = random_seed_; + GTEST_FLAG(repeat) = repeat_; + GTEST_FLAG(shuffle) = shuffle_; + GTEST_FLAG(stack_trace_depth) = stack_trace_depth_; + GTEST_FLAG(stream_result_to) = stream_result_to_; + GTEST_FLAG(throw_on_failure) = throw_on_failure_; + } + private: + // Fields for saving the original values of flags. + bool also_run_disabled_tests_; + bool break_on_failure_; + bool catch_exceptions_; + String color_; + String death_test_style_; + bool death_test_use_fork_; + String filter_; + String internal_run_death_test_; + bool list_tests_; + String output_; + bool print_time_; + bool pretty_; + internal::Int32 random_seed_; + internal::Int32 repeat_; + bool shuffle_; + internal::Int32 stack_trace_depth_; + String stream_result_to_; + bool throw_on_failure_; +} GTEST_ATTRIBUTE_UNUSED_; + +// Converts a Unicode code point to a narrow string in UTF-8 encoding. +// code_point parameter is of type UInt32 because wchar_t may not be +// wide enough to contain a code point. +// The output buffer str must containt at least 32 characters. +// The function returns the address of the output buffer. +// If the code_point is not a valid Unicode code point +// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be output +// as '(Invalid Unicode 0xXXXXXXXX)'. +GTEST_API_ char* CodePointToUtf8(UInt32 code_point, char* str); + +// Converts a wide string to a narrow string in UTF-8 encoding. +// The wide string is assumed to have the following encoding: +// UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin, Symbian OS) +// UTF-32 if sizeof(wchar_t) == 4 (on Linux) +// Parameter str points to a null-terminated wide string. +// Parameter num_chars may additionally limit the number +// of wchar_t characters processed. -1 is used when the entire string +// should be processed. +// If the string contains code points that are not valid Unicode code points +// (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output +// as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding +// and contains invalid UTF-16 surrogate pairs, values in those pairs +// will be encoded as individual Unicode characters from Basic Normal Plane. +GTEST_API_ String WideStringToUtf8(const wchar_t* str, int num_chars); + +// Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file +// if the variable is present. If a file already exists at this location, this +// function will write over it. If the variable is present, but the file cannot +// be created, prints an error and exits. +void WriteToShardStatusFileIfNeeded(); + +// Checks whether sharding is enabled by examining the relevant +// environment variable values. If the variables are present, +// but inconsistent (e.g., shard_index >= total_shards), prints +// an error and exits. If in_subprocess_for_death_test, sharding is +// disabled because it must only be applied to the original test +// process. Otherwise, we could filter out death tests we intended to execute. +GTEST_API_ bool ShouldShard(const char* total_shards_str, + const char* shard_index_str, + bool in_subprocess_for_death_test); + +// Parses the environment variable var as an Int32. If it is unset, +// returns default_val. If it is not an Int32, prints an error and +// and aborts. +GTEST_API_ Int32 Int32FromEnvOrDie(const char* env_var, Int32 default_val); + +// Given the total number of shards, the shard index, and the test id, +// returns true iff the test should be run on this shard. The test id is +// some arbitrary but unique non-negative integer assigned to each test +// method. Assumes that 0 <= shard_index < total_shards. +GTEST_API_ bool ShouldRunTestOnShard( + int total_shards, int shard_index, int test_id); + +// STL container utilities. + +// Returns the number of elements in the given container that satisfy +// the given predicate. +template <class Container, typename Predicate> +inline int CountIf(const Container& c, Predicate predicate) { + // Implemented as an explicit loop since std::count_if() in libCstd on + // Solaris has a non-standard signature. + int count = 0; + for (typename Container::const_iterator it = c.begin(); it != c.end(); ++it) { + if (predicate(*it)) + ++count; + } + return count; +} + +// Applies a function/functor to each element in the container. +template <class Container, typename Functor> +void ForEach(const Container& c, Functor functor) { + std::for_each(c.begin(), c.end(), functor); +} + +// Returns the i-th element of the vector, or default_value if i is not +// in range [0, v.size()). +template <typename E> +inline E GetElementOr(const std::vector<E>& v, int i, E default_value) { + return (i < 0 || i >= static_cast<int>(v.size())) ? default_value : v[i]; +} + +// Performs an in-place shuffle of a range of the vector's elements. +// 'begin' and 'end' are element indices as an STL-style range; +// i.e. [begin, end) are shuffled, where 'end' == size() means to +// shuffle to the end of the vector. +template <typename E> +void ShuffleRange(internal::Random* random, int begin, int end, + std::vector<E>* v) { + const int size = static_cast<int>(v->size()); + GTEST_CHECK_(0 <= begin && begin <= size) + << "Invalid shuffle range start " << begin << ": must be in range [0, " + << size << "]."; + GTEST_CHECK_(begin <= end && end <= size) + << "Invalid shuffle range finish " << end << ": must be in range [" + << begin << ", " << size << "]."; + + // Fisher-Yates shuffle, from + // http://en.wikipedia.org/wiki/Fisher-Yates_shuffle + for (int range_width = end - begin; range_width >= 2; range_width--) { + const int last_in_range = begin + range_width - 1; + const int selected = begin + random->Generate(range_width); + std::swap((*v)[selected], (*v)[last_in_range]); + } +} + +// Performs an in-place shuffle of the vector's elements. +template <typename E> +inline void Shuffle(internal::Random* random, std::vector<E>* v) { + ShuffleRange(random, 0, static_cast<int>(v->size()), v); +} + +// A function for deleting an object. Handy for being used as a +// functor. +template <typename T> +static void Delete(T* x) { + delete x; +} + +// A predicate that checks the key of a TestProperty against a known key. +// +// TestPropertyKeyIs is copyable. +class TestPropertyKeyIs { + public: + // Constructor. + // + // TestPropertyKeyIs has NO default constructor. + explicit TestPropertyKeyIs(const char* key) + : key_(key) {} + + // Returns true iff the test name of test property matches on key_. + bool operator()(const TestProperty& test_property) const { + return String(test_property.key()).Compare(key_) == 0; + } + + private: + String key_; +}; + +// Class UnitTestOptions. +// +// This class contains functions for processing options the user +// specifies when running the tests. It has only static members. +// +// In most cases, the user can specify an option using either an +// environment variable or a command line flag. E.g. you can set the +// test filter using either GTEST_FILTER or --gtest_filter. If both +// the variable and the flag are present, the latter overrides the +// former. +class GTEST_API_ UnitTestOptions { + public: + // Functions for processing the gtest_output flag. + + // Returns the output format, or "" for normal printed output. + static String GetOutputFormat(); + + // Returns the absolute path of the requested output file, or the + // default (test_detail.xml in the original working directory) if + // none was explicitly specified. + static String GetAbsolutePathToOutputFile(); + + // Functions for processing the gtest_filter flag. + + // Returns true iff the wildcard pattern matches the string. The + // first ':' or '\0' character in pattern marks the end of it. + // + // This recursive algorithm isn't very efficient, but is clear and + // works well enough for matching test names, which are short. + static bool PatternMatchesString(const char *pattern, const char *str); + + // Returns true iff the user-specified filter matches the test case + // name and the test name. + static bool FilterMatchesTest(const String &test_case_name, + const String &test_name); + +#if GTEST_OS_WINDOWS + // Function for supporting the gtest_catch_exception flag. + + // Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the + // given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise. + // This function is useful as an __except condition. + static int GTestShouldProcessSEH(DWORD exception_code); +#endif // GTEST_OS_WINDOWS + + // Returns true if "name" matches the ':' separated list of glob-style + // filters in "filter". + static bool MatchesFilter(const String& name, const char* filter); +}; + +// Returns the current application's name, removing directory path if that +// is present. Used by UnitTestOptions::GetOutputFile. +GTEST_API_ FilePath GetCurrentExecutableName(); + +// The role interface for getting the OS stack trace as a string. +class OsStackTraceGetterInterface { + public: + OsStackTraceGetterInterface() {} + virtual ~OsStackTraceGetterInterface() {} + + // Returns the current OS stack trace as a String. Parameters: + // + // max_depth - the maximum number of stack frames to be included + // in the trace. + // skip_count - the number of top frames to be skipped; doesn't count + // against max_depth. + virtual String CurrentStackTrace(int max_depth, int skip_count) = 0; + + // UponLeavingGTest() should be called immediately before Google Test calls + // user code. It saves some information about the current stack that + // CurrentStackTrace() will use to find and hide Google Test stack frames. + virtual void UponLeavingGTest() = 0; + + private: + GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetterInterface); +}; + +// A working implementation of the OsStackTraceGetterInterface interface. +class OsStackTraceGetter : public OsStackTraceGetterInterface { + public: + OsStackTraceGetter() : caller_frame_(NULL) {} + virtual String CurrentStackTrace(int max_depth, int skip_count); + virtual void UponLeavingGTest(); + + // This string is inserted in place of stack frames that are part of + // Google Test's implementation. + static const char* const kElidedFramesMarker; + + private: + Mutex mutex_; // protects all internal state + + // We save the stack frame below the frame that calls user code. + // We do this because the address of the frame immediately below + // the user code changes between the call to UponLeavingGTest() + // and any calls to CurrentStackTrace() from within the user code. + void* caller_frame_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetter); +}; + +// Information about a Google Test trace point. +struct TraceInfo { + const char* file; + int line; + String message; +}; + +// This is the default global test part result reporter used in UnitTestImpl. +// This class should only be used by UnitTestImpl. +class DefaultGlobalTestPartResultReporter + : public TestPartResultReporterInterface { + public: + explicit DefaultGlobalTestPartResultReporter(UnitTestImpl* unit_test); + // Implements the TestPartResultReporterInterface. Reports the test part + // result in the current test. + virtual void ReportTestPartResult(const TestPartResult& result); + + private: + UnitTestImpl* const unit_test_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultGlobalTestPartResultReporter); +}; + +// This is the default per thread test part result reporter used in +// UnitTestImpl. This class should only be used by UnitTestImpl. +class DefaultPerThreadTestPartResultReporter + : public TestPartResultReporterInterface { + public: + explicit DefaultPerThreadTestPartResultReporter(UnitTestImpl* unit_test); + // Implements the TestPartResultReporterInterface. The implementation just + // delegates to the current global test part result reporter of *unit_test_. + virtual void ReportTestPartResult(const TestPartResult& result); + + private: + UnitTestImpl* const unit_test_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultPerThreadTestPartResultReporter); +}; + +// The private implementation of the UnitTest class. We don't protect +// the methods under a mutex, as this class is not accessible by a +// user and the UnitTest class that delegates work to this class does +// proper locking. +class GTEST_API_ UnitTestImpl { + public: + explicit UnitTestImpl(UnitTest* parent); + virtual ~UnitTestImpl(); + + // There are two different ways to register your own TestPartResultReporter. + // You can register your own repoter to listen either only for test results + // from the current thread or for results from all threads. + // By default, each per-thread test result repoter just passes a new + // TestPartResult to the global test result reporter, which registers the + // test part result for the currently running test. + + // Returns the global test part result reporter. + TestPartResultReporterInterface* GetGlobalTestPartResultReporter(); + + // Sets the global test part result reporter. + void SetGlobalTestPartResultReporter( + TestPartResultReporterInterface* reporter); + + // Returns the test part result reporter for the current thread. + TestPartResultReporterInterface* GetTestPartResultReporterForCurrentThread(); + + // Sets the test part result reporter for the current thread. + void SetTestPartResultReporterForCurrentThread( + TestPartResultReporterInterface* reporter); + + // Gets the number of successful test cases. + int successful_test_case_count() const; + + // Gets the number of failed test cases. + int failed_test_case_count() const; + + // Gets the number of all test cases. + int total_test_case_count() const; + + // Gets the number of all test cases that contain at least one test + // that should run. + int test_case_to_run_count() const; + + // Gets the number of successful tests. + int successful_test_count() const; + + // Gets the number of failed tests. + int failed_test_count() const; + + // Gets the number of disabled tests. + int disabled_test_count() const; + + // Gets the number of all tests. + int total_test_count() const; + + // Gets the number of tests that should run. + int test_to_run_count() const; + + // Gets the elapsed time, in milliseconds. + TimeInMillis elapsed_time() const { return elapsed_time_; } + + // Returns true iff the unit test passed (i.e. all test cases passed). + bool Passed() const { return !Failed(); } + + // Returns true iff the unit test failed (i.e. some test case failed + // or something outside of all tests failed). + bool Failed() const { + return failed_test_case_count() > 0 || ad_hoc_test_result()->Failed(); + } + + // Gets the i-th test case among all the test cases. i can range from 0 to + // total_test_case_count() - 1. If i is not in that range, returns NULL. + const TestCase* GetTestCase(int i) const { + const int index = GetElementOr(test_case_indices_, i, -1); + return index < 0 ? NULL : test_cases_[i]; + } + + // Gets the i-th test case among all the test cases. i can range from 0 to + // total_test_case_count() - 1. If i is not in that range, returns NULL. + TestCase* GetMutableTestCase(int i) { + const int index = GetElementOr(test_case_indices_, i, -1); + return index < 0 ? NULL : test_cases_[index]; + } + + // Provides access to the event listener list. + TestEventListeners* listeners() { return &listeners_; } + + // Returns the TestResult for the test that's currently running, or + // the TestResult for the ad hoc test if no test is running. + TestResult* current_test_result(); + + // Returns the TestResult for the ad hoc test. + const TestResult* ad_hoc_test_result() const { return &ad_hoc_test_result_; } + + // Sets the OS stack trace getter. + // + // Does nothing if the input and the current OS stack trace getter + // are the same; otherwise, deletes the old getter and makes the + // input the current getter. + void set_os_stack_trace_getter(OsStackTraceGetterInterface* getter); + + // Returns the current OS stack trace getter if it is not NULL; + // otherwise, creates an OsStackTraceGetter, makes it the current + // getter, and returns it. + OsStackTraceGetterInterface* os_stack_trace_getter(); + + // Returns the current OS stack trace as a String. + // + // The maximum number of stack frames to be included is specified by + // the gtest_stack_trace_depth flag. The skip_count parameter + // specifies the number of top frames to be skipped, which doesn't + // count against the number of frames to be included. + // + // For example, if Foo() calls Bar(), which in turn calls + // CurrentOsStackTraceExceptTop(1), Foo() will be included in the + // trace but Bar() and CurrentOsStackTraceExceptTop() won't. + String CurrentOsStackTraceExceptTop(int skip_count); + + // Finds and returns a TestCase with the given name. If one doesn't + // exist, creates one and returns it. + // + // Arguments: + // + // test_case_name: name of the test case + // type_param: the name of the test's type parameter, or NULL if + // this is not a typed or a type-parameterized test. + // set_up_tc: pointer to the function that sets up the test case + // tear_down_tc: pointer to the function that tears down the test case + TestCase* GetTestCase(const char* test_case_name, + const char* type_param, + Test::SetUpTestCaseFunc set_up_tc, + Test::TearDownTestCaseFunc tear_down_tc); + + // Adds a TestInfo to the unit test. + // + // Arguments: + // + // set_up_tc: pointer to the function that sets up the test case + // tear_down_tc: pointer to the function that tears down the test case + // test_info: the TestInfo object + void AddTestInfo(Test::SetUpTestCaseFunc set_up_tc, + Test::TearDownTestCaseFunc tear_down_tc, + TestInfo* test_info) { + // In order to support thread-safe death tests, we need to + // remember the original working directory when the test program + // was first invoked. We cannot do this in RUN_ALL_TESTS(), as + // the user may have changed the current directory before calling + // RUN_ALL_TESTS(). Therefore we capture the current directory in + // AddTestInfo(), which is called to register a TEST or TEST_F + // before main() is reached. + if (original_working_dir_.IsEmpty()) { + original_working_dir_.Set(FilePath::GetCurrentDir()); + GTEST_CHECK_(!original_working_dir_.IsEmpty()) + << "Failed to get the current working directory."; + } + + GetTestCase(test_info->test_case_name(), + test_info->type_param(), + set_up_tc, + tear_down_tc)->AddTestInfo(test_info); + } + +#if GTEST_HAS_PARAM_TEST + // Returns ParameterizedTestCaseRegistry object used to keep track of + // value-parameterized tests and instantiate and register them. + internal::ParameterizedTestCaseRegistry& parameterized_test_registry() { + return parameterized_test_registry_; + } +#endif // GTEST_HAS_PARAM_TEST + + // Sets the TestCase object for the test that's currently running. + void set_current_test_case(TestCase* a_current_test_case) { + current_test_case_ = a_current_test_case; + } + + // Sets the TestInfo object for the test that's currently running. If + // current_test_info is NULL, the assertion results will be stored in + // ad_hoc_test_result_. + void set_current_test_info(TestInfo* a_current_test_info) { + current_test_info_ = a_current_test_info; + } + + // Registers all parameterized tests defined using TEST_P and + // INSTANTIATE_TEST_CASE_P, creating regular tests for each test/parameter + // combination. This method can be called more then once; it has guards + // protecting from registering the tests more then once. If + // value-parameterized tests are disabled, RegisterParameterizedTests is + // present but does nothing. + void RegisterParameterizedTests(); + + // Runs all tests in this UnitTest object, prints the result, and + // returns true if all tests are successful. If any exception is + // thrown during a test, this test is considered to be failed, but + // the rest of the tests will still be run. + bool RunAllTests(); + + // Clears the results of all tests, except the ad hoc tests. + void ClearNonAdHocTestResult() { + ForEach(test_cases_, TestCase::ClearTestCaseResult); + } + + // Clears the results of ad-hoc test assertions. + void ClearAdHocTestResult() { + ad_hoc_test_result_.Clear(); + } + + enum ReactionToSharding { + HONOR_SHARDING_PROTOCOL, + IGNORE_SHARDING_PROTOCOL + }; + + // Matches the full name of each test against the user-specified + // filter to decide whether the test should run, then records the + // result in each TestCase and TestInfo object. + // If shard_tests == HONOR_SHARDING_PROTOCOL, further filters tests + // based on sharding variables in the environment. + // Returns the number of tests that should run. + int FilterTests(ReactionToSharding shard_tests); + + // Prints the names of the tests matching the user-specified filter flag. + void ListTestsMatchingFilter(); + + const TestCase* current_test_case() const { return current_test_case_; } + TestInfo* current_test_info() { return current_test_info_; } + const TestInfo* current_test_info() const { return current_test_info_; } + + // Returns the vector of environments that need to be set-up/torn-down + // before/after the tests are run. + std::vector<Environment*>& environments() { return environments_; } + + // Getters for the per-thread Google Test trace stack. + std::vector<TraceInfo>& gtest_trace_stack() { + return *(gtest_trace_stack_.pointer()); + } + const std::vector<TraceInfo>& gtest_trace_stack() const { + return gtest_trace_stack_.get(); + } + +#if GTEST_HAS_DEATH_TEST + void InitDeathTestSubprocessControlInfo() { + internal_run_death_test_flag_.reset(ParseInternalRunDeathTestFlag()); + } + // Returns a pointer to the parsed --gtest_internal_run_death_test + // flag, or NULL if that flag was not specified. + // This information is useful only in a death test child process. + // Must not be called before a call to InitGoogleTest. + const InternalRunDeathTestFlag* internal_run_death_test_flag() const { + return internal_run_death_test_flag_.get(); + } + + // Returns a pointer to the current death test factory. + internal::DeathTestFactory* death_test_factory() { + return death_test_factory_.get(); + } + + void SuppressTestEventsIfInSubprocess(); + + friend class ReplaceDeathTestFactory; +#endif // GTEST_HAS_DEATH_TEST + + // Initializes the event listener performing XML output as specified by + // UnitTestOptions. Must not be called before InitGoogleTest. + void ConfigureXmlOutput(); + +#if GTEST_CAN_STREAM_RESULTS_ + // Initializes the event listener for streaming test results to a socket. + // Must not be called before InitGoogleTest. + void ConfigureStreamingOutput(); +#endif + + // Performs initialization dependent upon flag values obtained in + // ParseGoogleTestFlagsOnly. Is called from InitGoogleTest after the call to + // ParseGoogleTestFlagsOnly. In case a user neglects to call InitGoogleTest + // this function is also called from RunAllTests. Since this function can be + // called more than once, it has to be idempotent. + void PostFlagParsingInit(); + + // Gets the random seed used at the start of the current test iteration. + int random_seed() const { return random_seed_; } + + // Gets the random number generator. + internal::Random* random() { return &random_; } + + // Shuffles all test cases, and the tests within each test case, + // making sure that death tests are still run first. + void ShuffleTests(); + + // Restores the test cases and tests to their order before the first shuffle. + void UnshuffleTests(); + + // Returns the value of GTEST_FLAG(catch_exceptions) at the moment + // UnitTest::Run() starts. + bool catch_exceptions() const { return catch_exceptions_; } + + private: + friend class ::testing::UnitTest; + + // Used by UnitTest::Run() to capture the state of + // GTEST_FLAG(catch_exceptions) at the moment it starts. + void set_catch_exceptions(bool value) { catch_exceptions_ = value; } + + // The UnitTest object that owns this implementation object. + UnitTest* const parent_; + + // The working directory when the first TEST() or TEST_F() was + // executed. + internal::FilePath original_working_dir_; + + // The default test part result reporters. + DefaultGlobalTestPartResultReporter default_global_test_part_result_reporter_; + DefaultPerThreadTestPartResultReporter + default_per_thread_test_part_result_reporter_; + + // Points to (but doesn't own) the global test part result reporter. + TestPartResultReporterInterface* global_test_part_result_repoter_; + + // Protects read and write access to global_test_part_result_reporter_. + internal::Mutex global_test_part_result_reporter_mutex_; + + // Points to (but doesn't own) the per-thread test part result reporter. + internal::ThreadLocal<TestPartResultReporterInterface*> + per_thread_test_part_result_reporter_; + + // The vector of environments that need to be set-up/torn-down + // before/after the tests are run. + std::vector<Environment*> environments_; + + // The vector of TestCases in their original order. It owns the + // elements in the vector. + std::vector<TestCase*> test_cases_; + + // Provides a level of indirection for the test case list to allow + // easy shuffling and restoring the test case order. The i-th + // element of this vector is the index of the i-th test case in the + // shuffled order. + std::vector<int> test_case_indices_; + +#if GTEST_HAS_PARAM_TEST + // ParameterizedTestRegistry object used to register value-parameterized + // tests. + internal::ParameterizedTestCaseRegistry parameterized_test_registry_; + + // Indicates whether RegisterParameterizedTests() has been called already. + bool parameterized_tests_registered_; +#endif // GTEST_HAS_PARAM_TEST + + // Index of the last death test case registered. Initially -1. + int last_death_test_case_; + + // This points to the TestCase for the currently running test. It + // changes as Google Test goes through one test case after another. + // When no test is running, this is set to NULL and Google Test + // stores assertion results in ad_hoc_test_result_. Initially NULL. + TestCase* current_test_case_; + + // This points to the TestInfo for the currently running test. It + // changes as Google Test goes through one test after another. When + // no test is running, this is set to NULL and Google Test stores + // assertion results in ad_hoc_test_result_. Initially NULL. + TestInfo* current_test_info_; + + // Normally, a user only writes assertions inside a TEST or TEST_F, + // or inside a function called by a TEST or TEST_F. Since Google + // Test keeps track of which test is current running, it can + // associate such an assertion with the test it belongs to. + // + // If an assertion is encountered when no TEST or TEST_F is running, + // Google Test attributes the assertion result to an imaginary "ad hoc" + // test, and records the result in ad_hoc_test_result_. + TestResult ad_hoc_test_result_; + + // The list of event listeners that can be used to track events inside + // Google Test. + TestEventListeners listeners_; + + // The OS stack trace getter. Will be deleted when the UnitTest + // object is destructed. By default, an OsStackTraceGetter is used, + // but the user can set this field to use a custom getter if that is + // desired. + OsStackTraceGetterInterface* os_stack_trace_getter_; + + // True iff PostFlagParsingInit() has been called. + bool post_flag_parse_init_performed_; + + // The random number seed used at the beginning of the test run. + int random_seed_; + + // Our random number generator. + internal::Random random_; + + // How long the test took to run, in milliseconds. + TimeInMillis elapsed_time_; + +#if GTEST_HAS_DEATH_TEST + // The decomposed components of the gtest_internal_run_death_test flag, + // parsed when RUN_ALL_TESTS is called. + internal::scoped_ptr<InternalRunDeathTestFlag> internal_run_death_test_flag_; + internal::scoped_ptr<internal::DeathTestFactory> death_test_factory_; +#endif // GTEST_HAS_DEATH_TEST + + // A per-thread stack of traces created by the SCOPED_TRACE() macro. + internal::ThreadLocal<std::vector<TraceInfo> > gtest_trace_stack_; + + // The value of GTEST_FLAG(catch_exceptions) at the moment RunAllTests() + // starts. + bool catch_exceptions_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTestImpl); +}; // class UnitTestImpl + +// Convenience function for accessing the global UnitTest +// implementation object. +inline UnitTestImpl* GetUnitTestImpl() { + return UnitTest::GetInstance()->impl(); +} + +#if GTEST_USES_SIMPLE_RE + +// Internal helper functions for implementing the simple regular +// expression matcher. +GTEST_API_ bool IsInSet(char ch, const char* str); +GTEST_API_ bool IsAsciiDigit(char ch); +GTEST_API_ bool IsAsciiPunct(char ch); +GTEST_API_ bool IsRepeat(char ch); +GTEST_API_ bool IsAsciiWhiteSpace(char ch); +GTEST_API_ bool IsAsciiWordChar(char ch); +GTEST_API_ bool IsValidEscape(char ch); +GTEST_API_ bool AtomMatchesChar(bool escaped, char pattern, char ch); +GTEST_API_ bool ValidateRegex(const char* regex); +GTEST_API_ bool MatchRegexAtHead(const char* regex, const char* str); +GTEST_API_ bool MatchRepetitionAndRegexAtHead( + bool escaped, char ch, char repeat, const char* regex, const char* str); +GTEST_API_ bool MatchRegexAnywhere(const char* regex, const char* str); + +#endif // GTEST_USES_SIMPLE_RE + +// Parses the command line for Google Test flags, without initializing +// other parts of Google Test. +GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, char** argv); +GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv); + +#if GTEST_HAS_DEATH_TEST + +// Returns the message describing the last system error, regardless of the +// platform. +GTEST_API_ String GetLastErrnoDescription(); + +# if GTEST_OS_WINDOWS +// Provides leak-safe Windows kernel handle ownership. +class AutoHandle { + public: + AutoHandle() : handle_(INVALID_HANDLE_VALUE) {} + explicit AutoHandle(HANDLE handle) : handle_(handle) {} + + ~AutoHandle() { Reset(); } + + HANDLE Get() const { return handle_; } + void Reset() { Reset(INVALID_HANDLE_VALUE); } + void Reset(HANDLE handle) { + if (handle != handle_) { + if (handle_ != INVALID_HANDLE_VALUE) + ::CloseHandle(handle_); + handle_ = handle; + } + } + + private: + HANDLE handle_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(AutoHandle); +}; +# endif // GTEST_OS_WINDOWS + +// Attempts to parse a string into a positive integer pointed to by the +// number parameter. Returns true if that is possible. +// GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we can use +// it here. +template <typename Integer> +bool ParseNaturalNumber(const ::std::string& str, Integer* number) { + // Fail fast if the given string does not begin with a digit; + // this bypasses strtoXXX's "optional leading whitespace and plus + // or minus sign" semantics, which are undesirable here. + if (str.empty() || !IsDigit(str[0])) { + return false; + } + errno = 0; + + char* end; + // BiggestConvertible is the largest integer type that system-provided + // string-to-number conversion routines can return. + +# if GTEST_OS_WINDOWS && !defined(__GNUC__) + + // MSVC and C++ Builder define __int64 instead of the standard long long. + typedef unsigned __int64 BiggestConvertible; + const BiggestConvertible parsed = _strtoui64(str.c_str(), &end, 10); + +# else + + typedef unsigned long long BiggestConvertible; // NOLINT + const BiggestConvertible parsed = strtoull(str.c_str(), &end, 10); + +# endif // GTEST_OS_WINDOWS && !defined(__GNUC__) + + const bool parse_success = *end == '\0' && errno == 0; + + // TODO(vladl@google.com): Convert this to compile time assertion when it is + // available. + GTEST_CHECK_(sizeof(Integer) <= sizeof(parsed)); + + const Integer result = static_cast<Integer>(parsed); + if (parse_success && static_cast<BiggestConvertible>(result) == parsed) { + *number = result; + return true; + } + return false; +} +#endif // GTEST_HAS_DEATH_TEST + +// TestResult contains some private methods that should be hidden from +// Google Test user but are required for testing. This class allow our tests +// to access them. +// +// This class is supplied only for the purpose of testing Google Test's own +// constructs. Do not use it in user tests, either directly or indirectly. +class TestResultAccessor { + public: + static void RecordProperty(TestResult* test_result, + const TestProperty& property) { + test_result->RecordProperty(property); + } + + static void ClearTestPartResults(TestResult* test_result) { + test_result->ClearTestPartResults(); + } + + static const std::vector<testing::TestPartResult>& test_part_results( + const TestResult& test_result) { + return test_result.test_part_results(); + } +}; + +} // namespace internal +} // namespace testing + +#endif // GTEST_SRC_GTEST_INTERNAL_INL_H_ diff --git a/tests/gtest/src/gtest-port.cc b/tests/gtest/src/gtest-port.cc new file mode 100644 index 000000000..b860d4812 --- /dev/null +++ b/tests/gtest/src/gtest-port.cc @@ -0,0 +1,746 @@ +// Copyright 2008, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Author: wan@google.com (Zhanyong Wan) + +#include "gtest/internal/gtest-port.h" + +#include <limits.h> +#include <stdlib.h> +#include <stdio.h> +#include <string.h> + +#if GTEST_OS_WINDOWS_MOBILE +# include <windows.h> // For TerminateProcess() +#elif GTEST_OS_WINDOWS +# include <io.h> +# include <sys/stat.h> +#else +# include <unistd.h> +#endif // GTEST_OS_WINDOWS_MOBILE + +#if GTEST_OS_MAC +# include <mach/mach_init.h> +# include <mach/task.h> +# include <mach/vm_map.h> +#endif // GTEST_OS_MAC + +#include "gtest/gtest-spi.h" +#include "gtest/gtest-message.h" +#include "gtest/internal/gtest-internal.h" +#include "gtest/internal/gtest-string.h" + +// Indicates that this translation unit is part of Google Test's +// implementation. It must come before gtest-internal-inl.h is +// included, or there will be a compiler error. This trick is to +// prevent a user from accidentally including gtest-internal-inl.h in +// his code. +#define GTEST_IMPLEMENTATION_ 1 +#include "src/gtest-internal-inl.h" +#undef GTEST_IMPLEMENTATION_ + +namespace testing { +namespace internal { + +#if defined(_MSC_VER) || defined(__BORLANDC__) +// MSVC and C++Builder do not provide a definition of STDERR_FILENO. +const int kStdOutFileno = 1; +const int kStdErrFileno = 2; +#else +const int kStdOutFileno = STDOUT_FILENO; +const int kStdErrFileno = STDERR_FILENO; +#endif // _MSC_VER + +#if GTEST_OS_MAC + +// Returns the number of threads running in the process, or 0 to indicate that +// we cannot detect it. +size_t GetThreadCount() { + const task_t task = mach_task_self(); + mach_msg_type_number_t thread_count; + thread_act_array_t thread_list; + const kern_return_t status = task_threads(task, &thread_list, &thread_count); + if (status == KERN_SUCCESS) { + // task_threads allocates resources in thread_list and we need to free them + // to avoid leaks. + vm_deallocate(task, + reinterpret_cast<vm_address_t>(thread_list), + sizeof(thread_t) * thread_count); + return static_cast<size_t>(thread_count); + } else { + return 0; + } +} + +#else + +size_t GetThreadCount() { + // There's no portable way to detect the number of threads, so we just + // return 0 to indicate that we cannot detect it. + return 0; +} + +#endif // GTEST_OS_MAC + +#if GTEST_USES_POSIX_RE + +// Implements RE. Currently only needed for death tests. + +RE::~RE() { + if (is_valid_) { + // regfree'ing an invalid regex might crash because the content + // of the regex is undefined. Since the regex's are essentially + // the same, one cannot be valid (or invalid) without the other + // being so too. + regfree(&partial_regex_); + regfree(&full_regex_); + } + free(const_cast<char*>(pattern_)); +} + +// Returns true iff regular expression re matches the entire str. +bool RE::FullMatch(const char* str, const RE& re) { + if (!re.is_valid_) return false; + + regmatch_t match; + return regexec(&re.full_regex_, str, 1, &match, 0) == 0; +} + +// Returns true iff regular expression re matches a substring of str +// (including str itself). +bool RE::PartialMatch(const char* str, const RE& re) { + if (!re.is_valid_) return false; + + regmatch_t match; + return regexec(&re.partial_regex_, str, 1, &match, 0) == 0; +} + +// Initializes an RE from its string representation. +void RE::Init(const char* regex) { + pattern_ = posix::StrDup(regex); + + // Reserves enough bytes to hold the regular expression used for a + // full match. + const size_t full_regex_len = strlen(regex) + 10; + char* const full_pattern = new char[full_regex_len]; + + snprintf(full_pattern, full_regex_len, "^(%s)$", regex); + is_valid_ = regcomp(&full_regex_, full_pattern, REG_EXTENDED) == 0; + // We want to call regcomp(&partial_regex_, ...) even if the + // previous expression returns false. Otherwise partial_regex_ may + // not be properly initialized can may cause trouble when it's + // freed. + // + // Some implementation of POSIX regex (e.g. on at least some + // versions of Cygwin) doesn't accept the empty string as a valid + // regex. We change it to an equivalent form "()" to be safe. + if (is_valid_) { + const char* const partial_regex = (*regex == '\0') ? "()" : regex; + is_valid_ = regcomp(&partial_regex_, partial_regex, REG_EXTENDED) == 0; + } + EXPECT_TRUE(is_valid_) + << "Regular expression \"" << regex + << "\" is not a valid POSIX Extended regular expression."; + + delete[] full_pattern; +} + +#elif GTEST_USES_SIMPLE_RE + +// Returns true iff ch appears anywhere in str (excluding the +// terminating '\0' character). +bool IsInSet(char ch, const char* str) { + return ch != '\0' && strchr(str, ch) != NULL; +} + +// Returns true iff ch belongs to the given classification. Unlike +// similar functions in <ctype.h>, these aren't affected by the +// current locale. +bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; } +bool IsAsciiPunct(char ch) { + return IsInSet(ch, "^-!\"#$%&'()*+,./:;<=>?@[\\]_`{|}~"); +} +bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); } +bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); } +bool IsAsciiWordChar(char ch) { + return ('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z') || + ('0' <= ch && ch <= '9') || ch == '_'; +} + +// Returns true iff "\\c" is a supported escape sequence. +bool IsValidEscape(char c) { + return (IsAsciiPunct(c) || IsInSet(c, "dDfnrsStvwW")); +} + +// Returns true iff the given atom (specified by escaped and pattern) +// matches ch. The result is undefined if the atom is invalid. +bool AtomMatchesChar(bool escaped, char pattern_char, char ch) { + if (escaped) { // "\\p" where p is pattern_char. + switch (pattern_char) { + case 'd': return IsAsciiDigit(ch); + case 'D': return !IsAsciiDigit(ch); + case 'f': return ch == '\f'; + case 'n': return ch == '\n'; + case 'r': return ch == '\r'; + case 's': return IsAsciiWhiteSpace(ch); + case 'S': return !IsAsciiWhiteSpace(ch); + case 't': return ch == '\t'; + case 'v': return ch == '\v'; + case 'w': return IsAsciiWordChar(ch); + case 'W': return !IsAsciiWordChar(ch); + } + return IsAsciiPunct(pattern_char) && pattern_char == ch; + } + + return (pattern_char == '.' && ch != '\n') || pattern_char == ch; +} + +// Helper function used by ValidateRegex() to format error messages. +String FormatRegexSyntaxError(const char* regex, int index) { + return (Message() << "Syntax error at index " << index + << " in simple regular expression \"" << regex << "\": ").GetString(); +} + +// Generates non-fatal failures and returns false if regex is invalid; +// otherwise returns true. +bool ValidateRegex(const char* regex) { + if (regex == NULL) { + // TODO(wan@google.com): fix the source file location in the + // assertion failures to match where the regex is used in user + // code. + ADD_FAILURE() << "NULL is not a valid simple regular expression."; + return false; + } + + bool is_valid = true; + + // True iff ?, *, or + can follow the previous atom. + bool prev_repeatable = false; + for (int i = 0; regex[i]; i++) { + if (regex[i] == '\\') { // An escape sequence + i++; + if (regex[i] == '\0') { + ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1) + << "'\\' cannot appear at the end."; + return false; + } + + if (!IsValidEscape(regex[i])) { + ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1) + << "invalid escape sequence \"\\" << regex[i] << "\"."; + is_valid = false; + } + prev_repeatable = true; + } else { // Not an escape sequence. + const char ch = regex[i]; + + if (ch == '^' && i > 0) { + ADD_FAILURE() << FormatRegexSyntaxError(regex, i) + << "'^' can only appear at the beginning."; + is_valid = false; + } else if (ch == '$' && regex[i + 1] != '\0') { + ADD_FAILURE() << FormatRegexSyntaxError(regex, i) + << "'$' can only appear at the end."; + is_valid = false; + } else if (IsInSet(ch, "()[]{}|")) { + ADD_FAILURE() << FormatRegexSyntaxError(regex, i) + << "'" << ch << "' is unsupported."; + is_valid = false; + } else if (IsRepeat(ch) && !prev_repeatable) { + ADD_FAILURE() << FormatRegexSyntaxError(regex, i) + << "'" << ch << "' can only follow a repeatable token."; + is_valid = false; + } + + prev_repeatable = !IsInSet(ch, "^$?*+"); + } + } + + return is_valid; +} + +// Matches a repeated regex atom followed by a valid simple regular +// expression. The regex atom is defined as c if escaped is false, +// or \c otherwise. repeat is the repetition meta character (?, *, +// or +). The behavior is undefined if str contains too many +// characters to be indexable by size_t, in which case the test will +// probably time out anyway. We are fine with this limitation as +// std::string has it too. +bool MatchRepetitionAndRegexAtHead( + bool escaped, char c, char repeat, const char* regex, + const char* str) { + const size_t min_count = (repeat == '+') ? 1 : 0; + const size_t max_count = (repeat == '?') ? 1 : + static_cast<size_t>(-1) - 1; + // We cannot call numeric_limits::max() as it conflicts with the + // max() macro on Windows. + + for (size_t i = 0; i <= max_count; ++i) { + // We know that the atom matches each of the first i characters in str. + if (i >= min_count && MatchRegexAtHead(regex, str + i)) { + // We have enough matches at the head, and the tail matches too. + // Since we only care about *whether* the pattern matches str + // (as opposed to *how* it matches), there is no need to find a + // greedy match. + return true; + } + if (str[i] == '\0' || !AtomMatchesChar(escaped, c, str[i])) + return false; + } + return false; +} + +// Returns true iff regex matches a prefix of str. regex must be a +// valid simple regular expression and not start with "^", or the +// result is undefined. +bool MatchRegexAtHead(const char* regex, const char* str) { + if (*regex == '\0') // An empty regex matches a prefix of anything. + return true; + + // "$" only matches the end of a string. Note that regex being + // valid guarantees that there's nothing after "$" in it. + if (*regex == '$') + return *str == '\0'; + + // Is the first thing in regex an escape sequence? + const bool escaped = *regex == '\\'; + if (escaped) + ++regex; + if (IsRepeat(regex[1])) { + // MatchRepetitionAndRegexAtHead() calls MatchRegexAtHead(), so + // here's an indirect recursion. It terminates as the regex gets + // shorter in each recursion. + return MatchRepetitionAndRegexAtHead( + escaped, regex[0], regex[1], regex + 2, str); + } else { + // regex isn't empty, isn't "$", and doesn't start with a + // repetition. We match the first atom of regex with the first + // character of str and recurse. + return (*str != '\0') && AtomMatchesChar(escaped, *regex, *str) && + MatchRegexAtHead(regex + 1, str + 1); + } +} + +// Returns true iff regex matches any substring of str. regex must be +// a valid simple regular expression, or the result is undefined. +// +// The algorithm is recursive, but the recursion depth doesn't exceed +// the regex length, so we won't need to worry about running out of +// stack space normally. In rare cases the time complexity can be +// exponential with respect to the regex length + the string length, +// but usually it's must faster (often close to linear). +bool MatchRegexAnywhere(const char* regex, const char* str) { + if (regex == NULL || str == NULL) + return false; + + if (*regex == '^') + return MatchRegexAtHead(regex + 1, str); + + // A successful match can be anywhere in str. + do { + if (MatchRegexAtHead(regex, str)) + return true; + } while (*str++ != '\0'); + return false; +} + +// Implements the RE class. + +RE::~RE() { + free(const_cast<char*>(pattern_)); + free(const_cast<char*>(full_pattern_)); +} + +// Returns true iff regular expression re matches the entire str. +bool RE::FullMatch(const char* str, const RE& re) { + return re.is_valid_ && MatchRegexAnywhere(re.full_pattern_, str); +} + +// Returns true iff regular expression re matches a substring of str +// (including str itself). +bool RE::PartialMatch(const char* str, const RE& re) { + return re.is_valid_ && MatchRegexAnywhere(re.pattern_, str); +} + +// Initializes an RE from its string representation. +void RE::Init(const char* regex) { + pattern_ = full_pattern_ = NULL; + if (regex != NULL) { + pattern_ = posix::StrDup(regex); + } + + is_valid_ = ValidateRegex(regex); + if (!is_valid_) { + // No need to calculate the full pattern when the regex is invalid. + return; + } + + const size_t len = strlen(regex); + // Reserves enough bytes to hold the regular expression used for a + // full match: we need space to prepend a '^', append a '$', and + // terminate the string with '\0'. + char* buffer = static_cast<char*>(malloc(len + 3)); + full_pattern_ = buffer; + + if (*regex != '^') + *buffer++ = '^'; // Makes sure full_pattern_ starts with '^'. + + // We don't use snprintf or strncpy, as they trigger a warning when + // compiled with VC++ 8.0. + memcpy(buffer, regex, len); + buffer += len; + + if (len == 0 || regex[len - 1] != '$') + *buffer++ = '$'; // Makes sure full_pattern_ ends with '$'. + + *buffer = '\0'; +} + +#endif // GTEST_USES_POSIX_RE + +const char kUnknownFile[] = "unknown file"; + +// Formats a source file path and a line number as they would appear +// in an error message from the compiler used to compile this code. +GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) { + const char* const file_name = file == NULL ? kUnknownFile : file; + + if (line < 0) { + return String::Format("%s:", file_name).c_str(); + } +#ifdef _MSC_VER + return String::Format("%s(%d):", file_name, line).c_str(); +#else + return String::Format("%s:%d:", file_name, line).c_str(); +#endif // _MSC_VER +} + +// Formats a file location for compiler-independent XML output. +// Although this function is not platform dependent, we put it next to +// FormatFileLocation in order to contrast the two functions. +// Note that FormatCompilerIndependentFileLocation() does NOT append colon +// to the file location it produces, unlike FormatFileLocation(). +GTEST_API_ ::std::string FormatCompilerIndependentFileLocation( + const char* file, int line) { + const char* const file_name = file == NULL ? kUnknownFile : file; + + if (line < 0) + return file_name; + else + return String::Format("%s:%d", file_name, line).c_str(); +} + + +GTestLog::GTestLog(GTestLogSeverity severity, const char* file, int line) + : severity_(severity) { + const char* const marker = + severity == GTEST_INFO ? "[ INFO ]" : + severity == GTEST_WARNING ? "[WARNING]" : + severity == GTEST_ERROR ? "[ ERROR ]" : "[ FATAL ]"; + GetStream() << ::std::endl << marker << " " + << FormatFileLocation(file, line).c_str() << ": "; +} + +// Flushes the buffers and, if severity is GTEST_FATAL, aborts the program. +GTestLog::~GTestLog() { + GetStream() << ::std::endl; + if (severity_ == GTEST_FATAL) { + fflush(stderr); + posix::Abort(); + } +} +// Disable Microsoft deprecation warnings for POSIX functions called from +// this class (creat, dup, dup2, and close) +#ifdef _MSC_VER +# pragma warning(push) +# pragma warning(disable: 4996) +#endif // _MSC_VER + +#if GTEST_HAS_STREAM_REDIRECTION + +// Object that captures an output stream (stdout/stderr). +class CapturedStream { + public: + // The ctor redirects the stream to a temporary file. + CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) { + +# if GTEST_OS_WINDOWS + char temp_dir_path[MAX_PATH + 1] = { '\0' }; // NOLINT + char temp_file_path[MAX_PATH + 1] = { '\0' }; // NOLINT + + ::GetTempPathA(sizeof(temp_dir_path), temp_dir_path); + const UINT success = ::GetTempFileNameA(temp_dir_path, + "gtest_redir", + 0, // Generate unique file name. + temp_file_path); + GTEST_CHECK_(success != 0) + << "Unable to create a temporary file in " << temp_dir_path; + const int captured_fd = creat(temp_file_path, _S_IREAD | _S_IWRITE); + GTEST_CHECK_(captured_fd != -1) << "Unable to open temporary file " + << temp_file_path; + filename_ = temp_file_path; +# else + // There's no guarantee that a test has write access to the + // current directory, so we create the temporary file in the /tmp + // directory instead. + char name_template[] = "/tmp/captured_stream.XXXXXX"; + const int captured_fd = mkstemp(name_template); + filename_ = name_template; +# endif // GTEST_OS_WINDOWS + fflush(NULL); + dup2(captured_fd, fd_); + close(captured_fd); + } + + ~CapturedStream() { + remove(filename_.c_str()); + } + + String GetCapturedString() { + if (uncaptured_fd_ != -1) { + // Restores the original stream. + fflush(NULL); + dup2(uncaptured_fd_, fd_); + close(uncaptured_fd_); + uncaptured_fd_ = -1; + } + + FILE* const file = posix::FOpen(filename_.c_str(), "r"); + const String content = ReadEntireFile(file); + posix::FClose(file); + return content; + } + + private: + // Reads the entire content of a file as a String. + static String ReadEntireFile(FILE* file); + + // Returns the size (in bytes) of a file. + static size_t GetFileSize(FILE* file); + + const int fd_; // A stream to capture. + int uncaptured_fd_; + // Name of the temporary file holding the stderr output. + ::std::string filename_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(CapturedStream); +}; + +// Returns the size (in bytes) of a file. +size_t CapturedStream::GetFileSize(FILE* file) { + fseek(file, 0, SEEK_END); + return static_cast<size_t>(ftell(file)); +} + +// Reads the entire content of a file as a string. +String CapturedStream::ReadEntireFile(FILE* file) { + const size_t file_size = GetFileSize(file); + char* const buffer = new char[file_size]; + + size_t bytes_last_read = 0; // # of bytes read in the last fread() + size_t bytes_read = 0; // # of bytes read so far + + fseek(file, 0, SEEK_SET); + + // Keeps reading the file until we cannot read further or the + // pre-determined file size is reached. + do { + bytes_last_read = fread(buffer+bytes_read, 1, file_size-bytes_read, file); + bytes_read += bytes_last_read; + } while (bytes_last_read > 0 && bytes_read < file_size); + + const String content(buffer, bytes_read); + delete[] buffer; + + return content; +} + +# ifdef _MSC_VER +# pragma warning(pop) +# endif // _MSC_VER + +static CapturedStream* g_captured_stderr = NULL; +static CapturedStream* g_captured_stdout = NULL; + +// Starts capturing an output stream (stdout/stderr). +void CaptureStream(int fd, const char* stream_name, CapturedStream** stream) { + if (*stream != NULL) { + GTEST_LOG_(FATAL) << "Only one " << stream_name + << " capturer can exist at a time."; + } + *stream = new CapturedStream(fd); +} + +// Stops capturing the output stream and returns the captured string. +String GetCapturedStream(CapturedStream** captured_stream) { + const String content = (*captured_stream)->GetCapturedString(); + + delete *captured_stream; + *captured_stream = NULL; + + return content; +} + +// Starts capturing stdout. +void CaptureStdout() { + CaptureStream(kStdOutFileno, "stdout", &g_captured_stdout); +} + +// Starts capturing stderr. +void CaptureStderr() { + CaptureStream(kStdErrFileno, "stderr", &g_captured_stderr); +} + +// Stops capturing stdout and returns the captured string. +String GetCapturedStdout() { return GetCapturedStream(&g_captured_stdout); } + +// Stops capturing stderr and returns the captured string. +String GetCapturedStderr() { return GetCapturedStream(&g_captured_stderr); } + +#endif // GTEST_HAS_STREAM_REDIRECTION + +#if GTEST_HAS_DEATH_TEST + +// A copy of all command line arguments. Set by InitGoogleTest(). +::std::vector<String> g_argvs; + +// Returns the command line as a vector of strings. +const ::std::vector<String>& GetArgvs() { return g_argvs; } + +#endif // GTEST_HAS_DEATH_TEST + +#if GTEST_OS_WINDOWS_MOBILE +namespace posix { +void Abort() { + DebugBreak(); + TerminateProcess(GetCurrentProcess(), 1); +} +} // namespace posix +#endif // GTEST_OS_WINDOWS_MOBILE + +// Returns the name of the environment variable corresponding to the +// given flag. For example, FlagToEnvVar("foo") will return +// "GTEST_FOO" in the open-source version. +static String FlagToEnvVar(const char* flag) { + const String full_flag = + (Message() << GTEST_FLAG_PREFIX_ << flag).GetString(); + + Message env_var; + for (size_t i = 0; i != full_flag.length(); i++) { + env_var << ToUpper(full_flag.c_str()[i]); + } + + return env_var.GetString(); +} + +// Parses 'str' for a 32-bit signed integer. If successful, writes +// the result to *value and returns true; otherwise leaves *value +// unchanged and returns false. +bool ParseInt32(const Message& src_text, const char* str, Int32* value) { + // Parses the environment variable as a decimal integer. + char* end = NULL; + const long long_value = strtol(str, &end, 10); // NOLINT + + // Has strtol() consumed all characters in the string? + if (*end != '\0') { + // No - an invalid character was encountered. + Message msg; + msg << "WARNING: " << src_text + << " is expected to be a 32-bit integer, but actually" + << " has value \"" << str << "\".\n"; + printf("%s", msg.GetString().c_str()); + fflush(stdout); + return false; + } + + // Is the parsed value in the range of an Int32? + const Int32 result = static_cast<Int32>(long_value); + if (long_value == LONG_MAX || long_value == LONG_MIN || + // The parsed value overflows as a long. (strtol() returns + // LONG_MAX or LONG_MIN when the input overflows.) + result != long_value + // The parsed value overflows as an Int32. + ) { + Message msg; + msg << "WARNING: " << src_text + << " is expected to be a 32-bit integer, but actually" + << " has value " << str << ", which overflows.\n"; + printf("%s", msg.GetString().c_str()); + fflush(stdout); + return false; + } + + *value = result; + return true; +} + +// Reads and returns the Boolean environment variable corresponding to +// the given flag; if it's not set, returns default_value. +// +// The value is considered true iff it's not "0". +bool BoolFromGTestEnv(const char* flag, bool default_value) { + const String env_var = FlagToEnvVar(flag); + const char* const string_value = posix::GetEnv(env_var.c_str()); + return string_value == NULL ? + default_value : strcmp(string_value, "0") != 0; +} + +// Reads and returns a 32-bit integer stored in the environment +// variable corresponding to the given flag; if it isn't set or +// doesn't represent a valid 32-bit integer, returns default_value. +Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) { + const String env_var = FlagToEnvVar(flag); + const char* const string_value = posix::GetEnv(env_var.c_str()); + if (string_value == NULL) { + // The environment variable is not set. + return default_value; + } + + Int32 result = default_value; + if (!ParseInt32(Message() << "Environment variable " << env_var, + string_value, &result)) { + printf("The default value %s is used.\n", + (Message() << default_value).GetString().c_str()); + fflush(stdout); + return default_value; + } + + return result; +} + +// Reads and returns the string environment variable corresponding to +// the given flag; if it's not set, returns default_value. +const char* StringFromGTestEnv(const char* flag, const char* default_value) { + const String env_var = FlagToEnvVar(flag); + const char* const value = posix::GetEnv(env_var.c_str()); + return value == NULL ? default_value : value; +} + +} // namespace internal +} // namespace testing diff --git a/tests/gtest/src/gtest-printers.cc b/tests/gtest/src/gtest-printers.cc new file mode 100644 index 000000000..ed63c7b3b --- /dev/null +++ b/tests/gtest/src/gtest-printers.cc @@ -0,0 +1,356 @@ +// Copyright 2007, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Author: wan@google.com (Zhanyong Wan) + +// Google Test - The Google C++ Testing Framework +// +// This file implements a universal value printer that can print a +// value of any type T: +// +// void ::testing::internal::UniversalPrinter<T>::Print(value, ostream_ptr); +// +// It uses the << operator when possible, and prints the bytes in the +// object otherwise. A user can override its behavior for a class +// type Foo by defining either operator<<(::std::ostream&, const Foo&) +// or void PrintTo(const Foo&, ::std::ostream*) in the namespace that +// defines Foo. + +#include "gtest/gtest-printers.h" +#include <ctype.h> +#include <stdio.h> +#include <ostream> // NOLINT +#include <string> +#include "gtest/internal/gtest-port.h" + +namespace testing { + +namespace { + +using ::std::ostream; + +#if GTEST_OS_WINDOWS_MOBILE // Windows CE does not define _snprintf_s. +# define snprintf _snprintf +#elif _MSC_VER >= 1400 // VC 8.0 and later deprecate snprintf and _snprintf. +# define snprintf _snprintf_s +#elif _MSC_VER +# define snprintf _snprintf +#endif // GTEST_OS_WINDOWS_MOBILE + +// Prints a segment of bytes in the given object. +void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes, size_t start, + size_t count, ostream* os) { + char text[5] = ""; + for (size_t i = 0; i != count; i++) { + const size_t j = start + i; + if (i != 0) { + // Organizes the bytes into groups of 2 for easy parsing by + // human. + if ((j % 2) == 0) + *os << ' '; + else + *os << '-'; + } + snprintf(text, sizeof(text), "%02X", obj_bytes[j]); + *os << text; + } +} + +// Prints the bytes in the given value to the given ostream. +void PrintBytesInObjectToImpl(const unsigned char* obj_bytes, size_t count, + ostream* os) { + // Tells the user how big the object is. + *os << count << "-byte object <"; + + const size_t kThreshold = 132; + const size_t kChunkSize = 64; + // If the object size is bigger than kThreshold, we'll have to omit + // some details by printing only the first and the last kChunkSize + // bytes. + // TODO(wan): let the user control the threshold using a flag. + if (count < kThreshold) { + PrintByteSegmentInObjectTo(obj_bytes, 0, count, os); + } else { + PrintByteSegmentInObjectTo(obj_bytes, 0, kChunkSize, os); + *os << " ... "; + // Rounds up to 2-byte boundary. + const size_t resume_pos = (count - kChunkSize + 1)/2*2; + PrintByteSegmentInObjectTo(obj_bytes, resume_pos, count - resume_pos, os); + } + *os << ">"; +} + +} // namespace + +namespace internal2 { + +// Delegates to PrintBytesInObjectToImpl() to print the bytes in the +// given object. The delegation simplifies the implementation, which +// uses the << operator and thus is easier done outside of the +// ::testing::internal namespace, which contains a << operator that +// sometimes conflicts with the one in STL. +void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count, + ostream* os) { + PrintBytesInObjectToImpl(obj_bytes, count, os); +} + +} // namespace internal2 + +namespace internal { + +// Depending on the value of a char (or wchar_t), we print it in one +// of three formats: +// - as is if it's a printable ASCII (e.g. 'a', '2', ' '), +// - as a hexidecimal escape sequence (e.g. '\x7F'), or +// - as a special escape sequence (e.g. '\r', '\n'). +enum CharFormat { + kAsIs, + kHexEscape, + kSpecialEscape +}; + +// Returns true if c is a printable ASCII character. We test the +// value of c directly instead of calling isprint(), which is buggy on +// Windows Mobile. +inline bool IsPrintableAscii(wchar_t c) { + return 0x20 <= c && c <= 0x7E; +} + +// Prints a wide or narrow char c as a character literal without the +// quotes, escaping it when necessary; returns how c was formatted. +// The template argument UnsignedChar is the unsigned version of Char, +// which is the type of c. +template <typename UnsignedChar, typename Char> +static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) { + switch (static_cast<wchar_t>(c)) { + case L'\0': + *os << "\\0"; + break; + case L'\'': + *os << "\\'"; + break; + case L'\\': + *os << "\\\\"; + break; + case L'\a': + *os << "\\a"; + break; + case L'\b': + *os << "\\b"; + break; + case L'\f': + *os << "\\f"; + break; + case L'\n': + *os << "\\n"; + break; + case L'\r': + *os << "\\r"; + break; + case L'\t': + *os << "\\t"; + break; + case L'\v': + *os << "\\v"; + break; + default: + if (IsPrintableAscii(c)) { + *os << static_cast<char>(c); + return kAsIs; + } else { + *os << String::Format("\\x%X", static_cast<UnsignedChar>(c)); + return kHexEscape; + } + } + return kSpecialEscape; +} + +// Prints a char c as if it's part of a string literal, escaping it when +// necessary; returns how c was formatted. +static CharFormat PrintAsWideStringLiteralTo(wchar_t c, ostream* os) { + switch (c) { + case L'\'': + *os << "'"; + return kAsIs; + case L'"': + *os << "\\\""; + return kSpecialEscape; + default: + return PrintAsCharLiteralTo<wchar_t>(c, os); + } +} + +// Prints a char c as if it's part of a string literal, escaping it when +// necessary; returns how c was formatted. +static CharFormat PrintAsNarrowStringLiteralTo(char c, ostream* os) { + return PrintAsWideStringLiteralTo(static_cast<unsigned char>(c), os); +} + +// Prints a wide or narrow character c and its code. '\0' is printed +// as "'\\0'", other unprintable characters are also properly escaped +// using the standard C++ escape sequence. The template argument +// UnsignedChar is the unsigned version of Char, which is the type of c. +template <typename UnsignedChar, typename Char> +void PrintCharAndCodeTo(Char c, ostream* os) { + // First, print c as a literal in the most readable form we can find. + *os << ((sizeof(c) > 1) ? "L'" : "'"); + const CharFormat format = PrintAsCharLiteralTo<UnsignedChar>(c, os); + *os << "'"; + + // To aid user debugging, we also print c's code in decimal, unless + // it's 0 (in which case c was printed as '\\0', making the code + // obvious). + if (c == 0) + return; + *os << " (" << String::Format("%d", c).c_str(); + + // For more convenience, we print c's code again in hexidecimal, + // unless c was already printed in the form '\x##' or the code is in + // [1, 9]. + if (format == kHexEscape || (1 <= c && c <= 9)) { + // Do nothing. + } else { + *os << String::Format(", 0x%X", + static_cast<UnsignedChar>(c)).c_str(); + } + *os << ")"; +} + +void PrintTo(unsigned char c, ::std::ostream* os) { + PrintCharAndCodeTo<unsigned char>(c, os); +} +void PrintTo(signed char c, ::std::ostream* os) { + PrintCharAndCodeTo<unsigned char>(c, os); +} + +// Prints a wchar_t as a symbol if it is printable or as its internal +// code otherwise and also as its code. L'\0' is printed as "L'\\0'". +void PrintTo(wchar_t wc, ostream* os) { + PrintCharAndCodeTo<wchar_t>(wc, os); +} + +// Prints the given array of characters to the ostream. +// The array starts at *begin, the length is len, it may include '\0' characters +// and may not be null-terminated. +static void PrintCharsAsStringTo(const char* begin, size_t len, ostream* os) { + *os << "\""; + bool is_previous_hex = false; + for (size_t index = 0; index < len; ++index) { + const char cur = begin[index]; + if (is_previous_hex && IsXDigit(cur)) { + // Previous character is of '\x..' form and this character can be + // interpreted as another hexadecimal digit in its number. Break string to + // disambiguate. + *os << "\" \""; + } + is_previous_hex = PrintAsNarrowStringLiteralTo(cur, os) == kHexEscape; + } + *os << "\""; +} + +// Prints a (const) char array of 'len' elements, starting at address 'begin'. +void UniversalPrintArray(const char* begin, size_t len, ostream* os) { + PrintCharsAsStringTo(begin, len, os); +} + +// Prints the given array of wide characters to the ostream. +// The array starts at *begin, the length is len, it may include L'\0' +// characters and may not be null-terminated. +static void PrintWideCharsAsStringTo(const wchar_t* begin, size_t len, + ostream* os) { + *os << "L\""; + bool is_previous_hex = false; + for (size_t index = 0; index < len; ++index) { + const wchar_t cur = begin[index]; + if (is_previous_hex && isascii(cur) && IsXDigit(static_cast<char>(cur))) { + // Previous character is of '\x..' form and this character can be + // interpreted as another hexadecimal digit in its number. Break string to + // disambiguate. + *os << "\" L\""; + } + is_previous_hex = PrintAsWideStringLiteralTo(cur, os) == kHexEscape; + } + *os << "\""; +} + +// Prints the given C string to the ostream. +void PrintTo(const char* s, ostream* os) { + if (s == NULL) { + *os << "NULL"; + } else { + *os << ImplicitCast_<const void*>(s) << " pointing to "; + PrintCharsAsStringTo(s, strlen(s), os); + } +} + +// MSVC compiler can be configured to define whar_t as a typedef +// of unsigned short. Defining an overload for const wchar_t* in that case +// would cause pointers to unsigned shorts be printed as wide strings, +// possibly accessing more memory than intended and causing invalid +// memory accesses. MSVC defines _NATIVE_WCHAR_T_DEFINED symbol when +// wchar_t is implemented as a native type. +#if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED) +// Prints the given wide C string to the ostream. +void PrintTo(const wchar_t* s, ostream* os) { + if (s == NULL) { + *os << "NULL"; + } else { + *os << ImplicitCast_<const void*>(s) << " pointing to "; + PrintWideCharsAsStringTo(s, wcslen(s), os); + } +} +#endif // wchar_t is native + +// Prints a ::string object. +#if GTEST_HAS_GLOBAL_STRING +void PrintStringTo(const ::string& s, ostream* os) { + PrintCharsAsStringTo(s.data(), s.size(), os); +} +#endif // GTEST_HAS_GLOBAL_STRING + +void PrintStringTo(const ::std::string& s, ostream* os) { + PrintCharsAsStringTo(s.data(), s.size(), os); +} + +// Prints a ::wstring object. +#if GTEST_HAS_GLOBAL_WSTRING +void PrintWideStringTo(const ::wstring& s, ostream* os) { + PrintWideCharsAsStringTo(s.data(), s.size(), os); +} +#endif // GTEST_HAS_GLOBAL_WSTRING + +#if GTEST_HAS_STD_WSTRING +void PrintWideStringTo(const ::std::wstring& s, ostream* os) { + PrintWideCharsAsStringTo(s.data(), s.size(), os); +} +#endif // GTEST_HAS_STD_WSTRING + +} // namespace internal + +} // namespace testing diff --git a/tests/gtest/src/gtest-test-part.cc b/tests/gtest/src/gtest-test-part.cc new file mode 100644 index 000000000..5ddc67c1c --- /dev/null +++ b/tests/gtest/src/gtest-test-part.cc @@ -0,0 +1,110 @@ +// Copyright 2008, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Author: mheule@google.com (Markus Heule) +// +// The Google C++ Testing Framework (Google Test) + +#include "gtest/gtest-test-part.h" + +// Indicates that this translation unit is part of Google Test's +// implementation. It must come before gtest-internal-inl.h is +// included, or there will be a compiler error. This trick is to +// prevent a user from accidentally including gtest-internal-inl.h in +// his code. +#define GTEST_IMPLEMENTATION_ 1 +#include "src/gtest-internal-inl.h" +#undef GTEST_IMPLEMENTATION_ + +namespace testing { + +using internal::GetUnitTestImpl; + +// Gets the summary of the failure message by omitting the stack trace +// in it. +internal::String TestPartResult::ExtractSummary(const char* message) { + const char* const stack_trace = strstr(message, internal::kStackTraceMarker); + return stack_trace == NULL ? internal::String(message) : + internal::String(message, stack_trace - message); +} + +// Prints a TestPartResult object. +std::ostream& operator<<(std::ostream& os, const TestPartResult& result) { + return os + << result.file_name() << ":" << result.line_number() << ": " + << (result.type() == TestPartResult::kSuccess ? "Success" : + result.type() == TestPartResult::kFatalFailure ? "Fatal failure" : + "Non-fatal failure") << ":\n" + << result.message() << std::endl; +} + +// Appends a TestPartResult to the array. +void TestPartResultArray::Append(const TestPartResult& result) { + array_.push_back(result); +} + +// Returns the TestPartResult at the given index (0-based). +const TestPartResult& TestPartResultArray::GetTestPartResult(int index) const { + if (index < 0 || index >= size()) { + printf("\nInvalid index (%d) into TestPartResultArray.\n", index); + internal::posix::Abort(); + } + + return array_[index]; +} + +// Returns the number of TestPartResult objects in the array. +int TestPartResultArray::size() const { + return static_cast<int>(array_.size()); +} + +namespace internal { + +HasNewFatalFailureHelper::HasNewFatalFailureHelper() + : has_new_fatal_failure_(false), + original_reporter_(GetUnitTestImpl()-> + GetTestPartResultReporterForCurrentThread()) { + GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(this); +} + +HasNewFatalFailureHelper::~HasNewFatalFailureHelper() { + GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread( + original_reporter_); +} + +void HasNewFatalFailureHelper::ReportTestPartResult( + const TestPartResult& result) { + if (result.fatally_failed()) + has_new_fatal_failure_ = true; + original_reporter_->ReportTestPartResult(result); +} + +} // namespace internal + +} // namespace testing diff --git a/tests/gtest/src/gtest-typed-test.cc b/tests/gtest/src/gtest-typed-test.cc new file mode 100644 index 000000000..a5cc88f92 --- /dev/null +++ b/tests/gtest/src/gtest-typed-test.cc @@ -0,0 +1,110 @@ +// Copyright 2008 Google Inc. +// All Rights Reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Author: wan@google.com (Zhanyong Wan) + +#include "gtest/gtest-typed-test.h" +#include "gtest/gtest.h" + +namespace testing { +namespace internal { + +#if GTEST_HAS_TYPED_TEST_P + +// Skips to the first non-space char in str. Returns an empty string if str +// contains only whitespace characters. +static const char* SkipSpaces(const char* str) { + while (IsSpace(*str)) + str++; + return str; +} + +// Verifies that registered_tests match the test names in +// defined_test_names_; returns registered_tests if successful, or +// aborts the program otherwise. +const char* TypedTestCasePState::VerifyRegisteredTestNames( + const char* file, int line, const char* registered_tests) { + typedef ::std::set<const char*>::const_iterator DefinedTestIter; + registered_ = true; + + // Skip initial whitespace in registered_tests since some + // preprocessors prefix stringizied literals with whitespace. + registered_tests = SkipSpaces(registered_tests); + + Message errors; + ::std::set<String> tests; + for (const char* names = registered_tests; names != NULL; + names = SkipComma(names)) { + const String name = GetPrefixUntilComma(names); + if (tests.count(name) != 0) { + errors << "Test " << name << " is listed more than once.\n"; + continue; + } + + bool found = false; + for (DefinedTestIter it = defined_test_names_.begin(); + it != defined_test_names_.end(); + ++it) { + if (name == *it) { + found = true; + break; + } + } + + if (found) { + tests.insert(name); + } else { + errors << "No test named " << name + << " can be found in this test case.\n"; + } + } + + for (DefinedTestIter it = defined_test_names_.begin(); + it != defined_test_names_.end(); + ++it) { + if (tests.count(*it) == 0) { + errors << "You forgot to list test " << *it << ".\n"; + } + } + + const String& errors_str = errors.GetString(); + if (errors_str != "") { + fprintf(stderr, "%s %s", FormatFileLocation(file, line).c_str(), + errors_str.c_str()); + fflush(stderr); + posix::Abort(); + } + + return registered_tests; +} + +#endif // GTEST_HAS_TYPED_TEST_P + +} // namespace internal +} // namespace testing diff --git a/tests/gtest/src/gtest.cc b/tests/gtest/src/gtest.cc new file mode 100644 index 000000000..ee5eb1c49 --- /dev/null +++ b/tests/gtest/src/gtest.cc @@ -0,0 +1,4909 @@ +// Copyright 2005, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +// +// Author: wan@google.com (Zhanyong Wan) +// +// The Google C++ Testing Framework (Google Test) + +#include "gtest/gtest.h" +#include "gtest/gtest-spi.h" + +#include <ctype.h> +#include <math.h> +#include <stdarg.h> +#include <stdio.h> +#include <stdlib.h> +#include <wchar.h> +#include <wctype.h> + +#include <algorithm> +#include <ostream> // NOLINT +#include <sstream> +#include <vector> + +#if GTEST_OS_LINUX + +// TODO(kenton@google.com): Use autoconf to detect availability of +// gettimeofday(). +# define GTEST_HAS_GETTIMEOFDAY_ 1 + +# include <fcntl.h> // NOLINT +# include <limits.h> // NOLINT +# include <sched.h> // NOLINT +// Declares vsnprintf(). This header is not available on Windows. +# include <strings.h> // NOLINT +# include <sys/mman.h> // NOLINT +# include <sys/time.h> // NOLINT +# include <unistd.h> // NOLINT +# include <string> + +#elif GTEST_OS_SYMBIAN +# define GTEST_HAS_GETTIMEOFDAY_ 1 +# include <sys/time.h> // NOLINT + +#elif GTEST_OS_ZOS +# define GTEST_HAS_GETTIMEOFDAY_ 1 +# include <sys/time.h> // NOLINT + +// On z/OS we additionally need strings.h for strcasecmp. +# include <strings.h> // NOLINT + +#elif GTEST_OS_WINDOWS_MOBILE // We are on Windows CE. + +# include <windows.h> // NOLINT + +#elif GTEST_OS_WINDOWS // We are on Windows proper. + +# include <io.h> // NOLINT +# include <sys/timeb.h> // NOLINT +# include <sys/types.h> // NOLINT +# include <sys/stat.h> // NOLINT + +# if GTEST_OS_WINDOWS_MINGW +// MinGW has gettimeofday() but not _ftime64(). +// TODO(kenton@google.com): Use autoconf to detect availability of +// gettimeofday(). +// TODO(kenton@google.com): There are other ways to get the time on +// Windows, like GetTickCount() or GetSystemTimeAsFileTime(). MinGW +// supports these. consider using them instead. +# define GTEST_HAS_GETTIMEOFDAY_ 1 +# include <sys/time.h> // NOLINT +# endif // GTEST_OS_WINDOWS_MINGW + +// cpplint thinks that the header is already included, so we want to +// silence it. +# include <windows.h> // NOLINT + +#else + +// Assume other platforms have gettimeofday(). +// TODO(kenton@google.com): Use autoconf to detect availability of +// gettimeofday(). +# define GTEST_HAS_GETTIMEOFDAY_ 1 + +// cpplint thinks that the header is already included, so we want to +// silence it. +# include <sys/time.h> // NOLINT +# include <unistd.h> // NOLINT + +#endif // GTEST_OS_LINUX + +#if GTEST_HAS_EXCEPTIONS +# include <stdexcept> +#endif + +#if GTEST_CAN_STREAM_RESULTS_ +# include <arpa/inet.h> // NOLINT +# include <netdb.h> // NOLINT +#endif + +// Indicates that this translation unit is part of Google Test's +// implementation. It must come before gtest-internal-inl.h is +// included, or there will be a compiler error. This trick is to +// prevent a user from accidentally including gtest-internal-inl.h in +// his code. +#define GTEST_IMPLEMENTATION_ 1 +#include "src/gtest-internal-inl.h" +#undef GTEST_IMPLEMENTATION_ + +#if GTEST_OS_WINDOWS +# define vsnprintf _vsnprintf +#endif // GTEST_OS_WINDOWS + +namespace testing { + +using internal::CountIf; +using internal::ForEach; +using internal::GetElementOr; +using internal::Shuffle; + +// Constants. + +// A test whose test case name or test name matches this filter is +// disabled and not run. +static const char kDisableTestFilter[] = "DISABLED_*:*/DISABLED_*"; + +// A test case whose name matches this filter is considered a death +// test case and will be run before test cases whose name doesn't +// match this filter. +static const char kDeathTestCaseFilter[] = "*DeathTest:*DeathTest/*"; + +// A test filter that matches everything. +static const char kUniversalFilter[] = "*"; + +// The default output file for XML output. +static const char kDefaultOutputFile[] = "test_detail.xml"; + +// The environment variable name for the test shard index. +static const char kTestShardIndex[] = "GTEST_SHARD_INDEX"; +// The environment variable name for the total number of test shards. +static const char kTestTotalShards[] = "GTEST_TOTAL_SHARDS"; +// The environment variable name for the test shard status file. +static const char kTestShardStatusFile[] = "GTEST_SHARD_STATUS_FILE"; + +namespace internal { + +// The text used in failure messages to indicate the start of the +// stack trace. +const char kStackTraceMarker[] = "\nStack trace:\n"; + +// g_help_flag is true iff the --help flag or an equivalent form is +// specified on the command line. +bool g_help_flag = false; + +} // namespace internal + +GTEST_DEFINE_bool_( + also_run_disabled_tests, + internal::BoolFromGTestEnv("also_run_disabled_tests", false), + "Run disabled tests too, in addition to the tests normally being run."); + +GTEST_DEFINE_bool_( + break_on_failure, + internal::BoolFromGTestEnv("break_on_failure", false), + "True iff a failed assertion should be a debugger break-point."); + +GTEST_DEFINE_bool_( + catch_exceptions, + internal::BoolFromGTestEnv("catch_exceptions", true), + "True iff " GTEST_NAME_ + " should catch exceptions and treat them as test failures."); + +GTEST_DEFINE_string_( + color, + internal::StringFromGTestEnv("color", "auto"), + "Whether to use colors in the output. Valid values: yes, no, " + "and auto. 'auto' means to use colors if the output is " + "being sent to a terminal and the TERM environment variable " + "is set to xterm, xterm-color, xterm-256color, linux or cygwin."); + +GTEST_DEFINE_string_( + filter, + internal::StringFromGTestEnv("filter", kUniversalFilter), + "A colon-separated list of glob (not regex) patterns " + "for filtering the tests to run, optionally followed by a " + "'-' and a : separated list of negative patterns (tests to " + "exclude). A test is run if it matches one of the positive " + "patterns and does not match any of the negative patterns."); + +GTEST_DEFINE_bool_(list_tests, false, + "List all tests without running them."); + +GTEST_DEFINE_string_( + output, + internal::StringFromGTestEnv("output", ""), + "A format (currently must be \"xml\"), optionally followed " + "by a colon and an output file name or directory. A directory " + "is indicated by a trailing pathname separator. " + "Examples: \"xml:filename.xml\", \"xml::directoryname/\". " + "If a directory is specified, output files will be created " + "within that directory, with file-names based on the test " + "executable's name and, if necessary, made unique by adding " + "digits."); + +GTEST_DEFINE_bool_( + print_time, + internal::BoolFromGTestEnv("print_time", true), + "True iff " GTEST_NAME_ + " should display elapsed time in text output."); + +GTEST_DEFINE_int32_( + random_seed, + internal::Int32FromGTestEnv("random_seed", 0), + "Random number seed to use when shuffling test orders. Must be in range " + "[1, 99999], or 0 to use a seed based on the current time."); + +GTEST_DEFINE_int32_( + repeat, + internal::Int32FromGTestEnv("repeat", 1), + "How many times to repeat each test. Specify a negative number " + "for repeating forever. Useful for shaking out flaky tests."); + +GTEST_DEFINE_bool_( + show_internal_stack_frames, false, + "True iff " GTEST_NAME_ " should include internal stack frames when " + "printing test failure stack traces."); + +GTEST_DEFINE_bool_( + shuffle, + internal::BoolFromGTestEnv("shuffle", false), + "True iff " GTEST_NAME_ + " should randomize tests' order on every run."); + +GTEST_DEFINE_int32_( + stack_trace_depth, + internal::Int32FromGTestEnv("stack_trace_depth", kMaxStackTraceDepth), + "The maximum number of stack frames to print when an " + "assertion fails. The valid range is 0 through 100, inclusive."); + +GTEST_DEFINE_string_( + stream_result_to, + internal::StringFromGTestEnv("stream_result_to", ""), + "This flag specifies the host name and the port number on which to stream " + "test results. Example: \"localhost:555\". The flag is effective only on " + "Linux."); + +GTEST_DEFINE_bool_( + throw_on_failure, + internal::BoolFromGTestEnv("throw_on_failure", false), + "When this flag is specified, a failed assertion will throw an exception " + "if exceptions are enabled or exit the program with a non-zero code " + "otherwise."); + +namespace internal { + +// Generates a random number from [0, range), using a Linear +// Congruential Generator (LCG). Crashes if 'range' is 0 or greater +// than kMaxRange. +UInt32 Random::Generate(UInt32 range) { + // These constants are the same as are used in glibc's rand(3). + state_ = (1103515245U*state_ + 12345U) % kMaxRange; + + GTEST_CHECK_(range > 0) + << "Cannot generate a number in the range [0, 0)."; + GTEST_CHECK_(range <= kMaxRange) + << "Generation of a number in [0, " << range << ") was requested, " + << "but this can only generate numbers in [0, " << kMaxRange << ")."; + + // Converting via modulus introduces a bit of downward bias, but + // it's simple, and a linear congruential generator isn't too good + // to begin with. + return state_ % range; +} + +// GTestIsInitialized() returns true iff the user has initialized +// Google Test. Useful for catching the user mistake of not initializing +// Google Test before calling RUN_ALL_TESTS(). +// +// A user must call testing::InitGoogleTest() to initialize Google +// Test. g_init_gtest_count is set to the number of times +// InitGoogleTest() has been called. We don't protect this variable +// under a mutex as it is only accessed in the main thread. +int g_init_gtest_count = 0; +static bool GTestIsInitialized() { return g_init_gtest_count != 0; } + +// Iterates over a vector of TestCases, keeping a running sum of the +// results of calling a given int-returning method on each. +// Returns the sum. +static int SumOverTestCaseList(const std::vector<TestCase*>& case_list, + int (TestCase::*method)() const) { + int sum = 0; + for (size_t i = 0; i < case_list.size(); i++) { + sum += (case_list[i]->*method)(); + } + return sum; +} + +// Returns true iff the test case passed. +static bool TestCasePassed(const TestCase* test_case) { + return test_case->should_run() && test_case->Passed(); +} + +// Returns true iff the test case failed. +static bool TestCaseFailed(const TestCase* test_case) { + return test_case->should_run() && test_case->Failed(); +} + +// Returns true iff test_case contains at least one test that should +// run. +static bool ShouldRunTestCase(const TestCase* test_case) { + return test_case->should_run(); +} + +// AssertHelper constructor. +AssertHelper::AssertHelper(TestPartResult::Type type, + const char* file, + int line, + const char* message) + : data_(new AssertHelperData(type, file, line, message)) { +} + +AssertHelper::~AssertHelper() { + delete data_; +} + +// Message assignment, for assertion streaming support. +void AssertHelper::operator=(const Message& message) const { + UnitTest::GetInstance()-> + AddTestPartResult(data_->type, data_->file, data_->line, + AppendUserMessage(data_->message, message), + UnitTest::GetInstance()->impl() + ->CurrentOsStackTraceExceptTop(1) + // Skips the stack frame for this function itself. + ); // NOLINT +} + +// Mutex for linked pointers. +GTEST_DEFINE_STATIC_MUTEX_(g_linked_ptr_mutex); + +// Application pathname gotten in InitGoogleTest. +String g_executable_path; + +// Returns the current application's name, removing directory path if that +// is present. +FilePath GetCurrentExecutableName() { + FilePath result; + +#if GTEST_OS_WINDOWS + result.Set(FilePath(g_executable_path).RemoveExtension("exe")); +#else + result.Set(FilePath(g_executable_path)); +#endif // GTEST_OS_WINDOWS + + return result.RemoveDirectoryName(); +} + +// Functions for processing the gtest_output flag. + +// Returns the output format, or "" for normal printed output. +String UnitTestOptions::GetOutputFormat() { + const char* const gtest_output_flag = GTEST_FLAG(output).c_str(); + if (gtest_output_flag == NULL) return String(""); + + const char* const colon = strchr(gtest_output_flag, ':'); + return (colon == NULL) ? + String(gtest_output_flag) : + String(gtest_output_flag, colon - gtest_output_flag); +} + +// Returns the name of the requested output file, or the default if none +// was explicitly specified. +String UnitTestOptions::GetAbsolutePathToOutputFile() { + const char* const gtest_output_flag = GTEST_FLAG(output).c_str(); + if (gtest_output_flag == NULL) + return String(""); + + const char* const colon = strchr(gtest_output_flag, ':'); + if (colon == NULL) + return String(internal::FilePath::ConcatPaths( + internal::FilePath( + UnitTest::GetInstance()->original_working_dir()), + internal::FilePath(kDefaultOutputFile)).ToString() ); + + internal::FilePath output_name(colon + 1); + if (!output_name.IsAbsolutePath()) + // TODO(wan@google.com): on Windows \some\path is not an absolute + // path (as its meaning depends on the current drive), yet the + // following logic for turning it into an absolute path is wrong. + // Fix it. + output_name = internal::FilePath::ConcatPaths( + internal::FilePath(UnitTest::GetInstance()->original_working_dir()), + internal::FilePath(colon + 1)); + + if (!output_name.IsDirectory()) + return output_name.ToString(); + + internal::FilePath result(internal::FilePath::GenerateUniqueFileName( + output_name, internal::GetCurrentExecutableName(), + GetOutputFormat().c_str())); + return result.ToString(); +} + +// Returns true iff the wildcard pattern matches the string. The +// first ':' or '\0' character in pattern marks the end of it. +// +// This recursive algorithm isn't very efficient, but is clear and +// works well enough for matching test names, which are short. +bool UnitTestOptions::PatternMatchesString(const char *pattern, + const char *str) { + switch (*pattern) { + case '\0': + case ':': // Either ':' or '\0' marks the end of the pattern. + return *str == '\0'; + case '?': // Matches any single character. + return *str != '\0' && PatternMatchesString(pattern + 1, str + 1); + case '*': // Matches any string (possibly empty) of characters. + return (*str != '\0' && PatternMatchesString(pattern, str + 1)) || + PatternMatchesString(pattern + 1, str); + default: // Non-special character. Matches itself. + return *pattern == *str && + PatternMatchesString(pattern + 1, str + 1); + } +} + +bool UnitTestOptions::MatchesFilter(const String& name, const char* filter) { + const char *cur_pattern = filter; + for (;;) { + if (PatternMatchesString(cur_pattern, name.c_str())) { + return true; + } + + // Finds the next pattern in the filter. + cur_pattern = strchr(cur_pattern, ':'); + + // Returns if no more pattern can be found. + if (cur_pattern == NULL) { + return false; + } + + // Skips the pattern separater (the ':' character). + cur_pattern++; + } +} + +// TODO(keithray): move String function implementations to gtest-string.cc. + +// Returns true iff the user-specified filter matches the test case +// name and the test name. +bool UnitTestOptions::FilterMatchesTest(const String &test_case_name, + const String &test_name) { + const String& full_name = String::Format("%s.%s", + test_case_name.c_str(), + test_name.c_str()); + + // Split --gtest_filter at '-', if there is one, to separate into + // positive filter and negative filter portions + const char* const p = GTEST_FLAG(filter).c_str(); + const char* const dash = strchr(p, '-'); + String positive; + String negative; + if (dash == NULL) { + positive = GTEST_FLAG(filter).c_str(); // Whole string is a positive filter + negative = String(""); + } else { + positive = String(p, dash - p); // Everything up to the dash + negative = String(dash+1); // Everything after the dash + if (positive.empty()) { + // Treat '-test1' as the same as '*-test1' + positive = kUniversalFilter; + } + } + + // A filter is a colon-separated list of patterns. It matches a + // test if any pattern in it matches the test. + return (MatchesFilter(full_name, positive.c_str()) && + !MatchesFilter(full_name, negative.c_str())); +} + +#if GTEST_HAS_SEH +// Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the +// given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise. +// This function is useful as an __except condition. +int UnitTestOptions::GTestShouldProcessSEH(DWORD exception_code) { + // Google Test should handle a SEH exception if: + // 1. the user wants it to, AND + // 2. this is not a breakpoint exception, AND + // 3. this is not a C++ exception (VC++ implements them via SEH, + // apparently). + // + // SEH exception code for C++ exceptions. + // (see http://support.microsoft.com/kb/185294 for more information). + const DWORD kCxxExceptionCode = 0xe06d7363; + + bool should_handle = true; + + if (!GTEST_FLAG(catch_exceptions)) + should_handle = false; + else if (exception_code == EXCEPTION_BREAKPOINT) + should_handle = false; + else if (exception_code == kCxxExceptionCode) + should_handle = false; + + return should_handle ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH; +} +#endif // GTEST_HAS_SEH + +} // namespace internal + +// The c'tor sets this object as the test part result reporter used by +// Google Test. The 'result' parameter specifies where to report the +// results. Intercepts only failures from the current thread. +ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter( + TestPartResultArray* result) + : intercept_mode_(INTERCEPT_ONLY_CURRENT_THREAD), + result_(result) { + Init(); +} + +// The c'tor sets this object as the test part result reporter used by +// Google Test. The 'result' parameter specifies where to report the +// results. +ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter( + InterceptMode intercept_mode, TestPartResultArray* result) + : intercept_mode_(intercept_mode), + result_(result) { + Init(); +} + +void ScopedFakeTestPartResultReporter::Init() { + internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); + if (intercept_mode_ == INTERCEPT_ALL_THREADS) { + old_reporter_ = impl->GetGlobalTestPartResultReporter(); + impl->SetGlobalTestPartResultReporter(this); + } else { + old_reporter_ = impl->GetTestPartResultReporterForCurrentThread(); + impl->SetTestPartResultReporterForCurrentThread(this); + } +} + +// The d'tor restores the test part result reporter used by Google Test +// before. +ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() { + internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); + if (intercept_mode_ == INTERCEPT_ALL_THREADS) { + impl->SetGlobalTestPartResultReporter(old_reporter_); + } else { + impl->SetTestPartResultReporterForCurrentThread(old_reporter_); + } +} + +// Increments the test part result count and remembers the result. +// This method is from the TestPartResultReporterInterface interface. +void ScopedFakeTestPartResultReporter::ReportTestPartResult( + const TestPartResult& result) { + result_->Append(result); +} + +namespace internal { + +// Returns the type ID of ::testing::Test. We should always call this +// instead of GetTypeId< ::testing::Test>() to get the type ID of +// testing::Test. This is to work around a suspected linker bug when +// using Google Test as a framework on Mac OS X. The bug causes +// GetTypeId< ::testing::Test>() to return different values depending +// on whether the call is from the Google Test framework itself or +// from user test code. GetTestTypeId() is guaranteed to always +// return the same value, as it always calls GetTypeId<>() from the +// gtest.cc, which is within the Google Test framework. +TypeId GetTestTypeId() { + return GetTypeId<Test>(); +} + +// The value of GetTestTypeId() as seen from within the Google Test +// library. This is solely for testing GetTestTypeId(). +extern const TypeId kTestTypeIdInGoogleTest = GetTestTypeId(); + +// This predicate-formatter checks that 'results' contains a test part +// failure of the given type and that the failure message contains the +// given substring. +AssertionResult HasOneFailure(const char* /* results_expr */, + const char* /* type_expr */, + const char* /* substr_expr */, + const TestPartResultArray& results, + TestPartResult::Type type, + const string& substr) { + const String expected(type == TestPartResult::kFatalFailure ? + "1 fatal failure" : + "1 non-fatal failure"); + Message msg; + if (results.size() != 1) { + msg << "Expected: " << expected << "\n" + << " Actual: " << results.size() << " failures"; + for (int i = 0; i < results.size(); i++) { + msg << "\n" << results.GetTestPartResult(i); + } + return AssertionFailure() << msg; + } + + const TestPartResult& r = results.GetTestPartResult(0); + if (r.type() != type) { + return AssertionFailure() << "Expected: " << expected << "\n" + << " Actual:\n" + << r; + } + + if (strstr(r.message(), substr.c_str()) == NULL) { + return AssertionFailure() << "Expected: " << expected << " containing \"" + << substr << "\"\n" + << " Actual:\n" + << r; + } + + return AssertionSuccess(); +} + +// The constructor of SingleFailureChecker remembers where to look up +// test part results, what type of failure we expect, and what +// substring the failure message should contain. +SingleFailureChecker:: SingleFailureChecker( + const TestPartResultArray* results, + TestPartResult::Type type, + const string& substr) + : results_(results), + type_(type), + substr_(substr) {} + +// The destructor of SingleFailureChecker verifies that the given +// TestPartResultArray contains exactly one failure that has the given +// type and contains the given substring. If that's not the case, a +// non-fatal failure will be generated. +SingleFailureChecker::~SingleFailureChecker() { + EXPECT_PRED_FORMAT3(HasOneFailure, *results_, type_, substr_); +} + +DefaultGlobalTestPartResultReporter::DefaultGlobalTestPartResultReporter( + UnitTestImpl* unit_test) : unit_test_(unit_test) {} + +void DefaultGlobalTestPartResultReporter::ReportTestPartResult( + const TestPartResult& result) { + unit_test_->current_test_result()->AddTestPartResult(result); + unit_test_->listeners()->repeater()->OnTestPartResult(result); +} + +DefaultPerThreadTestPartResultReporter::DefaultPerThreadTestPartResultReporter( + UnitTestImpl* unit_test) : unit_test_(unit_test) {} + +void DefaultPerThreadTestPartResultReporter::ReportTestPartResult( + const TestPartResult& result) { + unit_test_->GetGlobalTestPartResultReporter()->ReportTestPartResult(result); +} + +// Returns the global test part result reporter. +TestPartResultReporterInterface* +UnitTestImpl::GetGlobalTestPartResultReporter() { + internal::MutexLock lock(&global_test_part_result_reporter_mutex_); + return global_test_part_result_repoter_; +} + +// Sets the global test part result reporter. +void UnitTestImpl::SetGlobalTestPartResultReporter( + TestPartResultReporterInterface* reporter) { + internal::MutexLock lock(&global_test_part_result_reporter_mutex_); + global_test_part_result_repoter_ = reporter; +} + +// Returns the test part result reporter for the current thread. +TestPartResultReporterInterface* +UnitTestImpl::GetTestPartResultReporterForCurrentThread() { + return per_thread_test_part_result_reporter_.get(); +} + +// Sets the test part result reporter for the current thread. +void UnitTestImpl::SetTestPartResultReporterForCurrentThread( + TestPartResultReporterInterface* reporter) { + per_thread_test_part_result_reporter_.set(reporter); +} + +// Gets the number of successful test cases. +int UnitTestImpl::successful_test_case_count() const { + return CountIf(test_cases_, TestCasePassed); +} + +// Gets the number of failed test cases. +int UnitTestImpl::failed_test_case_count() const { + return CountIf(test_cases_, TestCaseFailed); +} + +// Gets the number of all test cases. +int UnitTestImpl::total_test_case_count() const { + return static_cast<int>(test_cases_.size()); +} + +// Gets the number of all test cases that contain at least one test +// that should run. +int UnitTestImpl::test_case_to_run_count() const { + return CountIf(test_cases_, ShouldRunTestCase); +} + +// Gets the number of successful tests. +int UnitTestImpl::successful_test_count() const { + return SumOverTestCaseList(test_cases_, &TestCase::successful_test_count); +} + +// Gets the number of failed tests. +int UnitTestImpl::failed_test_count() const { + return SumOverTestCaseList(test_cases_, &TestCase::failed_test_count); +} + +// Gets the number of disabled tests. +int UnitTestImpl::disabled_test_count() const { + return SumOverTestCaseList(test_cases_, &TestCase::disabled_test_count); +} + +// Gets the number of all tests. +int UnitTestImpl::total_test_count() const { + return SumOverTestCaseList(test_cases_, &TestCase::total_test_count); +} + +// Gets the number of tests that should run. +int UnitTestImpl::test_to_run_count() const { + return SumOverTestCaseList(test_cases_, &TestCase::test_to_run_count); +} + +// Returns the current OS stack trace as a String. +// +// The maximum number of stack frames to be included is specified by +// the gtest_stack_trace_depth flag. The skip_count parameter +// specifies the number of top frames to be skipped, which doesn't +// count against the number of frames to be included. +// +// For example, if Foo() calls Bar(), which in turn calls +// CurrentOsStackTraceExceptTop(1), Foo() will be included in the +// trace but Bar() and CurrentOsStackTraceExceptTop() won't. +String UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) { + (void)skip_count; + return String(""); +} + +// Returns the current time in milliseconds. +TimeInMillis GetTimeInMillis() { +#if GTEST_OS_WINDOWS_MOBILE || defined(__BORLANDC__) + // Difference between 1970-01-01 and 1601-01-01 in milliseconds. + // http://analogous.blogspot.com/2005/04/epoch.html + const TimeInMillis kJavaEpochToWinFileTimeDelta = + static_cast<TimeInMillis>(116444736UL) * 100000UL; + const DWORD kTenthMicrosInMilliSecond = 10000; + + SYSTEMTIME now_systime; + FILETIME now_filetime; + ULARGE_INTEGER now_int64; + // TODO(kenton@google.com): Shouldn't this just use + // GetSystemTimeAsFileTime()? + GetSystemTime(&now_systime); + if (SystemTimeToFileTime(&now_systime, &now_filetime)) { + now_int64.LowPart = now_filetime.dwLowDateTime; + now_int64.HighPart = now_filetime.dwHighDateTime; + now_int64.QuadPart = (now_int64.QuadPart / kTenthMicrosInMilliSecond) - + kJavaEpochToWinFileTimeDelta; + return now_int64.QuadPart; + } + return 0; +#elif GTEST_OS_WINDOWS && !GTEST_HAS_GETTIMEOFDAY_ + __timeb64 now; + +# ifdef _MSC_VER + + // MSVC 8 deprecates _ftime64(), so we want to suppress warning 4996 + // (deprecated function) there. + // TODO(kenton@google.com): Use GetTickCount()? Or use + // SystemTimeToFileTime() +# pragma warning(push) // Saves the current warning state. +# pragma warning(disable:4996) // Temporarily disables warning 4996. + _ftime64(&now); +# pragma warning(pop) // Restores the warning state. +# else + + _ftime64(&now); + +# endif // _MSC_VER + + return static_cast<TimeInMillis>(now.time) * 1000 + now.millitm; +#elif GTEST_HAS_GETTIMEOFDAY_ + struct timeval now; + gettimeofday(&now, NULL); + return static_cast<TimeInMillis>(now.tv_sec) * 1000 + now.tv_usec / 1000; +#else +# error "Don't know how to get the current time on your system." +#endif +} + +// Utilities + +// class String + +// Returns the input enclosed in double quotes if it's not NULL; +// otherwise returns "(null)". For example, "\"Hello\"" is returned +// for input "Hello". +// +// This is useful for printing a C string in the syntax of a literal. +// +// Known issue: escape sequences are not handled yet. +String String::ShowCStringQuoted(const char* c_str) { + return c_str ? String::Format("\"%s\"", c_str) : String("(null)"); +} + +// Copies at most length characters from str into a newly-allocated +// piece of memory of size length+1. The memory is allocated with new[]. +// A terminating null byte is written to the memory, and a pointer to it +// is returned. If str is NULL, NULL is returned. +static char* CloneString(const char* str, size_t length) { + if (str == NULL) { + return NULL; + } else { + char* const clone = new char[length + 1]; + posix::StrNCpy(clone, str, length); + clone[length] = '\0'; + return clone; + } +} + +// Clones a 0-terminated C string, allocating memory using new. The +// caller is responsible for deleting[] the return value. Returns the +// cloned string, or NULL if the input is NULL. +const char * String::CloneCString(const char* c_str) { + return (c_str == NULL) ? + NULL : CloneString(c_str, strlen(c_str)); +} + +#if GTEST_OS_WINDOWS_MOBILE +// Creates a UTF-16 wide string from the given ANSI string, allocating +// memory using new. The caller is responsible for deleting the return +// value using delete[]. Returns the wide string, or NULL if the +// input is NULL. +LPCWSTR String::AnsiToUtf16(const char* ansi) { + if (!ansi) return NULL; + const int length = strlen(ansi); + const int unicode_length = + MultiByteToWideChar(CP_ACP, 0, ansi, length, + NULL, 0); + WCHAR* unicode = new WCHAR[unicode_length + 1]; + MultiByteToWideChar(CP_ACP, 0, ansi, length, + unicode, unicode_length); + unicode[unicode_length] = 0; + return unicode; +} + +// Creates an ANSI string from the given wide string, allocating +// memory using new. The caller is responsible for deleting the return +// value using delete[]. Returns the ANSI string, or NULL if the +// input is NULL. +const char* String::Utf16ToAnsi(LPCWSTR utf16_str) { + if (!utf16_str) return NULL; + const int ansi_length = + WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, + NULL, 0, NULL, NULL); + char* ansi = new char[ansi_length + 1]; + WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, + ansi, ansi_length, NULL, NULL); + ansi[ansi_length] = 0; + return ansi; +} + +#endif // GTEST_OS_WINDOWS_MOBILE + +// Compares two C strings. Returns true iff they have the same content. +// +// Unlike strcmp(), this function can handle NULL argument(s). A NULL +// C string is considered different to any non-NULL C string, +// including the empty string. +bool String::CStringEquals(const char * lhs, const char * rhs) { + if ( lhs == NULL ) return rhs == NULL; + + if ( rhs == NULL ) return false; + + return strcmp(lhs, rhs) == 0; +} + +#if GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING + +// Converts an array of wide chars to a narrow string using the UTF-8 +// encoding, and streams the result to the given Message object. +static void StreamWideCharsToMessage(const wchar_t* wstr, size_t length, + Message* msg) { + // TODO(wan): consider allowing a testing::String object to + // contain '\0'. This will make it behave more like std::string, + // and will allow ToUtf8String() to return the correct encoding + // for '\0' s.t. we can get rid of the conditional here (and in + // several other places). + for (size_t i = 0; i != length; ) { // NOLINT + if (wstr[i] != L'\0') { + *msg << WideStringToUtf8(wstr + i, static_cast<int>(length - i)); + while (i != length && wstr[i] != L'\0') + i++; + } else { + *msg << '\0'; + i++; + } + } +} + +#endif // GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING + +} // namespace internal + +#if GTEST_HAS_STD_WSTRING +// Converts the given wide string to a narrow string using the UTF-8 +// encoding, and streams the result to this Message object. +Message& Message::operator <<(const ::std::wstring& wstr) { + internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this); + return *this; +} +#endif // GTEST_HAS_STD_WSTRING + +#if GTEST_HAS_GLOBAL_WSTRING +// Converts the given wide string to a narrow string using the UTF-8 +// encoding, and streams the result to this Message object. +Message& Message::operator <<(const ::wstring& wstr) { + internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this); + return *this; +} +#endif // GTEST_HAS_GLOBAL_WSTRING + +// AssertionResult constructors. +// Used in EXPECT_TRUE/FALSE(assertion_result). +AssertionResult::AssertionResult(const AssertionResult& other) + : success_(other.success_), + message_(other.message_.get() != NULL ? + new ::std::string(*other.message_) : + static_cast< ::std::string*>(NULL)) { +} + +// Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE. +AssertionResult AssertionResult::operator!() const { + AssertionResult negation(!success_); + if (message_.get() != NULL) + negation << *message_; + return negation; +} + +// Makes a successful assertion result. +AssertionResult AssertionSuccess() { + return AssertionResult(true); +} + +// Makes a failed assertion result. +AssertionResult AssertionFailure() { + return AssertionResult(false); +} + +// Makes a failed assertion result with the given failure message. +// Deprecated; use AssertionFailure() << message. +AssertionResult AssertionFailure(const Message& message) { + return AssertionFailure() << message; +} + +namespace internal { + +// Constructs and returns the message for an equality assertion +// (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure. +// +// The first four parameters are the expressions used in the assertion +// and their values, as strings. For example, for ASSERT_EQ(foo, bar) +// where foo is 5 and bar is 6, we have: +// +// expected_expression: "foo" +// actual_expression: "bar" +// expected_value: "5" +// actual_value: "6" +// +// The ignoring_case parameter is true iff the assertion is a +// *_STRCASEEQ*. When it's true, the string " (ignoring case)" will +// be inserted into the message. +AssertionResult EqFailure(const char* expected_expression, + const char* actual_expression, + const String& expected_value, + const String& actual_value, + bool ignoring_case) { + Message msg; + msg << "Value of: " << actual_expression; + if (actual_value != actual_expression) { + msg << "\n Actual: " << actual_value; + } + + msg << "\nExpected: " << expected_expression; + if (ignoring_case) { + msg << " (ignoring case)"; + } + if (expected_value != expected_expression) { + msg << "\nWhich is: " << expected_value; + } + + return AssertionFailure() << msg; +} + +// Constructs a failure message for Boolean assertions such as EXPECT_TRUE. +String GetBoolAssertionFailureMessage(const AssertionResult& assertion_result, + const char* expression_text, + const char* actual_predicate_value, + const char* expected_predicate_value) { + const char* actual_message = assertion_result.message(); + Message msg; + msg << "Value of: " << expression_text + << "\n Actual: " << actual_predicate_value; + if (actual_message[0] != '\0') + msg << " (" << actual_message << ")"; + msg << "\nExpected: " << expected_predicate_value; + return msg.GetString(); +} + +// Helper function for implementing ASSERT_NEAR. +AssertionResult DoubleNearPredFormat(const char* expr1, + const char* expr2, + const char* abs_error_expr, + double val1, + double val2, + double abs_error) { + const double diff = fabs(val1 - val2); + if (diff <= abs_error) return AssertionSuccess(); + + // TODO(wan): do not print the value of an expression if it's + // already a literal. + return AssertionFailure() + << "The difference between " << expr1 << " and " << expr2 + << " is " << diff << ", which exceeds " << abs_error_expr << ", where\n" + << expr1 << " evaluates to " << val1 << ",\n" + << expr2 << " evaluates to " << val2 << ", and\n" + << abs_error_expr << " evaluates to " << abs_error << "."; +} + + +// Helper template for implementing FloatLE() and DoubleLE(). +template <typename RawType> +AssertionResult FloatingPointLE(const char* expr1, + const char* expr2, + RawType val1, + RawType val2) { + // Returns success if val1 is less than val2, + if (val1 < val2) { + return AssertionSuccess(); + } + + // or if val1 is almost equal to val2. + const FloatingPoint<RawType> lhs(val1), rhs(val2); + if (lhs.AlmostEquals(rhs)) { + return AssertionSuccess(); + } + + // Note that the above two checks will both fail if either val1 or + // val2 is NaN, as the IEEE floating-point standard requires that + // any predicate involving a NaN must return false. + + ::std::stringstream val1_ss; + val1_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2) + << val1; + + ::std::stringstream val2_ss; + val2_ss << std::setprecision(std::numeric_limits<RawType>::digits10 + 2) + << val2; + + return AssertionFailure() + << "Expected: (" << expr1 << ") <= (" << expr2 << ")\n" + << " Actual: " << StringStreamToString(&val1_ss) << " vs " + << StringStreamToString(&val2_ss); +} + +} // namespace internal + +// Asserts that val1 is less than, or almost equal to, val2. Fails +// otherwise. In particular, it fails if either val1 or val2 is NaN. +AssertionResult FloatLE(const char* expr1, const char* expr2, + float val1, float val2) { + return internal::FloatingPointLE<float>(expr1, expr2, val1, val2); +} + +// Asserts that val1 is less than, or almost equal to, val2. Fails +// otherwise. In particular, it fails if either val1 or val2 is NaN. +AssertionResult DoubleLE(const char* expr1, const char* expr2, + double val1, double val2) { + return internal::FloatingPointLE<double>(expr1, expr2, val1, val2); +} + +namespace internal { + +// The helper function for {ASSERT|EXPECT}_EQ with int or enum +// arguments. +AssertionResult CmpHelperEQ(const char* expected_expression, + const char* actual_expression, + BiggestInt expected, + BiggestInt actual) { + if (expected == actual) { + return AssertionSuccess(); + } + + return EqFailure(expected_expression, + actual_expression, + FormatForComparisonFailureMessage(expected, actual), + FormatForComparisonFailureMessage(actual, expected), + false); +} + +// A macro for implementing the helper functions needed to implement +// ASSERT_?? and EXPECT_?? with integer or enum arguments. It is here +// just to avoid copy-and-paste of similar code. +#define GTEST_IMPL_CMP_HELPER_(op_name, op)\ +AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \ + BiggestInt val1, BiggestInt val2) {\ + if (val1 op val2) {\ + return AssertionSuccess();\ + } else {\ + return AssertionFailure() \ + << "Expected: (" << expr1 << ") " #op " (" << expr2\ + << "), actual: " << FormatForComparisonFailureMessage(val1, val2)\ + << " vs " << FormatForComparisonFailureMessage(val2, val1);\ + }\ +} + +// Implements the helper function for {ASSERT|EXPECT}_NE with int or +// enum arguments. +GTEST_IMPL_CMP_HELPER_(NE, !=) +// Implements the helper function for {ASSERT|EXPECT}_LE with int or +// enum arguments. +GTEST_IMPL_CMP_HELPER_(LE, <=) +// Implements the helper function for {ASSERT|EXPECT}_LT with int or +// enum arguments. +GTEST_IMPL_CMP_HELPER_(LT, < ) +// Implements the helper function for {ASSERT|EXPECT}_GE with int or +// enum arguments. +GTEST_IMPL_CMP_HELPER_(GE, >=) +// Implements the helper function for {ASSERT|EXPECT}_GT with int or +// enum arguments. +GTEST_IMPL_CMP_HELPER_(GT, > ) + +#undef GTEST_IMPL_CMP_HELPER_ + +// The helper function for {ASSERT|EXPECT}_STREQ. +AssertionResult CmpHelperSTREQ(const char* expected_expression, + const char* actual_expression, + const char* expected, + const char* actual) { + if (String::CStringEquals(expected, actual)) { + return AssertionSuccess(); + } + + return EqFailure(expected_expression, + actual_expression, + String::ShowCStringQuoted(expected), + String::ShowCStringQuoted(actual), + false); +} + +// The helper function for {ASSERT|EXPECT}_STRCASEEQ. +AssertionResult CmpHelperSTRCASEEQ(const char* expected_expression, + const char* actual_expression, + const char* expected, + const char* actual) { + if (String::CaseInsensitiveCStringEquals(expected, actual)) { + return AssertionSuccess(); + } + + return EqFailure(expected_expression, + actual_expression, + String::ShowCStringQuoted(expected), + String::ShowCStringQuoted(actual), + true); +} + +// The helper function for {ASSERT|EXPECT}_STRNE. +AssertionResult CmpHelperSTRNE(const char* s1_expression, + const char* s2_expression, + const char* s1, + const char* s2) { + if (!String::CStringEquals(s1, s2)) { + return AssertionSuccess(); + } else { + return AssertionFailure() << "Expected: (" << s1_expression << ") != (" + << s2_expression << "), actual: \"" + << s1 << "\" vs \"" << s2 << "\""; + } +} + +// The helper function for {ASSERT|EXPECT}_STRCASENE. +AssertionResult CmpHelperSTRCASENE(const char* s1_expression, + const char* s2_expression, + const char* s1, + const char* s2) { + if (!String::CaseInsensitiveCStringEquals(s1, s2)) { + return AssertionSuccess(); + } else { + return AssertionFailure() + << "Expected: (" << s1_expression << ") != (" + << s2_expression << ") (ignoring case), actual: \"" + << s1 << "\" vs \"" << s2 << "\""; + } +} + +} // namespace internal + +namespace { + +// Helper functions for implementing IsSubString() and IsNotSubstring(). + +// This group of overloaded functions return true iff needle is a +// substring of haystack. NULL is considered a substring of itself +// only. + +bool IsSubstringPred(const char* needle, const char* haystack) { + if (needle == NULL || haystack == NULL) + return needle == haystack; + + return strstr(haystack, needle) != NULL; +} + +bool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) { + if (needle == NULL || haystack == NULL) + return needle == haystack; + + return wcsstr(haystack, needle) != NULL; +} + +// StringType here can be either ::std::string or ::std::wstring. +template <typename StringType> +bool IsSubstringPred(const StringType& needle, + const StringType& haystack) { + return haystack.find(needle) != StringType::npos; +} + +// This function implements either IsSubstring() or IsNotSubstring(), +// depending on the value of the expected_to_be_substring parameter. +// StringType here can be const char*, const wchar_t*, ::std::string, +// or ::std::wstring. +template <typename StringType> +AssertionResult IsSubstringImpl( + bool expected_to_be_substring, + const char* needle_expr, const char* haystack_expr, + const StringType& needle, const StringType& haystack) { + if (IsSubstringPred(needle, haystack) == expected_to_be_substring) + return AssertionSuccess(); + + const bool is_wide_string = sizeof(needle[0]) > 1; + const char* const begin_string_quote = is_wide_string ? "L\"" : "\""; + return AssertionFailure() + << "Value of: " << needle_expr << "\n" + << " Actual: " << begin_string_quote << needle << "\"\n" + << "Expected: " << (expected_to_be_substring ? "" : "not ") + << "a substring of " << haystack_expr << "\n" + << "Which is: " << begin_string_quote << haystack << "\""; +} + +} // namespace + +// IsSubstring() and IsNotSubstring() check whether needle is a +// substring of haystack (NULL is considered a substring of itself +// only), and return an appropriate error message when they fail. + +AssertionResult IsSubstring( + const char* needle_expr, const char* haystack_expr, + const char* needle, const char* haystack) { + return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); +} + +AssertionResult IsSubstring( + const char* needle_expr, const char* haystack_expr, + const wchar_t* needle, const wchar_t* haystack) { + return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); +} + +AssertionResult IsNotSubstring( + const char* needle_expr, const char* haystack_expr, + const char* needle, const char* haystack) { + return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); +} + +AssertionResult IsNotSubstring( + const char* needle_expr, const char* haystack_expr, + const wchar_t* needle, const wchar_t* haystack) { + return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); +} + +AssertionResult IsSubstring( + const char* needle_expr, const char* haystack_expr, + const ::std::string& needle, const ::std::string& haystack) { + return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); +} + +AssertionResult IsNotSubstring( + const char* needle_expr, const char* haystack_expr, + const ::std::string& needle, const ::std::string& haystack) { + return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); +} + +#if GTEST_HAS_STD_WSTRING +AssertionResult IsSubstring( + const char* needle_expr, const char* haystack_expr, + const ::std::wstring& needle, const ::std::wstring& haystack) { + return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); +} + +AssertionResult IsNotSubstring( + const char* needle_expr, const char* haystack_expr, + const ::std::wstring& needle, const ::std::wstring& haystack) { + return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); +} +#endif // GTEST_HAS_STD_WSTRING + +namespace internal { + +#if GTEST_OS_WINDOWS + +namespace { + +// Helper function for IsHRESULT{SuccessFailure} predicates +AssertionResult HRESULTFailureHelper(const char* expr, + const char* expected, + long hr) { // NOLINT +# if GTEST_OS_WINDOWS_MOBILE + + // Windows CE doesn't support FormatMessage. + const char error_text[] = ""; + +# else + + // Looks up the human-readable system message for the HRESULT code + // and since we're not passing any params to FormatMessage, we don't + // want inserts expanded. + const DWORD kFlags = FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS; + const DWORD kBufSize = 4096; // String::Format can't exceed this length. + // Gets the system's human readable message string for this HRESULT. + char error_text[kBufSize] = { '\0' }; + DWORD message_length = ::FormatMessageA(kFlags, + 0, // no source, we're asking system + hr, // the error + 0, // no line width restrictions + error_text, // output buffer + kBufSize, // buf size + NULL); // no arguments for inserts + // Trims tailing white space (FormatMessage leaves a trailing cr-lf) + for (; message_length && IsSpace(error_text[message_length - 1]); + --message_length) { + error_text[message_length - 1] = '\0'; + } + +# endif // GTEST_OS_WINDOWS_MOBILE + + const String error_hex(String::Format("0x%08X ", hr)); + return ::testing::AssertionFailure() + << "Expected: " << expr << " " << expected << ".\n" + << " Actual: " << error_hex << error_text << "\n"; +} + +} // namespace + +AssertionResult IsHRESULTSuccess(const char* expr, long hr) { // NOLINT + if (SUCCEEDED(hr)) { + return AssertionSuccess(); + } + return HRESULTFailureHelper(expr, "succeeds", hr); +} + +AssertionResult IsHRESULTFailure(const char* expr, long hr) { // NOLINT + if (FAILED(hr)) { + return AssertionSuccess(); + } + return HRESULTFailureHelper(expr, "fails", hr); +} + +#endif // GTEST_OS_WINDOWS + +// Utility functions for encoding Unicode text (wide strings) in +// UTF-8. + +// A Unicode code-point can have upto 21 bits, and is encoded in UTF-8 +// like this: +// +// Code-point length Encoding +// 0 - 7 bits 0xxxxxxx +// 8 - 11 bits 110xxxxx 10xxxxxx +// 12 - 16 bits 1110xxxx 10xxxxxx 10xxxxxx +// 17 - 21 bits 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx + +// The maximum code-point a one-byte UTF-8 sequence can represent. +const UInt32 kMaxCodePoint1 = (static_cast<UInt32>(1) << 7) - 1; + +// The maximum code-point a two-byte UTF-8 sequence can represent. +const UInt32 kMaxCodePoint2 = (static_cast<UInt32>(1) << (5 + 6)) - 1; + +// The maximum code-point a three-byte UTF-8 sequence can represent. +const UInt32 kMaxCodePoint3 = (static_cast<UInt32>(1) << (4 + 2*6)) - 1; + +// The maximum code-point a four-byte UTF-8 sequence can represent. +const UInt32 kMaxCodePoint4 = (static_cast<UInt32>(1) << (3 + 3*6)) - 1; + +// Chops off the n lowest bits from a bit pattern. Returns the n +// lowest bits. As a side effect, the original bit pattern will be +// shifted to the right by n bits. +inline UInt32 ChopLowBits(UInt32* bits, int n) { + const UInt32 low_bits = *bits & ((static_cast<UInt32>(1) << n) - 1); + *bits >>= n; + return low_bits; +} + +// Converts a Unicode code point to a narrow string in UTF-8 encoding. +// code_point parameter is of type UInt32 because wchar_t may not be +// wide enough to contain a code point. +// The output buffer str must containt at least 32 characters. +// The function returns the address of the output buffer. +// If the code_point is not a valid Unicode code point +// (i.e. outside of Unicode range U+0 to U+10FFFF) it will be output +// as '(Invalid Unicode 0xXXXXXXXX)'. +char* CodePointToUtf8(UInt32 code_point, char* str) { + if (code_point <= kMaxCodePoint1) { + str[1] = '\0'; + str[0] = static_cast<char>(code_point); // 0xxxxxxx + } else if (code_point <= kMaxCodePoint2) { + str[2] = '\0'; + str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx + str[0] = static_cast<char>(0xC0 | code_point); // 110xxxxx + } else if (code_point <= kMaxCodePoint3) { + str[3] = '\0'; + str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx + str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx + str[0] = static_cast<char>(0xE0 | code_point); // 1110xxxx + } else if (code_point <= kMaxCodePoint4) { + str[4] = '\0'; + str[3] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx + str[2] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx + str[1] = static_cast<char>(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx + str[0] = static_cast<char>(0xF0 | code_point); // 11110xxx + } else { + // The longest string String::Format can produce when invoked + // with these parameters is 28 character long (not including + // the terminating nul character). We are asking for 32 character + // buffer just in case. This is also enough for strncpy to + // null-terminate the destination string. + posix::StrNCpy( + str, String::Format("(Invalid Unicode 0x%X)", code_point).c_str(), 32); + str[31] = '\0'; // Makes sure no change in the format to strncpy leaves + // the result unterminated. + } + return str; +} + +// The following two functions only make sense if the the system +// uses UTF-16 for wide string encoding. All supported systems +// with 16 bit wchar_t (Windows, Cygwin, Symbian OS) do use UTF-16. + +// Determines if the arguments constitute UTF-16 surrogate pair +// and thus should be combined into a single Unicode code point +// using CreateCodePointFromUtf16SurrogatePair. +inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) { + return sizeof(wchar_t) == 2 && + (first & 0xFC00) == 0xD800 && (second & 0xFC00) == 0xDC00; +} + +// Creates a Unicode code point from UTF16 surrogate pair. +inline UInt32 CreateCodePointFromUtf16SurrogatePair(wchar_t first, + wchar_t second) { + const UInt32 mask = (1 << 10) - 1; + return (sizeof(wchar_t) == 2) ? + (((first & mask) << 10) | (second & mask)) + 0x10000 : + // This function should not be called when the condition is + // false, but we provide a sensible default in case it is. + static_cast<UInt32>(first); +} + +// Converts a wide string to a narrow string in UTF-8 encoding. +// The wide string is assumed to have the following encoding: +// UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin, Symbian OS) +// UTF-32 if sizeof(wchar_t) == 4 (on Linux) +// Parameter str points to a null-terminated wide string. +// Parameter num_chars may additionally limit the number +// of wchar_t characters processed. -1 is used when the entire string +// should be processed. +// If the string contains code points that are not valid Unicode code points +// (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output +// as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding +// and contains invalid UTF-16 surrogate pairs, values in those pairs +// will be encoded as individual Unicode characters from Basic Normal Plane. +String WideStringToUtf8(const wchar_t* str, int num_chars) { + if (num_chars == -1) + num_chars = static_cast<int>(wcslen(str)); + + ::std::stringstream stream; + for (int i = 0; i < num_chars; ++i) { + UInt32 unicode_code_point; + + if (str[i] == L'\0') { + break; + } else if (i + 1 < num_chars && IsUtf16SurrogatePair(str[i], str[i + 1])) { + unicode_code_point = CreateCodePointFromUtf16SurrogatePair(str[i], + str[i + 1]); + i++; + } else { + unicode_code_point = static_cast<UInt32>(str[i]); + } + + char buffer[32]; // CodePointToUtf8 requires a buffer this big. + stream << CodePointToUtf8(unicode_code_point, buffer); + } + return StringStreamToString(&stream); +} + +// Converts a wide C string to a String using the UTF-8 encoding. +// NULL will be converted to "(null)". +String String::ShowWideCString(const wchar_t * wide_c_str) { + if (wide_c_str == NULL) return String("(null)"); + + return String(internal::WideStringToUtf8(wide_c_str, -1).c_str()); +} + +// Similar to ShowWideCString(), except that this function encloses +// the converted string in double quotes. +String String::ShowWideCStringQuoted(const wchar_t* wide_c_str) { + if (wide_c_str == NULL) return String("(null)"); + + return String::Format("L\"%s\"", + String::ShowWideCString(wide_c_str).c_str()); +} + +// Compares two wide C strings. Returns true iff they have the same +// content. +// +// Unlike wcscmp(), this function can handle NULL argument(s). A NULL +// C string is considered different to any non-NULL C string, +// including the empty string. +bool String::WideCStringEquals(const wchar_t * lhs, const wchar_t * rhs) { + if (lhs == NULL) return rhs == NULL; + + if (rhs == NULL) return false; + + return wcscmp(lhs, rhs) == 0; +} + +// Helper function for *_STREQ on wide strings. +AssertionResult CmpHelperSTREQ(const char* expected_expression, + const char* actual_expression, + const wchar_t* expected, + const wchar_t* actual) { + if (String::WideCStringEquals(expected, actual)) { + return AssertionSuccess(); + } + + return EqFailure(expected_expression, + actual_expression, + String::ShowWideCStringQuoted(expected), + String::ShowWideCStringQuoted(actual), + false); +} + +// Helper function for *_STRNE on wide strings. +AssertionResult CmpHelperSTRNE(const char* s1_expression, + const char* s2_expression, + const wchar_t* s1, + const wchar_t* s2) { + if (!String::WideCStringEquals(s1, s2)) { + return AssertionSuccess(); + } + + return AssertionFailure() << "Expected: (" << s1_expression << ") != (" + << s2_expression << "), actual: " + << String::ShowWideCStringQuoted(s1) + << " vs " << String::ShowWideCStringQuoted(s2); +} + +// Compares two C strings, ignoring case. Returns true iff they have +// the same content. +// +// Unlike strcasecmp(), this function can handle NULL argument(s). A +// NULL C string is considered different to any non-NULL C string, +// including the empty string. +bool String::CaseInsensitiveCStringEquals(const char * lhs, const char * rhs) { + if (lhs == NULL) + return rhs == NULL; + if (rhs == NULL) + return false; + return posix::StrCaseCmp(lhs, rhs) == 0; +} + + // Compares two wide C strings, ignoring case. Returns true iff they + // have the same content. + // + // Unlike wcscasecmp(), this function can handle NULL argument(s). + // A NULL C string is considered different to any non-NULL wide C string, + // including the empty string. + // NB: The implementations on different platforms slightly differ. + // On windows, this method uses _wcsicmp which compares according to LC_CTYPE + // environment variable. On GNU platform this method uses wcscasecmp + // which compares according to LC_CTYPE category of the current locale. + // On MacOS X, it uses towlower, which also uses LC_CTYPE category of the + // current locale. +bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs, + const wchar_t* rhs) { + if (lhs == NULL) return rhs == NULL; + + if (rhs == NULL) return false; + +#if GTEST_OS_WINDOWS + return _wcsicmp(lhs, rhs) == 0; +#elif GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID + return wcscasecmp(lhs, rhs) == 0; +#else + // Android, Mac OS X and Cygwin don't define wcscasecmp. + // Other unknown OSes may not define it either. + wint_t left, right; + do { + left = towlower(*lhs++); + right = towlower(*rhs++); + } while (left && left == right); + return left == right; +#endif // OS selector +} + +// Compares this with another String. +// Returns < 0 if this is less than rhs, 0 if this is equal to rhs, or > 0 +// if this is greater than rhs. +int String::Compare(const String & rhs) const { + const char* const lhs_c_str = c_str(); + const char* const rhs_c_str = rhs.c_str(); + + if (lhs_c_str == NULL) { + return rhs_c_str == NULL ? 0 : -1; // NULL < anything except NULL + } else if (rhs_c_str == NULL) { + return 1; + } + + const size_t shorter_str_len = + length() <= rhs.length() ? length() : rhs.length(); + for (size_t i = 0; i != shorter_str_len; i++) { + if (lhs_c_str[i] < rhs_c_str[i]) { + return -1; + } else if (lhs_c_str[i] > rhs_c_str[i]) { + return 1; + } + } + return (length() < rhs.length()) ? -1 : + (length() > rhs.length()) ? 1 : 0; +} + +// Returns true iff this String ends with the given suffix. *Any* +// String is considered to end with a NULL or empty suffix. +bool String::EndsWith(const char* suffix) const { + if (suffix == NULL || CStringEquals(suffix, "")) return true; + + if (c_str() == NULL) return false; + + const size_t this_len = strlen(c_str()); + const size_t suffix_len = strlen(suffix); + return (this_len >= suffix_len) && + CStringEquals(c_str() + this_len - suffix_len, suffix); +} + +// Returns true iff this String ends with the given suffix, ignoring case. +// Any String is considered to end with a NULL or empty suffix. +bool String::EndsWithCaseInsensitive(const char* suffix) const { + if (suffix == NULL || CStringEquals(suffix, "")) return true; + + if (c_str() == NULL) return false; + + const size_t this_len = strlen(c_str()); + const size_t suffix_len = strlen(suffix); + return (this_len >= suffix_len) && + CaseInsensitiveCStringEquals(c_str() + this_len - suffix_len, suffix); +} + +// Formats a list of arguments to a String, using the same format +// spec string as for printf. +// +// We do not use the StringPrintf class as it is not universally +// available. +// +// The result is limited to 4096 characters (including the tailing 0). +// If 4096 characters are not enough to format the input, or if +// there's an error, "<formatting error or buffer exceeded>" is +// returned. +String String::Format(const char * format, ...) { + va_list args; + va_start(args, format); + + char buffer[4096]; + const int kBufferSize = sizeof(buffer)/sizeof(buffer[0]); + + // MSVC 8 deprecates vsnprintf(), so we want to suppress warning + // 4996 (deprecated function) there. +#ifdef _MSC_VER // We are using MSVC. +# pragma warning(push) // Saves the current warning state. +# pragma warning(disable:4996) // Temporarily disables warning 4996. + + const int size = vsnprintf(buffer, kBufferSize, format, args); + +# pragma warning(pop) // Restores the warning state. +#else // We are not using MSVC. + const int size = vsnprintf(buffer, kBufferSize, format, args); +#endif // _MSC_VER + va_end(args); + + // vsnprintf()'s behavior is not portable. When the buffer is not + // big enough, it returns a negative value in MSVC, and returns the + // needed buffer size on Linux. When there is an output error, it + // always returns a negative value. For simplicity, we lump the two + // error cases together. + if (size < 0 || size >= kBufferSize) { + return String("<formatting error or buffer exceeded>"); + } else { + return String(buffer, size); + } +} + +// Converts the buffer in a stringstream to a String, converting NUL +// bytes to "\\0" along the way. +String StringStreamToString(::std::stringstream* ss) { + const ::std::string& str = ss->str(); + const char* const start = str.c_str(); + const char* const end = start + str.length(); + + // We need to use a helper stringstream to do this transformation + // because String doesn't support push_back(). + ::std::stringstream helper; + for (const char* ch = start; ch != end; ++ch) { + if (*ch == '\0') { + helper << "\\0"; // Replaces NUL with "\\0"; + } else { + helper.put(*ch); + } + } + + return String(helper.str().c_str()); +} + +// Appends the user-supplied message to the Google-Test-generated message. +String AppendUserMessage(const String& gtest_msg, + const Message& user_msg) { + // Appends the user message if it's non-empty. + const String user_msg_string = user_msg.GetString(); + if (user_msg_string.empty()) { + return gtest_msg; + } + + Message msg; + msg << gtest_msg << "\n" << user_msg_string; + + return msg.GetString(); +} + +} // namespace internal + +// class TestResult + +// Creates an empty TestResult. +TestResult::TestResult() + : death_test_count_(0), + elapsed_time_(0) { +} + +// D'tor. +TestResult::~TestResult() { +} + +// Returns the i-th test part result among all the results. i can +// range from 0 to total_part_count() - 1. If i is not in that range, +// aborts the program. +const TestPartResult& TestResult::GetTestPartResult(int i) const { + if (i < 0 || i >= total_part_count()) + internal::posix::Abort(); + return test_part_results_.at(i); +} + +// Returns the i-th test property. i can range from 0 to +// test_property_count() - 1. If i is not in that range, aborts the +// program. +const TestProperty& TestResult::GetTestProperty(int i) const { + if (i < 0 || i >= test_property_count()) + internal::posix::Abort(); + return test_properties_.at(i); +} + +// Clears the test part results. +void TestResult::ClearTestPartResults() { + test_part_results_.clear(); +} + +// Adds a test part result to the list. +void TestResult::AddTestPartResult(const TestPartResult& test_part_result) { + test_part_results_.push_back(test_part_result); +} + +// Adds a test property to the list. If a property with the same key as the +// supplied property is already represented, the value of this test_property +// replaces the old value for that key. +void TestResult::RecordProperty(const TestProperty& test_property) { + if (!ValidateTestProperty(test_property)) { + return; + } + internal::MutexLock lock(&test_properites_mutex_); + const std::vector<TestProperty>::iterator property_with_matching_key = + std::find_if(test_properties_.begin(), test_properties_.end(), + internal::TestPropertyKeyIs(test_property.key())); + if (property_with_matching_key == test_properties_.end()) { + test_properties_.push_back(test_property); + return; + } + property_with_matching_key->SetValue(test_property.value()); +} + +// Adds a failure if the key is a reserved attribute of Google Test +// testcase tags. Returns true if the property is valid. +bool TestResult::ValidateTestProperty(const TestProperty& test_property) { + internal::String key(test_property.key()); + if (key == "name" || key == "status" || key == "time" || key == "classname") { + ADD_FAILURE() + << "Reserved key used in RecordProperty(): " + << key + << " ('name', 'status', 'time', and 'classname' are reserved by " + << GTEST_NAME_ << ")"; + return false; + } + return true; +} + +// Clears the object. +void TestResult::Clear() { + test_part_results_.clear(); + test_properties_.clear(); + death_test_count_ = 0; + elapsed_time_ = 0; +} + +// Returns true iff the test failed. +bool TestResult::Failed() const { + for (int i = 0; i < total_part_count(); ++i) { + if (GetTestPartResult(i).failed()) + return true; + } + return false; +} + +// Returns true iff the test part fatally failed. +static bool TestPartFatallyFailed(const TestPartResult& result) { + return result.fatally_failed(); +} + +// Returns true iff the test fatally failed. +bool TestResult::HasFatalFailure() const { + return CountIf(test_part_results_, TestPartFatallyFailed) > 0; +} + +// Returns true iff the test part non-fatally failed. +static bool TestPartNonfatallyFailed(const TestPartResult& result) { + return result.nonfatally_failed(); +} + +// Returns true iff the test has a non-fatal failure. +bool TestResult::HasNonfatalFailure() const { + return CountIf(test_part_results_, TestPartNonfatallyFailed) > 0; +} + +// Gets the number of all test parts. This is the sum of the number +// of successful test parts and the number of failed test parts. +int TestResult::total_part_count() const { + return static_cast<int>(test_part_results_.size()); +} + +// Returns the number of the test properties. +int TestResult::test_property_count() const { + return static_cast<int>(test_properties_.size()); +} + +// class Test + +// Creates a Test object. + +// The c'tor saves the values of all Google Test flags. +Test::Test() + : gtest_flag_saver_(new internal::GTestFlagSaver) { +} + +// The d'tor restores the values of all Google Test flags. +Test::~Test() { + delete gtest_flag_saver_; +} + +// Sets up the test fixture. +// +// A sub-class may override this. +void Test::SetUp() { +} + +// Tears down the test fixture. +// +// A sub-class may override this. +void Test::TearDown() { +} + +// Allows user supplied key value pairs to be recorded for later output. +void Test::RecordProperty(const char* key, const char* value) { + UnitTest::GetInstance()->RecordPropertyForCurrentTest(key, value); +} + +// Allows user supplied key value pairs to be recorded for later output. +void Test::RecordProperty(const char* key, int value) { + Message value_message; + value_message << value; + RecordProperty(key, value_message.GetString().c_str()); +} + +namespace internal { + +void ReportFailureInUnknownLocation(TestPartResult::Type result_type, + const String& message) { + // This function is a friend of UnitTest and as such has access to + // AddTestPartResult. + UnitTest::GetInstance()->AddTestPartResult( + result_type, + NULL, // No info about the source file where the exception occurred. + -1, // We have no info on which line caused the exception. + message, + String()); // No stack trace, either. +} + +} // namespace internal + +// Google Test requires all tests in the same test case to use the same test +// fixture class. This function checks if the current test has the +// same fixture class as the first test in the current test case. If +// yes, it returns true; otherwise it generates a Google Test failure and +// returns false. +bool Test::HasSameFixtureClass() { + internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); + const TestCase* const test_case = impl->current_test_case(); + + // Info about the first test in the current test case. + const TestInfo* const first_test_info = test_case->test_info_list()[0]; + const internal::TypeId first_fixture_id = first_test_info->fixture_class_id_; + const char* const first_test_name = first_test_info->name(); + + // Info about the current test. + const TestInfo* const this_test_info = impl->current_test_info(); + const internal::TypeId this_fixture_id = this_test_info->fixture_class_id_; + const char* const this_test_name = this_test_info->name(); + + if (this_fixture_id != first_fixture_id) { + // Is the first test defined using TEST? + const bool first_is_TEST = first_fixture_id == internal::GetTestTypeId(); + // Is this test defined using TEST? + const bool this_is_TEST = this_fixture_id == internal::GetTestTypeId(); + + if (first_is_TEST || this_is_TEST) { + // The user mixed TEST and TEST_F in this test case - we'll tell + // him/her how to fix it. + + // Gets the name of the TEST and the name of the TEST_F. Note + // that first_is_TEST and this_is_TEST cannot both be true, as + // the fixture IDs are different for the two tests. + const char* const TEST_name = + first_is_TEST ? first_test_name : this_test_name; + const char* const TEST_F_name = + first_is_TEST ? this_test_name : first_test_name; + + ADD_FAILURE() + << "All tests in the same test case must use the same test fixture\n" + << "class, so mixing TEST_F and TEST in the same test case is\n" + << "illegal. In test case " << this_test_info->test_case_name() + << ",\n" + << "test " << TEST_F_name << " is defined using TEST_F but\n" + << "test " << TEST_name << " is defined using TEST. You probably\n" + << "want to change the TEST to TEST_F or move it to another test\n" + << "case."; + } else { + // The user defined two fixture classes with the same name in + // two namespaces - we'll tell him/her how to fix it. + ADD_FAILURE() + << "All tests in the same test case must use the same test fixture\n" + << "class. However, in test case " + << this_test_info->test_case_name() << ",\n" + << "you defined test " << first_test_name + << " and test " << this_test_name << "\n" + << "using two different test fixture classes. This can happen if\n" + << "the two classes are from different namespaces or translation\n" + << "units and have the same name. You should probably rename one\n" + << "of the classes to put the tests into different test cases."; + } + return false; + } + + return true; +} + +#if GTEST_HAS_SEH + +// Adds an "exception thrown" fatal failure to the current test. This +// function returns its result via an output parameter pointer because VC++ +// prohibits creation of objects with destructors on stack in functions +// using __try (see error C2712). +static internal::String* FormatSehExceptionMessage(DWORD exception_code, + const char* location) { + Message message; + message << "SEH exception with code 0x" << std::setbase(16) << + exception_code << std::setbase(10) << " thrown in " << location << "."; + + return new internal::String(message.GetString()); +} + +#endif // GTEST_HAS_SEH + +#if GTEST_HAS_EXCEPTIONS + +// Adds an "exception thrown" fatal failure to the current test. +static internal::String FormatCxxExceptionMessage(const char* description, + const char* location) { + Message message; + if (description != NULL) { + message << "C++ exception with description \"" << description << "\""; + } else { + message << "Unknown C++ exception"; + } + message << " thrown in " << location << "."; + + return message.GetString(); +} + +static internal::String PrintTestPartResultToString( + const TestPartResult& test_part_result); + +// A failed Google Test assertion will throw an exception of this type when +// GTEST_FLAG(throw_on_failure) is true (if exceptions are enabled). We +// derive it from std::runtime_error, which is for errors presumably +// detectable only at run time. Since std::runtime_error inherits from +// std::exception, many testing frameworks know how to extract and print the +// message inside it. +class GoogleTestFailureException : public ::std::runtime_error { + public: + explicit GoogleTestFailureException(const TestPartResult& failure) + : ::std::runtime_error(PrintTestPartResultToString(failure).c_str()) {} +}; +#endif // GTEST_HAS_EXCEPTIONS + +namespace internal { +// We put these helper functions in the internal namespace as IBM's xlC +// compiler rejects the code if they were declared static. + +// Runs the given method and handles SEH exceptions it throws, when +// SEH is supported; returns the 0-value for type Result in case of an +// SEH exception. (Microsoft compilers cannot handle SEH and C++ +// exceptions in the same function. Therefore, we provide a separate +// wrapper function for handling SEH exceptions.) +template <class T, typename Result> +Result HandleSehExceptionsInMethodIfSupported( + T* object, Result (T::*method)(), const char* location) { +#if GTEST_HAS_SEH + __try { + return (object->*method)(); + } __except (internal::UnitTestOptions::GTestShouldProcessSEH( // NOLINT + GetExceptionCode())) { + // We create the exception message on the heap because VC++ prohibits + // creation of objects with destructors on stack in functions using __try + // (see error C2712). + internal::String* exception_message = FormatSehExceptionMessage( + GetExceptionCode(), location); + internal::ReportFailureInUnknownLocation(TestPartResult::kFatalFailure, + *exception_message); + delete exception_message; + return static_cast<Result>(0); + } +#else + (void)location; + return (object->*method)(); +#endif // GTEST_HAS_SEH +} + +// Runs the given method and catches and reports C++ and/or SEH-style +// exceptions, if they are supported; returns the 0-value for type +// Result in case of an SEH exception. +template <class T, typename Result> +Result HandleExceptionsInMethodIfSupported( + T* object, Result (T::*method)(), const char* location) { + // NOTE: The user code can affect the way in which Google Test handles + // exceptions by setting GTEST_FLAG(catch_exceptions), but only before + // RUN_ALL_TESTS() starts. It is technically possible to check the flag + // after the exception is caught and either report or re-throw the + // exception based on the flag's value: + // + // try { + // // Perform the test method. + // } catch (...) { + // if (GTEST_FLAG(catch_exceptions)) + // // Report the exception as failure. + // else + // throw; // Re-throws the original exception. + // } + // + // However, the purpose of this flag is to allow the program to drop into + // the debugger when the exception is thrown. On most platforms, once the + // control enters the catch block, the exception origin information is + // lost and the debugger will stop the program at the point of the + // re-throw in this function -- instead of at the point of the original + // throw statement in the code under test. For this reason, we perform + // the check early, sacrificing the ability to affect Google Test's + // exception handling in the method where the exception is thrown. + if (internal::GetUnitTestImpl()->catch_exceptions()) { +#if GTEST_HAS_EXCEPTIONS + try { + return HandleSehExceptionsInMethodIfSupported(object, method, location); + } catch (const GoogleTestFailureException&) { // NOLINT + // This exception doesn't originate in code under test. It makes no + // sense to report it as a test failure. + throw; + } catch (const std::exception& e) { // NOLINT + internal::ReportFailureInUnknownLocation( + TestPartResult::kFatalFailure, + FormatCxxExceptionMessage(e.what(), location)); + } catch (...) { // NOLINT + internal::ReportFailureInUnknownLocation( + TestPartResult::kFatalFailure, + FormatCxxExceptionMessage(NULL, location)); + } + return static_cast<Result>(0); +#else + return HandleSehExceptionsInMethodIfSupported(object, method, location); +#endif // GTEST_HAS_EXCEPTIONS + } else { + return (object->*method)(); + } +} + +} // namespace internal + +// Runs the test and updates the test result. +void Test::Run() { + if (!HasSameFixtureClass()) return; + + internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); + impl->os_stack_trace_getter()->UponLeavingGTest(); + internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()"); + // We will run the test only if SetUp() was successful. + if (!HasFatalFailure()) { + impl->os_stack_trace_getter()->UponLeavingGTest(); + internal::HandleExceptionsInMethodIfSupported( + this, &Test::TestBody, "the test body"); + } + + // However, we want to clean up as much as possible. Hence we will + // always call TearDown(), even if SetUp() or the test body has + // failed. + impl->os_stack_trace_getter()->UponLeavingGTest(); + internal::HandleExceptionsInMethodIfSupported( + this, &Test::TearDown, "TearDown()"); +} + +// Returns true iff the current test has a fatal failure. +bool Test::HasFatalFailure() { + return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure(); +} + +// Returns true iff the current test has a non-fatal failure. +bool Test::HasNonfatalFailure() { + return internal::GetUnitTestImpl()->current_test_result()-> + HasNonfatalFailure(); +} + +// class TestInfo + +// Constructs a TestInfo object. It assumes ownership of the test factory +// object. +// TODO(vladl@google.com): Make a_test_case_name and a_name const string&'s +// to signify they cannot be NULLs. +TestInfo::TestInfo(const char* a_test_case_name, + const char* a_name, + const char* a_type_param, + const char* a_value_param, + internal::TypeId fixture_class_id, + internal::TestFactoryBase* factory) + : test_case_name_(a_test_case_name), + name_(a_name), + type_param_(a_type_param ? new std::string(a_type_param) : NULL), + value_param_(a_value_param ? new std::string(a_value_param) : NULL), + fixture_class_id_(fixture_class_id), + should_run_(false), + is_disabled_(false), + matches_filter_(false), + factory_(factory), + result_() {} + +// Destructs a TestInfo object. +TestInfo::~TestInfo() { delete factory_; } + +namespace internal { + +// Creates a new TestInfo object and registers it with Google Test; +// returns the created object. +// +// Arguments: +// +// test_case_name: name of the test case +// name: name of the test +// type_param: the name of the test's type parameter, or NULL if +// this is not a typed or a type-parameterized test. +// value_param: text representation of the test's value parameter, +// or NULL if this is not a value-parameterized test. +// fixture_class_id: ID of the test fixture class +// set_up_tc: pointer to the function that sets up the test case +// tear_down_tc: pointer to the function that tears down the test case +// factory: pointer to the factory that creates a test object. +// The newly created TestInfo instance will assume +// ownership of the factory object. +TestInfo* MakeAndRegisterTestInfo( + const char* test_case_name, const char* name, + const char* type_param, + const char* value_param, + TypeId fixture_class_id, + SetUpTestCaseFunc set_up_tc, + TearDownTestCaseFunc tear_down_tc, + TestFactoryBase* factory) { + TestInfo* const test_info = + new TestInfo(test_case_name, name, type_param, value_param, + fixture_class_id, factory); + GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info); + return test_info; +} + +#if GTEST_HAS_PARAM_TEST +void ReportInvalidTestCaseType(const char* test_case_name, + const char* file, int line) { + Message errors; + errors + << "Attempted redefinition of test case " << test_case_name << ".\n" + << "All tests in the same test case must use the same test fixture\n" + << "class. However, in test case " << test_case_name << ", you tried\n" + << "to define a test using a fixture class different from the one\n" + << "used earlier. This can happen if the two fixture classes are\n" + << "from different namespaces and have the same name. You should\n" + << "probably rename one of the classes to put the tests into different\n" + << "test cases."; + + fprintf(stderr, "%s %s", FormatFileLocation(file, line).c_str(), + errors.GetString().c_str()); +} +#endif // GTEST_HAS_PARAM_TEST + +} // namespace internal + +namespace { + +// A predicate that checks the test name of a TestInfo against a known +// value. +// +// This is used for implementation of the TestCase class only. We put +// it in the anonymous namespace to prevent polluting the outer +// namespace. +// +// TestNameIs is copyable. +class TestNameIs { + public: + // Constructor. + // + // TestNameIs has NO default constructor. + explicit TestNameIs(const char* name) + : name_(name) {} + + // Returns true iff the test name of test_info matches name_. + bool operator()(const TestInfo * test_info) const { + return test_info && internal::String(test_info->name()).Compare(name_) == 0; + } + + private: + internal::String name_; +}; + +} // namespace + +namespace internal { + +// This method expands all parameterized tests registered with macros TEST_P +// and INSTANTIATE_TEST_CASE_P into regular tests and registers those. +// This will be done just once during the program runtime. +void UnitTestImpl::RegisterParameterizedTests() { +#if GTEST_HAS_PARAM_TEST + if (!parameterized_tests_registered_) { + parameterized_test_registry_.RegisterTests(); + parameterized_tests_registered_ = true; + } +#endif +} + +} // namespace internal + +// Creates the test object, runs it, records its result, and then +// deletes it. +void TestInfo::Run() { + if (!should_run_) return; + + // Tells UnitTest where to store test result. + internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); + impl->set_current_test_info(this); + + TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater(); + + // Notifies the unit test event listeners that a test is about to start. + repeater->OnTestStart(*this); + + const TimeInMillis start = internal::GetTimeInMillis(); + + impl->os_stack_trace_getter()->UponLeavingGTest(); + + // Creates the test object. + Test* const test = internal::HandleExceptionsInMethodIfSupported( + factory_, &internal::TestFactoryBase::CreateTest, + "the test fixture's constructor"); + + // Runs the test only if the test object was created and its + // constructor didn't generate a fatal failure. + if ((test != NULL) && !Test::HasFatalFailure()) { + // This doesn't throw as all user code that can throw are wrapped into + // exception handling code. + test->Run(); + } + + // Deletes the test object. + impl->os_stack_trace_getter()->UponLeavingGTest(); + internal::HandleExceptionsInMethodIfSupported( + test, &Test::DeleteSelf_, "the test fixture's destructor"); + + result_.set_elapsed_time(internal::GetTimeInMillis() - start); + + // Notifies the unit test event listener that a test has just finished. + repeater->OnTestEnd(*this); + + // Tells UnitTest to stop associating assertion results to this + // test. + impl->set_current_test_info(NULL); +} + +// class TestCase + +// Gets the number of successful tests in this test case. +int TestCase::successful_test_count() const { + return CountIf(test_info_list_, TestPassed); +} + +// Gets the number of failed tests in this test case. +int TestCase::failed_test_count() const { + return CountIf(test_info_list_, TestFailed); +} + +int TestCase::disabled_test_count() const { + return CountIf(test_info_list_, TestDisabled); +} + +// Get the number of tests in this test case that should run. +int TestCase::test_to_run_count() const { + return CountIf(test_info_list_, ShouldRunTest); +} + +// Gets the number of all tests. +int TestCase::total_test_count() const { + return static_cast<int>(test_info_list_.size()); +} + +// Creates a TestCase with the given name. +// +// Arguments: +// +// name: name of the test case +// a_type_param: the name of the test case's type parameter, or NULL if +// this is not a typed or a type-parameterized test case. +// set_up_tc: pointer to the function that sets up the test case +// tear_down_tc: pointer to the function that tears down the test case +TestCase::TestCase(const char* a_name, const char* a_type_param, + Test::SetUpTestCaseFunc set_up_tc, + Test::TearDownTestCaseFunc tear_down_tc) + : name_(a_name), + type_param_(a_type_param ? new std::string(a_type_param) : NULL), + set_up_tc_(set_up_tc), + tear_down_tc_(tear_down_tc), + should_run_(false), + elapsed_time_(0) { +} + +// Destructor of TestCase. +TestCase::~TestCase() { + // Deletes every Test in the collection. + ForEach(test_info_list_, internal::Delete<TestInfo>); +} + +// Returns the i-th test among all the tests. i can range from 0 to +// total_test_count() - 1. If i is not in that range, returns NULL. +const TestInfo* TestCase::GetTestInfo(int i) const { + const int index = GetElementOr(test_indices_, i, -1); + return index < 0 ? NULL : test_info_list_[index]; +} + +// Returns the i-th test among all the tests. i can range from 0 to +// total_test_count() - 1. If i is not in that range, returns NULL. +TestInfo* TestCase::GetMutableTestInfo(int i) { + const int index = GetElementOr(test_indices_, i, -1); + return index < 0 ? NULL : test_info_list_[index]; +} + +// Adds a test to this test case. Will delete the test upon +// destruction of the TestCase object. +void TestCase::AddTestInfo(TestInfo * test_info) { + test_info_list_.push_back(test_info); + test_indices_.push_back(static_cast<int>(test_indices_.size())); +} + +// Runs every test in this TestCase. +void TestCase::Run() { + if (!should_run_) return; + + internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); + impl->set_current_test_case(this); + + TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater(); + + repeater->OnTestCaseStart(*this); + impl->os_stack_trace_getter()->UponLeavingGTest(); + internal::HandleExceptionsInMethodIfSupported( + this, &TestCase::RunSetUpTestCase, "SetUpTestCase()"); + + const internal::TimeInMillis start = internal::GetTimeInMillis(); + for (int i = 0; i < total_test_count(); i++) { + GetMutableTestInfo(i)->Run(); + } + elapsed_time_ = internal::GetTimeInMillis() - start; + + impl->os_stack_trace_getter()->UponLeavingGTest(); + internal::HandleExceptionsInMethodIfSupported( + this, &TestCase::RunTearDownTestCase, "TearDownTestCase()"); + + repeater->OnTestCaseEnd(*this); + impl->set_current_test_case(NULL); +} + +// Clears the results of all tests in this test case. +void TestCase::ClearResult() { + ForEach(test_info_list_, TestInfo::ClearTestResult); +} + +// Shuffles the tests in this test case. +void TestCase::ShuffleTests(internal::Random* random) { + Shuffle(random, &test_indices_); +} + +// Restores the test order to before the first shuffle. +void TestCase::UnshuffleTests() { + for (size_t i = 0; i < test_indices_.size(); i++) { + test_indices_[i] = static_cast<int>(i); + } +} + +// Formats a countable noun. Depending on its quantity, either the +// singular form or the plural form is used. e.g. +// +// FormatCountableNoun(1, "formula", "formuli") returns "1 formula". +// FormatCountableNoun(5, "book", "books") returns "5 books". +static internal::String FormatCountableNoun(int count, + const char * singular_form, + const char * plural_form) { + return internal::String::Format("%d %s", count, + count == 1 ? singular_form : plural_form); +} + +// Formats the count of tests. +static internal::String FormatTestCount(int test_count) { + return FormatCountableNoun(test_count, "test", "tests"); +} + +// Formats the count of test cases. +static internal::String FormatTestCaseCount(int test_case_count) { + return FormatCountableNoun(test_case_count, "test case", "test cases"); +} + +// Converts a TestPartResult::Type enum to human-friendly string +// representation. Both kNonFatalFailure and kFatalFailure are translated +// to "Failure", as the user usually doesn't care about the difference +// between the two when viewing the test result. +static const char * TestPartResultTypeToString(TestPartResult::Type type) { + switch (type) { + case TestPartResult::kSuccess: + return "Success"; + + case TestPartResult::kNonFatalFailure: + case TestPartResult::kFatalFailure: +#ifdef _MSC_VER + return "error: "; +#else + return "Failure\n"; +#endif + default: + return "Unknown result type"; + } +} + +// Prints a TestPartResult to a String. +static internal::String PrintTestPartResultToString( + const TestPartResult& test_part_result) { + return (Message() + << internal::FormatFileLocation(test_part_result.file_name(), + test_part_result.line_number()) + << " " << TestPartResultTypeToString(test_part_result.type()) + << test_part_result.message()).GetString(); +} + +// Prints a TestPartResult. +static void PrintTestPartResult(const TestPartResult& test_part_result) { + const internal::String& result = + PrintTestPartResultToString(test_part_result); + printf("%s\n", result.c_str()); + fflush(stdout); + // If the test program runs in Visual Studio or a debugger, the + // following statements add the test part result message to the Output + // window such that the user can double-click on it to jump to the + // corresponding source code location; otherwise they do nothing. +#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE + // We don't call OutputDebugString*() on Windows Mobile, as printing + // to stdout is done by OutputDebugString() there already - we don't + // want the same message printed twice. + ::OutputDebugStringA(result.c_str()); + ::OutputDebugStringA("\n"); +#endif +} + +// class PrettyUnitTestResultPrinter + +namespace internal { + +enum GTestColor { + COLOR_DEFAULT, + COLOR_RED, + COLOR_GREEN, + COLOR_YELLOW +}; + +#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE + +// Returns the character attribute for the given color. +WORD GetColorAttribute(GTestColor color) { + switch (color) { + case COLOR_RED: return FOREGROUND_RED; + case COLOR_GREEN: return FOREGROUND_GREEN; + case COLOR_YELLOW: return FOREGROUND_RED | FOREGROUND_GREEN; + default: return 0; + } +} + +#else + +// Returns the ANSI color code for the given color. COLOR_DEFAULT is +// an invalid input. +const char* GetAnsiColorCode(GTestColor color) { + switch (color) { + case COLOR_RED: return "1"; + case COLOR_GREEN: return "2"; + case COLOR_YELLOW: return "3"; + default: return NULL; + }; +} + +#endif // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE + +// Returns true iff Google Test should use colors in the output. +bool ShouldUseColor(bool stdout_is_tty) { + const char* const gtest_color = GTEST_FLAG(color).c_str(); + + if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) { +#if GTEST_OS_WINDOWS + // On Windows the TERM variable is usually not set, but the + // console there does support colors. + return stdout_is_tty; +#else + // On non-Windows platforms, we rely on the TERM variable. + const char* const term = posix::GetEnv("TERM"); + const bool term_supports_color = + String::CStringEquals(term, "xterm") || + String::CStringEquals(term, "xterm-color") || + String::CStringEquals(term, "xterm-256color") || + String::CStringEquals(term, "screen") || + String::CStringEquals(term, "linux") || + String::CStringEquals(term, "cygwin"); + return stdout_is_tty && term_supports_color; +#endif // GTEST_OS_WINDOWS + } + + return String::CaseInsensitiveCStringEquals(gtest_color, "yes") || + String::CaseInsensitiveCStringEquals(gtest_color, "true") || + String::CaseInsensitiveCStringEquals(gtest_color, "t") || + String::CStringEquals(gtest_color, "1"); + // We take "yes", "true", "t", and "1" as meaning "yes". If the + // value is neither one of these nor "auto", we treat it as "no" to + // be conservative. +} + +// Helpers for printing colored strings to stdout. Note that on Windows, we +// cannot simply emit special characters and have the terminal change colors. +// This routine must actually emit the characters rather than return a string +// that would be colored when printed, as can be done on Linux. +void ColoredPrintf(GTestColor color, const char* fmt, ...) { + va_list args; + va_start(args, fmt); + +#if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS + const bool use_color = false; +#else + static const bool in_color_mode = + ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0); + const bool use_color = in_color_mode && (color != COLOR_DEFAULT); +#endif // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS + // The '!= 0' comparison is necessary to satisfy MSVC 7.1. + + if (!use_color) { + vprintf(fmt, args); + va_end(args); + return; + } + +#if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE + const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE); + + // Gets the current text color. + CONSOLE_SCREEN_BUFFER_INFO buffer_info; + GetConsoleScreenBufferInfo(stdout_handle, &buffer_info); + const WORD old_color_attrs = buffer_info.wAttributes; + + // We need to flush the stream buffers into the console before each + // SetConsoleTextAttribute call lest it affect the text that is already + // printed but has not yet reached the console. + fflush(stdout); + SetConsoleTextAttribute(stdout_handle, + GetColorAttribute(color) | FOREGROUND_INTENSITY); + vprintf(fmt, args); + + fflush(stdout); + // Restores the text color. + SetConsoleTextAttribute(stdout_handle, old_color_attrs); +#else + printf("\033[0;3%sm", GetAnsiColorCode(color)); + vprintf(fmt, args); + printf("\033[m"); // Resets the terminal to default. +#endif // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE + va_end(args); +} + +void PrintFullTestCommentIfPresent(const TestInfo& test_info) { + const char* const type_param = test_info.type_param(); + const char* const value_param = test_info.value_param(); + + if (type_param != NULL || value_param != NULL) { + printf(", where "); + if (type_param != NULL) { + printf("TypeParam = %s", type_param); + if (value_param != NULL) + printf(" and "); + } + if (value_param != NULL) { + printf("GetParam() = %s", value_param); + } + } +} + +// This class implements the TestEventListener interface. +// +// Class PrettyUnitTestResultPrinter is copyable. +class PrettyUnitTestResultPrinter : public TestEventListener { + public: + PrettyUnitTestResultPrinter() {} + static void PrintTestName(const char * test_case, const char * test) { + printf("%s.%s", test_case, test); + } + + // The following methods override what's in the TestEventListener class. + virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {} + virtual void OnTestIterationStart(const UnitTest& unit_test, int iteration); + virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test); + virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {} + virtual void OnTestCaseStart(const TestCase& test_case); + virtual void OnTestStart(const TestInfo& test_info); + virtual void OnTestPartResult(const TestPartResult& result); + virtual void OnTestEnd(const TestInfo& test_info); + virtual void OnTestCaseEnd(const TestCase& test_case); + virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test); + virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {} + virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration); + virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {} + + private: + static void PrintFailedTests(const UnitTest& unit_test); + + internal::String test_case_name_; +}; + + // Fired before each iteration of tests starts. +void PrettyUnitTestResultPrinter::OnTestIterationStart( + const UnitTest& unit_test, int iteration) { + if (GTEST_FLAG(repeat) != 1) + printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1); + + const char* const filter = GTEST_FLAG(filter).c_str(); + + // Prints the filter if it's not *. This reminds the user that some + // tests may be skipped. + if (!internal::String::CStringEquals(filter, kUniversalFilter)) { + ColoredPrintf(COLOR_YELLOW, + "Note: %s filter = %s\n", GTEST_NAME_, filter); + } + + if (internal::ShouldShard(kTestTotalShards, kTestShardIndex, false)) { + const Int32 shard_index = Int32FromEnvOrDie(kTestShardIndex, -1); + ColoredPrintf(COLOR_YELLOW, + "Note: This is test shard %d of %s.\n", + static_cast<int>(shard_index) + 1, + internal::posix::GetEnv(kTestTotalShards)); + } + + if (GTEST_FLAG(shuffle)) { + ColoredPrintf(COLOR_YELLOW, + "Note: Randomizing tests' orders with a seed of %d .\n", + unit_test.random_seed()); + } + + ColoredPrintf(COLOR_GREEN, "[==========] "); + printf("Running %s from %s.\n", + FormatTestCount(unit_test.test_to_run_count()).c_str(), + FormatTestCaseCount(unit_test.test_case_to_run_count()).c_str()); + fflush(stdout); +} + +void PrettyUnitTestResultPrinter::OnEnvironmentsSetUpStart( + const UnitTest& /*unit_test*/) { + ColoredPrintf(COLOR_GREEN, "[----------] "); + printf("Global test environment set-up.\n"); + fflush(stdout); +} + +void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) { + test_case_name_ = test_case.name(); + const internal::String counts = + FormatCountableNoun(test_case.test_to_run_count(), "test", "tests"); + ColoredPrintf(COLOR_GREEN, "[----------] "); + printf("%s from %s", counts.c_str(), test_case_name_.c_str()); + if (test_case.type_param() == NULL) { + printf("\n"); + } else { + printf(", where TypeParam = %s\n", test_case.type_param()); + } + fflush(stdout); +} + +void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) { + ColoredPrintf(COLOR_GREEN, "[ RUN ] "); + PrintTestName(test_case_name_.c_str(), test_info.name()); + printf("\n"); + fflush(stdout); +} + +// Called after an assertion failure. +void PrettyUnitTestResultPrinter::OnTestPartResult( + const TestPartResult& result) { + // If the test part succeeded, we don't need to do anything. + if (result.type() == TestPartResult::kSuccess) + return; + + // Print failure message from the assertion (e.g. expected this and got that). + PrintTestPartResult(result); + fflush(stdout); +} + +void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) { + if (test_info.result()->Passed()) { + ColoredPrintf(COLOR_GREEN, "[ OK ] "); + } else { + ColoredPrintf(COLOR_RED, "[ FAILED ] "); + } + PrintTestName(test_case_name_.c_str(), test_info.name()); + if (test_info.result()->Failed()) + PrintFullTestCommentIfPresent(test_info); + + if (GTEST_FLAG(print_time)) { + printf(" (%s ms)\n", internal::StreamableToString( + test_info.result()->elapsed_time()).c_str()); + } else { + printf("\n"); + } + fflush(stdout); +} + +void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) { + if (!GTEST_FLAG(print_time)) return; + + test_case_name_ = test_case.name(); + const internal::String counts = + FormatCountableNoun(test_case.test_to_run_count(), "test", "tests"); + ColoredPrintf(COLOR_GREEN, "[----------] "); + printf("%s from %s (%s ms total)\n\n", + counts.c_str(), test_case_name_.c_str(), + internal::StreamableToString(test_case.elapsed_time()).c_str()); + fflush(stdout); +} + +void PrettyUnitTestResultPrinter::OnEnvironmentsTearDownStart( + const UnitTest& /*unit_test*/) { + ColoredPrintf(COLOR_GREEN, "[----------] "); + printf("Global test environment tear-down\n"); + fflush(stdout); +} + +// Internal helper for printing the list of failed tests. +void PrettyUnitTestResultPrinter::PrintFailedTests(const UnitTest& unit_test) { + const int failed_test_count = unit_test.failed_test_count(); + if (failed_test_count == 0) { + return; + } + + for (int i = 0; i < unit_test.total_test_case_count(); ++i) { + const TestCase& test_case = *unit_test.GetTestCase(i); + if (!test_case.should_run() || (test_case.failed_test_count() == 0)) { + continue; + } + for (int j = 0; j < test_case.total_test_count(); ++j) { + const TestInfo& test_info = *test_case.GetTestInfo(j); + if (!test_info.should_run() || test_info.result()->Passed()) { + continue; + } + ColoredPrintf(COLOR_RED, "[ FAILED ] "); + printf("%s.%s", test_case.name(), test_info.name()); + PrintFullTestCommentIfPresent(test_info); + printf("\n"); + } + } +} + +void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test, + int /*iteration*/) { + ColoredPrintf(COLOR_GREEN, "[==========] "); + printf("%s from %s ran.", + FormatTestCount(unit_test.test_to_run_count()).c_str(), + FormatTestCaseCount(unit_test.test_case_to_run_count()).c_str()); + if (GTEST_FLAG(print_time)) { + printf(" (%s ms total)", + internal::StreamableToString(unit_test.elapsed_time()).c_str()); + } + printf("\n"); + ColoredPrintf(COLOR_GREEN, "[ PASSED ] "); + printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str()); + + int num_failures = unit_test.failed_test_count(); + if (!unit_test.Passed()) { + const int failed_test_count = unit_test.failed_test_count(); + ColoredPrintf(COLOR_RED, "[ FAILED ] "); + printf("%s, listed below:\n", FormatTestCount(failed_test_count).c_str()); + PrintFailedTests(unit_test); + printf("\n%2d FAILED %s\n", num_failures, + num_failures == 1 ? "TEST" : "TESTS"); + } + + int num_disabled = unit_test.disabled_test_count(); + if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) { + if (!num_failures) { + printf("\n"); // Add a spacer if no FAILURE banner is displayed. + } + ColoredPrintf(COLOR_YELLOW, + " YOU HAVE %d DISABLED %s\n\n", + num_disabled, + num_disabled == 1 ? "TEST" : "TESTS"); + } + // Ensure that Google Test output is printed before, e.g., heapchecker output. + fflush(stdout); +} + +// End PrettyUnitTestResultPrinter + +// class TestEventRepeater +// +// This class forwards events to other event listeners. +class TestEventRepeater : public TestEventListener { + public: + TestEventRepeater() : forwarding_enabled_(true) {} + virtual ~TestEventRepeater(); + void Append(TestEventListener *listener); + TestEventListener* Release(TestEventListener* listener); + + // Controls whether events will be forwarded to listeners_. Set to false + // in death test child processes. + bool forwarding_enabled() const { return forwarding_enabled_; } + void set_forwarding_enabled(bool enable) { forwarding_enabled_ = enable; } + + virtual void OnTestProgramStart(const UnitTest& unit_test); + virtual void OnTestIterationStart(const UnitTest& unit_test, int iteration); + virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test); + virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test); + virtual void OnTestCaseStart(const TestCase& test_case); + virtual void OnTestStart(const TestInfo& test_info); + virtual void OnTestPartResult(const TestPartResult& result); + virtual void OnTestEnd(const TestInfo& test_info); + virtual void OnTestCaseEnd(const TestCase& test_case); + virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test); + virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test); + virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration); + virtual void OnTestProgramEnd(const UnitTest& unit_test); + + private: + // Controls whether events will be forwarded to listeners_. Set to false + // in death test child processes. + bool forwarding_enabled_; + // The list of listeners that receive events. + std::vector<TestEventListener*> listeners_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventRepeater); +}; + +TestEventRepeater::~TestEventRepeater() { + ForEach(listeners_, Delete<TestEventListener>); +} + +void TestEventRepeater::Append(TestEventListener *listener) { + listeners_.push_back(listener); +} + +// TODO(vladl@google.com): Factor the search functionality into Vector::Find. +TestEventListener* TestEventRepeater::Release(TestEventListener *listener) { + for (size_t i = 0; i < listeners_.size(); ++i) { + if (listeners_[i] == listener) { + listeners_.erase(listeners_.begin() + i); + return listener; + } + } + + return NULL; +} + +// Since most methods are very similar, use macros to reduce boilerplate. +// This defines a member that forwards the call to all listeners. +#define GTEST_REPEATER_METHOD_(Name, Type) \ +void TestEventRepeater::Name(const Type& parameter) { \ + if (forwarding_enabled_) { \ + for (size_t i = 0; i < listeners_.size(); i++) { \ + listeners_[i]->Name(parameter); \ + } \ + } \ +} +// This defines a member that forwards the call to all listeners in reverse +// order. +#define GTEST_REVERSE_REPEATER_METHOD_(Name, Type) \ +void TestEventRepeater::Name(const Type& parameter) { \ + if (forwarding_enabled_) { \ + for (int i = static_cast<int>(listeners_.size()) - 1; i >= 0; i--) { \ + listeners_[i]->Name(parameter); \ + } \ + } \ +} + +GTEST_REPEATER_METHOD_(OnTestProgramStart, UnitTest) +GTEST_REPEATER_METHOD_(OnEnvironmentsSetUpStart, UnitTest) +GTEST_REPEATER_METHOD_(OnTestCaseStart, TestCase) +GTEST_REPEATER_METHOD_(OnTestStart, TestInfo) +GTEST_REPEATER_METHOD_(OnTestPartResult, TestPartResult) +GTEST_REPEATER_METHOD_(OnEnvironmentsTearDownStart, UnitTest) +GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsSetUpEnd, UnitTest) +GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsTearDownEnd, UnitTest) +GTEST_REVERSE_REPEATER_METHOD_(OnTestEnd, TestInfo) +GTEST_REVERSE_REPEATER_METHOD_(OnTestCaseEnd, TestCase) +GTEST_REVERSE_REPEATER_METHOD_(OnTestProgramEnd, UnitTest) + +#undef GTEST_REPEATER_METHOD_ +#undef GTEST_REVERSE_REPEATER_METHOD_ + +void TestEventRepeater::OnTestIterationStart(const UnitTest& unit_test, + int iteration) { + if (forwarding_enabled_) { + for (size_t i = 0; i < listeners_.size(); i++) { + listeners_[i]->OnTestIterationStart(unit_test, iteration); + } + } +} + +void TestEventRepeater::OnTestIterationEnd(const UnitTest& unit_test, + int iteration) { + if (forwarding_enabled_) { + for (int i = static_cast<int>(listeners_.size()) - 1; i >= 0; i--) { + listeners_[i]->OnTestIterationEnd(unit_test, iteration); + } + } +} + +// End TestEventRepeater + +// This class generates an XML output file. +class XmlUnitTestResultPrinter : public EmptyTestEventListener { + public: + explicit XmlUnitTestResultPrinter(const char* output_file); + + virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration); + + private: + // Is c a whitespace character that is normalized to a space character + // when it appears in an XML attribute value? + static bool IsNormalizableWhitespace(char c) { + return c == 0x9 || c == 0xA || c == 0xD; + } + + // May c appear in a well-formed XML document? + static bool IsValidXmlCharacter(char c) { + return IsNormalizableWhitespace(c) || c >= 0x20; + } + + // Returns an XML-escaped copy of the input string str. If + // is_attribute is true, the text is meant to appear as an attribute + // value, and normalizable whitespace is preserved by replacing it + // with character references. + static String EscapeXml(const char* str, bool is_attribute); + + // Returns the given string with all characters invalid in XML removed. + static string RemoveInvalidXmlCharacters(const string& str); + + // Convenience wrapper around EscapeXml when str is an attribute value. + static String EscapeXmlAttribute(const char* str) { + return EscapeXml(str, true); + } + + // Convenience wrapper around EscapeXml when str is not an attribute value. + static String EscapeXmlText(const char* str) { return EscapeXml(str, false); } + + // Streams an XML CDATA section, escaping invalid CDATA sequences as needed. + static void OutputXmlCDataSection(::std::ostream* stream, const char* data); + + // Streams an XML representation of a TestInfo object. + static void OutputXmlTestInfo(::std::ostream* stream, + const char* test_case_name, + const TestInfo& test_info); + + // Prints an XML representation of a TestCase object + static void PrintXmlTestCase(FILE* out, const TestCase& test_case); + + // Prints an XML summary of unit_test to output stream out. + static void PrintXmlUnitTest(FILE* out, const UnitTest& unit_test); + + // Produces a string representing the test properties in a result as space + // delimited XML attributes based on the property key="value" pairs. + // When the String is not empty, it includes a space at the beginning, + // to delimit this attribute from prior attributes. + static String TestPropertiesAsXmlAttributes(const TestResult& result); + + // The output file. + const String output_file_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(XmlUnitTestResultPrinter); +}; + +// Creates a new XmlUnitTestResultPrinter. +XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file) + : output_file_(output_file) { + if (output_file_.c_str() == NULL || output_file_.empty()) { + fprintf(stderr, "XML output file may not be null\n"); + fflush(stderr); + exit(EXIT_FAILURE); + } +} + +// Called after the unit test ends. +void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test, + int /*iteration*/) { + FILE* xmlout = NULL; + FilePath output_file(output_file_); + FilePath output_dir(output_file.RemoveFileName()); + + if (output_dir.CreateDirectoriesRecursively()) { + xmlout = posix::FOpen(output_file_.c_str(), "w"); + } + if (xmlout == NULL) { + // TODO(wan): report the reason of the failure. + // + // We don't do it for now as: + // + // 1. There is no urgent need for it. + // 2. It's a bit involved to make the errno variable thread-safe on + // all three operating systems (Linux, Windows, and Mac OS). + // 3. To interpret the meaning of errno in a thread-safe way, + // we need the strerror_r() function, which is not available on + // Windows. + fprintf(stderr, + "Unable to open file \"%s\"\n", + output_file_.c_str()); + fflush(stderr); + exit(EXIT_FAILURE); + } + PrintXmlUnitTest(xmlout, unit_test); + fclose(xmlout); +} + +// Returns an XML-escaped copy of the input string str. If is_attribute +// is true, the text is meant to appear as an attribute value, and +// normalizable whitespace is preserved by replacing it with character +// references. +// +// Invalid XML characters in str, if any, are stripped from the output. +// It is expected that most, if not all, of the text processed by this +// module will consist of ordinary English text. +// If this module is ever modified to produce version 1.1 XML output, +// most invalid characters can be retained using character references. +// TODO(wan): It might be nice to have a minimally invasive, human-readable +// escaping scheme for invalid characters, rather than dropping them. +String XmlUnitTestResultPrinter::EscapeXml(const char* str, bool is_attribute) { + Message m; + + if (str != NULL) { + for (const char* src = str; *src; ++src) { + switch (*src) { + case '<': + m << "<"; + break; + case '>': + m << ">"; + break; + case '&': + m << "&"; + break; + case '\'': + if (is_attribute) + m << "'"; + else + m << '\''; + break; + case '"': + if (is_attribute) + m << """; + else + m << '"'; + break; + default: + if (IsValidXmlCharacter(*src)) { + if (is_attribute && IsNormalizableWhitespace(*src)) + m << String::Format("&#x%02X;", unsigned(*src)); + else + m << *src; + } + break; + } + } + } + + return m.GetString(); +} + +// Returns the given string with all characters invalid in XML removed. +// Currently invalid characters are dropped from the string. An +// alternative is to replace them with certain characters such as . or ?. +string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters(const string& str) { + string output; + output.reserve(str.size()); + for (string::const_iterator it = str.begin(); it != str.end(); ++it) + if (IsValidXmlCharacter(*it)) + output.push_back(*it); + + return output; +} + +// The following routines generate an XML representation of a UnitTest +// object. +// +// This is how Google Test concepts map to the DTD: +// +// <testsuites name="AllTests"> <-- corresponds to a UnitTest object +// <testsuite name="testcase-name"> <-- corresponds to a TestCase object +// <testcase name="test-name"> <-- corresponds to a TestInfo object +// <failure message="...">...</failure> +// <failure message="...">...</failure> +// <failure message="...">...</failure> +// <-- individual assertion failures +// </testcase> +// </testsuite> +// </testsuites> + +// Formats the given time in milliseconds as seconds. +std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) { + ::std::stringstream ss; + ss << ms/1000.0; + return ss.str(); +} + +// Streams an XML CDATA section, escaping invalid CDATA sequences as needed. +void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream, + const char* data) { + const char* segment = data; + *stream << "<![CDATA["; + for (;;) { + const char* const next_segment = strstr(segment, "]]>"); + if (next_segment != NULL) { + stream->write( + segment, static_cast<std::streamsize>(next_segment - segment)); + *stream << "]]>]]><![CDATA["; + segment = next_segment + strlen("]]>"); + } else { + *stream << segment; + break; + } + } + *stream << "]]>"; +} + +// Prints an XML representation of a TestInfo object. +// TODO(wan): There is also value in printing properties with the plain printer. +void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream, + const char* test_case_name, + const TestInfo& test_info) { + if (test_info.filtered_out ()) + return; + + const TestResult& result = *test_info.result(); + *stream << " <testcase name=\"" + << EscapeXmlAttribute(test_info.name()).c_str() << "\""; + + if (test_info.value_param() != NULL) { + *stream << " value_param=\"" << EscapeXmlAttribute(test_info.value_param()) + << "\""; + } + if (test_info.type_param() != NULL) { + *stream << " type_param=\"" << EscapeXmlAttribute(test_info.type_param()) + << "\""; + } + + *stream << " status=\"" + << (test_info.should_run() ? "run" : "notrun") + << "\" time=\"" + << FormatTimeInMillisAsSeconds(result.elapsed_time()) + << "\" classname=\"" << EscapeXmlAttribute(test_case_name).c_str() + << "\"" << TestPropertiesAsXmlAttributes(result).c_str(); + + int failures = 0; + for (int i = 0; i < result.total_part_count(); ++i) { + const TestPartResult& part = result.GetTestPartResult(i); + if (part.failed()) { + if (++failures == 1) + *stream << ">\n"; + *stream << " <failure message=\"" + << EscapeXmlAttribute(part.summary()).c_str() + << "\" type=\"\">"; + const string location = internal::FormatCompilerIndependentFileLocation( + part.file_name(), part.line_number()); + const string message = location + "\n" + part.message(); + OutputXmlCDataSection(stream, + RemoveInvalidXmlCharacters(message).c_str()); + *stream << "</failure>\n"; + } + } + + if (failures == 0) + *stream << " />\n"; + else + *stream << " </testcase>\n"; +} + +// Prints an XML representation of a TestCase object +void XmlUnitTestResultPrinter::PrintXmlTestCase(FILE* out, + const TestCase& test_case) { + if (test_case.should_skip_report ()) + return; + + fprintf(out, + " <testsuite name=\"%s\" tests=\"%d\" failures=\"%d\" " + "disabled=\"%d\" ", + EscapeXmlAttribute(test_case.name()).c_str(), + test_case.total_test_count(), + test_case.failed_test_count(), + test_case.disabled_test_count()); + fprintf(out, + "errors=\"0\" time=\"%s\">\n", + FormatTimeInMillisAsSeconds(test_case.elapsed_time()).c_str()); + for (int i = 0; i < test_case.total_test_count(); ++i) { + ::std::stringstream stream; + OutputXmlTestInfo(&stream, test_case.name(), *test_case.GetTestInfo(i)); + fprintf(out, "%s", StringStreamToString(&stream).c_str()); + } + fprintf(out, " </testsuite>\n"); +} + +// Prints an XML summary of unit_test to output stream out. +void XmlUnitTestResultPrinter::PrintXmlUnitTest(FILE* out, + const UnitTest& unit_test) { + fprintf(out, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"); + fprintf(out, + "<testsuites tests=\"%d\" failures=\"%d\" disabled=\"%d\" " + "errors=\"0\" time=\"%s\" ", + unit_test.total_test_count(), + unit_test.failed_test_count(), + unit_test.disabled_test_count(), + FormatTimeInMillisAsSeconds(unit_test.elapsed_time()).c_str()); + if (GTEST_FLAG(shuffle)) { + fprintf(out, "random_seed=\"%d\" ", unit_test.random_seed()); + } + fprintf(out, "name=\"AllTests\">\n"); + for (int i = 0; i < unit_test.total_test_case_count(); ++i) + PrintXmlTestCase(out, *unit_test.GetTestCase(i)); + fprintf(out, "</testsuites>\n"); +} + +// Produces a string representing the test properties in a result as space +// delimited XML attributes based on the property key="value" pairs. +String XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes( + const TestResult& result) { + Message attributes; + for (int i = 0; i < result.test_property_count(); ++i) { + const TestProperty& property = result.GetTestProperty(i); + attributes << " " << property.key() << "=" + << "\"" << EscapeXmlAttribute(property.value()) << "\""; + } + return attributes.GetString(); +} + +// End XmlUnitTestResultPrinter + +#if GTEST_CAN_STREAM_RESULTS_ + +// Streams test results to the given port on the given host machine. +class StreamingListener : public EmptyTestEventListener { + public: + // Escapes '=', '&', '%', and '\n' characters in str as "%xx". + static string UrlEncode(const char* str); + + StreamingListener(const string& host, const string& port) + : sockfd_(-1), host_name_(host), port_num_(port) { + MakeConnection(); + Send("gtest_streaming_protocol_version=1.0\n"); + } + + virtual ~StreamingListener() { + if (sockfd_ != -1) + CloseConnection(); + } + + void OnTestProgramStart(const UnitTest& /* unit_test */) { + Send("event=TestProgramStart\n"); + } + + void OnTestProgramEnd(const UnitTest& unit_test) { + // Note that Google Test current only report elapsed time for each + // test iteration, not for the entire test program. + Send(String::Format("event=TestProgramEnd&passed=%d\n", + unit_test.Passed())); + + // Notify the streaming server to stop. + CloseConnection(); + } + + void OnTestIterationStart(const UnitTest& /* unit_test */, int iteration) { + Send(String::Format("event=TestIterationStart&iteration=%d\n", + iteration)); + } + + void OnTestIterationEnd(const UnitTest& unit_test, int /* iteration */) { + Send(String::Format("event=TestIterationEnd&passed=%d&elapsed_time=%sms\n", + unit_test.Passed(), + StreamableToString(unit_test.elapsed_time()).c_str())); + } + + void OnTestCaseStart(const TestCase& test_case) { + Send(String::Format("event=TestCaseStart&name=%s\n", test_case.name())); + } + + void OnTestCaseEnd(const TestCase& test_case) { + Send(String::Format("event=TestCaseEnd&passed=%d&elapsed_time=%sms\n", + test_case.Passed(), + StreamableToString(test_case.elapsed_time()).c_str())); + } + + void OnTestStart(const TestInfo& test_info) { + Send(String::Format("event=TestStart&name=%s\n", test_info.name())); + } + + void OnTestEnd(const TestInfo& test_info) { + Send(String::Format( + "event=TestEnd&passed=%d&elapsed_time=%sms\n", + (test_info.result())->Passed(), + StreamableToString((test_info.result())->elapsed_time()).c_str())); + } + + void OnTestPartResult(const TestPartResult& test_part_result) { + const char* file_name = test_part_result.file_name(); + if (file_name == NULL) + file_name = ""; + Send(String::Format("event=TestPartResult&file=%s&line=%d&message=", + UrlEncode(file_name).c_str(), + test_part_result.line_number())); + Send(UrlEncode(test_part_result.message()) + "\n"); + } + + private: + // Creates a client socket and connects to the server. + void MakeConnection(); + + // Closes the socket. + void CloseConnection() { + GTEST_CHECK_(sockfd_ != -1) + << "CloseConnection() can be called only when there is a connection."; + + close(sockfd_); + sockfd_ = -1; + } + + // Sends a string to the socket. + void Send(const string& message) { + GTEST_CHECK_(sockfd_ != -1) + << "Send() can be called only when there is a connection."; + + const int len = static_cast<int>(message.length()); + if (write(sockfd_, message.c_str(), len) != len) { + GTEST_LOG_(WARNING) + << "stream_result_to: failed to stream to " + << host_name_ << ":" << port_num_; + } + } + + int sockfd_; // socket file descriptor + const string host_name_; + const string port_num_; + + GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamingListener); +}; // class StreamingListener + +// Checks if str contains '=', '&', '%' or '\n' characters. If yes, +// replaces them by "%xx" where xx is their hexadecimal value. For +// example, replaces "=" with "%3D". This algorithm is O(strlen(str)) +// in both time and space -- important as the input str may contain an +// arbitrarily long test failure message and stack trace. +string StreamingListener::UrlEncode(const char* str) { + string result; + result.reserve(strlen(str) + 1); + for (char ch = *str; ch != '\0'; ch = *++str) { + switch (ch) { + case '%': + case '=': + case '&': + case '\n': + result.append(String::Format("%%%02x", static_cast<unsigned char>(ch))); + break; + default: + result.push_back(ch); + break; + } + } + return result; +} + +void StreamingListener::MakeConnection() { + GTEST_CHECK_(sockfd_ == -1) + << "MakeConnection() can't be called when there is already a connection."; + + addrinfo hints; + memset(&hints, 0, sizeof(hints)); + hints.ai_family = AF_UNSPEC; // To allow both IPv4 and IPv6 addresses. + hints.ai_socktype = SOCK_STREAM; + addrinfo* servinfo = NULL; + + // Use the getaddrinfo() to get a linked list of IP addresses for + // the given host name. + const int error_num = getaddrinfo( + host_name_.c_str(), port_num_.c_str(), &hints, &servinfo); + if (error_num != 0) { + GTEST_LOG_(WARNING) << "stream_result_to: getaddrinfo() failed: " + << gai_strerror(error_num); + } + + // Loop through all the results and connect to the first we can. + for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr != NULL; + cur_addr = cur_addr->ai_next) { + sockfd_ = socket( + cur_addr->ai_family, cur_addr->ai_socktype, cur_addr->ai_protocol); + if (sockfd_ != -1) { + // Connect the client socket to the server socket. + if (connect(sockfd_, cur_addr->ai_addr, cur_addr->ai_addrlen) == -1) { + close(sockfd_); + sockfd_ = -1; + } + } + } + + freeaddrinfo(servinfo); // all done with this structure + + if (sockfd_ == -1) { + GTEST_LOG_(WARNING) << "stream_result_to: failed to connect to " + << host_name_ << ":" << port_num_; + } +} + +// End of class Streaming Listener +#endif // GTEST_CAN_STREAM_RESULTS__ + +// Class ScopedTrace + +// Pushes the given source file location and message onto a per-thread +// trace stack maintained by Google Test. +// L < UnitTest::mutex_ +ScopedTrace::ScopedTrace(const char* file, int line, const Message& message) { + TraceInfo trace; + trace.file = file; + trace.line = line; + trace.message = message.GetString(); + + UnitTest::GetInstance()->PushGTestTrace(trace); +} + +// Pops the info pushed by the c'tor. +// L < UnitTest::mutex_ +ScopedTrace::~ScopedTrace() { + UnitTest::GetInstance()->PopGTestTrace(); +} + + +// class OsStackTraceGetter + +// Returns the current OS stack trace as a String. Parameters: +// +// max_depth - the maximum number of stack frames to be included +// in the trace. +// skip_count - the number of top frames to be skipped; doesn't count +// against max_depth. +// +// L < mutex_ +// We use "L < mutex_" to denote that the function may acquire mutex_. +String OsStackTraceGetter::CurrentStackTrace(int, int) { + return String(""); +} + +// L < mutex_ +void OsStackTraceGetter::UponLeavingGTest() { +} + +const char* const +OsStackTraceGetter::kElidedFramesMarker = + "... " GTEST_NAME_ " internal frames ..."; + +} // namespace internal + +// class TestEventListeners + +TestEventListeners::TestEventListeners() + : repeater_(new internal::TestEventRepeater()), + default_result_printer_(NULL), + default_xml_generator_(NULL) { +} + +TestEventListeners::~TestEventListeners() { delete repeater_; } + +// Returns the standard listener responsible for the default console +// output. Can be removed from the listeners list to shut down default +// console output. Note that removing this object from the listener list +// with Release transfers its ownership to the user. +void TestEventListeners::Append(TestEventListener* listener) { + repeater_->Append(listener); +} + +// Removes the given event listener from the list and returns it. It then +// becomes the caller's responsibility to delete the listener. Returns +// NULL if the listener is not found in the list. +TestEventListener* TestEventListeners::Release(TestEventListener* listener) { + if (listener == default_result_printer_) + default_result_printer_ = NULL; + else if (listener == default_xml_generator_) + default_xml_generator_ = NULL; + return repeater_->Release(listener); +} + +// Returns repeater that broadcasts the TestEventListener events to all +// subscribers. +TestEventListener* TestEventListeners::repeater() { return repeater_; } + +// Sets the default_result_printer attribute to the provided listener. +// The listener is also added to the listener list and previous +// default_result_printer is removed from it and deleted. The listener can +// also be NULL in which case it will not be added to the list. Does +// nothing if the previous and the current listener objects are the same. +void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) { + if (default_result_printer_ != listener) { + // It is an error to pass this method a listener that is already in the + // list. + delete Release(default_result_printer_); + default_result_printer_ = listener; + if (listener != NULL) + Append(listener); + } +} + +// Sets the default_xml_generator attribute to the provided listener. The +// listener is also added to the listener list and previous +// default_xml_generator is removed from it and deleted. The listener can +// also be NULL in which case it will not be added to the list. Does +// nothing if the previous and the current listener objects are the same. +void TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) { + if (default_xml_generator_ != listener) { + // It is an error to pass this method a listener that is already in the + // list. + delete Release(default_xml_generator_); + default_xml_generator_ = listener; + if (listener != NULL) + Append(listener); + } +} + +// Controls whether events will be forwarded by the repeater to the +// listeners in the list. +bool TestEventListeners::EventForwardingEnabled() const { + return repeater_->forwarding_enabled(); +} + +void TestEventListeners::SuppressEventForwarding() { + repeater_->set_forwarding_enabled(false); +} + +// class UnitTest + +// Gets the singleton UnitTest object. The first time this method is +// called, a UnitTest object is constructed and returned. Consecutive +// calls will return the same object. +// +// We don't protect this under mutex_ as a user is not supposed to +// call this before main() starts, from which point on the return +// value will never change. +UnitTest * UnitTest::GetInstance() { + // When compiled with MSVC 7.1 in optimized mode, destroying the + // UnitTest object upon exiting the program messes up the exit code, + // causing successful tests to appear failed. We have to use a + // different implementation in this case to bypass the compiler bug. + // This implementation makes the compiler happy, at the cost of + // leaking the UnitTest object. + + // CodeGear C++Builder insists on a public destructor for the + // default implementation. Use this implementation to keep good OO + // design with private destructor. + +#if (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__) + static UnitTest* const instance = new UnitTest; + return instance; +#else + static UnitTest instance; + return &instance; +#endif // (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__) +} + +// Gets the number of successful test cases. +int UnitTest::successful_test_case_count() const { + return impl()->successful_test_case_count(); +} + +// Gets the number of failed test cases. +int UnitTest::failed_test_case_count() const { + return impl()->failed_test_case_count(); +} + +// Gets the number of all test cases. +int UnitTest::total_test_case_count() const { + return impl()->total_test_case_count(); +} + +// Gets the number of all test cases that contain at least one test +// that should run. +int UnitTest::test_case_to_run_count() const { + return impl()->test_case_to_run_count(); +} + +// Gets the number of successful tests. +int UnitTest::successful_test_count() const { + return impl()->successful_test_count(); +} + +// Gets the number of failed tests. +int UnitTest::failed_test_count() const { return impl()->failed_test_count(); } + +// Gets the number of disabled tests. +int UnitTest::disabled_test_count() const { + return impl()->disabled_test_count(); +} + +// Gets the number of all tests. +int UnitTest::total_test_count() const { return impl()->total_test_count(); } + +// Gets the number of tests that should run. +int UnitTest::test_to_run_count() const { return impl()->test_to_run_count(); } + +// Gets the elapsed time, in milliseconds. +internal::TimeInMillis UnitTest::elapsed_time() const { + return impl()->elapsed_time(); +} + +// Returns true iff the unit test passed (i.e. all test cases passed). +bool UnitTest::Passed() const { return impl()->Passed(); } + +// Returns true iff the unit test failed (i.e. some test case failed +// or something outside of all tests failed). +bool UnitTest::Failed() const { return impl()->Failed(); } + +// Gets the i-th test case among all the test cases. i can range from 0 to +// total_test_case_count() - 1. If i is not in that range, returns NULL. +const TestCase* UnitTest::GetTestCase(int i) const { + return impl()->GetTestCase(i); +} + +// Gets the i-th test case among all the test cases. i can range from 0 to +// total_test_case_count() - 1. If i is not in that range, returns NULL. +TestCase* UnitTest::GetMutableTestCase(int i) { + return impl()->GetMutableTestCase(i); +} + +// Returns the list of event listeners that can be used to track events +// inside Google Test. +TestEventListeners& UnitTest::listeners() { + return *impl()->listeners(); +} + +// Registers and returns a global test environment. When a test +// program is run, all global test environments will be set-up in the +// order they were registered. After all tests in the program have +// finished, all global test environments will be torn-down in the +// *reverse* order they were registered. +// +// The UnitTest object takes ownership of the given environment. +// +// We don't protect this under mutex_, as we only support calling it +// from the main thread. +Environment* UnitTest::AddEnvironment(Environment* env) { + if (env == NULL) { + return NULL; + } + + impl_->environments().push_back(env); + return env; +} + +// Adds a TestPartResult to the current TestResult object. All Google Test +// assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) eventually call +// this to report their results. The user code should use the +// assertion macros instead of calling this directly. +// L < mutex_ +void UnitTest::AddTestPartResult(TestPartResult::Type result_type, + const char* file_name, + int line_number, + const internal::String& message, + const internal::String& os_stack_trace) { + Message msg; + msg << message; + + internal::MutexLock lock(&mutex_); + if (impl_->gtest_trace_stack().size() > 0) { + msg << "\n" << GTEST_NAME_ << " trace:"; + + for (int i = static_cast<int>(impl_->gtest_trace_stack().size()); + i > 0; --i) { + const internal::TraceInfo& trace = impl_->gtest_trace_stack()[i - 1]; + msg << "\n" << internal::FormatFileLocation(trace.file, trace.line) + << " " << trace.message; + } + } + + if (os_stack_trace.c_str() != NULL && !os_stack_trace.empty()) { + msg << internal::kStackTraceMarker << os_stack_trace; + } + + const TestPartResult result = + TestPartResult(result_type, file_name, line_number, + msg.GetString().c_str()); + impl_->GetTestPartResultReporterForCurrentThread()-> + ReportTestPartResult(result); + + if (result_type != TestPartResult::kSuccess) { + // gtest_break_on_failure takes precedence over + // gtest_throw_on_failure. This allows a user to set the latter + // in the code (perhaps in order to use Google Test assertions + // with another testing framework) and specify the former on the + // command line for debugging. + if (GTEST_FLAG(break_on_failure)) { +#if GTEST_OS_WINDOWS + // Using DebugBreak on Windows allows gtest to still break into a debugger + // when a failure happens and both the --gtest_break_on_failure and + // the --gtest_catch_exceptions flags are specified. + DebugBreak(); +#else + // Dereference NULL through a volatile pointer to prevent the compiler + // from removing. We use this rather than abort() or __builtin_trap() for + // portability: Symbian doesn't implement abort() well, and some debuggers + // don't correctly trap abort(). + *static_cast<volatile int*>(NULL) = 1; +#endif // GTEST_OS_WINDOWS + } else if (GTEST_FLAG(throw_on_failure)) { +#if GTEST_HAS_EXCEPTIONS + throw GoogleTestFailureException(result); +#else + // We cannot call abort() as it generates a pop-up in debug mode + // that cannot be suppressed in VC 7.1 or below. + exit(1); +#endif + } + } +} + +// Creates and adds a property to the current TestResult. If a property matching +// the supplied value already exists, updates its value instead. +void UnitTest::RecordPropertyForCurrentTest(const char* key, + const char* value) { + const TestProperty test_property(key, value); + impl_->current_test_result()->RecordProperty(test_property); +} + +// Runs all tests in this UnitTest object and prints the result. +// Returns 0 if successful, or 1 otherwise. +// +// We don't protect this under mutex_, as we only support calling it +// from the main thread. +int UnitTest::Run() { + // Captures the value of GTEST_FLAG(catch_exceptions). This value will be + // used for the duration of the program. + impl()->set_catch_exceptions(GTEST_FLAG(catch_exceptions)); + +#if GTEST_HAS_SEH + const bool in_death_test_child_process = + internal::GTEST_FLAG(internal_run_death_test).length() > 0; + + // Either the user wants Google Test to catch exceptions thrown by the + // tests or this is executing in the context of death test child + // process. In either case the user does not want to see pop-up dialogs + // about crashes - they are expected. + if (impl()->catch_exceptions() || in_death_test_child_process) { + +# if !GTEST_OS_WINDOWS_MOBILE + // SetErrorMode doesn't exist on CE. + SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT | + SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX); +# endif // !GTEST_OS_WINDOWS_MOBILE + +# if (defined(_MSC_VER) || GTEST_OS_WINDOWS_MINGW) && !GTEST_OS_WINDOWS_MOBILE + // Death test children can be terminated with _abort(). On Windows, + // _abort() can show a dialog with a warning message. This forces the + // abort message to go to stderr instead. + _set_error_mode(_OUT_TO_STDERR); +# endif + +# if _MSC_VER >= 1400 && !GTEST_OS_WINDOWS_MOBILE + // In the debug version, Visual Studio pops up a separate dialog + // offering a choice to debug the aborted program. We need to suppress + // this dialog or it will pop up for every EXPECT/ASSERT_DEATH statement + // executed. Google Test will notify the user of any unexpected + // failure via stderr. + // + // VC++ doesn't define _set_abort_behavior() prior to the version 8.0. + // Users of prior VC versions shall suffer the agony and pain of + // clicking through the countless debug dialogs. + // TODO(vladl@google.com): find a way to suppress the abort dialog() in the + // debug mode when compiled with VC 7.1 or lower. + if (!GTEST_FLAG(break_on_failure)) + _set_abort_behavior( + 0x0, // Clear the following flags: + _WRITE_ABORT_MSG | _CALL_REPORTFAULT); // pop-up window, core dump. +# endif + + } +#endif // GTEST_HAS_SEH + + return internal::HandleExceptionsInMethodIfSupported( + impl(), + &internal::UnitTestImpl::RunAllTests, + "auxiliary test code (environments or event listeners)") ? 0 : 1; +} + +// Returns the working directory when the first TEST() or TEST_F() was +// executed. +const char* UnitTest::original_working_dir() const { + return impl_->original_working_dir_.c_str(); +} + +// Returns the TestCase object for the test that's currently running, +// or NULL if no test is running. +// L < mutex_ +const TestCase* UnitTest::current_test_case() const { + internal::MutexLock lock(&mutex_); + return impl_->current_test_case(); +} + +// Returns the TestInfo object for the test that's currently running, +// or NULL if no test is running. +// L < mutex_ +const TestInfo* UnitTest::current_test_info() const { + internal::MutexLock lock(&mutex_); + return impl_->current_test_info(); +} + +// Returns the random seed used at the start of the current test run. +int UnitTest::random_seed() const { return impl_->random_seed(); } + +#if GTEST_HAS_PARAM_TEST +// Returns ParameterizedTestCaseRegistry object used to keep track of +// value-parameterized tests and instantiate and register them. +// L < mutex_ +internal::ParameterizedTestCaseRegistry& + UnitTest::parameterized_test_registry() { + return impl_->parameterized_test_registry(); +} +#endif // GTEST_HAS_PARAM_TEST + +// Creates an empty UnitTest. +UnitTest::UnitTest() { + impl_ = new internal::UnitTestImpl(this); +} + +// Destructor of UnitTest. +UnitTest::~UnitTest() { + delete impl_; +} + +// Pushes a trace defined by SCOPED_TRACE() on to the per-thread +// Google Test trace stack. +// L < mutex_ +void UnitTest::PushGTestTrace(const internal::TraceInfo& trace) { + internal::MutexLock lock(&mutex_); + impl_->gtest_trace_stack().push_back(trace); +} + +// Pops a trace from the per-thread Google Test trace stack. +// L < mutex_ +void UnitTest::PopGTestTrace() { + internal::MutexLock lock(&mutex_); + impl_->gtest_trace_stack().pop_back(); +} + +namespace internal { + +UnitTestImpl::UnitTestImpl(UnitTest* parent) + : parent_(parent), +#ifdef _MSC_VER +# pragma warning(push) // Saves the current warning state. +# pragma warning(disable:4355) // Temporarily disables warning 4355 + // (using this in initializer). + default_global_test_part_result_reporter_(this), + default_per_thread_test_part_result_reporter_(this), +# pragma warning(pop) // Restores the warning state again. +#else + default_global_test_part_result_reporter_(this), + default_per_thread_test_part_result_reporter_(this), +#endif // _MSC_VER + global_test_part_result_repoter_( + &default_global_test_part_result_reporter_), + per_thread_test_part_result_reporter_( + &default_per_thread_test_part_result_reporter_), +#if GTEST_HAS_PARAM_TEST + parameterized_test_registry_(), + parameterized_tests_registered_(false), +#endif // GTEST_HAS_PARAM_TEST + last_death_test_case_(-1), + current_test_case_(NULL), + current_test_info_(NULL), + ad_hoc_test_result_(), + os_stack_trace_getter_(NULL), + post_flag_parse_init_performed_(false), + random_seed_(0), // Will be overridden by the flag before first use. + random_(0), // Will be reseeded before first use. + elapsed_time_(0), +#if GTEST_HAS_DEATH_TEST + internal_run_death_test_flag_(NULL), + death_test_factory_(new DefaultDeathTestFactory), +#endif + // Will be overridden by the flag before first use. + catch_exceptions_(false) { + listeners()->SetDefaultResultPrinter(new PrettyUnitTestResultPrinter); +} + +UnitTestImpl::~UnitTestImpl() { + // Deletes every TestCase. + ForEach(test_cases_, internal::Delete<TestCase>); + + // Deletes every Environment. + ForEach(environments_, internal::Delete<Environment>); + + delete os_stack_trace_getter_; +} + +#if GTEST_HAS_DEATH_TEST +// Disables event forwarding if the control is currently in a death test +// subprocess. Must not be called before InitGoogleTest. +void UnitTestImpl::SuppressTestEventsIfInSubprocess() { + if (internal_run_death_test_flag_.get() != NULL) + listeners()->SuppressEventForwarding(); +} +#endif // GTEST_HAS_DEATH_TEST + +// Initializes event listeners performing XML output as specified by +// UnitTestOptions. Must not be called before InitGoogleTest. +void UnitTestImpl::ConfigureXmlOutput() { + const String& output_format = UnitTestOptions::GetOutputFormat(); + if (output_format == "xml") { + listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter( + UnitTestOptions::GetAbsolutePathToOutputFile().c_str())); + } else if (output_format != "") { + printf("WARNING: unrecognized output format \"%s\" ignored.\n", + output_format.c_str()); + fflush(stdout); + } +} + +#if GTEST_CAN_STREAM_RESULTS_ +// Initializes event listeners for streaming test results in String form. +// Must not be called before InitGoogleTest. +void UnitTestImpl::ConfigureStreamingOutput() { + const string& target = GTEST_FLAG(stream_result_to); + if (!target.empty()) { + const size_t pos = target.find(':'); + if (pos != string::npos) { + listeners()->Append(new StreamingListener(target.substr(0, pos), + target.substr(pos+1))); + } else { + printf("WARNING: unrecognized streaming target \"%s\" ignored.\n", + target.c_str()); + fflush(stdout); + } + } +} +#endif // GTEST_CAN_STREAM_RESULTS_ + +// Performs initialization dependent upon flag values obtained in +// ParseGoogleTestFlagsOnly. Is called from InitGoogleTest after the call to +// ParseGoogleTestFlagsOnly. In case a user neglects to call InitGoogleTest +// this function is also called from RunAllTests. Since this function can be +// called more than once, it has to be idempotent. +void UnitTestImpl::PostFlagParsingInit() { + // Ensures that this function does not execute more than once. + if (!post_flag_parse_init_performed_) { + post_flag_parse_init_performed_ = true; + +#if GTEST_HAS_DEATH_TEST + InitDeathTestSubprocessControlInfo(); + SuppressTestEventsIfInSubprocess(); +#endif // GTEST_HAS_DEATH_TEST + + // Registers parameterized tests. This makes parameterized tests + // available to the UnitTest reflection API without running + // RUN_ALL_TESTS. + RegisterParameterizedTests(); + + // Configures listeners for XML output. This makes it possible for users + // to shut down the default XML output before invoking RUN_ALL_TESTS. + ConfigureXmlOutput(); + +#if GTEST_CAN_STREAM_RESULTS_ + // Configures listeners for streaming test results to the specified server. + ConfigureStreamingOutput(); +#endif // GTEST_CAN_STREAM_RESULTS_ + } +} + +// A predicate that checks the name of a TestCase against a known +// value. +// +// This is used for implementation of the UnitTest class only. We put +// it in the anonymous namespace to prevent polluting the outer +// namespace. +// +// TestCaseNameIs is copyable. +class TestCaseNameIs { + public: + // Constructor. + explicit TestCaseNameIs(const String& name) + : name_(name) {} + + // Returns true iff the name of test_case matches name_. + bool operator()(const TestCase* test_case) const { + return test_case != NULL && strcmp(test_case->name(), name_.c_str()) == 0; + } + + private: + String name_; +}; + +// Finds and returns a TestCase with the given name. If one doesn't +// exist, creates one and returns it. It's the CALLER'S +// RESPONSIBILITY to ensure that this function is only called WHEN THE +// TESTS ARE NOT SHUFFLED. +// +// Arguments: +// +// test_case_name: name of the test case +// type_param: the name of the test case's type parameter, or NULL if +// this is not a typed or a type-parameterized test case. +// set_up_tc: pointer to the function that sets up the test case +// tear_down_tc: pointer to the function that tears down the test case +TestCase* UnitTestImpl::GetTestCase(const char* test_case_name, + const char* type_param, + Test::SetUpTestCaseFunc set_up_tc, + Test::TearDownTestCaseFunc tear_down_tc) { + // Can we find a TestCase with the given name? + const std::vector<TestCase*>::const_iterator test_case = + std::find_if(test_cases_.begin(), test_cases_.end(), + TestCaseNameIs(test_case_name)); + + if (test_case != test_cases_.end()) + return *test_case; + + // No. Let's create one. + TestCase* const new_test_case = + new TestCase(test_case_name, type_param, set_up_tc, tear_down_tc); + + // Is this a death test case? + if (internal::UnitTestOptions::MatchesFilter(String(test_case_name), + kDeathTestCaseFilter)) { + // Yes. Inserts the test case after the last death test case + // defined so far. This only works when the test cases haven't + // been shuffled. Otherwise we may end up running a death test + // after a non-death test. + ++last_death_test_case_; + test_cases_.insert(test_cases_.begin() + last_death_test_case_, + new_test_case); + } else { + // No. Appends to the end of the list. + test_cases_.push_back(new_test_case); + } + + test_case_indices_.push_back(static_cast<int>(test_case_indices_.size())); + return new_test_case; +} + +// Helpers for setting up / tearing down the given environment. They +// are for use in the ForEach() function. +static void SetUpEnvironment(Environment* env) { env->SetUp(); } +static void TearDownEnvironment(Environment* env) { env->TearDown(); } + +// Runs all tests in this UnitTest object, prints the result, and +// returns true if all tests are successful. If any exception is +// thrown during a test, the test is considered to be failed, but the +// rest of the tests will still be run. +// +// When parameterized tests are enabled, it expands and registers +// parameterized tests first in RegisterParameterizedTests(). +// All other functions called from RunAllTests() may safely assume that +// parameterized tests are ready to be counted and run. +bool UnitTestImpl::RunAllTests() { + // Makes sure InitGoogleTest() was called. + if (!GTestIsInitialized()) { + printf("%s", + "\nThis test program did NOT call ::testing::InitGoogleTest " + "before calling RUN_ALL_TESTS(). Please fix it.\n"); + return false; + } + + // Do not run any test if the --help flag was specified. + if (g_help_flag) + return true; + + // Repeats the call to the post-flag parsing initialization in case the + // user didn't call InitGoogleTest. + PostFlagParsingInit(); + + // Even if sharding is not on, test runners may want to use the + // GTEST_SHARD_STATUS_FILE to query whether the test supports the sharding + // protocol. + internal::WriteToShardStatusFileIfNeeded(); + + // True iff we are in a subprocess for running a thread-safe-style + // death test. + bool in_subprocess_for_death_test = false; + +#if GTEST_HAS_DEATH_TEST + in_subprocess_for_death_test = (internal_run_death_test_flag_.get() != NULL); +#endif // GTEST_HAS_DEATH_TEST + + const bool should_shard = ShouldShard(kTestTotalShards, kTestShardIndex, + in_subprocess_for_death_test); + + // Compares the full test names with the filter to decide which + // tests to run. + const bool has_tests_to_run = FilterTests(should_shard + ? HONOR_SHARDING_PROTOCOL + : IGNORE_SHARDING_PROTOCOL) > 0; + + // Lists the tests and exits if the --gtest_list_tests flag was specified. + if (GTEST_FLAG(list_tests)) { + // This must be called *after* FilterTests() has been called. + ListTestsMatchingFilter(); + return true; + } + + random_seed_ = GTEST_FLAG(shuffle) ? + GetRandomSeedFromFlag(GTEST_FLAG(random_seed)) : 0; + + // True iff at least one test has failed. + bool failed = false; + + TestEventListener* repeater = listeners()->repeater(); + + repeater->OnTestProgramStart(*parent_); + + // How many times to repeat the tests? We don't want to repeat them + // when we are inside the subprocess of a death test. + const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG(repeat); + // Repeats forever if the repeat count is negative. + const bool forever = repeat < 0; + for (int i = 0; forever || i != repeat; i++) { + // We want to preserve failures generated by ad-hoc test + // assertions executed before RUN_ALL_TESTS(). + ClearNonAdHocTestResult(); + + const TimeInMillis start = GetTimeInMillis(); + + // Shuffles test cases and tests if requested. + if (has_tests_to_run && GTEST_FLAG(shuffle)) { + random()->Reseed(random_seed_); + // This should be done before calling OnTestIterationStart(), + // such that a test event listener can see the actual test order + // in the event. + ShuffleTests(); + } + + // Tells the unit test event listeners that the tests are about to start. + repeater->OnTestIterationStart(*parent_, i); + + // Runs each test case if there is at least one test to run. + if (has_tests_to_run) { + // Sets up all environments beforehand. + repeater->OnEnvironmentsSetUpStart(*parent_); + ForEach(environments_, SetUpEnvironment); + repeater->OnEnvironmentsSetUpEnd(*parent_); + + // Runs the tests only if there was no fatal failure during global + // set-up. + if (!Test::HasFatalFailure()) { + for (int test_index = 0; test_index < total_test_case_count(); + test_index++) { + GetMutableTestCase(test_index)->Run(); + } + } + + // Tears down all environments in reverse order afterwards. + repeater->OnEnvironmentsTearDownStart(*parent_); + std::for_each(environments_.rbegin(), environments_.rend(), + TearDownEnvironment); + repeater->OnEnvironmentsTearDownEnd(*parent_); + } + + elapsed_time_ = GetTimeInMillis() - start; + + // Tells the unit test event listener that the tests have just finished. + repeater->OnTestIterationEnd(*parent_, i); + + // Gets the result and clears it. + if (!Passed()) { + failed = true; + } + + // Restores the original test order after the iteration. This + // allows the user to quickly repro a failure that happens in the + // N-th iteration without repeating the first (N - 1) iterations. + // This is not enclosed in "if (GTEST_FLAG(shuffle)) { ... }", in + // case the user somehow changes the value of the flag somewhere + // (it's always safe to unshuffle the tests). + UnshuffleTests(); + + if (GTEST_FLAG(shuffle)) { + // Picks a new random seed for each iteration. + random_seed_ = GetNextRandomSeed(random_seed_); + } + } + + repeater->OnTestProgramEnd(*parent_); + + return !failed; +} + +// Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file +// if the variable is present. If a file already exists at this location, this +// function will write over it. If the variable is present, but the file cannot +// be created, prints an error and exits. +void WriteToShardStatusFileIfNeeded() { + const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile); + if (test_shard_file != NULL) { + FILE* const file = posix::FOpen(test_shard_file, "w"); + if (file == NULL) { + ColoredPrintf(COLOR_RED, + "Could not write to the test shard status file \"%s\" " + "specified by the %s environment variable.\n", + test_shard_file, kTestShardStatusFile); + fflush(stdout); + exit(EXIT_FAILURE); + } + fclose(file); + } +} + +// Checks whether sharding is enabled by examining the relevant +// environment variable values. If the variables are present, +// but inconsistent (i.e., shard_index >= total_shards), prints +// an error and exits. If in_subprocess_for_death_test, sharding is +// disabled because it must only be applied to the original test +// process. Otherwise, we could filter out death tests we intended to execute. +bool ShouldShard(const char* total_shards_env, + const char* shard_index_env, + bool in_subprocess_for_death_test) { + if (in_subprocess_for_death_test) { + return false; + } + + const Int32 total_shards = Int32FromEnvOrDie(total_shards_env, -1); + const Int32 shard_index = Int32FromEnvOrDie(shard_index_env, -1); + + if (total_shards == -1 && shard_index == -1) { + return false; + } else if (total_shards == -1 && shard_index != -1) { + const Message msg = Message() + << "Invalid environment variables: you have " + << kTestShardIndex << " = " << shard_index + << ", but have left " << kTestTotalShards << " unset.\n"; + ColoredPrintf(COLOR_RED, msg.GetString().c_str()); + fflush(stdout); + exit(EXIT_FAILURE); + } else if (total_shards != -1 && shard_index == -1) { + const Message msg = Message() + << "Invalid environment variables: you have " + << kTestTotalShards << " = " << total_shards + << ", but have left " << kTestShardIndex << " unset.\n"; + ColoredPrintf(COLOR_RED, msg.GetString().c_str()); + fflush(stdout); + exit(EXIT_FAILURE); + } else if (shard_index < 0 || shard_index >= total_shards) { + const Message msg = Message() + << "Invalid environment variables: we require 0 <= " + << kTestShardIndex << " < " << kTestTotalShards + << ", but you have " << kTestShardIndex << "=" << shard_index + << ", " << kTestTotalShards << "=" << total_shards << ".\n"; + ColoredPrintf(COLOR_RED, msg.GetString().c_str()); + fflush(stdout); + exit(EXIT_FAILURE); + } + + return total_shards > 1; +} + +// Parses the environment variable var as an Int32. If it is unset, +// returns default_val. If it is not an Int32, prints an error +// and aborts. +Int32 Int32FromEnvOrDie(const char* var, Int32 default_val) { + const char* str_val = posix::GetEnv(var); + if (str_val == NULL) { + return default_val; + } + + Int32 result; + if (!ParseInt32(Message() << "The value of environment variable " << var, + str_val, &result)) { + exit(EXIT_FAILURE); + } + return result; +} + +// Given the total number of shards, the shard index, and the test id, +// returns true iff the test should be run on this shard. The test id is +// some arbitrary but unique non-negative integer assigned to each test +// method. Assumes that 0 <= shard_index < total_shards. +bool ShouldRunTestOnShard(int total_shards, int shard_index, int test_id) { + return (test_id % total_shards) == shard_index; +} + +// Compares the name of each test with the user-specified filter to +// decide whether the test should be run, then records the result in +// each TestCase and TestInfo object. +// If shard_tests == true, further filters tests based on sharding +// variables in the environment - see +// http://code.google.com/p/googletest/wiki/GoogleTestAdvancedGuide. +// Returns the number of tests that should run. +int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) { + const Int32 total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ? + Int32FromEnvOrDie(kTestTotalShards, -1) : -1; + const Int32 shard_index = shard_tests == HONOR_SHARDING_PROTOCOL ? + Int32FromEnvOrDie(kTestShardIndex, -1) : -1; + + // num_runnable_tests are the number of tests that will + // run across all shards (i.e., match filter and are not disabled). + // num_selected_tests are the number of tests to be run on + // this shard. + int num_runnable_tests = 0; + int num_selected_tests = 0; + for (size_t i = 0; i < test_cases_.size(); i++) { + TestCase* const test_case = test_cases_[i]; + const String &test_case_name = test_case->name(); + test_case->set_should_run(false); + + bool any_matched_filter = false; + + for (size_t j = 0; j < test_case->test_info_list().size(); j++) { + TestInfo* const test_info = test_case->test_info_list()[j]; + const String test_name(test_info->name()); + // A test is disabled if test case name or test name matches + // kDisableTestFilter. + const bool is_disabled = + internal::UnitTestOptions::MatchesFilter(test_case_name, + kDisableTestFilter) || + internal::UnitTestOptions::MatchesFilter(test_name, + kDisableTestFilter); + test_info->is_disabled_ = is_disabled; + + const bool matches_filter = + internal::UnitTestOptions::FilterMatchesTest(test_case_name, + test_name); + test_info->matches_filter_ = matches_filter; + any_matched_filter |= matches_filter; + + const bool is_runnable = + (GTEST_FLAG(also_run_disabled_tests) || !is_disabled) && + matches_filter; + + const bool is_selected = is_runnable && + (shard_tests == IGNORE_SHARDING_PROTOCOL || + ShouldRunTestOnShard(total_shards, shard_index, + num_runnable_tests)); + + num_runnable_tests += is_runnable; + num_selected_tests += is_selected; + + test_info->should_run_ = is_selected; + test_case->set_should_run(test_case->should_run() || is_selected); + } + + test_case->set_should_skip_report(!any_matched_filter); + } + return num_selected_tests; +} + +// Prints the names of the tests matching the user-specified filter flag. +void UnitTestImpl::ListTestsMatchingFilter() { + for (size_t i = 0; i < test_cases_.size(); i++) { + const TestCase* const test_case = test_cases_[i]; + bool printed_test_case_name = false; + + for (size_t j = 0; j < test_case->test_info_list().size(); j++) { + const TestInfo* const test_info = + test_case->test_info_list()[j]; + if (test_info->matches_filter_) { + if (!printed_test_case_name) { + printed_test_case_name = true; + printf("%s.\n", test_case->name()); + } + printf(" %s\n", test_info->name()); + } + } + } + fflush(stdout); +} + +// Sets the OS stack trace getter. +// +// Does nothing if the input and the current OS stack trace getter are +// the same; otherwise, deletes the old getter and makes the input the +// current getter. +void UnitTestImpl::set_os_stack_trace_getter( + OsStackTraceGetterInterface* getter) { + if (os_stack_trace_getter_ != getter) { + delete os_stack_trace_getter_; + os_stack_trace_getter_ = getter; + } +} + +// Returns the current OS stack trace getter if it is not NULL; +// otherwise, creates an OsStackTraceGetter, makes it the current +// getter, and returns it. +OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() { + if (os_stack_trace_getter_ == NULL) { + os_stack_trace_getter_ = new OsStackTraceGetter; + } + + return os_stack_trace_getter_; +} + +// Returns the TestResult for the test that's currently running, or +// the TestResult for the ad hoc test if no test is running. +TestResult* UnitTestImpl::current_test_result() { + return current_test_info_ ? + &(current_test_info_->result_) : &ad_hoc_test_result_; +} + +// Shuffles all test cases, and the tests within each test case, +// making sure that death tests are still run first. +void UnitTestImpl::ShuffleTests() { + // Shuffles the death test cases. + ShuffleRange(random(), 0, last_death_test_case_ + 1, &test_case_indices_); + + // Shuffles the non-death test cases. + ShuffleRange(random(), last_death_test_case_ + 1, + static_cast<int>(test_cases_.size()), &test_case_indices_); + + // Shuffles the tests inside each test case. + for (size_t i = 0; i < test_cases_.size(); i++) { + test_cases_[i]->ShuffleTests(random()); + } +} + +// Restores the test cases and tests to their order before the first shuffle. +void UnitTestImpl::UnshuffleTests() { + for (size_t i = 0; i < test_cases_.size(); i++) { + // Unshuffles the tests in each test case. + test_cases_[i]->UnshuffleTests(); + // Resets the index of each test case. + test_case_indices_[i] = static_cast<int>(i); + } +} + +// Returns the current OS stack trace as a String. +// +// The maximum number of stack frames to be included is specified by +// the gtest_stack_trace_depth flag. The skip_count parameter +// specifies the number of top frames to be skipped, which doesn't +// count against the number of frames to be included. +// +// For example, if Foo() calls Bar(), which in turn calls +// GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in +// the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't. +String GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/, + int skip_count) { + // We pass skip_count + 1 to skip this wrapper function in addition + // to what the user really wants to skip. + return GetUnitTestImpl()->CurrentOsStackTraceExceptTop(skip_count + 1); +} + +// Used by the GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_ macro to +// suppress unreachable code warnings. +namespace { +class ClassUniqueToAlwaysTrue {}; +} + +bool IsTrue(bool condition) { return condition; } + +bool AlwaysTrue() { +#if GTEST_HAS_EXCEPTIONS + // This condition is always false so AlwaysTrue() never actually throws, + // but it makes the compiler think that it may throw. + if (IsTrue(false)) + throw ClassUniqueToAlwaysTrue(); +#endif // GTEST_HAS_EXCEPTIONS + return true; +} + +// If *pstr starts with the given prefix, modifies *pstr to be right +// past the prefix and returns true; otherwise leaves *pstr unchanged +// and returns false. None of pstr, *pstr, and prefix can be NULL. +bool SkipPrefix(const char* prefix, const char** pstr) { + const size_t prefix_len = strlen(prefix); + if (strncmp(*pstr, prefix, prefix_len) == 0) { + *pstr += prefix_len; + return true; + } + return false; +} + +// Parses a string as a command line flag. The string should have +// the format "--flag=value". When def_optional is true, the "=value" +// part can be omitted. +// +// Returns the value of the flag, or NULL if the parsing failed. +const char* ParseFlagValue(const char* str, + const char* flag, + bool def_optional) { + // str and flag must not be NULL. + if (str == NULL || flag == NULL) return NULL; + + // The flag must start with "--" followed by GTEST_FLAG_PREFIX_. + const String flag_str = String::Format("--%s%s", GTEST_FLAG_PREFIX_, flag); + const size_t flag_len = flag_str.length(); + if (strncmp(str, flag_str.c_str(), flag_len) != 0) return NULL; + + // Skips the flag name. + const char* flag_end = str + flag_len; + + // When def_optional is true, it's OK to not have a "=value" part. + if (def_optional && (flag_end[0] == '\0')) { + return flag_end; + } + + // If def_optional is true and there are more characters after the + // flag name, or if def_optional is false, there must be a '=' after + // the flag name. + if (flag_end[0] != '=') return NULL; + + // Returns the string after "=". + return flag_end + 1; +} + +// Parses a string for a bool flag, in the form of either +// "--flag=value" or "--flag". +// +// In the former case, the value is taken as true as long as it does +// not start with '0', 'f', or 'F'. +// +// In the latter case, the value is taken as true. +// +// On success, stores the value of the flag in *value, and returns +// true. On failure, returns false without changing *value. +bool ParseBoolFlag(const char* str, const char* flag, bool* value) { + // Gets the value of the flag as a string. + const char* const value_str = ParseFlagValue(str, flag, true); + + // Aborts if the parsing failed. + if (value_str == NULL) return false; + + // Converts the string value to a bool. + *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F'); + return true; +} + +// Parses a string for an Int32 flag, in the form of +// "--flag=value". +// +// On success, stores the value of the flag in *value, and returns +// true. On failure, returns false without changing *value. +bool ParseInt32Flag(const char* str, const char* flag, Int32* value) { + // Gets the value of the flag as a string. + const char* const value_str = ParseFlagValue(str, flag, false); + + // Aborts if the parsing failed. + if (value_str == NULL) return false; + + // Sets *value to the value of the flag. + return ParseInt32(Message() << "The value of flag --" << flag, + value_str, value); +} + +// Parses a string for a string flag, in the form of +// "--flag=value". +// +// On success, stores the value of the flag in *value, and returns +// true. On failure, returns false without changing *value. +bool ParseStringFlag(const char* str, const char* flag, String* value) { + // Gets the value of the flag as a string. + const char* const value_str = ParseFlagValue(str, flag, false); + + // Aborts if the parsing failed. + if (value_str == NULL) return false; + + // Sets *value to the value of the flag. + *value = value_str; + return true; +} + +// Determines whether a string has a prefix that Google Test uses for its +// flags, i.e., starts with GTEST_FLAG_PREFIX_ or GTEST_FLAG_PREFIX_DASH_. +// If Google Test detects that a command line flag has its prefix but is not +// recognized, it will print its help message. Flags starting with +// GTEST_INTERNAL_PREFIX_ followed by "internal_" are considered Google Test +// internal flags and do not trigger the help message. +static bool HasGoogleTestFlagPrefix(const char* str) { + return (SkipPrefix("--", &str) || + SkipPrefix("-", &str) || + SkipPrefix("/", &str)) && + !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) && + (SkipPrefix(GTEST_FLAG_PREFIX_, &str) || + SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str)); +} + +// Prints a string containing code-encoded text. The following escape +// sequences can be used in the string to control the text color: +// +// @@ prints a single '@' character. +// @R changes the color to red. +// @G changes the color to green. +// @Y changes the color to yellow. +// @D changes to the default terminal text color. +// +// TODO(wan@google.com): Write tests for this once we add stdout +// capturing to Google Test. +static void PrintColorEncoded(const char* str) { + GTestColor color = COLOR_DEFAULT; // The current color. + + // Conceptually, we split the string into segments divided by escape + // sequences. Then we print one segment at a time. At the end of + // each iteration, the str pointer advances to the beginning of the + // next segment. + for (;;) { + const char* p = strchr(str, '@'); + if (p == NULL) { + ColoredPrintf(color, "%s", str); + return; + } + + ColoredPrintf(color, "%s", String(str, p - str).c_str()); + + const char ch = p[1]; + str = p + 2; + if (ch == '@') { + ColoredPrintf(color, "@"); + } else if (ch == 'D') { + color = COLOR_DEFAULT; + } else if (ch == 'R') { + color = COLOR_RED; + } else if (ch == 'G') { + color = COLOR_GREEN; + } else if (ch == 'Y') { + color = COLOR_YELLOW; + } else { + --str; + } + } +} + +static const char kColorEncodedHelpMessage[] = +"This program contains tests written using " GTEST_NAME_ ". You can use the\n" +"following command line flags to control its behavior:\n" +"\n" +"Test Selection:\n" +" @G--" GTEST_FLAG_PREFIX_ "list_tests@D\n" +" List the names of all tests instead of running them. The name of\n" +" TEST(Foo, Bar) is \"Foo.Bar\".\n" +" @G--" GTEST_FLAG_PREFIX_ "filter=@YPOSTIVE_PATTERNS" + "[@G-@YNEGATIVE_PATTERNS]@D\n" +" Run only the tests whose name matches one of the positive patterns but\n" +" none of the negative patterns. '?' matches any single character; '*'\n" +" matches any substring; ':' separates two patterns.\n" +" @G--" GTEST_FLAG_PREFIX_ "also_run_disabled_tests@D\n" +" Run all disabled tests too.\n" +"\n" +"Test Execution:\n" +" @G--" GTEST_FLAG_PREFIX_ "repeat=@Y[COUNT]@D\n" +" Run the tests repeatedly; use a negative count to repeat forever.\n" +" @G--" GTEST_FLAG_PREFIX_ "shuffle@D\n" +" Randomize tests' orders on every iteration.\n" +" @G--" GTEST_FLAG_PREFIX_ "random_seed=@Y[NUMBER]@D\n" +" Random number seed to use for shuffling test orders (between 1 and\n" +" 99999, or 0 to use a seed based on the current time).\n" +"\n" +"Test Output:\n" +" @G--" GTEST_FLAG_PREFIX_ "color=@Y(@Gyes@Y|@Gno@Y|@Gauto@Y)@D\n" +" Enable/disable colored output. The default is @Gauto@D.\n" +" -@G-" GTEST_FLAG_PREFIX_ "print_time=0@D\n" +" Don't print the elapsed time of each test.\n" +" @G--" GTEST_FLAG_PREFIX_ "output=xml@Y[@G:@YDIRECTORY_PATH@G" + GTEST_PATH_SEP_ "@Y|@G:@YFILE_PATH]@D\n" +" Generate an XML report in the given directory or with the given file\n" +" name. @YFILE_PATH@D defaults to @Gtest_details.xml@D.\n" +#if GTEST_CAN_STREAM_RESULTS_ +" @G--" GTEST_FLAG_PREFIX_ "stream_result_to=@YHOST@G:@YPORT@D\n" +" Stream test results to the given server.\n" +#endif // GTEST_CAN_STREAM_RESULTS_ +"\n" +"Assertion Behavior:\n" +#if GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS +" @G--" GTEST_FLAG_PREFIX_ "death_test_style=@Y(@Gfast@Y|@Gthreadsafe@Y)@D\n" +" Set the default death test style.\n" +#endif // GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS +" @G--" GTEST_FLAG_PREFIX_ "break_on_failure@D\n" +" Turn assertion failures into debugger break-points.\n" +" @G--" GTEST_FLAG_PREFIX_ "throw_on_failure@D\n" +" Turn assertion failures into C++ exceptions.\n" +" @G--" GTEST_FLAG_PREFIX_ "catch_exceptions=0@D\n" +" Do not report exceptions as test failures. Instead, allow them\n" +" to crash the program or throw a pop-up (on Windows).\n" +"\n" +"Except for @G--" GTEST_FLAG_PREFIX_ "list_tests@D, you can alternatively set " + "the corresponding\n" +"environment variable of a flag (all letters in upper-case). For example, to\n" +"disable colored text output, you can either specify @G--" GTEST_FLAG_PREFIX_ + "color=no@D or set\n" +"the @G" GTEST_FLAG_PREFIX_UPPER_ "COLOR@D environment variable to @Gno@D.\n" +"\n" +"For more information, please read the " GTEST_NAME_ " documentation at\n" +"@G" GTEST_PROJECT_URL_ "@D. If you find a bug in " GTEST_NAME_ "\n" +"(not one in your own code or tests), please report it to\n" +"@G<" GTEST_DEV_EMAIL_ ">@D.\n"; + +// Parses the command line for Google Test flags, without initializing +// other parts of Google Test. The type parameter CharType can be +// instantiated to either char or wchar_t. +template <typename CharType> +void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) { + for (int i = 1; i < *argc; i++) { + const String arg_string = StreamableToString(argv[i]); + const char* const arg = arg_string.c_str(); + + using internal::ParseBoolFlag; + using internal::ParseInt32Flag; + using internal::ParseStringFlag; + + // Do we see a Google Test flag? + if (ParseBoolFlag(arg, kAlsoRunDisabledTestsFlag, + >EST_FLAG(also_run_disabled_tests)) || + ParseBoolFlag(arg, kBreakOnFailureFlag, + >EST_FLAG(break_on_failure)) || + ParseBoolFlag(arg, kCatchExceptionsFlag, + >EST_FLAG(catch_exceptions)) || + ParseStringFlag(arg, kColorFlag, >EST_FLAG(color)) || + ParseStringFlag(arg, kDeathTestStyleFlag, + >EST_FLAG(death_test_style)) || + ParseBoolFlag(arg, kDeathTestUseFork, + >EST_FLAG(death_test_use_fork)) || + ParseStringFlag(arg, kFilterFlag, >EST_FLAG(filter)) || + ParseStringFlag(arg, kInternalRunDeathTestFlag, + >EST_FLAG(internal_run_death_test)) || + ParseBoolFlag(arg, kListTestsFlag, >EST_FLAG(list_tests)) || + ParseStringFlag(arg, kOutputFlag, >EST_FLAG(output)) || + ParseBoolFlag(arg, kPrintTimeFlag, >EST_FLAG(print_time)) || + ParseInt32Flag(arg, kRandomSeedFlag, >EST_FLAG(random_seed)) || + ParseInt32Flag(arg, kRepeatFlag, >EST_FLAG(repeat)) || + ParseBoolFlag(arg, kShuffleFlag, >EST_FLAG(shuffle)) || + ParseInt32Flag(arg, kStackTraceDepthFlag, + >EST_FLAG(stack_trace_depth)) || + ParseStringFlag(arg, kStreamResultToFlag, + >EST_FLAG(stream_result_to)) || + ParseBoolFlag(arg, kThrowOnFailureFlag, + >EST_FLAG(throw_on_failure)) + ) { + // Yes. Shift the remainder of the argv list left by one. Note + // that argv has (*argc + 1) elements, the last one always being + // NULL. The following loop moves the trailing NULL element as + // well. + for (int j = i; j != *argc; j++) { + argv[j] = argv[j + 1]; + } + + // Decrements the argument count. + (*argc)--; + + // We also need to decrement the iterator as we just removed + // an element. + i--; + } else if (arg_string == "--help" || arg_string == "-h" || + arg_string == "-?" || arg_string == "/?" || + HasGoogleTestFlagPrefix(arg)) { + // Both help flag and unrecognized Google Test flags (excluding + // internal ones) trigger help display. + g_help_flag = true; + } + } + + if (g_help_flag) { + // We print the help here instead of in RUN_ALL_TESTS(), as the + // latter may not be called at all if the user is using Google + // Test with another testing framework. + PrintColorEncoded(kColorEncodedHelpMessage); + } +} + +// Parses the command line for Google Test flags, without initializing +// other parts of Google Test. +void ParseGoogleTestFlagsOnly(int* argc, char** argv) { + ParseGoogleTestFlagsOnlyImpl(argc, argv); +} +void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) { + ParseGoogleTestFlagsOnlyImpl(argc, argv); +} + +// The internal implementation of InitGoogleTest(). +// +// The type parameter CharType can be instantiated to either char or +// wchar_t. +template <typename CharType> +void InitGoogleTestImpl(int* argc, CharType** argv) { + g_init_gtest_count++; + + // We don't want to run the initialization code twice. + if (g_init_gtest_count != 1) return; + + if (*argc <= 0) return; + + internal::g_executable_path = internal::StreamableToString(argv[0]); + +#if GTEST_HAS_DEATH_TEST + + g_argvs.clear(); + for (int i = 0; i != *argc; i++) { + g_argvs.push_back(StreamableToString(argv[i])); + } + +#endif // GTEST_HAS_DEATH_TEST + + ParseGoogleTestFlagsOnly(argc, argv); + GetUnitTestImpl()->PostFlagParsingInit(); +} + +} // namespace internal + +// Initializes Google Test. This must be called before calling +// RUN_ALL_TESTS(). In particular, it parses a command line for the +// flags that Google Test recognizes. Whenever a Google Test flag is +// seen, it is removed from argv, and *argc is decremented. +// +// No value is returned. Instead, the Google Test flag variables are +// updated. +// +// Calling the function for the second time has no user-visible effect. +void InitGoogleTest(int* argc, char** argv) { + internal::InitGoogleTestImpl(argc, argv); +} + +// This overloaded version can be used in Windows programs compiled in +// UNICODE mode. +void InitGoogleTest(int* argc, wchar_t** argv) { + internal::InitGoogleTestImpl(argc, argv); +} + +} // namespace testing diff --git a/tests/gtest/src/gtest_main.cc b/tests/gtest/src/gtest_main.cc new file mode 100644 index 000000000..a09bbe0c6 --- /dev/null +++ b/tests/gtest/src/gtest_main.cc @@ -0,0 +1,39 @@ +// Copyright 2006, Google Inc. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +#include <iostream> + +#include "gtest/gtest.h" + +GTEST_API_ int main(int argc, char **argv) { + std::cout << "Running main() from gtest_main.cc\n"; + + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} diff --git a/tests/hash-target.cpp b/tests/hash-target.cpp new file mode 100644 index 000000000..208bb04a8 --- /dev/null +++ b/tests/hash-target.cpp @@ -0,0 +1,60 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include <cstdint> +#include <cstdlib> +#include <cstring> +#include <limits> +#include "crypto/hash.h" +#include "cryptonote_core/difficulty.h" + +using namespace std; +using cryptonote::check_hash; + +int main(int argc, char *argv[]) { + crypto::hash h; + for (uint64_t diff = 1;; diff += 1 + (diff >> 8)) { + for (int b = 0; b < 256; b++) { + memset(&h, b, sizeof(crypto::hash)); + if (check_hash(h, diff) != (b == 0 || diff <= 255 / b)) { + return 1; + } + if (b > 0) { + memset(&h, 0, sizeof(crypto::hash)); + ((char *) &h)[31] = b; + if (check_hash(h, diff) != (diff <= 255 / b)) { + return 1; + } + } + } + if (diff < numeric_limits<uint64_t>::max() / 256) { + uint64_t val = 0; + for (int i = 31; i >= 0; i--) { + val = val * 256 + 255; + ((char *) &h)[i] = static_cast<char>(val / diff); + val %= diff; + } + if (check_hash(h, diff) != true) { + return 1; + } + if (diff > 1) { + for (int i = 0;; i++) { + if (i >= 32) { + abort(); + } + if (++((char *) &h)[i] != 0) { + break; + } + } + if (check_hash(h, diff) != false) { + return 1; + } + } + } + if (diff + 1 + (diff >> 8) < diff) { + break; + } + } + return 0; +} diff --git a/tests/hash/main.cpp b/tests/hash/main.cpp new file mode 100644 index 000000000..6c898c9fc --- /dev/null +++ b/tests/hash/main.cpp @@ -0,0 +1,96 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include <cstddef> +#include <fstream> +#include <iomanip> +#include <ios> +#include <string> + +#include "warnings.h" +#include "crypto/hash.h" +#include "../io.h" + +using namespace std; +using namespace crypto; +typedef crypto::hash chash; + +PUSH_WARNINGS +DISABLE_VS_WARNINGS(4297) +extern "C" { + static void hash_tree(const void *data, size_t length, char *hash) { + if ((length & 31) != 0) { + throw ios_base::failure("Invalid input length for tree_hash"); + } + tree_hash((const char (*)[32]) data, length >> 5, hash); + } +} +POP_WARNINGS + +extern "C" typedef void hash_f(const void *, size_t, char *); +struct hash_func { + const string name; + hash_f &f; +} hashes[] = {{"fast", cn_fast_hash}, {"slow", cn_slow_hash}, {"tree", hash_tree}, + {"extra-blake", hash_extra_blake}, {"extra-groestl", hash_extra_groestl}, + {"extra-jh", hash_extra_jh}, {"extra-skein", hash_extra_skein}}; + +int main(int argc, char *argv[]) { + hash_f *f; + hash_func *hf; + fstream input; + vector<char> data; + chash expected, actual; + size_t test = 0; + bool error = false; + if (argc != 3) { + cerr << "Wrong number of arguments" << endl; + return 1; + } + for (hf = hashes;; hf++) { + if (hf >= &hashes[sizeof(hashes) / sizeof(hash_func)]) { + cerr << "Unknown function" << endl; + return 1; + } + if (argv[1] == hf->name) { + f = &hf->f; + break; + } + } + input.open(argv[2], ios_base::in); + for (;;) { + ++test; + input.exceptions(ios_base::badbit); + get(input, expected); + if (input.rdstate() & ios_base::eofbit) { + break; + } + input.exceptions(ios_base::badbit | ios_base::failbit | ios_base::eofbit); + input.clear(input.rdstate()); + get(input, data); + f(data.data(), data.size(), (char *) &actual); + if (expected != actual) { + size_t i; + cerr << "Hash mismatch on test " << test << endl << "Input: "; + if (data.size() == 0) { + cerr << "empty"; + } else { + for (i = 0; i < data.size(); i++) { + cerr << setbase(16) << setw(2) << setfill('0') << int(static_cast<unsigned char>(data[i])); + } + } + cerr << endl << "Expected hash: "; + for (i = 0; i < 32; i++) { + cerr << setbase(16) << setw(2) << setfill('0') << int(reinterpret_cast<unsigned char *>(&expected)[i]); + } + cerr << endl << "Actual hash: "; + for (i = 0; i < 32; i++) { + cerr << setbase(16) << setw(2) << setfill('0') << int(reinterpret_cast<unsigned char *>(&actual)[i]); + } + cerr << endl; + error = true; + } + } + return error ? 1 : 0; +} diff --git a/tests/hash/tests-extra-blake.txt b/tests/hash/tests-extra-blake.txt new file mode 100644 index 000000000..537517c01 --- /dev/null +++ b/tests/hash/tests-extra-blake.txt @@ -0,0 +1,321 @@ +716f6e863f744b9ac22c97ec7b76ea5f5908bc5b2f67c61510bfc4751384ea7a x +e104256a2bc501f459d03fac96b9014f593e22d30f4de525fa680c3aa189eb4f cc +8f341148be7e354fdf38b693d8c6b4e0bd57301a734f6fd35cd85b8491c3ddcd 41fb +bc334d1069099f10c601883ac6f3e7e9787c6aa53171f76a21923cc5ad3ab937 1f877c +b672a16f53982bab1e77685b71c0a5f6703ffd46a1c834be69f614bd128d658e c1ecfdfc +d9134b2899057a7d8d320cc99e3e116982bc99d3c69d260a7f1ed3da8be68d99 21f134ac57 +637923bd29a35aa3ecbbd2a50549fc32c14cf0fdcaf41c3194dd7414fd224815 c6f50bb74e29 +70c092fd5c8c21e9ef4bbc82a5c7819e262a530a748caf285ff0cba891954f1e 119713cc83eeef +fdf092993edbb7a0dc7ca67f04051bbd14481639da0808947aff8bfab5abed4b 4a4f202484512526 +6f6fc234bf35beae1a366c44c520c59ad5aa70351b5f5085e21e1fe2bfcee709 1f66ab4185ed9b6375 +4fdaf89e2a0e78c000061b59455e0ea93a4445b440e7562c8f0cfa165c93de2e eed7422227613b6f53c9 +d6b780eee9c811f664393dc2c58b5a68c92b3c9fe9ceb70371d33ece63b5787e eaeed5cdffd89dece455f1 +d0015071d3e7ed048c764850d76406eceae52b8e2e6e5a2c3aa92ae880485b34 5be43c90f22902e4fe8ed2d3 +9b0207902f9932f7a85c24722e93e31f6ed2c75c406509aa0f2f6d1cab046ce4 a746273228122f381c3b46e4f1 +258020d5b04a814f2b72c1c661e1f5a5c395d9799e5eee8b8519cf7300e90cb1 3c5871cd619c69a63b540eb5a625 +4adae3b55baa907fefc253365fdd99d8398befd0551ed6bf9a2a2784d3c304d1 fa22874bcc068879e8ef11a69f0722 +6dd10d772f8d5b4a96c3c5d30878cd9a1073fa835bfe6d2b924fa64a1fab1711 52a608ab21ccdd8a4457a57ede782176 +0b8741ddf2259d3af2901eb1ae354f22836442c965556f5c1eb89501191cb46a 82e192e4043ddcd12ecf52969d0f807eed +f48a754ca8193a82643150ab94038b5dd170b4ebd1e0751b78cfb0a98fa5076a 75683dcb556140c522543bb6e9098b21a21e +5698409ab856b74d9fa5e9b259dfa46001f89041752da424e56e491577b88c86 06e4efe45035e61faaf4287b4d8d1f12ca97e5 +31d27842634441f452ef6f7319e43c864f9543f04c8dee0bdf02632d20afc2a6 e26193989d06568fe688e75540aea06747d9f851 +924c3797a6d97bc2dcbe905e3922b12f4c97bfd1390056678918284da530b37f d8dc8fdefbdce9d44e4cbafe78447bae3b5436102a +3e5dc9922f82da4b51d2bb202962977fc17546b901335c7ef4e074e8e6b6fadb 57085fd7e14216ab102d8317b0cb338a786d5fc32d8f +efdce9ccc566aa560d77a0c6703694a1136af9b119add173d4923cefc5f4feb1 a05404df5dbb57697e2c16fa29defac8ab3560d6126fa0 +bec6b97cc2a873239da37eae2d50a4e6a29de228e68c40d8ad5f5fe0dd139fa2 aecbb02759f7433d6fcb06963c74061cd83b5b3ffa6f13c6 +7d10e374784c9275627a6d3401b75216af415a228b40e2c36b113777bb90831c aafdc9243d3d4a096558a360cc27c8d862f0be73db5e88aa55 +8db764ebced55e0fff19a82119c5a3d47a0fb19fc7e1a021d0d0425f5db8b193 7bc84867f6f9e9fdc3e1046cae3a52c77ed485860ee260e30b15 +9149f241af9b134bb2fb970bd4586b0ff59de17202706b470d58ca7a4f86e0c2 fac523575a99ec48279a7a459e98ff901918a475034327efb55843 +51331e6e7af3a193ed66a2e58e1f8610779196145622a458e57bc5f52ad78c0f 0f8b2d8fcfd9d68cffc17ccfb117709b53d26462a3f346fb7c79b85e +485f559159c58ccec696b756543a2f8b1c4490634b4ec31fb9b3d8913b59da95 a963c3e895ff5a0be4824400518d81412f875fa50521e26e85eac90c04 +faf3b2da998fd51d4f6e359790c0bf533f806d39a00613662cf96ce2b09ff6ce 03a18688b10cc0edf83adf0a84808a9718383c4070c6c4f295098699ac2c +6796cc8fd9960890bd42a6f139992ab9bcacc5a17672648ae3e5ce600652627e 84fb51b517df6c5accb5d022f8f28da09b10232d42320ffc32dbecc3835b29 +bb603441f9cc752e780ebe371a02ec39bd810ffc7797dd49be728eb1fd50b384 9f2fcc7c90de090d6b87cd7e9718c1ea6cb21118fc2d5de9f97e5db6ac1e9c10 +fede0ad668c6bb8d2d65cd65ef6ff6e1a2fa03b98e46e642e1ea1f23f356e330 de8f1b3faa4b7040ed4563c3b8e598253178e87e4d0df75e4ff2f2dedd5a0be046 +ee9ade0ce8d1e864451dc8a79f3b36f7259d3f025eb0f405c2da609066408aad 62f154ec394d0bc757d045c798c8b87a00e0655d0481a7d2d9fb58d93aedc676b5a0 +9d8fed5ecc492de1bb1d0932ea41d8e6e5bd0ff4b66047fcac179df9c1acd640 b2dcfe9ff19e2b23ce7da2a4207d3e5ec7c6112a8a22aec9675a886378e14e5bfbad4e +759a023d09a25e5f88770190df7dfad00cd34c3c236ff40bf4d95c0f81193851 47f5697ac8c31409c0868827347a613a3562041c633cf1f1f86865a576e02835ed2c2492 +47ef7975922884f5fa0567c4306984a92cb2e012565eeb3388994c5c62364e4d 512a6d292e67ecb2fe486bfe92660953a75484ff4c4f2eca2b0af0edcdd4339c6b2ee4e542 +73495ae2b0ab412f9f24c73613fb09ff676b9c2a39f2aa5c36f11154320a78bf 973cf2b4dcf0bfa872b41194cb05bb4e16760a1840d8343301802576197ec19e2a1493d8f4fb +fd40278998e7925a5beb6fef313edde96117af5249f54cad7659a3c13e82b714 80beebcd2e3f8a9451d4499961c9731ae667cdc24ea020ce3b9aa4bbc0a7f79e30a934467da4b0 +6ee3915a5d8fef80b03e4e3dab9072e4143330675525988450c54554d5e61c94 7abaa12ec2a7347674e444140ae0fb659d08e1c66decd8d6eae925fa451d65f3c0308e29446b8ed3 +0c382ff250e6dee2569e5250a1f480b6accd0238f8d3840d9958fbd4d1160d8f c88dee9927679b8af422abcbacf283b904ff31e1cac58c7819809f65d5807d46723b20f67ba610c2b7 +d1efe8700d3d47a80a422fe86540a89f0e103fdead8848f616cfd3b939c29dd3 01e43fe350fcec450ec9b102053e6b5d56e09896e0ddd9074fe138e6038210270c834ce6eadc2bb86bf6 +b14bb4c03111e62ee6751d1c35498835df566fddc5ed5b70d2849b453d436b64 337023370a48b62ee43546f17c4ef2bf8d7ecd1d49f90bab604b839c2e6e5bd21540d29ba27ab8e309a4b7 +75d95470d72557d86cad03967552b34d925f6e5e9be7e887b57d6d444ec93d70 6892540f964c8c74bd2db02c0ad884510cb38afd4438af31fc912756f3efec6b32b58ebc38fc2a6b913596a8 +0d7c8efbee6b3fd4903e60c4ab19602c50b5020990ea248d98f5ad735103c541 f5961dfd2b1ffffda4ffbf30560c165bfedab8ce0be525845deb8dc61004b7db38467205f5dcfb34a2acfe96c0 +473bb75be6e05c0b8155c3c6777b34497037a14b24c76ab2e1b1c1e9e4d468ce ca061a2eb6ceed8881ce2057172d869d73a1951e63d57261384b80ceb5451e77b06cf0f5a0ea15ca907ee1c27eba +9fd55a16ed058649ecb835bed965f32fc9ed16c4a1c1bafd3f1bebc258ff9fc1 1743a77251d69242750c4f1140532cd3c33f9b5ccdf7514e8584d4a5f9fbd730bcf84d0d4726364b9bf95ab251d9bb +9d2b64fe62ad33552545a30c450cbe451c332d4bf6a859f24413782abd1258f1 d8faba1f5194c4db5f176fabfff856924ef627a37cd08cf55608bba8f1e324d7c7f157298eabc4dce7d89ce5162499f9 +b38fe07d9ab29794659b678ee6ec8501f23b4e7b5b81dff263429b0e70f1cd29 be9684be70340860373c9c482ba517e899fc81baaa12e5c6d7727975d1d41ba8bef788cdb5cf4606c9c1c7f61aed59f97d +b1457e6086ccc67cfb332325e3a3f4118ded982317798d4410c789b3b770baae 7e15d2b9ea74ca60f66c8dfab377d9198b7b16deb6a1ba0ea3c7ee2042f89d3786e779cf053c77785aa9e692f821f14a7f51 +866f44fbfba3978c7a161c11623c5197d3781987b4566b709cc00f11fde4f559 9a219be43713bd578015e9fda66c0f2d83cac563b776ab9f38f3e4f7ef229cb443304fba401efb2bdbd7ece939102298651c86 +abd55d3989f3fcd0d0b039fa5a1c8d03df1d65fdc049ac881c008d09235dba00 c8f2b693bd0d75ef99caebdc22adf4088a95a3542f637203e283bbc3268780e787d68d28cc3897452f6a22aa8573ccebf245972a +30c4f40c042a391b8c55fdbf5b2e76bc10df15d053748f39a2719601f99893c4 ec0f99711016c6a2a07ad80d16427506ce6f441059fd269442baaa28c6ca037b22eeac49d5d894c0bf66219f2c08e9d0e8ab21de52 +7670067cdbf1868e8bb82c9c73ee6cf39d3e6b2215fe481806e8234babc94c27 0dc45181337ca32a8222fe7a3bf42fc9f89744259cff653504d6051fe84b1a7ffd20cb47d4696ce212a686bb9be9a8ab1c697b6d6a33 +ad373db6defaefbeeff69e78e220a4ca9ef510ad5f85f0c698a749e0e6dcaeb5 de286ba4206e8b005714f80fb1cdfaebde91d29f84603e4a3ebc04686f99a46c9e880b96c574825582e8812a26e5a857ffc6579f63742f +cad656a57a59591a03e7b540a1e5a76a7645a60228e1057ea39b34f6b691510d eebcc18057252cbf3f9c070f1a73213356d5d4bc19ac2a411ec8cdeee7a571e2e20eaf61fd0c33a0ffeb297ddb77a97f0a415347db66bcaf +526fb1365175af61f6d33ee66c51f9eb67658742bd5ad827e3b3f12f535b8a3f 416b5cdc9fe951bd361bd7abfc120a5054758eba88fdd68fd84e39d3b09ac25497d36b43cbe7b85a6a3cebda8db4e5549c3ee51bb6fcb6ac1e +f93ea4fbe593e41d458148486363b9436b0700c0407c05eb88403632bab1efa5 5c5faf66f32e0f8311c32e8da8284a4ed60891a5a7e50fb2956b3cbaa79fc66ca376460e100415401fc2b8518c64502f187ea14bfc9503759705 +ff39988c582120d695b00606757074841a75a3ed0f2cc7321858c2ff09085003 7167e1e02be1a7ca69d788666f823ae4eef39271f3c26a5cf7cee05bca83161066dc2e217b330df821103799df6d74810eed363adc4ab99f36046a +94ba07439ed47e21b91ec7709c5605b116ef8caba952bdd27b1a9a0ca59aec4c 2fda311dbba27321c5329510fae6948f03210b76d43e7448d1689a063877b6d14c4f6d0eaa96c150051371f7dd8a4119f7da5c483cc3e6723c01fb7d +f0c7105f3b62d5fb78e82c1761809e9be1f44914f43c5bd96e7972ea6c3b7663 95d1474a5aab5d2422aca6e481187833a6212bd2d0f91451a67dd786dfc91dfed51b35f47e1deb8a8ab4b9cb67b70179cc26f553ae7b569969ce151b8d +34ff717bd5fdc5618ffc8da403a2f2359ecec9078f8c234f275d8cfaa39cc1d6 c71bd7941f41df044a2927a8ff55b4b467c33d089f0988aa253d294addbdb32530c0d4208b10d9959823f0c0f0734684006df79f7099870f6bf53211a88d +a17d2cdd3e3fd0aa2790ee8c3802606b46ae91b66db66684a56768fe52fb9760 f57c64006d9ea761892e145c99df1b24640883da79d9ed5262859dcda8c3c32e05b03d984f1ab4a230242ab6b78d368dc5aaa1e6d3498d53371e84b0c1d4ba +f76305a1bb52917ce0882111f20f57eb51ee545cf064ce331a61d35ef17272c3 e926ae8b0af6e53176dbffcc2a6b88c6bd765f939d3d178a9bde9ef3aa131c61e31c1e42cdfaf4b4dcde579a37e150efbef5555b4c1cb40439d835a724e2fae7 +d184236acc1b11b65b13752dd97928519a8504391fd4c8389d3bec3583ece2ef 16e8b3d8f988e9bb04de9c96f2627811c973ce4a5296b4772ca3eefeb80a652bdf21f50df79f32db23f9f73d393b2d57d9a0297f7a2f2e79cfda39fa393df1ac00 +29b27ed19703a7d94f3d4262db1970d53d752a2e83ab494fcb8077aa7edbe2f3 fc424eeb27c18a11c01f39c555d8b78a805b88dba1dc2a42ed5e2c0ec737ff68b2456d80eb85e11714fa3f8eabfb906d3c17964cb4f5e76b29c1765db03d91be37fc +277bea584fc97d2eb1bc7ae14c0eafacb5baf03d7d865fcce5b9ef40908a6279 abe3472b54e72734bdba7d9158736464251c4f21b33fbbc92d7fac9a35c4e3322ff01d2380cbaa4ef8fb07d21a2128b7b9f5b6d9f34e13f39c7ffc2e72e47888599ba5 +6e7a7bf2379339c004c0acdaa52aa71aea7496eb3e931b9d658427eb22767d77 36f9f0a65f2ca498d739b944d6eff3da5ebba57e7d9c41598a2b0e4380f3cf4b479ec2348d015ffe6256273511154afcf3b4b4bf09d6c4744fdd0f62d75079d440706b05 +ec6854b56c285e8b9a8a37aca30581d52e839c569a328f63b7aa07810f49cd68 abc87763cae1ca98bd8c5b82caba54ac83286f87e9610128ae4de68ac95df5e329c360717bd349f26b872528492ca7c94c2c1e1ef56b74dbb65c2ac351981fdb31d06c77a4 +c1ddb90c5eab10a482fd25c9575505bd4f9ab3d991b026c8de55d314022eedb5 94f7ca8e1a54234c6d53cc734bb3d3150c8ba8c5f880eab8d25fed13793a9701ebe320509286fd8e422e931d99c98da4df7e70ae447bab8cffd92382d8a77760a259fc4fbd72 +975a4986c2af8cc6a1f807dbefa5b15ed433831e7d0d9b00c2628497ababcb6e 13bd2811f6ed2b6f04ff3895aceed7bef8dcd45eb121791bc194a0f806206bffc3b9281c2b308b1a729ce008119dd3066e9378acdcc50a98a82e20738800b6cddbe5fe9694ad6d +ce7e64a7fea919ed5361e92e44579fadadbb95cbd10f87b538cd02f5a7468c00 1eed9cba179a009ec2ec5508773dd305477ca117e6d569e66b5f64c6bc64801ce25a8424ce4a26d575b8a6fb10ead3fd1992edddeec2ebe7150dc98f63adc3237ef57b91397aa8a7 +007a1e2c31fbc056a9e7a994c8eebb9b01824506687f4b382064b10680f65886 ba5b67b5ec3a3ffae2c19dd8176a2ef75c0cd903725d45c9cb7009a900c0b0ca7a2967a95ae68269a6dbf8466c7b6844a1d608ac661f7eff00538e323db5f2c644b78b2d48de1a08aa +0289b40b14608a7ff9901b40d9ab66e7f434c42d3b7f4a6ed833903963493a29 0efa26ac5673167dcacab860932ed612f65ff49b80fa9ae65465e5542cb62075df1c5ae54fba4db807be25b070033efa223bdd5b1d3c94c6e1909c02b620d4b1b3a6c9fed24d70749604 +0d363cc0d3a7653228ccced5b7c1e0ed58d24e386bc18b578f6cf50e8289befb bbfd933d1fd7bf594ac7f435277dc17d8d5a5b8e4d13d96d2f64e771abbd51a5a8aea741beccbddb177bcea05243ebd003cfdeae877cca4da94605b67691919d8b033f77d384ca01593c1b +6543286a4799a9f74a948a740fecfab6898517979bf3b77d2488cd037ea0e4a1 90078999fd3c35b8afbf4066cbde335891365f0fc75c1286cdd88fa51fab94f9b8def7c9ac582a5dbcd95817afb7d1b48f63704e19c2baa4df347f48d4a6d603013c23f1e9611d595ebac37c +bd291ad3741aa3c69cc869a1eb81da30c98f5de0452734d00457cc979d86d5ee 64105eca863515c20e7cfbaa0a0b8809046164f374d691cdbd6508aaabc1819f9ac84b52bafc1b0fe7cddbc554b608c01c8904c669d8db316a0953a4c68ece324ec5a49ffdb59a1bd6a292aa0e +4e3dba974a3cdd4995c256a34ae01063c716e760d3602e785170f02127a72f85 d4654be288b9f3b711c2d02015978a8cc57471d5680a092aa534f7372c71ceaab725a383c4fcf4d8deaa57fca3ce056f312961eccf9b86f14981ba5bed6ab5b4498e1f6c82c6cae6fc14845b3c8a +6d8b3ade529979111f8099a9fd1f0cd7fda3dd258a400b29846db8f5387de15e 12d9394888305ac96e65f2bf0e1b18c29c90fe9d714dd59f651f52b88b3008c588435548066ea2fc4c101118c91f32556224a540de6efddbca296ef1fb00341f5b01fecfc146bdb251b3bdad556cd2 +917cf68371edab397f933efd7916f0fa18792cbbec331070259546c440de7daf 871a0d7a5f36c3da1dfce57acd8ab8487c274fad336bc137ebd6ff4658b547c1dcfab65f037aa58f35ef16aff4abe77ba61f65826f7be681b5b6d5a1ea8085e2ae9cd5cf0991878a311b549a6d6af230 +73277049d2dcc2487a5fa342514de70032de1683d2f0e2f0253ce196f1fbf693 e90b4ffef4d457bc7711ff4aa72231ca25af6b2e206f8bf859d8758b89a7cd36105db2538d06da83bad5f663ba11a5f6f61f236fd5f8d53c5e89f183a3cec615b50c7c681e773d109ff7491b5cc22296c5 +e6024aef25ca0a496e6f8fbd030dccb5b22306f3d71e37e51053156a880ec73c e728de62d75856500c4c77a428612cd804f30c3f10d36fb219c5ca0aa30726ab190e5f3f279e0733d77e7267c17be27d21650a9a4d1e32f649627638dbada9702c7ca303269ed14014b2f3cf8b894eac8554 +44405d0508518b43b3c33f2d8e526f0064ee26cc5572584e49e664c2846783b5 6348f229e7b1df3b770c77544e5166e081850fa1c6c88169db74c76e42eb983facb276ad6a0d1fa7b50d3e3b6fcd799ec97470920a7abed47d288ff883e24ca21c7f8016b93bb9b9e078bdb9703d2b781b616e +039eed9e12e0b695cc70ba4fbbc8911a86c174d9165e12b8aa944d657e7aa65f 4b127fde5de733a1680c2790363627e63ac8a3f1b4707d982caea258655d9bf18f89afe54127482ba01e08845594b671306a025c9a5c5b6f93b0a39522dc877437be5c2436cbf300ce7ab6747934fcfc30aeaaf6 +6d40d076120ae4a5a5301fbc2fc5764f83fcfcfbb608738527b769108a33bb41 08461f006cff4cc64b752c957287e5a0faabc05c9bff89d23fd902d324c79903b48fcb8f8f4b01f3e4ddb483593d25f000386698f5ade7faade9615fdc50d32785ea51d49894e45baa3dc707e224688c6408b68b11 +f2490ed06e97f50bb209a748fa505982897f95814465e41dfa9daffd2f9bea32 68c8f8849b120e6e0c9969a5866af591a829b92f33cd9a4a3196957a148c49138e1e2f5c7619a6d5edebe995acd81ec8bb9c7b9cfca678d081ea9e25a75d39db04e18d475920ce828b94e72241f24db72546b352a0e4 +498f1736592b047b26080b6e1dc4e686cef4dce2929da83a8d140963cbb31068 b8d56472954e31fb54e28fca743f84d8dc34891cb564c64b08f7b71636debd64ca1edbdba7fc5c3e40049ce982bba8c7e0703034e331384695e9de76b5104f2fbc4535ecbeebc33bc27f29f18f6f27e8023b0fbb6f563c +689723c496746815869c2b8f2771db492a60edfaacce29ded86e2b4d11ca5118 0d58ac665fa84342e60cefee31b1a4eacdb092f122dfc68309077aed1f3e528f578859ee9e4cefb4a728e946324927b675cd4f4ac84f64db3dacfe850c1dd18744c74ceccd9fe4dc214085108f404eab6d8f452b5442a47d +bf958c62a4bdb72e1fed5cd0d68bed4b569557263183a622478d96c618f63f6a 1755e2d2e5d1c1b0156456b539753ff416651d44698e87002dcf61dcfa2b4e72f264d9ad591df1fdee7b41b2eb00283c5aebb3411323b672eaa145c5125185104f20f335804b02325b6dea65603f349f4d5d8b782dd3469ccd +5367368481ac046bf983f499552b0ca87b226350bd4cdf5023def4c6c7c7beb9 b180de1a611111ee7584ba2c4b020598cd574ac77e404e853d15a101c6f5a2e5c801d7d85dc95286a1804c870bb9f00fd4dcb03aa8328275158819dcad7253f3e3d237aeaa7979268a5db1c6ce08a9ec7c2579783c8afc1f91a7 +c9019a4a6f1da3d76ef4008f08dd7bb4e01680142dc6789ede0cc735c02f7b86 cf3583cbdfd4cbc17063b1e7d90b02f0e6e2ee05f99d77e24e560392535e47e05077157f96813544a17046914f9efb64762a23cf7a49fe52a0a4c01c630cfe8727b81fb99a89ff7cc11dca5173057e0417b8fe7a9efba6d95c555f +d8c82b3fa8f39d9f70e5149240a9b03272926621ab306af634e983bf0913cb3e 072fc02340ef99115bad72f92c01e4c093b9599f6cfc45cb380ee686cb5eb019e806ab9bd55e634ab10aa62a9510cc0672cd3eddb589c7df2b67fcd3329f61b1a4441eca87a33c8f55da4fbbad5cf2b2527b8e983bb31a2fadec7523 +714fac886919af28a9fa1be1eb1fdb19673814a676d739ebc3a141a48545f504 76eecf956a52649f877528146de33df249cd800e21830f65e90f0f25ca9d6540fde40603230eca6760f1139c7f268deba2060631eea92b1fff05f93fd5572fbe29579ecd48bc3a8d6c2eb4a6b26e38d6c5fbf2c08044aeea470a8f2f26 +a5be5b53c877628fd0210e38cfc45cdb5612395ce320aef5be28a742a5d54c99 7adc0b6693e61c269f278e6944a5a2d8300981e40022f839ac644387bfac9086650085c2cdc585fea47b9d2e52d65a2b29a7dc370401ef5d60dd0d21f9e2b90fae919319b14b8c5565b0423cefb827d5f1203302a9d01523498a4db10374 +9427036469f4375d424a00cadff752517fec80a690a114f6118aca6be5ae9127 e1fffa9826cce8b86bccefb8794e48c46cdf372013f782eced1e378269b7be2b7bf51374092261ae120e822be685f2e7a83664bcfbe38fe8633f24e633ffe1988e1bc5acf59a587079a57a910bda60060e85b5f5b6f776f0529639d9cce4bd +66ca51e2d44ab7b53d415345781c6f1205823c1e71d9b4cee074b75a8728977f 69f9abba65592ee01db4dce52dbab90b08fc04193602792ee4daa263033d59081587b09bbe49d0b49c9825d22840b2ff5d9c5155f975f8f2c2e7a90c75d2e4a8040fe39f63bbafb403d9e28cc3b86e04e394a9c9e8065bd3c85fa9f0c7891600 +67d1761ff1de244dad4cc6fc972f9f1c4451fa91cb630e2a1008202e64cdda47 38a10a352ca5aedfa8e19c64787d8e9c3a75dbf3b8674bfab29b5dbfc15a63d10fae66cd1a6e6d2452d557967eaad89a4c98449787b0b3164ca5b717a93f24eb0b506ceb70cbbcb8d72b2a72993f909aad92f044e0b5a2c9ac9cb16a0ca2f81f49 +12d264488aab5f92a89c647c4716b44d0b54bd1c59caa4c63086214419ba3e29 6d8c6e449bc13634f115749c248c17cd148b72157a2c37bf8969ea83b4d6ba8c0ee2711c28ee11495f43049596520ce436004b026b6c1f7292b9c436b055cbb72d530d860d1276a1502a5140e3c3f54a93663e4d20edec32d284e25564f624955b52 +2e5df5fd1c5e6d63a478b36a3571a2ddc095e1ffd93056682bf1aaab830582e7 6efcbcaf451c129dbe00b9cef0c3749d3ee9d41c7bd500ade40cdc65dedbbbadb885a5b14b32a0c0d087825201e303288a733842fa7e599c0c514e078f05c821c7a4498b01c40032e9f1872a1c925fa17ce253e8935e4c3c71282242cb716b2089ccc1 +1195a9f43d5528e2bcb43d8443e7b18c05f7f80946b61e2ab3d9eb15c8fff7a4 433c5303131624c0021d868a30825475e8d0bd3052a022180398f4ca4423b98214b6beaac21c8807a2c33f8c93bd42b092cc1b06cedf3224d5ed1ec29784444f22e08a55aa58542b524b02cd3d5d5f6907afe71c5d7462224a3f9d9e53e7e0846dcbb4ce +ad30542976e20a93bf2a2e2b341f04253cdc95826a629082fd668580777e488b a873e0c67ca639026b6683008f7aa6324d4979550e9bce064ca1e1fb97a30b147a24f3f666c0a72d71348ede701cf2d17e2253c34d1ec3b647dbcef2f879f4eb881c4830b791378c901eb725ea5c172316c6d606e0af7df4df7f76e490cd30b2badf45685f +79676a020a388a0da82bf48ed3e92c5abc6e34206ab3a1b3038344ae663f2fb2 006917b64f9dcdf1d2d87c8a6173b64f6587168e80faa80f82d84f60301e561e312d9fbce62f39a6fb476e01e925f26bcc91de621449be6504c504830aae394096c8fc7694651051365d4ee9070101ec9b68086f2ea8f8ab7b811ea8ad934d5c9b62c60a4771 +3d422f89bf9114776ae98024197429535113dc4f4ea1b1ba12d6b120dd55fd29 f13c972c52cb3cc4a4df28c97f2df11ce089b815466be88863243eb318c2adb1a417cb1041308598541720197b9b1cb5ba2318bd5574d1df2174af14884149ba9b2f446d609df240ce335599957b8ec80876d9a085ae084907bc5961b20bf5f6ca58d5dab38adb +e6dcdb50f90e7b0fc3bde1a24857927ae57a4f730d6a30d4bb8b4525fea4cf71 e35780eb9799ad4c77535d4ddb683cf33ef367715327cf4c4a58ed9cbdcdd486f669f80189d549a9364fa82a51a52654ec721bb3aab95dceb4a86a6afa93826db923517e928f33e3fba850d45660ef83b9876accafa2a9987a254b137c6e140a21691e1069413848 +53b93da8322604c79566119f860b0179a5684e7450aee256fc2dd7e7593dfa39 64ec021c9585e01ffe6d31bb50d44c79b6993d72678163db474947a053674619d158016adb243f5c8d50aa92f50ab36e579ff2dabb780a2b529370daa299207cfbcdd3a9a25006d19c4f1fe33e4b1eaec315d8c6ee1e730623fd1941875b924eb57d6d0c2edc4e78d6 +84c2cc80029b26b026342c562e2d31b1ab0be57c4a159e206f41367f5eef9c27 5954bab512cf327d66b5d9f296180080402624ad7628506b555eea8382562324cf452fba4a2130de3e165d11831a270d9cb97ce8c2d32a96f50d71600bb4ca268cf98e90d6496b0a6619a5a8c63db6d8a0634dfc6c7ec8ea9c006b6c456f1b20cd19e781af20454ac880 +ae6e977c0ba5e4dc36badceb2b0ddbbfc92383a6f0dfa8d5a8bafd08896e9141 03d9f92b2c565709a568724a0aff90f8f347f43b02338f94a03ed32e6f33666ff5802da4c81bdce0d0e86c04afd4edc2fc8b4141c2975b6f07639b1994c973d9a9afce3d9d365862003498513bfa166d2629e314d97441667b007414e739d7febf0fe3c32c17aa188a8683 +59c7e77fcaac2dd7b931fb681de0c7abadf103da0a3956c1a1834370a34830a5 f31e8b4f9e0621d531d22a380be5d9abd56faec53cbd39b1fab230ea67184440e5b1d15457bd25f56204fa917fa48e669016cb48c1ffc1e1e45274b3b47379e00a43843cf8601a5551411ec12503e5aac43d8676a1b2297ec7a0800dbfee04292e937f21c005f17411473041 +992a70622862446236a42e353b08503b1f62758e42a944331f4c4140d7420037 758ea3fea738973db0b8be7e599bbef4519373d6e6dcd7195ea885fc991d896762992759c2a09002912fb08e0cb5b76f49162aeb8cf87b172cf3ad190253df612f77b1f0c532e3b5fc99c2d31f8f65011695a087a35ee4eee5e334c369d8ee5d29f695815d866da99df3f79403 +c777f7ec527e56a347841df01d3238ad592ce68805b6974056c172f19aabc8e8 47c6e0c2b74948465921868804f0f7bd50dd323583dc784f998a93cd1ca4c6ef84d41dc81c2c40f34b5bee6a93867b3bdba0052c5f59e6f3657918c382e771d33109122cc8bb0e1e53c4e3d13b43ce44970f5e0c079d2ad7d7a3549cd75760c21bb15b447589e86e8d76b1e9ced2 +d49ea6685748992f274bb158cd4a936c479f1eba9217518068ffbbf9a44bb968 f690a132ab46b28edfa6479283d6444e371c6459108afd9c35dbd235e0b6b6ff4c4ea58e7554bd002460433b2164ca51e868f7947d7d7a0d792e4abf0be5f450853cc40d85485b2b8857ea31b5ea6e4ccfa2f3a7ef3380066d7d8979fdac618aad3d7e886dea4f005ae4ad05e5065f +166ed4abd425d074e8091f44ec2e9eeed471a9020adec03a4f1f003d7826f5ef 58d6a99bc6458824b256916770a8417040721cccfd4b79eacd8b65a3767ce5ba7e74104c985ac56b8cc9aebd16febd4cda5adb130b0ff2329cc8d611eb14dac268a2f9e633c99de33997fea41c52a7c5e1317d5b5daed35eba7d5a60e45d1fa7eaabc35f5c2b0a0f2379231953322c4e +158dbc6d91cd8403b8803a671e2d64ca2af964d5b61d20ae30b67c258b5acc0c befab574396d7f8b6705e2d5b58b2c1c820bb24e3f4bae3e8fbcd36dbf734ee14e5d6ab972aedd3540235466e825850ee4c512ea9795abfd33f330d9fd7f79e62bbb63a6ea85de15beaeea6f8d204a28956059e2632d11861dfb0e65bc07ac8a159388d5c3277e227286f65ff5e5b5aec1 +133c98d45490eb82d60a7bdb7981927a6e05d0ed82ec841ddef6a0a9c368637b 8e58144fa9179d686478622ce450c748260c95d1ba43b8f9b59abeca8d93488da73463ef40198b4d16fb0b0707201347e0506ff19d01bea0f42b8af9e71a1f1bd168781069d4d338fdef00bf419fbb003031df671f4a37979564f69282de9c65407847dd0da505ab1641c02dea4f0d834986 +0b1bccebc785202d23966d8962ab8c030c62a9607267b2fcd56368ca95027105 b55c10eae0ec684c16d13463f29291bf26c82e2fa0422a99c71db4af14dd9c7f33eda52fd73d017cc0f2dbe734d831f0d820d06d5f89dacc485739144f8cfd4799223b1aff9031a105cb6a029ba71e6e5867d85a554991c38df3c9ef8c1e1e9a7630be61caabca69280c399c1fb7a12d12aefc +76eb772a6c20e7ee60b6c22307991f4e418c265907b46b61abbb73558777ed89 2eeea693f585f4ed6f6f8865bbae47a6908aecd7c429e4bec4f0de1d0ca0183fa201a0cb14a529b7d7ac0e6ff6607a3243ee9fb11bcf3e2304fe75ffcddd6c5c2e2a4cd45f63c962d010645058d36571404a6d2b4f44755434d76998e83409c3205aa1615db44057db991231d2cb42624574f545 +de391381e7893d29cff28fe50bdba78d9d78daabe7bc13455e5994471bf36471 dab11dc0b047db0420a585f56c42d93175562852428499f66a0db811fcdddab2f7cdffed1543e5fb72110b64686bc7b6887a538ad44c050f1e42631bc4ec8a9f2a047163d822a38989ee4aab01b4c1f161b062d873b1cfa388fd301514f62224157b9bef423c7783b7aac8d30d65cd1bba8d689c2d +9191b96a3ab156ce4f1c8cdeda412f4fbb8fe82fea89e5e06b6e3cb0c31d1ba5 42e99a2f80aee0e001279a2434f731e01d34a44b1a8101726921c0590c30f3120eb83059f325e894a5ac959dca71ce2214799916424e859d27d789437b9d27240bf8c35adbafcecc322b48aa205b293962d858652abacbd588bcf6cbc388d0993bd622f96ed54614c25b6a9aa527589eaaffcf17ddf7 +216fa0351b39850c2bd7f2b5b9671cf8e40d9ff61a8e39f12f3a6e4494d7556b 3c9b46450c0f2cae8e3823f8bdb4277f31b744ce2eb17054bddc6dff36af7f49fb8a2320cc3bdf8e0a2ea29ad3a55de1165d219adeddb5175253e2d1489e9b6fdd02e2c3d3a4b54d60e3a47334c37913c5695378a669e9b72dec32af5434f93f46176ebf044c4784467c700470d0c0b40c8a088c815816 +97fc8bcdc75df30be496c8a19cc1374cf6a1ccb65f3a1395523aa293806a8dec d1e654b77cb155f5c77971a64df9e5d34c26a3cad6c7f6b300d39deb1910094691adaa095be4ba5d86690a976428635d5526f3e946f7dc3bd4dbc78999e653441187a81f9adcd5a3c5f254bc8256b0158f54673dcc1232f6e918ebfc6c51ce67eaeb042d9f57eec4bfe910e169af78b3de48d137df4f2840 +c9cdda7b2b3cc695d6d5ca1531801a4f3a23e0916b08d721e9e6fee4f7d0810a 626f68c18a69a6590159a9c46be03d5965698f2dac3de779b878b3d9c421e0f21b955a16c715c1ec1e22ce3eb645b8b4f263f60660ea3028981eebd6c8c3a367285b691c8ee56944a7cd1217997e1d9c21620b536bdbd5de8925ff71dec6fbc06624ab6b21e329813de90d1e572dfb89a18120c3f606355d25 +d4df2dd32859879f6a5f1c431cad5b87510bd5a0532765366c945ca358b71db0 651a6fb3c4b80c7c68c6011675e6094eb56abf5fc3057324ebc6477825061f9f27e7a94633abd1fa598a746e4a577caf524c52ec1788471f92b8c37f23795ca19d559d446cab16cbcdce90b79fa1026cee77bf4ab1b503c5b94c2256ad75b3eac6fd5dcb96aca4b03a834bfb4e9af988cecbf2ae597cb9097940 +d1f095caf1d7442428a58e5fa21478d9b94d39430562074fac9a0dff3432d39d 8aaf072fce8a2d96bc10b3c91c809ee93072fb205ca7f10abd82ecd82cf040b1bc49ea13d1857815c0e99781de3adbb5443ce1c897e55188ceaf221aa9681638de05ae1b322938f46bce51543b57ecdb4c266272259d1798de13be90e10efec2d07484d9b21a3870e2aa9e06c21aa2d0c9cf420080a80a91dee16f +140458c9a70ab6980f1c292a4da574dc9bce8cd5855321dc67d108e54bfa03ec 53f918fd00b1701bd504f8cdea803acca21ac18c564ab90c2a17da592c7d69688f6580575395551e8cd33e0fef08ca6ed4588d4d140b3e44c032355df1c531564d7f4835753344345a6781e11cd5e095b73df5f82c8ae3ad00877936896671e947cc52e2b29dcd463d90a0c9929128da222b5a211450bbc0e02448e2 +a5e935286f44db39a0b08726238ae3ee89038064eb4ba311f3954707613c6186 a64599b8a61b5ccec9e67aed69447459c8da3d1ec6c7c7c82a7428b9b584fa67e90f68e2c00fbbed4613666e5168da4a16f395f7a3c3832b3b134bfc9cbaa95d2a0fe252f44ac6681eb6d40ab91c1d0282fed6701c57463d3c5f2bb8c6a7301fb4576aa3b5f15510db8956ff77478c26a7c09bea7b398cfc83503f538e +eff0707442c2b43e455302819dec3894a2e41a9aab63ad168dd437a37408324a 0e3ab0e054739b00cdb6a87bd12cae024b54cb5e550e6c425360c2e87e59401f5ec24ef0314855f0f56c47695d56a7fb1417693af2a1ed5291f2fee95f75eed54a1b1c2e81226fbff6f63ade584911c71967a8eb70933bc3f5d15bc91b5c2644d9516d3c3a8c154ee48e118bd1442c043c7a0dba5ac5b1d5360aae5b9065 +45d0808107836411153667b2ca1b0b68476dad3eb8a46627923aceb32a920aaa a62fc595b4096e6336e53fcdfc8d1cc175d71dac9d750a6133d23199eaac288207944cea6b16d27631915b4619f743da2e30a0c00bbdb1bbb35ab852ef3b9aec6b0a8dcc6e9e1abaa3ad62ac0a6c5de765de2c3711b769e3fde44a74016fff82ac46fa8f1797d3b2a726b696e3dea5530439acee3a45c2a51bc32dd055650b +e9916891100d60a4f6686701b0ec5bc5ad200a496a89658e18ad10505b898ee6 2b6db7ced8665ebe9deb080295218426bdaa7c6da9add2088932cdffbaa1c14129bccdd70f369efb149285858d2b1d155d14de2fdb680a8b027284055182a0cae275234cc9c92863c1b4ab66f304cf0621cd54565f5bff461d3b461bd40df28198e3732501b4860eadd503d26d6e69338f4e0456e9e9baf3d827ae685fb1d817 +38443bdd9d99dd16d7570d0529f0662bc1797a516276d063327a722e43667fe8 10db509b2cdcaba6c062ae33be48116a29eb18e390e1bbada5ca0a2718afbcd23431440106594893043cc7f2625281bf7de2655880966a23705f0c5155c2f5cca9f2c2142e96d0a2e763b70686cd421b5db812daced0c6d65035fde558e94f26b3e6dde5bd13980cc80292b723013bd033284584bff27657871b0cf07a849f4ae2 +5ce13a4c40ad6e564e2eb90d0f34690f527d07d146443e88b263d0d943d0f820 9334de60c997bda6086101a6314f64e4458f5ff9450c509df006e8c547983c651ca97879175aaba0c539e82d05c1e02c480975cbb30118121061b1ebac4f8d9a3781e2db6b18042e01ecf9017a64a0e57447ec7fcbe6a7f82585f7403ee2223d52d37b4bf426428613d6b4257980972a0acab508a7620c1cb28eb4e9d30fc41361ec +19cb674d35076b2083f0fc9826fe184b5ea2e358300259cc934bf265ef121789 e88ab086891693aa535ceb20e64c7ab97c7dd3548f3786339897a5f0c39031549ca870166e477743ccfbe016b4428d89738e426f5ffe81626137f17aecff61b72dbee2dc20961880cfe281dfab5ee38b1921881450e16032de5e4d55ad8d4fca609721b0692bac79be5a06e177fe8c80c0c83519fb3347de9f43d5561cb8107b9b5edc +4f25eefba9cea8b323c6917a72027c668e9859ae025d2618467444800f695414 fd19e01a83eb6ec810b94582cb8fbfa2fcb992b53684fb748d2264f020d3b960cb1d6b8c348c2b54a9fcea72330c2aaa9a24ecdb00c436abc702361a82bb8828b85369b8c72ece0082fe06557163899c2a0efa466c33c04343a839417057399a63a3929be1ee4805d6ce3e5d0d0967fe9004696a5663f4cac9179006a2ceb75542d75d68 +da316803110775e55eaf40e85ba50f470acee5c7429dd9bc53bd70133071feeb 59ae20b6f7e0b3c7a989afb28324a40fca25d8651cf1f46ae383ef6d8441587aa1c04c3e3bf88e8131ce6145cfb8973d961e8432b202fa5af3e09d625faad825bc19da9b5c6c20d02abda2fcc58b5bd3fe507bf201263f30543819510c12bc23e2ddb4f711d087a86edb1b355313363a2de996b891025e147036087401ccf3ca7815bf3c49 +dcedc570a476055725f062daa0651383fe997cf539b2f1228a8da225befdb7d3 77ee804b9f3295ab2362798b72b0a1b2d3291dceb8139896355830f34b3b328561531f8079b79a6e9980705150866402fdc176c05897e359a6cb1a7ab067383eb497182a7e5aef7038e4c96d133b2782917417e391535b5e1b51f47d8ed7e4d4025fe98dc87b9c1622614bff3d1029e68e372de719803857ca52067cddaad958951cb2068cc6 +9213860134edd9693b7455405a1139e72fc1637fc7c6f4deb05950fe1cc4c8ae b771d5cef5d1a41a93d15643d7181d2a2ef0a8e84d91812f20ed21f147bef732bf3a60ef4067c3734b85bc8cd471780f10dc9e8291b58339a677b960218f71e793f2797aea349406512829065d37bb55ea796fa4f56fd8896b49b2cd19b43215ad967c712b24e5032d065232e02c127409d2ed4146b9d75d763d52db98d949d3b0fed6a8052fbb +2feb9de1b8f6706b05c594ac6ba953d2eb1077bcdc273586a1e9a7693b719b35 b32d95b0b9aad2a8816de6d06d1f86008505bd8c14124f6e9a163b5a2ade55f835d0ec3880ef50700d3b25e42cc0af050ccd1be5e555b23087e04d7bf9813622780c7313a1954f8740b6ee2d3f71f768dd417f520482bd3a08d4f222b4ee9dbd015447b33507dd50f3ab4247c5de9a8abd62a8decea01e3b87c8b927f5b08beb37674c6f8e380c04 +a7170c8b1c7c2ff96ff4324f1f91b49a06129d1e3b29dc70b303a735771c42c2 04410e31082a47584b406f051398a6abe74e4da59bb6f85e6b49e8a1f7f2ca00dfba5462c2cd2bfde8b64fb21d70c083f11318b56a52d03b81cac5eec29eb31bd0078b6156786da3d6d8c33098c5c47bb67ac64db14165af65b44544d806dde5f487d5373c7f9792c299e9686b7e5821e7c8e2458315b996b5677d926dac57b3f22da873c601016a0d +17f6b2a1f965b02a9b00c9af67308f45baac0e2702c4fe1f473ebd8ac865ff78 8b81e9badde026f14d95c019977024c9e13db7a5cd21f9e9fc491d716164bbacdc7060d882615d411438aea056c340cdf977788f6e17d118de55026855f93270472d1fd18b9e7e812bae107e0dfde7063301b71f6cfe4e225cab3b232905a56e994f08ee2891ba922d49c3dafeb75f7c69750cb67d822c96176c46bd8a29f1701373fb09a1a6e3c7158f +ff5c60968e17a08f9ecddf3327a95aec0964ec03ba5dab4ccdd1f0386b0b0ee1 fa6eed24da6666a22208146b19a532c2ec9ba94f09f1def1e7fc13c399a48e41acc2a589d099276296348f396253b57cb0e40291bd282773656b6e0d8bea1cda084a3738816a840485fcf3fb307f777fa5feac48695c2af4769720258c77943fb4556c362d9cba8bf103aeb9034baa8ea8bfb9c4f8e6742ce0d52c49ea8e974f339612e830e9e7a9c29065 +caf601a14e6f040318605c4134e845f9110c28358b91e9d059f426eb0e6af94b 9bb4af1b4f09c071ce3cafa92e4eb73ce8a6f5d82a85733440368dee4eb1cbc7b55ac150773b6fe47dbe036c45582ed67e23f4c74585dab509df1b83610564545642b2b1ec463e18048fc23477c6b2aa035594ecd33791af6af4cbc2a1166aba8d628c57e707f0b0e8707caf91cd44bdb915e0296e0190d56d33d8dde10b5b60377838973c1d943c22ed335e +44679d891ed6e8afe8d57b6decd41cb7a376c38ab6d0240f81806db625d02f09 2167f02118cc62043e9091a647cadbed95611a521fe0d64e8518f16c808ab297725598ae296880a773607a798f7c3cfce80d251ebec6885015f9abf7eaabae46798f82cb5926de5c23f44a3f9f9534b3c6f405b5364c2f8a8bdc5ca49c749bed8ce4ba48897062ae8424ca6dde5f55c0e42a95d1e292ca54fb46a84fbc9cd87f2d0c9e7448de3043ae22fdd229 +7b2ebd05afd8d80da41e30d4751454919d4274ac3dcc7d68043e66baae1cecf4 94b7fa0bc1c44e949b1d7617d31b4720cbe7ca57c6fa4f4094d4761567e389ecc64f6968e4064df70df836a47d0c713336b5028b35930d29eb7a7f9a5af9ad5cf441745baec9bb014ceeff5a41ba5c1ce085feb980bab9cf79f2158e03ef7e63e29c38d7816a84d4f71e0f548b7fc316085ae38a060ff9b8dec36f91ad9ebc0a5b6c338cbb8f6659d342a24368cf +b65e629abbfdfb1ea74835fdece61da229198d71d2408627c9afb30da8af89e7 ea40e83cb18b3a242c1ecc6ccd0b7853a439dab2c569cfc6dc38a19f5c90acbf76aef9ea3742ff3b54ef7d36eb7ce4ff1c9ab3bc119cff6be93c03e208783335c0ab8137be5b10cdc66ff3f89a1bddc6a1eed74f504cbe7290690bb295a872b9e3fe2cee9e6c67c41db8efd7d863cf10f840fe618e7936da3dca5ca6df933f24f6954ba0801a1294cd8d7e66dfafec +f2e3f93d6d23a16bf97a2ad32c3e1293de59805ee26277a04fe42f166570d296 157d5b7e4507f66d9a267476d33831e7bb768d4d04cc3438da12f9010263ea5fcafbde2579db2f6b58f911d593d5f79fb05fe3596e3fa80ff2f761d1b0e57080055c118c53e53cdb63055261d7c9b2b39bd90acc32520cbbdbda2c4fd8856dbcee173132a2679198daf83007a9b5c51511ae49766c792a29520388444ebefe28256fb33d4260439cba73a9479ee00c63 +0c647ea28d33c91160a56b0444400c2b1fbbf05cbcd579674c84c3911a705cc9 836b34b515476f613fe447a4e0c3f3b8f20910ac89a3977055c960d2d5d2b72bd8acc715a9035321b86703a411dde0466d58a59769672aa60ad587b8481de4bba552a1645779789501ec53d540b904821f32b0bd1855b04e4848f9f8cfe9ebd8911be95781a759d7ad9724a7102dbe576776b7c632bc39b9b5e19057e226552a5994c1dbb3b5c7871a11f5537011044c53 +78b62c2d16293639013f16fc5472f61a95e6ec004f67e96e2151d70708994476 cc7784a4912a7ab5ad3620aab29ba87077cd3cb83636adc9f3dc94f51edf521b2161ef108f21a0a298557981c0e53ce6ced45bdf782c1ef200d29bab81dd6460586964edab7cebdbbec75fd7925060f7da2b853b2b089588fa0f8c16ec6498b14c55dcee335cb3a91d698e4d393ab8e8eac0825f8adebeee196df41205c011674e53426caa453f8de1cbb57932b0b741d4c6 +c8f3afdae102094517caa3210d02da830531964863eefbd015c46f69810ab33d 7639b461fff270b2455ac1d1afce782944aea5e9087eb4a39eb96bb5c3baaf0e868c8526d3404f9405e79e77bfac5ffb89bf1957b523e17d341d7323c302ea7083872dd5e8705694acdda36d5a1b895aaa16eca6104c82688532c8bfe1790b5dc9f4ec5fe95baed37e1d287be710431f1e5e8ee105bc42ed37d74b1e55984bf1c09fe6a1fa13ef3b96faeaed6a2a1950a12153 +8912c6802e940c57664e714dd848d93dfa710ca879c75089595999a6082b5df6 eb6513fc61b30cfba58d4d7e80f94d14589090cf1d80b1df2e68088dc6104959ba0d583d585e9578ab0aec0cf36c48435eb52ed9ab4bbce7a5abe679c97ae2dbe35e8cc1d45b06dda3cf418665c57cbee4bbb47fa4caf78f4ee656fec237fe4eebbafa206e1ef2bd0ee4ae71bd0e9b2f54f91daadf1febfd7032381d636b733dcb3bf76fb14e23aff1f68ed3dbcf75c9b99c6f26 +70cc75de5ab9b56d4080afa804da9fcb951bb05e2c22f4045f856e54ad2f1b16 1594d74bf5dde444265d4c04dad9721ff3e34cbf622daf341fe16b96431f6c4df1f760d34f296eb97d98d560ad5286fec4dce1724f20b54fd7df51d4bf137add656c80546fb1bf516d62ee82baa992910ef4cc18b70f3f8698276fcfb44e0ec546c2c39cfd8ee91034ff9303058b4252462f86c823eb15bf481e6b79cc3a02218595b3658e8b37382bd5048eaed5fd02c37944e73b +b1e1b0c8bc208702f72e7d6fa5f7b977c6553cc729fee45e43bd372f1e47a2e4 4cfa1278903026f66fedd41374558be1b585d03c5c55dac94361df286d4bd39c7cb8037ed3b267b07c346626449d0cc5b0dd2cf221f7e4c3449a4be99985d2d5e67bff2923357ddeab5abcb4619f3a3a57b2cf928a022eb27676c6cf805689004fca4d41ea6c2d0a4789c7605f7bb838dd883b3ad3e6027e775bcf262881428099c7fff95b14c095ea130e0b9938a5e22fc52650f591 +91731e07a6b2d25c15895ecc7935029ec2977e74642efba76034446fbda7d11b d3e65cb92cfa79662f6af493d696a07ccf32aaadcceff06e73e8d9f6f909209e66715d6e978788c49efb9087b170ecf3aa86d2d4d1a065ae0efc8924f365d676b3cb9e2bec918fd96d0b43dee83727c9a93bf56ca2b2e59adba85696546a815067fc7a78039629d4948d157e7b0d826d1bf8e81237bab7321312fdaa4d521744f988db6fdf04549d0fdca393d639c729af716e9c8bba48 +0290b3a745c53f38a6698f1ab888f09a427eec3db47a151d13c5b7e91bd63a49 842cc583504539622d7f71e7e31863a2b885c56a0ba62db4c2a3f2fd12e79660dc7205ca29a0dc0a87db4dc62ee47a41db36b9ddb3293b9ac4baae7df5c6e7201e17f717ab56e12cad476be49608ad2d50309e7d48d2d8de4fa58ac3cfeafeee48c0a9eec88498e3efc51f54d300d828dddccb9d0b06dd021a29cf5cb5b2506915beb8a11998b8b886e0f9b7a80e97d91a7d01270f9a7717 +87b31ba330c464b08b0f9f93197534d415a958217a65c6cec77aba7c7f1e3faa 6c4b0a0719573e57248661e98febe326571f9a1ca813d3638531ae28b4860f23c3a3a8ac1c250034a660e2d71e16d3acc4bf9ce215c6f15b1c0fc7e77d3d27157e66da9ceec9258f8f2bf9e02b4ac93793dd6e29e307ede3695a0df63cbdc0fc66fb770813eb149ca2a916911bee4902c47c7802e69e405fe3c04ceb5522792a5503fa829f707272226621f7c488a7698c0d69aa561be9f378 +ae21d00bbe5899e35926e38666975ce50eac4d4edb9cdd6d8f2bb7b06902c014 51b7dbb7ce2ffeb427a91ccfe5218fd40f9e0b7e24756d4c47cd55606008bdc27d16400933906fd9f30effdd4880022d081155342af3fb6cd53672ab7fb5b3a3bcbe47be1fd3a2278cae8a5fd61c1433f7d350675dd21803746cadca574130f01200024c6340ab0cc2cf74f2234669f34e9009ef2eb94823d62b31407f4ba46f1a1eec41641e84d77727b59e746b8a671bef936f05be820759fa +461e3b5ac9591519c6708a0f48134213274bbca65a66acf1c760edd7800a3a7e 83599d93f5561e821bd01a472386bc2ff4efbd4aed60d5821e84aae74d8071029810f5e286f8f17651cd27da07b1eb4382f754cd1c95268783ad09220f5502840370d494beb17124220f6afce91ec8a0f55231f9652433e5ce3489b727716cf4aeba7dcda20cd29aa9a859201253f948dd94395aba9e3852bd1d60dda7ae5dc045b283da006e1cbad83cc13292a315db5553305c628dd091146597 +17f7c34dd3fde49241a36d36feae4fc3f9623758e07a5b1fd6d6b2bbc19080fd 2be9bf526c9d5a75d565dd11ef63b979d068659c7f026c08bea4af161d85a462d80e45040e91f4165c074c43ac661380311a8cbed59cc8e4c4518e80cd2c78ab1cabf66bff83eab3a80148550307310950d034a6286c93a1ece8929e6385c5e3bb6ea8a7c0fb6d6332e320e71cc4eb462a2a62e2bfe08f0ccad93e61bedb5dd0b786a728ab666f07e0576d189c92bf9fb20dca49ac2d3956d47385e2 +68562edbbd1ceefc12bb9930444a810090f8d08720e1fbf00b2e8605db81033f ca76d3a12595a817682617006848675547d3e8f50c2210f9af906c0e7ce50b4460186fe70457a9e879e79fd4d1a688c70a347361c847ba0dd6aa52936eaf8e58a1be2f5c1c704e20146d366aeb3853bed9de9befe9569ac8aaea37a9fb7139a1a1a7d5c748605a8defb297869ebedd71d615a5da23496d11e11abbb126b206fa0a7797ee7de117986012d0362dcef775c2fe145ada6bda1ccb326bf644 +1a9a95676b6032d9cc66ffcfb8d424411bdb7d163562d70d9eb538a2eb9df46a f76b85dc67421025d64e93096d1d712b7baf7fb001716f02d33b2160c2c882c310ef13a576b1c2d30ef8f78ef8d2f465007109aad93f74cb9e7d7bef7c9590e8af3b267c89c15db238138c45833c98cc4a471a7802723ef4c744a853cf80a0c2568dd4ed58a2c9644806f42104cee53628e5bdf7b63b0b338e931e31b87c24b146c6d040605567ceef5960df9e022cb469d4c787f4cba3c544a1ac91f95f +4732298d9c2825fe41274b71031afcdc963e39e1a8028e066361737bf959affc 25b8c9c032ea6bcd733ffc8718fbb2a503a4ea8f71dea1176189f694304f0ff68e862a8197b839957549ef243a5279fc2646bd4c009b6d1edebf24738197abb4c992f6b1dc9ba891f570879accd5a6b18691a93c7d0a8d38f95b639c1daeb48c4c2f15ccf5b9d508f8333c32de78781b41850f261b855c4bebcc125a380c54d501c5d3bd07e6b52102116088e53d76583b0161e2a58d0778f091206aabd5a1 +d55722366e397cd9740fdb19e3120c4d5df92e3d6e0a1d7daabfb1bbe1d61165 21cfdc2a7ccb7f331b3d2eefff37e48ad9fa9c788c3f3c200e0173d99963e1cbca93623b264e920394ae48bb4c3a5bb96ffbc8f0e53f30e22956adabc2765f57fb761e147ecbf8567533db6e50c8a1f894310a94edf806dd8ca6a0e141c0fa7c9fae6c6ae65f18c93a8529e6e5b553bf55f25be2e80a9882bd37f145fecbeb3d447a3c4e46c21524cc55cdd62f521ab92a8ba72b897996c49bb273198b7b1c9e +0862390d0191bdd152788f63e44ebd827b88f911919069083366019ef2709fdd 4e452ba42127dcc956ef4f8f35dd68cb225fb73b5bc7e1ec5a898bba2931563e74faff3b67314f241ec49f4a7061e3bd0213ae826bab380f1f14faab8b0efddd5fd1bb49373853a08f30553d5a55ccbbb8153de4704f29ca2bdeef0419468e05dd51557ccc80c0a96190bbcc4d77ecff21c66bdf486459d427f986410f883a80a5bcc32c20f0478bb9a97a126fc5f95451e40f292a4614930d054c851acd019ccf +04d01f5e37b134563dc69111f042d8060a80e8ff71fc0b947aaa032887e17678 fa85671df7dadf99a6ffee97a3ab9991671f5629195049880497487867a6c446b60087fac9a0f2fcc8e3b24e97e42345b93b5f7d3691829d3f8ccd4bb36411b85fc2328eb0c51cb3151f70860ad3246ce0623a8dc8b3c49f958f8690f8e3860e71eb2b1479a5cea0b3f8befd87acaf5362435eaeccb52f38617bc6c5c2c6e269ead1fbd69e941d4ad2012da2c5b21bcfbf98e4a77ab2af1f3fda3233f046d38f1dc8 +9a8e5b17512c41a4b2d05248f0468e26f4c55d64f51a0c7b6e8a9af1db6f5f8d e90847ae6797fbc0b6b36d6e588c0a743d725788ca50b6d792352ea8294f5ba654a15366b8e1b288d84f5178240827975a763bc45c7b0430e8a559df4488505e009c63da994f1403f407958203cebb6e37d89c94a5eacf6039a327f6c4dbbc7a2a307d976aa39e41af6537243fc218dfa6ab4dd817b6a397df5ca69107a9198799ed248641b63b42cb4c29bfdd7975ac96edfc274ac562d0474c60347a078ce4c25e88 +353185898990d860f1d17d886970643715c0e6e3bbbbe908688f01c1292a23fc f6d5c2b6c93954fc627602c00c4ca9a7d3ed12b27173f0b2c9b0e4a5939398a665e67e69d0b12fb7e4ceb253e8083d1ceb724ac07f009f094e42f2d6f2129489e846eaff0700a8d4453ef453a3eddc18f408c77a83275617fabc4ea3a2833aa73406c0e966276079d38e8e38539a70e194cc5513aaa457c699383fd1900b1e72bdfb835d1fd321b37ba80549b078a49ea08152869a918ca57f5b54ed71e4fd3ac5c06729 +afd00d9023347ea28e4217a64f0ff709e3ba9d19a78e80152d61fcfc244d3f4a cf8562b1bed89892d67ddaaf3deeb28246456e972326dbcdb5cf3fb289aca01e68da5d59896e3a6165358b071b304d6ab3d018944be5049d5e0e2bb819acf67a6006111089e6767132d72dd85beddcbb2d64496db0cc92955ab4c6234f1eea24f2d51483f2e209e4589bf9519fac51b4d061e801125e605f8093bb6997bc163d551596fe4ab7cfae8fb9a90f6980480ce0c229fd1675409bd788354daf316240cfe0af93eb +b9d6c27d1e95fe186d5d7f7ec080f82ed2e0710838c741e426de537d65128fe6 2ace31abb0a2e3267944d2f75e1559985db7354c6e605f18dc8470423fca30b7331d9b33c4a4326783d1caae1b4f07060eff978e4746bf0c7e30cd61040bd5ec2746b29863eb7f103ebda614c4291a805b6a4c8214230564a0557bc7102e0bd3ed23719252f7435d64d210ee2aafc585be903fa41e1968c50fd5d5367926df7a05e3a42cf07e656ff92de73b036cf8b19898c0cb34557c0c12c2d8b84e91181af467bc75a9d1 +b79172c5f852a390e76616bc1c4dc65579608f64fd76f1729ec8f1899c6e60eb 0d8d09aed19f1013969ce5e7eb92f83a209ae76be31c754844ea9116ceb39a22ebb6003017bbcf26555fa6624185187db8f0cb3564b8b1c06bf685d47f3286eda20b83358f599d2044bbf0583fab8d78f854fe0a596183230c5ef8e54426750eaf2cc4e29d3bdd037e734d863c2bd9789b4c243096138f7672c232314effdfc6513427e2da76916b5248933be312eb5dde4cf70804fb258ac5fb82d58d08177ac6f4756017fff5 +ff15b4aa0ce77a3179d9b1079d7187c737ba37c7999c89d899e42bbd9e7e0d59 c3236b73deb7662bf3f3daa58f137b358ba610560ef7455785a9befdb035a066e90704f929bd9689cef0ce3bda5acf4480bceb8d09d10b098ad8500d9b6071dfc3a14af6c77511d81e3aa8844986c3bea6f469f9e02194c92868cd5f51646256798ff0424954c1434bdfed9facb390b07d342e992936e0f88bfd0e884a0ddb679d0547ccdec6384285a45429d115ac7d235a717242021d1dc35641f5f0a48e8445dba58e6cb2c8ea +0766425f0911053564d7ad11bae97aeafe3f83142390bac6c802917598949d73 b39feb8283eadc63e8184b51df5ae3fd41aac8a963bb0be1cd08aa5867d8d910c669221e73243360646f6553d1ca05a84e8dc0de05b6419ec349ca994480193d01c92525f3fb3dcefb08afc6d26947bdbbfd85193f53b50609c6140905c53a6686b58e53a319a57b962331ede98149af3de3118a819da4d76706a0424b4e1d2910b0ed26af61d150ebcb46595d4266a0bd7f651ba47d0c7f179ca28545007d92e8419d48fdfbd744ce +4433e407c250469f6264a1e33e98c53f342ddf1c07273983a231117f05c73529 a983d54f503803e8c7999f4edbbe82e9084f422143a932ddddc47a17b0b7564a7f37a99d0786e99476428d29e29d3c197a72bfab1342c12a0fc4787fd7017d7a6174049ea43b5779169ef7472bdbbd941dcb82fc73aac45a8a94c9f2bd3477f61fd3b796f02a1b8264a214c6fea74b7051b226c722099ec7883a462b83b6afdd4009248b8a237f605fe5a08fe7d8b45321421ebba67bd70a0b00ddbf94baab7f359d5d1eea105f28dcfb +2883e69c655ef374f61fc28171eeec8568945ca51ca782f27b111a83be5c8605 e4d1c1897a0a866ce564635b74222f9696bf2c7f640dd78d7e2aca66e1b61c642bb03ea7536aae597811e9bf4a7b453ede31f97b46a5f0ef51a071a2b3918df16b152519ae3776f9f1edab4c2a377c3292e96408359d3613844d5eb393000283d5ad3401a318b12fd1474b8612f2bb50fb6a8b9e023a54d7dde28c43d6d8854c8d9d1155935c199811dbfc87e9e0072e90eb88681cc7529714f8fb8a2c9d88567adfb974ee205a9bf7b848 +a8b47e1fccbf494fbf02d16330c8d7386526b418d9ac85e921573e9a0d9e6ce5 b10c59723e3dcadd6d75df87d0a1580e73133a9b7d00cb95ec19f5547027323be75158b11f80b6e142c6a78531886d9047b08e551e75e6261e79785366d7024bd7cd9cf322d9be7d57fb661069f2481c7bb759cd71b4b36ca2bc2df6d3a328faebdb995a9794a8d72155ed551a1f87c80bf6059b43fc764900b18a1c2441f7487743cf84e565f61f8dd2ece6b6ccc9444049197aaaf53e926fbee3bfca8be588ec77f29d211be89de18b15f6 +3cf7e2f6bfa41354403a16b18644005289d97a725ee4b32a9642beb7fef4d576 db11f609baba7b0ca634926b1dd539c8cbada24967d7add4d9876f77c2d80c0f4dcefbd7121548373582705cca2495bd2a43716fe64ed26d059cfb566b3364bd49ee0717bdd9810dd14d8fad80dbbdc4cafb37cc60fb0fe2a80fb4541b8ca9d59dce457738a9d3d8f641af8c3fd6da162dc16fc01aac527a4a0255b4d231c0be50f44f0db0b713af03d968fe7f0f61ed0824c55c4b5265548febd6aad5c5eedf63efe793489c39b8fd29d104ce +108a3fbb93af7c0c2713116407767f08610c6e856cdf3474e406e35d8c64a140 bebd4f1a84fc8b15e4452a54bd02d69e304b7f32616aadd90537937106ae4e28de9d8aab02d19bc3e2fde1d651559e296453e4dba94370a14dbbb2d1d4e2022302ee90e208321efcd8528ad89e46dc839ea9df618ea8394a6bff308e7726bae0c19bcd4be52da6258e2ef4e96aa21244429f49ef5cb486d7ff35cac1bacb7e95711944bccb2ab34700d42d1eb38b5d536b947348a458ede3dc6bd6ec547b1b0cae5b257be36a7124e1060c170ffa +8fc89f8288be14a0b56e39a366bd112dddfd9af92f86366c16bbf9ffb77425b8 5aca56a03a13784bdc3289d9364f79e2a85c12276b49b92db0adaa4f206d5028f213f678c3510e111f9dc4c1c1f8b6acb17a6413aa227607c515c62a733817ba5e762cc6748e7e0d6872c984d723c9bb3b117eb8963185300a80bfa65cde495d70a46c44858605fccbed086c2b45cef963d33294dbe9706b13af22f1b7c4cd5a001cfec251fba18e722c6e1c4b1166918b4f6f48a98b64b3c07fc86a6b17a6d0480ab79d4e6415b520f1c484d675b1 +a92eb887c9ba1129f4315401c8aec9c4bd46b0c38539004f57b4e144938fa855 a5aad0e4646a32c85cfcac73f02fc5300f1982fabb2f2179e28303e447854094cdfc854310e5c0f60993ceff54d84d6b46323d930adb07c17599b35b505f09e784bca5985e0172257797fb53649e2e9723efd16865c31b5c3d5113b58bb0bfc8920fabdda086d7537e66d709d050bd14d0c960873f156fad5b3d3840cdfcdc9be6af519db262a27f40896ab25cc39f96984d650611c0d5a3080d5b3a1bf186abd42956588b3b58cd948970d298776060 +c2b7a22def0e5583a2ced2d4a295a0dc5cac7765e5ab94e9609cbf155ccbbf3a 06cbbe67e94a978203ead6c057a1a5b098478b4b4cbef5a97e93c8e42f5572713575fc2a884531d7622f8f879387a859a80f10ef02708cd8f7413ab385afc357678b9578c0ebf641ef076a1a30f1f75379e9dcb2a885bdd295905ee80c0168a62a9597d10cf12dd2d8cee46645c7e5a141f6e0e23aa482abe5661c16e69ef1e28371e2e236c359ba4e92c25626a7b7ff13f6ea4ae906e1cfe163e91719b1f750a96cbde5fbc953d9e576cd216afc90323a +3ccb149e7e8025d854b5a4ec8bab3622837ed7a5f89c019d26a42bb6dfef3074 f1c528cf7739874707d4d8ad5b98f7c77169de0b57188df233b2dc8a5b31eda5db4291dd9f68e6bad37b8d7f6c9c0044b3bf74bbc3d7d1798e138709b0d75e7c593d3cccdc1b20c7174b4e692add820ace262d45ccfae2077e878796347168060a162ecca8c38c1a88350bd63bb539134f700fd4addd5959e255337daa06bc86358fabcbefdfb5bc889783d843c08aadc6c4f6c36f65f156e851c9a0f917e4a367b5ad93d874812a1de6a7b93cd53ad97232 +4856403fe69f0293fc655b95d01a026826d5fbc4ac5cd906c89e370afbc523ab 9d9f3a7ecd51b41f6572fd0d0881e30390dfb780991dae7db3b47619134718e6f987810e542619dfaa7b505c76b7350c6432d8bf1cfebdf1069b90a35f0d04cbdf130b0dfc7875f4a4e62cdb8e525aadd7ce842520a482ac18f09442d78305fe85a74e39e760a4837482ed2f437dd13b2ec1042afcf9decdc3e877e50ff4106ad10a525230d11920324a81094da31deab6476aa42f20c84843cfc1c58545ee80352bdd3740dd6a16792ae2d86f11641bb717c2 +41d77e6571e39028e57bb5896d57c085d30f12ed423de8994f146b0c244cfcf5 5179888724819fbad3afa927d3577796660e6a81c52d98e9303261d5a4a83232f6f758934d50aa83ff9e20a5926dfebaac49529d006eb923c5ae5048ed544ec471ed7191edf46363383824f915769b3e688094c682b02151e5ee01e510b431c8865aff8b6b6f2f59cb6d129da79e97c6d2b8fa6c6da3f603199d2d1bcab547682a81cd6cf65f6551121391d78bcc23b5bd0e922ec6d8bf97c952e84dd28aef909aba31edb903b28fbfc33b7703cd996215a11238 +13fb8443c7490b1cbe9842a99a69d760ce51c347037f9ae1a01066953641f6e9 576ef3520d30b7a4899b8c0d5e359e45c5189add100e43be429a02fb3de5ff4f8fd0e79d9663acca72cd29c94582b19292a557c5b1315297d168fbb54e9e2ecd13809c2b5fce998edc6570545e1499dbe7fb74d47cd7f35823b212b05bf3f5a79caa34224fdd670d335fcb106f5d92c3946f44d3afcbae2e41ac554d8e6759f332b76be89a0324aa12c5482d1ea3ee89ded4936f3e3c080436f539fa137e74c6d3389bdf5a45074c47bc7b20b0948407a66d855e2f +7f4d4f09cf585ab8ff2b8bd432fd2c090b8eb9e6d9ee2a87f63f7f4b6de6a88e 0df2152fa4f4357c8741529dd77e783925d3d76e95bafa2b542a2c33f3d1d117d159cf473f82310356fee4c90a9e505e70f8f24859656368ba09381fa245eb6c3d763f3093f0c89b972e66b53d59406d9f01aea07f8b3b615cac4ee4d05f542e7d0dab45d67ccccd3a606ccbeb31ea1fa7005ba07176e60dab7d78f6810ef086f42f08e595f0ec217372b98970cc6321576d92ce38f7c397a403bada1548d205c343ac09deca86325373c3b76d9f32028fea8eb32515 +f25fe32f288cda7a485074918a49cbd4c2290b13f3e4960d530b99a0d3661c66 3e15350d87d6ebb5c8ad99d42515cfe17980933c7a8f6b8bbbf0a63728cefaad2052623c0bd5931839112a48633fb3c2004e0749c87a41b26a8b48945539d1ff41a4b269462fd199bfecd45374756f55a9116e92093ac99451aefb2af9fd32d6d7f5fbc7f7a540d5097c096ebc3b3a721541de073a1cc02f7fb0fb1b9327fb0b1218ca49c9487ab5396622a13ae546c97abdef6b56380dda7012a8384091b6656d0ab272d363cea78163ff765cdd13ab1738b940d16cae +5a3fd997324783c6b7758cce29e641e580c2aac62dcb38c7b1dcab2922807521 c38d6b0b757cb552be40940ece0009ef3b0b59307c1451686f1a22702922800d58bce7a636c1727ee547c01b214779e898fc0e560f8ae7f61bef4d75eaa696b921fd6b735d171535e9edd267c192b99880c87997711002009095d8a7a437e258104a41a505e5ef71e5613ddd2008195f0c574e6ba3fe40099cfa116e5f1a2fa8a6da04badcb4e2d5d0de31fdc4800891c45781a0aac7c907b56d631fca5ce8b2cde620d11d1777ed9fa603541de794ddc5758fcd5fad78c0 +aa17fda17d2ecf6d17dd48725fc72b2f0e81f53349a4923ef6b556b2245b6773 8d2de3f0b37a6385c90739805b170057f091cd0c7a0bc951540f26a5a75b3e694631bb64c7635eed316f51318e9d8de13c70a2aba04a14836855f35e480528b776d0a1e8a23b547c8b8d6a0d09b241d3be9377160cca4e6793d00a515dc2992cb7fc741daca171431da99cce6f7789f129e2ac5cf65b40d703035cd2185bb936c82002daf8cbc27a7a9e554b06196630446a6f0a14ba155ed26d95bd627b7205c072d02b60db0fd7e49ea058c2e0ba202daff0de91e845cf79 +6a9561677ebbe041fa2c90875e147a63ab8da53ba0864580aeaa0679c8180fab c464bbdad275c50dcd983b65ad1019b9ff85a1e71c807f3204bb2c921dc31fbcd8c5fc45868ae9ef85b6c9b83bba2a5a822201ed68586ec5ec27fb2857a5d1a2d09d09115f22dcc39fe61f5e1ba0ff6e8b4acb4c6da748be7f3f0839739394ff7fa8e39f7f7e84a33c3866875c01bcb1263c9405d91908e9e0b50e7459fabb63d8c6bbb73d8e3483c099b55bc30ff092ff68b6adedfd477d63570c9f5515847f36e24ba0b705557130cec57ebad1d0b31a378e91894ee26e3a04 +90e235e455596158a9022afe81b86d89cdf03ae5738b25e78727c9d46eb5aa1b 8b8d68bb8a75732fe272815a68a1c9c5aa31b41dedc8493e76525d1d013d33cebd9e21a5bb95db2616976a8c07fcf411f5f6bc6f7e0b57aca78cc2790a6f9b898858ac9c79b165ff24e66677531e39f572be5d81eb3264524181115f32780257bfb9aeec6af12af28e587cac068a1a2953b59ad680f4c245b2e3ec36f59940d37e1d3db38e13edb29b5c0f404f6ff87f80fc8be7a225ff22fbb9c8b6b1d7330c57840d24bc75b06b80d30dad6806544d510af6c4785e823ac3e0b8 +3fb8d2afa87a90ab98955b4e82240a7bd7cf779d03a5375c049bfbc05be32fad 6b018710446f368e7421f1bc0ccf562d9c1843846bc8d98d1c9bf7d9d6fcb48bfc3bf83b36d44c4fa93430af75cd190bde36a7f92f867f58a803900df8018150384d85d82132f123006ac2aeba58e02a037fe6afbd65eca7c44977dd3dc74f48b6e7a1bfd5cc4dcf24e4d52e92bd4455848e4928b0eac8b7476fe3cc03e862aa4dff4470dbfed6de48e410f25096487ecfc32a27277f3f5023b2725ade461b1355889554a8836c9cf53bd767f5737d55184eea1ab3f53edd0976c485 +348228c78f0d6051ac26bb293a25c85ecca518fa9ec0bcde0e8a76ed71dd8d02 c9534a24714bd4be37c88a3da1082eda7cabd154c309d7bd670dccd95aa535594463058a29f79031d6ecaa9f675d1211e9359be82669a79c855ea8d89dd38c2c761ddd0ec0ce9e97597432e9a1beae062cdd71edfdfd464119be9e69d18a7a7fd7ce0e2106f0c8b0abf4715e2ca48ef9f454dc203c96656653b727083513f8efb86e49c513bb758b3b052fe21f1c05bb33c37129d6cc81f1aef6adc45b0e8827a830fe545cf57d0955802c117d23ccb55ea28f95c0d8c2f9c5a242b33f +135fdd756450b9cd60ae96e8f94fba1dae68bb115c441e7b025556c1d4c5542a 07906c87297b867abf4576e9f3cc7f82f22b154afcbf293b9319f1b0584da6a40c27b32e0b1b7f412c4f1b82480e70a9235b12ec27090a5a33175a2bb28d8adc475cefe33f7803f8ce27967217381f02e67a3b4f84a71f1c5228e0c2ad971373f6f672624fcea8d1a9f85170fad30fa0bbd25035c3b41a6175d467998bd1215f6f3866f53847f9cf68ef3e2fbb54bc994de2302b829c5eea68ec441fcbafd7d16ae4fe9fff98bf00e5bc2ad54dd91ff9fda4dd77b6c754a91955d1fbaad0 +733b20df55216003deeb53f846ae05945073ad2463ddf38932a1f89f6487a15b 588e94b9054abc2189df69b8ba34341b77cdd528e7860e5defcaa79b0c9a452ad4b82aa306be84536eb7cedcbe058d7b84a6aef826b028b8a0271b69ac3605a9635ea9f5ea0aa700f3eb7835bc54611b922964300c953efe7491e3677c2cebe0822e956cd16433b02c68c4a23252c3f9e151a416b4963257b783e038f6b4d5c9f110f871652c7a649a7bcedcbccc6f2d0725bb903cc196ba76c76aa9f10a190b1d1168993baa9ffc96a1655216773458bec72b0e39c9f2c121378feab4e76a +e668c1b29fa473b1b408a6572883ad1f6d19f9e98c2dbf9dd80a806e01971316 08959a7e4baae874928813364071194e2939772f20db7c3157078987c557c2a6d5abe68d520eef3dc491692e1e21bcd880adebf63bb4213b50897fa005256ed41b5690f78f52855c8d9168a4b666fce2da2b456d7a7e7c17ab5f2fb1ee90b79e698712e963715983fd07641ae4b4e9dc73203fac1ae11fa1f8c7941fcc82eab247addb56e2638447e9d609e610b60ce086656aaebf1da3c8a231d7d94e2fd0afe46b391ff14a72eaeb3f44ad4df85866def43d4781a0b3578bc996c87970b132 +16d95c2c49428e83a2b233f9a457fc063c8060b8baee9e6e14330a2e4697bb36 cb2a234f45e2ecd5863895a451d389a369aab99cfef0d5c9ffca1e6e63f763b5c14fb9b478313c8e8c0efeb3ac9500cf5fd93791b789e67eac12fd038e2547cc8e0fc9db591f33a1e4907c64a922dda23ec9827310b306098554a4a78f050262db5b545b159e1ff1dca6eb734b872343b842c57eafcfda8405eedbb48ef32e99696d135979235c3a05364e371c2d76f1902f1d83146df9495c0a6c57d7bf9ee77e80f9787aee27be1fe126cdc9ef893a4a7dcbbc367e40fe4e1ee90b42ea25af01 +d6e589f9efdb02f8eadceb0c3cbd2f6c124d21ffc285c865c37210a542d679e7 d16beadf02ab1d4dc6f88b8c4554c51e866df830b89c06e786a5f8757e8909310af51c840efe8d20b35331f4355d80f73295974653ddd620cdde4730fb6c8d0d2dcb2b45d92d4fbdb567c0a3e86bd1a8a795af26fbf29fc6c65941cddb090ff7cd230ac5268ab4606fccba9eded0a2b5d014ee0c34f0b2881ac036e24e151be89eeb6cd9a7a790afccff234d7cb11b99ebf58cd0c589f20bdac4f9f0e28f75e3e04e5b3debce607a496d848d67fa7b49132c71b878fd5557e082a18eca1fbda94d4b +71ce35be3f5678864e97967efe59ae7aa043ec80760264d8374838aa87364310 8f65f6bc59a85705016e2bae7fe57980de3127e5ab275f573d334f73f8603106ec3553016608ef2dd6e69b24be0b7113bf6a760ba6e9ce1c48f9e186012cf96a1d4849d75df5bb8315387fd78e9e153e76f8ba7ec6c8849810f59fb4bb9b004318210b37f1299526866f44059e017e22e96cbe418699d014c6ea01c9f0038b10299884dbec3199bb05adc94e955a1533219c1115fed0e5f21228b071f40dd57c4240d98d37b73e412fe0fa4703120d7c0c67972ed233e5deb300a22605472fa3a3ba86 +8ebb40af11c7572012e0de2aca9260f7276c8fd3e7419d2c047ac238ecb7b5b5 84891e52e0d451813210c3fd635b39a03a6b7a7317b221a7abc270dfa946c42669aacbbbdf801e1584f330e28c729847ea14152bd637b3d0f2b38b4bd5bf9c791c58806281103a3eabbaede5e711e539e6a8b2cf297cf351c078b4fa8f7f35cf61bebf8814bf248a01d41e86c5715ea40c63f7375379a7eb1d78f27622fb468ab784aaaba4e534a6dfd1df6fa15511341e725ed2e87f98737ccb7b6a6dfae416477472b046bf1811187d151bfa9f7b2bf9acdb23a3be507cdf14cfdf517d2cb5fb9e4ab6 +0c828f3467d2cd08edd9badcf1963444c3ad270adf6e511f03c88349d8869b54 fdd7a9433a3b4afabd7a3a5e3457e56debf78e84b7a0b0ca0e8c6d53bd0c2dae31b2700c6128334f43981be3b213b1d7a118d59c7e6b6493a86f866a1635c12859cfb9ad17460a77b4522a5c1883c3d6acc86e6162667ec414e9a104aa892053a2b1d72165a855bacd8faf8034a5dd9b716f47a0818c09bb6baf22aa503c06b4ca261f557761989d2afbd88b6a678ad128af68672107d0f1fc73c5ca740459297b3292b281e93bceb761bde7221c3a55708e5ec84472cddcaa84ecf23723cc0991355c6280 +313a38d32b97476b9b28ce8fe6b81377713f9833d6256e7ba2570adbefdc15a4 70a40bfbef92277a1aad72f6b79d0177197c4ebd432668cfec05d099accb651062b5dff156c0b27336687a94b26679cfdd9daf7ad204338dd9c4d14114033a5c225bd11f217b5f4732da167ee3f939262d4043fc9cba92303b7b5e96aea12adda64859df4b86e9ee0b58e39091e6b188b408ac94e1294a8911245ee361e60e601eff58d1d37639f3753bec80ebb4efde25817436076623fc65415fe51d1b0280366d12c554d86743f3c3b6572e400361a60726131441ba493a83fbe9afda90f7af1ae717238d +72880b5673f50c071b59a625f4210d4e5104e76d8bcc250a636d86f359f03d52 74356e449f4bf8644f77b14f4d67cb6bd9c1f5ae357621d5b8147e562b65c66585caf2e491b48529a01a34d226d436959153815380d5689e30b35357cdac6e08d3f2b0e88e200600d62bd9f5eaf488df86a4470ea227006182e44809009868c4c280c43d7d64a5268fa719074960087b3a6abc837882f882c837834535929389a12b2c78187e2ea07ef8b8eef27dc85002c3ae35f1a50bee6a1c48ba7e175f3316670b27983472aa6a61eed0a683a39ee323080620ea44a9f74411ae5ce99030528f9ab49c79f2 +0f7dce85d2ccdd765235e016caf17075c278727c1e433608aeffa2799352225e 8c3798e51bc68482d7337d3abb75dc9ffe860714a9ad73551e120059860dde24ab87327222b64cf774415a70f724cdf270de3fe47dda07b61c9ef2a3551f45a5584860248fabde676e1cd75f6355aa3eaeabe3b51dc813d9fb2eaa4f0f1d9f834d7cad9c7c695ae84b329385bc0bef895b9f1edf44a03d4b410cc23a79a6b62e4f346a5e8dd851c2857995ddbf5b2d717aeb847310e1f6a46ac3d26a7f9b44985af656d2b7c9406e8a9e8f47dcb4ef6b83caacf9aefb6118bfcff7e44bef6937ebddc89186839b77 +cbdc6acd2ec50b59d14aab724285f541f44860acb559dc8c34a0d2510febfe0e fa56bf730c4f8395875189c10c4fb251605757a8fecc31f9737e3c2503b02608e6731e85d7a38393c67de516b85304824bfb135e33bf22b3a23b913bf6acd2b7ab85198b8187b2bcd454d5e3318cacb32fd6261c31ae7f6c54ef6a7a2a4c9f3ecb81ce3555d4f0ad466dd4c108a90399d70041997c3b25345a9653f3c9a6711ab1b91d6a9d2216442da2c973cbd685ee7643bfd77327a2f7ae9cb283620a08716dfb462e5c1d65432ca9d56a90e811443cd1ecb8f0de179c9cb48ba4f6fec360c66f252f6e64edc96b +c5306c224bebafd19eb92fa480bd10a7d332279856f1ad7b37d2cae1b9b999ed b6134f9c3e91dd8000740d009dd806240811d51ab1546a974bcb18d344642baa5cd5903af84d58ec5ba17301d5ec0f10ccd0509cbb3fd3fff9172d193af0f782252fd1338c7244d40e0e42362275b22d01c4c3389f19dd69bdf958ebe28e31a4ffe2b5f18a87831cfb7095f58a87c9fa21db72ba269379b2dc2384b3da953c7925761fed324620acea435e52b424a7723f6a2357374157a34cd8252351c25a1b232826cefe1bd3e70ffc15a31e7c0598219d7f00436294d11891b82497bc78aa5363892a2495df8c1eef +8d2e8fcc878cfc6843247debf62a89e3844c94d32920937f83a9c378ffe97cd0 c941cdb9c28ab0a791f2e5c8e8bb52850626aa89205bec3a7e22682313d198b1fa33fc7295381354858758ae6c8ec6fac3245c6e454d16fa2f51c4166fab51df272858f2d603770c40987f64442d487af49cd5c3991ce858ea2a60dab6a65a34414965933973ac2457089e359160b7cdedc42f29e10a91921785f6b7224ee0b349393cdcff6151b50b377d609559923d0984cda6000829b916ab6896693ef6a2199b3c22f7dc5500a15b8258420e314c222bc000bc4e5413e6dd82c993f8330f5c6d1be4bc79f08a1a0a46 +eafe83d51c716d4761554f55be42d586f50fdc9dc39a2f932dc06e950669dfc4 4499efffac4bcea52747efd1e4f20b73e48758be915c88a1ffe5299b0b005837a46b2f20a9cb3c6e64a9e3c564a27c0f1c6ad1960373036ec5bfe1a8fc6a435c2185ed0f114c50e8b3e4c7ed96b06a036819c9463e864a58d6286f785e32a804443a56af0b4df6abc57ed5c2b185ddee8489ea080deeee66aa33c2e6dab36251c402682b6824821f998c32163164298e1fafd31babbcffb594c91888c6219079d907fdb438ed89529d6d96212fd55abe20399dbefd342248507436931cdead496eb6e4a80358acc78647d043 +82a80f1b11ed92bbddc5ef6b90b1bca76a26878359c1b14b59b90282f71b0b2c eecbb8fdfa4da62170fd06727f697d81f83f601ff61e478105d3cb7502f2c89bf3e8f56edd469d049807a38882a7eefbc85fc9a950952e9fa84b8afebd3ce782d4da598002827b1eb98882ea1f0a8f7aa9ce013a6e9bc462fb66c8d4a18da21401e1b93356eb12f3725b6db1684f2300a98b9a119e5d27ff704affb618e12708e77e6e5f34139a5a41131fd1d6336c272a8fc37080f041c71341bee6ab550cb4a20a6ddb6a8e0299f2b14bc730c54b8b1c1c487b494bdccfd3a53535ab2f231590bf2c4062fd2ad58f906a2d0d +eff240f24a8e7f37ceff92b73e18f34afcad14fc419055e9ec359e6c2bd3af4e e64f3e4ace5c8418d65fec2bc5d2a303dd458034736e3b0df719098be7a206deaf52d6ba82316caf330ef852375188cde2b39cc94aa449578a7e2a8e3f5a9d68e816b8d16889fbc0ebf0939d04f63033ae9ae2bdab73b88c26d6bd25ee460ee1ef58fb0afa92cc539f8c76d3d097e7a6a63ebb9b5887edf3cf076028c5bbd5b9db3211371ad3fe121d4e9bf44229f4e1ecf5a0f9f0eba4d5ceb72878ab22c3f0eb5a625323ac66f7061f4a81fac834471e0c59553f108475fe290d43e6a055ae3ee46fb67422f814a68c4be3e8c9 +7985f2ebee310f6f307cf438fe162a57cba90e1bdd5522c51c927525f98c7e97 d2cb2d733033f9e91395312808383cc4f0ca974e87ec68400d52e96b3fa6984ac58d9ad0938dde5a973008d818c49607d9de2284e7618f1b8aed8372fbd52ed54557af4220fac09dfa8443011699b97d743f8f2b1aef3537ebb45dcc9e13dfb438428ee190a4efdb3caeb7f3933117bf63abdc7e57beb4171c7e1ad260ab0587806c4d137b6316b50abc9cce0dff3acada47bbb86be777e617bbe578ff4519844db360e0a96c6701290e76bb95d26f0f804c8a4f2717eac4e7de9f2cff3bbc55a17e776c0d02856032a6cd10ad2838 +0146b3848391f9bd60ac650ccfdd49a0fe60f18aa044a16d10d10189fce7f15b f2998955613dd414cc111df5ce30a995bb792e260b0e37a5b1d942fe90171a4ac2f66d4928d7ad377f4d0554cbf4c523d21f6e5f379d6f4b028cdcb9b1758d3b39663242ff3cb6ede6a36a6f05db3bc41e0d861b384b6dec58bb096d0a422fd542df175e1be1571fb52ae66f2d86a2f6824a8cfaacbac4a7492ad0433eeb15454af8f312b3b2a577750e3efbd370e8a8cac1582581971fba3ba4bd0d76e718dacf8433d33a59d287f8cc92234e7a271041b526e389efb0e40b6a18b3aaf658e82ed1c78631fd23b4c3eb27c3faec8685 +718a00ed31d5375aa4e9dc26d5621e21d0901f9e1569e237e6535bd4e5d5f363 447797e2899b72a356ba55bf4df3acca6cdb1041eb477bd1834a9f9acbc340a294d729f2f97df3a610be0ff15edb9c6d5db41644b9874360140fc64f52aa03f0286c8a640670067a84e017926a70438db1bb361defee7317021425f8821def26d1efd77fc853b818545d055adc9284796e583c76e6fe74c9ac2587aa46aa8f8804f2feb5836cc4b3ababab8429a5783e17d5999f32242eb59ef30cd7adabc16d72dbdb097623047c98989f88d14eaf02a7212be16ec2d07981aaa99949ddf89ecd90333a77bc4e1988a82abf7c7caf3291 +b17366f76307d583f52c211f4a025d032a1eb573a995ff9c3c1e31df014bd709 9f2c18ade9b380c784e170fb763e9aa205f64303067eb1bcea93df5dac4bf5a2e00b78195f808df24fc76e26cb7be31dc35f0844cded1567bba29858cffc97fb29010331b01d6a3fb3159cc1b973d255da9843e34a0a4061cabdb9ed37f241bfabb3c20d32743f4026b59a4ccc385a2301f83c0b0a190b0f2d01acb8f0d41111e10f2f4e149379275599a52dc089b35fdd5234b0cfb7b6d8aebd563ca1fa653c5c021dfd6f5920e6f18bfafdbecbf0ab00281333ed50b9a999549c1c8f8c63d7626c48322e9791d5ff72294049bde91e73f8 +389724e7e0f8af0fae8dea24ab3c3e343df97adbafb624f341bd4df0bf1de40c ae159f3fa33619002ae6bcce8cbbdd7d28e5ed9d61534595c4c9f43c402a9bb31f3b301cbfd4a43ce4c24cd5c9849cc6259eca90e2a79e01ffbac07ba0e147fa42676a1d668570e0396387b5bcd599e8e66aaed1b8a191c5a47547f61373021fa6deadcb55363d233c24440f2c73dbb519f7c9fa5a8962efd5f6252c0407f190dfefad707f3c7007d69ff36b8489a5b6b7c557e79dd4f50c06511f599f56c896b35c917b63ba35c6ff8092baf7d1658e77fc95d8a6a43eeb4c01f33f03877f92774be89c1114dd531c011e53a34dc248a2f0e6 +d6c2cb98a9f5ce5ca862f0188cb928aec4e3db5ab341829fda81753abb71db64 3b8e97c5ffc2d6a40fa7de7fcefc90f3b12c940e7ab415321e29ee692dfac799b009c99dcddb708fce5a178c5c35ee2b8617143edc4c40b4d313661f49abdd93cea79d117518805496fe6acf292c4c2a1f76b403a97d7c399daf85b46ad84e16246c67d6836757bde336c290d5d401e6c1386ab32797af6bb251e9b2d8fe754c47482b72e0b394eab76916126fd68ea7d65eb93d59f5b4c5ac40f7c3b37e7f3694f29424c24af8c8f0ef59cd9dbf1d28e0e10f799a6f78cad1d45b9db3d7dee4a7059abe99182714983b9c9d44d7f5643596d4f3 +77e624db0016d71adfa33d77eabac4912a2f32c5a403d12b13ae9dffa6e65492 3434ec31b10fafdbfeec0dd6bd94e80f7ba9dca19ef075f7eb017512af66d6a4bcf7d16ba0819a1892a6372f9b35bcc7ca8155ee19e8428bc22d214856ed5fa9374c3c09bde169602cc219679f65a1566fc7316f4cc3b631a18fb4449fa6afa16a3db2bc4212eff539c67cf184680826535589c7111d73bffce431b4c40492e763d9279560aaa38eb2dc14a212d723f994a1fe656ff4dd14551ce4e7c621b2aa5604a10001b2878a897a28a08095c325e10a26d2fb1a75bfd64c250309bb55a44f23bbac0d5516a1c687d3b41ef2fbbf9cc56d4739 +88c4852ec2ceaf975d72a6d47bdfcd800797ed730fa528446f6168da6140005d 7c7953d81c8d208fd1c97681d48f49dd003456de60475b84070ef4847c333b74575b1fc8d2a186964485a3b8634feaa3595aaa1a2f4595a7d6b6153563dee31bbac443c8a33eed6d5d956a980a68366c2527b550ee950250dfb691eacbd5d56ae14b970668be174c89df2fea43ae52f13142639c884fd62a3683c0c3792f0f24ab1318bcb27e21f4737fab62c77ea38bc8fd1cf41f7dab64c13febe7152bf5bb7ab5a78f5346d43cc741cb6f72b7b8980f268b68bf62abdfb1577a52438fe14b591498cc95f071228460c7c5d5ceb4a7bde588e7f21c +30f68700be6fd947d523cfa5710435364cf1ccd4ae2c472759ef47404c4be0f2 7a6a4f4fdc59a1d223381ae5af498d74b7252ecf59e389e49130c7eaee626e7bd9897effd92017f4ccde66b0440462cdedfd352d8153e6a4c8d7a0812f701cc737b5178c2556f07111200eb627dbc299caa792dfa58f35935299fa3a3519e9b03166dffa159103ffa35e8577f7c0a86c6b46fe13db8e2cdd9dcfba85bdddcce0a7a8e155f81f712d8e9fe646153d3d22c811bd39f830433b2213dd46301941b59293fd0a33e2b63adbd95239bc01315c46fdb678875b3c81e053a40f581cfbec24a1404b1671a1b88a6d06120229518fb13a74ca0ac5ae +a1a1230b5c360e14d1a8f538abc89efa63eeebb567c4833a49a184eab6e5960b d9faa14cebe9b7de551b6c0765409a33938562013b5e8e0e1e0a6418df7399d0a6a771fb81c3ca9bd3bb8e2951b0bc792525a294ebd1083688806fe5e7f1e17fd4e3a41d00c89e8fcf4a363caedb1acb558e3d562f1302b3d83bb886ed27b76033798131dab05b4217381eaaa7ba15ec820bb5c13b516dd640eaec5a27d05fdfca0f35b3a5312146806b4c0275bcd0aaa3b2017f346975db566f9b4d137f4ee10644c2a2da66deeca5342e236495c3c6280528bfd32e90af4cd9bb908f34012b52b4bc56d48cc8a6b59bab014988eabd12e1a0a1c2e170e7 +0be6ab58bb34ae7640c0d31e548c8100defb9e9013187d7628331432fdda37a0 2d8427433d0c61f2d96cfe80cf1e932265a191365c3b61aaa3d6dcc039f6ba2ad52a6a8cc30fc10f705e6b7705105977fa496c1c708a277a124304f1fc40911e7441d1b5e77b951aad7b01fd5db1b377d165b05bbf898042e39660caf8b279fe5229d1a8db86c0999ed65e53d01ccbc4b43173ccf992b3a14586f6ba42f5fe30afa8ae40c5df29966f9346da5f8b35f16a1de3ab6de0f477d8d8660918060e88b9b9e9ca6a4207033b87a812dbf5544d39e4882010f82b6ce005f8e8ff6fe3c3806bc2b73c2b83afb704345629304f9f86358712e9fae3ca3e +8539f8d93bb669908b34440c219980a3c0195768e5cf751e07045afe4fcfea05 5e19d97887fcaac0387e22c6f803c34a3dacd2604172433f7a8a7a526ca4a2a1271ecfc5d5d7be5ac0d85d921095350dfc65997d443c21c8094e0a3fefd2961bcb94aed03291ae310ccda75d8ace4bc7d89e7d3e5d1650bda5d668b8b50bfc8e608e184f4d3a9a2badc4ff5f07e0c0bc8a9f2e0b2a26fd6d8c550008faaab75fd71af2a424bec9a7cd9d83fad4c8e9319115656a8717d3b523a68ff8004258b9990ed362308461804ba3e3a7e92d8f2ffae5c2fba55ba5a3c27c0a2f71bd711d2fe1799c2adb31b200035481e9ee5c4adf2ab9c0fa50b23975cf +1fa468b1b220013035925acb87dee25c5bb4f734599784c66628cb81b6a8d7a4 c8e976ab4638909387ce3b8d4e510c3230e5690e02c45093b1d297910abc481e56eea0f296f98379dfc9080af69e73b2399d1c143bee80ae1328162ce1ba7f6a8374679b20aacd380eb4e61382c99998704d62701afa914f9a2705cdb065885f50d086c3eb5753700c387118bb142f3e6da1e988dfb31ac75d7368931e45d1391a274b22f83ceb072f9bcabc0b216685bfd789f5023971024b1878a205442522f9ea7d8797a4102a3df41703768251fd5e017c85d1200a464118aa35654e7ca39f3c375b8ef8cbe7534dbc64bc20befb417cf60ec92f63d9ee7397 +5bedb760cb1b6f713eb4479069d2962a50befec45850064651191f1bcc536be2 7145fa124b7429a1fc2231237a949ba7201bcc1822d3272de005b682398196c25f7e5cc2f289fbf44415f699cb7fe6757791b1443410234ae061edf623359e2b4e32c19bf88450432dd01caa5eb16a1dc378f391ca5e3c4e5f356728bddd4975db7c890da8bbc84cc73ff244394d0d48954978765e4a00b593f70f2ca082673a261ed88dbcef1127728d8cd89bc2c597e9102ced6010f65fa75a14ebe467fa57ce3bd4948b6867d74a9df5c0ec6f530cbf2ee61ce6f06bc8f2864dff5583776b31df8c7ffcb61428a56bf7bd37188b4a5123bbf338393af46eda85e6 +a9f6370705bd8be565645567ba02a77cf84f359acc912993a72aee709f9687f1 7fdfadcc9d29bad23ae038c6c65cda1aef757221b8872ed3d75ff8df7da0627d266e224e812c39f7983e4558bfd0a1f2bef3feb56ba09120ef762917b9c093867948547aee98600d10d87b20106878a8d22c64378bf634f7f75900c03986b077b0bf8b740a82447b61b99fee5376c5eb6680ec9e3088f0bdd0c56883413d60c1357d3c811950e5890e7600103c916341b80c743c6a852b7b4fb60c3ba21f3bc15b8382437a68454779cf3cd7f9f90ccc8ef28d0b706535b1e4108eb5627bb45d719cb046839aee311ca1abdc8319e050d67972cb35a6b1601b25dbf487 +6afbd061f024f85fadf64d1151f87be6c5d0322580a36a0ec6c7a439182404ca 988638219fd3095421f826f56e4f09e356296b628c3ce6930c9f2e758fd1a80c8273f2f61e4daae65c4f110d3e7ca0965ac7d24e34c0dc4ba2d6ff0bf5bbe93b3585f354d7543cb542a1aa54674d375077f2d360a8f4d42f3db131c3b7ab7306267ba107659864a90c8c909460a73621d1f5d9d3fd95beb19b23db1cb6c0d0fba91d36891529b8bd8263caa1bab56a4affaed44962df096d8d5b1eb845ef31188b3e10f1af811a13f156beb7a288aae593ebd1471b624aa1a7c6adf01e2200b3d72d88a3aed3100c88231e41efc376906f0b580dc895f080fda5741db1cb +39945efa3a76c7a7d1caa901d912d42c3e36d9759c16e1bf15abb39f53856f8d 5aab62756d307a669d146aba988d9074c5a159b3de85151a819b117ca1ff6597f6156e80fdd28c9c3176835164d37da7da11d94e09add770b68a6e081cd22ca0c004bfe7cd283bf43a588da91f509b27a6584c474a4a2f3ee0f1f56447379240a5ab1fb77fdca49b305f07ba86b62756fb9efb4fc225c86845f026ea542076b91a0bc2cdd136e122c659be259d98e5841df4c2f60330d4d8cdee7bf1a0a244524eecc68ff2aef5bf0069c9e87a11c6e519de1a4062a10c83837388f7ef58598a3846f49d499682b683c4a062b421594fafbc1383c943ba83bdef515efcf10d +c88f730c14a7b34d3b41e6d368a1370d6d773665bff573c32effe950e0045dc8 47b8216aa0fbb5d67966f2e82c17c07aa2d6327e96fcd83e3de7333689f3ee79994a1bf45082c4d725ed8d41205cb5bcdf5c341f77facb1da46a5b9b2cbc49eadf786bcd881f371a95fa17df73f606519aea0ff79d5a11427b98ee7f13a5c00637e2854134691059839121fea9abe2cd1bcbbbf27c74caf3678e05bfb1c949897ea01f56ffa4dafbe8644611685c617a3206c7a7036e4ac816799f693dafe7f19f303ce4eba09d21e03610201bfc665b72400a547a1e00fa9b7ad8d84f84b34aef118515e74def11b9188bd1e1f97d9a12c30132ec2806339bdadacda2fd8b78 +593be66e2c5c96c5019ce038e84d5e3f5c99d745b91cf4507cdbaf4d846009c8 8cff1f67fe53c098896d9136389bd8881816ccab34862bb67a656e3d98896f3ce6ffd4da73975809fcdf9666760d6e561c55238b205d8049c1cedeef374d1735daa533147bfa960b2cce4a4f254176bb4d1bd1e89654432b8dbe1a135c42115b394b024856a2a83dc85d6782be4b444239567ccec4b184d4548eae3ff6a192f343292ba2e32a0f267f31cc26719eb85245d415fb897ac2da433ee91a99424c9d7f1766a44171d1651001c38fc79294accc68ceb5665d36218454d3ba169ae058a831338c17743603f81ee173bfc0927464f9bd728dee94c6aeab7aae6ee3a627e8 +c1455e3d7f3dcdd64eba0b32d64518578713c241bb73d88847df3a16cabde318 eacd07971cff9b9939903f8c1d8cbb5d4db1b548a85d04e037514a583604e787f32992bf2111b97ac5e8a938233552731321522ab5e8583561260b7d13ebeef785b23a41fd8576a6da764a8ed6d822d4957a545d5244756c18aa80e1aad4d1f9c20d259dee1711e2cc8fd013169fb7cc4ce38b362f8e0936ae9198b7e838dcea4f7a5b9429bb3f6bbcf2dc92565e3676c1c5e6eb3dd2a0f86aa23edd3d0891f197447692794b3dfa269611ad97f72b795602b4fdb198f3fd3eb41b415064256e345e8d8c51c555dc8a21904a9b0f1ad0effab7786aac2da3b196507e9f33ca356427 +85c14348d396111ec5ce76500d87cf46f99a22e6f569dbc4cedc5d9d129b38f5 23ac4e9a42c6ef45c3336ce6dfc2ff7de8884cd23dc912fef0f7756c09d335c189f3ad3a23697abda851a81881a0c8ccafc980ab2c702564c2be15fe4c4b9f10dfb2248d0d0cb2e2887fd4598a1d4acda897944a2ffc580ff92719c95cf2aa42dc584674cb5a9bc5765b9d6ddf5789791d15f8dd925aa12bffafbce60827b490bb7df3dda6f2a143c8bf96abc903d83d59a791e2d62814a89b8080a28060568cf24a80ae61179fe84e0ffad00388178cb6a617d37efd54cc01970a4a41d1a8d3ddce46edbba4ab7c90ad565398d376f431189ce8c1c33e132feae6a8cd17a61c630012 +2072345a273c2f8f5a060e97a567ea70a4471a78953fd7af0fbd9acba9978990 0172df732282c9d488669c358e3492260cbe91c95cfbc1e3fea6c4b0ec129b45f242ace09f152fc6234e1bee8aab8cd56e8b486e1dcba9c05407c2f95da8d8f1c0af78ee2ed82a3a79ec0cb0709396ee62aadb84f8a4ee8a7ccca3c1ee84e302a09ea802204afecf04097e67d0f8e8a9d2651126c0a598a37081e42d168b0ae8a71951c524259e4e2054e535b779679bdade566fe55700858618e626b4a0faf895bcce9011504a49e05fd56127eae3d1f8917afb548ecadabda1020111fec9314c413498a360b08640549a22cb23c731ace743252a8227a0d2689d4c6001606678dfb921 +81dff0b99f2d0af83f56700ed14bf214c2c94181c6f3abacc5b33e07a2b7ef89 3875b9240cf3e0a8b59c658540f26a701cf188496e2c2174788b126fd29402d6a75453ba0635284d08835f40051a2a9683dc92afb9383719191231170379ba6f4adc816fecbb0f9c446b785bf520796841e58878b73c58d3ebb097ce4761fdeabe15de2f319dfbaf1742cdeb389559c788131a6793e193856661376c81ce9568da19aa6925b47ffd77a43c7a0e758c37d69254909ff0fbd415ef8eb937bcd49f91468b49974c07dc819abd67395db0e05874ff83dddab895344abd0e7111b2df9e58d76d85ad98106b36295826be04d435615595605e4b4bb824b33c4afeb5e7bb0d19f909 +a90fba78a75aa9cda52d0b0937330edf55d46fc2474c29388e1a40978ccc6ffc 747cc1a59fefba94a9c75ba866c30dc5c1cb0c0f8e9361d98484956dd5d1a40f6184afbe3dac9f76028d1caeccfbf69199c6ce2b4c092a3f4d2a56fe5a33a00757f4d7dee5dfb0524311a97ae0668a47971b95766e2f6dd48c3f57841f91f04a00ad5ea70f2d479a2620dc5cd78eaab3a3b011719b7e78d19ddf70d9423798af77517ebc55392fcd01fc600d8d466b9e7a7a85bf33f9cc5419e9bd874ddfd60981150ddaf8d7febaa4374f0872a5628d318000311e2f5655365ad4d407c20e5c04df17a222e7deec79c5ab1116d8572f91cd06e1ccc7ced53736fc867fd49ecebe6bf8082e8a +b953444533c87532ebde64faef511eb8cced6a99007cce8cbffda7f86dbaa482 57af971fccaec97435dc2ec9ef0429bcedc6b647729ea168858a6e49ac1071e706f4a5a645ca14e8c7746d65511620682c906c8b86ec901f3dded4167b3f00b06cbfac6aee3728051b3e5ff10b4f9ed8bd0b8da94303c833755b3ca3aeddf0b54bc8d6632138b5d25bab03d17b3458a9d782108006f5bb7de75b5c0ba854b423d8bb801e701e99dc4feaad59bc1c7112453b04d33ea3635639fb802c73c2b71d58a56bbd671b18fe34ed2e3dca38827d63fdb1d4fb3285405004b2b3e26081a8ff08cd6d2b08f8e7b7e90a2ab1ed7a41b1d0128522c2f8bff56a7fe67969422ce839a9d4608f03 +89ba5316a8c4aaa899d63b23ce0d30a54dd9f3f03eda58d9e83b1bc3b7f20902 04e16dedc1227902baaf332d3d08923601bdd64f573faa1bb7201918cfe16b1e10151dae875da0c0d63c59c3dd050c4c6a874011b018421afc4623ab0381831b2da2a8ba42c96e4f70864ac44e106f94311051e74c77c1291bf5db9539e69567bf6a11cf6932bbbad33f8946bf5814c066d851633d1a513510039b349939bfd42b858c21827c8ff05f1d09b1b0765dc78a135b5ca4dfba0801bcaddfa175623c8b647eacfb4444b85a44f73890607d06d507a4f8393658788669f6ef4deb58d08c50ca0756d5e2f49d1a7ad73e0f0b3d3b5f090acf622b1878c59133e4a848e05153592ea81c6fbf +df00136d02abce412f093ac9dd83448cd9e50535c9565d105d723ae0859fc3c9 7c815c384eee0f288ece27cced52a01603127b079c007378bc5d1e6c5e9e6d1c735723acbbd5801ac49854b2b569d4472d33f40bbb8882956245c366dc3582d71696a97a4e19557e41e54dee482a14229005f93afd2c4a7d8614d10a97a9dfa07f7cd946fa45263063ddd29db8f9e34db60daa32684f0072ea2a9426ecebfa5239fb67f29c18cbaa2af6ed4bf4283936823ac1790164fec5457a9cba7c767ca59392d94cab7448f50eb34e9a93a80027471ce59736f099c886dea1ab4cba4d89f5fc7ae2f21ccd27f611eca4626b2d08dc22382e92c1efb2f6afdc8fdc3d2172604f5035c46b8197d3 +b8fc7e6eda0086aa84ff61f92f2b7be06aa3b2465196f5580a6c0dcf1386c516 e29d505158dbdd937d9e3d2145658ee6f5992a2fc790f4f608d9cdb44a091d5b94b88e81fac4fdf5c49442f13b911c55886469629551189eaff62488f1a479b7db11a1560e198ddccccf50159093425ff7f1cb8d1d1246d0978764087d6bac257026b090efae8cec5f22b6f21c59ace1ac7386f5b8837ca6a12b6fbf5534dd0560ef05ca78104d3b943ddb220feaec89aa5e692a00f822a2ab9a2fe60350d75e7be16ff2526dc643872502d01f42f188abed0a6e9a6f5fd0d1ce7d5755c9ffa66b0af0b20bd806f08e06156690d81ac811778ca3dac2c249b96002017fce93e507e3b953acf99964b847 +df47d9543ea09b04851efa7df647b63d3b991699af4b277f14829d6c75f47906 d85588696f576e65eca0155f395f0cfacd83f36a99111ed5768df2d116d2121e32357ba4f54ede927f189f297d3a97fad4e9a0f5b41d8d89dd7fe20156799c2b7b6bf9c957ba0d6763f5c3bc5129747bbb53652b49290cff1c87e2cdf2c4b95d8aaee09bc8fbfa6883e62d237885810491bfc101f1d8c636e3d0ede838ad05c207a3df4fad76452979eb99f29afaecedd1c63b8d36cf378454a1bb67a741c77ac6b6b3f95f4f02b64dabc15438613ea49750df42ee90101f115aa9abb9ff64324dde9dabbb01054e1bd6b4bcdc7930a44c2300d87ca78c06924d0323ad7887e46c90e8c4d100acd9eed21e +85d560b1517bd45c88c130a7e8fe3b080291deb162c7c5977a6ace13fcfeffec 3a12f8508b40c32c74492b66323375dcfe49184c78f73179f3314b79e63376b8ac683f5a51f1534bd729b02b04d002f55cbd8e8fc9b5ec1ea6bbe6a0d0e7431518e6ba45d124035f9d3dce0a8bb7bf1430a9f657e0b4ea9f20eb20c786a58181a1e20a96f1628f8728a13bdf7a4b4b32fc8aa7054cc4881ae7fa19afa65c6c3ee1b3ade3192af42054a8a911b8ec1826865d46d93f1e7c5e2b7813c92a506e53886f3d4701bb93d2a681ad109c845904bb861af8af0646b6e399b38b614051d34f6842563a0f37ec00cb3d865fc5d746c4987de2a65071100883a2a9c7a2bfe1e2dd603d9ea24dc7c5fd06be +96f65533fd89b8a48a0cb5e3b7e60fec3b1773f8bbc75d89e4773da423d4f3c7 1861edce46fa5ad17e1ff1deae084dec580f97d0a67885dfe834b9dfac1ae076742ce9e267512ca51f6df5a455af0c5fd6abf94acea103a3370c354485a7846fb84f3ac7c2904b5b2fbf227002ce512133bb7e1c4e50057bfd1e44db33c7cdb969a99e284b184f50a14b068a1fc5009d9b298dbe92239572a7627aac02abe8f3e3b473417f36d4d2505d16b7577f4526c9d94a270a2dfe450d06da8f6fa956879a0a55cfe99e742ea555ea477ba3e9b44ccd508c375423611af92e55345dc215779b2d5119eba49c71d49b9fe3f1569fa24e5ca3e332d042422a8b8158d3ec66a80012976f31ffdf305f0c9c5e +122a894106b7ab1e52677fdb432d1db0b70187815d704b978acd5c2548a31626 08d0ffde3a6e4ef65608ea672e4830c12943d7187ccff08f4941cfc13e545f3b9c7ad5eebbe2b01642b486caf855c2c73f58c1e4e3391da8e2d63d96e15fd84953ae5c231911b00ad6050cd7aafdaac9b0f663ae6aab45519d0f5391a541707d479034e73a6ad805ae3598096af078f1393301493d663dd71f83869ca27ba508b7e91e81e128c1716dc3acfe3084b2201e04cf8006617eecf1b640474a5d45cfde9f4d3ef92d6d055b909892194d8a8218db6d8203a84261d200d71473d7488f3427416b6896c137d455f231071cacbc86e0415ab88aec841d96b7b8af41e05bb461a40645bf176601f1e760de5f +ce1056a8ae81b0159931a803e0bb7498393292dd31bf38937ce2e11a2f1f8f6b d782abb72a5be3392757be02d3e45be6e2099d6f000d042c8a543f50ed6ebc055a7f133b0dd8e9bc348536edcaae2e12ec18e8837df7a1b3c87ec46d50c241dee820fd586197552dc20beea50f445a07a38f1768a39e2b2ff05dddedf751f1def612d2e4d810daa3a0cc904516f9a43af660315385178a529e51f8aae141808c8bc5d7b60cac26bb984ac1890d0436ef780426c547e94a7b08f01acbfc4a3825eae04f520a9016f2fb8bf5165ed12736fc71e36a49a73614739eaa3ec834069b1b40f1350c2b3ab885c02c640b9f7686ed5f99527e41cfcd796fe4c256c9173186c226169ff257954ebda81c0e5f99 +930ce249bc62194653f326268d33cd349535498f48a808e22032b064dfe99bb4 5fce8109a358570e40983e1184e541833bb9091e280f258cfb144387b05d190e431cb19baa67273ba0c58abe91308e1844dcd0b3678baa42f335f2fa05267a0240b3c718a5942b3b3e3bfa98a55c25a1466e8d7a603722cb2bbf03afa54cd769a99f310735ee5a05dae2c22d397bd95635f58c48a67f90e1b73aafcd3f82117f0166657838691005b18da6f341d6e90fc1cdb352b30fae45d348294e501b63252de14740f2b85ae5299ddec3172de8b6d0ba219a20a23bb5e10ff434d39db3f583305e9f5c039d98569e377b75a70ab837d1df269b8a4b566f40bb91b577455fd3c356c914fa06b9a7ce24c7317a172d +295b04a3eb72bae7d1af8c97778e317e0c9d3bfe797a568d0e942434f0e30143 6172f1971a6e1e4e6170afbad95d5fec99bf69b24b674bc17dd78011615e502de6f56b86b1a71d3f4348087218ac7b7d09302993be272e4a591968aef18a1262d665610d1070ee91cc8da36e1f841a69a7a682c580e836941d21d909a3afc1f0b963e1ca5ab193e124a1a53df1c587470e5881fb54dae1b0d840f0c8f9d1b04c645ba1041c7d8dbf22030a623aa15638b3d99a2c400ff76f3252079af88d2b37f35ee66c1ad7801a28d3d388ac450b97d5f0f79e4541755356b3b1a5696b023f39ab7ab5f28df4202936bc97393b93bc915cb159ea1bd7a0a414cb4b7a1ac3af68f50d79f0c9c7314e750f7d02faa58bfa +e29ff387a5dcb86ac6e3442e0590172f4161c34e1f3b4f83146c094cfd02fd99 5668ecd99dfbe215c4118398ac9c9eaf1a1433fab4ccdd3968064752b625ea944731f75d48a27d047d67547f14dd0ffaa55fa5e29f7af0d161d85eafc4f2029b717c918eab9d304543290bdba7158b68020c0ba4e079bc95b5bc0fc044a992b94b4ccd3bd66d0eabb5dbbab904d62e00752c4e3b0091d773bcf4c14b4377da3efff824b1cb2fa01b32d1e46c909e626ed2dae920f4c7dbeb635bc754facbd8d49beba3f23c1c41ccbfcd0ee0c114e69737f5597c0bf1d859f0c767e18002ae8e39c26261ffde2920d3d0baf0e906138696cfe5b7e32b600f45df3aaa39932f3a7df95b60fa8712a2271fcaf3911ce7b511b1 +1ea1e16a92d23d49b84bee4cc022c4b3d11ac26273be1e9440d358b8b7b3fe45 03d625488354df30e3f875a68edfcf340e8366a8e1ab67f9d5c5486a96829dfac0578289082b2a62117e1cf418b43b90e0adc881fc6ae8105c888e9ecd21aea1c9ae1a4038dfd17378fed71d02ae492087d7cdcd98f746855227967cb1ab4714261ee3bead3f4db118329d3ebef4bc48a875c19ba763966da0ebea800e01b2f50b00e9dd4caca6dcb314d00184ef71ea2391d760c950710db4a70f9212ffc54861f9dc752ce18867b8ad0c48df8466ef7231e7ac567f0eb55099e622ebb86cb237520190a61c66ad34f1f4e289cb3282ae3eaac6152ed24d2c92bae5a7658252a53c49b7b02dfe54fdb2e90074b6cf310ac661 +ba95a7e5eaa57cd8339286b53b6aca811763cfed558aea46f0e9518e45312d7f 2edc282ffb90b97118dd03aaa03b145f363905e3cbd2d50ecd692b37bf000185c651d3e9726c690d3773ec1e48510e42b17742b0b0377e7de6b8f55e00a8a4db4740cee6db0830529dd19617501dc1e9359aa3bcf147e0a76b3ab70c4984c13e339e6806bb35e683af8527093670859f3d8a0fc7d493bcba6bb12b5f65e71e705ca5d6c948d66ed3d730b26db395b3447737c26fad089aa0ad0e306cb28bf0acf106f89af3745f0ec72d534968cca543cd2ca50c94b1456743254e358c1317c07a07bf2b0eca438a709367fafc89a57239028fc5fecfd53b8ef958ef10ee0608b7f5cb9923ad97058ec067700cc746c127a61ee3 +b1b21afb252748a178212650ddc4d25dd75e3608ce9418ea3e3a77026752037f 90b28a6aa1fe533915bcb8e81ed6cacdc10962b7ff82474f845eeb86977600cf70b07ba8e3796141ee340e3fce842a38a50afbe90301a3bdcc591f2e7d9de53e495525560b908c892439990a2ca2679c5539ffdf636777ad9c1cdef809cda9e8dcdb451abb9e9c17efa4379abd24b182bd981cafc792640a183b61694301d04c5b3eaad694a6bd4cc06ef5da8fa23b4fa2a64559c5a68397930079d250c51bcf00e2b16a6c49171433b0aadfd80231276560b80458dd77089b7a1bbcc9e7e4b9f881eacd6c92c4318348a13f4914eb27115a1cfc5d16d7fd94954c3532efaca2cab025103b2d02c6fd71da3a77f417d7932685888a +05fad405421d9aac1e2a0bb281f290044db798c9c81d2e7e37b8cf27ea3dbde7 2969447d175490f2aa9bb055014dbef2e6854c95f8d60950bfe8c0be8de254c26b2d31b9e4de9c68c9adf49e4ee9b1c2850967f29f5d08738483b417bb96b2a56f0c8aca632b552059c59aac3f61f7b45c966b75f1d9931ff4e596406378cee91aaa726a3a84c33f37e9cdbe626b5745a0b06064a8a8d56e53aaf102d23dd9df0a3fdf7a638509a6761a33fa42fa8ddbd8e16159c93008b53765019c3f0e9f10b144ce2ac57f5d7297f9c9949e4ff68b70d339f87501ce8550b772f32c6da8ad2ce2100a895d8b08fa1eead7c376b407709703c510b50f87e73e43f8e7348f87c3832a547ef2bbe5799abedcf5e1f372ea809233f006 +1067006f5ba77614c85654e29e6b8731d626da0e106a5fce8c60f40548ce3ee9 721645633a44a2c78b19024eaecf58575ab23c27190833c26875dc0f0d50b46aea9c343d82ea7d5b3e50ec700545c615daeaea64726a0f05607576dcd396d812b03fb6551c641087856d050b10e6a4d5577b82a98afb89cee8594c9dc19e79feff0382fcfd127f1b803a4b9946f4ac9a4378e1e6e041b1389a53e3450cd32d9d2941b0cbabdb50da8ea2513145164c3ab6bcbd251c448d2d4b087ac57a59c2285d564f16da4ed5e607ed979592146ffb0ef3f3db308fb342df5eb5924a48256fc763141a278814c82d6d6348577545870ae3a83c7230ac02a1540fe1798f7ef09e335a865a2ae0949b21e4f748fb8a51f44750e213a8fb +04cb00e26c2956c95b4271d63b354128bf91377352903a0c8f3cc81316a45c52 6b860d39725a14b498bb714574b4d37ca787404768f64c648b1751b353ac92bac2c3a28ea909fdf0423336401a02e63ec24325300d823b6864bb701f9d7c7a1f8ec9d0ae3584aa6dd62ea1997cd831b4babd9a4da50932d4efda745c61e4130890e156aee6113716daf95764222a91187db2effea49d5d0596102d619bd26a616bbfda8335505fbb0d90b4c180d1a2335b91538e1668f9f9642790b4e55f9cab0fe2bdd2935d001ee6419abab5457880d0dbff20ed8758f4c20fe759efb33141cf0e892587fe8187e5fbc57786b7e8b089612c936dfc03d27efbbe7c8673f1606bd51d5ff386f4a7ab68edf59f385eb1291f117bfe717399 +99eaa72ed6a8e331edbd368c47cf409604969e7f7c26f5f4958cc01f5cdf92aa 6a01830af3889a25183244decb508bd01253d5b508ab490d3124afbf42626b2e70894e9b562b288d0a2450cfacf14a0ddae5c04716e5a0082c33981f6037d23d5e045ee1ef2283fb8b6378a914c5d9441627a722c282ff452e25a7ea608d69cee4393a0725d17963d0342684f255496d8a18c2961145315130549311fc07f0312fb78e6077334f87eaa873bee8aa95698996eb21375eb2b4ef53c14401207deb4568398e5dd9a7cf97e8c9663e23334b46912f8344c19efcf8c2ba6f04325f1a27e062b62a58d0766fc6db4d2c6a1928604b0175d872d16b7908ebc041761187cc785526c2a3873feac3a642bb39f5351550af9770c328af7b +09242088f93a06bc379e4c5a0df13c85294b6b7d8a1694e4cf1e82cbba70e6f3 b3c5e74b69933c2533106c563b4ca20238f2b6e675e8681e34a389894785bdade59652d4a73d80a5c85bd454fd1e9ffdad1c3815f5038e9ef432aac5c3c4fe840cc370cf86580a6011778bbedaf511a51b56d1a2eb68394aa299e26da9ada6a2f39b9faff7fba457689b9c1a577b2a1e505fdf75c7a0a64b1df81b3a356001bf0df4e02a1fc59f651c9d585ec6224bb279c6beba2966e8882d68376081b987468e7aed1ef90ebd090ae825795cdca1b4f09a979c8dfc21a48d8a53cdbb26c4db547fc06efe2f9850edd2685a4661cb4911f165d4b63ef25b87d0a96d3dff6ab0758999aad214d07bd4f133a6734fde445fe474711b69a98f7e2b +03c9894656d0d1a69702c1ae8418f59d22d62b6de7c1e86e7425a2f5a1e97bde 83af34279ccb5430febec07a81950d30f4b66f484826afee7456f0071a51e1bbc55570b5cc7ec6f9309c17bf5befdd7c6ba6e968cf218a2b34bd5cf927ab846e38a40bbd81759e9e33381016a755f699df35d660007b5eadf292feefb735207ebf70b5bd17834f7bfa0e16cb219ad4af524ab1ea37334aa66435e5d397fc0a065c411ebbce32c240b90476d307ce802ec82c1c49bc1bec48c0675ec2a6c6f3ed3e5b741d13437095707c565e10d8a20b8c20468ff9514fcf31b4249cd82dcee58c0a2af538b291a87e3390d737191a07484a5d3f3fb8c8f15ce056e5e5f8febe5e1fb59d6740980aa06ca8a0c20f5712b4cde5d032e92ab89f0ae1 +d16b9501702423d6497a1922352b8b298df15b72ebaf83687ea808e1b4c2fb17 a7ed84749ccc56bb1dfba57119d279d412b8a986886d810f067af349e8749e9ea746a60b03742636c464fc1ee233acc52c1983914692b64309edfdf29f1ab912ec3e8da074d3f1d231511f5756f0b6eead3e89a6a88fe330a10face267bffbfc3e3090c7fd9a850561f363ad75ea881e7244f80ff55802d5ef7a1a4e7b89fcfa80f16df54d1b056ee637e6964b9e0ffd15b6196bdd7db270c56b47251485348e49813b4eb9ed122a01b3ea45ad5e1a929df61d5c0f3e77e1fdc356b63883a60e9cbb9fc3e00c2f32dbd469659883f690c6772e335f617bc33f161d6f6984252ee12e62b6000ac5231e0c9bc65be223d8dfd94c5004a101af9fd6c0fb +0066894354c34948d24296383063e73ccdd2600611bfee86a143e7c21e4ab094 a6fe30dcfcda1a329e82ab50e32b5f50eb25c873c5d2305860a835aecee6264aa36a47429922c4b8b3afd00da16035830edb897831c4e7b00f2c23fc0b15fdc30d85fb70c30c431c638e1a25b51caf1d7e8b050b7f89bfb30f59f0f20fecff3d639abc4255b3868fc45dd81e47eb12ab40f2aac735df5d1dc1ad997cefc4d836b854cee9ac02900036f3867fe0d84afff37bde3308c2206c62c4743375094108877c73b87b2546fe05ea137bedfc06a2796274099a0d554da8f7d7223a48cbf31b7decaa1ebc8b145763e3673168c1b1b715c1cd99ecd3ddb238b06049885ecad9347c2436dff32c771f34a38587a44a82c5d3d137a03caa27e66c8ff6 +8843695ff3055fa63c6190500ebfe5a4ba4b64706d0f4fdbdc49b5834b34b28a 83167ff53704c3aa19e9fb3303539759c46dd4091a52ddae9ad86408b69335989e61414bc20ab4d01220e35241eff5c9522b079fba597674c8d716fe441e566110b6211531ceccf8fd06bc8e511d00785e57788ed9a1c5c73524f01830d2e1148c92d0edc97113e3b7b5cd3049627abdb8b39dd4d6890e0ee91993f92b03354a88f52251c546e64434d9c3d74544f23fb93e5a2d2f1fb15545b4e1367c97335b0291944c8b730ad3d4789273fa44fb98d78a36c3c3764abeeac7c569c1e43a352e5b770c3504f87090dee075a1c4c85c0c39cf421bdcc615f9eff6cb4fe6468004aece5f30e1ecc6db22ad9939bb2b0ccc96521dfbf4ae008b5b46bc006e +29a2913d7b509828fc8dbd420dc76ecac0f007569d9df431294bf3d6cdd9ae9f 3a3a819c48efde2ad914fbf00e18ab6bc4f14513ab27d0c178a188b61431e7f5623cb66b23346775d386b50e982c493adbbfc54b9a3cd383382336a1a0b2150a15358f336d03ae18f666c7573d55c4fd181c29e6ccfde63ea35f0adf5885cfc0a3d84a2b2e4dd24496db789e663170cef74798aa1bbcd4574ea0bba40489d764b2f83aadc66b148b4a0cd95246c127d5871c4f11418690a5ddf01246a0c80a43c70088b6183639dcfda4125bd113a8f49ee23ed306faac576c3fb0c1e256671d817fc2534a52f5b439f72e424de376f4c565cca82307dd9ef76da5b7c4eb7e085172e328807c02d011ffbf33785378d79dc266f6a5be6bb0e4a92eceebaeb1 +df7f65c50b8670aa5f33684d5de178e4cbabea4ff20bde5561c2c70b7f5ddf08 724627916c50338643e6996f07877eafd96bdf01da7e991d4155b9be1295ea7d21c9391f4c4a41c75f77e5d27389253393725f1427f57914b273ab862b9e31dabce506e558720520d33352d119f699e784f9e548ff91bc35ca147042128709820d69a8287ea3257857615eb0321270e94b84f446942765ce882b191faee7e1c87e0f0bd4e0cd8a927703524b559b769ca4ece1f6dbf313fdcf67c572ec4185c1a88e86ec11b6454b371980020f19633b6b95bd280e4fbcb0161e1a82470320cec6ecfa25ac73d09f1536f286d3f9dacafb2cd1d0ce72d64d197f5c7520b3ccb2fd74eb72664ba93853ef41eabf52f015dd591500d018dd162815cc993595b195 +ff4115399db3d9191ff17588c947f78733eebab655103737d5bd264fa72b27c3 3139840b8ad4bcd39092916fd9d01798ff5aa1e48f34702c72dfe74b12e98a114e318cdd2d47a9c320fff908a8dbc2a5b1d87267c8e983829861a567558b37b292d4575e200de9f1de45755faff9efae34964e4336c259f1e66599a7c904ec02539f1a8eab8706e0b4f48f72fec2794909ee4a7b092d6061c74481c9e21b9332dc7c6e482d7f9cc3210b38a6f88f7918c2d8c55e64a428ce2b68fd07ab572a8b0a2388664f99489f04eb54df1376271810e0e7bce396f52807710e0dea94eb49f4b367271260c3456b9818fc7a72234e6bf2205ff6a36546205015ebd7d8c2527aa430f58e0e8ac97a7b6b793cd403d517d66295f37a34d0b7d2fa7bc345ac04ca1e266480deec39f5c88641c9dc0bd1358158fdecdd96685bbbb5c1fe5ea89d2cb4a9d5d12bb8c893281ff38e87d6b4841f0650092d447e013f20ea934e18 +85416179e046d3921c196f6f8cd1dbee20ba83bb3c1f8971e90cd6ce6e3c8b33 023d91ac532601c7ca3942d62827566d9268bb4276fcaa1ae927693a6961652676dba09219a01b3d5adfa12547a946e78f3c5c62dd880b02d2eeeb4b96636529c6b01120b23efc49ccfb36b8497cd19767b53710a636683bc5e0e5c9534cfc004691e87d1bee39b86b953572927bd668620eab87836d9f3f8f28ace41150776c0bc6657178ebf297fe1f7214edd9f215ffb491b681b06ac2032d35e6fdf832a8b06056da70d77f1e9b4d26ae712d8523c86f79250718405f91b0a87c725f2d3f52088965f887d8cf87206dfde422386e58edda34dde2783b3049b86917b4628027a05d4d1f429d2b49c4b1c898dddcb82f343e145596de11a54182f39f4718ecae8f506bd9739f5cd5d5686d7fefc834514cd1b2c91c33b381b45e2e5335d7a8720a8f17afc8c2cb2bd88b14aa2dca099b00aa575d0a0ccf099cdec4870fb710d2680e60c48bfc291ff0cef2eebf9b36902e9fba8c889bf6b4b9f5ce53a19b0d9399cd19d61bd08c0c2ec25e099959848e6a550ca7137b63f43138d7b651 +aebc4e7b9af59a03cf87d2bee44f7ed8bc4fc5f95b99a241967a7a8649b054ba 20ff454369a5d05b81a78f3db05819fea9b08c2384f75cb0ab6aa115dd690da3131874a1ca8f708ad1519ea952c1e249cb540d196392c79e87755424fee7c890808c562722359eea52e8a12fbbb969dd7961d2ba52037493755a5fa04f0d50a1aa26c9b44148c0d3b94d1c4a59a31aca15ae8bd44acb7833d8e91c4b86fa3135a423387b8151b4133ed23f6d7187b50ec2204ad901ad74d396e44274e0ecafaae17b3b9085e22260b35ca53b15cc52abba758af6798fbd04eceeced648f3af4fdb3ded7557a9a5cfb7382612a8a8f3f45947d1a29ce29072928ec193ca25d51071bd5e1984ecf402f306ea762f0f25282f5296d997658be3f983696ffa6d095c6369b4daf79e9a5d3136229128f8eb63c12b9e9fa78aff7a3e9e19a62022493cd136defbb5bb7ba1b938f367fd2f63eb5ca76c0b0ff21b9e36c3f07230cf3c3074e5da587040a76975d7e39f4494ace5486fcbf380ab7558c4fe89656335b82e4db8659509eab46a19613126e594042732dd4c411f41aa8cdeac71c0fb40a94e6da558c05e77b6182806f26d9afdf3da00c69419222c8186a6efad600b410e6ce2f2a797e49dc1f135319801fa6f396b06f975e2a190a023e474b618e7 +b6a6ce4a895b2deadc38f22151de8cfb7a5b5232f2068777ebbda3750e402eb1 4fbdc596508d24a2a0010e140980b809fb9c6d55ec75125891dd985d37665bd80f9beb6a50207588abf3ceee8c77cd8a5ad48a9e0aa074ed388738362496d2fb2c87543bb3349ea64997ce3e7b424ea92d122f57dbb0855a803058437fe08afb0c8b5e7179b9044bbf4d81a7163b3139e30888b536b0f957eff99a7162f4ca5aa756a4a982dfadbf31ef255083c4b5c6c1b99a107d7d3afffdb89147c2cc4c9a2643f478e5e2d393aea37b4c7cb4b5e97dadcf16b6b50aae0f3b549ece47746db6ce6f67dd4406cd4e75595d5103d13f9dfa79372924d328f8dd1fcbeb5a8e2e8bf4c76de08e3fc46aa021f989c49329c7acac5a688556d7bcbcb2a5d4be69d3284e9c40ec4838ee8592120ce20a0b635ecadaa84fd5690509f54f77e35a417c584648bc9839b974e07bfab0038e90295d0b13902530a830d1c2bdd53f1f9c9faed43ca4eed0a8dd761bc7edbdda28a287c60cd42af5f9c758e5c7250231c09a582563689afc65e2b79a7a2b68200667752e9101746f03184e2399e4ed8835cb8e9ae90e296af220ae234259fe0bd0bcc60f7a4a5ff3f70c5ed4de9c8c519a10e962f673c82c5e9351786a8a3bfd570031857bd4c87f4fca31ed4d50e14f2107da02cb5058700b74ea241a8b41d78461658f1b2b90bfd84a4c2c9d6543861ab3c56451757dcfb9ba60333488dbdd02d601b41aae317ca7474eb6e6dd +cb2d5a48170bbcd8dc17228d63de0a4727b8ad3cfe12c3bce62a9de460d1479f fe06a4706468b369f7624f62d04f9fac020f05152f13e350016b2a29efff9a393940c138553356b0e2848c01b622b95ffa11ab07585f7dcbbf90e9f8ec5fa2fb7b4cee0d0a4e8d33490abd058cf3bb85f0cd9b1bd3e9823082d70b1a92aca6f2c87216b4ba09feddcaa4cf254336146cc75604fb1f286918fa2434ca36be2621049438a400bdeea6c657f0301503cd7e6e38350838f60ea7f001755da4142ce4579b39029da83f1646b7ecb9947ee89aba377099b82026960b9ee600779bf00d6eb0cd09226db6915a7aded27e6749e2cbc2c8b030ce1850ebfbe24c0658f29e9e709cd10db8a77efdefc90fdd7b9ad7a7e0334412a53d248c4c12bf2987b7accd2a8a602f184583aa560c016093b56b100154477b834664e6b85a19f8dc909b4d79816af12266c731e29a304e9bed8ef1c8030365b7deaf3d436957308117c7c5767e0cda6e342ddaf824233cbf4e699dc667357cb35c602ac6bddee71b352af55cb93941a1a6301a9904447af9ee486114d57ae03901f10084adc0096e465e2ead2496273112f2fae626e230d42ec22ea10a8289b3e35eee42150769d6e663a3ca29174316ec93a24f148d984053b8f98664eaca3e0dea0b42e8ee30f81a2cd6e42c189a25fecb6e643e693e1f8871b837c3f5ff2aafd1650a465dc8e5c1993be65cffd87f2c680c86b0ad3118834a5f2e490015137ba945c2775dbd77fb3e5c67819a9a7a94a656fc4761659c5b30ed2ac55a6d249b700bc9c93d590490aaaaa75a9fc34a90d5a9106f2860bde19fe5815436068a7f8ea4636a +8de83bb217c6dbc8697361388665c921ae81ad8b1fc29f1d117faab5bb2f2481 d0ff6e045f4b636f75a389799f314066644854821b6e7ae4047adfde2d0c0e02c250f0be582bec94011189b964a8af430f5921ed9d9f4446e4c788515b89ca69e5f7cdfccc9e83e8f9460145b43ddc41c07cc512b7e6fdd0e1e7aaba29a6c016ccb7bd54b145f3951eab9bc4908f623e5a9b0c5b36056292540b79fd15c53457dc74a65fd773a34d6b313a056f79bc29a3fac15f6a1446bfaeeaafbac8ecf8168dde5f6ae6b6e579bd3ce74e7abfadf361d0fd32d56586a8d2d4ff4cfdf8a750fafde4c2e9eb32b06847fa30b13cc273532d1a23c8257f80c60b8fa94fa976f534145cd61c41c0a511b62cadd5848ceff643f83ce43f8e6969c5a559afad60e310599a34b2e5e029fbddf2988fce59269c7128a1fc79a74b154d8aa2850dcfdbf594684e74099e37882b440367c1dd3003f61cafb46ac75d30e677af54559a5dab70c506cf61a9c35e0e56e1430746916ddeec8d89b0c10daa02c5d7e9f42621d2b312eaffc9ff306297952a32d26c2148570aec90501ca739ce5e689e7066d9580a4fc25e2023897c74c6856273133e1275a0d275dc5b75db724cd12c9c01bb95ab5a227b7850020630506096878d289923177183ea9282a4c78ec212d2e898cb99d81a3364df20927ee34d4475a5cf5cdb24088ed75b60201922e9c972d8556ca75f8274d15f3fb88a6b42c766def6b21329dee7c457446dde8c26405fe5d0309a04229f449e8490cf9000ee8df400cb7c7ee831bd7059d24088fb42d61681cde45050fca78ff64d9c8d1f58b55f802fa5d2f2e723f3e4eed4338b060d31c8acc46d26870bd45d0de0798d48e32aad1a6d4322e69f5e72309b9d7fa1f24bb1d63ff09ed47391c232497bf222c542a70975c8292d275197a4ca +3a2c7b8656ae28c125a588e20eda947a50d4fe1b8754cb80575b701f01891bc0 c9a0b51f3199339c11a5753c9d9c95104b400127087177f14d3e15be881ee89bf416f97d4f7aa9636c5ef29ebbf8930804006eb26839415d3984b920882499752c36a5bbd583308e716db16f28db98b3a3e718a2ebcdfefa75d7ccbb6a746e32feaa38d034843461dbcfca7f983e19f5b23ec2e3d74d2b4402f3bdce7d7a9df1384668c746cce466b0654cdd5ca56a77d68a100ae06d63cd9af512aebae78993808ce672330e2065c0f71e05c0fe821cd5f85732315f04666f3e4e6c4f3e9f415e31fe0980d874994108e12464609c6d5c19cedfc85846b0a84ef3ccbd3b655fb0de8cb892bdf774df39c955f04f322856d470981beed0f752d82ead73b4131c5dbf0424b4ab654f72e26ef0cd292b87bd5b66fbd5e7eba96c62cffefd4b1d870bfef312b86e38ed5c0f50935e2ecf9fcb8c95d35d19a8fc8f202bd9dba768ca48fbbb071179413c0de4fde86762ed4b13e1eef2a00add5d1c2a3af7937787debaf1f6f12f3f0225ffe587a5540cb550f7bc11dd6af864d6b6d16db1488cb226ebb2199da75fdd59a71158867298f63961b40a31209f8f16629b1cce7ffb617072748fde8920d11cc0d0678389d1f719df3ed19846fe9893b04db60fa603170d9573b1bfc7da663e07254552ab6253dde814117185f84373fecd7f98ded170c884d41d1ac81814c73ea48ad94eca1b7733d8393e320c8c467ef6189b4ac324c68c8a2ecf679c893b7dbc4310cd05dadd80bb6326b51ecd99a441bff77be8d644d752f3c5c794e7d45ba76283acf8913bbf2a420f9e5d14d7a23e95fdebc69b455e466423012e9d1de9353e40d4bdc3107c3144b96c6dafd41ccefeb2b7ff848cb9fdbea8648be32160fab7e7dfccb807fb019ebf159231edcf2d487d76a3e882f3f50ca48dd08a23b06ee887bd7df9d7c6cc2bdbe348e3125c4532448f400cd57a8679abab13e582b13d49442638e2698fb7a563c7fb264157 +34ceb42384c798a41a6b25e5866827fb533e23ac512570789dd46bacc7177235 da5b2118cbd59f408ce56362489fda69ef73172f46dec16c0d4a66e3f3cca373927cb6784ce62bbcb08a490d003a8f77391e82cdd87860909383b054db95816720112e2f96de9e0ffc8babc1350ed46b9aeb5d46b66940efa311f4853f3118063c550733e7679d871729001c12270e98439e375e0cd24769d318e03cbc97d643f1dc5f1b5ef59d12789f22449bd8fa43a13ce78a4186166523f3807b0b621079cc528f4e17c258d4f9bdd095a3e365614b94f2cd778cacabf26244891531eedc24e1bf4598319eb8b7527736bb1e734429360f47f04b2e95d5aae997763a467cc5303d1141c2c01f7ab9edab860d180697c906ce1558aeff5adce603f8a4a10fc6c1699189e73b489f64cefb89ac557c5bb8826c0317eaef2302e855fbd96777898104365d96ae8a8ed8669c568c4dbeb0a70f6cf4c22fd933014473f91871c08d5a7b44a928295fb2aa56d5e2c39ca79d2837fb39b35c6810c378d749aacb543368a19c137b872229e0a6f469022aa93bcb2be38b761c85ac09415ca7deeb38ff2a2101507206fe322a89666d32750af0f4d7b2e59571f02a048b8f94fe2d231072e301c8641d1cdb4f841ab165af297495a348bccd937712e68852a4aca948c1294f8b733d06d67de89f206498dd401e149fcc1edca92deb92952ede4ebdc7cd7992104769a04de8705027a31337b88e8de93f6624e8f10b9f9924e8ce5a9d841c9260753fa1492cddffe6b4400c5719d76fb5b01b234f32ffe64f04d0a00676fbfc58dbe17b4d552fdf0c5b802c0cadf723f73f86e8ffc493992d23e8c0b84f7220a983ddda21170b1f730c736e75549af6ecb8dc94fb25c26bcddee420c83e8a45ae4c345816b7163cfe016dccfe47c66979d610a7f9b4a7b1ba5e230344c9f46ba076f2fcea68aada8fa09bf0b5cbb3850ddedd80a30e1f7a639ac69e5595c6a4083aa959831ebbeb84c018068723192f58baecddd18c857e212d4c7e7215b6c954728183fbaa07720b97189af6a7729c30d28db33a889f225d027d164f254535770c504c506aee4ec4676771f69f935ba08a1c6c85 +f640aa22bc2f56fd723f1f6e83133fa95943ced744d1bd2c8d0a84ecddccb20c d1890b4704e169c28e44ddf62a1091450404910539fc2daeb26e8acf4533b024e5215c2d02820dd8fb2cfc1743955cbacff0f8f35dfbb5e3f942f36247f68211d518f3f601aae12a1cdc000bab43d4c973f287e80741dd1fcf6c34f2e6b4b6c313d01c4ff3cbf9166f26946f18ef2d58271ba9233f09a6b77bfd4f48b36eb3d73d1133c4f842a7dc3907f680b0b773242c11e3dd973a44327ea7cea9c0f8e07d682b6651e506b587559fe01ed721000baf570a16fbdd9ea29fa3def4be912058321a8b720c5c102e48a6e7ed6f8838d400dd57d06eedbcd15323f86d855c94b21e41b14ec9e1bbc8019211fd88138c91f9abbd9bb3914d26c1ddc21673d2d51263b39d66e741d924cf2b192c5d2c1a140126a3d64a2c77be6c2c6ebe8599978ae90bd36cbb9af64d078910c4094ab3bf399c34f2ab8ef843e9fe1bf88bf443ba21e4377e5f49c07fd9653b526e14562237f02d11b904bca6ac31ae721a43e3c4910a24af6f4d80c031c109fc0fe49f15274bca92bda04c3b4196c192f6ce489c63a806acfc895ab52cad657c1783b528e12d0ed856e1f8fc91f2aafdfa0a92498d68530772ee73b359fcf1418d1096c46b34dcf90e5b468bbb2970becbd70089cfb039d64cc50fff5eef26384d34f24515a6558b06a1fdd88f1050c5bd78cc6ed83d4c2b0e882aebcf84afb0430d0bf09f2fb42b8b4589158093a7709aae75a790910e211ee1333ffb6fd80778da3bf73858978e9dd647978841b18001dbaaea43ca0c0a03dbb9bcf30ce76a6f4b2cf2a9b6531b3e4051e7e05090cd421bc66c4731e7122ad129fc42dedc83bb460e3f889992fbd3ca072686e56b72c720fbc98d723ef7f247286f77ccddc728738e941b1a74d4f16671c21fdd5643a115ddbcb88ee7ec67ea66fd2bce718df6e085d4b5fc71a72696636a8f7b3a68afa51a896771faaa7f1f827430ac5e8089dbc0d4175e1b22a057bc5f1724eadc1a41e78fa3acaa8b97e5f2e19ef9d59ae12b04e7f0e8a621e098a66910e2a5ed2102b824cd3ea044a854f1cd0b33e61e7f737414b2953549f25dd34d19aa1981de7cd5649ff6c6364a4f25312ef62395a747ab88aad722c05aec40deea8eee5e779ef458a68840bc6bd5d29ad40f98b3ae010b6213372abb7bb8b8 +02932ccfb76d27188139a4822e3746a13723dd439038f69cb12bd066ed3d88e9 d9257004993c7ae50d20f534b42b4ec39bf358393b9fb5c8e37f87ac7361354554be596f40e67b2ed499887e26dc435c4331cde3bf1a118f60fd821477ffa3b92f6469568cd2cda6fc0a2b13906ae459cf5d5417de2ce104d0b6499d3683beb40715582ce70ded5c5f8461edeaa38bfa31979661a2dc96d926307128f77700f2c7d38b8a9d6c6f70a3973005350f938b9b4a64e228cc3b3f9c4fd446fc650aa6377152d7f46903d8ec8e9340710e28475cf21e641737e7d7da3cdf18d01c8f37131e727c7274b2db759c5586fb84ec36a5ce2d820e553de6426b8b96111295c19dba8d17a2b7047fcdf662a59c2af27a9abee37a7f8afc06944346e343e779ebd895119d7460e7da998962fb1100e950a8d7fe214360ad263b8d070f2b7dc91c9d77c6692da0f472a0a4646a1edb069ccd9ce4ca6fc24713d650153b9a253db5136a3710198e60934dd2053315d313e27dd2c6ffd2ecf028625f0e937afd8c2ffb1f646e51a768204d83a649798a51b8e87fcdda7bddf58ed943bb7e29c7d7c5dff024545f6a689aa0e727fecd80b561011a731acdd9b3f283123098ba66b6b9fce6123b35b6f3a20ef1055be9e257cde97e5af41eb796438727a62aa665cc9b771c4a2052efac61bc91bcdf573f7263107d44dfeb125e66d1f3dded3bd63845af3bf4185a9a24a7f4b777c32496a6107b7ac940af24be983f6a758e5064f8717eabbb86e6aada7da75f72abed59a42de82b1aa2642f5ef1b2e7304f642eb2aafbf00c1183d9b5fb83893edd48e9034dc7a7ab66f3f392f9666c00ecc9743ac4f777edcf47b6818a34b7392b4ab8e38891fab4018dfb99af06369115d60c4fa073240d9c2605e020a42db2e1e0ae4ade3a04b825927a05d4fe3f50c1c7add7a496da7e95825c064315196c2007524d1e1ef2c51303dd1203ab66d9fe89de553cb4b95a6c5d629b89b7116463ee10ab3cf2c2615f95741ca226f9e9a20e99303888f725c77476533b4c393763170f18f292c89a22df68eabdb81aef11cc2ac329c174bdae5d3cc0bdcea6eb225e00c15021432264ba7c5eb49a49231d1f7a13afc238bd4efc04da3c15ae0bb7d693a0150e6a5ad9b1e11a490b3ce90c027442501684c528fe260881162d9e5ef84d6e4f73f222e779e58b71d5176d9a27f65e49d83efbb2d7810e5b06619d8cef7e7b51cdfb6e8138e4cf5674242f947eac13fad08d68a8a11aac9754a5316c93738ba7f3c3bd2e827a +9b5668b8253457df9296876436d9d40f031af59539436f13f06c646932df109d 09cf132ab943654184a3fc8d0368b421fdac4ef1081a29f3691a527fbdbd74c6372233b38dc432ba610f9c54fa68699f9ec2a6bfb0b2cf7aa6d10ae2207a7554163aa14fb6a9cfa023ce63546b7b02af03370a899ea73b27bdb5c380613c0ea670c659803d5f6f75c0ce62b311dc157de843a93905e7a28a2557684ae3db4fd009412a107098f881dc06622ed9e3df2c8fe69fe50bfae158b87ca761fe1e221856610bca301ee68958c25bf58d3be203af928a919ace53c3d99f55ab00dfc8a1a28ab83e78617f194efc46daa77573d02ffcaa1f9d96fd8da8dead3d4e75ee5e65fc360b2a567cd34d52bc9aab8b71160312e8e21aa506105d6644e6863e7d5e75ed47c1760743d113a4526553b303341fcee5fdd005d35929f2afa760bb8314d0c0eac960fda3263a1e6688098251618c90332005c757af958714571b77bf2a69030d99f71d1a5259658be565fbd098070122c43edfd400999c90a98ace95315faee4f1c0441c9315d527c7ff1a8171415d2a076e2c513d40b03cfe5513c0e74ea3a03ad4958c00a3e1916d34273e301d517b0a5e770393880d9afb4d0eb44d3140ff7d827c48f67c6d92b865d8fe7c7e45aa50dfd8525f530de1188f3af98b3dc625d335e191fbad5ee9df09c97b43f203bfed798f7d171bf00c82ea0ed17d5890c3d6b9ef6fdc04c5ffb645e3050406fe2fb6bdbe2ffe083e751dc19f2f06445397019b61cf1f505875520f09c6b719e642b81b2fbfbdcc072b7981a666d51e7065e21244679dfe056bc9d42b8851f9d2905fd838707b279a8106eb894b60a72e4851c344119ceeb5bbe110b1c5b21c9a5f7545283002d4b1c115308b1cb20f6d9cb869ed0459c569662aa5729a7d7178de7d69e4885ca77c011e785ecf0e2ecbb8f5245579dbef7a5eb30307e0b40b817bd1112d28eefd548374bc867e0c34d2236952b9f859903e87e977190ff94f5d815699154f96e5449ddc1a14e4196c83e4fb02f5f58c30eeed691de47c81f4883bd84f6ed711fed0c198bfa2b8296182d7225e8989acf55d3612a93e77d24f7b6eef813fd514ce2183571602976391f5ac4e86da59a64233230fb67ff0bb9ec40667f54ccb235d04b3fe1d9a47e163cb19c316046fc1353a6642219e9cecf6e3151c0f4fae1177b67f19b4964df96bb6af37012b8ea9e5ee24c57a010c872b15c8a65d0266589f6da20e38d9be2e2c215c69f558084e48eeb61f4eaae83c57f3f1cd08d05783fb9f5ab1cda5e4b86291fffb14fe9b497ec73292bbd295c5657d71cc74d38a2f3db73ba972986b7169f76ba376376f4747ed65f2f1a5e67889af38a380 +855dee08ef1aca391266889139c4cc2cd5818efcc3c2048d0a0a55c479775221 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 +b98f79e84c65bce8806e756de95083a75df3d597807e025403555bad5f698742 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 +49c978a31ad0ea1a2ce70f0c23069ea5121ac5260ffc459657b19d0c891bf98d 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 +92449ff6c4031ed17a8312f892377a3cc24b59aa615640cfc2c9fefaf83a0eff 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 +3a045f1db785b36e84069ccd5ee242a609e2c8ff5c13a73a04234f78ef7ecbc2 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 +103279a389e9d96ece9d7e2c7474bdecb7affa38a0964c9a032ce5d76f73306d 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 +13c0a87bcb0cd8c07eb745257c51f236c36c90a27a2f6637a86f39495e15b11f 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 +5c0910b7d5b5f188651d42f77a33c61b870ed2bb0fa602827e1406e78f6bbddb 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 +3765ac7f690548081ff4ba51b5dee24a9845f9128459d3e634801b9c38761f90 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 +cf1a67e45a7c51e5d0741bf813982721916a47469820981b852dcf0ea2819a89 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 +12af510e5211ca3e65985ed9c938b18c9af7571b5ab066c9c18c2eb513a45e25 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 +91b0494b3658b10dfed194a743c78cebd7ac31a18bfcef300bea5fd268719eb7 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 +8bde8ef3c0648c97e1423a987680a99c85ae871fce8863293b073e41108e002b 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 +0661dfa666905518d9a67d282e23687bc39a92c274071c815798b72e7b29a050 523de8b1f4cbb65e81ff0b6ccd6eb8ef0a0f0a691acaf4a77f25acd2d66ad4b3efd25be70308853c094412a518a32020e3020a9f6ab32f0cd60ec0d7a194917d6c457b168a54a4b46f7b0d0c71bd61cd202f4c718776a701e0770b0efa05418770f98e4e79cd066366fb3300e8be359a98b82b764bc2fbbf59c7e8f94a157b01c6c7577b1428138cd422bc47330f8ed99f4c0aab0d984287445539839389ee08d6345108af26aded0ec1d7be774cfb8c5205dfe07cf6caf8c1afe37c7a2e4fe6013b93eb2463de4e0971c7178d6a76b16a0e8960c984ce8bbe71b3b466edf0445b835f09414d01f14c7b6167ff78ff118127bbd5f812c27facd57b3b120e2bcfe87315c7a92b82ef5d50ca14a7174d1bea7e056523e055a6ae42ea3765094e5544e5ed003c989c2f98f38a17e3dda74dbaf9c669a319638a2698b0e4a611480d8ad3cf016792ecd1034925f42b9811a7214d623d047abca31997ddeb03275f80dd21f40ddc80616e7ad3d481e8ebc0a1a6a398e16a78369215541ed10b75671adeb1aae6e11142a1cf665fc1b7332dfbb0e10c21a2b48f78e57319ac9c58dfa8b1c2548e2979ef1accfeb215afcd6c2c1b46fe97dd491758378330effc7283661d2cb84fa05281e9e517408508d24d042e7b9bcd34db87ce972e4cbcdb98615fb93093369dfedc782f44bcd03e81cf93051318b2401ff29f753a264bda65af199e3fcbb8b5d39c838a67d6c7a3db046dc56c323ddbb5340cbc229e47cff8c9d29b7a49ac0ec8c1440ae498c7d150ef91c29bea7df3efcc2871a13a1d72d139cb4603d9fffe85f6ddd544850ef63c3944fb35dbc00d4308ceaa6394b6e23f650d323f8f7ef50ddb68f1486eabf989bf44451f620ec9485c0b52d1415d3c909a2cfbe9d77db19d069d33baee4d77292e63fcbf65c1eba24bffddefe95211ef0aaf8abfda9f94445e582976f986f5382cb669506af2b4a5a0c43000a3c72c5ca4aacdc9d3d39fc5c492a393b6c341b86dacbbf6ba8b465100cc683edb2d9b9f83edf9c6a32645f51cc79adc22a52a007baaca618be35e356d1fd1cfbda73f1ed09253039def609450fd2d5943b9cd49cbd52a318ee3510d7cf3fd8fb388ac6cb9c6eefef3d3cad8501b91cc04a888d33e16d6a4c9666f5f5f3b257193f2b46dedde11842909d8c48ade57775b0b272e2dc9cef1a083eb2ce58f4d1f211922fd6aded1b82fe6f5b11251cd396e5a3666ed9626036e4e356231c146bba0a91afd3648eb7bfe0b9c14f15af2f92309826f468945cad0ac422de3d6a773b76178422107ce0270e7f580b5cceba82ca0184aafa8341141e65e39859885768fbc5ce63b965a0604b659e71d9da2c7a43646088d8071d76926163aafc69e25355bb0a222b7b2da9f0a20c021adc462e905a9c3bf31c16d87fbec3f014f3957a720f1432e1741553092052fb58a198640479abcaa51b104cc93e2636e1460643ea812bd44e819c2166eb6b349ba5bdebad59078910b5c22a56f004b8d9e4b1224d8d204b48abe7355548a402736c5cb110f3a1476ed631ff168f4f3efd89b38de4751536548647523d334fad7cc2d142973f2db3c1fe08fc5cf83f9f2bd2daa524b37864816af29ee05951fa09d1c51d9d14ee4f72fd7bbf18b1a724ff5a0958a063947c430142ad2356e4400aaeca442e163372a8f1cd36e2db988e7781165e5d4e7074ace40858e8370e883694af09977704347fb735c8717c42bc4eeeb2aaa50dfe637c640909ce379bfb9e2608f88751377038d1669f248178ad580a908d7a1b8dcc7e53e01801f1e485b5893f103f03e0f53b2b1440be95644d85aa7f6eb7edfbb46652196695ea23c08573397b111ff909025e20c5201293b4d223bf7aa01de7cb28b94714370434b9588097e2401b62c7a0def1fbf89809e810749fd3ce9ec3c07ce4bf4c43dc966429b2beb4d711fc6c448a12097b36f1e6817eaf4937a983f85d9cf3e62cc1b2ac6ae1ec9eaa8cd8ee2c3322239cfe5db3d4e8786282e630a7d259c2fefeca03031c960a66a71e436a3ed6f2f3cfab4bd77c660d14205abf606fe561a346f7d849b69475ac9f6822d80b9a2e56d5d495e4b309b0ea963c9fc5c7ef94b217ee5337989afbc7107d233a8b362ac27c4f69df9e191cd65ae97d6eb9e5484eb6f10349575e4cae51452380151f902415ac9cf42c824eb23c9541d2da1c26db85f53cdafb06a12b8393cd580a8e494edb6710c720dcae30832967e33e6303a92b1df0841d7724284ffd2e00b95c6d623b168d21ac1bd3c675eda33182a2c22370998de1e5eb905372cc6ef32d5b765f5c94870df4842d011603be4cdb1c227e41eb2f2e8542cd325884fedc9c5c7bb07a92d20d64b836215c59f162a3da8bb67d6fc13fef97cab6ecb8a29e431a6519a6261c4521ccb90e6e609869e6fe398404ae047f64ec4263566defee66329dd40ac985eb8a08d26529a544891b6f57cc235c63c09057ab6b6ed720ef41a3c9ae65768b43f6dcf4962a103dd93c213171dc2c9194e43265c689b49331450281a3febc618d1aa4d65a135137051fd46b568ce294c89 +150904206aff7f668da603bfd7a3598fc822205390366ed856aeda360ea3ad3e 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 +81c07cb8e6f763fc3fb0b4edeed131ebf9ce117d838f48fbb894586da17ca30a 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 +9b98af5ab3c3253b89fb51dcdd237c9e983198590948ff868a8aabe8c4dfe474 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 +ffd94d687f3fabac9518f20ecb10ff0e2aa1370fba3458a82580358ba301fc4a 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 +e82256801bbd45241fb49bd3177430a3b16386ef7a10399ff2372633f03cf346 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 +6ef35b31742b443a0368e9bd630767a56543b34096329ca41215c04869afb8ac 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 +348cc295d0f0fd7071771fe479bcad42315e1c345001c65d01fbdf6f3782dbdf 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 +a4faa1736367886749614a6445b4b9a78a4ab8dfaaac465bb3a0dc49e344d036 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 +ff09ec4542b83f530e100cc8493a8bdb566e902a7a35246d202e23724bf07bb0 34a8b8956bf5adfa5ef8f10b673f6e53bc3fef8dd1f9428078c256a8fa1d8da1e724ba90b65bd4394eacac5469c520bac2ced1640ba26efef44f50baa72a9e7cc8bff69eb8719aa1d88a2450f5c3b4fa54a2977ced1a904c09356f483301add61006524ff814ca0b1fd50d3f3a30492ba70c2921e3b9da58cf8f5bee32ac15e39371fd9d784256054a3d145563c62e7258fff3a16524d38767a75fc27fc3d0a9f0f585a0046d6369dc6dd17fc65b53380184b4d9eeaff245fce1aea0d4e8407d2ebff6ec0fae8b654747eecce13bea89d4879e0c92e1f47ead8e5cd7f56b04c62c2b7cc13c5cc2d9e6a87d77de73e54dcb9829001a3a9813dc1958e4fa10bbe4027822f8923af17d0b04bde97b9810b31e26ff74f9ae95e50c6ea25a49ee557559c2c9c83d01737b6cd7216c46859d2833f04def7a7efc849f8b13f627e20fcf0cd3e0b1cc7d0b22b4ebd576cbc2a397828eaed2e4afe51104507c0b3176a74a0261a159525e0883f4514f1856d1bca3ceb1084441e99facdcc5b7edbc5a4c803f6448119745c23e5d795a0aa96f31a48f431960b3c41c9c6b13a22826743839e571f40bf5c965eeedb293dd5ddd22442071895bd9c34d8a344907e17af7ef48008801066aa8f434019d95a01ce34c30dc116d6a5d9f6d43bc2cae327b613e61299e75d580c7323eceaf494d54825553c98514d841568f5bce9c97194ec36a16f6b10d9f1808ecc1da80be4d37735adb6d1b83a157edec266612e65e57ee419abfc35e342a6772b5ffe8ab1d8095bc92bf9982a7a32e8505d8f2bdddd626d09f208930427f14111b91ad66ebf710d9b1eafb22fc34b2616458283e9fe1218a2886a7b73742342962bfe5dfc2f829a77226fa8bb6165efc66873d618d8b6acece0412515c5a032e44685f7354f2df2ca1f903ecf1a53894a9a87e07fb36759ff666560605ca55488a7b3bfcfebf6a0d616417c93835ece08fb69450e041a7c23981520ce03d5194dce2ac492f2e4892b8028a7eafbb913930942fb26643394bfdd67b9381b1581f9f62993708a3c461ffa43f11af679b68f62f2553500ed3d7d04990a6fc1017d8d7aff9b6dd58b22f168161e71ead31183eb338c75c0bfa00a701a19f72b73c5a772090a86bec03e4f9f2554948d94e150310c5aaeee46d1aee5b837695fb49368e59d176e0199cddea6085c897ae2829b10c592553d54ec9a0a7b8b78809a51b9dead66d0879e8d716b0519801ad71fca62d848313d40f8224861e58f0d107ef855a6fe9315df8ee624c04c56473c61c4006e9372cb22b4cc3dde10e60ed03d6d6fc928efefe11ba7cec15351fc0b0a5597deabc58b91040b70bbdaf8e1615ea5246ca993bbf653efec3faff587467a18a4f3868c1109fb355338e54eff58a1c90e2bbdadb0220f22511c5d8cba90ac474fccb0f9dab7b66109bafba8e82382cbb851c2f0869b3bff09a90751b591bdcb617c6871fd8e22bf554f3af8097e9443d0d85f9a7ac3432dc8b3e3f0c8a570e2f97dfb0e4445152e4dd0b0ef1e656dd7b7a50b303b6bbc73439f873737b47af21af435c9703f704ddc153b26788fe932cfcf00e87e33eb195a38c58128a435c81a0dfb42edbb0b9eb27f64c0ffe8357fd995e8ac70bf0c7fbb2622ab5477ca8f65ef1ccbfdde0ddf2d610f7913d7ff69279dd33eaf4a49e3a5326e57ae3e8dfb752e989c99d170389c01c9adbda22846868cbad5f62b974bfc6a5a4a88eb6e04a28752de094391576fc17275d876a5d3b470845a7a064e00be791b20daddbe58812ceb296884fd7246ff67411aab73d049fc3250da9111d1b3f192bd8bc650fc4ac9392eb18840b36d8460a80d7967b20755bfcf8251836961f98b5e717d7f078d3a2cbb09bfeda034274b93e8092d37f060cee0659269a09a11cac907c0ec027da78a723a207b217735b15998ecfb3c43d87aef6671b54a76666933dd98d5db4c7a738c43173e77b2573c7618239f4b664031477029666fb8d3bc203f1190dcc27ba0608b276b51f7cfbbc70f5d4b1443dbe37dcea0354dd288dd4d851f182283fbad31d4a8e5734a28c49094de61af6674960dabb2e6332fd5a9217a92e5cb101223d98a4bd50e56824c7da09af1668b1e98beefa8cc9da8f5b6489ff1f795b6f2e3da96526ec0233604a5c300ca991d5090a358ad21b01e918e5fb9fc0070d3ec1a8647a1f40fd9a662db16aaf39b8fc351d2fb077ba37800258202449db1f1a95fa9def31e48cbbcc594f6ad63cca4fc3eb3bb5728cbfe4026c4a7aba1fed992661e58edd334b555dc93d34bf346410122cac14f774b3990e68508dd21ef27a83d6bb6ce21eefdbaaa2ca63443000ebfafdfc18c0c96d7ff7eb47448fc946a1a096b0008ead107520e2536cff86ceddc93f5f8f727825575c7fd7d528477e14549c91fd86fbeea832d1f69d21d05f220d81af9c241766cad8aa6154dd6661789ebd44b67915f2f55b38eab1074e48b1137cfb1c440f1bef438ac1db4180b4d50cf735d39af8201e9236dc6056d2974b951ab4174751969fa0b33705fb605d2e926a764da3ca2992cc930854075c0da0e5d1b7bcc8b66cb937fd6b92a2776c88c02b391d353759a04b5aba5034905aad61d0c330c9b00969d1fd1dd99284d2313e90a5b8b0803bcc19d702e131b4133bb91ced8aab62b0106cbe3d0ba597c69cbbabe0cf669fe446aad7df1e4e6827e280fe8f2ee91c99b1db44d10a6576a535b4fbc6c76269d1b0252cf482b921889aacba14b4c0a2eb5907611290ce04b29ac5436edb8d5d77a6e8ac5c672d67e107b6a866c4bae36e82e22fe6fc5b31538484402a30a5221fa2357c3d17a1317ef8e5acf7329c670b67d38f1ce60a05dd991ba855c598f9c32e518b95b6aeb84587103815019e39753d43a71a8c825895cf2569786358b78a74a5b47b7dfc3292146badbe0867a353a7285487badde28e9d78f7e8b2fe0e7cf78330d4bada0d606d6d40fe9296eb500cc906545d72596c8c98188673f410576d154e3bcb1f8887e5613c3cf279be307c0224dadf58a91e93211f1173c461ef42f351c7dba499d6974245e1d88ba22830b07f6d735c5a74de475c7f08a940460512eee2caa46705580868d639e46b3fde805aa1343cec3805ceb7e624539fb2b362382f5bf0d55e6f3b90d2125162ae7babdf96fee54b29bfa9effd80a508e80b478ef67997af166b5417620ba5886d631df501eeb242cc40d05387c9730bbe8cb070b2210a8775dd25a5b76755380ba7e2ea02142e43a3fffb6f1bed559caa68b09dfc8dfc1864edaff705bb1e30fb58c3a27c5b1c425b22d0c1073726a2caae5cfa631cc2edac96c10fb25329f0e6d15e4d52694f8670d3d054e9fbb2 +4829078ecb51147b8976b9c3cb281c7a881178918079b86eb947e933a1e56bf2 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 +610b553621f2a760f00e8902c4012ee240704d5e41ce73f613fddbf5d3e6b2e3 cad9ef077a98e3f2e5706ebec4960d5a5b78b57cc8017db1112f2c537076350c807d5cb1421c235ad2f8abf7ce905c26b18566d8fd6af44908269785e789caafa1002bea64ed46b1abe2a8812ffdf400b18a39b731040a8c703d837e463f29d4218cc4ac0e38945f5c79263d2ea86ae52811724424644ee274c55fb6a050782807f3df60547ba058465372c8a664e833b5176ced42c40177cd3483e636ae6f0b9c7aab5dde5309e5f377af74314680a72dc1088afb861e6d564db6db6e6d3e66da3f3d539616408d7b0727cdb924bba38c3bd5ebb823e7f441d2567fb36d31313c5834154abe1623723449fa8324c85a149ed1eb8687be0e8a6c07527bc0d9282651cf36d5596e1e07489131ac3c71b75513ac3acee7cf9098d1d5c710d31a80b2a6037b37228810b885160b764223d4b016480cc9835a695dec0013e9e064c0834b580c254c6f04689d0ff80c6999882ce2ae5b4d8f01cdc5c2728890c7c795b10c5b7e01ad2054e750783d4dafa677cef7ca6141b0c5fc6e5fc38b0d1ae088b16a02c31ffe242afa4264c21d4aadee3fe6b3f43afd38fc554bf168c4331a388508adb66a12b85af205e6f2a6000c7f222b5e3e326ae9e572956330575a07713ee32f427878a62146810b85483f10363722279af71290e58fd7da3c79c8fa0378648423e18f2bc4649e8ebac7e28ab3f8d1ab64750791fa9158b0c9261b2da1a8174f5002aafaca122eb2857851de26278f594b59646b3b2f6b51a4011ded6188ee52d64311db7e50dd8197ea0187ef00f0411d501e5d1be946e31603242757b28f3d05cf1744d62ced24366566dd16a3f8f3dd4d52d7fc891a31e83ee8038dd78afea84ec8896958397aa7aba0056db3b16a04a2023af67a1948dcbad4a0a5376475a320371194919c939f4e63971bcaddc344799aaa151434d2a5c402d02d4ccc29ecb1bc40b297d9bf72aa09ca9dd2cc5268f2c3f49e10fbe4733ee83647b9efc1f59bb9f7d8e2bddfce717cb1afe7df9ffe8b4a7bc79371b74f1a038c9c4fb8b7b1eefd38988bd591dd2817e19e9d6c52b522e90dcd89c70d3eed91b1286c3891d546f4e198bfb385554e882ade07aaaa4559ad517c5cd7cea7cc659beaf8214716ed9d750d382389ee8ab7c3c8aac48968220027ede85f939098fd679d97865926f120d8a9a360429cf00a7c1def836a9933655abcb384e9f630b4163f204238e9a38ed949af36f5204b74dcc45266f89af90e6db2c948e7d773d72e653d35c848c77936e6e689f75dd78ec2754e02fbe119c572885bf090b04a4390bc7d5983809e5ac7e4a16f6ad023c8b28e6b01591b0fab80dff9e1300de11be3168ba2f1691e6cb7c416c3201fae3f171975bacdffa520571f518fd8477553be92539a0ecc5ffc161043139cbfa35673f71949ffbda64693a032cde6a34432cc7736f1856b4daf68d39369327744355afb6a4e89b82e5bbb1d53b5ecd1ebbca25f6b51f1b0076c34068676b2b879c13f64d91b277fc82ead7420f2497b86c9feb5341aa553c7916ebe6620de18eba7f453883a6e8a037c314ec159869132e1856943ca6da2411830d6af8354346acb06578ce89e277e2619596330476ee1b8a1ecd28e201c065bc30ece1feee5e7ae182efa8d0310eb731c30ca7184d6e9f3c9cf08ef2b2e63ccb369a36ad63207dde3ccb04de341b5d093a0a140aa0a8dbe811f03114b235f07499e622ebec39521fac671183f0798ac50919d260941415832b1c5686d7c27a7a5d0e6222a991e341c9a8b10a76e01e79b1e7a0c18227a39079d50f5ee94b18b62c51ac36650ed3adfe142ba5a34a839449599355d4ac9542b146156be4fc4dbfdd10cb8dd15d0c51ab23ab19c16500f770693c94ef61df26da43a09b00d4eb7206e9325cd66780ab47a7e95b50df423c40767229df1dd41a808fa70da64771fb91b5f6f76872759a8cb77fda87e2f2d7f030b9cdb456005db9a88d0f27d4796803bd570440fd0b7e99c3d08fd8e603c92098aa4150d5a87c2917cd750bf0077e9d71c43f5bd3dab919c23e16bb90537e7fe694a847ee843df4c8262d44c39bce4d9c49069b213f1074453ec66ea054833fbdb72b81161dba424390413dbcf96cbd56a35fce6510ddc2bd9296f7cd2f7474f86fe24cd61c9665cee251420c0a0d1f56f9fb06c83ffdfcf034a5c27b8c68935c4b2abd2fb92d570f1fb610b3ff4f66a3110a7a0b89c07191bd5928a39d579191633b96f1123e5535953f0d25d28675f5ddee31ff2b6e13ff21a2db1990f4ea8d0ab5d4a73af9a41d5ff8b1467a11cd297ec416f448c5b0d77df8d02e6880a7dca283054beaf1fb986acbf838b68a32c6a4dfd097c9fc998fa13e382399677cc947af6e4ca5b37bdbde394b89582c04bd05dc7c04038c626c5b72788189fc01799a4ca03a1e65c744f6c4893b19d2749709b23af92592044224aba18e1052820250d0c35cf8d76e51c73c94386c6e0f147c770ec379976b574ef2ec6d68c39ff2c287fe5149f71497e1abf07176b024e408479bb7b56b373367d40a5bd08aa38bcfccc705531d2984cd386f0f47f0864e00d758eec1ba0ed0971a0a2a84eec663f198326aa62f931daabe381dea692a7c43425d54acd99e2ff5b7464f5bb794d2009035ca9ff721b1b4494cd8cc5cca9957660f29b77ddf173d78ac56b36aac5e28374c38253b22e16bdb93e4cbdf9f0e854ea1d79983f8f9cf6d25ddaa7648055354a8cea372ba54eefca4cd040d3eadd23b89ab64c545b7462d2d6d2d249a919703bccbea471251d36a1a27bf0fd653f5f1d8490586d9568aab141383b186630a270bc7d2a8a299b4c90bb22fdf08c30b2745dbe6d6ae7dec9bfd112f5611a83f9deff408346dd62f75de00550f6e56b3f9f9b80d7027a0c7bf6306aca159972f2ae43346985a4601b481722eabf3786696f9623e1366f93dc585758fe8f245e82211ef984bd31dcc9fc7d7cecd099dac9e45cbe655dacd687a848f53353d7bc1d68103d4c8c740c91b69517b164f47ed718e52687757a51f086a4ddef8ea4c858580d6eb8064a044534e277a7dd5975af13ef5c43066ea26902e7a36df395f2495ed4311c3736e91450650843a1828feeb42e6bd5a05d0fe4af8d7a543463038bcc3d31a589108038dcffc8c7a3cb86c57ced3a1e3e22357cbaca328ebe1dbd16c1b882fb009a697c1efeb3efca007753ddc51f6e7da8900b3a37312ebbf41c0a7ecf23c39213fc8a23c2c5ee6d783a1b6520b07ff747a143f6a8dc512209c37adbed276de13c5ca27ff7a595545c024b11f5eefedcbf61d92ec0a107bd1ca00934618927da450c940f6dab1c180b29e72c0e8709627e51e91632c364fe45fbdae43ab876d33000fb1ab437d499b33250d75a1d23192a55f813859cb693773ddde616e5570e753128572bc119a46951c86f99b3f931416c0347d95d5a6be502c3c8f696ee026c3e66e4f0a3847aa49815cf40c902ba79ec7c4e3d82ee140c8c09f73ebaac0b5ca11723b08793fe17dff3efcac0c576d8f5d9699b741861e6e2e9770a +f1c97945e0468c87f228ccad6f4208cf334086e1d52648b8d9ca28072bb38f1e 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 +c6d1bbf6e19c438a64098a1b0e4dc2f5d2a198c1dc64a729dbdc9b2cb2623b08 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 +093212eafcc72b253f0eb167400f1c95d866236936325b10ce730926781adda4 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 +ad5e6d827897b23852781273209d80a53a215b9176316be60198d8613b2dcc89 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 +1d825db86cbd7386c1eea3b536356763c90ecb76fc0448c45a357604c0a0ef90 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 +fa1dfbfe0aba58fedf10d6d177818c992125a12ff47f7705a20d359e6161f7b9 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 +129c36d11930da0bb8e9adc3f49ab1ed4a5c6fd06587e25c752469175bf9fe08 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 +71d02703d9a6a506270d654fa9b1aabc577b75d48227786ccf0023666e6019d3 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 +f29a70d4f4493219453851d4a85eebe73e8f4ee99f8b8b54b98cc14db7cae4a8 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 +448582e158afc5087486029fc6a0e74d60fc0ce0ad6686c5734d5f8cffd911b3 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 +84935526ae4e13643081703b3ad1157eca78465864b7354fd7096cbd21e8518b 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 +c8687a0fc0c6ad3ae4e3af4a00cf9971a4762d032ac1c0fed2472c9d090b8061 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 +69b880d35b57919839fa99b09fb048528229e3c943a301b699cdf2de8a811361 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 +ff22a43b23b579b97a4a255177e998f98568624668c5b2bc42eacef6e3a47161 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 +3558e80203b240a562dde334bf24e27b07be1f69b520f3f3b43d85bdc7bbbd3f d80e6fe59b7228d25e78586f94f268ea62ebe04238ab44e97316b22e96c91d186fac862eba9212ce845bedc23cec43fc3da42aa7025637e0ef65823eba6fed261afe9a48074258b235559a916e644bfbc9c3b6f44d760e3047bf7c885f9c70c44246a81d29f9c10594b9359eaa8c8c572c71426a930f02f2692d504e0f19e12f6bd115c085988bbdf2748a2edcdccaa3d29329b4e8a1a17cc20243191d2abc7a4cfe384291fa8d7ec57821e12175a156f893587e2dbd5fd32c2c1a7804756aec8ff12bcad4308dd33eef5cff2983650fefc04ddfc4301107193dfa9eb7e8a6ea2748072879b063c7b0955654ae2a68bf0f00c37f0323c6458310b4707dd2464da5a52b8a8e7ce6589970116ba93eab2024040c45f22e9b478b34edff4bc876896d143152565732fff04efe656e06eac38f19f4eebff224e32159ab375511b42b6f74001ddb15ac0cb4f6baec84901059882f58ebf940cc973422f6f6940a94c5101eb24ed21bc0c417d959b4f08693173e88c6dbe28b487b3d0ca00af26239b5b8992c60ec3bcd3855d2db197ac95c4862b9b90c5b4ae366759a38868a2b838e36d7e42552b3566d7a28fe6e208ae9c6aee50524881c482b8f48e9133ae2a9d9377a6f966f30603e25a0ff06106b2925012313cb3e79fa3f0dada7cc3d015b4c0baea4a79ec8e37d792fa13c19aa173e134774df393e1de9133369e858e47200648b44740f18bc0550266f7ee7805b85d8a19368c68110cd11f14032a099cc797db39390c2930f68059ca31592fbe73619043e1c095777d297158ae6c28c863face2299ea435cc1e7a09fb29071c21780924d2ecc41c9c9749da3ef0819a41ec086cd2b7370870694b0392d18b6b721b81282dadfe3c3c3fe21288e992c7e3a8fa685f32307529e6d50acb4252d3e170334c42c70fab02df832569c7e5e05042f71a4fa939b58572cc8b0cee4331220742d2ea9b1117362a1831c8247e1f6e1f42a88ff5eb9aa665f9a637db1be7e4ff5a75dc21137a50d07087185de1310bc5eb098450914b9c6ad8ddf67ac0dcc99ac61c3cb09b101df6273e0c3abb3768f24fd2c4bd2ef6dbecb1a1ecde1418ae5fca22d41dba0cb6c16b06f2cd26fe1657c1ea7abebc5bbc8dcb58738f855bf38cd96f29bf7732e91b261b70a776eee64145c1421fa300bdf80bdf6457e318f9beba2243ce8cf57dfa8ba0d5f124afc6859ddb0f3ed457fca64623b54a49be589953078dfda65745fa39cf0c4d9866c38f76231fcb44d3131f8df389ab755742f16db218b3978528799746a99dc7e3a958632563748039fdd9ffcbff6f93bd83dacf06ba93e39251621af02f8175cf541f0c800c5d2f5af06894b2fa14b9a6faa3a3c95570423613299f141ce25ee77c0259a40279a2ff60b51acafcf82cae4297e57861645dc7442eb052309001e89ff2ff5ba41f2f7d48fc9a49bd3062b80c75be51fbcc8764ad6d2e647574edc03660c9f4b7ae58888678dea4d6a5c2512f12a6aecd3047ad08cfecb6a4c95993164c583c91fc8558cad146c73c7f4c24704ebbd00d9dc2c72f4af1b24f1dd5c0bf97c283b7f69937a6af0c5ab195ac8d179169bab6b141a5a61f7fabd2b0a23ea29cc295ab04de123290485048e06af0ec211d93cdf8feada722b82b994134911b5ebcbf21d0130f910dde8cf7cd3e46c2be4ae26796f25b653f926569371ea09c7a5e2f38565d08c9d377baf51b6dc854866c50563b9da26fa30e0a87f5b2fc6472291550fcc7a0c423ce82d0aef24f54c05087627fde9c9ee2ebf228d12291b2b25cc8facae9c6209dc43547ba0208d359677c94fd17a76d0d84d9b18084c8afe1548ef4b7fc94d70450087edf0374cc414561e6575ad401c99908ecf28c6aee82f3412379a86f78ea9841cea2d597664340e90714c4f75453cbc4c24c963264dc8f13487a0bfd4fd04aca1315a1b70eb4888265143d82cd63046f0daf27d8f1a6ef988f48d13c56eabbbf27b5785e51d68db08b4ae2b9411596ae87c760d28a4e2c38a76bd6b715293c59131d3d6308c722282495bea69009ca71aa78a28b681cb782fe4274d499a856aab6f19fe9f87931ea93774ab13ca5b3e29c1ec6b300e67e525b9438c2f3c3af3c38276039fe82bb15cac81013b195ea9c430b8381f73b5f95cdfce403c0277be77fb7d8cc38f5c075347cdf1da4689845d803c9360911f0156f6c92b5f775d502674ccd635f642b266a2b03748ed6247250ba23878853ecc69cab7eef2a29a08e29072bdf32db742de368125cddb36953d15712302a9e4ad58c8c63c7721d4647bde4a16e582181144ad9ee4d51133a5534936fa3a7884d0981785f8ec556505738e5293020a2fc31bc3d95080e1f747b2e25281ed256540d279c07fe3218a35d4574d22d4155e3f12f7450f37f8fec6c467566746720538bd1a297dd9b987dbabf2d6110fef51b6991012cf338f2371e394f2d4967a7a462c054e43bca22794a20675854d742d441f0aa289b0dbf55e48f0d495864e3ef5b145351b93a2459b6ca848f40df1d8b588ff679771c0dcb69a7196d19c141ea0846d5d2934aa5c662acf1a7859db2c02c791250bdc1f5acba5638815dcfffc858b0bf1e086ead0be46e9c4018159729e645c486a4973e6e1380f9850128f08f315e9f9d6efe64ea210fb8070a498f98a1ece8ff4279b4028efc7d3634fa3ca8cfc10c58e349b988d3f6a13a18b6487b526ac779c82473d121456eb2c18167cdd74018c0079a5347c1f9873cec00715f0fa530550c814cec5b96121a9914a8291713d6c7b9f65a9e45b85ea43e93a79dcfb9dc6a6bdcef820242dfe7cfa4c2a532e6371681c8f39fd659a1f54536eceb20fb528c8b8bfa96069fafc4a8b23deaf0ab27d8e190fa846669f403bec4f302c7cd5ab9972529827d5819e6d1fdf2b6cf2afa57899f8f9cbe1fccbebe8d738e84779134545614243a1556ceb4601ed1a6da90599bd3b2e2aef9b060e27d879d1e08120651739456062a18cab94aae2807ce12fe0761aa96598ac40d1db86887708041a90d59c66b37ba63ab409c9fb025c5992b985a35c1bc3fea87b7791b6d0832a461a58b221933d2b9ad6ccd80e08cb8f85f52d3b9a0dd6ed57ab7a62f1ac77834bb86fc542131c779dafee3df16e26ceb0953661aff00843def77210011965016942b3ffad479749817ba8a85ef288091f92edba11d7fc01681a80513b3281800632a33b3a73b4ff9187c12a5701520724e77afc84e6a3ffceec439d530b38abd9805ee0a8016831cbfb54b167b65d466f9eec8058e13d25f977bcdccf82c7274ad9a71ddac8a0928e57b4cb732ded8d314e8312f99effaea028cd48be614256c6d39ca0b2f77a13829f172af85fa857bb734383e757a0e526b019d188df17bdd90815cc90d289e6fd1048c0963d65b5bda595d34ed760aa1066f1e3d9e48ae2a2dc492701e9ce465bb5a39ff722cf55e9e2f8611790920a3eeaab9ab0bf86ed270fe658c3a5f633fff633ece639a93332f3bff0746b5c4a5efe9ae4844f996fb842748c2e25ef24b6d0f8d5a476bdeb8328444e46393c0544ec9f1d28cb83a8c965e0d9b066db0366b431306459b6c837dc9e672fdba234a12abec8c8c813d2ff6fc625de96d35461cf72ef1529e5425ea1988ecda7381c0f84d86eba98f4f4d0f45f1c16f5cb3f8456da4bea3030f97b56dd494ee97c630656e58abb7ac6f2d8676c04a34c2ee4ab1bd10d1630dd59b6999acda447e646a84aa66d53c6ac0e3bedd0fc01aea8aa9fc7648d44bf585f6f133a25a590d63b4a83e6519f528b310bc03b9c97fda5fe700978a66f1ef4227afb3cbec112cc4552de5f605d9cd0772122b09ae196e8725827538c4473f82a3aa0f695c5c5d71f91f16cc8674445b799077e5516ab55853d86c1fe9e4bee06cbf8f9601e14684b00579f277964aa162beb92ab476e322e7aba464c0657bcb65059b47668a82190fc093ba433a16f36b22936ab30f6790601907048c6ecf7c4a41a406ecf866d70a3a3aa2a1bc6472ddac9f97d37ac790c117a609dd3741fac7a011960aa6e278100fa04d345796645e5958a0ae0a68b3b6d3f11df7403932e6aabc332a77417f2fed3651667bb0859133c0732c56ec52acdf8614534e4a2e007343833389073db6c212e567b7588b0bc81f0d622e1646acda0f5dfc807073efa779d687357ccd1d102b2b6189680c502435bc6522caf5cc16bec795174503a884fbf209d0a235762c7162ebc66828bb8f23dfdbb6468a5e62294d4597ff4f91d99cb1417b685cf1849d9abb58e63fc77f380ede5ac5e658c103414f68de7eafeb3e69e6641c04b0ca57c7e938d9ebb290d61a2d42e1b5c0f956009a6a80403e0c77773f281ef604c1959edfd1df210df127c302311e4a71a75622def0f91eca4717fae455dd9fea557deba0ebe1aab6186aac0094ef34447c24125706102c0b27e17fdf4f1d22ebc6506f28685e0d1d886dd41729f9bab64486e7e96155a26cfed69df3bdeb62775189e9ede39d7a0d03c511ab4d605343356bad7ae86f43e1e9eae2303028d187bc81fd3365d7b80e094ba629ad56ca352f3de8ed6dfdbbe7d2064c757af36b7db4efc0e9e8f2f25e6282780f7e059ec9aba8c04f5913e9632981241f75514c50d6502d7b01f4008422318c0bace5d135327e09e4f97fdbfd7cecdabbf16ba2887f76d9720e34c26cb8d199fb46b486d47e24ff943c1c23f3e99e472d96fb4b6477eac3f364e02ff192f3fefe13c69560fd4f4a2830a3a74ba8c8eaeb82e84d8eceb983a6f1cb024a9dffce69ae0dc766fe283619c11c5885b2fdf38e230b187d822cc6a54a2b643029a5d9af17c5c705f41403ae62956d977bbbc7ce900ceec2b7 +85cf752d665b9387099f692f26253a59e57e09ba181d2f2b6728af7177f5dd68 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 +c2e3b8554579cc42c4036778527265a9786100116f8dea396f32ce651819727e 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 +28a84c9d876577bb858158d254f954eb110dbd33f99bc78257c4a90b5aca321b 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 +21437fa9755b88921e1d0cba74ca3116e4357aabc01ca3bb287ecd81a1e7f51b 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 +b46f75068cfe2285a8a912df3e895b7c2af63993d63a5522b4a428b7422b52d1 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 +9c624190ef1c90ee3aa0f69a3f679b9b08a93de39e3b3329f4defbb93c7e0d35 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 +80129f0baaa2f46e07885236c997f27fe59a8593947f697e8bd305f92bdbb475 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 +104ac12a602945e1c1a4f6611ed275d87dced67c4047883438ff52a17f63bbbb 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 +28390dd2f3c4e9409e5d96e0d96622b0034b094a40cf537b0a9d5cbb8afc226a 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 +be9759ac7cf852f887ed38c1c855de0bed1b468ed99320e0ae0e971caabe595f 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 +6f5732af54272a0ede6d7cd7f309968f402867008fbe2b1300ea2863aa850ff8 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 +466f4aeaa29c0b39feec5749855085429e90db0119ea16078c1a29e8112e4c02 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 +122ed6f2bbf68f5b80bd8a32d6716966ed6544c0788641de0b362d1ac09f3571 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 diff --git a/tests/hash/tests-extra-groestl.txt b/tests/hash/tests-extra-groestl.txt new file mode 100644 index 000000000..1a579c2fe --- /dev/null +++ b/tests/hash/tests-extra-groestl.txt @@ -0,0 +1,321 @@ +1a52d11d550039be16107f9c58db9ebcc417f16f736adb2502567119f0083467 x +15e2671f0eaf66c0de3093ab7b1e39dc68f945d7002fc5dfd52d60527e7228d1 cc +846f1c22fc62b770de1782ef33414aa5baa44b690ebfb7d1bdcca8d2ac59c929 41fb +05fe7de2d8ce1770df766739f788037d0cf2ca7c2b7620835cc34f45b3fcf919 1f877c +b5efd33ac395b5b003d7fbdde66197ae4ee6da86946f808f0f1f867f77c53fc8 c1ecfdfc +ad5daa1673e9a9e476a843b12d39de4992ec9aa15fcf33ae094ba5aae6764742 21f134ac57 +dc545e6b3b1a1a8b15fefaa2799ff90fba664bd2a0466cdc327381af41760bf8 c6f50bb74e29 +878c893000731295d3e1dab2dbf97cfcdc142c70a74ee7a2c96e84d5b3c873ac 119713cc83eeef +b9a9049619ffa74d3393530dddd00b7eb0e25074afff5a0a6ecf80841b80282b 4a4f202484512526 +96525b717c3503abbdee13637a44e6c9dd14b056a976776920b90ee29eaec5ac 1f66ab4185ed9b6375 +80cadacd1255d1683bb6ffb7c5fe8e88048bc40b4b6b1718c35e21b57fbe9ce7 eed7422227613b6f53c9 +76cec88bb9d48d78ae6b8f82978a6077301c892ddd307d1a3f9e2ae1cdd7a292 eaeed5cdffd89dece455f1 +32f868669da5165f5b7acf81da9895d2ce44229064275e8fcc1504585fdbe22f 5be43c90f22902e4fe8ed2d3 +7bc9ece3080afc7787d62318b97360c0911b5848eed942cd874da47df43acfba a746273228122f381c3b46e4f1 +cf8aabfe63504f2b2b1bc9ea3b15a0c84a6f86be66202cb1e517433473dff3bf 3c5871cd619c69a63b540eb5a625 +01bc4ca8e6009df18003c76b64858186699dcf8a436dc48d5f72d6b592f23d8b fa22874bcc068879e8ef11a69f0722 +604abe432c627d185e163904298327214e11ff8b7bebcafcb62bc71212589b4f 52a608ab21ccdd8a4457a57ede782176 +d0b9e639253d64d271d6f2160983da5655aebf3ae108c499e5b096ca9089887c 82e192e4043ddcd12ecf52969d0f807eed +dbf49a1b950da9a4ebee2f021d7cd43fe12667b4eeabbeb3ebc4995ccae86646 75683dcb556140c522543bb6e9098b21a21e +517d980ffee53233905f46a115af8df0d91e11944a71ddef54c7ac6d92625be6 06e4efe45035e61faaf4287b4d8d1f12ca97e5 +378d969cb27a92cb74d76cf7fb061bd916c5dbf8c50df6b75e37e921914f0f2c e26193989d06568fe688e75540aea06747d9f851 +0c06c53344b7d95e93da3787bcd36a8ebebcfdb676c0c9e7175009cfa73a590c d8dc8fdefbdce9d44e4cbafe78447bae3b5436102a +4be81ce799a004c7f09fc7dc7e880e0756687d5cd2e392765c6dd98dfeb2fd25 57085fd7e14216ab102d8317b0cb338a786d5fc32d8f +f72473574dd945b2ce4b00ae5ec5c45937a4253a79019d170962261de24b3d81 a05404df5dbb57697e2c16fa29defac8ab3560d6126fa0 +d3e49b6d93deffd26f944a62c8127844fcdd1eb54014be3e1ddc43d6c8b124cc aecbb02759f7433d6fcb06963c74061cd83b5b3ffa6f13c6 +3b4780ec9045c38aac6b46e3d5a834ac7cf54b9c5ceee2109a70a04fcf190165 aafdc9243d3d4a096558a360cc27c8d862f0be73db5e88aa55 +0472c08a4e0c3f9ade0c073030b482305762879ffc058d58b5adfd379e3d6ffc 7bc84867f6f9e9fdc3e1046cae3a52c77ed485860ee260e30b15 +8f208aaf597f5b28a3be3aaae08b29dcf9ad313adf4e9292c2940565801cf080 fac523575a99ec48279a7a459e98ff901918a475034327efb55843 +e49850a1996a39f5cace5f27eb4151586f91a1b2faaa294e81c777705c8be5b4 0f8b2d8fcfd9d68cffc17ccfb117709b53d26462a3f346fb7c79b85e +264f5cf71284898728628998136e0ef2b6d0b91b41aef02a392d30133e350c50 a963c3e895ff5a0be4824400518d81412f875fa50521e26e85eac90c04 +04abcb19e6990659fb853d8fa647dad546954f1483d6b00a5662a9cabb25116b 03a18688b10cc0edf83adf0a84808a9718383c4070c6c4f295098699ac2c +5b3bf21ef89c52eb97dc1b7a97d34abfdcbeb24878de31b6c6540219e2c443a8 84fb51b517df6c5accb5d022f8f28da09b10232d42320ffc32dbecc3835b29 +03742380f81141b9e66b5bdba56f107ff59f66e86d1b7ebc9349d24e9ece594a 9f2fcc7c90de090d6b87cd7e9718c1ea6cb21118fc2d5de9f97e5db6ac1e9c10 +4e2ec284da72e0ceb7fe202111c607a7f53122718bc62c4d4ca84255fbf94da5 de8f1b3faa4b7040ed4563c3b8e598253178e87e4d0df75e4ff2f2dedd5a0be046 +df27537b2baa52c6d84919395bbe273497f9c8466c0e22c1a9e628b89fdf7708 62f154ec394d0bc757d045c798c8b87a00e0655d0481a7d2d9fb58d93aedc676b5a0 +20bfe0ad185b8284ac6ac7115b6c9db656ff2c21affaaa79a16c601463859de0 b2dcfe9ff19e2b23ce7da2a4207d3e5ec7c6112a8a22aec9675a886378e14e5bfbad4e +074b5c7ea4cb338fe98dcfb5167d02bd2b9a7dfa6edaf6da39ee6059857bcc2c 47f5697ac8c31409c0868827347a613a3562041c633cf1f1f86865a576e02835ed2c2492 +790ce470c7ad41aa963d78cb76eac0ebc7dba4f6ad445d83c398146a37cd82b6 512a6d292e67ecb2fe486bfe92660953a75484ff4c4f2eca2b0af0edcdd4339c6b2ee4e542 +22772ff51573fa5b62ddd108fda09c6de3a39a5e1720191f774d04bca4ad4d5c 973cf2b4dcf0bfa872b41194cb05bb4e16760a1840d8343301802576197ec19e2a1493d8f4fb +6aefe468c0b0ae2b90e1799cdc7d659b322ae23a8ff7d5d312aee98afc149f42 80beebcd2e3f8a9451d4499961c9731ae667cdc24ea020ce3b9aa4bbc0a7f79e30a934467da4b0 +6a3255eb14d4f485c08cc925601a7d973099b7fcf609ade440b08278269fcc4b 7abaa12ec2a7347674e444140ae0fb659d08e1c66decd8d6eae925fa451d65f3c0308e29446b8ed3 +d09aa101ce40204c74daed60fee45f715eb5b7800703cfe39d506de7d43f1e39 c88dee9927679b8af422abcbacf283b904ff31e1cac58c7819809f65d5807d46723b20f67ba610c2b7 +0614e0c8754f7d070697b9b4678f3a5f68ff016ca9b26f88ab9d1544332f46e3 01e43fe350fcec450ec9b102053e6b5d56e09896e0ddd9074fe138e6038210270c834ce6eadc2bb86bf6 +d618183c656423ecd70861b0ee12b77e8501aa24ee29dea1b9b734a15afa19c2 337023370a48b62ee43546f17c4ef2bf8d7ecd1d49f90bab604b839c2e6e5bd21540d29ba27ab8e309a4b7 +24b489acd9e3858e3f353d2cc80b2efccbea6edc2776f1bb9fe61558abee10fa 6892540f964c8c74bd2db02c0ad884510cb38afd4438af31fc912756f3efec6b32b58ebc38fc2a6b913596a8 +08917efd4022fd4d0c0f2d7078dc8062c74b03c3eb0545e862c6110244b2c7b0 f5961dfd2b1ffffda4ffbf30560c165bfedab8ce0be525845deb8dc61004b7db38467205f5dcfb34a2acfe96c0 +00a49a4f4704281f15c7c81a40eba2bcf12045dae9e2b20661d959888792338b ca061a2eb6ceed8881ce2057172d869d73a1951e63d57261384b80ceb5451e77b06cf0f5a0ea15ca907ee1c27eba +e74f7c10823b0d5a13512e7edb63e50ac06ddaf86131eb5d40fc6d91d325dcfc 1743a77251d69242750c4f1140532cd3c33f9b5ccdf7514e8584d4a5f9fbd730bcf84d0d4726364b9bf95ab251d9bb +a4fc820ade474688d90be3c0765dad696af2d5b76ff450a34621d2e8c7fb61a2 d8faba1f5194c4db5f176fabfff856924ef627a37cd08cf55608bba8f1e324d7c7f157298eabc4dce7d89ce5162499f9 +73501818a4c595e31ec58669fd378be4d8a57b3f220348f6e28987b247d45561 be9684be70340860373c9c482ba517e899fc81baaa12e5c6d7727975d1d41ba8bef788cdb5cf4606c9c1c7f61aed59f97d +29d00676743939018ba7017429ee50d262230cc2182e584c2c1c09ef8c5c4644 7e15d2b9ea74ca60f66c8dfab377d9198b7b16deb6a1ba0ea3c7ee2042f89d3786e779cf053c77785aa9e692f821f14a7f51 +6ce4c50b5b8bb9af78f7793afe5df945bd5e1e0705ed4ad41bd14c7f11c580a3 9a219be43713bd578015e9fda66c0f2d83cac563b776ab9f38f3e4f7ef229cb443304fba401efb2bdbd7ece939102298651c86 +d0f11210bc8438e248829e47cdae4f5f70da887d72fc714363afcef353e2c33a c8f2b693bd0d75ef99caebdc22adf4088a95a3542f637203e283bbc3268780e787d68d28cc3897452f6a22aa8573ccebf245972a +0604b82a24fca2fbc4d7d5b0734dc4e7b6f13c47191b699479d26151c9710cad ec0f99711016c6a2a07ad80d16427506ce6f441059fd269442baaa28c6ca037b22eeac49d5d894c0bf66219f2c08e9d0e8ab21de52 +f6bdbbe09ea7786afc0021fc9703f85c619ca8f5fb566b810dbe9ae277d5845a 0dc45181337ca32a8222fe7a3bf42fc9f89744259cff653504d6051fe84b1a7ffd20cb47d4696ce212a686bb9be9a8ab1c697b6d6a33 +51ecb0fe1bc249ef84a7602971e70885f38d4e0a60dec0614fa760e4243a6ceb de286ba4206e8b005714f80fb1cdfaebde91d29f84603e4a3ebc04686f99a46c9e880b96c574825582e8812a26e5a857ffc6579f63742f +1db8b9b50186a8a8a122d9a861ed45b9d01aaf8256bf2c8956b09fb166c92f6d eebcc18057252cbf3f9c070f1a73213356d5d4bc19ac2a411ec8cdeee7a571e2e20eaf61fd0c33a0ffeb297ddb77a97f0a415347db66bcaf +4354e30785fc3e139a17c78a9a038c92f01a6feee2360be97b0712957d294d8a 416b5cdc9fe951bd361bd7abfc120a5054758eba88fdd68fd84e39d3b09ac25497d36b43cbe7b85a6a3cebda8db4e5549c3ee51bb6fcb6ac1e +26c7f167475b618c76d8a82d057fd83fc25aac3c660cb94770b10d1b0f2d6907 5c5faf66f32e0f8311c32e8da8284a4ed60891a5a7e50fb2956b3cbaa79fc66ca376460e100415401fc2b8518c64502f187ea14bfc9503759705 +dfb16c414cb6d6ba3006b478be1d65e96d78de2067d3863c402d7115286c3a7f 7167e1e02be1a7ca69d788666f823ae4eef39271f3c26a5cf7cee05bca83161066dc2e217b330df821103799df6d74810eed363adc4ab99f36046a +a1b2ac83b80ef1e948ac0f72668c163077ccff3279a5419fb03ee28225fc7432 2fda311dbba27321c5329510fae6948f03210b76d43e7448d1689a063877b6d14c4f6d0eaa96c150051371f7dd8a4119f7da5c483cc3e6723c01fb7d +2df7930f31a0bdf114b356e975d9182379e4acfe8fe2588e6461f82e272c8cb1 95d1474a5aab5d2422aca6e481187833a6212bd2d0f91451a67dd786dfc91dfed51b35f47e1deb8a8ab4b9cb67b70179cc26f553ae7b569969ce151b8d +74621ca404ee51690dc5ab30ccb6219fb458bf35f534068aac14c357c49a3cd7 c71bd7941f41df044a2927a8ff55b4b467c33d089f0988aa253d294addbdb32530c0d4208b10d9959823f0c0f0734684006df79f7099870f6bf53211a88d +bcf360ae1494dfd755471adfb62feb4a68415ee501620b278e99cd60955ff3f9 f57c64006d9ea761892e145c99df1b24640883da79d9ed5262859dcda8c3c32e05b03d984f1ab4a230242ab6b78d368dc5aaa1e6d3498d53371e84b0c1d4ba +5adebbfdf6fd6178892b39a97a32b29fb605f97e1e5c3bbcf624a0e9cd72d145 e926ae8b0af6e53176dbffcc2a6b88c6bd765f939d3d178a9bde9ef3aa131c61e31c1e42cdfaf4b4dcde579a37e150efbef5555b4c1cb40439d835a724e2fae7 +5f27dd5b62ba1301867becd5ae6347790e4c56d5526554903824b1717c3b3065 16e8b3d8f988e9bb04de9c96f2627811c973ce4a5296b4772ca3eefeb80a652bdf21f50df79f32db23f9f73d393b2d57d9a0297f7a2f2e79cfda39fa393df1ac00 +14cdc95536c738db0ff1d8885c0534de2fa3ca9fe129ef37a0a6d6af73c3ae76 fc424eeb27c18a11c01f39c555d8b78a805b88dba1dc2a42ed5e2c0ec737ff68b2456d80eb85e11714fa3f8eabfb906d3c17964cb4f5e76b29c1765db03d91be37fc +eae02d643f805f7f11c68982aff2ce014dc67e88c0d522666867124f7d3c8f96 abe3472b54e72734bdba7d9158736464251c4f21b33fbbc92d7fac9a35c4e3322ff01d2380cbaa4ef8fb07d21a2128b7b9f5b6d9f34e13f39c7ffc2e72e47888599ba5 +4c86f19dba3f4e20ae6b0287614329c336e8fa97df67cc78ab664930b7474dbc 36f9f0a65f2ca498d739b944d6eff3da5ebba57e7d9c41598a2b0e4380f3cf4b479ec2348d015ffe6256273511154afcf3b4b4bf09d6c4744fdd0f62d75079d440706b05 +ed43d8bfb6ed11c7038703bd208d41bf038fb48561a9596a58fe13d0bde72d14 abc87763cae1ca98bd8c5b82caba54ac83286f87e9610128ae4de68ac95df5e329c360717bd349f26b872528492ca7c94c2c1e1ef56b74dbb65c2ac351981fdb31d06c77a4 +6ffec58e97268f03fdfff1732ca05e7506a19957c41cbe12b43884c9198c03cf 94f7ca8e1a54234c6d53cc734bb3d3150c8ba8c5f880eab8d25fed13793a9701ebe320509286fd8e422e931d99c98da4df7e70ae447bab8cffd92382d8a77760a259fc4fbd72 +bcbb04f360e229d33bb00dff55e5f40d3bd4af4602d725bea6659016aaaf2604 13bd2811f6ed2b6f04ff3895aceed7bef8dcd45eb121791bc194a0f806206bffc3b9281c2b308b1a729ce008119dd3066e9378acdcc50a98a82e20738800b6cddbe5fe9694ad6d +c40e7fb3bd538939918cd97180f1a0d5bb45be2c8f6972a34b3ac46e4cb0eefe 1eed9cba179a009ec2ec5508773dd305477ca117e6d569e66b5f64c6bc64801ce25a8424ce4a26d575b8a6fb10ead3fd1992edddeec2ebe7150dc98f63adc3237ef57b91397aa8a7 +714012acb534f652c08df155f09e3160d0c5fd3579bfd505e9a17dfa762b34d7 ba5b67b5ec3a3ffae2c19dd8176a2ef75c0cd903725d45c9cb7009a900c0b0ca7a2967a95ae68269a6dbf8466c7b6844a1d608ac661f7eff00538e323db5f2c644b78b2d48de1a08aa +74bb818b04558f1da334f902d26f39108fb0e6376f0ead112a2ea2603328df88 0efa26ac5673167dcacab860932ed612f65ff49b80fa9ae65465e5542cb62075df1c5ae54fba4db807be25b070033efa223bdd5b1d3c94c6e1909c02b620d4b1b3a6c9fed24d70749604 +1791c9910728928ab416c5ebf8df58f81e81c49037d94acc3270edaabd891012 bbfd933d1fd7bf594ac7f435277dc17d8d5a5b8e4d13d96d2f64e771abbd51a5a8aea741beccbddb177bcea05243ebd003cfdeae877cca4da94605b67691919d8b033f77d384ca01593c1b +9875504e0cc21d251025fcbf4de4af4eda0f7cd7bfc735aab49dc8f8200173a7 90078999fd3c35b8afbf4066cbde335891365f0fc75c1286cdd88fa51fab94f9b8def7c9ac582a5dbcd95817afb7d1b48f63704e19c2baa4df347f48d4a6d603013c23f1e9611d595ebac37c +e9b8c7bdb9a3e1f8b47c313c37e89026d1d86730c2e80dd026bb1975ce9761fd 64105eca863515c20e7cfbaa0a0b8809046164f374d691cdbd6508aaabc1819f9ac84b52bafc1b0fe7cddbc554b608c01c8904c669d8db316a0953a4c68ece324ec5a49ffdb59a1bd6a292aa0e +6b27d78ea2bbc4d1ad0a895de6dbe0571f6341b2363646fab30a05db2ee5109a d4654be288b9f3b711c2d02015978a8cc57471d5680a092aa534f7372c71ceaab725a383c4fcf4d8deaa57fca3ce056f312961eccf9b86f14981ba5bed6ab5b4498e1f6c82c6cae6fc14845b3c8a +6cf10f51f468bb32fdd5b15a4d0ade8bc50d7d6133d576409d540780bb3d21f8 12d9394888305ac96e65f2bf0e1b18c29c90fe9d714dd59f651f52b88b3008c588435548066ea2fc4c101118c91f32556224a540de6efddbca296ef1fb00341f5b01fecfc146bdb251b3bdad556cd2 +2aeccfd66bc7920c2eb7d94f9304f51971970398ad4eb3ccd3ce8b7d41fd2b91 871a0d7a5f36c3da1dfce57acd8ab8487c274fad336bc137ebd6ff4658b547c1dcfab65f037aa58f35ef16aff4abe77ba61f65826f7be681b5b6d5a1ea8085e2ae9cd5cf0991878a311b549a6d6af230 +8756600930a683a2b62603856b415f75849331583f9adac369c48467f73b68c2 e90b4ffef4d457bc7711ff4aa72231ca25af6b2e206f8bf859d8758b89a7cd36105db2538d06da83bad5f663ba11a5f6f61f236fd5f8d53c5e89f183a3cec615b50c7c681e773d109ff7491b5cc22296c5 +7d06570cbe3a29153812c7a585020fd4f6322fa0285228189d29f6daed1aaf2a e728de62d75856500c4c77a428612cd804f30c3f10d36fb219c5ca0aa30726ab190e5f3f279e0733d77e7267c17be27d21650a9a4d1e32f649627638dbada9702c7ca303269ed14014b2f3cf8b894eac8554 +0b8b80c466e84d8ed0813870005277043cfa208f1c42557fba037c78e3ac541f 6348f229e7b1df3b770c77544e5166e081850fa1c6c88169db74c76e42eb983facb276ad6a0d1fa7b50d3e3b6fcd799ec97470920a7abed47d288ff883e24ca21c7f8016b93bb9b9e078bdb9703d2b781b616e +0b3d9b97b9605452adb90ce180e1023b1cbf87ce498f7bc6c3ac73d63e8c7f33 4b127fde5de733a1680c2790363627e63ac8a3f1b4707d982caea258655d9bf18f89afe54127482ba01e08845594b671306a025c9a5c5b6f93b0a39522dc877437be5c2436cbf300ce7ab6747934fcfc30aeaaf6 +73b2d36579f9340beac27bc4ba79a6d219ec35c73d2edbb19c91d255870cee4b 08461f006cff4cc64b752c957287e5a0faabc05c9bff89d23fd902d324c79903b48fcb8f8f4b01f3e4ddb483593d25f000386698f5ade7faade9615fdc50d32785ea51d49894e45baa3dc707e224688c6408b68b11 +d4f798ed0291f7c5730e09d3c8a42c73d69fb20e3c7dc9c7f367771ff94befd4 68c8f8849b120e6e0c9969a5866af591a829b92f33cd9a4a3196957a148c49138e1e2f5c7619a6d5edebe995acd81ec8bb9c7b9cfca678d081ea9e25a75d39db04e18d475920ce828b94e72241f24db72546b352a0e4 +1e1e108ef3f362b9822761468f1f2d10f0d0c47c174981380109b3163d6653a5 b8d56472954e31fb54e28fca743f84d8dc34891cb564c64b08f7b71636debd64ca1edbdba7fc5c3e40049ce982bba8c7e0703034e331384695e9de76b5104f2fbc4535ecbeebc33bc27f29f18f6f27e8023b0fbb6f563c +0388172f4af08803ad7a906c0251fa7fa306128d421309cd31566751de602558 0d58ac665fa84342e60cefee31b1a4eacdb092f122dfc68309077aed1f3e528f578859ee9e4cefb4a728e946324927b675cd4f4ac84f64db3dacfe850c1dd18744c74ceccd9fe4dc214085108f404eab6d8f452b5442a47d +401c64949498bd700e18c48b12615872a84f01e692ee8511ddeea2af65ead0f8 1755e2d2e5d1c1b0156456b539753ff416651d44698e87002dcf61dcfa2b4e72f264d9ad591df1fdee7b41b2eb00283c5aebb3411323b672eaa145c5125185104f20f335804b02325b6dea65603f349f4d5d8b782dd3469ccd +db9df93e2d3987e62149ac5003b68365cb9918839c9d2f00ea8e988d306cdbcd b180de1a611111ee7584ba2c4b020598cd574ac77e404e853d15a101c6f5a2e5c801d7d85dc95286a1804c870bb9f00fd4dcb03aa8328275158819dcad7253f3e3d237aeaa7979268a5db1c6ce08a9ec7c2579783c8afc1f91a7 +b2e3d4e51aa821334b20c3ab2ff6783f7491f44226d90f9b22b5d680d5d62e82 cf3583cbdfd4cbc17063b1e7d90b02f0e6e2ee05f99d77e24e560392535e47e05077157f96813544a17046914f9efb64762a23cf7a49fe52a0a4c01c630cfe8727b81fb99a89ff7cc11dca5173057e0417b8fe7a9efba6d95c555f +19be72d897222e6b7478577e26ffea8da4d6f4292bf288152bf9218d454b1064 072fc02340ef99115bad72f92c01e4c093b9599f6cfc45cb380ee686cb5eb019e806ab9bd55e634ab10aa62a9510cc0672cd3eddb589c7df2b67fcd3329f61b1a4441eca87a33c8f55da4fbbad5cf2b2527b8e983bb31a2fadec7523 +f9e7419f0d5e7417fb408b96841a2d6b045f4b5d661a1e179331e3ece8baa37e 76eecf956a52649f877528146de33df249cd800e21830f65e90f0f25ca9d6540fde40603230eca6760f1139c7f268deba2060631eea92b1fff05f93fd5572fbe29579ecd48bc3a8d6c2eb4a6b26e38d6c5fbf2c08044aeea470a8f2f26 +414e67b3fc1e32881dd1578bf9b76e37a306928944aef51570af2785e2f3f2a2 7adc0b6693e61c269f278e6944a5a2d8300981e40022f839ac644387bfac9086650085c2cdc585fea47b9d2e52d65a2b29a7dc370401ef5d60dd0d21f9e2b90fae919319b14b8c5565b0423cefb827d5f1203302a9d01523498a4db10374 +adf37736dded1edc2c59c121e3501ca2e276ad618dfac6ea9488d706a57b34ff e1fffa9826cce8b86bccefb8794e48c46cdf372013f782eced1e378269b7be2b7bf51374092261ae120e822be685f2e7a83664bcfbe38fe8633f24e633ffe1988e1bc5acf59a587079a57a910bda60060e85b5f5b6f776f0529639d9cce4bd +ad172ce63859d319d4521bb533f71e3aa3611833c9af032073fc1d846041f1b9 69f9abba65592ee01db4dce52dbab90b08fc04193602792ee4daa263033d59081587b09bbe49d0b49c9825d22840b2ff5d9c5155f975f8f2c2e7a90c75d2e4a8040fe39f63bbafb403d9e28cc3b86e04e394a9c9e8065bd3c85fa9f0c7891600 +9dafcb6597b858c7a8c26b47a7a43e68a45e9c3bb65b243430e1d366c8406fe7 38a10a352ca5aedfa8e19c64787d8e9c3a75dbf3b8674bfab29b5dbfc15a63d10fae66cd1a6e6d2452d557967eaad89a4c98449787b0b3164ca5b717a93f24eb0b506ceb70cbbcb8d72b2a72993f909aad92f044e0b5a2c9ac9cb16a0ca2f81f49 +d6999f4ddd08b7d450431266d637e8fd87295251bb9ce022c240559dde4cc941 6d8c6e449bc13634f115749c248c17cd148b72157a2c37bf8969ea83b4d6ba8c0ee2711c28ee11495f43049596520ce436004b026b6c1f7292b9c436b055cbb72d530d860d1276a1502a5140e3c3f54a93663e4d20edec32d284e25564f624955b52 +2dcb4de3faafd2a0ab17525b7ed91e56337bcd31fff998c45655eb7f101c28eb 6efcbcaf451c129dbe00b9cef0c3749d3ee9d41c7bd500ade40cdc65dedbbbadb885a5b14b32a0c0d087825201e303288a733842fa7e599c0c514e078f05c821c7a4498b01c40032e9f1872a1c925fa17ce253e8935e4c3c71282242cb716b2089ccc1 +ad36c7d5267823155a9c3cd5c7c2a7d5af8f651edf1a1d347c5a0637f80ef65c 433c5303131624c0021d868a30825475e8d0bd3052a022180398f4ca4423b98214b6beaac21c8807a2c33f8c93bd42b092cc1b06cedf3224d5ed1ec29784444f22e08a55aa58542b524b02cd3d5d5f6907afe71c5d7462224a3f9d9e53e7e0846dcbb4ce +f000e80e9eb58c2d1099e91ab9da1fc68b3801cbb9cfe830953ccdb2be52fbaa a873e0c67ca639026b6683008f7aa6324d4979550e9bce064ca1e1fb97a30b147a24f3f666c0a72d71348ede701cf2d17e2253c34d1ec3b647dbcef2f879f4eb881c4830b791378c901eb725ea5c172316c6d606e0af7df4df7f76e490cd30b2badf45685f +928ca57e34918f93989b029c05aa0f24ada5f2be560bce8ccd8d1a350d3df158 006917b64f9dcdf1d2d87c8a6173b64f6587168e80faa80f82d84f60301e561e312d9fbce62f39a6fb476e01e925f26bcc91de621449be6504c504830aae394096c8fc7694651051365d4ee9070101ec9b68086f2ea8f8ab7b811ea8ad934d5c9b62c60a4771 +77e1e25f1f193af5a86372729ad7d1cad64f049ac7390f1268ade06176b4f9f5 f13c972c52cb3cc4a4df28c97f2df11ce089b815466be88863243eb318c2adb1a417cb1041308598541720197b9b1cb5ba2318bd5574d1df2174af14884149ba9b2f446d609df240ce335599957b8ec80876d9a085ae084907bc5961b20bf5f6ca58d5dab38adb +19c8c37d71f9bebd1905953be0869c0d3909e5b23db9da07be483aae23105bef e35780eb9799ad4c77535d4ddb683cf33ef367715327cf4c4a58ed9cbdcdd486f669f80189d549a9364fa82a51a52654ec721bb3aab95dceb4a86a6afa93826db923517e928f33e3fba850d45660ef83b9876accafa2a9987a254b137c6e140a21691e1069413848 +850fa2c7f64abb17e2ab6f63851a22710bd4ba1410e3323c45ffdff78b17ba77 64ec021c9585e01ffe6d31bb50d44c79b6993d72678163db474947a053674619d158016adb243f5c8d50aa92f50ab36e579ff2dabb780a2b529370daa299207cfbcdd3a9a25006d19c4f1fe33e4b1eaec315d8c6ee1e730623fd1941875b924eb57d6d0c2edc4e78d6 +bf2249aae7ffcc4dbe1d62e50e0e5cf1b5af567681de64f9fbf0600b7ebb9331 5954bab512cf327d66b5d9f296180080402624ad7628506b555eea8382562324cf452fba4a2130de3e165d11831a270d9cb97ce8c2d32a96f50d71600bb4ca268cf98e90d6496b0a6619a5a8c63db6d8a0634dfc6c7ec8ea9c006b6c456f1b20cd19e781af20454ac880 +e4aba860d055a5a7206ebc5e098491de34be74e18f45d1f92f510ab52163b4ad 03d9f92b2c565709a568724a0aff90f8f347f43b02338f94a03ed32e6f33666ff5802da4c81bdce0d0e86c04afd4edc2fc8b4141c2975b6f07639b1994c973d9a9afce3d9d365862003498513bfa166d2629e314d97441667b007414e739d7febf0fe3c32c17aa188a8683 +8b03d0fecc472c4dc932e2eaaa8f9c6c4e085a99b08c5ed1d8b7cb3ddb7c86cf f31e8b4f9e0621d531d22a380be5d9abd56faec53cbd39b1fab230ea67184440e5b1d15457bd25f56204fa917fa48e669016cb48c1ffc1e1e45274b3b47379e00a43843cf8601a5551411ec12503e5aac43d8676a1b2297ec7a0800dbfee04292e937f21c005f17411473041 +c57304529d2f14ffa2a0efe343921e8465f50ad7f5b954c6b08bd637ad97359a 758ea3fea738973db0b8be7e599bbef4519373d6e6dcd7195ea885fc991d896762992759c2a09002912fb08e0cb5b76f49162aeb8cf87b172cf3ad190253df612f77b1f0c532e3b5fc99c2d31f8f65011695a087a35ee4eee5e334c369d8ee5d29f695815d866da99df3f79403 +4911d03f24ad4b000f1f9dc27ed18b948620ab07f9f73a93d351e3636019228d 47c6e0c2b74948465921868804f0f7bd50dd323583dc784f998a93cd1ca4c6ef84d41dc81c2c40f34b5bee6a93867b3bdba0052c5f59e6f3657918c382e771d33109122cc8bb0e1e53c4e3d13b43ce44970f5e0c079d2ad7d7a3549cd75760c21bb15b447589e86e8d76b1e9ced2 +5eae8c4fa2e296ef5b246bf8abd0874b02b579ddfa372ca8e7543e7cbf5280a2 f690a132ab46b28edfa6479283d6444e371c6459108afd9c35dbd235e0b6b6ff4c4ea58e7554bd002460433b2164ca51e868f7947d7d7a0d792e4abf0be5f450853cc40d85485b2b8857ea31b5ea6e4ccfa2f3a7ef3380066d7d8979fdac618aad3d7e886dea4f005ae4ad05e5065f +dc57217032f0fbc452799adc8eb4cc69f5e2ee897b683109bbb8f209f8b5ff5a 58d6a99bc6458824b256916770a8417040721cccfd4b79eacd8b65a3767ce5ba7e74104c985ac56b8cc9aebd16febd4cda5adb130b0ff2329cc8d611eb14dac268a2f9e633c99de33997fea41c52a7c5e1317d5b5daed35eba7d5a60e45d1fa7eaabc35f5c2b0a0f2379231953322c4e +22ad1cc3af216b694406ef50a5b8c9b8b11b39ebdd6427aa68f8b716e5df31ca befab574396d7f8b6705e2d5b58b2c1c820bb24e3f4bae3e8fbcd36dbf734ee14e5d6ab972aedd3540235466e825850ee4c512ea9795abfd33f330d9fd7f79e62bbb63a6ea85de15beaeea6f8d204a28956059e2632d11861dfb0e65bc07ac8a159388d5c3277e227286f65ff5e5b5aec1 +6b92e57f39edd40ab91a92388ff228b4a5b431c85ba971c7a249d12e7a2d916b 8e58144fa9179d686478622ce450c748260c95d1ba43b8f9b59abeca8d93488da73463ef40198b4d16fb0b0707201347e0506ff19d01bea0f42b8af9e71a1f1bd168781069d4d338fdef00bf419fbb003031df671f4a37979564f69282de9c65407847dd0da505ab1641c02dea4f0d834986 +3155a4a0c38bdbe5505484a29032a1886d8c3a5d91010bc0ff81c9c505d69ffc b55c10eae0ec684c16d13463f29291bf26c82e2fa0422a99c71db4af14dd9c7f33eda52fd73d017cc0f2dbe734d831f0d820d06d5f89dacc485739144f8cfd4799223b1aff9031a105cb6a029ba71e6e5867d85a554991c38df3c9ef8c1e1e9a7630be61caabca69280c399c1fb7a12d12aefc +7a83af473ebc521487e2e28607407ae0ef6034f750f89639cb4fb26b36cbd7e4 2eeea693f585f4ed6f6f8865bbae47a6908aecd7c429e4bec4f0de1d0ca0183fa201a0cb14a529b7d7ac0e6ff6607a3243ee9fb11bcf3e2304fe75ffcddd6c5c2e2a4cd45f63c962d010645058d36571404a6d2b4f44755434d76998e83409c3205aa1615db44057db991231d2cb42624574f545 +54d82b42c84b9bcd11f4834a50e1d968fb54c451b649b5a5201f4358997c2555 dab11dc0b047db0420a585f56c42d93175562852428499f66a0db811fcdddab2f7cdffed1543e5fb72110b64686bc7b6887a538ad44c050f1e42631bc4ec8a9f2a047163d822a38989ee4aab01b4c1f161b062d873b1cfa388fd301514f62224157b9bef423c7783b7aac8d30d65cd1bba8d689c2d +0193633694b53296da8f1dfde3783466804c1dc1d95e89555e069228544aefb6 42e99a2f80aee0e001279a2434f731e01d34a44b1a8101726921c0590c30f3120eb83059f325e894a5ac959dca71ce2214799916424e859d27d789437b9d27240bf8c35adbafcecc322b48aa205b293962d858652abacbd588bcf6cbc388d0993bd622f96ed54614c25b6a9aa527589eaaffcf17ddf7 +14f30b014222c3c85f7f8d9ade2f86347303ec62aa79add7ddf45cb5f77b4098 3c9b46450c0f2cae8e3823f8bdb4277f31b744ce2eb17054bddc6dff36af7f49fb8a2320cc3bdf8e0a2ea29ad3a55de1165d219adeddb5175253e2d1489e9b6fdd02e2c3d3a4b54d60e3a47334c37913c5695378a669e9b72dec32af5434f93f46176ebf044c4784467c700470d0c0b40c8a088c815816 +50b3b3cadebefa8702671075d02b8a9d6a7a770393c3b8a02b4e6d4496f2f766 d1e654b77cb155f5c77971a64df9e5d34c26a3cad6c7f6b300d39deb1910094691adaa095be4ba5d86690a976428635d5526f3e946f7dc3bd4dbc78999e653441187a81f9adcd5a3c5f254bc8256b0158f54673dcc1232f6e918ebfc6c51ce67eaeb042d9f57eec4bfe910e169af78b3de48d137df4f2840 +c1307f4c1e033297ae938227d6eb924ffa73c169169864d2ec766b020f76e1e9 626f68c18a69a6590159a9c46be03d5965698f2dac3de779b878b3d9c421e0f21b955a16c715c1ec1e22ce3eb645b8b4f263f60660ea3028981eebd6c8c3a367285b691c8ee56944a7cd1217997e1d9c21620b536bdbd5de8925ff71dec6fbc06624ab6b21e329813de90d1e572dfb89a18120c3f606355d25 +bb897b143c1821169c77adb41f861d319094697c30538671d5cab18d311ec370 651a6fb3c4b80c7c68c6011675e6094eb56abf5fc3057324ebc6477825061f9f27e7a94633abd1fa598a746e4a577caf524c52ec1788471f92b8c37f23795ca19d559d446cab16cbcdce90b79fa1026cee77bf4ab1b503c5b94c2256ad75b3eac6fd5dcb96aca4b03a834bfb4e9af988cecbf2ae597cb9097940 +b9e3651b761c60b3180f3a88900bd22e81df2b8b9c370b0cd609153b5190e095 8aaf072fce8a2d96bc10b3c91c809ee93072fb205ca7f10abd82ecd82cf040b1bc49ea13d1857815c0e99781de3adbb5443ce1c897e55188ceaf221aa9681638de05ae1b322938f46bce51543b57ecdb4c266272259d1798de13be90e10efec2d07484d9b21a3870e2aa9e06c21aa2d0c9cf420080a80a91dee16f +138cebb576af32d5616c05e698ed85b71a9424cdf74645876746033f75ff5eaa 53f918fd00b1701bd504f8cdea803acca21ac18c564ab90c2a17da592c7d69688f6580575395551e8cd33e0fef08ca6ed4588d4d140b3e44c032355df1c531564d7f4835753344345a6781e11cd5e095b73df5f82c8ae3ad00877936896671e947cc52e2b29dcd463d90a0c9929128da222b5a211450bbc0e02448e2 +0756000c37ce0c12f78174a8e26355b577d7c4da66db5862804e02f7f4eb4b0d a64599b8a61b5ccec9e67aed69447459c8da3d1ec6c7c7c82a7428b9b584fa67e90f68e2c00fbbed4613666e5168da4a16f395f7a3c3832b3b134bfc9cbaa95d2a0fe252f44ac6681eb6d40ab91c1d0282fed6701c57463d3c5f2bb8c6a7301fb4576aa3b5f15510db8956ff77478c26a7c09bea7b398cfc83503f538e +0e114a3d197ad4a3f9dffba3f71e566627f66daade41c6fbde09974eb810890f 0e3ab0e054739b00cdb6a87bd12cae024b54cb5e550e6c425360c2e87e59401f5ec24ef0314855f0f56c47695d56a7fb1417693af2a1ed5291f2fee95f75eed54a1b1c2e81226fbff6f63ade584911c71967a8eb70933bc3f5d15bc91b5c2644d9516d3c3a8c154ee48e118bd1442c043c7a0dba5ac5b1d5360aae5b9065 +458fbae7f8089c8e6c5289f213daeca46360bba6e7e875730e3d3278b2fd3dd4 a62fc595b4096e6336e53fcdfc8d1cc175d71dac9d750a6133d23199eaac288207944cea6b16d27631915b4619f743da2e30a0c00bbdb1bbb35ab852ef3b9aec6b0a8dcc6e9e1abaa3ad62ac0a6c5de765de2c3711b769e3fde44a74016fff82ac46fa8f1797d3b2a726b696e3dea5530439acee3a45c2a51bc32dd055650b +b8a871928fcc39ab286e5a768b0ae61ddbd765fbc55c2dd2f3d10477d362a08f 2b6db7ced8665ebe9deb080295218426bdaa7c6da9add2088932cdffbaa1c14129bccdd70f369efb149285858d2b1d155d14de2fdb680a8b027284055182a0cae275234cc9c92863c1b4ab66f304cf0621cd54565f5bff461d3b461bd40df28198e3732501b4860eadd503d26d6e69338f4e0456e9e9baf3d827ae685fb1d817 +3fb802f7e1a02f103c236227fa733eb0f4e1624238e152987897b58dce46e48f 10db509b2cdcaba6c062ae33be48116a29eb18e390e1bbada5ca0a2718afbcd23431440106594893043cc7f2625281bf7de2655880966a23705f0c5155c2f5cca9f2c2142e96d0a2e763b70686cd421b5db812daced0c6d65035fde558e94f26b3e6dde5bd13980cc80292b723013bd033284584bff27657871b0cf07a849f4ae2 +dcd06d48fc1f1b1465de9926a2f6d954694677fe642f54d20612ef906f9ff494 9334de60c997bda6086101a6314f64e4458f5ff9450c509df006e8c547983c651ca97879175aaba0c539e82d05c1e02c480975cbb30118121061b1ebac4f8d9a3781e2db6b18042e01ecf9017a64a0e57447ec7fcbe6a7f82585f7403ee2223d52d37b4bf426428613d6b4257980972a0acab508a7620c1cb28eb4e9d30fc41361ec +df75c5ef578b90e43e31e2469ded46c8121c74739eeaa671ef4d6daaf5971c8a e88ab086891693aa535ceb20e64c7ab97c7dd3548f3786339897a5f0c39031549ca870166e477743ccfbe016b4428d89738e426f5ffe81626137f17aecff61b72dbee2dc20961880cfe281dfab5ee38b1921881450e16032de5e4d55ad8d4fca609721b0692bac79be5a06e177fe8c80c0c83519fb3347de9f43d5561cb8107b9b5edc +e2454ecc01361f697cb6fe9065882507378cbcaa4dbfec0abd84389988250b6e fd19e01a83eb6ec810b94582cb8fbfa2fcb992b53684fb748d2264f020d3b960cb1d6b8c348c2b54a9fcea72330c2aaa9a24ecdb00c436abc702361a82bb8828b85369b8c72ece0082fe06557163899c2a0efa466c33c04343a839417057399a63a3929be1ee4805d6ce3e5d0d0967fe9004696a5663f4cac9179006a2ceb75542d75d68 +7209e1a97c1c0c3e11b0403281cc583173fedc5f7bdabf32c196bf2d49274137 59ae20b6f7e0b3c7a989afb28324a40fca25d8651cf1f46ae383ef6d8441587aa1c04c3e3bf88e8131ce6145cfb8973d961e8432b202fa5af3e09d625faad825bc19da9b5c6c20d02abda2fcc58b5bd3fe507bf201263f30543819510c12bc23e2ddb4f711d087a86edb1b355313363a2de996b891025e147036087401ccf3ca7815bf3c49 +e4d6f3bed3e95ee629a290f3d8c0c38127765eb8ddf414c0eeced665d4d838ca 77ee804b9f3295ab2362798b72b0a1b2d3291dceb8139896355830f34b3b328561531f8079b79a6e9980705150866402fdc176c05897e359a6cb1a7ab067383eb497182a7e5aef7038e4c96d133b2782917417e391535b5e1b51f47d8ed7e4d4025fe98dc87b9c1622614bff3d1029e68e372de719803857ca52067cddaad958951cb2068cc6 +de5f8bc4d8a9936318ea2aad610cd6b81e83eb11d3b70f1fca7bf2192c1bf863 b771d5cef5d1a41a93d15643d7181d2a2ef0a8e84d91812f20ed21f147bef732bf3a60ef4067c3734b85bc8cd471780f10dc9e8291b58339a677b960218f71e793f2797aea349406512829065d37bb55ea796fa4f56fd8896b49b2cd19b43215ad967c712b24e5032d065232e02c127409d2ed4146b9d75d763d52db98d949d3b0fed6a8052fbb +9eb6140b06999ec2f242d4f79a259aba2527f10b5a9e8dc818dc91bcf5591f2f b32d95b0b9aad2a8816de6d06d1f86008505bd8c14124f6e9a163b5a2ade55f835d0ec3880ef50700d3b25e42cc0af050ccd1be5e555b23087e04d7bf9813622780c7313a1954f8740b6ee2d3f71f768dd417f520482bd3a08d4f222b4ee9dbd015447b33507dd50f3ab4247c5de9a8abd62a8decea01e3b87c8b927f5b08beb37674c6f8e380c04 +23bb7025478aab44ccef2d94c6385faaf26441fc6e3feacd20c9b18f8ca2c4ac 04410e31082a47584b406f051398a6abe74e4da59bb6f85e6b49e8a1f7f2ca00dfba5462c2cd2bfde8b64fb21d70c083f11318b56a52d03b81cac5eec29eb31bd0078b6156786da3d6d8c33098c5c47bb67ac64db14165af65b44544d806dde5f487d5373c7f9792c299e9686b7e5821e7c8e2458315b996b5677d926dac57b3f22da873c601016a0d +abb947cadc601b4106843833d792b99b0b7beb58f67ab88d208bea6192f23f9a 8b81e9badde026f14d95c019977024c9e13db7a5cd21f9e9fc491d716164bbacdc7060d882615d411438aea056c340cdf977788f6e17d118de55026855f93270472d1fd18b9e7e812bae107e0dfde7063301b71f6cfe4e225cab3b232905a56e994f08ee2891ba922d49c3dafeb75f7c69750cb67d822c96176c46bd8a29f1701373fb09a1a6e3c7158f +214ca18eb5b50ff5620e8b0763ef0b9106266164e041d06b89c38d87cbf6318f fa6eed24da6666a22208146b19a532c2ec9ba94f09f1def1e7fc13c399a48e41acc2a589d099276296348f396253b57cb0e40291bd282773656b6e0d8bea1cda084a3738816a840485fcf3fb307f777fa5feac48695c2af4769720258c77943fb4556c362d9cba8bf103aeb9034baa8ea8bfb9c4f8e6742ce0d52c49ea8e974f339612e830e9e7a9c29065 +a805eea9da6369fc906d29328f7d33ddf69a1e0331663a9f6b088dc1720f15e9 9bb4af1b4f09c071ce3cafa92e4eb73ce8a6f5d82a85733440368dee4eb1cbc7b55ac150773b6fe47dbe036c45582ed67e23f4c74585dab509df1b83610564545642b2b1ec463e18048fc23477c6b2aa035594ecd33791af6af4cbc2a1166aba8d628c57e707f0b0e8707caf91cd44bdb915e0296e0190d56d33d8dde10b5b60377838973c1d943c22ed335e +cbb1021658c18350dd9d874c46c7e4ff21ecf843004f0085050608e4ba3f9b42 2167f02118cc62043e9091a647cadbed95611a521fe0d64e8518f16c808ab297725598ae296880a773607a798f7c3cfce80d251ebec6885015f9abf7eaabae46798f82cb5926de5c23f44a3f9f9534b3c6f405b5364c2f8a8bdc5ca49c749bed8ce4ba48897062ae8424ca6dde5f55c0e42a95d1e292ca54fb46a84fbc9cd87f2d0c9e7448de3043ae22fdd229 +2909b5fcdc88b48d94affd10f5319e3b958bab5ddf3178de9d472d05909d4463 94b7fa0bc1c44e949b1d7617d31b4720cbe7ca57c6fa4f4094d4761567e389ecc64f6968e4064df70df836a47d0c713336b5028b35930d29eb7a7f9a5af9ad5cf441745baec9bb014ceeff5a41ba5c1ce085feb980bab9cf79f2158e03ef7e63e29c38d7816a84d4f71e0f548b7fc316085ae38a060ff9b8dec36f91ad9ebc0a5b6c338cbb8f6659d342a24368cf +0a674b2879066d973a12cee73eba6e220bea71ae4f79f3ac5d6a7b45b481b2a8 ea40e83cb18b3a242c1ecc6ccd0b7853a439dab2c569cfc6dc38a19f5c90acbf76aef9ea3742ff3b54ef7d36eb7ce4ff1c9ab3bc119cff6be93c03e208783335c0ab8137be5b10cdc66ff3f89a1bddc6a1eed74f504cbe7290690bb295a872b9e3fe2cee9e6c67c41db8efd7d863cf10f840fe618e7936da3dca5ca6df933f24f6954ba0801a1294cd8d7e66dfafec +3f0c1e7d29cd2df17fcaf8ca094430f4425778c5a034ea17ac1867938404443f 157d5b7e4507f66d9a267476d33831e7bb768d4d04cc3438da12f9010263ea5fcafbde2579db2f6b58f911d593d5f79fb05fe3596e3fa80ff2f761d1b0e57080055c118c53e53cdb63055261d7c9b2b39bd90acc32520cbbdbda2c4fd8856dbcee173132a2679198daf83007a9b5c51511ae49766c792a29520388444ebefe28256fb33d4260439cba73a9479ee00c63 +d7de799525c98315db3e49fa35e300feea4e0329f802ad67527317cc8c203642 836b34b515476f613fe447a4e0c3f3b8f20910ac89a3977055c960d2d5d2b72bd8acc715a9035321b86703a411dde0466d58a59769672aa60ad587b8481de4bba552a1645779789501ec53d540b904821f32b0bd1855b04e4848f9f8cfe9ebd8911be95781a759d7ad9724a7102dbe576776b7c632bc39b9b5e19057e226552a5994c1dbb3b5c7871a11f5537011044c53 +4592fd749e2ae0a557bb282cd40322cd317aae31fdbcf2bdc3ce5d7d0cf634a8 cc7784a4912a7ab5ad3620aab29ba87077cd3cb83636adc9f3dc94f51edf521b2161ef108f21a0a298557981c0e53ce6ced45bdf782c1ef200d29bab81dd6460586964edab7cebdbbec75fd7925060f7da2b853b2b089588fa0f8c16ec6498b14c55dcee335cb3a91d698e4d393ab8e8eac0825f8adebeee196df41205c011674e53426caa453f8de1cbb57932b0b741d4c6 +e560dd6bd58810e07d3c91bcc33d217c609d30ec3ee2137ae4cda91490dae910 7639b461fff270b2455ac1d1afce782944aea5e9087eb4a39eb96bb5c3baaf0e868c8526d3404f9405e79e77bfac5ffb89bf1957b523e17d341d7323c302ea7083872dd5e8705694acdda36d5a1b895aaa16eca6104c82688532c8bfe1790b5dc9f4ec5fe95baed37e1d287be710431f1e5e8ee105bc42ed37d74b1e55984bf1c09fe6a1fa13ef3b96faeaed6a2a1950a12153 +d979990b8884f9c744b36c0f53c32fa33fae8b4c4533e2116049d9c14990d8c9 eb6513fc61b30cfba58d4d7e80f94d14589090cf1d80b1df2e68088dc6104959ba0d583d585e9578ab0aec0cf36c48435eb52ed9ab4bbce7a5abe679c97ae2dbe35e8cc1d45b06dda3cf418665c57cbee4bbb47fa4caf78f4ee656fec237fe4eebbafa206e1ef2bd0ee4ae71bd0e9b2f54f91daadf1febfd7032381d636b733dcb3bf76fb14e23aff1f68ed3dbcf75c9b99c6f26 +afccf346f6301ebe80871e171ff25aa4e4ecf9fa7cd1c11f8555405fbc22161c 1594d74bf5dde444265d4c04dad9721ff3e34cbf622daf341fe16b96431f6c4df1f760d34f296eb97d98d560ad5286fec4dce1724f20b54fd7df51d4bf137add656c80546fb1bf516d62ee82baa992910ef4cc18b70f3f8698276fcfb44e0ec546c2c39cfd8ee91034ff9303058b4252462f86c823eb15bf481e6b79cc3a02218595b3658e8b37382bd5048eaed5fd02c37944e73b +7d3d653d673b21cad0daf9cae11f0bc912d3d5eb224982ebd554d9cfbbd873ad 4cfa1278903026f66fedd41374558be1b585d03c5c55dac94361df286d4bd39c7cb8037ed3b267b07c346626449d0cc5b0dd2cf221f7e4c3449a4be99985d2d5e67bff2923357ddeab5abcb4619f3a3a57b2cf928a022eb27676c6cf805689004fca4d41ea6c2d0a4789c7605f7bb838dd883b3ad3e6027e775bcf262881428099c7fff95b14c095ea130e0b9938a5e22fc52650f591 +d8012fd0aa4283088281355e4b4dfa2d2603921af66fddde3239d31dbb036c0f d3e65cb92cfa79662f6af493d696a07ccf32aaadcceff06e73e8d9f6f909209e66715d6e978788c49efb9087b170ecf3aa86d2d4d1a065ae0efc8924f365d676b3cb9e2bec918fd96d0b43dee83727c9a93bf56ca2b2e59adba85696546a815067fc7a78039629d4948d157e7b0d826d1bf8e81237bab7321312fdaa4d521744f988db6fdf04549d0fdca393d639c729af716e9c8bba48 +190250efa83814c8b75d82e93058e5a933e5ebe80f8bfe2e6e205edad40c2f72 842cc583504539622d7f71e7e31863a2b885c56a0ba62db4c2a3f2fd12e79660dc7205ca29a0dc0a87db4dc62ee47a41db36b9ddb3293b9ac4baae7df5c6e7201e17f717ab56e12cad476be49608ad2d50309e7d48d2d8de4fa58ac3cfeafeee48c0a9eec88498e3efc51f54d300d828dddccb9d0b06dd021a29cf5cb5b2506915beb8a11998b8b886e0f9b7a80e97d91a7d01270f9a7717 +dd8339c37bb0f457d84294ab80c1dc2dca5222762ebd9f17230eda87a9adaedc 6c4b0a0719573e57248661e98febe326571f9a1ca813d3638531ae28b4860f23c3a3a8ac1c250034a660e2d71e16d3acc4bf9ce215c6f15b1c0fc7e77d3d27157e66da9ceec9258f8f2bf9e02b4ac93793dd6e29e307ede3695a0df63cbdc0fc66fb770813eb149ca2a916911bee4902c47c7802e69e405fe3c04ceb5522792a5503fa829f707272226621f7c488a7698c0d69aa561be9f378 +87be560576aae40443bab303023a8b8ebba990cd5e797d6810b80513e0319429 51b7dbb7ce2ffeb427a91ccfe5218fd40f9e0b7e24756d4c47cd55606008bdc27d16400933906fd9f30effdd4880022d081155342af3fb6cd53672ab7fb5b3a3bcbe47be1fd3a2278cae8a5fd61c1433f7d350675dd21803746cadca574130f01200024c6340ab0cc2cf74f2234669f34e9009ef2eb94823d62b31407f4ba46f1a1eec41641e84d77727b59e746b8a671bef936f05be820759fa +5166641b609c300ba0e221c978dd2b0204bebd7c6610ea703bd08cca5b34dd86 83599d93f5561e821bd01a472386bc2ff4efbd4aed60d5821e84aae74d8071029810f5e286f8f17651cd27da07b1eb4382f754cd1c95268783ad09220f5502840370d494beb17124220f6afce91ec8a0f55231f9652433e5ce3489b727716cf4aeba7dcda20cd29aa9a859201253f948dd94395aba9e3852bd1d60dda7ae5dc045b283da006e1cbad83cc13292a315db5553305c628dd091146597 +58d67b49df09b78221be4b0b79bf088f51d97041e0d655593a319fdd5e6ef721 2be9bf526c9d5a75d565dd11ef63b979d068659c7f026c08bea4af161d85a462d80e45040e91f4165c074c43ac661380311a8cbed59cc8e4c4518e80cd2c78ab1cabf66bff83eab3a80148550307310950d034a6286c93a1ece8929e6385c5e3bb6ea8a7c0fb6d6332e320e71cc4eb462a2a62e2bfe08f0ccad93e61bedb5dd0b786a728ab666f07e0576d189c92bf9fb20dca49ac2d3956d47385e2 +d2e94b437c6dbd286268130fe7f6fb297d2adec27aa568e64782306a6ef90b68 ca76d3a12595a817682617006848675547d3e8f50c2210f9af906c0e7ce50b4460186fe70457a9e879e79fd4d1a688c70a347361c847ba0dd6aa52936eaf8e58a1be2f5c1c704e20146d366aeb3853bed9de9befe9569ac8aaea37a9fb7139a1a1a7d5c748605a8defb297869ebedd71d615a5da23496d11e11abbb126b206fa0a7797ee7de117986012d0362dcef775c2fe145ada6bda1ccb326bf644 +04cc4e4e3e9f792773ee28f9349abd6208be1d3f4adf2ac19ec7b26888ec8c42 f76b85dc67421025d64e93096d1d712b7baf7fb001716f02d33b2160c2c882c310ef13a576b1c2d30ef8f78ef8d2f465007109aad93f74cb9e7d7bef7c9590e8af3b267c89c15db238138c45833c98cc4a471a7802723ef4c744a853cf80a0c2568dd4ed58a2c9644806f42104cee53628e5bdf7b63b0b338e931e31b87c24b146c6d040605567ceef5960df9e022cb469d4c787f4cba3c544a1ac91f95f +8553e8aae38c5f761e9c8acd43debfcd29532f084f61f808f51ec9811c8c4cd2 25b8c9c032ea6bcd733ffc8718fbb2a503a4ea8f71dea1176189f694304f0ff68e862a8197b839957549ef243a5279fc2646bd4c009b6d1edebf24738197abb4c992f6b1dc9ba891f570879accd5a6b18691a93c7d0a8d38f95b639c1daeb48c4c2f15ccf5b9d508f8333c32de78781b41850f261b855c4bebcc125a380c54d501c5d3bd07e6b52102116088e53d76583b0161e2a58d0778f091206aabd5a1 +579cbafd2441e12bec57c47e64986127935f5d45f7f3551bbe6e5619673e541f 21cfdc2a7ccb7f331b3d2eefff37e48ad9fa9c788c3f3c200e0173d99963e1cbca93623b264e920394ae48bb4c3a5bb96ffbc8f0e53f30e22956adabc2765f57fb761e147ecbf8567533db6e50c8a1f894310a94edf806dd8ca6a0e141c0fa7c9fae6c6ae65f18c93a8529e6e5b553bf55f25be2e80a9882bd37f145fecbeb3d447a3c4e46c21524cc55cdd62f521ab92a8ba72b897996c49bb273198b7b1c9e +9b45593f27266870c23ceb772d5144fa7bcca881c29e2d8e7230cd3a6f9c49f1 4e452ba42127dcc956ef4f8f35dd68cb225fb73b5bc7e1ec5a898bba2931563e74faff3b67314f241ec49f4a7061e3bd0213ae826bab380f1f14faab8b0efddd5fd1bb49373853a08f30553d5a55ccbbb8153de4704f29ca2bdeef0419468e05dd51557ccc80c0a96190bbcc4d77ecff21c66bdf486459d427f986410f883a80a5bcc32c20f0478bb9a97a126fc5f95451e40f292a4614930d054c851acd019ccf +be26144c1afdd116746ec0f8eef3109ac73373f81ceb733ecd3e5dabd592df75 fa85671df7dadf99a6ffee97a3ab9991671f5629195049880497487867a6c446b60087fac9a0f2fcc8e3b24e97e42345b93b5f7d3691829d3f8ccd4bb36411b85fc2328eb0c51cb3151f70860ad3246ce0623a8dc8b3c49f958f8690f8e3860e71eb2b1479a5cea0b3f8befd87acaf5362435eaeccb52f38617bc6c5c2c6e269ead1fbd69e941d4ad2012da2c5b21bcfbf98e4a77ab2af1f3fda3233f046d38f1dc8 +909c957f496e5f9086f9db17737f4e8d4ec6f7cf0dbb43ab34fcba202318d0f0 e90847ae6797fbc0b6b36d6e588c0a743d725788ca50b6d792352ea8294f5ba654a15366b8e1b288d84f5178240827975a763bc45c7b0430e8a559df4488505e009c63da994f1403f407958203cebb6e37d89c94a5eacf6039a327f6c4dbbc7a2a307d976aa39e41af6537243fc218dfa6ab4dd817b6a397df5ca69107a9198799ed248641b63b42cb4c29bfdd7975ac96edfc274ac562d0474c60347a078ce4c25e88 +7f2d6197ba1462806da377ea44609bc4e5a3dd0fd97de5366ae9c066810699f5 f6d5c2b6c93954fc627602c00c4ca9a7d3ed12b27173f0b2c9b0e4a5939398a665e67e69d0b12fb7e4ceb253e8083d1ceb724ac07f009f094e42f2d6f2129489e846eaff0700a8d4453ef453a3eddc18f408c77a83275617fabc4ea3a2833aa73406c0e966276079d38e8e38539a70e194cc5513aaa457c699383fd1900b1e72bdfb835d1fd321b37ba80549b078a49ea08152869a918ca57f5b54ed71e4fd3ac5c06729 +84a94e3988adce3c90b8226c617ac86702b139a67c2bd9ff4aa7e9aed1be1cb9 cf8562b1bed89892d67ddaaf3deeb28246456e972326dbcdb5cf3fb289aca01e68da5d59896e3a6165358b071b304d6ab3d018944be5049d5e0e2bb819acf67a6006111089e6767132d72dd85beddcbb2d64496db0cc92955ab4c6234f1eea24f2d51483f2e209e4589bf9519fac51b4d061e801125e605f8093bb6997bc163d551596fe4ab7cfae8fb9a90f6980480ce0c229fd1675409bd788354daf316240cfe0af93eb +dda89323ed7e2989db52bca5fdfa39dca829ab29279d63eec830bb5ec3e841aa 2ace31abb0a2e3267944d2f75e1559985db7354c6e605f18dc8470423fca30b7331d9b33c4a4326783d1caae1b4f07060eff978e4746bf0c7e30cd61040bd5ec2746b29863eb7f103ebda614c4291a805b6a4c8214230564a0557bc7102e0bd3ed23719252f7435d64d210ee2aafc585be903fa41e1968c50fd5d5367926df7a05e3a42cf07e656ff92de73b036cf8b19898c0cb34557c0c12c2d8b84e91181af467bc75a9d1 +9f64cb18cec6378bb9d822a3abfc8b2466c9815ebc2a5da19657050c20a64765 0d8d09aed19f1013969ce5e7eb92f83a209ae76be31c754844ea9116ceb39a22ebb6003017bbcf26555fa6624185187db8f0cb3564b8b1c06bf685d47f3286eda20b83358f599d2044bbf0583fab8d78f854fe0a596183230c5ef8e54426750eaf2cc4e29d3bdd037e734d863c2bd9789b4c243096138f7672c232314effdfc6513427e2da76916b5248933be312eb5dde4cf70804fb258ac5fb82d58d08177ac6f4756017fff5 +801d351f60d183c6db817a005c3f45add27311ef9e7a269c835f0250e768c7b1 c3236b73deb7662bf3f3daa58f137b358ba610560ef7455785a9befdb035a066e90704f929bd9689cef0ce3bda5acf4480bceb8d09d10b098ad8500d9b6071dfc3a14af6c77511d81e3aa8844986c3bea6f469f9e02194c92868cd5f51646256798ff0424954c1434bdfed9facb390b07d342e992936e0f88bfd0e884a0ddb679d0547ccdec6384285a45429d115ac7d235a717242021d1dc35641f5f0a48e8445dba58e6cb2c8ea +7ccd6e7cc440941c3603ac052568820a6557dc7817064e08a70eb9c5edfb36aa b39feb8283eadc63e8184b51df5ae3fd41aac8a963bb0be1cd08aa5867d8d910c669221e73243360646f6553d1ca05a84e8dc0de05b6419ec349ca994480193d01c92525f3fb3dcefb08afc6d26947bdbbfd85193f53b50609c6140905c53a6686b58e53a319a57b962331ede98149af3de3118a819da4d76706a0424b4e1d2910b0ed26af61d150ebcb46595d4266a0bd7f651ba47d0c7f179ca28545007d92e8419d48fdfbd744ce +8bf79cc0d8706b40b7dcc53d342df0f428d88cb6794bf18e1fda572f7c617996 a983d54f503803e8c7999f4edbbe82e9084f422143a932ddddc47a17b0b7564a7f37a99d0786e99476428d29e29d3c197a72bfab1342c12a0fc4787fd7017d7a6174049ea43b5779169ef7472bdbbd941dcb82fc73aac45a8a94c9f2bd3477f61fd3b796f02a1b8264a214c6fea74b7051b226c722099ec7883a462b83b6afdd4009248b8a237f605fe5a08fe7d8b45321421ebba67bd70a0b00ddbf94baab7f359d5d1eea105f28dcfb +c90eca0cad1c95a47fc2d543e047fe046dcacbe8476c833d264fad2a2d1f6588 e4d1c1897a0a866ce564635b74222f9696bf2c7f640dd78d7e2aca66e1b61c642bb03ea7536aae597811e9bf4a7b453ede31f97b46a5f0ef51a071a2b3918df16b152519ae3776f9f1edab4c2a377c3292e96408359d3613844d5eb393000283d5ad3401a318b12fd1474b8612f2bb50fb6a8b9e023a54d7dde28c43d6d8854c8d9d1155935c199811dbfc87e9e0072e90eb88681cc7529714f8fb8a2c9d88567adfb974ee205a9bf7b848 +a76f275cc188df8ce6c23a9a3bd665ccd1514ac49bb118e21715db19a08e73d2 b10c59723e3dcadd6d75df87d0a1580e73133a9b7d00cb95ec19f5547027323be75158b11f80b6e142c6a78531886d9047b08e551e75e6261e79785366d7024bd7cd9cf322d9be7d57fb661069f2481c7bb759cd71b4b36ca2bc2df6d3a328faebdb995a9794a8d72155ed551a1f87c80bf6059b43fc764900b18a1c2441f7487743cf84e565f61f8dd2ece6b6ccc9444049197aaaf53e926fbee3bfca8be588ec77f29d211be89de18b15f6 +781eeb74e8692c9cb7d372a275e7d5b3747250219a6d7654469620b5ff441a78 db11f609baba7b0ca634926b1dd539c8cbada24967d7add4d9876f77c2d80c0f4dcefbd7121548373582705cca2495bd2a43716fe64ed26d059cfb566b3364bd49ee0717bdd9810dd14d8fad80dbbdc4cafb37cc60fb0fe2a80fb4541b8ca9d59dce457738a9d3d8f641af8c3fd6da162dc16fc01aac527a4a0255b4d231c0be50f44f0db0b713af03d968fe7f0f61ed0824c55c4b5265548febd6aad5c5eedf63efe793489c39b8fd29d104ce +659351b47c2d59cd9fef294dbd6d67aa8a7fe506fbd190e1b354e1d787f3700f bebd4f1a84fc8b15e4452a54bd02d69e304b7f32616aadd90537937106ae4e28de9d8aab02d19bc3e2fde1d651559e296453e4dba94370a14dbbb2d1d4e2022302ee90e208321efcd8528ad89e46dc839ea9df618ea8394a6bff308e7726bae0c19bcd4be52da6258e2ef4e96aa21244429f49ef5cb486d7ff35cac1bacb7e95711944bccb2ab34700d42d1eb38b5d536b947348a458ede3dc6bd6ec547b1b0cae5b257be36a7124e1060c170ffa +d3ba66b3ef189d14062b31fb59cb726cc6132d289bb192c928a1b817e464d65e 5aca56a03a13784bdc3289d9364f79e2a85c12276b49b92db0adaa4f206d5028f213f678c3510e111f9dc4c1c1f8b6acb17a6413aa227607c515c62a733817ba5e762cc6748e7e0d6872c984d723c9bb3b117eb8963185300a80bfa65cde495d70a46c44858605fccbed086c2b45cef963d33294dbe9706b13af22f1b7c4cd5a001cfec251fba18e722c6e1c4b1166918b4f6f48a98b64b3c07fc86a6b17a6d0480ab79d4e6415b520f1c484d675b1 +1903eea5755535b33d099bf9bf0a514a013de749a4ad707600e89118db38c415 a5aad0e4646a32c85cfcac73f02fc5300f1982fabb2f2179e28303e447854094cdfc854310e5c0f60993ceff54d84d6b46323d930adb07c17599b35b505f09e784bca5985e0172257797fb53649e2e9723efd16865c31b5c3d5113b58bb0bfc8920fabdda086d7537e66d709d050bd14d0c960873f156fad5b3d3840cdfcdc9be6af519db262a27f40896ab25cc39f96984d650611c0d5a3080d5b3a1bf186abd42956588b3b58cd948970d298776060 +93fa9529c6b6fd1f353464e6391089a66927149623d502f7652b8b476636bcc0 06cbbe67e94a978203ead6c057a1a5b098478b4b4cbef5a97e93c8e42f5572713575fc2a884531d7622f8f879387a859a80f10ef02708cd8f7413ab385afc357678b9578c0ebf641ef076a1a30f1f75379e9dcb2a885bdd295905ee80c0168a62a9597d10cf12dd2d8cee46645c7e5a141f6e0e23aa482abe5661c16e69ef1e28371e2e236c359ba4e92c25626a7b7ff13f6ea4ae906e1cfe163e91719b1f750a96cbde5fbc953d9e576cd216afc90323a +df1bd24753ebfca8796e365ab850a92e0c7fa38fcddc8e0f8dd5f5ac4910267b f1c528cf7739874707d4d8ad5b98f7c77169de0b57188df233b2dc8a5b31eda5db4291dd9f68e6bad37b8d7f6c9c0044b3bf74bbc3d7d1798e138709b0d75e7c593d3cccdc1b20c7174b4e692add820ace262d45ccfae2077e878796347168060a162ecca8c38c1a88350bd63bb539134f700fd4addd5959e255337daa06bc86358fabcbefdfb5bc889783d843c08aadc6c4f6c36f65f156e851c9a0f917e4a367b5ad93d874812a1de6a7b93cd53ad97232 +6e17ff0c1e6607dfba2686dc0221f44ed2268e1be7dadafeb1fc8c1a09723267 9d9f3a7ecd51b41f6572fd0d0881e30390dfb780991dae7db3b47619134718e6f987810e542619dfaa7b505c76b7350c6432d8bf1cfebdf1069b90a35f0d04cbdf130b0dfc7875f4a4e62cdb8e525aadd7ce842520a482ac18f09442d78305fe85a74e39e760a4837482ed2f437dd13b2ec1042afcf9decdc3e877e50ff4106ad10a525230d11920324a81094da31deab6476aa42f20c84843cfc1c58545ee80352bdd3740dd6a16792ae2d86f11641bb717c2 +e5f1f68e013ff447082efbd6114d2d22b89d7485dba55b1c548d163b9f2368ea 5179888724819fbad3afa927d3577796660e6a81c52d98e9303261d5a4a83232f6f758934d50aa83ff9e20a5926dfebaac49529d006eb923c5ae5048ed544ec471ed7191edf46363383824f915769b3e688094c682b02151e5ee01e510b431c8865aff8b6b6f2f59cb6d129da79e97c6d2b8fa6c6da3f603199d2d1bcab547682a81cd6cf65f6551121391d78bcc23b5bd0e922ec6d8bf97c952e84dd28aef909aba31edb903b28fbfc33b7703cd996215a11238 +3f90894bd5220b26a884a3c97c4c00469d966793c891532df481662bfb1b91b1 576ef3520d30b7a4899b8c0d5e359e45c5189add100e43be429a02fb3de5ff4f8fd0e79d9663acca72cd29c94582b19292a557c5b1315297d168fbb54e9e2ecd13809c2b5fce998edc6570545e1499dbe7fb74d47cd7f35823b212b05bf3f5a79caa34224fdd670d335fcb106f5d92c3946f44d3afcbae2e41ac554d8e6759f332b76be89a0324aa12c5482d1ea3ee89ded4936f3e3c080436f539fa137e74c6d3389bdf5a45074c47bc7b20b0948407a66d855e2f +6c7a614a0ec46d716b3312fc978673a7f5c059886f29b2a337b568723c684678 0df2152fa4f4357c8741529dd77e783925d3d76e95bafa2b542a2c33f3d1d117d159cf473f82310356fee4c90a9e505e70f8f24859656368ba09381fa245eb6c3d763f3093f0c89b972e66b53d59406d9f01aea07f8b3b615cac4ee4d05f542e7d0dab45d67ccccd3a606ccbeb31ea1fa7005ba07176e60dab7d78f6810ef086f42f08e595f0ec217372b98970cc6321576d92ce38f7c397a403bada1548d205c343ac09deca86325373c3b76d9f32028fea8eb32515 +7a2157721266c71dda18fbc6479bcbf68c40f9c3569d120d75431edbc5e5bf1e 3e15350d87d6ebb5c8ad99d42515cfe17980933c7a8f6b8bbbf0a63728cefaad2052623c0bd5931839112a48633fb3c2004e0749c87a41b26a8b48945539d1ff41a4b269462fd199bfecd45374756f55a9116e92093ac99451aefb2af9fd32d6d7f5fbc7f7a540d5097c096ebc3b3a721541de073a1cc02f7fb0fb1b9327fb0b1218ca49c9487ab5396622a13ae546c97abdef6b56380dda7012a8384091b6656d0ab272d363cea78163ff765cdd13ab1738b940d16cae +2913963a2d566fd69c111ee76940959dde89981b11e29583025a6a1fcf8f2db9 c38d6b0b757cb552be40940ece0009ef3b0b59307c1451686f1a22702922800d58bce7a636c1727ee547c01b214779e898fc0e560f8ae7f61bef4d75eaa696b921fd6b735d171535e9edd267c192b99880c87997711002009095d8a7a437e258104a41a505e5ef71e5613ddd2008195f0c574e6ba3fe40099cfa116e5f1a2fa8a6da04badcb4e2d5d0de31fdc4800891c45781a0aac7c907b56d631fca5ce8b2cde620d11d1777ed9fa603541de794ddc5758fcd5fad78c0 +54b5a217128ee6917d00a31f7c9dce7728c3f36b26e5dd137a1539a0354e07c4 8d2de3f0b37a6385c90739805b170057f091cd0c7a0bc951540f26a5a75b3e694631bb64c7635eed316f51318e9d8de13c70a2aba04a14836855f35e480528b776d0a1e8a23b547c8b8d6a0d09b241d3be9377160cca4e6793d00a515dc2992cb7fc741daca171431da99cce6f7789f129e2ac5cf65b40d703035cd2185bb936c82002daf8cbc27a7a9e554b06196630446a6f0a14ba155ed26d95bd627b7205c072d02b60db0fd7e49ea058c2e0ba202daff0de91e845cf79 +5ef2734128a08dd44b2a3c82626f01d65baa6356adeca5072c598c3f1e5f0e5b c464bbdad275c50dcd983b65ad1019b9ff85a1e71c807f3204bb2c921dc31fbcd8c5fc45868ae9ef85b6c9b83bba2a5a822201ed68586ec5ec27fb2857a5d1a2d09d09115f22dcc39fe61f5e1ba0ff6e8b4acb4c6da748be7f3f0839739394ff7fa8e39f7f7e84a33c3866875c01bcb1263c9405d91908e9e0b50e7459fabb63d8c6bbb73d8e3483c099b55bc30ff092ff68b6adedfd477d63570c9f5515847f36e24ba0b705557130cec57ebad1d0b31a378e91894ee26e3a04 +8e59525a79d022c12ff116b1b07bbcb9953225e0222f4cebce8d26fcb2e157f1 8b8d68bb8a75732fe272815a68a1c9c5aa31b41dedc8493e76525d1d013d33cebd9e21a5bb95db2616976a8c07fcf411f5f6bc6f7e0b57aca78cc2790a6f9b898858ac9c79b165ff24e66677531e39f572be5d81eb3264524181115f32780257bfb9aeec6af12af28e587cac068a1a2953b59ad680f4c245b2e3ec36f59940d37e1d3db38e13edb29b5c0f404f6ff87f80fc8be7a225ff22fbb9c8b6b1d7330c57840d24bc75b06b80d30dad6806544d510af6c4785e823ac3e0b8 +9ea851da02d9504bdf3188c8ac120b16238f2a9696c538b5bc5f3f1db44349e4 6b018710446f368e7421f1bc0ccf562d9c1843846bc8d98d1c9bf7d9d6fcb48bfc3bf83b36d44c4fa93430af75cd190bde36a7f92f867f58a803900df8018150384d85d82132f123006ac2aeba58e02a037fe6afbd65eca7c44977dd3dc74f48b6e7a1bfd5cc4dcf24e4d52e92bd4455848e4928b0eac8b7476fe3cc03e862aa4dff4470dbfed6de48e410f25096487ecfc32a27277f3f5023b2725ade461b1355889554a8836c9cf53bd767f5737d55184eea1ab3f53edd0976c485 +50a545f704b0c1f74faf7ff89d303f09f1680e6a99f49a2bced38e5193e43075 c9534a24714bd4be37c88a3da1082eda7cabd154c309d7bd670dccd95aa535594463058a29f79031d6ecaa9f675d1211e9359be82669a79c855ea8d89dd38c2c761ddd0ec0ce9e97597432e9a1beae062cdd71edfdfd464119be9e69d18a7a7fd7ce0e2106f0c8b0abf4715e2ca48ef9f454dc203c96656653b727083513f8efb86e49c513bb758b3b052fe21f1c05bb33c37129d6cc81f1aef6adc45b0e8827a830fe545cf57d0955802c117d23ccb55ea28f95c0d8c2f9c5a242b33f +8d16f41e5743253f7c10bbc14d0d613eb877d1177d171101b9f50a9644461bdf 07906c87297b867abf4576e9f3cc7f82f22b154afcbf293b9319f1b0584da6a40c27b32e0b1b7f412c4f1b82480e70a9235b12ec27090a5a33175a2bb28d8adc475cefe33f7803f8ce27967217381f02e67a3b4f84a71f1c5228e0c2ad971373f6f672624fcea8d1a9f85170fad30fa0bbd25035c3b41a6175d467998bd1215f6f3866f53847f9cf68ef3e2fbb54bc994de2302b829c5eea68ec441fcbafd7d16ae4fe9fff98bf00e5bc2ad54dd91ff9fda4dd77b6c754a91955d1fbaad0 +62c77748f32c754f6ea7fd03048efbc7da1c0fa54efb81267bab209a40ddba61 588e94b9054abc2189df69b8ba34341b77cdd528e7860e5defcaa79b0c9a452ad4b82aa306be84536eb7cedcbe058d7b84a6aef826b028b8a0271b69ac3605a9635ea9f5ea0aa700f3eb7835bc54611b922964300c953efe7491e3677c2cebe0822e956cd16433b02c68c4a23252c3f9e151a416b4963257b783e038f6b4d5c9f110f871652c7a649a7bcedcbccc6f2d0725bb903cc196ba76c76aa9f10a190b1d1168993baa9ffc96a1655216773458bec72b0e39c9f2c121378feab4e76a +d9aa50386743fb6bebe243fde6138e6ff396a73fbcce4957352ae35b84f747b1 08959a7e4baae874928813364071194e2939772f20db7c3157078987c557c2a6d5abe68d520eef3dc491692e1e21bcd880adebf63bb4213b50897fa005256ed41b5690f78f52855c8d9168a4b666fce2da2b456d7a7e7c17ab5f2fb1ee90b79e698712e963715983fd07641ae4b4e9dc73203fac1ae11fa1f8c7941fcc82eab247addb56e2638447e9d609e610b60ce086656aaebf1da3c8a231d7d94e2fd0afe46b391ff14a72eaeb3f44ad4df85866def43d4781a0b3578bc996c87970b132 +53ec2601c69a2c1cf111e912513d2932f7f052844d1cb2c1cff5ed0b1da1863a cb2a234f45e2ecd5863895a451d389a369aab99cfef0d5c9ffca1e6e63f763b5c14fb9b478313c8e8c0efeb3ac9500cf5fd93791b789e67eac12fd038e2547cc8e0fc9db591f33a1e4907c64a922dda23ec9827310b306098554a4a78f050262db5b545b159e1ff1dca6eb734b872343b842c57eafcfda8405eedbb48ef32e99696d135979235c3a05364e371c2d76f1902f1d83146df9495c0a6c57d7bf9ee77e80f9787aee27be1fe126cdc9ef893a4a7dcbbc367e40fe4e1ee90b42ea25af01 +b696977f4ae6f455d3591f19c03a8858876364910cd71b90ef2c289aaa0c6d9e d16beadf02ab1d4dc6f88b8c4554c51e866df830b89c06e786a5f8757e8909310af51c840efe8d20b35331f4355d80f73295974653ddd620cdde4730fb6c8d0d2dcb2b45d92d4fbdb567c0a3e86bd1a8a795af26fbf29fc6c65941cddb090ff7cd230ac5268ab4606fccba9eded0a2b5d014ee0c34f0b2881ac036e24e151be89eeb6cd9a7a790afccff234d7cb11b99ebf58cd0c589f20bdac4f9f0e28f75e3e04e5b3debce607a496d848d67fa7b49132c71b878fd5557e082a18eca1fbda94d4b +0556cb43f90d4fbe966ea60ea66e89ef46679b529e75d758ffd2ccb37a0dfe10 8f65f6bc59a85705016e2bae7fe57980de3127e5ab275f573d334f73f8603106ec3553016608ef2dd6e69b24be0b7113bf6a760ba6e9ce1c48f9e186012cf96a1d4849d75df5bb8315387fd78e9e153e76f8ba7ec6c8849810f59fb4bb9b004318210b37f1299526866f44059e017e22e96cbe418699d014c6ea01c9f0038b10299884dbec3199bb05adc94e955a1533219c1115fed0e5f21228b071f40dd57c4240d98d37b73e412fe0fa4703120d7c0c67972ed233e5deb300a22605472fa3a3ba86 +f49a241f411f0b5c935a5e2a2e0329bbd0b10900d587b8d6d8cb12bbaae5ec8f 84891e52e0d451813210c3fd635b39a03a6b7a7317b221a7abc270dfa946c42669aacbbbdf801e1584f330e28c729847ea14152bd637b3d0f2b38b4bd5bf9c791c58806281103a3eabbaede5e711e539e6a8b2cf297cf351c078b4fa8f7f35cf61bebf8814bf248a01d41e86c5715ea40c63f7375379a7eb1d78f27622fb468ab784aaaba4e534a6dfd1df6fa15511341e725ed2e87f98737ccb7b6a6dfae416477472b046bf1811187d151bfa9f7b2bf9acdb23a3be507cdf14cfdf517d2cb5fb9e4ab6 +715ef966d442d432c81f2c8fd7d3c2da61c6b2ad3d6508addefb5b7c54e40bb6 fdd7a9433a3b4afabd7a3a5e3457e56debf78e84b7a0b0ca0e8c6d53bd0c2dae31b2700c6128334f43981be3b213b1d7a118d59c7e6b6493a86f866a1635c12859cfb9ad17460a77b4522a5c1883c3d6acc86e6162667ec414e9a104aa892053a2b1d72165a855bacd8faf8034a5dd9b716f47a0818c09bb6baf22aa503c06b4ca261f557761989d2afbd88b6a678ad128af68672107d0f1fc73c5ca740459297b3292b281e93bceb761bde7221c3a55708e5ec84472cddcaa84ecf23723cc0991355c6280 +a141a61a0eaa1e0e8b90e341e89071ea81eb1e1c7ae00e855a7b06ff11e241b2 70a40bfbef92277a1aad72f6b79d0177197c4ebd432668cfec05d099accb651062b5dff156c0b27336687a94b26679cfdd9daf7ad204338dd9c4d14114033a5c225bd11f217b5f4732da167ee3f939262d4043fc9cba92303b7b5e96aea12adda64859df4b86e9ee0b58e39091e6b188b408ac94e1294a8911245ee361e60e601eff58d1d37639f3753bec80ebb4efde25817436076623fc65415fe51d1b0280366d12c554d86743f3c3b6572e400361a60726131441ba493a83fbe9afda90f7af1ae717238d +f06fbde44b4f52744420919723466e5c6c8074285d362bbe399d771af677bf6b 74356e449f4bf8644f77b14f4d67cb6bd9c1f5ae357621d5b8147e562b65c66585caf2e491b48529a01a34d226d436959153815380d5689e30b35357cdac6e08d3f2b0e88e200600d62bd9f5eaf488df86a4470ea227006182e44809009868c4c280c43d7d64a5268fa719074960087b3a6abc837882f882c837834535929389a12b2c78187e2ea07ef8b8eef27dc85002c3ae35f1a50bee6a1c48ba7e175f3316670b27983472aa6a61eed0a683a39ee323080620ea44a9f74411ae5ce99030528f9ab49c79f2 +64c6a5553aa262ec66fcf70d303d4b88168d2a93acbd0483e1519a3300ce7695 8c3798e51bc68482d7337d3abb75dc9ffe860714a9ad73551e120059860dde24ab87327222b64cf774415a70f724cdf270de3fe47dda07b61c9ef2a3551f45a5584860248fabde676e1cd75f6355aa3eaeabe3b51dc813d9fb2eaa4f0f1d9f834d7cad9c7c695ae84b329385bc0bef895b9f1edf44a03d4b410cc23a79a6b62e4f346a5e8dd851c2857995ddbf5b2d717aeb847310e1f6a46ac3d26a7f9b44985af656d2b7c9406e8a9e8f47dcb4ef6b83caacf9aefb6118bfcff7e44bef6937ebddc89186839b77 +efc9fcf021f4169d1987cb3547b8aeceb84e5ca883af9be8f75fac09d1e3119c fa56bf730c4f8395875189c10c4fb251605757a8fecc31f9737e3c2503b02608e6731e85d7a38393c67de516b85304824bfb135e33bf22b3a23b913bf6acd2b7ab85198b8187b2bcd454d5e3318cacb32fd6261c31ae7f6c54ef6a7a2a4c9f3ecb81ce3555d4f0ad466dd4c108a90399d70041997c3b25345a9653f3c9a6711ab1b91d6a9d2216442da2c973cbd685ee7643bfd77327a2f7ae9cb283620a08716dfb462e5c1d65432ca9d56a90e811443cd1ecb8f0de179c9cb48ba4f6fec360c66f252f6e64edc96b +677dc162c0899c68b1eb6597991bbb2225cf33aaaa95d4e4dcdc30fb00fdd1a0 b6134f9c3e91dd8000740d009dd806240811d51ab1546a974bcb18d344642baa5cd5903af84d58ec5ba17301d5ec0f10ccd0509cbb3fd3fff9172d193af0f782252fd1338c7244d40e0e42362275b22d01c4c3389f19dd69bdf958ebe28e31a4ffe2b5f18a87831cfb7095f58a87c9fa21db72ba269379b2dc2384b3da953c7925761fed324620acea435e52b424a7723f6a2357374157a34cd8252351c25a1b232826cefe1bd3e70ffc15a31e7c0598219d7f00436294d11891b82497bc78aa5363892a2495df8c1eef +05b095f639037aca5f3dfffee5237bf7fbc5a3ad82b63c9c291731b2bddc283d c941cdb9c28ab0a791f2e5c8e8bb52850626aa89205bec3a7e22682313d198b1fa33fc7295381354858758ae6c8ec6fac3245c6e454d16fa2f51c4166fab51df272858f2d603770c40987f64442d487af49cd5c3991ce858ea2a60dab6a65a34414965933973ac2457089e359160b7cdedc42f29e10a91921785f6b7224ee0b349393cdcff6151b50b377d609559923d0984cda6000829b916ab6896693ef6a2199b3c22f7dc5500a15b8258420e314c222bc000bc4e5413e6dd82c993f8330f5c6d1be4bc79f08a1a0a46 +7b183c917ea8ef52e2b8cdd7db353d17e6911d243b0f26c6591531694c2fe336 4499efffac4bcea52747efd1e4f20b73e48758be915c88a1ffe5299b0b005837a46b2f20a9cb3c6e64a9e3c564a27c0f1c6ad1960373036ec5bfe1a8fc6a435c2185ed0f114c50e8b3e4c7ed96b06a036819c9463e864a58d6286f785e32a804443a56af0b4df6abc57ed5c2b185ddee8489ea080deeee66aa33c2e6dab36251c402682b6824821f998c32163164298e1fafd31babbcffb594c91888c6219079d907fdb438ed89529d6d96212fd55abe20399dbefd342248507436931cdead496eb6e4a80358acc78647d043 +232c0710fd89a33ea56ed47a040a9a123239c49e2d18d95c4b45dd243ea75cd5 eecbb8fdfa4da62170fd06727f697d81f83f601ff61e478105d3cb7502f2c89bf3e8f56edd469d049807a38882a7eefbc85fc9a950952e9fa84b8afebd3ce782d4da598002827b1eb98882ea1f0a8f7aa9ce013a6e9bc462fb66c8d4a18da21401e1b93356eb12f3725b6db1684f2300a98b9a119e5d27ff704affb618e12708e77e6e5f34139a5a41131fd1d6336c272a8fc37080f041c71341bee6ab550cb4a20a6ddb6a8e0299f2b14bc730c54b8b1c1c487b494bdccfd3a53535ab2f231590bf2c4062fd2ad58f906a2d0d +cf0c82eb67841863764bd08676c36fa627977f86c2c18869d4e616b93c44a944 e64f3e4ace5c8418d65fec2bc5d2a303dd458034736e3b0df719098be7a206deaf52d6ba82316caf330ef852375188cde2b39cc94aa449578a7e2a8e3f5a9d68e816b8d16889fbc0ebf0939d04f63033ae9ae2bdab73b88c26d6bd25ee460ee1ef58fb0afa92cc539f8c76d3d097e7a6a63ebb9b5887edf3cf076028c5bbd5b9db3211371ad3fe121d4e9bf44229f4e1ecf5a0f9f0eba4d5ceb72878ab22c3f0eb5a625323ac66f7061f4a81fac834471e0c59553f108475fe290d43e6a055ae3ee46fb67422f814a68c4be3e8c9 +6d162e87fa8f3309e8c2059c4a2f5738a3854c45dd52b2a6b457428382e89b20 d2cb2d733033f9e91395312808383cc4f0ca974e87ec68400d52e96b3fa6984ac58d9ad0938dde5a973008d818c49607d9de2284e7618f1b8aed8372fbd52ed54557af4220fac09dfa8443011699b97d743f8f2b1aef3537ebb45dcc9e13dfb438428ee190a4efdb3caeb7f3933117bf63abdc7e57beb4171c7e1ad260ab0587806c4d137b6316b50abc9cce0dff3acada47bbb86be777e617bbe578ff4519844db360e0a96c6701290e76bb95d26f0f804c8a4f2717eac4e7de9f2cff3bbc55a17e776c0d02856032a6cd10ad2838 +1e723ca54587378c12d24f1052c450f1e68daba7dfe4f313b240062aee65b32c f2998955613dd414cc111df5ce30a995bb792e260b0e37a5b1d942fe90171a4ac2f66d4928d7ad377f4d0554cbf4c523d21f6e5f379d6f4b028cdcb9b1758d3b39663242ff3cb6ede6a36a6f05db3bc41e0d861b384b6dec58bb096d0a422fd542df175e1be1571fb52ae66f2d86a2f6824a8cfaacbac4a7492ad0433eeb15454af8f312b3b2a577750e3efbd370e8a8cac1582581971fba3ba4bd0d76e718dacf8433d33a59d287f8cc92234e7a271041b526e389efb0e40b6a18b3aaf658e82ed1c78631fd23b4c3eb27c3faec8685 +94ff0c7b716a99015ac8860fafa11afe3fdc10b68fe3a1e9f93191f3ea1d6391 447797e2899b72a356ba55bf4df3acca6cdb1041eb477bd1834a9f9acbc340a294d729f2f97df3a610be0ff15edb9c6d5db41644b9874360140fc64f52aa03f0286c8a640670067a84e017926a70438db1bb361defee7317021425f8821def26d1efd77fc853b818545d055adc9284796e583c76e6fe74c9ac2587aa46aa8f8804f2feb5836cc4b3ababab8429a5783e17d5999f32242eb59ef30cd7adabc16d72dbdb097623047c98989f88d14eaf02a7212be16ec2d07981aaa99949ddf89ecd90333a77bc4e1988a82abf7c7caf3291 +a099f2676ca0f477d2c6fc75ac572b874ea4f5aae1816f9401d6059c9c5187d9 9f2c18ade9b380c784e170fb763e9aa205f64303067eb1bcea93df5dac4bf5a2e00b78195f808df24fc76e26cb7be31dc35f0844cded1567bba29858cffc97fb29010331b01d6a3fb3159cc1b973d255da9843e34a0a4061cabdb9ed37f241bfabb3c20d32743f4026b59a4ccc385a2301f83c0b0a190b0f2d01acb8f0d41111e10f2f4e149379275599a52dc089b35fdd5234b0cfb7b6d8aebd563ca1fa653c5c021dfd6f5920e6f18bfafdbecbf0ab00281333ed50b9a999549c1c8f8c63d7626c48322e9791d5ff72294049bde91e73f8 +4d3fe295ff8b5892f661e4a16c4f92aec4412d6c77e4eafa5f4b5c14ff11c244 ae159f3fa33619002ae6bcce8cbbdd7d28e5ed9d61534595c4c9f43c402a9bb31f3b301cbfd4a43ce4c24cd5c9849cc6259eca90e2a79e01ffbac07ba0e147fa42676a1d668570e0396387b5bcd599e8e66aaed1b8a191c5a47547f61373021fa6deadcb55363d233c24440f2c73dbb519f7c9fa5a8962efd5f6252c0407f190dfefad707f3c7007d69ff36b8489a5b6b7c557e79dd4f50c06511f599f56c896b35c917b63ba35c6ff8092baf7d1658e77fc95d8a6a43eeb4c01f33f03877f92774be89c1114dd531c011e53a34dc248a2f0e6 +7e30f2698ad3314558fe42c0f3066eefb3c74f71625e861548bd674207a03fcd 3b8e97c5ffc2d6a40fa7de7fcefc90f3b12c940e7ab415321e29ee692dfac799b009c99dcddb708fce5a178c5c35ee2b8617143edc4c40b4d313661f49abdd93cea79d117518805496fe6acf292c4c2a1f76b403a97d7c399daf85b46ad84e16246c67d6836757bde336c290d5d401e6c1386ab32797af6bb251e9b2d8fe754c47482b72e0b394eab76916126fd68ea7d65eb93d59f5b4c5ac40f7c3b37e7f3694f29424c24af8c8f0ef59cd9dbf1d28e0e10f799a6f78cad1d45b9db3d7dee4a7059abe99182714983b9c9d44d7f5643596d4f3 +4bb1100737f443a976a7cf5adec1d7b9b0729f9ef8d642e6b4679f32a0ed1e66 3434ec31b10fafdbfeec0dd6bd94e80f7ba9dca19ef075f7eb017512af66d6a4bcf7d16ba0819a1892a6372f9b35bcc7ca8155ee19e8428bc22d214856ed5fa9374c3c09bde169602cc219679f65a1566fc7316f4cc3b631a18fb4449fa6afa16a3db2bc4212eff539c67cf184680826535589c7111d73bffce431b4c40492e763d9279560aaa38eb2dc14a212d723f994a1fe656ff4dd14551ce4e7c621b2aa5604a10001b2878a897a28a08095c325e10a26d2fb1a75bfd64c250309bb55a44f23bbac0d5516a1c687d3b41ef2fbbf9cc56d4739 +7242e5f34cb68b5b05cf5b0bbc4300a1166224db05038ccb2857c1b15117db91 7c7953d81c8d208fd1c97681d48f49dd003456de60475b84070ef4847c333b74575b1fc8d2a186964485a3b8634feaa3595aaa1a2f4595a7d6b6153563dee31bbac443c8a33eed6d5d956a980a68366c2527b550ee950250dfb691eacbd5d56ae14b970668be174c89df2fea43ae52f13142639c884fd62a3683c0c3792f0f24ab1318bcb27e21f4737fab62c77ea38bc8fd1cf41f7dab64c13febe7152bf5bb7ab5a78f5346d43cc741cb6f72b7b8980f268b68bf62abdfb1577a52438fe14b591498cc95f071228460c7c5d5ceb4a7bde588e7f21c +1227a353daa9e63009e688a4eb9ff4e033871504d970d42044e88b21493e2ea4 7a6a4f4fdc59a1d223381ae5af498d74b7252ecf59e389e49130c7eaee626e7bd9897effd92017f4ccde66b0440462cdedfd352d8153e6a4c8d7a0812f701cc737b5178c2556f07111200eb627dbc299caa792dfa58f35935299fa3a3519e9b03166dffa159103ffa35e8577f7c0a86c6b46fe13db8e2cdd9dcfba85bdddcce0a7a8e155f81f712d8e9fe646153d3d22c811bd39f830433b2213dd46301941b59293fd0a33e2b63adbd95239bc01315c46fdb678875b3c81e053a40f581cfbec24a1404b1671a1b88a6d06120229518fb13a74ca0ac5ae +c5ccb560ec7884b39b59f885b7d86e338da3dc75b5aa683e7fd20f56aed61606 d9faa14cebe9b7de551b6c0765409a33938562013b5e8e0e1e0a6418df7399d0a6a771fb81c3ca9bd3bb8e2951b0bc792525a294ebd1083688806fe5e7f1e17fd4e3a41d00c89e8fcf4a363caedb1acb558e3d562f1302b3d83bb886ed27b76033798131dab05b4217381eaaa7ba15ec820bb5c13b516dd640eaec5a27d05fdfca0f35b3a5312146806b4c0275bcd0aaa3b2017f346975db566f9b4d137f4ee10644c2a2da66deeca5342e236495c3c6280528bfd32e90af4cd9bb908f34012b52b4bc56d48cc8a6b59bab014988eabd12e1a0a1c2e170e7 +9b90c3d27825bf560c27df99cb12ad863f1be6f882ebeaf7aff939eb882aca8d 2d8427433d0c61f2d96cfe80cf1e932265a191365c3b61aaa3d6dcc039f6ba2ad52a6a8cc30fc10f705e6b7705105977fa496c1c708a277a124304f1fc40911e7441d1b5e77b951aad7b01fd5db1b377d165b05bbf898042e39660caf8b279fe5229d1a8db86c0999ed65e53d01ccbc4b43173ccf992b3a14586f6ba42f5fe30afa8ae40c5df29966f9346da5f8b35f16a1de3ab6de0f477d8d8660918060e88b9b9e9ca6a4207033b87a812dbf5544d39e4882010f82b6ce005f8e8ff6fe3c3806bc2b73c2b83afb704345629304f9f86358712e9fae3ca3e +7fbf2df42eb8d7581947be07846cf29e4ddf25569bd8f08b6614103cd9b061fb 5e19d97887fcaac0387e22c6f803c34a3dacd2604172433f7a8a7a526ca4a2a1271ecfc5d5d7be5ac0d85d921095350dfc65997d443c21c8094e0a3fefd2961bcb94aed03291ae310ccda75d8ace4bc7d89e7d3e5d1650bda5d668b8b50bfc8e608e184f4d3a9a2badc4ff5f07e0c0bc8a9f2e0b2a26fd6d8c550008faaab75fd71af2a424bec9a7cd9d83fad4c8e9319115656a8717d3b523a68ff8004258b9990ed362308461804ba3e3a7e92d8f2ffae5c2fba55ba5a3c27c0a2f71bd711d2fe1799c2adb31b200035481e9ee5c4adf2ab9c0fa50b23975cf +1a7f9c922c7c6dcd53f388599a8127c230e76f59c4909ab231cad7007e7e397b c8e976ab4638909387ce3b8d4e510c3230e5690e02c45093b1d297910abc481e56eea0f296f98379dfc9080af69e73b2399d1c143bee80ae1328162ce1ba7f6a8374679b20aacd380eb4e61382c99998704d62701afa914f9a2705cdb065885f50d086c3eb5753700c387118bb142f3e6da1e988dfb31ac75d7368931e45d1391a274b22f83ceb072f9bcabc0b216685bfd789f5023971024b1878a205442522f9ea7d8797a4102a3df41703768251fd5e017c85d1200a464118aa35654e7ca39f3c375b8ef8cbe7534dbc64bc20befb417cf60ec92f63d9ee7397 +305b5392ca56a87c35a8b854ba54c131c60ba7581709c772051c718f04fe3977 7145fa124b7429a1fc2231237a949ba7201bcc1822d3272de005b682398196c25f7e5cc2f289fbf44415f699cb7fe6757791b1443410234ae061edf623359e2b4e32c19bf88450432dd01caa5eb16a1dc378f391ca5e3c4e5f356728bddd4975db7c890da8bbc84cc73ff244394d0d48954978765e4a00b593f70f2ca082673a261ed88dbcef1127728d8cd89bc2c597e9102ced6010f65fa75a14ebe467fa57ce3bd4948b6867d74a9df5c0ec6f530cbf2ee61ce6f06bc8f2864dff5583776b31df8c7ffcb61428a56bf7bd37188b4a5123bbf338393af46eda85e6 +7d584ec4f3ced7a3475e05f425e4fa083abf27f55ed6f1b43fa7350a59d29a18 7fdfadcc9d29bad23ae038c6c65cda1aef757221b8872ed3d75ff8df7da0627d266e224e812c39f7983e4558bfd0a1f2bef3feb56ba09120ef762917b9c093867948547aee98600d10d87b20106878a8d22c64378bf634f7f75900c03986b077b0bf8b740a82447b61b99fee5376c5eb6680ec9e3088f0bdd0c56883413d60c1357d3c811950e5890e7600103c916341b80c743c6a852b7b4fb60c3ba21f3bc15b8382437a68454779cf3cd7f9f90ccc8ef28d0b706535b1e4108eb5627bb45d719cb046839aee311ca1abdc8319e050d67972cb35a6b1601b25dbf487 +dfe9ca6f209b9cde125a04b091089007f1e4f27da105e036b2c9d4fbb899e254 988638219fd3095421f826f56e4f09e356296b628c3ce6930c9f2e758fd1a80c8273f2f61e4daae65c4f110d3e7ca0965ac7d24e34c0dc4ba2d6ff0bf5bbe93b3585f354d7543cb542a1aa54674d375077f2d360a8f4d42f3db131c3b7ab7306267ba107659864a90c8c909460a73621d1f5d9d3fd95beb19b23db1cb6c0d0fba91d36891529b8bd8263caa1bab56a4affaed44962df096d8d5b1eb845ef31188b3e10f1af811a13f156beb7a288aae593ebd1471b624aa1a7c6adf01e2200b3d72d88a3aed3100c88231e41efc376906f0b580dc895f080fda5741db1cb +3b96f8be7486a98f987f519220dca9b29837c4e7bf0174d46ae63fc66e80ab12 5aab62756d307a669d146aba988d9074c5a159b3de85151a819b117ca1ff6597f6156e80fdd28c9c3176835164d37da7da11d94e09add770b68a6e081cd22ca0c004bfe7cd283bf43a588da91f509b27a6584c474a4a2f3ee0f1f56447379240a5ab1fb77fdca49b305f07ba86b62756fb9efb4fc225c86845f026ea542076b91a0bc2cdd136e122c659be259d98e5841df4c2f60330d4d8cdee7bf1a0a244524eecc68ff2aef5bf0069c9e87a11c6e519de1a4062a10c83837388f7ef58598a3846f49d499682b683c4a062b421594fafbc1383c943ba83bdef515efcf10d +77968b98b4ea3bebdadc06a2f6712f19db3b409f03dec29b12bbe852cfc21b72 47b8216aa0fbb5d67966f2e82c17c07aa2d6327e96fcd83e3de7333689f3ee79994a1bf45082c4d725ed8d41205cb5bcdf5c341f77facb1da46a5b9b2cbc49eadf786bcd881f371a95fa17df73f606519aea0ff79d5a11427b98ee7f13a5c00637e2854134691059839121fea9abe2cd1bcbbbf27c74caf3678e05bfb1c949897ea01f56ffa4dafbe8644611685c617a3206c7a7036e4ac816799f693dafe7f19f303ce4eba09d21e03610201bfc665b72400a547a1e00fa9b7ad8d84f84b34aef118515e74def11b9188bd1e1f97d9a12c30132ec2806339bdadacda2fd8b78 +2ea7ee39e43da3296f197e2f844ce577b9e43016c44e7b2c9ea29d16572877c1 8cff1f67fe53c098896d9136389bd8881816ccab34862bb67a656e3d98896f3ce6ffd4da73975809fcdf9666760d6e561c55238b205d8049c1cedeef374d1735daa533147bfa960b2cce4a4f254176bb4d1bd1e89654432b8dbe1a135c42115b394b024856a2a83dc85d6782be4b444239567ccec4b184d4548eae3ff6a192f343292ba2e32a0f267f31cc26719eb85245d415fb897ac2da433ee91a99424c9d7f1766a44171d1651001c38fc79294accc68ceb5665d36218454d3ba169ae058a831338c17743603f81ee173bfc0927464f9bd728dee94c6aeab7aae6ee3a627e8 +55cd65def1f7ebe06b45e1413fd0f73b405911e2c4574f101fc511227a1a37bf eacd07971cff9b9939903f8c1d8cbb5d4db1b548a85d04e037514a583604e787f32992bf2111b97ac5e8a938233552731321522ab5e8583561260b7d13ebeef785b23a41fd8576a6da764a8ed6d822d4957a545d5244756c18aa80e1aad4d1f9c20d259dee1711e2cc8fd013169fb7cc4ce38b362f8e0936ae9198b7e838dcea4f7a5b9429bb3f6bbcf2dc92565e3676c1c5e6eb3dd2a0f86aa23edd3d0891f197447692794b3dfa269611ad97f72b795602b4fdb198f3fd3eb41b415064256e345e8d8c51c555dc8a21904a9b0f1ad0effab7786aac2da3b196507e9f33ca356427 +afcf1214f34c6c5d0cbde0ad7c623d95ae45623bc6a704d26815e4ab72c6b868 23ac4e9a42c6ef45c3336ce6dfc2ff7de8884cd23dc912fef0f7756c09d335c189f3ad3a23697abda851a81881a0c8ccafc980ab2c702564c2be15fe4c4b9f10dfb2248d0d0cb2e2887fd4598a1d4acda897944a2ffc580ff92719c95cf2aa42dc584674cb5a9bc5765b9d6ddf5789791d15f8dd925aa12bffafbce60827b490bb7df3dda6f2a143c8bf96abc903d83d59a791e2d62814a89b8080a28060568cf24a80ae61179fe84e0ffad00388178cb6a617d37efd54cc01970a4a41d1a8d3ddce46edbba4ab7c90ad565398d376f431189ce8c1c33e132feae6a8cd17a61c630012 +455cd72692d6aaf49445c91aafcf37aeb2c59cae89e4f1759f0f2445338198dc 0172df732282c9d488669c358e3492260cbe91c95cfbc1e3fea6c4b0ec129b45f242ace09f152fc6234e1bee8aab8cd56e8b486e1dcba9c05407c2f95da8d8f1c0af78ee2ed82a3a79ec0cb0709396ee62aadb84f8a4ee8a7ccca3c1ee84e302a09ea802204afecf04097e67d0f8e8a9d2651126c0a598a37081e42d168b0ae8a71951c524259e4e2054e535b779679bdade566fe55700858618e626b4a0faf895bcce9011504a49e05fd56127eae3d1f8917afb548ecadabda1020111fec9314c413498a360b08640549a22cb23c731ace743252a8227a0d2689d4c6001606678dfb921 +d103820d59e191217c55b462394d136ebc03921c64c4b1d1a0f1de41ffa8794e 3875b9240cf3e0a8b59c658540f26a701cf188496e2c2174788b126fd29402d6a75453ba0635284d08835f40051a2a9683dc92afb9383719191231170379ba6f4adc816fecbb0f9c446b785bf520796841e58878b73c58d3ebb097ce4761fdeabe15de2f319dfbaf1742cdeb389559c788131a6793e193856661376c81ce9568da19aa6925b47ffd77a43c7a0e758c37d69254909ff0fbd415ef8eb937bcd49f91468b49974c07dc819abd67395db0e05874ff83dddab895344abd0e7111b2df9e58d76d85ad98106b36295826be04d435615595605e4b4bb824b33c4afeb5e7bb0d19f909 +4929ddfccc34098e17e429c7500b97ae7e5079250582933fb06eaa43a88ac4bd 747cc1a59fefba94a9c75ba866c30dc5c1cb0c0f8e9361d98484956dd5d1a40f6184afbe3dac9f76028d1caeccfbf69199c6ce2b4c092a3f4d2a56fe5a33a00757f4d7dee5dfb0524311a97ae0668a47971b95766e2f6dd48c3f57841f91f04a00ad5ea70f2d479a2620dc5cd78eaab3a3b011719b7e78d19ddf70d9423798af77517ebc55392fcd01fc600d8d466b9e7a7a85bf33f9cc5419e9bd874ddfd60981150ddaf8d7febaa4374f0872a5628d318000311e2f5655365ad4d407c20e5c04df17a222e7deec79c5ab1116d8572f91cd06e1ccc7ced53736fc867fd49ecebe6bf8082e8a +cc01303976ec27965931fad03aa106a58d194d6b689c35c6e3948194d1c50042 57af971fccaec97435dc2ec9ef0429bcedc6b647729ea168858a6e49ac1071e706f4a5a645ca14e8c7746d65511620682c906c8b86ec901f3dded4167b3f00b06cbfac6aee3728051b3e5ff10b4f9ed8bd0b8da94303c833755b3ca3aeddf0b54bc8d6632138b5d25bab03d17b3458a9d782108006f5bb7de75b5c0ba854b423d8bb801e701e99dc4feaad59bc1c7112453b04d33ea3635639fb802c73c2b71d58a56bbd671b18fe34ed2e3dca38827d63fdb1d4fb3285405004b2b3e26081a8ff08cd6d2b08f8e7b7e90a2ab1ed7a41b1d0128522c2f8bff56a7fe67969422ce839a9d4608f03 +4d2654db2ae011e32f6a9cafa9c7b81e9f88d245aec12434e2ee5f7d2984a44f 04e16dedc1227902baaf332d3d08923601bdd64f573faa1bb7201918cfe16b1e10151dae875da0c0d63c59c3dd050c4c6a874011b018421afc4623ab0381831b2da2a8ba42c96e4f70864ac44e106f94311051e74c77c1291bf5db9539e69567bf6a11cf6932bbbad33f8946bf5814c066d851633d1a513510039b349939bfd42b858c21827c8ff05f1d09b1b0765dc78a135b5ca4dfba0801bcaddfa175623c8b647eacfb4444b85a44f73890607d06d507a4f8393658788669f6ef4deb58d08c50ca0756d5e2f49d1a7ad73e0f0b3d3b5f090acf622b1878c59133e4a848e05153592ea81c6fbf +257d1ad7ac7bf8e058152148068354759902ecf49c7e44d82d18208de567e72d 7c815c384eee0f288ece27cced52a01603127b079c007378bc5d1e6c5e9e6d1c735723acbbd5801ac49854b2b569d4472d33f40bbb8882956245c366dc3582d71696a97a4e19557e41e54dee482a14229005f93afd2c4a7d8614d10a97a9dfa07f7cd946fa45263063ddd29db8f9e34db60daa32684f0072ea2a9426ecebfa5239fb67f29c18cbaa2af6ed4bf4283936823ac1790164fec5457a9cba7c767ca59392d94cab7448f50eb34e9a93a80027471ce59736f099c886dea1ab4cba4d89f5fc7ae2f21ccd27f611eca4626b2d08dc22382e92c1efb2f6afdc8fdc3d2172604f5035c46b8197d3 +62c76c5d8ab54732c43d5e6c5ff0e9c18a4b7b3df698844ee36e0c474e82c258 e29d505158dbdd937d9e3d2145658ee6f5992a2fc790f4f608d9cdb44a091d5b94b88e81fac4fdf5c49442f13b911c55886469629551189eaff62488f1a479b7db11a1560e198ddccccf50159093425ff7f1cb8d1d1246d0978764087d6bac257026b090efae8cec5f22b6f21c59ace1ac7386f5b8837ca6a12b6fbf5534dd0560ef05ca78104d3b943ddb220feaec89aa5e692a00f822a2ab9a2fe60350d75e7be16ff2526dc643872502d01f42f188abed0a6e9a6f5fd0d1ce7d5755c9ffa66b0af0b20bd806f08e06156690d81ac811778ca3dac2c249b96002017fce93e507e3b953acf99964b847 +9347b5f29d13c274bc455cfdc9405ae63dec485e52edf7ea9ca5c2dcccdeb50d d85588696f576e65eca0155f395f0cfacd83f36a99111ed5768df2d116d2121e32357ba4f54ede927f189f297d3a97fad4e9a0f5b41d8d89dd7fe20156799c2b7b6bf9c957ba0d6763f5c3bc5129747bbb53652b49290cff1c87e2cdf2c4b95d8aaee09bc8fbfa6883e62d237885810491bfc101f1d8c636e3d0ede838ad05c207a3df4fad76452979eb99f29afaecedd1c63b8d36cf378454a1bb67a741c77ac6b6b3f95f4f02b64dabc15438613ea49750df42ee90101f115aa9abb9ff64324dde9dabbb01054e1bd6b4bcdc7930a44c2300d87ca78c06924d0323ad7887e46c90e8c4d100acd9eed21e +7ee50a71ac3ecfa78712eeb5fe581143913411b48d1a5c26f61ff7dea65c8ff7 3a12f8508b40c32c74492b66323375dcfe49184c78f73179f3314b79e63376b8ac683f5a51f1534bd729b02b04d002f55cbd8e8fc9b5ec1ea6bbe6a0d0e7431518e6ba45d124035f9d3dce0a8bb7bf1430a9f657e0b4ea9f20eb20c786a58181a1e20a96f1628f8728a13bdf7a4b4b32fc8aa7054cc4881ae7fa19afa65c6c3ee1b3ade3192af42054a8a911b8ec1826865d46d93f1e7c5e2b7813c92a506e53886f3d4701bb93d2a681ad109c845904bb861af8af0646b6e399b38b614051d34f6842563a0f37ec00cb3d865fc5d746c4987de2a65071100883a2a9c7a2bfe1e2dd603d9ea24dc7c5fd06be +3f40916f729ec90f9e5fbced7b4bf48b86fe491fa89eb0af5ccc8e93c8f5c6a8 1861edce46fa5ad17e1ff1deae084dec580f97d0a67885dfe834b9dfac1ae076742ce9e267512ca51f6df5a455af0c5fd6abf94acea103a3370c354485a7846fb84f3ac7c2904b5b2fbf227002ce512133bb7e1c4e50057bfd1e44db33c7cdb969a99e284b184f50a14b068a1fc5009d9b298dbe92239572a7627aac02abe8f3e3b473417f36d4d2505d16b7577f4526c9d94a270a2dfe450d06da8f6fa956879a0a55cfe99e742ea555ea477ba3e9b44ccd508c375423611af92e55345dc215779b2d5119eba49c71d49b9fe3f1569fa24e5ca3e332d042422a8b8158d3ec66a80012976f31ffdf305f0c9c5e +6e61ea5dd922efb8353d27a9f30bccee749522b512199c0f31720747bd1c0368 08d0ffde3a6e4ef65608ea672e4830c12943d7187ccff08f4941cfc13e545f3b9c7ad5eebbe2b01642b486caf855c2c73f58c1e4e3391da8e2d63d96e15fd84953ae5c231911b00ad6050cd7aafdaac9b0f663ae6aab45519d0f5391a541707d479034e73a6ad805ae3598096af078f1393301493d663dd71f83869ca27ba508b7e91e81e128c1716dc3acfe3084b2201e04cf8006617eecf1b640474a5d45cfde9f4d3ef92d6d055b909892194d8a8218db6d8203a84261d200d71473d7488f3427416b6896c137d455f231071cacbc86e0415ab88aec841d96b7b8af41e05bb461a40645bf176601f1e760de5f +3082083c6be2f1e8d61b7968065b1d93fa8c8ecae7cab5fae32c947ccfc370ff d782abb72a5be3392757be02d3e45be6e2099d6f000d042c8a543f50ed6ebc055a7f133b0dd8e9bc348536edcaae2e12ec18e8837df7a1b3c87ec46d50c241dee820fd586197552dc20beea50f445a07a38f1768a39e2b2ff05dddedf751f1def612d2e4d810daa3a0cc904516f9a43af660315385178a529e51f8aae141808c8bc5d7b60cac26bb984ac1890d0436ef780426c547e94a7b08f01acbfc4a3825eae04f520a9016f2fb8bf5165ed12736fc71e36a49a73614739eaa3ec834069b1b40f1350c2b3ab885c02c640b9f7686ed5f99527e41cfcd796fe4c256c9173186c226169ff257954ebda81c0e5f99 +f9f793ad867db3c90cdbd69c63427b8e4da58058a9db22e52e02b9fe792f617f 5fce8109a358570e40983e1184e541833bb9091e280f258cfb144387b05d190e431cb19baa67273ba0c58abe91308e1844dcd0b3678baa42f335f2fa05267a0240b3c718a5942b3b3e3bfa98a55c25a1466e8d7a603722cb2bbf03afa54cd769a99f310735ee5a05dae2c22d397bd95635f58c48a67f90e1b73aafcd3f82117f0166657838691005b18da6f341d6e90fc1cdb352b30fae45d348294e501b63252de14740f2b85ae5299ddec3172de8b6d0ba219a20a23bb5e10ff434d39db3f583305e9f5c039d98569e377b75a70ab837d1df269b8a4b566f40bb91b577455fd3c356c914fa06b9a7ce24c7317a172d +dc55e133f009884bf96d909288f747bdc2e9def0911e7aeb5215ef298c6d752f 6172f1971a6e1e4e6170afbad95d5fec99bf69b24b674bc17dd78011615e502de6f56b86b1a71d3f4348087218ac7b7d09302993be272e4a591968aef18a1262d665610d1070ee91cc8da36e1f841a69a7a682c580e836941d21d909a3afc1f0b963e1ca5ab193e124a1a53df1c587470e5881fb54dae1b0d840f0c8f9d1b04c645ba1041c7d8dbf22030a623aa15638b3d99a2c400ff76f3252079af88d2b37f35ee66c1ad7801a28d3d388ac450b97d5f0f79e4541755356b3b1a5696b023f39ab7ab5f28df4202936bc97393b93bc915cb159ea1bd7a0a414cb4b7a1ac3af68f50d79f0c9c7314e750f7d02faa58bfa +b00f62df7c9f780a65d32608ca690812920a654717b045728a4460ccd43fc22e 5668ecd99dfbe215c4118398ac9c9eaf1a1433fab4ccdd3968064752b625ea944731f75d48a27d047d67547f14dd0ffaa55fa5e29f7af0d161d85eafc4f2029b717c918eab9d304543290bdba7158b68020c0ba4e079bc95b5bc0fc044a992b94b4ccd3bd66d0eabb5dbbab904d62e00752c4e3b0091d773bcf4c14b4377da3efff824b1cb2fa01b32d1e46c909e626ed2dae920f4c7dbeb635bc754facbd8d49beba3f23c1c41ccbfcd0ee0c114e69737f5597c0bf1d859f0c767e18002ae8e39c26261ffde2920d3d0baf0e906138696cfe5b7e32b600f45df3aaa39932f3a7df95b60fa8712a2271fcaf3911ce7b511b1 +06375c05976039faebf7e5c356657f7fe6ef68f9cc1686f2ed3a973294c3d72f 03d625488354df30e3f875a68edfcf340e8366a8e1ab67f9d5c5486a96829dfac0578289082b2a62117e1cf418b43b90e0adc881fc6ae8105c888e9ecd21aea1c9ae1a4038dfd17378fed71d02ae492087d7cdcd98f746855227967cb1ab4714261ee3bead3f4db118329d3ebef4bc48a875c19ba763966da0ebea800e01b2f50b00e9dd4caca6dcb314d00184ef71ea2391d760c950710db4a70f9212ffc54861f9dc752ce18867b8ad0c48df8466ef7231e7ac567f0eb55099e622ebb86cb237520190a61c66ad34f1f4e289cb3282ae3eaac6152ed24d2c92bae5a7658252a53c49b7b02dfe54fdb2e90074b6cf310ac661 +0b9ad10eb56c23efc68c2156166e8acebcbe2d60898d3f4f7c3cced90589fc36 2edc282ffb90b97118dd03aaa03b145f363905e3cbd2d50ecd692b37bf000185c651d3e9726c690d3773ec1e48510e42b17742b0b0377e7de6b8f55e00a8a4db4740cee6db0830529dd19617501dc1e9359aa3bcf147e0a76b3ab70c4984c13e339e6806bb35e683af8527093670859f3d8a0fc7d493bcba6bb12b5f65e71e705ca5d6c948d66ed3d730b26db395b3447737c26fad089aa0ad0e306cb28bf0acf106f89af3745f0ec72d534968cca543cd2ca50c94b1456743254e358c1317c07a07bf2b0eca438a709367fafc89a57239028fc5fecfd53b8ef958ef10ee0608b7f5cb9923ad97058ec067700cc746c127a61ee3 +41ece44a7f8f9b7d2ae7df54d13016e303f0ba743bf0a479859027c6b1104a71 90b28a6aa1fe533915bcb8e81ed6cacdc10962b7ff82474f845eeb86977600cf70b07ba8e3796141ee340e3fce842a38a50afbe90301a3bdcc591f2e7d9de53e495525560b908c892439990a2ca2679c5539ffdf636777ad9c1cdef809cda9e8dcdb451abb9e9c17efa4379abd24b182bd981cafc792640a183b61694301d04c5b3eaad694a6bd4cc06ef5da8fa23b4fa2a64559c5a68397930079d250c51bcf00e2b16a6c49171433b0aadfd80231276560b80458dd77089b7a1bbcc9e7e4b9f881eacd6c92c4318348a13f4914eb27115a1cfc5d16d7fd94954c3532efaca2cab025103b2d02c6fd71da3a77f417d7932685888a +7d41277c98f3e8dc68b23876094b5cbeb617af4df29563b6fbc626e28932cac1 2969447d175490f2aa9bb055014dbef2e6854c95f8d60950bfe8c0be8de254c26b2d31b9e4de9c68c9adf49e4ee9b1c2850967f29f5d08738483b417bb96b2a56f0c8aca632b552059c59aac3f61f7b45c966b75f1d9931ff4e596406378cee91aaa726a3a84c33f37e9cdbe626b5745a0b06064a8a8d56e53aaf102d23dd9df0a3fdf7a638509a6761a33fa42fa8ddbd8e16159c93008b53765019c3f0e9f10b144ce2ac57f5d7297f9c9949e4ff68b70d339f87501ce8550b772f32c6da8ad2ce2100a895d8b08fa1eead7c376b407709703c510b50f87e73e43f8e7348f87c3832a547ef2bbe5799abedcf5e1f372ea809233f006 +783b815e713682afbc596865d7f92e391de264e9754191f819c3a750b5075c4a 721645633a44a2c78b19024eaecf58575ab23c27190833c26875dc0f0d50b46aea9c343d82ea7d5b3e50ec700545c615daeaea64726a0f05607576dcd396d812b03fb6551c641087856d050b10e6a4d5577b82a98afb89cee8594c9dc19e79feff0382fcfd127f1b803a4b9946f4ac9a4378e1e6e041b1389a53e3450cd32d9d2941b0cbabdb50da8ea2513145164c3ab6bcbd251c448d2d4b087ac57a59c2285d564f16da4ed5e607ed979592146ffb0ef3f3db308fb342df5eb5924a48256fc763141a278814c82d6d6348577545870ae3a83c7230ac02a1540fe1798f7ef09e335a865a2ae0949b21e4f748fb8a51f44750e213a8fb +058124017f3bca7db76d2085c79fb94f40d1cb301c7a8919112719b101049279 6b860d39725a14b498bb714574b4d37ca787404768f64c648b1751b353ac92bac2c3a28ea909fdf0423336401a02e63ec24325300d823b6864bb701f9d7c7a1f8ec9d0ae3584aa6dd62ea1997cd831b4babd9a4da50932d4efda745c61e4130890e156aee6113716daf95764222a91187db2effea49d5d0596102d619bd26a616bbfda8335505fbb0d90b4c180d1a2335b91538e1668f9f9642790b4e55f9cab0fe2bdd2935d001ee6419abab5457880d0dbff20ed8758f4c20fe759efb33141cf0e892587fe8187e5fbc57786b7e8b089612c936dfc03d27efbbe7c8673f1606bd51d5ff386f4a7ab68edf59f385eb1291f117bfe717399 +99e07a7569c747514c4819972b37b40128eb7dbfbed5d0c2646e9d0816734ee2 6a01830af3889a25183244decb508bd01253d5b508ab490d3124afbf42626b2e70894e9b562b288d0a2450cfacf14a0ddae5c04716e5a0082c33981f6037d23d5e045ee1ef2283fb8b6378a914c5d9441627a722c282ff452e25a7ea608d69cee4393a0725d17963d0342684f255496d8a18c2961145315130549311fc07f0312fb78e6077334f87eaa873bee8aa95698996eb21375eb2b4ef53c14401207deb4568398e5dd9a7cf97e8c9663e23334b46912f8344c19efcf8c2ba6f04325f1a27e062b62a58d0766fc6db4d2c6a1928604b0175d872d16b7908ebc041761187cc785526c2a3873feac3a642bb39f5351550af9770c328af7b +cdccd0280f84f20a2c90446cf653e8e6f930300a60bdbab5ff5b18746bd4bcb8 b3c5e74b69933c2533106c563b4ca20238f2b6e675e8681e34a389894785bdade59652d4a73d80a5c85bd454fd1e9ffdad1c3815f5038e9ef432aac5c3c4fe840cc370cf86580a6011778bbedaf511a51b56d1a2eb68394aa299e26da9ada6a2f39b9faff7fba457689b9c1a577b2a1e505fdf75c7a0a64b1df81b3a356001bf0df4e02a1fc59f651c9d585ec6224bb279c6beba2966e8882d68376081b987468e7aed1ef90ebd090ae825795cdca1b4f09a979c8dfc21a48d8a53cdbb26c4db547fc06efe2f9850edd2685a4661cb4911f165d4b63ef25b87d0a96d3dff6ab0758999aad214d07bd4f133a6734fde445fe474711b69a98f7e2b +8f9d264010f0702f35ce22f3c1db9a4cdae2dc15a69ca9c9820e6e32a1708da1 83af34279ccb5430febec07a81950d30f4b66f484826afee7456f0071a51e1bbc55570b5cc7ec6f9309c17bf5befdd7c6ba6e968cf218a2b34bd5cf927ab846e38a40bbd81759e9e33381016a755f699df35d660007b5eadf292feefb735207ebf70b5bd17834f7bfa0e16cb219ad4af524ab1ea37334aa66435e5d397fc0a065c411ebbce32c240b90476d307ce802ec82c1c49bc1bec48c0675ec2a6c6f3ed3e5b741d13437095707c565e10d8a20b8c20468ff9514fcf31b4249cd82dcee58c0a2af538b291a87e3390d737191a07484a5d3f3fb8c8f15ce056e5e5f8febe5e1fb59d6740980aa06ca8a0c20f5712b4cde5d032e92ab89f0ae1 +eccd55e2a00b3917b219e66d5fc9bd5a1a581abf105863fa8285ca0e6f09f5a0 a7ed84749ccc56bb1dfba57119d279d412b8a986886d810f067af349e8749e9ea746a60b03742636c464fc1ee233acc52c1983914692b64309edfdf29f1ab912ec3e8da074d3f1d231511f5756f0b6eead3e89a6a88fe330a10face267bffbfc3e3090c7fd9a850561f363ad75ea881e7244f80ff55802d5ef7a1a4e7b89fcfa80f16df54d1b056ee637e6964b9e0ffd15b6196bdd7db270c56b47251485348e49813b4eb9ed122a01b3ea45ad5e1a929df61d5c0f3e77e1fdc356b63883a60e9cbb9fc3e00c2f32dbd469659883f690c6772e335f617bc33f161d6f6984252ee12e62b6000ac5231e0c9bc65be223d8dfd94c5004a101af9fd6c0fb +9bc57d33d43b27461cf22dcc4ab039a216d8aebe8407acccbc1813c8ef4474c6 a6fe30dcfcda1a329e82ab50e32b5f50eb25c873c5d2305860a835aecee6264aa36a47429922c4b8b3afd00da16035830edb897831c4e7b00f2c23fc0b15fdc30d85fb70c30c431c638e1a25b51caf1d7e8b050b7f89bfb30f59f0f20fecff3d639abc4255b3868fc45dd81e47eb12ab40f2aac735df5d1dc1ad997cefc4d836b854cee9ac02900036f3867fe0d84afff37bde3308c2206c62c4743375094108877c73b87b2546fe05ea137bedfc06a2796274099a0d554da8f7d7223a48cbf31b7decaa1ebc8b145763e3673168c1b1b715c1cd99ecd3ddb238b06049885ecad9347c2436dff32c771f34a38587a44a82c5d3d137a03caa27e66c8ff6 +fc28cbfe9844b71f3b54fcf5d0f9f87541cbec18a7658645f1f67958d8981922 83167ff53704c3aa19e9fb3303539759c46dd4091a52ddae9ad86408b69335989e61414bc20ab4d01220e35241eff5c9522b079fba597674c8d716fe441e566110b6211531ceccf8fd06bc8e511d00785e57788ed9a1c5c73524f01830d2e1148c92d0edc97113e3b7b5cd3049627abdb8b39dd4d6890e0ee91993f92b03354a88f52251c546e64434d9c3d74544f23fb93e5a2d2f1fb15545b4e1367c97335b0291944c8b730ad3d4789273fa44fb98d78a36c3c3764abeeac7c569c1e43a352e5b770c3504f87090dee075a1c4c85c0c39cf421bdcc615f9eff6cb4fe6468004aece5f30e1ecc6db22ad9939bb2b0ccc96521dfbf4ae008b5b46bc006e +aa65c8ad802d0733e6ebbee59d1eeb9c02550df812226f68860b652f0a266471 3a3a819c48efde2ad914fbf00e18ab6bc4f14513ab27d0c178a188b61431e7f5623cb66b23346775d386b50e982c493adbbfc54b9a3cd383382336a1a0b2150a15358f336d03ae18f666c7573d55c4fd181c29e6ccfde63ea35f0adf5885cfc0a3d84a2b2e4dd24496db789e663170cef74798aa1bbcd4574ea0bba40489d764b2f83aadc66b148b4a0cd95246c127d5871c4f11418690a5ddf01246a0c80a43c70088b6183639dcfda4125bd113a8f49ee23ed306faac576c3fb0c1e256671d817fc2534a52f5b439f72e424de376f4c565cca82307dd9ef76da5b7c4eb7e085172e328807c02d011ffbf33785378d79dc266f6a5be6bb0e4a92eceebaeb1 +f6595b5faa8715167f429eb8013180485b0d3f09b86057245099fd1a1b6ec464 724627916c50338643e6996f07877eafd96bdf01da7e991d4155b9be1295ea7d21c9391f4c4a41c75f77e5d27389253393725f1427f57914b273ab862b9e31dabce506e558720520d33352d119f699e784f9e548ff91bc35ca147042128709820d69a8287ea3257857615eb0321270e94b84f446942765ce882b191faee7e1c87e0f0bd4e0cd8a927703524b559b769ca4ece1f6dbf313fdcf67c572ec4185c1a88e86ec11b6454b371980020f19633b6b95bd280e4fbcb0161e1a82470320cec6ecfa25ac73d09f1536f286d3f9dacafb2cd1d0ce72d64d197f5c7520b3ccb2fd74eb72664ba93853ef41eabf52f015dd591500d018dd162815cc993595b195 +f9b943e99c428493bb10ae162148d3406cb3d4719e8fb507e0b71150efce6dcc 3139840b8ad4bcd39092916fd9d01798ff5aa1e48f34702c72dfe74b12e98a114e318cdd2d47a9c320fff908a8dbc2a5b1d87267c8e983829861a567558b37b292d4575e200de9f1de45755faff9efae34964e4336c259f1e66599a7c904ec02539f1a8eab8706e0b4f48f72fec2794909ee4a7b092d6061c74481c9e21b9332dc7c6e482d7f9cc3210b38a6f88f7918c2d8c55e64a428ce2b68fd07ab572a8b0a2388664f99489f04eb54df1376271810e0e7bce396f52807710e0dea94eb49f4b367271260c3456b9818fc7a72234e6bf2205ff6a36546205015ebd7d8c2527aa430f58e0e8ac97a7b6b793cd403d517d66295f37a34d0b7d2fa7bc345ac04ca1e266480deec39f5c88641c9dc0bd1358158fdecdd96685bbbb5c1fe5ea89d2cb4a9d5d12bb8c893281ff38e87d6b4841f0650092d447e013f20ea934e18 +35aa745c00e207f40e93e4068fdb5ac85cde2ae1ab57270ed02cac1bd60e3ec6 023d91ac532601c7ca3942d62827566d9268bb4276fcaa1ae927693a6961652676dba09219a01b3d5adfa12547a946e78f3c5c62dd880b02d2eeeb4b96636529c6b01120b23efc49ccfb36b8497cd19767b53710a636683bc5e0e5c9534cfc004691e87d1bee39b86b953572927bd668620eab87836d9f3f8f28ace41150776c0bc6657178ebf297fe1f7214edd9f215ffb491b681b06ac2032d35e6fdf832a8b06056da70d77f1e9b4d26ae712d8523c86f79250718405f91b0a87c725f2d3f52088965f887d8cf87206dfde422386e58edda34dde2783b3049b86917b4628027a05d4d1f429d2b49c4b1c898dddcb82f343e145596de11a54182f39f4718ecae8f506bd9739f5cd5d5686d7fefc834514cd1b2c91c33b381b45e2e5335d7a8720a8f17afc8c2cb2bd88b14aa2dca099b00aa575d0a0ccf099cdec4870fb710d2680e60c48bfc291ff0cef2eebf9b36902e9fba8c889bf6b4b9f5ce53a19b0d9399cd19d61bd08c0c2ec25e099959848e6a550ca7137b63f43138d7b651 +ef0cbcd459dda5bc3cbdb47a2f5862ab37c8777d65a60fa5d8699fdbf51b0e2d 20ff454369a5d05b81a78f3db05819fea9b08c2384f75cb0ab6aa115dd690da3131874a1ca8f708ad1519ea952c1e249cb540d196392c79e87755424fee7c890808c562722359eea52e8a12fbbb969dd7961d2ba52037493755a5fa04f0d50a1aa26c9b44148c0d3b94d1c4a59a31aca15ae8bd44acb7833d8e91c4b86fa3135a423387b8151b4133ed23f6d7187b50ec2204ad901ad74d396e44274e0ecafaae17b3b9085e22260b35ca53b15cc52abba758af6798fbd04eceeced648f3af4fdb3ded7557a9a5cfb7382612a8a8f3f45947d1a29ce29072928ec193ca25d51071bd5e1984ecf402f306ea762f0f25282f5296d997658be3f983696ffa6d095c6369b4daf79e9a5d3136229128f8eb63c12b9e9fa78aff7a3e9e19a62022493cd136defbb5bb7ba1b938f367fd2f63eb5ca76c0b0ff21b9e36c3f07230cf3c3074e5da587040a76975d7e39f4494ace5486fcbf380ab7558c4fe89656335b82e4db8659509eab46a19613126e594042732dd4c411f41aa8cdeac71c0fb40a94e6da558c05e77b6182806f26d9afdf3da00c69419222c8186a6efad600b410e6ce2f2a797e49dc1f135319801fa6f396b06f975e2a190a023e474b618e7 +a7af08b1fda7c63dffa47c1e6f6cc8c7a0948dfba24868d01c9a882c1c5b4814 4fbdc596508d24a2a0010e140980b809fb9c6d55ec75125891dd985d37665bd80f9beb6a50207588abf3ceee8c77cd8a5ad48a9e0aa074ed388738362496d2fb2c87543bb3349ea64997ce3e7b424ea92d122f57dbb0855a803058437fe08afb0c8b5e7179b9044bbf4d81a7163b3139e30888b536b0f957eff99a7162f4ca5aa756a4a982dfadbf31ef255083c4b5c6c1b99a107d7d3afffdb89147c2cc4c9a2643f478e5e2d393aea37b4c7cb4b5e97dadcf16b6b50aae0f3b549ece47746db6ce6f67dd4406cd4e75595d5103d13f9dfa79372924d328f8dd1fcbeb5a8e2e8bf4c76de08e3fc46aa021f989c49329c7acac5a688556d7bcbcb2a5d4be69d3284e9c40ec4838ee8592120ce20a0b635ecadaa84fd5690509f54f77e35a417c584648bc9839b974e07bfab0038e90295d0b13902530a830d1c2bdd53f1f9c9faed43ca4eed0a8dd761bc7edbdda28a287c60cd42af5f9c758e5c7250231c09a582563689afc65e2b79a7a2b68200667752e9101746f03184e2399e4ed8835cb8e9ae90e296af220ae234259fe0bd0bcc60f7a4a5ff3f70c5ed4de9c8c519a10e962f673c82c5e9351786a8a3bfd570031857bd4c87f4fca31ed4d50e14f2107da02cb5058700b74ea241a8b41d78461658f1b2b90bfd84a4c2c9d6543861ab3c56451757dcfb9ba60333488dbdd02d601b41aae317ca7474eb6e6dd +790c4bbb9493eead2f13cff641496583c076e5288ac952f15fbff712d0b067ff fe06a4706468b369f7624f62d04f9fac020f05152f13e350016b2a29efff9a393940c138553356b0e2848c01b622b95ffa11ab07585f7dcbbf90e9f8ec5fa2fb7b4cee0d0a4e8d33490abd058cf3bb85f0cd9b1bd3e9823082d70b1a92aca6f2c87216b4ba09feddcaa4cf254336146cc75604fb1f286918fa2434ca36be2621049438a400bdeea6c657f0301503cd7e6e38350838f60ea7f001755da4142ce4579b39029da83f1646b7ecb9947ee89aba377099b82026960b9ee600779bf00d6eb0cd09226db6915a7aded27e6749e2cbc2c8b030ce1850ebfbe24c0658f29e9e709cd10db8a77efdefc90fdd7b9ad7a7e0334412a53d248c4c12bf2987b7accd2a8a602f184583aa560c016093b56b100154477b834664e6b85a19f8dc909b4d79816af12266c731e29a304e9bed8ef1c8030365b7deaf3d436957308117c7c5767e0cda6e342ddaf824233cbf4e699dc667357cb35c602ac6bddee71b352af55cb93941a1a6301a9904447af9ee486114d57ae03901f10084adc0096e465e2ead2496273112f2fae626e230d42ec22ea10a8289b3e35eee42150769d6e663a3ca29174316ec93a24f148d984053b8f98664eaca3e0dea0b42e8ee30f81a2cd6e42c189a25fecb6e643e693e1f8871b837c3f5ff2aafd1650a465dc8e5c1993be65cffd87f2c680c86b0ad3118834a5f2e490015137ba945c2775dbd77fb3e5c67819a9a7a94a656fc4761659c5b30ed2ac55a6d249b700bc9c93d590490aaaaa75a9fc34a90d5a9106f2860bde19fe5815436068a7f8ea4636a +bfd9250bd939854e419fe154fa90f6be85b7b140272feabd73cfbab5f2feb7c9 d0ff6e045f4b636f75a389799f314066644854821b6e7ae4047adfde2d0c0e02c250f0be582bec94011189b964a8af430f5921ed9d9f4446e4c788515b89ca69e5f7cdfccc9e83e8f9460145b43ddc41c07cc512b7e6fdd0e1e7aaba29a6c016ccb7bd54b145f3951eab9bc4908f623e5a9b0c5b36056292540b79fd15c53457dc74a65fd773a34d6b313a056f79bc29a3fac15f6a1446bfaeeaafbac8ecf8168dde5f6ae6b6e579bd3ce74e7abfadf361d0fd32d56586a8d2d4ff4cfdf8a750fafde4c2e9eb32b06847fa30b13cc273532d1a23c8257f80c60b8fa94fa976f534145cd61c41c0a511b62cadd5848ceff643f83ce43f8e6969c5a559afad60e310599a34b2e5e029fbddf2988fce59269c7128a1fc79a74b154d8aa2850dcfdbf594684e74099e37882b440367c1dd3003f61cafb46ac75d30e677af54559a5dab70c506cf61a9c35e0e56e1430746916ddeec8d89b0c10daa02c5d7e9f42621d2b312eaffc9ff306297952a32d26c2148570aec90501ca739ce5e689e7066d9580a4fc25e2023897c74c6856273133e1275a0d275dc5b75db724cd12c9c01bb95ab5a227b7850020630506096878d289923177183ea9282a4c78ec212d2e898cb99d81a3364df20927ee34d4475a5cf5cdb24088ed75b60201922e9c972d8556ca75f8274d15f3fb88a6b42c766def6b21329dee7c457446dde8c26405fe5d0309a04229f449e8490cf9000ee8df400cb7c7ee831bd7059d24088fb42d61681cde45050fca78ff64d9c8d1f58b55f802fa5d2f2e723f3e4eed4338b060d31c8acc46d26870bd45d0de0798d48e32aad1a6d4322e69f5e72309b9d7fa1f24bb1d63ff09ed47391c232497bf222c542a70975c8292d275197a4ca +2bbb8fec8562d19f70ef7ea9a7b6cd46da4f3591007a05e88a3ce78bd339f0e4 c9a0b51f3199339c11a5753c9d9c95104b400127087177f14d3e15be881ee89bf416f97d4f7aa9636c5ef29ebbf8930804006eb26839415d3984b920882499752c36a5bbd583308e716db16f28db98b3a3e718a2ebcdfefa75d7ccbb6a746e32feaa38d034843461dbcfca7f983e19f5b23ec2e3d74d2b4402f3bdce7d7a9df1384668c746cce466b0654cdd5ca56a77d68a100ae06d63cd9af512aebae78993808ce672330e2065c0f71e05c0fe821cd5f85732315f04666f3e4e6c4f3e9f415e31fe0980d874994108e12464609c6d5c19cedfc85846b0a84ef3ccbd3b655fb0de8cb892bdf774df39c955f04f322856d470981beed0f752d82ead73b4131c5dbf0424b4ab654f72e26ef0cd292b87bd5b66fbd5e7eba96c62cffefd4b1d870bfef312b86e38ed5c0f50935e2ecf9fcb8c95d35d19a8fc8f202bd9dba768ca48fbbb071179413c0de4fde86762ed4b13e1eef2a00add5d1c2a3af7937787debaf1f6f12f3f0225ffe587a5540cb550f7bc11dd6af864d6b6d16db1488cb226ebb2199da75fdd59a71158867298f63961b40a31209f8f16629b1cce7ffb617072748fde8920d11cc0d0678389d1f719df3ed19846fe9893b04db60fa603170d9573b1bfc7da663e07254552ab6253dde814117185f84373fecd7f98ded170c884d41d1ac81814c73ea48ad94eca1b7733d8393e320c8c467ef6189b4ac324c68c8a2ecf679c893b7dbc4310cd05dadd80bb6326b51ecd99a441bff77be8d644d752f3c5c794e7d45ba76283acf8913bbf2a420f9e5d14d7a23e95fdebc69b455e466423012e9d1de9353e40d4bdc3107c3144b96c6dafd41ccefeb2b7ff848cb9fdbea8648be32160fab7e7dfccb807fb019ebf159231edcf2d487d76a3e882f3f50ca48dd08a23b06ee887bd7df9d7c6cc2bdbe348e3125c4532448f400cd57a8679abab13e582b13d49442638e2698fb7a563c7fb264157 +3a73e8c6c9b762835ef9d666fb35f2ddf6e50dfa4692e319ca47919c8febc5dd da5b2118cbd59f408ce56362489fda69ef73172f46dec16c0d4a66e3f3cca373927cb6784ce62bbcb08a490d003a8f77391e82cdd87860909383b054db95816720112e2f96de9e0ffc8babc1350ed46b9aeb5d46b66940efa311f4853f3118063c550733e7679d871729001c12270e98439e375e0cd24769d318e03cbc97d643f1dc5f1b5ef59d12789f22449bd8fa43a13ce78a4186166523f3807b0b621079cc528f4e17c258d4f9bdd095a3e365614b94f2cd778cacabf26244891531eedc24e1bf4598319eb8b7527736bb1e734429360f47f04b2e95d5aae997763a467cc5303d1141c2c01f7ab9edab860d180697c906ce1558aeff5adce603f8a4a10fc6c1699189e73b489f64cefb89ac557c5bb8826c0317eaef2302e855fbd96777898104365d96ae8a8ed8669c568c4dbeb0a70f6cf4c22fd933014473f91871c08d5a7b44a928295fb2aa56d5e2c39ca79d2837fb39b35c6810c378d749aacb543368a19c137b872229e0a6f469022aa93bcb2be38b761c85ac09415ca7deeb38ff2a2101507206fe322a89666d32750af0f4d7b2e59571f02a048b8f94fe2d231072e301c8641d1cdb4f841ab165af297495a348bccd937712e68852a4aca948c1294f8b733d06d67de89f206498dd401e149fcc1edca92deb92952ede4ebdc7cd7992104769a04de8705027a31337b88e8de93f6624e8f10b9f9924e8ce5a9d841c9260753fa1492cddffe6b4400c5719d76fb5b01b234f32ffe64f04d0a00676fbfc58dbe17b4d552fdf0c5b802c0cadf723f73f86e8ffc493992d23e8c0b84f7220a983ddda21170b1f730c736e75549af6ecb8dc94fb25c26bcddee420c83e8a45ae4c345816b7163cfe016dccfe47c66979d610a7f9b4a7b1ba5e230344c9f46ba076f2fcea68aada8fa09bf0b5cbb3850ddedd80a30e1f7a639ac69e5595c6a4083aa959831ebbeb84c018068723192f58baecddd18c857e212d4c7e7215b6c954728183fbaa07720b97189af6a7729c30d28db33a889f225d027d164f254535770c504c506aee4ec4676771f69f935ba08a1c6c85 +c427d12d1ac96e27257d5af560fce66fc814bebcd7f912b271225f60aaf925e2 d1890b4704e169c28e44ddf62a1091450404910539fc2daeb26e8acf4533b024e5215c2d02820dd8fb2cfc1743955cbacff0f8f35dfbb5e3f942f36247f68211d518f3f601aae12a1cdc000bab43d4c973f287e80741dd1fcf6c34f2e6b4b6c313d01c4ff3cbf9166f26946f18ef2d58271ba9233f09a6b77bfd4f48b36eb3d73d1133c4f842a7dc3907f680b0b773242c11e3dd973a44327ea7cea9c0f8e07d682b6651e506b587559fe01ed721000baf570a16fbdd9ea29fa3def4be912058321a8b720c5c102e48a6e7ed6f8838d400dd57d06eedbcd15323f86d855c94b21e41b14ec9e1bbc8019211fd88138c91f9abbd9bb3914d26c1ddc21673d2d51263b39d66e741d924cf2b192c5d2c1a140126a3d64a2c77be6c2c6ebe8599978ae90bd36cbb9af64d078910c4094ab3bf399c34f2ab8ef843e9fe1bf88bf443ba21e4377e5f49c07fd9653b526e14562237f02d11b904bca6ac31ae721a43e3c4910a24af6f4d80c031c109fc0fe49f15274bca92bda04c3b4196c192f6ce489c63a806acfc895ab52cad657c1783b528e12d0ed856e1f8fc91f2aafdfa0a92498d68530772ee73b359fcf1418d1096c46b34dcf90e5b468bbb2970becbd70089cfb039d64cc50fff5eef26384d34f24515a6558b06a1fdd88f1050c5bd78cc6ed83d4c2b0e882aebcf84afb0430d0bf09f2fb42b8b4589158093a7709aae75a790910e211ee1333ffb6fd80778da3bf73858978e9dd647978841b18001dbaaea43ca0c0a03dbb9bcf30ce76a6f4b2cf2a9b6531b3e4051e7e05090cd421bc66c4731e7122ad129fc42dedc83bb460e3f889992fbd3ca072686e56b72c720fbc98d723ef7f247286f77ccddc728738e941b1a74d4f16671c21fdd5643a115ddbcb88ee7ec67ea66fd2bce718df6e085d4b5fc71a72696636a8f7b3a68afa51a896771faaa7f1f827430ac5e8089dbc0d4175e1b22a057bc5f1724eadc1a41e78fa3acaa8b97e5f2e19ef9d59ae12b04e7f0e8a621e098a66910e2a5ed2102b824cd3ea044a854f1cd0b33e61e7f737414b2953549f25dd34d19aa1981de7cd5649ff6c6364a4f25312ef62395a747ab88aad722c05aec40deea8eee5e779ef458a68840bc6bd5d29ad40f98b3ae010b6213372abb7bb8b8 +1888746cb598374a1372ea1f176f85d361c4ffc536bad3f7dd944f44d1bee47a d9257004993c7ae50d20f534b42b4ec39bf358393b9fb5c8e37f87ac7361354554be596f40e67b2ed499887e26dc435c4331cde3bf1a118f60fd821477ffa3b92f6469568cd2cda6fc0a2b13906ae459cf5d5417de2ce104d0b6499d3683beb40715582ce70ded5c5f8461edeaa38bfa31979661a2dc96d926307128f77700f2c7d38b8a9d6c6f70a3973005350f938b9b4a64e228cc3b3f9c4fd446fc650aa6377152d7f46903d8ec8e9340710e28475cf21e641737e7d7da3cdf18d01c8f37131e727c7274b2db759c5586fb84ec36a5ce2d820e553de6426b8b96111295c19dba8d17a2b7047fcdf662a59c2af27a9abee37a7f8afc06944346e343e779ebd895119d7460e7da998962fb1100e950a8d7fe214360ad263b8d070f2b7dc91c9d77c6692da0f472a0a4646a1edb069ccd9ce4ca6fc24713d650153b9a253db5136a3710198e60934dd2053315d313e27dd2c6ffd2ecf028625f0e937afd8c2ffb1f646e51a768204d83a649798a51b8e87fcdda7bddf58ed943bb7e29c7d7c5dff024545f6a689aa0e727fecd80b561011a731acdd9b3f283123098ba66b6b9fce6123b35b6f3a20ef1055be9e257cde97e5af41eb796438727a62aa665cc9b771c4a2052efac61bc91bcdf573f7263107d44dfeb125e66d1f3dded3bd63845af3bf4185a9a24a7f4b777c32496a6107b7ac940af24be983f6a758e5064f8717eabbb86e6aada7da75f72abed59a42de82b1aa2642f5ef1b2e7304f642eb2aafbf00c1183d9b5fb83893edd48e9034dc7a7ab66f3f392f9666c00ecc9743ac4f777edcf47b6818a34b7392b4ab8e38891fab4018dfb99af06369115d60c4fa073240d9c2605e020a42db2e1e0ae4ade3a04b825927a05d4fe3f50c1c7add7a496da7e95825c064315196c2007524d1e1ef2c51303dd1203ab66d9fe89de553cb4b95a6c5d629b89b7116463ee10ab3cf2c2615f95741ca226f9e9a20e99303888f725c77476533b4c393763170f18f292c89a22df68eabdb81aef11cc2ac329c174bdae5d3cc0bdcea6eb225e00c15021432264ba7c5eb49a49231d1f7a13afc238bd4efc04da3c15ae0bb7d693a0150e6a5ad9b1e11a490b3ce90c027442501684c528fe260881162d9e5ef84d6e4f73f222e779e58b71d5176d9a27f65e49d83efbb2d7810e5b06619d8cef7e7b51cdfb6e8138e4cf5674242f947eac13fad08d68a8a11aac9754a5316c93738ba7f3c3bd2e827a +c5b7dc0282ea792b16b66ff98673b0f0d137b4413d60e2d7fbcedabefb6b3d12 09cf132ab943654184a3fc8d0368b421fdac4ef1081a29f3691a527fbdbd74c6372233b38dc432ba610f9c54fa68699f9ec2a6bfb0b2cf7aa6d10ae2207a7554163aa14fb6a9cfa023ce63546b7b02af03370a899ea73b27bdb5c380613c0ea670c659803d5f6f75c0ce62b311dc157de843a93905e7a28a2557684ae3db4fd009412a107098f881dc06622ed9e3df2c8fe69fe50bfae158b87ca761fe1e221856610bca301ee68958c25bf58d3be203af928a919ace53c3d99f55ab00dfc8a1a28ab83e78617f194efc46daa77573d02ffcaa1f9d96fd8da8dead3d4e75ee5e65fc360b2a567cd34d52bc9aab8b71160312e8e21aa506105d6644e6863e7d5e75ed47c1760743d113a4526553b303341fcee5fdd005d35929f2afa760bb8314d0c0eac960fda3263a1e6688098251618c90332005c757af958714571b77bf2a69030d99f71d1a5259658be565fbd098070122c43edfd400999c90a98ace95315faee4f1c0441c9315d527c7ff1a8171415d2a076e2c513d40b03cfe5513c0e74ea3a03ad4958c00a3e1916d34273e301d517b0a5e770393880d9afb4d0eb44d3140ff7d827c48f67c6d92b865d8fe7c7e45aa50dfd8525f530de1188f3af98b3dc625d335e191fbad5ee9df09c97b43f203bfed798f7d171bf00c82ea0ed17d5890c3d6b9ef6fdc04c5ffb645e3050406fe2fb6bdbe2ffe083e751dc19f2f06445397019b61cf1f505875520f09c6b719e642b81b2fbfbdcc072b7981a666d51e7065e21244679dfe056bc9d42b8851f9d2905fd838707b279a8106eb894b60a72e4851c344119ceeb5bbe110b1c5b21c9a5f7545283002d4b1c115308b1cb20f6d9cb869ed0459c569662aa5729a7d7178de7d69e4885ca77c011e785ecf0e2ecbb8f5245579dbef7a5eb30307e0b40b817bd1112d28eefd548374bc867e0c34d2236952b9f859903e87e977190ff94f5d815699154f96e5449ddc1a14e4196c83e4fb02f5f58c30eeed691de47c81f4883bd84f6ed711fed0c198bfa2b8296182d7225e8989acf55d3612a93e77d24f7b6eef813fd514ce2183571602976391f5ac4e86da59a64233230fb67ff0bb9ec40667f54ccb235d04b3fe1d9a47e163cb19c316046fc1353a6642219e9cecf6e3151c0f4fae1177b67f19b4964df96bb6af37012b8ea9e5ee24c57a010c872b15c8a65d0266589f6da20e38d9be2e2c215c69f558084e48eeb61f4eaae83c57f3f1cd08d05783fb9f5ab1cda5e4b86291fffb14fe9b497ec73292bbd295c5657d71cc74d38a2f3db73ba972986b7169f76ba376376f4747ed65f2f1a5e67889af38a380 +575321bfe7bb9649f8260234872a4287abf09f17038e12236836c22781c86bdf 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 +f8a176bd45b537818073b5286e7acbbac510d55817fafb8876da6d9becd5ed30 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 +6a6a2bef411cd096c017cbf1158f91cd825774828c90ffb668dad39c3d642bc1 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 +7d00cf3bd1e77c1ff2f964c1dc3ae3d1c28d4086986b65e56b003e3bc904a2c8 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 +529bc52d9ebe4b7b6c697906e5d0ac59017753a8926ff87c79ae4ab364fd852e 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 +4e92efb0b2d7488473936dfdfb97fec2b5ba2c5af165a6669499c7d7cbecd06d 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 +263f6fcafb92c0cf3e2cae52a3cb2462206234b5093da0b12b71e55eadb6ebc2 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 +7f909a56e39a2b693bee95b7d024bdfb722d72e36f98b1639aff90d41de5e935 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 +909f0387068361b66c38fb7c377f6a351ed9a008ba0dd902db33dcfe7a540451 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 +b9e698079392e05a948ac695ecbae3781e6b089c5dfdbe43443fbcbb88eb8fc5 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 +864e0e686e4bdbc6e2de3c95b32eab887cb64027ebe8686b794627239c956192 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 +3979a57ecc1821890fff9b30b5396b422516297c0a9d306e14e607a90e9bbce2 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 +6787eb6fdd39db363286504bfeb06509dbd808d54c989a2ec9758688caa862fb 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 +1a3116b680386b3a82f55f3aaf257c494a219741b6f3c046b9b33901c08b5134 523de8b1f4cbb65e81ff0b6ccd6eb8ef0a0f0a691acaf4a77f25acd2d66ad4b3efd25be70308853c094412a518a32020e3020a9f6ab32f0cd60ec0d7a194917d6c457b168a54a4b46f7b0d0c71bd61cd202f4c718776a701e0770b0efa05418770f98e4e79cd066366fb3300e8be359a98b82b764bc2fbbf59c7e8f94a157b01c6c7577b1428138cd422bc47330f8ed99f4c0aab0d984287445539839389ee08d6345108af26aded0ec1d7be774cfb8c5205dfe07cf6caf8c1afe37c7a2e4fe6013b93eb2463de4e0971c7178d6a76b16a0e8960c984ce8bbe71b3b466edf0445b835f09414d01f14c7b6167ff78ff118127bbd5f812c27facd57b3b120e2bcfe87315c7a92b82ef5d50ca14a7174d1bea7e056523e055a6ae42ea3765094e5544e5ed003c989c2f98f38a17e3dda74dbaf9c669a319638a2698b0e4a611480d8ad3cf016792ecd1034925f42b9811a7214d623d047abca31997ddeb03275f80dd21f40ddc80616e7ad3d481e8ebc0a1a6a398e16a78369215541ed10b75671adeb1aae6e11142a1cf665fc1b7332dfbb0e10c21a2b48f78e57319ac9c58dfa8b1c2548e2979ef1accfeb215afcd6c2c1b46fe97dd491758378330effc7283661d2cb84fa05281e9e517408508d24d042e7b9bcd34db87ce972e4cbcdb98615fb93093369dfedc782f44bcd03e81cf93051318b2401ff29f753a264bda65af199e3fcbb8b5d39c838a67d6c7a3db046dc56c323ddbb5340cbc229e47cff8c9d29b7a49ac0ec8c1440ae498c7d150ef91c29bea7df3efcc2871a13a1d72d139cb4603d9fffe85f6ddd544850ef63c3944fb35dbc00d4308ceaa6394b6e23f650d323f8f7ef50ddb68f1486eabf989bf44451f620ec9485c0b52d1415d3c909a2cfbe9d77db19d069d33baee4d77292e63fcbf65c1eba24bffddefe95211ef0aaf8abfda9f94445e582976f986f5382cb669506af2b4a5a0c43000a3c72c5ca4aacdc9d3d39fc5c492a393b6c341b86dacbbf6ba8b465100cc683edb2d9b9f83edf9c6a32645f51cc79adc22a52a007baaca618be35e356d1fd1cfbda73f1ed09253039def609450fd2d5943b9cd49cbd52a318ee3510d7cf3fd8fb388ac6cb9c6eefef3d3cad8501b91cc04a888d33e16d6a4c9666f5f5f3b257193f2b46dedde11842909d8c48ade57775b0b272e2dc9cef1a083eb2ce58f4d1f211922fd6aded1b82fe6f5b11251cd396e5a3666ed9626036e4e356231c146bba0a91afd3648eb7bfe0b9c14f15af2f92309826f468945cad0ac422de3d6a773b76178422107ce0270e7f580b5cceba82ca0184aafa8341141e65e39859885768fbc5ce63b965a0604b659e71d9da2c7a43646088d8071d76926163aafc69e25355bb0a222b7b2da9f0a20c021adc462e905a9c3bf31c16d87fbec3f014f3957a720f1432e1741553092052fb58a198640479abcaa51b104cc93e2636e1460643ea812bd44e819c2166eb6b349ba5bdebad59078910b5c22a56f004b8d9e4b1224d8d204b48abe7355548a402736c5cb110f3a1476ed631ff168f4f3efd89b38de4751536548647523d334fad7cc2d142973f2db3c1fe08fc5cf83f9f2bd2daa524b37864816af29ee05951fa09d1c51d9d14ee4f72fd7bbf18b1a724ff5a0958a063947c430142ad2356e4400aaeca442e163372a8f1cd36e2db988e7781165e5d4e7074ace40858e8370e883694af09977704347fb735c8717c42bc4eeeb2aaa50dfe637c640909ce379bfb9e2608f88751377038d1669f248178ad580a908d7a1b8dcc7e53e01801f1e485b5893f103f03e0f53b2b1440be95644d85aa7f6eb7edfbb46652196695ea23c08573397b111ff909025e20c5201293b4d223bf7aa01de7cb28b94714370434b9588097e2401b62c7a0def1fbf89809e810749fd3ce9ec3c07ce4bf4c43dc966429b2beb4d711fc6c448a12097b36f1e6817eaf4937a983f85d9cf3e62cc1b2ac6ae1ec9eaa8cd8ee2c3322239cfe5db3d4e8786282e630a7d259c2fefeca03031c960a66a71e436a3ed6f2f3cfab4bd77c660d14205abf606fe561a346f7d849b69475ac9f6822d80b9a2e56d5d495e4b309b0ea963c9fc5c7ef94b217ee5337989afbc7107d233a8b362ac27c4f69df9e191cd65ae97d6eb9e5484eb6f10349575e4cae51452380151f902415ac9cf42c824eb23c9541d2da1c26db85f53cdafb06a12b8393cd580a8e494edb6710c720dcae30832967e33e6303a92b1df0841d7724284ffd2e00b95c6d623b168d21ac1bd3c675eda33182a2c22370998de1e5eb905372cc6ef32d5b765f5c94870df4842d011603be4cdb1c227e41eb2f2e8542cd325884fedc9c5c7bb07a92d20d64b836215c59f162a3da8bb67d6fc13fef97cab6ecb8a29e431a6519a6261c4521ccb90e6e609869e6fe398404ae047f64ec4263566defee66329dd40ac985eb8a08d26529a544891b6f57cc235c63c09057ab6b6ed720ef41a3c9ae65768b43f6dcf4962a103dd93c213171dc2c9194e43265c689b49331450281a3febc618d1aa4d65a135137051fd46b568ce294c89 +0c0683e77f72ec95f3b328aabffad937dfd4fd7bc313147a6da7718303a72eb6 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 +6a54f32e2ee20d377296056da5894323c6726d8854812c097e652bbd59bebd28 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 +ebc932c3a96134053fd9c341c346005e46a6bc6bfeb13b3f2afdb13a466dcd47 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 +20fda29262c8e8e0dccc712169c4070be9d6c64f915be5c327c9ad8689026fd4 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 +af1511e4c9a14735df9ad8a555cd7ceb39c9e4e113ab0800d6c83d796fc75594 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 +7c463367a7be07b17be43566265e2a2f4c38dffff63337500ac4223c7f9f47f1 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 +87dc458faa48dc38e06af5f0ebdd3e4aad7c249f94c9f4c06f935eb755f4ee46 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 +1a57b463fe093a0ac6ebd4d5f760ed362f05f4572c5145096b6d084855850bf3 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 +8b597b223e1aa53106810405d149597c9e5428297b287ba44a93a68f93036141 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 +8f0c2164beb74a3acae29547bc20630e14e5ed0fae478e065d1849769a110d2e b7202c31c33e5579599d14d12511cd700e5a077679266b94b44586b363677692a4f2838f50d437c909e5a41ba747a6f2c72be85149d53a834f7e66b6dc74927250b543121b6b4780542ab511adf2011380f0d7133bf82b38a2e377b5c7755e49bb1abc16ee0a4a772f5653bbfe06be7773290aa4a9a059b98647c188bba609d31af594d0594b375963f249296fc6974d2520cfe9ebab8c4154f1b9a7eee66968b853f19f74d3125b8283e5f167395ee1077263eef91cf573f1a258384d369c0a1b8f4e12c05f942b330d43a168290d82325eb2b77d49f25e028aa37751a28c405a6ab190b744c5f998d7cabae18ce184d96ba9be24281556387d710e66fd7780eb1a0d91a3f6396ccaa54a7b2b223abc1902a660a44ed1fc2606aa054e1c0fd9124eebcc0993922b79ab6dc225826cc3fbb0b99046529ab3cfc79eab58ea68a153f0c14e5735cb4296fbfcb23acd158adc1b049bbf854054a7e08bfe0b7d4c8896670a90bc1a3a9d4a2f74d1fb5e143a4d22ede79c738b41b91b93ab34a91c8e327bf17a1e86884544b70557d4ec184f82ea5b5c5682e33af7cc38c5f91bf5d024cfffd145a5aea6fd7b6b0456af14bdcf60734cc93c1387a48dfb97b91bb23d7f68eb783eb0cdbd0bbe4104ab212147c9caa9dd923e883c3e24b53aebcc3f7fa5aa5c887078628efd7e82543f8600fdf89a3312ad6902271321b77c1f8dff1b92250c59e037411c6791c7e930d686e7bf359ec480c6d0bd05d2009f2d339d2089d5202c65b8fe737ebea6cb6d9271b0bbd3ecd6328aa27ec7722cbb3e700662ee6afebdc4ff5e9b00949ec3da530aa271a78ca7328217bdb5600448d9f825836e04892cef50a95f8ceaaa5c28f2b9b185536ff2ddf380808ea351bbd7a068bd43bfe8eea7a3292c65130915e828204c0ec1939f1e3088058cce4b2921530e3a2c8cbd3fca2ee39504b72ee72de1203164ab0af78b66600b27a067cd62d7dfac4815b23a712870aa4f2659157037285386beaf2649741da70fb7e031b4e1f37768a0c349c7b8c90a3da6138447db7cda00c9fb01647e3239a680ffb6c8d4d536dea7131480fa95c597bff67ab5bae2578954be01be5f3892688a98b0ad0a21b0af40e562175164018d32d6a886dccb256ed7c4148eeb963042bca34b689c44bc485f286a65d1ec44e5a0c90f5a1e8d6a29dc30810917b8a3a6deb0362d5967f75802e8174725b734b61787437aa6ff8a4fea6c2390c477dda085a62c6477e994913502b862bae548798a17716a48fcecf315487844a1d98eaf122521173807cb72308cdfc6cfa2f1b9324a305869e47ce15cd18cb38ce83ed3b41a71205be49cab4b93142d8e20a4c4365e4b0e72b48e5440c8e8f5a8abbe22e5c24d2ffa0e062434fb17119028299ad5ae732f0fa39127e533d591a27c7a0107a9442b7c2211c2f7fdade86bf032ce72e94e71d6072466e7c50c62e01c35af9bf5de708a309c5694c84ed47ab397c409057219b2b81d9bca7526765c11701e6993378bed05f5e5ba5f9c5fc3e3e6097d39c86b2995a9fe75dbdd0cbd3a9d96c335c8f30fb00419622f8d6119246f1b94ee8524a275738a2b312d036ad0a8ab72ac50f76c8642b00f354b00e0311ac1c11c1332372e4ad1a982027230536e7a3d451bb1e55e509ad026188668be90b12cdcb64ab4c19e46bd19983f4e1d26f85258504af4daaa3c188fc2acaf6ade8fefa7a42aba19dc7d1f2269fddfb15ed2c659725829e0736947dacc67d83b0ff4f1dfdb8b998efd4e50d8e505583814e049a31923febe479ea88816a7fd044a52339b761f9e069c7585d9ed7f2397ad4c208ab06c5fe4bc6ff9b367d109dd3fbbbb48f319053c8bcf643e1b8346ea42920e9cda202ea0a74e44305f8ef7b18cfa5c921c9e5e546276d3ead2568a9df7b7883d4c20b0f38bed538d9b41aba491a4ba3e4c4787fbb6f75b18dc6c356a95debd8985a028c1d0c56ab5d06406e547cb4fe88bea7d0f8b3d244f0d57652a18d122fbd1c6df0002f3bfa071971399c749a05569f972ac0c79cf6532507740c3b906e1c56641942e215fe60002acb2f330c99800b84100982123211a1bb9c05845c29ed03e3549861787868cdf9f20c9dc3dd9c638a9d5ec0238ab05bb2c31e475f008dd3e5c9adcb0968d022b99f1c848339ed38601fd594f2be5438440f6371ac954573012d626f9cfffb06af4dc2f0c522e5258968a6eb28822584835cb64dcb1a1593029588594665be0f56848e24f6ba914d3ac6df6ee019a4371d8d7cfc74733f29784ef56e0183639dbd8fe001c63e85fc3206b299f1ec1036dddc01851d189b5ee270ee5293b77abf4a4bc6f986814fc0ed65011754f4030ddca7dc67d6051246136951cfcb6aafe145f5c14df5390b105ff1ef9d35d31ecbb05b2d88140a7c662ca6f58e2682cb21f1da837191220e3b2dbf92546d576e27709c67fb3ea8ab8b53f394c82834dd9fcb317a1b51d1723bbda7ab5315778b27afa89d191f1a47f8a0e0c15e33f0bdf577f92efe3eaed6546a9487233cf9c77550d482da1b99fb3b721ab7ef7826550fc4bf953426b69cca80549569e1ec6e523822060b4cb8a88bcae1b9f480e073a90e4cdbc8e60994b6b953ed153c9da146f4ac0d2030105bdee296dc6bfdbebf75e6353add84330e8011f9483f83a39f8d06a50961a07557d4ed83dbfd9e5cc434f0eaa70d69de7d034e359a412864d8be292f588d607294a57cc3c5065781e111439a2033dd64b94b7155aa565368045214c588d3ebe04a04b7f7df5630a460bbfbc39dedde14d590b2c79664504ef027f4ac22712f8ee8b4399f01a7418a8ab9cddc4da649f5203a9ca15eb758059b911b7431ec07ac541d4d2acbb3d67838f4be54a387757f1d19d9cdcd7ca1e5e6edd25046ba117844d98153008401a83989c6788274852488d9c3a90a3c0936dc09087a4dd6c08eb2813ccdb49f1ea8680f66d580b10ebb30901c832d833ced19b52b419cacc1e01a61d16913396cbcbd31efaefcf1fda31072af08c1f1213658c4c6dd7640cea2c2c4111a4e2e39b806cdddd6c6083ce7876bd196400ba07fbb9f6beb7656281d9650317d8f2edeb962e62e31fe73d53759a357da4b8571337e3c7588b998628f567909cfbec3d6bd818214fc7f0fe7225e0f8ab64bb4b0d74aa79d9945e56177f0e81793552b5f2d78289309e132d16fc7424155195e1f5db8cc327b650f2e3f1af987af84149052f27a1da66251b08a562e8be10e92f976cea41cda5317035dd78b327d9faaa0b3c897ce1106b0746606fc4b6ac5f358d2f2e10f7938e5fef61e540181bdced5a74d3aead4207e18305a4ee2e999435a75914f21202fe3f39c39e5face4e391910b937fb5abe043d633410e47f99cde9db85015adcbdf48f45190193acf6e6251e99b65a56868cd248f6935aa9c6720c2979fb5a5d54b45fe84fce1 +5c3d54127f3f4105f9e802926fcda6c785463037a64d555ac4dcf9e08693345e cad9ef077a98e3f2e5706ebec4960d5a5b78b57cc8017db1112f2c537076350c807d5cb1421c235ad2f8abf7ce905c26b18566d8fd6af44908269785e789caafa1002bea64ed46b1abe2a8812ffdf400b18a39b731040a8c703d837e463f29d4218cc4ac0e38945f5c79263d2ea86ae52811724424644ee274c55fb6a050782807f3df60547ba058465372c8a664e833b5176ced42c40177cd3483e636ae6f0b9c7aab5dde5309e5f377af74314680a72dc1088afb861e6d564db6db6e6d3e66da3f3d539616408d7b0727cdb924bba38c3bd5ebb823e7f441d2567fb36d31313c5834154abe1623723449fa8324c85a149ed1eb8687be0e8a6c07527bc0d9282651cf36d5596e1e07489131ac3c71b75513ac3acee7cf9098d1d5c710d31a80b2a6037b37228810b885160b764223d4b016480cc9835a695dec0013e9e064c0834b580c254c6f04689d0ff80c6999882ce2ae5b4d8f01cdc5c2728890c7c795b10c5b7e01ad2054e750783d4dafa677cef7ca6141b0c5fc6e5fc38b0d1ae088b16a02c31ffe242afa4264c21d4aadee3fe6b3f43afd38fc554bf168c4331a388508adb66a12b85af205e6f2a6000c7f222b5e3e326ae9e572956330575a07713ee32f427878a62146810b85483f10363722279af71290e58fd7da3c79c8fa0378648423e18f2bc4649e8ebac7e28ab3f8d1ab64750791fa9158b0c9261b2da1a8174f5002aafaca122eb2857851de26278f594b59646b3b2f6b51a4011ded6188ee52d64311db7e50dd8197ea0187ef00f0411d501e5d1be946e31603242757b28f3d05cf1744d62ced24366566dd16a3f8f3dd4d52d7fc891a31e83ee8038dd78afea84ec8896958397aa7aba0056db3b16a04a2023af67a1948dcbad4a0a5376475a320371194919c939f4e63971bcaddc344799aaa151434d2a5c402d02d4ccc29ecb1bc40b297d9bf72aa09ca9dd2cc5268f2c3f49e10fbe4733ee83647b9efc1f59bb9f7d8e2bddfce717cb1afe7df9ffe8b4a7bc79371b74f1a038c9c4fb8b7b1eefd38988bd591dd2817e19e9d6c52b522e90dcd89c70d3eed91b1286c3891d546f4e198bfb385554e882ade07aaaa4559ad517c5cd7cea7cc659beaf8214716ed9d750d382389ee8ab7c3c8aac48968220027ede85f939098fd679d97865926f120d8a9a360429cf00a7c1def836a9933655abcb384e9f630b4163f204238e9a38ed949af36f5204b74dcc45266f89af90e6db2c948e7d773d72e653d35c848c77936e6e689f75dd78ec2754e02fbe119c572885bf090b04a4390bc7d5983809e5ac7e4a16f6ad023c8b28e6b01591b0fab80dff9e1300de11be3168ba2f1691e6cb7c416c3201fae3f171975bacdffa520571f518fd8477553be92539a0ecc5ffc161043139cbfa35673f71949ffbda64693a032cde6a34432cc7736f1856b4daf68d39369327744355afb6a4e89b82e5bbb1d53b5ecd1ebbca25f6b51f1b0076c34068676b2b879c13f64d91b277fc82ead7420f2497b86c9feb5341aa553c7916ebe6620de18eba7f453883a6e8a037c314ec159869132e1856943ca6da2411830d6af8354346acb06578ce89e277e2619596330476ee1b8a1ecd28e201c065bc30ece1feee5e7ae182efa8d0310eb731c30ca7184d6e9f3c9cf08ef2b2e63ccb369a36ad63207dde3ccb04de341b5d093a0a140aa0a8dbe811f03114b235f07499e622ebec39521fac671183f0798ac50919d260941415832b1c5686d7c27a7a5d0e6222a991e341c9a8b10a76e01e79b1e7a0c18227a39079d50f5ee94b18b62c51ac36650ed3adfe142ba5a34a839449599355d4ac9542b146156be4fc4dbfdd10cb8dd15d0c51ab23ab19c16500f770693c94ef61df26da43a09b00d4eb7206e9325cd66780ab47a7e95b50df423c40767229df1dd41a808fa70da64771fb91b5f6f76872759a8cb77fda87e2f2d7f030b9cdb456005db9a88d0f27d4796803bd570440fd0b7e99c3d08fd8e603c92098aa4150d5a87c2917cd750bf0077e9d71c43f5bd3dab919c23e16bb90537e7fe694a847ee843df4c8262d44c39bce4d9c49069b213f1074453ec66ea054833fbdb72b81161dba424390413dbcf96cbd56a35fce6510ddc2bd9296f7cd2f7474f86fe24cd61c9665cee251420c0a0d1f56f9fb06c83ffdfcf034a5c27b8c68935c4b2abd2fb92d570f1fb610b3ff4f66a3110a7a0b89c07191bd5928a39d579191633b96f1123e5535953f0d25d28675f5ddee31ff2b6e13ff21a2db1990f4ea8d0ab5d4a73af9a41d5ff8b1467a11cd297ec416f448c5b0d77df8d02e6880a7dca283054beaf1fb986acbf838b68a32c6a4dfd097c9fc998fa13e382399677cc947af6e4ca5b37bdbde394b89582c04bd05dc7c04038c626c5b72788189fc01799a4ca03a1e65c744f6c4893b19d2749709b23af92592044224aba18e1052820250d0c35cf8d76e51c73c94386c6e0f147c770ec379976b574ef2ec6d68c39ff2c287fe5149f71497e1abf07176b024e408479bb7b56b373367d40a5bd08aa38bcfccc705531d2984cd386f0f47f0864e00d758eec1ba0ed0971a0a2a84eec663f198326aa62f931daabe381dea692a7c43425d54acd99e2ff5b7464f5bb794d2009035ca9ff721b1b4494cd8cc5cca9957660f29b77ddf173d78ac56b36aac5e28374c38253b22e16bdb93e4cbdf9f0e854ea1d79983f8f9cf6d25ddaa7648055354a8cea372ba54eefca4cd040d3eadd23b89ab64c545b7462d2d6d2d249a919703bccbea471251d36a1a27bf0fd653f5f1d8490586d9568aab141383b186630a270bc7d2a8a299b4c90bb22fdf08c30b2745dbe6d6ae7dec9bfd112f5611a83f9deff408346dd62f75de00550f6e56b3f9f9b80d7027a0c7bf6306aca159972f2ae43346985a4601b481722eabf3786696f9623e1366f93dc585758fe8f245e82211ef984bd31dcc9fc7d7cecd099dac9e45cbe655dacd687a848f53353d7bc1d68103d4c8c740c91b69517b164f47ed718e52687757a51f086a4ddef8ea4c858580d6eb8064a044534e277a7dd5975af13ef5c43066ea26902e7a36df395f2495ed4311c3736e91450650843a1828feeb42e6bd5a05d0fe4af8d7a543463038bcc3d31a589108038dcffc8c7a3cb86c57ced3a1e3e22357cbaca328ebe1dbd16c1b882fb009a697c1efeb3efca007753ddc51f6e7da8900b3a37312ebbf41c0a7ecf23c39213fc8a23c2c5ee6d783a1b6520b07ff747a143f6a8dc512209c37adbed276de13c5ca27ff7a595545c024b11f5eefedcbf61d92ec0a107bd1ca00934618927da450c940f6dab1c180b29e72c0e8709627e51e91632c364fe45fbdae43ab876d33000fb1ab437d499b33250d75a1d23192a55f813859cb693773ddde616e5570e753128572bc119a46951c86f99b3f931416c0347d95d5a6be502c3c8f696ee026c3e66e4f0a3847aa49815cf40c902ba79ec7c4e3d82ee140c8c09f73ebaac0b5ca11723b08793fe17dff3efcac0c576d8f5d9699b741861e6e2e9770a +e4db2576b90d45a7fd170002406ab3d5d2c7cd638cab1cfcfefbeae07266b616 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 +396a885e4fe8ba62aca7a7876618913d401e9a8aad7ae124d7642c0a207e6960 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 +4a3479e93e638f18abb00b68d66e5e5be77a17987210081a240be5c0af167afd 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 +b8bba805866868c4031d92f498c72d60267e3fcb6f3c7aa23d7f2ef877d0da79 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 +47dd80e9c81f84d8761fadbd40e555734c92fcc3021a0cae6476e7c02a678401 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 +087ef44dd80713a12063f44df34f4999547619d5b7c994e3ee4bb80c467a11d5 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 +fda21373fc76c650225a32f2cb8539ee7d6e5fd23191ba9394dab9762cbe496a 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 +8cab349e4014a76db8710fd236129927c17b2b010b9f4710a0af506d523fc2b7 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 +1dd50d0f533ddf67a26bfb0f069d9c67637890cb986aa9d31d7b8c1acca83f46 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 +cfa31b43d6101744b702f7b1ebee73bc5b259de35126cc10816c3f66fedfb6d6 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 +4bfa8719b5d04ea31d3cc48e406538318d80af73eed4062a1f147d2015b9995e 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 +ebe420997602e4bf5ec759e1aa458874d2be771e24366d97b139550fbf197a6f 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 +4ea0535becb466b8ae55e88b6525a8033d1bf34c43bbee26a62a82d17f323478 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 +efc5c20cc677bc1974f37b91cb00cef0d91a306ccc0f6baa36c37c4505d3a214 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 +d21fd9a2df4fb6fa4c135fe67f9deeb3b676f66a5396f21f72c6945c0b1c4000 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 +1905a2b2eca5c25445c3064605bf2a430165370b92b20df6a18906f36ac83c4e 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 +d1f333e3ce05eb4423b52d0a65dd330e7c37eee26b0025231e50c73494e93fc7 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 +c1621304fb02d48434c5d754c50533f76333adfe9347b0cb0c853ea77fef720e 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 +b8a4f59926ac63fe3868706e34d9ade0141f96dab11daf4d54d0a3e07f4f1be3 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 +d983a3ab7ead7af2cd4e378bbd8707d0cec6df53ffbebc062f5cfe400d4f3ecf 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 +7ccc25ab41f82c134012b4bc942d85226bf8fc692be8f525ad921bd748d2adeb 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 +8f2da5c9bd89e9b0680d89c31d775cb7bb3efeb75c974d575a10854153cdf78d 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 +62078921ee0bce945d1b8c93e6c5f4639bba1d3b3e786a6b0c55086ec769794b 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 +27c62a0671d68217615e99dff56897fef7e46497ca746b642f70222043948159 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 +4e9ab501a1c18b841c0290b5cd89d22798a0308571719117344b92949041b893 0e31c80a1c41df5f706db8da40dcc06e61b4d6969715ea02113e2a63663da6aa3df8ba755109a580446e7e94e9e33dc98ee6b119d3abe78b3b9f990349a63dd609008ff72e2cb6710b99522021aed51b7485b7b3b89c4c5f81e0ce61b5310789556d93646d531744e6b393aa38e1aca0d6565728560403423c5c5bf3b80b4e99bba5fa53765a8f0b67e99bbd0f1e31929731175b49e237eec448d08d282ca634d720ce74c55925b68f0bcf08b6493b180465ce03ab4db3c74bea45d245d21698e9f1cc8ed46ec4bf4ad4ffdaaab9ca2bd75af81780ae59610b652715a30f45812ad1075fb9051340167f69ccd01b05fdf1f4cfa36c053269b06e40d99c5cbc685dc18e266f60b23c19565776a5f76c5ea917aab08db863dc88c2342c7f7f0e00246b66eafe2d3de1384a108df5dd5aac8fce8bedbf495f065dbf4307c98b879a6b386f8a4261daeaa00a331fd2d827e895d2fdeb840126564ed561624abbef25b0427fafefd705f56e2f362ab7410cb777591bb0126cf70e390efbb4e7a13b0745d7edd864e6f90e8e38b61c706e144bd50fbc6b5a5abb810b5b82e2c0d13bc40efc83e9e790f990d34a07a5f312e253900b57b04eb634ddfeaa537aaf8d118f1f0db57d6e6206c0eaf94ce2d540f6ee2e2e204941848a537d868f9d95d681f0c5935881288e0d91c12de10c3629e43e9dc43620189f44985b59427ac131b35ab4574a3ce288806b9f4cd23ee2463f3ae947fe6eee2fd3ca9b7780e0939b615e8dcf94ff684fb41b76d25c6143c282ced5d9799ee19fce194b047e8072b8154e9c3cef1a34e7dfca73d4ea1636cd8120a8483285b21affd02ee06ec882f74bb8ed08d011a9a17043d12c4bfe83efc8208549e53874497741aff8e5b8fc594191e1b92e581b1b7361ee57bd39c5b2dfd49f15c758b57de8fd5f2d65f725804148a641a2e30a732b5932fe8ce43a212c6be5563fee8510e3b8a9fe21a0ffb64979180ec1d0842f612f1d58ea555f5b5c7dc82ebf2e4ae783f608a37dea30186f558ee743c3c2d2c90d5f51269200a28455d15fd4065166ae51d5a8268793011b7777bb8dfb523c278c9a7d1f690aaf05bdf90e076b3db87606e6575a8ec0a5c5bda9635fde179d40deb4466dcd2cf2f0ce93554ca6c453b302498fdc5dfc4fe1cc717529c332c7771540b29cb3a3babb522dcc7c0c108296893b4d90629492decd4af23ee8c84830fea1482c9b9cbf0af143af68354ec57cdd8b3e1a503968a9691233d76b3630b18e1c79263eb05f8105d1e1070701d35cc032dbfd5b2e877212e7a11940df6cdca84d5cf7f7436e655716a0090d2124cb0dc6f07bd051ee9356287a9196f43b17f73d3f056dcd38cf0983f5dae8db939803d6866ad4f2800cf1b316ca31041eabbd59d0df8380fce7f3b62461a4dd6e14f9e48dc130791c04ff7c6e3e8462f38594b62b11d6b865622170b954ff9909af29990ab4134d48d494bed3bf8f939ffba76e3a3a8a263f75f8a1f3b219422525d8ac91948872f221f8c07987a4ee8529f71a9f2b8ae7c7a054c73f130f97a2ea8ebeaeeac308ae9e984447573bcb295654261e09804c65d3accc932c32d265e8261250bc045fdb5896ab266cf3ba5b9254dd8e54112f2bfcc9f119ef4e2059a9ec0ff62b42c3dffba2868e4aa1c7021ac35c9aec2cb5d133e2db8e11ce6b2cce87754f4da3a40789f95ef560bc90578f50f8087f4e53444af8c453774d998e13bcbf0ce54cbcf56958254959685979e56f0cfbee657fae0bdb0480907627ac2231eedc0f78bac28b5abe1d20a0e428973d15e6f1296e3b0ab8761d77dc928a43aece9ca5c502ef7466874b681085ddb5e7377e16d11ea20fd931f9bc213ae0f544aaedea9e4fb7f5465b94c14979f3bb231676831ee73fb7a379b789365701d6e2e2a247c1c21ae5ebf6f3edd9c46898974b734306e70c9b5573b4d052e63f9c44396bc89c9566800a7e2a9a4c32902f799b4ff22cc9bc21f39b8a8af4e34007cae37ade40cb859decea4d274bd11dbb2f5ba304313c66a77f7a43b5aa7dfe18be40a9f499b95e4b825ea00bb83a0d4f11f2f62f5ea70fb817dc6c666b09bb6c919972b2a0c7bfb10c5b467492b8291a2b9820e2d8bc6e7250355e23f50662dafeece00cc8c0b74fe20278dddf870dddaf083480b1504e11b518d3f9e9933c3ff2f0ca3c423b8691683e3ea1902004aa51cd823709bb05141a8b8cfbcb4ef9f73aca2f09716558d879418dc7b0882faa381aacefaab611ecc336f36d6fd789eb734652a08bbfc61d19925067c6e5dcac4f05bfdab6fcf083599f2845d0429c05a616d1977004803bfff90874514a79c0f45e4cc5b3182be7c45a9e2f9a0dd976fe3c220542cf11cb527861cd7461e03f5335290e24c483b15dd2617b31371a6ff98cd62fd8e713f166c3954f0867dc8c3641c9cdb1a24f3a9ef270d56337537c98d3fe904cfc320d8d19a241e1540cf5cbfc5a5579c76026cdf961ae88d3224818e8eacd70ae4307b335bb759f8eb71d4a32d12f61184d91cb081737eb9ef5c36b8bd5a762b3781253403a9d621b9070eb22b77d41db6a8b23b6b6dffba92b4d54d4c625ff55ba5bb0d1bf499fee64813e762cbe9be8a66566a5f733b0eb407cb025a0d90e6e2e8a415d9ced3217a541c28deaff17ab8655db001f523ff303921337ed2ee0aeac6070f8adf9ffd61332ecbfd2df68ab366751c83885367eff7f589ecc4b7da65103f814ebc2b399930316241323a1f5a2bfc71fca019bf888f6d5632ac916d73a3e915d26dd11a2816a27e238568ed0bb4d2dbb13fe6b6db57b0ed9ed500559791b01755179ea68f57fc40bc357925d114401f328bf6afb7a3548f957ea12f76976671a8b5cc2a5b0d085eca87cdb911d1344aa7fe02c92f10e5c86b6bd4c1fc2c6f02cccec98aaeb752057cb4e64434d1e0986b93e3f981d1b5835d75691cf580654b5ab3468859b214b0f3bf6a75605901a6a1ec1ef0ee0a6ce0132d28cd79e6365ec6a992f8ad730a4040c8bc2a0feb8315a90639516b0d30db4a66f7e7248b04ffec3985b2a1995df3ed58c3531675c4ba885d5a488a773ddb3e94d2982fa22a7d424414305a336171992de01e31e7245cbd3b54d46209014921d5fbdd3077f3bfd86a3a99cf998d141c3a433e7d68aad547c0ec99ca30f2d15ff5f26cd00f0d45f2f0461ef700a30038877004a22d54ce3f198b44ad470f20adead37bd7f7482e727c1202145335488a739e688f7823254dd669df59bfd94ec7b08c526286aabded0ec28714e7c5c56379f5f0297e53512dd1e71de493e463d3f4d180097b8771b5e055fc7e436c57b53365423d359eea41496effc10f90b46a2204ef4cf3daebb60a3047866d736da1a3553bd32a78a370ad149319ea4cdfeb9921ff920b4d6a2752e9f6396da5f32ab8d79e717f04ff90d198d249976c081cd298159bace7d7200e34c82d0c76a61dc0898287ca0a77e9f4d649557e0cd4c5e138da53d30d47c5bb4cad52677321ca0dec309cb658f73d93d6c05726bba1204d78cbe97bb3fb76c7b9f640d6f96170a8739f77430111711e13d9e4e734863cb39a3e366c406de7bd0a716384e5a0eefee581cd16705d1745f13d56bb5053dd1866bf9cde1ad9c462a76d882422f5c9a6025131f8b5878adf97d32a0fd89321d62ea5f5b8ba3c3809057c4d553a391dee75b93c8529ac498a49b52f2e3ab6bf659cde1b210aebc3a85ec8709e9ab6c6134081ea0b020e0b0867c72a654583b954cbcf8ef2a73ce983c2f8f0b5db5776c16f56079239a6d7464696a182ac51855246f8ddf087fb403840fbfaf215b1c49d2e7b8cdc567431f1d00c37954dc7b40bee9a868f2eada29e6f0a73186c119278197af054c7e3f88e5f696b0d4c94c1196f058ffd72722f6495f16dc41e675833df9e4394afbcc7a32b11cc2388e4929786865be4178f540ca525d067f0a786be596f10670a25fc6f2f525cac40e7e341addcfcb91f069a5c2aecd7b86ed1fbebe8e3bdbc3fe27f9042cc53bec16198ad42230256c8386b46c4ad987eafcb6f07e347cc7c4ab4b04ef9d20cb581245c9c102ccba044a1884140666f38be3e64fac46350c4b3e983d9678845e9cfcc655a24bf89a8fd4600536d605082668612038b6255285be6e6266c90756a3cb116931f7d7412d1725143760feb86f4f8c4cdf1f4b06beed0f69e3f64c5dc7975face5f209b4b67cedb734c23073f9ae1d824ef849be836f02d48aa40348221fd09e111c076e617374cc430f3120383fceb38c42dd6f4b53e66ef6c80368e0fb96512fcb25ecbc4c2c3b99a07789e6920311daca599dd8c9f0ca413a4bf9b9b986d9202137c9dddd36f9b16b048268f8334af0cfb13dcc2589007e4ddc4b34a216f7358f316effff9dc33a8d5fd91a95bd433bad8bb31d4a14d6d45f6cb5e8a8ec31180a76aa03e83ab3b2cb9a7de0740ec7bbb55ddb5632d4be1182e2abe3f625923bf5b94488a00072414deb2fbfc79444465ef10aa7eaabcc52e13f68601250f313b40d3dde694fd935e92d04a940a8bb7d5670ed454b47725d933e64ea6485e4589f1d9e53de5eb1c9450049f35d14bcf8c38d20be815d5a61703f3636f6e293ea384b742a9088ae006d3acb0a296ead4680f3152deb56801530d6044aa040505ea4fb656ecae9e389a3e5040fb66490c79f26e980af8856bcd381a53e0736a9a4bc004cea03f127c42d3aa75a0b9d9084326f57caf346229f818a94fdf92cf32fc3df08080c57e2bd9342fa0e60004e9091d514c500d4c3100c73610ed989ccf5c2d40996f52e4fa469bbcef2ce1a7b2efb9d70ddb30b28728f7b599f503d921c59370fcae3e07bab4885e197261f9d0959ad49b418b2f445c02728db039042824245ccc77542e0c0b15c73c8e01767be6a2b0ab3709f35630225d9749e23110bc96f591b8d822491b90d7f893dc1127812181565954ee6b8122865bdb496ad533eb7481806d4bb061e18170a1da37cb435cf356dbfa570ad4eeb26342612bc73f6e0d39ca45e0eb44ceb07e49d29e1b726712f510b68ef2975cfcfeb6561640b0f0c2ef923fc6810fa5cc5e5f7e5c2992fc7e023ccabc78b8d9f3eeabffff3a3c3c38d321657e595bb4e6cf104f8b59dd4491a88c96b11aa5179c3e2306305f49f813a0598037cdfa95a2449290659c8c1f1671ca688a19ca498eda4f5771a972b234f02fa70cf198ea4222701d1f30131310f1ba4401eabc06190ac9dbc8eb1c7526d045fee0a9cbdcb24e04464e0033123d6f8f2f24f123c5e6dfd75d943639c47a6114f8ddb7af965b8dda8460fdbc4b258489490e66326697404592a4ad4124e3d879db864186279d307015d2c3adf96e2f57160f0e4a2037d6c760c5c4c852d4000ade51ebc6613a7b48c0aa400d0fced3c5e47074c3b917703d2fb1b04b058ecf33ff54efea37495e45c9bba1c1b26f160de0beef21d26f19131041163babfe16e4d38d83519bbc16622ef690e3fd0a61a968f06320a4454aa43883da580a396bc65e8af8727495cde042a0587085399fdbdf68f77ae2bec132d667904d1ffbff7a2b361e67dba5018d0d75c025d2fd77e4827448beba2e91c3c4f456565aabf8f9e1caab020a797d6b8c2c9a730fdd80f5d227ef9daf88bb0026a9e93c3d80a1636830ce832b09b942cc6d6278cec5e29429aa6d672f2ba0712d5a84580c154c0df08b6032e5902353ceb6793ad9c8ec953531b4f0602edbf3d069a070f4166f12a3ae3d3 +1198423d98794cadea3cebc00a11df93e1083e732d1ca821f2d61e750cc270b0 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 +d73108973583e9299a6a9731592d843a94b76ef2bf1017c77b576c51e3fe8303 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 +83d3da3480824cc905c1fe0d9161448533b89c9feb3328abb4019c1b002ef28d 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 diff --git a/tests/hash/tests-extra-jh.txt b/tests/hash/tests-extra-jh.txt new file mode 100644 index 000000000..f109bb46d --- /dev/null +++ b/tests/hash/tests-extra-jh.txt @@ -0,0 +1,321 @@ +46e64619c18bb0a92a5e87185a47eef83ca747b8fcc8e1412921357e326df434 x +7b1191f13a2667830142541bfc5918543d2a434c7692e70c3e5e9bbdddb7f581 cc +ef3eeeae2d2457db084f2a933647d9e77a476eb4e58569a18ad4ba55754f9034 41fb +54418f1e9b472e53e2fcc3bb10d1bd13f63b3c416589401389e51896fd6766ad 1f877c +8d7e972ca6eeca9b09b829e4d627c72572b6b8555c7aa081e66167e9e4a10f11 c1ecfdfc +3a550fcd062011d809cfe08aef1735089385025fa983a4c1b1ef00a85c474641 21f134ac57 +b3ef5d675a1448c355e959228a66e4a6e97bc32980615a19275c60798cf8facf c6f50bb74e29 +ebaa0bbdd492c14c111375b075f79f9f2e15bda29f1d8d614611cc974e0026ab 119713cc83eeef +2cf254d773dd18ba2efd3be2cb9c8f88ab313fb285da11e38c8a6680521dbb48 4a4f202484512526 +443d065a47f394a2bea55f2018343382159c734ca0badad7bf5400a7f7ca151c 1f66ab4185ed9b6375 +5261d72a7b72bbe12b8d338531259c1337f7713feb48e8ed6568d00076dda3bb eed7422227613b6f53c9 +41312347fd2182de55e608451fcda1808e3d3bd695eac759c6a3dca7973f8aed eaeed5cdffd89dece455f1 +ea0e14275a163beef3e124b591507b0ee8f0e25aa736b9afce6dd6ec9cf8c070 5be43c90f22902e4fe8ed2d3 +e9a78bdfbe479d6502e4e35af4d876d42acdc5b647371dcc3f24119314cc4395 a746273228122f381c3b46e4f1 +0a652eb85cb10a2edc79ab47b3c6d8c05aa0a05baa660d2e91b997cd36d00b84 3c5871cd619c69a63b540eb5a625 +715a57eb6d309889dedf4e327f146313b1491afea21e1181af2ff67e1af8d0cb fa22874bcc068879e8ef11a69f0722 +f51ae94b7e45f0723e444512f8a12b170ee630f08c8271b4f2c50883153213f1 52a608ab21ccdd8a4457a57ede782176 +8866707041274bb36373e4ed4473d19bfaf47eec09071d9e2c6a5ff6cfbb39bf 82e192e4043ddcd12ecf52969d0f807eed +f6b7782697860a778fa6d80832106b0e4307bd1032af215bc7b1cdf7eeb9c9ad 75683dcb556140c522543bb6e9098b21a21e +10af55da5f5d82de69809b5a723a2f03732860c32edd356d2ac396d1bcefb73f 06e4efe45035e61faaf4287b4d8d1f12ca97e5 +46d53b64e7e0c6c5b398dee32f77357b42ac7150501ceaf52373548c2649d722 e26193989d06568fe688e75540aea06747d9f851 +2bebb287410e17fd292c684673731304da159c67ef3476437d3be133fd274180 d8dc8fdefbdce9d44e4cbafe78447bae3b5436102a +b5ae41925ee163794f405cfd0701b3eb6643a695eabd4d3e7388af2a612a1a75 57085fd7e14216ab102d8317b0cb338a786d5fc32d8f +5194bcfe6ad91f458b8e3fc484832c6457849022631fa74a6df1622acde31f4b a05404df5dbb57697e2c16fa29defac8ab3560d6126fa0 +dfc2db3010b7efd4d8fc6ff7e97cb1f467a680989813ffd15630601eede1b439 aecbb02759f7433d6fcb06963c74061cd83b5b3ffa6f13c6 +50ef533d5e8bb35068f0ddc182a7a64160c16a6eb6bcf86f2d856245d31d730c aafdc9243d3d4a096558a360cc27c8d862f0be73db5e88aa55 +662a6b40f2cc799a0131ad6cb2fb27250860642be677a4692284970370ca8337 7bc84867f6f9e9fdc3e1046cae3a52c77ed485860ee260e30b15 +a9fafca1d4f2a102313b236d412e10250b694abb57ee001088eaee4af0ac843e fac523575a99ec48279a7a459e98ff901918a475034327efb55843 +b56a7149b7cd4579fd11cebce62b7399f9140f28da3ff0d1f561ec6f333e1dd9 0f8b2d8fcfd9d68cffc17ccfb117709b53d26462a3f346fb7c79b85e +f9dafd795798da47cc0efe05449bc7c968192592a7d6f7aae21fcc4ecf76a8f4 a963c3e895ff5a0be4824400518d81412f875fa50521e26e85eac90c04 +805fa3e9b7c527ffa9b03fe6e321f19c12aca66c9d25723fe7ca7bd82453747b 03a18688b10cc0edf83adf0a84808a9718383c4070c6c4f295098699ac2c +26261993148d5a72a7b674cd5e42481f5c10f621612c2a86512e691db691adbb 84fb51b517df6c5accb5d022f8f28da09b10232d42320ffc32dbecc3835b29 +bde228032195db23df94fabd1a8f3f11062f58781ffb716daa89323380d1d4a8 9f2fcc7c90de090d6b87cd7e9718c1ea6cb21118fc2d5de9f97e5db6ac1e9c10 +72daae3f607618c0fa6bed77a8a47eccf4792ddc1d47e448ffe878dac1cca86a de8f1b3faa4b7040ed4563c3b8e598253178e87e4d0df75e4ff2f2dedd5a0be046 +08eed97851fba9fd0ad2989fe4f2106d82b7fb5573297d725a237ccc09df0eb4 62f154ec394d0bc757d045c798c8b87a00e0655d0481a7d2d9fb58d93aedc676b5a0 +5bbe6f11de358af6c933957ee0a63332f30375f669bf8efe5e7b54cad0639b42 b2dcfe9ff19e2b23ce7da2a4207d3e5ec7c6112a8a22aec9675a886378e14e5bfbad4e +9596326307dfd761d4a7c7f45ce100afd0a08953bc841874db9adbc92b43cf56 47f5697ac8c31409c0868827347a613a3562041c633cf1f1f86865a576e02835ed2c2492 +1ef40d478b8f36eb7e4db89ba5b38146061bdd8dbd1884a5a7d408497fbe9d70 512a6d292e67ecb2fe486bfe92660953a75484ff4c4f2eca2b0af0edcdd4339c6b2ee4e542 +893678504a72f95f0be0cdfe82f19a0f722ab8ebd43aaa60ed1aad4560f6b7d2 973cf2b4dcf0bfa872b41194cb05bb4e16760a1840d8343301802576197ec19e2a1493d8f4fb +8f9bc82e46327f5f6034b386932028cd575abca6cdef3b43202eeb9223ca034d 80beebcd2e3f8a9451d4499961c9731ae667cdc24ea020ce3b9aa4bbc0a7f79e30a934467da4b0 +6d703f42384d92817a2b0d02c02366d220b3b6a3174501b4c60fb7018f57c83b 7abaa12ec2a7347674e444140ae0fb659d08e1c66decd8d6eae925fa451d65f3c0308e29446b8ed3 +b0ebd02837938a1dac42e7e52c5bb28eeb53114285322778cafc0ffae16ed44a c88dee9927679b8af422abcbacf283b904ff31e1cac58c7819809f65d5807d46723b20f67ba610c2b7 +9233396287ec4e1752a5b84f7a589fd5434bea7b94d9a82d5cf3b0347f051952 01e43fe350fcec450ec9b102053e6b5d56e09896e0ddd9074fe138e6038210270c834ce6eadc2bb86bf6 +d488c5a30a1b5984e6beda0947327ac28d96572e6c80cf1c48b4fe72bdb426d5 337023370a48b62ee43546f17c4ef2bf8d7ecd1d49f90bab604b839c2e6e5bd21540d29ba27ab8e309a4b7 +5fb0d09fa9cf1ef3f8fc4db556dc37c1a0985c9a31c4f1625fe517106b9734ae 6892540f964c8c74bd2db02c0ad884510cb38afd4438af31fc912756f3efec6b32b58ebc38fc2a6b913596a8 +d9757caaa51fd67bf7424f3ffbca075e1ca4c4db1f153ddcd4236885660bc85d f5961dfd2b1ffffda4ffbf30560c165bfedab8ce0be525845deb8dc61004b7db38467205f5dcfb34a2acfe96c0 +8dd792af2bd49e05475b83e47daef37344c0157c04379eb4c8bafb0cbf3a2320 ca061a2eb6ceed8881ce2057172d869d73a1951e63d57261384b80ceb5451e77b06cf0f5a0ea15ca907ee1c27eba +7129b71d8076fd494bfe19147914a74f137513f7775a461153491315a7f25c7c 1743a77251d69242750c4f1140532cd3c33f9b5ccdf7514e8584d4a5f9fbd730bcf84d0d4726364b9bf95ab251d9bb +9aa00804e2dc87a0a3ef0fb97b1a26fe61cf7f59653ec3a2733f095c635c6b9c d8faba1f5194c4db5f176fabfff856924ef627a37cd08cf55608bba8f1e324d7c7f157298eabc4dce7d89ce5162499f9 +0a7c4721d9d36a1b0dd282247df92fbeb0a2c76f3a5e3fb285ce371c656b849f be9684be70340860373c9c482ba517e899fc81baaa12e5c6d7727975d1d41ba8bef788cdb5cf4606c9c1c7f61aed59f97d +7ab52fdb041dbb956f47a50b675b2a56e1307f8b16f5a433b61f7b0ff1bc47a9 7e15d2b9ea74ca60f66c8dfab377d9198b7b16deb6a1ba0ea3c7ee2042f89d3786e779cf053c77785aa9e692f821f14a7f51 +ce3b21beb07bf0dcf3cfc40593d62b00f71abe310d5d1a2ab0a216cdbd6bf23d 9a219be43713bd578015e9fda66c0f2d83cac563b776ab9f38f3e4f7ef229cb443304fba401efb2bdbd7ece939102298651c86 +bf6e912b292e07fe6c3475319cac095b7073f3ba46e663d0f414d537520a9d1a c8f2b693bd0d75ef99caebdc22adf4088a95a3542f637203e283bbc3268780e787d68d28cc3897452f6a22aa8573ccebf245972a +198e04c8f7f096537e49c30c1ccf365ab47a7bdbbf6c71044df44b3befbd3016 ec0f99711016c6a2a07ad80d16427506ce6f441059fd269442baaa28c6ca037b22eeac49d5d894c0bf66219f2c08e9d0e8ab21de52 +9fd4e7cb34351df38eb745f6d4d55babee1331789d9ad58343f82987709c2560 0dc45181337ca32a8222fe7a3bf42fc9f89744259cff653504d6051fe84b1a7ffd20cb47d4696ce212a686bb9be9a8ab1c697b6d6a33 +3d50b9f2e622249062cb3c51014c68a2460f69a005b2879d74a65ca41e5be204 de286ba4206e8b005714f80fb1cdfaebde91d29f84603e4a3ebc04686f99a46c9e880b96c574825582e8812a26e5a857ffc6579f63742f +dc8b0beee7f15eadb52b6279c4efc517391b5ffb378af123b166cc1183473430 eebcc18057252cbf3f9c070f1a73213356d5d4bc19ac2a411ec8cdeee7a571e2e20eaf61fd0c33a0ffeb297ddb77a97f0a415347db66bcaf +685ef958a6ff9b51bdc5809e635e94c91821328b1dd6ada0eb89e04bce130ca7 416b5cdc9fe951bd361bd7abfc120a5054758eba88fdd68fd84e39d3b09ac25497d36b43cbe7b85a6a3cebda8db4e5549c3ee51bb6fcb6ac1e +8561f50711ed53de42ba090a3cdccad3e5045dafe570dcd9f42cbaaff7fc61a4 5c5faf66f32e0f8311c32e8da8284a4ed60891a5a7e50fb2956b3cbaa79fc66ca376460e100415401fc2b8518c64502f187ea14bfc9503759705 +16d693bae055dce82d1232aabcf24f2712808de692a00ce40cd9d7f3901fa56f 7167e1e02be1a7ca69d788666f823ae4eef39271f3c26a5cf7cee05bca83161066dc2e217b330df821103799df6d74810eed363adc4ab99f36046a +546b7b2c682c3dff30f20682dde460ef046446ef7dd79f185502eb04a37e38ec 2fda311dbba27321c5329510fae6948f03210b76d43e7448d1689a063877b6d14c4f6d0eaa96c150051371f7dd8a4119f7da5c483cc3e6723c01fb7d +3848f720850d26fdcffa920f9ca661df834966a562718109c3625eef0fb5f02e 95d1474a5aab5d2422aca6e481187833a6212bd2d0f91451a67dd786dfc91dfed51b35f47e1deb8a8ab4b9cb67b70179cc26f553ae7b569969ce151b8d +6ccd55e13af5b1c470e1462b831c52560ac6b77e705ec649953be8bc11fa035f c71bd7941f41df044a2927a8ff55b4b467c33d089f0988aa253d294addbdb32530c0d4208b10d9959823f0c0f0734684006df79f7099870f6bf53211a88d +98f236f14420fa4d6d7187d429f446b28a82c359e7d0ff59d0efc983bb224ad9 f57c64006d9ea761892e145c99df1b24640883da79d9ed5262859dcda8c3c32e05b03d984f1ab4a230242ab6b78d368dc5aaa1e6d3498d53371e84b0c1d4ba +9d35c0cc1880a36ebb6cb33b732c0c2adb4a418b4bf0df9173b539263653e90b e926ae8b0af6e53176dbffcc2a6b88c6bd765f939d3d178a9bde9ef3aa131c61e31c1e42cdfaf4b4dcde579a37e150efbef5555b4c1cb40439d835a724e2fae7 +334f80e3a32b128528267a1541821dda9ea69199ce506f6e88dcbf35ebb80f4e 16e8b3d8f988e9bb04de9c96f2627811c973ce4a5296b4772ca3eefeb80a652bdf21f50df79f32db23f9f73d393b2d57d9a0297f7a2f2e79cfda39fa393df1ac00 +a53f4100b48236169225d91fba3f2798e268ddd7fc821d2d76e3e911ca4cb262 fc424eeb27c18a11c01f39c555d8b78a805b88dba1dc2a42ed5e2c0ec737ff68b2456d80eb85e11714fa3f8eabfb906d3c17964cb4f5e76b29c1765db03d91be37fc +668125889c33c5f3d0d32e455a9289fc0d2b0da1230db74a5627cda76cef3183 abe3472b54e72734bdba7d9158736464251c4f21b33fbbc92d7fac9a35c4e3322ff01d2380cbaa4ef8fb07d21a2128b7b9f5b6d9f34e13f39c7ffc2e72e47888599ba5 +d1fcaddd0cd76d95c94f6a79c56bf1932d39e604c6eaba0339fefa53e23059f1 36f9f0a65f2ca498d739b944d6eff3da5ebba57e7d9c41598a2b0e4380f3cf4b479ec2348d015ffe6256273511154afcf3b4b4bf09d6c4744fdd0f62d75079d440706b05 +6d0f92f6e5447a8ab2a9eb104fc9102e292d60ad5af8524e1ec67f6007af09cb abc87763cae1ca98bd8c5b82caba54ac83286f87e9610128ae4de68ac95df5e329c360717bd349f26b872528492ca7c94c2c1e1ef56b74dbb65c2ac351981fdb31d06c77a4 +e75aa79324322fb0b4b6dcadb93ff9f31f3abcc0d147e8e3b4e1a9d49faa0ed4 94f7ca8e1a54234c6d53cc734bb3d3150c8ba8c5f880eab8d25fed13793a9701ebe320509286fd8e422e931d99c98da4df7e70ae447bab8cffd92382d8a77760a259fc4fbd72 +e0883b334c203195ef6f8c871beb1ecad66ba0415f1b40221e1cb1869b2d3c2e 13bd2811f6ed2b6f04ff3895aceed7bef8dcd45eb121791bc194a0f806206bffc3b9281c2b308b1a729ce008119dd3066e9378acdcc50a98a82e20738800b6cddbe5fe9694ad6d +a07496d03fe16e4e3602d7b613b38fde460fb96e20fcfdc01d5cb6663bab348f 1eed9cba179a009ec2ec5508773dd305477ca117e6d569e66b5f64c6bc64801ce25a8424ce4a26d575b8a6fb10ead3fd1992edddeec2ebe7150dc98f63adc3237ef57b91397aa8a7 +c418fed5573aa06d70df160755da83a3dc3ef605d32d579d8bc3a16653ca31e7 ba5b67b5ec3a3ffae2c19dd8176a2ef75c0cd903725d45c9cb7009a900c0b0ca7a2967a95ae68269a6dbf8466c7b6844a1d608ac661f7eff00538e323db5f2c644b78b2d48de1a08aa +a2ea41790c0082e5b3257d5d001114cd4f243266b7c2f5a9b860b026ae247c92 0efa26ac5673167dcacab860932ed612f65ff49b80fa9ae65465e5542cb62075df1c5ae54fba4db807be25b070033efa223bdd5b1d3c94c6e1909c02b620d4b1b3a6c9fed24d70749604 +cb317f4a8aa0df86c8fe2fb10ca76d7e92d7cdd13cd0132261e02f736bfa7c45 bbfd933d1fd7bf594ac7f435277dc17d8d5a5b8e4d13d96d2f64e771abbd51a5a8aea741beccbddb177bcea05243ebd003cfdeae877cca4da94605b67691919d8b033f77d384ca01593c1b +67d16d0c9798988ccd45fd4491c2ff70b509ccf6893917b7eefb8dcee1dd0ff6 90078999fd3c35b8afbf4066cbde335891365f0fc75c1286cdd88fa51fab94f9b8def7c9ac582a5dbcd95817afb7d1b48f63704e19c2baa4df347f48d4a6d603013c23f1e9611d595ebac37c +aef7000049b7339eaa043eba476fe3d7c83fa12bd3a6f300ebef798319c4dfcb 64105eca863515c20e7cfbaa0a0b8809046164f374d691cdbd6508aaabc1819f9ac84b52bafc1b0fe7cddbc554b608c01c8904c669d8db316a0953a4c68ece324ec5a49ffdb59a1bd6a292aa0e +df66ed821793c5598e3ece3b43e22f642d8ad9ae4abcbd3b201da8fbec5fb162 d4654be288b9f3b711c2d02015978a8cc57471d5680a092aa534f7372c71ceaab725a383c4fcf4d8deaa57fca3ce056f312961eccf9b86f14981ba5bed6ab5b4498e1f6c82c6cae6fc14845b3c8a +0bc6f4eb2e00750d5bd4849c9cb28c1f87a31297b8521d895e9a2cec999223de 12d9394888305ac96e65f2bf0e1b18c29c90fe9d714dd59f651f52b88b3008c588435548066ea2fc4c101118c91f32556224a540de6efddbca296ef1fb00341f5b01fecfc146bdb251b3bdad556cd2 +72b273d738749a57c29b8c2614e07f1c0cd68eb02256679e4958a23dd326f0f5 871a0d7a5f36c3da1dfce57acd8ab8487c274fad336bc137ebd6ff4658b547c1dcfab65f037aa58f35ef16aff4abe77ba61f65826f7be681b5b6d5a1ea8085e2ae9cd5cf0991878a311b549a6d6af230 +817a562a819f2281fd28452177da3e6e4f367a2ccb946fb76189f2c45fc6b0b6 e90b4ffef4d457bc7711ff4aa72231ca25af6b2e206f8bf859d8758b89a7cd36105db2538d06da83bad5f663ba11a5f6f61f236fd5f8d53c5e89f183a3cec615b50c7c681e773d109ff7491b5cc22296c5 +5fe885424326ef838cb2d2f39f04c749c2df4a544bf6a7bfabb4ab4413bd1146 e728de62d75856500c4c77a428612cd804f30c3f10d36fb219c5ca0aa30726ab190e5f3f279e0733d77e7267c17be27d21650a9a4d1e32f649627638dbada9702c7ca303269ed14014b2f3cf8b894eac8554 +ec05d5d6f15821bf0e191fcdd1bc9a7736ef008deac2ef71690d5958d4cdddbb 6348f229e7b1df3b770c77544e5166e081850fa1c6c88169db74c76e42eb983facb276ad6a0d1fa7b50d3e3b6fcd799ec97470920a7abed47d288ff883e24ca21c7f8016b93bb9b9e078bdb9703d2b781b616e +c304220fec9bd282a09aca91c14fa97acf3013d2a87aeeb902b1517b183e9b72 4b127fde5de733a1680c2790363627e63ac8a3f1b4707d982caea258655d9bf18f89afe54127482ba01e08845594b671306a025c9a5c5b6f93b0a39522dc877437be5c2436cbf300ce7ab6747934fcfc30aeaaf6 +ca50b1215a128d529030bdf2f56aa661c14599e1724653fde6fde9e2cbc0e408 08461f006cff4cc64b752c957287e5a0faabc05c9bff89d23fd902d324c79903b48fcb8f8f4b01f3e4ddb483593d25f000386698f5ade7faade9615fdc50d32785ea51d49894e45baa3dc707e224688c6408b68b11 +dbb17bb0a74f953f9c6f01d8401d1945792314dd03c9500b8cbb4bb04c74ee47 68c8f8849b120e6e0c9969a5866af591a829b92f33cd9a4a3196957a148c49138e1e2f5c7619a6d5edebe995acd81ec8bb9c7b9cfca678d081ea9e25a75d39db04e18d475920ce828b94e72241f24db72546b352a0e4 +ea7417e2ffcf2c83785b831f62cd0899a4d055b7d789a679361ba368882edd44 b8d56472954e31fb54e28fca743f84d8dc34891cb564c64b08f7b71636debd64ca1edbdba7fc5c3e40049ce982bba8c7e0703034e331384695e9de76b5104f2fbc4535ecbeebc33bc27f29f18f6f27e8023b0fbb6f563c +f99d9700a0fd6971b63b04a50fd7da80bd93159fa56854c09f8049badc317ced 0d58ac665fa84342e60cefee31b1a4eacdb092f122dfc68309077aed1f3e528f578859ee9e4cefb4a728e946324927b675cd4f4ac84f64db3dacfe850c1dd18744c74ceccd9fe4dc214085108f404eab6d8f452b5442a47d +224ba3a4fe567db31c51fd1656ce153c1faf8b7eb9252ee7223f4fe3f14d4cd8 1755e2d2e5d1c1b0156456b539753ff416651d44698e87002dcf61dcfa2b4e72f264d9ad591df1fdee7b41b2eb00283c5aebb3411323b672eaa145c5125185104f20f335804b02325b6dea65603f349f4d5d8b782dd3469ccd +9d519db96ec633539db906b888ea771cef06583d1503b7d5d788c5f59aa41ec5 b180de1a611111ee7584ba2c4b020598cd574ac77e404e853d15a101c6f5a2e5c801d7d85dc95286a1804c870bb9f00fd4dcb03aa8328275158819dcad7253f3e3d237aeaa7979268a5db1c6ce08a9ec7c2579783c8afc1f91a7 +03e5486053682b6d5e3e877ef9d0018956c0955dde4b9cfe88cfa80e626c5c58 cf3583cbdfd4cbc17063b1e7d90b02f0e6e2ee05f99d77e24e560392535e47e05077157f96813544a17046914f9efb64762a23cf7a49fe52a0a4c01c630cfe8727b81fb99a89ff7cc11dca5173057e0417b8fe7a9efba6d95c555f +17f0aee3de8c230a3481eeec2b213d87c5836affc9c1cdf80acb16e29a996fb7 072fc02340ef99115bad72f92c01e4c093b9599f6cfc45cb380ee686cb5eb019e806ab9bd55e634ab10aa62a9510cc0672cd3eddb589c7df2b67fcd3329f61b1a4441eca87a33c8f55da4fbbad5cf2b2527b8e983bb31a2fadec7523 +9e55bf83241005c70b51831d50a444a6cad4d329e2b212d2edb0ea248ee37faf 76eecf956a52649f877528146de33df249cd800e21830f65e90f0f25ca9d6540fde40603230eca6760f1139c7f268deba2060631eea92b1fff05f93fd5572fbe29579ecd48bc3a8d6c2eb4a6b26e38d6c5fbf2c08044aeea470a8f2f26 +4e4298644eed194486aa42d200402d28e3720d578e907a55f9bf371fc7e7e7c0 7adc0b6693e61c269f278e6944a5a2d8300981e40022f839ac644387bfac9086650085c2cdc585fea47b9d2e52d65a2b29a7dc370401ef5d60dd0d21f9e2b90fae919319b14b8c5565b0423cefb827d5f1203302a9d01523498a4db10374 +dccf057f6739095b68b8f27ec21c5c920b544e79ea6a692d8d576f4def16f3fd e1fffa9826cce8b86bccefb8794e48c46cdf372013f782eced1e378269b7be2b7bf51374092261ae120e822be685f2e7a83664bcfbe38fe8633f24e633ffe1988e1bc5acf59a587079a57a910bda60060e85b5f5b6f776f0529639d9cce4bd +a8640e72d80b75523acef56f9598e39124dbfc7376c7e66c4850c845fb0720fe 69f9abba65592ee01db4dce52dbab90b08fc04193602792ee4daa263033d59081587b09bbe49d0b49c9825d22840b2ff5d9c5155f975f8f2c2e7a90c75d2e4a8040fe39f63bbafb403d9e28cc3b86e04e394a9c9e8065bd3c85fa9f0c7891600 +9e3d5a2050d370c83410db134cbf3f8da5a7074a2d80ce3e5428ead49445cc7e 38a10a352ca5aedfa8e19c64787d8e9c3a75dbf3b8674bfab29b5dbfc15a63d10fae66cd1a6e6d2452d557967eaad89a4c98449787b0b3164ca5b717a93f24eb0b506ceb70cbbcb8d72b2a72993f909aad92f044e0b5a2c9ac9cb16a0ca2f81f49 +d13c894171f3b046180eb2fcc5f5f198398a2a159293cbe71338a2743a5bf127 6d8c6e449bc13634f115749c248c17cd148b72157a2c37bf8969ea83b4d6ba8c0ee2711c28ee11495f43049596520ce436004b026b6c1f7292b9c436b055cbb72d530d860d1276a1502a5140e3c3f54a93663e4d20edec32d284e25564f624955b52 +0c9246a07b1dab880b8f6e1676d28a659c4fc6d3985fa46093cae71e70b42295 6efcbcaf451c129dbe00b9cef0c3749d3ee9d41c7bd500ade40cdc65dedbbbadb885a5b14b32a0c0d087825201e303288a733842fa7e599c0c514e078f05c821c7a4498b01c40032e9f1872a1c925fa17ce253e8935e4c3c71282242cb716b2089ccc1 +caed3eebc63fd905c53ac8c46397d60334cb55f5691b9ef4f73ef1352c343bc7 433c5303131624c0021d868a30825475e8d0bd3052a022180398f4ca4423b98214b6beaac21c8807a2c33f8c93bd42b092cc1b06cedf3224d5ed1ec29784444f22e08a55aa58542b524b02cd3d5d5f6907afe71c5d7462224a3f9d9e53e7e0846dcbb4ce +d0dcfd7d640800b8f6959e1300863a69988024bc5e20d4bc999ae381a74f1362 a873e0c67ca639026b6683008f7aa6324d4979550e9bce064ca1e1fb97a30b147a24f3f666c0a72d71348ede701cf2d17e2253c34d1ec3b647dbcef2f879f4eb881c4830b791378c901eb725ea5c172316c6d606e0af7df4df7f76e490cd30b2badf45685f +5394a1398c700ce06e059c97a1cef8ca04e40e3f43494eb00628fa404ae0a4db 006917b64f9dcdf1d2d87c8a6173b64f6587168e80faa80f82d84f60301e561e312d9fbce62f39a6fb476e01e925f26bcc91de621449be6504c504830aae394096c8fc7694651051365d4ee9070101ec9b68086f2ea8f8ab7b811ea8ad934d5c9b62c60a4771 +dc2e91487a97fa440ab66cba71116038c4767e494e7559c176ca8db94da64957 f13c972c52cb3cc4a4df28c97f2df11ce089b815466be88863243eb318c2adb1a417cb1041308598541720197b9b1cb5ba2318bd5574d1df2174af14884149ba9b2f446d609df240ce335599957b8ec80876d9a085ae084907bc5961b20bf5f6ca58d5dab38adb +07fd71e0246db1e2734000fc3435a0d44fdf8a99634efa3928734df969a5d338 e35780eb9799ad4c77535d4ddb683cf33ef367715327cf4c4a58ed9cbdcdd486f669f80189d549a9364fa82a51a52654ec721bb3aab95dceb4a86a6afa93826db923517e928f33e3fba850d45660ef83b9876accafa2a9987a254b137c6e140a21691e1069413848 +5a9bd4bc4556bdd4553b117b5d66a0e3df0a79d402502bbfda1c6e65ee277ab8 64ec021c9585e01ffe6d31bb50d44c79b6993d72678163db474947a053674619d158016adb243f5c8d50aa92f50ab36e579ff2dabb780a2b529370daa299207cfbcdd3a9a25006d19c4f1fe33e4b1eaec315d8c6ee1e730623fd1941875b924eb57d6d0c2edc4e78d6 +f9a64e45fe4ef9eab2c1da249dc35872e8dfbcc9a1094bd12547d06d70496521 5954bab512cf327d66b5d9f296180080402624ad7628506b555eea8382562324cf452fba4a2130de3e165d11831a270d9cb97ce8c2d32a96f50d71600bb4ca268cf98e90d6496b0a6619a5a8c63db6d8a0634dfc6c7ec8ea9c006b6c456f1b20cd19e781af20454ac880 +341c440fb9ae4d56227260869617786b31d245b999ca1403b6a157dbbe6e46ce 03d9f92b2c565709a568724a0aff90f8f347f43b02338f94a03ed32e6f33666ff5802da4c81bdce0d0e86c04afd4edc2fc8b4141c2975b6f07639b1994c973d9a9afce3d9d365862003498513bfa166d2629e314d97441667b007414e739d7febf0fe3c32c17aa188a8683 +0ccafa7034c59672141f381b28dc38cfdb052dd1d66cf7a44e6752946e9c715a f31e8b4f9e0621d531d22a380be5d9abd56faec53cbd39b1fab230ea67184440e5b1d15457bd25f56204fa917fa48e669016cb48c1ffc1e1e45274b3b47379e00a43843cf8601a5551411ec12503e5aac43d8676a1b2297ec7a0800dbfee04292e937f21c005f17411473041 +4249e539e3550d048cdefbaeafd249d70c644d70c4382967a0bdaf4f22a57bcf 758ea3fea738973db0b8be7e599bbef4519373d6e6dcd7195ea885fc991d896762992759c2a09002912fb08e0cb5b76f49162aeb8cf87b172cf3ad190253df612f77b1f0c532e3b5fc99c2d31f8f65011695a087a35ee4eee5e334c369d8ee5d29f695815d866da99df3f79403 +15c7a76c80987191b10d8426dfe5d7839757c8479fe821c980e46021a48c8fbd 47c6e0c2b74948465921868804f0f7bd50dd323583dc784f998a93cd1ca4c6ef84d41dc81c2c40f34b5bee6a93867b3bdba0052c5f59e6f3657918c382e771d33109122cc8bb0e1e53c4e3d13b43ce44970f5e0c079d2ad7d7a3549cd75760c21bb15b447589e86e8d76b1e9ced2 +f01429d4c048fa93d38c1679a1012ab57511fb8d7d6cac6eb2df6b82baf7397d f690a132ab46b28edfa6479283d6444e371c6459108afd9c35dbd235e0b6b6ff4c4ea58e7554bd002460433b2164ca51e868f7947d7d7a0d792e4abf0be5f450853cc40d85485b2b8857ea31b5ea6e4ccfa2f3a7ef3380066d7d8979fdac618aad3d7e886dea4f005ae4ad05e5065f +aa58c9a9e5ff59945ed59c68a20d8cbaeedc184bdf1b878fa5c0e3bd185d9c21 58d6a99bc6458824b256916770a8417040721cccfd4b79eacd8b65a3767ce5ba7e74104c985ac56b8cc9aebd16febd4cda5adb130b0ff2329cc8d611eb14dac268a2f9e633c99de33997fea41c52a7c5e1317d5b5daed35eba7d5a60e45d1fa7eaabc35f5c2b0a0f2379231953322c4e +5362685d62db37a31cd0d7707579eb8df5b0b2574b10b5f52cdbd6ac75caa53b befab574396d7f8b6705e2d5b58b2c1c820bb24e3f4bae3e8fbcd36dbf734ee14e5d6ab972aedd3540235466e825850ee4c512ea9795abfd33f330d9fd7f79e62bbb63a6ea85de15beaeea6f8d204a28956059e2632d11861dfb0e65bc07ac8a159388d5c3277e227286f65ff5e5b5aec1 +9063dfcac98677dfc73f12c2ca2bed41da4c5c1e923b383e2506ff2c8a83290b 8e58144fa9179d686478622ce450c748260c95d1ba43b8f9b59abeca8d93488da73463ef40198b4d16fb0b0707201347e0506ff19d01bea0f42b8af9e71a1f1bd168781069d4d338fdef00bf419fbb003031df671f4a37979564f69282de9c65407847dd0da505ab1641c02dea4f0d834986 +85e8f8371d7efb72142d7fbe7e1d9d8ce5f0fe0b0d5165b8a7528cd9a006d65a b55c10eae0ec684c16d13463f29291bf26c82e2fa0422a99c71db4af14dd9c7f33eda52fd73d017cc0f2dbe734d831f0d820d06d5f89dacc485739144f8cfd4799223b1aff9031a105cb6a029ba71e6e5867d85a554991c38df3c9ef8c1e1e9a7630be61caabca69280c399c1fb7a12d12aefc +a127760fc4d2df02b3ed57a33e664cdcc51d42e4b072b438d3d00e1881fc0811 2eeea693f585f4ed6f6f8865bbae47a6908aecd7c429e4bec4f0de1d0ca0183fa201a0cb14a529b7d7ac0e6ff6607a3243ee9fb11bcf3e2304fe75ffcddd6c5c2e2a4cd45f63c962d010645058d36571404a6d2b4f44755434d76998e83409c3205aa1615db44057db991231d2cb42624574f545 +1b9fd52389e52bb3d3eb436a362a2bb69f72ff5c7a96ce0c134504a3840f51e2 dab11dc0b047db0420a585f56c42d93175562852428499f66a0db811fcdddab2f7cdffed1543e5fb72110b64686bc7b6887a538ad44c050f1e42631bc4ec8a9f2a047163d822a38989ee4aab01b4c1f161b062d873b1cfa388fd301514f62224157b9bef423c7783b7aac8d30d65cd1bba8d689c2d +362e7dcee131391702a9741c51d4604474a347245885d84516e1744743356129 42e99a2f80aee0e001279a2434f731e01d34a44b1a8101726921c0590c30f3120eb83059f325e894a5ac959dca71ce2214799916424e859d27d789437b9d27240bf8c35adbafcecc322b48aa205b293962d858652abacbd588bcf6cbc388d0993bd622f96ed54614c25b6a9aa527589eaaffcf17ddf7 +6a9d6fe70214225050779c1505639b0c342ee0bdce26dc7cf5d2fed1b952d2b2 3c9b46450c0f2cae8e3823f8bdb4277f31b744ce2eb17054bddc6dff36af7f49fb8a2320cc3bdf8e0a2ea29ad3a55de1165d219adeddb5175253e2d1489e9b6fdd02e2c3d3a4b54d60e3a47334c37913c5695378a669e9b72dec32af5434f93f46176ebf044c4784467c700470d0c0b40c8a088c815816 +ae80210494b265dc4daecd8d7c1e81148c86db3664fa5420386f0d7653cb569a d1e654b77cb155f5c77971a64df9e5d34c26a3cad6c7f6b300d39deb1910094691adaa095be4ba5d86690a976428635d5526f3e946f7dc3bd4dbc78999e653441187a81f9adcd5a3c5f254bc8256b0158f54673dcc1232f6e918ebfc6c51ce67eaeb042d9f57eec4bfe910e169af78b3de48d137df4f2840 +7d20748fbd82fcdfa67c1847adf9f129079cb3fdf9a93d94b3e24b9ad30a2164 626f68c18a69a6590159a9c46be03d5965698f2dac3de779b878b3d9c421e0f21b955a16c715c1ec1e22ce3eb645b8b4f263f60660ea3028981eebd6c8c3a367285b691c8ee56944a7cd1217997e1d9c21620b536bdbd5de8925ff71dec6fbc06624ab6b21e329813de90d1e572dfb89a18120c3f606355d25 +7f19f0d6de07aa293f88b25be32eb55c84929ba0b55906111ab3d0f74976d0a7 651a6fb3c4b80c7c68c6011675e6094eb56abf5fc3057324ebc6477825061f9f27e7a94633abd1fa598a746e4a577caf524c52ec1788471f92b8c37f23795ca19d559d446cab16cbcdce90b79fa1026cee77bf4ab1b503c5b94c2256ad75b3eac6fd5dcb96aca4b03a834bfb4e9af988cecbf2ae597cb9097940 +25b628f9c1a65c56ed012faa270096cecab4b86d2cd40d558ce76bbb76d91fa3 8aaf072fce8a2d96bc10b3c91c809ee93072fb205ca7f10abd82ecd82cf040b1bc49ea13d1857815c0e99781de3adbb5443ce1c897e55188ceaf221aa9681638de05ae1b322938f46bce51543b57ecdb4c266272259d1798de13be90e10efec2d07484d9b21a3870e2aa9e06c21aa2d0c9cf420080a80a91dee16f +c0d7efb2f3ecbf539bd7990da1faa9ea03017571000acfb18a24a317c9ca2789 53f918fd00b1701bd504f8cdea803acca21ac18c564ab90c2a17da592c7d69688f6580575395551e8cd33e0fef08ca6ed4588d4d140b3e44c032355df1c531564d7f4835753344345a6781e11cd5e095b73df5f82c8ae3ad00877936896671e947cc52e2b29dcd463d90a0c9929128da222b5a211450bbc0e02448e2 +190c6626a6b14eed1fb15c804651b39d33cb8566e8c904f91d172ff3bbffac7c a64599b8a61b5ccec9e67aed69447459c8da3d1ec6c7c7c82a7428b9b584fa67e90f68e2c00fbbed4613666e5168da4a16f395f7a3c3832b3b134bfc9cbaa95d2a0fe252f44ac6681eb6d40ab91c1d0282fed6701c57463d3c5f2bb8c6a7301fb4576aa3b5f15510db8956ff77478c26a7c09bea7b398cfc83503f538e +95f96213c2f7237a20c97a3f85eda1c9ba0257a52e0b6646bddcdfcd3d5548bf 0e3ab0e054739b00cdb6a87bd12cae024b54cb5e550e6c425360c2e87e59401f5ec24ef0314855f0f56c47695d56a7fb1417693af2a1ed5291f2fee95f75eed54a1b1c2e81226fbff6f63ade584911c71967a8eb70933bc3f5d15bc91b5c2644d9516d3c3a8c154ee48e118bd1442c043c7a0dba5ac5b1d5360aae5b9065 +7ff3cf7b9a468cfb581a5bd21cc68ff0c3ef3fcfe2a63bd68e9b3934e0ffd488 a62fc595b4096e6336e53fcdfc8d1cc175d71dac9d750a6133d23199eaac288207944cea6b16d27631915b4619f743da2e30a0c00bbdb1bbb35ab852ef3b9aec6b0a8dcc6e9e1abaa3ad62ac0a6c5de765de2c3711b769e3fde44a74016fff82ac46fa8f1797d3b2a726b696e3dea5530439acee3a45c2a51bc32dd055650b +43b7d01d93213874b2ac0792bed8c137e865ba5fa87b20a3151a984f4af267a6 2b6db7ced8665ebe9deb080295218426bdaa7c6da9add2088932cdffbaa1c14129bccdd70f369efb149285858d2b1d155d14de2fdb680a8b027284055182a0cae275234cc9c92863c1b4ab66f304cf0621cd54565f5bff461d3b461bd40df28198e3732501b4860eadd503d26d6e69338f4e0456e9e9baf3d827ae685fb1d817 +68a86305ba645c8c2590290db45a3f297bdec0e390546376c8759ffa19bbbd1a 10db509b2cdcaba6c062ae33be48116a29eb18e390e1bbada5ca0a2718afbcd23431440106594893043cc7f2625281bf7de2655880966a23705f0c5155c2f5cca9f2c2142e96d0a2e763b70686cd421b5db812daced0c6d65035fde558e94f26b3e6dde5bd13980cc80292b723013bd033284584bff27657871b0cf07a849f4ae2 +1b0b5fbcc9653633a2ea365f84ba8a12cb015c0da3a986f33fce266a69ede97e 9334de60c997bda6086101a6314f64e4458f5ff9450c509df006e8c547983c651ca97879175aaba0c539e82d05c1e02c480975cbb30118121061b1ebac4f8d9a3781e2db6b18042e01ecf9017a64a0e57447ec7fcbe6a7f82585f7403ee2223d52d37b4bf426428613d6b4257980972a0acab508a7620c1cb28eb4e9d30fc41361ec +bdf14eda1e3f445d4610d8ac00cd5ae2b61f6a4a4efda7d767c21943ec3eea50 e88ab086891693aa535ceb20e64c7ab97c7dd3548f3786339897a5f0c39031549ca870166e477743ccfbe016b4428d89738e426f5ffe81626137f17aecff61b72dbee2dc20961880cfe281dfab5ee38b1921881450e16032de5e4d55ad8d4fca609721b0692bac79be5a06e177fe8c80c0c83519fb3347de9f43d5561cb8107b9b5edc +cbb83c515338dfd08d456c56258efd78cc2d0031d27acd672dafbfb57007e88f fd19e01a83eb6ec810b94582cb8fbfa2fcb992b53684fb748d2264f020d3b960cb1d6b8c348c2b54a9fcea72330c2aaa9a24ecdb00c436abc702361a82bb8828b85369b8c72ece0082fe06557163899c2a0efa466c33c04343a839417057399a63a3929be1ee4805d6ce3e5d0d0967fe9004696a5663f4cac9179006a2ceb75542d75d68 +a2e65aef150c1a095cc247daf79c2cc4703b30643329ddf109e436db91501aed 59ae20b6f7e0b3c7a989afb28324a40fca25d8651cf1f46ae383ef6d8441587aa1c04c3e3bf88e8131ce6145cfb8973d961e8432b202fa5af3e09d625faad825bc19da9b5c6c20d02abda2fcc58b5bd3fe507bf201263f30543819510c12bc23e2ddb4f711d087a86edb1b355313363a2de996b891025e147036087401ccf3ca7815bf3c49 +da93492a0437f372d75855d37103fb8b8ef81abd9e11b3625535e0004ce1741a 77ee804b9f3295ab2362798b72b0a1b2d3291dceb8139896355830f34b3b328561531f8079b79a6e9980705150866402fdc176c05897e359a6cb1a7ab067383eb497182a7e5aef7038e4c96d133b2782917417e391535b5e1b51f47d8ed7e4d4025fe98dc87b9c1622614bff3d1029e68e372de719803857ca52067cddaad958951cb2068cc6 +7e2cd8c54c6ba2995a3c97e606156df1d153ad1105ee28fda3b7661f102c0e97 b771d5cef5d1a41a93d15643d7181d2a2ef0a8e84d91812f20ed21f147bef732bf3a60ef4067c3734b85bc8cd471780f10dc9e8291b58339a677b960218f71e793f2797aea349406512829065d37bb55ea796fa4f56fd8896b49b2cd19b43215ad967c712b24e5032d065232e02c127409d2ed4146b9d75d763d52db98d949d3b0fed6a8052fbb +0c7e1ae54559b2197825b074149e2ad0a959ff5fb10f6954f8e0801bd04847f4 b32d95b0b9aad2a8816de6d06d1f86008505bd8c14124f6e9a163b5a2ade55f835d0ec3880ef50700d3b25e42cc0af050ccd1be5e555b23087e04d7bf9813622780c7313a1954f8740b6ee2d3f71f768dd417f520482bd3a08d4f222b4ee9dbd015447b33507dd50f3ab4247c5de9a8abd62a8decea01e3b87c8b927f5b08beb37674c6f8e380c04 +a6859618a64ae9ca4750eb2d7e7495a386a0e6631ee983df28cad32f52293a5c 04410e31082a47584b406f051398a6abe74e4da59bb6f85e6b49e8a1f7f2ca00dfba5462c2cd2bfde8b64fb21d70c083f11318b56a52d03b81cac5eec29eb31bd0078b6156786da3d6d8c33098c5c47bb67ac64db14165af65b44544d806dde5f487d5373c7f9792c299e9686b7e5821e7c8e2458315b996b5677d926dac57b3f22da873c601016a0d +1103957a14a32c61ea2c0cb4568bf8b9fdc73b4c0c4010e18993eba5dc737d17 8b81e9badde026f14d95c019977024c9e13db7a5cd21f9e9fc491d716164bbacdc7060d882615d411438aea056c340cdf977788f6e17d118de55026855f93270472d1fd18b9e7e812bae107e0dfde7063301b71f6cfe4e225cab3b232905a56e994f08ee2891ba922d49c3dafeb75f7c69750cb67d822c96176c46bd8a29f1701373fb09a1a6e3c7158f +40223098a1806e9620e0a709e8dd6e276f76a707ba3c390e7f35937ac43fa5e6 fa6eed24da6666a22208146b19a532c2ec9ba94f09f1def1e7fc13c399a48e41acc2a589d099276296348f396253b57cb0e40291bd282773656b6e0d8bea1cda084a3738816a840485fcf3fb307f777fa5feac48695c2af4769720258c77943fb4556c362d9cba8bf103aeb9034baa8ea8bfb9c4f8e6742ce0d52c49ea8e974f339612e830e9e7a9c29065 +3d7d818b755abe6d7bef29ae81b40cc6ea5f000b64a258f2c36fa3ac879a8419 9bb4af1b4f09c071ce3cafa92e4eb73ce8a6f5d82a85733440368dee4eb1cbc7b55ac150773b6fe47dbe036c45582ed67e23f4c74585dab509df1b83610564545642b2b1ec463e18048fc23477c6b2aa035594ecd33791af6af4cbc2a1166aba8d628c57e707f0b0e8707caf91cd44bdb915e0296e0190d56d33d8dde10b5b60377838973c1d943c22ed335e +80f7256772607d1cd9ed488a2021dd26e98c67efd235879b2e95522d0814302b 2167f02118cc62043e9091a647cadbed95611a521fe0d64e8518f16c808ab297725598ae296880a773607a798f7c3cfce80d251ebec6885015f9abf7eaabae46798f82cb5926de5c23f44a3f9f9534b3c6f405b5364c2f8a8bdc5ca49c749bed8ce4ba48897062ae8424ca6dde5f55c0e42a95d1e292ca54fb46a84fbc9cd87f2d0c9e7448de3043ae22fdd229 +bb6d2a234b435b304676958ad4b36551d68fafc3fbbc03db4171388736a3c0ce 94b7fa0bc1c44e949b1d7617d31b4720cbe7ca57c6fa4f4094d4761567e389ecc64f6968e4064df70df836a47d0c713336b5028b35930d29eb7a7f9a5af9ad5cf441745baec9bb014ceeff5a41ba5c1ce085feb980bab9cf79f2158e03ef7e63e29c38d7816a84d4f71e0f548b7fc316085ae38a060ff9b8dec36f91ad9ebc0a5b6c338cbb8f6659d342a24368cf +8516cbb22eb0bbf28324c6eee6da5512140e14f2000b8020ca7fac4fe3aae94f ea40e83cb18b3a242c1ecc6ccd0b7853a439dab2c569cfc6dc38a19f5c90acbf76aef9ea3742ff3b54ef7d36eb7ce4ff1c9ab3bc119cff6be93c03e208783335c0ab8137be5b10cdc66ff3f89a1bddc6a1eed74f504cbe7290690bb295a872b9e3fe2cee9e6c67c41db8efd7d863cf10f840fe618e7936da3dca5ca6df933f24f6954ba0801a1294cd8d7e66dfafec +ccf24ad8595f8fe0caddd2f9881da9477e2b00ec64ca1c4617637477ebb9c288 157d5b7e4507f66d9a267476d33831e7bb768d4d04cc3438da12f9010263ea5fcafbde2579db2f6b58f911d593d5f79fb05fe3596e3fa80ff2f761d1b0e57080055c118c53e53cdb63055261d7c9b2b39bd90acc32520cbbdbda2c4fd8856dbcee173132a2679198daf83007a9b5c51511ae49766c792a29520388444ebefe28256fb33d4260439cba73a9479ee00c63 +cb71496e542430b457d2b49310852d527215a35cbe866b5ca03df3e21973ea40 836b34b515476f613fe447a4e0c3f3b8f20910ac89a3977055c960d2d5d2b72bd8acc715a9035321b86703a411dde0466d58a59769672aa60ad587b8481de4bba552a1645779789501ec53d540b904821f32b0bd1855b04e4848f9f8cfe9ebd8911be95781a759d7ad9724a7102dbe576776b7c632bc39b9b5e19057e226552a5994c1dbb3b5c7871a11f5537011044c53 +d8fe4fc29c6e60d02231d0ccdaab86e927c48f025f354dc175898680a4b543e7 cc7784a4912a7ab5ad3620aab29ba87077cd3cb83636adc9f3dc94f51edf521b2161ef108f21a0a298557981c0e53ce6ced45bdf782c1ef200d29bab81dd6460586964edab7cebdbbec75fd7925060f7da2b853b2b089588fa0f8c16ec6498b14c55dcee335cb3a91d698e4d393ab8e8eac0825f8adebeee196df41205c011674e53426caa453f8de1cbb57932b0b741d4c6 +a91b97a04e638ee717400ad13606148d26c16e524828a623c3e34f3b39892d7e 7639b461fff270b2455ac1d1afce782944aea5e9087eb4a39eb96bb5c3baaf0e868c8526d3404f9405e79e77bfac5ffb89bf1957b523e17d341d7323c302ea7083872dd5e8705694acdda36d5a1b895aaa16eca6104c82688532c8bfe1790b5dc9f4ec5fe95baed37e1d287be710431f1e5e8ee105bc42ed37d74b1e55984bf1c09fe6a1fa13ef3b96faeaed6a2a1950a12153 +e125ce25082c6273aba67c5bf18ccd567dbddbc18f25e2251089d132f74f52ba eb6513fc61b30cfba58d4d7e80f94d14589090cf1d80b1df2e68088dc6104959ba0d583d585e9578ab0aec0cf36c48435eb52ed9ab4bbce7a5abe679c97ae2dbe35e8cc1d45b06dda3cf418665c57cbee4bbb47fa4caf78f4ee656fec237fe4eebbafa206e1ef2bd0ee4ae71bd0e9b2f54f91daadf1febfd7032381d636b733dcb3bf76fb14e23aff1f68ed3dbcf75c9b99c6f26 +9e47dfa0851b60069f224b0737b29e564a769921837e3d8b3a345cdcecec7fc6 1594d74bf5dde444265d4c04dad9721ff3e34cbf622daf341fe16b96431f6c4df1f760d34f296eb97d98d560ad5286fec4dce1724f20b54fd7df51d4bf137add656c80546fb1bf516d62ee82baa992910ef4cc18b70f3f8698276fcfb44e0ec546c2c39cfd8ee91034ff9303058b4252462f86c823eb15bf481e6b79cc3a02218595b3658e8b37382bd5048eaed5fd02c37944e73b +f0a186900989ec1a9b1af6a4b03a7ea913b2867417ff3418dfebfe794d0e37ba 4cfa1278903026f66fedd41374558be1b585d03c5c55dac94361df286d4bd39c7cb8037ed3b267b07c346626449d0cc5b0dd2cf221f7e4c3449a4be99985d2d5e67bff2923357ddeab5abcb4619f3a3a57b2cf928a022eb27676c6cf805689004fca4d41ea6c2d0a4789c7605f7bb838dd883b3ad3e6027e775bcf262881428099c7fff95b14c095ea130e0b9938a5e22fc52650f591 +65ae36fcadf66e9fe6e3425690a60036a0b169651c237c5e47826e159beae593 d3e65cb92cfa79662f6af493d696a07ccf32aaadcceff06e73e8d9f6f909209e66715d6e978788c49efb9087b170ecf3aa86d2d4d1a065ae0efc8924f365d676b3cb9e2bec918fd96d0b43dee83727c9a93bf56ca2b2e59adba85696546a815067fc7a78039629d4948d157e7b0d826d1bf8e81237bab7321312fdaa4d521744f988db6fdf04549d0fdca393d639c729af716e9c8bba48 +2cb44f43aaf07ceef5737e935ff1fff68faa2aea042e5c63426d0ee0ea18ba25 842cc583504539622d7f71e7e31863a2b885c56a0ba62db4c2a3f2fd12e79660dc7205ca29a0dc0a87db4dc62ee47a41db36b9ddb3293b9ac4baae7df5c6e7201e17f717ab56e12cad476be49608ad2d50309e7d48d2d8de4fa58ac3cfeafeee48c0a9eec88498e3efc51f54d300d828dddccb9d0b06dd021a29cf5cb5b2506915beb8a11998b8b886e0f9b7a80e97d91a7d01270f9a7717 +f0a3ecbeb1d481791929637da47f39204f47b76fe555b19689adabbcca1482ba 6c4b0a0719573e57248661e98febe326571f9a1ca813d3638531ae28b4860f23c3a3a8ac1c250034a660e2d71e16d3acc4bf9ce215c6f15b1c0fc7e77d3d27157e66da9ceec9258f8f2bf9e02b4ac93793dd6e29e307ede3695a0df63cbdc0fc66fb770813eb149ca2a916911bee4902c47c7802e69e405fe3c04ceb5522792a5503fa829f707272226621f7c488a7698c0d69aa561be9f378 +2729fe3217e7d1cc26aa4fae176e02cf9030eddc51a5781d36ed9f2b2825f2fd 51b7dbb7ce2ffeb427a91ccfe5218fd40f9e0b7e24756d4c47cd55606008bdc27d16400933906fd9f30effdd4880022d081155342af3fb6cd53672ab7fb5b3a3bcbe47be1fd3a2278cae8a5fd61c1433f7d350675dd21803746cadca574130f01200024c6340ab0cc2cf74f2234669f34e9009ef2eb94823d62b31407f4ba46f1a1eec41641e84d77727b59e746b8a671bef936f05be820759fa +ca2c6b7f53d726c6636928563ed25c9d6adb01ee4a8b6c66f623f189e3c787ea 83599d93f5561e821bd01a472386bc2ff4efbd4aed60d5821e84aae74d8071029810f5e286f8f17651cd27da07b1eb4382f754cd1c95268783ad09220f5502840370d494beb17124220f6afce91ec8a0f55231f9652433e5ce3489b727716cf4aeba7dcda20cd29aa9a859201253f948dd94395aba9e3852bd1d60dda7ae5dc045b283da006e1cbad83cc13292a315db5553305c628dd091146597 +2193dc87d51721516148ed1037c05a196fb9084ee9703db88ef6f94283d762c9 2be9bf526c9d5a75d565dd11ef63b979d068659c7f026c08bea4af161d85a462d80e45040e91f4165c074c43ac661380311a8cbed59cc8e4c4518e80cd2c78ab1cabf66bff83eab3a80148550307310950d034a6286c93a1ece8929e6385c5e3bb6ea8a7c0fb6d6332e320e71cc4eb462a2a62e2bfe08f0ccad93e61bedb5dd0b786a728ab666f07e0576d189c92bf9fb20dca49ac2d3956d47385e2 +e0a279e2467610b367435a5c64dcba6bb17a766281b2e0519fb874e4c67637d0 ca76d3a12595a817682617006848675547d3e8f50c2210f9af906c0e7ce50b4460186fe70457a9e879e79fd4d1a688c70a347361c847ba0dd6aa52936eaf8e58a1be2f5c1c704e20146d366aeb3853bed9de9befe9569ac8aaea37a9fb7139a1a1a7d5c748605a8defb297869ebedd71d615a5da23496d11e11abbb126b206fa0a7797ee7de117986012d0362dcef775c2fe145ada6bda1ccb326bf644 +1400ab53ed0a980c99f810379644d6f6d15744579d6c65f9b31007b6603925e8 f76b85dc67421025d64e93096d1d712b7baf7fb001716f02d33b2160c2c882c310ef13a576b1c2d30ef8f78ef8d2f465007109aad93f74cb9e7d7bef7c9590e8af3b267c89c15db238138c45833c98cc4a471a7802723ef4c744a853cf80a0c2568dd4ed58a2c9644806f42104cee53628e5bdf7b63b0b338e931e31b87c24b146c6d040605567ceef5960df9e022cb469d4c787f4cba3c544a1ac91f95f +19ddc3133787940c7ee48f515fa080680b750ea2ca269eacfa79750a7051dd4d 25b8c9c032ea6bcd733ffc8718fbb2a503a4ea8f71dea1176189f694304f0ff68e862a8197b839957549ef243a5279fc2646bd4c009b6d1edebf24738197abb4c992f6b1dc9ba891f570879accd5a6b18691a93c7d0a8d38f95b639c1daeb48c4c2f15ccf5b9d508f8333c32de78781b41850f261b855c4bebcc125a380c54d501c5d3bd07e6b52102116088e53d76583b0161e2a58d0778f091206aabd5a1 +0edcdf340e8a9f5235240da7860772468ae3d7d3b09bb71c31668089f28e6598 21cfdc2a7ccb7f331b3d2eefff37e48ad9fa9c788c3f3c200e0173d99963e1cbca93623b264e920394ae48bb4c3a5bb96ffbc8f0e53f30e22956adabc2765f57fb761e147ecbf8567533db6e50c8a1f894310a94edf806dd8ca6a0e141c0fa7c9fae6c6ae65f18c93a8529e6e5b553bf55f25be2e80a9882bd37f145fecbeb3d447a3c4e46c21524cc55cdd62f521ab92a8ba72b897996c49bb273198b7b1c9e +4aec11260ee9df531eb6039b88eae16230319420119fc5ba4800e51704353c2e 4e452ba42127dcc956ef4f8f35dd68cb225fb73b5bc7e1ec5a898bba2931563e74faff3b67314f241ec49f4a7061e3bd0213ae826bab380f1f14faab8b0efddd5fd1bb49373853a08f30553d5a55ccbbb8153de4704f29ca2bdeef0419468e05dd51557ccc80c0a96190bbcc4d77ecff21c66bdf486459d427f986410f883a80a5bcc32c20f0478bb9a97a126fc5f95451e40f292a4614930d054c851acd019ccf +60514233cc49e2a3fcd62f346bc6cfdb2df4d7e1902cb0cc9cf2d4a244686619 fa85671df7dadf99a6ffee97a3ab9991671f5629195049880497487867a6c446b60087fac9a0f2fcc8e3b24e97e42345b93b5f7d3691829d3f8ccd4bb36411b85fc2328eb0c51cb3151f70860ad3246ce0623a8dc8b3c49f958f8690f8e3860e71eb2b1479a5cea0b3f8befd87acaf5362435eaeccb52f38617bc6c5c2c6e269ead1fbd69e941d4ad2012da2c5b21bcfbf98e4a77ab2af1f3fda3233f046d38f1dc8 +0f7c05b8f74cf03df03ed16b0243a4f82dfcbb92970d1f1dad30595747a60250 e90847ae6797fbc0b6b36d6e588c0a743d725788ca50b6d792352ea8294f5ba654a15366b8e1b288d84f5178240827975a763bc45c7b0430e8a559df4488505e009c63da994f1403f407958203cebb6e37d89c94a5eacf6039a327f6c4dbbc7a2a307d976aa39e41af6537243fc218dfa6ab4dd817b6a397df5ca69107a9198799ed248641b63b42cb4c29bfdd7975ac96edfc274ac562d0474c60347a078ce4c25e88 +80529f4547749ac2b461c02b329ab134251b35dbe77d802512c956ea5c0a53fe f6d5c2b6c93954fc627602c00c4ca9a7d3ed12b27173f0b2c9b0e4a5939398a665e67e69d0b12fb7e4ceb253e8083d1ceb724ac07f009f094e42f2d6f2129489e846eaff0700a8d4453ef453a3eddc18f408c77a83275617fabc4ea3a2833aa73406c0e966276079d38e8e38539a70e194cc5513aaa457c699383fd1900b1e72bdfb835d1fd321b37ba80549b078a49ea08152869a918ca57f5b54ed71e4fd3ac5c06729 +fd831aae1d0a16d475b2e25ce2e0cc060804edf4fc2011d1515061cb02fa671f cf8562b1bed89892d67ddaaf3deeb28246456e972326dbcdb5cf3fb289aca01e68da5d59896e3a6165358b071b304d6ab3d018944be5049d5e0e2bb819acf67a6006111089e6767132d72dd85beddcbb2d64496db0cc92955ab4c6234f1eea24f2d51483f2e209e4589bf9519fac51b4d061e801125e605f8093bb6997bc163d551596fe4ab7cfae8fb9a90f6980480ce0c229fd1675409bd788354daf316240cfe0af93eb +4b5897141a30e13aea07da468bc8a150810d75b559458c48a497e7e602185d8e 2ace31abb0a2e3267944d2f75e1559985db7354c6e605f18dc8470423fca30b7331d9b33c4a4326783d1caae1b4f07060eff978e4746bf0c7e30cd61040bd5ec2746b29863eb7f103ebda614c4291a805b6a4c8214230564a0557bc7102e0bd3ed23719252f7435d64d210ee2aafc585be903fa41e1968c50fd5d5367926df7a05e3a42cf07e656ff92de73b036cf8b19898c0cb34557c0c12c2d8b84e91181af467bc75a9d1 +18694cae4d6ab5b6624ea58c4c5951da44d89118c9e801e3d51af30d642cc19f 0d8d09aed19f1013969ce5e7eb92f83a209ae76be31c754844ea9116ceb39a22ebb6003017bbcf26555fa6624185187db8f0cb3564b8b1c06bf685d47f3286eda20b83358f599d2044bbf0583fab8d78f854fe0a596183230c5ef8e54426750eaf2cc4e29d3bdd037e734d863c2bd9789b4c243096138f7672c232314effdfc6513427e2da76916b5248933be312eb5dde4cf70804fb258ac5fb82d58d08177ac6f4756017fff5 +5dd8712c8600e43b089d5b7d7934d2574b0d31a60d495d9f3d4d9ec2d6e1ecab c3236b73deb7662bf3f3daa58f137b358ba610560ef7455785a9befdb035a066e90704f929bd9689cef0ce3bda5acf4480bceb8d09d10b098ad8500d9b6071dfc3a14af6c77511d81e3aa8844986c3bea6f469f9e02194c92868cd5f51646256798ff0424954c1434bdfed9facb390b07d342e992936e0f88bfd0e884a0ddb679d0547ccdec6384285a45429d115ac7d235a717242021d1dc35641f5f0a48e8445dba58e6cb2c8ea +729c063e5eeffcf708b317d4ee9055c241613ee1bf9a8ddd98ac93a98d9b2d7d b39feb8283eadc63e8184b51df5ae3fd41aac8a963bb0be1cd08aa5867d8d910c669221e73243360646f6553d1ca05a84e8dc0de05b6419ec349ca994480193d01c92525f3fb3dcefb08afc6d26947bdbbfd85193f53b50609c6140905c53a6686b58e53a319a57b962331ede98149af3de3118a819da4d76706a0424b4e1d2910b0ed26af61d150ebcb46595d4266a0bd7f651ba47d0c7f179ca28545007d92e8419d48fdfbd744ce +5d5a535b25a0c772b102409706a720af41ba0de7198b28755947df62b5c05f44 a983d54f503803e8c7999f4edbbe82e9084f422143a932ddddc47a17b0b7564a7f37a99d0786e99476428d29e29d3c197a72bfab1342c12a0fc4787fd7017d7a6174049ea43b5779169ef7472bdbbd941dcb82fc73aac45a8a94c9f2bd3477f61fd3b796f02a1b8264a214c6fea74b7051b226c722099ec7883a462b83b6afdd4009248b8a237f605fe5a08fe7d8b45321421ebba67bd70a0b00ddbf94baab7f359d5d1eea105f28dcfb +3e0f97f4dee5406521fcd500a6cb05937a15979fccffc29ea5ba4269852cea9d e4d1c1897a0a866ce564635b74222f9696bf2c7f640dd78d7e2aca66e1b61c642bb03ea7536aae597811e9bf4a7b453ede31f97b46a5f0ef51a071a2b3918df16b152519ae3776f9f1edab4c2a377c3292e96408359d3613844d5eb393000283d5ad3401a318b12fd1474b8612f2bb50fb6a8b9e023a54d7dde28c43d6d8854c8d9d1155935c199811dbfc87e9e0072e90eb88681cc7529714f8fb8a2c9d88567adfb974ee205a9bf7b848 +2817ae5c02d40d41d287d2f236e2cc367c2b08318e7f2104caaf8777d3035ac4 b10c59723e3dcadd6d75df87d0a1580e73133a9b7d00cb95ec19f5547027323be75158b11f80b6e142c6a78531886d9047b08e551e75e6261e79785366d7024bd7cd9cf322d9be7d57fb661069f2481c7bb759cd71b4b36ca2bc2df6d3a328faebdb995a9794a8d72155ed551a1f87c80bf6059b43fc764900b18a1c2441f7487743cf84e565f61f8dd2ece6b6ccc9444049197aaaf53e926fbee3bfca8be588ec77f29d211be89de18b15f6 +4db77b903c9d54c79008b8a9cb08cfe4265c1c18605200da803e1ed560cf60bd db11f609baba7b0ca634926b1dd539c8cbada24967d7add4d9876f77c2d80c0f4dcefbd7121548373582705cca2495bd2a43716fe64ed26d059cfb566b3364bd49ee0717bdd9810dd14d8fad80dbbdc4cafb37cc60fb0fe2a80fb4541b8ca9d59dce457738a9d3d8f641af8c3fd6da162dc16fc01aac527a4a0255b4d231c0be50f44f0db0b713af03d968fe7f0f61ed0824c55c4b5265548febd6aad5c5eedf63efe793489c39b8fd29d104ce +0f524fe180d98b7a7bf80c11701bc670447370cc3e73de653e06bdee7a39419d bebd4f1a84fc8b15e4452a54bd02d69e304b7f32616aadd90537937106ae4e28de9d8aab02d19bc3e2fde1d651559e296453e4dba94370a14dbbb2d1d4e2022302ee90e208321efcd8528ad89e46dc839ea9df618ea8394a6bff308e7726bae0c19bcd4be52da6258e2ef4e96aa21244429f49ef5cb486d7ff35cac1bacb7e95711944bccb2ab34700d42d1eb38b5d536b947348a458ede3dc6bd6ec547b1b0cae5b257be36a7124e1060c170ffa +7636445a2de43f9a5160b62aa409517c5b5db1214118335ba1d7e55133db4fc4 5aca56a03a13784bdc3289d9364f79e2a85c12276b49b92db0adaa4f206d5028f213f678c3510e111f9dc4c1c1f8b6acb17a6413aa227607c515c62a733817ba5e762cc6748e7e0d6872c984d723c9bb3b117eb8963185300a80bfa65cde495d70a46c44858605fccbed086c2b45cef963d33294dbe9706b13af22f1b7c4cd5a001cfec251fba18e722c6e1c4b1166918b4f6f48a98b64b3c07fc86a6b17a6d0480ab79d4e6415b520f1c484d675b1 +5e2d4fac21886cf118bd36c246aa10d4d84c025af1145930845dad32351026ae a5aad0e4646a32c85cfcac73f02fc5300f1982fabb2f2179e28303e447854094cdfc854310e5c0f60993ceff54d84d6b46323d930adb07c17599b35b505f09e784bca5985e0172257797fb53649e2e9723efd16865c31b5c3d5113b58bb0bfc8920fabdda086d7537e66d709d050bd14d0c960873f156fad5b3d3840cdfcdc9be6af519db262a27f40896ab25cc39f96984d650611c0d5a3080d5b3a1bf186abd42956588b3b58cd948970d298776060 +1a478bf35625e8c61f1f3ebe34f247db0c4a2f66e6547e4ddf12e976fd9ad1b8 06cbbe67e94a978203ead6c057a1a5b098478b4b4cbef5a97e93c8e42f5572713575fc2a884531d7622f8f879387a859a80f10ef02708cd8f7413ab385afc357678b9578c0ebf641ef076a1a30f1f75379e9dcb2a885bdd295905ee80c0168a62a9597d10cf12dd2d8cee46645c7e5a141f6e0e23aa482abe5661c16e69ef1e28371e2e236c359ba4e92c25626a7b7ff13f6ea4ae906e1cfe163e91719b1f750a96cbde5fbc953d9e576cd216afc90323a +8aa31165f84d9655e5c779fd95f1f4dca98839157f2a6b37b408bbabf20bf845 f1c528cf7739874707d4d8ad5b98f7c77169de0b57188df233b2dc8a5b31eda5db4291dd9f68e6bad37b8d7f6c9c0044b3bf74bbc3d7d1798e138709b0d75e7c593d3cccdc1b20c7174b4e692add820ace262d45ccfae2077e878796347168060a162ecca8c38c1a88350bd63bb539134f700fd4addd5959e255337daa06bc86358fabcbefdfb5bc889783d843c08aadc6c4f6c36f65f156e851c9a0f917e4a367b5ad93d874812a1de6a7b93cd53ad97232 +11f5174a3cb5326cab14c1dbee67fb14c2a758cb1d0c74cb1d94134ae0cbcc1b 9d9f3a7ecd51b41f6572fd0d0881e30390dfb780991dae7db3b47619134718e6f987810e542619dfaa7b505c76b7350c6432d8bf1cfebdf1069b90a35f0d04cbdf130b0dfc7875f4a4e62cdb8e525aadd7ce842520a482ac18f09442d78305fe85a74e39e760a4837482ed2f437dd13b2ec1042afcf9decdc3e877e50ff4106ad10a525230d11920324a81094da31deab6476aa42f20c84843cfc1c58545ee80352bdd3740dd6a16792ae2d86f11641bb717c2 +90a4fb849543e4ac9391b732e76d65b2a1bc52bf4d89867431de4b29fd3a6e22 5179888724819fbad3afa927d3577796660e6a81c52d98e9303261d5a4a83232f6f758934d50aa83ff9e20a5926dfebaac49529d006eb923c5ae5048ed544ec471ed7191edf46363383824f915769b3e688094c682b02151e5ee01e510b431c8865aff8b6b6f2f59cb6d129da79e97c6d2b8fa6c6da3f603199d2d1bcab547682a81cd6cf65f6551121391d78bcc23b5bd0e922ec6d8bf97c952e84dd28aef909aba31edb903b28fbfc33b7703cd996215a11238 +eac179f2012c2c1e95da737eb5c7403449649ea13aa164cf0bc2e882a59181b4 576ef3520d30b7a4899b8c0d5e359e45c5189add100e43be429a02fb3de5ff4f8fd0e79d9663acca72cd29c94582b19292a557c5b1315297d168fbb54e9e2ecd13809c2b5fce998edc6570545e1499dbe7fb74d47cd7f35823b212b05bf3f5a79caa34224fdd670d335fcb106f5d92c3946f44d3afcbae2e41ac554d8e6759f332b76be89a0324aa12c5482d1ea3ee89ded4936f3e3c080436f539fa137e74c6d3389bdf5a45074c47bc7b20b0948407a66d855e2f +4d8bc7e521c77a9ff82670e0d95245675c4414191568927be00b47e06eccd1bf 0df2152fa4f4357c8741529dd77e783925d3d76e95bafa2b542a2c33f3d1d117d159cf473f82310356fee4c90a9e505e70f8f24859656368ba09381fa245eb6c3d763f3093f0c89b972e66b53d59406d9f01aea07f8b3b615cac4ee4d05f542e7d0dab45d67ccccd3a606ccbeb31ea1fa7005ba07176e60dab7d78f6810ef086f42f08e595f0ec217372b98970cc6321576d92ce38f7c397a403bada1548d205c343ac09deca86325373c3b76d9f32028fea8eb32515 +71d0c0d03861d7b63d0311690e299e0f17273b92ec8e2284dc762fde78637bf3 3e15350d87d6ebb5c8ad99d42515cfe17980933c7a8f6b8bbbf0a63728cefaad2052623c0bd5931839112a48633fb3c2004e0749c87a41b26a8b48945539d1ff41a4b269462fd199bfecd45374756f55a9116e92093ac99451aefb2af9fd32d6d7f5fbc7f7a540d5097c096ebc3b3a721541de073a1cc02f7fb0fb1b9327fb0b1218ca49c9487ab5396622a13ae546c97abdef6b56380dda7012a8384091b6656d0ab272d363cea78163ff765cdd13ab1738b940d16cae +bdb1411673beb61f8a164cec25481cf15954ad4cb198eac07933f77901d74b59 c38d6b0b757cb552be40940ece0009ef3b0b59307c1451686f1a22702922800d58bce7a636c1727ee547c01b214779e898fc0e560f8ae7f61bef4d75eaa696b921fd6b735d171535e9edd267c192b99880c87997711002009095d8a7a437e258104a41a505e5ef71e5613ddd2008195f0c574e6ba3fe40099cfa116e5f1a2fa8a6da04badcb4e2d5d0de31fdc4800891c45781a0aac7c907b56d631fca5ce8b2cde620d11d1777ed9fa603541de794ddc5758fcd5fad78c0 +ec9a4ce1119df6c8fe03ed4ad787d8d4d7514e5dc253a69d388b0ef83b3eb6e3 8d2de3f0b37a6385c90739805b170057f091cd0c7a0bc951540f26a5a75b3e694631bb64c7635eed316f51318e9d8de13c70a2aba04a14836855f35e480528b776d0a1e8a23b547c8b8d6a0d09b241d3be9377160cca4e6793d00a515dc2992cb7fc741daca171431da99cce6f7789f129e2ac5cf65b40d703035cd2185bb936c82002daf8cbc27a7a9e554b06196630446a6f0a14ba155ed26d95bd627b7205c072d02b60db0fd7e49ea058c2e0ba202daff0de91e845cf79 +0babfe847f3976337b4ec52857ccad67c9054385876005d710a20770f022eb7f c464bbdad275c50dcd983b65ad1019b9ff85a1e71c807f3204bb2c921dc31fbcd8c5fc45868ae9ef85b6c9b83bba2a5a822201ed68586ec5ec27fb2857a5d1a2d09d09115f22dcc39fe61f5e1ba0ff6e8b4acb4c6da748be7f3f0839739394ff7fa8e39f7f7e84a33c3866875c01bcb1263c9405d91908e9e0b50e7459fabb63d8c6bbb73d8e3483c099b55bc30ff092ff68b6adedfd477d63570c9f5515847f36e24ba0b705557130cec57ebad1d0b31a378e91894ee26e3a04 +6117aba73e9c148b0c9b54153cab27e6853206e89793d8f89d865d3ca453342d 8b8d68bb8a75732fe272815a68a1c9c5aa31b41dedc8493e76525d1d013d33cebd9e21a5bb95db2616976a8c07fcf411f5f6bc6f7e0b57aca78cc2790a6f9b898858ac9c79b165ff24e66677531e39f572be5d81eb3264524181115f32780257bfb9aeec6af12af28e587cac068a1a2953b59ad680f4c245b2e3ec36f59940d37e1d3db38e13edb29b5c0f404f6ff87f80fc8be7a225ff22fbb9c8b6b1d7330c57840d24bc75b06b80d30dad6806544d510af6c4785e823ac3e0b8 +94da8077cf8a5e17171c809651793692ddcb89e56c2b4632a0b3a831af2602b2 6b018710446f368e7421f1bc0ccf562d9c1843846bc8d98d1c9bf7d9d6fcb48bfc3bf83b36d44c4fa93430af75cd190bde36a7f92f867f58a803900df8018150384d85d82132f123006ac2aeba58e02a037fe6afbd65eca7c44977dd3dc74f48b6e7a1bfd5cc4dcf24e4d52e92bd4455848e4928b0eac8b7476fe3cc03e862aa4dff4470dbfed6de48e410f25096487ecfc32a27277f3f5023b2725ade461b1355889554a8836c9cf53bd767f5737d55184eea1ab3f53edd0976c485 +fc94dd2ee082377908c65919d510792d63608a8157d8ae5098fa3777e97c579d c9534a24714bd4be37c88a3da1082eda7cabd154c309d7bd670dccd95aa535594463058a29f79031d6ecaa9f675d1211e9359be82669a79c855ea8d89dd38c2c761ddd0ec0ce9e97597432e9a1beae062cdd71edfdfd464119be9e69d18a7a7fd7ce0e2106f0c8b0abf4715e2ca48ef9f454dc203c96656653b727083513f8efb86e49c513bb758b3b052fe21f1c05bb33c37129d6cc81f1aef6adc45b0e8827a830fe545cf57d0955802c117d23ccb55ea28f95c0d8c2f9c5a242b33f +6254b3d5fd9406078dbc970a67f9de5c6771dd31a02ab71131b7c55e28af1baf 07906c87297b867abf4576e9f3cc7f82f22b154afcbf293b9319f1b0584da6a40c27b32e0b1b7f412c4f1b82480e70a9235b12ec27090a5a33175a2bb28d8adc475cefe33f7803f8ce27967217381f02e67a3b4f84a71f1c5228e0c2ad971373f6f672624fcea8d1a9f85170fad30fa0bbd25035c3b41a6175d467998bd1215f6f3866f53847f9cf68ef3e2fbb54bc994de2302b829c5eea68ec441fcbafd7d16ae4fe9fff98bf00e5bc2ad54dd91ff9fda4dd77b6c754a91955d1fbaad0 +07f02e98c6b1101780c78401564e73134ddbe12bc8d07571f642be64d65595b6 588e94b9054abc2189df69b8ba34341b77cdd528e7860e5defcaa79b0c9a452ad4b82aa306be84536eb7cedcbe058d7b84a6aef826b028b8a0271b69ac3605a9635ea9f5ea0aa700f3eb7835bc54611b922964300c953efe7491e3677c2cebe0822e956cd16433b02c68c4a23252c3f9e151a416b4963257b783e038f6b4d5c9f110f871652c7a649a7bcedcbccc6f2d0725bb903cc196ba76c76aa9f10a190b1d1168993baa9ffc96a1655216773458bec72b0e39c9f2c121378feab4e76a +6fac75b7775222f07dd7e7106c3fae00b25602bb122699b3e8bc2e16343f9bb1 08959a7e4baae874928813364071194e2939772f20db7c3157078987c557c2a6d5abe68d520eef3dc491692e1e21bcd880adebf63bb4213b50897fa005256ed41b5690f78f52855c8d9168a4b666fce2da2b456d7a7e7c17ab5f2fb1ee90b79e698712e963715983fd07641ae4b4e9dc73203fac1ae11fa1f8c7941fcc82eab247addb56e2638447e9d609e610b60ce086656aaebf1da3c8a231d7d94e2fd0afe46b391ff14a72eaeb3f44ad4df85866def43d4781a0b3578bc996c87970b132 +ee76bba183e51b5f762d54c14b3fb626156947d54c0ddf14871b39bc0ddda087 cb2a234f45e2ecd5863895a451d389a369aab99cfef0d5c9ffca1e6e63f763b5c14fb9b478313c8e8c0efeb3ac9500cf5fd93791b789e67eac12fd038e2547cc8e0fc9db591f33a1e4907c64a922dda23ec9827310b306098554a4a78f050262db5b545b159e1ff1dca6eb734b872343b842c57eafcfda8405eedbb48ef32e99696d135979235c3a05364e371c2d76f1902f1d83146df9495c0a6c57d7bf9ee77e80f9787aee27be1fe126cdc9ef893a4a7dcbbc367e40fe4e1ee90b42ea25af01 +e964cddc607f3f728d6578c434289b979a9d96ecf8a0f1063c092179156e3bed d16beadf02ab1d4dc6f88b8c4554c51e866df830b89c06e786a5f8757e8909310af51c840efe8d20b35331f4355d80f73295974653ddd620cdde4730fb6c8d0d2dcb2b45d92d4fbdb567c0a3e86bd1a8a795af26fbf29fc6c65941cddb090ff7cd230ac5268ab4606fccba9eded0a2b5d014ee0c34f0b2881ac036e24e151be89eeb6cd9a7a790afccff234d7cb11b99ebf58cd0c589f20bdac4f9f0e28f75e3e04e5b3debce607a496d848d67fa7b49132c71b878fd5557e082a18eca1fbda94d4b +9247d1057833d546dbfd2c8bd575add5177f363398b8804b194a0b8add6086d5 8f65f6bc59a85705016e2bae7fe57980de3127e5ab275f573d334f73f8603106ec3553016608ef2dd6e69b24be0b7113bf6a760ba6e9ce1c48f9e186012cf96a1d4849d75df5bb8315387fd78e9e153e76f8ba7ec6c8849810f59fb4bb9b004318210b37f1299526866f44059e017e22e96cbe418699d014c6ea01c9f0038b10299884dbec3199bb05adc94e955a1533219c1115fed0e5f21228b071f40dd57c4240d98d37b73e412fe0fa4703120d7c0c67972ed233e5deb300a22605472fa3a3ba86 +b1c622edd087c7422e5c9d7507987e1dc0525f42c43e614da56ab2f1049054b3 84891e52e0d451813210c3fd635b39a03a6b7a7317b221a7abc270dfa946c42669aacbbbdf801e1584f330e28c729847ea14152bd637b3d0f2b38b4bd5bf9c791c58806281103a3eabbaede5e711e539e6a8b2cf297cf351c078b4fa8f7f35cf61bebf8814bf248a01d41e86c5715ea40c63f7375379a7eb1d78f27622fb468ab784aaaba4e534a6dfd1df6fa15511341e725ed2e87f98737ccb7b6a6dfae416477472b046bf1811187d151bfa9f7b2bf9acdb23a3be507cdf14cfdf517d2cb5fb9e4ab6 +6cd3c634878db33967fa063fb3b3e60a78babf524e9aa1d4a889366ed14a2cde fdd7a9433a3b4afabd7a3a5e3457e56debf78e84b7a0b0ca0e8c6d53bd0c2dae31b2700c6128334f43981be3b213b1d7a118d59c7e6b6493a86f866a1635c12859cfb9ad17460a77b4522a5c1883c3d6acc86e6162667ec414e9a104aa892053a2b1d72165a855bacd8faf8034a5dd9b716f47a0818c09bb6baf22aa503c06b4ca261f557761989d2afbd88b6a678ad128af68672107d0f1fc73c5ca740459297b3292b281e93bceb761bde7221c3a55708e5ec84472cddcaa84ecf23723cc0991355c6280 +8470f81681f9304f2d702e0ebdbe1059bdce94ea25256c57e8c3ec27defb94bd 70a40bfbef92277a1aad72f6b79d0177197c4ebd432668cfec05d099accb651062b5dff156c0b27336687a94b26679cfdd9daf7ad204338dd9c4d14114033a5c225bd11f217b5f4732da167ee3f939262d4043fc9cba92303b7b5e96aea12adda64859df4b86e9ee0b58e39091e6b188b408ac94e1294a8911245ee361e60e601eff58d1d37639f3753bec80ebb4efde25817436076623fc65415fe51d1b0280366d12c554d86743f3c3b6572e400361a60726131441ba493a83fbe9afda90f7af1ae717238d +e750666e656ad41b3fc04362f10c0811704c23fa018a3f4a058e3d42b9c8b2a9 74356e449f4bf8644f77b14f4d67cb6bd9c1f5ae357621d5b8147e562b65c66585caf2e491b48529a01a34d226d436959153815380d5689e30b35357cdac6e08d3f2b0e88e200600d62bd9f5eaf488df86a4470ea227006182e44809009868c4c280c43d7d64a5268fa719074960087b3a6abc837882f882c837834535929389a12b2c78187e2ea07ef8b8eef27dc85002c3ae35f1a50bee6a1c48ba7e175f3316670b27983472aa6a61eed0a683a39ee323080620ea44a9f74411ae5ce99030528f9ab49c79f2 +81762fe2792ccb4b8ed9d02eb56ec26c2f9fa33ac45668a2cc89301c41bb7a12 8c3798e51bc68482d7337d3abb75dc9ffe860714a9ad73551e120059860dde24ab87327222b64cf774415a70f724cdf270de3fe47dda07b61c9ef2a3551f45a5584860248fabde676e1cd75f6355aa3eaeabe3b51dc813d9fb2eaa4f0f1d9f834d7cad9c7c695ae84b329385bc0bef895b9f1edf44a03d4b410cc23a79a6b62e4f346a5e8dd851c2857995ddbf5b2d717aeb847310e1f6a46ac3d26a7f9b44985af656d2b7c9406e8a9e8f47dcb4ef6b83caacf9aefb6118bfcff7e44bef6937ebddc89186839b77 +6291eb2604f88665f53177baed99c50770b1a8b8c0a793b4d961ff1ccf03de6b fa56bf730c4f8395875189c10c4fb251605757a8fecc31f9737e3c2503b02608e6731e85d7a38393c67de516b85304824bfb135e33bf22b3a23b913bf6acd2b7ab85198b8187b2bcd454d5e3318cacb32fd6261c31ae7f6c54ef6a7a2a4c9f3ecb81ce3555d4f0ad466dd4c108a90399d70041997c3b25345a9653f3c9a6711ab1b91d6a9d2216442da2c973cbd685ee7643bfd77327a2f7ae9cb283620a08716dfb462e5c1d65432ca9d56a90e811443cd1ecb8f0de179c9cb48ba4f6fec360c66f252f6e64edc96b +b28cce3e41765e9e52b7964981641e4d10e091e5e54626928589b61af997c433 b6134f9c3e91dd8000740d009dd806240811d51ab1546a974bcb18d344642baa5cd5903af84d58ec5ba17301d5ec0f10ccd0509cbb3fd3fff9172d193af0f782252fd1338c7244d40e0e42362275b22d01c4c3389f19dd69bdf958ebe28e31a4ffe2b5f18a87831cfb7095f58a87c9fa21db72ba269379b2dc2384b3da953c7925761fed324620acea435e52b424a7723f6a2357374157a34cd8252351c25a1b232826cefe1bd3e70ffc15a31e7c0598219d7f00436294d11891b82497bc78aa5363892a2495df8c1eef +af86ec4daf6c860b1181745fced0a6ce118ca6b1dde4f044c10ec7091c8a38c5 c941cdb9c28ab0a791f2e5c8e8bb52850626aa89205bec3a7e22682313d198b1fa33fc7295381354858758ae6c8ec6fac3245c6e454d16fa2f51c4166fab51df272858f2d603770c40987f64442d487af49cd5c3991ce858ea2a60dab6a65a34414965933973ac2457089e359160b7cdedc42f29e10a91921785f6b7224ee0b349393cdcff6151b50b377d609559923d0984cda6000829b916ab6896693ef6a2199b3c22f7dc5500a15b8258420e314c222bc000bc4e5413e6dd82c993f8330f5c6d1be4bc79f08a1a0a46 +6b52f9014ac2862ea8ef6585ecae97f96027d68734de757a6e9aa36a4ba52cb0 4499efffac4bcea52747efd1e4f20b73e48758be915c88a1ffe5299b0b005837a46b2f20a9cb3c6e64a9e3c564a27c0f1c6ad1960373036ec5bfe1a8fc6a435c2185ed0f114c50e8b3e4c7ed96b06a036819c9463e864a58d6286f785e32a804443a56af0b4df6abc57ed5c2b185ddee8489ea080deeee66aa33c2e6dab36251c402682b6824821f998c32163164298e1fafd31babbcffb594c91888c6219079d907fdb438ed89529d6d96212fd55abe20399dbefd342248507436931cdead496eb6e4a80358acc78647d043 +7a175e3059040518712b144d9b491896bddabdf77acbe9aa21c544f8ceeacbc8 eecbb8fdfa4da62170fd06727f697d81f83f601ff61e478105d3cb7502f2c89bf3e8f56edd469d049807a38882a7eefbc85fc9a950952e9fa84b8afebd3ce782d4da598002827b1eb98882ea1f0a8f7aa9ce013a6e9bc462fb66c8d4a18da21401e1b93356eb12f3725b6db1684f2300a98b9a119e5d27ff704affb618e12708e77e6e5f34139a5a41131fd1d6336c272a8fc37080f041c71341bee6ab550cb4a20a6ddb6a8e0299f2b14bc730c54b8b1c1c487b494bdccfd3a53535ab2f231590bf2c4062fd2ad58f906a2d0d +702ccb5dd8ddf26063385c777a347b2d084c947235b908049bb0b53db52921ba e64f3e4ace5c8418d65fec2bc5d2a303dd458034736e3b0df719098be7a206deaf52d6ba82316caf330ef852375188cde2b39cc94aa449578a7e2a8e3f5a9d68e816b8d16889fbc0ebf0939d04f63033ae9ae2bdab73b88c26d6bd25ee460ee1ef58fb0afa92cc539f8c76d3d097e7a6a63ebb9b5887edf3cf076028c5bbd5b9db3211371ad3fe121d4e9bf44229f4e1ecf5a0f9f0eba4d5ceb72878ab22c3f0eb5a625323ac66f7061f4a81fac834471e0c59553f108475fe290d43e6a055ae3ee46fb67422f814a68c4be3e8c9 +dfd7fb5fdff226ded87399a29c7a4beac3ae71c209053f820d17bf9366bd953e d2cb2d733033f9e91395312808383cc4f0ca974e87ec68400d52e96b3fa6984ac58d9ad0938dde5a973008d818c49607d9de2284e7618f1b8aed8372fbd52ed54557af4220fac09dfa8443011699b97d743f8f2b1aef3537ebb45dcc9e13dfb438428ee190a4efdb3caeb7f3933117bf63abdc7e57beb4171c7e1ad260ab0587806c4d137b6316b50abc9cce0dff3acada47bbb86be777e617bbe578ff4519844db360e0a96c6701290e76bb95d26f0f804c8a4f2717eac4e7de9f2cff3bbc55a17e776c0d02856032a6cd10ad2838 +f105cda4c9fe1b990b99546b7a2f8b12fef7e4753545039535771a4fcad73eae f2998955613dd414cc111df5ce30a995bb792e260b0e37a5b1d942fe90171a4ac2f66d4928d7ad377f4d0554cbf4c523d21f6e5f379d6f4b028cdcb9b1758d3b39663242ff3cb6ede6a36a6f05db3bc41e0d861b384b6dec58bb096d0a422fd542df175e1be1571fb52ae66f2d86a2f6824a8cfaacbac4a7492ad0433eeb15454af8f312b3b2a577750e3efbd370e8a8cac1582581971fba3ba4bd0d76e718dacf8433d33a59d287f8cc92234e7a271041b526e389efb0e40b6a18b3aaf658e82ed1c78631fd23b4c3eb27c3faec8685 +1ab14ec928f99e3747acd68b661922d6fdd433c48ce9c4e311ae219787e738a0 447797e2899b72a356ba55bf4df3acca6cdb1041eb477bd1834a9f9acbc340a294d729f2f97df3a610be0ff15edb9c6d5db41644b9874360140fc64f52aa03f0286c8a640670067a84e017926a70438db1bb361defee7317021425f8821def26d1efd77fc853b818545d055adc9284796e583c76e6fe74c9ac2587aa46aa8f8804f2feb5836cc4b3ababab8429a5783e17d5999f32242eb59ef30cd7adabc16d72dbdb097623047c98989f88d14eaf02a7212be16ec2d07981aaa99949ddf89ecd90333a77bc4e1988a82abf7c7caf3291 +5a840c7aa35a9d1bf842c11bfb59d1b506405fb850ac55cd1d4e65c694b6b815 9f2c18ade9b380c784e170fb763e9aa205f64303067eb1bcea93df5dac4bf5a2e00b78195f808df24fc76e26cb7be31dc35f0844cded1567bba29858cffc97fb29010331b01d6a3fb3159cc1b973d255da9843e34a0a4061cabdb9ed37f241bfabb3c20d32743f4026b59a4ccc385a2301f83c0b0a190b0f2d01acb8f0d41111e10f2f4e149379275599a52dc089b35fdd5234b0cfb7b6d8aebd563ca1fa653c5c021dfd6f5920e6f18bfafdbecbf0ab00281333ed50b9a999549c1c8f8c63d7626c48322e9791d5ff72294049bde91e73f8 +aec04ed48104e372f70a22c2bfcf1a46fc0224bbadb9caafbe8d27f8aa3f0581 ae159f3fa33619002ae6bcce8cbbdd7d28e5ed9d61534595c4c9f43c402a9bb31f3b301cbfd4a43ce4c24cd5c9849cc6259eca90e2a79e01ffbac07ba0e147fa42676a1d668570e0396387b5bcd599e8e66aaed1b8a191c5a47547f61373021fa6deadcb55363d233c24440f2c73dbb519f7c9fa5a8962efd5f6252c0407f190dfefad707f3c7007d69ff36b8489a5b6b7c557e79dd4f50c06511f599f56c896b35c917b63ba35c6ff8092baf7d1658e77fc95d8a6a43eeb4c01f33f03877f92774be89c1114dd531c011e53a34dc248a2f0e6 +171d2414425bdf18004be32970c90e0f1e3cbc37d29c2a78e78a7611d4c7a729 3b8e97c5ffc2d6a40fa7de7fcefc90f3b12c940e7ab415321e29ee692dfac799b009c99dcddb708fce5a178c5c35ee2b8617143edc4c40b4d313661f49abdd93cea79d117518805496fe6acf292c4c2a1f76b403a97d7c399daf85b46ad84e16246c67d6836757bde336c290d5d401e6c1386ab32797af6bb251e9b2d8fe754c47482b72e0b394eab76916126fd68ea7d65eb93d59f5b4c5ac40f7c3b37e7f3694f29424c24af8c8f0ef59cd9dbf1d28e0e10f799a6f78cad1d45b9db3d7dee4a7059abe99182714983b9c9d44d7f5643596d4f3 +4c09a9a603845ee3d5f7ceab08294e556f8db5fecd2ff32010a458a014644d2e 3434ec31b10fafdbfeec0dd6bd94e80f7ba9dca19ef075f7eb017512af66d6a4bcf7d16ba0819a1892a6372f9b35bcc7ca8155ee19e8428bc22d214856ed5fa9374c3c09bde169602cc219679f65a1566fc7316f4cc3b631a18fb4449fa6afa16a3db2bc4212eff539c67cf184680826535589c7111d73bffce431b4c40492e763d9279560aaa38eb2dc14a212d723f994a1fe656ff4dd14551ce4e7c621b2aa5604a10001b2878a897a28a08095c325e10a26d2fb1a75bfd64c250309bb55a44f23bbac0d5516a1c687d3b41ef2fbbf9cc56d4739 +bf0109cbe55c21419e567d8c2ff6fa7d708743197d78e7eaf974c87e94b2e1a8 7c7953d81c8d208fd1c97681d48f49dd003456de60475b84070ef4847c333b74575b1fc8d2a186964485a3b8634feaa3595aaa1a2f4595a7d6b6153563dee31bbac443c8a33eed6d5d956a980a68366c2527b550ee950250dfb691eacbd5d56ae14b970668be174c89df2fea43ae52f13142639c884fd62a3683c0c3792f0f24ab1318bcb27e21f4737fab62c77ea38bc8fd1cf41f7dab64c13febe7152bf5bb7ab5a78f5346d43cc741cb6f72b7b8980f268b68bf62abdfb1577a52438fe14b591498cc95f071228460c7c5d5ceb4a7bde588e7f21c +bc33e5fe917cb1914c9e825b024887235566eab4fa451322415a9ce943c00d53 7a6a4f4fdc59a1d223381ae5af498d74b7252ecf59e389e49130c7eaee626e7bd9897effd92017f4ccde66b0440462cdedfd352d8153e6a4c8d7a0812f701cc737b5178c2556f07111200eb627dbc299caa792dfa58f35935299fa3a3519e9b03166dffa159103ffa35e8577f7c0a86c6b46fe13db8e2cdd9dcfba85bdddcce0a7a8e155f81f712d8e9fe646153d3d22c811bd39f830433b2213dd46301941b59293fd0a33e2b63adbd95239bc01315c46fdb678875b3c81e053a40f581cfbec24a1404b1671a1b88a6d06120229518fb13a74ca0ac5ae +8bcb334db0bb9f095fc0c9b1b65097576e1af5a93e9a95e52b313da089e305e9 d9faa14cebe9b7de551b6c0765409a33938562013b5e8e0e1e0a6418df7399d0a6a771fb81c3ca9bd3bb8e2951b0bc792525a294ebd1083688806fe5e7f1e17fd4e3a41d00c89e8fcf4a363caedb1acb558e3d562f1302b3d83bb886ed27b76033798131dab05b4217381eaaa7ba15ec820bb5c13b516dd640eaec5a27d05fdfca0f35b3a5312146806b4c0275bcd0aaa3b2017f346975db566f9b4d137f4ee10644c2a2da66deeca5342e236495c3c6280528bfd32e90af4cd9bb908f34012b52b4bc56d48cc8a6b59bab014988eabd12e1a0a1c2e170e7 +028dd0c1e80f6457141174f3b2b02b27ac6ce9f6c9b5d95133bb76cf99921185 2d8427433d0c61f2d96cfe80cf1e932265a191365c3b61aaa3d6dcc039f6ba2ad52a6a8cc30fc10f705e6b7705105977fa496c1c708a277a124304f1fc40911e7441d1b5e77b951aad7b01fd5db1b377d165b05bbf898042e39660caf8b279fe5229d1a8db86c0999ed65e53d01ccbc4b43173ccf992b3a14586f6ba42f5fe30afa8ae40c5df29966f9346da5f8b35f16a1de3ab6de0f477d8d8660918060e88b9b9e9ca6a4207033b87a812dbf5544d39e4882010f82b6ce005f8e8ff6fe3c3806bc2b73c2b83afb704345629304f9f86358712e9fae3ca3e +7519aa77241e5e89a53be2b633b0b04b11b249ab01086910ffcb36ea717f7b76 5e19d97887fcaac0387e22c6f803c34a3dacd2604172433f7a8a7a526ca4a2a1271ecfc5d5d7be5ac0d85d921095350dfc65997d443c21c8094e0a3fefd2961bcb94aed03291ae310ccda75d8ace4bc7d89e7d3e5d1650bda5d668b8b50bfc8e608e184f4d3a9a2badc4ff5f07e0c0bc8a9f2e0b2a26fd6d8c550008faaab75fd71af2a424bec9a7cd9d83fad4c8e9319115656a8717d3b523a68ff8004258b9990ed362308461804ba3e3a7e92d8f2ffae5c2fba55ba5a3c27c0a2f71bd711d2fe1799c2adb31b200035481e9ee5c4adf2ab9c0fa50b23975cf +d7cdfc8349f780fe3797673641eb404a331bbba18ad2ec190a8fb85169a9cb03 c8e976ab4638909387ce3b8d4e510c3230e5690e02c45093b1d297910abc481e56eea0f296f98379dfc9080af69e73b2399d1c143bee80ae1328162ce1ba7f6a8374679b20aacd380eb4e61382c99998704d62701afa914f9a2705cdb065885f50d086c3eb5753700c387118bb142f3e6da1e988dfb31ac75d7368931e45d1391a274b22f83ceb072f9bcabc0b216685bfd789f5023971024b1878a205442522f9ea7d8797a4102a3df41703768251fd5e017c85d1200a464118aa35654e7ca39f3c375b8ef8cbe7534dbc64bc20befb417cf60ec92f63d9ee7397 +4880b27208182a8aaa55a9283843359476941d9bf029f64848e72910a298de01 7145fa124b7429a1fc2231237a949ba7201bcc1822d3272de005b682398196c25f7e5cc2f289fbf44415f699cb7fe6757791b1443410234ae061edf623359e2b4e32c19bf88450432dd01caa5eb16a1dc378f391ca5e3c4e5f356728bddd4975db7c890da8bbc84cc73ff244394d0d48954978765e4a00b593f70f2ca082673a261ed88dbcef1127728d8cd89bc2c597e9102ced6010f65fa75a14ebe467fa57ce3bd4948b6867d74a9df5c0ec6f530cbf2ee61ce6f06bc8f2864dff5583776b31df8c7ffcb61428a56bf7bd37188b4a5123bbf338393af46eda85e6 +0c072e5620296f6ac63890df1eb1cefe9362700e140c450252474ba022fda2f7 7fdfadcc9d29bad23ae038c6c65cda1aef757221b8872ed3d75ff8df7da0627d266e224e812c39f7983e4558bfd0a1f2bef3feb56ba09120ef762917b9c093867948547aee98600d10d87b20106878a8d22c64378bf634f7f75900c03986b077b0bf8b740a82447b61b99fee5376c5eb6680ec9e3088f0bdd0c56883413d60c1357d3c811950e5890e7600103c916341b80c743c6a852b7b4fb60c3ba21f3bc15b8382437a68454779cf3cd7f9f90ccc8ef28d0b706535b1e4108eb5627bb45d719cb046839aee311ca1abdc8319e050d67972cb35a6b1601b25dbf487 +e90e482191764738b0ce698891de103bd5ab2b06963090381cb00f2e2e19a93a 988638219fd3095421f826f56e4f09e356296b628c3ce6930c9f2e758fd1a80c8273f2f61e4daae65c4f110d3e7ca0965ac7d24e34c0dc4ba2d6ff0bf5bbe93b3585f354d7543cb542a1aa54674d375077f2d360a8f4d42f3db131c3b7ab7306267ba107659864a90c8c909460a73621d1f5d9d3fd95beb19b23db1cb6c0d0fba91d36891529b8bd8263caa1bab56a4affaed44962df096d8d5b1eb845ef31188b3e10f1af811a13f156beb7a288aae593ebd1471b624aa1a7c6adf01e2200b3d72d88a3aed3100c88231e41efc376906f0b580dc895f080fda5741db1cb +917574201be67ea394537778f89034332a981cdfdce786f06edf069430598ade 5aab62756d307a669d146aba988d9074c5a159b3de85151a819b117ca1ff6597f6156e80fdd28c9c3176835164d37da7da11d94e09add770b68a6e081cd22ca0c004bfe7cd283bf43a588da91f509b27a6584c474a4a2f3ee0f1f56447379240a5ab1fb77fdca49b305f07ba86b62756fb9efb4fc225c86845f026ea542076b91a0bc2cdd136e122c659be259d98e5841df4c2f60330d4d8cdee7bf1a0a244524eecc68ff2aef5bf0069c9e87a11c6e519de1a4062a10c83837388f7ef58598a3846f49d499682b683c4a062b421594fafbc1383c943ba83bdef515efcf10d +a38dff1b9033044dc1b992e80fb956f2da17a59160ca43140e54e1c388ca6c54 47b8216aa0fbb5d67966f2e82c17c07aa2d6327e96fcd83e3de7333689f3ee79994a1bf45082c4d725ed8d41205cb5bcdf5c341f77facb1da46a5b9b2cbc49eadf786bcd881f371a95fa17df73f606519aea0ff79d5a11427b98ee7f13a5c00637e2854134691059839121fea9abe2cd1bcbbbf27c74caf3678e05bfb1c949897ea01f56ffa4dafbe8644611685c617a3206c7a7036e4ac816799f693dafe7f19f303ce4eba09d21e03610201bfc665b72400a547a1e00fa9b7ad8d84f84b34aef118515e74def11b9188bd1e1f97d9a12c30132ec2806339bdadacda2fd8b78 +5294810eddebc276bd66d1de607ef49dfedaacc4fb8910492bc7efdd739a0588 8cff1f67fe53c098896d9136389bd8881816ccab34862bb67a656e3d98896f3ce6ffd4da73975809fcdf9666760d6e561c55238b205d8049c1cedeef374d1735daa533147bfa960b2cce4a4f254176bb4d1bd1e89654432b8dbe1a135c42115b394b024856a2a83dc85d6782be4b444239567ccec4b184d4548eae3ff6a192f343292ba2e32a0f267f31cc26719eb85245d415fb897ac2da433ee91a99424c9d7f1766a44171d1651001c38fc79294accc68ceb5665d36218454d3ba169ae058a831338c17743603f81ee173bfc0927464f9bd728dee94c6aeab7aae6ee3a627e8 +44a0e90cb8f09ee739a33b7909e25af3e9c10a852a21e472f3b59ef990f91ff3 eacd07971cff9b9939903f8c1d8cbb5d4db1b548a85d04e037514a583604e787f32992bf2111b97ac5e8a938233552731321522ab5e8583561260b7d13ebeef785b23a41fd8576a6da764a8ed6d822d4957a545d5244756c18aa80e1aad4d1f9c20d259dee1711e2cc8fd013169fb7cc4ce38b362f8e0936ae9198b7e838dcea4f7a5b9429bb3f6bbcf2dc92565e3676c1c5e6eb3dd2a0f86aa23edd3d0891f197447692794b3dfa269611ad97f72b795602b4fdb198f3fd3eb41b415064256e345e8d8c51c555dc8a21904a9b0f1ad0effab7786aac2da3b196507e9f33ca356427 +759b53590ab85ed67a29852f114c128b7fc8720cd8f94ce481bfe65e60d3003d 23ac4e9a42c6ef45c3336ce6dfc2ff7de8884cd23dc912fef0f7756c09d335c189f3ad3a23697abda851a81881a0c8ccafc980ab2c702564c2be15fe4c4b9f10dfb2248d0d0cb2e2887fd4598a1d4acda897944a2ffc580ff92719c95cf2aa42dc584674cb5a9bc5765b9d6ddf5789791d15f8dd925aa12bffafbce60827b490bb7df3dda6f2a143c8bf96abc903d83d59a791e2d62814a89b8080a28060568cf24a80ae61179fe84e0ffad00388178cb6a617d37efd54cc01970a4a41d1a8d3ddce46edbba4ab7c90ad565398d376f431189ce8c1c33e132feae6a8cd17a61c630012 +d47cc49f84c6e975b1dc15fa54b6255f3123012a793058c4a2f6ebe1507440aa 0172df732282c9d488669c358e3492260cbe91c95cfbc1e3fea6c4b0ec129b45f242ace09f152fc6234e1bee8aab8cd56e8b486e1dcba9c05407c2f95da8d8f1c0af78ee2ed82a3a79ec0cb0709396ee62aadb84f8a4ee8a7ccca3c1ee84e302a09ea802204afecf04097e67d0f8e8a9d2651126c0a598a37081e42d168b0ae8a71951c524259e4e2054e535b779679bdade566fe55700858618e626b4a0faf895bcce9011504a49e05fd56127eae3d1f8917afb548ecadabda1020111fec9314c413498a360b08640549a22cb23c731ace743252a8227a0d2689d4c6001606678dfb921 +e917e78a80083089177f3900c3b265566f11591c3cf7415a6f331b17ea05db98 3875b9240cf3e0a8b59c658540f26a701cf188496e2c2174788b126fd29402d6a75453ba0635284d08835f40051a2a9683dc92afb9383719191231170379ba6f4adc816fecbb0f9c446b785bf520796841e58878b73c58d3ebb097ce4761fdeabe15de2f319dfbaf1742cdeb389559c788131a6793e193856661376c81ce9568da19aa6925b47ffd77a43c7a0e758c37d69254909ff0fbd415ef8eb937bcd49f91468b49974c07dc819abd67395db0e05874ff83dddab895344abd0e7111b2df9e58d76d85ad98106b36295826be04d435615595605e4b4bb824b33c4afeb5e7bb0d19f909 +049a2958239b4b7147767ba10f62c86a06525d8aa64a90b8c489cb6e5e2cc4ed 747cc1a59fefba94a9c75ba866c30dc5c1cb0c0f8e9361d98484956dd5d1a40f6184afbe3dac9f76028d1caeccfbf69199c6ce2b4c092a3f4d2a56fe5a33a00757f4d7dee5dfb0524311a97ae0668a47971b95766e2f6dd48c3f57841f91f04a00ad5ea70f2d479a2620dc5cd78eaab3a3b011719b7e78d19ddf70d9423798af77517ebc55392fcd01fc600d8d466b9e7a7a85bf33f9cc5419e9bd874ddfd60981150ddaf8d7febaa4374f0872a5628d318000311e2f5655365ad4d407c20e5c04df17a222e7deec79c5ab1116d8572f91cd06e1ccc7ced53736fc867fd49ecebe6bf8082e8a +99003c79008e00b33fe9376d8fc53d0650b8d7c7933449816680d159ae73e249 57af971fccaec97435dc2ec9ef0429bcedc6b647729ea168858a6e49ac1071e706f4a5a645ca14e8c7746d65511620682c906c8b86ec901f3dded4167b3f00b06cbfac6aee3728051b3e5ff10b4f9ed8bd0b8da94303c833755b3ca3aeddf0b54bc8d6632138b5d25bab03d17b3458a9d782108006f5bb7de75b5c0ba854b423d8bb801e701e99dc4feaad59bc1c7112453b04d33ea3635639fb802c73c2b71d58a56bbd671b18fe34ed2e3dca38827d63fdb1d4fb3285405004b2b3e26081a8ff08cd6d2b08f8e7b7e90a2ab1ed7a41b1d0128522c2f8bff56a7fe67969422ce839a9d4608f03 +fd964eab80f6a8312f8366ce864f6dd5047c80f8b39c56fb7e0abeb35cd9a5af 04e16dedc1227902baaf332d3d08923601bdd64f573faa1bb7201918cfe16b1e10151dae875da0c0d63c59c3dd050c4c6a874011b018421afc4623ab0381831b2da2a8ba42c96e4f70864ac44e106f94311051e74c77c1291bf5db9539e69567bf6a11cf6932bbbad33f8946bf5814c066d851633d1a513510039b349939bfd42b858c21827c8ff05f1d09b1b0765dc78a135b5ca4dfba0801bcaddfa175623c8b647eacfb4444b85a44f73890607d06d507a4f8393658788669f6ef4deb58d08c50ca0756d5e2f49d1a7ad73e0f0b3d3b5f090acf622b1878c59133e4a848e05153592ea81c6fbf +58368a57250f3ec6e32f5e94c9ea9d7e7d23053af6ad005fe7c2dab1379ddbf8 7c815c384eee0f288ece27cced52a01603127b079c007378bc5d1e6c5e9e6d1c735723acbbd5801ac49854b2b569d4472d33f40bbb8882956245c366dc3582d71696a97a4e19557e41e54dee482a14229005f93afd2c4a7d8614d10a97a9dfa07f7cd946fa45263063ddd29db8f9e34db60daa32684f0072ea2a9426ecebfa5239fb67f29c18cbaa2af6ed4bf4283936823ac1790164fec5457a9cba7c767ca59392d94cab7448f50eb34e9a93a80027471ce59736f099c886dea1ab4cba4d89f5fc7ae2f21ccd27f611eca4626b2d08dc22382e92c1efb2f6afdc8fdc3d2172604f5035c46b8197d3 +670b36f976b82bd7b2721f1e6c970359e51d88028e1301c4795ccf5eb2f19851 e29d505158dbdd937d9e3d2145658ee6f5992a2fc790f4f608d9cdb44a091d5b94b88e81fac4fdf5c49442f13b911c55886469629551189eaff62488f1a479b7db11a1560e198ddccccf50159093425ff7f1cb8d1d1246d0978764087d6bac257026b090efae8cec5f22b6f21c59ace1ac7386f5b8837ca6a12b6fbf5534dd0560ef05ca78104d3b943ddb220feaec89aa5e692a00f822a2ab9a2fe60350d75e7be16ff2526dc643872502d01f42f188abed0a6e9a6f5fd0d1ce7d5755c9ffa66b0af0b20bd806f08e06156690d81ac811778ca3dac2c249b96002017fce93e507e3b953acf99964b847 +f3c709173cc867ca763b5192c3eaea5050fcb74f97155b6e0ae9e66abf0c2c81 d85588696f576e65eca0155f395f0cfacd83f36a99111ed5768df2d116d2121e32357ba4f54ede927f189f297d3a97fad4e9a0f5b41d8d89dd7fe20156799c2b7b6bf9c957ba0d6763f5c3bc5129747bbb53652b49290cff1c87e2cdf2c4b95d8aaee09bc8fbfa6883e62d237885810491bfc101f1d8c636e3d0ede838ad05c207a3df4fad76452979eb99f29afaecedd1c63b8d36cf378454a1bb67a741c77ac6b6b3f95f4f02b64dabc15438613ea49750df42ee90101f115aa9abb9ff64324dde9dabbb01054e1bd6b4bcdc7930a44c2300d87ca78c06924d0323ad7887e46c90e8c4d100acd9eed21e +8f0ee8f68f79eb91fb9efc57346fc8ae2dead528bca0823db1f1ec584f10bbf6 3a12f8508b40c32c74492b66323375dcfe49184c78f73179f3314b79e63376b8ac683f5a51f1534bd729b02b04d002f55cbd8e8fc9b5ec1ea6bbe6a0d0e7431518e6ba45d124035f9d3dce0a8bb7bf1430a9f657e0b4ea9f20eb20c786a58181a1e20a96f1628f8728a13bdf7a4b4b32fc8aa7054cc4881ae7fa19afa65c6c3ee1b3ade3192af42054a8a911b8ec1826865d46d93f1e7c5e2b7813c92a506e53886f3d4701bb93d2a681ad109c845904bb861af8af0646b6e399b38b614051d34f6842563a0f37ec00cb3d865fc5d746c4987de2a65071100883a2a9c7a2bfe1e2dd603d9ea24dc7c5fd06be +5b7566600a0ffaff5a7d540e68f074c26bc78ad664c37af2deb6acc67bbbf8a6 1861edce46fa5ad17e1ff1deae084dec580f97d0a67885dfe834b9dfac1ae076742ce9e267512ca51f6df5a455af0c5fd6abf94acea103a3370c354485a7846fb84f3ac7c2904b5b2fbf227002ce512133bb7e1c4e50057bfd1e44db33c7cdb969a99e284b184f50a14b068a1fc5009d9b298dbe92239572a7627aac02abe8f3e3b473417f36d4d2505d16b7577f4526c9d94a270a2dfe450d06da8f6fa956879a0a55cfe99e742ea555ea477ba3e9b44ccd508c375423611af92e55345dc215779b2d5119eba49c71d49b9fe3f1569fa24e5ca3e332d042422a8b8158d3ec66a80012976f31ffdf305f0c9c5e +5891b9af920b0a1832a705dc04c1ccb7653eac7686377909790545906066a0f1 08d0ffde3a6e4ef65608ea672e4830c12943d7187ccff08f4941cfc13e545f3b9c7ad5eebbe2b01642b486caf855c2c73f58c1e4e3391da8e2d63d96e15fd84953ae5c231911b00ad6050cd7aafdaac9b0f663ae6aab45519d0f5391a541707d479034e73a6ad805ae3598096af078f1393301493d663dd71f83869ca27ba508b7e91e81e128c1716dc3acfe3084b2201e04cf8006617eecf1b640474a5d45cfde9f4d3ef92d6d055b909892194d8a8218db6d8203a84261d200d71473d7488f3427416b6896c137d455f231071cacbc86e0415ab88aec841d96b7b8af41e05bb461a40645bf176601f1e760de5f +6a37845e39b935d5cc07e9b1171c1903f609189fc285602d5f3005bd115f218c d782abb72a5be3392757be02d3e45be6e2099d6f000d042c8a543f50ed6ebc055a7f133b0dd8e9bc348536edcaae2e12ec18e8837df7a1b3c87ec46d50c241dee820fd586197552dc20beea50f445a07a38f1768a39e2b2ff05dddedf751f1def612d2e4d810daa3a0cc904516f9a43af660315385178a529e51f8aae141808c8bc5d7b60cac26bb984ac1890d0436ef780426c547e94a7b08f01acbfc4a3825eae04f520a9016f2fb8bf5165ed12736fc71e36a49a73614739eaa3ec834069b1b40f1350c2b3ab885c02c640b9f7686ed5f99527e41cfcd796fe4c256c9173186c226169ff257954ebda81c0e5f99 +75f8f059e4b0b2fb2900bfb82853956d8ffe148c6f81358923e20c30fd57b126 5fce8109a358570e40983e1184e541833bb9091e280f258cfb144387b05d190e431cb19baa67273ba0c58abe91308e1844dcd0b3678baa42f335f2fa05267a0240b3c718a5942b3b3e3bfa98a55c25a1466e8d7a603722cb2bbf03afa54cd769a99f310735ee5a05dae2c22d397bd95635f58c48a67f90e1b73aafcd3f82117f0166657838691005b18da6f341d6e90fc1cdb352b30fae45d348294e501b63252de14740f2b85ae5299ddec3172de8b6d0ba219a20a23bb5e10ff434d39db3f583305e9f5c039d98569e377b75a70ab837d1df269b8a4b566f40bb91b577455fd3c356c914fa06b9a7ce24c7317a172d +99e19e4026442595d82664cfae29ed302c333ad7cbca30923c54adb03c9a35b1 6172f1971a6e1e4e6170afbad95d5fec99bf69b24b674bc17dd78011615e502de6f56b86b1a71d3f4348087218ac7b7d09302993be272e4a591968aef18a1262d665610d1070ee91cc8da36e1f841a69a7a682c580e836941d21d909a3afc1f0b963e1ca5ab193e124a1a53df1c587470e5881fb54dae1b0d840f0c8f9d1b04c645ba1041c7d8dbf22030a623aa15638b3d99a2c400ff76f3252079af88d2b37f35ee66c1ad7801a28d3d388ac450b97d5f0f79e4541755356b3b1a5696b023f39ab7ab5f28df4202936bc97393b93bc915cb159ea1bd7a0a414cb4b7a1ac3af68f50d79f0c9c7314e750f7d02faa58bfa +9c7f2a286ee619e006371e7bc5a38743ebd7c918a70dcf8ec702a3266dc1da49 5668ecd99dfbe215c4118398ac9c9eaf1a1433fab4ccdd3968064752b625ea944731f75d48a27d047d67547f14dd0ffaa55fa5e29f7af0d161d85eafc4f2029b717c918eab9d304543290bdba7158b68020c0ba4e079bc95b5bc0fc044a992b94b4ccd3bd66d0eabb5dbbab904d62e00752c4e3b0091d773bcf4c14b4377da3efff824b1cb2fa01b32d1e46c909e626ed2dae920f4c7dbeb635bc754facbd8d49beba3f23c1c41ccbfcd0ee0c114e69737f5597c0bf1d859f0c767e18002ae8e39c26261ffde2920d3d0baf0e906138696cfe5b7e32b600f45df3aaa39932f3a7df95b60fa8712a2271fcaf3911ce7b511b1 +011525f5e7b5a6b9148583b92455fe191b44d094062a8e41e1c3d170727d06b9 03d625488354df30e3f875a68edfcf340e8366a8e1ab67f9d5c5486a96829dfac0578289082b2a62117e1cf418b43b90e0adc881fc6ae8105c888e9ecd21aea1c9ae1a4038dfd17378fed71d02ae492087d7cdcd98f746855227967cb1ab4714261ee3bead3f4db118329d3ebef4bc48a875c19ba763966da0ebea800e01b2f50b00e9dd4caca6dcb314d00184ef71ea2391d760c950710db4a70f9212ffc54861f9dc752ce18867b8ad0c48df8466ef7231e7ac567f0eb55099e622ebb86cb237520190a61c66ad34f1f4e289cb3282ae3eaac6152ed24d2c92bae5a7658252a53c49b7b02dfe54fdb2e90074b6cf310ac661 +2b759eed924c58b163bf2106c6e7144215fff943b3c5f7e9628d321030d102f6 2edc282ffb90b97118dd03aaa03b145f363905e3cbd2d50ecd692b37bf000185c651d3e9726c690d3773ec1e48510e42b17742b0b0377e7de6b8f55e00a8a4db4740cee6db0830529dd19617501dc1e9359aa3bcf147e0a76b3ab70c4984c13e339e6806bb35e683af8527093670859f3d8a0fc7d493bcba6bb12b5f65e71e705ca5d6c948d66ed3d730b26db395b3447737c26fad089aa0ad0e306cb28bf0acf106f89af3745f0ec72d534968cca543cd2ca50c94b1456743254e358c1317c07a07bf2b0eca438a709367fafc89a57239028fc5fecfd53b8ef958ef10ee0608b7f5cb9923ad97058ec067700cc746c127a61ee3 +fcb279a3871d89f31de16ceddf78715f4fce578e72ca37818b45db6b38fbf958 90b28a6aa1fe533915bcb8e81ed6cacdc10962b7ff82474f845eeb86977600cf70b07ba8e3796141ee340e3fce842a38a50afbe90301a3bdcc591f2e7d9de53e495525560b908c892439990a2ca2679c5539ffdf636777ad9c1cdef809cda9e8dcdb451abb9e9c17efa4379abd24b182bd981cafc792640a183b61694301d04c5b3eaad694a6bd4cc06ef5da8fa23b4fa2a64559c5a68397930079d250c51bcf00e2b16a6c49171433b0aadfd80231276560b80458dd77089b7a1bbcc9e7e4b9f881eacd6c92c4318348a13f4914eb27115a1cfc5d16d7fd94954c3532efaca2cab025103b2d02c6fd71da3a77f417d7932685888a +b02a0ad3c067ef9c776f6f360eb87052d16246157d3b7710d0bfbcc23641adfb 2969447d175490f2aa9bb055014dbef2e6854c95f8d60950bfe8c0be8de254c26b2d31b9e4de9c68c9adf49e4ee9b1c2850967f29f5d08738483b417bb96b2a56f0c8aca632b552059c59aac3f61f7b45c966b75f1d9931ff4e596406378cee91aaa726a3a84c33f37e9cdbe626b5745a0b06064a8a8d56e53aaf102d23dd9df0a3fdf7a638509a6761a33fa42fa8ddbd8e16159c93008b53765019c3f0e9f10b144ce2ac57f5d7297f9c9949e4ff68b70d339f87501ce8550b772f32c6da8ad2ce2100a895d8b08fa1eead7c376b407709703c510b50f87e73e43f8e7348f87c3832a547ef2bbe5799abedcf5e1f372ea809233f006 +54f167f4d38976677da77439c927ca9d3557fe2f36284dc80ad1b28fbb463d50 721645633a44a2c78b19024eaecf58575ab23c27190833c26875dc0f0d50b46aea9c343d82ea7d5b3e50ec700545c615daeaea64726a0f05607576dcd396d812b03fb6551c641087856d050b10e6a4d5577b82a98afb89cee8594c9dc19e79feff0382fcfd127f1b803a4b9946f4ac9a4378e1e6e041b1389a53e3450cd32d9d2941b0cbabdb50da8ea2513145164c3ab6bcbd251c448d2d4b087ac57a59c2285d564f16da4ed5e607ed979592146ffb0ef3f3db308fb342df5eb5924a48256fc763141a278814c82d6d6348577545870ae3a83c7230ac02a1540fe1798f7ef09e335a865a2ae0949b21e4f748fb8a51f44750e213a8fb +125d1f988c2dd0baef3dacf1ace707efad7cf10fc59647efc85b89f02c5c023a 6b860d39725a14b498bb714574b4d37ca787404768f64c648b1751b353ac92bac2c3a28ea909fdf0423336401a02e63ec24325300d823b6864bb701f9d7c7a1f8ec9d0ae3584aa6dd62ea1997cd831b4babd9a4da50932d4efda745c61e4130890e156aee6113716daf95764222a91187db2effea49d5d0596102d619bd26a616bbfda8335505fbb0d90b4c180d1a2335b91538e1668f9f9642790b4e55f9cab0fe2bdd2935d001ee6419abab5457880d0dbff20ed8758f4c20fe759efb33141cf0e892587fe8187e5fbc57786b7e8b089612c936dfc03d27efbbe7c8673f1606bd51d5ff386f4a7ab68edf59f385eb1291f117bfe717399 +d671202c4c8c57d902e400a3c6264694f316b5ed1d070e03e5cb6c58dea72f3d 6a01830af3889a25183244decb508bd01253d5b508ab490d3124afbf42626b2e70894e9b562b288d0a2450cfacf14a0ddae5c04716e5a0082c33981f6037d23d5e045ee1ef2283fb8b6378a914c5d9441627a722c282ff452e25a7ea608d69cee4393a0725d17963d0342684f255496d8a18c2961145315130549311fc07f0312fb78e6077334f87eaa873bee8aa95698996eb21375eb2b4ef53c14401207deb4568398e5dd9a7cf97e8c9663e23334b46912f8344c19efcf8c2ba6f04325f1a27e062b62a58d0766fc6db4d2c6a1928604b0175d872d16b7908ebc041761187cc785526c2a3873feac3a642bb39f5351550af9770c328af7b +aec42d10e806142442ade3f96e45e4a04a400979fed2eb57e0124aeef00dc16c b3c5e74b69933c2533106c563b4ca20238f2b6e675e8681e34a389894785bdade59652d4a73d80a5c85bd454fd1e9ffdad1c3815f5038e9ef432aac5c3c4fe840cc370cf86580a6011778bbedaf511a51b56d1a2eb68394aa299e26da9ada6a2f39b9faff7fba457689b9c1a577b2a1e505fdf75c7a0a64b1df81b3a356001bf0df4e02a1fc59f651c9d585ec6224bb279c6beba2966e8882d68376081b987468e7aed1ef90ebd090ae825795cdca1b4f09a979c8dfc21a48d8a53cdbb26c4db547fc06efe2f9850edd2685a4661cb4911f165d4b63ef25b87d0a96d3dff6ab0758999aad214d07bd4f133a6734fde445fe474711b69a98f7e2b +a25f5a5ce05551c5b64db6a8f80075085d29e8da2301dc5dddcf730541d6b7a6 83af34279ccb5430febec07a81950d30f4b66f484826afee7456f0071a51e1bbc55570b5cc7ec6f9309c17bf5befdd7c6ba6e968cf218a2b34bd5cf927ab846e38a40bbd81759e9e33381016a755f699df35d660007b5eadf292feefb735207ebf70b5bd17834f7bfa0e16cb219ad4af524ab1ea37334aa66435e5d397fc0a065c411ebbce32c240b90476d307ce802ec82c1c49bc1bec48c0675ec2a6c6f3ed3e5b741d13437095707c565e10d8a20b8c20468ff9514fcf31b4249cd82dcee58c0a2af538b291a87e3390d737191a07484a5d3f3fb8c8f15ce056e5e5f8febe5e1fb59d6740980aa06ca8a0c20f5712b4cde5d032e92ab89f0ae1 +c7e6a5050175e6d8aa85826611d3a1f69ac79a52ad085e5ad269114207031c19 a7ed84749ccc56bb1dfba57119d279d412b8a986886d810f067af349e8749e9ea746a60b03742636c464fc1ee233acc52c1983914692b64309edfdf29f1ab912ec3e8da074d3f1d231511f5756f0b6eead3e89a6a88fe330a10face267bffbfc3e3090c7fd9a850561f363ad75ea881e7244f80ff55802d5ef7a1a4e7b89fcfa80f16df54d1b056ee637e6964b9e0ffd15b6196bdd7db270c56b47251485348e49813b4eb9ed122a01b3ea45ad5e1a929df61d5c0f3e77e1fdc356b63883a60e9cbb9fc3e00c2f32dbd469659883f690c6772e335f617bc33f161d6f6984252ee12e62b6000ac5231e0c9bc65be223d8dfd94c5004a101af9fd6c0fb +50817c02ed8b053460f7cbd00db07056e2e9b07b78ad1c97ccc6f0c18a02d52e a6fe30dcfcda1a329e82ab50e32b5f50eb25c873c5d2305860a835aecee6264aa36a47429922c4b8b3afd00da16035830edb897831c4e7b00f2c23fc0b15fdc30d85fb70c30c431c638e1a25b51caf1d7e8b050b7f89bfb30f59f0f20fecff3d639abc4255b3868fc45dd81e47eb12ab40f2aac735df5d1dc1ad997cefc4d836b854cee9ac02900036f3867fe0d84afff37bde3308c2206c62c4743375094108877c73b87b2546fe05ea137bedfc06a2796274099a0d554da8f7d7223a48cbf31b7decaa1ebc8b145763e3673168c1b1b715c1cd99ecd3ddb238b06049885ecad9347c2436dff32c771f34a38587a44a82c5d3d137a03caa27e66c8ff6 +129204aad1026c8241fc19d5a042afdc8c760703be1e68e8d81741bc537d5484 83167ff53704c3aa19e9fb3303539759c46dd4091a52ddae9ad86408b69335989e61414bc20ab4d01220e35241eff5c9522b079fba597674c8d716fe441e566110b6211531ceccf8fd06bc8e511d00785e57788ed9a1c5c73524f01830d2e1148c92d0edc97113e3b7b5cd3049627abdb8b39dd4d6890e0ee91993f92b03354a88f52251c546e64434d9c3d74544f23fb93e5a2d2f1fb15545b4e1367c97335b0291944c8b730ad3d4789273fa44fb98d78a36c3c3764abeeac7c569c1e43a352e5b770c3504f87090dee075a1c4c85c0c39cf421bdcc615f9eff6cb4fe6468004aece5f30e1ecc6db22ad9939bb2b0ccc96521dfbf4ae008b5b46bc006e +d02b055958e12ef6f499f400144d2b8fb8b4e8975be487a2fb3b135646783974 3a3a819c48efde2ad914fbf00e18ab6bc4f14513ab27d0c178a188b61431e7f5623cb66b23346775d386b50e982c493adbbfc54b9a3cd383382336a1a0b2150a15358f336d03ae18f666c7573d55c4fd181c29e6ccfde63ea35f0adf5885cfc0a3d84a2b2e4dd24496db789e663170cef74798aa1bbcd4574ea0bba40489d764b2f83aadc66b148b4a0cd95246c127d5871c4f11418690a5ddf01246a0c80a43c70088b6183639dcfda4125bd113a8f49ee23ed306faac576c3fb0c1e256671d817fc2534a52f5b439f72e424de376f4c565cca82307dd9ef76da5b7c4eb7e085172e328807c02d011ffbf33785378d79dc266f6a5be6bb0e4a92eceebaeb1 +3ba8fe77b8bff4b015fae5f35eb8c70df5d8fd754abe426d694be5d19bf3bb97 724627916c50338643e6996f07877eafd96bdf01da7e991d4155b9be1295ea7d21c9391f4c4a41c75f77e5d27389253393725f1427f57914b273ab862b9e31dabce506e558720520d33352d119f699e784f9e548ff91bc35ca147042128709820d69a8287ea3257857615eb0321270e94b84f446942765ce882b191faee7e1c87e0f0bd4e0cd8a927703524b559b769ca4ece1f6dbf313fdcf67c572ec4185c1a88e86ec11b6454b371980020f19633b6b95bd280e4fbcb0161e1a82470320cec6ecfa25ac73d09f1536f286d3f9dacafb2cd1d0ce72d64d197f5c7520b3ccb2fd74eb72664ba93853ef41eabf52f015dd591500d018dd162815cc993595b195 +0fd8e7ecfa2f0004a6b5730a40e84b5740f90637a95c19d513f60c32feaa32c8 3139840b8ad4bcd39092916fd9d01798ff5aa1e48f34702c72dfe74b12e98a114e318cdd2d47a9c320fff908a8dbc2a5b1d87267c8e983829861a567558b37b292d4575e200de9f1de45755faff9efae34964e4336c259f1e66599a7c904ec02539f1a8eab8706e0b4f48f72fec2794909ee4a7b092d6061c74481c9e21b9332dc7c6e482d7f9cc3210b38a6f88f7918c2d8c55e64a428ce2b68fd07ab572a8b0a2388664f99489f04eb54df1376271810e0e7bce396f52807710e0dea94eb49f4b367271260c3456b9818fc7a72234e6bf2205ff6a36546205015ebd7d8c2527aa430f58e0e8ac97a7b6b793cd403d517d66295f37a34d0b7d2fa7bc345ac04ca1e266480deec39f5c88641c9dc0bd1358158fdecdd96685bbbb5c1fe5ea89d2cb4a9d5d12bb8c893281ff38e87d6b4841f0650092d447e013f20ea934e18 +cb845f14c0175e28820566c2c0577d21b66c7abc3a0dd18f2869cb9639fbe62c 023d91ac532601c7ca3942d62827566d9268bb4276fcaa1ae927693a6961652676dba09219a01b3d5adfa12547a946e78f3c5c62dd880b02d2eeeb4b96636529c6b01120b23efc49ccfb36b8497cd19767b53710a636683bc5e0e5c9534cfc004691e87d1bee39b86b953572927bd668620eab87836d9f3f8f28ace41150776c0bc6657178ebf297fe1f7214edd9f215ffb491b681b06ac2032d35e6fdf832a8b06056da70d77f1e9b4d26ae712d8523c86f79250718405f91b0a87c725f2d3f52088965f887d8cf87206dfde422386e58edda34dde2783b3049b86917b4628027a05d4d1f429d2b49c4b1c898dddcb82f343e145596de11a54182f39f4718ecae8f506bd9739f5cd5d5686d7fefc834514cd1b2c91c33b381b45e2e5335d7a8720a8f17afc8c2cb2bd88b14aa2dca099b00aa575d0a0ccf099cdec4870fb710d2680e60c48bfc291ff0cef2eebf9b36902e9fba8c889bf6b4b9f5ce53a19b0d9399cd19d61bd08c0c2ec25e099959848e6a550ca7137b63f43138d7b651 +a7b21a59258ecd632ed35c2118e0072b1571e45652f5a9d04a8476db1338d0aa 20ff454369a5d05b81a78f3db05819fea9b08c2384f75cb0ab6aa115dd690da3131874a1ca8f708ad1519ea952c1e249cb540d196392c79e87755424fee7c890808c562722359eea52e8a12fbbb969dd7961d2ba52037493755a5fa04f0d50a1aa26c9b44148c0d3b94d1c4a59a31aca15ae8bd44acb7833d8e91c4b86fa3135a423387b8151b4133ed23f6d7187b50ec2204ad901ad74d396e44274e0ecafaae17b3b9085e22260b35ca53b15cc52abba758af6798fbd04eceeced648f3af4fdb3ded7557a9a5cfb7382612a8a8f3f45947d1a29ce29072928ec193ca25d51071bd5e1984ecf402f306ea762f0f25282f5296d997658be3f983696ffa6d095c6369b4daf79e9a5d3136229128f8eb63c12b9e9fa78aff7a3e9e19a62022493cd136defbb5bb7ba1b938f367fd2f63eb5ca76c0b0ff21b9e36c3f07230cf3c3074e5da587040a76975d7e39f4494ace5486fcbf380ab7558c4fe89656335b82e4db8659509eab46a19613126e594042732dd4c411f41aa8cdeac71c0fb40a94e6da558c05e77b6182806f26d9afdf3da00c69419222c8186a6efad600b410e6ce2f2a797e49dc1f135319801fa6f396b06f975e2a190a023e474b618e7 +74b1c87769e4c7de854beae03fe026d4c2b4a026dcf2220818c5b48f728608ff 4fbdc596508d24a2a0010e140980b809fb9c6d55ec75125891dd985d37665bd80f9beb6a50207588abf3ceee8c77cd8a5ad48a9e0aa074ed388738362496d2fb2c87543bb3349ea64997ce3e7b424ea92d122f57dbb0855a803058437fe08afb0c8b5e7179b9044bbf4d81a7163b3139e30888b536b0f957eff99a7162f4ca5aa756a4a982dfadbf31ef255083c4b5c6c1b99a107d7d3afffdb89147c2cc4c9a2643f478e5e2d393aea37b4c7cb4b5e97dadcf16b6b50aae0f3b549ece47746db6ce6f67dd4406cd4e75595d5103d13f9dfa79372924d328f8dd1fcbeb5a8e2e8bf4c76de08e3fc46aa021f989c49329c7acac5a688556d7bcbcb2a5d4be69d3284e9c40ec4838ee8592120ce20a0b635ecadaa84fd5690509f54f77e35a417c584648bc9839b974e07bfab0038e90295d0b13902530a830d1c2bdd53f1f9c9faed43ca4eed0a8dd761bc7edbdda28a287c60cd42af5f9c758e5c7250231c09a582563689afc65e2b79a7a2b68200667752e9101746f03184e2399e4ed8835cb8e9ae90e296af220ae234259fe0bd0bcc60f7a4a5ff3f70c5ed4de9c8c519a10e962f673c82c5e9351786a8a3bfd570031857bd4c87f4fca31ed4d50e14f2107da02cb5058700b74ea241a8b41d78461658f1b2b90bfd84a4c2c9d6543861ab3c56451757dcfb9ba60333488dbdd02d601b41aae317ca7474eb6e6dd +602b8c111bd1aea29475e0582c11ba77891f499fbc3277207b606d93936da730 fe06a4706468b369f7624f62d04f9fac020f05152f13e350016b2a29efff9a393940c138553356b0e2848c01b622b95ffa11ab07585f7dcbbf90e9f8ec5fa2fb7b4cee0d0a4e8d33490abd058cf3bb85f0cd9b1bd3e9823082d70b1a92aca6f2c87216b4ba09feddcaa4cf254336146cc75604fb1f286918fa2434ca36be2621049438a400bdeea6c657f0301503cd7e6e38350838f60ea7f001755da4142ce4579b39029da83f1646b7ecb9947ee89aba377099b82026960b9ee600779bf00d6eb0cd09226db6915a7aded27e6749e2cbc2c8b030ce1850ebfbe24c0658f29e9e709cd10db8a77efdefc90fdd7b9ad7a7e0334412a53d248c4c12bf2987b7accd2a8a602f184583aa560c016093b56b100154477b834664e6b85a19f8dc909b4d79816af12266c731e29a304e9bed8ef1c8030365b7deaf3d436957308117c7c5767e0cda6e342ddaf824233cbf4e699dc667357cb35c602ac6bddee71b352af55cb93941a1a6301a9904447af9ee486114d57ae03901f10084adc0096e465e2ead2496273112f2fae626e230d42ec22ea10a8289b3e35eee42150769d6e663a3ca29174316ec93a24f148d984053b8f98664eaca3e0dea0b42e8ee30f81a2cd6e42c189a25fecb6e643e693e1f8871b837c3f5ff2aafd1650a465dc8e5c1993be65cffd87f2c680c86b0ad3118834a5f2e490015137ba945c2775dbd77fb3e5c67819a9a7a94a656fc4761659c5b30ed2ac55a6d249b700bc9c93d590490aaaaa75a9fc34a90d5a9106f2860bde19fe5815436068a7f8ea4636a +40186e41ac117aabf2211e154a5a9cc41a2798a814dc4491bfae9dd6f2c810d5 d0ff6e045f4b636f75a389799f314066644854821b6e7ae4047adfde2d0c0e02c250f0be582bec94011189b964a8af430f5921ed9d9f4446e4c788515b89ca69e5f7cdfccc9e83e8f9460145b43ddc41c07cc512b7e6fdd0e1e7aaba29a6c016ccb7bd54b145f3951eab9bc4908f623e5a9b0c5b36056292540b79fd15c53457dc74a65fd773a34d6b313a056f79bc29a3fac15f6a1446bfaeeaafbac8ecf8168dde5f6ae6b6e579bd3ce74e7abfadf361d0fd32d56586a8d2d4ff4cfdf8a750fafde4c2e9eb32b06847fa30b13cc273532d1a23c8257f80c60b8fa94fa976f534145cd61c41c0a511b62cadd5848ceff643f83ce43f8e6969c5a559afad60e310599a34b2e5e029fbddf2988fce59269c7128a1fc79a74b154d8aa2850dcfdbf594684e74099e37882b440367c1dd3003f61cafb46ac75d30e677af54559a5dab70c506cf61a9c35e0e56e1430746916ddeec8d89b0c10daa02c5d7e9f42621d2b312eaffc9ff306297952a32d26c2148570aec90501ca739ce5e689e7066d9580a4fc25e2023897c74c6856273133e1275a0d275dc5b75db724cd12c9c01bb95ab5a227b7850020630506096878d289923177183ea9282a4c78ec212d2e898cb99d81a3364df20927ee34d4475a5cf5cdb24088ed75b60201922e9c972d8556ca75f8274d15f3fb88a6b42c766def6b21329dee7c457446dde8c26405fe5d0309a04229f449e8490cf9000ee8df400cb7c7ee831bd7059d24088fb42d61681cde45050fca78ff64d9c8d1f58b55f802fa5d2f2e723f3e4eed4338b060d31c8acc46d26870bd45d0de0798d48e32aad1a6d4322e69f5e72309b9d7fa1f24bb1d63ff09ed47391c232497bf222c542a70975c8292d275197a4ca +646d9537d4a57ccf63922c94d5a4777034e55a8b0aeb4b990ec78254cd939a03 c9a0b51f3199339c11a5753c9d9c95104b400127087177f14d3e15be881ee89bf416f97d4f7aa9636c5ef29ebbf8930804006eb26839415d3984b920882499752c36a5bbd583308e716db16f28db98b3a3e718a2ebcdfefa75d7ccbb6a746e32feaa38d034843461dbcfca7f983e19f5b23ec2e3d74d2b4402f3bdce7d7a9df1384668c746cce466b0654cdd5ca56a77d68a100ae06d63cd9af512aebae78993808ce672330e2065c0f71e05c0fe821cd5f85732315f04666f3e4e6c4f3e9f415e31fe0980d874994108e12464609c6d5c19cedfc85846b0a84ef3ccbd3b655fb0de8cb892bdf774df39c955f04f322856d470981beed0f752d82ead73b4131c5dbf0424b4ab654f72e26ef0cd292b87bd5b66fbd5e7eba96c62cffefd4b1d870bfef312b86e38ed5c0f50935e2ecf9fcb8c95d35d19a8fc8f202bd9dba768ca48fbbb071179413c0de4fde86762ed4b13e1eef2a00add5d1c2a3af7937787debaf1f6f12f3f0225ffe587a5540cb550f7bc11dd6af864d6b6d16db1488cb226ebb2199da75fdd59a71158867298f63961b40a31209f8f16629b1cce7ffb617072748fde8920d11cc0d0678389d1f719df3ed19846fe9893b04db60fa603170d9573b1bfc7da663e07254552ab6253dde814117185f84373fecd7f98ded170c884d41d1ac81814c73ea48ad94eca1b7733d8393e320c8c467ef6189b4ac324c68c8a2ecf679c893b7dbc4310cd05dadd80bb6326b51ecd99a441bff77be8d644d752f3c5c794e7d45ba76283acf8913bbf2a420f9e5d14d7a23e95fdebc69b455e466423012e9d1de9353e40d4bdc3107c3144b96c6dafd41ccefeb2b7ff848cb9fdbea8648be32160fab7e7dfccb807fb019ebf159231edcf2d487d76a3e882f3f50ca48dd08a23b06ee887bd7df9d7c6cc2bdbe348e3125c4532448f400cd57a8679abab13e582b13d49442638e2698fb7a563c7fb264157 +020462553fb0c1179c0097b06448a192e7e2c0fd2652b2f2e2258635eb2772e3 da5b2118cbd59f408ce56362489fda69ef73172f46dec16c0d4a66e3f3cca373927cb6784ce62bbcb08a490d003a8f77391e82cdd87860909383b054db95816720112e2f96de9e0ffc8babc1350ed46b9aeb5d46b66940efa311f4853f3118063c550733e7679d871729001c12270e98439e375e0cd24769d318e03cbc97d643f1dc5f1b5ef59d12789f22449bd8fa43a13ce78a4186166523f3807b0b621079cc528f4e17c258d4f9bdd095a3e365614b94f2cd778cacabf26244891531eedc24e1bf4598319eb8b7527736bb1e734429360f47f04b2e95d5aae997763a467cc5303d1141c2c01f7ab9edab860d180697c906ce1558aeff5adce603f8a4a10fc6c1699189e73b489f64cefb89ac557c5bb8826c0317eaef2302e855fbd96777898104365d96ae8a8ed8669c568c4dbeb0a70f6cf4c22fd933014473f91871c08d5a7b44a928295fb2aa56d5e2c39ca79d2837fb39b35c6810c378d749aacb543368a19c137b872229e0a6f469022aa93bcb2be38b761c85ac09415ca7deeb38ff2a2101507206fe322a89666d32750af0f4d7b2e59571f02a048b8f94fe2d231072e301c8641d1cdb4f841ab165af297495a348bccd937712e68852a4aca948c1294f8b733d06d67de89f206498dd401e149fcc1edca92deb92952ede4ebdc7cd7992104769a04de8705027a31337b88e8de93f6624e8f10b9f9924e8ce5a9d841c9260753fa1492cddffe6b4400c5719d76fb5b01b234f32ffe64f04d0a00676fbfc58dbe17b4d552fdf0c5b802c0cadf723f73f86e8ffc493992d23e8c0b84f7220a983ddda21170b1f730c736e75549af6ecb8dc94fb25c26bcddee420c83e8a45ae4c345816b7163cfe016dccfe47c66979d610a7f9b4a7b1ba5e230344c9f46ba076f2fcea68aada8fa09bf0b5cbb3850ddedd80a30e1f7a639ac69e5595c6a4083aa959831ebbeb84c018068723192f58baecddd18c857e212d4c7e7215b6c954728183fbaa07720b97189af6a7729c30d28db33a889f225d027d164f254535770c504c506aee4ec4676771f69f935ba08a1c6c85 +ce89eb5a515df08ccdf2e5a4cca3e5ecf5b4c170c68277a1457a368e46cb3763 d1890b4704e169c28e44ddf62a1091450404910539fc2daeb26e8acf4533b024e5215c2d02820dd8fb2cfc1743955cbacff0f8f35dfbb5e3f942f36247f68211d518f3f601aae12a1cdc000bab43d4c973f287e80741dd1fcf6c34f2e6b4b6c313d01c4ff3cbf9166f26946f18ef2d58271ba9233f09a6b77bfd4f48b36eb3d73d1133c4f842a7dc3907f680b0b773242c11e3dd973a44327ea7cea9c0f8e07d682b6651e506b587559fe01ed721000baf570a16fbdd9ea29fa3def4be912058321a8b720c5c102e48a6e7ed6f8838d400dd57d06eedbcd15323f86d855c94b21e41b14ec9e1bbc8019211fd88138c91f9abbd9bb3914d26c1ddc21673d2d51263b39d66e741d924cf2b192c5d2c1a140126a3d64a2c77be6c2c6ebe8599978ae90bd36cbb9af64d078910c4094ab3bf399c34f2ab8ef843e9fe1bf88bf443ba21e4377e5f49c07fd9653b526e14562237f02d11b904bca6ac31ae721a43e3c4910a24af6f4d80c031c109fc0fe49f15274bca92bda04c3b4196c192f6ce489c63a806acfc895ab52cad657c1783b528e12d0ed856e1f8fc91f2aafdfa0a92498d68530772ee73b359fcf1418d1096c46b34dcf90e5b468bbb2970becbd70089cfb039d64cc50fff5eef26384d34f24515a6558b06a1fdd88f1050c5bd78cc6ed83d4c2b0e882aebcf84afb0430d0bf09f2fb42b8b4589158093a7709aae75a790910e211ee1333ffb6fd80778da3bf73858978e9dd647978841b18001dbaaea43ca0c0a03dbb9bcf30ce76a6f4b2cf2a9b6531b3e4051e7e05090cd421bc66c4731e7122ad129fc42dedc83bb460e3f889992fbd3ca072686e56b72c720fbc98d723ef7f247286f77ccddc728738e941b1a74d4f16671c21fdd5643a115ddbcb88ee7ec67ea66fd2bce718df6e085d4b5fc71a72696636a8f7b3a68afa51a896771faaa7f1f827430ac5e8089dbc0d4175e1b22a057bc5f1724eadc1a41e78fa3acaa8b97e5f2e19ef9d59ae12b04e7f0e8a621e098a66910e2a5ed2102b824cd3ea044a854f1cd0b33e61e7f737414b2953549f25dd34d19aa1981de7cd5649ff6c6364a4f25312ef62395a747ab88aad722c05aec40deea8eee5e779ef458a68840bc6bd5d29ad40f98b3ae010b6213372abb7bb8b8 +dd3bad1e796defbb340900bd12070a7c4d2cb511116602ddd8ad8d093acc9c40 d9257004993c7ae50d20f534b42b4ec39bf358393b9fb5c8e37f87ac7361354554be596f40e67b2ed499887e26dc435c4331cde3bf1a118f60fd821477ffa3b92f6469568cd2cda6fc0a2b13906ae459cf5d5417de2ce104d0b6499d3683beb40715582ce70ded5c5f8461edeaa38bfa31979661a2dc96d926307128f77700f2c7d38b8a9d6c6f70a3973005350f938b9b4a64e228cc3b3f9c4fd446fc650aa6377152d7f46903d8ec8e9340710e28475cf21e641737e7d7da3cdf18d01c8f37131e727c7274b2db759c5586fb84ec36a5ce2d820e553de6426b8b96111295c19dba8d17a2b7047fcdf662a59c2af27a9abee37a7f8afc06944346e343e779ebd895119d7460e7da998962fb1100e950a8d7fe214360ad263b8d070f2b7dc91c9d77c6692da0f472a0a4646a1edb069ccd9ce4ca6fc24713d650153b9a253db5136a3710198e60934dd2053315d313e27dd2c6ffd2ecf028625f0e937afd8c2ffb1f646e51a768204d83a649798a51b8e87fcdda7bddf58ed943bb7e29c7d7c5dff024545f6a689aa0e727fecd80b561011a731acdd9b3f283123098ba66b6b9fce6123b35b6f3a20ef1055be9e257cde97e5af41eb796438727a62aa665cc9b771c4a2052efac61bc91bcdf573f7263107d44dfeb125e66d1f3dded3bd63845af3bf4185a9a24a7f4b777c32496a6107b7ac940af24be983f6a758e5064f8717eabbb86e6aada7da75f72abed59a42de82b1aa2642f5ef1b2e7304f642eb2aafbf00c1183d9b5fb83893edd48e9034dc7a7ab66f3f392f9666c00ecc9743ac4f777edcf47b6818a34b7392b4ab8e38891fab4018dfb99af06369115d60c4fa073240d9c2605e020a42db2e1e0ae4ade3a04b825927a05d4fe3f50c1c7add7a496da7e95825c064315196c2007524d1e1ef2c51303dd1203ab66d9fe89de553cb4b95a6c5d629b89b7116463ee10ab3cf2c2615f95741ca226f9e9a20e99303888f725c77476533b4c393763170f18f292c89a22df68eabdb81aef11cc2ac329c174bdae5d3cc0bdcea6eb225e00c15021432264ba7c5eb49a49231d1f7a13afc238bd4efc04da3c15ae0bb7d693a0150e6a5ad9b1e11a490b3ce90c027442501684c528fe260881162d9e5ef84d6e4f73f222e779e58b71d5176d9a27f65e49d83efbb2d7810e5b06619d8cef7e7b51cdfb6e8138e4cf5674242f947eac13fad08d68a8a11aac9754a5316c93738ba7f3c3bd2e827a +438850d222c5e013dc4411d46f5febbf30845f567346348bc3f38362709be423 09cf132ab943654184a3fc8d0368b421fdac4ef1081a29f3691a527fbdbd74c6372233b38dc432ba610f9c54fa68699f9ec2a6bfb0b2cf7aa6d10ae2207a7554163aa14fb6a9cfa023ce63546b7b02af03370a899ea73b27bdb5c380613c0ea670c659803d5f6f75c0ce62b311dc157de843a93905e7a28a2557684ae3db4fd009412a107098f881dc06622ed9e3df2c8fe69fe50bfae158b87ca761fe1e221856610bca301ee68958c25bf58d3be203af928a919ace53c3d99f55ab00dfc8a1a28ab83e78617f194efc46daa77573d02ffcaa1f9d96fd8da8dead3d4e75ee5e65fc360b2a567cd34d52bc9aab8b71160312e8e21aa506105d6644e6863e7d5e75ed47c1760743d113a4526553b303341fcee5fdd005d35929f2afa760bb8314d0c0eac960fda3263a1e6688098251618c90332005c757af958714571b77bf2a69030d99f71d1a5259658be565fbd098070122c43edfd400999c90a98ace95315faee4f1c0441c9315d527c7ff1a8171415d2a076e2c513d40b03cfe5513c0e74ea3a03ad4958c00a3e1916d34273e301d517b0a5e770393880d9afb4d0eb44d3140ff7d827c48f67c6d92b865d8fe7c7e45aa50dfd8525f530de1188f3af98b3dc625d335e191fbad5ee9df09c97b43f203bfed798f7d171bf00c82ea0ed17d5890c3d6b9ef6fdc04c5ffb645e3050406fe2fb6bdbe2ffe083e751dc19f2f06445397019b61cf1f505875520f09c6b719e642b81b2fbfbdcc072b7981a666d51e7065e21244679dfe056bc9d42b8851f9d2905fd838707b279a8106eb894b60a72e4851c344119ceeb5bbe110b1c5b21c9a5f7545283002d4b1c115308b1cb20f6d9cb869ed0459c569662aa5729a7d7178de7d69e4885ca77c011e785ecf0e2ecbb8f5245579dbef7a5eb30307e0b40b817bd1112d28eefd548374bc867e0c34d2236952b9f859903e87e977190ff94f5d815699154f96e5449ddc1a14e4196c83e4fb02f5f58c30eeed691de47c81f4883bd84f6ed711fed0c198bfa2b8296182d7225e8989acf55d3612a93e77d24f7b6eef813fd514ce2183571602976391f5ac4e86da59a64233230fb67ff0bb9ec40667f54ccb235d04b3fe1d9a47e163cb19c316046fc1353a6642219e9cecf6e3151c0f4fae1177b67f19b4964df96bb6af37012b8ea9e5ee24c57a010c872b15c8a65d0266589f6da20e38d9be2e2c215c69f558084e48eeb61f4eaae83c57f3f1cd08d05783fb9f5ab1cda5e4b86291fffb14fe9b497ec73292bbd295c5657d71cc74d38a2f3db73ba972986b7169f76ba376376f4747ed65f2f1a5e67889af38a380 +512322f446325c72685b43cefa3dacaa0f5893bddaed564a913819da894589ad 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 +5c28a91d387b46726604a31722cdd51b71f1e4cedd8de1bd4897d728933e5821 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 +9d1ec3e11e9a8f26592369c84e0d4eca78ad119cadafbc42dc7bad7a3062b23f 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 +d284e71126466c74b67a08a05881579aabcd3a9aea86613b596c80a198e9304a 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 +cefa7d1963ddc5e87cbc0e5f5192e8bf37d4c4b51a46c5c1760c451232e5671d 218a31573465b8a543e293e5a591113e9cccd2095f519d2b0d7a195a625950ae2fd52ad7d5e5c984e5bca89f7fbaebaaf4686db96826e8e0cdef1b787cd08129f7ac7bb0e1635f7f52c5b6d6497a0db6125bf0b2fdc06c8f72fe16f4d75d5ef9620786c85d0c128aecdd362390039e2548d1dcaa008b0fd870be34e40e66c0aefca28bc631b8fd8031fe7a5f39e81d19c0cca18f1aecbb8ae0c9a4d10b85393cb58412b565a29999cd039883eb095547e8cbf589b086444f0ec302236e6efc508c3c08873cfe13d565f5508790fdac239158ae65a23819f365ecbf4586eaaf39a5b73ce6afef6533d56d20758720f22e27e2a4be08659b5b749ac209910eaf590e5d1276b8ce3bcc49331fe73813417c0b1e6efbb2418c82724607032433a0d720c381474eba5749305d8fee1230ee0bef48286e602c593b9c5434cd5e4daa36ed48c47bb9b540f077d21feff369179c443665ccb98ba0d5a7b8932a8dd7d5dc020f6261e24fdea9c6611a096bbffc44aad997c7bb3ea32305a6ab41e33c55f027d3a990520017cb8cc95094d225c98fe7ffc21c4480967376ec8a22b2216fe467c49e50ed8ccc42fe9bb3c5210b086a9ff194074842affffda8f4734e354c971ddaa48f38fba1b7d5cd74f7433ef5a45d0f6cf1d99080c2a7c0dea6e8adf51bd59aaa502e75c96bf6d53974da31af027843f3afcc34ce1ecb81b614e9d2c382d8b0b6007cb4c54ec507feebed9992df8d1251c74e79b570ee4c268d8e03cd8573005f17dce24c6a52c076995e72ab5f72f290682081932e3357f4cf0659f5ac6a0d324c9f52811bb52c9cd0cc858178b9283aa53c523045004b2b55bc273a49cac17b95e36f8d39c64877530141c668da715c3e1b2e2172422728c1f7c1fdd3476d13487f193cb18c1fcef43cce594b548f164a24d2e0c15dd4f65614c0f0bed2597b453a9349ec79f154e52e9fb74eb55161466617943cc9189e681a3ca51150ce23b3009ae991649c882629f76ffa9161baa1d02042baf0d816bacc3d3a5c90279f3994d4a5eed4da6495cdf9560e900d7a7e582ccb92e543c3e42abcbfc2a8d53e9141942e3b58115b6b64aa654f9c8ea1b856588d464b9a6a642d0fcf4430b88637206758af500daa35c7b652a844edbbfd908aa93b7929248280dbf48cf1cbabe15aca02fe6d72bfe7fbac98a0032a32346f40b2eceb6de2be6e580f89a86e4eacaf0e952e508537566577dd6de6bef2fc93559b96e64a2a9f9334c3c26d0bbd849788f328429d3a8b26647c96b3d553f380619ad4f799bbbd56aff22ce8b61fe7c18ed88ebb5dbc4796bce01606d1eb762fb11fdbbd3cc6c55aeb68bd93e9f355cf7b07cfd05c2502f0ba792c7703a030c52cbd545f394108140cb9b5a149b616fb6a45dba59b5118b66cb0949a3db9e39ede0abc2e2e4f76cbfc32d7d98d36d23e757f3c5b3cd3b37916b2cc32e4fb4ce191c03edd7ab4f061c5f1075e59328eb696e7d000c9149c93126aad94e30884c976172e75bf25967785ebb5afa68409dae873a612a744a1524c2b96843de61bb959dbc7dc782b42c39171f60c420497db5f77bd5f84b52cc3924605f534005f8068d24c47ef82ed7cd4e5216501c3304bda3659906e8afb98c74f865dab33a700a6c8839e405bc6cee1c361a72fb6baf4b1183fc800bdeedbef141a597253ad54fe11d6db361865dd58825116b534ae08b07586371a3791fc62710c4356e2be12700ddfc7f3e309f5ecac4754a4a2cee266a37d67a3f8cf97c45d37 +cdd9469f7a1bf26309b87c94e4a2448520f3117b5b1607dead52e990ace837b7 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 +7b221a497cdd2bf67e0855f02fc5ad04167f3c99173f813a0e11ccd9d742cda0 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 +d84c494ef03a22fadd3942c6d8bf658977cb8aa784a55d38c789e123cc7aa93f 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 +5b270ba349db61705bed78768a1d0e114e69704e92f725c1f0a807999ec51912 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 +992b8b784ee4cd20701f7b90f8051aa2fa1d938d6ce4d8613ee58a237e2a7316 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 +732b5c94e3853267498f4ddfd0c08268e17218c0675e359f2b6339fbfa7c46dc 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 +4d228395ad0f80faa5d9a7bee0d0435dd5fe38e51cbe0392fc84298c16765481 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 +c872f342cee52c2c440b7acc66505ebee3287f7561124993b04ab3e5bfdd543f 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 +92c668b3696b7d5a286591a1b236f9a7fbb312d6cefe5d057f7b676655fc09bc 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 +51011741a9e64ee600ce97812659c3e28c6f84a2b8fbbe5509299e2a35207029 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 +9060a8550e0b9178b35710119668b6c580d254f434d6a3a1ac67b56f27a96ef8 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 +90d129c0f3f1937cd68275c441de99bea716ec13ebc6bcf8a191e48f98f05e59 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 +0458d75e5386077b8495b6bc007f036202da59115e0c0183a2e9fa96b3b5b399 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 +7cd8d813368f47c3fd281495af441d26d0ce1f084b68a0727f7ab8b79c3c7995 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 +ae515b084c1bf3b9a47123c204f9dc645996b6f8fcce431083af842cb2e5be28 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 +e48955cb11cc99df4ee81d69f4bcf1c1931daad8cf12a285395f665595cb5529 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 +e0aa6b837d880764facd0b506263eed49ba2c424903e2a08a3132acfdfbd7da4 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 +051acda865b1edc17fe63a537b14984e580495694314365daadbee48c525c142 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 +af170c4bde6d67729b30b995267abe56d0b851d8ac34f6767444b4710c4d77da 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 +a3b1e415aca73ed4f9feebb55dad960b3549b816f95ca5e67de39f0fcd8ff70a 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 +dd386e97d8e916c57037ee5b9a8f1dcf1dc8b113f3b17988c248df2425e4c870 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 +45ad1a000eee4a4c8842d94e1543197a2cc94a9ceda7df02dcc2b4d9648b7685 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 +3515ec872293cd87d3174056eacc757eb89ce5aea6fd5aa8fe346b830821e87e 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 +3894074584e7d8e92f5df774e1c279b9e046c73ddc2667e17eeef8e9a534dd08 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 +a79dfcc806a2267c8502dc2836ec1d7d8a2d5fe9d838887786d742ca99968f39 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 +58372bef5c8719aee62281daaa22a27d0f66c427cc45271d632d2dba0d6f5970 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 +56ace12c4f44b43ad29160279757c6a8bc6b3324f86edec06258af584a9b0d69 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 +1eed583735207adab18e31f1f89ae3df78045718240a02fef722dd58d3cbc931 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 +c8f16c1f1822f0c148eff531830cddab8039c9e38b42c5d23a3e7176e0a30b3d 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 +ce4cda5de7dcb540f0641dd45a2842ed2352ac14d1f9c199fe97bbd6c033ae16 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 +009757df45ff6aed56bea611741a235d334fb420a977a6bed101b43c613a0a7e 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 +4dd15d9404cb0ef64e2401f75a4cdd7ea98aa5c3e647b4f949b59b17c34c5974 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 +2fb94c13d3a0399f614b44d50ae27414c72289c5d30531a041f5afd7535b8d7d 1a3deafce70af6f3f55d66ad9ce78d5f4d5c5f2638a810afcd07d67e9f9a1380d6b34be482ef030c22f1e978f544609cce35a74c5109ee7038495b6210cdbca8dc82c6e9e7b0d593fad9665382b3c401ab8941df71307dd77ebaf140aa66a1f76316478850e58886a9610631e9c722f459fa00c0b53124fb4f12778bbba3760826d3dba67cd030a96b654af93f8e395f5f439549489f8161683f124bc980e6939c83a6085e4b6caaf8bcd89a0e01ed70db487166cc29735d9235a9cdc57b80c9c2e591df6322f5bedd32937073f781a30389552ae83fbe147d1b3d3461a3df96c15cd96900c56718eaae838417057579115936862679f5f2a45dadf65d14108af1641df987b57986384fa1433789f5dfbe87e90bd4e9d8d4d0741fcda7348322b967b566b18612dbb8fe64f151947c3f7e361ee868676bccd0cb3a1afe046be70057a05add3e65af31e3ff414a627c0183e8ff583b41b75b203650420216e6dfcab289665f054cfe3ea0943647528518573bbb1d0f27e1449e98739eaf0d009432df0c1edc1625264b94a71db762659ff5a3a7a867f182d1f1fd34b341a4a181221870dc4a494013091a7e3b2b07e0160c438f1ee1e8a2b989c4ffec36b5083ea427606767c29672f44779a8505b422b25a56907f565b27690d011426a62df0036d57d967cd1d14e915bbc2691e7af818c769d9e1f9edd40894be88fa1d7a5952afd898e837716acd73953bf2d1d448123fd1a0276d2c2ebdc760a4b787416cfae5e963fcbdc8b551cb70f91da0ed4a8090fef178e879f2c34f3a269dffff09772d44a13d7a17468b5834c460957d5243c325f63f05f89d4ed98d361e7f0ab8a83948a64d0cff8514841aa21c7f337920a9983e59be4a0f1339e1e462f92dc1fc070126206012458a499a8111fae078e00b0ca3bc1d6c7087cd318d5603c1c7e0425e6f729ceeca5f35b82f8a42e0e9b950efb0904c5fb5c06d91d239913665ed1f1ee4b82185a01ba86ca2d3ea94e5a8842231a94c05280183b7aca289984103f122203ec2fba4a382e6f5236d6f68da05e3bb0c558421f0efab91dceef6d1ecdc60f9b88f8befe31cdc3c2f024a1af2c7336aa5d151e8cda814a5fe898badeb9dd680e337e682ebc22bfae445417e37d2d89a338659a280ab1206db74dd42c6f25639c1803bfdf2156df613b0f5924d209f7f9003ce8794f989f4f27b82121210f4f65ec5a1f7723305cee438c41f793ee04496bbe337bbd2fd3023830b1c8889c6f4d0c1192e364edbe1cd987ba5d66224ee9c9405e1dfcec0eeffc5c73d3123f6731c6295d1e6b854b884fd22b6a3bbbe5395312585cd138bca67532c6ab71bebc6657c50da87d2ac6068fa3970202c5e15eb7b4b3d2676c0134bcf1eac2b26ba46930b5e660b16060894884c88bfacd6779276b86f685ab6f17c6d53f621275fad66d021d26d1d480afab4b5ec75e0e763ffc45f599ea02504da5d91eb5efc3e4ae196f219e45e7cb05594958c876ff474a020ef73c1f09b1f7f7457e816d3af51d86663d4d461754cd5e907456691e02446d6cacfd33516206a31870543d574592087773653d4086c2bdcbab3c9b65ca11ad0d4e58ddda8b440309989857103929549b7300ced42651d4086661694092c42875cb62858e6d1be5f7274b4bcd83aa4da05caca186a30902830790f9ffa24418e1f9db00fa40477e83b05c2d11ad7d81dddb1e31f94a9dd5e9e13391c22479b570976e3afc1be41086d3be6689d87ca4326a7cde8e5b396a678d3cdb2c80fecfba2bc799ae8b1528e96d880cd098dde910d097eaae660ad4d7ea51c18f18aa1b39614299a172512521dfd231b9840909839eb69c892ee23f1bceec1fadba75786c7ded93bc9983f74ceab397eb8ba84f7e4130b34258d628594a6f9e2348fd91ba2594e07b8057e8a2ae3adfea0ef919555385977041c5b6dc4f3880569171f7217aaa9a85f2f5bbdfe3ffdf79248f2a35fd4dec34980c67290339b1c0a5a6ab8838157ae2f5140b4a24924a6688ae5ce72a48103ee9029ce8a0f15b1fbb19a12faab80a7cd9c0e389fc2775833e3190f1cf735ecdfe7f6b6c326506aa82613cbeda8dd3691b81f4c1e3b0fc32d7e6719cbfc12f4a26e0fc29d6417953abc9568db4ed9a294b9fd5f2a666dda546aba301b1c60985033953efd6f4538333b5c7dd3148814a3fd7927c366f40b3d7abbdeb2332ddb586af80959097663cfab2feecad6d368ae10eff9663d5f8bab95935d25f45776f7f04b46817d05165a9dd4770509abb92f8b9e7373ca780703569981754a51d6d376d65c57f55cd70e2df5fdf5a6b829ae30ce3bf942815c8b4be858db58151d02a68aab9fd373e047efa51bd1a0cd1b61744d9e97ceba3334b3baafea3bc9e43ae097cf2c3d713eecc247ff43ec74d54907d8bf45e45b2e0e11d82b126a8179d3f66c055e11f69ea67aacc5fee8af01faa379e51998f5070f9ee0fd30a2eb22a925586fb1b39024eb5eb1e127c76a149e7f02af1b73c16e9e5a5dbe378e08a9fadf1194c625132ab3fdefe8fe9a89bb8e0035a1a3ac5278f5d3d0ade0e41c81c6853a41c4ac45be3f68180fe23f27f18be2e339de1d559d75de63adf7a32bae42b037aeaa3e123a5314891bcd35ca48d57df4c17540e97202a8ea1328da25b1fd6be2b56aec1e5deb209f3b7a13adb1cbe53eb645956e577a7621d74e42376d70bc5c4aacd239a852fbb7b3f62cf59fe10438c1dc8e1e46566325da0ca43aaa63fb7e0b450a2db3e3a2204704d894db24b72b3078106e096cd543dcf027650cb4965e38ac36a8ad588c5962b4e26548ab88f0bc20e10acc1c3fc00ef415b3c32499264552b14e2c0e789a3b8a8bff9620fd939d0b34e806177ec696a4b3b1ca4b32ba979b2690cfb3a6b17bcee6877ffce757e4116da01099ffe82add5a0c593e73449a96db9cc2b9e846d166b095174f2caf8b35dd878c836d9bb6eeeaf8e1bc5d0e149c739828cc480d731dc16b35b80d4ad82ed7d29bd05018239efecf8deae180c6a459dbcbfe4aab9a5e2c1e1bc31418cf2eeeb31fdf8ba02c9a91525e9163f672bae2edec38c1bdb84ea237b4ef86bf5c0f0ffe178e3761e82d94f66e5ea40ba8170bf768409e1b4177aafd9937bce3fbff590320d7c445372463fbbfb34f57447f42c16e026f179cbf82f617c86d1e8d42f6c908f9c6b77e38d25d51303dbd781ffab569b4cf31fd0b947c45e1768a2e9dfe8369f520dc38d77937b69b821db4ffea8f50ebc404f0587b5598189f54b5a5b98966fd16801c87de2c3c7813dd70dc600824d426d88c55e89d47214d59206a7a65a65da7ca2e42fa62ed17e7aa5b3ed446bcc71f17fec8593be96d2037bd07f9476d4d732b32bc5df8c921316b45699004716fc89f8d45bae402c26dbcdf1a340847b932ff882dbeafbedd252e126c89a1e1fdd8908a1f67d15d8e432dad8e08e950a3bc46b96cb89cc5bdac703b3fa3e986ef1c6e7e6606e6845ba1eb2fbdcfee744b5e45206f4a419e1cb103c8490eb293ee9aec1f0a0d294f9d3847737413d30873f3c94740e8fd072817815ebbce3f09edec9d1211a9e99547d620b2ec56c89e9cb8144ae9e46636324bd13c6cca3ab9cd9fd8f7f937ababc598232384427a2d4ce0cbf9765f7225e208c3ce128602b0ad08a1baab77edb3111f0c6ca7ba0eac9d89d5b4378eb82c17f6ea08308a79a53d150d3f85efab77294f02ee0e2885ee2ab2793392b87db11fa77992f5b4fd75ef2f1a822e87407a4878894215ab89b6cc4a120f5a78b3c31ab80ffcc9acef53fc6f7f85685eb9d56d30d87c21abbf1652eef8f32c7c567bd1f08623b09c29f33561d42727a5649a3850071aa6c11735ae63c4fd31559ce560b27a362786a83353fe460b37074664a9421d3b2f6a864d5aca087187b27e2b82f31cb3df5e985cea271c609b94b4e58356d40c7d5c7ff2e5990fb39588154843ea5fca92f120075d4c4d006661a0fa1b0585454bea725473eef7d58117d5840c8348999003736c5eeb7858ffd273a1c3eb2812f5697c59110275b08f6befbe84c92497d5f73b7b6f794a849713b23ac5f29d5c7112fb2e7a6e89eb54ddfa3122e6c79624c1bf25ebfb9fe5ce6daa779f3ecb2984da42f8c6adc77b21dd291e684fca50e46070962a2d4f00813d8de1b8ed33fed9715180c7ea8e2bb74fa65d9c7f6e142f3c81cdc59172e1020f62f65ca5a12cf2bed9dea04a4d8cabc2948f7be823a3e792625275b3925a6c8d8e2b428c75a5db0f7120278cd7d6cab768755c7fe2fbf89fded1fb38ac7f76a2f8798ca36ed42cb7c07f006271205f546a4812c20077f050d4cdc79459fa686e97f0704b7a9ff7de16318e862c53d361bc635a55a264be15016545dbfce3c6d6849576adefb6884edd768214e0b438b0231b4f2692c2c0b5c177674f8a0de236eacd9e0cec7c8647e4e9a5861b957ec834a2f8572f01304c3fd6a06019e5f1499b62baa8670b652467fa9a4f10f053263bfe9743cc7d933f86136aae3a6fb56754d7d238397a0030cebea87cb255af36138c373dbbac41dd4a697032e4796c552ad9c9b3fa713c3a4e09e0ec5581e94be7f31065157662f9e9c678b1ef1b8b8a847c51789c22b1841bcfc855820af3258af9e08231090b45d10046a00178e89bd515616b8a44e77bf57795dabaf40687b2cda7a5014168f +79657727000d7d13e002b30e4cd7b57c21a07229feabed37187428903fd5c69a 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 +c01659dd354d40b96b7135c50c7c423187d3ed6439e42257c1c3c7fe34a24cb4 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 +f1da4244d6aafbde023e3f9964200770e884ed559319ca566de1050d390288a3 3581d4aef0860c1729eb3e6b504f00919c656a1c56c10111d21a2f9a77ec0ef7118bff2a881973cba46686d4f104cc94c30b93f62769aa2c0f4c7f3fb931b696ddb632b0fe71d57cadfe27573913cea488a68d0e45b90cceda68d966b725152ccf054757211d4e9eb42a97308c6af1e0b7a0df67c61f9357a1542ceabf000cfdaa1fbe71d305300d43a448a4845ec94df696c7c0129b088aaac29a43bce19726f94dfbade2d0f7cd7c4ef0fce12681fbe496bee9d7725f549281f4ae666110bf40f5235526606127ee041c09874c103caec8ee320d5e9f2d62bdbce321fdf7681fc988f453ef999b9fffd9dc285bedd0ebd36fc22b613765a34bc097dcd1f19b14c60140c8e23d7894132343ffc2b8ed144d9055d2795cbb20b8fee92363f6672bea4d40f9acd55a2be27cf813b0599cab2e08225c4f909e7b647a39f888b9370ec69b2a6e6591604a38a5bc2e0abf8b722e9aa2f05ad9aedef55a37810f935a46eee33389c375613941102d670ca6709506861bedd3dcd0f1467f4a0ab681084bd482730f7c753fa3f5ab47b7845c5cb17d17392581219af440cd67013986cac4ffa4b6fa004e7b5eee95742e7c40044b9c5a4691c2b584dde6a8a45a36481e715d6d9fb2734e5339dd5a1856392e8fecc416778805117989e30d422ab8d358b690787e9fed3767a408dd99234463b25b91c30abb93f3ceec89823c37023e7393f29f5065acd499d22e13b5909857180f7785749734027aeb843245f5569c715a881a1e7554179d5d993fadff2aae71cb0016e1459ae6c2ec7954c0b6cc8bb1116bbb8cbd81cb62dde57442f602147cbc64c2a4c456c1523b8075d0defa053578c31492b3234cc7370aea593aec0359abe3d1c7431cb62973e93b0cf3c37018b468267b664db3f45fcee737cff976bce35e061aef48e8cb20f0461d729fd1691e0d2f8f2e0d44f77b640131b9e62b80c751d0186f183760b63296b6bdce97a9c0ab4cc37a27a85e1897f6de52df9f0b08f37c850f2405831cbe9826f3584e99f7811f08fd05b335f6d07409a80229a567763ad8f20539e1641236e87a7cd3c847c9e8ec063a5a8d21f77f941ca7a56e23f90130b74798b71e7a9cf8416739a4c750c0d5752a781b11f994a0b0e1cb6d8377488ec2de642903f9b44657e85d8a213f1fc80e674dffb747c63aac85e62e295428aa315f60585bb5d5203598db4f6ba78fbf3f053d579534a0c270b542da82848b8189de8a77a339d0052b74b21d806217e902d9deee2fbe97db9e414ca9439ece353fe0ea8a72ed2116f002365c88af05d0e803ab494c3d1720297ace858cad90d30e8185d02de9bb4cc3409772c08734cdbce22b498661d73a18fe2738297f25f5466becf4df3be1f3d9160def5566318620a22c0bcc27e91cbb3f1c586fc8e09c60dcd424e8c68418ecce193fe29e4529e1419b1b0ea3597a98f19e999c780e543068cac84d7ea226ffd535f75de15134556d8d637064cf85f62799cbc15fa46a62c03b0012af4615f7cc4a6fd09396a1a6d13d55d27cc76e9dd09597d6becc0467b098f5dec034ebcae7a660394521cff7d82bd418ff8cef7c1e5c0fbe1c1f262b4dfa186c785b00ce614c4558d93716e17766d4d5eac4b0b81c0b866e41e68ba0be222d32f8d83507925417bafec4b7ee39c374412f71767df78376605a002990845b9e791011724151cd3ef26191e6c2db99ae0eca5579f3a24d021f15a09319235508135b396e97819dcff83617e641d6778829d6e3a26f7186efb14ddeaf2113b9ea538ffb2c2207b737f7b708ef54c16252f2a63297fe571034fb4bcaa1ea6c4b65017fb4ec7050bdfa24bacb1afe2e2d526ee2784e1ac92512e4efddb72e4b12810997cdc39ea1a827fa08dd2d7d88e781862e7c5bd964a143f61223423689b81675231cf97c64a3a71618f7cf6a44ce458037730a2592711582ea9d9eff63400fca70b7b5251da70da3d339b768762111d27b1a2e9ca559f544adf00f8c2372cfbf03c215b75cefbdd6b3634a8fd1054a5c016ff1feaf0526ed8b968cb44d279c04159e77a0289717d3e2515db6a7b5b4860681cf8c7a1589a3d85c5724a28976193312ada24c2397d2c10baf2fa933d71f2bb2794190730242e117c90faa6391fdac1ec61ce780a7864f6f1d6d8cc19c024f4791b4928f1a2b5ec91cdcc1fbc1e89e7cf5feb974a0231dd71d435741d8fdc3730012795fcdb4b15267cd200e576b7d1eb9c5210f24b916a01ddd1bfb1378aa865ed86d0056ca5c92e5f7bd57d447572560ed23107ee6c08f0510e2594f47e19ad6725bb303eed63be2f94c0501c609c565e40ad74211fe97de80cdc82b20977a1d24a7e35c3edcac3a590ebf65ee6f5d044f43eefee6ca71326aa713fdd878ccb6f53d09913420113220af1e37cec5fd5b1f1743ec129267a6d5503943bb5d4d21bdbe149e1ff74626b191bf75b19b5a2e4225fa8ec887914787a75ebd7c0cafbfe0f5caee05f2cf468a1604bbb1c5ffc78944017a814077b07edf48524eb9a9badced4e562674210a5ea26507dfe26211b57ad3f613cf951306ae51d4da53a976e139b3eff7830d661cedb059c92f93bde0209c184bed15e38373a58e8e107b1fb0df85dfffcafe9b005c0ef9c8c7bd3166f777fa5d061ee827cd45bae34bcf7ebca1a47f76f459d6dc5f85efb0d9b5fa5c4bf19494ef7bb5f76fccec4ede71b4bb4a4b37113289873f3d57d06b3d42ce543c113c789cfb88db8207d26007c809be2098c20034eca5539ac8122640a714b0ee35f6b466dd0d0a1d07d6547e6ef4b243ce9835b9bf6ce2d1711744be3a405f6e46e1824a625bebc42ff340220e68b785af5cd5c05c215a6d3e31df1ca97d054298c0399ffb08b4ce8b2d6d08a3cafb33ee536bb01fefa5fcc7aa905c83af895047cc7bb6051482dcd5aada28e906ead9b90cee2b32f9b917123651258d474cc699934fe732a9db3d830ce1c33ff39e946f6bbe363aeb3a3f0895ca09f78ed37b66c919a15d85e9ea68f9aef383a7ab61101bc6d4beb7e36bb9bcc04421a0bf7a263651c30a40b652286a5678ea0da516d4baf89d747d0559b119199a7a615528ccdb2d5b10e99b2bec59b742b40f8a3046481858f70d18b5441974d4a5f4a732041b999773a93c3fb4325b6e5f5eb7849923407e15a55ba46f3804de3e8ca9561bf87622ec8e91698c0fd97b6413d3212f1410d9ad0754b457f041a6805fc30d7a7a98700c5d6adcef4a1f23e51950f2fa40f74fdd6aeed47cbae6cbccb93e8a06950d980ca261705a8efb5b7bc866f5451f709e8f01791600aa7e93ad41088dab6ac9ea25285214d4fa5a1c4c31ed4e0157a3a6bb94f8e0acb66b0e5fb323284c54fa9e07542030679384aaea817576329fad20bf28d80cf824d751206be17a0ce16a9c2ebd0d80c7e643867cc32ff9ca92e9adab3e1096cdde69b6c2990466611489bedaeccb9bc135eb2ef54502acfafe497ed668af4c984959cff284b2ae81638f2e11cdc463318845a363eb08385b4002e3638fffa347039b40ef7315c88efbf01f9eab73a6f0596a1a16943b03139f4e1a3ea5182b401f8dbe08527d81ed45682d6459bcc9362de5d351a5b8437d79d24899bf5316e81a182acf4f740eafffef365ae54832822ab4f58d89596014fedd5b99caabc0e877604bf4da5a4a8f8a93dac8b5ff7f68bf4167560579317a7799d9ed14b7c4719e34aa3312f2b9f07321bd38fe232b66fcebcfa5a15ea6971c92c0eb377c44a8b2c92be3634705f7fd01f8e2b10f61a7adaab93009b0b612cfcac9315ebfaf321c27b9fb2da0120a08f512a9a9149b4797e400da17e749bfd1683df628de0d062a86b931dd19a639aa7ee332c53a8c771e787f7b7c6d817f53b6e57153c32b25f87a1df9407d2390f02cf6da3a508d1721f55e155e6e20bfec0d2550598d815f71e065426e4afd677a1fcf41a24cbd82db6135f45d74d0e8aed94bda26a0f42d19f52028122df55106e45f8b364f65e314ef77ef0b7bcdd82425d8e3212e3c7ddb4ea1d378e2300f10ae707466752b15eb4489cea807e9aa03b886f3d623514a7d16672b6dc025502bbb69a8ac5e374b94a0f153dd86b3b55308ac05ae5869c0ae5e18208bb0aecec3d5e399936d58ff9fb933ba349ad567f9ccf743c264606b41d8aa1a4c164ffdfc9853fbe6acf11f213490a471e80c15def7d985aa9c340c126473d1d14bcc826c12c200d72e1a00b392767bde0884005d270a1c62413aef754804a2f04ba3c9b4a4fc9076951860f9a0dea80bd6cf5fd6e51983af344b887ac3f907a40a694ded8840998c3a273fb1267c4c7cbc2fd0a51315f313e32818b45d6c7fbedb5aa673e7a8069c931ab838de2045e79852fd832c0546228aee6bc77d72d8e984575e27ec610e411de7e02725085aab0ba967a9300583f27a1893c1432f3e651be3e49d60690652d6177b39bcd6b8e0a6a6a812048fb2ccfc6cc636a0fea989ceaca7bfdb5286e9f9b34ee5bbe0ce93d4a4614a354ea91dea8ba0fe6af3a4350288b0caab1fcc135275ae5a659e4c3a08c9e2481febd150596e684009137de6a0f1752e25240283dfa58451c94f9ab96bc4f3df5507230e152bb0c7f0f4c0f00d9480509595eb25bdd3f3b299cd0d165ea4c2f2ba5b022bf57a30e8e39cbbdde047f1c91f87b658215076ef534fdec75580e210a948bb1c3ed8be98181dfb6e15ffde2bb7f3ec5da5907a71fab770d29ada2762d5887b306f7a8586223d8cb89a8e8421609cd80f2175f2daa61ae3bd7bd135be39eddd2b2687381420e2c92a107e28e3e00b507e325f4ace54137b37a0a750e3629d64596e1c1b5091f1761f3eb7c34ab6c54e108a89dd1edb833d21ec688ef3c37ab1f762e5aad7c6b3764b5ec04b3c3f319732c1a3d20582d9ef30c4b3536b7c47197c97c76792145cb847bd2fb84a7cb460842f0956020c320d48 +a3c7d700e3a8279067d46d574be74930f29c808e2fcfb1f4bf3f127678e1ec1b 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 +8d2202e99f8bdbc4f9b5f3f42f9a7fdd7ee6293f99c619a5d6a46c81fb8e3ab5 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 +95da650e8b08284046116d7e5f5f49e338d978cacb97dc2c8c97c675578a87f1 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 +d0aecd7104679365430dd2f44bf0a2237bfeb3a3523bcc916e1a961e0390d1b6 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 +13ecd4b41ba0799ef91c7f61cfdda23ff55dddcf241691443ebcd21699c2cadc 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 +17bb1b893646fae1f9a23483ba6f2fcf1247b43f67068563b44da04ba688d5dc d1fa123c468d0052c58c93bf306c7c1dc90968eccac6b0c2f4e3ecc3f908f2be6a54ab69aec5c496d291d0263243bf1827773dbffc02a9d5fbf7aff63da5355d5869f492b0cae82b229a36331dfa642557c6f6627ffb0995e593df8e0fbd3abe66126b7e5da1f1891bd28873fd9c96c0076215b60548075d16cda92a2b99eae5776f6d1e7ae2d8ca30546bd33271d50a6fd34b23809534ae6e4a875d6981492f23752a68d1e870d174a021ff8c550e01993e3dc3358274e4da2b45c000c43fac307d82ee2b5d42a6d9849c11a8a5676605b7b3c45220bfa5bfc7118e2487da143df0797870303c185c9233af63f447ce53d8199b986aba367735fd745f84f8d94ba0c1a08db280d860bf656ee871ad1094fcb41c7bfbf0fbe0959a31b3ed573498ad35026694abfb90684b35be284b18d4b663cb2ea5de1a88e2947be8012858c57ad8601cfd1744573f79906849b4a5552aa87d5e64c21a054a7fd31b7efe2a5e401553463fddb881355fd94c9ef7f6f9e3da4cd845ee16db2d1a7d4e31c9e8b42c0ee5d30296a606b00aad9ea09509208188d4a15b328ef7564c2e36fe79c06e466af598eb64280f0019a3ac81b18fa254b0b79d7b80ecdc9ada3dd3d13f1899cd3eeb6cebdacc7f69e6ed02b2550eb3c76e1774e189661bf791ab8842a92d86af9489771d1d6fe8302be395d6750ebbfb1ed7237c2c97ab655c7a6c7157a5ea5c51036acd9f1c031277a90450bdbab5d4a9b36da52a6ef7865bd0b5571f228d5d61d15a01c36c3a7d2f133f04d0a17255271a1fa0bc7cd60a85bff17efe1d49a24d7e87807f67a01358b7ced01a112d8b71a6dd70518bf6aa8b65a5d510e6f5084f5ecaef108f6e6564032ad9259e8406076b9348ce337005fa4b205f47736a79693c7e963635ea634ca67b9749a098b299879973ca9cb355b1080de5a9054c7f39c158aae4e25bf72c0547fda9f66a234ac3e2df8dd22752ae66d26fdb32515b9e9239d1b583a314ae231dbdce9013da4f98213cd6ab9f42582f62d639e20cd183560f341007c600b2e01233098fc61a50c27d949822c6f99fda51ad788bae101cc379b48ac8cfac3b5df81c9f7b4e1e0353f7f10ab340157fc7a8f92ffc43d31f24b498b381c7b20bf0a31b74c45627b9e9858d8479af5977782a5fa88d258ebce97e6d0fa0971dbfcab6afbb3011f9cc24d8c4e3db57698e299f6793741810e2a94295d0d91f3f769f184da2fffca771a148728a2f95237b77864dea20d80e09e7a0a36637062800065acf15572355bea8dfe27509f4a757079bea6d6df3429353aaeb7777a143e3ed1a20de487162f6666ba5d27eb9d350d6a5c724bf19a1d058acdef126f6008ebcd192516fb0d4797dd5fd3216a9cdcd2ee24a2c40bb2cbff75cc59db2e3cdd8df4e0b36a670952b07871a0299eeda9377e8296ad3788c78728de71d31241f20c2b2046928ca2751bebd10bc0c455f49f30d7ad979b0d86b66a55429853aab62575f9219483603924b4d39935489e8b2ad6e105b8d11e74785fea9d1a9377d189ba290cd414f57ed67137523a355f90c9ff5ff2cb760d4a31faa2f1c478f9547fe4c4b0b1cbbd71b690fb3eeaef87a53eaa1eb6526b7488963fb64d17b37bb387105e39969dbabcd79ec28dffb5a61a1101b34c14202bd0ec1cf800e21d695ababa494431ddaa20d88ed7501ad360f9b6ed41b4ccdd0fb5778cf53d7c18c36c4ba783e68b9b0d26c7bbcb3b2a015bb1e2fb51fa9c323c08a7251e48f140a4e519b1c389e0fe4a87b9d65b8d91a2081405f05d01f71024a56ba89550a418bfac2863928bc870413cede1411f0d7c3e77c760b76e0d94f7d9adedabe9e4a632b6a1fb5ccbf8eb2cfe772fc31dc0d1ba63adef21caebf846418c6adf2e474edb4a0207271c326f14d20c0b95e1af7d86331f0d4f792d7545874f550892b3e081fcfac6074e172f8826e04f289201420f064ff3c53ac7b9a15a291e878b590b3f47f53e6ccbba897653d6ff4c6cbfac90cb8666c86dfca4d554d8b87ad1ed5bd39411ea35a417a51f9119b630904be6575aa257be54716a788922972cfdc5a5bcb4b6054532aab913e7d8b0f5a450180a3e7deef61bb0815120d7869086291c3f3dfb71014bc66e3d5c8854b52e800c8f64765c4089e482012550e2377104f93ae57f047a35c0db243bdc7e1846ba0d0eb42aaf97742984d2637c2f2befa40213900c3af5a758f85fd4342f9fc0b3821ff97b5302332db2ddeb688c8572691aac5afd777c5ac88200993d3ef100a5f95b51aa92881acaa5faf68e6134221391c04a88c7c07cb39d07d5a245aee0d63395018c0c8e1d45bb640220c2f993831dce2597133c87014d12f5ced521aa45273f7434da8acca2fe35a26feedcf701af1328e4c2358bf74513cdfbb6a0864ea9670c281c5e7c51e26f3de15649985de90abbcfc2d85c26886f0a0c33c8fd74e33122c42012f1c5ecdd01ff96fd75c6b067c60f2501088e2c8c2530a0191c17a113b38240345414569b3b80f8db755dc3362c52dd1d36c06d02442c3afd24058343f9cfc6931cca0442d3ca2ccc84c6267c42cc85f4d6bb78f34df54d4e20205d7c379d924c649ac7ea8fc127b7ee288064b2b69fa95c93f0e0df1e863c590e2069a0998a3c2b99c95b690b5f7014f401befaa835cfb414cca8a5b7cd027e52ae3acd21b618b6c9d1e240e5da3a5f9d2ef4f9aae6b3224070fc41c130251d93e8e4a9452a3a2ace2e919b6cbe248a3eab6479ffe4acc55eaf54dada9a84130cd6bbb0be41637558a170982eae9a88853fcbfa6cb076841a8e36e8824d21ad2e3ad1d7f829a5b13296b15d0053bdd521d7d15e76b356d62f02ee20eb78d04838af7e4b084b0d2575ede7de2130c5472d8eb1839c19fde06d7e77bacfae1058a0a19eec6485485d401a70a8920290aee1d0f36c67324a6d87d3b9628ff69479aea4740ab9f2563895d418f9a5f04c67cb4529115146629cadf3c1949b3aff50e8976003688a376c5e889aa0b764027335fd8174f648c3e072cf4618ff2c2189521056c03bc2e530fb89b391cc5627964a6555e8ccf102d628cf1b3ef1c32499013cc37d81a0e8e3e033facf41c1295f3f8abe317d1cf1d2b1c5fb891e197cca3422522a4b68c6481d4c74556e05e06d0e45be294e910632b747f3fb34fe5d3ac012690d9e3b7a4338fd58818e622ae7f71dd90a34081496215d8f224252c50cb1bbfaa08810fb6b4d0da50d007ad6d5309e5c0e27fd91b8b343746b6cbed1083f91523a7b51b9046737f7114f507bd7668835ce2eae7398617e3f298f5b8b38966a9bdb3beb342eefbe61368dd8302747c682b83c3ad4e184a5f8da2ccc4f7ee99a33156274d97134126b0b89627d811bf07f7683e840c51f15b711d1db0c3c41be989e0f156a5b948dbffc19b4047a7d93c9d9a22dcdf0c14897b5cf29d03cd426c62e6014ee396c11483eee85a2d3212387b5c48df8252b21db40aec9f8a2a1ad8a55baf263812094e9c81d5c18fe1fb56593e51888c8a0272ea2f8189782f462783bc996541b86eee4f7be53d535b4e85dd786bd982c5d494ea017cbf354617d219a495e6448b00992df83c94fabb3567e75220705bc449c2367c118c76ef7482c9ab77a1e0afcd3dae4dbf0b211ad79ef141217db599f4f74557b9333629a11ab482ec3d7050d95ae052f3e1f814f630e9809b87046d1cc408076b5cdddb90a389f8eb3fdf64fc7dd71e6c0d5d6c2c2c507622a387c5a3ae60a6d723dfcccd1b6a08b40cae54d6fa519b5897497e0b972bfa1966ce2a3db3fefc41ab3393171ba46bac2fa93ae3613ce88273ab92921f4cf8a5840cce3f3b3c41622eda57e33b436ff8108268e358cfe0aa72fd0d2ad5576712195f6336293bb3067ed389d69b8618dfeaa8cb1d12b43b370b17d29ec2035ee9348d69f0e64dffd8096168f6cf020661e72bf64fa0d03e0602750a7da0daf4a4ed909bcf170e76eab0889ff15d84e9f8233b3c57b34084bfbe7732500a4034bff241ae4b89f9bcb2be60715c14d3b2f5f8e3c9b9c7f7eb11e6b0ebe70c9b63571abdd5a10a86c8f9c2eb64f7075ea1f0bc02573bf83c3af68ca831e16f5f40e558ae0557de3b046d5418a10b9e230ccd22d4cadd50cc912df9a42af82ec97c91aacf027240f95b19fae3ddd36eaeb11fa79c6c17bc6a43796151700f587b64cf3a2ed521b22e36c8259dad86de55f46eb665ac0ce9c59d91d5310369f88754ccb1484f4999b9dbe31a9085c5d8ac64b624904a63df3d1dab994e0a845365cc6daaf47633f32a929ac74b9e8a76f4091da80e49f3aaebba70544d1705b60e408055f07e3cc71f0d2cea3b4b16d5995a6a9f476466765bedb2bd44f97d45858d1403c6348884ac7163aeb21364534d8c19b0796ccb507d9441f6266725fdb340ac1159d7c63ed0c5ab42daa9918c0a3dab2fa70f84d499acdbac62f74201302d6e2b854e37b1c790196e878adc03c001f006d2196c285fe5001fe395795d843b2aee6f7d6c22acc3a42307f5f3ffa861e996f169318248c3c41bf9d1a51bdbcf5a33a79815063e07cdf5a0c4676ec96ab576d27e117b3dff7a2f1dd219a1f1b1637a64f38b122d60b9501bbe3639cb76d8e746165ebbebb90692461b61086eae6f6f5aa5e0053d84b6fca8147d976de801b11b306c1a506110c6a8b0ff62236889718b18b5507cc2ed073f1ac48ad1db1aa771295634272f338323ae5dc1fb19b937d891efe2e960b17d343e38f2f208d4b8ce21f25fe87b5f12038ec57e29c7407914473e96c3654162e5dfab9939a011baacce48010898f1157740780946b67e5a44d49240b1a694f679cd689e720b0381adc691c8b24de8ea99a4c739fd5a82c06ce12c9df334e91c63b48cb833cd0e57d2435fbe1a6083278aaf574e2c0b706a27625fb4934e139163006ff91319773e996e08e91e0bbf55779971d458241cc27b4adb43f3c52533f4a61365956f496332af91a4b50c21365c5da82feafc6ed819545c23e3153020b86471563af40143a9213658eab2321f5667a85de88d6ad77d3acc205d130db4d88901e92f6cc8386a60cdbe8c604d2c577939b44f6b6e8db738033084f84990932a21f8ff91a09a28ba1173b2ddb32422c999eb42afea02172a1451bd9070e281885024bbbe7008e340881bb2cd61eb36b6dd4aa3883a79b8399acb8656d0dfd7520063ff1ff95a62376c1c99adf2dcdf0e62e06fdd1c23e8b4b25daac31791ec772dc96ec1e8ccc4fb5455357dd6c32682b27fc929e5f28caf9fd9ebfed73a13b0d74d9d47480dbc7d9550078b25492c9e2d3e3f5a86f58f0ad35744edf214e3f810075e77be797de0862d4b3e771406f6007f7c29426c16fb3cc5483498646fdde644c5542b28371019efefe50f29b2479cc68e7c40d681d8e496356d71be30798897ae496416d7a3ab9751cfebb143e00c036c542f79f69f051887e42984954ea5844dadf56b9bbd19e8d20cb9a4ea +4309824ee1da79a7dc896015d36cab8a65541210942c067a22723b70b9a8f999 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 +9e051baea5bd55a44646936983a5a04d724b87297e00c444a9d213714bc28b6e 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 +3c9ac322f9155202b711b2245315448e92103f4d478201c1204b653388ab8c08 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 +915342ce2960affdfb8e4ca6afdfbebb1e75cc51fd25a7a4a2a59db9f4398bce 61cc4d97f411d959562a0fc4109b442afff59bdb158415e8658f9545a4aa2ba8b64a65b0c71fdf338d2f48ee031d8b6fc2b049c2be4f25cfb5d959c77099689b4c607a2f81c5fafecb3290633c5e7766c2e766b4cbb1f97f8a4d61c6c55ca996c8ffef51ef28a90c06dc75e20aff339a28a44fc057fe51fede7260938e89ad74acfe13767bcdb8d25bb890c1401c5986c6a1ddd366eb5edca55ec9b65c1014dea47597dab811446ed3c7a3571bc77d1e3e97cac5608c43cd032c63455406ea98b311688f11a0792a0b8e65ff804526638a730ef25a6f4a7b1892de226b6fa40b65e4fef5387ac4eeda6eeccf155712e7536c1a4aaad5f78f8c8668420da7a48d486f4c4f006329e7bd8750165512005d88061ef2354a84749ef29fc0d5d4753006878686d09825825d25589aa3f386abd079396312e8cb26cc92420ccac17492895b2abd20170a1df011181f4051aeff2de784913cc40fa85e5f26c3fb36bc396f6b1ee7117e77d29a253e37f02769f7574d6ca23a56f92514aa615a424b484f90f382e1ad0d3ac3915e048d99d74779be1403e49c61f6760949e8945593f7a0de5d884bdc2e94f4bbefd51d83e331fdb7fe8e4c4b0429a24ec02ed9f3df54404f6d7c8ff52895e5853442c03dcdb9a980377e09c21ab8819b29ec96ad0d0fabdb77e42bccc7fc7a70b83ee053f556b905c63f8114c17a45ae8d19ceca6e5218336ec11613dc11532d91652e78f86726a80749d70cc54ca41c33d643f280f109f6269c3da377bfe87bfa60a1d167881af220fc8d2a6e290226fc2d0f66d2a1a7fabe47aa8007eec301e82ff50bf7148463645dd2471927f9546da78e15d102e701bf06c972eed2b489de28bc2148577fb489141de8cb51d24282e621267a4139d1f0bc35dc9d9c42bc33a04f81095ab3f176c4212e50b77ea2d132c9a5b90b1e32e631cf1e10c5583514325978581c1e55f752d76dbffc8576f56422c5da1ce20e77387f5173894467ab0588653bbb44bcbebe4853fdb9cd39157068c907b32cfc4aa5daf2d024e0c3b2a804fe5f2cde75d299b37c5fb4422d7e61e959abf90c9a3d8df629e76f4a44b76263e9eb7ad1649ea89f8838705e1a632fa0b91482e907f077b992c96b3064d6d7604d09e682a5886a2d9334138161df5141c3f06251bd470163875387afb38163394b335b79210bad92aca568bd1ae1e511c22803bba36079fef028353aa0f5734a1c7c6c4e6ed684742babad0e93edbcd0de50473a5f46cbd9c592fa92d42ebe010acea97bb36fbabe2f14bd02b1a07b35701d131623bdd526beddad0b4fc6fbbfd4cfca8e513767ed4d10ec64f920e9e6cd528676875a070ca6d7aac6807b53b7b13749cbe350d5fcfe1b34e4df2e89507019bd6fcb24afc3a1c9bd64ca4c7572fac9d87649510d5f91b373efa0b97ede7b8768d0186b968e5a7f6d181cb5f45be2ebb942e23d821bd7a8a1d7b0e2a735dee8944c378ff9a98e13ad7344198b576c6cc770c082d640936d3f07021293764662f77195cf956e91aa7d14ebdd06c41b57c9e881f2de467aef05fe9ea1809c450a45f3f0d67d7447f8af8f87dd52b30362f44afaff54a2a0331ad8c18c2f3594a1e187a1d94a4c1829d87ea67ece045772bbc82c231feaafa81e2f6e18d7f45020aed2b22fee1df13fc31847ebc9f8ca140e4944f8d111a4deb56c0888880eb95601fbace79918a6be2f0bd370215689988725e9afa988553867f898c939a8dc4a58faab9b105185904cd543382f7dde811ebd114ae109b97efb4a7bd4e582c3f60423b48c1e35b8c0f291048c29375f9cc2d4c01079a207bb7bcf875fc7535bf47db251ed8a60f03d84e49e32ec5e72f6df26f18ba040f508a02ece21597bd710c36052ebf7a0cfa8c1fda132ee3f9dff8814cfdfe0a514c91fc79546b82447926d422b8aab87b94cc29f165e1f970ff274fe2a6621eac5f12816129d27b8df06e32a41752a65de0b47283ef049422a9af58a9bfcb042ace1ce470124369a915e2bddcc292431e88982bc6f9c51ac4c8b3e2aa96bfd6b574ae9d702a2673081ebf54fb332f552ee17ba638112816286e94fe43c6695752e67f69ce6dc4893e1dbe8c5df8f292271f4f5c140f324afb49a1565717ff0e0681f01cb7cf96d2f8c50a2d76fa6b4509701211e07c7142d22a2fc40c2cb47e91a0dde3cd86fbd02ee53f8367d1f25e6bc0c04f19080ac19689e721327634289261827333594cf23a7cc0b0c95261257f2f2a4d9eaf72704890f29a5c6f12394c6a57688bbf61e187012cb7c92d720585976aee344bccba607e74f5032c14592c317d211c3848fd76cbfd84d7a621e3d89feca1ac8d1c0090855d530df05978ea50c36db86d311fde0f8c6598dffa94f094e4c034fcb13986eccf09dcca03f2ba06f86d2e49aa9115bd80cf49549e6fb23a81419826f7f3704a1feacaa456da4c107614c992443d5dbc8940f66c2f396786ce6520e08b715d1dc3ac0e695b7be348972522dc4c831f02b4253dc76181f979c6f0450a7303288abe8b9fd6f8a9f46aa93c4e6724e29c9891ba4eb8403013def6068413bcb4d413eabd69b812f479a2b63437abe8c0ce4aab34386de580bd704aa364f17c031195f0def63cfd88f1246a5895d3d06c2bfc919939280ecb8d1177d799062b4f4f0b3c7d855aad76a525301eb6706695639d03a4c0cfab11a1ea74aad65d68baeff5b0355aec1bcdff9fca7f3ba5dfa9f7e1d073305bd96f9abf5ec76a14be21ee536e09866c1e0c4b9ab8e70430bc708dde617f6686c2b6165981bf5c70c747ab222482b076f5032656ea780e0798c5f18223590d3872804c379e5114c6a49c8dbfc14bee6804612eb21b2055afcc7c1b2a8e8be67fad7fd8b5e2641fe8cf37792fe47bfc35c76949610f6718db9403b29f536de09ce4a254f9d612dcb93175f5592466cf9b7ed0585f83d1eb7ae64cd83c117a7f7a02a859a73377baf4624bcb5b7c313f6c2613138245fa0a40b844cd8670111aa27bbb01a7368aa56bf24dc7d8e21fca56e84a32776571ff60b3ae38b3ad1ed3ed3bdd19ede8c24c2aa71ecc2b28124dd0afc382b784e273e838afb698d8aa336016c4988a58ece0d8a2a2d94362d738346c950bf05008a10e29bf27f15b802f213b8e69473b023332952912f20472fdcf193077a0f460e684f9fdecd2d7793ddb33d5457ba30b4d91ec272d1e6e5d2795698a9af406a8c05d1ba2a64f883d37ea18505a0f5745a2dda217eab1774a9d813b8387ea16c48ec8e5600c16d98fd4ba0a1ef2888fdfcef5365401004b02cf704623277ce502a54e4e03d91914ba829c56740f777a5c28fbd45eac571dda7b89ec7fc982f65e5cb382415440162091c2f041fc0f97f20693305c25de7837a2f650577ac6cbffc09f1f695417cd5ecc555697693b12166cda47b8a745f489406942c599af5f085306efaa508b5bf0a406269f600b68b58ce3e204c3bea59e4f3c19157c60246edf18141597bc0cfff8308878e4f36e4c443ba874be58278fd5b332ca73cbaba2a302579e5df863db92251c597cd45f836d0b9d3add59ef92468542b377e3250fbade0833914066a39566009507d4c3d575851224e860429f617ac7ebebdf534dea8f3ac3f7a14f815751c8e72e907f9077b54aac645b4bdadbfd969ab38312cba888f0568170c02f36a4c5f0055e6702f39d62b2383835a719a60e3a6055df550b3590341b66770897bcc66f8a52016f1491973d565eed5d1c718ca8997c8a64d467170608991d14f1e50a8fc63c4a3b464d08d05f72e9ceb8ac69b5f889ee16f99454bb5f822f153c9d9dcf4f0bbbeb510d706f2c7ce5e516e1af5cbb838c95d973b34230379cc30299da585bdd8ad8bdd43ea6ad8aa8f4447ed4f411e4a3ce25c4b338882c6ddda40a8c2228491cb6cb33a5ae703d29865a151bebbfc5910b6441b10cf64c189a71911677c10f11decba96a420de0ef9c124f36fc5d27fdd75c388533c88667347b5277c2e1fc0026b75e38e6e46acecb2ba8efadbaf1489cf45f4a9225691492bc63785966c018a8fbefe58c5533e2bf2c601a0a5ef08cbf1b115bf3452c94953acb7294ff09c7fce12f8cb86333ad7eea514ae12333558f255f5d7039af77d724f66c962192509c5b5e07ca8161d6002417b793f25b92532c61d67ca6ce4e1718b414a86b237fcf0199d7e560c2136afb290711b3e2b8d403ee0537c351972e86551e5eb9a3535d7d602e5c444219b3b3d63412592399a7ee91bf3bfc26f5a3a91bfe9ef9a875cca8c6cde2fcc7cddc971897e559ba56761599c5f883a7c2aa2e4ccb753c659678d16d158ef12af987260fe98087c23773ae20f81fd590e1cf738d3c04b0955f2b20b30f54381c106115d4ed83fc7f6be6d143b61c2d589a317e98e18336150b3350ce0e16e8214da55476887da6fc64d61ba49425da1c156db5eca01411fa062183dd29fa1ced491e5e1e2e3ce160a8e9e4ff1000baf632a92d8e972077c23c666810339e9d9b5f62fda5bcdc45d315bf8db41b81aa165763780becb544f277bf10491cd085a8f5ad91eb6dce793f480a27c448ac8db95738e36ad0f15fae23a98f73e1bd96a6dfa6b1a4df4d34441d973af7e1994c06763bbab81ac19b0be9ec856365de6721840b2a4800f27e32d9046fc67b7f443a88c3bae70138305e9f162dba6219e6f8fd68494fe644bf6f198d1b3a934416e96ac219c72ea95648b1d9677c7dba1e3cc6e6b01198ea85a6fa3dbe68ffd5b936747bf86253622bf0656c4178e9b259f01fbfbef7dbb6f45ea2d01cf4ad075718440c00dc66321b311f399436064e7f56d254baae85a3199c31357b70e81180d1bede7fce128d2aa7fe5c5095a05314b056205e719f13c738fc443f94dd3dd8bf28a8024491d3625794cef85b2c2c810208a8557b04f517c42efd9502a1b4de412b47c530ee6f0056b5eac5be87ae7442aa84f30ad9b6c50d8518632bd4512783bd3fb358b9cbee1ecd5d634d617a57ba8ac2d8f12c99c1a146d6fcb9901f46c05fdb5bc3ddb7d8c0d694b5e0432e29a2bb3bda70d3977d7967082069aa36f425c60d3eda2922fd41ddb7d1fa2ce76256e3ec53a5575de0b0919bb719cd73884f052a35fda47861c13bb523509bf91233acfb82c674bc46fb5aaba970e29ea48af84feaee9aac0cde8ad0ff2b38aa378963d62217b8c079bee27985b725ec8327f8a496cbca3ebc763793cdda9c5c84b42678a0aa6b9baa03a5cbd7e2f733e956dd9b5712317068ea369d7821e3c288c019110c0eb792ef4fe7bde199ef10c973138af40fa52fb35dffa939e3d843ada7750896917772101e49076812e623f8fe435452cc39cfc3c6bd3665bb7e20fd09e28c08d9d29cdb7a4c5f7302acfb63a56bd481f535a136182577e0af1436c050ea376b335da9cf960042a1158fa842a85dcc923bb7ee96016860c2231a1f0d859275801958cebdb374cc1bcee2069ae9a2e970391172ab7bb9d39d991f68c2e087a0773387b62a608641ec54a7e8976b7a9ad1fa9904bb3fa98fbb332d14b6b23a82f4ffa69a8dbeeb4733b7e69430bf6b1ec5c8e5b0d7801b4c745d92dfe071224c7da687a7e1991b03867e82e7f3d3dcc2c63ad5ee9cfc20451bec862d421e03b11195bcaf01ec4428691cde6618db63ae73c08181304d4b06561383176664d20052bd5b7373a7ec53d1a4fcd63d7390d00d2217cfde499036e6ea389dbac12d08f40d6322a26c5681ff0c1f9b638cc08ced61524ec48a8e8bf93d2028dc10ffe063cb807c94cad3c2b694ed9747385ef5934f4c84f907af7999e476c2735e1318aad6ebb7947d9a64b2f625e2dab7e77b6fdbf +748c1aa5ab29afb65d2f47192387070d5457424c94f093d4e20093bc182bed94 6964e2d650b19aa6d31b839c604a90aa3d105834f3854df4a41d4787a387042cc413de27503a1efc366b87ed677ea63dccd40d9c7f699fff9b8a42b596173014b9e811d42d2de574ed5c80fc6a5a86b772a3eebe5640102527401c0e9bef57e05bbf06986535d3163788c60c92ec7460b7fc685fb45fb8a18fa84ef5a37c94a2ec3a948dcafc69b83e2434abcfdafce948d8c76ed9ba780d39ac3dd098ebb3208538a666ced8acf1b3031c5ef23592fc432ac25be0552c1a6463e3cc778d456a520432a8c55436573219c49e6bc27474aa4bd9b1b3bc64917d016b6580aef2a0ba41acfb98ea869d3995012715d06d64e0aaefb2627125f225e2efea21af7ec49304b8e6399623fac15d6cdf39c4177a12254e5d807b4aaeced6d591f4d0bf50c07f5b69e7d60055062654e7b1c8b96af726bcb34b10c60b7fc3b10dbc69107c7d81043bcaa681eb354cf19af26ae3c7cb321b892c33cd044a24a5249f2f2ea3f804944b5049ca887eaa6d4cd5e52d17cf01cb0fcecda47425ec85f8362ae045ed0d109758c90134ea27c4cbf6e3abe7f283f4c3ffc4455eae4790329ae47658db2850b09a79a89bdbf72a20dc887b6ad7adecbd5a86c08479d446ef817e13a37819c227792e3e0ff80a2831b20760b879a489a4ae50aff9fb1dff39132dd84300ef7abe05e98c5929683a2ddfea99468996d652dccc698183f9a3103f7c049a7227733d0c14ed1bb809b4ef750df19094885961d327394d6cfa0a21b341681738b7e6feefcbf4dd474b7b45ea64a3a60b97bff297e8a52cd4aa6e92d6dbb7fef7f736d29ce3b041488a6db68d28f3c0204cfff82ce6ead11e11d7b060a0ff550711be33288acc63b6dcf2062251771544ad41b35b1ea5f11c4b196c48f5fbfcb4b39c60044a70e1dbb2cfbf9d8fcc855dec9a0b33f2021cc76b236adeb5a1356cfb8590fc1ddf8a721d9331861db604ad0c8c89871e960019a0daba43202addd526c1706e782fac5f98295f4c6036b8e2df6d225b6335d1314143573ab8e66a7750bdb6420452fa060b24fbbc3618d951490534718d97e3ae994d5e770d103e1f405a5357a2521e9393ed2ed197e7aac87e142205c69dbee846034fe6f2168dc207d13022e11427e8f02087d2f4e850e7fd21237d56be970781cd779f7b0d8e9f689e6cada3386b5e779e382ae3deb6cb20dba16a94d147101fe594790a5b331d40551c8c1d81052ce00642f56e4048f6831d713e74e3f4c6ed2352854854e35c06313f0104fa47eeb282aff9a3ed3d683fc88e9684aa0c460c3ec333080d5f557520a359803563a1d8ba7c716082cbea808dff6296947cef7ea30cbad458c0b90a07847e3e557cfc33b0e3893d32924934da966f6d451ff8c6b28ecad7480cc137327e5db10d180d41e8088660297dfa99126f7e2ab290f206c02644b4f28a603e959077e13d65c650cc0513259c36324cb5223e829350eb0a567317fa176213ebefd40b98c38055b24ad85171ff0724410926b38d8a06de500775d39e472b0b3212122204136d0793ed28f6ea070ed50745745df57079f7d4c63c6b5a862a031da93f4e576873e6ed03eaabc2a59d4fde5a670850a52b17dfb059ad5a0822ff68b9a3a11a26bde519e86a2c7f743bc932bb29208383621d509da438a56b56e1aaadc330a0ceade51ea65eca256e3dee4495c3fb94f41c121b03b6996981033d5d9e5540719e29eb1ad9a10c2182811629bb5a7d2296842fca6018e44b1b2b0ee56db63edacffa837a0147d1fbea737fd66b614fa097819422daeb9e1f04b81d4b1e569aa84708afac7a9dd92f95d9cac1137404f950c70d0e337c956bfd2c7b64a3b99f1499f9b297391b0996b42289e205b47900168f8bc3a30c84cdf00af52ef14d8b4a87675f8859e9c3980524c2081d3a08de576c1fd5b40459e299ba89fbd05c8ed01e3bedd893f7ec17dd1be1eee0b19186e739dde650566c395eb143451c09eb51c6e14eef3fc3e20210ce62c49d0bb862cec28872c0cd989050b56eeeb062ae2645c1510635e4085f5940eec6274ca982e312ab21ba0930be4d6b57ad8d36bbf58dc05d353e32a5cfcc4eb008610e24a8f2a1fcb57bf6e4adcf80d3408997d6872a2ea5e94e74cc184eccbba15882745e03146045dbf6e94127581cee20f2f408841d1982132e5b7f582b91784740761efdc9346bd9ebb3c1fd341c3056f4dbb4b36ea9e4bf05c965b367346472d0eb55b840ed49ef245c6f86ec5394063305ba0df45db30f7658d28aa988cc9ad97f0a9c0b3e59fb623d55c61f2e202521714970c2285bdbf7c6119fa3097d82f6a1ebc33d42c85a93630ae18521a2f8aa785a17c2d9354033fe297b172ea1f06cca686de4e1a28836da559e4405856411d58533ce33c6b573ec51f0f565499f6fca8837fc80bc4925867eeb6bdcab15ef1c70b17e02a535e2f423d36591a22cf527d118d5c540a6749e1c206058c0452bd9c8f5885eb5823ba8515c105f8d96fd5f4af9337e66d35069d19ec041a7d979452e5743a6a22da0df662fd9d1a2ac3f8d431a61f4fb944089c52233167e0d53899b6d45c51393f3ef6894921486d2f9f4d5e6e95107fb975c8e856afc76b06bf3648668eaff6aa59fc9a3aa536e548880d4d79c9eb5cfeba4d6d5d402197c0e1608500d69833c069bd1c45d766a7bc783c0194a2c813b223f141d8ae2868fd65d68dd67ef463e34e4fc20c7777be17a3fcfa51a9d98fb23b341b12cdd2b430b0602cab03a226c7cee4f9488c8319ddbf4eff1b614ba9c1fe0098e9ce1b57ea4d8d777ee89f4c2e3c729216b6b2ee2685db9c1945b27986c748dca51bb361824824fb2a31ef9d7244b734779b86354bc0dba438d378193a84785b6b864306eb6e6a0a80fa2af04985fc540477b911d7ea859d8f956dd1df3e464d884a6355e8b24ca3f05f25ee53b23ebe43ce6c32774fb74bace33a12e7c1798b7116bee1245cbe323882464c49b647d61350adeb84cae9c61b02bd702e6d8de849fad57a57ad297150312198d89ef1366e45286f4bcc8217db2edd39b144d6ba1d6cb0d1c74be396cb535e6ff9900ac371a6f9e8daa45dd1b1842fc685d1fdee0fc127a165b03b561002ca56f19143024c41520489befa82af92fce5bb220dcec1aa047b299f7fac2bcb489c99044aefaf2920c324597daacab92f6347bc0ef95ca619dc19a7f28a1cbbacefc85ea2bd7a769e6be424f4af08af7f24f5475ee2434aceecec18bfbcfd3479226363b2bfa915da76b839857a33641b4b9f64f15702adb3964e5db19faf48489a7f6f9f56a2a258c54e0e5f97f382fa99274b2607d3d6a6b94ca075eb454080b01435c5aba8b45ad6edfd00ddc0270c7e54919a43dc715cb7b37e8423c7d2285d222aec66e4dc4b55bc6eed3ced1b8d5b364f5fed35ba0312e46418192937792e865ebf5d5315f1e395194004b77f1d15e48203e3e5bd2c508e3cd8d1e2075b3d6db0a5b28c10f155b13954297db518a3e47db5da1c0ed8536fa7b5945e952bb5c4e24c40fca0c344302a5202b92a351738225505209d810789f7a590672ecaad866ace771a3f9091a1695da17b3576213a0db5c4641e78045822afd939b6272d12e05cdd1040681aaee55523be6371c53fced13638a9448c0e9af8aef55acaf723d513dab5138f62e28feb489e75be072418051cdfdabc7ceb0c99f181c6ad95e7eff5226be5c4f4edee7a8c4a0500241edbc363cb4c3ac12dd046ef0c840933740f48c63de39c082ff4374c2d8453f2b813f397b822e90fd59b448262c00fdcae73bcf90cae164bae33041cb809e7cafcfdd658065b84b7c370ce3e08d505f7a2ba783a666ef74d8743336fa4df4e20a1f8d58cd0b0eff66fa77803f42169f51109a4ccfd008f36e23edbaaa6abf53b822c9ef356b79027cf28df9e5d5d7ca360aeb407cf02ca2689f8131c78ce6de7c5d8a2dc65a91df7aca7787ecd5145c5c791b7428f3f9cbb22f584eb564af89263f5750cb37c8151f205b2fca7df746226d5afe10177c8bc456452ea65d449e19b4253d6625d5c3349f3ec3be554d4158df219de226af379a422a8dac91b97c64e19c120141d806767f7ee931d88e293ee8ae1efd2766ee83174de19bb645ee3455133b81e2270ac1c7cceb037a50a5ccd540f00abe27f05bbc29a2f10542ca0ae130d2b2a1464db03c0b2510a9e7fb98ab24fd391cbae0a112a66eac05304127d1545be6638b6d35606877719c3cd782fae3faad1b89eb603750c7b5c3ce84f93fac147346350c750cf2ca7ef9099d6725bd31172c37fae60e07f33572cb843e67e8662d0dd55e424afa9b1d57cbf9ddcde447a3b8b604efa253ebb2cebe01521f0353c521f457f451cd93346d815d6bcba87b3d2f96a22ed17c17b90be3ddf7e04838c4f780be2c96b781558b4a4999b3adbaaca1229f22ff637cfc068ce8802f8684aac32ae32bd09cd5c1d770900cc7c5fe8df41e8110faad782c15c3cd637ba619a0037d7378c72cb0c95a35a9109be11f8c4bf0d3bb80949a15c64a0d6f52a9b52a521d06dc749cd0e553418e127fb519bda401f59e5ae517cbc2f538b6c32f9ce5c34088cfffe03fdc7d36a7a912ede8254b7ea46f1262973be564089c44825437d8dba98be04cf7f6ab5d03c5c10ab51557f331d0b1b919b9643efad709080d2ff46be83e081551f64ecd826db09469179ff4b068cca172d1e16750bd6d4c805146dc0221a555c81931a60206af7cb485d2fb7fa9d7aacbc3e3729eb09979d2e683ea3ed8ad3b4baaf4fe25f8b227568795563d3f2902a97375c521ba20f9c5e860dfac83a0f0ed347588f250a44f01c93611405aeb04c6e75153f0a6e064e19d895df7596c6a48a0bb3804a78937a45bcd05486314baf72661349e8eb516fcfbaffb31639716c5b88caf4255e20ee90a6ef402e7a39c5ccdc5b196a99c5455639e9ecb788f94abd7a711833b92db9fd56b6412bf84c6bee9505682ea300ceeda496ef06cc477c272318f9883212794e9ad88177b65cecc1ba8474d3de7656b61a3b832240578a4ff704caa65e01a29f365c1abb1df23d61ad41c08b092ce870ba1103857da37d8f5647a5d5ada7bb1d9804c547c187bd1767258292514491cec97ba41f48c6b581fe8e74520d0f0f6b0e44c9920290f68684d169253087540ebe733ae2465254ba04beb703f3a309be14b4f22ea63aa2de8e674d2ad446f356d1cfe1207a5ed7c2d565ccd5cc1ef0eb1e7919c26e92b851f7478c83de6cd21a3547cd4464a6b6b4da6a8d8f736d16d818063d1fb95a8d6a46911fc564aa5cfb1cf76ef09d0c104648f92db9b28816f560a24935923a945a1fb52ad9fac6ea2e640a64f79f25693398b0a0e567518d950714a8aaf343a68a4eb1ee1f518acbe99e05041ca505ad509f6ebcc68c84d85dc17e60f0240ec848a842f4a1abf11371f46ce69d5b535fab5634523e359ae14dd07749fbc6390eeb9e5330fc07926c971c719cd02aa565048cda7e534365a3f39555f25bec847c0fe5a76ef68f038ff552da2722581cc14eceda1297942a1a67d0501815747c61517a9ac876db662641f750a917edfd8ea199d27e5d56855e5200791cd404d15b6ef6f5771234b0902c9db5b033f260359f1a52e6646dbde9e4f9876a7bf2c5fd7ba028baa306ff9d4287df88aa055c833ed8ac6a56d2c83ad69ad3fd6ffa96ab717444035d3b8dae9d26d475767cad452b607b3eca6c573c38530db071968b7e1dc26058827c57ad84a14b495fe082419255c495c5e13f5bc34d96cb498378cc16dbf6683d54836e12d44d76956a6b0ce788af5282b9f06b5bad30347a1d537ef864bb0c1496176b1b10118d02a56407609c0208e860b86a47c82b6fde76cec5aa70cf58b4b110d67e70e7b37dfe3a1d530183111e2ac6b30736be4ffd6dbaec5dcbb7194b9f0cc733f0a3a +d337ce8a8769fe7bd2416aa33457cba8c4244f66e3c00e8207946bae44cbd13c 0ebf64ac017febdca40ff85fd4aeb8f1a827561c150f74cd5e864857fbba9c08a46efb9ff7a16919618c9fb06bf8fe3f0859774da6c38c5a0c54d44075d1baf6482b7705c8e1a86e79b0fbf0328246b5e6be013f934d4ecc34808a3639c49464309df5ad250bf4521e41b4cde563566b8625076ad7e260018eee2f3252d15f36bdbbce3c74758c68a0e72d83a37db4d2022a80a4f6b16f4515053e1fe398cc6a74d343d4cbb403597ae68533e18ef893f756f6f554f98bccbc84702d19f875d347c345b09edfcb1c71bd6955c5178dfcb07376728cfc3ab9565c0a1a8dca78221028b00b51b175a2da2cc0a90c33c169ea8a1a2e375c087ac3657d28ac481d5b5c225aefa85919fb8628f32f42f1fc0806a250143c084322fe9e30bcc8b89f3da73469ceb935ee25887d843321cc8abb3c75e15f4894cbb5731782372a5631979bbe6aeacdfb711a84f83bb89e0f92b88c5ee83e4f9a3c4f80624a17ed5549b77ed7d939c368cd9a92eaae595105de7e2889cad71d01201580038fcf4ab4d285a13befaaa14facfe5099a83f9e71d512519d055f44f757757bcebbd2734cb91c5c4ce7b411d1e83b42689fdf8a69e63ddfd255b977d7435beeb5debbba7a47b19cdab3f1c40e79b926a481a1629a818525c2a198983f23f0da5da8b99633689292332bcc2a4ad49769b3e448f8cedb87c1de2ef5d04e1c3a8116c3328f6b19b59c318e18f8db29875c22a0a0c8ea615a593439f7b90aa2ad9c16ca573040a8190a834370378554bda9da9486aa3ce3f1b01dba14b032b3c334f7a1e961426302ed2d38c34f61d7b4d182c0ca303c2f379e74eaf65a48d3d8a95616b2aba5c88dbf6284c5cd68d902e3958a7b9529f49d38091bac288734247fce886d49bce00ab98b1b962a8da8b4710644e9da418529e79a27408b52eb655fde025a129a38eeeba936657f725f0ec668380b9dd50c0759ac150f81b696b886e86a5447ccdcb3fbec08c79471dc3111042fcfffadc1a973340dd68610631fdda6ad25148c2d0b48ada24e6b2d42ea7510991c0455ba1b7f393ca1fa5801f182f89117885455dbf88f63ce0b77669ba965b73a344d3c4c787e3b4aaf58c56fb2589967c71969b1fe92c5e7d91094dba84f470437339c1dc6918dd5fb835cbe69750363691b0cee7b80f0d0aeb31ddbdac52f904a3a91051b54adf75b0d195763d29fd1b88244f61d6a304807b646326e76fb880d1df37281a11ced52d5b5873668642c72cd7c70e36825cc17da6e03c577d12f79ccefd6b7b76c88b19f7606536793d8d33f7e0a598769883b417c3662b6267001be7d0914563b2402149357d1c64680da80b32207a67611edf0e8d9a767e2be2abb21956fc764200945e4bc5830acccdc80de485086514c63da7f785cba0c1e9ce5b249b52e7ee570d8657c63c4fc90856dfbbb24c8d2a711cb3a0960685ec55540f6ec2641a429d3dc99d82f26d2c7eacc614ffe988117d8f13b7442a9ae2929d3e1f67b974bb4a4aa960015c9216afa844a243095f167b114700fb11215eb54357bcb1d4792a0b676c708e710211c3af73d61b82f4d04bc40c898ce00a2d34c77f5e22db71f46c939a0ec9c37d1647e23a0f44cc23d710a1db20e38d009c6580192295c40b478a85a0930181d0962c3b18b6aac7f5be99607add25bbc23a7530e7e58c93f9fd4afe5133fd228c6b4d9e43538cd9dcbe76c4d7dedf22741839558a6b561847327df7cff1c17e03eb0ed9dd921974954638cadbf645a4baa4a62774ba66e2e458a1f7ac67ec394429339c2f620d457f5dd06ae551b69baddee99a6c93edc7bf7cd56898cec4ab4e633489dd1934b3eab68601e3560092cb9b1c64b90c9fbb6f62be60b0e221f1f6e1d58444b731b30ab04c40988093fbd396e65ba703f52ace0695035ee78e7a4969d3eb5834c58ef60fee1de0f0e03e4203ff50f957ed68513f9134a4332b56044ee14ce80ead7ce532aca58b1f98423c3cabd9921f83a81c7467b3c6f6de4b12ad741c7345bd645854bbf859d110c8d60f53afe65f6a8a0856bbf78954f8ecc831fbb43f030449a9fe72a3c86ab7962acd28975530cb567cea713be76b2262a70896b8a3cac66772c56a9ed139f3f4349898aeccdebd5622f32a75ebbc9fe202fe56c957356d40afee4718c52d30fbf683ce17056e672f909110c087d361c196fe33c6d80dc6925769f6a93dd41b5bb5fea806f3bf56c50d69b45a371ac5dcf5cf356bc552e0cf87e22af0f121b21278b067138e2afa098e7ede1c0a8ab29b6ccf6b85d39adb9cedd013886d2c23c273a21267b2f2c22b5bf25d5a5cbd083684b454ab5fb854f90cb49b2f53795bbfd46348b30958398344f9c362040e1412f331e2dd1679f31adbcf8d40bd3bf707a4f3558239a0b9488b3d6a264e6da3911b0be47dff3257b193129dda9f3c0d9adeb161f8426ccd01ad2d0854f7319e12df89da88c98fbfea96d1f40bd098aa46beb471834b039d6f001f804ed3dc47cde01d5b594d565d94f70ba7387822dbe8d0e44645a914f25d1d15f38eb4e5c9b4f48c6146dbeff8d36c17e5e57a3f07e561af390edfa4e2cfeca19722a3beeea23782cd7af8a61767b010f89a7082e04e807f5cec49bf5ac71db3dfdc5665cd1fa5b9eb0c3c7343c674730ec650a13bae412126c68daf917862adb4e220461a6cd0c7511f4f31c47f8a41ac54fc0b34f07dc15060e9a43855da0a162436b1d3a4b6d8ea87229faecbbd9a2f0792266dd160e0f8671690411f8a9bc7429f8e0f4eb0098e33f0532057d1e05e6a78ff48a6bdf78176fb462e56b305476a78f099786a6793d2fc3f4f74dabd3a34bc2e50267f06157494b9966e1bf1f8708cbb770580cbb2467fc1b3595345a49a5d8ec528f3e2b3f91b06e0693f87fda3b68cf99df5c47bb18b767fbe74ec0b664ac0f1cc6592f01a5659a7f3b4293bfb8541f0a9e3f923a547dd1c784ed624cd3a2c9d1b8c308b3236e4146c93cdc36e17dfeda5c123e735ad4feaadcaabf9581bc1060726f545c308e56c7310093f7938a2083dc468bf5ff3c84c2271ec7533838ff15e6f7ee8c71115ea8e342bc33ad64467640b11efe5f33cecdee3058e8c17f8ca0488918506fe2fa10b92b9fa87dd7305362d24d4ce454a779612b112c7c7e6d4b632a8475edadbea13486cfaf5647e4df1fb135ae793f8e6d23216b0adf664a14397dae07e133a1a58e15b25e9092b61fad3619bd551858144b80d9075d34128c351643f101baddfa990ce910f2a8d721b64c495a12f07af3d32cedac92e20dd9638c0db36eb7b1286138fe056eae9d91c4a0ab7dc5267fb16a41b771eb01d54701fb43570482157be10c6fa9e4d866b8b5d650ee6f3fe117b1fa79cbe4f8a9b97928eba2fca6d7669b384184895bfe76abf484b03b9f7ca10308c6ce31197ca15b1a36cedc3774b6b9ddcc2431e732db36537f1f4f4883e81e7b3c6d368b4ebdce34c657711d2cbb4158d519e027c5b4b64575afcd87ce736c45028d378d70c0fde73b5499ffb307b9dd82073833c0a84769964fbd7d01c4ece805e122364b2b485b6dac7793f1ee7f1cb2a50ae6565cd210308260ef64d9b2fe8378516ad093960d5ca8cfa9fcf28762998020743086b93eedec324784428eba23141466185c740055b1e87bf7f6bef5ce8e28dd270f9da64d6fff2cb0d73a734d45dc56cd03be9414db568ee2366f2166fd6d43af9eeecb13c4a5d3a8e775bee5942194033ae3ee1754fc046be91130979ab88e47a4cea379ed9e77bc4310ddae2bdb7a5b941e3fb6081cc3ed710e0c603d47efa82fccc0d556d4ab58825ebe6ec7700f02fb7a0eed44cd2f8772ccdee4ba4b883daab46264a569aaae97a0e4369ec00f59d841a1a7cf2d39bc58725b248c7b159d6d68b3d9721231cacaad38f26f357bfd31ffcec18cf34ee42c3b375c827c4284b31fcd4374cfe8c2c7a6b952581c9837587cb161eeca237290afe8095e069a99514dfafc2fd8cfc734b4ae64807d3aca2681ade0fa018b17d2a61f30f0307ae86d67d4a14d9ce214cf41edb702735f99d58bdace7f28c7d95a9cae8b079708c6c7e78accab67f67a598f7c86fe8b8ab6539b2ebb376b6a17144a3adad6be5d617d30607ab4d94c11a7c1858e19b5c7b12f9be4ac245a9e91a22ee5471aa58538afb35319f53d6dd69bc2ae48d2b649dff6e71dea3b797c071a0c345f66df053475a40031f323908c71a198c7fb2d542aa8dd97b2f1ce01d11e7fc458518ce1cb451bb9b1d57530d15ec95ba73bd5a386947ff8d0f565549a11b88759d6aba3a83967bf9543e640a33f6f9d9655a547785b42b11216ec1cce067630e89708ca896733129db5312169003b8facb8de3f99e65427aef51cc1c91005bb7f5b65218b1b492fdd67761e0f7c2fc60f7eca13b09df6b2a53b5b9ceab43d5a1ec3260a89b54bc257850f0659e3240daf073cc5236f65b159cf8fdec771911c054bb417f6799330d443a735704e66ea9f1d3351837197c19e8226d27a1eb5b664781cf0651231ab25678a4c9f9973da830ed3871a6ee638dda3c789b0ac27df49717ca2a1df46968d56035ef02b712d12067e72b1e661120fc1fde4fe6b11bb4d189f29112dbbd6dd0d9e4e78501c8e5eeecc333b208d7b86522c61de4ed0d4454d19ca62027627344f455c05f429fa17e4a6f0bafcd4b575cba3755b042382942190b6eaf762df7714797e916d58e7dd0de2cfc41d8e6e410de623ea5c547334d3a21488cd2d65e6f9e0f123166fd8304309d0160b5a605317e0122308f9ff065ae6ed422437c962a1362ec1f2804b274e3bae118292ff930bd519efd3a93e40f949abc60e8e9190daaf9fc8099a44311861b02ffb4f9a0aea81999170ed5bd14b727b42eb44b0b55983f1ac2f2ba80734630d6b7500d65eab42f6771eea6872677e252da4c717baa07760bfc5fe09d4835a65200a80c2759a476a930b7fb4a738241c3e73a9c75d5a7f0a0be52138dda2812aefba8fd78d5840e6ea1d15c57ea66a59b3a882a8fd04093a5815a5324be75c4f83cf16b785d2d3bd36602a0026a9895cb343688eea40cdb483edcd87788b668a69d0bc75b07d8c8247a9780e4c1ec342c1198295d699f0829e41a78f0f9978dd52d6491898f1f05b979e587f711df66f38c23c2bff9c69086ab970c468315b3b6c36d58a7ae9c749fa06429e6781ae7d49b3b368048641a63db95ee293a1954201cad72e92a85e34c7a74b2fd1bca6aa61435af2dc32c1a2f559f63e716a6c96f076097e6c45f4372ae6828e9eaae3eb82361710ec14f67f7d0ed9859249c18d14985302847fc8f3301bd31c7e1e09b2057e9ee46fcc7c9bd8db59eb0deb0b1d8d291508cb3837c9b2f191a49595d6aaddcefef0dd59ed3a05fa8f6ef03d38f534139d56bcbd4bc3256e1a120d49a5db1badb528b0256c61a2f179a23c49928738f9c0fa81fc196d1a74507998415f070ef9c38baa53951fee7b68008bc675e0e15bc32a61c30bc132e79c58a3a970ffddb8b806782dd31242b3c3cf9810beea5fb5a1b250ea62336456e7694b4c829508c7dbfe090af6a850f79d04d2c698637816017f8a920e1b1ade236e227b3480899bcbb991f6c6c240bbd4114aaf9875935558394a486652b0942f3409b66faf8b8bf711cc8c34cca41b8e16c2cdf0160b92a332c1f04bc64582446b98aff34189675b7a10ffc6f13b3f74654ed7c0590d4af7f4d747bf89bb2a8f5c8ce610cf4fa4ab714a845e15649b53e54a95213d5a73905941d9467b0bedda2becc1c219e1cab699652d85b8cd7e0cd11ce5b0cac76f9ef3d74bd829877898e7350cca72101076a970bec6756c3fd1aaf3396f72833f8d4e716aec6f93718b262710b0da2f3fd6cbdb204ed0e91d65cab39ed35f22a01e5d509282752837ebee968b140989ef5f4d513452784bdb892cafd8387e05b3012c0458a369e62191f5bdc57dd63ce42e945f493c2b42306b8084f3b25e94abacf08ee155f3621acc9626ee487c7a7e4667f0377ae4b2 diff --git a/tests/hash/tests-extra-skein.txt b/tests/hash/tests-extra-skein.txt new file mode 100644 index 000000000..edf14cde5 --- /dev/null +++ b/tests/hash/tests-extra-skein.txt @@ -0,0 +1,321 @@ +39ccc4554a8b31853b9de7a1fe638a24cce6b35a55f2431009e18780335d2621 x +a018268ed814e0ad0f2d0304e8fe3f4118fcefc07454d07123cc2c3e40e06a4f cc +f91902ddcc9688462e48f0bcdfca031637f0d8da577c1e2aa316b5c022450bf2 41fb +ae5520f519d56cb15f15be222b46548bf967397f353d40b109732f066f6396dc 1f877c +2638b1711f1346d08bf02b5d1a575cd924140a608512af5b8e4475632599a896 c1ecfdfc +391cf2ccf93b44fc60e965e77d1d83dea8ce6f8df64872721f6cba5a7d5a8052 21f134ac57 +783ae71c0badc74771c4a30c1a02619ecb8aae05a49a514a45985b1b78aeee59 c6f50bb74e29 +234b29e28e19c7008e05fa529f1df2a52219fa1c93d414937a7f53c3b10273e9 119713cc83eeef +dc278f71c1f634918a85129bfe0d7a9fa45156fa4ee970e89f4e85d5e3a9d24b 4a4f202484512526 +9a3b62cc26e36c9a8629320242d18900a5ba08ddcc37d06a32a1cf7c6f6ad718 1f66ab4185ed9b6375 +52a05352d70dc99e888ab366ed71f557fc3a44e408e0301c00970c9b9df0768d eed7422227613b6f53c9 +46077ca953690bd06f228abcf2f2f8e5452964069c04310ad3deef995478ebf7 eaeed5cdffd89dece455f1 +0a52d798101ee6f154b260743237df31e15671fa8ab6fbb048f8df46ed4a1044 5be43c90f22902e4fe8ed2d3 +b054a5dde925709ddf26c1fa45bdc2a9b6b82c71f2a80c7594082a9031ff666d a746273228122f381c3b46e4f1 +27c80578d5fa8b471e7f5013e9221068fbce0c9df15da33f8339e1282163f211 3c5871cd619c69a63b540eb5a625 +bf961e0b1f629ae5ba8a5a0f5d120ce7deb8186f39ce57142beaf8d7bb92f496 fa22874bcc068879e8ef11a69f0722 +aeb4e6d540b5887adfcb5d005d6e453b35f8305a4c5cedfa39b6ab63fafb9cdd 52a608ab21ccdd8a4457a57ede782176 +bb872a962a4c9916350b87c40aa475c1a050370891238ead820b7c12565d5e3b 82e192e4043ddcd12ecf52969d0f807eed +941704a1f94ee92bc65c12d665799ae654e59630422f0d55f3011b2db511d5fa 75683dcb556140c522543bb6e9098b21a21e +368f23396932f2258289166067635cc1a7397bc4699d21c937156986179d4b22 06e4efe45035e61faaf4287b4d8d1f12ca97e5 +6b9d5fad64ac4a0c0412f1e8a568beab02f109529556a51d66a5716c0f695dc8 e26193989d06568fe688e75540aea06747d9f851 +0f363ecc1b9f971e7af89169a686237e3aac4330300f387f3a589cadaa392ac4 d8dc8fdefbdce9d44e4cbafe78447bae3b5436102a +f3b9e46d7cdbc0ec120761ee58876454fcc3eda92920d6c319936ca6b36d8cdc 57085fd7e14216ab102d8317b0cb338a786d5fc32d8f +00680831552ec4ef9706264ff51a9c3b27ec3ecea96d5efddb386edb2a5e42fb a05404df5dbb57697e2c16fa29defac8ab3560d6126fa0 +a1af52917a60b9d58cdf795616b3e29e4bce1d88d0902d85f0102d95774a74a5 aecbb02759f7433d6fcb06963c74061cd83b5b3ffa6f13c6 +cad6aa978c8f95272c4f9c0529664ded99af248554c14b9d64953f9ee7636097 aafdc9243d3d4a096558a360cc27c8d862f0be73db5e88aa55 +ac5e951c83dd9228382a2419d0b1fb9137fdeeabc3c597a178d348e4180c0381 7bc84867f6f9e9fdc3e1046cae3a52c77ed485860ee260e30b15 +0b309226be30c552b80324b5f57492597f1adb39e0fa07048bf0558096eb5722 fac523575a99ec48279a7a459e98ff901918a475034327efb55843 +7a8aeea414409dd1a7305eba6752a5f3ec1b4a51d31d775215f37d797b864f9c 0f8b2d8fcfd9d68cffc17ccfb117709b53d26462a3f346fb7c79b85e +cd697f37a1e6379a4a127224827a29c58b7d48fe5a8fb94281e32356dfdfc00b a963c3e895ff5a0be4824400518d81412f875fa50521e26e85eac90c04 +7a7dbdae0560e7aad205e8d1da28c61eed8afae6a17b8452d64632e4491b2220 03a18688b10cc0edf83adf0a84808a9718383c4070c6c4f295098699ac2c +bc861ee3baaa81d9b145bcc16346ebbb6245ae1613b69443455006f5b6730d41 84fb51b517df6c5accb5d022f8f28da09b10232d42320ffc32dbecc3835b29 +9ec82726e31bad61a93c9a34ea6634e6e0a2023b04a47eb929a92b1f692a5ab7 9f2fcc7c90de090d6b87cd7e9718c1ea6cb21118fc2d5de9f97e5db6ac1e9c10 +38a42107f2767f7144fcf9a753939cf3a44e5a54a01f5a5debed987ca7fa421c de8f1b3faa4b7040ed4563c3b8e598253178e87e4d0df75e4ff2f2dedd5a0be046 +78bdfa9c96ad96eda8a3e2afff06f92f2f1becfd4b9ba6e3a51d4a42a40abf71 62f154ec394d0bc757d045c798c8b87a00e0655d0481a7d2d9fb58d93aedc676b5a0 +94309484994a3cf04b882c8d53315c58fa2454d1cc753c8b703a073e6b5bf476 b2dcfe9ff19e2b23ce7da2a4207d3e5ec7c6112a8a22aec9675a886378e14e5bfbad4e +dd0e9dca8b0b9a754816fc0cd75efe3119926c2946fbfa60e85328d1e54a0ce3 47f5697ac8c31409c0868827347a613a3562041c633cf1f1f86865a576e02835ed2c2492 +a45830d06036d67d5893bef27404ef6e2fedb7a310fb45e3c5b15b32a3ab96f9 512a6d292e67ecb2fe486bfe92660953a75484ff4c4f2eca2b0af0edcdd4339c6b2ee4e542 +7ef5ac7c9d83383d2ffa30e340118d556dad25d5eb3771fac674b027e3b53d49 973cf2b4dcf0bfa872b41194cb05bb4e16760a1840d8343301802576197ec19e2a1493d8f4fb +f3efdb3615a0b5a241dd7a59d27b075c7d880ac19b5cf973c6de56815e5aa02d 80beebcd2e3f8a9451d4499961c9731ae667cdc24ea020ce3b9aa4bbc0a7f79e30a934467da4b0 +d74f60a0e767a8068a16be3ec6f0ed2f5534009c8fc3c4bc7466b987a4582ee6 7abaa12ec2a7347674e444140ae0fb659d08e1c66decd8d6eae925fa451d65f3c0308e29446b8ed3 +90e61a8c10fd1830f3d9224eac3231c284b57ddff5e1fe4b05858c89e7f5cd03 c88dee9927679b8af422abcbacf283b904ff31e1cac58c7819809f65d5807d46723b20f67ba610c2b7 +5d03c3c3a6ce9a4af70270e6737ba7194fb0be9333b6ff53ce470f15ae335117 01e43fe350fcec450ec9b102053e6b5d56e09896e0ddd9074fe138e6038210270c834ce6eadc2bb86bf6 +9aa90ee34964a1201fce5b195c7c62fe118d6318fcf7ecd0d3be7fea480a1d7b 337023370a48b62ee43546f17c4ef2bf8d7ecd1d49f90bab604b839c2e6e5bd21540d29ba27ab8e309a4b7 +a095b61415cad26f554d9fa725290cb1c6e213d88c1a2e25a2030dbca69fbd0f 6892540f964c8c74bd2db02c0ad884510cb38afd4438af31fc912756f3efec6b32b58ebc38fc2a6b913596a8 +4c2d4d0e6c05d8ead7468053cac8f7399823d13ae53dc23545a6f831676dad91 f5961dfd2b1ffffda4ffbf30560c165bfedab8ce0be525845deb8dc61004b7db38467205f5dcfb34a2acfe96c0 +91dabb844959046a64958991a4a7a18f5b24df9f112f97e275bbb8c09c495a75 ca061a2eb6ceed8881ce2057172d869d73a1951e63d57261384b80ceb5451e77b06cf0f5a0ea15ca907ee1c27eba +978fb5d4157bce824b8f88237d6fa7c0dc526882bf13476a34ef1756f396a28d 1743a77251d69242750c4f1140532cd3c33f9b5ccdf7514e8584d4a5f9fbd730bcf84d0d4726364b9bf95ab251d9bb +6782789af2f889d97d9bdc0eb98713cc94c2f6cdec176d8ab8a067cbab10ce9d d8faba1f5194c4db5f176fabfff856924ef627a37cd08cf55608bba8f1e324d7c7f157298eabc4dce7d89ce5162499f9 +a1a9a97cd2d77e51588e5c659d209ac0d1469c6e41006938695c5e8dbd450b33 be9684be70340860373c9c482ba517e899fc81baaa12e5c6d7727975d1d41ba8bef788cdb5cf4606c9c1c7f61aed59f97d +7279be30b4f1ca70d243818b223ea198b51b9e04d1231483c40d6325ae5c03ed 7e15d2b9ea74ca60f66c8dfab377d9198b7b16deb6a1ba0ea3c7ee2042f89d3786e779cf053c77785aa9e692f821f14a7f51 +40a6112ca57d40bbce88fc0ba62137fc3543037bddacae3feccf5e1e1eb99bbe 9a219be43713bd578015e9fda66c0f2d83cac563b776ab9f38f3e4f7ef229cb443304fba401efb2bdbd7ece939102298651c86 +53a057e7182dcf231e9113392c24832368632d55fa38560d2a8b7ac4a3bf1baa c8f2b693bd0d75ef99caebdc22adf4088a95a3542f637203e283bbc3268780e787d68d28cc3897452f6a22aa8573ccebf245972a +0cb6dc402b26b013a5ec764d9c8e3d70a389b126c18a31af02f0b5e7ea1b9f1b ec0f99711016c6a2a07ad80d16427506ce6f441059fd269442baaa28c6ca037b22eeac49d5d894c0bf66219f2c08e9d0e8ab21de52 +48de1d6037c0882afd1c0ea6a2e4d154b68f20741e4bce7639bd1c21a58bf0c1 0dc45181337ca32a8222fe7a3bf42fc9f89744259cff653504d6051fe84b1a7ffd20cb47d4696ce212a686bb9be9a8ab1c697b6d6a33 +640ec963cbca339b5f01c0649ef6d01a1af4c9f7e84622cad95fd3b3d44fc98d de286ba4206e8b005714f80fb1cdfaebde91d29f84603e4a3ebc04686f99a46c9e880b96c574825582e8812a26e5a857ffc6579f63742f +bf067598c5ecd7377a9c787b352079144c7b0ccd2523087292f066c44fbaaea6 eebcc18057252cbf3f9c070f1a73213356d5d4bc19ac2a411ec8cdeee7a571e2e20eaf61fd0c33a0ffeb297ddb77a97f0a415347db66bcaf +1888363fa0f4176b75ca5a978a8937d87b6cf330d1632fee17bead16ef1eb74c 416b5cdc9fe951bd361bd7abfc120a5054758eba88fdd68fd84e39d3b09ac25497d36b43cbe7b85a6a3cebda8db4e5549c3ee51bb6fcb6ac1e +b0d012a15ddc5796ea900c2c1b5aeb2307b6cfc80cff88a76bff2fadb81560f6 5c5faf66f32e0f8311c32e8da8284a4ed60891a5a7e50fb2956b3cbaa79fc66ca376460e100415401fc2b8518c64502f187ea14bfc9503759705 +eb73c16f090acb059f8e31c92f6239c61e721e8c47d6cd64b55501b757f17671 7167e1e02be1a7ca69d788666f823ae4eef39271f3c26a5cf7cee05bca83161066dc2e217b330df821103799df6d74810eed363adc4ab99f36046a +d90789efa7cc0fce8e0ba9be68f9de25228d9b3b4e12c3293bdd98c43dedff45 2fda311dbba27321c5329510fae6948f03210b76d43e7448d1689a063877b6d14c4f6d0eaa96c150051371f7dd8a4119f7da5c483cc3e6723c01fb7d +095fe20cac9643225c06b5d10364247d97c909d66e05ddf3c111062af4d08d6c 95d1474a5aab5d2422aca6e481187833a6212bd2d0f91451a67dd786dfc91dfed51b35f47e1deb8a8ab4b9cb67b70179cc26f553ae7b569969ce151b8d +6c6b2655e9a5f60b2fd15679ea3a22e82d677870c47001c42f5390ada1e39ab7 c71bd7941f41df044a2927a8ff55b4b467c33d089f0988aa253d294addbdb32530c0d4208b10d9959823f0c0f0734684006df79f7099870f6bf53211a88d +8c7ab8b3e4410566e586b851bc660cbd0814a9adf847d51fc03e74e413f33147 f57c64006d9ea761892e145c99df1b24640883da79d9ed5262859dcda8c3c32e05b03d984f1ab4a230242ab6b78d368dc5aaa1e6d3498d53371e84b0c1d4ba +08375c3267e2196834e65d2abf25ea2a33e74abcca281e4a4d816bd7c8b5adbd e926ae8b0af6e53176dbffcc2a6b88c6bd765f939d3d178a9bde9ef3aa131c61e31c1e42cdfaf4b4dcde579a37e150efbef5555b4c1cb40439d835a724e2fae7 +3ccdcbb0c34ce4241173cb0e85ffa50955a8d597381aac3e11f362cb23eaef7b 16e8b3d8f988e9bb04de9c96f2627811c973ce4a5296b4772ca3eefeb80a652bdf21f50df79f32db23f9f73d393b2d57d9a0297f7a2f2e79cfda39fa393df1ac00 +2ee4684b5db641809a9b74e1d44c5a8c71c7a57b8974ee9c197222b1d23f1380 fc424eeb27c18a11c01f39c555d8b78a805b88dba1dc2a42ed5e2c0ec737ff68b2456d80eb85e11714fa3f8eabfb906d3c17964cb4f5e76b29c1765db03d91be37fc +a21894f2710469b386a7aa124ead2ad09aae7eb6f3b5cf347491cd9cf41ee73f abe3472b54e72734bdba7d9158736464251c4f21b33fbbc92d7fac9a35c4e3322ff01d2380cbaa4ef8fb07d21a2128b7b9f5b6d9f34e13f39c7ffc2e72e47888599ba5 +19cdc0972b16f5a084b23c8437fa11392df5a1d07ac5c3a47b7326459be5b673 36f9f0a65f2ca498d739b944d6eff3da5ebba57e7d9c41598a2b0e4380f3cf4b479ec2348d015ffe6256273511154afcf3b4b4bf09d6c4744fdd0f62d75079d440706b05 +e11d1332806bd947d675dc8e67b54b6d3916b7261031151fdb49522813686e00 abc87763cae1ca98bd8c5b82caba54ac83286f87e9610128ae4de68ac95df5e329c360717bd349f26b872528492ca7c94c2c1e1ef56b74dbb65c2ac351981fdb31d06c77a4 +5d7b5cd43d331b77e9d19af0c76366e1587dd7b6c1fd25324af6aab01f6ccb4c 94f7ca8e1a54234c6d53cc734bb3d3150c8ba8c5f880eab8d25fed13793a9701ebe320509286fd8e422e931d99c98da4df7e70ae447bab8cffd92382d8a77760a259fc4fbd72 +5cac4b0d209c0584f7b015e97cab3dc8e4806b892477e16f0c10150b72ea4ba5 13bd2811f6ed2b6f04ff3895aceed7bef8dcd45eb121791bc194a0f806206bffc3b9281c2b308b1a729ce008119dd3066e9378acdcc50a98a82e20738800b6cddbe5fe9694ad6d +54bf78bb3de4db0ad5b7072713ebc2cba4b0905f2db751e290ba4b0268224a3e 1eed9cba179a009ec2ec5508773dd305477ca117e6d569e66b5f64c6bc64801ce25a8424ce4a26d575b8a6fb10ead3fd1992edddeec2ebe7150dc98f63adc3237ef57b91397aa8a7 +0a3d37f3e3229230b572da75cc602a84494ce54e3f71b6b4502119d97ef5cf38 ba5b67b5ec3a3ffae2c19dd8176a2ef75c0cd903725d45c9cb7009a900c0b0ca7a2967a95ae68269a6dbf8466c7b6844a1d608ac661f7eff00538e323db5f2c644b78b2d48de1a08aa +a10fdec0af7a84254b0ccec804fc6459a967d2be4f9213209f2756a2acc8d9ff 0efa26ac5673167dcacab860932ed612f65ff49b80fa9ae65465e5542cb62075df1c5ae54fba4db807be25b070033efa223bdd5b1d3c94c6e1909c02b620d4b1b3a6c9fed24d70749604 +c73c5491c50c2d82428408997197f185188de6b37cb7ff390e71cb3baf675df2 bbfd933d1fd7bf594ac7f435277dc17d8d5a5b8e4d13d96d2f64e771abbd51a5a8aea741beccbddb177bcea05243ebd003cfdeae877cca4da94605b67691919d8b033f77d384ca01593c1b +b2d5cae8ea14910786baf1c9f191f984dff3139b44c82970100b818c63437be6 90078999fd3c35b8afbf4066cbde335891365f0fc75c1286cdd88fa51fab94f9b8def7c9ac582a5dbcd95817afb7d1b48f63704e19c2baa4df347f48d4a6d603013c23f1e9611d595ebac37c +22096e7b0bf4d02d6d7917372de40061c98912ba4780ce8ea2809127ef8b16c5 64105eca863515c20e7cfbaa0a0b8809046164f374d691cdbd6508aaabc1819f9ac84b52bafc1b0fe7cddbc554b608c01c8904c669d8db316a0953a4c68ece324ec5a49ffdb59a1bd6a292aa0e +1ee4600134eb024596bde2cbefa4fc7a28c4c5ed755c8ac56fe610f2abb189c0 d4654be288b9f3b711c2d02015978a8cc57471d5680a092aa534f7372c71ceaab725a383c4fcf4d8deaa57fca3ce056f312961eccf9b86f14981ba5bed6ab5b4498e1f6c82c6cae6fc14845b3c8a +462a31be893a3683ad570b07f508fb094dbc0cd9473208385f62eb673ec22cba 12d9394888305ac96e65f2bf0e1b18c29c90fe9d714dd59f651f52b88b3008c588435548066ea2fc4c101118c91f32556224a540de6efddbca296ef1fb00341f5b01fecfc146bdb251b3bdad556cd2 +792e3a09971fa8fd06977085de010586b925e20726b845d500f8a885f26c318c 871a0d7a5f36c3da1dfce57acd8ab8487c274fad336bc137ebd6ff4658b547c1dcfab65f037aa58f35ef16aff4abe77ba61f65826f7be681b5b6d5a1ea8085e2ae9cd5cf0991878a311b549a6d6af230 +be1d265301623309f6f86fc9af57d1ce79508ada3d399d2a329b313388ce75b7 e90b4ffef4d457bc7711ff4aa72231ca25af6b2e206f8bf859d8758b89a7cd36105db2538d06da83bad5f663ba11a5f6f61f236fd5f8d53c5e89f183a3cec615b50c7c681e773d109ff7491b5cc22296c5 +9217ff1985fc7b5d3c3659d88e121278b182a724adbc33daab22ac1a3d23dc3b e728de62d75856500c4c77a428612cd804f30c3f10d36fb219c5ca0aa30726ab190e5f3f279e0733d77e7267c17be27d21650a9a4d1e32f649627638dbada9702c7ca303269ed14014b2f3cf8b894eac8554 +735deee414c6baba288b90af36d3d2dbc8f6939ba4f5abdf07cf58659f68e78c 6348f229e7b1df3b770c77544e5166e081850fa1c6c88169db74c76e42eb983facb276ad6a0d1fa7b50d3e3b6fcd799ec97470920a7abed47d288ff883e24ca21c7f8016b93bb9b9e078bdb9703d2b781b616e +c9634f96094d298d3451bd375760d6eaa55b0dcc3aba31f60f5b857f9dd6c6ee 4b127fde5de733a1680c2790363627e63ac8a3f1b4707d982caea258655d9bf18f89afe54127482ba01e08845594b671306a025c9a5c5b6f93b0a39522dc877437be5c2436cbf300ce7ab6747934fcfc30aeaaf6 +e517f08db939f856eb454201b35ab1ab440a4aa5bb1909106948a3527bfb28b5 08461f006cff4cc64b752c957287e5a0faabc05c9bff89d23fd902d324c79903b48fcb8f8f4b01f3e4ddb483593d25f000386698f5ade7faade9615fdc50d32785ea51d49894e45baa3dc707e224688c6408b68b11 +ba7c163c9772f526b8383088f6044909ad135aab6d768a10f52d6492160eb503 68c8f8849b120e6e0c9969a5866af591a829b92f33cd9a4a3196957a148c49138e1e2f5c7619a6d5edebe995acd81ec8bb9c7b9cfca678d081ea9e25a75d39db04e18d475920ce828b94e72241f24db72546b352a0e4 +f2cfa80fc4f00e0cb60beb539bde774f7859a7d8b5a5d4de5443df25a6d5300f b8d56472954e31fb54e28fca743f84d8dc34891cb564c64b08f7b71636debd64ca1edbdba7fc5c3e40049ce982bba8c7e0703034e331384695e9de76b5104f2fbc4535ecbeebc33bc27f29f18f6f27e8023b0fbb6f563c +2a56dbdc7adffa534bd5d85075c23e237bd72436fc704682fdebbc5a66b8e3a0 0d58ac665fa84342e60cefee31b1a4eacdb092f122dfc68309077aed1f3e528f578859ee9e4cefb4a728e946324927b675cd4f4ac84f64db3dacfe850c1dd18744c74ceccd9fe4dc214085108f404eab6d8f452b5442a47d +bc42076ade8f4064f392665bc6b38df1f318eb1f187f69739d8f1b12ea7d852a 1755e2d2e5d1c1b0156456b539753ff416651d44698e87002dcf61dcfa2b4e72f264d9ad591df1fdee7b41b2eb00283c5aebb3411323b672eaa145c5125185104f20f335804b02325b6dea65603f349f4d5d8b782dd3469ccd +5e0e986bcb24a4ea1acd804bff693fa0d4ffadf04eabc2306dd290fb3e6b8311 b180de1a611111ee7584ba2c4b020598cd574ac77e404e853d15a101c6f5a2e5c801d7d85dc95286a1804c870bb9f00fd4dcb03aa8328275158819dcad7253f3e3d237aeaa7979268a5db1c6ce08a9ec7c2579783c8afc1f91a7 +ec126d1f638bca0e5b6f564f3557c40055d1d7b7d1a20f4a99e048c91bbc9081 cf3583cbdfd4cbc17063b1e7d90b02f0e6e2ee05f99d77e24e560392535e47e05077157f96813544a17046914f9efb64762a23cf7a49fe52a0a4c01c630cfe8727b81fb99a89ff7cc11dca5173057e0417b8fe7a9efba6d95c555f +b85c3e3bc8a4c5357a9e8f865c26e2cf06419f06d6cacef987a2d062141e91bc 072fc02340ef99115bad72f92c01e4c093b9599f6cfc45cb380ee686cb5eb019e806ab9bd55e634ab10aa62a9510cc0672cd3eddb589c7df2b67fcd3329f61b1a4441eca87a33c8f55da4fbbad5cf2b2527b8e983bb31a2fadec7523 +7360743b6ef8d22e3aa211db4475f9bd5a35c7ced9e5a9467020e50842a79a24 76eecf956a52649f877528146de33df249cd800e21830f65e90f0f25ca9d6540fde40603230eca6760f1139c7f268deba2060631eea92b1fff05f93fd5572fbe29579ecd48bc3a8d6c2eb4a6b26e38d6c5fbf2c08044aeea470a8f2f26 +89e18b58920943de7867a603c1b73075743c4306ccd1d78913d7a3b740d3c825 7adc0b6693e61c269f278e6944a5a2d8300981e40022f839ac644387bfac9086650085c2cdc585fea47b9d2e52d65a2b29a7dc370401ef5d60dd0d21f9e2b90fae919319b14b8c5565b0423cefb827d5f1203302a9d01523498a4db10374 +1fa9ab02096cde60d0bc70d57bdf91434ca0f05917381ad7df87b215586ce909 e1fffa9826cce8b86bccefb8794e48c46cdf372013f782eced1e378269b7be2b7bf51374092261ae120e822be685f2e7a83664bcfbe38fe8633f24e633ffe1988e1bc5acf59a587079a57a910bda60060e85b5f5b6f776f0529639d9cce4bd +fef2a642c782251b43096681c3e08e8e8cbf4e5d1d593c76e6908ac1a8f8d387 69f9abba65592ee01db4dce52dbab90b08fc04193602792ee4daa263033d59081587b09bbe49d0b49c9825d22840b2ff5d9c5155f975f8f2c2e7a90c75d2e4a8040fe39f63bbafb403d9e28cc3b86e04e394a9c9e8065bd3c85fa9f0c7891600 +fc607d26583e38eceb4429c2fef1901050a154a035535e85fdfd368acd4b67ff 38a10a352ca5aedfa8e19c64787d8e9c3a75dbf3b8674bfab29b5dbfc15a63d10fae66cd1a6e6d2452d557967eaad89a4c98449787b0b3164ca5b717a93f24eb0b506ceb70cbbcb8d72b2a72993f909aad92f044e0b5a2c9ac9cb16a0ca2f81f49 +3d1d387bed0f63dc7644e0642f717ad8d230560fdd59d40bcbef43d25458fd28 6d8c6e449bc13634f115749c248c17cd148b72157a2c37bf8969ea83b4d6ba8c0ee2711c28ee11495f43049596520ce436004b026b6c1f7292b9c436b055cbb72d530d860d1276a1502a5140e3c3f54a93663e4d20edec32d284e25564f624955b52 +00d88bf06eb22471678c9c4849daef658c19ba46f818fcbb696c2c1977ddd1e5 6efcbcaf451c129dbe00b9cef0c3749d3ee9d41c7bd500ade40cdc65dedbbbadb885a5b14b32a0c0d087825201e303288a733842fa7e599c0c514e078f05c821c7a4498b01c40032e9f1872a1c925fa17ce253e8935e4c3c71282242cb716b2089ccc1 +617440b5a98e810a8316f5d038e6d39b73a4561d963ac21641ea1671b593568a 433c5303131624c0021d868a30825475e8d0bd3052a022180398f4ca4423b98214b6beaac21c8807a2c33f8c93bd42b092cc1b06cedf3224d5ed1ec29784444f22e08a55aa58542b524b02cd3d5d5f6907afe71c5d7462224a3f9d9e53e7e0846dcbb4ce +0e52ecfc7e59b70b21ac4f6e02aa5a277dc315f111092df7d9451fd84df1ccf3 a873e0c67ca639026b6683008f7aa6324d4979550e9bce064ca1e1fb97a30b147a24f3f666c0a72d71348ede701cf2d17e2253c34d1ec3b647dbcef2f879f4eb881c4830b791378c901eb725ea5c172316c6d606e0af7df4df7f76e490cd30b2badf45685f +fd95f439ab9837c8296f635bd54f146d4f6c3ee8021f991938b99635ba55c05d 006917b64f9dcdf1d2d87c8a6173b64f6587168e80faa80f82d84f60301e561e312d9fbce62f39a6fb476e01e925f26bcc91de621449be6504c504830aae394096c8fc7694651051365d4ee9070101ec9b68086f2ea8f8ab7b811ea8ad934d5c9b62c60a4771 +d8a7e38369be51555c48d30178a90c961c429825c0335ee77d91611c7dd7f99a f13c972c52cb3cc4a4df28c97f2df11ce089b815466be88863243eb318c2adb1a417cb1041308598541720197b9b1cb5ba2318bd5574d1df2174af14884149ba9b2f446d609df240ce335599957b8ec80876d9a085ae084907bc5961b20bf5f6ca58d5dab38adb +0931e5ade3d0c28f3ec2bc467de1ab7a2604a06260e8ae4c54c96dc8b315e369 e35780eb9799ad4c77535d4ddb683cf33ef367715327cf4c4a58ed9cbdcdd486f669f80189d549a9364fa82a51a52654ec721bb3aab95dceb4a86a6afa93826db923517e928f33e3fba850d45660ef83b9876accafa2a9987a254b137c6e140a21691e1069413848 +4de61fd93f93b804a55b72760ecae851589c56f4ef73acbde9694df338c5b41a 64ec021c9585e01ffe6d31bb50d44c79b6993d72678163db474947a053674619d158016adb243f5c8d50aa92f50ab36e579ff2dabb780a2b529370daa299207cfbcdd3a9a25006d19c4f1fe33e4b1eaec315d8c6ee1e730623fd1941875b924eb57d6d0c2edc4e78d6 +9142f5aae02dc1e3912af868e023de29292bab840103dda21c4303cd2d953298 5954bab512cf327d66b5d9f296180080402624ad7628506b555eea8382562324cf452fba4a2130de3e165d11831a270d9cb97ce8c2d32a96f50d71600bb4ca268cf98e90d6496b0a6619a5a8c63db6d8a0634dfc6c7ec8ea9c006b6c456f1b20cd19e781af20454ac880 +2c5c98fffe3e2c815d290e00f1cddd15b27807a3ef9878a226fff53f203797a1 03d9f92b2c565709a568724a0aff90f8f347f43b02338f94a03ed32e6f33666ff5802da4c81bdce0d0e86c04afd4edc2fc8b4141c2975b6f07639b1994c973d9a9afce3d9d365862003498513bfa166d2629e314d97441667b007414e739d7febf0fe3c32c17aa188a8683 +fd453f0448152f1fc7d4995419874af356deb6111d827c3316a2286b53149cf1 f31e8b4f9e0621d531d22a380be5d9abd56faec53cbd39b1fab230ea67184440e5b1d15457bd25f56204fa917fa48e669016cb48c1ffc1e1e45274b3b47379e00a43843cf8601a5551411ec12503e5aac43d8676a1b2297ec7a0800dbfee04292e937f21c005f17411473041 +c0030ec3d454644ed92cbf2aacf9768d1ea21b59c22dbe98c8f2ba696d1ce9a0 758ea3fea738973db0b8be7e599bbef4519373d6e6dcd7195ea885fc991d896762992759c2a09002912fb08e0cb5b76f49162aeb8cf87b172cf3ad190253df612f77b1f0c532e3b5fc99c2d31f8f65011695a087a35ee4eee5e334c369d8ee5d29f695815d866da99df3f79403 +ecd9886c5257852b01e916cd257fae9ca07c8a0f27448dcc63e959827da750a7 47c6e0c2b74948465921868804f0f7bd50dd323583dc784f998a93cd1ca4c6ef84d41dc81c2c40f34b5bee6a93867b3bdba0052c5f59e6f3657918c382e771d33109122cc8bb0e1e53c4e3d13b43ce44970f5e0c079d2ad7d7a3549cd75760c21bb15b447589e86e8d76b1e9ced2 +3533601fefba47577e021c44f49aaf61d4a6a6f79cfc8f4a9805adecbe1495e9 f690a132ab46b28edfa6479283d6444e371c6459108afd9c35dbd235e0b6b6ff4c4ea58e7554bd002460433b2164ca51e868f7947d7d7a0d792e4abf0be5f450853cc40d85485b2b8857ea31b5ea6e4ccfa2f3a7ef3380066d7d8979fdac618aad3d7e886dea4f005ae4ad05e5065f +dedbd8e69d095f7baba95cfd1313359f645c822969b69413e22655b2cdf9656c 58d6a99bc6458824b256916770a8417040721cccfd4b79eacd8b65a3767ce5ba7e74104c985ac56b8cc9aebd16febd4cda5adb130b0ff2329cc8d611eb14dac268a2f9e633c99de33997fea41c52a7c5e1317d5b5daed35eba7d5a60e45d1fa7eaabc35f5c2b0a0f2379231953322c4e +f5f30cb5d4adeb62718c3fdf7fca1aa50e6ecdd334e1ddf2134dff178d60ca67 befab574396d7f8b6705e2d5b58b2c1c820bb24e3f4bae3e8fbcd36dbf734ee14e5d6ab972aedd3540235466e825850ee4c512ea9795abfd33f330d9fd7f79e62bbb63a6ea85de15beaeea6f8d204a28956059e2632d11861dfb0e65bc07ac8a159388d5c3277e227286f65ff5e5b5aec1 +9ab8fbfc3c53430a30dab8ec0aa96a4b85f538bcbbe4aaf410f0ef12bc979ad9 8e58144fa9179d686478622ce450c748260c95d1ba43b8f9b59abeca8d93488da73463ef40198b4d16fb0b0707201347e0506ff19d01bea0f42b8af9e71a1f1bd168781069d4d338fdef00bf419fbb003031df671f4a37979564f69282de9c65407847dd0da505ab1641c02dea4f0d834986 +4b38bf69c2d08d92a2a92905852b8ee90b4c684be7ec550e1559f57202633661 b55c10eae0ec684c16d13463f29291bf26c82e2fa0422a99c71db4af14dd9c7f33eda52fd73d017cc0f2dbe734d831f0d820d06d5f89dacc485739144f8cfd4799223b1aff9031a105cb6a029ba71e6e5867d85a554991c38df3c9ef8c1e1e9a7630be61caabca69280c399c1fb7a12d12aefc +33ebf28d8881b61523689193f6a471a783c0f5d76df73e47c035a24004f1185f 2eeea693f585f4ed6f6f8865bbae47a6908aecd7c429e4bec4f0de1d0ca0183fa201a0cb14a529b7d7ac0e6ff6607a3243ee9fb11bcf3e2304fe75ffcddd6c5c2e2a4cd45f63c962d010645058d36571404a6d2b4f44755434d76998e83409c3205aa1615db44057db991231d2cb42624574f545 +5171e62cbe96290d66161d561e95bf79295768b65e0f87ee0a8571418c74b96d dab11dc0b047db0420a585f56c42d93175562852428499f66a0db811fcdddab2f7cdffed1543e5fb72110b64686bc7b6887a538ad44c050f1e42631bc4ec8a9f2a047163d822a38989ee4aab01b4c1f161b062d873b1cfa388fd301514f62224157b9bef423c7783b7aac8d30d65cd1bba8d689c2d +b2ca862fc344030728ec4df7ca5462587af39acc4ab97f7437960e7fa3f0208b 42e99a2f80aee0e001279a2434f731e01d34a44b1a8101726921c0590c30f3120eb83059f325e894a5ac959dca71ce2214799916424e859d27d789437b9d27240bf8c35adbafcecc322b48aa205b293962d858652abacbd588bcf6cbc388d0993bd622f96ed54614c25b6a9aa527589eaaffcf17ddf7 +d0ca3b616e3f1c29e4a6f18913ebedaeaaae18401de3c7c26ddec12746ca2765 3c9b46450c0f2cae8e3823f8bdb4277f31b744ce2eb17054bddc6dff36af7f49fb8a2320cc3bdf8e0a2ea29ad3a55de1165d219adeddb5175253e2d1489e9b6fdd02e2c3d3a4b54d60e3a47334c37913c5695378a669e9b72dec32af5434f93f46176ebf044c4784467c700470d0c0b40c8a088c815816 +cfaf20ba211e0e57bc2b5c4e9f1fb413e20000e28a2594df0f524fa385bd063e d1e654b77cb155f5c77971a64df9e5d34c26a3cad6c7f6b300d39deb1910094691adaa095be4ba5d86690a976428635d5526f3e946f7dc3bd4dbc78999e653441187a81f9adcd5a3c5f254bc8256b0158f54673dcc1232f6e918ebfc6c51ce67eaeb042d9f57eec4bfe910e169af78b3de48d137df4f2840 +e360d12ce51f0a0408dcd07311d795a66dfee13b5f545d1a87fa01888910bb2e 626f68c18a69a6590159a9c46be03d5965698f2dac3de779b878b3d9c421e0f21b955a16c715c1ec1e22ce3eb645b8b4f263f60660ea3028981eebd6c8c3a367285b691c8ee56944a7cd1217997e1d9c21620b536bdbd5de8925ff71dec6fbc06624ab6b21e329813de90d1e572dfb89a18120c3f606355d25 +d91bddf47646fdb8704bf341ecfb3f7a38865b74ab66c0fc61739ea27f3b40a2 651a6fb3c4b80c7c68c6011675e6094eb56abf5fc3057324ebc6477825061f9f27e7a94633abd1fa598a746e4a577caf524c52ec1788471f92b8c37f23795ca19d559d446cab16cbcdce90b79fa1026cee77bf4ab1b503c5b94c2256ad75b3eac6fd5dcb96aca4b03a834bfb4e9af988cecbf2ae597cb9097940 +caf2cc15cdf0dda5b1400321d61a02b30303606d69a40f3a9bb4b852a632ab0d 8aaf072fce8a2d96bc10b3c91c809ee93072fb205ca7f10abd82ecd82cf040b1bc49ea13d1857815c0e99781de3adbb5443ce1c897e55188ceaf221aa9681638de05ae1b322938f46bce51543b57ecdb4c266272259d1798de13be90e10efec2d07484d9b21a3870e2aa9e06c21aa2d0c9cf420080a80a91dee16f +b93c7b2b07866e6fbe146c88cb92dbce7b4f33f3d90c1b69d2eb39b17aa122b8 53f918fd00b1701bd504f8cdea803acca21ac18c564ab90c2a17da592c7d69688f6580575395551e8cd33e0fef08ca6ed4588d4d140b3e44c032355df1c531564d7f4835753344345a6781e11cd5e095b73df5f82c8ae3ad00877936896671e947cc52e2b29dcd463d90a0c9929128da222b5a211450bbc0e02448e2 +f5259b275f25da827232684cab4b615609fe0d161916293fa173a71cde464b37 a64599b8a61b5ccec9e67aed69447459c8da3d1ec6c7c7c82a7428b9b584fa67e90f68e2c00fbbed4613666e5168da4a16f395f7a3c3832b3b134bfc9cbaa95d2a0fe252f44ac6681eb6d40ab91c1d0282fed6701c57463d3c5f2bb8c6a7301fb4576aa3b5f15510db8956ff77478c26a7c09bea7b398cfc83503f538e +3d148ed7cdb57edfc12ffe9d5d6373de7f94927c7c1c5f5a5a883d3d6806a8b5 0e3ab0e054739b00cdb6a87bd12cae024b54cb5e550e6c425360c2e87e59401f5ec24ef0314855f0f56c47695d56a7fb1417693af2a1ed5291f2fee95f75eed54a1b1c2e81226fbff6f63ade584911c71967a8eb70933bc3f5d15bc91b5c2644d9516d3c3a8c154ee48e118bd1442c043c7a0dba5ac5b1d5360aae5b9065 +056067952a0c8980ea0d580e45516c2cb0d2ed3ac0666474843f4a3c8c1cd7db a62fc595b4096e6336e53fcdfc8d1cc175d71dac9d750a6133d23199eaac288207944cea6b16d27631915b4619f743da2e30a0c00bbdb1bbb35ab852ef3b9aec6b0a8dcc6e9e1abaa3ad62ac0a6c5de765de2c3711b769e3fde44a74016fff82ac46fa8f1797d3b2a726b696e3dea5530439acee3a45c2a51bc32dd055650b +646f10ba11e7b11292e7f60551316c36625382f200959f3569de356f64ddea55 2b6db7ced8665ebe9deb080295218426bdaa7c6da9add2088932cdffbaa1c14129bccdd70f369efb149285858d2b1d155d14de2fdb680a8b027284055182a0cae275234cc9c92863c1b4ab66f304cf0621cd54565f5bff461d3b461bd40df28198e3732501b4860eadd503d26d6e69338f4e0456e9e9baf3d827ae685fb1d817 +86244ea88b4719b0d9bb3a5331e7377add4b344787e1e1aedb5255fdc91a3bdd 10db509b2cdcaba6c062ae33be48116a29eb18e390e1bbada5ca0a2718afbcd23431440106594893043cc7f2625281bf7de2655880966a23705f0c5155c2f5cca9f2c2142e96d0a2e763b70686cd421b5db812daced0c6d65035fde558e94f26b3e6dde5bd13980cc80292b723013bd033284584bff27657871b0cf07a849f4ae2 +050e9efcc769a37a0d2e2025d188420f64da7462ff23c84097bf0459b5bc72e0 9334de60c997bda6086101a6314f64e4458f5ff9450c509df006e8c547983c651ca97879175aaba0c539e82d05c1e02c480975cbb30118121061b1ebac4f8d9a3781e2db6b18042e01ecf9017a64a0e57447ec7fcbe6a7f82585f7403ee2223d52d37b4bf426428613d6b4257980972a0acab508a7620c1cb28eb4e9d30fc41361ec +ea579b71967afe941af6f387ec21333a6d54d0dccf8b8030a62d4dce323e6cde e88ab086891693aa535ceb20e64c7ab97c7dd3548f3786339897a5f0c39031549ca870166e477743ccfbe016b4428d89738e426f5ffe81626137f17aecff61b72dbee2dc20961880cfe281dfab5ee38b1921881450e16032de5e4d55ad8d4fca609721b0692bac79be5a06e177fe8c80c0c83519fb3347de9f43d5561cb8107b9b5edc +4b4e15c2ffbcdf3d85ebb40df82b33dbef5fe7db148f0d1df56b2649127455e1 fd19e01a83eb6ec810b94582cb8fbfa2fcb992b53684fb748d2264f020d3b960cb1d6b8c348c2b54a9fcea72330c2aaa9a24ecdb00c436abc702361a82bb8828b85369b8c72ece0082fe06557163899c2a0efa466c33c04343a839417057399a63a3929be1ee4805d6ce3e5d0d0967fe9004696a5663f4cac9179006a2ceb75542d75d68 +c24fa9ecb586c843de5d2ecc64704580777ec32b92167a383bdcf664f7b9f39a 59ae20b6f7e0b3c7a989afb28324a40fca25d8651cf1f46ae383ef6d8441587aa1c04c3e3bf88e8131ce6145cfb8973d961e8432b202fa5af3e09d625faad825bc19da9b5c6c20d02abda2fcc58b5bd3fe507bf201263f30543819510c12bc23e2ddb4f711d087a86edb1b355313363a2de996b891025e147036087401ccf3ca7815bf3c49 +f639af0e45033dc8f3643646adda30fd522b1e375cf34bd4f04e46049dee8246 77ee804b9f3295ab2362798b72b0a1b2d3291dceb8139896355830f34b3b328561531f8079b79a6e9980705150866402fdc176c05897e359a6cb1a7ab067383eb497182a7e5aef7038e4c96d133b2782917417e391535b5e1b51f47d8ed7e4d4025fe98dc87b9c1622614bff3d1029e68e372de719803857ca52067cddaad958951cb2068cc6 +6d76b610320c5c7732cdc5c23781d7f931dca1dc4de0b438b2a07442bd1fa90c b771d5cef5d1a41a93d15643d7181d2a2ef0a8e84d91812f20ed21f147bef732bf3a60ef4067c3734b85bc8cd471780f10dc9e8291b58339a677b960218f71e793f2797aea349406512829065d37bb55ea796fa4f56fd8896b49b2cd19b43215ad967c712b24e5032d065232e02c127409d2ed4146b9d75d763d52db98d949d3b0fed6a8052fbb +d7b30952f814d5bf6d4203443d21bd353e866cd615f93b555220d1fb0a7c0df7 b32d95b0b9aad2a8816de6d06d1f86008505bd8c14124f6e9a163b5a2ade55f835d0ec3880ef50700d3b25e42cc0af050ccd1be5e555b23087e04d7bf9813622780c7313a1954f8740b6ee2d3f71f768dd417f520482bd3a08d4f222b4ee9dbd015447b33507dd50f3ab4247c5de9a8abd62a8decea01e3b87c8b927f5b08beb37674c6f8e380c04 +3db2149af362d83e1af96e2fd2b7a08c367d9f59ba4b65f0fd09945b39083fcb 04410e31082a47584b406f051398a6abe74e4da59bb6f85e6b49e8a1f7f2ca00dfba5462c2cd2bfde8b64fb21d70c083f11318b56a52d03b81cac5eec29eb31bd0078b6156786da3d6d8c33098c5c47bb67ac64db14165af65b44544d806dde5f487d5373c7f9792c299e9686b7e5821e7c8e2458315b996b5677d926dac57b3f22da873c601016a0d +b912aa656a2e33d9710cf86ec449461078c7abde85d8e31ccd39f4acc8d67f91 8b81e9badde026f14d95c019977024c9e13db7a5cd21f9e9fc491d716164bbacdc7060d882615d411438aea056c340cdf977788f6e17d118de55026855f93270472d1fd18b9e7e812bae107e0dfde7063301b71f6cfe4e225cab3b232905a56e994f08ee2891ba922d49c3dafeb75f7c69750cb67d822c96176c46bd8a29f1701373fb09a1a6e3c7158f +811ef2aac250b75a2231cc9be17339afa3778fd44336e4b4d1cda73fd9c1b4aa fa6eed24da6666a22208146b19a532c2ec9ba94f09f1def1e7fc13c399a48e41acc2a589d099276296348f396253b57cb0e40291bd282773656b6e0d8bea1cda084a3738816a840485fcf3fb307f777fa5feac48695c2af4769720258c77943fb4556c362d9cba8bf103aeb9034baa8ea8bfb9c4f8e6742ce0d52c49ea8e974f339612e830e9e7a9c29065 +cbab02b97b7636b86c23cc21fca742453e75ac7b29b95072bf03df27bd7cd13b 9bb4af1b4f09c071ce3cafa92e4eb73ce8a6f5d82a85733440368dee4eb1cbc7b55ac150773b6fe47dbe036c45582ed67e23f4c74585dab509df1b83610564545642b2b1ec463e18048fc23477c6b2aa035594ecd33791af6af4cbc2a1166aba8d628c57e707f0b0e8707caf91cd44bdb915e0296e0190d56d33d8dde10b5b60377838973c1d943c22ed335e +83f63733c1092b4bca9bae01afdb80a0dc5fc1d60287b3bed5a2beccf94dce07 2167f02118cc62043e9091a647cadbed95611a521fe0d64e8518f16c808ab297725598ae296880a773607a798f7c3cfce80d251ebec6885015f9abf7eaabae46798f82cb5926de5c23f44a3f9f9534b3c6f405b5364c2f8a8bdc5ca49c749bed8ce4ba48897062ae8424ca6dde5f55c0e42a95d1e292ca54fb46a84fbc9cd87f2d0c9e7448de3043ae22fdd229 +d785429352e1672e59afd2caa4445e2129f80c1a31eb98661528dc4d15d827b7 94b7fa0bc1c44e949b1d7617d31b4720cbe7ca57c6fa4f4094d4761567e389ecc64f6968e4064df70df836a47d0c713336b5028b35930d29eb7a7f9a5af9ad5cf441745baec9bb014ceeff5a41ba5c1ce085feb980bab9cf79f2158e03ef7e63e29c38d7816a84d4f71e0f548b7fc316085ae38a060ff9b8dec36f91ad9ebc0a5b6c338cbb8f6659d342a24368cf +5444fa5b925075ed148d11844224362fa1081a15f2bd44859a717b411dfd0f83 ea40e83cb18b3a242c1ecc6ccd0b7853a439dab2c569cfc6dc38a19f5c90acbf76aef9ea3742ff3b54ef7d36eb7ce4ff1c9ab3bc119cff6be93c03e208783335c0ab8137be5b10cdc66ff3f89a1bddc6a1eed74f504cbe7290690bb295a872b9e3fe2cee9e6c67c41db8efd7d863cf10f840fe618e7936da3dca5ca6df933f24f6954ba0801a1294cd8d7e66dfafec +2b6bb3691b9617d1691ee51528ba35dfe0f6ca83ca8df670eeb9ab41bdb03a5f 157d5b7e4507f66d9a267476d33831e7bb768d4d04cc3438da12f9010263ea5fcafbde2579db2f6b58f911d593d5f79fb05fe3596e3fa80ff2f761d1b0e57080055c118c53e53cdb63055261d7c9b2b39bd90acc32520cbbdbda2c4fd8856dbcee173132a2679198daf83007a9b5c51511ae49766c792a29520388444ebefe28256fb33d4260439cba73a9479ee00c63 +793df7427fa71156e9e7f0376c5ff0065877c8e937154010b9739360a33c26c3 836b34b515476f613fe447a4e0c3f3b8f20910ac89a3977055c960d2d5d2b72bd8acc715a9035321b86703a411dde0466d58a59769672aa60ad587b8481de4bba552a1645779789501ec53d540b904821f32b0bd1855b04e4848f9f8cfe9ebd8911be95781a759d7ad9724a7102dbe576776b7c632bc39b9b5e19057e226552a5994c1dbb3b5c7871a11f5537011044c53 +566a86949f03886d205e51fa7e7d892c24bdbe4d9d10e956dee0ef61c88ea4c0 cc7784a4912a7ab5ad3620aab29ba87077cd3cb83636adc9f3dc94f51edf521b2161ef108f21a0a298557981c0e53ce6ced45bdf782c1ef200d29bab81dd6460586964edab7cebdbbec75fd7925060f7da2b853b2b089588fa0f8c16ec6498b14c55dcee335cb3a91d698e4d393ab8e8eac0825f8adebeee196df41205c011674e53426caa453f8de1cbb57932b0b741d4c6 +48872584a1f006928081f777b8ac410e564a16e2d9302bb395dd49b91682d8a6 7639b461fff270b2455ac1d1afce782944aea5e9087eb4a39eb96bb5c3baaf0e868c8526d3404f9405e79e77bfac5ffb89bf1957b523e17d341d7323c302ea7083872dd5e8705694acdda36d5a1b895aaa16eca6104c82688532c8bfe1790b5dc9f4ec5fe95baed37e1d287be710431f1e5e8ee105bc42ed37d74b1e55984bf1c09fe6a1fa13ef3b96faeaed6a2a1950a12153 +c1d4648e6e385343201c67a184c7a6f598905a37a131bae2f942f33f6e5dd816 eb6513fc61b30cfba58d4d7e80f94d14589090cf1d80b1df2e68088dc6104959ba0d583d585e9578ab0aec0cf36c48435eb52ed9ab4bbce7a5abe679c97ae2dbe35e8cc1d45b06dda3cf418665c57cbee4bbb47fa4caf78f4ee656fec237fe4eebbafa206e1ef2bd0ee4ae71bd0e9b2f54f91daadf1febfd7032381d636b733dcb3bf76fb14e23aff1f68ed3dbcf75c9b99c6f26 +c46c4d7ae2db1ccf0541100432c6a914f517e13311880dc00c9942ae28327ecd 1594d74bf5dde444265d4c04dad9721ff3e34cbf622daf341fe16b96431f6c4df1f760d34f296eb97d98d560ad5286fec4dce1724f20b54fd7df51d4bf137add656c80546fb1bf516d62ee82baa992910ef4cc18b70f3f8698276fcfb44e0ec546c2c39cfd8ee91034ff9303058b4252462f86c823eb15bf481e6b79cc3a02218595b3658e8b37382bd5048eaed5fd02c37944e73b +95b9f8b71da1deb5fb6ece239a78d4ae05c16d1a6bd0a3a50eca8913e49e67e6 4cfa1278903026f66fedd41374558be1b585d03c5c55dac94361df286d4bd39c7cb8037ed3b267b07c346626449d0cc5b0dd2cf221f7e4c3449a4be99985d2d5e67bff2923357ddeab5abcb4619f3a3a57b2cf928a022eb27676c6cf805689004fca4d41ea6c2d0a4789c7605f7bb838dd883b3ad3e6027e775bcf262881428099c7fff95b14c095ea130e0b9938a5e22fc52650f591 +06c41ae52120920d08807c1b192074578683d619855e2086db03a4f451c235dc d3e65cb92cfa79662f6af493d696a07ccf32aaadcceff06e73e8d9f6f909209e66715d6e978788c49efb9087b170ecf3aa86d2d4d1a065ae0efc8924f365d676b3cb9e2bec918fd96d0b43dee83727c9a93bf56ca2b2e59adba85696546a815067fc7a78039629d4948d157e7b0d826d1bf8e81237bab7321312fdaa4d521744f988db6fdf04549d0fdca393d639c729af716e9c8bba48 +1484139c615266cd88d53299ceb4423cacb8ed0f61a168d5cceab5ec42d157e2 842cc583504539622d7f71e7e31863a2b885c56a0ba62db4c2a3f2fd12e79660dc7205ca29a0dc0a87db4dc62ee47a41db36b9ddb3293b9ac4baae7df5c6e7201e17f717ab56e12cad476be49608ad2d50309e7d48d2d8de4fa58ac3cfeafeee48c0a9eec88498e3efc51f54d300d828dddccb9d0b06dd021a29cf5cb5b2506915beb8a11998b8b886e0f9b7a80e97d91a7d01270f9a7717 +d10faa55a303f8bb1c7bb04a88401230f87b06d41922f1783dcaeaa72704c06d 6c4b0a0719573e57248661e98febe326571f9a1ca813d3638531ae28b4860f23c3a3a8ac1c250034a660e2d71e16d3acc4bf9ce215c6f15b1c0fc7e77d3d27157e66da9ceec9258f8f2bf9e02b4ac93793dd6e29e307ede3695a0df63cbdc0fc66fb770813eb149ca2a916911bee4902c47c7802e69e405fe3c04ceb5522792a5503fa829f707272226621f7c488a7698c0d69aa561be9f378 +85c0a4eb3930c65a860decd952073587281a8f300d25b56847193c966d11a651 51b7dbb7ce2ffeb427a91ccfe5218fd40f9e0b7e24756d4c47cd55606008bdc27d16400933906fd9f30effdd4880022d081155342af3fb6cd53672ab7fb5b3a3bcbe47be1fd3a2278cae8a5fd61c1433f7d350675dd21803746cadca574130f01200024c6340ab0cc2cf74f2234669f34e9009ef2eb94823d62b31407f4ba46f1a1eec41641e84d77727b59e746b8a671bef936f05be820759fa +11372edebef36cce2ab05d2d1fc69619b8122bbad2a0c3dccefaf025f3d2358b 83599d93f5561e821bd01a472386bc2ff4efbd4aed60d5821e84aae74d8071029810f5e286f8f17651cd27da07b1eb4382f754cd1c95268783ad09220f5502840370d494beb17124220f6afce91ec8a0f55231f9652433e5ce3489b727716cf4aeba7dcda20cd29aa9a859201253f948dd94395aba9e3852bd1d60dda7ae5dc045b283da006e1cbad83cc13292a315db5553305c628dd091146597 +8393e6903e3f13269e12a36bcabf0b2ac562c88db8d6e712b02051784d6231d5 2be9bf526c9d5a75d565dd11ef63b979d068659c7f026c08bea4af161d85a462d80e45040e91f4165c074c43ac661380311a8cbed59cc8e4c4518e80cd2c78ab1cabf66bff83eab3a80148550307310950d034a6286c93a1ece8929e6385c5e3bb6ea8a7c0fb6d6332e320e71cc4eb462a2a62e2bfe08f0ccad93e61bedb5dd0b786a728ab666f07e0576d189c92bf9fb20dca49ac2d3956d47385e2 +9852f04e0b0de5ba2730b13f309918d0a9659d55c4f1ad6d41e021ea27400231 ca76d3a12595a817682617006848675547d3e8f50c2210f9af906c0e7ce50b4460186fe70457a9e879e79fd4d1a688c70a347361c847ba0dd6aa52936eaf8e58a1be2f5c1c704e20146d366aeb3853bed9de9befe9569ac8aaea37a9fb7139a1a1a7d5c748605a8defb297869ebedd71d615a5da23496d11e11abbb126b206fa0a7797ee7de117986012d0362dcef775c2fe145ada6bda1ccb326bf644 +441f12172d7ba309f914f6f0c028a03f5bb65b6311a575dcc4f58743c7f96806 f76b85dc67421025d64e93096d1d712b7baf7fb001716f02d33b2160c2c882c310ef13a576b1c2d30ef8f78ef8d2f465007109aad93f74cb9e7d7bef7c9590e8af3b267c89c15db238138c45833c98cc4a471a7802723ef4c744a853cf80a0c2568dd4ed58a2c9644806f42104cee53628e5bdf7b63b0b338e931e31b87c24b146c6d040605567ceef5960df9e022cb469d4c787f4cba3c544a1ac91f95f +2cb9727430fe2ac583b1fc544d6d1d40435483c68e842a4c8b3e848472a121f8 25b8c9c032ea6bcd733ffc8718fbb2a503a4ea8f71dea1176189f694304f0ff68e862a8197b839957549ef243a5279fc2646bd4c009b6d1edebf24738197abb4c992f6b1dc9ba891f570879accd5a6b18691a93c7d0a8d38f95b639c1daeb48c4c2f15ccf5b9d508f8333c32de78781b41850f261b855c4bebcc125a380c54d501c5d3bd07e6b52102116088e53d76583b0161e2a58d0778f091206aabd5a1 +775d4282398533fdceb51f582df79f0d58f266bbfe7054d63588210f03dde1bb 21cfdc2a7ccb7f331b3d2eefff37e48ad9fa9c788c3f3c200e0173d99963e1cbca93623b264e920394ae48bb4c3a5bb96ffbc8f0e53f30e22956adabc2765f57fb761e147ecbf8567533db6e50c8a1f894310a94edf806dd8ca6a0e141c0fa7c9fae6c6ae65f18c93a8529e6e5b553bf55f25be2e80a9882bd37f145fecbeb3d447a3c4e46c21524cc55cdd62f521ab92a8ba72b897996c49bb273198b7b1c9e +8b7a28798f57467e11f67618461e2d68fa46936e1140e3e04e7bca5f5770871b 4e452ba42127dcc956ef4f8f35dd68cb225fb73b5bc7e1ec5a898bba2931563e74faff3b67314f241ec49f4a7061e3bd0213ae826bab380f1f14faab8b0efddd5fd1bb49373853a08f30553d5a55ccbbb8153de4704f29ca2bdeef0419468e05dd51557ccc80c0a96190bbcc4d77ecff21c66bdf486459d427f986410f883a80a5bcc32c20f0478bb9a97a126fc5f95451e40f292a4614930d054c851acd019ccf +3defd55d53403a607ef9ddb4fa46ac538369a384ff5b1bbea52a4e58f90573ba fa85671df7dadf99a6ffee97a3ab9991671f5629195049880497487867a6c446b60087fac9a0f2fcc8e3b24e97e42345b93b5f7d3691829d3f8ccd4bb36411b85fc2328eb0c51cb3151f70860ad3246ce0623a8dc8b3c49f958f8690f8e3860e71eb2b1479a5cea0b3f8befd87acaf5362435eaeccb52f38617bc6c5c2c6e269ead1fbd69e941d4ad2012da2c5b21bcfbf98e4a77ab2af1f3fda3233f046d38f1dc8 +45f62d59a636a8534ee1be1c59e2886aa7ca91cf46918ca2ea58bdb1b261639d e90847ae6797fbc0b6b36d6e588c0a743d725788ca50b6d792352ea8294f5ba654a15366b8e1b288d84f5178240827975a763bc45c7b0430e8a559df4488505e009c63da994f1403f407958203cebb6e37d89c94a5eacf6039a327f6c4dbbc7a2a307d976aa39e41af6537243fc218dfa6ab4dd817b6a397df5ca69107a9198799ed248641b63b42cb4c29bfdd7975ac96edfc274ac562d0474c60347a078ce4c25e88 +8aeb26e5c317f7213f4ebd663cd03470579eb1c9123cd54fbe51366b67f67ecd f6d5c2b6c93954fc627602c00c4ca9a7d3ed12b27173f0b2c9b0e4a5939398a665e67e69d0b12fb7e4ceb253e8083d1ceb724ac07f009f094e42f2d6f2129489e846eaff0700a8d4453ef453a3eddc18f408c77a83275617fabc4ea3a2833aa73406c0e966276079d38e8e38539a70e194cc5513aaa457c699383fd1900b1e72bdfb835d1fd321b37ba80549b078a49ea08152869a918ca57f5b54ed71e4fd3ac5c06729 +a7732e2c8a537fa70093190bcf79d4b6027f9f1117d806a759bbd7c8e86463dd cf8562b1bed89892d67ddaaf3deeb28246456e972326dbcdb5cf3fb289aca01e68da5d59896e3a6165358b071b304d6ab3d018944be5049d5e0e2bb819acf67a6006111089e6767132d72dd85beddcbb2d64496db0cc92955ab4c6234f1eea24f2d51483f2e209e4589bf9519fac51b4d061e801125e605f8093bb6997bc163d551596fe4ab7cfae8fb9a90f6980480ce0c229fd1675409bd788354daf316240cfe0af93eb +405027d542ca47aab86e8ec3559949073038c63f1d387950aff366324f7bea26 2ace31abb0a2e3267944d2f75e1559985db7354c6e605f18dc8470423fca30b7331d9b33c4a4326783d1caae1b4f07060eff978e4746bf0c7e30cd61040bd5ec2746b29863eb7f103ebda614c4291a805b6a4c8214230564a0557bc7102e0bd3ed23719252f7435d64d210ee2aafc585be903fa41e1968c50fd5d5367926df7a05e3a42cf07e656ff92de73b036cf8b19898c0cb34557c0c12c2d8b84e91181af467bc75a9d1 +21da77b4feeb0e383d1593cdfe0c4a85d2da53eb1ce0b6e459d23337de40a567 0d8d09aed19f1013969ce5e7eb92f83a209ae76be31c754844ea9116ceb39a22ebb6003017bbcf26555fa6624185187db8f0cb3564b8b1c06bf685d47f3286eda20b83358f599d2044bbf0583fab8d78f854fe0a596183230c5ef8e54426750eaf2cc4e29d3bdd037e734d863c2bd9789b4c243096138f7672c232314effdfc6513427e2da76916b5248933be312eb5dde4cf70804fb258ac5fb82d58d08177ac6f4756017fff5 +7a4d72fd944ef3f85db6249b7cde3f57234bbe83594090075ffa251bc9496ea0 c3236b73deb7662bf3f3daa58f137b358ba610560ef7455785a9befdb035a066e90704f929bd9689cef0ce3bda5acf4480bceb8d09d10b098ad8500d9b6071dfc3a14af6c77511d81e3aa8844986c3bea6f469f9e02194c92868cd5f51646256798ff0424954c1434bdfed9facb390b07d342e992936e0f88bfd0e884a0ddb679d0547ccdec6384285a45429d115ac7d235a717242021d1dc35641f5f0a48e8445dba58e6cb2c8ea +7f972b1f0e3eb173cb63cb7c6a8907df8de1120fb5af85528f0b13cbcd93709b b39feb8283eadc63e8184b51df5ae3fd41aac8a963bb0be1cd08aa5867d8d910c669221e73243360646f6553d1ca05a84e8dc0de05b6419ec349ca994480193d01c92525f3fb3dcefb08afc6d26947bdbbfd85193f53b50609c6140905c53a6686b58e53a319a57b962331ede98149af3de3118a819da4d76706a0424b4e1d2910b0ed26af61d150ebcb46595d4266a0bd7f651ba47d0c7f179ca28545007d92e8419d48fdfbd744ce +d2fe6c5c26c24f492c8e29b2e2f2138a1488aa25ad62e28d5f602e8e324dbbab a983d54f503803e8c7999f4edbbe82e9084f422143a932ddddc47a17b0b7564a7f37a99d0786e99476428d29e29d3c197a72bfab1342c12a0fc4787fd7017d7a6174049ea43b5779169ef7472bdbbd941dcb82fc73aac45a8a94c9f2bd3477f61fd3b796f02a1b8264a214c6fea74b7051b226c722099ec7883a462b83b6afdd4009248b8a237f605fe5a08fe7d8b45321421ebba67bd70a0b00ddbf94baab7f359d5d1eea105f28dcfb +8cd3ccd8a2080c0ce4eac9211d3b013fdec990fda15975133d01e917cdecb43d e4d1c1897a0a866ce564635b74222f9696bf2c7f640dd78d7e2aca66e1b61c642bb03ea7536aae597811e9bf4a7b453ede31f97b46a5f0ef51a071a2b3918df16b152519ae3776f9f1edab4c2a377c3292e96408359d3613844d5eb393000283d5ad3401a318b12fd1474b8612f2bb50fb6a8b9e023a54d7dde28c43d6d8854c8d9d1155935c199811dbfc87e9e0072e90eb88681cc7529714f8fb8a2c9d88567adfb974ee205a9bf7b848 +072dcbc9ec0cb4c069005401c1ef6f08aacdb4987f34d3fdc0a10b2c63440036 b10c59723e3dcadd6d75df87d0a1580e73133a9b7d00cb95ec19f5547027323be75158b11f80b6e142c6a78531886d9047b08e551e75e6261e79785366d7024bd7cd9cf322d9be7d57fb661069f2481c7bb759cd71b4b36ca2bc2df6d3a328faebdb995a9794a8d72155ed551a1f87c80bf6059b43fc764900b18a1c2441f7487743cf84e565f61f8dd2ece6b6ccc9444049197aaaf53e926fbee3bfca8be588ec77f29d211be89de18b15f6 +9c5c246d8dcea6dc951c75695494979df6ea10c4c02dd850d566e090cdea7f7a db11f609baba7b0ca634926b1dd539c8cbada24967d7add4d9876f77c2d80c0f4dcefbd7121548373582705cca2495bd2a43716fe64ed26d059cfb566b3364bd49ee0717bdd9810dd14d8fad80dbbdc4cafb37cc60fb0fe2a80fb4541b8ca9d59dce457738a9d3d8f641af8c3fd6da162dc16fc01aac527a4a0255b4d231c0be50f44f0db0b713af03d968fe7f0f61ed0824c55c4b5265548febd6aad5c5eedf63efe793489c39b8fd29d104ce +7cf815ee452712716457935062d65b4a02ec61e035d310f2db73b2646847cd06 bebd4f1a84fc8b15e4452a54bd02d69e304b7f32616aadd90537937106ae4e28de9d8aab02d19bc3e2fde1d651559e296453e4dba94370a14dbbb2d1d4e2022302ee90e208321efcd8528ad89e46dc839ea9df618ea8394a6bff308e7726bae0c19bcd4be52da6258e2ef4e96aa21244429f49ef5cb486d7ff35cac1bacb7e95711944bccb2ab34700d42d1eb38b5d536b947348a458ede3dc6bd6ec547b1b0cae5b257be36a7124e1060c170ffa +c4d9850774ae7356e1611f3053af679461585643550eea4d17dfabf56080926e 5aca56a03a13784bdc3289d9364f79e2a85c12276b49b92db0adaa4f206d5028f213f678c3510e111f9dc4c1c1f8b6acb17a6413aa227607c515c62a733817ba5e762cc6748e7e0d6872c984d723c9bb3b117eb8963185300a80bfa65cde495d70a46c44858605fccbed086c2b45cef963d33294dbe9706b13af22f1b7c4cd5a001cfec251fba18e722c6e1c4b1166918b4f6f48a98b64b3c07fc86a6b17a6d0480ab79d4e6415b520f1c484d675b1 +cb5f77251039b98b8c824c4a4b9d0488e91cefb9c0034a8dada90892cf44130c a5aad0e4646a32c85cfcac73f02fc5300f1982fabb2f2179e28303e447854094cdfc854310e5c0f60993ceff54d84d6b46323d930adb07c17599b35b505f09e784bca5985e0172257797fb53649e2e9723efd16865c31b5c3d5113b58bb0bfc8920fabdda086d7537e66d709d050bd14d0c960873f156fad5b3d3840cdfcdc9be6af519db262a27f40896ab25cc39f96984d650611c0d5a3080d5b3a1bf186abd42956588b3b58cd948970d298776060 +a81b4d1186780d240dfa3ee37e1b0d7d88d25c55f6f301a79df30988247bbc70 06cbbe67e94a978203ead6c057a1a5b098478b4b4cbef5a97e93c8e42f5572713575fc2a884531d7622f8f879387a859a80f10ef02708cd8f7413ab385afc357678b9578c0ebf641ef076a1a30f1f75379e9dcb2a885bdd295905ee80c0168a62a9597d10cf12dd2d8cee46645c7e5a141f6e0e23aa482abe5661c16e69ef1e28371e2e236c359ba4e92c25626a7b7ff13f6ea4ae906e1cfe163e91719b1f750a96cbde5fbc953d9e576cd216afc90323a +f0425b89b75eab5d927e4a03034fbbff2f80e59d704655efd75153d1caec7316 f1c528cf7739874707d4d8ad5b98f7c77169de0b57188df233b2dc8a5b31eda5db4291dd9f68e6bad37b8d7f6c9c0044b3bf74bbc3d7d1798e138709b0d75e7c593d3cccdc1b20c7174b4e692add820ace262d45ccfae2077e878796347168060a162ecca8c38c1a88350bd63bb539134f700fd4addd5959e255337daa06bc86358fabcbefdfb5bc889783d843c08aadc6c4f6c36f65f156e851c9a0f917e4a367b5ad93d874812a1de6a7b93cd53ad97232 +2f5c290fdcb38d252a6c5aa2b0f2519fb47aa97f9b5151dbed387b3e60d639c0 9d9f3a7ecd51b41f6572fd0d0881e30390dfb780991dae7db3b47619134718e6f987810e542619dfaa7b505c76b7350c6432d8bf1cfebdf1069b90a35f0d04cbdf130b0dfc7875f4a4e62cdb8e525aadd7ce842520a482ac18f09442d78305fe85a74e39e760a4837482ed2f437dd13b2ec1042afcf9decdc3e877e50ff4106ad10a525230d11920324a81094da31deab6476aa42f20c84843cfc1c58545ee80352bdd3740dd6a16792ae2d86f11641bb717c2 +9c4b1992d5ec2ddc9504d85d97d9a845972e2501b09e13ee4c1e2ecc84b581e7 5179888724819fbad3afa927d3577796660e6a81c52d98e9303261d5a4a83232f6f758934d50aa83ff9e20a5926dfebaac49529d006eb923c5ae5048ed544ec471ed7191edf46363383824f915769b3e688094c682b02151e5ee01e510b431c8865aff8b6b6f2f59cb6d129da79e97c6d2b8fa6c6da3f603199d2d1bcab547682a81cd6cf65f6551121391d78bcc23b5bd0e922ec6d8bf97c952e84dd28aef909aba31edb903b28fbfc33b7703cd996215a11238 +f69fd7169508a69d59f81431a40b355cb932e06a850f19b334e758b4851bdde5 576ef3520d30b7a4899b8c0d5e359e45c5189add100e43be429a02fb3de5ff4f8fd0e79d9663acca72cd29c94582b19292a557c5b1315297d168fbb54e9e2ecd13809c2b5fce998edc6570545e1499dbe7fb74d47cd7f35823b212b05bf3f5a79caa34224fdd670d335fcb106f5d92c3946f44d3afcbae2e41ac554d8e6759f332b76be89a0324aa12c5482d1ea3ee89ded4936f3e3c080436f539fa137e74c6d3389bdf5a45074c47bc7b20b0948407a66d855e2f +392a2ad8a05da5927e742523113ef9bee70672f85247f5c05a6fdbb507434964 0df2152fa4f4357c8741529dd77e783925d3d76e95bafa2b542a2c33f3d1d117d159cf473f82310356fee4c90a9e505e70f8f24859656368ba09381fa245eb6c3d763f3093f0c89b972e66b53d59406d9f01aea07f8b3b615cac4ee4d05f542e7d0dab45d67ccccd3a606ccbeb31ea1fa7005ba07176e60dab7d78f6810ef086f42f08e595f0ec217372b98970cc6321576d92ce38f7c397a403bada1548d205c343ac09deca86325373c3b76d9f32028fea8eb32515 +7120ecafc3ddc28d152d796b9630ab7a7b7742e9f639f831a42595af6a8ec8e4 3e15350d87d6ebb5c8ad99d42515cfe17980933c7a8f6b8bbbf0a63728cefaad2052623c0bd5931839112a48633fb3c2004e0749c87a41b26a8b48945539d1ff41a4b269462fd199bfecd45374756f55a9116e92093ac99451aefb2af9fd32d6d7f5fbc7f7a540d5097c096ebc3b3a721541de073a1cc02f7fb0fb1b9327fb0b1218ca49c9487ab5396622a13ae546c97abdef6b56380dda7012a8384091b6656d0ab272d363cea78163ff765cdd13ab1738b940d16cae +da9737030e97b534c1ef0204519bd64abc568bcda2c04f426edb8f4966e9ac7f c38d6b0b757cb552be40940ece0009ef3b0b59307c1451686f1a22702922800d58bce7a636c1727ee547c01b214779e898fc0e560f8ae7f61bef4d75eaa696b921fd6b735d171535e9edd267c192b99880c87997711002009095d8a7a437e258104a41a505e5ef71e5613ddd2008195f0c574e6ba3fe40099cfa116e5f1a2fa8a6da04badcb4e2d5d0de31fdc4800891c45781a0aac7c907b56d631fca5ce8b2cde620d11d1777ed9fa603541de794ddc5758fcd5fad78c0 +d6eb621f0b57f913e2a782e63a67808e788e1c4673acc7467dd6a9218b747119 8d2de3f0b37a6385c90739805b170057f091cd0c7a0bc951540f26a5a75b3e694631bb64c7635eed316f51318e9d8de13c70a2aba04a14836855f35e480528b776d0a1e8a23b547c8b8d6a0d09b241d3be9377160cca4e6793d00a515dc2992cb7fc741daca171431da99cce6f7789f129e2ac5cf65b40d703035cd2185bb936c82002daf8cbc27a7a9e554b06196630446a6f0a14ba155ed26d95bd627b7205c072d02b60db0fd7e49ea058c2e0ba202daff0de91e845cf79 +164aaff496c06cc2b089726c5f3702eff2ed35c5159a9b74306c5cf3639ebe90 c464bbdad275c50dcd983b65ad1019b9ff85a1e71c807f3204bb2c921dc31fbcd8c5fc45868ae9ef85b6c9b83bba2a5a822201ed68586ec5ec27fb2857a5d1a2d09d09115f22dcc39fe61f5e1ba0ff6e8b4acb4c6da748be7f3f0839739394ff7fa8e39f7f7e84a33c3866875c01bcb1263c9405d91908e9e0b50e7459fabb63d8c6bbb73d8e3483c099b55bc30ff092ff68b6adedfd477d63570c9f5515847f36e24ba0b705557130cec57ebad1d0b31a378e91894ee26e3a04 +99039cfbcc6b979118fd416ab3ca7f2540eb62f61e8895685c32becdfd661f8d 8b8d68bb8a75732fe272815a68a1c9c5aa31b41dedc8493e76525d1d013d33cebd9e21a5bb95db2616976a8c07fcf411f5f6bc6f7e0b57aca78cc2790a6f9b898858ac9c79b165ff24e66677531e39f572be5d81eb3264524181115f32780257bfb9aeec6af12af28e587cac068a1a2953b59ad680f4c245b2e3ec36f59940d37e1d3db38e13edb29b5c0f404f6ff87f80fc8be7a225ff22fbb9c8b6b1d7330c57840d24bc75b06b80d30dad6806544d510af6c4785e823ac3e0b8 +146fdd252459aff5e14a963ae6e7fd1c9c509911a4a100b2cf62bffd4e2a8d4f 6b018710446f368e7421f1bc0ccf562d9c1843846bc8d98d1c9bf7d9d6fcb48bfc3bf83b36d44c4fa93430af75cd190bde36a7f92f867f58a803900df8018150384d85d82132f123006ac2aeba58e02a037fe6afbd65eca7c44977dd3dc74f48b6e7a1bfd5cc4dcf24e4d52e92bd4455848e4928b0eac8b7476fe3cc03e862aa4dff4470dbfed6de48e410f25096487ecfc32a27277f3f5023b2725ade461b1355889554a8836c9cf53bd767f5737d55184eea1ab3f53edd0976c485 +8fd3daadccda89d6fe84bb94b4ba194a969badceec9e510eab6d77fea83f5930 c9534a24714bd4be37c88a3da1082eda7cabd154c309d7bd670dccd95aa535594463058a29f79031d6ecaa9f675d1211e9359be82669a79c855ea8d89dd38c2c761ddd0ec0ce9e97597432e9a1beae062cdd71edfdfd464119be9e69d18a7a7fd7ce0e2106f0c8b0abf4715e2ca48ef9f454dc203c96656653b727083513f8efb86e49c513bb758b3b052fe21f1c05bb33c37129d6cc81f1aef6adc45b0e8827a830fe545cf57d0955802c117d23ccb55ea28f95c0d8c2f9c5a242b33f +c900c0a33321ce80ed34a3d3a88af670a13019b06f2066dbfa14104a79ad578b 07906c87297b867abf4576e9f3cc7f82f22b154afcbf293b9319f1b0584da6a40c27b32e0b1b7f412c4f1b82480e70a9235b12ec27090a5a33175a2bb28d8adc475cefe33f7803f8ce27967217381f02e67a3b4f84a71f1c5228e0c2ad971373f6f672624fcea8d1a9f85170fad30fa0bbd25035c3b41a6175d467998bd1215f6f3866f53847f9cf68ef3e2fbb54bc994de2302b829c5eea68ec441fcbafd7d16ae4fe9fff98bf00e5bc2ad54dd91ff9fda4dd77b6c754a91955d1fbaad0 +815ba6349b6c7704802c59c9d54fb796c64cde7e4fc87f870447e4e98eeba3b3 588e94b9054abc2189df69b8ba34341b77cdd528e7860e5defcaa79b0c9a452ad4b82aa306be84536eb7cedcbe058d7b84a6aef826b028b8a0271b69ac3605a9635ea9f5ea0aa700f3eb7835bc54611b922964300c953efe7491e3677c2cebe0822e956cd16433b02c68c4a23252c3f9e151a416b4963257b783e038f6b4d5c9f110f871652c7a649a7bcedcbccc6f2d0725bb903cc196ba76c76aa9f10a190b1d1168993baa9ffc96a1655216773458bec72b0e39c9f2c121378feab4e76a +4f726b5a60d083798af6d1407d1c17368f553502424162d0549c93c5b370749d 08959a7e4baae874928813364071194e2939772f20db7c3157078987c557c2a6d5abe68d520eef3dc491692e1e21bcd880adebf63bb4213b50897fa005256ed41b5690f78f52855c8d9168a4b666fce2da2b456d7a7e7c17ab5f2fb1ee90b79e698712e963715983fd07641ae4b4e9dc73203fac1ae11fa1f8c7941fcc82eab247addb56e2638447e9d609e610b60ce086656aaebf1da3c8a231d7d94e2fd0afe46b391ff14a72eaeb3f44ad4df85866def43d4781a0b3578bc996c87970b132 +8970e3e29f24f3cb0ec4200101613be64c14ea7c117df6704e392b62d7f9927f cb2a234f45e2ecd5863895a451d389a369aab99cfef0d5c9ffca1e6e63f763b5c14fb9b478313c8e8c0efeb3ac9500cf5fd93791b789e67eac12fd038e2547cc8e0fc9db591f33a1e4907c64a922dda23ec9827310b306098554a4a78f050262db5b545b159e1ff1dca6eb734b872343b842c57eafcfda8405eedbb48ef32e99696d135979235c3a05364e371c2d76f1902f1d83146df9495c0a6c57d7bf9ee77e80f9787aee27be1fe126cdc9ef893a4a7dcbbc367e40fe4e1ee90b42ea25af01 +f6cbe810ccc93a606683e556fba4b78aab5bc74cba137f0d4e31f5705ece4aa5 d16beadf02ab1d4dc6f88b8c4554c51e866df830b89c06e786a5f8757e8909310af51c840efe8d20b35331f4355d80f73295974653ddd620cdde4730fb6c8d0d2dcb2b45d92d4fbdb567c0a3e86bd1a8a795af26fbf29fc6c65941cddb090ff7cd230ac5268ab4606fccba9eded0a2b5d014ee0c34f0b2881ac036e24e151be89eeb6cd9a7a790afccff234d7cb11b99ebf58cd0c589f20bdac4f9f0e28f75e3e04e5b3debce607a496d848d67fa7b49132c71b878fd5557e082a18eca1fbda94d4b +4bc436a09b83523b49b9721f1c9bbc96d2c4b2a9eafc461df343e819401f10fe 8f65f6bc59a85705016e2bae7fe57980de3127e5ab275f573d334f73f8603106ec3553016608ef2dd6e69b24be0b7113bf6a760ba6e9ce1c48f9e186012cf96a1d4849d75df5bb8315387fd78e9e153e76f8ba7ec6c8849810f59fb4bb9b004318210b37f1299526866f44059e017e22e96cbe418699d014c6ea01c9f0038b10299884dbec3199bb05adc94e955a1533219c1115fed0e5f21228b071f40dd57c4240d98d37b73e412fe0fa4703120d7c0c67972ed233e5deb300a22605472fa3a3ba86 +967cff9deb5b79d5a79e7255b50bd14b7a060cef866e22768765d3d192367f44 84891e52e0d451813210c3fd635b39a03a6b7a7317b221a7abc270dfa946c42669aacbbbdf801e1584f330e28c729847ea14152bd637b3d0f2b38b4bd5bf9c791c58806281103a3eabbaede5e711e539e6a8b2cf297cf351c078b4fa8f7f35cf61bebf8814bf248a01d41e86c5715ea40c63f7375379a7eb1d78f27622fb468ab784aaaba4e534a6dfd1df6fa15511341e725ed2e87f98737ccb7b6a6dfae416477472b046bf1811187d151bfa9f7b2bf9acdb23a3be507cdf14cfdf517d2cb5fb9e4ab6 +f76063cc288b4a2945d50fd90ac056149bed0f4e68ec1a2907ce290fd7db7242 fdd7a9433a3b4afabd7a3a5e3457e56debf78e84b7a0b0ca0e8c6d53bd0c2dae31b2700c6128334f43981be3b213b1d7a118d59c7e6b6493a86f866a1635c12859cfb9ad17460a77b4522a5c1883c3d6acc86e6162667ec414e9a104aa892053a2b1d72165a855bacd8faf8034a5dd9b716f47a0818c09bb6baf22aa503c06b4ca261f557761989d2afbd88b6a678ad128af68672107d0f1fc73c5ca740459297b3292b281e93bceb761bde7221c3a55708e5ec84472cddcaa84ecf23723cc0991355c6280 +c09252dcdcee60b6d40d7cfb313cdd1b56e0c95d5900f213d0cf33bf27f0073f 70a40bfbef92277a1aad72f6b79d0177197c4ebd432668cfec05d099accb651062b5dff156c0b27336687a94b26679cfdd9daf7ad204338dd9c4d14114033a5c225bd11f217b5f4732da167ee3f939262d4043fc9cba92303b7b5e96aea12adda64859df4b86e9ee0b58e39091e6b188b408ac94e1294a8911245ee361e60e601eff58d1d37639f3753bec80ebb4efde25817436076623fc65415fe51d1b0280366d12c554d86743f3c3b6572e400361a60726131441ba493a83fbe9afda90f7af1ae717238d +d8e3df304d967fca273d4d9daa82ef70c1c3e01cb391094a2c35797acab3865d 74356e449f4bf8644f77b14f4d67cb6bd9c1f5ae357621d5b8147e562b65c66585caf2e491b48529a01a34d226d436959153815380d5689e30b35357cdac6e08d3f2b0e88e200600d62bd9f5eaf488df86a4470ea227006182e44809009868c4c280c43d7d64a5268fa719074960087b3a6abc837882f882c837834535929389a12b2c78187e2ea07ef8b8eef27dc85002c3ae35f1a50bee6a1c48ba7e175f3316670b27983472aa6a61eed0a683a39ee323080620ea44a9f74411ae5ce99030528f9ab49c79f2 +b702fe508bf21919e30edda6879f47dcd9a07f860a779db54b7f93b86074e13e 8c3798e51bc68482d7337d3abb75dc9ffe860714a9ad73551e120059860dde24ab87327222b64cf774415a70f724cdf270de3fe47dda07b61c9ef2a3551f45a5584860248fabde676e1cd75f6355aa3eaeabe3b51dc813d9fb2eaa4f0f1d9f834d7cad9c7c695ae84b329385bc0bef895b9f1edf44a03d4b410cc23a79a6b62e4f346a5e8dd851c2857995ddbf5b2d717aeb847310e1f6a46ac3d26a7f9b44985af656d2b7c9406e8a9e8f47dcb4ef6b83caacf9aefb6118bfcff7e44bef6937ebddc89186839b77 +338596124cf38b825e1ec2f1882b414f1a2e5f88706361d5c7b22c38e385be97 fa56bf730c4f8395875189c10c4fb251605757a8fecc31f9737e3c2503b02608e6731e85d7a38393c67de516b85304824bfb135e33bf22b3a23b913bf6acd2b7ab85198b8187b2bcd454d5e3318cacb32fd6261c31ae7f6c54ef6a7a2a4c9f3ecb81ce3555d4f0ad466dd4c108a90399d70041997c3b25345a9653f3c9a6711ab1b91d6a9d2216442da2c973cbd685ee7643bfd77327a2f7ae9cb283620a08716dfb462e5c1d65432ca9d56a90e811443cd1ecb8f0de179c9cb48ba4f6fec360c66f252f6e64edc96b +cc632b6299b71eaf8106b35771eca7bf2ddc3fa5b54fc278d402aeea12e5dee8 b6134f9c3e91dd8000740d009dd806240811d51ab1546a974bcb18d344642baa5cd5903af84d58ec5ba17301d5ec0f10ccd0509cbb3fd3fff9172d193af0f782252fd1338c7244d40e0e42362275b22d01c4c3389f19dd69bdf958ebe28e31a4ffe2b5f18a87831cfb7095f58a87c9fa21db72ba269379b2dc2384b3da953c7925761fed324620acea435e52b424a7723f6a2357374157a34cd8252351c25a1b232826cefe1bd3e70ffc15a31e7c0598219d7f00436294d11891b82497bc78aa5363892a2495df8c1eef +2e3a0ad6fd16b9dc2e43c209464b340444712b1ddebc1d366d198723b06f5a87 c941cdb9c28ab0a791f2e5c8e8bb52850626aa89205bec3a7e22682313d198b1fa33fc7295381354858758ae6c8ec6fac3245c6e454d16fa2f51c4166fab51df272858f2d603770c40987f64442d487af49cd5c3991ce858ea2a60dab6a65a34414965933973ac2457089e359160b7cdedc42f29e10a91921785f6b7224ee0b349393cdcff6151b50b377d609559923d0984cda6000829b916ab6896693ef6a2199b3c22f7dc5500a15b8258420e314c222bc000bc4e5413e6dd82c993f8330f5c6d1be4bc79f08a1a0a46 +587b6cde5af1c260a1f225337b6bd487b2140028b1d1266a58c4d9b1dcd0f59f 4499efffac4bcea52747efd1e4f20b73e48758be915c88a1ffe5299b0b005837a46b2f20a9cb3c6e64a9e3c564a27c0f1c6ad1960373036ec5bfe1a8fc6a435c2185ed0f114c50e8b3e4c7ed96b06a036819c9463e864a58d6286f785e32a804443a56af0b4df6abc57ed5c2b185ddee8489ea080deeee66aa33c2e6dab36251c402682b6824821f998c32163164298e1fafd31babbcffb594c91888c6219079d907fdb438ed89529d6d96212fd55abe20399dbefd342248507436931cdead496eb6e4a80358acc78647d043 +11c167c3b9114ecd0efed8def748324d873165175c5467ca286a954c86057381 eecbb8fdfa4da62170fd06727f697d81f83f601ff61e478105d3cb7502f2c89bf3e8f56edd469d049807a38882a7eefbc85fc9a950952e9fa84b8afebd3ce782d4da598002827b1eb98882ea1f0a8f7aa9ce013a6e9bc462fb66c8d4a18da21401e1b93356eb12f3725b6db1684f2300a98b9a119e5d27ff704affb618e12708e77e6e5f34139a5a41131fd1d6336c272a8fc37080f041c71341bee6ab550cb4a20a6ddb6a8e0299f2b14bc730c54b8b1c1c487b494bdccfd3a53535ab2f231590bf2c4062fd2ad58f906a2d0d +35175ed1977ab325c9e2ee0fcd6519ef0a9bd1c6db9e1a9d62bb3cb684ec28f4 e64f3e4ace5c8418d65fec2bc5d2a303dd458034736e3b0df719098be7a206deaf52d6ba82316caf330ef852375188cde2b39cc94aa449578a7e2a8e3f5a9d68e816b8d16889fbc0ebf0939d04f63033ae9ae2bdab73b88c26d6bd25ee460ee1ef58fb0afa92cc539f8c76d3d097e7a6a63ebb9b5887edf3cf076028c5bbd5b9db3211371ad3fe121d4e9bf44229f4e1ecf5a0f9f0eba4d5ceb72878ab22c3f0eb5a625323ac66f7061f4a81fac834471e0c59553f108475fe290d43e6a055ae3ee46fb67422f814a68c4be3e8c9 +78a2b33ca04de4c0a372b8c49522f3bb92b8242d38de344f827f0ba922a398d6 d2cb2d733033f9e91395312808383cc4f0ca974e87ec68400d52e96b3fa6984ac58d9ad0938dde5a973008d818c49607d9de2284e7618f1b8aed8372fbd52ed54557af4220fac09dfa8443011699b97d743f8f2b1aef3537ebb45dcc9e13dfb438428ee190a4efdb3caeb7f3933117bf63abdc7e57beb4171c7e1ad260ab0587806c4d137b6316b50abc9cce0dff3acada47bbb86be777e617bbe578ff4519844db360e0a96c6701290e76bb95d26f0f804c8a4f2717eac4e7de9f2cff3bbc55a17e776c0d02856032a6cd10ad2838 +19b67b2c65cdda7f8ce2f1d8e811e19a98fe81232c36779a48791cd74374af7a f2998955613dd414cc111df5ce30a995bb792e260b0e37a5b1d942fe90171a4ac2f66d4928d7ad377f4d0554cbf4c523d21f6e5f379d6f4b028cdcb9b1758d3b39663242ff3cb6ede6a36a6f05db3bc41e0d861b384b6dec58bb096d0a422fd542df175e1be1571fb52ae66f2d86a2f6824a8cfaacbac4a7492ad0433eeb15454af8f312b3b2a577750e3efbd370e8a8cac1582581971fba3ba4bd0d76e718dacf8433d33a59d287f8cc92234e7a271041b526e389efb0e40b6a18b3aaf658e82ed1c78631fd23b4c3eb27c3faec8685 +b53f312518c9388436e34d48dd454f2c29afb3b12093b487c71e60b93712aaf6 447797e2899b72a356ba55bf4df3acca6cdb1041eb477bd1834a9f9acbc340a294d729f2f97df3a610be0ff15edb9c6d5db41644b9874360140fc64f52aa03f0286c8a640670067a84e017926a70438db1bb361defee7317021425f8821def26d1efd77fc853b818545d055adc9284796e583c76e6fe74c9ac2587aa46aa8f8804f2feb5836cc4b3ababab8429a5783e17d5999f32242eb59ef30cd7adabc16d72dbdb097623047c98989f88d14eaf02a7212be16ec2d07981aaa99949ddf89ecd90333a77bc4e1988a82abf7c7caf3291 +c8b9be64e82f970997915c3aaa37e51c1a579eac6cd4468850fa73f23bf4b5f1 9f2c18ade9b380c784e170fb763e9aa205f64303067eb1bcea93df5dac4bf5a2e00b78195f808df24fc76e26cb7be31dc35f0844cded1567bba29858cffc97fb29010331b01d6a3fb3159cc1b973d255da9843e34a0a4061cabdb9ed37f241bfabb3c20d32743f4026b59a4ccc385a2301f83c0b0a190b0f2d01acb8f0d41111e10f2f4e149379275599a52dc089b35fdd5234b0cfb7b6d8aebd563ca1fa653c5c021dfd6f5920e6f18bfafdbecbf0ab00281333ed50b9a999549c1c8f8c63d7626c48322e9791d5ff72294049bde91e73f8 +3d8c612433f48db7fb54b15976c9a236881c063856d49196cb1f511b89a05510 ae159f3fa33619002ae6bcce8cbbdd7d28e5ed9d61534595c4c9f43c402a9bb31f3b301cbfd4a43ce4c24cd5c9849cc6259eca90e2a79e01ffbac07ba0e147fa42676a1d668570e0396387b5bcd599e8e66aaed1b8a191c5a47547f61373021fa6deadcb55363d233c24440f2c73dbb519f7c9fa5a8962efd5f6252c0407f190dfefad707f3c7007d69ff36b8489a5b6b7c557e79dd4f50c06511f599f56c896b35c917b63ba35c6ff8092baf7d1658e77fc95d8a6a43eeb4c01f33f03877f92774be89c1114dd531c011e53a34dc248a2f0e6 +ed206c5bda53bcc418757e00856836439ac9e08a6e508686afb5a46e6654170f 3b8e97c5ffc2d6a40fa7de7fcefc90f3b12c940e7ab415321e29ee692dfac799b009c99dcddb708fce5a178c5c35ee2b8617143edc4c40b4d313661f49abdd93cea79d117518805496fe6acf292c4c2a1f76b403a97d7c399daf85b46ad84e16246c67d6836757bde336c290d5d401e6c1386ab32797af6bb251e9b2d8fe754c47482b72e0b394eab76916126fd68ea7d65eb93d59f5b4c5ac40f7c3b37e7f3694f29424c24af8c8f0ef59cd9dbf1d28e0e10f799a6f78cad1d45b9db3d7dee4a7059abe99182714983b9c9d44d7f5643596d4f3 +e96e6aaacd7861831357dd9c329f4056c2a1686622fd3f86193156e14d6b2e94 3434ec31b10fafdbfeec0dd6bd94e80f7ba9dca19ef075f7eb017512af66d6a4bcf7d16ba0819a1892a6372f9b35bcc7ca8155ee19e8428bc22d214856ed5fa9374c3c09bde169602cc219679f65a1566fc7316f4cc3b631a18fb4449fa6afa16a3db2bc4212eff539c67cf184680826535589c7111d73bffce431b4c40492e763d9279560aaa38eb2dc14a212d723f994a1fe656ff4dd14551ce4e7c621b2aa5604a10001b2878a897a28a08095c325e10a26d2fb1a75bfd64c250309bb55a44f23bbac0d5516a1c687d3b41ef2fbbf9cc56d4739 +9a601fdd743dd62bf8d34381bbadee8f17d5e1b4b7cc0cabe53479a0aa1567a1 7c7953d81c8d208fd1c97681d48f49dd003456de60475b84070ef4847c333b74575b1fc8d2a186964485a3b8634feaa3595aaa1a2f4595a7d6b6153563dee31bbac443c8a33eed6d5d956a980a68366c2527b550ee950250dfb691eacbd5d56ae14b970668be174c89df2fea43ae52f13142639c884fd62a3683c0c3792f0f24ab1318bcb27e21f4737fab62c77ea38bc8fd1cf41f7dab64c13febe7152bf5bb7ab5a78f5346d43cc741cb6f72b7b8980f268b68bf62abdfb1577a52438fe14b591498cc95f071228460c7c5d5ceb4a7bde588e7f21c +46b054cab7793e1a16cca37ca85712838081fa3a334642c0e441842f7071c534 7a6a4f4fdc59a1d223381ae5af498d74b7252ecf59e389e49130c7eaee626e7bd9897effd92017f4ccde66b0440462cdedfd352d8153e6a4c8d7a0812f701cc737b5178c2556f07111200eb627dbc299caa792dfa58f35935299fa3a3519e9b03166dffa159103ffa35e8577f7c0a86c6b46fe13db8e2cdd9dcfba85bdddcce0a7a8e155f81f712d8e9fe646153d3d22c811bd39f830433b2213dd46301941b59293fd0a33e2b63adbd95239bc01315c46fdb678875b3c81e053a40f581cfbec24a1404b1671a1b88a6d06120229518fb13a74ca0ac5ae +16188c138d46fcee0b58456cf6eee9214d405b280a14dd293403fdd1bf4f90e8 d9faa14cebe9b7de551b6c0765409a33938562013b5e8e0e1e0a6418df7399d0a6a771fb81c3ca9bd3bb8e2951b0bc792525a294ebd1083688806fe5e7f1e17fd4e3a41d00c89e8fcf4a363caedb1acb558e3d562f1302b3d83bb886ed27b76033798131dab05b4217381eaaa7ba15ec820bb5c13b516dd640eaec5a27d05fdfca0f35b3a5312146806b4c0275bcd0aaa3b2017f346975db566f9b4d137f4ee10644c2a2da66deeca5342e236495c3c6280528bfd32e90af4cd9bb908f34012b52b4bc56d48cc8a6b59bab014988eabd12e1a0a1c2e170e7 +20ea35a4b0101dae67cc931dc3e5fe49bdf57d9c7363447aa91582356b0f24f2 2d8427433d0c61f2d96cfe80cf1e932265a191365c3b61aaa3d6dcc039f6ba2ad52a6a8cc30fc10f705e6b7705105977fa496c1c708a277a124304f1fc40911e7441d1b5e77b951aad7b01fd5db1b377d165b05bbf898042e39660caf8b279fe5229d1a8db86c0999ed65e53d01ccbc4b43173ccf992b3a14586f6ba42f5fe30afa8ae40c5df29966f9346da5f8b35f16a1de3ab6de0f477d8d8660918060e88b9b9e9ca6a4207033b87a812dbf5544d39e4882010f82b6ce005f8e8ff6fe3c3806bc2b73c2b83afb704345629304f9f86358712e9fae3ca3e +1f1bf037bbaacc00647465511091824888d04d56ff40b53aae3e78280fb7497e 5e19d97887fcaac0387e22c6f803c34a3dacd2604172433f7a8a7a526ca4a2a1271ecfc5d5d7be5ac0d85d921095350dfc65997d443c21c8094e0a3fefd2961bcb94aed03291ae310ccda75d8ace4bc7d89e7d3e5d1650bda5d668b8b50bfc8e608e184f4d3a9a2badc4ff5f07e0c0bc8a9f2e0b2a26fd6d8c550008faaab75fd71af2a424bec9a7cd9d83fad4c8e9319115656a8717d3b523a68ff8004258b9990ed362308461804ba3e3a7e92d8f2ffae5c2fba55ba5a3c27c0a2f71bd711d2fe1799c2adb31b200035481e9ee5c4adf2ab9c0fa50b23975cf +2d9ad26cef0b7dec8436f19672cd1487ff65e6c5763778e90d4164ea2f0d74a1 c8e976ab4638909387ce3b8d4e510c3230e5690e02c45093b1d297910abc481e56eea0f296f98379dfc9080af69e73b2399d1c143bee80ae1328162ce1ba7f6a8374679b20aacd380eb4e61382c99998704d62701afa914f9a2705cdb065885f50d086c3eb5753700c387118bb142f3e6da1e988dfb31ac75d7368931e45d1391a274b22f83ceb072f9bcabc0b216685bfd789f5023971024b1878a205442522f9ea7d8797a4102a3df41703768251fd5e017c85d1200a464118aa35654e7ca39f3c375b8ef8cbe7534dbc64bc20befb417cf60ec92f63d9ee7397 +fcd651fb9d79865f0be6c8144fad6750b534b4924a547102bde67761b44a2c1e 7145fa124b7429a1fc2231237a949ba7201bcc1822d3272de005b682398196c25f7e5cc2f289fbf44415f699cb7fe6757791b1443410234ae061edf623359e2b4e32c19bf88450432dd01caa5eb16a1dc378f391ca5e3c4e5f356728bddd4975db7c890da8bbc84cc73ff244394d0d48954978765e4a00b593f70f2ca082673a261ed88dbcef1127728d8cd89bc2c597e9102ced6010f65fa75a14ebe467fa57ce3bd4948b6867d74a9df5c0ec6f530cbf2ee61ce6f06bc8f2864dff5583776b31df8c7ffcb61428a56bf7bd37188b4a5123bbf338393af46eda85e6 +73c2f21b32cd6192a9547bf74a6bb7622e6fa6b044f92122758ddf485b21ddb4 7fdfadcc9d29bad23ae038c6c65cda1aef757221b8872ed3d75ff8df7da0627d266e224e812c39f7983e4558bfd0a1f2bef3feb56ba09120ef762917b9c093867948547aee98600d10d87b20106878a8d22c64378bf634f7f75900c03986b077b0bf8b740a82447b61b99fee5376c5eb6680ec9e3088f0bdd0c56883413d60c1357d3c811950e5890e7600103c916341b80c743c6a852b7b4fb60c3ba21f3bc15b8382437a68454779cf3cd7f9f90ccc8ef28d0b706535b1e4108eb5627bb45d719cb046839aee311ca1abdc8319e050d67972cb35a6b1601b25dbf487 +082e5d0692cf3d274897917abc66a0e0688a5d4c87da370009a4d3f91022b0a8 988638219fd3095421f826f56e4f09e356296b628c3ce6930c9f2e758fd1a80c8273f2f61e4daae65c4f110d3e7ca0965ac7d24e34c0dc4ba2d6ff0bf5bbe93b3585f354d7543cb542a1aa54674d375077f2d360a8f4d42f3db131c3b7ab7306267ba107659864a90c8c909460a73621d1f5d9d3fd95beb19b23db1cb6c0d0fba91d36891529b8bd8263caa1bab56a4affaed44962df096d8d5b1eb845ef31188b3e10f1af811a13f156beb7a288aae593ebd1471b624aa1a7c6adf01e2200b3d72d88a3aed3100c88231e41efc376906f0b580dc895f080fda5741db1cb +c88dd85bc74dfa17eb4a683018335cc71e73363cfe24e45690d25d98e969eb74 5aab62756d307a669d146aba988d9074c5a159b3de85151a819b117ca1ff6597f6156e80fdd28c9c3176835164d37da7da11d94e09add770b68a6e081cd22ca0c004bfe7cd283bf43a588da91f509b27a6584c474a4a2f3ee0f1f56447379240a5ab1fb77fdca49b305f07ba86b62756fb9efb4fc225c86845f026ea542076b91a0bc2cdd136e122c659be259d98e5841df4c2f60330d4d8cdee7bf1a0a244524eecc68ff2aef5bf0069c9e87a11c6e519de1a4062a10c83837388f7ef58598a3846f49d499682b683c4a062b421594fafbc1383c943ba83bdef515efcf10d +2aa62c1184d50edefb26b3aa922749356fb0741d6e3d9bcbf555521acb106dee 47b8216aa0fbb5d67966f2e82c17c07aa2d6327e96fcd83e3de7333689f3ee79994a1bf45082c4d725ed8d41205cb5bcdf5c341f77facb1da46a5b9b2cbc49eadf786bcd881f371a95fa17df73f606519aea0ff79d5a11427b98ee7f13a5c00637e2854134691059839121fea9abe2cd1bcbbbf27c74caf3678e05bfb1c949897ea01f56ffa4dafbe8644611685c617a3206c7a7036e4ac816799f693dafe7f19f303ce4eba09d21e03610201bfc665b72400a547a1e00fa9b7ad8d84f84b34aef118515e74def11b9188bd1e1f97d9a12c30132ec2806339bdadacda2fd8b78 +0a27caa8388e204cd880a7facd901ee93d98e019cd246111d634ea25afad33f5 8cff1f67fe53c098896d9136389bd8881816ccab34862bb67a656e3d98896f3ce6ffd4da73975809fcdf9666760d6e561c55238b205d8049c1cedeef374d1735daa533147bfa960b2cce4a4f254176bb4d1bd1e89654432b8dbe1a135c42115b394b024856a2a83dc85d6782be4b444239567ccec4b184d4548eae3ff6a192f343292ba2e32a0f267f31cc26719eb85245d415fb897ac2da433ee91a99424c9d7f1766a44171d1651001c38fc79294accc68ceb5665d36218454d3ba169ae058a831338c17743603f81ee173bfc0927464f9bd728dee94c6aeab7aae6ee3a627e8 +fb6f77140837df9e820106140fb80c6aa06688085bb05cc118b7131e5f4bcb20 eacd07971cff9b9939903f8c1d8cbb5d4db1b548a85d04e037514a583604e787f32992bf2111b97ac5e8a938233552731321522ab5e8583561260b7d13ebeef785b23a41fd8576a6da764a8ed6d822d4957a545d5244756c18aa80e1aad4d1f9c20d259dee1711e2cc8fd013169fb7cc4ce38b362f8e0936ae9198b7e838dcea4f7a5b9429bb3f6bbcf2dc92565e3676c1c5e6eb3dd2a0f86aa23edd3d0891f197447692794b3dfa269611ad97f72b795602b4fdb198f3fd3eb41b415064256e345e8d8c51c555dc8a21904a9b0f1ad0effab7786aac2da3b196507e9f33ca356427 +fe039b7451f493b06607af7f50116a7c9d5322bf18a942077cefffb6aa781073 23ac4e9a42c6ef45c3336ce6dfc2ff7de8884cd23dc912fef0f7756c09d335c189f3ad3a23697abda851a81881a0c8ccafc980ab2c702564c2be15fe4c4b9f10dfb2248d0d0cb2e2887fd4598a1d4acda897944a2ffc580ff92719c95cf2aa42dc584674cb5a9bc5765b9d6ddf5789791d15f8dd925aa12bffafbce60827b490bb7df3dda6f2a143c8bf96abc903d83d59a791e2d62814a89b8080a28060568cf24a80ae61179fe84e0ffad00388178cb6a617d37efd54cc01970a4a41d1a8d3ddce46edbba4ab7c90ad565398d376f431189ce8c1c33e132feae6a8cd17a61c630012 +685ad3988956726fb7f0669c8140d8119e5c3fa386c976172248554319dde6d0 0172df732282c9d488669c358e3492260cbe91c95cfbc1e3fea6c4b0ec129b45f242ace09f152fc6234e1bee8aab8cd56e8b486e1dcba9c05407c2f95da8d8f1c0af78ee2ed82a3a79ec0cb0709396ee62aadb84f8a4ee8a7ccca3c1ee84e302a09ea802204afecf04097e67d0f8e8a9d2651126c0a598a37081e42d168b0ae8a71951c524259e4e2054e535b779679bdade566fe55700858618e626b4a0faf895bcce9011504a49e05fd56127eae3d1f8917afb548ecadabda1020111fec9314c413498a360b08640549a22cb23c731ace743252a8227a0d2689d4c6001606678dfb921 +6fd7cd6c507ab2978cfc6cb16fb5278517d5bc9e944cc12b53c2b1407c27db76 3875b9240cf3e0a8b59c658540f26a701cf188496e2c2174788b126fd29402d6a75453ba0635284d08835f40051a2a9683dc92afb9383719191231170379ba6f4adc816fecbb0f9c446b785bf520796841e58878b73c58d3ebb097ce4761fdeabe15de2f319dfbaf1742cdeb389559c788131a6793e193856661376c81ce9568da19aa6925b47ffd77a43c7a0e758c37d69254909ff0fbd415ef8eb937bcd49f91468b49974c07dc819abd67395db0e05874ff83dddab895344abd0e7111b2df9e58d76d85ad98106b36295826be04d435615595605e4b4bb824b33c4afeb5e7bb0d19f909 +48deca46a39f2d84a8740169512cc3d99f6c229752d7c4741f14349e3d9f5970 747cc1a59fefba94a9c75ba866c30dc5c1cb0c0f8e9361d98484956dd5d1a40f6184afbe3dac9f76028d1caeccfbf69199c6ce2b4c092a3f4d2a56fe5a33a00757f4d7dee5dfb0524311a97ae0668a47971b95766e2f6dd48c3f57841f91f04a00ad5ea70f2d479a2620dc5cd78eaab3a3b011719b7e78d19ddf70d9423798af77517ebc55392fcd01fc600d8d466b9e7a7a85bf33f9cc5419e9bd874ddfd60981150ddaf8d7febaa4374f0872a5628d318000311e2f5655365ad4d407c20e5c04df17a222e7deec79c5ab1116d8572f91cd06e1ccc7ced53736fc867fd49ecebe6bf8082e8a +1e6e99cd27a58b5a84f68b573c2595106da4301478c9f54fd95d1a4926fb1224 57af971fccaec97435dc2ec9ef0429bcedc6b647729ea168858a6e49ac1071e706f4a5a645ca14e8c7746d65511620682c906c8b86ec901f3dded4167b3f00b06cbfac6aee3728051b3e5ff10b4f9ed8bd0b8da94303c833755b3ca3aeddf0b54bc8d6632138b5d25bab03d17b3458a9d782108006f5bb7de75b5c0ba854b423d8bb801e701e99dc4feaad59bc1c7112453b04d33ea3635639fb802c73c2b71d58a56bbd671b18fe34ed2e3dca38827d63fdb1d4fb3285405004b2b3e26081a8ff08cd6d2b08f8e7b7e90a2ab1ed7a41b1d0128522c2f8bff56a7fe67969422ce839a9d4608f03 +2d19bf4397b20fd9693d4167c334aa1f44898fb5456dd94f9cb3b21c8dea28be 04e16dedc1227902baaf332d3d08923601bdd64f573faa1bb7201918cfe16b1e10151dae875da0c0d63c59c3dd050c4c6a874011b018421afc4623ab0381831b2da2a8ba42c96e4f70864ac44e106f94311051e74c77c1291bf5db9539e69567bf6a11cf6932bbbad33f8946bf5814c066d851633d1a513510039b349939bfd42b858c21827c8ff05f1d09b1b0765dc78a135b5ca4dfba0801bcaddfa175623c8b647eacfb4444b85a44f73890607d06d507a4f8393658788669f6ef4deb58d08c50ca0756d5e2f49d1a7ad73e0f0b3d3b5f090acf622b1878c59133e4a848e05153592ea81c6fbf +1c089d1f7b04e3f871828e02560d59402356fe52e3332139bdae63d7b82430db 7c815c384eee0f288ece27cced52a01603127b079c007378bc5d1e6c5e9e6d1c735723acbbd5801ac49854b2b569d4472d33f40bbb8882956245c366dc3582d71696a97a4e19557e41e54dee482a14229005f93afd2c4a7d8614d10a97a9dfa07f7cd946fa45263063ddd29db8f9e34db60daa32684f0072ea2a9426ecebfa5239fb67f29c18cbaa2af6ed4bf4283936823ac1790164fec5457a9cba7c767ca59392d94cab7448f50eb34e9a93a80027471ce59736f099c886dea1ab4cba4d89f5fc7ae2f21ccd27f611eca4626b2d08dc22382e92c1efb2f6afdc8fdc3d2172604f5035c46b8197d3 +e9aa79c0065a30290b7db60cf78252b4c9a65000da256bc4bf46c9e6ec2d36da e29d505158dbdd937d9e3d2145658ee6f5992a2fc790f4f608d9cdb44a091d5b94b88e81fac4fdf5c49442f13b911c55886469629551189eaff62488f1a479b7db11a1560e198ddccccf50159093425ff7f1cb8d1d1246d0978764087d6bac257026b090efae8cec5f22b6f21c59ace1ac7386f5b8837ca6a12b6fbf5534dd0560ef05ca78104d3b943ddb220feaec89aa5e692a00f822a2ab9a2fe60350d75e7be16ff2526dc643872502d01f42f188abed0a6e9a6f5fd0d1ce7d5755c9ffa66b0af0b20bd806f08e06156690d81ac811778ca3dac2c249b96002017fce93e507e3b953acf99964b847 +e0d9bb2c3fa082f0931c3091fff450a3b43ef40a1ab23b7ced5d3dbb35c8d090 d85588696f576e65eca0155f395f0cfacd83f36a99111ed5768df2d116d2121e32357ba4f54ede927f189f297d3a97fad4e9a0f5b41d8d89dd7fe20156799c2b7b6bf9c957ba0d6763f5c3bc5129747bbb53652b49290cff1c87e2cdf2c4b95d8aaee09bc8fbfa6883e62d237885810491bfc101f1d8c636e3d0ede838ad05c207a3df4fad76452979eb99f29afaecedd1c63b8d36cf378454a1bb67a741c77ac6b6b3f95f4f02b64dabc15438613ea49750df42ee90101f115aa9abb9ff64324dde9dabbb01054e1bd6b4bcdc7930a44c2300d87ca78c06924d0323ad7887e46c90e8c4d100acd9eed21e +6bfc745a0ecf2a0ec61b18dc3864171cb06f390397c8ef56baa9fdb691eda61f 3a12f8508b40c32c74492b66323375dcfe49184c78f73179f3314b79e63376b8ac683f5a51f1534bd729b02b04d002f55cbd8e8fc9b5ec1ea6bbe6a0d0e7431518e6ba45d124035f9d3dce0a8bb7bf1430a9f657e0b4ea9f20eb20c786a58181a1e20a96f1628f8728a13bdf7a4b4b32fc8aa7054cc4881ae7fa19afa65c6c3ee1b3ade3192af42054a8a911b8ec1826865d46d93f1e7c5e2b7813c92a506e53886f3d4701bb93d2a681ad109c845904bb861af8af0646b6e399b38b614051d34f6842563a0f37ec00cb3d865fc5d746c4987de2a65071100883a2a9c7a2bfe1e2dd603d9ea24dc7c5fd06be +c04b36b064a0e7255f9d93726beb8ceb6af104aacf95e0b1d9fe6674e3e28500 1861edce46fa5ad17e1ff1deae084dec580f97d0a67885dfe834b9dfac1ae076742ce9e267512ca51f6df5a455af0c5fd6abf94acea103a3370c354485a7846fb84f3ac7c2904b5b2fbf227002ce512133bb7e1c4e50057bfd1e44db33c7cdb969a99e284b184f50a14b068a1fc5009d9b298dbe92239572a7627aac02abe8f3e3b473417f36d4d2505d16b7577f4526c9d94a270a2dfe450d06da8f6fa956879a0a55cfe99e742ea555ea477ba3e9b44ccd508c375423611af92e55345dc215779b2d5119eba49c71d49b9fe3f1569fa24e5ca3e332d042422a8b8158d3ec66a80012976f31ffdf305f0c9c5e +d1bab81690777d5953c7758304dba49d869eebe5614ccb7b43d29b206abf86e0 08d0ffde3a6e4ef65608ea672e4830c12943d7187ccff08f4941cfc13e545f3b9c7ad5eebbe2b01642b486caf855c2c73f58c1e4e3391da8e2d63d96e15fd84953ae5c231911b00ad6050cd7aafdaac9b0f663ae6aab45519d0f5391a541707d479034e73a6ad805ae3598096af078f1393301493d663dd71f83869ca27ba508b7e91e81e128c1716dc3acfe3084b2201e04cf8006617eecf1b640474a5d45cfde9f4d3ef92d6d055b909892194d8a8218db6d8203a84261d200d71473d7488f3427416b6896c137d455f231071cacbc86e0415ab88aec841d96b7b8af41e05bb461a40645bf176601f1e760de5f +59f8c65d1a89437dfed8776ddfc679c2a7090ebae7cefda8d5c5e7131726e61c d782abb72a5be3392757be02d3e45be6e2099d6f000d042c8a543f50ed6ebc055a7f133b0dd8e9bc348536edcaae2e12ec18e8837df7a1b3c87ec46d50c241dee820fd586197552dc20beea50f445a07a38f1768a39e2b2ff05dddedf751f1def612d2e4d810daa3a0cc904516f9a43af660315385178a529e51f8aae141808c8bc5d7b60cac26bb984ac1890d0436ef780426c547e94a7b08f01acbfc4a3825eae04f520a9016f2fb8bf5165ed12736fc71e36a49a73614739eaa3ec834069b1b40f1350c2b3ab885c02c640b9f7686ed5f99527e41cfcd796fe4c256c9173186c226169ff257954ebda81c0e5f99 +fcc79031940d459b1afff94245872ec10f365e4191cfeb730073d8fd6542faa6 5fce8109a358570e40983e1184e541833bb9091e280f258cfb144387b05d190e431cb19baa67273ba0c58abe91308e1844dcd0b3678baa42f335f2fa05267a0240b3c718a5942b3b3e3bfa98a55c25a1466e8d7a603722cb2bbf03afa54cd769a99f310735ee5a05dae2c22d397bd95635f58c48a67f90e1b73aafcd3f82117f0166657838691005b18da6f341d6e90fc1cdb352b30fae45d348294e501b63252de14740f2b85ae5299ddec3172de8b6d0ba219a20a23bb5e10ff434d39db3f583305e9f5c039d98569e377b75a70ab837d1df269b8a4b566f40bb91b577455fd3c356c914fa06b9a7ce24c7317a172d +2ffc21a7a45695b5112e00ede09b4309d4332784b44df8f7a318f399d419ef44 6172f1971a6e1e4e6170afbad95d5fec99bf69b24b674bc17dd78011615e502de6f56b86b1a71d3f4348087218ac7b7d09302993be272e4a591968aef18a1262d665610d1070ee91cc8da36e1f841a69a7a682c580e836941d21d909a3afc1f0b963e1ca5ab193e124a1a53df1c587470e5881fb54dae1b0d840f0c8f9d1b04c645ba1041c7d8dbf22030a623aa15638b3d99a2c400ff76f3252079af88d2b37f35ee66c1ad7801a28d3d388ac450b97d5f0f79e4541755356b3b1a5696b023f39ab7ab5f28df4202936bc97393b93bc915cb159ea1bd7a0a414cb4b7a1ac3af68f50d79f0c9c7314e750f7d02faa58bfa +07f623f572ad11b9f025d3700331f105ecbea315d3acfc93d00f064c1d2124f8 5668ecd99dfbe215c4118398ac9c9eaf1a1433fab4ccdd3968064752b625ea944731f75d48a27d047d67547f14dd0ffaa55fa5e29f7af0d161d85eafc4f2029b717c918eab9d304543290bdba7158b68020c0ba4e079bc95b5bc0fc044a992b94b4ccd3bd66d0eabb5dbbab904d62e00752c4e3b0091d773bcf4c14b4377da3efff824b1cb2fa01b32d1e46c909e626ed2dae920f4c7dbeb635bc754facbd8d49beba3f23c1c41ccbfcd0ee0c114e69737f5597c0bf1d859f0c767e18002ae8e39c26261ffde2920d3d0baf0e906138696cfe5b7e32b600f45df3aaa39932f3a7df95b60fa8712a2271fcaf3911ce7b511b1 +b87633654fd1d30a3c7f7fc08a5901ade1dfe1ad121eae77f6ca81cdaf0f28fa 03d625488354df30e3f875a68edfcf340e8366a8e1ab67f9d5c5486a96829dfac0578289082b2a62117e1cf418b43b90e0adc881fc6ae8105c888e9ecd21aea1c9ae1a4038dfd17378fed71d02ae492087d7cdcd98f746855227967cb1ab4714261ee3bead3f4db118329d3ebef4bc48a875c19ba763966da0ebea800e01b2f50b00e9dd4caca6dcb314d00184ef71ea2391d760c950710db4a70f9212ffc54861f9dc752ce18867b8ad0c48df8466ef7231e7ac567f0eb55099e622ebb86cb237520190a61c66ad34f1f4e289cb3282ae3eaac6152ed24d2c92bae5a7658252a53c49b7b02dfe54fdb2e90074b6cf310ac661 +3243cc1a40eb34682a5bb6731e6895b532a9fd119e5d132d969504f964b687dd 2edc282ffb90b97118dd03aaa03b145f363905e3cbd2d50ecd692b37bf000185c651d3e9726c690d3773ec1e48510e42b17742b0b0377e7de6b8f55e00a8a4db4740cee6db0830529dd19617501dc1e9359aa3bcf147e0a76b3ab70c4984c13e339e6806bb35e683af8527093670859f3d8a0fc7d493bcba6bb12b5f65e71e705ca5d6c948d66ed3d730b26db395b3447737c26fad089aa0ad0e306cb28bf0acf106f89af3745f0ec72d534968cca543cd2ca50c94b1456743254e358c1317c07a07bf2b0eca438a709367fafc89a57239028fc5fecfd53b8ef958ef10ee0608b7f5cb9923ad97058ec067700cc746c127a61ee3 +7ef35a6d1831da07bc5fec817843308b0ccfd303f40b1f40dcc56d0f2281d74c 90b28a6aa1fe533915bcb8e81ed6cacdc10962b7ff82474f845eeb86977600cf70b07ba8e3796141ee340e3fce842a38a50afbe90301a3bdcc591f2e7d9de53e495525560b908c892439990a2ca2679c5539ffdf636777ad9c1cdef809cda9e8dcdb451abb9e9c17efa4379abd24b182bd981cafc792640a183b61694301d04c5b3eaad694a6bd4cc06ef5da8fa23b4fa2a64559c5a68397930079d250c51bcf00e2b16a6c49171433b0aadfd80231276560b80458dd77089b7a1bbcc9e7e4b9f881eacd6c92c4318348a13f4914eb27115a1cfc5d16d7fd94954c3532efaca2cab025103b2d02c6fd71da3a77f417d7932685888a +cd86a27f91af52ae38271459e2d3531e6960981cc6a1fdb7b27d050faa7a1911 2969447d175490f2aa9bb055014dbef2e6854c95f8d60950bfe8c0be8de254c26b2d31b9e4de9c68c9adf49e4ee9b1c2850967f29f5d08738483b417bb96b2a56f0c8aca632b552059c59aac3f61f7b45c966b75f1d9931ff4e596406378cee91aaa726a3a84c33f37e9cdbe626b5745a0b06064a8a8d56e53aaf102d23dd9df0a3fdf7a638509a6761a33fa42fa8ddbd8e16159c93008b53765019c3f0e9f10b144ce2ac57f5d7297f9c9949e4ff68b70d339f87501ce8550b772f32c6da8ad2ce2100a895d8b08fa1eead7c376b407709703c510b50f87e73e43f8e7348f87c3832a547ef2bbe5799abedcf5e1f372ea809233f006 +cbd9ae4bce3abc5b01754388ded697f95adb8fad595b9cad613ea5eedc5f6f36 721645633a44a2c78b19024eaecf58575ab23c27190833c26875dc0f0d50b46aea9c343d82ea7d5b3e50ec700545c615daeaea64726a0f05607576dcd396d812b03fb6551c641087856d050b10e6a4d5577b82a98afb89cee8594c9dc19e79feff0382fcfd127f1b803a4b9946f4ac9a4378e1e6e041b1389a53e3450cd32d9d2941b0cbabdb50da8ea2513145164c3ab6bcbd251c448d2d4b087ac57a59c2285d564f16da4ed5e607ed979592146ffb0ef3f3db308fb342df5eb5924a48256fc763141a278814c82d6d6348577545870ae3a83c7230ac02a1540fe1798f7ef09e335a865a2ae0949b21e4f748fb8a51f44750e213a8fb +6a9c06f5740755e87ea22671b99749c1e7e8b8261e6c514b0fb68f6fd593576f 6b860d39725a14b498bb714574b4d37ca787404768f64c648b1751b353ac92bac2c3a28ea909fdf0423336401a02e63ec24325300d823b6864bb701f9d7c7a1f8ec9d0ae3584aa6dd62ea1997cd831b4babd9a4da50932d4efda745c61e4130890e156aee6113716daf95764222a91187db2effea49d5d0596102d619bd26a616bbfda8335505fbb0d90b4c180d1a2335b91538e1668f9f9642790b4e55f9cab0fe2bdd2935d001ee6419abab5457880d0dbff20ed8758f4c20fe759efb33141cf0e892587fe8187e5fbc57786b7e8b089612c936dfc03d27efbbe7c8673f1606bd51d5ff386f4a7ab68edf59f385eb1291f117bfe717399 +f80cf26b72499ff551f99236cf91c2e8152d36bb6952cc7cfd1d8f415da4f6bc 6a01830af3889a25183244decb508bd01253d5b508ab490d3124afbf42626b2e70894e9b562b288d0a2450cfacf14a0ddae5c04716e5a0082c33981f6037d23d5e045ee1ef2283fb8b6378a914c5d9441627a722c282ff452e25a7ea608d69cee4393a0725d17963d0342684f255496d8a18c2961145315130549311fc07f0312fb78e6077334f87eaa873bee8aa95698996eb21375eb2b4ef53c14401207deb4568398e5dd9a7cf97e8c9663e23334b46912f8344c19efcf8c2ba6f04325f1a27e062b62a58d0766fc6db4d2c6a1928604b0175d872d16b7908ebc041761187cc785526c2a3873feac3a642bb39f5351550af9770c328af7b +d012bf61d4a8587d0c891aa96c550539cdbbe77385075b214bf607b9096de3fb b3c5e74b69933c2533106c563b4ca20238f2b6e675e8681e34a389894785bdade59652d4a73d80a5c85bd454fd1e9ffdad1c3815f5038e9ef432aac5c3c4fe840cc370cf86580a6011778bbedaf511a51b56d1a2eb68394aa299e26da9ada6a2f39b9faff7fba457689b9c1a577b2a1e505fdf75c7a0a64b1df81b3a356001bf0df4e02a1fc59f651c9d585ec6224bb279c6beba2966e8882d68376081b987468e7aed1ef90ebd090ae825795cdca1b4f09a979c8dfc21a48d8a53cdbb26c4db547fc06efe2f9850edd2685a4661cb4911f165d4b63ef25b87d0a96d3dff6ab0758999aad214d07bd4f133a6734fde445fe474711b69a98f7e2b +ebd2851fc04b38e57323ce3199854dbb56da53771ea6aa36f92d4f9d410a5750 83af34279ccb5430febec07a81950d30f4b66f484826afee7456f0071a51e1bbc55570b5cc7ec6f9309c17bf5befdd7c6ba6e968cf218a2b34bd5cf927ab846e38a40bbd81759e9e33381016a755f699df35d660007b5eadf292feefb735207ebf70b5bd17834f7bfa0e16cb219ad4af524ab1ea37334aa66435e5d397fc0a065c411ebbce32c240b90476d307ce802ec82c1c49bc1bec48c0675ec2a6c6f3ed3e5b741d13437095707c565e10d8a20b8c20468ff9514fcf31b4249cd82dcee58c0a2af538b291a87e3390d737191a07484a5d3f3fb8c8f15ce056e5e5f8febe5e1fb59d6740980aa06ca8a0c20f5712b4cde5d032e92ab89f0ae1 +22c3ffdb2f4f12f5e7e7e1b440f793f807c82c6a1758ad385c119144f8afdf4e a7ed84749ccc56bb1dfba57119d279d412b8a986886d810f067af349e8749e9ea746a60b03742636c464fc1ee233acc52c1983914692b64309edfdf29f1ab912ec3e8da074d3f1d231511f5756f0b6eead3e89a6a88fe330a10face267bffbfc3e3090c7fd9a850561f363ad75ea881e7244f80ff55802d5ef7a1a4e7b89fcfa80f16df54d1b056ee637e6964b9e0ffd15b6196bdd7db270c56b47251485348e49813b4eb9ed122a01b3ea45ad5e1a929df61d5c0f3e77e1fdc356b63883a60e9cbb9fc3e00c2f32dbd469659883f690c6772e335f617bc33f161d6f6984252ee12e62b6000ac5231e0c9bc65be223d8dfd94c5004a101af9fd6c0fb +aacbaedb29ac2298073c5a4cd93ec4911829379957544dab0f0913b6b6afcef2 a6fe30dcfcda1a329e82ab50e32b5f50eb25c873c5d2305860a835aecee6264aa36a47429922c4b8b3afd00da16035830edb897831c4e7b00f2c23fc0b15fdc30d85fb70c30c431c638e1a25b51caf1d7e8b050b7f89bfb30f59f0f20fecff3d639abc4255b3868fc45dd81e47eb12ab40f2aac735df5d1dc1ad997cefc4d836b854cee9ac02900036f3867fe0d84afff37bde3308c2206c62c4743375094108877c73b87b2546fe05ea137bedfc06a2796274099a0d554da8f7d7223a48cbf31b7decaa1ebc8b145763e3673168c1b1b715c1cd99ecd3ddb238b06049885ecad9347c2436dff32c771f34a38587a44a82c5d3d137a03caa27e66c8ff6 +e16b44c16364e7a8a9747ca062eda67c07688f5353db8ac76b97e4b87a33271c 83167ff53704c3aa19e9fb3303539759c46dd4091a52ddae9ad86408b69335989e61414bc20ab4d01220e35241eff5c9522b079fba597674c8d716fe441e566110b6211531ceccf8fd06bc8e511d00785e57788ed9a1c5c73524f01830d2e1148c92d0edc97113e3b7b5cd3049627abdb8b39dd4d6890e0ee91993f92b03354a88f52251c546e64434d9c3d74544f23fb93e5a2d2f1fb15545b4e1367c97335b0291944c8b730ad3d4789273fa44fb98d78a36c3c3764abeeac7c569c1e43a352e5b770c3504f87090dee075a1c4c85c0c39cf421bdcc615f9eff6cb4fe6468004aece5f30e1ecc6db22ad9939bb2b0ccc96521dfbf4ae008b5b46bc006e +89d35349d86b5fabbcff385931532888f7dab44b35e4522b196dbcc34ff5f912 3a3a819c48efde2ad914fbf00e18ab6bc4f14513ab27d0c178a188b61431e7f5623cb66b23346775d386b50e982c493adbbfc54b9a3cd383382336a1a0b2150a15358f336d03ae18f666c7573d55c4fd181c29e6ccfde63ea35f0adf5885cfc0a3d84a2b2e4dd24496db789e663170cef74798aa1bbcd4574ea0bba40489d764b2f83aadc66b148b4a0cd95246c127d5871c4f11418690a5ddf01246a0c80a43c70088b6183639dcfda4125bd113a8f49ee23ed306faac576c3fb0c1e256671d817fc2534a52f5b439f72e424de376f4c565cca82307dd9ef76da5b7c4eb7e085172e328807c02d011ffbf33785378d79dc266f6a5be6bb0e4a92eceebaeb1 +523f527e2272d62055ae674b40b5c96a2f64e30d5485c4750fdba5237d3a8f0e 724627916c50338643e6996f07877eafd96bdf01da7e991d4155b9be1295ea7d21c9391f4c4a41c75f77e5d27389253393725f1427f57914b273ab862b9e31dabce506e558720520d33352d119f699e784f9e548ff91bc35ca147042128709820d69a8287ea3257857615eb0321270e94b84f446942765ce882b191faee7e1c87e0f0bd4e0cd8a927703524b559b769ca4ece1f6dbf313fdcf67c572ec4185c1a88e86ec11b6454b371980020f19633b6b95bd280e4fbcb0161e1a82470320cec6ecfa25ac73d09f1536f286d3f9dacafb2cd1d0ce72d64d197f5c7520b3ccb2fd74eb72664ba93853ef41eabf52f015dd591500d018dd162815cc993595b195 +5a62c13c0acdca84467b9b936668f7e74afac8eeb6ac96bf5fe1ed37b87b86b8 3139840b8ad4bcd39092916fd9d01798ff5aa1e48f34702c72dfe74b12e98a114e318cdd2d47a9c320fff908a8dbc2a5b1d87267c8e983829861a567558b37b292d4575e200de9f1de45755faff9efae34964e4336c259f1e66599a7c904ec02539f1a8eab8706e0b4f48f72fec2794909ee4a7b092d6061c74481c9e21b9332dc7c6e482d7f9cc3210b38a6f88f7918c2d8c55e64a428ce2b68fd07ab572a8b0a2388664f99489f04eb54df1376271810e0e7bce396f52807710e0dea94eb49f4b367271260c3456b9818fc7a72234e6bf2205ff6a36546205015ebd7d8c2527aa430f58e0e8ac97a7b6b793cd403d517d66295f37a34d0b7d2fa7bc345ac04ca1e266480deec39f5c88641c9dc0bd1358158fdecdd96685bbbb5c1fe5ea89d2cb4a9d5d12bb8c893281ff38e87d6b4841f0650092d447e013f20ea934e18 +e4999091bdd8b3296942940e892169de916c840c4e0fbfc40f50f93fbef6ca56 023d91ac532601c7ca3942d62827566d9268bb4276fcaa1ae927693a6961652676dba09219a01b3d5adfa12547a946e78f3c5c62dd880b02d2eeeb4b96636529c6b01120b23efc49ccfb36b8497cd19767b53710a636683bc5e0e5c9534cfc004691e87d1bee39b86b953572927bd668620eab87836d9f3f8f28ace41150776c0bc6657178ebf297fe1f7214edd9f215ffb491b681b06ac2032d35e6fdf832a8b06056da70d77f1e9b4d26ae712d8523c86f79250718405f91b0a87c725f2d3f52088965f887d8cf87206dfde422386e58edda34dde2783b3049b86917b4628027a05d4d1f429d2b49c4b1c898dddcb82f343e145596de11a54182f39f4718ecae8f506bd9739f5cd5d5686d7fefc834514cd1b2c91c33b381b45e2e5335d7a8720a8f17afc8c2cb2bd88b14aa2dca099b00aa575d0a0ccf099cdec4870fb710d2680e60c48bfc291ff0cef2eebf9b36902e9fba8c889bf6b4b9f5ce53a19b0d9399cd19d61bd08c0c2ec25e099959848e6a550ca7137b63f43138d7b651 +9b39a13c80f3ccda6354bc98121f502211f8649708d7ac1425bf894d88c3facf 20ff454369a5d05b81a78f3db05819fea9b08c2384f75cb0ab6aa115dd690da3131874a1ca8f708ad1519ea952c1e249cb540d196392c79e87755424fee7c890808c562722359eea52e8a12fbbb969dd7961d2ba52037493755a5fa04f0d50a1aa26c9b44148c0d3b94d1c4a59a31aca15ae8bd44acb7833d8e91c4b86fa3135a423387b8151b4133ed23f6d7187b50ec2204ad901ad74d396e44274e0ecafaae17b3b9085e22260b35ca53b15cc52abba758af6798fbd04eceeced648f3af4fdb3ded7557a9a5cfb7382612a8a8f3f45947d1a29ce29072928ec193ca25d51071bd5e1984ecf402f306ea762f0f25282f5296d997658be3f983696ffa6d095c6369b4daf79e9a5d3136229128f8eb63c12b9e9fa78aff7a3e9e19a62022493cd136defbb5bb7ba1b938f367fd2f63eb5ca76c0b0ff21b9e36c3f07230cf3c3074e5da587040a76975d7e39f4494ace5486fcbf380ab7558c4fe89656335b82e4db8659509eab46a19613126e594042732dd4c411f41aa8cdeac71c0fb40a94e6da558c05e77b6182806f26d9afdf3da00c69419222c8186a6efad600b410e6ce2f2a797e49dc1f135319801fa6f396b06f975e2a190a023e474b618e7 +8a75ce59bcf23e9615c598ac18cbd032b50076288975f44d6f4c4fe7bc652ebd 4fbdc596508d24a2a0010e140980b809fb9c6d55ec75125891dd985d37665bd80f9beb6a50207588abf3ceee8c77cd8a5ad48a9e0aa074ed388738362496d2fb2c87543bb3349ea64997ce3e7b424ea92d122f57dbb0855a803058437fe08afb0c8b5e7179b9044bbf4d81a7163b3139e30888b536b0f957eff99a7162f4ca5aa756a4a982dfadbf31ef255083c4b5c6c1b99a107d7d3afffdb89147c2cc4c9a2643f478e5e2d393aea37b4c7cb4b5e97dadcf16b6b50aae0f3b549ece47746db6ce6f67dd4406cd4e75595d5103d13f9dfa79372924d328f8dd1fcbeb5a8e2e8bf4c76de08e3fc46aa021f989c49329c7acac5a688556d7bcbcb2a5d4be69d3284e9c40ec4838ee8592120ce20a0b635ecadaa84fd5690509f54f77e35a417c584648bc9839b974e07bfab0038e90295d0b13902530a830d1c2bdd53f1f9c9faed43ca4eed0a8dd761bc7edbdda28a287c60cd42af5f9c758e5c7250231c09a582563689afc65e2b79a7a2b68200667752e9101746f03184e2399e4ed8835cb8e9ae90e296af220ae234259fe0bd0bcc60f7a4a5ff3f70c5ed4de9c8c519a10e962f673c82c5e9351786a8a3bfd570031857bd4c87f4fca31ed4d50e14f2107da02cb5058700b74ea241a8b41d78461658f1b2b90bfd84a4c2c9d6543861ab3c56451757dcfb9ba60333488dbdd02d601b41aae317ca7474eb6e6dd +cdcc6271dfa1848b66a303c6a47df21d12d2b4b82bdcabd0122b64b4bc6629e2 fe06a4706468b369f7624f62d04f9fac020f05152f13e350016b2a29efff9a393940c138553356b0e2848c01b622b95ffa11ab07585f7dcbbf90e9f8ec5fa2fb7b4cee0d0a4e8d33490abd058cf3bb85f0cd9b1bd3e9823082d70b1a92aca6f2c87216b4ba09feddcaa4cf254336146cc75604fb1f286918fa2434ca36be2621049438a400bdeea6c657f0301503cd7e6e38350838f60ea7f001755da4142ce4579b39029da83f1646b7ecb9947ee89aba377099b82026960b9ee600779bf00d6eb0cd09226db6915a7aded27e6749e2cbc2c8b030ce1850ebfbe24c0658f29e9e709cd10db8a77efdefc90fdd7b9ad7a7e0334412a53d248c4c12bf2987b7accd2a8a602f184583aa560c016093b56b100154477b834664e6b85a19f8dc909b4d79816af12266c731e29a304e9bed8ef1c8030365b7deaf3d436957308117c7c5767e0cda6e342ddaf824233cbf4e699dc667357cb35c602ac6bddee71b352af55cb93941a1a6301a9904447af9ee486114d57ae03901f10084adc0096e465e2ead2496273112f2fae626e230d42ec22ea10a8289b3e35eee42150769d6e663a3ca29174316ec93a24f148d984053b8f98664eaca3e0dea0b42e8ee30f81a2cd6e42c189a25fecb6e643e693e1f8871b837c3f5ff2aafd1650a465dc8e5c1993be65cffd87f2c680c86b0ad3118834a5f2e490015137ba945c2775dbd77fb3e5c67819a9a7a94a656fc4761659c5b30ed2ac55a6d249b700bc9c93d590490aaaaa75a9fc34a90d5a9106f2860bde19fe5815436068a7f8ea4636a +546f4136b0a7da560551c9c19a86860f63a743edba4f296f4cf5ee156412418b d0ff6e045f4b636f75a389799f314066644854821b6e7ae4047adfde2d0c0e02c250f0be582bec94011189b964a8af430f5921ed9d9f4446e4c788515b89ca69e5f7cdfccc9e83e8f9460145b43ddc41c07cc512b7e6fdd0e1e7aaba29a6c016ccb7bd54b145f3951eab9bc4908f623e5a9b0c5b36056292540b79fd15c53457dc74a65fd773a34d6b313a056f79bc29a3fac15f6a1446bfaeeaafbac8ecf8168dde5f6ae6b6e579bd3ce74e7abfadf361d0fd32d56586a8d2d4ff4cfdf8a750fafde4c2e9eb32b06847fa30b13cc273532d1a23c8257f80c60b8fa94fa976f534145cd61c41c0a511b62cadd5848ceff643f83ce43f8e6969c5a559afad60e310599a34b2e5e029fbddf2988fce59269c7128a1fc79a74b154d8aa2850dcfdbf594684e74099e37882b440367c1dd3003f61cafb46ac75d30e677af54559a5dab70c506cf61a9c35e0e56e1430746916ddeec8d89b0c10daa02c5d7e9f42621d2b312eaffc9ff306297952a32d26c2148570aec90501ca739ce5e689e7066d9580a4fc25e2023897c74c6856273133e1275a0d275dc5b75db724cd12c9c01bb95ab5a227b7850020630506096878d289923177183ea9282a4c78ec212d2e898cb99d81a3364df20927ee34d4475a5cf5cdb24088ed75b60201922e9c972d8556ca75f8274d15f3fb88a6b42c766def6b21329dee7c457446dde8c26405fe5d0309a04229f449e8490cf9000ee8df400cb7c7ee831bd7059d24088fb42d61681cde45050fca78ff64d9c8d1f58b55f802fa5d2f2e723f3e4eed4338b060d31c8acc46d26870bd45d0de0798d48e32aad1a6d4322e69f5e72309b9d7fa1f24bb1d63ff09ed47391c232497bf222c542a70975c8292d275197a4ca +67aa852f5bc0f7d97eb093a189171dab14e56ed39bdda5d5f92b5e7afe24275a c9a0b51f3199339c11a5753c9d9c95104b400127087177f14d3e15be881ee89bf416f97d4f7aa9636c5ef29ebbf8930804006eb26839415d3984b920882499752c36a5bbd583308e716db16f28db98b3a3e718a2ebcdfefa75d7ccbb6a746e32feaa38d034843461dbcfca7f983e19f5b23ec2e3d74d2b4402f3bdce7d7a9df1384668c746cce466b0654cdd5ca56a77d68a100ae06d63cd9af512aebae78993808ce672330e2065c0f71e05c0fe821cd5f85732315f04666f3e4e6c4f3e9f415e31fe0980d874994108e12464609c6d5c19cedfc85846b0a84ef3ccbd3b655fb0de8cb892bdf774df39c955f04f322856d470981beed0f752d82ead73b4131c5dbf0424b4ab654f72e26ef0cd292b87bd5b66fbd5e7eba96c62cffefd4b1d870bfef312b86e38ed5c0f50935e2ecf9fcb8c95d35d19a8fc8f202bd9dba768ca48fbbb071179413c0de4fde86762ed4b13e1eef2a00add5d1c2a3af7937787debaf1f6f12f3f0225ffe587a5540cb550f7bc11dd6af864d6b6d16db1488cb226ebb2199da75fdd59a71158867298f63961b40a31209f8f16629b1cce7ffb617072748fde8920d11cc0d0678389d1f719df3ed19846fe9893b04db60fa603170d9573b1bfc7da663e07254552ab6253dde814117185f84373fecd7f98ded170c884d41d1ac81814c73ea48ad94eca1b7733d8393e320c8c467ef6189b4ac324c68c8a2ecf679c893b7dbc4310cd05dadd80bb6326b51ecd99a441bff77be8d644d752f3c5c794e7d45ba76283acf8913bbf2a420f9e5d14d7a23e95fdebc69b455e466423012e9d1de9353e40d4bdc3107c3144b96c6dafd41ccefeb2b7ff848cb9fdbea8648be32160fab7e7dfccb807fb019ebf159231edcf2d487d76a3e882f3f50ca48dd08a23b06ee887bd7df9d7c6cc2bdbe348e3125c4532448f400cd57a8679abab13e582b13d49442638e2698fb7a563c7fb264157 +36b0293921092d24b90aa6117d2d88be25cc7dd26030a72ff6fde9b209ec1976 da5b2118cbd59f408ce56362489fda69ef73172f46dec16c0d4a66e3f3cca373927cb6784ce62bbcb08a490d003a8f77391e82cdd87860909383b054db95816720112e2f96de9e0ffc8babc1350ed46b9aeb5d46b66940efa311f4853f3118063c550733e7679d871729001c12270e98439e375e0cd24769d318e03cbc97d643f1dc5f1b5ef59d12789f22449bd8fa43a13ce78a4186166523f3807b0b621079cc528f4e17c258d4f9bdd095a3e365614b94f2cd778cacabf26244891531eedc24e1bf4598319eb8b7527736bb1e734429360f47f04b2e95d5aae997763a467cc5303d1141c2c01f7ab9edab860d180697c906ce1558aeff5adce603f8a4a10fc6c1699189e73b489f64cefb89ac557c5bb8826c0317eaef2302e855fbd96777898104365d96ae8a8ed8669c568c4dbeb0a70f6cf4c22fd933014473f91871c08d5a7b44a928295fb2aa56d5e2c39ca79d2837fb39b35c6810c378d749aacb543368a19c137b872229e0a6f469022aa93bcb2be38b761c85ac09415ca7deeb38ff2a2101507206fe322a89666d32750af0f4d7b2e59571f02a048b8f94fe2d231072e301c8641d1cdb4f841ab165af297495a348bccd937712e68852a4aca948c1294f8b733d06d67de89f206498dd401e149fcc1edca92deb92952ede4ebdc7cd7992104769a04de8705027a31337b88e8de93f6624e8f10b9f9924e8ce5a9d841c9260753fa1492cddffe6b4400c5719d76fb5b01b234f32ffe64f04d0a00676fbfc58dbe17b4d552fdf0c5b802c0cadf723f73f86e8ffc493992d23e8c0b84f7220a983ddda21170b1f730c736e75549af6ecb8dc94fb25c26bcddee420c83e8a45ae4c345816b7163cfe016dccfe47c66979d610a7f9b4a7b1ba5e230344c9f46ba076f2fcea68aada8fa09bf0b5cbb3850ddedd80a30e1f7a639ac69e5595c6a4083aa959831ebbeb84c018068723192f58baecddd18c857e212d4c7e7215b6c954728183fbaa07720b97189af6a7729c30d28db33a889f225d027d164f254535770c504c506aee4ec4676771f69f935ba08a1c6c85 +5829d188a994e97e6c899aca287f6d204b769fac0cdddab534258c0c65bcda77 d1890b4704e169c28e44ddf62a1091450404910539fc2daeb26e8acf4533b024e5215c2d02820dd8fb2cfc1743955cbacff0f8f35dfbb5e3f942f36247f68211d518f3f601aae12a1cdc000bab43d4c973f287e80741dd1fcf6c34f2e6b4b6c313d01c4ff3cbf9166f26946f18ef2d58271ba9233f09a6b77bfd4f48b36eb3d73d1133c4f842a7dc3907f680b0b773242c11e3dd973a44327ea7cea9c0f8e07d682b6651e506b587559fe01ed721000baf570a16fbdd9ea29fa3def4be912058321a8b720c5c102e48a6e7ed6f8838d400dd57d06eedbcd15323f86d855c94b21e41b14ec9e1bbc8019211fd88138c91f9abbd9bb3914d26c1ddc21673d2d51263b39d66e741d924cf2b192c5d2c1a140126a3d64a2c77be6c2c6ebe8599978ae90bd36cbb9af64d078910c4094ab3bf399c34f2ab8ef843e9fe1bf88bf443ba21e4377e5f49c07fd9653b526e14562237f02d11b904bca6ac31ae721a43e3c4910a24af6f4d80c031c109fc0fe49f15274bca92bda04c3b4196c192f6ce489c63a806acfc895ab52cad657c1783b528e12d0ed856e1f8fc91f2aafdfa0a92498d68530772ee73b359fcf1418d1096c46b34dcf90e5b468bbb2970becbd70089cfb039d64cc50fff5eef26384d34f24515a6558b06a1fdd88f1050c5bd78cc6ed83d4c2b0e882aebcf84afb0430d0bf09f2fb42b8b4589158093a7709aae75a790910e211ee1333ffb6fd80778da3bf73858978e9dd647978841b18001dbaaea43ca0c0a03dbb9bcf30ce76a6f4b2cf2a9b6531b3e4051e7e05090cd421bc66c4731e7122ad129fc42dedc83bb460e3f889992fbd3ca072686e56b72c720fbc98d723ef7f247286f77ccddc728738e941b1a74d4f16671c21fdd5643a115ddbcb88ee7ec67ea66fd2bce718df6e085d4b5fc71a72696636a8f7b3a68afa51a896771faaa7f1f827430ac5e8089dbc0d4175e1b22a057bc5f1724eadc1a41e78fa3acaa8b97e5f2e19ef9d59ae12b04e7f0e8a621e098a66910e2a5ed2102b824cd3ea044a854f1cd0b33e61e7f737414b2953549f25dd34d19aa1981de7cd5649ff6c6364a4f25312ef62395a747ab88aad722c05aec40deea8eee5e779ef458a68840bc6bd5d29ad40f98b3ae010b6213372abb7bb8b8 +85d0d6edfde942dd257320f9c947bf3a3e64f63151926162cf7ec212bc11078f d9257004993c7ae50d20f534b42b4ec39bf358393b9fb5c8e37f87ac7361354554be596f40e67b2ed499887e26dc435c4331cde3bf1a118f60fd821477ffa3b92f6469568cd2cda6fc0a2b13906ae459cf5d5417de2ce104d0b6499d3683beb40715582ce70ded5c5f8461edeaa38bfa31979661a2dc96d926307128f77700f2c7d38b8a9d6c6f70a3973005350f938b9b4a64e228cc3b3f9c4fd446fc650aa6377152d7f46903d8ec8e9340710e28475cf21e641737e7d7da3cdf18d01c8f37131e727c7274b2db759c5586fb84ec36a5ce2d820e553de6426b8b96111295c19dba8d17a2b7047fcdf662a59c2af27a9abee37a7f8afc06944346e343e779ebd895119d7460e7da998962fb1100e950a8d7fe214360ad263b8d070f2b7dc91c9d77c6692da0f472a0a4646a1edb069ccd9ce4ca6fc24713d650153b9a253db5136a3710198e60934dd2053315d313e27dd2c6ffd2ecf028625f0e937afd8c2ffb1f646e51a768204d83a649798a51b8e87fcdda7bddf58ed943bb7e29c7d7c5dff024545f6a689aa0e727fecd80b561011a731acdd9b3f283123098ba66b6b9fce6123b35b6f3a20ef1055be9e257cde97e5af41eb796438727a62aa665cc9b771c4a2052efac61bc91bcdf573f7263107d44dfeb125e66d1f3dded3bd63845af3bf4185a9a24a7f4b777c32496a6107b7ac940af24be983f6a758e5064f8717eabbb86e6aada7da75f72abed59a42de82b1aa2642f5ef1b2e7304f642eb2aafbf00c1183d9b5fb83893edd48e9034dc7a7ab66f3f392f9666c00ecc9743ac4f777edcf47b6818a34b7392b4ab8e38891fab4018dfb99af06369115d60c4fa073240d9c2605e020a42db2e1e0ae4ade3a04b825927a05d4fe3f50c1c7add7a496da7e95825c064315196c2007524d1e1ef2c51303dd1203ab66d9fe89de553cb4b95a6c5d629b89b7116463ee10ab3cf2c2615f95741ca226f9e9a20e99303888f725c77476533b4c393763170f18f292c89a22df68eabdb81aef11cc2ac329c174bdae5d3cc0bdcea6eb225e00c15021432264ba7c5eb49a49231d1f7a13afc238bd4efc04da3c15ae0bb7d693a0150e6a5ad9b1e11a490b3ce90c027442501684c528fe260881162d9e5ef84d6e4f73f222e779e58b71d5176d9a27f65e49d83efbb2d7810e5b06619d8cef7e7b51cdfb6e8138e4cf5674242f947eac13fad08d68a8a11aac9754a5316c93738ba7f3c3bd2e827a +13d01c9bbf6d1ec44015f0c0eeae55b4387a80897b787f80c7b3367d1a62b65c 09cf132ab943654184a3fc8d0368b421fdac4ef1081a29f3691a527fbdbd74c6372233b38dc432ba610f9c54fa68699f9ec2a6bfb0b2cf7aa6d10ae2207a7554163aa14fb6a9cfa023ce63546b7b02af03370a899ea73b27bdb5c380613c0ea670c659803d5f6f75c0ce62b311dc157de843a93905e7a28a2557684ae3db4fd009412a107098f881dc06622ed9e3df2c8fe69fe50bfae158b87ca761fe1e221856610bca301ee68958c25bf58d3be203af928a919ace53c3d99f55ab00dfc8a1a28ab83e78617f194efc46daa77573d02ffcaa1f9d96fd8da8dead3d4e75ee5e65fc360b2a567cd34d52bc9aab8b71160312e8e21aa506105d6644e6863e7d5e75ed47c1760743d113a4526553b303341fcee5fdd005d35929f2afa760bb8314d0c0eac960fda3263a1e6688098251618c90332005c757af958714571b77bf2a69030d99f71d1a5259658be565fbd098070122c43edfd400999c90a98ace95315faee4f1c0441c9315d527c7ff1a8171415d2a076e2c513d40b03cfe5513c0e74ea3a03ad4958c00a3e1916d34273e301d517b0a5e770393880d9afb4d0eb44d3140ff7d827c48f67c6d92b865d8fe7c7e45aa50dfd8525f530de1188f3af98b3dc625d335e191fbad5ee9df09c97b43f203bfed798f7d171bf00c82ea0ed17d5890c3d6b9ef6fdc04c5ffb645e3050406fe2fb6bdbe2ffe083e751dc19f2f06445397019b61cf1f505875520f09c6b719e642b81b2fbfbdcc072b7981a666d51e7065e21244679dfe056bc9d42b8851f9d2905fd838707b279a8106eb894b60a72e4851c344119ceeb5bbe110b1c5b21c9a5f7545283002d4b1c115308b1cb20f6d9cb869ed0459c569662aa5729a7d7178de7d69e4885ca77c011e785ecf0e2ecbb8f5245579dbef7a5eb30307e0b40b817bd1112d28eefd548374bc867e0c34d2236952b9f859903e87e977190ff94f5d815699154f96e5449ddc1a14e4196c83e4fb02f5f58c30eeed691de47c81f4883bd84f6ed711fed0c198bfa2b8296182d7225e8989acf55d3612a93e77d24f7b6eef813fd514ce2183571602976391f5ac4e86da59a64233230fb67ff0bb9ec40667f54ccb235d04b3fe1d9a47e163cb19c316046fc1353a6642219e9cecf6e3151c0f4fae1177b67f19b4964df96bb6af37012b8ea9e5ee24c57a010c872b15c8a65d0266589f6da20e38d9be2e2c215c69f558084e48eeb61f4eaae83c57f3f1cd08d05783fb9f5ab1cda5e4b86291fffb14fe9b497ec73292bbd295c5657d71cc74d38a2f3db73ba972986b7169f76ba376376f4747ed65f2f1a5e67889af38a380 +26a36654abfe624ab140b8bb67276d6f48b66a42fd6c835f438c4e88f688e42b 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 +4c5fbe2ca7ac39d702a2d61a9a7ccfa1ec00ae4b56eb9908a0422e88b2149174 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 +2e025455031b77a04602fc64506ceae3feaee69b2835f59142e01b9ce803f147 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 +2e1c97dc026c679c890d17d67c9c1da91620a687ce9f1d7bbdaca14cb78da647 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 +15fdecefce27317d246e6cb067350799bf641a4bf937cc47754c7c5e9017bc07 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 +6bffba6ac87453cf8ce98d15acb8f79a2c6cdc0fda6dd8d40e2f7e1f3761f681 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 +96326da17cd8709c5e24ea13d01d03f868bf9c9e2c3bb3cb30805e5f21ce3bb5 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 +dfbc38c7499eb1a3a26e965019961cede98f32a51fe0536e6075757412f9d770 824a155d7798e12962f4464ead9af132a226da4da6e899629efb938ea29a86937fb144866d8c7b2df9988604ced96892da482d4d0deb4658844f41835f0d9c20c796929c83cfb49113f5d95a7b66d9116a4697bfe335bc83629678cd5deedb7c9f8f11dda079bdce8c2719b6cd400c02a6a5654f19b6d568473d37174f62ab6684c9c919c1cfaf35116ff7ae4f5b0f0bd243c74384c2c9392f1189b2ad448b9d7946c2ccad04d2f20cb8cf1f9590d1504b1e1b1d74a04424bd27d0117676b8c823022858a4c12aadf21fa45c99fad60120b24fe04ba3036b80ac5f46e983032b6d78830f51e65a62310b9058a4dd3f3f8f90ed5311e1f47987e0d410f78b2a76580fbfdda0f944bbe466c8a8170b5c77e8132ccd7d5e9946a5fedc73ab9465e30beee9cfad68b70a2176393ad8a173cd9afe8f9b33023e852876824b720365e688b3fb4ba925040385559fef7bdcfa7dd18bbc31b24936557edd679b502864588cd4bc270099a30dc3b3ef7a392f3e33e21a53fb83756ee371a1986930c4a34ae1301ec44e189e23adb7eaaa121c6d787007a44e998d112484019f7d7d8e16985b039c8ce01ec8ccefb647f07f9fac114babc3d831afd6f08597222a4da8c4f6cb22c673c0437c16fcce7eeb64e7050af9bf41e95d3a0112fc049d405df0e322422072a16df248e10aa22ee5f198c67c59eb8198421da855dbf2c78b36352b1373f7f66b5a5bdcffd44c76b7cdf56d894187de7bfb05c0535c3d2aa491f37d35c3177e0f312a9fc7f1c6668ae0b6b4b6c195eb4aea219f147a9799a9c84449d7477fceeaa0abb836150487abee7a1902540b905e998a532add68b2d15a1fbb63ddecc54c8c206ee655353c7d1db411bd33419f6f905bea567f8d67b5461f15acfb8f8505ccdc29cd708be679238ce30ea3d1aa183befc35938d755c50963ff9c89ceb28764a7ba8e72a2d22d168172dc5d91f4ad5980b12474a96db75e1f7a9ef9cf1a0318d18b01b108cd165a3734d671d436708ba030c1e860eee860b40e61ee5b72a4a98aea24ac343bb6d4095f79fd9f1c8d64057b6672821b96f954df23cf294f516bdc1045170e162bf58e75db11288b466a4b83125f1b54286f14ba0b55267397d9605a57f16ec357853df6f3c8943a73f7d20659ee01b3cf70bafe432089bfd9dce1e31d441c174f42d3bc04084705d0da308c21f30875d68f8611b62f49af1b937319346dcddee9632f5c7044107c3c5b49cd59169008d497c4bd9cf2123ff7636a5b20501ba368ac6d18a32bf798419bf93bf7cd7b1e998471d4c85a2bc50e316e89d17acf327469f1f45a68fde54714cffa976d488989f65fb4e8f9f85d43010f982453223bd060babefdeb9dc10dbd28cff842366dd55170c33eaaafe90428d9e632785621c5f836d118c4bb97bd2dfc2a734c64f614a9fd3179512720c9511a1df29ea9792226fa5d3b74d0d29d4741edd5821904f52aa7961d303b51e54a6ccb80bb851ae57db1f97b656772897190714a5df7450d7eefb982188131d81c6d273021a2aaac777b0083f0cc363e619a1faed4cc2cc7f28e24f682c9f9eed99e09e19a8200e68ab9dcae56aa92c99823015f82c8f90a40df0f729888c8320a7f0b1e2f6155c82aad1b4aca0870deb69f04cd137b556b9919bd920db20a1c1dcfc45236e6e90fa3054a8e29211bf76b13800f3ac4657449c89fb76d32892024e6fe7664bd23038457fa00b1eb88334f4c8ad05691c8e3100f2889c0e96a327c9b36dbe6d9cbfbf9de93adc8c17864cee6d30ebf0bdf8f6b9d65d2d6471d26334089b40c9b0edcc3d0da4710e76b28b392f7c3bad6f34c776a72ab211b720ccbe60e844cec4832ecb8014bb236e0af9a39912ce12a5386d409f5117c01478d75296edab33e1c5273718709487ad0ab5b180a2d065c31dbc1e0737d9a800260c71a0244f19528e79072d8b8322225c6c6ae8471068bfeb61c578beb30f9ab6a173d70373d5f28e7c353fe723316143b2a6edf78eabd60124138b607d9a09d6ace70882d4303eef2c2 +059d3f77bdcbf468086586ad7b713fe446648ea6ac21009228cde567abadf557 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 +7b80a0d3956d73a22269e6ca68fe6c750fac721e325b6ece27ca781798f87287 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 +bd8ff737433b3da01959d2c1f06d430fbec1b77d6f982849d117711e4d70b090 8f1c1e85393b9c2a2b593363dceb818b102d0f57d4e1d31bd33c034dfb1f17e2a9db960d70d2fa0aaebb7b56c809ea067e93c449f4026a258ac04b6ce809a734d15b7fe13e4faf8f2614db9c3a42435fbf158e3e6cb30aa727272a4e323df21720ad65d72b18a4a6baff9dde47cabb343db282175d85ff51b34a197752138af3a017d19939df728a09c8f28cdef4ce5ff540a6c9968f4635d8d3281f1a5126fc3a7ed368dffd41b5aadfaafce5fc069056854a78054917d39a34945fb5e608febac88f0a5360a524d9c887241d2953bd36e46db75a458f4df4940ed71110334407dd0008a6dcae7d13fa5cbfcefd6667bac657dcbe1dfbab483daec686ab870eb60225689633f71f0d3c4c870bfe6090298b372b73d5aca2225ad724200ce2400a77d4788ee6d4b560332a020da035da3d520aa9cc52229329a81847acf680b3afeb2c1bc84b06800af381cdb9aa0a687c50d03029a0a6b5641a8d3a8e40fd9318d3c5add51a4abe661bc3c5c47d38507a8aa7d6275df3082633637e5700787714fc977698edd2218ffd47a81d428b0fd61be651478df0010dddf9363e93d8b37b3d8e1b122b76e15985d9f4eccf55936d918f0cbe39734a1c41b33b3efd34d845de5526c183d918786c8ed3faf1deb92e85cd6fc30421d209d6cca47e9db5341251e253e932c8f08628d2115e565c2d581f8c8955d71936dd505e8558dea1409e84ea31ba5355d7e2d011f7df83acb9ce0c6defa51b16185a66d3d6d1d1d7142168d9b8a0832fd2ecadad64cabee8c79328b9513328fd4c7006222685af6c39ab5f081edd49154b5a25375eeba3f663f7799aedc40fd74748be956ec66f77ec97457d1c08c4a03ba324365499d8d0afe4a45e7563bc0e4e33af704e7cbd8f85ce14fe1f84e1bbb871d361d46e0eb0b044d4af33b8672b68483e7187f1f89bde3da29c405029dd3da3b2eb8c248e3235cd8d2ec17271ba5563a09f5daaa5e9d118b1e2aa61d232f4ef928de1a10c786ce3270b889b6d859f35ee00da10fbbcde01a9cd472717e1bb35daac57531d44c0b62bf86063bf355e0c08e3baf6499fa0ba8ea96fc338507b675d1a31008f97987b2cc366e715f43446f9de4dc8c0aa7d81bb3b2e7ba7236d317b320c934ad80a7b17f0f591fd9dbbdb1800bc377b6b04dff1d268f3f6191d3a37015624a8b4efddc1f6882d6679fb0fd92bfc9526272cd6a2cf768e6dbf3fd1732f6b46cd4cde5d07b7aab467fb8716e41ca9b8ea9139d09701736b038d25013666a8dbe63e0b60f93f6e77bd27055984730a6cc5791c6b5585a1a51f787eaa42b3db7ce6159471dc5454b7313aba20f2df104bf98862340fe0a7043a555ffd07dd1112f9c1627d541a896bc66e78a01af4ac308003cf970a5c11d2880e395bd92d455960446a67ccdcee71cb6e76f9887cebdd1d5a60131d2bae7531e14f3e04a4eaf5bd366d4e1710293189131d2b9d8f28b8919b27f54a01fb804c2d1a66b49366c59465ede6d6281ba5656e0bc14578ed3ae2189b1dc73db53a217f534e27543004af45451e6a8fb964b3fa2c8af0144a3b22ca3b0d5f382417139dd8b1e62469aceb1781acb4986d9725bdcb8bd821a2c4490a6e75fa4e0540533c39a9dcc8697c169d535ec71bf1db04a6446ccc07cf34ea440b4d45cd8d664a8a35aae7a16ff8ac4d2360d400ea19e9f000e60b92229c51bef3090ffe9c5461fe79d395eecf4c11aa546ca00cda99b5cd5ce4f41e0f00be6c2ae3c4eec7df60d7e760cd3076ecf5fa61dac163dfe102e3917f692b36cc1bcee79ff8fdcf8e18ac90d4ab0069cadc2ee6e4a92e52970e63152e77fb4a047d20e33526a4def63ab812a17f09065e60aabb7a2b898cfa10a35b7b7ca9fab1583f357894ccd8aaab08c6d9f6fdf1b8eee4d938068d35b3eb0b1aeac3d676ca5034448c6b07df0c9e105890912693a84c981c636e7fc8d31b19fc2deb423f13e422594bf34f74db5ab0806f9f2e7c0f224f37e6c43cb192593c851a7cc1902741b55b86365bebbbf1188005105f492d43e0a9a07c7af5c605a3c0569bb4052697775a9905c7a0233bcb9699e6bb0982ea7dc252404451ce6dfd1a47c298c5abffa15041ca28157fcb4f484772767c025d0c4a8e89a1f59517d72693a45d13998816698ec21c640eb8e9f75d401b8118aa3a79f65e2592b50611113cf405002d6162540a0ba003d409c1d58e81d2f4a7175747eaec68cb60a854580b7e9930524cda26e9b74c488f98ba2bb08b06114b8d1f24b51f5b7abf7e456178ada8c77d9ca1a932f85df4db00ca44c483 +9cf6ed964b30a3eadde6813ca423346c2c59e5bd9767ed864cb17e3c98c6d546 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 +2365ec685c9ea71c03af13ba135db9bdff1c7f1c5d66ef4b6f74b0ded4aedd9e 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 +11cf85bfc46b3aaf47dccf6d509705519f1ac87f41f1af8cf21e7739dcb9f4ad 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 +696273db554b27c438730fc15124e1eff6c1e010ec841b4726a1ccffaf1befce 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 +460a3a08843ca63cf20bcb51343df05fa07f764df307a9344a85c8936405839e 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 +4faa02be768501b7cbaecd77f8fc3c779ef521112893ddfbdb1168d5e5a91e0e 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 +2c3e09a223433b11c718f99bfbd66c7aef4d373037537cba3bd7005b436fd28b 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 +3bf08a0ae34b46e7e1e3cebbfee9c51976011e7004030c862d5cad6b41bbc3ed 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 +d1897d3810998e7af1a8cc39a3eadd10704ab5025e70a5101b25cd139fbf6a7a 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 +86c7ad37f1fc295c6e220e2980277d3c8ca3f99d1e473eeb51ba4cd1f1a90de4 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 +436b2e99ac5d49f8a26ce37b1e6b9c51ff6aea687228eb64871dde8444cacd55 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 +7bb998f3c5b0c1df8bba35c136eaa1fcc523d6e4914abdeeab39720e5212796b 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 +d5f6188abfb785c30677817cf867b3c21f9fb47c5a9dfd56e35f6c9a10837802 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 +da46870c04cf1ce8e8eda60db2277181c94dbbedfd01d0b91cd1a86245870f3b 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 +a351bb86306bcd3c3155fb3f488f38e152218ce94f151d22773f4a5e241ec84a 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 +fcdce5a164b9a75372b2a80cdb73753ba3f5e43e95b33100033dc9c555a57a69 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 +0e8ff997e8d8ef10c2b9f4b4b2b0857c7e9bc030e5c4447098dee4552fa3cb12 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 +3ae5189bd087f8cfee43a69777fd6c1447e583d59add1f780cd11e9b6541e665 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 +d3fd09222af7b31feceaec2bad722f4bb5d7c8f6a0a2cd9440ffd3abfcd2a034 08944cb473b828b118a31986db67fc757f238182e790553404b792aa4f0095a6a83291e287cdd16521a3ae8c48f56fbc909dfccfaa7bcc570c2159f26592dcd6b15bc4dd55cc05595ac634b2c3de15360b0f07a03b5957bc9333cc5097919399dd9973ace15e55940178c4c96bb5e0a0a10bae175769548ebce11e0d7d9db29647f197d4b87f7039f5d4e59e016531dbebf55a797ac9a6835032cdf34240a7ee7423e89c09124829cafc5f89431c8afc54fd979e50d48a82b47a53523c84b6004daa323efb708203e5388a6a5110c6ce2e341048a65fdeadeb3837a03420f9faddc3f02a544f1e46d96b07c90c7971a7040a179e8198e90aa019268e00367120d5f3d98a5cce82c885e77144b1aad66ee682847776b04f01f501dcbefe3903080a8058b3b8f1d823d917ecf31fc2d5b0795bf95a55c7093eca7c801dd0bd0dbdbede7d56513128b29fc0b4d25a6240b24c99e017bdff7acafc8f8de9faf5a2944384aece82bea04dccc6d51fc6e6f27aa38f131b7959b13681a09b311d242e6222a1ce5687de5c080508b1db16b6f8290d33a3cc0d0138ac61fd9093825e9d3752889e9f20db9f80f92750eac88b38ac81c0016d40371eab4a87e845e91446b0a07081b84f559cdb95340cb020af22aea1bff2fda12f7a42973ff163a1c6f33db8b8214ae27abdf1c54f5b03e29310fa210125e1296e8af93a2996dbaefbadd4c51c2c3b8a3e2bc9fe060c42ba32768f6992a99599206cd2291ccc5bbd50856f7f8d2d0ae1efb5892c15a799b77482de4553736b162abb06631f1688f6746e7d7a37ee7ef24e6cc901175f04960c01990178f81e957e941deaac8846b3704e24204f43ddb0765c433f3f7d4d201459cd65682b7ddf3d47e95cdb31b96a4cb22907f08ba6e92a4a07703b2dcf150f922c4b7cf181380303fb72547847305999c3c8f9ac877d05d9dc4159deb8a13d36ad1d533a56950e20f906d29d51ddc45bd15c1773991707480e37b827044bdc6473181b760a9036e0d3fa491c2f08c55130d8cdd5ac8e97d0813164af3d28a585f0c2ec7004d498f95c6b62231a632a56c2d0c48fc3a6992d4051957b9ed6d9a86dbccd962a8883cf82caf01da2f51a203d56b6089bc8fd0b1bd414c8063031ed469555e22ef872689c130b1c101034d572fd8cd0eddabec9ef1503d7f728b0941efe2b9512438c7ddb176be2ec2d9ffcd56495a4511428df02819cdda18d1ed5d3b16c6f42aa0ac681a9fab51e8a1a856c15c51a3ec1031427142ea12543014dd4acac640b8a7729e63ab7df1051112cdefd4b988a2258334fa9a7f5b3a87a02074b9f69dd81b83fc74089a91d76aa4041259e80fa255f2084902aeb9e996ac2288ab464bdec47aab26a28a2a8194989755d48fc9a5c9279285f2f1dbb8b8018f3e4e13115d78a879792e45a8f4f24ed4a317440ba63e6929056efc1d2529b75a709d6c0097dc2d97f646f334ebe6195ec5630132fde58e25dbc17dad822d9fa0938a2a2c926b105d108403dc29cf371c3504ff73bce9c7acf9a74c4954ce6a32da96b21cf3211b3e49953dab78c49c3e532a349003c59c62f7d40261cba63a9ea21c89a38aa63ce431c43ae261c4d9999b1caf491fab8e7be6e8c3454f1be8793b2d27141fc107da599a4694c41353d7785c05b5e31440458d17c6db66feb8a9c5c073fb946a67ac0312bb669d9b12fabaa5272ca6631379ef4ed420a4424a5cd08526384c047c33a84d5d7dc0c2153663b54c73dd799a3568c01b818992cdf8143f1dadd6b50cae6eae13ac66f31ffa2b362cc4d2880592b7fee4b9e4cd6aa5e5de27aab9b5dad9f7d39407ae927530cab2b61cd7394a21ef47bfb813b5ea6091458d239664923280ed0d5cca8285bb2281a2f9fb3ffecc8e9147e1e8fac957d90c9e5f513738745a47c2ad0c31fd8986ef3b6388c6e821f166513811d547ab4336b5e04643497fc9f8d6e380ef6478b82b6e2f5f65dd98a63c68c32b94610e1d3b9538f13a7688fbb1ec3448be9bd77bb93a34546172ae8d614f85228988e7feb18c9a0c9827699e8b3cbc69750bdfecda8268f694f4c509befc1a1166f85c829725299d173f867a300987a2d36d1bbbe37be3208fb8efe9152a41a5f0e931b6382ff7f9b18937958fb180e61f2a8c28f36c3c80c3722935aacb81c24aa17fb3e7a1026f7031a7449818ed62ba7705ca27c2d3268f90b6322921683dff800a306cfc186cf2a61b37f35837b217e3b2cecb0843d84eac67431e3d689f01522d4a4c73618b7c2965c9dabb15c0be637d10ceef72271cf39a7b803b41767bc34433c3e6ff449a439ae13da1eafa038cb9f2e1c84f1ce39c05df56fe3d7b82386c4e628b6e27cbc5d575c66ada3510c246bd04db48f4afc2d7352966da2266c2bc9831532f53655d8be42b421ac0d70d8ad1d3587257886dbf93668e907e861ba64f45999badb0f766eadce5238b5ed397f265935194812c03c5769137bac97140525303cf48d65f39004a3f59b1fab09895cee05335d15b9b12265892f4abb92ab1dd2002ed00cf3562cb67dfe1055968e4ab3306bb34bb87d0f64b26848812a2f7b50424a21ff94081a7f70f7b684ab0f092b2b085dcf84ca38414cf7290f607bf79c37ea84253abca8d4184d2dbe2e900200b81479e1ce8b71dcf2bd6e3c557a8e431d627ba669c2ea03068e0f7ea62c29777b22142d7a1d451bd541ef8ebddbba4e3bd8ffcd340e935be7c66efc14a13ea48134f655b0de3180101f09d204c379743a357e6df1268b55a9f7524398ecf3a59849a27b142239059998083e8fa91785e91c4d220b2fb17e3389ebaa384a49d89b5d78136dd2454f06cde9837f096b744d53221127869904ac227cdf30bfea78cc5545583f999b9c42a1184e2fb9ff3ec095b9da0d138205c4eac4c8c480c43153608849f63e161135c79d8b6c9cfe9b8dfd8afab559d8b595ddd43835033b4bbd391e028bb2a60832d9b697ee61408f149744dce71aa11bb2b0436c1e2626ac3a27cda293366b90b9cde2d927855130758d3946b867192dcf3fce9a3b9a5276e8c37b8cb136fc90a6dc22650f95e796a9886efd3f424be63a66dbb1041cb3d4a06f4e7eee89f0b6d15c36f9ea010c66b332011c8888e8e4ab2b3ab5223191e1388613a0fd0f07c1b26d7cc7cdf1ac62a226454d6291b431cc3ef2db2b2442b37defb942117fa247096beae598611b8104f37bebedd8bb8b949a89b5bf8e228eca1d8f16bfec75a02ffbb4eee3a6d4a6087c43634d675311e72a9f3253bb5dd364e07eb4b9c84f586ba267baffaefec79e03b83b18595fe06d7e063ee604ff287004d141c1a43af0ca7c5651d98f633fa875b4743353fb07bde59b6567ae25f7095f1d9edf30570e2f7d7ec194216898d910f9e295a41dfee072cb56f914bb78cc9854129250f9874b63bb3ebe9a1cdc6ebcb0916e1c440354ded6aa818f2811da913912a21d3961ac94a39f0827d3a419616905dc45842c8e69a43004b8ae922c8de1e8cd0668674a7760153213835bc63fae4f8d65614afd74a34d42abad5025b884b34639340b45d49cced423771916e18aa077291923017ca50795f3b7a3f349a3d29923833ce57801c631576e23b838a7767ca1bda92b82ac502db3688ffc83c09a4e40cac31d20d9d32fa6724a80be7091cde9c7a6560cfb326b467caddb9e9b7a491eda283efb0b61b4a1116dd859d5c0897eaa2a3fb2cd82ffb33770bf9e08091363b6b81d23e61c2a647d2be440c5c79ea89690656d9f10b1f07942834e1cb6e2d2df106eb6d6a21fa23819e65028515e88bd279f9317beaffd394ea51f8639371c3a89f11305a4ca35fb0711f5e2c7c3dd1659c790245812113204b4ed8aae9ff09d43c6ddb13f5070d98831b2c7639fb6b9b01c288812ddfa8861db32dc8268c07d30cf969953042b3dad530d9d744c06aabe7a886c0fe57b09b7f42d193fb3e9c06329818251a2f7e6474462c95ded +69bd6158b4b876d461c2d3718065f492265fa4f22f0841d8f3445989a0aa3304 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 +dd6fa520fc68a557ec2a485cff63e54ff38486040da0f85926f200390373d673 16f85f578206f4d625a5831cb3b029f09d6f9e13f8e4271fd41a429ceb638a1300e51b403ed6124420b363191f55b32e14d286584b51d3572536a0b7022b63f844f85c457719f88d4b91b1034d2b58e77c3faa34a33db8089284ad13c993c234ca883e0263d4fbe209afa31a445021a2fb4f457633a54d158d94f2342bedb2cb65dd67088f8e017b58bb787ed0400ae30466085eb72f190118bcd6b00a7e1be12d3e86553948859fdb930522ac99399685fa8d2927d4c97637ea57730c1216e00c2bd8e8ba684e1e8202289f8708d5e43f68efbd1dce5db6408889e5e6d32bc6b20c1e40301471ee658a2b89873589a95f1b1923972377e6599dc7a0276d52b54b18245a38cf56b9e4603bb9bfb7f9a68cb63184221345895dfaefb6db77c8fc11a2b0637ee6478db74f2dc771ae293c9d1b496a410ad012133f65eaf4d3737e01b4142b50c739b0766e846e3a372936e8f05d00cc91fc4b01df2e39151dec6c11c3e059aeeb884ad4b146f0ccc66ce48d8959d7ab9920f895fa911d6f127c97f1e8583d5ac8b0bbb959ca80e6f025b4df440747648dab69662edb9f4ee44a6eb7b3a086870b167418c4cadfdf6408e86fc07459d37870f95d1aa11d3caadb3fd65038cfadc758c69e8e77b9f0d08844f942a73b2a16b99fe58f35444c3e5cbff03cc7cb4b95da6ca7d9a70ffd846227cda9bb71a7212cb7f66bd635b2b25116f1a68ccc239fb5c510e876bc602dbc518f068f55024715c2236bea45f42964acc022ecc3653c12399fd65095e0e30614d02d8274c63bc4b88f3d11dfead0e406b1cfbec34065059ddce76327973ef82d5b0a6db9b3014607207e545bb9650518e4be41bf9454ac5fbfc984586f6fc5714293adc8438c897522fe2cc6b1b800bf64381d91abfb2ef2b7703e337ad631d24498fa36fc948f7b7bd668187ce9d94c396fc322e53f341971f8b79d504289da46199d7df841b985d0ebe2f82d9b742a92cd1879cef6a9fe968f3dd0875f4c172afc3a289a86da0f4d03e8e5e27df20eb1c819b2566a6362a3a202ed318851f218d39364c4c47e5b47e16894b645fcc7a84ff4ae8a075a65237559e69f6f634736129a6783b7c13bfbbbc9e3fbf5f8fe52dcacf563ef41c1e876751206e5fb7cf869f3f6bf382c1e73334f1c05e5f6fe81344b7d5cdf58061775cb3457d7476c3085f9fe620cca92679b1a5490d1620f613b7e8ce137c2f39ba5ccbcb7c61bccbd6a024eaa79e58939b7caef19348f745a4640d15226c0532f1ac35740ae23cdf1c5f7113725022a7948615a33468a3f2e8450154e4d9de452d3b9d5368980075858ac06ab9b30fdd432e44edd9dd3c57281bfb5f4e6822d8bacc2e3512834af79e0f8e13f8604c6cc838e2bd356bc3224d351187c89cf0a35069c7891bbf9f2e7d6b5d186ec92ca96a17a75b5315ca5eca94c03767c500b2728e36b7c7c10a39155af28a8c262152065cb68ae92965f0a0289fbc470fdf712cce4a03cd0afa7d9d3da1e0799177d78c5e87ea5ae6aa1fcf4a514812d0ed0587417f706891cab158429a326bfda07f6c3112f7212756e6aed0e548cfd788aedc7cb0d03d1345b2a28c6d3864ec67360ce237f008a225de38b3c3d95047d2ea919e47ded2b2b8139cd37d300a5296550a162cafa5bc0e8014830495487a3c2c4c49282b8e04bb988d744c0c7248ae2003f41ccd44666e06796c60a0e585bb1e10b5cb8d346e58f9843425fa3271b5227d0498aed2906f36d9076b1083bc26fa3f505d908f0b294148c796ee28aab1191b9f46f5a4950485dbe913b9e22365f0064720e9f096884c0b36d18405f35ec928101adcc82e3d56dd578b6e81dd0ef2a98dc9416682883522a5f357c36f292edb5337e0e6b33db1771edd2e98cf440a6116eee24c7eba0bcfdb2ff1e1c852a6927cd122ed05a2d414c51a56944b3012f5f9eb545b838781c964bed1c55f0b4e36f258f4d0ffd1a01d5cad9a2ed53df6a192ee74df63df7f6587eb31ed365f58f1666343c33e42d75322fe5857543cae191b799e312d1ebb8f70db19f831f136ec11f3fdb80b693cd2d2c2a56a3d5a1f48c63dd691e036387d660ee988885f08e4db47a72e57c8b16c583a7ba9c13d6f686e6c7164e9119709bedd892db2ed244e7325c311e3fff4827cde0ac7507dd2d2388bb978c6280ac6e096a12cc8b44c77a5e4b4c79e2cceb84e24ce7e3046867f2b96aa3dc663a2d66d481f47d81ab487b1a7fb04b6b1443e1edd6a2c8fa09015bc17cda3d7a82b9dfa4194094b40353e0b23b1f878c3f3fba505d7017ed16ef0a0372f1443e81d69dbe1fff79943ac8b6fa31aabd090733109917730333b86c093d7227dd54fcb590614d8f195922b120904393974560ccc44e225d1740f5590ad873e3093bbb1eaac54ac77047aff1b8b1439944b5ec784ce8a4b1a116f7d008c3b23f2f7c9ea10b802b3bd0c57d00ba7d5fcac12fc3b033c35ecab30c2563a0143c7b54ebf3b5ee18d800ffea1a04e92a41754b1b0f7190e9aa0f12f3498625f222de621ec311186e2299f7f86b4d95e3024b46a58989723ed88ad57b9b9917647f948420fb0cfb24a865610f0650ba773c258df09d739f73fda76b12e7b56c1774e62ecba24a0e00da25cb890642e49ab6636ce5b2ddb572d6caa0a9231d163a72d5666fbd466724de80f7bc67a47f9ed51367164b9f8762b7b4a0cb4e91fec551427cc9db52855c6457cad53599ae416d2e9434aa4ad72d191e162502d9afd354e8a3bef8b85a7ca1d52735f5c1aee0a7f98e3d1d793148f0163e4f8639c07980c9780b025a8f2f78790186bc382b766d8018a1c3f6fc088e14fbaaccd9e97d67ca25938799798f11edeefaec5f96d1782f1073a14b971fb09fcd37be34d39a6b5e1308f53ff291cd19bbae6abb7997836178c074f7181d26931611e1c86e90ba8ef3781c81ca4c93086dd2f4daabc2f7ef30ced53aafb90f972b75774cf7d3112cd1ca5bff8c1b463fdf46aeccee30a2247e9a2023ec1e3ec21b2250b8e9fe2b4bcca82c84f0be24600589f7b9d6be5bea4d2ae543d738d0f2b7b086c88e92f7e18b323bebc44eaeea26be12fe32753e3d2064e3deb7ec9ea4925e69de6b41e31820d49d6fa8e303de0faf1b1fe6c7c23a4e1dcc23bc626c108d5184141d6914c4dbbb15d0a2f55bc2dd4ecbed4c419b9b00a6444d639522600c8f9204b0de1fce3b6be57e5a9b0e3cde2a45595978fefaa4008cf74b13ce86db5c9af0ff4ce122f60f07069423f5e8c513b5b955d2a5c22b11d4103f9f37afabd606d50f7976c88fe0f01cacd075f4825615d3b9890f9dfebe49ab86e60f390ed2d756594e94827a4946172232979665fa8264b7c0ce1d8bfca203edbd7d394a9dd06b90d428da3f7d58f961d3680608ae82a0469bf3b3eadedd344898240663088b62b6fd38235bc0d391151238963c8061470f07e21d3b7fe3bc6cfc4efc550e2940872b67322353bde6025cd6d65c169b9d66748d73b9de6bf9edc57da1d7aa072bb2c35961df26fc7bc5a4928a4c6a95371b87e03fc52c2a06342959f7a1bbe8961d69ff1704fab283b4a5bd417a80e45d92727e0547a43ab04a59272ee8b3f6c4495414d00b88aa8a10e22a1a6829dc2b3ea2f9d2a544ada933fb44251dc6fb814c82b0e2ab1dad9f8609fe86ebefa6277a6774c81d4963578d56a49ca1a5b80423a6b1d1735ba3e6c0a0cd4aec877d9aaea84245caba678666cb5c2b48ae671befed3ed327188ff20c1a5e44a7e14e4eaa6be3a01c8a658e37f337f3cc8074d65eb3725595441fe7d66e1321385b2181060efcd92fdd5a556b8339890884a54edf0afe4133123f018e9a27051a9bcd04731e9ead9233ef0564e162d546319b13fc430b8d434e2ddb069d983cc12bf178983868d34f39f252a8f1f1e827f83a53bd7c04fd83049dae31e2df2b5efb6ab8538d090189a0a95570e3aede41e938f4af84d195458402829bd27759d3a429153a0a8666011a023ec50cfdf765c55ecf05426b872b95fcf281db662dd8f1689d08ee83bb32241b29765a1be2d8c9e5342789da439e7d94a4e6730741182df1e61e18e5b820d190e46fa461ee4faf5e797290d3458fe4ba805750ad85679a167718fdc1b35b07645d9e82194659fa4d524327600cbf69e19a76944ee7 +44565edae57c82df29d8f083019989285d0c6a7d357e9ea788ec02e7de592185 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 +6da05e702f43c760153bdc89d1fe3baef7061c211a9bb6db29074f2c4e77962b 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 +973b65df6d92d4fc45a83a926bb7307d1d50dc12a2606c9a734e0cc4fb95d7d9 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 +70041f0cae64cd6f9900c3cbd50a2f28b3d54b5738cb4c087b1b6dc8fdb6f3b1 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 +e20a2310beace89b093af94ffc4b45055ec34d8b239e5dd02bfdf389af580e08 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 +66f7582f57de1eca688305ff5d3093d4dcd34a4d0b00dffb50a1dbc952f63556 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 +d8327330459eb1a87aa137834e3f97f545abaaaf981bc260ddd5c5aa7d78d3c8 93b01f62e3cb9658b4809361da42e9074e311b9d632776d32a2a3e1bf168c7a6173e449f5ee483ff20b6030362a471fb3f02663d9d862a05767cbc32211d47efa54607c052bee3ecbc211c7de60ea83bff1638f80f203ac6675a07756ce149a56903f78db2018dbafef1b93fcadafb639a184155ee7a2aa9e49dc667012298b1d489143ff203f939e8a826290b95cc4c45a6fb25a4687e582328ce2d9690950a32fdc5b5f05f39582c8c689040cd4fedd7919c5bb9ddccefb127750f2776b901edaf7173e90c0354fb375c6249c935890632b86dfb37e475fc480e4aceb702f9353d250ef73ac075b0bb6c6b2f0316842b19accae8e084f0739533e3e3d62c5fc107033937edbf1ec95e92512dbddaeaac8bddc2cb8ec3488eefeb62a1fe844901bc12d9a0abdd8da4a06f7b9a9f095761dd80e891d2245e5d359b39c2e461ba80e33e1bf7c532a8c7cb35002deb5ddd49cb113c4ea214c04b95c4a5a68f68f513d9b470459cd87489e7e103d19bfe1ec3aa8269a611f0a516408232e396463dad842d0c1e92b25e9a3ca1696a5f2a684c23dde0a6b3f2ff2ea1d956d5e6af67f7d72e3d0692930e446aaae18373861a9521d67cf741c61eeab4e8d7a3f496eefac6780bfb826b532bc868b75609b1be86f9ec249732a831a6a8a490e2bb60ba628d144be19502eb99910e3130e5658fb5e3348ce9dd030e68a519407197f563b365f237816d9f683c5b736c40b236fa4ac9cec9a0cf8d5b54d5ab3609131a5a0e6bb4c4caca24aae1989f1859d1cd554cef05fd31220f7f46cc2e2d94c7b94840735a0f3a70a556d7e5f4845123cf16ddfb563346b9035ccb3422197b2f8805ed2d3f6a15bcc02209b40fa7609aa86fb6b91f765aa189e283148517931ede0f19552c945a341b1d693cef0167ebb382933fdca1e9d5b5e2f0d881ae1265e67e39793abf652b2df9813951d4335d988670ffbc2b9c98ebaec716d13d221d8c448474ed813c1dfa3ee8f8bcde51792e87f797a4efd8003ecc9b274d0f8693ae5657629da8e12468524ee8ff1e6790df08e9af05b1c6c061e6a24cf952baf4ce54400f3a1e223c0c181ce974eb413664db47bdcd62a0c368f8d4c2eb457bc5e7554b00e9da621805d97f677202390079bdd8171796dc51b1adc27723ce76f4fc1977b1b0f882599c8c4a1276b990912003b2d2bc9e8ef995bfc3d2993783688e1d7ff53eaa16700a4fd150340f84630d1cf90f9da0c969a4acda92c7c7adc9bb3f0b22b74e956fcff9005b059451add0e9097843f43e980f5cad9942018c6a801f779f04721d6896976bdd2748b3f2b2e2da690214afd6afd2172ae29bfd6b071ce2d693814a79ae083e9b1dad6474eceb547cb18d55d24f98e8d5a343690a0ffb96f7f3213eb1a11a7bdd6c377a2d9e85bfb7d09c53a13640f0417bd0366b31f482c2d8b558ddfb3ab4e6fa99dffa644bd693de9204a1b61e0ad790f83ecba5d445b3ed1c7d4a686d2ab014eba7807a40a84fd39e5a7526a9eb5be1ca254b02b529526ece401aac1899f6fb8c9eb0cdc5092b2208368baf9aae501283f8e7023cba4f17bed1b6bc52c8cde3f84faec6fc1f11fcd1f7dd3c6099486cc8f6cc7589ff18a4fb7ef203f6fccec16160d9197ac419e044d3bbaa2a42e03360585ef383c4b8c8c1025b8ce9cc99fcd3af5f0edc45409d5e3545cd66cdaa1dbcfbf727bde4141d2e659a7888ffaf73aaedff9a79bd5e89a28f4fd692da3ff432d2250774906b737adfdb06fb70bf3f6d90cc3b0b2735f66a005297eab3e3bcef4299bd8127bc8648bf35f4f8a14766f1921985c939799e2dcf04243b142e21516b429111ec9472ebcc9d082ce72ad41dfd2c887bcb86c31435564df1b397897dc7bf5565a1d59a4c7e3a1d5e28844a3c3e98ee11cfac4e91daec761b796617b092ca922725b09492b6bdf7cbb02f327875d2312cae9f312e18472e3efe7497a3ebd4ec105bf6cc0819beaeb6befd4d23cef5e7070d3e6efd79a64b4db4fff8726cca73e180c822497d0a23a1b9802a90447156809efef25cbd7414bb945c8dc78d5e3e531e4aa93cbb12b1be227aa6c9b90538634b01a50fda8e786619a4c4eb1717726f8365ce568f83831fef3d70d1a1bfce193b48593ab270c0ae156b2e4baabaf9f0fae96d0075a59620e9ad574570c1f22d3fac28a6641bd29e51d4d1d6bcfdc684c1470de7332728a82f910d524cd3b89eb568eea65899067d8e2d41a2b6bca64871bf53616ccbb06d50aefcebba942ef0d793c3e5827750d5c18017eba0b8829820beb3e8a938d5b2afedb984469c93dff63db17569bfc9d34bcf1f68d08ee24c4310ce9730bd5c8b0ee84a0fa6bb5e9fcc0a1dbc05de24c19ff31713eed55a672f476605d310190dbfa313c9c7b39c41bfc5727dc5063dc0f86cb5685e721faa85e42bd786206b2f8be20848813ace13afeac10a6f0a5cdb11b67fdc6db81165393bd4efc21a634450bccdaee378b71ae9e3a83a21a6b7c5d8a2b797d9178225c1e3e0a01905105ceb8f8a36faf0f7a7b93b695aac546bb7354ae0596e9bc49c1504cc2167ba959f58b0a2be263072067d5d89311f005fbc146823e9f10017575223c9342757f6eae3c00289fdad155f5d5df87651ed2e1d1ec43ad3abf521e782200e8a2438dc6ad400d549f622ac6dd0f99d16cf5035fb61457be66d1c7977420eac767edb3ee3500d072b04cbb3481be845ec09883886a8a0660dff30f25567abc2de05778d22797b4c1b2588ce383f28ba0c6cee621fb464c5ceecbeddef1d9a26f45046d5332b33deabdab7dc2e07c7732bee25f6b9e72e085d8965ce2a555a8b7dbf728bb85581120e16d4b4b53d5e8bf8a07d6f97010824e11b24a8566ad4d1075988aaa494142d3fbc9e5b29866b6c0090006c5e7a21ad534d5fd4fbc2abf5646b3cd3fd3f3c321d188b608cf6b6657839ae7a7e124984e7aef67a99c939eb3bf3b568583cf9ff13fddefbac6b63d4e1d9968f0fdc223d16046b5adb631c890c89ed795dd351cc51144872e57c750e7c01626a81b36bea868d80d319a4d0eba3de56c41e706ce8d0b7071b130bd946bf5a7fd1f0777b6c7ab9f03daf3eefa62c63f40cd65f4dc4f957acf9c4859819991cd0377370c58a71b2e78ee082e20ec09fda691290241f722c0a54126906b971c18d7669b7956d0b20cfe454f93d8849230340a99ea23b7f07dc7586c293dd0a96f9c2c9731946542c0b39a8bd98f77fa3f3cd1f7dc6af9786297300e7b0fb2c9a46df02732d761443ba36daabb8dff1b8364738b65e4ad6564b9802100c9100cb6b4c3259ae7db00031da4d7b36032344a166dee3867ae1ae499b89ee270dd5e87f421873012e2498b7ae63d40f68a123bdb238192653273eb360d852250024e24717037770454e23046c7dd84f980d76c4a0fe11ef4f02b9435fdf3378e2017f62274933aa23608f9ac426d9aaece609745c71465ec8786d4e7d06a91b24492f9f98ca43703f0c4fa97c076e0f5ff46036506b4eba5ba7a267346dab8e1a9462c956e8f4c3782c1353fd5584bbebe9ef40f92c9e8fbb28601b1138ff8a380213b672f4265018ced7630b5121807ba5a9dd2ff1086f7b70431a9f229f8695d6c66eb8b9fb83720f7c1f6c3ea50aed00ab3247df979288ba6185d424d5548507d6a73fb8169b1e17dce927e0cce71323ce25bc45b2d7ac05e92723ad357f8c90abb6a4b96edff1a76941f2c24bfc577d5b7d15d6250f87dbfe063306f19306d0ed329fdb6e5cdd6d6f6f21e019e58c3ffec8bedc57036ab69d9a0e19da5c1db8d0c6ac801687ed617da94f85161d10868a277d9354ce1e7aefecbffcbbcd441ca9fefd36646b28ac5ce2d9aa0624a5501bd8c5c2b2ed8d1c89ecbe58bd0b373b08e42fb222e7c4ef4bc8061e3555734267c07474b675dccf9156cd94731604d06f7cbf5fa22c316920fd6448c935b5e5663c95550d0634c200656a040ca293fbdac3e03239e0c6ae4b1926a16029d3fb00bd595e8e835b02885275310ec28b52b98c5c079629b8754a14dd4d88b3fea948dfafb235da712a06784391d3bbb9018d0054427c1e92266e980d876b25d8d8d3e163a9e5812e4fab120a2e297d2facc6512542b254682c8dc7be6bd1acaa5d917321718f2a2c424b3bce4e157ee4426eda54e21ca2d35f6b38766a7f684d39f8f3b950c368ffb33a08a7533769cd77199552d773294cec13050f4e7f65b5175a54a8591b079e9bdb496d597c0654700e1fcf3ab5c9942141c7be487b1d57383d334be037f45020885cfe71e4360aab5cf47b124f0d3562770f0106f2a66f0cd7b5cba869ee27ec6af4d613ea8a86fa99ea78bd51f55e8951afdd380d2a3f7ea077e62b215d7871faff18d2f807f6cecb50c1960c2a801d7f0436790877d1f19b708a183b3a949e35034640d38093a89fcb7fd3badb077ec1502187f4a110f26c69a118f4dde2296f20a7c2d444200e3b00b312d8863e478fbff8fc4f9a1f792c2edeb4f73f9a7c7c9e9ab4dcb7d7f5a39403d3b0d1945c2af7c80f54ff3eaab8d7ee5ff2b669fffaae319e6f4cfcc54f6cffa715691959e3504f3349e90d6f04ef7bd0222f57f11c912f44744c2ad3108da304995ca7d9bdb383b32a8110823d59a62bc32d610e083bf49560d76dbaec82292818377ea5ea68ed76daa15b2bfae09d1729b44adeeb45bd4709cc306e31953c74fb6ff05757cda9b0b422746b1cca7fa67c290a8c50a83c242f0bdf8addae3dacc687f4f8a89fd9077590634f984a1871aafbd9f2c35b +8ee6126ec5a994f4b4a866cd58752691871e42d974111aa0db8a00155f8b4fb6 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 +445539b87c5ca9894e7163cdc6f9ee214e6fb105c6988d39dd1a3995712c9d31 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 +5691e33a75b6e6bcf741c8995fc74258fae47ed350074912c74e665955409612 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 +9a7dc134b66188eeffa0793e0b2ff1fc1ed6c438be11e91a0311786a83ea432a e691e8feb744957b275e5fd879a3abe54d6d6c8c7f589f0b1a17c08c299c559e5f07c9eaa12b3dbf0e06342e6344229e9931217e77f34b53014577ab76fbee38ec3f491e7e0a129500beecae77745f98370cf6d4d0e39c4273aef366b9bb28640ccd6b11b4a7ea7f4be9c5c9ee529d0a1bfd1450b5fb9190c1d8bbcf1b80336c212992d428c200b5cd34ca3cdd75e175997ac6181e3d4972886fc9d41038b077cd1e786ab3ac82c3c8ad6dd5d01effa39629540a3d6002c9ab63a183a8a85b3bdfcf4d817f6505c7747abeb763dc78246b6f56a3e12e1001520f5d35c8e3f251702a66de663c9cb9c53e0584207bef86ecd046979044dee55e2639f40a4d0520968be443c46d71f9b6c75a82d8f7cf05a0d4a1a897e6b57c93922a5f82e4e7578612b3c68b7994d8ef2f85b35bd0dddd149ccdd8c9084f6f8ff61900fe8cbeae6525dfb8209026f6380ae677263b1d7ced5f8b2b0b313466966995a7af768a3383215ad8327707c8cb2656dc1e91902806b613bacb93d04b1caaee759b97d7d13cd0770a20a3f229068b28ff36c7048208a4693d4896a9f12162f3dcf18e97ddb84946fabd8fd5039f6ef6dd09540df8d5a6b7926cacba509f985fdf23a1f4eee5145d13d7d0e3e4bfdd1809a3918cac7734609f6c3f38bebeea3ffc3e4b4a8acaa1387440c92d1ced43511654e95b33b56f988dd43ede143afffe3b6e04f4b38b593251e0fddad3d26bfc1b40c5fe0573f010671ac3e3e6210e8799f256b153e1d95093bd452d70968ce651c7717bc935bf2fb77c21029b6550f535c3bdf804e7c2b1a5728ae231c005e31913be6aea15bd90491f70cdd222a548c3f38c7b2cb454b3b550699f6eea351a5bd69b97c2c823acb21f48a52533587b3b2b51eff4f453ea66a1ec559f11c387e7b5a111c7d885bfbb557959959aeafdac8693b22dea0cd30454b2c4b1a07aa64e3df3e4a36fa4666b70e0744f245dc0161ae2cfc5cd0f7a35e67651549e86407cf8d2ef259bf65ee75f2032e3a0d3cc6ea8eaf5fb16563671ae9f1185fda552639083558dde883adf86cb31bbb8764bcc096df60207e37cf5aa87e0d3565d5510ff0ac9359af6540c513bd3ac35f1829c5b342e66ec78be0356735e0ecd97d20f854094d124cd918a3bfd045545b1a7e17fe3e10eed4d11f8aa1b0e33285c7837db7033ac0d712730c0bce1c38514fd02985f99b88a20057c9781ff0444c290a7e0645e17d0beb2cd3a458184f6b4b5e100cb0d69279a9a185736e7eec42d8740e63d5b261cae061b54183e4c21994cfe6cd5c5441d6c3d2300509a40cc2efe67e63d0e1966c781bdf546e9e917fd283cff735b0017550b5cfb8b5ab22adafcee1e3ec19e0616dec2e5e7b45c2e547e48425be27123aaf91b4468b4b1389a095b3bcdc2cfa403b94231411ed835694190e54539f9126688f6232ea13002253e937e508c00165a3ef523621f06fea1440b81e8499c20bd2d817422b48f8e83131e0af707126ccad03a23237a4ad20353ebca6af49f7e8599b32b708f9c3bafea0a7be24c227fb0866703677ed85774f1069665cd8ef88c96cab5ec3f5ceb4cea915361dec906a67539abe4127954fd53b2d734d58f84e4c2e6e90cc1958c20b7080e6e067032186f2b38b80edd45fdf1c7f10e2cdc0f0ccb734e7cb286a97594b6d90228911379ff4c6174b9aa1c8b291ce061a97c82add414f551a1eeb9fc89dbe645cf82dec048d6bde94835d6d476f6e5e08e47616ed5766cb369a94d51f2a5f03e5fee943058c09dad21e08b822d7f51be5296dfc398b141817f5671df7b032b5c4bee779b7b5ecfd228fad0a6f102ed8d7a620fb0c6e8e84a020948eecb10fa27eedf71ff5e11d0e1a2da41be4029472cf6f26dd3f6ed6e4a5a7fd441200dc690307673ff9bbe81d71649680e3f62d62433ce3496269507aa4af5b1e002cb01cad3ae5080b152d5ea0c910376bd06e4c63f72af731721e8ae38e91756d816a46830a11ccf5ade1218a0301711d4889a90cf0527b8c29911cdabc832528d93b9ea9d80ade81b5a1b8b261995ccc4823b09e3b4236ca9bfcf0f430390554e4c3b3a0ef0fbaf130778ee84420cb24490c5863ce5f3d84a46fa4dad06a99ec00a17656b4c8497c5ddd4518ad30f929a1fc4f21df78f87f99fc1f9d7528e63152a1668000776da4658d3181d259903443fb9aa32d5e07d3f2464bbf241cb2fb60cd4c6a93de4a6a93c6cc48df885a8a8175e1a3805adc539c1c98e1091a6b5dfa38eacaac4ebd5fba707da54125a3da9bc1fd1be01e9be53426e7415796ec7c5673bda853b9a9a42fb762a63943d57f6554764a33301220af0ff6648f8709cef5244add70544586b033754f90ce00dd9b3884e27c25fd032261d57320cd8dc3435a22710569b22f95eae3b98ef5ba723c04c49d53a8740603fda4551a52716aa8bcaed8e505df7abf6d85383b9ac93f212b7110cc9aa680221aa148757b30185e2117be1e31d6a91cb0d4cbaa397706bd1a9541a21d38a42b9c86ef146880d00ecfcb293ab9e04d3b4bc12be7d35da30d8ef2baaf8684c07144a3322d355b993f1967bb6bffaae163631c4b7a865ac7c1be3be4b995b6c34f96a5e04bc54bb05b6cadcb6b82849ee9fc0b4a71972bbc36a00832b52b46ecd27117c60abb0075e438bd58611ef61b4e5fb16d58e2c3481ad2cd10002a7929d6764a11699cd1eafda718a1524c6bf18d9fb141fc9cbe224351c6b693316aa81fee436a30798b817c7b01787fb85103e730e62341ac2e803ea54506ee36e13c8de2802a84e9f5562e8b14ef55496811e2c1732caaeb39b030d752176f40b95cd5d5504b055e1a96e8cd190d956814344823f3bd57b5286067cb29a10ed94288ee8bc1658201571c15d79171a3feea48df6d1753f9957df79d7671e1697f17be08cc02133c96f725a2f67d6eae26dc67ff83324c4adb4e11b732513c7c46f8142ece31568c26176326fa4df0376b015620c5adf3c5ead45e547ede93e63f72187de806681d6f69cfe7e03cfa4cc9b39f6f1b6a3a3af90f5050a8a836b597da1a0544c2fe8f1ea7ffb27784d8bb8d8030072947beb283af708febcc00e1b3708b64a2019d01673a2b57d125cb244e0378fa8fd9c36e58e5380bf1b8e2986b203f090780c8d2efabe0c8204a6a86bc228179b165a6b5243c1a024a9a4fc2b60ce150ba1120be333b8c753a6193d3dd24fb4100b29f9f5e0cd41d7a15d5fd4c6fcb11eb903c57a10d264e0fae632526d0cebb43236cfa2605f8028a4d504a0650358f5f5bc09fdd7bd31919c2ad1cade90cdfc5d911691eb16d95c6fa0441f0294592a7565203c651c3057d9857cd1709662081d8c0b9d60625f66d51ccf94603eaa32d1183d1286b2483d251d4b4b16de1647e4bafb560e60f7c7f1b2897b450162d3fd2b491b38e1f42ead2ba92ac5a0bb517cba1080ecfce7261045152570c98f43494960772dd8f2601c19d22ccb586a6c7268af934597a55c79b30fcd44f9859cccf4f04a8d9341a20f9c240bfa3236a115ded021936bfa3ec90194dd617fb2d73ee30cc39e7d8db94edac85dd2479b3b1dfaaad2ac1c77db585586da142d52b0bb48540f4648281ed4c2fdd2d00ddf7a38096bc6c6842038c5a6bfb94edd676a690abe8a82d36c530ade04dd73f91218888d678c80bcbc530c886f09d61add7474be8153bd95a25f18f8b0c7084ddeb3b32a295ddca56068fa5a488c1a6949f2480334a54561d81bad1e63b92485a05786cdaecd5f5731fa72a69b69e4706180d01299ad26a7a07359f9b5addcafcc56c73f0b3e3a53ea8ef35757b39b46aac121372f50aab7ee71da1db329e00d5977c244255d43ba5232701d792534f441e2fc6c522acff45ee18577cf948d780488f5ac4c593d14d9438ab10f04d34b6cd118624c931e85623b4a7f08f844086882edf0ad22fb1594511ab21c79f476e48bdd43212851921e55cf6c83ff3e8fb38d17182eea9203a8d01fdbe8dc76fa8b88f290a25e0c46eac28ecea44cf436b34af668298a4b2911fab6ff585f175e8266f9e8709177305a81101cfc52b3517cbef6ec44b1a27d32361463864e4d15739d85badebaf7c2f58fafa8ea6a6d37379a30ca64e44139c68512d2713aa700c6ff2535b8edb795f6e3c46829edd1cd342fdb0dddf2302a1ca593b4aa3956573d10bf2a920b05777abe2e72a313c26a4ea385237e0f0b3fc6039c4ae5dbb055a4945ce74cc90627a5832c82d7667cbcff0d3cb6425d2e1ba479d928576bd46056e8af0c3b0aeca0a944858c97c0e64822fd3e91c2b763f888ef4a659bbbae149fc4bdac76ab6a507ff2d5c604719b08cff84c871356f344294fdadfbd560bba0d1eefb6442fc88ff1ca10112031d3046d6e83d02cf9e8f31c5918ed87987dd1ba2ab8731126ee506b03f85d6f9ffae34479c6a7d2d0facab8dcdbafa9b2f02e21c666d78fa034893f2d1026608984d68f9333395e0bf195bcaf7f15cb122419e1f2bf3b3e1e831a61e27336e25eb6480403c90980bc597e87b52cf5d0ff7770355ed502810d265f3265241b75fe2cf37fe0d5acc2fd3758a0414c4798bba778e2452dbe86bf9e2c7a3a5563019f60ddd5344f29ccebdb9defbb60c6c0f503432d76eeb47fe36d637a673596dbca4e55a880fb28f4cb8193c7a40844309b55e4c010faed3fae05d85648a339b47d5ae3cd142759f6d009029719f9af5f81c88eca88edd4372c7a827ece87060f2576ea82389a5f3f3ee51f503709b46a6d3b7f2a97fedc9bae4f156a0abdd77444dd5981a9882e5534ca71e315feaeca7d5d06a9f74b6f089c3607a17eac3a200557666817db7efd524bf37c58ffbfb0feae9d00f78d6eb7240c87df54d1774f87be2dcb26c9f0ac70b85c482c672051ea0020c24265cd97f265ea3e2db3c93fe14db832d20f5bca7f0e57a3b7e438afbdf349215a8d83b6dd80bf2997403de350bcfa832e2f393b434ee515b46e4125039e0ab05b7914ddaedb87c2c0a5bc32b2de4568fdff238c9c39408c604ead6f4c5a24a7c36d96cbd897cc38bf600d51ce093b71c63a1c8c36f45730d18ebd951a6ab74b014d915eb2a951458cbeecb4512240342a83c58379b5c98664202f783453b8c8cab89302883195 +d397fe128f9db7ea26857c8ef7998367aa040139e5a3316b54729223ab02e7d8 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 +9d3bdd478b0dd9660f67af07613e1a5515fcf2769b8e3e78fbe95d38eb9a4d01 86a9e1ce8c1f20458683cad72cba1a63789e61f8cbd6a54343064d72495a8c686a073a819dab8582a29ed75b327f02e001f64bf54d4c7a42df210b5fd2e225607289ddb67d002492ec0b2773e86097e631709ad777e9a12b14e6fb0b27d7a6b072a0cf1071365d04e7648470b6be00d588d9378c8e1af2f31768c56daac4282bb3911969b381371ca46b62f3eb1f50df99535c00ff523d781b2519e1bcfe4309ae568b1ab92293fbcedcae52b1bd6c605bd35ef6330a61adfd5cebe62b78df1c95168e41260b520b76c40cb767ce844837cc486e66a6d6892632b87afd270a965352eee8a8d234c566bf78b5390d940948f3dce2e973d68656977939a787916922ccd949bd41a0640bd44a33cd772040407baa11d95a6f2ef18e9f2974f1039c63c14fff476d976ce57cae6f2aca0218aed385b6d91262977d23e5a0ac9fffbda87c54c895902465bac9c5c6bb3e10a276c3aa7ef902b2ffebffb014a77f65383a277b10d1ea736b6d8b845408251046a1c5548f718e948e290bc94c86a05e030d7c0183cd2bd3f3166c8df648fcc3764ab9c27e77f06ba72de87c79cf7f8d6e83a8d5ce6287d2b17b9e7d90b25b9e757beca72368f9909d8935179524c136b0ea3240d4108265558944d8e77701ca4f187bcb48708f4c015cbdb81ddb09cc6afa46f4734f7853b1409413ada5d5584494034f5b4517fa7de3dfc07531cb6fd213a6874c212805df0c8dae74969e54cd9ac4ae778aba8ca52619e379ea17fd109572f2dd38c031cdf58de8f00e1e5fa2f1cf2ea39442116fd90dff3dbc92cb52afae95eb17535d48415998f1235fd966499faddc4135b269f6db55e392c0d0b50e2a94d53b13f220567729698f4a6465efce138a5db3aeca6ea2da5a4311706bb8e3ac2fef19cee75877151898beccf75b0555347e52c571b8c0001acc08c3bfe64fd455628dc7b8bfe30873760306c548acea0b7e8c6124065a16b04ac50998bfa57fa1f595df8272a0cf7d4cb401977f048d9530e5a1e5cadbcdb0a3d524b6ceb7d16b5d62725aa083b55ba595b46d68310edf2da3d6e0d50d87414e6421c6c31f51fa56bf9b46ed5216549e2a2e0900eb2194fd413a40e5bde52a85063aa11e51739f7325e109e16882b9b8e0e2df04727fb3ea6c66e415f2faeb65cb02db101d97b47932fcde8f121051363ffc17debaaf557de6314e8baeeda9d79cf7cb612ba87c7a2910a72ba20edf2f6927cdd6d6792b1c7973a604b7ee9673eacfa9c014fbd088f3706cd762727169bbaed092d80c75b47cfff0c6affd8b7883d8a8e1fe97ff1ff6e6f39cb47d876bbace345e205900eca0f6a193c1150748c2c5ee97ea8820b846ac7af90634aa62cb6e9ba39c5d94434e9da3a566ca2a089927aa9ac9a5e13f2cab624f2a7277ca415fb3cf19cadcafe6fc586e0439bfb120589c29012c873d5ed751e37727f867d0fd4e2dfe3b3cd53995a0f4269a3db407f5ace9fce499983135fe2ebc48cd7e708680444afbbe55838c92d23bef0713a9fa381789e760fc64aba84548461f62dcf93300bf8e1f0de9b1e2fb54f3722e0748802704532a156367984604b64eb400559e907c1a2ff27d3d91c523afb0abccc7575de30c1aabcc4d0ae4259f0acac4b2eda798970e4ee99c39c09e85ac281efe136b835eca8fd709d93c138e2c32e3d74444af0cf0146fa8e90c25869edb12ed7fb87cf170b65f203431f6c74c982fcfdd6a079e1487f1a8f2f1b2902564031a1ecefa435b6e6a6f61bb1a8b6ac55d6e7c8709291f1dbf627ea1565f1b834c3765ce94a3a0e012dbe7d70146ada1c74b08f21c38f05c05149eb0e7a6cfe7c16a1909cc3b5796768036813142cea62cc49634e07ca2fb27476019d3f5d32670ad88919579b91f79126415896bfe30e16b82289d8bc775b5d1cabf9ec28c4cec19e6ebc91e40976ed3c79b02dbb257458b84cd256cfc559e5be5b9ee9ae24270e10448d497923a71fe428f13fd1d9fbb49f58ec62c5bddfbd34276872bb3e7d55fdd1668f8856cd04b4f616b7b21e2b4eca9f727903d935a8075ffa7f388df6a89f5eeda1de46e26275ef5e5cbb60a0a745a38586fcb5bbd48312e6a665558cdf315969c2778f270ca2a2320ab4b99080a008c56e05d7baa9e82fa53b0463d74ce409becaadfbe45a3665945bac2188d9607def5546bb895e5ea89ea1e0f77ec533929a7db48410eabbdb346a309be64dfd207dd20702341f1819faaf938923e44b041f1127679549e3bbccc5f8f6ec7131952522166b5352420cb210c09c20357ccaab709628a92f57c92a21c1c9a7a7f4f83ce87c6033305814acc8101013760ac25dd61148ad63f8b96f1d629ee5f42a09ec413593fa03b60e3ba22423413320c674a8ecb1afee2d6a7b0355eb8915709c1d4a0b42741e2958988ecdc18abe89ac555543bb9aebc35243397f9a3f7a53baffee6badc82d8a5d58f20856219f28d5695ee59bcf14ddfd5b703d93f371cb608fe010dc96688060b59c185b043dd8440558bf6975fa7b7933350fd69d70f9c9c1b89675f4b08ccb7ccf67ca457ab338f744ad9d5958e8ef51f3203f8d70e05c208a310ad2ed9898b1601ec3bf5693b020abd7fe2b5019901b11d7407f13182311cb4e7e2368542106e03b5b3b864a42649485915b2584c62feae05c047b1ead2303245c3450d7e872bf3d3a65d9e6ac6dd623d53f879000a3556d46760d0548a552b83adc917ec8617e953f4d84064e3a48a795291240ece56dbedad22d05c78752acdd3b5854fe59c217efa6f538d15ee1a78b5c4791b06057e593b3bb754aaadc08d71f7913a2202d53c8bd1d83b2142de9b70abfc0436312c1c59193f63e2d209f1d5f1f81fb4e8fb134f656887a71f68c07323fc534cf6acce144c4f7c7c41818b18e76e15c1c0258e5bc63887dcea5f99738be85cb1f4c9fdf1faebc534ae8a285c80f13b2e208c5fe4afbaf5f6c38ecccbc8b1e9afdada591247ba07f16ba9e4e36f940e569834f1f80cbca9ce8e3edd4caf4d32d37ef45264864b36a29e1729b2ab9aed0c450b45f9d600e773da9d6c5f780055306eaa6d19e7aaafa8f41428247360fe13bdd873bbc749dcb509b02a76e79e2f2e528e4f381b7bb3ae24b26fa32a21d7723ecb9853c1b606a54f14b881bab00c2231c770448656151f7ed9e4795600122c2fc459c872cf53e80e4241220882054708ca33b2f3b4f21fa384884c810512ab5eea4b6612d3e4def6040d9e5f3603e6eac73c73cb79cd540435ada4a5d9b82df4545b69ee0f4840d2954e023b48da0444564fa3ff4259b7d8a20fcb66241c6f06412669cefb3c8b9e9e0a83e9ca0ac744ec7a26d896cd43e994588278a56dd5827e2539b55f8dd9f121725527b07623d4876adedecbfe0b4bd41510bd30e3aab253098844c60a0b598e69db2e1cddd77a964db8433756b5f954453a2ae8620fabe6737b615dc4006d03327df04e65c8e80946d9fe5ae5ff38a58232eeebe85797a0d332b55b21770b10015379a9a5294404f4d356eeeea47c129e40b6014c19f84cc1b96e3445935aed67ab3a1aa53dba570aa0f29ba19b2ae1a6c48e345f39a1e1a28b2bf637723eb708d989eb25decdea9ecae0b2b2d93fddcc68377ea3fcd2a9386b0cec6893bc3a57867b2e48201a6c019adefd0f05553b0554b938d744872d061fac649a68d834ca52a4752ab4b36471c5d4c65754868c031fc35d8050e50e803960f8175ff0bacc08644b51d316dcfd9982d076a6a2cbadf7006167fabc7753084b7f75c138b059f145a668c59957637bb8f7abefb8922d509fefbcdd357f15edf1f62bb16b94b6a1e7b4e353256dbe17b2a466e6c4ad72d25a177ac333be505db8bafd9244b5068ba7d4dd283ee08459bd47b2276f3c25dac5d7001ebd0e8892bef4f0f17272dbc70d15b626e3643e1664cb7bcb5cb6521c0cc8e2e08357ffc3a329c72dff9b4f0009a3011931a1630020ad83df6a803dc11deda448260206475fd7b2d0c4ae8057ee9358ac8efefeadd2835de0ee6d8f5a2593b7ea0bd5f8a7fb0d003e5c175e4080ef77fcefe8c34fd09ac0c5621e034ba475de9dde49d2d80dde836e6a75e9b257e46373ac2cd1c81f8898cfe8b2dab05d35c404477c13303438eadcd2502ecab5689c3b0b01cc6128d27784bb283ed8888b204160361dae14aec97cbcd81a9c1cdfb372a543fbe7c0314613fa7a1149221a169f58f26c0f0086141292b10b9124d91123d95074e53ea029801e6b187e5d28d83ec90ad51c80d9b350813cc019c7e5a2be39bfcea02bf08b865e6b31c302f4090166ae3a624f19a219dd7e6ecbb29578bc96a919e04b650d794fd17c81ee27ae97455939727ffecf7bf36789ba34b04e8892fd2236d6402c80884eefc9388de1621c746d663582305b6a7b3e1d8854afd6339785769d4abe411b9f990a42a5ef9b43c8f5c459d50559f61690d7816d43ca9b15bfc4c5dd5a2f520527729bb187c14cb494885142bcce3d9d1737ee57518a1cbb8e9194dd9d27276e875edeaec931b1227bda3bec2f7c3f0f5690c5de5e9db8aced68b0963d35535e6f8962ff45264b0112b88c9bfc9212027de6468e86f1ac632d4c8b264ad1eefcf2f5971acfeae6b8925617034814cb3c9610e3b34284ad38fadd07def491ddfd660f4a54880c6b71d9daff18b5ae53a7274aa6f62c9abce4538e5cc76e9fd8b271778fb8587f154bfb0ed98e20a4a5e58d21c7201e70d268a744fb9daa1a3dbee501c6552ee5eb7e98fb426decb5db8771f0d1e8692ab8fca7b62a5b14093db30ac68518cf728fa8757677b67b95a732d8317d47a615eb6772817e89aa523940b9b08aa503e74a5d755e8c267480b57f398bac10fc8717688d23a737822f7a031a3e02993896c57324b0c049e0d0a3b6ec32bf78dc16d5436b10a3988112ac87aea164c0612dacd8fac6ade09eaa14b443524dadc696570f8bb9219fda4af04ddabcc83bec86a4e30788242337c17d721db5fa208883d2f00af1d1599cd58d80dfeace67f180ea8953f92c16bda7e620312cf4599b4807a705c50354d8dcdc2d4b518cd66225bc9c90bd3383163b24eff6de768eabd77e6ebfa2c2edaebce46e58ed8b858b55ed87fb14e3489ba11861ed0434d1c3c4d2090d28bf72ecd252df9dc34bdc41dd409049811fab93254b2395271244772dbdb594e2da076906d0e0f85a025b2ff3c6ec1088c5c37f85b92f6ee7db41f7c867e35b1aae99a4e6b60f734e01e5980b608022ef2439d582685e5e1232b25c71bced4a91e3aceed3e6a1488d8b582d10b7971e9871e5ac2e6936ef2d55353d +dc6f64709ad3c35a8ae4390f94624e30de92fdac895ab7d611bcf7611e3fc216 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 +6e47d5567eb622e8a5080ab49ed4fca6c5ee039c83be6d5fde47ff963f61be10 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 +241bfaaf5890aaafafba9f058440fa9f5db47a3414ab4793056427a91b2298c1 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 +d0348a809144fd96b1c2b1a3450254befbe6c4e22f417e86ab913c7b1440d80d 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 +896a7e19a3c3f3533c7b1dbb118ee83e7aac8f23b516a0954f494bd1cf00a4c5 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 +bd1923ee52adcaf4feab09128333ac273dd359f6885aac9ea3a6d71d4208757c 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 +70ee2e3c2722f7fdb9e1460ce5de41c05361526a21f17f8e56f85c45c376598c 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 +6ce0fa1661a755da32f20aaa041125c3a0c57cf1104de60d0feefc7308526000 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 diff --git a/tests/hash/tests-fast.txt b/tests/hash/tests-fast.txt new file mode 100644 index 000000000..4dbf7e431 --- /dev/null +++ b/tests/hash/tests-fast.txt @@ -0,0 +1,321 @@ +c5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 x +eead6dbfc7340a56caedc044696a168870549a6a7f6f56961e84a54bd9970b8a cc +a8eaceda4d47b3281a795ad9e1ea2122b407baf9aabcb9e18b5717b7873537d2 41fb +627d7bc1491b2ab127282827b8de2d276b13d7d70fb4c5957fdf20655bc7ac30 1f877c +b149e766d7612eaf7d55f74e1a4fdd63709a8115b14f61fcd22aa4abc8b8e122 c1ecfdfc +67f05544dbe97d5d6417c1b1ea9bc0e3a99a541381d1cd9b08a9765687eb5bb4 21f134ac57 +923062c4e6f057597220d182dbb10e81cd25f60b54005b2a75dd33d6dac518d0 c6f50bb74e29 +feb8405dcd315d48c6cbf7a3504996de8e25cc22566efec67433712eda99894f 119713cc83eeef +e620d8f2982b24fedaaa3baa9b46c3f9ce204ee356666553ecb35e15c3ff9bf9 4a4f202484512526 +9e03f7c9a3d055eca1d786ed6fb624d93f1cf0ac27f9c2b6c05e509fac9e7fca 1f66ab4185ed9b6375 +caad8e1ed546630748a12f5351b518a9a431cda6ba56cbfc3ccbdd8aae5092f7 eed7422227613b6f53c9 +d61708bdb3211a9aab28d4df01dfa4b29ed40285844d841042257e97488617b0 eaeed5cdffd89dece455f1 +0f53be55990780b3fad9870f04f7d8153c3ae605c057c85abb5d71765043aaa8 5be43c90f22902e4fe8ed2d3 +32215ae88204a782b62d1810d945de49948de458600f5e1e3896ceca2ed3292b a746273228122f381c3b46e4f1 +9510da68e58ebb8d2ab9de8485bb408e358299a9c011ae8544b0d0faf9d4a4ea 3c5871cd619c69a63b540eb5a625 +f20b3bcf743aa6fa084038520791c364cb6d3d1dd75841f8d7021cd98322bd8f fa22874bcc068879e8ef11a69f0722 +0e32defa2071f0b5ac0e6a108b842ed0f1d3249712f58ee0ddf956fe332a5f95 52a608ab21ccdd8a4457a57ede782176 +9204550677b9aa770e6e93e319b9958540d54ff4dccb063c8561302cd8aff676 82e192e4043ddcd12ecf52969d0f807eed +a6d5444cb7aa61f5106cdedb39d5e1dd7d608f102798d7e818ac87289123a1db 75683dcb556140c522543bb6e9098b21a21e +5796b993d0bd1257cf26782b4e58fafb22b0986d88684ab5a2e6cec6706275f9 06e4efe45035e61faaf4287b4d8d1f12ca97e5 +cfbe73c6585be6204dd473abe356b539477174c4b770bfc91e9fdbcbc57086e6 e26193989d06568fe688e75540aea06747d9f851 +31c8006b0ec35e690674297cb27476db6066b5fa9825c60728e9e0bb338fb7c3 d8dc8fdefbdce9d44e4cbafe78447bae3b5436102a +3b8fa3904fe1b837565a50d0fbf03e487d6d72fc3cea41adcce33df1b835d247 57085fd7e14216ab102d8317b0cb338a786d5fc32d8f +37febc4df9d50daeabd0caa6578812a687e55f1ac0b109d2512810d00548c85b a05404df5dbb57697e2c16fa29defac8ab3560d6126fa0 +2329810b5a4735bcd49c10e6456c0b1ded5eac258af47cbb797ca162ab6d1ba8 aecbb02759f7433d6fcb06963c74061cd83b5b3ffa6f13c6 +6fffa070b865be3ee766dc2db49b6aa55c369f7de3703ada2612d754145c01e6 aafdc9243d3d4a096558a360cc27c8d862f0be73db5e88aa55 +b30761c053e926f150b9dce7e005b4d87811ccfb9e3b6edb0221022f01711cf0 7bc84867f6f9e9fdc3e1046cae3a52c77ed485860ee260e30b15 +04f1b3c1e25ba5d012e22ad144e5a8719d94322d05ad9ef61e7db49b59959b3a fac523575a99ec48279a7a459e98ff901918a475034327efb55843 +aeef4b4da420834ffced26db291248fb2d01e765e2b0564057f8e6c2030ac37f 0f8b2d8fcfd9d68cffc17ccfb117709b53d26462a3f346fb7c79b85e +03d26aeeb4a7bdddbff7cff667198c425941a2776922df2bec545f5304e2c61c a963c3e895ff5a0be4824400518d81412f875fa50521e26e85eac90c04 +435cfc0d1afd8d5509a9ccbf49706575038685bf08db549d9714548240463ee9 03a18688b10cc0edf83adf0a84808a9718383c4070c6c4f295098699ac2c +d477fb02caaa95b3280ec8ee882c29d9e8a654b21ef178e0f97571bf9d4d3c1c 84fb51b517df6c5accb5d022f8f28da09b10232d42320ffc32dbecc3835b29 +24dd2ee02482144f539f810d2caa8a7b75d0fa33657e47932122d273c3f6f6d1 9f2fcc7c90de090d6b87cd7e9718c1ea6cb21118fc2d5de9f97e5db6ac1e9c10 +e78c421e6213aff8de1f025759a4f2c943db62bbde359c8737e19b3776ed2dd2 de8f1b3faa4b7040ed4563c3b8e598253178e87e4d0df75e4ff2f2dedd5a0be046 +cce3e3d498328a4d9c5b4dbf9a1209628ab82621ad1a0d0a18680362889e6164 62f154ec394d0bc757d045c798c8b87a00e0655d0481a7d2d9fb58d93aedc676b5a0 +f871db93c5c92ecd65d4edb96fcb12e4729bc2a1899f7fb029f50bff431cbb72 b2dcfe9ff19e2b23ce7da2a4207d3e5ec7c6112a8a22aec9675a886378e14e5bfbad4e +4eb143477431df019311aed936cab91a912ec1e6868b71e9eddb777408d4af34 47f5697ac8c31409c0868827347a613a3562041c633cf1f1f86865a576e02835ed2c2492 +9a0c1d50a59dbf657f6713c795ed14e1f23b4eaa137c5540aacdb0a7e32c29fc 512a6d292e67ecb2fe486bfe92660953a75484ff4c4f2eca2b0af0edcdd4339c6b2ee4e542 +ba062e5d370216d11985c4ca7a2658ddc7328b4be4b40a52dd8fa3ca662f09d1 973cf2b4dcf0bfa872b41194cb05bb4e16760a1840d8343301802576197ec19e2a1493d8f4fb +3a083ae163df42bd51b9c664bee9dc4362f16e63383df16473df71be6dd40c1c 80beebcd2e3f8a9451d4499961c9731ae667cdc24ea020ce3b9aa4bbc0a7f79e30a934467da4b0 +4876e273ac00942576d9608d5b63ecc9a3e75d5e0c42c6abdbcde037785af9a7 7abaa12ec2a7347674e444140ae0fb659d08e1c66decd8d6eae925fa451d65f3c0308e29446b8ed3 +4797ba1c7ab7197050d6b2e506f2df4550e4b673df78f18c465424e48df5e997 c88dee9927679b8af422abcbacf283b904ff31e1cac58c7819809f65d5807d46723b20f67ba610c2b7 +41c91be98c5813a4c5d8ae7c29b9919c1cc95b4a05f82433948cb99d9a6d039c 01e43fe350fcec450ec9b102053e6b5d56e09896e0ddd9074fe138e6038210270c834ce6eadc2bb86bf6 +ee354290e3f9ce9123c49ba616e1a2684a90f3ddd84e73a1d2c232f740412b18 337023370a48b62ee43546f17c4ef2bf8d7ecd1d49f90bab604b839c2e6e5bd21540d29ba27ab8e309a4b7 +fbec0b6d71696eede900b77aa6d7d25f4ab45df8961ca9c8b3f4f9b51af983ab 6892540f964c8c74bd2db02c0ad884510cb38afd4438af31fc912756f3efec6b32b58ebc38fc2a6b913596a8 +9d24aeea08f9a4b5fb8b6de85a2296f5f4108ddd1eea4f8ee58819cf84edb765 f5961dfd2b1ffffda4ffbf30560c165bfedab8ce0be525845deb8dc61004b7db38467205f5dcfb34a2acfe96c0 +732034cae3ff1116f07fc18b5a26ef8faf3fe75d3dbca05e48795365e0a17c40 ca061a2eb6ceed8881ce2057172d869d73a1951e63d57261384b80ceb5451e77b06cf0f5a0ea15ca907ee1c27eba +deac521805bc6a97c0870e9e225d1c4b2fd8f3a9a7f6b39e357c26414821e2dd 1743a77251d69242750c4f1140532cd3c33f9b5ccdf7514e8584d4a5f9fbd730bcf84d0d4726364b9bf95ab251d9bb +ad55537347b20d9fca02683e6de1032ec10eb84da4cbd501e49744a666292edf d8faba1f5194c4db5f176fabfff856924ef627a37cd08cf55608bba8f1e324d7c7f157298eabc4dce7d89ce5162499f9 +b1f990204bf630569a3edc634864274786f40ce1c57165ee32d0e29f5d0c6851 be9684be70340860373c9c482ba517e899fc81baaa12e5c6d7727975d1d41ba8bef788cdb5cf4606c9c1c7f61aed59f97d +fa460cd51bc611786d364fcabe39052bcd5f009edfa81f4701c5b22b729b0016 7e15d2b9ea74ca60f66c8dfab377d9198b7b16deb6a1ba0ea3c7ee2042f89d3786e779cf053c77785aa9e692f821f14a7f51 +f7b0fe5a69ff44060d4f6ad2486e6cde9ed679af9aa1ada613e4cc392442beb5 9a219be43713bd578015e9fda66c0f2d83cac563b776ab9f38f3e4f7ef229cb443304fba401efb2bdbd7ece939102298651c86 +24204d491f202534859fc0a208237184471a2d801fb3b934d0968d0d843d0345 c8f2b693bd0d75ef99caebdc22adf4088a95a3542f637203e283bbc3268780e787d68d28cc3897452f6a22aa8573ccebf245972a +81147cba0647eee78c4784874c0557621a138ca781fb6f5dcd0d9c609af56f35 ec0f99711016c6a2a07ad80d16427506ce6f441059fd269442baaa28c6ca037b22eeac49d5d894c0bf66219f2c08e9d0e8ab21de52 +5b6d7eda559574fae882e6266f4c2be362133e44b5a947ecb6e75db9fc8567e0 0dc45181337ca32a8222fe7a3bf42fc9f89744259cff653504d6051fe84b1a7ffd20cb47d4696ce212a686bb9be9a8ab1c697b6d6a33 +86f87e75c87f9be39e4aa6d0c5a37a5964d6ffdc462525c0642c9db010de38ee de286ba4206e8b005714f80fb1cdfaebde91d29f84603e4a3ebc04686f99a46c9e880b96c574825582e8812a26e5a857ffc6579f63742f +959fe007b57c2947c36d1d66cc0808d80db7df45d68a34852b70d2dda192c25c eebcc18057252cbf3f9c070f1a73213356d5d4bc19ac2a411ec8cdeee7a571e2e20eaf61fd0c33a0ffeb297ddb77a97f0a415347db66bcaf +1a93567eebc41cc44d9346cde646005d3e82de8eeeb131e9c1f6d1e4afd260f7 416b5cdc9fe951bd361bd7abfc120a5054758eba88fdd68fd84e39d3b09ac25497d36b43cbe7b85a6a3cebda8db4e5549c3ee51bb6fcb6ac1e +549db056b65edf7d05bd66661b6d0a39b29b825bc80910f8bf7060a53bff68e1 5c5faf66f32e0f8311c32e8da8284a4ed60891a5a7e50fb2956b3cbaa79fc66ca376460e100415401fc2b8518c64502f187ea14bfc9503759705 +794abfd7eb622d5608c1c7b3f0a7821a71900b7172847fb0907aa2899972663e 7167e1e02be1a7ca69d788666f823ae4eef39271f3c26a5cf7cee05bca83161066dc2e217b330df821103799df6d74810eed363adc4ab99f36046a +9ce89958cbddd8dcb22f66e8cba5f6091a51953189464803bdc773abc7faa906 2fda311dbba27321c5329510fae6948f03210b76d43e7448d1689a063877b6d14c4f6d0eaa96c150051371f7dd8a4119f7da5c483cc3e6723c01fb7d +6da733817dc826e8da773beca7338131ab7396417104eda25970980c4eb2a15f 95d1474a5aab5d2422aca6e481187833a6212bd2d0f91451a67dd786dfc91dfed51b35f47e1deb8a8ab4b9cb67b70179cc26f553ae7b569969ce151b8d +66c9cdc8e8c6c9417d7ffbef3b54b702eee5f01a9bda8dd4e28fe3335debbb51 c71bd7941f41df044a2927a8ff55b4b467c33d089f0988aa253d294addbdb32530c0d4208b10d9959823f0c0f0734684006df79f7099870f6bf53211a88d +24ab37a93674ccb1ceec9e5681efc8bdf9fcc7721cf1cac175e0b20e461575b8 f57c64006d9ea761892e145c99df1b24640883da79d9ed5262859dcda8c3c32e05b03d984f1ab4a230242ab6b78d368dc5aaa1e6d3498d53371e84b0c1d4ba +574271cd13959e8ddeae5bfbdb02a3fdf54f2babfd0cbeb893082a974957d0c1 e926ae8b0af6e53176dbffcc2a6b88c6bd765f939d3d178a9bde9ef3aa131c61e31c1e42cdfaf4b4dcde579a37e150efbef5555b4c1cb40439d835a724e2fae7 +1947e901fa59ea789845775f2a4db9b4848f8a776073d53d84cbd5d927a96bff 16e8b3d8f988e9bb04de9c96f2627811c973ce4a5296b4772ca3eefeb80a652bdf21f50df79f32db23f9f73d393b2d57d9a0297f7a2f2e79cfda39fa393df1ac00 +0c1b8c1af237e9c5501b50316a80865aac08a34acf4f8bedd4a2d6e7b7bcbb85 fc424eeb27c18a11c01f39c555d8b78a805b88dba1dc2a42ed5e2c0ec737ff68b2456d80eb85e11714fa3f8eabfb906d3c17964cb4f5e76b29c1765db03d91be37fc +c4315666c71fea834d8ff27f025f5cc34f37c1aae78604a4b08dac45decd42be abe3472b54e72734bdba7d9158736464251c4f21b33fbbc92d7fac9a35c4e3322ff01d2380cbaa4ef8fb07d21a2128b7b9f5b6d9f34e13f39c7ffc2e72e47888599ba5 +5ff8734db3f9977eee9cf5e2cf725c57af09926490c55abd9d00a42e91a8c344 36f9f0a65f2ca498d739b944d6eff3da5ebba57e7d9c41598a2b0e4380f3cf4b479ec2348d015ffe6256273511154afcf3b4b4bf09d6c4744fdd0f62d75079d440706b05 +1e141a171cab085252ea4c2f8f1f1087dd85a75ab3acd0b3c28eaa5735d349af abc87763cae1ca98bd8c5b82caba54ac83286f87e9610128ae4de68ac95df5e329c360717bd349f26b872528492ca7c94c2c1e1ef56b74dbb65c2ac351981fdb31d06c77a4 +ef763f22f359dd7f5b3fe6a745c423d6b641ec07ba5235232a0701510f74426e 94f7ca8e1a54234c6d53cc734bb3d3150c8ba8c5f880eab8d25fed13793a9701ebe320509286fd8e422e931d99c98da4df7e70ae447bab8cffd92382d8a77760a259fc4fbd72 +6a769f93f255b078fe73aff68f0422a279939920e4690b4aff0e433cfa3d3df3 13bd2811f6ed2b6f04ff3895aceed7bef8dcd45eb121791bc194a0f806206bffc3b9281c2b308b1a729ce008119dd3066e9378acdcc50a98a82e20738800b6cddbe5fe9694ad6d +c06dd4261638c44afcb186f0af5de20ea53aa63316fbb71728f874ff3daceb0d 1eed9cba179a009ec2ec5508773dd305477ca117e6d569e66b5f64c6bc64801ce25a8424ce4a26d575b8a6fb10ead3fd1992edddeec2ebe7150dc98f63adc3237ef57b91397aa8a7 +b5d84b1809e83b5e75aa53bdee79e3a97f3fe3a7d3162ebd4908240ff69131d8 ba5b67b5ec3a3ffae2c19dd8176a2ef75c0cd903725d45c9cb7009a900c0b0ca7a2967a95ae68269a6dbf8466c7b6844a1d608ac661f7eff00538e323db5f2c644b78b2d48de1a08aa +cad7abb5bba5905b5181dd2dbc4e68cfd01ba8659f21c8290d3f835c1a68bbe5 0efa26ac5673167dcacab860932ed612f65ff49b80fa9ae65465e5542cb62075df1c5ae54fba4db807be25b070033efa223bdd5b1d3c94c6e1909c02b620d4b1b3a6c9fed24d70749604 +83ca09c1f418b5dad0a7f64a904a2e07c3314f7d02d92622f8f4674bc1f6aa3d bbfd933d1fd7bf594ac7f435277dc17d8d5a5b8e4d13d96d2f64e771abbd51a5a8aea741beccbddb177bcea05243ebd003cfdeae877cca4da94605b67691919d8b033f77d384ca01593c1b +330de3ee16aef6711461a994863eed47af71b362d4c2f243534ef432f63a091a 90078999fd3c35b8afbf4066cbde335891365f0fc75c1286cdd88fa51fab94f9b8def7c9ac582a5dbcd95817afb7d1b48f63704e19c2baa4df347f48d4a6d603013c23f1e9611d595ebac37c +b5675197e49b357218f7118cd15ee773b39bd59b224d9a45ca71c6e371d938f1 64105eca863515c20e7cfbaa0a0b8809046164f374d691cdbd6508aaabc1819f9ac84b52bafc1b0fe7cddbc554b608c01c8904c669d8db316a0953a4c68ece324ec5a49ffdb59a1bd6a292aa0e +cd9038c1066a59990df5752107b066eebbe672cbca0f60d687d03a9d821934be d4654be288b9f3b711c2d02015978a8cc57471d5680a092aa534f7372c71ceaab725a383c4fcf4d8deaa57fca3ce056f312961eccf9b86f14981ba5bed6ab5b4498e1f6c82c6cae6fc14845b3c8a +d3172ca263aff2b9db6fb13337f2543c5af51151801a76194012f710306c14f6 12d9394888305ac96e65f2bf0e1b18c29c90fe9d714dd59f651f52b88b3008c588435548066ea2fc4c101118c91f32556224a540de6efddbca296ef1fb00341f5b01fecfc146bdb251b3bdad556cd2 +9e3d4bcf580eece39bcf13e5716e5bb8f5e8c3fc3723f66246f836d8db1238f1 871a0d7a5f36c3da1dfce57acd8ab8487c274fad336bc137ebd6ff4658b547c1dcfab65f037aa58f35ef16aff4abe77ba61f65826f7be681b5b6d5a1ea8085e2ae9cd5cf0991878a311b549a6d6af230 +edc2d3b49c85b8dd75f7b5128da04cd76bf4878779a0077af3f1d7fb44f18931 e90b4ffef4d457bc7711ff4aa72231ca25af6b2e206f8bf859d8758b89a7cd36105db2538d06da83bad5f663ba11a5f6f61f236fd5f8d53c5e89f183a3cec615b50c7c681e773d109ff7491b5cc22296c5 +80dce7f04dd6ac17ce709b56cf6ea6c0a57190649bb187b5e6d95fa18100c7ac e728de62d75856500c4c77a428612cd804f30c3f10d36fb219c5ca0aa30726ab190e5f3f279e0733d77e7267c17be27d21650a9a4d1e32f649627638dbada9702c7ca303269ed14014b2f3cf8b894eac8554 +49bbd5435d2706f85fe77b84a5fa15ddd8259e5d2c20fb947f139373e5c86121 6348f229e7b1df3b770c77544e5166e081850fa1c6c88169db74c76e42eb983facb276ad6a0d1fa7b50d3e3b6fcd799ec97470920a7abed47d288ff883e24ca21c7f8016b93bb9b9e078bdb9703d2b781b616e +6b6c11f9731d60789d713daf53d2eb10ab9ccf15430ea5d1249be06edfe2bff6 4b127fde5de733a1680c2790363627e63ac8a3f1b4707d982caea258655d9bf18f89afe54127482ba01e08845594b671306a025c9a5c5b6f93b0a39522dc877437be5c2436cbf300ce7ab6747934fcfc30aeaaf6 +7e738e8eb3d47d18e97d87c7b3fc681f86417883ced92ba93c3077812bbd17e7 08461f006cff4cc64b752c957287e5a0faabc05c9bff89d23fd902d324c79903b48fcb8f8f4b01f3e4ddb483593d25f000386698f5ade7faade9615fdc50d32785ea51d49894e45baa3dc707e224688c6408b68b11 +a278ba93ba0d7cd2677be08c9dfc5f516a37f722bb06565fa22500f66fe031a9 68c8f8849b120e6e0c9969a5866af591a829b92f33cd9a4a3196957a148c49138e1e2f5c7619a6d5edebe995acd81ec8bb9c7b9cfca678d081ea9e25a75d39db04e18d475920ce828b94e72241f24db72546b352a0e4 +9c0a9f0da113d39f491b7da6c4da5d84fe1cc46367e5acc433ca3e0500951738 b8d56472954e31fb54e28fca743f84d8dc34891cb564c64b08f7b71636debd64ca1edbdba7fc5c3e40049ce982bba8c7e0703034e331384695e9de76b5104f2fbc4535ecbeebc33bc27f29f18f6f27e8023b0fbb6f563c +6bed496d02fe4cc27d96dceed14a67da7bdf75e19b624896dff6b0b68e4fcc12 0d58ac665fa84342e60cefee31b1a4eacdb092f122dfc68309077aed1f3e528f578859ee9e4cefb4a728e946324927b675cd4f4ac84f64db3dacfe850c1dd18744c74ceccd9fe4dc214085108f404eab6d8f452b5442a47d +ecd2e3faf4ba4dd67e5a8656cebebdb24611611678e92eb60f7cbd3111d0a345 1755e2d2e5d1c1b0156456b539753ff416651d44698e87002dcf61dcfa2b4e72f264d9ad591df1fdee7b41b2eb00283c5aebb3411323b672eaa145c5125185104f20f335804b02325b6dea65603f349f4d5d8b782dd3469ccd +634a95a7e8ba58f7818a13903ec8f3411b6ecb7e389ec9aa97c0ecf87fadd588 b180de1a611111ee7584ba2c4b020598cd574ac77e404e853d15a101c6f5a2e5c801d7d85dc95286a1804c870bb9f00fd4dcb03aa8328275158819dcad7253f3e3d237aeaa7979268a5db1c6ce08a9ec7c2579783c8afc1f91a7 +a0fe352ba2389b0430edbe1201032eb09c255514c5c5b529c4baafceb1ac9817 cf3583cbdfd4cbc17063b1e7d90b02f0e6e2ee05f99d77e24e560392535e47e05077157f96813544a17046914f9efb64762a23cf7a49fe52a0a4c01c630cfe8727b81fb99a89ff7cc11dca5173057e0417b8fe7a9efba6d95c555f +9a0bfe14f9f3127aca86773a620945731df781a6d7dc82930ccde2f69dac8f94 072fc02340ef99115bad72f92c01e4c093b9599f6cfc45cb380ee686cb5eb019e806ab9bd55e634ab10aa62a9510cc0672cd3eddb589c7df2b67fcd3329f61b1a4441eca87a33c8f55da4fbbad5cf2b2527b8e983bb31a2fadec7523 +19e5101bde60b200a8b171e4c3ea3dfd913e10111d96f9682acc7467282b4e31 76eecf956a52649f877528146de33df249cd800e21830f65e90f0f25ca9d6540fde40603230eca6760f1139c7f268deba2060631eea92b1fff05f93fd5572fbe29579ecd48bc3a8d6c2eb4a6b26e38d6c5fbf2c08044aeea470a8f2f26 +4cc2aff141987f4c2e683fa2de30042bacdcd06087d7a7b014996e9cfeaa58ce 7adc0b6693e61c269f278e6944a5a2d8300981e40022f839ac644387bfac9086650085c2cdc585fea47b9d2e52d65a2b29a7dc370401ef5d60dd0d21f9e2b90fae919319b14b8c5565b0423cefb827d5f1203302a9d01523498a4db10374 +9a8ce819894efccc2153b239c3adc3f07d0968eac5ec8080ac0174f2d5e6959c e1fffa9826cce8b86bccefb8794e48c46cdf372013f782eced1e378269b7be2b7bf51374092261ae120e822be685f2e7a83664bcfbe38fe8633f24e633ffe1988e1bc5acf59a587079a57a910bda60060e85b5f5b6f776f0529639d9cce4bd +8b35768525f59ac77d35522ac885831a9947299e114a8956fe5bca103db7bb2c 69f9abba65592ee01db4dce52dbab90b08fc04193602792ee4daa263033d59081587b09bbe49d0b49c9825d22840b2ff5d9c5155f975f8f2c2e7a90c75d2e4a8040fe39f63bbafb403d9e28cc3b86e04e394a9c9e8065bd3c85fa9f0c7891600 +955f1f7e4e54660b26f30086f2dddaedd32813547c1b95d305d882682b4ff7a0 38a10a352ca5aedfa8e19c64787d8e9c3a75dbf3b8674bfab29b5dbfc15a63d10fae66cd1a6e6d2452d557967eaad89a4c98449787b0b3164ca5b717a93f24eb0b506ceb70cbbcb8d72b2a72993f909aad92f044e0b5a2c9ac9cb16a0ca2f81f49 +8fac5a34ebafa38b55333624a9514fe97d9956e74309c5252cd2090d3bbe2f9e 6d8c6e449bc13634f115749c248c17cd148b72157a2c37bf8969ea83b4d6ba8c0ee2711c28ee11495f43049596520ce436004b026b6c1f7292b9c436b055cbb72d530d860d1276a1502a5140e3c3f54a93663e4d20edec32d284e25564f624955b52 +62039e0f53869480f88c87bb3d19a31aad32878f27f2c4e78ff02bbea2b8b0b9 6efcbcaf451c129dbe00b9cef0c3749d3ee9d41c7bd500ade40cdc65dedbbbadb885a5b14b32a0c0d087825201e303288a733842fa7e599c0c514e078f05c821c7a4498b01c40032e9f1872a1c925fa17ce253e8935e4c3c71282242cb716b2089ccc1 +ce87a5173bffd92399221658f801d45c294d9006ee9f3f9d419c8d427748dc41 433c5303131624c0021d868a30825475e8d0bd3052a022180398f4ca4423b98214b6beaac21c8807a2c33f8c93bd42b092cc1b06cedf3224d5ed1ec29784444f22e08a55aa58542b524b02cd3d5d5f6907afe71c5d7462224a3f9d9e53e7e0846dcbb4ce +2ef8907b60108638e50eac535cc46ca02e04581ddb4235fbac5cb5c53583e24b a873e0c67ca639026b6683008f7aa6324d4979550e9bce064ca1e1fb97a30b147a24f3f666c0a72d71348ede701cf2d17e2253c34d1ec3b647dbcef2f879f4eb881c4830b791378c901eb725ea5c172316c6d606e0af7df4df7f76e490cd30b2badf45685f +be8b5bd36518e9c5f4c768fc02461bb3d39a5d00edef82cec7df351df80238e0 006917b64f9dcdf1d2d87c8a6173b64f6587168e80faa80f82d84f60301e561e312d9fbce62f39a6fb476e01e925f26bcc91de621449be6504c504830aae394096c8fc7694651051365d4ee9070101ec9b68086f2ea8f8ab7b811ea8ad934d5c9b62c60a4771 +52cbc5dbe49b009663c43f079dd180e38a77533778062a72a29e864a58522922 f13c972c52cb3cc4a4df28c97f2df11ce089b815466be88863243eb318c2adb1a417cb1041308598541720197b9b1cb5ba2318bd5574d1df2174af14884149ba9b2f446d609df240ce335599957b8ec80876d9a085ae084907bc5961b20bf5f6ca58d5dab38adb +3a8dfcfd1b362003ddfa17910727539e64b18021abba018b5f58d71f7a449733 e35780eb9799ad4c77535d4ddb683cf33ef367715327cf4c4a58ed9cbdcdd486f669f80189d549a9364fa82a51a52654ec721bb3aab95dceb4a86a6afa93826db923517e928f33e3fba850d45660ef83b9876accafa2a9987a254b137c6e140a21691e1069413848 +fa221deee80e25e53c6c448aa22028b72501f07d1ff2c3fc7f93af9838b2d0a9 64ec021c9585e01ffe6d31bb50d44c79b6993d72678163db474947a053674619d158016adb243f5c8d50aa92f50ab36e579ff2dabb780a2b529370daa299207cfbcdd3a9a25006d19c4f1fe33e4b1eaec315d8c6ee1e730623fd1941875b924eb57d6d0c2edc4e78d6 +ed9c8b87fce27be4e95610db1ddd0c035847f4699dfc8c039a798a30343a6059 5954bab512cf327d66b5d9f296180080402624ad7628506b555eea8382562324cf452fba4a2130de3e165d11831a270d9cb97ce8c2d32a96f50d71600bb4ca268cf98e90d6496b0a6619a5a8c63db6d8a0634dfc6c7ec8ea9c006b6c456f1b20cd19e781af20454ac880 +a485cc9cf4ca4f659f89a0b791a4423953424ac57146b879d385a9e4062afe52 03d9f92b2c565709a568724a0aff90f8f347f43b02338f94a03ed32e6f33666ff5802da4c81bdce0d0e86c04afd4edc2fc8b4141c2975b6f07639b1994c973d9a9afce3d9d365862003498513bfa166d2629e314d97441667b007414e739d7febf0fe3c32c17aa188a8683 +93cd4369a7796239a5cdf78bce22ebb2137a631c3a613d5e35816d2a64a34947 f31e8b4f9e0621d531d22a380be5d9abd56faec53cbd39b1fab230ea67184440e5b1d15457bd25f56204fa917fa48e669016cb48c1ffc1e1e45274b3b47379e00a43843cf8601a5551411ec12503e5aac43d8676a1b2297ec7a0800dbfee04292e937f21c005f17411473041 +3751ce08750d927eb5c3ae4ca62a703a481d86a4fa1c011e812b4bc0a2fef08d 758ea3fea738973db0b8be7e599bbef4519373d6e6dcd7195ea885fc991d896762992759c2a09002912fb08e0cb5b76f49162aeb8cf87b172cf3ad190253df612f77b1f0c532e3b5fc99c2d31f8f65011695a087a35ee4eee5e334c369d8ee5d29f695815d866da99df3f79403 +a88c7ef7b89b7b6f75d83922b8fd00f034d719f97c67884121434447ae9dd3b9 47c6e0c2b74948465921868804f0f7bd50dd323583dc784f998a93cd1ca4c6ef84d41dc81c2c40f34b5bee6a93867b3bdba0052c5f59e6f3657918c382e771d33109122cc8bb0e1e53c4e3d13b43ce44970f5e0c079d2ad7d7a3549cd75760c21bb15b447589e86e8d76b1e9ced2 +2b4f8f9ef7d6ed60bb4881e635e0f887a51b0c1a42bab077976b43d2c715e11a f690a132ab46b28edfa6479283d6444e371c6459108afd9c35dbd235e0b6b6ff4c4ea58e7554bd002460433b2164ca51e868f7947d7d7a0d792e4abf0be5f450853cc40d85485b2b8857ea31b5ea6e4ccfa2f3a7ef3380066d7d8979fdac618aad3d7e886dea4f005ae4ad05e5065f +586cffdc434313cc4e133e85ac88b3e5dea71818abcac236f0aae418f72b6cde 58d6a99bc6458824b256916770a8417040721cccfd4b79eacd8b65a3767ce5ba7e74104c985ac56b8cc9aebd16febd4cda5adb130b0ff2329cc8d611eb14dac268a2f9e633c99de33997fea41c52a7c5e1317d5b5daed35eba7d5a60e45d1fa7eaabc35f5c2b0a0f2379231953322c4e +52d14ab96b24aa4a7a55721aa8550b1fccac3653c78234783f7295ae5f39a17a befab574396d7f8b6705e2d5b58b2c1c820bb24e3f4bae3e8fbcd36dbf734ee14e5d6ab972aedd3540235466e825850ee4c512ea9795abfd33f330d9fd7f79e62bbb63a6ea85de15beaeea6f8d204a28956059e2632d11861dfb0e65bc07ac8a159388d5c3277e227286f65ff5e5b5aec1 +b6345edd966030cf70dfb5b7552bc141c42efe7a7e84f957b1baf4671bae4354 8e58144fa9179d686478622ce450c748260c95d1ba43b8f9b59abeca8d93488da73463ef40198b4d16fb0b0707201347e0506ff19d01bea0f42b8af9e71a1f1bd168781069d4d338fdef00bf419fbb003031df671f4a37979564f69282de9c65407847dd0da505ab1641c02dea4f0d834986 +0347901965d3635005e75a1095695cca050bc9ed2d440c0372a31b348514a889 b55c10eae0ec684c16d13463f29291bf26c82e2fa0422a99c71db4af14dd9c7f33eda52fd73d017cc0f2dbe734d831f0d820d06d5f89dacc485739144f8cfd4799223b1aff9031a105cb6a029ba71e6e5867d85a554991c38df3c9ef8c1e1e9a7630be61caabca69280c399c1fb7a12d12aefc +f0bf7105870f2382b76863bb97aee79f95ae0e8142675bbccdb3475b0c99352f 2eeea693f585f4ed6f6f8865bbae47a6908aecd7c429e4bec4f0de1d0ca0183fa201a0cb14a529b7d7ac0e6ff6607a3243ee9fb11bcf3e2304fe75ffcddd6c5c2e2a4cd45f63c962d010645058d36571404a6d2b4f44755434d76998e83409c3205aa1615db44057db991231d2cb42624574f545 +631c6f5abe50b27c9dea557fc3fbd3fb25781fcb1bbf9f2e010cca20ec52dbc4 dab11dc0b047db0420a585f56c42d93175562852428499f66a0db811fcdddab2f7cdffed1543e5fb72110b64686bc7b6887a538ad44c050f1e42631bc4ec8a9f2a047163d822a38989ee4aab01b4c1f161b062d873b1cfa388fd301514f62224157b9bef423c7783b7aac8d30d65cd1bba8d689c2d +3757a53d195b43b403a796a74aafb2064072a69e372ee5b36cc2b7a791f75c9f 42e99a2f80aee0e001279a2434f731e01d34a44b1a8101726921c0590c30f3120eb83059f325e894a5ac959dca71ce2214799916424e859d27d789437b9d27240bf8c35adbafcecc322b48aa205b293962d858652abacbd588bcf6cbc388d0993bd622f96ed54614c25b6a9aa527589eaaffcf17ddf7 +0cc903acbced724b221d34877d1d1427182f9493a33df7758720e8bfc7af98ee 3c9b46450c0f2cae8e3823f8bdb4277f31b744ce2eb17054bddc6dff36af7f49fb8a2320cc3bdf8e0a2ea29ad3a55de1165d219adeddb5175253e2d1489e9b6fdd02e2c3d3a4b54d60e3a47334c37913c5695378a669e9b72dec32af5434f93f46176ebf044c4784467c700470d0c0b40c8a088c815816 +f23750c32973f24c2422f4e2b43589d9e76d6a575938e01a96ae8e73d026569c d1e654b77cb155f5c77971a64df9e5d34c26a3cad6c7f6b300d39deb1910094691adaa095be4ba5d86690a976428635d5526f3e946f7dc3bd4dbc78999e653441187a81f9adcd5a3c5f254bc8256b0158f54673dcc1232f6e918ebfc6c51ce67eaeb042d9f57eec4bfe910e169af78b3de48d137df4f2840 +1ece87e44a99f59d26411418fb8793689ff8a9c6ef75599056087d8c995bce1e 626f68c18a69a6590159a9c46be03d5965698f2dac3de779b878b3d9c421e0f21b955a16c715c1ec1e22ce3eb645b8b4f263f60660ea3028981eebd6c8c3a367285b691c8ee56944a7cd1217997e1d9c21620b536bdbd5de8925ff71dec6fbc06624ab6b21e329813de90d1e572dfb89a18120c3f606355d25 +71b4f90ac9215d7474b1197d1b8b24449fd57e9b05483d32edbebcb21a82f866 651a6fb3c4b80c7c68c6011675e6094eb56abf5fc3057324ebc6477825061f9f27e7a94633abd1fa598a746e4a577caf524c52ec1788471f92b8c37f23795ca19d559d446cab16cbcdce90b79fa1026cee77bf4ab1b503c5b94c2256ad75b3eac6fd5dcb96aca4b03a834bfb4e9af988cecbf2ae597cb9097940 +3b3678bb116fadab484291f0cf972606523501f5b45d51063797972928e333c0 8aaf072fce8a2d96bc10b3c91c809ee93072fb205ca7f10abd82ecd82cf040b1bc49ea13d1857815c0e99781de3adbb5443ce1c897e55188ceaf221aa9681638de05ae1b322938f46bce51543b57ecdb4c266272259d1798de13be90e10efec2d07484d9b21a3870e2aa9e06c21aa2d0c9cf420080a80a91dee16f +4068246495f508897813332962d3ae0b84685045e832a9a39ad5e94c154d2679 53f918fd00b1701bd504f8cdea803acca21ac18c564ab90c2a17da592c7d69688f6580575395551e8cd33e0fef08ca6ed4588d4d140b3e44c032355df1c531564d7f4835753344345a6781e11cd5e095b73df5f82c8ae3ad00877936896671e947cc52e2b29dcd463d90a0c9929128da222b5a211450bbc0e02448e2 +82696259536520e5e4d47e106bd1dcb397529aafb75878f332d2af2684493f1b a64599b8a61b5ccec9e67aed69447459c8da3d1ec6c7c7c82a7428b9b584fa67e90f68e2c00fbbed4613666e5168da4a16f395f7a3c3832b3b134bfc9cbaa95d2a0fe252f44ac6681eb6d40ab91c1d0282fed6701c57463d3c5f2bb8c6a7301fb4576aa3b5f15510db8956ff77478c26a7c09bea7b398cfc83503f538e +b494852603393b2b71845bacbdce89fa1427dfe4af9cdf925d4f93fa83b9966b 0e3ab0e054739b00cdb6a87bd12cae024b54cb5e550e6c425360c2e87e59401f5ec24ef0314855f0f56c47695d56a7fb1417693af2a1ed5291f2fee95f75eed54a1b1c2e81226fbff6f63ade584911c71967a8eb70933bc3f5d15bc91b5c2644d9516d3c3a8c154ee48e118bd1442c043c7a0dba5ac5b1d5360aae5b9065 +d8a619c0dfbed2a9498a147b53d7b33dd653d390e5c0cd691f02c8608822d06a a62fc595b4096e6336e53fcdfc8d1cc175d71dac9d750a6133d23199eaac288207944cea6b16d27631915b4619f743da2e30a0c00bbdb1bbb35ab852ef3b9aec6b0a8dcc6e9e1abaa3ad62ac0a6c5de765de2c3711b769e3fde44a74016fff82ac46fa8f1797d3b2a726b696e3dea5530439acee3a45c2a51bc32dd055650b +d82e257d000dc9fa279a00e2961e3286d2fe1c02ef59833ab8a6a7101bc25054 2b6db7ced8665ebe9deb080295218426bdaa7c6da9add2088932cdffbaa1c14129bccdd70f369efb149285858d2b1d155d14de2fdb680a8b027284055182a0cae275234cc9c92863c1b4ab66f304cf0621cd54565f5bff461d3b461bd40df28198e3732501b4860eadd503d26d6e69338f4e0456e9e9baf3d827ae685fb1d817 +8d5b7dbf3947219acdb04fb2e11a84a313c54c22f2ae858dfc8887bf6265f5f3 10db509b2cdcaba6c062ae33be48116a29eb18e390e1bbada5ca0a2718afbcd23431440106594893043cc7f2625281bf7de2655880966a23705f0c5155c2f5cca9f2c2142e96d0a2e763b70686cd421b5db812daced0c6d65035fde558e94f26b3e6dde5bd13980cc80292b723013bd033284584bff27657871b0cf07a849f4ae2 +607c3f31342c3ee5c93e552a8dd79fa86dccae2c1b58aabac25b5918acfa4da5 9334de60c997bda6086101a6314f64e4458f5ff9450c509df006e8c547983c651ca97879175aaba0c539e82d05c1e02c480975cbb30118121061b1ebac4f8d9a3781e2db6b18042e01ecf9017a64a0e57447ec7fcbe6a7f82585f7403ee2223d52d37b4bf426428613d6b4257980972a0acab508a7620c1cb28eb4e9d30fc41361ec +0656de9dcd7b7112a86c7ba199637d2c1c9e9cfbb713e4ede79f8862ee69993f e88ab086891693aa535ceb20e64c7ab97c7dd3548f3786339897a5f0c39031549ca870166e477743ccfbe016b4428d89738e426f5ffe81626137f17aecff61b72dbee2dc20961880cfe281dfab5ee38b1921881450e16032de5e4d55ad8d4fca609721b0692bac79be5a06e177fe8c80c0c83519fb3347de9f43d5561cb8107b9b5edc +4ddd6224858299f3378e3f5a0ecc52fa4c419c8ebb20f635c4c43f36324ecb4e fd19e01a83eb6ec810b94582cb8fbfa2fcb992b53684fb748d2264f020d3b960cb1d6b8c348c2b54a9fcea72330c2aaa9a24ecdb00c436abc702361a82bb8828b85369b8c72ece0082fe06557163899c2a0efa466c33c04343a839417057399a63a3929be1ee4805d6ce3e5d0d0967fe9004696a5663f4cac9179006a2ceb75542d75d68 +ec096314e2f73b6a7027fffa02104c2f6dd187f20c743445befd4b5c034b3295 59ae20b6f7e0b3c7a989afb28324a40fca25d8651cf1f46ae383ef6d8441587aa1c04c3e3bf88e8131ce6145cfb8973d961e8432b202fa5af3e09d625faad825bc19da9b5c6c20d02abda2fcc58b5bd3fe507bf201263f30543819510c12bc23e2ddb4f711d087a86edb1b355313363a2de996b891025e147036087401ccf3ca7815bf3c49 +fe71d01c2ee50e054d6b07147ef62954fde7e6959d6eeba68e3c94107eb0084d 77ee804b9f3295ab2362798b72b0a1b2d3291dceb8139896355830f34b3b328561531f8079b79a6e9980705150866402fdc176c05897e359a6cb1a7ab067383eb497182a7e5aef7038e4c96d133b2782917417e391535b5e1b51f47d8ed7e4d4025fe98dc87b9c1622614bff3d1029e68e372de719803857ca52067cddaad958951cb2068cc6 +bd6f5492582a7c1b116304de28314df9fffe95b0da11af52fe9440a717a34859 b771d5cef5d1a41a93d15643d7181d2a2ef0a8e84d91812f20ed21f147bef732bf3a60ef4067c3734b85bc8cd471780f10dc9e8291b58339a677b960218f71e793f2797aea349406512829065d37bb55ea796fa4f56fd8896b49b2cd19b43215ad967c712b24e5032d065232e02c127409d2ed4146b9d75d763d52db98d949d3b0fed6a8052fbb +e717a7769448abbe5fef8187954a88ac56ded1d22e63940ab80d029585a21921 b32d95b0b9aad2a8816de6d06d1f86008505bd8c14124f6e9a163b5a2ade55f835d0ec3880ef50700d3b25e42cc0af050ccd1be5e555b23087e04d7bf9813622780c7313a1954f8740b6ee2d3f71f768dd417f520482bd3a08d4f222b4ee9dbd015447b33507dd50f3ab4247c5de9a8abd62a8decea01e3b87c8b927f5b08beb37674c6f8e380c04 +a95d50b50b4545f0947441df74a1e9d74622eb3baa49c1bbfc3a0cce6619c1aa 04410e31082a47584b406f051398a6abe74e4da59bb6f85e6b49e8a1f7f2ca00dfba5462c2cd2bfde8b64fb21d70c083f11318b56a52d03b81cac5eec29eb31bd0078b6156786da3d6d8c33098c5c47bb67ac64db14165af65b44544d806dde5f487d5373c7f9792c299e9686b7e5821e7c8e2458315b996b5677d926dac57b3f22da873c601016a0d +ed53d72595ace3a6d5166a4ede41cce362d644bded772be616b87bcf678a6364 8b81e9badde026f14d95c019977024c9e13db7a5cd21f9e9fc491d716164bbacdc7060d882615d411438aea056c340cdf977788f6e17d118de55026855f93270472d1fd18b9e7e812bae107e0dfde7063301b71f6cfe4e225cab3b232905a56e994f08ee2891ba922d49c3dafeb75f7c69750cb67d822c96176c46bd8a29f1701373fb09a1a6e3c7158f +810401b247c23529e24655cab86c42df44085da76ca01c9a14618e563b7c41be fa6eed24da6666a22208146b19a532c2ec9ba94f09f1def1e7fc13c399a48e41acc2a589d099276296348f396253b57cb0e40291bd282773656b6e0d8bea1cda084a3738816a840485fcf3fb307f777fa5feac48695c2af4769720258c77943fb4556c362d9cba8bf103aeb9034baa8ea8bfb9c4f8e6742ce0d52c49ea8e974f339612e830e9e7a9c29065 +9f01e63f2355393ecb1908d0caf39718833004a4bf37ebf4cf8d7319b65172df 9bb4af1b4f09c071ce3cafa92e4eb73ce8a6f5d82a85733440368dee4eb1cbc7b55ac150773b6fe47dbe036c45582ed67e23f4c74585dab509df1b83610564545642b2b1ec463e18048fc23477c6b2aa035594ecd33791af6af4cbc2a1166aba8d628c57e707f0b0e8707caf91cd44bdb915e0296e0190d56d33d8dde10b5b60377838973c1d943c22ed335e +7ec11de7db790a850281f043592779b409195db4ecedeefbb93ba683d3bca851 2167f02118cc62043e9091a647cadbed95611a521fe0d64e8518f16c808ab297725598ae296880a773607a798f7c3cfce80d251ebec6885015f9abf7eaabae46798f82cb5926de5c23f44a3f9f9534b3c6f405b5364c2f8a8bdc5ca49c749bed8ce4ba48897062ae8424ca6dde5f55c0e42a95d1e292ca54fb46a84fbc9cd87f2d0c9e7448de3043ae22fdd229 +a74af9c523b4a08d9db9692ea89255977a5919b9292b7cd0d92c90c97c98e224 94b7fa0bc1c44e949b1d7617d31b4720cbe7ca57c6fa4f4094d4761567e389ecc64f6968e4064df70df836a47d0c713336b5028b35930d29eb7a7f9a5af9ad5cf441745baec9bb014ceeff5a41ba5c1ce085feb980bab9cf79f2158e03ef7e63e29c38d7816a84d4f71e0f548b7fc316085ae38a060ff9b8dec36f91ad9ebc0a5b6c338cbb8f6659d342a24368cf +344d129c228359463c40555d94213d015627e5871c04f106a0feef9361cdecb6 ea40e83cb18b3a242c1ecc6ccd0b7853a439dab2c569cfc6dc38a19f5c90acbf76aef9ea3742ff3b54ef7d36eb7ce4ff1c9ab3bc119cff6be93c03e208783335c0ab8137be5b10cdc66ff3f89a1bddc6a1eed74f504cbe7290690bb295a872b9e3fe2cee9e6c67c41db8efd7d863cf10f840fe618e7936da3dca5ca6df933f24f6954ba0801a1294cd8d7e66dfafec +4ce7c2b935f21fc34c5e56d940a555c593872aec2f896de4e68f2a017060f535 157d5b7e4507f66d9a267476d33831e7bb768d4d04cc3438da12f9010263ea5fcafbde2579db2f6b58f911d593d5f79fb05fe3596e3fa80ff2f761d1b0e57080055c118c53e53cdb63055261d7c9b2b39bd90acc32520cbbdbda2c4fd8856dbcee173132a2679198daf83007a9b5c51511ae49766c792a29520388444ebefe28256fb33d4260439cba73a9479ee00c63 +24b69d8ab35baccbd92f94e1b70b07c4c0ecf14eaeac4b6b8560966d5be086f3 836b34b515476f613fe447a4e0c3f3b8f20910ac89a3977055c960d2d5d2b72bd8acc715a9035321b86703a411dde0466d58a59769672aa60ad587b8481de4bba552a1645779789501ec53d540b904821f32b0bd1855b04e4848f9f8cfe9ebd8911be95781a759d7ad9724a7102dbe576776b7c632bc39b9b5e19057e226552a5994c1dbb3b5c7871a11f5537011044c53 +19f34215373e8e80f686953e03ca472b50216719cb515e0667d4e686e45fcf7c cc7784a4912a7ab5ad3620aab29ba87077cd3cb83636adc9f3dc94f51edf521b2161ef108f21a0a298557981c0e53ce6ced45bdf782c1ef200d29bab81dd6460586964edab7cebdbbec75fd7925060f7da2b853b2b089588fa0f8c16ec6498b14c55dcee335cb3a91d698e4d393ab8e8eac0825f8adebeee196df41205c011674e53426caa453f8de1cbb57932b0b741d4c6 +290bd4808e5676eb0c978084e4cd68e745031659a26807ad615b10cda589b969 7639b461fff270b2455ac1d1afce782944aea5e9087eb4a39eb96bb5c3baaf0e868c8526d3404f9405e79e77bfac5ffb89bf1957b523e17d341d7323c302ea7083872dd5e8705694acdda36d5a1b895aaa16eca6104c82688532c8bfe1790b5dc9f4ec5fe95baed37e1d287be710431f1e5e8ee105bc42ed37d74b1e55984bf1c09fe6a1fa13ef3b96faeaed6a2a1950a12153 +70999ab9818309afa8f1adc4fea47a071a8abd94012f7ce28cc794a0d997c5cb eb6513fc61b30cfba58d4d7e80f94d14589090cf1d80b1df2e68088dc6104959ba0d583d585e9578ab0aec0cf36c48435eb52ed9ab4bbce7a5abe679c97ae2dbe35e8cc1d45b06dda3cf418665c57cbee4bbb47fa4caf78f4ee656fec237fe4eebbafa206e1ef2bd0ee4ae71bd0e9b2f54f91daadf1febfd7032381d636b733dcb3bf76fb14e23aff1f68ed3dbcf75c9b99c6f26 +83120033b0140fe3e3e1cbfebff323abc08535c0aa017803f5d2f4ecb35f5dfb 1594d74bf5dde444265d4c04dad9721ff3e34cbf622daf341fe16b96431f6c4df1f760d34f296eb97d98d560ad5286fec4dce1724f20b54fd7df51d4bf137add656c80546fb1bf516d62ee82baa992910ef4cc18b70f3f8698276fcfb44e0ec546c2c39cfd8ee91034ff9303058b4252462f86c823eb15bf481e6b79cc3a02218595b3658e8b37382bd5048eaed5fd02c37944e73b +5584bf3e93bc25945c508b9188d0502c6e755bbebabfc8cb907fa7a252ef464a 4cfa1278903026f66fedd41374558be1b585d03c5c55dac94361df286d4bd39c7cb8037ed3b267b07c346626449d0cc5b0dd2cf221f7e4c3449a4be99985d2d5e67bff2923357ddeab5abcb4619f3a3a57b2cf928a022eb27676c6cf805689004fca4d41ea6c2d0a4789c7605f7bb838dd883b3ad3e6027e775bcf262881428099c7fff95b14c095ea130e0b9938a5e22fc52650f591 +c234b252c21edb842634cc124da5bee8a4749cffba134723f7963b3a9729c0b4 d3e65cb92cfa79662f6af493d696a07ccf32aaadcceff06e73e8d9f6f909209e66715d6e978788c49efb9087b170ecf3aa86d2d4d1a065ae0efc8924f365d676b3cb9e2bec918fd96d0b43dee83727c9a93bf56ca2b2e59adba85696546a815067fc7a78039629d4948d157e7b0d826d1bf8e81237bab7321312fdaa4d521744f988db6fdf04549d0fdca393d639c729af716e9c8bba48 +645f25456752091fffcaade806c34c79dffe72140c7c75d6a6ecfeedf6db401c 842cc583504539622d7f71e7e31863a2b885c56a0ba62db4c2a3f2fd12e79660dc7205ca29a0dc0a87db4dc62ee47a41db36b9ddb3293b9ac4baae7df5c6e7201e17f717ab56e12cad476be49608ad2d50309e7d48d2d8de4fa58ac3cfeafeee48c0a9eec88498e3efc51f54d300d828dddccb9d0b06dd021a29cf5cb5b2506915beb8a11998b8b886e0f9b7a80e97d91a7d01270f9a7717 +2d7cac697e7410c1f7735dd691624a7d04fa51815858e8ba98b19b0ded0638b5 6c4b0a0719573e57248661e98febe326571f9a1ca813d3638531ae28b4860f23c3a3a8ac1c250034a660e2d71e16d3acc4bf9ce215c6f15b1c0fc7e77d3d27157e66da9ceec9258f8f2bf9e02b4ac93793dd6e29e307ede3695a0df63cbdc0fc66fb770813eb149ca2a916911bee4902c47c7802e69e405fe3c04ceb5522792a5503fa829f707272226621f7c488a7698c0d69aa561be9f378 +f664f626bc6b7a8cf03be429155ee1f5cd6ecf14816de49a5e229903f89a4dc6 51b7dbb7ce2ffeb427a91ccfe5218fd40f9e0b7e24756d4c47cd55606008bdc27d16400933906fd9f30effdd4880022d081155342af3fb6cd53672ab7fb5b3a3bcbe47be1fd3a2278cae8a5fd61c1433f7d350675dd21803746cadca574130f01200024c6340ab0cc2cf74f2234669f34e9009ef2eb94823d62b31407f4ba46f1a1eec41641e84d77727b59e746b8a671bef936f05be820759fa +06425e83e4af817d735e9962c0cddce2cd40a087a6b0af3599719e415ab9a72a 83599d93f5561e821bd01a472386bc2ff4efbd4aed60d5821e84aae74d8071029810f5e286f8f17651cd27da07b1eb4382f754cd1c95268783ad09220f5502840370d494beb17124220f6afce91ec8a0f55231f9652433e5ce3489b727716cf4aeba7dcda20cd29aa9a859201253f948dd94395aba9e3852bd1d60dda7ae5dc045b283da006e1cbad83cc13292a315db5553305c628dd091146597 +e8c329149b075c459e11c8ac1e7e6acfa51ca981c89ec0768ed79d19f4e484fb 2be9bf526c9d5a75d565dd11ef63b979d068659c7f026c08bea4af161d85a462d80e45040e91f4165c074c43ac661380311a8cbed59cc8e4c4518e80cd2c78ab1cabf66bff83eab3a80148550307310950d034a6286c93a1ece8929e6385c5e3bb6ea8a7c0fb6d6332e320e71cc4eb462a2a62e2bfe08f0ccad93e61bedb5dd0b786a728ab666f07e0576d189c92bf9fb20dca49ac2d3956d47385e2 +c86768f6c349eb323bd82db19676e10bd8ae9f7057763556bbb6d0b671e60f2a ca76d3a12595a817682617006848675547d3e8f50c2210f9af906c0e7ce50b4460186fe70457a9e879e79fd4d1a688c70a347361c847ba0dd6aa52936eaf8e58a1be2f5c1c704e20146d366aeb3853bed9de9befe9569ac8aaea37a9fb7139a1a1a7d5c748605a8defb297869ebedd71d615a5da23496d11e11abbb126b206fa0a7797ee7de117986012d0362dcef775c2fe145ada6bda1ccb326bf644 +d97f46f3b7edbfb16e52bfec7dba0815b94d46e4251e48a853eabdf876127714 f76b85dc67421025d64e93096d1d712b7baf7fb001716f02d33b2160c2c882c310ef13a576b1c2d30ef8f78ef8d2f465007109aad93f74cb9e7d7bef7c9590e8af3b267c89c15db238138c45833c98cc4a471a7802723ef4c744a853cf80a0c2568dd4ed58a2c9644806f42104cee53628e5bdf7b63b0b338e931e31b87c24b146c6d040605567ceef5960df9e022cb469d4c787f4cba3c544a1ac91f95f +51d08e00aaa252812d873357107616055b1b8c5fb2ac7917d0f901dfb01fac47 25b8c9c032ea6bcd733ffc8718fbb2a503a4ea8f71dea1176189f694304f0ff68e862a8197b839957549ef243a5279fc2646bd4c009b6d1edebf24738197abb4c992f6b1dc9ba891f570879accd5a6b18691a93c7d0a8d38f95b639c1daeb48c4c2f15ccf5b9d508f8333c32de78781b41850f261b855c4bebcc125a380c54d501c5d3bd07e6b52102116088e53d76583b0161e2a58d0778f091206aabd5a1 +c6a188a6bdaca4dd7b1bc3e41019afe93473063f932c166e3242b7f52a3c6f8e 21cfdc2a7ccb7f331b3d2eefff37e48ad9fa9c788c3f3c200e0173d99963e1cbca93623b264e920394ae48bb4c3a5bb96ffbc8f0e53f30e22956adabc2765f57fb761e147ecbf8567533db6e50c8a1f894310a94edf806dd8ca6a0e141c0fa7c9fae6c6ae65f18c93a8529e6e5b553bf55f25be2e80a9882bd37f145fecbeb3d447a3c4e46c21524cc55cdd62f521ab92a8ba72b897996c49bb273198b7b1c9e +2b31fbc565110110011ab2c8f6cc3da8fb55d41b1ae5e04310283f207d39682d 4e452ba42127dcc956ef4f8f35dd68cb225fb73b5bc7e1ec5a898bba2931563e74faff3b67314f241ec49f4a7061e3bd0213ae826bab380f1f14faab8b0efddd5fd1bb49373853a08f30553d5a55ccbbb8153de4704f29ca2bdeef0419468e05dd51557ccc80c0a96190bbcc4d77ecff21c66bdf486459d427f986410f883a80a5bcc32c20f0478bb9a97a126fc5f95451e40f292a4614930d054c851acd019ccf +1351f5dba46098b9a773381d85d52fad491b3a82af9107f173db81fb35ed91d2 fa85671df7dadf99a6ffee97a3ab9991671f5629195049880497487867a6c446b60087fac9a0f2fcc8e3b24e97e42345b93b5f7d3691829d3f8ccd4bb36411b85fc2328eb0c51cb3151f70860ad3246ce0623a8dc8b3c49f958f8690f8e3860e71eb2b1479a5cea0b3f8befd87acaf5362435eaeccb52f38617bc6c5c2c6e269ead1fbd69e941d4ad2012da2c5b21bcfbf98e4a77ab2af1f3fda3233f046d38f1dc8 +dffc700f3e4d84d9131cbb1f98fb843dbafcb2ef94a52e89d204d431451a3331 e90847ae6797fbc0b6b36d6e588c0a743d725788ca50b6d792352ea8294f5ba654a15366b8e1b288d84f5178240827975a763bc45c7b0430e8a559df4488505e009c63da994f1403f407958203cebb6e37d89c94a5eacf6039a327f6c4dbbc7a2a307d976aa39e41af6537243fc218dfa6ab4dd817b6a397df5ca69107a9198799ed248641b63b42cb4c29bfdd7975ac96edfc274ac562d0474c60347a078ce4c25e88 +26726b52242ef8ecf4c66aed9c4b46bf6f5d87044a0b99d4e4af47dc360b9b0e f6d5c2b6c93954fc627602c00c4ca9a7d3ed12b27173f0b2c9b0e4a5939398a665e67e69d0b12fb7e4ceb253e8083d1ceb724ac07f009f094e42f2d6f2129489e846eaff0700a8d4453ef453a3eddc18f408c77a83275617fabc4ea3a2833aa73406c0e966276079d38e8e38539a70e194cc5513aaa457c699383fd1900b1e72bdfb835d1fd321b37ba80549b078a49ea08152869a918ca57f5b54ed71e4fd3ac5c06729 +25e536315f08a40976adecb54756ebc0b224c38faf11509371b5a692a5269ab5 cf8562b1bed89892d67ddaaf3deeb28246456e972326dbcdb5cf3fb289aca01e68da5d59896e3a6165358b071b304d6ab3d018944be5049d5e0e2bb819acf67a6006111089e6767132d72dd85beddcbb2d64496db0cc92955ab4c6234f1eea24f2d51483f2e209e4589bf9519fac51b4d061e801125e605f8093bb6997bc163d551596fe4ab7cfae8fb9a90f6980480ce0c229fd1675409bd788354daf316240cfe0af93eb +ab504592ad7184be83cc659efb5d3de88ba04b060b45d16a76f034080dde56c6 2ace31abb0a2e3267944d2f75e1559985db7354c6e605f18dc8470423fca30b7331d9b33c4a4326783d1caae1b4f07060eff978e4746bf0c7e30cd61040bd5ec2746b29863eb7f103ebda614c4291a805b6a4c8214230564a0557bc7102e0bd3ed23719252f7435d64d210ee2aafc585be903fa41e1968c50fd5d5367926df7a05e3a42cf07e656ff92de73b036cf8b19898c0cb34557c0c12c2d8b84e91181af467bc75a9d1 +5d8ee133ec441a3df50a5268a8f393f13f30f23f226ae3a18ec331844402ff54 0d8d09aed19f1013969ce5e7eb92f83a209ae76be31c754844ea9116ceb39a22ebb6003017bbcf26555fa6624185187db8f0cb3564b8b1c06bf685d47f3286eda20b83358f599d2044bbf0583fab8d78f854fe0a596183230c5ef8e54426750eaf2cc4e29d3bdd037e734d863c2bd9789b4c243096138f7672c232314effdfc6513427e2da76916b5248933be312eb5dde4cf70804fb258ac5fb82d58d08177ac6f4756017fff5 +712b1cc04c009b52035cc44c9505bb5cb577ba0ad1734ec23620f57eef3d37fb c3236b73deb7662bf3f3daa58f137b358ba610560ef7455785a9befdb035a066e90704f929bd9689cef0ce3bda5acf4480bceb8d09d10b098ad8500d9b6071dfc3a14af6c77511d81e3aa8844986c3bea6f469f9e02194c92868cd5f51646256798ff0424954c1434bdfed9facb390b07d342e992936e0f88bfd0e884a0ddb679d0547ccdec6384285a45429d115ac7d235a717242021d1dc35641f5f0a48e8445dba58e6cb2c8ea +942e39e230a2251ffdb2f85202871c98597008401b322ff9840cc90cc85b337d b39feb8283eadc63e8184b51df5ae3fd41aac8a963bb0be1cd08aa5867d8d910c669221e73243360646f6553d1ca05a84e8dc0de05b6419ec349ca994480193d01c92525f3fb3dcefb08afc6d26947bdbbfd85193f53b50609c6140905c53a6686b58e53a319a57b962331ede98149af3de3118a819da4d76706a0424b4e1d2910b0ed26af61d150ebcb46595d4266a0bd7f651ba47d0c7f179ca28545007d92e8419d48fdfbd744ce +b542b6cd8ef2dab4ed83b77ac6dc52daf554ecda4ef7ab0a50e546bebe2d8e5a a983d54f503803e8c7999f4edbbe82e9084f422143a932ddddc47a17b0b7564a7f37a99d0786e99476428d29e29d3c197a72bfab1342c12a0fc4787fd7017d7a6174049ea43b5779169ef7472bdbbd941dcb82fc73aac45a8a94c9f2bd3477f61fd3b796f02a1b8264a214c6fea74b7051b226c722099ec7883a462b83b6afdd4009248b8a237f605fe5a08fe7d8b45321421ebba67bd70a0b00ddbf94baab7f359d5d1eea105f28dcfb +f7e9e825722e6554a8619cca3e57f5b5e6b7347431d55ce178372c917bfb3dc2 e4d1c1897a0a866ce564635b74222f9696bf2c7f640dd78d7e2aca66e1b61c642bb03ea7536aae597811e9bf4a7b453ede31f97b46a5f0ef51a071a2b3918df16b152519ae3776f9f1edab4c2a377c3292e96408359d3613844d5eb393000283d5ad3401a318b12fd1474b8612f2bb50fb6a8b9e023a54d7dde28c43d6d8854c8d9d1155935c199811dbfc87e9e0072e90eb88681cc7529714f8fb8a2c9d88567adfb974ee205a9bf7b848 +14bb22b98eaf41a4c224fd3c37188a755f9b04f46f3e23a652da3db9e25d2f2c b10c59723e3dcadd6d75df87d0a1580e73133a9b7d00cb95ec19f5547027323be75158b11f80b6e142c6a78531886d9047b08e551e75e6261e79785366d7024bd7cd9cf322d9be7d57fb661069f2481c7bb759cd71b4b36ca2bc2df6d3a328faebdb995a9794a8d72155ed551a1f87c80bf6059b43fc764900b18a1c2441f7487743cf84e565f61f8dd2ece6b6ccc9444049197aaaf53e926fbee3bfca8be588ec77f29d211be89de18b15f6 +eb5668f9941c06e5e38ea01b7fa980638b9536ca1939950c1629f84a6eff3866 db11f609baba7b0ca634926b1dd539c8cbada24967d7add4d9876f77c2d80c0f4dcefbd7121548373582705cca2495bd2a43716fe64ed26d059cfb566b3364bd49ee0717bdd9810dd14d8fad80dbbdc4cafb37cc60fb0fe2a80fb4541b8ca9d59dce457738a9d3d8f641af8c3fd6da162dc16fc01aac527a4a0255b4d231c0be50f44f0db0b713af03d968fe7f0f61ed0824c55c4b5265548febd6aad5c5eedf63efe793489c39b8fd29d104ce +913014bb6e243fac3a22a185f8227a68c2311dc0b718e276bbbdb73af98be35f bebd4f1a84fc8b15e4452a54bd02d69e304b7f32616aadd90537937106ae4e28de9d8aab02d19bc3e2fde1d651559e296453e4dba94370a14dbbb2d1d4e2022302ee90e208321efcd8528ad89e46dc839ea9df618ea8394a6bff308e7726bae0c19bcd4be52da6258e2ef4e96aa21244429f49ef5cb486d7ff35cac1bacb7e95711944bccb2ab34700d42d1eb38b5d536b947348a458ede3dc6bd6ec547b1b0cae5b257be36a7124e1060c170ffa +0284418c10190f413042e3eceb3954979b94afbf2e545fc7f8a3c7db2c235916 5aca56a03a13784bdc3289d9364f79e2a85c12276b49b92db0adaa4f206d5028f213f678c3510e111f9dc4c1c1f8b6acb17a6413aa227607c515c62a733817ba5e762cc6748e7e0d6872c984d723c9bb3b117eb8963185300a80bfa65cde495d70a46c44858605fccbed086c2b45cef963d33294dbe9706b13af22f1b7c4cd5a001cfec251fba18e722c6e1c4b1166918b4f6f48a98b64b3c07fc86a6b17a6d0480ab79d4e6415b520f1c484d675b1 +8febff801787f5803e151dca3434a5cd44adb49f1c2ffd5d0cd077a9075a492d a5aad0e4646a32c85cfcac73f02fc5300f1982fabb2f2179e28303e447854094cdfc854310e5c0f60993ceff54d84d6b46323d930adb07c17599b35b505f09e784bca5985e0172257797fb53649e2e9723efd16865c31b5c3d5113b58bb0bfc8920fabdda086d7537e66d709d050bd14d0c960873f156fad5b3d3840cdfcdc9be6af519db262a27f40896ab25cc39f96984d650611c0d5a3080d5b3a1bf186abd42956588b3b58cd948970d298776060 +ea7511b993b786df59a3b3e0b3cd876c0f056d6ca43cc89c51c1b21ccdc79b42 06cbbe67e94a978203ead6c057a1a5b098478b4b4cbef5a97e93c8e42f5572713575fc2a884531d7622f8f879387a859a80f10ef02708cd8f7413ab385afc357678b9578c0ebf641ef076a1a30f1f75379e9dcb2a885bdd295905ee80c0168a62a9597d10cf12dd2d8cee46645c7e5a141f6e0e23aa482abe5661c16e69ef1e28371e2e236c359ba4e92c25626a7b7ff13f6ea4ae906e1cfe163e91719b1f750a96cbde5fbc953d9e576cd216afc90323a +baaecb6e9db57971d5c70f5819ff89c5093254de19ef6059c43cc0afda7c5d34 f1c528cf7739874707d4d8ad5b98f7c77169de0b57188df233b2dc8a5b31eda5db4291dd9f68e6bad37b8d7f6c9c0044b3bf74bbc3d7d1798e138709b0d75e7c593d3cccdc1b20c7174b4e692add820ace262d45ccfae2077e878796347168060a162ecca8c38c1a88350bd63bb539134f700fd4addd5959e255337daa06bc86358fabcbefdfb5bc889783d843c08aadc6c4f6c36f65f156e851c9a0f917e4a367b5ad93d874812a1de6a7b93cd53ad97232 +56db69430b8ca852221d55d7bbff477dc83f7cb44ab44ddd64c31a52c483db4f 9d9f3a7ecd51b41f6572fd0d0881e30390dfb780991dae7db3b47619134718e6f987810e542619dfaa7b505c76b7350c6432d8bf1cfebdf1069b90a35f0d04cbdf130b0dfc7875f4a4e62cdb8e525aadd7ce842520a482ac18f09442d78305fe85a74e39e760a4837482ed2f437dd13b2ec1042afcf9decdc3e877e50ff4106ad10a525230d11920324a81094da31deab6476aa42f20c84843cfc1c58545ee80352bdd3740dd6a16792ae2d86f11641bb717c2 +f8538f597f4463cad7a91905744b87156db33c65ba87b912427fec3669f425d4 5179888724819fbad3afa927d3577796660e6a81c52d98e9303261d5a4a83232f6f758934d50aa83ff9e20a5926dfebaac49529d006eb923c5ae5048ed544ec471ed7191edf46363383824f915769b3e688094c682b02151e5ee01e510b431c8865aff8b6b6f2f59cb6d129da79e97c6d2b8fa6c6da3f603199d2d1bcab547682a81cd6cf65f6551121391d78bcc23b5bd0e922ec6d8bf97c952e84dd28aef909aba31edb903b28fbfc33b7703cd996215a11238 +447eda923cfe1112a6f1a3e4c735bf8ee9e4f2aee7de666a472ff8cf0fc65315 576ef3520d30b7a4899b8c0d5e359e45c5189add100e43be429a02fb3de5ff4f8fd0e79d9663acca72cd29c94582b19292a557c5b1315297d168fbb54e9e2ecd13809c2b5fce998edc6570545e1499dbe7fb74d47cd7f35823b212b05bf3f5a79caa34224fdd670d335fcb106f5d92c3946f44d3afcbae2e41ac554d8e6759f332b76be89a0324aa12c5482d1ea3ee89ded4936f3e3c080436f539fa137e74c6d3389bdf5a45074c47bc7b20b0948407a66d855e2f +74d94c13afea4ddd07a637b68b6fe095017c092b3cdccdc498e26035d86d921e 0df2152fa4f4357c8741529dd77e783925d3d76e95bafa2b542a2c33f3d1d117d159cf473f82310356fee4c90a9e505e70f8f24859656368ba09381fa245eb6c3d763f3093f0c89b972e66b53d59406d9f01aea07f8b3b615cac4ee4d05f542e7d0dab45d67ccccd3a606ccbeb31ea1fa7005ba07176e60dab7d78f6810ef086f42f08e595f0ec217372b98970cc6321576d92ce38f7c397a403bada1548d205c343ac09deca86325373c3b76d9f32028fea8eb32515 +cc11196c095bffa090a05ba0bc255d38bda7218d9311143f4f200b1852d1bb0d 3e15350d87d6ebb5c8ad99d42515cfe17980933c7a8f6b8bbbf0a63728cefaad2052623c0bd5931839112a48633fb3c2004e0749c87a41b26a8b48945539d1ff41a4b269462fd199bfecd45374756f55a9116e92093ac99451aefb2af9fd32d6d7f5fbc7f7a540d5097c096ebc3b3a721541de073a1cc02f7fb0fb1b9327fb0b1218ca49c9487ab5396622a13ae546c97abdef6b56380dda7012a8384091b6656d0ab272d363cea78163ff765cdd13ab1738b940d16cae +8c085b54c213704374ddd920a45168608be65dfd036a562659f47143604144c2 c38d6b0b757cb552be40940ece0009ef3b0b59307c1451686f1a22702922800d58bce7a636c1727ee547c01b214779e898fc0e560f8ae7f61bef4d75eaa696b921fd6b735d171535e9edd267c192b99880c87997711002009095d8a7a437e258104a41a505e5ef71e5613ddd2008195f0c574e6ba3fe40099cfa116e5f1a2fa8a6da04badcb4e2d5d0de31fdc4800891c45781a0aac7c907b56d631fca5ce8b2cde620d11d1777ed9fa603541de794ddc5758fcd5fad78c0 +d2e233264a3773495ffd12159ef7b631660c1b3e53a3da0f24ae14466f167757 8d2de3f0b37a6385c90739805b170057f091cd0c7a0bc951540f26a5a75b3e694631bb64c7635eed316f51318e9d8de13c70a2aba04a14836855f35e480528b776d0a1e8a23b547c8b8d6a0d09b241d3be9377160cca4e6793d00a515dc2992cb7fc741daca171431da99cce6f7789f129e2ac5cf65b40d703035cd2185bb936c82002daf8cbc27a7a9e554b06196630446a6f0a14ba155ed26d95bd627b7205c072d02b60db0fd7e49ea058c2e0ba202daff0de91e845cf79 +ffac7ca5fa067419d1bdb00c0e49c6e1a748880923a23ed5dd67dde63d777edb c464bbdad275c50dcd983b65ad1019b9ff85a1e71c807f3204bb2c921dc31fbcd8c5fc45868ae9ef85b6c9b83bba2a5a822201ed68586ec5ec27fb2857a5d1a2d09d09115f22dcc39fe61f5e1ba0ff6e8b4acb4c6da748be7f3f0839739394ff7fa8e39f7f7e84a33c3866875c01bcb1263c9405d91908e9e0b50e7459fabb63d8c6bbb73d8e3483c099b55bc30ff092ff68b6adedfd477d63570c9f5515847f36e24ba0b705557130cec57ebad1d0b31a378e91894ee26e3a04 +5b2eca0920d32b1964bbf5810a6e6e53675ed1b83897fd04600d72e097845859 8b8d68bb8a75732fe272815a68a1c9c5aa31b41dedc8493e76525d1d013d33cebd9e21a5bb95db2616976a8c07fcf411f5f6bc6f7e0b57aca78cc2790a6f9b898858ac9c79b165ff24e66677531e39f572be5d81eb3264524181115f32780257bfb9aeec6af12af28e587cac068a1a2953b59ad680f4c245b2e3ec36f59940d37e1d3db38e13edb29b5c0f404f6ff87f80fc8be7a225ff22fbb9c8b6b1d7330c57840d24bc75b06b80d30dad6806544d510af6c4785e823ac3e0b8 +68f41fdfc7217e89687ed118bc31ac6ed2d9d1e1a2f1b20a2d429729fa03517b 6b018710446f368e7421f1bc0ccf562d9c1843846bc8d98d1c9bf7d9d6fcb48bfc3bf83b36d44c4fa93430af75cd190bde36a7f92f867f58a803900df8018150384d85d82132f123006ac2aeba58e02a037fe6afbd65eca7c44977dd3dc74f48b6e7a1bfd5cc4dcf24e4d52e92bd4455848e4928b0eac8b7476fe3cc03e862aa4dff4470dbfed6de48e410f25096487ecfc32a27277f3f5023b2725ade461b1355889554a8836c9cf53bd767f5737d55184eea1ab3f53edd0976c485 +fa2f3de31e9cf25ab9a978c82d605a43ee39b68ac8e30f49f9d209cb4e172ab4 c9534a24714bd4be37c88a3da1082eda7cabd154c309d7bd670dccd95aa535594463058a29f79031d6ecaa9f675d1211e9359be82669a79c855ea8d89dd38c2c761ddd0ec0ce9e97597432e9a1beae062cdd71edfdfd464119be9e69d18a7a7fd7ce0e2106f0c8b0abf4715e2ca48ef9f454dc203c96656653b727083513f8efb86e49c513bb758b3b052fe21f1c05bb33c37129d6cc81f1aef6adc45b0e8827a830fe545cf57d0955802c117d23ccb55ea28f95c0d8c2f9c5a242b33f +ba2af506c10da8d7751e67ed766cfcd47d048d6ef9277dbd2abfe2fd5d787b79 07906c87297b867abf4576e9f3cc7f82f22b154afcbf293b9319f1b0584da6a40c27b32e0b1b7f412c4f1b82480e70a9235b12ec27090a5a33175a2bb28d8adc475cefe33f7803f8ce27967217381f02e67a3b4f84a71f1c5228e0c2ad971373f6f672624fcea8d1a9f85170fad30fa0bbd25035c3b41a6175d467998bd1215f6f3866f53847f9cf68ef3e2fbb54bc994de2302b829c5eea68ec441fcbafd7d16ae4fe9fff98bf00e5bc2ad54dd91ff9fda4dd77b6c754a91955d1fbaad0 +3cd33f8811af12183c53e978528f53ae7d559432724029e55fcfa9b990b91713 588e94b9054abc2189df69b8ba34341b77cdd528e7860e5defcaa79b0c9a452ad4b82aa306be84536eb7cedcbe058d7b84a6aef826b028b8a0271b69ac3605a9635ea9f5ea0aa700f3eb7835bc54611b922964300c953efe7491e3677c2cebe0822e956cd16433b02c68c4a23252c3f9e151a416b4963257b783e038f6b4d5c9f110f871652c7a649a7bcedcbccc6f2d0725bb903cc196ba76c76aa9f10a190b1d1168993baa9ffc96a1655216773458bec72b0e39c9f2c121378feab4e76a +3ecc9d27994022045cbeab4fc041f12419cec8060c8f6f9f0372884df6074b5c 08959a7e4baae874928813364071194e2939772f20db7c3157078987c557c2a6d5abe68d520eef3dc491692e1e21bcd880adebf63bb4213b50897fa005256ed41b5690f78f52855c8d9168a4b666fce2da2b456d7a7e7c17ab5f2fb1ee90b79e698712e963715983fd07641ae4b4e9dc73203fac1ae11fa1f8c7941fcc82eab247addb56e2638447e9d609e610b60ce086656aaebf1da3c8a231d7d94e2fd0afe46b391ff14a72eaeb3f44ad4df85866def43d4781a0b3578bc996c87970b132 +1501988a55372ac1b0b78849f3b7e107e0bf1f2cbaf670de7f15acbb1a00ad3d cb2a234f45e2ecd5863895a451d389a369aab99cfef0d5c9ffca1e6e63f763b5c14fb9b478313c8e8c0efeb3ac9500cf5fd93791b789e67eac12fd038e2547cc8e0fc9db591f33a1e4907c64a922dda23ec9827310b306098554a4a78f050262db5b545b159e1ff1dca6eb734b872343b842c57eafcfda8405eedbb48ef32e99696d135979235c3a05364e371c2d76f1902f1d83146df9495c0a6c57d7bf9ee77e80f9787aee27be1fe126cdc9ef893a4a7dcbbc367e40fe4e1ee90b42ea25af01 +5c4e860a0175c92c1e6af2cbb3084162403ced073faac901d0d358b6bf5eefa9 d16beadf02ab1d4dc6f88b8c4554c51e866df830b89c06e786a5f8757e8909310af51c840efe8d20b35331f4355d80f73295974653ddd620cdde4730fb6c8d0d2dcb2b45d92d4fbdb567c0a3e86bd1a8a795af26fbf29fc6c65941cddb090ff7cd230ac5268ab4606fccba9eded0a2b5d014ee0c34f0b2881ac036e24e151be89eeb6cd9a7a790afccff234d7cb11b99ebf58cd0c589f20bdac4f9f0e28f75e3e04e5b3debce607a496d848d67fa7b49132c71b878fd5557e082a18eca1fbda94d4b +272b4f689263057fbf7605aaa67af012d742267164c4fab68035d99c5829b4f0 8f65f6bc59a85705016e2bae7fe57980de3127e5ab275f573d334f73f8603106ec3553016608ef2dd6e69b24be0b7113bf6a760ba6e9ce1c48f9e186012cf96a1d4849d75df5bb8315387fd78e9e153e76f8ba7ec6c8849810f59fb4bb9b004318210b37f1299526866f44059e017e22e96cbe418699d014c6ea01c9f0038b10299884dbec3199bb05adc94e955a1533219c1115fed0e5f21228b071f40dd57c4240d98d37b73e412fe0fa4703120d7c0c67972ed233e5deb300a22605472fa3a3ba86 +9b28e42b67ef32ec80da10a07b004e1d71c6dce71d8013ffa0305d0d0ce0469d 84891e52e0d451813210c3fd635b39a03a6b7a7317b221a7abc270dfa946c42669aacbbbdf801e1584f330e28c729847ea14152bd637b3d0f2b38b4bd5bf9c791c58806281103a3eabbaede5e711e539e6a8b2cf297cf351c078b4fa8f7f35cf61bebf8814bf248a01d41e86c5715ea40c63f7375379a7eb1d78f27622fb468ab784aaaba4e534a6dfd1df6fa15511341e725ed2e87f98737ccb7b6a6dfae416477472b046bf1811187d151bfa9f7b2bf9acdb23a3be507cdf14cfdf517d2cb5fb9e4ab6 +ee53f83d2e2ccc315c6377eadda5f42f42f3aadd664e3e895c37cbe9d0e9b9de fdd7a9433a3b4afabd7a3a5e3457e56debf78e84b7a0b0ca0e8c6d53bd0c2dae31b2700c6128334f43981be3b213b1d7a118d59c7e6b6493a86f866a1635c12859cfb9ad17460a77b4522a5c1883c3d6acc86e6162667ec414e9a104aa892053a2b1d72165a855bacd8faf8034a5dd9b716f47a0818c09bb6baf22aa503c06b4ca261f557761989d2afbd88b6a678ad128af68672107d0f1fc73c5ca740459297b3292b281e93bceb761bde7221c3a55708e5ec84472cddcaa84ecf23723cc0991355c6280 +21ccfda65c4b915303012b852ab29481030f87347c29917e21f210f2bd5efc9c 70a40bfbef92277a1aad72f6b79d0177197c4ebd432668cfec05d099accb651062b5dff156c0b27336687a94b26679cfdd9daf7ad204338dd9c4d14114033a5c225bd11f217b5f4732da167ee3f939262d4043fc9cba92303b7b5e96aea12adda64859df4b86e9ee0b58e39091e6b188b408ac94e1294a8911245ee361e60e601eff58d1d37639f3753bec80ebb4efde25817436076623fc65415fe51d1b0280366d12c554d86743f3c3b6572e400361a60726131441ba493a83fbe9afda90f7af1ae717238d +f5bf70710da440edb43afd3eb7698180317ffefa81406bb4df9c2bb8b0b1c034 74356e449f4bf8644f77b14f4d67cb6bd9c1f5ae357621d5b8147e562b65c66585caf2e491b48529a01a34d226d436959153815380d5689e30b35357cdac6e08d3f2b0e88e200600d62bd9f5eaf488df86a4470ea227006182e44809009868c4c280c43d7d64a5268fa719074960087b3a6abc837882f882c837834535929389a12b2c78187e2ea07ef8b8eef27dc85002c3ae35f1a50bee6a1c48ba7e175f3316670b27983472aa6a61eed0a683a39ee323080620ea44a9f74411ae5ce99030528f9ab49c79f2 +e83ea21f5bc0976953af86069a10eb6024a1ac59d609688e4a9759bb8b6c9441 8c3798e51bc68482d7337d3abb75dc9ffe860714a9ad73551e120059860dde24ab87327222b64cf774415a70f724cdf270de3fe47dda07b61c9ef2a3551f45a5584860248fabde676e1cd75f6355aa3eaeabe3b51dc813d9fb2eaa4f0f1d9f834d7cad9c7c695ae84b329385bc0bef895b9f1edf44a03d4b410cc23a79a6b62e4f346a5e8dd851c2857995ddbf5b2d717aeb847310e1f6a46ac3d26a7f9b44985af656d2b7c9406e8a9e8f47dcb4ef6b83caacf9aefb6118bfcff7e44bef6937ebddc89186839b77 +a2d93c6367e1862809d367ec37f9da44cb3a8b4319c6a094c5e7d7266fe3a593 fa56bf730c4f8395875189c10c4fb251605757a8fecc31f9737e3c2503b02608e6731e85d7a38393c67de516b85304824bfb135e33bf22b3a23b913bf6acd2b7ab85198b8187b2bcd454d5e3318cacb32fd6261c31ae7f6c54ef6a7a2a4c9f3ecb81ce3555d4f0ad466dd4c108a90399d70041997c3b25345a9653f3c9a6711ab1b91d6a9d2216442da2c973cbd685ee7643bfd77327a2f7ae9cb283620a08716dfb462e5c1d65432ca9d56a90e811443cd1ecb8f0de179c9cb48ba4f6fec360c66f252f6e64edc96b +3c647b195f22dc16d6decc8873017df369ee1c4696340934db158dc4059c76df b6134f9c3e91dd8000740d009dd806240811d51ab1546a974bcb18d344642baa5cd5903af84d58ec5ba17301d5ec0f10ccd0509cbb3fd3fff9172d193af0f782252fd1338c7244d40e0e42362275b22d01c4c3389f19dd69bdf958ebe28e31a4ffe2b5f18a87831cfb7095f58a87c9fa21db72ba269379b2dc2384b3da953c7925761fed324620acea435e52b424a7723f6a2357374157a34cd8252351c25a1b232826cefe1bd3e70ffc15a31e7c0598219d7f00436294d11891b82497bc78aa5363892a2495df8c1eef +3bb394d056d94fde68920cd383378ee3abcc44b7259d3db9cd0a897e021f7e2e c941cdb9c28ab0a791f2e5c8e8bb52850626aa89205bec3a7e22682313d198b1fa33fc7295381354858758ae6c8ec6fac3245c6e454d16fa2f51c4166fab51df272858f2d603770c40987f64442d487af49cd5c3991ce858ea2a60dab6a65a34414965933973ac2457089e359160b7cdedc42f29e10a91921785f6b7224ee0b349393cdcff6151b50b377d609559923d0984cda6000829b916ab6896693ef6a2199b3c22f7dc5500a15b8258420e314c222bc000bc4e5413e6dd82c993f8330f5c6d1be4bc79f08a1a0a46 +43640f408613cbf7393d900b921f22b826357f3b4fdff7168ec45cbfb3ef5eff 4499efffac4bcea52747efd1e4f20b73e48758be915c88a1ffe5299b0b005837a46b2f20a9cb3c6e64a9e3c564a27c0f1c6ad1960373036ec5bfe1a8fc6a435c2185ed0f114c50e8b3e4c7ed96b06a036819c9463e864a58d6286f785e32a804443a56af0b4df6abc57ed5c2b185ddee8489ea080deeee66aa33c2e6dab36251c402682b6824821f998c32163164298e1fafd31babbcffb594c91888c6219079d907fdb438ed89529d6d96212fd55abe20399dbefd342248507436931cdead496eb6e4a80358acc78647d043 +cb3713a5d5abbc6af72f8b38a701c71269b3b51c62ec5116f96ad0d42a10fd90 eecbb8fdfa4da62170fd06727f697d81f83f601ff61e478105d3cb7502f2c89bf3e8f56edd469d049807a38882a7eefbc85fc9a950952e9fa84b8afebd3ce782d4da598002827b1eb98882ea1f0a8f7aa9ce013a6e9bc462fb66c8d4a18da21401e1b93356eb12f3725b6db1684f2300a98b9a119e5d27ff704affb618e12708e77e6e5f34139a5a41131fd1d6336c272a8fc37080f041c71341bee6ab550cb4a20a6ddb6a8e0299f2b14bc730c54b8b1c1c487b494bdccfd3a53535ab2f231590bf2c4062fd2ad58f906a2d0d +b304fc4ca22131857d242eb12fe899ed9e6b55717c3360f113512a84174e6a77 e64f3e4ace5c8418d65fec2bc5d2a303dd458034736e3b0df719098be7a206deaf52d6ba82316caf330ef852375188cde2b39cc94aa449578a7e2a8e3f5a9d68e816b8d16889fbc0ebf0939d04f63033ae9ae2bdab73b88c26d6bd25ee460ee1ef58fb0afa92cc539f8c76d3d097e7a6a63ebb9b5887edf3cf076028c5bbd5b9db3211371ad3fe121d4e9bf44229f4e1ecf5a0f9f0eba4d5ceb72878ab22c3f0eb5a625323ac66f7061f4a81fac834471e0c59553f108475fe290d43e6a055ae3ee46fb67422f814a68c4be3e8c9 +a3ca830d4771c1baa7fada76c5fceadd0f3cb9736e19cfec52e9e74f56bfdd55 d2cb2d733033f9e91395312808383cc4f0ca974e87ec68400d52e96b3fa6984ac58d9ad0938dde5a973008d818c49607d9de2284e7618f1b8aed8372fbd52ed54557af4220fac09dfa8443011699b97d743f8f2b1aef3537ebb45dcc9e13dfb438428ee190a4efdb3caeb7f3933117bf63abdc7e57beb4171c7e1ad260ab0587806c4d137b6316b50abc9cce0dff3acada47bbb86be777e617bbe578ff4519844db360e0a96c6701290e76bb95d26f0f804c8a4f2717eac4e7de9f2cff3bbc55a17e776c0d02856032a6cd10ad2838 +ca158c46370e64a9f032f5ba8e091460fd555ef700edf7087e56bebffa261de7 f2998955613dd414cc111df5ce30a995bb792e260b0e37a5b1d942fe90171a4ac2f66d4928d7ad377f4d0554cbf4c523d21f6e5f379d6f4b028cdcb9b1758d3b39663242ff3cb6ede6a36a6f05db3bc41e0d861b384b6dec58bb096d0a422fd542df175e1be1571fb52ae66f2d86a2f6824a8cfaacbac4a7492ad0433eeb15454af8f312b3b2a577750e3efbd370e8a8cac1582581971fba3ba4bd0d76e718dacf8433d33a59d287f8cc92234e7a271041b526e389efb0e40b6a18b3aaf658e82ed1c78631fd23b4c3eb27c3faec8685 +5901cda0cd1510db5455d072d2737a6721ad9ee3272953a19c7ab378bf3646c5 447797e2899b72a356ba55bf4df3acca6cdb1041eb477bd1834a9f9acbc340a294d729f2f97df3a610be0ff15edb9c6d5db41644b9874360140fc64f52aa03f0286c8a640670067a84e017926a70438db1bb361defee7317021425f8821def26d1efd77fc853b818545d055adc9284796e583c76e6fe74c9ac2587aa46aa8f8804f2feb5836cc4b3ababab8429a5783e17d5999f32242eb59ef30cd7adabc16d72dbdb097623047c98989f88d14eaf02a7212be16ec2d07981aaa99949ddf89ecd90333a77bc4e1988a82abf7c7caf3291 +f64562d6273efb5ebd027e0a6f38c3fb204a6dbe894ee01200ea249b747cfe66 9f2c18ade9b380c784e170fb763e9aa205f64303067eb1bcea93df5dac4bf5a2e00b78195f808df24fc76e26cb7be31dc35f0844cded1567bba29858cffc97fb29010331b01d6a3fb3159cc1b973d255da9843e34a0a4061cabdb9ed37f241bfabb3c20d32743f4026b59a4ccc385a2301f83c0b0a190b0f2d01acb8f0d41111e10f2f4e149379275599a52dc089b35fdd5234b0cfb7b6d8aebd563ca1fa653c5c021dfd6f5920e6f18bfafdbecbf0ab00281333ed50b9a999549c1c8f8c63d7626c48322e9791d5ff72294049bde91e73f8 +e7d7a113b3a33175d0abd2cf4f9add8e41dc86c93c9552c5b3588277fbcaa24a ae159f3fa33619002ae6bcce8cbbdd7d28e5ed9d61534595c4c9f43c402a9bb31f3b301cbfd4a43ce4c24cd5c9849cc6259eca90e2a79e01ffbac07ba0e147fa42676a1d668570e0396387b5bcd599e8e66aaed1b8a191c5a47547f61373021fa6deadcb55363d233c24440f2c73dbb519f7c9fa5a8962efd5f6252c0407f190dfefad707f3c7007d69ff36b8489a5b6b7c557e79dd4f50c06511f599f56c896b35c917b63ba35c6ff8092baf7d1658e77fc95d8a6a43eeb4c01f33f03877f92774be89c1114dd531c011e53a34dc248a2f0e6 +3b40c1493af411ae7849904d478df2407254bf62b88e9bffd7b42bd2a60ce0fa 3b8e97c5ffc2d6a40fa7de7fcefc90f3b12c940e7ab415321e29ee692dfac799b009c99dcddb708fce5a178c5c35ee2b8617143edc4c40b4d313661f49abdd93cea79d117518805496fe6acf292c4c2a1f76b403a97d7c399daf85b46ad84e16246c67d6836757bde336c290d5d401e6c1386ab32797af6bb251e9b2d8fe754c47482b72e0b394eab76916126fd68ea7d65eb93d59f5b4c5ac40f7c3b37e7f3694f29424c24af8c8f0ef59cd9dbf1d28e0e10f799a6f78cad1d45b9db3d7dee4a7059abe99182714983b9c9d44d7f5643596d4f3 +feeb172aeab2f0deb748fb77801ca22d3ce99b7a9f9789e479b93d1f4b1d227f 3434ec31b10fafdbfeec0dd6bd94e80f7ba9dca19ef075f7eb017512af66d6a4bcf7d16ba0819a1892a6372f9b35bcc7ca8155ee19e8428bc22d214856ed5fa9374c3c09bde169602cc219679f65a1566fc7316f4cc3b631a18fb4449fa6afa16a3db2bc4212eff539c67cf184680826535589c7111d73bffce431b4c40492e763d9279560aaa38eb2dc14a212d723f994a1fe656ff4dd14551ce4e7c621b2aa5604a10001b2878a897a28a08095c325e10a26d2fb1a75bfd64c250309bb55a44f23bbac0d5516a1c687d3b41ef2fbbf9cc56d4739 +b240bc52b8af1b502e26bf1d5e75fe2663bfba503faf10f46754dc3d23cb61c1 7c7953d81c8d208fd1c97681d48f49dd003456de60475b84070ef4847c333b74575b1fc8d2a186964485a3b8634feaa3595aaa1a2f4595a7d6b6153563dee31bbac443c8a33eed6d5d956a980a68366c2527b550ee950250dfb691eacbd5d56ae14b970668be174c89df2fea43ae52f13142639c884fd62a3683c0c3792f0f24ab1318bcb27e21f4737fab62c77ea38bc8fd1cf41f7dab64c13febe7152bf5bb7ab5a78f5346d43cc741cb6f72b7b8980f268b68bf62abdfb1577a52438fe14b591498cc95f071228460c7c5d5ceb4a7bde588e7f21c +3ebace41f578fde6603e032fc1c7cfeef1cb79fe938a94d4c7b58b0ba4cb9720 7a6a4f4fdc59a1d223381ae5af498d74b7252ecf59e389e49130c7eaee626e7bd9897effd92017f4ccde66b0440462cdedfd352d8153e6a4c8d7a0812f701cc737b5178c2556f07111200eb627dbc299caa792dfa58f35935299fa3a3519e9b03166dffa159103ffa35e8577f7c0a86c6b46fe13db8e2cdd9dcfba85bdddcce0a7a8e155f81f712d8e9fe646153d3d22c811bd39f830433b2213dd46301941b59293fd0a33e2b63adbd95239bc01315c46fdb678875b3c81e053a40f581cfbec24a1404b1671a1b88a6d06120229518fb13a74ca0ac5ae +65eb4bd5ecca7164ce9b66727f112c1ac6120ddd200dcb5ce75b7487843fcdb8 d9faa14cebe9b7de551b6c0765409a33938562013b5e8e0e1e0a6418df7399d0a6a771fb81c3ca9bd3bb8e2951b0bc792525a294ebd1083688806fe5e7f1e17fd4e3a41d00c89e8fcf4a363caedb1acb558e3d562f1302b3d83bb886ed27b76033798131dab05b4217381eaaa7ba15ec820bb5c13b516dd640eaec5a27d05fdfca0f35b3a5312146806b4c0275bcd0aaa3b2017f346975db566f9b4d137f4ee10644c2a2da66deeca5342e236495c3c6280528bfd32e90af4cd9bb908f34012b52b4bc56d48cc8a6b59bab014988eabd12e1a0a1c2e170e7 +d7155f6d3a90801f5e547689389ff62a604c81b7c1583d9204ac6b0194f0e8dd 2d8427433d0c61f2d96cfe80cf1e932265a191365c3b61aaa3d6dcc039f6ba2ad52a6a8cc30fc10f705e6b7705105977fa496c1c708a277a124304f1fc40911e7441d1b5e77b951aad7b01fd5db1b377d165b05bbf898042e39660caf8b279fe5229d1a8db86c0999ed65e53d01ccbc4b43173ccf992b3a14586f6ba42f5fe30afa8ae40c5df29966f9346da5f8b35f16a1de3ab6de0f477d8d8660918060e88b9b9e9ca6a4207033b87a812dbf5544d39e4882010f82b6ce005f8e8ff6fe3c3806bc2b73c2b83afb704345629304f9f86358712e9fae3ca3e +aa7adaf16f39e398b4ab0ada037710556b720b0248d84817b2cfdf7600933595 5e19d97887fcaac0387e22c6f803c34a3dacd2604172433f7a8a7a526ca4a2a1271ecfc5d5d7be5ac0d85d921095350dfc65997d443c21c8094e0a3fefd2961bcb94aed03291ae310ccda75d8ace4bc7d89e7d3e5d1650bda5d668b8b50bfc8e608e184f4d3a9a2badc4ff5f07e0c0bc8a9f2e0b2a26fd6d8c550008faaab75fd71af2a424bec9a7cd9d83fad4c8e9319115656a8717d3b523a68ff8004258b9990ed362308461804ba3e3a7e92d8f2ffae5c2fba55ba5a3c27c0a2f71bd711d2fe1799c2adb31b200035481e9ee5c4adf2ab9c0fa50b23975cf +b195463fe22a160802be0a0464ee3ab4d2b117de517b331c7bf04c8ba90c6120 c8e976ab4638909387ce3b8d4e510c3230e5690e02c45093b1d297910abc481e56eea0f296f98379dfc9080af69e73b2399d1c143bee80ae1328162ce1ba7f6a8374679b20aacd380eb4e61382c99998704d62701afa914f9a2705cdb065885f50d086c3eb5753700c387118bb142f3e6da1e988dfb31ac75d7368931e45d1391a274b22f83ceb072f9bcabc0b216685bfd789f5023971024b1878a205442522f9ea7d8797a4102a3df41703768251fd5e017c85d1200a464118aa35654e7ca39f3c375b8ef8cbe7534dbc64bc20befb417cf60ec92f63d9ee7397 +9f9296c53e753a4de4e5c5a547f51763a96903b083fbc7a7828effe4763a7ce6 7145fa124b7429a1fc2231237a949ba7201bcc1822d3272de005b682398196c25f7e5cc2f289fbf44415f699cb7fe6757791b1443410234ae061edf623359e2b4e32c19bf88450432dd01caa5eb16a1dc378f391ca5e3c4e5f356728bddd4975db7c890da8bbc84cc73ff244394d0d48954978765e4a00b593f70f2ca082673a261ed88dbcef1127728d8cd89bc2c597e9102ced6010f65fa75a14ebe467fa57ce3bd4948b6867d74a9df5c0ec6f530cbf2ee61ce6f06bc8f2864dff5583776b31df8c7ffcb61428a56bf7bd37188b4a5123bbf338393af46eda85e6 +51de4090aec36f6c446476c709253272cab595d9887ca5d52a9b38086854d58f 7fdfadcc9d29bad23ae038c6c65cda1aef757221b8872ed3d75ff8df7da0627d266e224e812c39f7983e4558bfd0a1f2bef3feb56ba09120ef762917b9c093867948547aee98600d10d87b20106878a8d22c64378bf634f7f75900c03986b077b0bf8b740a82447b61b99fee5376c5eb6680ec9e3088f0bdd0c56883413d60c1357d3c811950e5890e7600103c916341b80c743c6a852b7b4fb60c3ba21f3bc15b8382437a68454779cf3cd7f9f90ccc8ef28d0b706535b1e4108eb5627bb45d719cb046839aee311ca1abdc8319e050d67972cb35a6b1601b25dbf487 +87a17400f919f2f53232b2205e1e8b14bd5698a76e74b9bdd5638a5c7ba5de1e 988638219fd3095421f826f56e4f09e356296b628c3ce6930c9f2e758fd1a80c8273f2f61e4daae65c4f110d3e7ca0965ac7d24e34c0dc4ba2d6ff0bf5bbe93b3585f354d7543cb542a1aa54674d375077f2d360a8f4d42f3db131c3b7ab7306267ba107659864a90c8c909460a73621d1f5d9d3fd95beb19b23db1cb6c0d0fba91d36891529b8bd8263caa1bab56a4affaed44962df096d8d5b1eb845ef31188b3e10f1af811a13f156beb7a288aae593ebd1471b624aa1a7c6adf01e2200b3d72d88a3aed3100c88231e41efc376906f0b580dc895f080fda5741db1cb +9742536c461d0c3503a6c943fa8105dbcd1e542f728d71ccc0517cffc232ea68 5aab62756d307a669d146aba988d9074c5a159b3de85151a819b117ca1ff6597f6156e80fdd28c9c3176835164d37da7da11d94e09add770b68a6e081cd22ca0c004bfe7cd283bf43a588da91f509b27a6584c474a4a2f3ee0f1f56447379240a5ab1fb77fdca49b305f07ba86b62756fb9efb4fc225c86845f026ea542076b91a0bc2cdd136e122c659be259d98e5841df4c2f60330d4d8cdee7bf1a0a244524eecc68ff2aef5bf0069c9e87a11c6e519de1a4062a10c83837388f7ef58598a3846f49d499682b683c4a062b421594fafbc1383c943ba83bdef515efcf10d +ae3bf0936497a2955df874b7f2685314c7606030b9c6e7bfb8a8dff9825957b5 47b8216aa0fbb5d67966f2e82c17c07aa2d6327e96fcd83e3de7333689f3ee79994a1bf45082c4d725ed8d41205cb5bcdf5c341f77facb1da46a5b9b2cbc49eadf786bcd881f371a95fa17df73f606519aea0ff79d5a11427b98ee7f13a5c00637e2854134691059839121fea9abe2cd1bcbbbf27c74caf3678e05bfb1c949897ea01f56ffa4dafbe8644611685c617a3206c7a7036e4ac816799f693dafe7f19f303ce4eba09d21e03610201bfc665b72400a547a1e00fa9b7ad8d84f84b34aef118515e74def11b9188bd1e1f97d9a12c30132ec2806339bdadacda2fd8b78 +5fe0216dcc1bdb48f3375b9173b7b232939aa2177c6d056e908c8f2b9293b030 8cff1f67fe53c098896d9136389bd8881816ccab34862bb67a656e3d98896f3ce6ffd4da73975809fcdf9666760d6e561c55238b205d8049c1cedeef374d1735daa533147bfa960b2cce4a4f254176bb4d1bd1e89654432b8dbe1a135c42115b394b024856a2a83dc85d6782be4b444239567ccec4b184d4548eae3ff6a192f343292ba2e32a0f267f31cc26719eb85245d415fb897ac2da433ee91a99424c9d7f1766a44171d1651001c38fc79294accc68ceb5665d36218454d3ba169ae058a831338c17743603f81ee173bfc0927464f9bd728dee94c6aeab7aae6ee3a627e8 +c339904ec865f24fb3f88f142a8786d770934e006eaeddbf45acbb6b38431021 eacd07971cff9b9939903f8c1d8cbb5d4db1b548a85d04e037514a583604e787f32992bf2111b97ac5e8a938233552731321522ab5e8583561260b7d13ebeef785b23a41fd8576a6da764a8ed6d822d4957a545d5244756c18aa80e1aad4d1f9c20d259dee1711e2cc8fd013169fb7cc4ce38b362f8e0936ae9198b7e838dcea4f7a5b9429bb3f6bbcf2dc92565e3676c1c5e6eb3dd2a0f86aa23edd3d0891f197447692794b3dfa269611ad97f72b795602b4fdb198f3fd3eb41b415064256e345e8d8c51c555dc8a21904a9b0f1ad0effab7786aac2da3b196507e9f33ca356427 +4ca8b7febdf0a8062e9b76185cf4165071bb30928c18f14338c305626789c6d3 23ac4e9a42c6ef45c3336ce6dfc2ff7de8884cd23dc912fef0f7756c09d335c189f3ad3a23697abda851a81881a0c8ccafc980ab2c702564c2be15fe4c4b9f10dfb2248d0d0cb2e2887fd4598a1d4acda897944a2ffc580ff92719c95cf2aa42dc584674cb5a9bc5765b9d6ddf5789791d15f8dd925aa12bffafbce60827b490bb7df3dda6f2a143c8bf96abc903d83d59a791e2d62814a89b8080a28060568cf24a80ae61179fe84e0ffad00388178cb6a617d37efd54cc01970a4a41d1a8d3ddce46edbba4ab7c90ad565398d376f431189ce8c1c33e132feae6a8cd17a61c630012 +23d2614420859b2f13ac084453dd35c33fe47c894dd50c087fd1653fcaeea00b 0172df732282c9d488669c358e3492260cbe91c95cfbc1e3fea6c4b0ec129b45f242ace09f152fc6234e1bee8aab8cd56e8b486e1dcba9c05407c2f95da8d8f1c0af78ee2ed82a3a79ec0cb0709396ee62aadb84f8a4ee8a7ccca3c1ee84e302a09ea802204afecf04097e67d0f8e8a9d2651126c0a598a37081e42d168b0ae8a71951c524259e4e2054e535b779679bdade566fe55700858618e626b4a0faf895bcce9011504a49e05fd56127eae3d1f8917afb548ecadabda1020111fec9314c413498a360b08640549a22cb23c731ace743252a8227a0d2689d4c6001606678dfb921 +5590bb75247d7cd0b35620f0062b90ffb2a24de41220ed629d9e9a7abcadfb51 3875b9240cf3e0a8b59c658540f26a701cf188496e2c2174788b126fd29402d6a75453ba0635284d08835f40051a2a9683dc92afb9383719191231170379ba6f4adc816fecbb0f9c446b785bf520796841e58878b73c58d3ebb097ce4761fdeabe15de2f319dfbaf1742cdeb389559c788131a6793e193856661376c81ce9568da19aa6925b47ffd77a43c7a0e758c37d69254909ff0fbd415ef8eb937bcd49f91468b49974c07dc819abd67395db0e05874ff83dddab895344abd0e7111b2df9e58d76d85ad98106b36295826be04d435615595605e4b4bb824b33c4afeb5e7bb0d19f909 +e5932441b012e503b0b0c6104703ba02613e472ad65655c085b0adb07656b28f 747cc1a59fefba94a9c75ba866c30dc5c1cb0c0f8e9361d98484956dd5d1a40f6184afbe3dac9f76028d1caeccfbf69199c6ce2b4c092a3f4d2a56fe5a33a00757f4d7dee5dfb0524311a97ae0668a47971b95766e2f6dd48c3f57841f91f04a00ad5ea70f2d479a2620dc5cd78eaab3a3b011719b7e78d19ddf70d9423798af77517ebc55392fcd01fc600d8d466b9e7a7a85bf33f9cc5419e9bd874ddfd60981150ddaf8d7febaa4374f0872a5628d318000311e2f5655365ad4d407c20e5c04df17a222e7deec79c5ab1116d8572f91cd06e1ccc7ced53736fc867fd49ecebe6bf8082e8a +21c0d84eb7b61774f97db5d9acf1dffafb662c01ed291a442bec6f14d1334699 57af971fccaec97435dc2ec9ef0429bcedc6b647729ea168858a6e49ac1071e706f4a5a645ca14e8c7746d65511620682c906c8b86ec901f3dded4167b3f00b06cbfac6aee3728051b3e5ff10b4f9ed8bd0b8da94303c833755b3ca3aeddf0b54bc8d6632138b5d25bab03d17b3458a9d782108006f5bb7de75b5c0ba854b423d8bb801e701e99dc4feaad59bc1c7112453b04d33ea3635639fb802c73c2b71d58a56bbd671b18fe34ed2e3dca38827d63fdb1d4fb3285405004b2b3e26081a8ff08cd6d2b08f8e7b7e90a2ab1ed7a41b1d0128522c2f8bff56a7fe67969422ce839a9d4608f03 +0d1e6bb88188b49af0a9a05eb1af94255e6799515a2f8eb46aa6af9a9dd5b9e0 04e16dedc1227902baaf332d3d08923601bdd64f573faa1bb7201918cfe16b1e10151dae875da0c0d63c59c3dd050c4c6a874011b018421afc4623ab0381831b2da2a8ba42c96e4f70864ac44e106f94311051e74c77c1291bf5db9539e69567bf6a11cf6932bbbad33f8946bf5814c066d851633d1a513510039b349939bfd42b858c21827c8ff05f1d09b1b0765dc78a135b5ca4dfba0801bcaddfa175623c8b647eacfb4444b85a44f73890607d06d507a4f8393658788669f6ef4deb58d08c50ca0756d5e2f49d1a7ad73e0f0b3d3b5f090acf622b1878c59133e4a848e05153592ea81c6fbf +935ded24f5cecc69e1f012b60b7831abce7ef50eeb0bea7f816c3dbf2b4abdc1 7c815c384eee0f288ece27cced52a01603127b079c007378bc5d1e6c5e9e6d1c735723acbbd5801ac49854b2b569d4472d33f40bbb8882956245c366dc3582d71696a97a4e19557e41e54dee482a14229005f93afd2c4a7d8614d10a97a9dfa07f7cd946fa45263063ddd29db8f9e34db60daa32684f0072ea2a9426ecebfa5239fb67f29c18cbaa2af6ed4bf4283936823ac1790164fec5457a9cba7c767ca59392d94cab7448f50eb34e9a93a80027471ce59736f099c886dea1ab4cba4d89f5fc7ae2f21ccd27f611eca4626b2d08dc22382e92c1efb2f6afdc8fdc3d2172604f5035c46b8197d3 +6755bf7e60e4e07965bac24e51b1de93e3dd42ae780f256647d4cc2ef8eff771 e29d505158dbdd937d9e3d2145658ee6f5992a2fc790f4f608d9cdb44a091d5b94b88e81fac4fdf5c49442f13b911c55886469629551189eaff62488f1a479b7db11a1560e198ddccccf50159093425ff7f1cb8d1d1246d0978764087d6bac257026b090efae8cec5f22b6f21c59ace1ac7386f5b8837ca6a12b6fbf5534dd0560ef05ca78104d3b943ddb220feaec89aa5e692a00f822a2ab9a2fe60350d75e7be16ff2526dc643872502d01f42f188abed0a6e9a6f5fd0d1ce7d5755c9ffa66b0af0b20bd806f08e06156690d81ac811778ca3dac2c249b96002017fce93e507e3b953acf99964b847 +62c9f5e5b56e2994327a7f9a03888da7bad67e387593803b1807482b137b4509 d85588696f576e65eca0155f395f0cfacd83f36a99111ed5768df2d116d2121e32357ba4f54ede927f189f297d3a97fad4e9a0f5b41d8d89dd7fe20156799c2b7b6bf9c957ba0d6763f5c3bc5129747bbb53652b49290cff1c87e2cdf2c4b95d8aaee09bc8fbfa6883e62d237885810491bfc101f1d8c636e3d0ede838ad05c207a3df4fad76452979eb99f29afaecedd1c63b8d36cf378454a1bb67a741c77ac6b6b3f95f4f02b64dabc15438613ea49750df42ee90101f115aa9abb9ff64324dde9dabbb01054e1bd6b4bcdc7930a44c2300d87ca78c06924d0323ad7887e46c90e8c4d100acd9eed21e +9927fa5efd86304e73d54aa4928818c05b01504672c529471394a82e049e5f95 3a12f8508b40c32c74492b66323375dcfe49184c78f73179f3314b79e63376b8ac683f5a51f1534bd729b02b04d002f55cbd8e8fc9b5ec1ea6bbe6a0d0e7431518e6ba45d124035f9d3dce0a8bb7bf1430a9f657e0b4ea9f20eb20c786a58181a1e20a96f1628f8728a13bdf7a4b4b32fc8aa7054cc4881ae7fa19afa65c6c3ee1b3ade3192af42054a8a911b8ec1826865d46d93f1e7c5e2b7813c92a506e53886f3d4701bb93d2a681ad109c845904bb861af8af0646b6e399b38b614051d34f6842563a0f37ec00cb3d865fc5d746c4987de2a65071100883a2a9c7a2bfe1e2dd603d9ea24dc7c5fd06be +84e056bf7bdfc73a3aaa95b00a74a136d776069beeb304423bead90120db6350 1861edce46fa5ad17e1ff1deae084dec580f97d0a67885dfe834b9dfac1ae076742ce9e267512ca51f6df5a455af0c5fd6abf94acea103a3370c354485a7846fb84f3ac7c2904b5b2fbf227002ce512133bb7e1c4e50057bfd1e44db33c7cdb969a99e284b184f50a14b068a1fc5009d9b298dbe92239572a7627aac02abe8f3e3b473417f36d4d2505d16b7577f4526c9d94a270a2dfe450d06da8f6fa956879a0a55cfe99e742ea555ea477ba3e9b44ccd508c375423611af92e55345dc215779b2d5119eba49c71d49b9fe3f1569fa24e5ca3e332d042422a8b8158d3ec66a80012976f31ffdf305f0c9c5e +401c3be59cc373453aef9603f7335c1d5fe669909a1425d7671dcb84a49887ca 08d0ffde3a6e4ef65608ea672e4830c12943d7187ccff08f4941cfc13e545f3b9c7ad5eebbe2b01642b486caf855c2c73f58c1e4e3391da8e2d63d96e15fd84953ae5c231911b00ad6050cd7aafdaac9b0f663ae6aab45519d0f5391a541707d479034e73a6ad805ae3598096af078f1393301493d663dd71f83869ca27ba508b7e91e81e128c1716dc3acfe3084b2201e04cf8006617eecf1b640474a5d45cfde9f4d3ef92d6d055b909892194d8a8218db6d8203a84261d200d71473d7488f3427416b6896c137d455f231071cacbc86e0415ab88aec841d96b7b8af41e05bb461a40645bf176601f1e760de5f +020485dcd264296afdb7f643ca828c93356f1714cbcc2fbbdd30f9896c3f2789 d782abb72a5be3392757be02d3e45be6e2099d6f000d042c8a543f50ed6ebc055a7f133b0dd8e9bc348536edcaae2e12ec18e8837df7a1b3c87ec46d50c241dee820fd586197552dc20beea50f445a07a38f1768a39e2b2ff05dddedf751f1def612d2e4d810daa3a0cc904516f9a43af660315385178a529e51f8aae141808c8bc5d7b60cac26bb984ac1890d0436ef780426c547e94a7b08f01acbfc4a3825eae04f520a9016f2fb8bf5165ed12736fc71e36a49a73614739eaa3ec834069b1b40f1350c2b3ab885c02c640b9f7686ed5f99527e41cfcd796fe4c256c9173186c226169ff257954ebda81c0e5f99 +f8c43e28816bb41993bdb866888f3cc59efba208390144d3878dbf9fbfa1d57e 5fce8109a358570e40983e1184e541833bb9091e280f258cfb144387b05d190e431cb19baa67273ba0c58abe91308e1844dcd0b3678baa42f335f2fa05267a0240b3c718a5942b3b3e3bfa98a55c25a1466e8d7a603722cb2bbf03afa54cd769a99f310735ee5a05dae2c22d397bd95635f58c48a67f90e1b73aafcd3f82117f0166657838691005b18da6f341d6e90fc1cdb352b30fae45d348294e501b63252de14740f2b85ae5299ddec3172de8b6d0ba219a20a23bb5e10ff434d39db3f583305e9f5c039d98569e377b75a70ab837d1df269b8a4b566f40bb91b577455fd3c356c914fa06b9a7ce24c7317a172d +4ea524e705020284b18284e34683725590e1ee565a6ff598ed4d42b1c987471e 6172f1971a6e1e4e6170afbad95d5fec99bf69b24b674bc17dd78011615e502de6f56b86b1a71d3f4348087218ac7b7d09302993be272e4a591968aef18a1262d665610d1070ee91cc8da36e1f841a69a7a682c580e836941d21d909a3afc1f0b963e1ca5ab193e124a1a53df1c587470e5881fb54dae1b0d840f0c8f9d1b04c645ba1041c7d8dbf22030a623aa15638b3d99a2c400ff76f3252079af88d2b37f35ee66c1ad7801a28d3d388ac450b97d5f0f79e4541755356b3b1a5696b023f39ab7ab5f28df4202936bc97393b93bc915cb159ea1bd7a0a414cb4b7a1ac3af68f50d79f0c9c7314e750f7d02faa58bfa +e4963e74ae01ff7774b96b4f614d1cb2a4cf8d206ed93c66fa42f71432be2c3f 5668ecd99dfbe215c4118398ac9c9eaf1a1433fab4ccdd3968064752b625ea944731f75d48a27d047d67547f14dd0ffaa55fa5e29f7af0d161d85eafc4f2029b717c918eab9d304543290bdba7158b68020c0ba4e079bc95b5bc0fc044a992b94b4ccd3bd66d0eabb5dbbab904d62e00752c4e3b0091d773bcf4c14b4377da3efff824b1cb2fa01b32d1e46c909e626ed2dae920f4c7dbeb635bc754facbd8d49beba3f23c1c41ccbfcd0ee0c114e69737f5597c0bf1d859f0c767e18002ae8e39c26261ffde2920d3d0baf0e906138696cfe5b7e32b600f45df3aaa39932f3a7df95b60fa8712a2271fcaf3911ce7b511b1 +0f0d72bf8c0198459e45ece9cc18e930cb86263accf1fc7a00bc857ac9f201ad 03d625488354df30e3f875a68edfcf340e8366a8e1ab67f9d5c5486a96829dfac0578289082b2a62117e1cf418b43b90e0adc881fc6ae8105c888e9ecd21aea1c9ae1a4038dfd17378fed71d02ae492087d7cdcd98f746855227967cb1ab4714261ee3bead3f4db118329d3ebef4bc48a875c19ba763966da0ebea800e01b2f50b00e9dd4caca6dcb314d00184ef71ea2391d760c950710db4a70f9212ffc54861f9dc752ce18867b8ad0c48df8466ef7231e7ac567f0eb55099e622ebb86cb237520190a61c66ad34f1f4e289cb3282ae3eaac6152ed24d2c92bae5a7658252a53c49b7b02dfe54fdb2e90074b6cf310ac661 +dd1d2a92b3f3f3902f064365838e1f5f3468730c343e2974e7a9ecfcd84aa6db 2edc282ffb90b97118dd03aaa03b145f363905e3cbd2d50ecd692b37bf000185c651d3e9726c690d3773ec1e48510e42b17742b0b0377e7de6b8f55e00a8a4db4740cee6db0830529dd19617501dc1e9359aa3bcf147e0a76b3ab70c4984c13e339e6806bb35e683af8527093670859f3d8a0fc7d493bcba6bb12b5f65e71e705ca5d6c948d66ed3d730b26db395b3447737c26fad089aa0ad0e306cb28bf0acf106f89af3745f0ec72d534968cca543cd2ca50c94b1456743254e358c1317c07a07bf2b0eca438a709367fafc89a57239028fc5fecfd53b8ef958ef10ee0608b7f5cb9923ad97058ec067700cc746c127a61ee3 +21bf20664cec2cd2ceb1dffc1d78893d5ca1a7da88eb6bfd0c6efca6190c9e15 90b28a6aa1fe533915bcb8e81ed6cacdc10962b7ff82474f845eeb86977600cf70b07ba8e3796141ee340e3fce842a38a50afbe90301a3bdcc591f2e7d9de53e495525560b908c892439990a2ca2679c5539ffdf636777ad9c1cdef809cda9e8dcdb451abb9e9c17efa4379abd24b182bd981cafc792640a183b61694301d04c5b3eaad694a6bd4cc06ef5da8fa23b4fa2a64559c5a68397930079d250c51bcf00e2b16a6c49171433b0aadfd80231276560b80458dd77089b7a1bbcc9e7e4b9f881eacd6c92c4318348a13f4914eb27115a1cfc5d16d7fd94954c3532efaca2cab025103b2d02c6fd71da3a77f417d7932685888a +6472d7c530b548e4b47d2278d7172b421a0fb6398a2823dd2f2b26208af8942e 2969447d175490f2aa9bb055014dbef2e6854c95f8d60950bfe8c0be8de254c26b2d31b9e4de9c68c9adf49e4ee9b1c2850967f29f5d08738483b417bb96b2a56f0c8aca632b552059c59aac3f61f7b45c966b75f1d9931ff4e596406378cee91aaa726a3a84c33f37e9cdbe626b5745a0b06064a8a8d56e53aaf102d23dd9df0a3fdf7a638509a6761a33fa42fa8ddbd8e16159c93008b53765019c3f0e9f10b144ce2ac57f5d7297f9c9949e4ff68b70d339f87501ce8550b772f32c6da8ad2ce2100a895d8b08fa1eead7c376b407709703c510b50f87e73e43f8e7348f87c3832a547ef2bbe5799abedcf5e1f372ea809233f006 +2ac7ff80ee36d500995c973b8746d8466715e6d8b0f554aacb5d2876d7f5b874 721645633a44a2c78b19024eaecf58575ab23c27190833c26875dc0f0d50b46aea9c343d82ea7d5b3e50ec700545c615daeaea64726a0f05607576dcd396d812b03fb6551c641087856d050b10e6a4d5577b82a98afb89cee8594c9dc19e79feff0382fcfd127f1b803a4b9946f4ac9a4378e1e6e041b1389a53e3450cd32d9d2941b0cbabdb50da8ea2513145164c3ab6bcbd251c448d2d4b087ac57a59c2285d564f16da4ed5e607ed979592146ffb0ef3f3db308fb342df5eb5924a48256fc763141a278814c82d6d6348577545870ae3a83c7230ac02a1540fe1798f7ef09e335a865a2ae0949b21e4f748fb8a51f44750e213a8fb +9ff81d575f7bf0c4ef340b4279d56e16ce68821afcdf2a69105d4f9cadadd3cf 6b860d39725a14b498bb714574b4d37ca787404768f64c648b1751b353ac92bac2c3a28ea909fdf0423336401a02e63ec24325300d823b6864bb701f9d7c7a1f8ec9d0ae3584aa6dd62ea1997cd831b4babd9a4da50932d4efda745c61e4130890e156aee6113716daf95764222a91187db2effea49d5d0596102d619bd26a616bbfda8335505fbb0d90b4c180d1a2335b91538e1668f9f9642790b4e55f9cab0fe2bdd2935d001ee6419abab5457880d0dbff20ed8758f4c20fe759efb33141cf0e892587fe8187e5fbc57786b7e8b089612c936dfc03d27efbbe7c8673f1606bd51d5ff386f4a7ab68edf59f385eb1291f117bfe717399 +09edc465d4fd91c5e86b292f041bcc17571e1f2e17d584dff21dd7dd8d8bff35 6a01830af3889a25183244decb508bd01253d5b508ab490d3124afbf42626b2e70894e9b562b288d0a2450cfacf14a0ddae5c04716e5a0082c33981f6037d23d5e045ee1ef2283fb8b6378a914c5d9441627a722c282ff452e25a7ea608d69cee4393a0725d17963d0342684f255496d8a18c2961145315130549311fc07f0312fb78e6077334f87eaa873bee8aa95698996eb21375eb2b4ef53c14401207deb4568398e5dd9a7cf97e8c9663e23334b46912f8344c19efcf8c2ba6f04325f1a27e062b62a58d0766fc6db4d2c6a1928604b0175d872d16b7908ebc041761187cc785526c2a3873feac3a642bb39f5351550af9770c328af7b +c6d86cc4ccef3bb70bf7bfddec6a9a04a0dd0a68fe1bf51c14648cf506a03e98 b3c5e74b69933c2533106c563b4ca20238f2b6e675e8681e34a389894785bdade59652d4a73d80a5c85bd454fd1e9ffdad1c3815f5038e9ef432aac5c3c4fe840cc370cf86580a6011778bbedaf511a51b56d1a2eb68394aa299e26da9ada6a2f39b9faff7fba457689b9c1a577b2a1e505fdf75c7a0a64b1df81b3a356001bf0df4e02a1fc59f651c9d585ec6224bb279c6beba2966e8882d68376081b987468e7aed1ef90ebd090ae825795cdca1b4f09a979c8dfc21a48d8a53cdbb26c4db547fc06efe2f9850edd2685a4661cb4911f165d4b63ef25b87d0a96d3dff6ab0758999aad214d07bd4f133a6734fde445fe474711b69a98f7e2b +1afc9ba63eea27603b3a7a5562e12b31e8fe9a96812b531e9d048385fb76d44f 83af34279ccb5430febec07a81950d30f4b66f484826afee7456f0071a51e1bbc55570b5cc7ec6f9309c17bf5befdd7c6ba6e968cf218a2b34bd5cf927ab846e38a40bbd81759e9e33381016a755f699df35d660007b5eadf292feefb735207ebf70b5bd17834f7bfa0e16cb219ad4af524ab1ea37334aa66435e5d397fc0a065c411ebbce32c240b90476d307ce802ec82c1c49bc1bec48c0675ec2a6c6f3ed3e5b741d13437095707c565e10d8a20b8c20468ff9514fcf31b4249cd82dcee58c0a2af538b291a87e3390d737191a07484a5d3f3fb8c8f15ce056e5e5f8febe5e1fb59d6740980aa06ca8a0c20f5712b4cde5d032e92ab89f0ae1 +9b5e15531385f0d495fdbe686e3e02eca42b9f1b1ce8837ad3b3e42e6198050a a7ed84749ccc56bb1dfba57119d279d412b8a986886d810f067af349e8749e9ea746a60b03742636c464fc1ee233acc52c1983914692b64309edfdf29f1ab912ec3e8da074d3f1d231511f5756f0b6eead3e89a6a88fe330a10face267bffbfc3e3090c7fd9a850561f363ad75ea881e7244f80ff55802d5ef7a1a4e7b89fcfa80f16df54d1b056ee637e6964b9e0ffd15b6196bdd7db270c56b47251485348e49813b4eb9ed122a01b3ea45ad5e1a929df61d5c0f3e77e1fdc356b63883a60e9cbb9fc3e00c2f32dbd469659883f690c6772e335f617bc33f161d6f6984252ee12e62b6000ac5231e0c9bc65be223d8dfd94c5004a101af9fd6c0fb +216fc325f942eed08401527a8f41c088527c6479342622c907ea08ff3290f8c6 a6fe30dcfcda1a329e82ab50e32b5f50eb25c873c5d2305860a835aecee6264aa36a47429922c4b8b3afd00da16035830edb897831c4e7b00f2c23fc0b15fdc30d85fb70c30c431c638e1a25b51caf1d7e8b050b7f89bfb30f59f0f20fecff3d639abc4255b3868fc45dd81e47eb12ab40f2aac735df5d1dc1ad997cefc4d836b854cee9ac02900036f3867fe0d84afff37bde3308c2206c62c4743375094108877c73b87b2546fe05ea137bedfc06a2796274099a0d554da8f7d7223a48cbf31b7decaa1ebc8b145763e3673168c1b1b715c1cd99ecd3ddb238b06049885ecad9347c2436dff32c771f34a38587a44a82c5d3d137a03caa27e66c8ff6 +43184b9f2db5b6da5160bc255dbe19a0c94533b884809815b7b326d868589edc 83167ff53704c3aa19e9fb3303539759c46dd4091a52ddae9ad86408b69335989e61414bc20ab4d01220e35241eff5c9522b079fba597674c8d716fe441e566110b6211531ceccf8fd06bc8e511d00785e57788ed9a1c5c73524f01830d2e1148c92d0edc97113e3b7b5cd3049627abdb8b39dd4d6890e0ee91993f92b03354a88f52251c546e64434d9c3d74544f23fb93e5a2d2f1fb15545b4e1367c97335b0291944c8b730ad3d4789273fa44fb98d78a36c3c3764abeeac7c569c1e43a352e5b770c3504f87090dee075a1c4c85c0c39cf421bdcc615f9eff6cb4fe6468004aece5f30e1ecc6db22ad9939bb2b0ccc96521dfbf4ae008b5b46bc006e +348fb774adc970a16b1105669442625e6adaa8257a89effdb5a802f161b862ea 3a3a819c48efde2ad914fbf00e18ab6bc4f14513ab27d0c178a188b61431e7f5623cb66b23346775d386b50e982c493adbbfc54b9a3cd383382336a1a0b2150a15358f336d03ae18f666c7573d55c4fd181c29e6ccfde63ea35f0adf5885cfc0a3d84a2b2e4dd24496db789e663170cef74798aa1bbcd4574ea0bba40489d764b2f83aadc66b148b4a0cd95246c127d5871c4f11418690a5ddf01246a0c80a43c70088b6183639dcfda4125bd113a8f49ee23ed306faac576c3fb0c1e256671d817fc2534a52f5b439f72e424de376f4c565cca82307dd9ef76da5b7c4eb7e085172e328807c02d011ffbf33785378d79dc266f6a5be6bb0e4a92eceebaeb1 +ea0e416c0f7b4f11e3f00479fddf954f2539e5e557753bd546f69ee375a5de29 724627916c50338643e6996f07877eafd96bdf01da7e991d4155b9be1295ea7d21c9391f4c4a41c75f77e5d27389253393725f1427f57914b273ab862b9e31dabce506e558720520d33352d119f699e784f9e548ff91bc35ca147042128709820d69a8287ea3257857615eb0321270e94b84f446942765ce882b191faee7e1c87e0f0bd4e0cd8a927703524b559b769ca4ece1f6dbf313fdcf67c572ec4185c1a88e86ec11b6454b371980020f19633b6b95bd280e4fbcb0161e1a82470320cec6ecfa25ac73d09f1536f286d3f9dacafb2cd1d0ce72d64d197f5c7520b3ccb2fd74eb72664ba93853ef41eabf52f015dd591500d018dd162815cc993595b195 +59e904b2aa0ccbf2a9d127446f113b7cc3d07b970e07a322325ecee66ae0c9ca 3139840b8ad4bcd39092916fd9d01798ff5aa1e48f34702c72dfe74b12e98a114e318cdd2d47a9c320fff908a8dbc2a5b1d87267c8e983829861a567558b37b292d4575e200de9f1de45755faff9efae34964e4336c259f1e66599a7c904ec02539f1a8eab8706e0b4f48f72fec2794909ee4a7b092d6061c74481c9e21b9332dc7c6e482d7f9cc3210b38a6f88f7918c2d8c55e64a428ce2b68fd07ab572a8b0a2388664f99489f04eb54df1376271810e0e7bce396f52807710e0dea94eb49f4b367271260c3456b9818fc7a72234e6bf2205ff6a36546205015ebd7d8c2527aa430f58e0e8ac97a7b6b793cd403d517d66295f37a34d0b7d2fa7bc345ac04ca1e266480deec39f5c88641c9dc0bd1358158fdecdd96685bbbb5c1fe5ea89d2cb4a9d5d12bb8c893281ff38e87d6b4841f0650092d447e013f20ea934e18 +6c2a841318066b90a9604d0c8eccb2986b84a0c8675cd243e96957d26e9c1cfd 023d91ac532601c7ca3942d62827566d9268bb4276fcaa1ae927693a6961652676dba09219a01b3d5adfa12547a946e78f3c5c62dd880b02d2eeeb4b96636529c6b01120b23efc49ccfb36b8497cd19767b53710a636683bc5e0e5c9534cfc004691e87d1bee39b86b953572927bd668620eab87836d9f3f8f28ace41150776c0bc6657178ebf297fe1f7214edd9f215ffb491b681b06ac2032d35e6fdf832a8b06056da70d77f1e9b4d26ae712d8523c86f79250718405f91b0a87c725f2d3f52088965f887d8cf87206dfde422386e58edda34dde2783b3049b86917b4628027a05d4d1f429d2b49c4b1c898dddcb82f343e145596de11a54182f39f4718ecae8f506bd9739f5cd5d5686d7fefc834514cd1b2c91c33b381b45e2e5335d7a8720a8f17afc8c2cb2bd88b14aa2dca099b00aa575d0a0ccf099cdec4870fb710d2680e60c48bfc291ff0cef2eebf9b36902e9fba8c889bf6b4b9f5ce53a19b0d9399cd19d61bd08c0c2ec25e099959848e6a550ca7137b63f43138d7b651 +0ec8d9d20ddf0a7b0251e941a7261b557507ff6287b504362a8f1734c5a91012 20ff454369a5d05b81a78f3db05819fea9b08c2384f75cb0ab6aa115dd690da3131874a1ca8f708ad1519ea952c1e249cb540d196392c79e87755424fee7c890808c562722359eea52e8a12fbbb969dd7961d2ba52037493755a5fa04f0d50a1aa26c9b44148c0d3b94d1c4a59a31aca15ae8bd44acb7833d8e91c4b86fa3135a423387b8151b4133ed23f6d7187b50ec2204ad901ad74d396e44274e0ecafaae17b3b9085e22260b35ca53b15cc52abba758af6798fbd04eceeced648f3af4fdb3ded7557a9a5cfb7382612a8a8f3f45947d1a29ce29072928ec193ca25d51071bd5e1984ecf402f306ea762f0f25282f5296d997658be3f983696ffa6d095c6369b4daf79e9a5d3136229128f8eb63c12b9e9fa78aff7a3e9e19a62022493cd136defbb5bb7ba1b938f367fd2f63eb5ca76c0b0ff21b9e36c3f07230cf3c3074e5da587040a76975d7e39f4494ace5486fcbf380ab7558c4fe89656335b82e4db8659509eab46a19613126e594042732dd4c411f41aa8cdeac71c0fb40a94e6da558c05e77b6182806f26d9afdf3da00c69419222c8186a6efad600b410e6ce2f2a797e49dc1f135319801fa6f396b06f975e2a190a023e474b618e7 +0ea33e2e34f572440640244c7f1f5f04697ce97139bda72a6558d8663c02b388 4fbdc596508d24a2a0010e140980b809fb9c6d55ec75125891dd985d37665bd80f9beb6a50207588abf3ceee8c77cd8a5ad48a9e0aa074ed388738362496d2fb2c87543bb3349ea64997ce3e7b424ea92d122f57dbb0855a803058437fe08afb0c8b5e7179b9044bbf4d81a7163b3139e30888b536b0f957eff99a7162f4ca5aa756a4a982dfadbf31ef255083c4b5c6c1b99a107d7d3afffdb89147c2cc4c9a2643f478e5e2d393aea37b4c7cb4b5e97dadcf16b6b50aae0f3b549ece47746db6ce6f67dd4406cd4e75595d5103d13f9dfa79372924d328f8dd1fcbeb5a8e2e8bf4c76de08e3fc46aa021f989c49329c7acac5a688556d7bcbcb2a5d4be69d3284e9c40ec4838ee8592120ce20a0b635ecadaa84fd5690509f54f77e35a417c584648bc9839b974e07bfab0038e90295d0b13902530a830d1c2bdd53f1f9c9faed43ca4eed0a8dd761bc7edbdda28a287c60cd42af5f9c758e5c7250231c09a582563689afc65e2b79a7a2b68200667752e9101746f03184e2399e4ed8835cb8e9ae90e296af220ae234259fe0bd0bcc60f7a4a5ff3f70c5ed4de9c8c519a10e962f673c82c5e9351786a8a3bfd570031857bd4c87f4fca31ed4d50e14f2107da02cb5058700b74ea241a8b41d78461658f1b2b90bfd84a4c2c9d6543861ab3c56451757dcfb9ba60333488dbdd02d601b41aae317ca7474eb6e6dd +d31038ec77ccad00af3d9d5e9f5ce717f5945bde71c87cea837be4b360de595a fe06a4706468b369f7624f62d04f9fac020f05152f13e350016b2a29efff9a393940c138553356b0e2848c01b622b95ffa11ab07585f7dcbbf90e9f8ec5fa2fb7b4cee0d0a4e8d33490abd058cf3bb85f0cd9b1bd3e9823082d70b1a92aca6f2c87216b4ba09feddcaa4cf254336146cc75604fb1f286918fa2434ca36be2621049438a400bdeea6c657f0301503cd7e6e38350838f60ea7f001755da4142ce4579b39029da83f1646b7ecb9947ee89aba377099b82026960b9ee600779bf00d6eb0cd09226db6915a7aded27e6749e2cbc2c8b030ce1850ebfbe24c0658f29e9e709cd10db8a77efdefc90fdd7b9ad7a7e0334412a53d248c4c12bf2987b7accd2a8a602f184583aa560c016093b56b100154477b834664e6b85a19f8dc909b4d79816af12266c731e29a304e9bed8ef1c8030365b7deaf3d436957308117c7c5767e0cda6e342ddaf824233cbf4e699dc667357cb35c602ac6bddee71b352af55cb93941a1a6301a9904447af9ee486114d57ae03901f10084adc0096e465e2ead2496273112f2fae626e230d42ec22ea10a8289b3e35eee42150769d6e663a3ca29174316ec93a24f148d984053b8f98664eaca3e0dea0b42e8ee30f81a2cd6e42c189a25fecb6e643e693e1f8871b837c3f5ff2aafd1650a465dc8e5c1993be65cffd87f2c680c86b0ad3118834a5f2e490015137ba945c2775dbd77fb3e5c67819a9a7a94a656fc4761659c5b30ed2ac55a6d249b700bc9c93d590490aaaaa75a9fc34a90d5a9106f2860bde19fe5815436068a7f8ea4636a +e4e3bb662be094610f04d5594eef5f78b1ab080f2ebe5acf41d661fa13a68dbd d0ff6e045f4b636f75a389799f314066644854821b6e7ae4047adfde2d0c0e02c250f0be582bec94011189b964a8af430f5921ed9d9f4446e4c788515b89ca69e5f7cdfccc9e83e8f9460145b43ddc41c07cc512b7e6fdd0e1e7aaba29a6c016ccb7bd54b145f3951eab9bc4908f623e5a9b0c5b36056292540b79fd15c53457dc74a65fd773a34d6b313a056f79bc29a3fac15f6a1446bfaeeaafbac8ecf8168dde5f6ae6b6e579bd3ce74e7abfadf361d0fd32d56586a8d2d4ff4cfdf8a750fafde4c2e9eb32b06847fa30b13cc273532d1a23c8257f80c60b8fa94fa976f534145cd61c41c0a511b62cadd5848ceff643f83ce43f8e6969c5a559afad60e310599a34b2e5e029fbddf2988fce59269c7128a1fc79a74b154d8aa2850dcfdbf594684e74099e37882b440367c1dd3003f61cafb46ac75d30e677af54559a5dab70c506cf61a9c35e0e56e1430746916ddeec8d89b0c10daa02c5d7e9f42621d2b312eaffc9ff306297952a32d26c2148570aec90501ca739ce5e689e7066d9580a4fc25e2023897c74c6856273133e1275a0d275dc5b75db724cd12c9c01bb95ab5a227b7850020630506096878d289923177183ea9282a4c78ec212d2e898cb99d81a3364df20927ee34d4475a5cf5cdb24088ed75b60201922e9c972d8556ca75f8274d15f3fb88a6b42c766def6b21329dee7c457446dde8c26405fe5d0309a04229f449e8490cf9000ee8df400cb7c7ee831bd7059d24088fb42d61681cde45050fca78ff64d9c8d1f58b55f802fa5d2f2e723f3e4eed4338b060d31c8acc46d26870bd45d0de0798d48e32aad1a6d4322e69f5e72309b9d7fa1f24bb1d63ff09ed47391c232497bf222c542a70975c8292d275197a4ca +6e1bb4d034e9b9816ed1a846f903f62cb1bdb8a00d446c9cc777e475a327c58d c9a0b51f3199339c11a5753c9d9c95104b400127087177f14d3e15be881ee89bf416f97d4f7aa9636c5ef29ebbf8930804006eb26839415d3984b920882499752c36a5bbd583308e716db16f28db98b3a3e718a2ebcdfefa75d7ccbb6a746e32feaa38d034843461dbcfca7f983e19f5b23ec2e3d74d2b4402f3bdce7d7a9df1384668c746cce466b0654cdd5ca56a77d68a100ae06d63cd9af512aebae78993808ce672330e2065c0f71e05c0fe821cd5f85732315f04666f3e4e6c4f3e9f415e31fe0980d874994108e12464609c6d5c19cedfc85846b0a84ef3ccbd3b655fb0de8cb892bdf774df39c955f04f322856d470981beed0f752d82ead73b4131c5dbf0424b4ab654f72e26ef0cd292b87bd5b66fbd5e7eba96c62cffefd4b1d870bfef312b86e38ed5c0f50935e2ecf9fcb8c95d35d19a8fc8f202bd9dba768ca48fbbb071179413c0de4fde86762ed4b13e1eef2a00add5d1c2a3af7937787debaf1f6f12f3f0225ffe587a5540cb550f7bc11dd6af864d6b6d16db1488cb226ebb2199da75fdd59a71158867298f63961b40a31209f8f16629b1cce7ffb617072748fde8920d11cc0d0678389d1f719df3ed19846fe9893b04db60fa603170d9573b1bfc7da663e07254552ab6253dde814117185f84373fecd7f98ded170c884d41d1ac81814c73ea48ad94eca1b7733d8393e320c8c467ef6189b4ac324c68c8a2ecf679c893b7dbc4310cd05dadd80bb6326b51ecd99a441bff77be8d644d752f3c5c794e7d45ba76283acf8913bbf2a420f9e5d14d7a23e95fdebc69b455e466423012e9d1de9353e40d4bdc3107c3144b96c6dafd41ccefeb2b7ff848cb9fdbea8648be32160fab7e7dfccb807fb019ebf159231edcf2d487d76a3e882f3f50ca48dd08a23b06ee887bd7df9d7c6cc2bdbe348e3125c4532448f400cd57a8679abab13e582b13d49442638e2698fb7a563c7fb264157 +6319c9117ec0fdfb189c83b551015145fc61ff66b0d1b1568ac8d17d61f2a08f da5b2118cbd59f408ce56362489fda69ef73172f46dec16c0d4a66e3f3cca373927cb6784ce62bbcb08a490d003a8f77391e82cdd87860909383b054db95816720112e2f96de9e0ffc8babc1350ed46b9aeb5d46b66940efa311f4853f3118063c550733e7679d871729001c12270e98439e375e0cd24769d318e03cbc97d643f1dc5f1b5ef59d12789f22449bd8fa43a13ce78a4186166523f3807b0b621079cc528f4e17c258d4f9bdd095a3e365614b94f2cd778cacabf26244891531eedc24e1bf4598319eb8b7527736bb1e734429360f47f04b2e95d5aae997763a467cc5303d1141c2c01f7ab9edab860d180697c906ce1558aeff5adce603f8a4a10fc6c1699189e73b489f64cefb89ac557c5bb8826c0317eaef2302e855fbd96777898104365d96ae8a8ed8669c568c4dbeb0a70f6cf4c22fd933014473f91871c08d5a7b44a928295fb2aa56d5e2c39ca79d2837fb39b35c6810c378d749aacb543368a19c137b872229e0a6f469022aa93bcb2be38b761c85ac09415ca7deeb38ff2a2101507206fe322a89666d32750af0f4d7b2e59571f02a048b8f94fe2d231072e301c8641d1cdb4f841ab165af297495a348bccd937712e68852a4aca948c1294f8b733d06d67de89f206498dd401e149fcc1edca92deb92952ede4ebdc7cd7992104769a04de8705027a31337b88e8de93f6624e8f10b9f9924e8ce5a9d841c9260753fa1492cddffe6b4400c5719d76fb5b01b234f32ffe64f04d0a00676fbfc58dbe17b4d552fdf0c5b802c0cadf723f73f86e8ffc493992d23e8c0b84f7220a983ddda21170b1f730c736e75549af6ecb8dc94fb25c26bcddee420c83e8a45ae4c345816b7163cfe016dccfe47c66979d610a7f9b4a7b1ba5e230344c9f46ba076f2fcea68aada8fa09bf0b5cbb3850ddedd80a30e1f7a639ac69e5595c6a4083aa959831ebbeb84c018068723192f58baecddd18c857e212d4c7e7215b6c954728183fbaa07720b97189af6a7729c30d28db33a889f225d027d164f254535770c504c506aee4ec4676771f69f935ba08a1c6c85 +c7490b05b172a1dbaaa66faa823108d44c82f1e82a41fd57fd95000f30de747e d1890b4704e169c28e44ddf62a1091450404910539fc2daeb26e8acf4533b024e5215c2d02820dd8fb2cfc1743955cbacff0f8f35dfbb5e3f942f36247f68211d518f3f601aae12a1cdc000bab43d4c973f287e80741dd1fcf6c34f2e6b4b6c313d01c4ff3cbf9166f26946f18ef2d58271ba9233f09a6b77bfd4f48b36eb3d73d1133c4f842a7dc3907f680b0b773242c11e3dd973a44327ea7cea9c0f8e07d682b6651e506b587559fe01ed721000baf570a16fbdd9ea29fa3def4be912058321a8b720c5c102e48a6e7ed6f8838d400dd57d06eedbcd15323f86d855c94b21e41b14ec9e1bbc8019211fd88138c91f9abbd9bb3914d26c1ddc21673d2d51263b39d66e741d924cf2b192c5d2c1a140126a3d64a2c77be6c2c6ebe8599978ae90bd36cbb9af64d078910c4094ab3bf399c34f2ab8ef843e9fe1bf88bf443ba21e4377e5f49c07fd9653b526e14562237f02d11b904bca6ac31ae721a43e3c4910a24af6f4d80c031c109fc0fe49f15274bca92bda04c3b4196c192f6ce489c63a806acfc895ab52cad657c1783b528e12d0ed856e1f8fc91f2aafdfa0a92498d68530772ee73b359fcf1418d1096c46b34dcf90e5b468bbb2970becbd70089cfb039d64cc50fff5eef26384d34f24515a6558b06a1fdd88f1050c5bd78cc6ed83d4c2b0e882aebcf84afb0430d0bf09f2fb42b8b4589158093a7709aae75a790910e211ee1333ffb6fd80778da3bf73858978e9dd647978841b18001dbaaea43ca0c0a03dbb9bcf30ce76a6f4b2cf2a9b6531b3e4051e7e05090cd421bc66c4731e7122ad129fc42dedc83bb460e3f889992fbd3ca072686e56b72c720fbc98d723ef7f247286f77ccddc728738e941b1a74d4f16671c21fdd5643a115ddbcb88ee7ec67ea66fd2bce718df6e085d4b5fc71a72696636a8f7b3a68afa51a896771faaa7f1f827430ac5e8089dbc0d4175e1b22a057bc5f1724eadc1a41e78fa3acaa8b97e5f2e19ef9d59ae12b04e7f0e8a621e098a66910e2a5ed2102b824cd3ea044a854f1cd0b33e61e7f737414b2953549f25dd34d19aa1981de7cd5649ff6c6364a4f25312ef62395a747ab88aad722c05aec40deea8eee5e779ef458a68840bc6bd5d29ad40f98b3ae010b6213372abb7bb8b8 +183642468be2707c3349132cd3b0633aa63e5752488c3adc0d501265ff0529b0 d9257004993c7ae50d20f534b42b4ec39bf358393b9fb5c8e37f87ac7361354554be596f40e67b2ed499887e26dc435c4331cde3bf1a118f60fd821477ffa3b92f6469568cd2cda6fc0a2b13906ae459cf5d5417de2ce104d0b6499d3683beb40715582ce70ded5c5f8461edeaa38bfa31979661a2dc96d926307128f77700f2c7d38b8a9d6c6f70a3973005350f938b9b4a64e228cc3b3f9c4fd446fc650aa6377152d7f46903d8ec8e9340710e28475cf21e641737e7d7da3cdf18d01c8f37131e727c7274b2db759c5586fb84ec36a5ce2d820e553de6426b8b96111295c19dba8d17a2b7047fcdf662a59c2af27a9abee37a7f8afc06944346e343e779ebd895119d7460e7da998962fb1100e950a8d7fe214360ad263b8d070f2b7dc91c9d77c6692da0f472a0a4646a1edb069ccd9ce4ca6fc24713d650153b9a253db5136a3710198e60934dd2053315d313e27dd2c6ffd2ecf028625f0e937afd8c2ffb1f646e51a768204d83a649798a51b8e87fcdda7bddf58ed943bb7e29c7d7c5dff024545f6a689aa0e727fecd80b561011a731acdd9b3f283123098ba66b6b9fce6123b35b6f3a20ef1055be9e257cde97e5af41eb796438727a62aa665cc9b771c4a2052efac61bc91bcdf573f7263107d44dfeb125e66d1f3dded3bd63845af3bf4185a9a24a7f4b777c32496a6107b7ac940af24be983f6a758e5064f8717eabbb86e6aada7da75f72abed59a42de82b1aa2642f5ef1b2e7304f642eb2aafbf00c1183d9b5fb83893edd48e9034dc7a7ab66f3f392f9666c00ecc9743ac4f777edcf47b6818a34b7392b4ab8e38891fab4018dfb99af06369115d60c4fa073240d9c2605e020a42db2e1e0ae4ade3a04b825927a05d4fe3f50c1c7add7a496da7e95825c064315196c2007524d1e1ef2c51303dd1203ab66d9fe89de553cb4b95a6c5d629b89b7116463ee10ab3cf2c2615f95741ca226f9e9a20e99303888f725c77476533b4c393763170f18f292c89a22df68eabdb81aef11cc2ac329c174bdae5d3cc0bdcea6eb225e00c15021432264ba7c5eb49a49231d1f7a13afc238bd4efc04da3c15ae0bb7d693a0150e6a5ad9b1e11a490b3ce90c027442501684c528fe260881162d9e5ef84d6e4f73f222e779e58b71d5176d9a27f65e49d83efbb2d7810e5b06619d8cef7e7b51cdfb6e8138e4cf5674242f947eac13fad08d68a8a11aac9754a5316c93738ba7f3c3bd2e827a +ca372beceabf8170b01127add4d3f709e1267afb3efb4271e2e68fe955080367 09cf132ab943654184a3fc8d0368b421fdac4ef1081a29f3691a527fbdbd74c6372233b38dc432ba610f9c54fa68699f9ec2a6bfb0b2cf7aa6d10ae2207a7554163aa14fb6a9cfa023ce63546b7b02af03370a899ea73b27bdb5c380613c0ea670c659803d5f6f75c0ce62b311dc157de843a93905e7a28a2557684ae3db4fd009412a107098f881dc06622ed9e3df2c8fe69fe50bfae158b87ca761fe1e221856610bca301ee68958c25bf58d3be203af928a919ace53c3d99f55ab00dfc8a1a28ab83e78617f194efc46daa77573d02ffcaa1f9d96fd8da8dead3d4e75ee5e65fc360b2a567cd34d52bc9aab8b71160312e8e21aa506105d6644e6863e7d5e75ed47c1760743d113a4526553b303341fcee5fdd005d35929f2afa760bb8314d0c0eac960fda3263a1e6688098251618c90332005c757af958714571b77bf2a69030d99f71d1a5259658be565fbd098070122c43edfd400999c90a98ace95315faee4f1c0441c9315d527c7ff1a8171415d2a076e2c513d40b03cfe5513c0e74ea3a03ad4958c00a3e1916d34273e301d517b0a5e770393880d9afb4d0eb44d3140ff7d827c48f67c6d92b865d8fe7c7e45aa50dfd8525f530de1188f3af98b3dc625d335e191fbad5ee9df09c97b43f203bfed798f7d171bf00c82ea0ed17d5890c3d6b9ef6fdc04c5ffb645e3050406fe2fb6bdbe2ffe083e751dc19f2f06445397019b61cf1f505875520f09c6b719e642b81b2fbfbdcc072b7981a666d51e7065e21244679dfe056bc9d42b8851f9d2905fd838707b279a8106eb894b60a72e4851c344119ceeb5bbe110b1c5b21c9a5f7545283002d4b1c115308b1cb20f6d9cb869ed0459c569662aa5729a7d7178de7d69e4885ca77c011e785ecf0e2ecbb8f5245579dbef7a5eb30307e0b40b817bd1112d28eefd548374bc867e0c34d2236952b9f859903e87e977190ff94f5d815699154f96e5449ddc1a14e4196c83e4fb02f5f58c30eeed691de47c81f4883bd84f6ed711fed0c198bfa2b8296182d7225e8989acf55d3612a93e77d24f7b6eef813fd514ce2183571602976391f5ac4e86da59a64233230fb67ff0bb9ec40667f54ccb235d04b3fe1d9a47e163cb19c316046fc1353a6642219e9cecf6e3151c0f4fae1177b67f19b4964df96bb6af37012b8ea9e5ee24c57a010c872b15c8a65d0266589f6da20e38d9be2e2c215c69f558084e48eeb61f4eaae83c57f3f1cd08d05783fb9f5ab1cda5e4b86291fffb14fe9b497ec73292bbd295c5657d71cc74d38a2f3db73ba972986b7169f76ba376376f4747ed65f2f1a5e67889af38a380 +8fb55eed063f80476cc7b2a22ebdd351d0288dba7149ff0a99d5c6f89546fb04 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 +e431208e1a690a1c9f83092cb57bf0126d0d3afc0ea0d188460a259f4212d127 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 +12bcf175ba9f1a6e3066855e3c23d462b83901618abe536e86ed14b24ae53e0e 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 +33c10ccc7eac44f37dc5d0d58ed590c804402d64d2f1ddfcacf3b303efcca84b 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 +f33c45d1420eeeac9fa73846c080aeaa05253404f7d4028f57457c4afe1545de 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 +eb351838fe8225fbebea9168dbb708872ca43ac93480c3affbe6cc3a15a2263c 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 +a26370edefba1aa516fa4e4902294f9ff7b491d0eaaceec7486eb262e8b1249a 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 +9f4ea3427642d8a8b392a57e3f00a5cabccf568e0b81218814b18ea47c852726 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 +03b5a9218af0fb5abd1ad6dfb1b32e2ee82b054cbb046abc656cc52620828553 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 +e259703be72cc326094d4d531cd7ffc6f2e50ddf394d964e8d29fee3d758e456 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 +c42c010303456fbf39c43aa996d42ac86b363bc6365fdbd9ea758cc8961cd9de 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 +1bae639940ec63dcb67f9e806c4b2ede6751cf540e63bcec0ad83d7906a89137 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 +83f1111a37ec61e9d5231024b81e8883f7bd11bba9a5da46fa0f6f19b381b2a7 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 +96baee8eca9dcdbdc467549e307d95c20a07feb72eccc780dbc29d40ae7cae45 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 +fbf2fba45d6f02bcfa8788c443701104fec7c81700aaf2d0311132958e1ba57f 24b1190170418126dd7a5a81fc080a9804311b48c4e4da680727b874318d17bdd34be726daa760a40208bb6f512e5aa889b135d277cffe6af802954bc918e4d599ee185d598701c2fa3c28f7edb355d74a8d2f1a9eff8b6c2abed776be8bacdcfc6c98c5e73c24fa0967b6f2f79051e648ecd953ab5430b8c7d96352e600a6fc04fd42250d24e4a5969bae7712c6c1bf8b95481a0f8186298ed2a70e16ff8209c0511ad4e2ea17f539789f9a1d47ee291e157806cf680067d37231032b032d5efb1552925497e57d088ece2b3869684357c466db454d4fd9ee9bcfc5dfd7ad3620b3fb244f717a48facf0157f87cbba94b91c0c39002f78351e3ea6d411ca587b91a0cba4ce21a8932ec9f0f6e8fed5de7ddd03a3b90b6c6d828f7831aae1f879fcaff77b76fba1c0013cddb19e93d878b3428fa91f1a5179f7240a5b47b146fa34e3997730b601dd56f587622114813b57239a289dba2348b2bd8207fcdb1ce0032984d9389d731942edc5a44d872eb86038e281f49c868dba278d1c94ad1ac376d57085ebe875cba7ad071d5cb3843ddadc6ecf8af7d6c546938957668e4e8dc05700900ff2a0a2e8dba726ccea443f8681644a377d7fb39fd159f72b8b6edabab76e4af39fa065c9b947f53702a3797552e92d313540a50e73981c4340e88722ce19797dd5305e561156bccfad147685fef2b76f4cf8083515ce8f0c60a52699f08e6ab24c1df612d93d7ca26ccb2d5156bace4da28e8f1e9992bb8480d301046babf55954fd5f29c074806482facec432da10bb7556287f2f108b114904c122de43e6a77048af3b47920515d1b03e280c1e7c05bc71089ec769f7fa04e0c4984d186f8c8ee305b1fb21d03f025c95c8ce9c50ad6fb527ef505bd203acb5b12d4cfe08f4579971590bd43755a85a03bd296885128ae64333dc30301dd7c9b8e035e22f75f411050db6a17265dcf3f3dcdf8fe0b728a680b60eead7fbe141f6d9298edbdd07d52decde153aafda6698f415eaf8622861e54a2b279e3b1c0eafd5a589e7121df6e51e4d7698566bcd5021013180d77a1908c17169c9bba1bcacd5aa4799df84593013e21c303acb670de66b5cf08fad04769cd05d69e3adcd5b0002c75618a6a1f440918b04df7b2de363639152cb6a26d77db7f400291e21479d5a7e0facd36ed09f2a2e74f564b8b676d3e3de07712e1f69840bfb48de63141a2455debe2e9fb8186a01921bfc8d644dbe315eea943d370ec648ae74657aa57512b39b6d872212dd13bbc7fdcb481f7201f65348017d0259fa99a69084d0b62e63a7408aab24da4d3ba6f7b187d014a372fa8160175f3b37399eedd7f6fe869a1f0ab8b0a3b835c9d086927da75ad483cdbf83f7571fe1041376b8b57a15dd1da7075ecd040ae2f5bd6d371ed3eddcc13f8d611c22b29fe9f246125b2b868adaeaeed40ba1c3150beb50940875b08e650c00a095ec2abff723f7f1f5b97985b7d1c1d81bfc031f64e452125cdd13732d86a9cb7ee1d89381434d939b515f3f461567b905cce4d6a7a5a0b7f964fd6d5fe90fa726efe18787d26b083bbc8ab5d7ee7f9d79d3556616e0282fc14b80c9cfe02a3bd845b1a3ead1dec61393f0049b85ea64a7bbc0585a0e24c53d774e5a085fc217ef6f0370a794a96e6bf572a4c3195e916c9a51814989dc4ae65d090976bab9709fbb51b004694ab9c0833637fe100183ebecfa6f78d26014a00dbb204471a6a379d9e4294a5da78f38ef2b0a474e92ae6d811e112ffb224c6ee2f5b2a3a5ed5b529efd2b9106d878b386ac974cd5da99113f11700783226315ae8b9cc9c41423e47b51d10b51ad503ba968a7046753d3f5fb0cb601f4a8d594b12e283843911710b8977412c3b64e8611728ad4684d7e242a1d85ffa5d01e7f3dadbc1b1691030c8aa51095cd2baf36e5b45d1fb7da28973a98fb3bce835932a475edaa12c232bbae4f793324f82bbb4e19cc9e4482393438f94006246c3a81ab51be7721311ebf1927488f1bcbbb26792d6180d0ce59b69e397a6d60db83c321bf971f5d804512d554fc3453aec14f6b0b5e82b8a87bc8eafdf7cad1eb07e164df61b6d0deaaed33d4b56b175184730102e77cf81823ee82bfe945e3b7923818157c579a774e8d05fd77fe84ab36a3d266be1f094048b8e417ff0556c95c20c0cc1f3963965e5c37df5b4d88653f831bb222f399d867ed77bf8c89bf6160449a34ea78ab7d9928001fd8dde94f30c8cbdee4d06fba150852ec255c69c590d07b5a803707e11a0ef689ceea9dc0ef8809af685e48b79b4337c756b0e567d3bec43b4431e86b79d6522c56dc31802b76893d548f8f851d7696d8fd8dd15f60253163f8335b9897c477e6d4c743be22b1deaff90693337ba8032978e97bf73bd3fa1b53a46a779b13cbba453346234c3a68f369afcdda203c058e3f3a21adf8b7c872c8acdecc0c292dcc43638d1326b5d2e1870537777ec8a47e69eb54a30f9b1ae214ed0a14506ec218b05cc44086f653048d7e06949d6017bdcc7713983b6ea9dd7d79365431dfeca3af4f6cf1efa18ad23b716814f614ed2a22a5d8b377f442f2c402de05cc8c2dbaa5076133e0905ff843d64545a7409711e1563071c5d48e2ae765afdbaa84c2499fac8f1848db65b745776a49211d0 +a3bad41905d8d509951ebeccf3148d5234d3987b34844270dce8158f1504511e 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 +54216e68a6bbddd27827d5fca11b0110ffa89d7896e5914d57495bd2c39e9495 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 +3c79a3bd824542c20af71f21d6c28df2213a041f77dd79a328a0078123954e7b 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 +22614d379659dec8f34b8926f919151638c1ebb871304e519006e185f8e225de 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 +ab9bebef053ad57060fb0a7cbfc7e42a6d78b49f60cdb5aa8bd3bce173b5c2b7 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 +20526a0d4e6f0624521b036983fdd4f37bc79b790fe2aa8aed1b166b40cd999d 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 +6c8723da27cd98e20f2583d01868051ef2dafa645901f82c74d5320eafc18aac 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 +c36ac151be5458239ae7a0e6b4706950a1c6b046f02d64295dc1e5e96e7ffd5b 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 +260afcf38dedd0a23c5f75b4f044a665fb648bd7997c28e2d4dc6e64ee5e2420 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 +a020f8f6464853c46491d17de76ed981570e182057ea64bfc4c988ae581bb89e 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 +72f0bb32eb6e4bb970a12bace80a7e3ca8616a3fa51f40438fc90b327f0e75f6 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 +62e837a83d1cc3f6306420f091ea71f61ddc73e4bc1d3ad638ae28daae69b583 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 +fc98c16723d8b85312519793bf97ba50f420df6871c61811778fc155c4acb247 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 +95c8e68259dca8b85e81688c128280b59f7e105d8edd89cb9f295b93ea40e291 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 +3d20746dda871a104202ec1ad7d60d8e165fbf97afc1929511e41781a35cba45 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 +ea2dbce665278aa9bf9afee34a0060215f1d257143d73f0fbe541b2942f1bcbc 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 +2597aab9214e2ca7373c7e7e07b4f24bc9293c50ff226ffed8f02024127de828 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 +3f3d3afaf6173dc5a3811add409ff25301029cc0bcbde4c70d21ecb5872c1c12 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 +a60377b7dcb5e0233285fda3a54e5b91119380a8251af2f4c216da3363754e11 d339611e4d57f858a0b749088d129cf1258c2035ee049d5f47816c0b82d640458c8ffa131afda45bef3105dd60469a70eacd18ee594ccbac487d94085e957f8a82086ecbdfcabb8aceda5120a7e15a12577985def9ced321a1c8d350255cce7d336825484c86f9dd1823565d2624982516a6027a21fba2702571cdc05c514f6b9a7138ab8a441d805fd37bdafeeee30159130ee5f90c90de030f9a904e6d2a03cdbbe241f0430fa813a251d44643c04c4bef5d07273c9237f70530c30cb269d7e7b6e7f10831069eee541d5ef986ccf0e1e870564fe558bc1c219dd870af2870321ab62dec23118b77d16418465b54ef71a68dd17e2a0ad16e31b618191577bcaa5c29c2f36c2b56dc932ef2f8ef641118fa3a78b65b5604e0913a48539c4b26f0b5e73f77de1d6d86ebe0038c7883c2f69c0ff462907dc3b85ccbd87b85b0678139297aa478f03a588c6cd9bacf2d5cb5540c066a5d52889bc370a08ace06953c2398e92e2a6aa11616b40927c42203326b3888cecb70f7425c1038e57d6d3bb19bb643704f83ae6a55fe8b3234dc25175d243ffd7e16bc5cb84e8579e619cf699b54bf98890c0563c424477b5b18e59314999fbc4c13d2866dbedd9836c11a62c4e1e5199bda93d2c90483a4fc3590bf66472bb8b1f499dbf94a56d8a2d27f9607b019228acc75f8da8f3f9a24ea0fbef55cbe6c3b55506ae4fed8499543b0f04bba76f7f164f31dfc7681051ef05b32846933ce4c1261659d6c414bdff597af14d01d73d4f3270db309b8e8b62001ea17b35bb7b7cc7cbbfcdc846a3d19929b7fed5693089a3f81a467a539be1cebccebfb5b384cd025eb2dedf5c4390f607f7c9ee3ef273d7270e5150a241abeb97b678ca3808f318da5e38f6842a2a3c09cdf25c8d093caee7c5adbab436b8da15ae3fe3f0b84ab2b43cf1cf9ae3c0d44770282b6f1cc1cd7e82d195be2a5e5af40735449f6948c7037f6e1733189984b4d1da1f0bbcbab8373c3a9a3c0dae236768883634eb42e574525264403e90a503a7d890530834b4701adc1a9c6b953981b9581721ae37ab01cfc2b9571f2d65d4e35f3381f7f05f2cda160ed6143e25c6d9d2ad6dc9b3f69ed693a325110f49192e169ab5eed6be88a3e0be03d1fa29fc002335979971c16f096bddc4d88eb2300ba514b167d4a9dcb353d7ab0c3db7ad991415da362275d3264360d0568bc5b60b5ebcdaa5bd62edb040c6583a9b997d9838479a508f79e9acaafa63f90660fb0c0d0eecaa72bde7fc7ab4b77d29c210fe6aebc6abeec7f201c8c64cb306aeed1110768b3360b8b2f30f8d1d2c1ee7b5dfcfd5d56515f3f617dec24f56c4fbe6604597edacb6a42f9447bac63c53b54010b5ad6f3a5a8c37f89cd345def631450c2b491e7ad6436f6f923a0cec85a76fb04c0b559a6972284145954ec82cf84b0637e4ba11b3f8bd68dc125eb5693a3ed2cb3a62959cbf41c9409d84f2ac9264e99ff695443ffe689464b349b299ab240d542b29cedea37f2221b5444b92616386a2bc74414395b97ebd3df78c583234883af5c7907cd68ba81e19ae616b4950326e526cdec80443497b1bc42cbc4111573d39ed236323a8eab36ab7dd45d65dbbb9f5f7d657ccf944f00ced4f12817de3d031960bc334ed3f864643737b2641c6f392a4a60527252272e1334bced47637dce95292a8e4273cba03e17e16670225c2e2733d7858e2c7d9da6e14333f2917c6df92f233acb60553bedc68da7a99f18c2d3854fec8c0706980c5ddac1174befad6a7da03dc1df372caed2b7b5625eefe93d6419494c3dd1890113e190719abc2b695f7f2aaccd372ef78181c428f19918bc2e2cc16fd97f1aef7e4fc3297578e0be19b8b2ce6ddfa200e593692efa8b11fb5a55919393b98a2fe31bf7b80701b67430f1b33911af41504b2c3cd000e3eae148014c451d166c47b6fe8266f44e62ed7515c6f30511743143485982c3245332fe19890fc8e7db99791a36e77abfafbd0b65cdd861eeff1f29e142df903e723b2ec3b4a4fff8c5b4f3f4377e3837cf134d742d46ef148c986dd161a939482fdf40d4bb4a4231b7d5648e2dbd8a9d8516c6bda0a370fa53620d5255341830b84c751e31b8e17f3fce027906afcc2ae7e5e104a1109e86fb20897e3109d07e700c13e6ffa7016ead35969245a16be032cada0f2327844dfb3b45d9b3e9e309a98dd927c5e75aed3270714041e35a703c3ea7c10348fe521cfcdfb7c02ea9e123b267c22f091a4b98473330e93a362c358f92519f9f42b0e6d2aafa0538ec32af4a52358efe45b59a9ac05cf4d6d82af2b88bbf327d3ee61a4f341178bad4b228ca86d9ceffb459c64ef12e5c5339471054fe09de0933595c2b1a5cd98581675dfa0b9c04db65ddcf452c49d720c0876be88e9d7232737865c598a5d20862d749d3807a7f052f4fc0e0961ff314df69829b3a3085148a818b0f53840b92ebba0266a42719d49902775b72d15162b1643f80993393a9280a99e72aca1fc8b2f8454e566bc79cd9075fe091f5edb4eb0da5e0dc5c4ed85a8fc3997389d235cb5436e9a8aed1d4604575834c1eb2fcf1378e465f77cf037503639482a285a9d0b476cb9ddffc0b82e64bbd175538c2647382d2d7587225c845d8c14f3874c1456205071c0c0b3965fe30e9ce3b616e4de78b3953a9ec525e43ceeacc0c303c6400cb4d52fdfd142376075d26ac1123ec4cfbf82e77cb04efc09cc95601b14681c90a7b0840efc819613aa06fafe2dab4b036951f82579a02efefd08df0eeefd2146080734961725b6e917739fb80deb9b8bb6dce39e20372ccc079add9030799061ef1f011699445570ef0cb963483099eb17f22226698deb110495c159eb63da750d231e78c4a7c734941e443af7f2b5a3a06cc5334ef76743fcbe8edd3939abd48ce32a03dd59d2553ba408b444d9599c2358443294c406d03d86a23f872992a1c455027aa4d7ea35afce35af0a40a8b58ce2c149c00ed49ddfbf01f1efbad3db59d2214b795c7f78229889da77c4a4faab944ebb033a045156aaeb5b457ba7fe0a970fac195ef5d206e28ff9151310cc91937fc33e61a50755ab1c109e4dd87dc511964f970784bc3019afcf015c6ebadd5c4c32256311e8996fab7dc3945cd87d55fc9c851e863dad371d6e9d69157c5040bd702f828c088c5a8e4e35ed19e8731eb9addc7d31edeb95e2fa57ec514d97fe5914264dd0016bb430fdd7dcd5a161732802963bec1549e5cd5151ce9c8bd46b26f441cb68bbc9dcc08c139dd9adac1a158b5f9e54d2c20f01ae66be788c10067c60e088fdcf828f7be908d863604e19f318389e5ac148237e11be711ff432869c5a9082e5fd9fd24c39e57863d63bd85d5b78c6329c6649f562324398c21ceca17cc78750ae9adab612ca3bd0ab6ffaa9f230637927da9dec3077ab6f425d21ee971a0744732f39ed82f6b06f1e84cd777f1910a9290a66c77264e484693108d973a25908a9701c414920cb0e3b82a74d1ea8304e8594c777290cd32864738c657bdbbd57edf42ec9a2f522ce911c1378275ad43889cc26e9a3818987ff0671a7a94573c013eeebdfcfab5d9bb405d05b66eb641c976a4233169a46338895467f36f9fe7fc1cb3eab830f46f261252aac0492c0699443303949530687533cd09cbff09dcc8f12a49e892a47ab0a2bffe1b7a493bfd66d9e4822598781bb8a94a4d7d63d77c8f1b4112f89ca215decb610f1339184f8cf66bb59169553013276472bbf7753a7eab046f55e720c0b235407748b8cfa07e748808875a896661a54dde939e0d64cb3031a4d48d565e24a56ae117ecfeb27928e42c06614b4327b9261be4ab24169b26f9a7a463a42f0ada305359314e7d48993ebfe46fed1ef6f65f733483b883b72deefd5ae803a0cbce91e5161090da188c475b38379fa2cb191d0c172e966376fc8c7a5ef4263949d75a955ee94e0391e70ce04c61d3f4f49cc5f1774515f01ba6cf83bea9bdfb7f158f6ced3bc33beffacb80ba3767e476f3180c392f17de1f72719466b4e814d7570c9b08eb3f053d728e5efa2c28aeb4fa557a2c809e357f9ccab21f4e9fc3291cee7ccde2edf7b086f844b531c6d6d5744ab2c3fa2795a7c2b26a3fde44ac46738972d374e534d1972322d4dc8b349fdd5d3aee827bc4de6ded715b87f1a26fe09fa12a495919997e07e75e268899d599be0fc699433619d73c63b34a377f6cd511d095da8ed29a9fa86944b3795bb69fb8f51fbc34d07809dec6fc646ba63ba48322717a1ee01ec9b1cadce556b07e943f619a073faec003ecfa657d7c0086631f41909bfddaae09054948934225a3 +a93287952dbf8598d69d817770558330c5dae87c12688248e700314ee789628b 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 +c8d65566e346b9d8d5ee750c13457d0d5b18223b5a92e3a5421dd15b3349feef 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 +316dbaabd73cb331e4cad899b446dff65eb8668f5c4ef9a1db8e8ae424128f66 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 +4ba150c2f4db2449515cc9b545ec0012747324700d0ac1e554eab84a262baf00 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 +17c8a5f52364c9f651de5f10021e05daf6cc63d68f66666e762edbd757525882 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 +0238b0a1e357c7382129ad2940ed71820f7d45a7f0f2629391c10829ae801bf5 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 +df6e9b0844153e3cd654d460d5370ee1917762f67dc29bece44df2652ea6ae59 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 +e379775ae8003b80a825f794c83eb652969fb064c541a799e174549580cb7659 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 +312083d969689740c23cc287077b60ad35316a14f2eb015fa0a1125cb6347f76 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 +07128f9452cf601e2a305ab75cdd13017bbf79b0ae3b5b43c2ce0771b04f5719 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 +c6c25cfb97e85b3d59c5f7ceaef6d06fc314c0b23f37c3c0454890821a9cc816 86a9e1ce8c1f20458683cad72cba1a63789e61f8cbd6a54343064d72495a8c686a073a819dab8582a29ed75b327f02e001f64bf54d4c7a42df210b5fd2e225607289ddb67d002492ec0b2773e86097e631709ad777e9a12b14e6fb0b27d7a6b072a0cf1071365d04e7648470b6be00d588d9378c8e1af2f31768c56daac4282bb3911969b381371ca46b62f3eb1f50df99535c00ff523d781b2519e1bcfe4309ae568b1ab92293fbcedcae52b1bd6c605bd35ef6330a61adfd5cebe62b78df1c95168e41260b520b76c40cb767ce844837cc486e66a6d6892632b87afd270a965352eee8a8d234c566bf78b5390d940948f3dce2e973d68656977939a787916922ccd949bd41a0640bd44a33cd772040407baa11d95a6f2ef18e9f2974f1039c63c14fff476d976ce57cae6f2aca0218aed385b6d91262977d23e5a0ac9fffbda87c54c895902465bac9c5c6bb3e10a276c3aa7ef902b2ffebffb014a77f65383a277b10d1ea736b6d8b845408251046a1c5548f718e948e290bc94c86a05e030d7c0183cd2bd3f3166c8df648fcc3764ab9c27e77f06ba72de87c79cf7f8d6e83a8d5ce6287d2b17b9e7d90b25b9e757beca72368f9909d8935179524c136b0ea3240d4108265558944d8e77701ca4f187bcb48708f4c015cbdb81ddb09cc6afa46f4734f7853b1409413ada5d5584494034f5b4517fa7de3dfc07531cb6fd213a6874c212805df0c8dae74969e54cd9ac4ae778aba8ca52619e379ea17fd109572f2dd38c031cdf58de8f00e1e5fa2f1cf2ea39442116fd90dff3dbc92cb52afae95eb17535d48415998f1235fd966499faddc4135b269f6db55e392c0d0b50e2a94d53b13f220567729698f4a6465efce138a5db3aeca6ea2da5a4311706bb8e3ac2fef19cee75877151898beccf75b0555347e52c571b8c0001acc08c3bfe64fd455628dc7b8bfe30873760306c548acea0b7e8c6124065a16b04ac50998bfa57fa1f595df8272a0cf7d4cb401977f048d9530e5a1e5cadbcdb0a3d524b6ceb7d16b5d62725aa083b55ba595b46d68310edf2da3d6e0d50d87414e6421c6c31f51fa56bf9b46ed5216549e2a2e0900eb2194fd413a40e5bde52a85063aa11e51739f7325e109e16882b9b8e0e2df04727fb3ea6c66e415f2faeb65cb02db101d97b47932fcde8f121051363ffc17debaaf557de6314e8baeeda9d79cf7cb612ba87c7a2910a72ba20edf2f6927cdd6d6792b1c7973a604b7ee9673eacfa9c014fbd088f3706cd762727169bbaed092d80c75b47cfff0c6affd8b7883d8a8e1fe97ff1ff6e6f39cb47d876bbace345e205900eca0f6a193c1150748c2c5ee97ea8820b846ac7af90634aa62cb6e9ba39c5d94434e9da3a566ca2a089927aa9ac9a5e13f2cab624f2a7277ca415fb3cf19cadcafe6fc586e0439bfb120589c29012c873d5ed751e37727f867d0fd4e2dfe3b3cd53995a0f4269a3db407f5ace9fce499983135fe2ebc48cd7e708680444afbbe55838c92d23bef0713a9fa381789e760fc64aba84548461f62dcf93300bf8e1f0de9b1e2fb54f3722e0748802704532a156367984604b64eb400559e907c1a2ff27d3d91c523afb0abccc7575de30c1aabcc4d0ae4259f0acac4b2eda798970e4ee99c39c09e85ac281efe136b835eca8fd709d93c138e2c32e3d74444af0cf0146fa8e90c25869edb12ed7fb87cf170b65f203431f6c74c982fcfdd6a079e1487f1a8f2f1b2902564031a1ecefa435b6e6a6f61bb1a8b6ac55d6e7c8709291f1dbf627ea1565f1b834c3765ce94a3a0e012dbe7d70146ada1c74b08f21c38f05c05149eb0e7a6cfe7c16a1909cc3b5796768036813142cea62cc49634e07ca2fb27476019d3f5d32670ad88919579b91f79126415896bfe30e16b82289d8bc775b5d1cabf9ec28c4cec19e6ebc91e40976ed3c79b02dbb257458b84cd256cfc559e5be5b9ee9ae24270e10448d497923a71fe428f13fd1d9fbb49f58ec62c5bddfbd34276872bb3e7d55fdd1668f8856cd04b4f616b7b21e2b4eca9f727903d935a8075ffa7f388df6a89f5eeda1de46e26275ef5e5cbb60a0a745a38586fcb5bbd48312e6a665558cdf315969c2778f270ca2a2320ab4b99080a008c56e05d7baa9e82fa53b0463d74ce409becaadfbe45a3665945bac2188d9607def5546bb895e5ea89ea1e0f77ec533929a7db48410eabbdb346a309be64dfd207dd20702341f1819faaf938923e44b041f1127679549e3bbccc5f8f6ec7131952522166b5352420cb210c09c20357ccaab709628a92f57c92a21c1c9a7a7f4f83ce87c6033305814acc8101013760ac25dd61148ad63f8b96f1d629ee5f42a09ec413593fa03b60e3ba22423413320c674a8ecb1afee2d6a7b0355eb8915709c1d4a0b42741e2958988ecdc18abe89ac555543bb9aebc35243397f9a3f7a53baffee6badc82d8a5d58f20856219f28d5695ee59bcf14ddfd5b703d93f371cb608fe010dc96688060b59c185b043dd8440558bf6975fa7b7933350fd69d70f9c9c1b89675f4b08ccb7ccf67ca457ab338f744ad9d5958e8ef51f3203f8d70e05c208a310ad2ed9898b1601ec3bf5693b020abd7fe2b5019901b11d7407f13182311cb4e7e2368542106e03b5b3b864a42649485915b2584c62feae05c047b1ead2303245c3450d7e872bf3d3a65d9e6ac6dd623d53f879000a3556d46760d0548a552b83adc917ec8617e953f4d84064e3a48a795291240ece56dbedad22d05c78752acdd3b5854fe59c217efa6f538d15ee1a78b5c4791b06057e593b3bb754aaadc08d71f7913a2202d53c8bd1d83b2142de9b70abfc0436312c1c59193f63e2d209f1d5f1f81fb4e8fb134f656887a71f68c07323fc534cf6acce144c4f7c7c41818b18e76e15c1c0258e5bc63887dcea5f99738be85cb1f4c9fdf1faebc534ae8a285c80f13b2e208c5fe4afbaf5f6c38ecccbc8b1e9afdada591247ba07f16ba9e4e36f940e569834f1f80cbca9ce8e3edd4caf4d32d37ef45264864b36a29e1729b2ab9aed0c450b45f9d600e773da9d6c5f780055306eaa6d19e7aaafa8f41428247360fe13bdd873bbc749dcb509b02a76e79e2f2e528e4f381b7bb3ae24b26fa32a21d7723ecb9853c1b606a54f14b881bab00c2231c770448656151f7ed9e4795600122c2fc459c872cf53e80e4241220882054708ca33b2f3b4f21fa384884c810512ab5eea4b6612d3e4def6040d9e5f3603e6eac73c73cb79cd540435ada4a5d9b82df4545b69ee0f4840d2954e023b48da0444564fa3ff4259b7d8a20fcb66241c6f06412669cefb3c8b9e9e0a83e9ca0ac744ec7a26d896cd43e994588278a56dd5827e2539b55f8dd9f121725527b07623d4876adedecbfe0b4bd41510bd30e3aab253098844c60a0b598e69db2e1cddd77a964db8433756b5f954453a2ae8620fabe6737b615dc4006d03327df04e65c8e80946d9fe5ae5ff38a58232eeebe85797a0d332b55b21770b10015379a9a5294404f4d356eeeea47c129e40b6014c19f84cc1b96e3445935aed67ab3a1aa53dba570aa0f29ba19b2ae1a6c48e345f39a1e1a28b2bf637723eb708d989eb25decdea9ecae0b2b2d93fddcc68377ea3fcd2a9386b0cec6893bc3a57867b2e48201a6c019adefd0f05553b0554b938d744872d061fac649a68d834ca52a4752ab4b36471c5d4c65754868c031fc35d8050e50e803960f8175ff0bacc08644b51d316dcfd9982d076a6a2cbadf7006167fabc7753084b7f75c138b059f145a668c59957637bb8f7abefb8922d509fefbcdd357f15edf1f62bb16b94b6a1e7b4e353256dbe17b2a466e6c4ad72d25a177ac333be505db8bafd9244b5068ba7d4dd283ee08459bd47b2276f3c25dac5d7001ebd0e8892bef4f0f17272dbc70d15b626e3643e1664cb7bcb5cb6521c0cc8e2e08357ffc3a329c72dff9b4f0009a3011931a1630020ad83df6a803dc11deda448260206475fd7b2d0c4ae8057ee9358ac8efefeadd2835de0ee6d8f5a2593b7ea0bd5f8a7fb0d003e5c175e4080ef77fcefe8c34fd09ac0c5621e034ba475de9dde49d2d80dde836e6a75e9b257e46373ac2cd1c81f8898cfe8b2dab05d35c404477c13303438eadcd2502ecab5689c3b0b01cc6128d27784bb283ed8888b204160361dae14aec97cbcd81a9c1cdfb372a543fbe7c0314613fa7a1149221a169f58f26c0f0086141292b10b9124d91123d95074e53ea029801e6b187e5d28d83ec90ad51c80d9b350813cc019c7e5a2be39bfcea02bf08b865e6b31c302f4090166ae3a624f19a219dd7e6ecbb29578bc96a919e04b650d794fd17c81ee27ae97455939727ffecf7bf36789ba34b04e8892fd2236d6402c80884eefc9388de1621c746d663582305b6a7b3e1d8854afd6339785769d4abe411b9f990a42a5ef9b43c8f5c459d50559f61690d7816d43ca9b15bfc4c5dd5a2f520527729bb187c14cb494885142bcce3d9d1737ee57518a1cbb8e9194dd9d27276e875edeaec931b1227bda3bec2f7c3f0f5690c5de5e9db8aced68b0963d35535e6f8962ff45264b0112b88c9bfc9212027de6468e86f1ac632d4c8b264ad1eefcf2f5971acfeae6b8925617034814cb3c9610e3b34284ad38fadd07def491ddfd660f4a54880c6b71d9daff18b5ae53a7274aa6f62c9abce4538e5cc76e9fd8b271778fb8587f154bfb0ed98e20a4a5e58d21c7201e70d268a744fb9daa1a3dbee501c6552ee5eb7e98fb426decb5db8771f0d1e8692ab8fca7b62a5b14093db30ac68518cf728fa8757677b67b95a732d8317d47a615eb6772817e89aa523940b9b08aa503e74a5d755e8c267480b57f398bac10fc8717688d23a737822f7a031a3e02993896c57324b0c049e0d0a3b6ec32bf78dc16d5436b10a3988112ac87aea164c0612dacd8fac6ade09eaa14b443524dadc696570f8bb9219fda4af04ddabcc83bec86a4e30788242337c17d721db5fa208883d2f00af1d1599cd58d80dfeace67f180ea8953f92c16bda7e620312cf4599b4807a705c50354d8dcdc2d4b518cd66225bc9c90bd3383163b24eff6de768eabd77e6ebfa2c2edaebce46e58ed8b858b55ed87fb14e3489ba11861ed0434d1c3c4d2090d28bf72ecd252df9dc34bdc41dd409049811fab93254b2395271244772dbdb594e2da076906d0e0f85a025b2ff3c6ec1088c5c37f85b92f6ee7db41f7c867e35b1aae99a4e6b60f734e01e5980b608022ef2439d582685e5e1232b25c71bced4a91e3aceed3e6a1488d8b582d10b7971e9871e5ac2e6936ef2d55353d +192eaea84038d588ad55dc5143f2bb10040ef78bfc7fb91f6b5e4c053466af00 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 +7c96cff2d7caf02d6fcd46a3120c1dd940fab7bc5b70cf97e182ccf71abeb643 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 +96805c12a752a26900cfbe7a47fb94d03c949a8dd3d7ec1521dd1c9aef0068b2 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 +00856eecb7b72e76d815f7ae0424519eb5b50c8128c4b17d15df0113bc302a0b 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 +ec23f3c45243233933a581ab554ea391acb3afff8ced26e7ed29445040a8d527 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 +9471607946031a2e589ddf6f7ae6896cd94e7d0f86306e0d1a75774513ac9553 61cc4d97f411d959562a0fc4109b442afff59bdb158415e8658f9545a4aa2ba8b64a65b0c71fdf338d2f48ee031d8b6fc2b049c2be4f25cfb5d959c77099689b4c607a2f81c5fafecb3290633c5e7766c2e766b4cbb1f97f8a4d61c6c55ca996c8ffef51ef28a90c06dc75e20aff339a28a44fc057fe51fede7260938e89ad74acfe13767bcdb8d25bb890c1401c5986c6a1ddd366eb5edca55ec9b65c1014dea47597dab811446ed3c7a3571bc77d1e3e97cac5608c43cd032c63455406ea98b311688f11a0792a0b8e65ff804526638a730ef25a6f4a7b1892de226b6fa40b65e4fef5387ac4eeda6eeccf155712e7536c1a4aaad5f78f8c8668420da7a48d486f4c4f006329e7bd8750165512005d88061ef2354a84749ef29fc0d5d4753006878686d09825825d25589aa3f386abd079396312e8cb26cc92420ccac17492895b2abd20170a1df011181f4051aeff2de784913cc40fa85e5f26c3fb36bc396f6b1ee7117e77d29a253e37f02769f7574d6ca23a56f92514aa615a424b484f90f382e1ad0d3ac3915e048d99d74779be1403e49c61f6760949e8945593f7a0de5d884bdc2e94f4bbefd51d83e331fdb7fe8e4c4b0429a24ec02ed9f3df54404f6d7c8ff52895e5853442c03dcdb9a980377e09c21ab8819b29ec96ad0d0fabdb77e42bccc7fc7a70b83ee053f556b905c63f8114c17a45ae8d19ceca6e5218336ec11613dc11532d91652e78f86726a80749d70cc54ca41c33d643f280f109f6269c3da377bfe87bfa60a1d167881af220fc8d2a6e290226fc2d0f66d2a1a7fabe47aa8007eec301e82ff50bf7148463645dd2471927f9546da78e15d102e701bf06c972eed2b489de28bc2148577fb489141de8cb51d24282e621267a4139d1f0bc35dc9d9c42bc33a04f81095ab3f176c4212e50b77ea2d132c9a5b90b1e32e631cf1e10c5583514325978581c1e55f752d76dbffc8576f56422c5da1ce20e77387f5173894467ab0588653bbb44bcbebe4853fdb9cd39157068c907b32cfc4aa5daf2d024e0c3b2a804fe5f2cde75d299b37c5fb4422d7e61e959abf90c9a3d8df629e76f4a44b76263e9eb7ad1649ea89f8838705e1a632fa0b91482e907f077b992c96b3064d6d7604d09e682a5886a2d9334138161df5141c3f06251bd470163875387afb38163394b335b79210bad92aca568bd1ae1e511c22803bba36079fef028353aa0f5734a1c7c6c4e6ed684742babad0e93edbcd0de50473a5f46cbd9c592fa92d42ebe010acea97bb36fbabe2f14bd02b1a07b35701d131623bdd526beddad0b4fc6fbbfd4cfca8e513767ed4d10ec64f920e9e6cd528676875a070ca6d7aac6807b53b7b13749cbe350d5fcfe1b34e4df2e89507019bd6fcb24afc3a1c9bd64ca4c7572fac9d87649510d5f91b373efa0b97ede7b8768d0186b968e5a7f6d181cb5f45be2ebb942e23d821bd7a8a1d7b0e2a735dee8944c378ff9a98e13ad7344198b576c6cc770c082d640936d3f07021293764662f77195cf956e91aa7d14ebdd06c41b57c9e881f2de467aef05fe9ea1809c450a45f3f0d67d7447f8af8f87dd52b30362f44afaff54a2a0331ad8c18c2f3594a1e187a1d94a4c1829d87ea67ece045772bbc82c231feaafa81e2f6e18d7f45020aed2b22fee1df13fc31847ebc9f8ca140e4944f8d111a4deb56c0888880eb95601fbace79918a6be2f0bd370215689988725e9afa988553867f898c939a8dc4a58faab9b105185904cd543382f7dde811ebd114ae109b97efb4a7bd4e582c3f60423b48c1e35b8c0f291048c29375f9cc2d4c01079a207bb7bcf875fc7535bf47db251ed8a60f03d84e49e32ec5e72f6df26f18ba040f508a02ece21597bd710c36052ebf7a0cfa8c1fda132ee3f9dff8814cfdfe0a514c91fc79546b82447926d422b8aab87b94cc29f165e1f970ff274fe2a6621eac5f12816129d27b8df06e32a41752a65de0b47283ef049422a9af58a9bfcb042ace1ce470124369a915e2bddcc292431e88982bc6f9c51ac4c8b3e2aa96bfd6b574ae9d702a2673081ebf54fb332f552ee17ba638112816286e94fe43c6695752e67f69ce6dc4893e1dbe8c5df8f292271f4f5c140f324afb49a1565717ff0e0681f01cb7cf96d2f8c50a2d76fa6b4509701211e07c7142d22a2fc40c2cb47e91a0dde3cd86fbd02ee53f8367d1f25e6bc0c04f19080ac19689e721327634289261827333594cf23a7cc0b0c95261257f2f2a4d9eaf72704890f29a5c6f12394c6a57688bbf61e187012cb7c92d720585976aee344bccba607e74f5032c14592c317d211c3848fd76cbfd84d7a621e3d89feca1ac8d1c0090855d530df05978ea50c36db86d311fde0f8c6598dffa94f094e4c034fcb13986eccf09dcca03f2ba06f86d2e49aa9115bd80cf49549e6fb23a81419826f7f3704a1feacaa456da4c107614c992443d5dbc8940f66c2f396786ce6520e08b715d1dc3ac0e695b7be348972522dc4c831f02b4253dc76181f979c6f0450a7303288abe8b9fd6f8a9f46aa93c4e6724e29c9891ba4eb8403013def6068413bcb4d413eabd69b812f479a2b63437abe8c0ce4aab34386de580bd704aa364f17c031195f0def63cfd88f1246a5895d3d06c2bfc919939280ecb8d1177d799062b4f4f0b3c7d855aad76a525301eb6706695639d03a4c0cfab11a1ea74aad65d68baeff5b0355aec1bcdff9fca7f3ba5dfa9f7e1d073305bd96f9abf5ec76a14be21ee536e09866c1e0c4b9ab8e70430bc708dde617f6686c2b6165981bf5c70c747ab222482b076f5032656ea780e0798c5f18223590d3872804c379e5114c6a49c8dbfc14bee6804612eb21b2055afcc7c1b2a8e8be67fad7fd8b5e2641fe8cf37792fe47bfc35c76949610f6718db9403b29f536de09ce4a254f9d612dcb93175f5592466cf9b7ed0585f83d1eb7ae64cd83c117a7f7a02a859a73377baf4624bcb5b7c313f6c2613138245fa0a40b844cd8670111aa27bbb01a7368aa56bf24dc7d8e21fca56e84a32776571ff60b3ae38b3ad1ed3ed3bdd19ede8c24c2aa71ecc2b28124dd0afc382b784e273e838afb698d8aa336016c4988a58ece0d8a2a2d94362d738346c950bf05008a10e29bf27f15b802f213b8e69473b023332952912f20472fdcf193077a0f460e684f9fdecd2d7793ddb33d5457ba30b4d91ec272d1e6e5d2795698a9af406a8c05d1ba2a64f883d37ea18505a0f5745a2dda217eab1774a9d813b8387ea16c48ec8e5600c16d98fd4ba0a1ef2888fdfcef5365401004b02cf704623277ce502a54e4e03d91914ba829c56740f777a5c28fbd45eac571dda7b89ec7fc982f65e5cb382415440162091c2f041fc0f97f20693305c25de7837a2f650577ac6cbffc09f1f695417cd5ecc555697693b12166cda47b8a745f489406942c599af5f085306efaa508b5bf0a406269f600b68b58ce3e204c3bea59e4f3c19157c60246edf18141597bc0cfff8308878e4f36e4c443ba874be58278fd5b332ca73cbaba2a302579e5df863db92251c597cd45f836d0b9d3add59ef92468542b377e3250fbade0833914066a39566009507d4c3d575851224e860429f617ac7ebebdf534dea8f3ac3f7a14f815751c8e72e907f9077b54aac645b4bdadbfd969ab38312cba888f0568170c02f36a4c5f0055e6702f39d62b2383835a719a60e3a6055df550b3590341b66770897bcc66f8a52016f1491973d565eed5d1c718ca8997c8a64d467170608991d14f1e50a8fc63c4a3b464d08d05f72e9ceb8ac69b5f889ee16f99454bb5f822f153c9d9dcf4f0bbbeb510d706f2c7ce5e516e1af5cbb838c95d973b34230379cc30299da585bdd8ad8bdd43ea6ad8aa8f4447ed4f411e4a3ce25c4b338882c6ddda40a8c2228491cb6cb33a5ae703d29865a151bebbfc5910b6441b10cf64c189a71911677c10f11decba96a420de0ef9c124f36fc5d27fdd75c388533c88667347b5277c2e1fc0026b75e38e6e46acecb2ba8efadbaf1489cf45f4a9225691492bc63785966c018a8fbefe58c5533e2bf2c601a0a5ef08cbf1b115bf3452c94953acb7294ff09c7fce12f8cb86333ad7eea514ae12333558f255f5d7039af77d724f66c962192509c5b5e07ca8161d6002417b793f25b92532c61d67ca6ce4e1718b414a86b237fcf0199d7e560c2136afb290711b3e2b8d403ee0537c351972e86551e5eb9a3535d7d602e5c444219b3b3d63412592399a7ee91bf3bfc26f5a3a91bfe9ef9a875cca8c6cde2fcc7cddc971897e559ba56761599c5f883a7c2aa2e4ccb753c659678d16d158ef12af987260fe98087c23773ae20f81fd590e1cf738d3c04b0955f2b20b30f54381c106115d4ed83fc7f6be6d143b61c2d589a317e98e18336150b3350ce0e16e8214da55476887da6fc64d61ba49425da1c156db5eca01411fa062183dd29fa1ced491e5e1e2e3ce160a8e9e4ff1000baf632a92d8e972077c23c666810339e9d9b5f62fda5bcdc45d315bf8db41b81aa165763780becb544f277bf10491cd085a8f5ad91eb6dce793f480a27c448ac8db95738e36ad0f15fae23a98f73e1bd96a6dfa6b1a4df4d34441d973af7e1994c06763bbab81ac19b0be9ec856365de6721840b2a4800f27e32d9046fc67b7f443a88c3bae70138305e9f162dba6219e6f8fd68494fe644bf6f198d1b3a934416e96ac219c72ea95648b1d9677c7dba1e3cc6e6b01198ea85a6fa3dbe68ffd5b936747bf86253622bf0656c4178e9b259f01fbfbef7dbb6f45ea2d01cf4ad075718440c00dc66321b311f399436064e7f56d254baae85a3199c31357b70e81180d1bede7fce128d2aa7fe5c5095a05314b056205e719f13c738fc443f94dd3dd8bf28a8024491d3625794cef85b2c2c810208a8557b04f517c42efd9502a1b4de412b47c530ee6f0056b5eac5be87ae7442aa84f30ad9b6c50d8518632bd4512783bd3fb358b9cbee1ecd5d634d617a57ba8ac2d8f12c99c1a146d6fcb9901f46c05fdb5bc3ddb7d8c0d694b5e0432e29a2bb3bda70d3977d7967082069aa36f425c60d3eda2922fd41ddb7d1fa2ce76256e3ec53a5575de0b0919bb719cd73884f052a35fda47861c13bb523509bf91233acfb82c674bc46fb5aaba970e29ea48af84feaee9aac0cde8ad0ff2b38aa378963d62217b8c079bee27985b725ec8327f8a496cbca3ebc763793cdda9c5c84b42678a0aa6b9baa03a5cbd7e2f733e956dd9b5712317068ea369d7821e3c288c019110c0eb792ef4fe7bde199ef10c973138af40fa52fb35dffa939e3d843ada7750896917772101e49076812e623f8fe435452cc39cfc3c6bd3665bb7e20fd09e28c08d9d29cdb7a4c5f7302acfb63a56bd481f535a136182577e0af1436c050ea376b335da9cf960042a1158fa842a85dcc923bb7ee96016860c2231a1f0d859275801958cebdb374cc1bcee2069ae9a2e970391172ab7bb9d39d991f68c2e087a0773387b62a608641ec54a7e8976b7a9ad1fa9904bb3fa98fbb332d14b6b23a82f4ffa69a8dbeeb4733b7e69430bf6b1ec5c8e5b0d7801b4c745d92dfe071224c7da687a7e1991b03867e82e7f3d3dcc2c63ad5ee9cfc20451bec862d421e03b11195bcaf01ec4428691cde6618db63ae73c08181304d4b06561383176664d20052bd5b7373a7ec53d1a4fcd63d7390d00d2217cfde499036e6ea389dbac12d08f40d6322a26c5681ff0c1f9b638cc08ced61524ec48a8e8bf93d2028dc10ffe063cb807c94cad3c2b694ed9747385ef5934f4c84f907af7999e476c2735e1318aad6ebb7947d9a64b2f625e2dab7e77b6fdbf +89d2231fc658e28be2a1ca2382187137479e3834b498d8e070711515ef670b4d 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 +86ec5342ab7607103547985bd832a271426acde8dcac941aa7c4ff17cfb17602 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 diff --git a/tests/hash/tests-slow.txt b/tests/hash/tests-slow.txt new file mode 100644 index 000000000..9085daf44 --- /dev/null +++ b/tests/hash/tests-slow.txt @@ -0,0 +1,4 @@ +2f8e3df40bd11f9ac90c743ca8e32bb391da4fb98612aa3b6cdc639ee00b31f5 6465206f6d6e69627573206475626974616e64756d +722fa8ccd594d40e4a41f3822734304c8d5eff7e1b528408e2229da38ba553c4 6162756e64616e732063617574656c61206e6f6e206e6f636574 +bbec2cacf69866a8e740380fe7b818fc78f8571221742d729d9d02d7f8989b87 63617665617420656d70746f72 +b1257de4efc5ce28c6b40ceb1c6c8f812a64634eb3e81c5220bee9b2b76a6f05 6578206e6968696c6f206e6968696c20666974 diff --git a/tests/hash/tests-tree.txt b/tests/hash/tests-tree.txt new file mode 100644 index 000000000..dd523053a --- /dev/null +++ b/tests/hash/tests-tree.txt @@ -0,0 +1,16 @@ +676567f8b1b470207c20d8efbaacfa64b2753301b46139562111636f36304bb8 676567f8b1b470207c20d8efbaacfa64b2753301b46139562111636f36304bb8 +5077570fed2363a14fa978218185b914059e23517faf366f08a87cf3c47fd58e 3124758667bc8e76e25403eee75a1044175d58fcd3b984e0745d0ab18f473984975ce54240407d80eedba2b395bcad5be99b5c920abc2423865e3066edd4847a +f8e26aaa7c36523cea4c5202f2df159c62bf70d10670c96aed516dbfd5cb5227 decc1e0aa505d7d5fbe8ed823d7f5da55307c4cc7008e306da82dbce492a0576dbcf0c26646d36b36a92408941f5f2539f7715bcb1e2b1309cedb86ae4211554f56f5e6b2fce16536e44c851d473d1f994793873996ba448dd59b3b4b922b183 +45f6e06fc0263e667caddd8fba84c9fb723a961a01a5b115f7cab7fe8f2c7e44 53edbbf98d3fa50a85fd2d46c42502aafad3fea30bc25ba4f16ec8bf4a475c4d87da8ad3e5c90aae0b10a559a77a0985608eaa3cc3dd338239be52572c3bdf4ba403d27466991997b3cf4e8d238d002a1451ccc9c4790269d0f0085d9382d60fef37717f59726e4cc8787d5d2d75238ba9adb9627a8f4aeeec8d80465ed3f5fb +e678fb87749ec082a9f92537716de8e19d8bd5bc4c4d832bd3fcfd42498dac83 051a082e670c688e6a0fc2c8fd5b66b7a23cd380c7c49bd0cfffb0e80fb8c2334bb717c5e90db0ac353dfc0750c8b43a07edae0be99d6e820acc6da9f113123ae084c38ccdbf9c6730e228b5d98e7beb9843cfb523747cc32f09f2b16def67f76765cee044883827b9af31c179d3135b16c30f04453943d9676a59b907a6439658f6c98159b8fa1b152f1bcf748740754ca31c918501dbd577faf602c641df59 +7db3258ea536fef652eaaa9ccb158045770900b3c301d727bcb7e60f9831ae2c 4231b54cddc617d06e0e311536fa400e5be0a35aab5fec9ec8d98f6c6dad3916fe6cdb1f63be231f95cdc83bb15b0d99d32d9922331b738c423625471fad7f408e60c0773fe78938b054e28b86ac06a194d141c1bde5f3c6f2b11468b43702cb3121b40ccbcb5461fa9321c35c9342e21efd7c1c22f523d78b9d4de28112b6cc51552642ffc126c66f25038f9d3b0cf485cc252215c144d51a139c8ea9a0ecc16e81d8d92dd3660d885deca60070d3d00069d89db1a85acb9c1f18d0c90736a7 +ad56b3e027d78a372adebe839e154668aec5236f7d40296cfdb562fca1dc73c2 68e09573a758b75ea8e7d925fe81e3155afecddc4c8aeb3fe70d87411ee53aceac63c0233d172cd49b2708350fd64e2cf4dccb13352e3a159c06647c609429349197163eca2c2dae0c8643fdfe5d346b2ffd45a2d46f38599efbfa587c3ac0c3119e19508e009556fe53e4f78ef30eed649cdc1e090c8cb662eae1863fdc683bbabea966764f550a142dd68e5b8eb1930ff0c7333c9f2555712489a8cf6a5d188a70841510fca540b8c0425123efca47d5a698cf392e3bdbb7226053459fae01fd19ddb9d16d5f5499525feb49ffca9411e7ac48de15256559f3f65f899b80af +090a95612ed9df6eeb854ae320355889a302498b4f5164a79d8e384a3a0d9748 42e7f4058ca80d513c140837dd661acde3fb914779079baccfe188cbce275aed4b515094bb49ab9a825bcc2ac13f84b14a9defeb1b62fc68124b088272a3562696d62ccdfb5d896b2d2b410a2a79f9b1e7849feebc17617ba12a08d4e80affe970ff2fb79917ac13708f79be215bb6484d298b2fe22b4818536e74894db5e0350e1505ca2681da7b7d7171e3d10c89348cab160ff5b2e739d3591443d2af60db5eb36c50a2dfdb79b8ab83b0792161ac4756d9b831f1863188e10c81af5077d0fdb123f66e51670f03a203ff2287dea6827dcd5afd4904736ec4fe9f3b52f7e2bed7beaa1543bd8bfbfff6a8ae8bf1791dc34efa92c6342532fa33a3b72b6c9f +997ac1178ab7414bab823fbca45b5630df8d1d8263063e6c57da463b85d68a74 947fbbc55ad237fc5dbd7d52dddd44bf3f2a09005c78873422f7ef282d8e6fcc554e35c9566febf91cbbcb1d57a7ebd119abb0ad33a006d01623b7b379e966e00be000ae2fe8a45940e99c953d22014bae4932d8493ad4a551a97d437db2939dd53abedc11a63417f76257a5587f382a57d46d63c372182600c7920bcaf74e9e65289e8c45123ac8a54a45a6104dce5b8c065065ff3a3b6f8bf4d86bf96cb56116df4e01eb3153223d5f3a8c0d7de9eb348158e5ca0c363568674215f68b6ff8e54aeb4a2661f1144cb4f1bde7f9e6371d8a5568d4b3ff3382c65e143ae5d3a5834c890559be95b8b80b82c83d70df85c934bf9dd4b0f2b5f60b8553bd1c1e537b7a1f78a89a17a335a06f5d7143dfecff0c10a2e0a524c91ce913ae04501b65 +d7647e967e4f1ad3d5a0b2d231f62c4fe8fea85b845a72aaf57aeea96f2388f2 5b0bf1b5c843cc5ea8e907c0d6ea901f1d4259cd61e68895fa1a9df76973ac6c87ee22343802565be146e4fcd768cde3cdd1b1996b8626e53b62648a9fd7f5aee2ce5b4aacb090d1beeaf42d47e7f0e90174af6554e8bd4aea3df45e90537eb7572b9583b3fcedf56ff69c412c4576a1353458292b7a6b10536887da47fb95c999ff1a074dfb52db43cf423e81e02aacb267b5f3b48761de9c3a73efe199d710e09043e4701792d04112d18e33d5f78efe4fbda461b4e0f2f55f07ca04eed04762d956b396ff0471c28f48462bf9b6b47caac50be8dd822198a39366071b18f4d4e8188bd11421b606108e9bbcfb1377e122c36083beca6a2306e48bfdbc64c9e6435ed838eba78e0af101abf79ff9600f6cc1b2b776783491161ae2d1d8df2d436a20c053c9237a7d224016878906352eba550d778e91ba830906b8d0be4e6e +bc4b8c89368a254ccd0fb8ad2e9bcf95e06e1189b9a87774a3f70c51809967ef 0bea27a480254ca07321850f25294478628ce83a025af4624902644f9dec23e8fb2c2313332449ae662e59b0bf99c30263a573f152cdcfd731402fe4bc10a758fbc005a236a1fb4c06f25c0564726bace64ae59c9051fc4e6171b5fb1466623f5c6a33ed05f196a6eb43852aa0735f1004245a58f68d3f8848ee916dcdfea2d7c63159daff81f0a9d10261d416ba290752f8333afbb7e22ca1b9c7f55b9023386b759fa69caa43c5caa7c339a0ddcfd95d9c12bea4c2cb450838080b54e270c4aa6580cdbb3431acb13dad236d1999d8b1ec1ed78f3e14061a890c6720947d18ee2dfa62ae4ad5e5ad6d8234ce99a1b2a21ba096325d8acf951380eacac551423d108b090ede16d479483ca0f9acc6cf1db8b8e4597b1c64738675f13665f84043ace791a58acf22d31e6298e7687c24276252f10396c203d38a79b232b200d1c53abb01b9678296797b9e08e4bf0251d8acfe3f42127db1295e3c90241a594d +d765c015e0d30f911278d3b011faba39e8707962d90dabafb37081805dfbe121 dbbd17543ddcc85cd6e3d96d08ae74f1eb5bb69b5d04ed538622423e0f78add6152cf461b569d733167cf18c94c5c09061aced2c59cbd75529c3e5d857528d6be15dab61315fa2e18ad41fc7e7c99cd274e1f7e4e6005e48015118153fd78b190a4960c135213f187da7675369611ad66b546cb5b041ab1743deae82edad9c4e62dabbff022a54c1f1cbd65614fad0d33f894ace380426618330339f238e703e40df8ef6a73ec8de5e35a2c41904552be0d029cfafe3629662dafd39069d25a1982e021ca076aff80f75ccc92ce29219ea273874a29a9c5357dc630a244a0025a7bccd0b6489f38b9603027a032b048cdaa5c88bafb1e72f4a69e0040c0c7b4532b1a91e7b92ed2cd5533b8a4f119ab15c76943204ecbe61b15dd2610c49ed38b771e6ba16c7beb09c70c0550afac81f3580d12491c4470c4773424796a857539616f29cd2df4e187363d24c22bb6cc91530705d7057b9a4380767d9fd8be0963ba503132cac79c870fa4c42fc32ee39a7a3c2ded84cd4b6e302d132f3d8e2ea +3828d41d973d48f171a901cd67f99d073cfbc4dc954fe9c58a48f31a2b0c8927 ac68da2f276c44fcddf6018bfad995e66a50ef120dbcd734834f2473542179f0754c132933fffa46b3c61b01231b5a30cdca82b16afdb5f5183a4f733345dade7ddb2a26b4adf0c23520a8e2d7bf979a7aeca3022153da6a65091172c34ec3a2b8bd5bc6e2dd971cf9b6582b0cdc24f84c48ee23a47c078ecfe306a3791eabe93fc38d28e6a82bb3f80448b7fa3b3f687e59447e6b41074217cf336e4ba50b580f8724b18f95908a13517f5215b67b1b9d0f7129c4e91efa23df763142be2e28f4d394cd6493ea6185aefa0ce8d73b5c0c11f5e8ada75a7c29438ce162749deb113cba0d436005742d35e7397d4fec8419b24320a21dcb18089e5c7644abe3d57b2554c19c0eb55ebfe943ac13beafcd9bad66a967fcc1e747c778bf452c6ccfc9b96772caf052bd768d50977cda7255f479510af8628d5e24125b9482b0e786a65e99bdfb73e6c6e57f01458a7735d0e16b30546d1856683002aa1d0980b54afc8086b75eff6b7a0b448e31e2bf741b24e7399dded0321f745ef034d4c80fc15719b81a797b751c27110480e48c7e98e27aa9397b7c58917147200fd4770d55 +834e5f13dd06f541753f60fe2b5854eff15e54c4141cc0836c4688769a0db0a4 ec58450fe3887a480b39cc493599bf4107d276f57453257bbd1446ccec960ce8aad0e7623c1ac4fe07c2255376dd1aaf4b78a079e8f701a74560805d295d466a6987e81e2ed74b4ccc6a0f121eb6f173f4efeb74f801e1b80e1ee97bf4216376c00a92962c5234d276bea8975e49718c546c3027d57131333a4e4c5756899ba7c9643ff8335553325d4706cd72930b09d632c561072b39b49106c2d424fa6773bbb0bb01fed84effb8ed7471b14581213e49b8fd8dacd1c3f9c50f2a915bfcd77d07abb95cd0aa13df084adc54a04e3214c639cef5cc22fd0a1477a1a196a919d37dff128318900dce936b5cf3a3154fb05f9b2841481554805b681c2943eeade2b21fcc72c6380dc70d4f404dcfe0c0686f94f979989e663f4028189ae5839f0ff8d2c58b4ea09797ece5f5554fccb824c24293b7b7bf8af4da3536548ee5ebbf80c8ea56f88bfa8174df124f5acdecb9e919041ec664e384a8eaeb8e20be270350a2f1cb65f691c0cb1392226a928a3a3aac3f69fe5eab76d125fdeb5ea4c4b2dd59993e7df68221c0da90a1ee89885b217bb6b67ab2d64feb33b66b31087795ddeeb52d40c9a260da14b383caad730ddc8f1e6b59baf7bf110a452a05e8bb +bca11932a196feb98e7779662b8c0f3754a6438311209a858bb891de6bf09581 23c2a65a1917cb82949e89ca65585f4d0b09a5d90a912aed4d8aff9af2a2ce6594305a47ad8e6b744a5fd79cb27e5f4a3b28a3893c655efe3f61105c85183c822d293c74b60d4cc0c7ee002616a97411a3b1d3d8c1be1079a1b300e8e17c95568defd202af2d290cbf1e678e881430d05419c2c543b8e476b424232bc7396e14928e459597e6a8cf9cc6c95051b16d0bcc0e4034ffbcd4ee321b9e94bbc0a1729ee8ab4cd43158c4e8e571ee64c2102f181402238cd53a57693dbfdd5e6be3bf23103e73c40248ce7afb8dad6dd2c2107aab20569f740197d64efbe6159a553c013c04c5c54aa9a4dbe41f2910554bba612e16fe3c682d493c7a1b35c0b3476337badb053bae123c6306442812f5f2df8995c29d7e9c218d4d9e86699cca19d06be9688bf8150d487ede28911089ea86d0be0986b51adc270317c438b622748321d2d9c9f93400b73d7fdbe3e1f6ff36f16be9416b568a80e2764a258b6789d570d80bf91e832baa1ab92289759eb2504ab4b0d3b826e944f5f4beb5d6a3764dd9225a0a1e78a7d0485ffc6808651ef1a26bda9c7e436ab48587e91cfdab4a7c1dbb13a78025ac77baa1e389f9b82994c6cb725c30708a266b5e1a9d0b52128ba340a4a609095e70cc7b30cf6d3a2156b4a35c1bba574f240c37f94718616e48 +2d0ad2566627b50cd45125e89e963433b212b368cd2d91662c44813ba9ec90c2 21f750d5d938dd4ed1fa4daa4d260beb5b73509de9a9b145624d3f1afb671461b07d768cf1f5f8266b89ecdc150a2ad55ccd76d4c12d3a380b21862809a85af623269a23ee1b4694b26aa317b5cd4f259925f6b3288a8f60fb871b1ad3ac00cb1e6c55eddfc438e1f3e7b638ea6026cc01495010bafdfd789c47dff282c1af4c6a8f83e5f2fca6940a756ef4faa15c7137082a7c31dffe0b2f5112d126ad4af1d536c0e626cc9d2fe1b72256f5285728558f22a3dbb36e0918bcfc01d4ae7284d0bfb8e90647cdb01c292a53a31ff3fe6f350882f1dae2b09374db45f4d54c67d3b4e0829c4f9f63ad235d8ef838d8fb39546d90d99bbd831aff55dbbb642e2bf529ceccd0479b9f194475c2a15143f0edac762e9bbce810436e765550c69e234c22276c41d7d7e28c10afc5e144a9ce32aa9c0f28bb4fcf171af7d7404fa5e28b79dc97bd4147f4df6d38b935bd83fb634414bae9d64a32ab45384fba5b8da5c147d51cd2a8f7f2a9c07b1bddc5b28b74bf0c0f0632ac2fc43d0d306dd1ac1481cabe60a358d6043d4733202d489664a929d6bf76a39828954846beb47a3baacb35d2065cbe3ad34cf78bf895f6323a6d76fc1256306f58e4baecabd7a779388c6bf2734897c193d39c343fce49a456f0ef84cf963593c5401a14621cc6ec1bef01b53735ccb02bc96c5fd454105053e3b016174437ed83b25d2a79a88268f2 diff --git a/tests/io.h b/tests/io.h new file mode 100644 index 000000000..64f2bae77 --- /dev/null +++ b/tests/io.h @@ -0,0 +1,107 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include <cstddef> +#include <ios> +#include <iostream> +#include <type_traits> +#include <vector> + +inline bool hexdecode(const char *from, std::size_t length, void *to) { + std::size_t i; + for (i = 0; i < length; i++) { + int v = 0; + if (from[2 * i] >= '0' && from[2 * i] <= '9') { + v = from[2 * i] - '0'; + } else if (from[2 * i] >= 'a' && from[2 * i] <= 'f') { + v = from[2 * i] - 'a' + 10; + } else { + return false; + } + v <<= 4; + if (from[2 * i + 1] >= '0' && from[2 * i + 1] <= '9') { + v |= from[2 * i + 1] - '0'; + } else if (from[2 * i + 1] >= 'a' && from[2 * i + 1] <= 'f') { + v |= from[2 * i + 1] - 'a' + 10; + } else { + return false; + } + *(reinterpret_cast<unsigned char *>(to) + i) = v; + } + return true; +} + +inline void get(std::istream &input, bool &res) { + std::string sres; + input >> sres; + if (sres == "false") { + res = false; + } else if (sres == "true") { + res = true; + } else { + input.setstate(std::ios_base::failbit); + } +} + +template<typename T> +typename std::enable_if<std::is_integral<T>::value, void>::type +get(std::istream &input, T &res) { + input >> res; +} + +inline void getvar(std::istream &input, std::size_t length, void *res) { + std::string sres; + input >> sres; + if (sres.length() != 2 * length || !hexdecode(sres.data(), length, res)) { + input.setstate(std::ios_base::failbit); + } +} + +template<typename T> +typename std::enable_if<std::is_standard_layout<T>::value && !std::is_scalar<T>::value, void>::type +get(std::istream &input, T &res) { + getvar(input, sizeof(T), &res); +} + +inline void get(std::istream &input, std::vector<char> &res) { + std::string sres; + input >> sres; + if (sres == "x") { + res.clear(); + } else if (sres.length() % 2 != 0) { + input.setstate(std::ios_base::failbit); + } else { + std::size_t length = sres.length() / 2; + res.resize(length); + if (!hexdecode(sres.data(), length, res.data())) { + input.setstate(std::ios_base::failbit); + } + } +} + +#if !defined(_MSC_VER) + +template<typename T, typename... TT> +typename std::enable_if<(sizeof...(TT) > 0), void>::type +get(std::istream &input, T &res, TT &... resres) { + get(input, res); + get(input, resres...); +} + +#else +#include <boost/preprocessor/cat.hpp> +#include <boost/preprocessor/repetition/enum_binary_params.hpp> +#include <boost/preprocessor/repetition/enum_params.hpp> +#include <boost/preprocessor/repetition/repeat.hpp> +#include <boost/preprocessor/repetition/repeat_from_to.hpp> + +#define NESTED_GET(z, n, data) get(input, BOOST_PP_CAT(res, n)); +#define GET(z, n, data) \ +template<BOOST_PP_ENUM_PARAMS(n, typename T)> \ +void get(std::istream &input, BOOST_PP_ENUM_BINARY_PARAMS(n, T, &res)) { \ + BOOST_PP_REPEAT(n, NESTED_GET, ~) \ +} +BOOST_PP_REPEAT_FROM_TO(2, 5, GET, ~) + +#endif diff --git a/tests/net_load_tests/clt.cpp b/tests/net_load_tests/clt.cpp new file mode 100644 index 000000000..45c1d0859 --- /dev/null +++ b/tests/net_load_tests/clt.cpp @@ -0,0 +1,603 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include <atomic> +#include <chrono> +#include <functional> +#include <numeric> +#include <thread> +#include <vector> + +#include "gtest/gtest.h" + +#include "include_base_utils.h" +#include "misc_log_ex.h" +#include "storages/levin_abstract_invoke2.h" + +#include "net_load_tests.h" + +using namespace net_load_tests; + +namespace +{ + const size_t CONNECTION_COUNT = 100000; + const size_t CONNECTION_TIMEOUT = 10000; + const size_t DEFAULT_OPERATION_TIMEOUT = 30000; + const size_t RESERVED_CONN_CNT = 1; + + template<typename t_predicate> + bool busy_wait_for(size_t timeout_ms, const t_predicate& predicate, size_t sleep_ms = 10) + { + for (size_t i = 0; i < timeout_ms / sleep_ms; ++i) + { + if (predicate()) + return true; + std::this_thread::sleep_for(std::chrono::milliseconds(sleep_ms)); + } + return false; + } + + class t_connection_opener_1 + { + public: + t_connection_opener_1(test_tcp_server& tcp_server, size_t open_request_target) + : m_tcp_server(tcp_server) + , m_open_request_target(open_request_target) + , m_next_id(0) + , m_error_count(0) + , m_connections(open_request_target) + { + for (auto& conn_id : m_connections) + conn_id = boost::uuids::nil_uuid(); + } + + bool open() + { + size_t id = m_next_id.fetch_add(1, std::memory_order_relaxed); + if (m_open_request_target <= id) + return false; + + bool r = m_tcp_server.connect_async("127.0.0.1", srv_port, CONNECTION_TIMEOUT, [=](const test_connection_context& context, const boost::system::error_code& ec) { + if (!ec) + { + m_connections[id] = context.m_connection_id; + } + else + { + m_error_count.fetch_add(1, std::memory_order_relaxed); + } + }); + + if (!r) + { + m_error_count.fetch_add(1, std::memory_order_relaxed); + } + + return true; + } + + bool close(size_t id) + { + if (!m_connections[id].is_nil()) + { + m_tcp_server.get_config_object().close(m_connections[id]); + return true; + } + else + { + return false; + } + } + + size_t error_count() const { return m_error_count.load(std::memory_order_relaxed); } + + private: + test_tcp_server& m_tcp_server; + size_t m_open_request_target; + std::atomic<size_t> m_next_id; + std::atomic<size_t> m_error_count; + std::vector<boost::uuids::uuid> m_connections; + }; + + class t_connection_opener_2 + { + public: + t_connection_opener_2(test_tcp_server& tcp_server, size_t open_request_target, size_t max_opened_connection_count) + : m_tcp_server(tcp_server) + , m_open_request_target(open_request_target) + , m_open_request_count(0) + , m_error_count(0) + , m_open_close_test_helper(tcp_server, open_request_target, max_opened_connection_count) + { + } + + bool open_and_close() + { + size_t req_count = m_open_request_count.fetch_add(1, std::memory_order_relaxed); + if (m_open_request_target <= req_count) + return false; + + bool r = m_tcp_server.connect_async("127.0.0.1", srv_port, CONNECTION_TIMEOUT, [=](const test_connection_context& context, const boost::system::error_code& ec) { + if (!ec) + { + m_open_close_test_helper.handle_new_connection(context.m_connection_id); + } + else + { + m_error_count.fetch_add(1, std::memory_order_relaxed); + } + }); + + if (!r) + { + m_error_count.fetch_add(1, std::memory_order_relaxed); + } + + return true; + } + + void close_remaining_connections() + { + m_open_close_test_helper.close_remaining_connections(); + } + + size_t opened_connection_count() const { return m_open_close_test_helper.opened_connection_count(); } + size_t error_count() const { return m_error_count.load(std::memory_order_relaxed); } + + private: + test_tcp_server& m_tcp_server; + size_t m_open_request_target; + std::atomic<size_t> m_open_request_count; + std::atomic<size_t> m_error_count; + open_close_test_helper m_open_close_test_helper; + }; + + class net_load_test_clt : public ::testing::Test + { + protected: + virtual void SetUp() + { + m_thread_count = (std::max)(min_thread_count, std::thread::hardware_concurrency() / 2); + + m_tcp_server.get_config_object().m_pcommands_handler = &m_commands_handler; + m_tcp_server.get_config_object().m_invoke_timeout = CONNECTION_TIMEOUT; + + ASSERT_TRUE(m_tcp_server.init_server(clt_port, "127.0.0.1")); + ASSERT_TRUE(m_tcp_server.run_server(m_thread_count, false)); + + // Connect to server + std::atomic<int> conn_status(0); + m_cmd_conn_id = boost::uuids::nil_uuid(); + ASSERT_TRUE(m_tcp_server.connect_async("127.0.0.1", srv_port, CONNECTION_TIMEOUT, [&](const test_connection_context& context, const boost::system::error_code& ec) { + if (!ec) + { + m_cmd_conn_id = context.m_connection_id; + } + else + { + LOG_ERROR("Connection error: " << ec.message()); + } + conn_status.store(1, std::memory_order_seq_cst); + })); + + EXPECT_TRUE(busy_wait_for(DEFAULT_OPERATION_TIMEOUT, [&]{ return 0 != conn_status.load(std::memory_order_seq_cst); })) << "connect_async timed out"; + ASSERT_EQ(1, conn_status.load(std::memory_order_seq_cst)); + ASSERT_FALSE(m_cmd_conn_id.is_nil()); + + conn_status.store(0, std::memory_order_seq_cst); + CMD_RESET_STATISTICS::request req; + ASSERT_TRUE(epee::net_utils::async_invoke_remote_command2<CMD_RESET_STATISTICS::response>(m_cmd_conn_id, CMD_RESET_STATISTICS::ID, req, + m_tcp_server.get_config_object(), [&](int code, const CMD_RESET_STATISTICS::response& rsp, const test_connection_context&) { + conn_status.store(code, std::memory_order_seq_cst); + })); + + EXPECT_TRUE(busy_wait_for(DEFAULT_OPERATION_TIMEOUT, [&]{ return 0 != conn_status.load(std::memory_order_seq_cst); })) << "reset statistics timed out"; + ASSERT_LT(0, conn_status.load(std::memory_order_seq_cst)); + } + + virtual void TearDown() + { + m_tcp_server.send_stop_signal(); + ASSERT_TRUE(m_tcp_server.timed_wait_server_stop(DEFAULT_OPERATION_TIMEOUT)); + } + + static void TearDownTestCase() + { + // Stop server + test_levin_commands_handler commands_handler; + test_tcp_server tcp_server; + tcp_server.get_config_object().m_pcommands_handler = &commands_handler; + tcp_server.get_config_object().m_invoke_timeout = CONNECTION_TIMEOUT; + + if (!tcp_server.init_server(clt_port, "127.0.0.1")) return; + if (!tcp_server.run_server(2, false)) return; + + // Connect to server and invoke shutdown command + std::atomic<int> conn_status(0); + boost::uuids::uuid cmd_conn_id = boost::uuids::nil_uuid(); + tcp_server.connect_async("127.0.0.1", srv_port, CONNECTION_TIMEOUT, [&](const test_connection_context& context, const boost::system::error_code& ec) { + cmd_conn_id = context.m_connection_id; + conn_status.store(!ec ? 1 : -1, std::memory_order_seq_cst); + }); + + if (!busy_wait_for(DEFAULT_OPERATION_TIMEOUT, [&]{ return 0 != conn_status.load(std::memory_order_seq_cst); })) return; + if (1 != conn_status.load(std::memory_order_seq_cst)) return; + + epee::net_utils::notify_remote_command2(cmd_conn_id, CMD_SHUTDOWN::ID, CMD_SHUTDOWN::request(), tcp_server.get_config_object()); + + busy_wait_for(DEFAULT_OPERATION_TIMEOUT, [&]{ return 0 != commands_handler.close_connection_counter(); }); + } + + template<typename Func> + static auto call_func(size_t /*thread_index*/, const Func& func, int) -> decltype(func()) + { + func(); + } + + template<typename Func> + static auto call_func(size_t thread_index, const Func& func, long) -> decltype(func(thread_index)) + { + func(thread_index); + } + + template<typename Func> + void parallel_exec(const Func& func) + { + unit_test::call_counter properly_finished_threads; + std::vector<std::thread> threads(m_thread_count); + for (size_t i = 0; i < threads.size(); ++i) + { + threads[i] = std::thread([&, i] { + call_func(i, func, 0); + properly_finished_threads.inc(); + }); + } + + for (auto& th : threads) + th.join(); + + ASSERT_EQ(properly_finished_threads.get(), m_thread_count); + } + + void get_server_statistics(CMD_GET_STATISTICS::response& statistics) + { + std::atomic<int> req_status(0); + CMD_GET_STATISTICS::request req; + ASSERT_TRUE(epee::net_utils::async_invoke_remote_command2<CMD_GET_STATISTICS::response>(m_cmd_conn_id, CMD_GET_STATISTICS::ID, req, + m_tcp_server.get_config_object(), [&](int code, const CMD_GET_STATISTICS::response& rsp, const test_connection_context&) { + if (0 < code) + { + statistics = rsp; + } + else + { + LOG_ERROR("Get server statistics error: " << code); + } + req_status.store(0 < code ? 1 : -1, std::memory_order_seq_cst); + })); + + EXPECT_TRUE(busy_wait_for(DEFAULT_OPERATION_TIMEOUT, [&]{ return 0 != req_status.load(std::memory_order_seq_cst); })) << "get_server_statistics timed out"; + ASSERT_EQ(1, req_status.load(std::memory_order_seq_cst)); + } + + template <typename t_predicate> + bool busy_wait_for_server_statistics(CMD_GET_STATISTICS::response& statistics, const t_predicate& predicate) + { + for (size_t i = 0; i < 30; ++i) + { + get_server_statistics(statistics); + if (predicate(statistics)) + { + return true; + } + + std::this_thread::sleep_for(std::chrono::seconds(1)); + } + + return false; + } + + void ask_for_data_requests(size_t request_size = 0) + { + CMD_SEND_DATA_REQUESTS::request req; + req.request_size = request_size; + epee::net_utils::notify_remote_command2(m_cmd_conn_id, CMD_SEND_DATA_REQUESTS::ID, req, m_tcp_server.get_config_object()); + } + + protected: + test_tcp_server m_tcp_server; + test_levin_commands_handler m_commands_handler; + size_t m_thread_count; + boost::uuids::uuid m_cmd_conn_id; + }; +} + +TEST_F(net_load_test_clt, a_lot_of_client_connections_and_connections_closed_by_client) +{ + // Open connections + t_connection_opener_1 connection_opener(m_tcp_server, CONNECTION_COUNT); + parallel_exec([&] { + while (connection_opener.open()); + }); + + // Wait for all open requests to complete + EXPECT_TRUE(busy_wait_for(DEFAULT_OPERATION_TIMEOUT, [&]{ return CONNECTION_COUNT + RESERVED_CONN_CNT <= m_commands_handler.new_connection_counter() + connection_opener.error_count(); })); + LOG_PRINT_L0("number of opened connections / fails (total): " << m_commands_handler.new_connection_counter() << + " / " << connection_opener.error_count() << " (" << (m_commands_handler.new_connection_counter() + connection_opener.error_count()) << ")"); + + // Check + ASSERT_GT(m_commands_handler.new_connection_counter(), RESERVED_CONN_CNT); + ASSERT_EQ(m_commands_handler.new_connection_counter() + connection_opener.error_count(), CONNECTION_COUNT + RESERVED_CONN_CNT); + ASSERT_EQ(m_commands_handler.new_connection_counter() - m_commands_handler.close_connection_counter(), m_tcp_server.get_config_object().get_connections_count()); + + // Close connections + parallel_exec([&](size_t thread_idx) { + for (size_t i = thread_idx; i < CONNECTION_COUNT; i += m_thread_count) + { + connection_opener.close(i); + } + }); + + // Wait for all opened connections to close + EXPECT_TRUE(busy_wait_for(DEFAULT_OPERATION_TIMEOUT, [&]{ return m_commands_handler.new_connection_counter() - RESERVED_CONN_CNT <= m_commands_handler.close_connection_counter(); })); + LOG_PRINT_L0("number of opened / closed connections: " << m_tcp_server.get_config_object().get_connections_count() << + " / " << m_commands_handler.close_connection_counter()); + + // Check all connections are closed + ASSERT_EQ(m_commands_handler.new_connection_counter() - RESERVED_CONN_CNT, m_commands_handler.close_connection_counter()); + ASSERT_EQ(RESERVED_CONN_CNT, m_tcp_server.get_config_object().get_connections_count()); + + // Wait for server to handle all open and close requests + CMD_GET_STATISTICS::response srv_stat; + busy_wait_for_server_statistics(srv_stat, [](const CMD_GET_STATISTICS::response& stat) { return stat.new_connection_counter - RESERVED_CONN_CNT <= stat.close_connection_counter; }); + LOG_PRINT_L0("server statistics: " << srv_stat.to_string()); + + // Check server status + // It's OK, if server didn't close all opened connections, because of it could receive not all FIN packets + ASSERT_LE(srv_stat.close_connection_counter, srv_stat.new_connection_counter - RESERVED_CONN_CNT); + ASSERT_LE(RESERVED_CONN_CNT, srv_stat.opened_connections_count); + + // Request data from server, it causes to close rest connections + ask_for_data_requests(); + + // Wait for server to close rest connections + busy_wait_for_server_statistics(srv_stat, [](const CMD_GET_STATISTICS::response& stat) { return stat.new_connection_counter - RESERVED_CONN_CNT <= stat.close_connection_counter; }); + LOG_PRINT_L0("server statistics: " << srv_stat.to_string()); + + // Check server status. All connections should be closed + ASSERT_EQ(srv_stat.close_connection_counter, srv_stat.new_connection_counter - RESERVED_CONN_CNT); + ASSERT_EQ(RESERVED_CONN_CNT, srv_stat.opened_connections_count); +} + +TEST_F(net_load_test_clt, a_lot_of_client_connections_and_connections_closed_by_server) +{ + // Open connections + t_connection_opener_1 connection_opener(m_tcp_server, CONNECTION_COUNT); + parallel_exec([&] { + while (connection_opener.open()); + }); + + // Wait for all open requests to complete + EXPECT_TRUE(busy_wait_for(DEFAULT_OPERATION_TIMEOUT, [&](){ return CONNECTION_COUNT + RESERVED_CONN_CNT <= m_commands_handler.new_connection_counter() + connection_opener.error_count(); })); + LOG_PRINT_L0("number of opened connections / fails (total): " << m_commands_handler.new_connection_counter() << + " / " << connection_opener.error_count() << " (" << (m_commands_handler.new_connection_counter() + connection_opener.error_count()) << ")"); + + // Check + ASSERT_GT(m_commands_handler.new_connection_counter(), RESERVED_CONN_CNT); + ASSERT_EQ(m_commands_handler.new_connection_counter() + connection_opener.error_count(), CONNECTION_COUNT + RESERVED_CONN_CNT); + ASSERT_EQ(m_commands_handler.new_connection_counter() - m_commands_handler.close_connection_counter(), m_tcp_server.get_config_object().get_connections_count()); + + // Wait for server accepts all connections + CMD_GET_STATISTICS::response srv_stat; + int last_new_connection_counter = -1; + busy_wait_for_server_statistics(srv_stat, [&last_new_connection_counter](const CMD_GET_STATISTICS::response& stat) { + if (last_new_connection_counter == static_cast<int>(stat.new_connection_counter)) return true; + else { last_new_connection_counter = static_cast<int>(stat.new_connection_counter); return false; } + }); + + // Close connections + CMD_CLOSE_ALL_CONNECTIONS::request req; + ASSERT_TRUE(epee::net_utils::notify_remote_command2(m_cmd_conn_id, CMD_CLOSE_ALL_CONNECTIONS::ID, req, m_tcp_server.get_config_object())); + + // Wait for all opened connections to close + busy_wait_for(DEFAULT_OPERATION_TIMEOUT, [&](){ return m_commands_handler.new_connection_counter() - RESERVED_CONN_CNT <= m_commands_handler.close_connection_counter(); }); + LOG_PRINT_L0("number of opened / closed connections: " << m_tcp_server.get_config_object().get_connections_count() << + " / " << m_commands_handler.close_connection_counter()); + + // It's OK, if server didn't close all connections, because it could accept not all our connections + ASSERT_LE(m_commands_handler.close_connection_counter(), m_commands_handler.new_connection_counter() - RESERVED_CONN_CNT); + ASSERT_LE(RESERVED_CONN_CNT, m_tcp_server.get_config_object().get_connections_count()); + + // Wait for server to handle all open and close requests + busy_wait_for_server_statistics(srv_stat, [](const CMD_GET_STATISTICS::response& stat) { return stat.new_connection_counter - RESERVED_CONN_CNT <= stat.close_connection_counter; }); + LOG_PRINT_L0("server statistics: " << srv_stat.to_string()); + + // Check server status + ASSERT_EQ(srv_stat.close_connection_counter, srv_stat.new_connection_counter - RESERVED_CONN_CNT); + ASSERT_EQ(RESERVED_CONN_CNT, srv_stat.opened_connections_count); + + // Close rest connections + m_tcp_server.get_config_object().foreach_connection([&](test_connection_context& ctx) { + if (ctx.m_connection_id != m_cmd_conn_id) + { + CMD_DATA_REQUEST::request req; + bool r = epee::net_utils::async_invoke_remote_command2<CMD_DATA_REQUEST::response>(ctx.m_connection_id, CMD_DATA_REQUEST::ID, req, + m_tcp_server.get_config_object(), [=](int code, const CMD_DATA_REQUEST::response& rsp, const test_connection_context&) { + if (code <= 0) + { + LOG_PRINT_L0("Failed to invoke CMD_DATA_REQUEST. code = " << code); + } + }); + if (!r) + LOG_PRINT_L0("Failed to invoke CMD_DATA_REQUEST"); + } + return true; + }); + + // Wait for all opened connections to close + EXPECT_TRUE(busy_wait_for(DEFAULT_OPERATION_TIMEOUT, [&](){ return m_commands_handler.new_connection_counter() - RESERVED_CONN_CNT <= m_commands_handler.close_connection_counter(); })); + LOG_PRINT_L0("number of opened / closed connections: " << m_tcp_server.get_config_object().get_connections_count() << + " / " << m_commands_handler.close_connection_counter()); + + // Check + ASSERT_EQ(m_commands_handler.close_connection_counter(), m_commands_handler.new_connection_counter() - RESERVED_CONN_CNT); + ASSERT_EQ(RESERVED_CONN_CNT, m_tcp_server.get_config_object().get_connections_count()); +} + +TEST_F(net_load_test_clt, permament_open_and_close_and_connections_closed_by_client) +{ + static const size_t MAX_OPENED_CONN_COUNT = 100; + + // Open/close connections + t_connection_opener_2 connection_opener(m_tcp_server, CONNECTION_COUNT, MAX_OPENED_CONN_COUNT); + parallel_exec([&] { + while (connection_opener.open_and_close()); + }); + + // Wait for all open requests to complete + EXPECT_TRUE(busy_wait_for(DEFAULT_OPERATION_TIMEOUT, [&](){ return CONNECTION_COUNT + RESERVED_CONN_CNT <= m_commands_handler.new_connection_counter() + connection_opener.error_count(); })); + LOG_PRINT_L0("number of opened connections / fails (total): " << m_commands_handler.new_connection_counter() << + " / " << connection_opener.error_count() << " (" << (m_commands_handler.new_connection_counter() + connection_opener.error_count()) << ")"); + + // Check + ASSERT_GT(m_commands_handler.new_connection_counter(), RESERVED_CONN_CNT); + ASSERT_EQ(m_commands_handler.new_connection_counter() + connection_opener.error_count(), CONNECTION_COUNT + RESERVED_CONN_CNT); + + // Wait for all close requests to complete + EXPECT_TRUE(busy_wait_for(4 * DEFAULT_OPERATION_TIMEOUT, [&](){ return connection_opener.opened_connection_count() <= MAX_OPENED_CONN_COUNT; })); + LOG_PRINT_L0("actual number of opened connections: " << connection_opener.opened_connection_count()); + + // Check + ASSERT_EQ(MAX_OPENED_CONN_COUNT, connection_opener.opened_connection_count()); + + connection_opener.close_remaining_connections(); + + // Wait for all close requests to complete + EXPECT_TRUE(busy_wait_for(DEFAULT_OPERATION_TIMEOUT, [&](){ return m_commands_handler.new_connection_counter() <= m_commands_handler.close_connection_counter() + RESERVED_CONN_CNT; })); + LOG_PRINT_L0("actual number of opened connections: " << connection_opener.opened_connection_count()); + + ASSERT_EQ(m_commands_handler.new_connection_counter(), m_commands_handler.close_connection_counter() + RESERVED_CONN_CNT); + ASSERT_EQ(0, connection_opener.opened_connection_count()); + ASSERT_EQ(RESERVED_CONN_CNT, m_tcp_server.get_config_object().get_connections_count()); + + // Wait for server to handle all open and close requests + CMD_GET_STATISTICS::response srv_stat; + busy_wait_for_server_statistics(srv_stat, [](const CMD_GET_STATISTICS::response& stat) { return stat.new_connection_counter - RESERVED_CONN_CNT <= stat.close_connection_counter; }); + LOG_PRINT_L0("server statistics: " << srv_stat.to_string()); + + // Check server status + // It's OK, if server didn't close all opened connections, because of it could receive not all FIN packets + ASSERT_LE(srv_stat.close_connection_counter, srv_stat.new_connection_counter - RESERVED_CONN_CNT); + ASSERT_LE(RESERVED_CONN_CNT, srv_stat.opened_connections_count); + + // Request data from server, it causes to close rest connections + ask_for_data_requests(); + + // Wait for server to close rest connections + busy_wait_for_server_statistics(srv_stat, [](const CMD_GET_STATISTICS::response& stat) { return stat.new_connection_counter - RESERVED_CONN_CNT <= stat.close_connection_counter; }); + LOG_PRINT_L0("server statistics: " << srv_stat.to_string()); + + // Check server status. All connections should be closed + ASSERT_EQ(srv_stat.close_connection_counter, srv_stat.new_connection_counter - RESERVED_CONN_CNT); + ASSERT_EQ(RESERVED_CONN_CNT, srv_stat.opened_connections_count); +} + +TEST_F(net_load_test_clt, permament_open_and_close_and_connections_closed_by_server) +{ + static const size_t MAX_OPENED_CONN_COUNT = 100; + + // Init test + std::atomic<int> test_state(0); + CMD_START_OPEN_CLOSE_TEST::request req_start; + req_start.open_request_target = CONNECTION_COUNT; + req_start.max_opened_conn_count = MAX_OPENED_CONN_COUNT; + ASSERT_TRUE(epee::net_utils::async_invoke_remote_command2<CMD_START_OPEN_CLOSE_TEST::response>(m_cmd_conn_id, CMD_START_OPEN_CLOSE_TEST::ID, req_start, + m_tcp_server.get_config_object(), [&](int code, const CMD_START_OPEN_CLOSE_TEST::response&, const test_connection_context&) { + test_state.store(0 < code ? 1 : -1, std::memory_order_seq_cst); + })); + + // Wait for server response + EXPECT_TRUE(busy_wait_for(DEFAULT_OPERATION_TIMEOUT, [&]{ return 1 == test_state.load(std::memory_order_seq_cst); })); + ASSERT_EQ(1, test_state.load(std::memory_order_seq_cst)); + + // Open connections + t_connection_opener_1 connection_opener(m_tcp_server, CONNECTION_COUNT); + parallel_exec([&] { + while (connection_opener.open()); + }); + + // Wait for all open requests to complete + EXPECT_TRUE(busy_wait_for(DEFAULT_OPERATION_TIMEOUT, [&](){ return CONNECTION_COUNT + RESERVED_CONN_CNT <= m_commands_handler.new_connection_counter() + connection_opener.error_count(); })); + LOG_PRINT_L0("number of opened connections / fails (total): " << m_commands_handler.new_connection_counter() << + " / " << connection_opener.error_count() << " (" << (m_commands_handler.new_connection_counter() + connection_opener.error_count()) << ")"); + LOG_PRINT_L0("actual number of opened connections: " << m_tcp_server.get_config_object().get_connections_count()); + + ASSERT_GT(m_commands_handler.new_connection_counter(), RESERVED_CONN_CNT); + ASSERT_EQ(m_commands_handler.new_connection_counter() + connection_opener.error_count(), CONNECTION_COUNT + RESERVED_CONN_CNT); + + // Wait for server accepts all connections + CMD_GET_STATISTICS::response srv_stat; + int last_new_connection_counter = -1; + busy_wait_for_server_statistics(srv_stat, [&last_new_connection_counter](const CMD_GET_STATISTICS::response& stat) { + if (last_new_connection_counter == static_cast<int>(stat.new_connection_counter)) return true; + else { last_new_connection_counter = static_cast<int>(stat.new_connection_counter); return false; } + }); + + // Ask server to close rest connections + CMD_CLOSE_ALL_CONNECTIONS::request req; + ASSERT_TRUE(epee::net_utils::notify_remote_command2(m_cmd_conn_id, CMD_CLOSE_ALL_CONNECTIONS::ID, req, m_tcp_server.get_config_object())); + + // Wait for almost all connections to be closed by server + busy_wait_for(DEFAULT_OPERATION_TIMEOUT, [&](){ return m_commands_handler.new_connection_counter() <= m_commands_handler.close_connection_counter() + RESERVED_CONN_CNT; }); + + // It's OK, if there are opened connections, because server could accept not all our connections + ASSERT_LE(m_commands_handler.close_connection_counter() + RESERVED_CONN_CNT, m_commands_handler.new_connection_counter()); + ASSERT_LE(RESERVED_CONN_CNT, m_tcp_server.get_config_object().get_connections_count()); + + // Wait for server to handle all open and close requests + busy_wait_for_server_statistics(srv_stat, [](const CMD_GET_STATISTICS::response& stat) { return stat.new_connection_counter - RESERVED_CONN_CNT <= stat.close_connection_counter; }); + LOG_PRINT_L0("server statistics: " << srv_stat.to_string()); + + // Check server status + ASSERT_EQ(srv_stat.close_connection_counter, srv_stat.new_connection_counter - RESERVED_CONN_CNT); + ASSERT_EQ(RESERVED_CONN_CNT, srv_stat.opened_connections_count); + + // Close rest connections + m_tcp_server.get_config_object().foreach_connection([&](test_connection_context& ctx) { + if (ctx.m_connection_id != m_cmd_conn_id) + { + CMD_DATA_REQUEST::request req; + bool r = epee::net_utils::async_invoke_remote_command2<CMD_DATA_REQUEST::response>(ctx.m_connection_id, CMD_DATA_REQUEST::ID, req, + m_tcp_server.get_config_object(), [=](int code, const CMD_DATA_REQUEST::response& rsp, const test_connection_context&) { + if (code <= 0) + { + LOG_PRINT_L0("Failed to invoke CMD_DATA_REQUEST. code = " << code); + } + }); + if (!r) + LOG_PRINT_L0("Failed to invoke CMD_DATA_REQUEST"); + } + return true; + }); + + // Wait for all opened connections to close + EXPECT_TRUE(busy_wait_for(DEFAULT_OPERATION_TIMEOUT, [&](){ return m_commands_handler.new_connection_counter() - RESERVED_CONN_CNT <= m_commands_handler.close_connection_counter(); })); + LOG_PRINT_L0("number of opened / closed connections: " << m_tcp_server.get_config_object().get_connections_count() << + " / " << m_commands_handler.close_connection_counter()); + + // Check + ASSERT_EQ(m_commands_handler.close_connection_counter(), m_commands_handler.new_connection_counter() - RESERVED_CONN_CNT); + ASSERT_EQ(RESERVED_CONN_CNT, m_tcp_server.get_config_object().get_connections_count()); +} + +int main(int argc, char** argv) +{ + epee::debug::get_set_enable_assert(true, false); + //set up logging options + epee::log_space::get_set_log_detalisation_level(true, LOG_LEVEL_0); + epee::log_space::log_singletone::add_logger(LOGGER_CONSOLE, NULL, NULL); + + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} diff --git a/tests/net_load_tests/net_load_tests.h b/tests/net_load_tests/net_load_tests.h new file mode 100644 index 000000000..20da11bf3 --- /dev/null +++ b/tests/net_load_tests/net_load_tests.h @@ -0,0 +1,329 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#pragma once + +#include <atomic> + +#include <boost/asio/io_service.hpp> + +#include "include_base_utils.h" +#include "string_tools.h" +#include "net/levin_protocol_handler_async.h" +#include "net/abstract_tcp_server2.h" +#include "serialization/keyvalue_serialization.h" + +#include "../unit_tests/unit_tests_utils.h" + +namespace net_load_tests +{ + struct test_connection_context : epee::net_utils::connection_context_base + { + volatile bool m_closed; + }; + + typedef epee::levin::async_protocol_handler<test_connection_context> test_levin_protocol_handler; + typedef epee::levin::async_protocol_handler_config<test_connection_context> test_levin_protocol_handler_config; + typedef epee::net_utils::connection<test_levin_protocol_handler> test_connection; + typedef epee::net_utils::boosted_tcp_server<test_levin_protocol_handler> test_tcp_server; + + struct test_levin_commands_handler : public epee::levin::levin_commands_handler<test_connection_context> + { + test_levin_commands_handler() + //: m_return_code(LEVIN_OK) + //, m_last_command(-1) + { + } + + virtual int invoke(int command, const std::string& in_buff, std::string& buff_out, test_connection_context& context) + { + //m_invoke_counter.inc(); + //std::unique_lock<std::mutex> lock(m_mutex); + //m_last_command = command; + //m_last_in_buf = in_buff; + //buff_out = m_invoke_out_buf; + //return m_return_code; + return LEVIN_OK; + } + + virtual int notify(int command, const std::string& in_buff, test_connection_context& context) + { + //m_notify_counter.inc(); + //std::unique_lock<std::mutex> lock(m_mutex); + //m_last_command = command; + //m_last_in_buf = in_buff; + //return m_return_code; + return LEVIN_OK; + } + + virtual void callback(test_connection_context& context) + { + //m_callback_counter.inc(); + //std::cout << "test_levin_commands_handler::callback()" << std::endl; + } + + virtual void on_connection_new(test_connection_context& context) + { + m_new_connection_counter.inc(); + //std::cout << "test_levin_commands_handler::on_connection_new()" << std::endl; + } + + virtual void on_connection_close(test_connection_context& context) + { + m_close_connection_counter.inc(); + //std::cout << "test_levin_commands_handler::on_connection_close()" << std::endl; + } + + //size_t invoke_counter() const { return m_invoke_counter.get(); } + //size_t notify_counter() const { return m_notify_counter.get(); } + //size_t callback_counter() const { return m_callback_counter.get(); } + size_t new_connection_counter() const { return m_new_connection_counter.get(); } + size_t close_connection_counter() const { return m_close_connection_counter.get(); } + + //int return_code() const { return m_return_code; } + //void return_code(int v) { m_return_code = v; } + + //const std::string& invoke_out_buf() const { return m_invoke_out_buf; } + //void invoke_out_buf(const std::string& v) { m_invoke_out_buf = v; } + + //int last_command() const { return m_last_command; } + //const std::string& last_in_buf() const { return m_last_in_buf; } + + protected: + //unit_test::call_counter m_invoke_counter; + //unit_test::call_counter m_notify_counter; + //unit_test::call_counter m_callback_counter; + unit_test::call_counter m_new_connection_counter; + unit_test::call_counter m_close_connection_counter; + + //std::mutex m_mutex; + + //int m_return_code; + //std::string m_invoke_out_buf; + + //int m_last_command; + //std::string m_last_in_buf; + }; + + class open_close_test_helper + { + public: + open_close_test_helper(test_tcp_server& tcp_server, size_t open_request_target, size_t max_opened_connection_count) + : m_tcp_server(tcp_server) + , m_open_request_target(open_request_target) + , m_max_opened_connection_count(max_opened_connection_count) + , m_opened_connection_count(0) + , m_next_opened_conn_idx(0) + , m_next_closed_conn_idx(0) + , m_connections(open_request_target) + { + for (auto& conn_id : m_connections) + conn_id = boost::uuids::nil_uuid(); + } + + bool handle_new_connection(const boost::uuids::uuid& connection_id, bool ignore_close_fails = false) + { + size_t idx = m_next_opened_conn_idx.fetch_add(1, std::memory_order_relaxed); + m_connections[idx] = connection_id; + + size_t prev_connection_count = m_opened_connection_count.fetch_add(1, std::memory_order_relaxed); + if (m_max_opened_connection_count <= prev_connection_count) + { + return close_next_connection(ignore_close_fails); + } + + return true; + } + + void close_remaining_connections() + { + while (close_next_connection(false)); + } + + bool close_next_connection(bool ignore_close_fails) + { + size_t idx = m_next_closed_conn_idx.fetch_add(1, std::memory_order_relaxed); + if (m_next_opened_conn_idx.load(std::memory_order_relaxed) <= idx) + { + LOG_PRINT_L0("Not enough opened connections"); + return false; + } + if (m_connections[idx].is_nil()) + { + LOG_PRINT_L0("Connection isn't opened"); + return false; + } + if (!m_tcp_server.get_config_object().close(m_connections[idx])) + { + LOG_PRINT_L0("Close connection error: " << m_connections[idx]); + if (!ignore_close_fails) + { + return false; + } + } + + m_connections[idx] = boost::uuids::nil_uuid(); + m_opened_connection_count.fetch_sub(1, std::memory_order_relaxed); + return true; + } + + size_t opened_connection_count() const { return m_opened_connection_count.load(std::memory_order_relaxed); } + + private: + test_tcp_server& m_tcp_server; + size_t m_open_request_target; + size_t m_max_opened_connection_count; + std::atomic<size_t> m_opened_connection_count; + std::atomic<size_t> m_next_opened_conn_idx; + std::atomic<size_t> m_next_closed_conn_idx; + std::vector<boost::uuids::uuid> m_connections; + }; + + const unsigned int min_thread_count = 2; + const std::string clt_port("36230"); + const std::string srv_port("36231"); + + enum command_ids + { + cmd_close_all_connections_id = 73564, + cmd_start_open_close_test_id, + cmd_get_statistics_id, + cmd_reset_statistics_id, + cmd_shutdown_id, + cmd_send_data_requests_id, + cmd_data_request_id + }; + + struct CMD_CLOSE_ALL_CONNECTIONS + { + const static int ID = cmd_close_all_connections_id; + + struct request + { + BEGIN_KV_SERIALIZE_MAP() + END_KV_SERIALIZE_MAP() + }; + }; + + struct CMD_START_OPEN_CLOSE_TEST + { + const static int ID = cmd_start_open_close_test_id; + + struct request + { + size_t open_request_target; + size_t max_opened_conn_count; + + BEGIN_KV_SERIALIZE_MAP() + KV_SERIALIZE(open_request_target) + KV_SERIALIZE(max_opened_conn_count) + END_KV_SERIALIZE_MAP() + }; + + struct response + { + BEGIN_KV_SERIALIZE_MAP() + END_KV_SERIALIZE_MAP() + }; + }; + + struct CMD_GET_STATISTICS + { + const static int ID = cmd_get_statistics_id; + + struct request + { + BEGIN_KV_SERIALIZE_MAP() + END_KV_SERIALIZE_MAP() + }; + + struct response + { + size_t opened_connections_count; + size_t new_connection_counter; + size_t close_connection_counter; + + BEGIN_KV_SERIALIZE_MAP() + KV_SERIALIZE(opened_connections_count) + KV_SERIALIZE(new_connection_counter) + KV_SERIALIZE(close_connection_counter) + END_KV_SERIALIZE_MAP() + + std::string to_string() const + { + std::stringstream ss; + ss << "opened_connections_count = " << opened_connections_count << + ", new_connection_counter = " << new_connection_counter << + ", close_connection_counter = " << close_connection_counter; + return ss.str(); + } + }; + }; + + struct CMD_RESET_STATISTICS + { + const static int ID = cmd_reset_statistics_id; + + struct request + { + BEGIN_KV_SERIALIZE_MAP() + END_KV_SERIALIZE_MAP() + }; + + struct response + { + BEGIN_KV_SERIALIZE_MAP() + END_KV_SERIALIZE_MAP() + }; + }; + + struct CMD_SHUTDOWN + { + const static int ID = cmd_shutdown_id; + + struct request + { + BEGIN_KV_SERIALIZE_MAP() + END_KV_SERIALIZE_MAP() + }; + }; + + struct CMD_SEND_DATA_REQUESTS + { + const static int ID = cmd_send_data_requests_id; + + struct request + { + size_t request_size; + + BEGIN_KV_SERIALIZE_MAP() + KV_SERIALIZE(request_size) + END_KV_SERIALIZE_MAP() + }; + }; + + struct CMD_DATA_REQUEST + { + const static int ID = cmd_data_request_id; + + struct request + { + std::string data; + size_t response_size; + + BEGIN_KV_SERIALIZE_MAP() + KV_SERIALIZE(data) + END_KV_SERIALIZE_MAP() + }; + + struct response + { + std::string data; + + BEGIN_KV_SERIALIZE_MAP() + KV_SERIALIZE(data) + END_KV_SERIALIZE_MAP() + }; + }; +} diff --git a/tests/net_load_tests/srv.cpp b/tests/net_load_tests/srv.cpp new file mode 100644 index 000000000..52895c9dd --- /dev/null +++ b/tests/net_load_tests/srv.cpp @@ -0,0 +1,211 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include <mutex> +#include <thread> + +#include "include_base_utils.h" +#include "misc_log_ex.h" +#include "storages/levin_abstract_invoke2.h" + +#include "net_load_tests.h" + +using namespace net_load_tests; + +#define EXIT_ON_ERROR(cond) { if (!(cond)) { LOG_PRINT_L0("ERROR: " << #cond); exit(1); } else {} } + +namespace +{ + struct srv_levin_commands_handler : public test_levin_commands_handler + { + srv_levin_commands_handler(test_tcp_server& tcp_server) + : m_tcp_server(tcp_server) + , m_open_close_test_conn_id(boost::uuids::nil_uuid()) + { + } + + virtual void on_connection_new(test_connection_context& context) + { + test_levin_commands_handler::on_connection_new(context); + context.m_closed = false; + + //std::this_thread::sleep_for(std::chrono::milliseconds(10)); + + std::unique_lock<std::mutex> lock(m_open_close_test_mutex); + if (!m_open_close_test_conn_id.is_nil()) + { + EXIT_ON_ERROR(m_open_close_test_helper->handle_new_connection(context.m_connection_id, true)); + } + } + + virtual void on_connection_close(test_connection_context& context) + { + test_levin_commands_handler::on_connection_close(context); + + std::unique_lock<std::mutex> lock(m_open_close_test_mutex); + if (context.m_connection_id == m_open_close_test_conn_id) + { + LOG_PRINT_L0("Stop open/close test"); + m_open_close_test_conn_id = boost::uuids::nil_uuid(); + m_open_close_test_helper.reset(0); + } + } + + CHAIN_LEVIN_INVOKE_MAP2(test_connection_context); + CHAIN_LEVIN_NOTIFY_MAP2(test_connection_context); + + BEGIN_INVOKE_MAP2(srv_levin_commands_handler) + HANDLE_NOTIFY_T2(CMD_CLOSE_ALL_CONNECTIONS, &srv_levin_commands_handler::handle_close_all_connections) + HANDLE_NOTIFY_T2(CMD_SHUTDOWN, &srv_levin_commands_handler::handle_shutdown) + HANDLE_NOTIFY_T2(CMD_SEND_DATA_REQUESTS, &srv_levin_commands_handler::handle_send_data_requests) + HANDLE_INVOKE_T2(CMD_GET_STATISTICS, &srv_levin_commands_handler::handle_get_statistics) + HANDLE_INVOKE_T2(CMD_RESET_STATISTICS, &srv_levin_commands_handler::handle_reset_statistics) + HANDLE_INVOKE_T2(CMD_START_OPEN_CLOSE_TEST, &srv_levin_commands_handler::handle_start_open_close_test) + END_INVOKE_MAP2() + + int handle_close_all_connections(int command, const CMD_CLOSE_ALL_CONNECTIONS::request& req, test_connection_context& context) + { + close_connections(context.m_connection_id); + return 1; + } + + int handle_get_statistics(int command, const CMD_GET_STATISTICS::request&, CMD_GET_STATISTICS::response& rsp, test_connection_context& /*context*/) + { + rsp.opened_connections_count = m_tcp_server.get_config_object().get_connections_count(); + rsp.new_connection_counter = new_connection_counter(); + rsp.close_connection_counter = close_connection_counter(); + LOG_PRINT_L0("Statistics: " << rsp.to_string()); + return 1; + } + + int handle_reset_statistics(int command, const CMD_RESET_STATISTICS::request&, CMD_RESET_STATISTICS::response& /*rsp*/, test_connection_context& /*context*/) + { + m_new_connection_counter.reset(); + m_new_connection_counter.inc(); + m_close_connection_counter.reset(); + return 1; + } + + int handle_start_open_close_test(int command, const CMD_START_OPEN_CLOSE_TEST::request& req, CMD_START_OPEN_CLOSE_TEST::response&, test_connection_context& context) + { + std::unique_lock<std::mutex> lock(m_open_close_test_mutex); + if (0 == m_open_close_test_helper.get()) + { + LOG_PRINT_L0("Start open/close test (" << req.open_request_target << ", " << req.max_opened_conn_count << ")"); + + m_open_close_test_conn_id = context.m_connection_id; + m_open_close_test_helper.reset(new open_close_test_helper(m_tcp_server, req.open_request_target, req.max_opened_conn_count)); + return 1; + } + else + { + return -1; + } + } + + int handle_shutdown(int command, const CMD_SHUTDOWN::request& req, test_connection_context& /*context*/) + { + LOG_PRINT_L0("Got shutdown requst. Shutting down..."); + m_tcp_server.send_stop_signal(); + return 1; + } + + int handle_send_data_requests(int /*command*/, const CMD_SEND_DATA_REQUESTS::request& req, test_connection_context& context) + { + boost::uuids::uuid cmd_conn_id = context.m_connection_id; + m_tcp_server.get_config_object().foreach_connection([&](test_connection_context& ctx) { + if (ctx.m_connection_id != cmd_conn_id) + { + CMD_DATA_REQUEST::request req2; + req2.data.resize(req.request_size); + + bool r = epee::net_utils::async_invoke_remote_command2<CMD_DATA_REQUEST::response>(ctx.m_connection_id, CMD_DATA_REQUEST::ID, req2, + m_tcp_server.get_config_object(), [=](int code, const CMD_DATA_REQUEST::response& rsp, const test_connection_context&) { + if (code <= 0) + { + LOG_PRINT_L0("Failed to invoke CMD_DATA_REQUEST. code = " << code); + } + }); + if (!r) + LOG_PRINT_L0("Failed to invoke CMD_DATA_REQUEST"); + } + return true; + }); + + return 1; + } + + private: + void close_connections(boost::uuids::uuid cmd_conn_id) + { + LOG_PRINT_L0("Closing connections. Number of opened connections: " << m_tcp_server.get_config_object().get_connections_count()); + + size_t count = 0; + bool r = m_tcp_server.get_config_object().foreach_connection([&](test_connection_context& ctx) { + if (ctx.m_connection_id != cmd_conn_id) + { + ++count; + if (!ctx.m_closed) + { + ctx.m_closed = true; + m_tcp_server.get_config_object().close(ctx.m_connection_id); + } + else + { + LOG_PRINT_L0(count << " connection already closed"); + } + } + return true; + }); + + if (0 < count) + { + // Perhaps not all connections were closed, try to close it after 7 seconds + boost::shared_ptr<boost::asio::deadline_timer> sh_deadline(new boost::asio::deadline_timer(m_tcp_server.get_io_service(), boost::posix_time::seconds(7))); + sh_deadline->async_wait([=](const boost::system::error_code& ec) + { + boost::shared_ptr<boost::asio::deadline_timer> t = sh_deadline; // Capture sh_deadline + if (!ec) + { + close_connections(cmd_conn_id); + } + else + { + LOG_PRINT_L0("ERROR: " << ec.message() << ':' << ec.value()); + } + }); + } + } + + private: + test_tcp_server& m_tcp_server; + + boost::uuids::uuid m_open_close_test_conn_id; + std::mutex m_open_close_test_mutex; + std::unique_ptr<open_close_test_helper> m_open_close_test_helper; + }; +} + +int main(int argc, char** argv) +{ + //set up logging options + epee::log_space::get_set_log_detalisation_level(true, LOG_LEVEL_0); + epee::log_space::log_singletone::add_logger(LOGGER_CONSOLE, NULL, NULL); + + size_t thread_count = (std::max)(min_thread_count, std::thread::hardware_concurrency() / 2); + + test_tcp_server tcp_server; + if (!tcp_server.init_server(srv_port, "127.0.0.1")) + return 1; + + srv_levin_commands_handler commands_handler(tcp_server); + tcp_server.get_config_object().m_pcommands_handler = &commands_handler; + tcp_server.get_config_object().m_invoke_timeout = 10000; + //tcp_server.get_config_object().m_max_packet_size = max_packet_size; + + if (!tcp_server.run_server(thread_count, true)) + return 2; + + return 0; +} diff --git a/tests/performance_tests/check_ring_signature.h b/tests/performance_tests/check_ring_signature.h new file mode 100644 index 000000000..fc7574f92 --- /dev/null +++ b/tests/performance_tests/check_ring_signature.h @@ -0,0 +1,57 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#pragma once + +#include <vector> + +#include "cryptonote_core/account.h" +#include "cryptonote_core/cryptonote_basic.h" +#include "cryptonote_core/cryptonote_format_utils.h" +#include "crypto/crypto.h" + +#include "multi_tx_test_base.h" + +template<size_t a_ring_size> +class test_check_ring_signature : private multi_tx_test_base<a_ring_size> +{ + static_assert(0 < a_ring_size, "ring_size must be greater than 0"); + +public: + static const size_t loop_count = a_ring_size < 100 ? 100 : 10; + static const size_t ring_size = a_ring_size; + + typedef multi_tx_test_base<a_ring_size> base_class; + + bool init() + { + using namespace cryptonote; + + if (!base_class::init()) + return false; + + m_alice.generate(); + + std::vector<tx_destination_entry> destinations; + destinations.push_back(tx_destination_entry(this->m_source_amount, m_alice.get_keys().m_account_address)); + + if (!construct_tx(this->m_miners[this->real_source_idx].get_keys(), this->m_sources, destinations, m_tx, 0)) + return false; + + get_transaction_prefix_hash(m_tx, m_tx_prefix_hash); + + return true; + } + + bool test() + { + const cryptonote::txin_to_key& txin = boost::get<cryptonote::txin_to_key>(m_tx.vin[0]); + return crypto::check_ring_signature(m_tx_prefix_hash, txin.k_image, this->m_public_key_ptrs, ring_size, m_tx.signatures[0].data()); + } + +private: + cryptonote::account_base m_alice; + cryptonote::transaction m_tx; + crypto::hash m_tx_prefix_hash; +}; diff --git a/tests/performance_tests/construct_tx.h b/tests/performance_tests/construct_tx.h new file mode 100644 index 000000000..36507d6f3 --- /dev/null +++ b/tests/performance_tests/construct_tx.h @@ -0,0 +1,52 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#pragma once + +#include "cryptonote_core/account.h" +#include "cryptonote_core/cryptonote_basic.h" +#include "cryptonote_core/cryptonote_format_utils.h" + +#include "multi_tx_test_base.h" + +template<size_t a_in_count, size_t a_out_count> +class test_construct_tx : private multi_tx_test_base<a_in_count> +{ + static_assert(0 < a_in_count, "in_count must be greater than 0"); + static_assert(0 < a_out_count, "out_count must be greater than 0"); + +public: + static const size_t loop_count = (a_in_count + a_out_count < 100) ? 100 : 10; + static const size_t in_count = a_in_count; + static const size_t out_count = a_out_count; + + typedef multi_tx_test_base<a_in_count> base_class; + + bool init() + { + using namespace cryptonote; + + if (!base_class::init()) + return false; + + m_alice.generate(); + + for (size_t i = 0; i < out_count; ++i) + { + m_destinations.push_back(tx_destination_entry(this->m_source_amount / out_count, m_alice.get_keys().m_account_address)); + } + + return true; + } + + bool test() + { + return cryptonote::construct_tx(this->m_miners[this->real_source_idx].get_keys(), this->m_sources, m_destinations, m_tx, 0); + } + +private: + cryptonote::account_base m_alice; + std::vector<cryptonote::tx_destination_entry> m_destinations; + cryptonote::transaction m_tx; +}; diff --git a/tests/performance_tests/derive_public_key.h b/tests/performance_tests/derive_public_key.h new file mode 100644 index 000000000..ec9d64e09 --- /dev/null +++ b/tests/performance_tests/derive_public_key.h @@ -0,0 +1,38 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#pragma once + +#include "crypto/crypto.h" +#include "cryptonote_core/cryptonote_basic.h" + +#include "single_tx_test_base.h" + +class test_derive_public_key : public single_tx_test_base +{ +public: + static const size_t loop_count = 1000; + + bool init() + { + if (!single_tx_test_base::init()) + return false; + + crypto::generate_key_derivation(m_tx_pub_key, m_bob.get_keys().m_view_secret_key, m_key_derivation); + m_spend_public_key = m_bob.get_keys().m_account_address.m_spend_public_key; + + return true; + } + + bool test() + { + cryptonote::keypair in_ephemeral; + crypto::derive_public_key(m_key_derivation, 0, m_spend_public_key, in_ephemeral.pub); + return true; + } + +private: + crypto::key_derivation m_key_derivation; + crypto::public_key m_spend_public_key; +}; diff --git a/tests/performance_tests/derive_secret_key.h b/tests/performance_tests/derive_secret_key.h new file mode 100644 index 000000000..bd915846d --- /dev/null +++ b/tests/performance_tests/derive_secret_key.h @@ -0,0 +1,38 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#pragma once + +#include "crypto/crypto.h" +#include "cryptonote_core/cryptonote_basic.h" + +#include "single_tx_test_base.h" + +class test_derive_secret_key : public single_tx_test_base +{ +public: + static const size_t loop_count = 1000000; + + bool init() + { + if (!single_tx_test_base::init()) + return false; + + crypto::generate_key_derivation(m_tx_pub_key, m_bob.get_keys().m_view_secret_key, m_key_derivation); + m_spend_secret_key = m_bob.get_keys().m_spend_secret_key; + + return true; + } + + bool test() + { + cryptonote::keypair in_ephemeral; + crypto::derive_secret_key(m_key_derivation, 0, m_spend_secret_key, in_ephemeral.sec); + return true; + } + +private: + crypto::key_derivation m_key_derivation; + crypto::secret_key m_spend_secret_key; +}; diff --git a/tests/performance_tests/generate_key_derivation.h b/tests/performance_tests/generate_key_derivation.h new file mode 100644 index 000000000..c2fce687d --- /dev/null +++ b/tests/performance_tests/generate_key_derivation.h @@ -0,0 +1,23 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#pragma once + +#include "crypto/crypto.h" +#include "cryptonote_core/cryptonote_basic.h" + +#include "single_tx_test_base.h" + +class test_generate_key_derivation : public single_tx_test_base +{ +public: + static const size_t loop_count = 1000; + + bool test() + { + crypto::key_derivation recv_derivation; + crypto::generate_key_derivation(m_tx_pub_key, m_bob.get_keys().m_view_secret_key, recv_derivation); + return true; + } +}; diff --git a/tests/performance_tests/generate_key_image.h b/tests/performance_tests/generate_key_image.h new file mode 100644 index 000000000..f6a00ffe3 --- /dev/null +++ b/tests/performance_tests/generate_key_image.h @@ -0,0 +1,44 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#pragma once + +#include "crypto/crypto.h" +#include "cryptonote_core/cryptonote_basic.h" + +#include "single_tx_test_base.h" + +class test_generate_key_image : public single_tx_test_base +{ +public: + static const size_t loop_count = 1000; + + bool init() + { + using namespace cryptonote; + + if (!single_tx_test_base::init()) + return false; + + account_keys bob_keys = m_bob.get_keys(); + + crypto::key_derivation recv_derivation; + crypto::generate_key_derivation(m_tx_pub_key, bob_keys.m_view_secret_key, recv_derivation); + + crypto::derive_public_key(recv_derivation, 0, bob_keys.m_account_address.m_spend_public_key, m_in_ephemeral.pub); + crypto::derive_secret_key(recv_derivation, 0, bob_keys.m_spend_secret_key, m_in_ephemeral.sec); + + return true; + } + + bool test() + { + crypto::key_image ki; + crypto::generate_key_image(m_in_ephemeral.pub, m_in_ephemeral.sec, ki); + return true; + } + +private: + cryptonote::keypair m_in_ephemeral; +}; diff --git a/tests/performance_tests/generate_key_image_helper.h b/tests/performance_tests/generate_key_image_helper.h new file mode 100644 index 000000000..1c072f443 --- /dev/null +++ b/tests/performance_tests/generate_key_image_helper.h @@ -0,0 +1,24 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#pragma once + +#include "cryptonote_core/account.h" +#include "cryptonote_core/cryptonote_basic.h" +#include "cryptonote_core/cryptonote_format_utils.h" + +#include "single_tx_test_base.h" + +class test_generate_key_image_helper : public single_tx_test_base +{ +public: + static const size_t loop_count = 500; + + bool test() + { + cryptonote::keypair in_ephemeral; + crypto::key_image ki; + return cryptonote::generate_key_image_helper(m_bob.get_keys(), m_tx_pub_key, 0, in_ephemeral, ki); + } +}; diff --git a/tests/performance_tests/is_out_to_acc.h b/tests/performance_tests/is_out_to_acc.h new file mode 100644 index 000000000..4a33c25fb --- /dev/null +++ b/tests/performance_tests/is_out_to_acc.h @@ -0,0 +1,23 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#pragma once + +#include "cryptonote_core/account.h" +#include "cryptonote_core/cryptonote_basic.h" +#include "cryptonote_core/cryptonote_format_utils.h" + +#include "single_tx_test_base.h" + +class test_is_out_to_acc : public single_tx_test_base +{ +public: + static const size_t loop_count = 1000; + + bool test() + { + const cryptonote::txout_to_key& tx_out = boost::get<cryptonote::txout_to_key>(m_tx.vout[0].target); + return cryptonote::is_out_to_acc(m_bob.get_keys(), tx_out, m_tx_pub_key, 0); + } +}; diff --git a/tests/performance_tests/main.cpp b/tests/performance_tests/main.cpp new file mode 100644 index 000000000..2ad503b83 --- /dev/null +++ b/tests/performance_tests/main.cpp @@ -0,0 +1,62 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include "performance_tests.h" +#include "performance_utils.h" + +// tests +#include "construct_tx.h" +#include "check_ring_signature.h" +#include "derive_public_key.h" +#include "derive_secret_key.h" +#include "generate_key_derivation.h" +#include "generate_key_image.h" +#include "generate_key_image_helper.h" +#include "is_out_to_acc.h" + +int main(int argc, char** argv) +{ + set_process_affinity(1); + set_thread_high_priority(); + + performance_timer timer; + timer.start(); + + TEST_PERFORMANCE2(test_construct_tx, 1, 1); + TEST_PERFORMANCE2(test_construct_tx, 1, 2); + TEST_PERFORMANCE2(test_construct_tx, 1, 10); + TEST_PERFORMANCE2(test_construct_tx, 1, 100); + TEST_PERFORMANCE2(test_construct_tx, 1, 1000); + + TEST_PERFORMANCE2(test_construct_tx, 2, 1); + TEST_PERFORMANCE2(test_construct_tx, 2, 2); + TEST_PERFORMANCE2(test_construct_tx, 2, 10); + TEST_PERFORMANCE2(test_construct_tx, 2, 100); + + TEST_PERFORMANCE2(test_construct_tx, 10, 1); + TEST_PERFORMANCE2(test_construct_tx, 10, 2); + TEST_PERFORMANCE2(test_construct_tx, 10, 10); + TEST_PERFORMANCE2(test_construct_tx, 10, 100); + + TEST_PERFORMANCE2(test_construct_tx, 100, 1); + TEST_PERFORMANCE2(test_construct_tx, 100, 2); + TEST_PERFORMANCE2(test_construct_tx, 100, 10); + TEST_PERFORMANCE2(test_construct_tx, 100, 100); + + TEST_PERFORMANCE1(test_check_ring_signature, 1); + TEST_PERFORMANCE1(test_check_ring_signature, 2); + TEST_PERFORMANCE1(test_check_ring_signature, 10); + TEST_PERFORMANCE1(test_check_ring_signature, 100); + + TEST_PERFORMANCE0(test_is_out_to_acc); + TEST_PERFORMANCE0(test_generate_key_image_helper); + TEST_PERFORMANCE0(test_generate_key_derivation); + TEST_PERFORMANCE0(test_generate_key_image); + TEST_PERFORMANCE0(test_derive_public_key); + TEST_PERFORMANCE0(test_derive_secret_key); + + std::cout << "Tests finished. Elapsed time: " << timer.elapsed_ms() / 1000 << " sec" << std::endl; + + return 0; +} diff --git a/tests/performance_tests/multi_tx_test_base.h b/tests/performance_tests/multi_tx_test_base.h new file mode 100644 index 000000000..a65062362 --- /dev/null +++ b/tests/performance_tests/multi_tx_test_base.h @@ -0,0 +1,64 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#pragma once + +#include <vector> + +#include "cryptonote_core/account.h" +#include "cryptonote_core/cryptonote_basic.h" +#include "cryptonote_core/cryptonote_format_utils.h" +#include "crypto/crypto.h" + +template<size_t a_ring_size> +class multi_tx_test_base +{ + static_assert(0 < a_ring_size, "ring_size must be greater than 0"); + +public: + static const size_t ring_size = a_ring_size; + static const size_t real_source_idx = ring_size / 2; + + bool init() + { + using namespace cryptonote; + + std::vector<tx_source_entry::output_entry> output_entries; + for (size_t i = 0; i < ring_size; ++i) + { + m_miners[i].generate(); + + std::vector<size_t> block_sizes; + if (!construct_miner_tx(0, 0, m_miners[i].get_keys().m_account_address, m_miner_txs[i], 0, block_sizes, 2)) + return false; + + txout_to_key tx_out = boost::get<txout_to_key>(m_miner_txs[i].vout[0].target); + output_entries.push_back(std::make_pair(i, tx_out.key)); + m_public_keys[i] = tx_out.key; + m_public_key_ptrs[i] = &m_public_keys[i]; + } + + m_source_amount = m_miner_txs[0].vout[0].amount; + + tx_source_entry source_entry; + source_entry.amount = m_source_amount; + source_entry.real_out_tx_key = get_tx_pub_key_from_extra(m_miner_txs[real_source_idx]); + source_entry.real_output_in_tx_index = 0; + source_entry.outputs.swap(output_entries); + source_entry.real_output = real_source_idx; + + m_sources.push_back(source_entry); + + return true; + } + +protected: + cryptonote::account_base m_miners[ring_size]; + cryptonote::transaction m_miner_txs[ring_size]; + uint64_t m_source_amount; + + std::vector<cryptonote::tx_source_entry> m_sources; + crypto::public_key m_public_keys[ring_size]; + const crypto::public_key* m_public_key_ptrs[ring_size]; +}; diff --git a/tests/performance_tests/performance_tests.h b/tests/performance_tests/performance_tests.h new file mode 100644 index 000000000..c7efe93f1 --- /dev/null +++ b/tests/performance_tests/performance_tests.h @@ -0,0 +1,118 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#pragma once + +#include <iostream> +#include <stdint.h> + +#include <boost/chrono.hpp> + +class performance_timer +{ +public: + typedef boost::chrono::high_resolution_clock clock; + + performance_timer() + { + m_base = clock::now(); + } + + void start() + { + m_start = clock::now(); + } + + int elapsed_ms() + { + clock::duration elapsed = clock::now() - m_start; + return static_cast<int>(boost::chrono::duration_cast<boost::chrono::milliseconds>(elapsed).count()); + } + +private: + clock::time_point m_base; + clock::time_point m_start; +}; + + +template <typename T> +class test_runner +{ +public: + test_runner() + : m_elapsed(0) + { + } + + bool run() + { + T test; + if (!test.init()) + return false; + + performance_timer timer; + timer.start(); + warm_up(); + std::cout << "Warm up: " << timer.elapsed_ms() << " ms" << std::endl; + + timer.start(); + for (size_t i = 0; i < T::loop_count; ++i) + { + if (!test.test()) + return false; + } + m_elapsed = timer.elapsed_ms(); + + return true; + } + + int elapsed_time() const { return m_elapsed; } + + int time_per_call() const + { + static_assert(0 < T::loop_count, "T::loop_count must be greater than 0"); + return m_elapsed / T::loop_count; + } + +private: + /** + * Warm up processor core, enabling turbo boost, etc. + */ + uint64_t warm_up() + { + const size_t warm_up_rounds = 1000 * 1000 * 1000; + m_warm_up = 0; + for (size_t i = 0; i < warm_up_rounds; ++i) + { + ++m_warm_up; + } + return m_warm_up; + } + +private: + volatile uint64_t m_warm_up; ///<! This field is intended for preclude compiler optimizations + int m_elapsed; +}; + +template <typename T> +void run_test(const char* test_name) +{ + test_runner<T> runner; + if (runner.run()) + { + std::cout << test_name << " - OK:\n"; + std::cout << " loop count: " << T::loop_count << '\n'; + std::cout << " elapsed: " << runner.elapsed_time() << " ms\n"; + std::cout << " time per call: " << runner.time_per_call() << " ms/call\n" << std::endl; + } + else + { + std::cout << test_name << " - FAILED" << std::endl; + } +} + +#define QUOTEME(x) #x +#define TEST_PERFORMANCE0(test_class) run_test< test_class >(QUOTEME(test_class)) +#define TEST_PERFORMANCE1(test_class, a0) run_test< test_class<a0> >(QUOTEME(test_class<a0>)) +#define TEST_PERFORMANCE2(test_class, a0, a1) run_test< test_class<a0, a1> >(QUOTEME(test_class) "<" QUOTEME(a0) ", " QUOTEME(a1) ">") diff --git a/tests/performance_tests/performance_utils.h b/tests/performance_tests/performance_utils.h new file mode 100644 index 000000000..b2ac4076f --- /dev/null +++ b/tests/performance_tests/performance_utils.h @@ -0,0 +1,55 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#pragma once + +#include <iostream> + +#include <boost/config.hpp> + +#ifdef BOOST_WINDOWS +#include <windows.h> +#endif + +void set_process_affinity(int core) +{ +#if defined(BOOST_WINDOWS) + DWORD_PTR mask = 1; + for (int i = 0; i < core; ++i) + { + mask <<= 1; + } + ::SetProcessAffinityMask(::GetCurrentProcess(), core); +#elif defined(BOOST_HAS_PTHREADS) + cpu_set_t cpuset; + CPU_ZERO(&cpuset); + CPU_SET(core, &cpuset); + if (0 != ::pthread_setaffinity_np(::pthread_self(), sizeof(cpuset), &cpuset)) + { + std::cout << "pthread_setaffinity_np - ERROR" << std::endl; + } +#endif +} + +void set_thread_high_priority() +{ +#if defined(BOOST_WINDOWS) + ::SetPriorityClass(::GetCurrentProcess(), HIGH_PRIORITY_CLASS); +#elif defined(BOOST_HAS_PTHREADS) + pthread_attr_t attr; + int policy = 0; + int max_prio_for_policy = 0; + + ::pthread_attr_init(&attr); + ::pthread_attr_getschedpolicy(&attr, &policy); + max_prio_for_policy = ::sched_get_priority_max(policy); + + if (0 != ::pthread_setschedprio(::pthread_self(), max_prio_for_policy)) + { + std::cout << "pthread_setschedprio - ERROR" << std::endl; + } + + ::pthread_attr_destroy(&attr); +#endif +} diff --git a/tests/performance_tests/single_tx_test_base.h b/tests/performance_tests/single_tx_test_base.h new file mode 100644 index 000000000..a622fce89 --- /dev/null +++ b/tests/performance_tests/single_tx_test_base.h @@ -0,0 +1,32 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#pragma once + +#include "cryptonote_core/account.h" +#include "cryptonote_core/cryptonote_basic.h" +#include "cryptonote_core/cryptonote_format_utils.h" + +class single_tx_test_base +{ +public: + bool init() + { + using namespace cryptonote; + + m_bob.generate(); + + std::vector<size_t> block_sizes; + if (!construct_miner_tx(0, 0, m_bob.get_keys().m_account_address, m_tx, 0, block_sizes, 2)) + return false; + + m_tx_pub_key = get_tx_pub_key_from_extra(m_tx); + return true; + } + +protected: + cryptonote::account_base m_bob; + cryptonote::transaction m_tx; + crypto::public_key m_tx_pub_key; +}; diff --git a/tests/unit_tests/base58.cpp b/tests/unit_tests/base58.cpp new file mode 100644 index 000000000..05bf5afc7 --- /dev/null +++ b/tests/unit_tests/base58.cpp @@ -0,0 +1,502 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include "gtest/gtest.h" + +#include <cstdint> + +#include "common/base58.cpp" +#include "cryptonote_core/cryptonote_basic_impl.h" +#include "serialization/binary_utils.h" + +using namespace tools; + +#define MAKE_STR(arr) std::string(arr, sizeof(arr) - 1) + +namespace +{ + void do_test_uint_8be_to_64(uint64_t expected, const uint8_t* data, size_t size) + { + uint64_t val = base58::uint_8be_to_64(data, size); + ASSERT_EQ(val, expected); + } + + void do_test_uint_64_to_8be(uint64_t num, const std::string& expected_str) + { + std::string data(expected_str.size(), '\x0'); + base58::uint_64_to_8be(num, data.size(), reinterpret_cast<uint8_t*>(&data[0])); + ASSERT_EQ(data, expected_str); + } + + void do_test_encode_block(const std::string& block, const std::string& expected) + { + ASSERT_TRUE(1 <= block.size() && block.size() <= base58::full_block_size); + std::string enc(base58::encoded_block_sizes[block.size()], base58::alphabet[0]); + base58::encode_block(block.data(), block.size(), &enc[0]); + ASSERT_EQ(enc, expected); + + std::string dec(block.size(), '\0'); + ASSERT_TRUE(base58::decode_block(enc.data(), enc.size(), &dec[0])); + ASSERT_EQ(block, dec); + } + + void do_test_decode_block_pos(const std::string& enc, const std::string& expected) + { + std::string data(base58::decoded_block_sizes::instance(enc.size()), '\0'); + ASSERT_TRUE(base58::decode_block(enc.data(), enc.size(), &data[0])); + ASSERT_EQ(data, expected); + } + + void do_test_decode_block_neg(const std::string& enc) + { + std::string data(base58::full_block_size, '\0'); + ASSERT_FALSE(base58::decode_block(enc.data(), enc.size(), &data[0])); + } + + void do_test_encode(const std::string& data, const std::string& expected) + { + std::string enc = base58::encode(data); + ASSERT_EQ(enc, expected); + + std::string dec; + ASSERT_TRUE(base58::decode(enc, dec)); + ASSERT_EQ(dec, data); + } + + void do_test_decode_pos(const std::string& enc, const std::string& expected) + { + std::string dec; + ASSERT_TRUE(base58::decode(enc, dec)); + ASSERT_EQ(dec, expected); + } + + void do_test_decode_neg(const std::string& enc) + { + std::string dec; + ASSERT_FALSE(base58::decode(enc, dec)); + } + + void do_test_encode_decode_addr(uint64_t tag, const std::string& data, const std::string& expected) + { + std::string addr = base58::encode_addr(tag, data); + ASSERT_EQ(addr, expected); + + uint64_t dec_tag; + std::string dec_data; + ASSERT_TRUE(base58::decode_addr(addr, dec_tag, dec_data)); + ASSERT_EQ(tag, dec_tag); + ASSERT_EQ(data, dec_data); + } +} + +#define TEST_uint_8be_to_64(expected, str) \ + TEST(base58_uint_8be_to_64, handles_bytes_##expected) \ + { \ + std::string data = str; \ + do_test_uint_8be_to_64(expected, reinterpret_cast<const uint8_t*>(data.data()), data.size()); \ + } + +TEST_uint_8be_to_64(0x0000000000000001, "\x1"); +TEST_uint_8be_to_64(0x0000000000000102, "\x1\x2"); +TEST_uint_8be_to_64(0x0000000000010203, "\x1\x2\x3"); +TEST_uint_8be_to_64(0x0000000001020304, "\x1\x2\x3\x4"); +TEST_uint_8be_to_64(0x0000000102030405, "\x1\x2\x3\x4\x5"); +TEST_uint_8be_to_64(0x0000010203040506, "\x1\x2\x3\x4\x5\x6"); +TEST_uint_8be_to_64(0x0001020304050607, "\x1\x2\x3\x4\x5\x6\x7"); +TEST_uint_8be_to_64(0x0102030405060708, "\x1\x2\x3\x4\x5\x6\x7\x8"); + + +#define TEST_uint_64_to_8be(num, expected_str) \ + TEST(base58_uint_64_to_8be, handles_bytes_##num) \ + { \ + do_test_uint_64_to_8be(num, expected_str); \ + } + +TEST_uint_64_to_8be(0x0000000000000001, "\x1"); +TEST_uint_64_to_8be(0x0000000000000102, "\x1\x2"); +TEST_uint_64_to_8be(0x0000000000010203, "\x1\x2\x3"); +TEST_uint_64_to_8be(0x0000000001020304, "\x1\x2\x3\x4"); +TEST_uint_64_to_8be(0x0000000102030405, "\x1\x2\x3\x4\x5"); +TEST_uint_64_to_8be(0x0000010203040506, "\x1\x2\x3\x4\x5\x6"); +TEST_uint_64_to_8be(0x0001020304050607, "\x1\x2\x3\x4\x5\x6\x7"); +TEST_uint_64_to_8be(0x0102030405060708, "\x1\x2\x3\x4\x5\x6\x7\x8"); + +TEST(reverse_alphabet, is_correct) +{ + ASSERT_EQ(-1, base58::reverse_alphabet::instance(0)); + ASSERT_EQ(-1, base58::reverse_alphabet::instance(std::numeric_limits<char>::min())); + ASSERT_EQ(-1, base58::reverse_alphabet::instance(std::numeric_limits<char>::max())); + ASSERT_EQ(-1, base58::reverse_alphabet::instance('1' - 1)); + ASSERT_EQ(-1, base58::reverse_alphabet::instance('z' + 1)); + ASSERT_EQ(-1, base58::reverse_alphabet::instance('0')); + ASSERT_EQ(-1, base58::reverse_alphabet::instance('I')); + ASSERT_EQ(-1, base58::reverse_alphabet::instance('O')); + ASSERT_EQ(-1, base58::reverse_alphabet::instance('l')); + ASSERT_EQ(0, base58::reverse_alphabet::instance('1')); + ASSERT_EQ(8, base58::reverse_alphabet::instance('9')); + ASSERT_EQ(base58::alphabet_size - 1, base58::reverse_alphabet::instance('z')); +} + + +#define TEST_encode_block(block, expected) \ + TEST(base58_encode_block, handles_##expected) \ + { \ + do_test_encode_block(MAKE_STR(block), #expected); \ + } + +TEST_encode_block("\x00", 11); +TEST_encode_block("\x39", 1z); +TEST_encode_block("\xFF", 5Q); + +TEST_encode_block("\x00\x00", 111); +TEST_encode_block("\x00\x39", 11z); +TEST_encode_block("\x01\x00", 15R); +TEST_encode_block("\xFF\xFF", LUv); + +TEST_encode_block("\x00\x00\x00", 11111); +TEST_encode_block("\x00\x00\x39", 1111z); +TEST_encode_block("\x01\x00\x00", 11LUw); +TEST_encode_block("\xFF\xFF\xFF", 2UzHL); + +TEST_encode_block("\x00\x00\x00\x39", 11111z); +TEST_encode_block("\xFF\xFF\xFF\xFF", 7YXq9G); +TEST_encode_block("\x00\x00\x00\x00\x39", 111111z); +TEST_encode_block("\xFF\xFF\xFF\xFF\xFF", VtB5VXc); +TEST_encode_block("\x00\x00\x00\x00\x00\x39", 11111111z); +TEST_encode_block("\xFF\xFF\xFF\xFF\xFF\xFF", 3CUsUpv9t); +TEST_encode_block("\x00\x00\x00\x00\x00\x00\x39", 111111111z); +TEST_encode_block("\xFF\xFF\xFF\xFF\xFF\xFF\xFF", Ahg1opVcGW); +TEST_encode_block("\x00\x00\x00\x00\x00\x00\x00\x39", 1111111111z); +TEST_encode_block("\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF", jpXCZedGfVQ); + +TEST_encode_block("\x00\x00\x00\x00\x00\x00\x00\x00", 11111111111); +TEST_encode_block("\x00\x00\x00\x00\x00\x00\x00\x01", 11111111112); +TEST_encode_block("\x00\x00\x00\x00\x00\x00\x00\x08", 11111111119); +TEST_encode_block("\x00\x00\x00\x00\x00\x00\x00\x09", 1111111111A); +TEST_encode_block("\x00\x00\x00\x00\x00\x00\x00\x3A", 11111111121); +TEST_encode_block("\x00\xFF\xFF\xFF\xFF\xFF\xFF\xFF", 1Ahg1opVcGW); +TEST_encode_block("\x06\x15\x60\x13\x76\x28\x79\xF7", 22222222222); +TEST_encode_block("\x05\xE0\x22\xBA\x37\x4B\x2A\x00", 1z111111111); + + +#define TEST_decode_block_pos(enc, expected) \ + TEST(base58_decode_block, handles_pos_##enc) \ + { \ + do_test_decode_block_pos(#enc, MAKE_STR(expected)); \ + } + +#define TEST_decode_block_neg(enc) \ + TEST(base58_decode_block, handles_neg_##enc) \ + { \ + do_test_decode_block_neg(#enc); \ + } + +// 1-byte block +TEST_decode_block_neg(1); +TEST_decode_block_neg(z); +// 2-bytes block +TEST_decode_block_pos(11, "\x00"); +TEST_decode_block_pos(5Q, "\xFF"); +TEST_decode_block_neg(5R); +TEST_decode_block_neg(zz); +// 3-bytes block +TEST_decode_block_pos(111, "\x00\x00"); +TEST_decode_block_pos(LUv, "\xFF\xFF"); +TEST_decode_block_neg(LUw); +TEST_decode_block_neg(zzz); +// 4-bytes block +TEST_decode_block_neg(1111); +TEST_decode_block_neg(zzzz); +// 5-bytes block +TEST_decode_block_pos(11111, "\x00\x00\x00"); +TEST_decode_block_pos(2UzHL, "\xFF\xFF\xFF"); +TEST_decode_block_neg(2UzHM); +TEST_decode_block_neg(zzzzz); +// 6-bytes block +TEST_decode_block_pos(111111, "\x00\x00\x00\x00"); +TEST_decode_block_pos(7YXq9G, "\xFF\xFF\xFF\xFF"); +TEST_decode_block_neg(7YXq9H); +TEST_decode_block_neg(zzzzzz); +// 7-bytes block +TEST_decode_block_pos(1111111, "\x00\x00\x00\x00\x00"); +TEST_decode_block_pos(VtB5VXc, "\xFF\xFF\xFF\xFF\xFF"); +TEST_decode_block_neg(VtB5VXd); +TEST_decode_block_neg(zzzzzzz); +// 8-bytes block +TEST_decode_block_neg(11111111); +TEST_decode_block_neg(zzzzzzzz); +// 9-bytes block +TEST_decode_block_pos(111111111, "\x00\x00\x00\x00\x00\x00"); +TEST_decode_block_pos(3CUsUpv9t, "\xFF\xFF\xFF\xFF\xFF\xFF"); +TEST_decode_block_neg(3CUsUpv9u); +TEST_decode_block_neg(zzzzzzzzz); +// 10-bytes block +TEST_decode_block_pos(1111111111, "\x00\x00\x00\x00\x00\x00\x00"); +TEST_decode_block_pos(Ahg1opVcGW, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF"); +TEST_decode_block_neg(Ahg1opVcGX); +TEST_decode_block_neg(zzzzzzzzzz); +// 11-bytes block +TEST_decode_block_pos(11111111111, "\x00\x00\x00\x00\x00\x00\x00\x00"); +TEST_decode_block_pos(jpXCZedGfVQ, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"); +TEST_decode_block_neg(jpXCZedGfVR); +TEST_decode_block_neg(zzzzzzzzzzz); +// Invalid symbols +TEST_decode_block_neg(01111111111); +TEST_decode_block_neg(11111111110); +TEST_decode_block_neg(11111011111); +TEST_decode_block_neg(I1111111111); +TEST_decode_block_neg(O1111111111); +TEST_decode_block_neg(l1111111111); +TEST_decode_block_neg(_1111111111); + + +#define TEST_encode(expected, data) \ + TEST(base58_encode, handles_##expected) \ + { \ + do_test_encode(MAKE_STR(data), #expected); \ + } + +TEST_encode(11, "\x00"); +TEST_encode(111, "\x00\x00"); +TEST_encode(11111, "\x00\x00\x00"); +TEST_encode(111111, "\x00\x00\x00\x00"); +TEST_encode(1111111, "\x00\x00\x00\x00\x00"); +TEST_encode(111111111, "\x00\x00\x00\x00\x00\x00"); +TEST_encode(1111111111, "\x00\x00\x00\x00\x00\x00\x00"); +TEST_encode(11111111111, "\x00\x00\x00\x00\x00\x00\x00\x00"); +TEST_encode(1111111111111, "\x00\x00\x00\x00\x00\x00\x00\x00\x00"); +TEST_encode(11111111111111, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); +TEST_encode(1111111111111111, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); +TEST_encode(11111111111111111, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); +TEST_encode(111111111111111111, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); +TEST_encode(11111111111111111111, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); +TEST_encode(111111111111111111111, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); +TEST_encode(1111111111111111111111, "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); +TEST_encode(22222222222VtB5VXc, "\x06\x15\x60\x13\x76\x28\x79\xF7\xFF\xFF\xFF\xFF\xFF"); + + +#define TEST_decode_pos(enc, expected) \ + TEST(base58_decode_pos, handles_pos_##enc) \ + { \ + do_test_decode_pos(#enc, MAKE_STR(expected)); \ + } + +#define TEST_decode_neg(enc) \ + TEST(base58_decode_neg, handles_neg_##enc) \ + { \ + do_test_decode_neg(#enc); \ + } + +TEST_decode_pos(, ""); +TEST_decode_pos(5Q, "\xFF"); +TEST_decode_pos(LUv, "\xFF\xFF"); +TEST_decode_pos(2UzHL, "\xFF\xFF\xFF"); +TEST_decode_pos(7YXq9G, "\xFF\xFF\xFF\xFF"); +TEST_decode_pos(VtB5VXc, "\xFF\xFF\xFF\xFF\xFF"); +TEST_decode_pos(3CUsUpv9t, "\xFF\xFF\xFF\xFF\xFF\xFF"); +TEST_decode_pos(Ahg1opVcGW, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF"); +TEST_decode_pos(jpXCZedGfVQ, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"); +TEST_decode_pos(jpXCZedGfVQ5Q, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"); +TEST_decode_pos(jpXCZedGfVQLUv, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"); +TEST_decode_pos(jpXCZedGfVQ2UzHL, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"); +TEST_decode_pos(jpXCZedGfVQ7YXq9G, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"); +TEST_decode_pos(jpXCZedGfVQVtB5VXc, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"); +TEST_decode_pos(jpXCZedGfVQ3CUsUpv9t, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"); +TEST_decode_pos(jpXCZedGfVQAhg1opVcGW, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"); +TEST_decode_pos(jpXCZedGfVQjpXCZedGfVQ, "\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"); +// Invalid length +TEST_decode_neg(1); +TEST_decode_neg(z); +TEST_decode_neg(1111); +TEST_decode_neg(zzzz); +TEST_decode_neg(11111111); +TEST_decode_neg(zzzzzzzz); +TEST_decode_neg(123456789AB1); +TEST_decode_neg(123456789ABz); +TEST_decode_neg(123456789AB1111); +TEST_decode_neg(123456789ABzzzz); +TEST_decode_neg(123456789AB11111111); +TEST_decode_neg(123456789ABzzzzzzzz); +// Overflow +TEST_decode_neg(5R); +TEST_decode_neg(zz); +TEST_decode_neg(LUw); +TEST_decode_neg(zzz); +TEST_decode_neg(2UzHM); +TEST_decode_neg(zzzzz); +TEST_decode_neg(7YXq9H); +TEST_decode_neg(zzzzzz); +TEST_decode_neg(VtB5VXd); +TEST_decode_neg(zzzzzzz); +TEST_decode_neg(3CUsUpv9u); +TEST_decode_neg(zzzzzzzzz); +TEST_decode_neg(Ahg1opVcGX); +TEST_decode_neg(zzzzzzzzzz); +TEST_decode_neg(jpXCZedGfVR); +TEST_decode_neg(zzzzzzzzzzz); +TEST_decode_neg(123456789AB5R); +TEST_decode_neg(123456789ABzz); +TEST_decode_neg(123456789ABLUw); +TEST_decode_neg(123456789ABzzz); +TEST_decode_neg(123456789AB2UzHM); +TEST_decode_neg(123456789ABzzzzz); +TEST_decode_neg(123456789AB7YXq9H); +TEST_decode_neg(123456789ABzzzzzz); +TEST_decode_neg(123456789ABVtB5VXd); +TEST_decode_neg(123456789ABzzzzzzz); +TEST_decode_neg(123456789AB3CUsUpv9u); +TEST_decode_neg(123456789ABzzzzzzzzz); +TEST_decode_neg(123456789ABAhg1opVcGX); +TEST_decode_neg(123456789ABzzzzzzzzzz); +TEST_decode_neg(123456789ABjpXCZedGfVR); +TEST_decode_neg(123456789ABzzzzzzzzzzz); +TEST_decode_neg(zzzzzzzzzzz11); +// Invalid symbols +TEST_decode_neg(10); +TEST_decode_neg(11I); +TEST_decode_neg(11O11); +TEST_decode_neg(11l111); +TEST_decode_neg(11_11111111); +TEST_decode_neg(1101111111111); +TEST_decode_neg(11I11111111111111); +TEST_decode_neg(11O1111111111111111111); +TEST_decode_neg(1111111111110); +TEST_decode_neg(111111111111l1111); +TEST_decode_neg(111111111111_111111111); + + +#define TEST_encode_decode_addr(addr, tag, data) \ + TEST(base58_encode_decode_addr, handles_##addr) \ + { \ + do_test_encode_decode_addr(UINT64_C(tag), MAKE_STR(data), #addr); \ + } + +TEST_encode_decode_addr(21D35quxec71111111111111111111111111111111111111111111111111111111111111111111111111111116Q5tCH, 6, + "\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" + "\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"); +TEST_encode_decode_addr(2Aui6ejTFscjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQVqegMoV, 6, + "\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" + "\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"); +TEST_encode_decode_addr(1119XrkPuSmLzdHXgVgrZKjepg5hZAxffLzdHXgVgrZKjepg5hZAxffLzdHXgVgrZKjepg5hZAxffLzdHXgVgrZKVphZRvn, 0, + "\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF" + "\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF"); +TEST_encode_decode_addr(111111111111111111111111111111111111111111111111111111111111111111111111111111111111111115TXfiA, 0, + "\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" + "\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"); +TEST_encode_decode_addr(PuT7GAdgbA83qvSEivPLYo11111111111111111111111111111111111111111111111111111111111111111111111111111169tWrH, 0x1122334455667788, + "\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" + "\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"); +TEST_encode_decode_addr(PuT7GAdgbA841d7FXjswpJjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQjpXCZedGfVQVq4LL1v, 0x1122334455667788, + "\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" + "\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"); +TEST_encode_decode_addr(PuT7GAdgbA819VwdWVDP, 0x1122334455667788, "\x11"); +TEST_encode_decode_addr(PuT7GAdgbA81efAfdCjPg, 0x1122334455667788, "\x22\x22"); +TEST_encode_decode_addr(PuT7GAdgbA83sryEt3YC8Q, 0x1122334455667788, "\x33\x33\x33"); +TEST_encode_decode_addr(PuT7GAdgbA83tWUuc54PFP3b, 0x1122334455667788, "\x44\x44\x44\x44"); +TEST_encode_decode_addr(PuT7GAdgbA83u9zaKrtRKZ1J6, 0x1122334455667788, "\x55\x55\x55\x55\x55"); +TEST_encode_decode_addr(PuT7GAdgbA83uoWF3eanGG1aRoG, 0x1122334455667788, "\x66\x66\x66\x66\x66\x66"); +TEST_encode_decode_addr(PuT7GAdgbA83vT1umSHMYJ4oNVdu, 0x1122334455667788, "\x77\x77\x77\x77\x77\x77\x77"); +TEST_encode_decode_addr(PuT7GAdgbA83w6XaVDyvpoGQBEWbB, 0x1122334455667788, "\x88\x88\x88\x88\x88\x88\x88\x88"); +TEST_encode_decode_addr(PuT7GAdgbA83wk3FD1gW7J2KVGofA1r, 0x1122334455667788, "\x99\x99\x99\x99\x99\x99\x99\x99\x99"); +TEST_encode_decode_addr(11efCaY6UjG7JrxuB, 0, "\x11\x22\x33\x44\x55\x66\x77"); +TEST_encode_decode_addr(21rhHRT48LN4PriP9, 6, "\x11\x22\x33\x44\x55\x66\x77"); +TEST_encode_decode_addr(3BzAD7n3y, 0xFF, ""); + + +#define TEST_decode_addr_neg(addr, test_name) \ + TEST(base58_decode_addr_neg, test_name) \ + { \ + uint64_t tag; \ + std::string data; \ + ASSERT_FALSE(base58::decode_addr(MAKE_STR(addr), tag, data)); \ + } + +TEST_decode_addr_neg("zuT7GAdgbA819VwdWVDP", decode_fails_due_overflow); +TEST_decode_addr_neg("0uT7GAdgbA819VwdWVDP", decode_fails_due_invalid_char_0); +TEST_decode_addr_neg("IuT7GAdgbA819VwdWVDP", decode_fails_due_invalid_char_I); +TEST_decode_addr_neg("OuT7GAdgbA819VwdWVDP", decode_fails_due_invalid_char_O); +TEST_decode_addr_neg("luT7GAdgbA819VwdWVDP", decode_fails_due_invalid_char_l); +TEST_decode_addr_neg("\0uT7GAdgbA819VwdWVDP", decode_fails_due_invalid_char_00); +TEST_decode_addr_neg("PuT7GAdgbA819VwdWVD", decode_fails_due_invalid_lenght); +TEST_decode_addr_neg("11efCaY6UjG7JrxuC", handles_invalid_checksum); +TEST_decode_addr_neg("jerj2e4mESo", handles_non_correct_tag); // "jerj2e4mESo" == "\xFF\x00\xFF\xFF\x5A\xD9\xF1\x1C" + +namespace +{ + std::string test_serialized_keys = MAKE_STR( + "\xf7\x24\xbc\x5c\x6c\xfb\xb9\xd9\x76\x02\xc3\x00\x42\x3a\x2f\x28" + "\x64\x18\x74\x51\x3a\x03\x57\x78\xa0\xc1\x77\x8d\x83\x32\x01\xe9" + "\x22\x09\x39\x68\x9e\xdf\x1a\xbd\x5b\xc1\xd0\x31\xf7\x3e\xcd\x6c" + "\x99\x3a\xdd\x66\xd6\x80\x88\x70\x45\x6a\xfe\xb8\xe7\xee\xb6\x8d"); + std::string test_keys_addr_str = "2AaF4qEmER6dNeM6dfiBFL7kqund3HYGvMBF3ttsNd9SfzgYB6L7ep1Yg1osYJzLdaKAYSLVh6e6jKnAuzj3bw1oGyd1x7Z"; +} + +TEST(get_account_address_as_str, works_correctly) +{ + cryptonote::account_public_address addr; + ASSERT_TRUE(serialization::parse_binary(test_serialized_keys, addr)); + std::string addr_str = cryptonote::get_account_address_as_str(addr); + ASSERT_EQ(addr_str, test_keys_addr_str); +} + +TEST(get_account_address_from_str, handles_valid_address) +{ + cryptonote::account_public_address addr; + ASSERT_TRUE(cryptonote::get_account_address_from_str(addr, test_keys_addr_str)); + + std::string blob; + ASSERT_TRUE(serialization::dump_binary(addr, blob)); + ASSERT_EQ(blob, test_serialized_keys); +} + +TEST(get_account_address_from_str, fails_on_invalid_address_format) +{ + cryptonote::account_public_address addr; + std::string addr_str = test_keys_addr_str; + addr_str[0] = '0'; + + ASSERT_FALSE(cryptonote::get_account_address_from_str(addr, addr_str)); +} + +TEST(get_account_address_from_str, fails_on_invalid_address_prefix) +{ + std::string addr_str = base58::encode_addr(0, test_serialized_keys); + + cryptonote::account_public_address addr; + ASSERT_FALSE(cryptonote::get_account_address_from_str(addr, addr_str)); +} + +TEST(get_account_address_from_str, fails_on_invalid_address_content) +{ + std::string addr_str = base58::encode_addr(CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX, test_serialized_keys.substr(1)); + + cryptonote::account_public_address addr; + ASSERT_FALSE(cryptonote::get_account_address_from_str(addr, addr_str)); +} + +TEST(get_account_address_from_str, fails_on_invalid_address_spend_key) +{ + std::string serialized_keys_copy = test_serialized_keys; + serialized_keys_copy[0] = '\0'; + std::string addr_str = base58::encode_addr(CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX, serialized_keys_copy); + + cryptonote::account_public_address addr; + ASSERT_FALSE(cryptonote::get_account_address_from_str(addr, addr_str)); +} + +TEST(get_account_address_from_str, fails_on_invalid_address_view_key) +{ + std::string serialized_keys_copy = test_serialized_keys; + serialized_keys_copy.back() = '\x01'; + std::string addr_str = base58::encode_addr(CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX, serialized_keys_copy); + + cryptonote::account_public_address addr; + ASSERT_FALSE(cryptonote::get_account_address_from_str(addr, addr_str)); +} + +TEST(get_account_address_from_str, parses_old_address_format) +{ + cryptonote::account_public_address addr; + ASSERT_TRUE(cryptonote::get_account_address_from_str(addr, "002391bbbb24dea6fd95232e97594a27769d0153d053d2102b789c498f57a2b00b69cd6f2f5c529c1660f2f4a2b50178d6640c20ce71fe26373041af97c5b10236fc")); +} diff --git a/tests/unit_tests/block_reward.cpp b/tests/unit_tests/block_reward.cpp new file mode 100644 index 000000000..cfa12a7c8 --- /dev/null +++ b/tests/unit_tests/block_reward.cpp @@ -0,0 +1,226 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include "gtest/gtest.h" + +#include "cryptonote_core/cryptonote_basic_impl.h" + +using namespace cryptonote; + +namespace +{ + //-------------------------------------------------------------------------------------------------------------------- + class block_reward_and_already_generated_coins : public ::testing::Test + { + protected: + static const size_t current_block_size = CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE / 2; + + std::vector<size_t> m_last_block_sizes; + bool m_block_too_big; + uint64_t m_block_reward; + }; + + #define TEST_ALREADY_GENERATED_COINS(already_generated_coins, expected_reward) \ + m_block_reward = get_block_reward(m_last_block_sizes, current_block_size, m_block_too_big, already_generated_coins); \ + ASSERT_FALSE(m_block_too_big); \ + ASSERT_EQ(m_block_reward, UINT64_C(expected_reward)); + + TEST_F(block_reward_and_already_generated_coins, handles_first_values) + { + TEST_ALREADY_GENERATED_COINS(0, 70368744177663); + TEST_ALREADY_GENERATED_COINS(m_block_reward, 70368475742208); + TEST_ALREADY_GENERATED_COINS(UINT64_C(2756434948434199641), 59853779316998); + } + + TEST_F(block_reward_and_already_generated_coins, correctly_steps_from_2_to_1) + { + TEST_ALREADY_GENERATED_COINS(MONEY_SUPPLY - ((2 << 18) + 1), 2); + TEST_ALREADY_GENERATED_COINS(MONEY_SUPPLY - (2 << 18) , 2); + TEST_ALREADY_GENERATED_COINS(MONEY_SUPPLY - ((2 << 18) - 1), 1); + } + + TEST_F(block_reward_and_already_generated_coins, handles_max) + { + TEST_ALREADY_GENERATED_COINS(MONEY_SUPPLY - ((1 << 18) + 1), 1); + TEST_ALREADY_GENERATED_COINS(MONEY_SUPPLY - (1 << 18) , 1); + TEST_ALREADY_GENERATED_COINS(MONEY_SUPPLY - ((1 << 18) - 1), 0); + } + + //-------------------------------------------------------------------------------------------------------------------- + class block_reward_and_current_block_size : public ::testing::Test + { + protected: + virtual void SetUp() + { + m_standard_block_reward = get_block_reward(m_last_block_sizes, 0, m_block_too_big, already_generated_coins); + ASSERT_FALSE(m_block_too_big); + ASSERT_LT(CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE, m_standard_block_reward); + } + + void do_test(size_t current_block_size) + { + m_block_reward = get_block_reward(m_last_block_sizes, current_block_size, m_block_too_big, already_generated_coins); + } + + static const uint64_t already_generated_coins = 0; + + std::vector<size_t> m_last_block_sizes; + bool m_block_too_big; + uint64_t m_block_reward; + uint64_t m_standard_block_reward; + }; + + TEST_F(block_reward_and_current_block_size, handles_block_size_less_relevance_level) + { + do_test(CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE - 1); + ASSERT_FALSE(m_block_too_big); + ASSERT_EQ(m_block_reward, m_standard_block_reward); + } + + TEST_F(block_reward_and_current_block_size, handles_block_size_eq_relevance_level) + { + do_test(CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE); + ASSERT_FALSE(m_block_too_big); + ASSERT_EQ(m_block_reward, m_standard_block_reward); + } + + TEST_F(block_reward_and_current_block_size, handles_block_size_gt_relevance_level) + { + do_test(CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE + 1); + ASSERT_FALSE(m_block_too_big); + ASSERT_LT(m_block_reward, m_standard_block_reward); + } + + TEST_F(block_reward_and_current_block_size, handles_block_size_less_2_relevance_level) + { + do_test(2 * CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE - 1); + ASSERT_FALSE(m_block_too_big); + ASSERT_LT(m_block_reward, m_standard_block_reward); + ASSERT_LT(0, m_block_reward); + } + + TEST_F(block_reward_and_current_block_size, handles_block_size_eq_2_relevance_level) + { + do_test(2 * CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE); + ASSERT_FALSE(m_block_too_big); + ASSERT_EQ(0, m_block_reward); + } + + TEST_F(block_reward_and_current_block_size, handles_block_size_gt_2_relevance_level) + { + do_test(2 * CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE + 1); + ASSERT_TRUE(m_block_too_big); + } + + TEST_F(block_reward_and_current_block_size, fails_on_huge_median_size) + { +#if !defined(NDEBUG) + size_t huge_size = std::numeric_limits<uint32_t>::max() + UINT64_C(2); + m_last_block_sizes.push_back(huge_size); + ASSERT_DEATH(do_test(huge_size + 1), ""); +#endif + } + + TEST_F(block_reward_and_current_block_size, fails_on_huge_block_size) + { +#if !defined(NDEBUG) + size_t huge_size = std::numeric_limits<uint32_t>::max() + UINT64_C(2); + m_last_block_sizes.push_back(huge_size - 2); + ASSERT_DEATH(do_test(huge_size), ""); +#endif + } + + //-------------------------------------------------------------------------------------------------------------------- + class block_reward_and_last_block_sizes : public ::testing::Test + { + protected: + virtual void SetUp() + { + m_last_block_sizes.push_back(3 * CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE); + m_last_block_sizes.push_back(5 * CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE); + m_last_block_sizes.push_back(7 * CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE); + m_last_block_sizes.push_back(11 * CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE); + m_last_block_sizes.push_back(13 * CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE); + + m_last_block_sizes_median = 7 * CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE; + + m_standard_block_reward = get_block_reward(m_last_block_sizes, 0, m_block_too_big, already_generated_coins); + ASSERT_FALSE(m_block_too_big); + ASSERT_LT(CRYPTONOTE_BLOCK_GRANTED_FULL_REWARD_ZONE, m_standard_block_reward); + } + + void do_test(size_t current_block_size) + { + m_block_reward = get_block_reward(m_last_block_sizes, current_block_size, m_block_too_big, already_generated_coins); + } + + static const uint64_t already_generated_coins = 0; + + std::vector<size_t> m_last_block_sizes; + uint64_t m_last_block_sizes_median; + bool m_block_too_big; + uint64_t m_block_reward; + uint64_t m_standard_block_reward; + }; + + TEST_F(block_reward_and_last_block_sizes, handles_block_size_less_median) + { + do_test(m_last_block_sizes_median - 1); + ASSERT_FALSE(m_block_too_big); + ASSERT_EQ(m_block_reward, m_standard_block_reward); + } + + TEST_F(block_reward_and_last_block_sizes, handles_block_size_eq_median) + { + do_test(m_last_block_sizes_median); + ASSERT_FALSE(m_block_too_big); + ASSERT_EQ(m_block_reward, m_standard_block_reward); + } + + TEST_F(block_reward_and_last_block_sizes, handles_block_size_gt_median) + { + do_test(m_last_block_sizes_median + 1); + ASSERT_FALSE(m_block_too_big); + ASSERT_LT(m_block_reward, m_standard_block_reward); + } + + TEST_F(block_reward_and_last_block_sizes, handles_block_size_less_2_medians) + { + do_test(2 * m_last_block_sizes_median - 1); + ASSERT_FALSE(m_block_too_big); + ASSERT_LT(m_block_reward, m_standard_block_reward); + ASSERT_LT(0, m_block_reward); + } + + TEST_F(block_reward_and_last_block_sizes, handles_block_size_eq_2_medians) + { + do_test(2 * m_last_block_sizes_median); + ASSERT_FALSE(m_block_too_big); + ASSERT_EQ(0, m_block_reward); + } + + TEST_F(block_reward_and_last_block_sizes, handles_block_size_gt_2_medians) + { + do_test(2 * m_last_block_sizes_median + 1); + ASSERT_TRUE(m_block_too_big); + } + + TEST_F(block_reward_and_last_block_sizes, calculates_correctly) + { + ASSERT_EQ(0, m_last_block_sizes_median % 8); + + do_test(m_last_block_sizes_median * 9 / 8); + ASSERT_FALSE(m_block_too_big); + ASSERT_EQ(m_block_reward, m_standard_block_reward * 63 / 64); + + // 3/2 = 12/8 + do_test(m_last_block_sizes_median * 3 / 2); + ASSERT_FALSE(m_block_too_big); + ASSERT_EQ(m_block_reward, m_standard_block_reward * 3 / 4); + + do_test(m_last_block_sizes_median * 15 / 8); + ASSERT_FALSE(m_block_too_big); + ASSERT_EQ(m_block_reward, m_standard_block_reward * 15 / 64); + } +} diff --git a/tests/unit_tests/chacha8.cpp b/tests/unit_tests/chacha8.cpp new file mode 100644 index 000000000..e3eeae5cf --- /dev/null +++ b/tests/unit_tests/chacha8.cpp @@ -0,0 +1,84 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include <string> + +#include "gtest/gtest.h" + +#include "crypto/chacha8.h" + +namespace +{ + struct test_data { + const uint8_t* key; + const uint8_t* iv; + const size_t text_length; + const uint8_t* plain_text; + const uint8_t* cipher_text; + }; + + #define ARR(...) __VA_ARGS__ + + #define MAKE_TEST_DATA(index, key, iv, plain_text, cipher_text) \ + static const uint8_t test_key_##index[] = key; \ + static const uint8_t test_iv_##index[] = iv; \ + static const uint8_t test_plain_text_##index[] = plain_text; \ + static const uint8_t test_cipher_text_##index[] = cipher_text; \ + static const test_data test_##index = {test_key_##index, test_iv_##index, sizeof(test_plain_text_##index), test_plain_text_##index, test_cipher_text_##index}; + + MAKE_TEST_DATA( + 0, + ARR({0x00, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}), + ARR({0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}), + ARR({0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}), + ARR({0x65, 0x3f, 0x4a, 0x18, 0xe3, 0xd2, 0x7d, 0xaf, 0x51, 0xf8, 0x41, 0xa0, 0x0b, 0x6c, 0x1a, 0x2b, 0xd2, 0x48, 0x98, 0x52, 0xd4, 0xae, 0x07, 0x11, 0xe1, 0xa4, 0xa3, 0x2a, 0xd1, 0x66, 0xfa, 0x6f, 0x88, 0x1a, 0x28, 0x43, 0x23, 0x8c, 0x7e, 0x17, 0x78, 0x6b, 0xa5, 0x16, 0x2b, 0xc0, 0x19, 0xd5, 0x73, 0x84, 0x9c, 0x16, 0x76, 0x68, 0x51, 0x0a, 0xda, 0x2f, 0x62, 0xb4, 0xff, 0x31, 0xad, 0x04}) + ) + + MAKE_TEST_DATA( + 1, + ARR({0x0f, 0x62, 0xb5, 0x08, 0x5b, 0xae, 0x01, 0x54, 0xa7, 0xfa, 0x4d, 0xa0, 0xf3, 0x46, 0x99, 0xec, 0x3f, 0x92, 0xe5, 0x38, 0x8b, 0xde, 0x31, 0x84, 0xd7, 0x2a, 0x7d, 0xd0, 0x23, 0x76, 0xc9, 0x1c}), + ARR({0x28, 0x8f, 0xf6, 0x5d, 0xc4, 0x2b, 0x92, 0xf9}), + ARR({0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}), + ARR({0xdb, 0x16, 0x58, 0x14, 0xf6, 0x67, 0x33, 0xb7, 0xa8, 0xe3, 0x4d, 0x1f, 0xfc, 0x12, 0x34, 0x27, 0x12, 0x56, 0xd3, 0xbf, 0x8d, 0x8d, 0xa2, 0x16, 0x69, 0x22, 0xe5, 0x98, 0xac, 0xac, 0x70, 0xf4, 0x12, 0xb3, 0xfe, 0x35, 0xa9, 0x41, 0x90, 0xad, 0x0a, 0xe2, 0xe8, 0xec, 0x62, 0x13, 0x48, 0x19, 0xab, 0x61, 0xad, 0xdc, 0xcc, 0xfe, 0x99, 0xd8, 0x67, 0xca, 0x3d, 0x73, 0x18, 0x3f, 0xa3, 0xfd}) + ) + + MAKE_TEST_DATA( + 2, + ARR({0x0f, 0x62, 0xb5, 0x08, 0x5b, 0xae, 0x01, 0x54, 0xa7, 0xfa, 0x4d, 0xa0, 0xf3, 0x46, 0x99, 0xec, 0x3f, 0x92, 0xe5, 0x38, 0x8b, 0xde, 0x31, 0x84, 0xd7, 0x2a, 0x7d, 0xd0, 0x23, 0x76, 0xc9, 0x1c}), + ARR({0x28, 0x8f, 0xf6, 0x5d, 0xc4, 0x2b, 0x92, 0xf9}), + ARR({0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}), + ARR({0xdb, 0x16, 0x58, 0x14, 0xf6, 0x67, 0x33, 0xb7, 0xa8, 0xe3, 0x4d, 0x1f, 0xfc, 0x12, 0x34, 0x27, 0x12, 0x56, 0xd3, 0xbf, 0x8d, 0x8d, 0xa2, 0x16, 0x69, 0x22, 0xe5, 0x98, 0xac, 0xac, 0x70, 0xf4, 0x12, 0xb3, 0xfe, 0x35, 0xa9, 0x41, 0x90, 0xad, 0x0a, 0xe2, 0xe8, 0xec, 0x62, 0x13, 0x48, 0x19, 0xab, 0x61, 0xad, 0xdc, 0xcc, 0xfe, 0x99, 0xd8, 0x67, 0xca, 0x3d, 0x73, 0x18, 0x3f, 0xa3, 0xfd, 0x82, 0x87, 0x0F}) + ) + + MAKE_TEST_DATA( + 3, + ARR({0x0f, 0x62, 0xb5, 0x08, 0x5b, 0xae, 0x01, 0x54, 0xa7, 0xfa, 0x4d, 0xa0, 0xf3, 0x46, 0x99, 0xec, 0x3f, 0x92, 0xe5, 0x38, 0x8b, 0xde, 0x31, 0x84, 0xd7, 0x2a, 0x7d, 0xd0, 0x23, 0x76, 0xc9, 0x1c}), + ARR({0x28, 0x8f, 0xf6, 0x5d, 0xc4, 0x2b, 0x92, 0xf9}), + ARR({0x00}), + ARR({0xdb}) + ) + + void run_test(const test_data* test) + { + std::string buf; + buf.resize(test->text_length); + + crypto::chacha8(test->plain_text, test->text_length, test->key, test->iv, &buf[0]); + ASSERT_EQ(buf, std::string(reinterpret_cast<const char*>(test->cipher_text), test->text_length)); + + crypto::chacha8(test->cipher_text, test->text_length, test->key, test->iv, &buf[0]); + ASSERT_EQ(buf, std::string(reinterpret_cast<const char*>(test->plain_text), test->text_length)); + } +} + +#define TEST_CHACHA8(test_no) \ + TEST(chacha8, is_correct_##test_no) \ + { \ + run_test(&test_##test_no); \ + } + +TEST_CHACHA8(0) +TEST_CHACHA8(1) +TEST_CHACHA8(2) +TEST_CHACHA8(3) diff --git a/tests/unit_tests/decompose_amount_into_digits.cpp b/tests/unit_tests/decompose_amount_into_digits.cpp new file mode 100644 index 000000000..d7c66cc73 --- /dev/null +++ b/tests/unit_tests/decompose_amount_into_digits.cpp @@ -0,0 +1,119 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include "gtest/gtest.h" + +#include <cstdint> +#include <vector> + +#include "cryptonote_core/cryptonote_format_utils.h" + +#define VEC_FROM_ARR(vec) \ + std::vector<uint64_t> vec; \ + for (size_t i = 0; i < sizeof(vec##_arr) / sizeof(vec##_arr[0]); ++i) \ + { \ + vec.push_back(vec##_arr[i]); \ + } + +namespace +{ + struct chunk_handler_t + { + void operator()(uint64_t chunk) const + { + m_chunks.push_back(chunk); + } + + mutable std::vector<uint64_t> m_chunks; + }; + + struct dust_handler_t + { + dust_handler_t() + : m_dust(0) + , m_has_dust(false) + { + } + + void operator()(uint64_t dust) const + { + m_dust = dust; + m_has_dust = true; + } + + mutable uint64_t m_dust; + mutable bool m_has_dust; + }; + + class decompose_amount_into_digits_test : public ::testing::Test + { + protected: + chunk_handler_t m_chunk_handler; + dust_handler_t m_dust_handler; + }; +} + +TEST_F(decompose_amount_into_digits_test, is_correct_0) +{ + uint64_t expected_chunks_arr[] = {0}; + VEC_FROM_ARR(expected_chunks); + cryptonote::decompose_amount_into_digits(0, 0, m_chunk_handler, m_dust_handler); + ASSERT_EQ(m_chunk_handler.m_chunks, expected_chunks); + ASSERT_EQ(m_dust_handler.m_has_dust, false); +} + +TEST_F(decompose_amount_into_digits_test, is_correct_1) +{ + uint64_t expected_chunks_arr[] = {0}; + VEC_FROM_ARR(expected_chunks); + cryptonote::decompose_amount_into_digits(0, 10, m_chunk_handler, m_dust_handler); + ASSERT_EQ(m_chunk_handler.m_chunks, expected_chunks); + ASSERT_EQ(m_dust_handler.m_has_dust, false); +} + +TEST_F(decompose_amount_into_digits_test, is_correct_2) +{ + uint64_t expected_chunks_arr[] = {10}; + VEC_FROM_ARR(expected_chunks); + cryptonote::decompose_amount_into_digits(10, 0, m_chunk_handler, m_dust_handler); + ASSERT_EQ(m_chunk_handler.m_chunks, expected_chunks); + ASSERT_EQ(m_dust_handler.m_has_dust, false); +} + +TEST_F(decompose_amount_into_digits_test, is_correct_3) +{ + std::vector<uint64_t> expected_chunks; + uint64_t expected_dust = 10; + cryptonote::decompose_amount_into_digits(10, 10, m_chunk_handler, m_dust_handler); + ASSERT_EQ(m_chunk_handler.m_chunks, expected_chunks); + ASSERT_EQ(m_dust_handler.m_dust, expected_dust); +} + +TEST_F(decompose_amount_into_digits_test, is_correct_4) +{ + uint64_t expected_dust = 8100; + std::vector<uint64_t> expected_chunks; + cryptonote::decompose_amount_into_digits(8100, 1000000, m_chunk_handler, m_dust_handler); + ASSERT_EQ(m_chunk_handler.m_chunks, expected_chunks); + ASSERT_EQ(m_dust_handler.m_dust, expected_dust); +} + +TEST_F(decompose_amount_into_digits_test, is_correct_5) +{ + uint64_t expected_chunks_arr[] = {100, 900000, 8000000}; + VEC_FROM_ARR(expected_chunks); + cryptonote::decompose_amount_into_digits(8900100, 10, m_chunk_handler, m_dust_handler); + ASSERT_EQ(m_chunk_handler.m_chunks, expected_chunks); + ASSERT_EQ(m_dust_handler.m_has_dust, false); +} + +TEST_F(decompose_amount_into_digits_test, is_correct_6) +{ + uint64_t expected_chunks_arr[] = {900000, 8000000}; + VEC_FROM_ARR(expected_chunks); + uint64_t expected_dust = 100; + cryptonote::decompose_amount_into_digits(8900100, 1000, m_chunk_handler, m_dust_handler); + ASSERT_EQ(m_chunk_handler.m_chunks, expected_chunks); + ASSERT_EQ(m_dust_handler.m_dust, expected_dust); +} diff --git a/tests/unit_tests/epee_boosted_tcp_server.cpp b/tests/unit_tests/epee_boosted_tcp_server.cpp new file mode 100644 index 000000000..1e606163d --- /dev/null +++ b/tests/unit_tests/epee_boosted_tcp_server.cpp @@ -0,0 +1,109 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include <condition_variable> +#include <chrono> +#include <mutex> +#include <thread> + +#include "gtest/gtest.h" + +#include "include_base_utils.h" +#include "string_tools.h" +#include "net/abstract_tcp_server2.h" + +namespace +{ + const uint32_t test_server_port = 5626; + const std::string test_server_host("127.0.0.1"); + + struct test_connection_context : public epee::net_utils::connection_context_base + { + }; + + struct test_protocol_handler_config + { + }; + + struct test_protocol_handler + { + typedef test_connection_context connection_context; + typedef test_protocol_handler_config config_type; + + test_protocol_handler(epee::net_utils::i_service_endpoint* /*psnd_hndlr*/, config_type& /*config*/, connection_context& /*conn_context*/) + { + } + + void after_init_connection() + { + } + + void handle_qued_callback() + { + } + + bool release_protocol() + { + return true; + } + + bool handle_recv(const void* /*data*/, size_t /*size*/) + { + return false; + } + }; + + typedef epee::net_utils::boosted_tcp_server<test_protocol_handler> test_tcp_server; +} + +TEST(boosted_tcp_server, worker_threads_are_exception_resistant) +{ + test_tcp_server srv; + ASSERT_TRUE(srv.init_server(test_server_port, test_server_host)); + + std::mutex mtx; + std::condition_variable cond; + int counter = 0; + + auto counter_incrementer = [&counter, &cond, &mtx]() + { + std::unique_lock<std::mutex> lock(mtx); + ++counter; + if (4 <= counter) + { + cond.notify_one(); + } + }; + + // 2 theads, but 4 exceptions + ASSERT_TRUE(srv.run_server(2, false)); + ASSERT_TRUE(srv.async_call([&counter_incrementer]() { counter_incrementer(); throw std::runtime_error("test 1"); })); + ASSERT_TRUE(srv.async_call([&counter_incrementer]() { counter_incrementer(); throw std::string("test 2"); })); + ASSERT_TRUE(srv.async_call([&counter_incrementer]() { counter_incrementer(); throw "test 3"; })); + ASSERT_TRUE(srv.async_call([&counter_incrementer]() { counter_incrementer(); throw 4; })); + + { + std::unique_lock<std::mutex> lock(mtx); + ASSERT_NE(std::cv_status::timeout, cond.wait_for(lock, std::chrono::seconds(5))); + ASSERT_EQ(4, counter); + } + + // Check if threads are alive + counter = 0; + //auto counter_incrementer = [&counter]() { counter.fetch_add(1); epee::misc_utils::sleep_no_w(counter.load() * 10); }; + ASSERT_TRUE(srv.async_call(counter_incrementer)); + ASSERT_TRUE(srv.async_call(counter_incrementer)); + ASSERT_TRUE(srv.async_call(counter_incrementer)); + ASSERT_TRUE(srv.async_call(counter_incrementer)); + + { + std::unique_lock<std::mutex> lock(mtx); + ASSERT_NE(std::cv_status::timeout, cond.wait_for(lock, std::chrono::seconds(5))); + ASSERT_EQ(4, counter); + } + + srv.send_stop_signal(); + ASSERT_TRUE(srv.timed_wait_server_stop(5 * 1000)); + ASSERT_TRUE(srv.deinit_server()); +} diff --git a/tests/unit_tests/epee_levin_protocol_handler_async.cpp b/tests/unit_tests/epee_levin_protocol_handler_async.cpp new file mode 100644 index 000000000..da22d9d2d --- /dev/null +++ b/tests/unit_tests/epee_levin_protocol_handler_async.cpp @@ -0,0 +1,506 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include <mutex> +#include <thread> + +#include "gtest/gtest.h" + +#include "include_base_utils.h" +#include "string_tools.h" +#include "net/levin_protocol_handler_async.h" +#include "net/net_utils_base.h" +#include "unit_tests_utils.h" + +namespace +{ + struct test_levin_connection_context : public epee::net_utils::connection_context_base + { + }; + + typedef epee::levin::async_protocol_handler_config<test_levin_connection_context> test_levin_protocol_handler_config; + typedef epee::levin::async_protocol_handler<test_levin_connection_context> test_levin_protocol_handler; + + struct test_levin_commands_handler : public epee::levin::levin_commands_handler<test_levin_connection_context> + { + test_levin_commands_handler() + : m_return_code(LEVIN_OK) + , m_last_command(-1) + { + } + + virtual int invoke(int command, const std::string& in_buff, std::string& buff_out, test_levin_connection_context& context) + { + m_invoke_counter.inc(); + std::unique_lock<std::mutex> lock(m_mutex); + m_last_command = command; + m_last_in_buf = in_buff; + buff_out = m_invoke_out_buf; + return m_return_code; + } + + virtual int notify(int command, const std::string& in_buff, test_levin_connection_context& context) + { + m_notify_counter.inc(); + std::unique_lock<std::mutex> lock(m_mutex); + m_last_command = command; + m_last_in_buf = in_buff; + return m_return_code; + } + + virtual void callback(test_levin_connection_context& context) + { + m_callback_counter.inc(); + //std::cout << "test_levin_commands_handler::callback()" << std::endl; + } + + virtual void on_connection_new(test_levin_connection_context& context) + { + m_new_connection_counter.inc(); + //std::cout << "test_levin_commands_handler::on_connection_new()" << std::endl; + } + + virtual void on_connection_close(test_levin_connection_context& context) + { + m_close_connection_counter.inc(); + //std::cout << "test_levin_commands_handler::on_connection_close()" << std::endl; + } + + size_t invoke_counter() const { return m_invoke_counter.get(); } + size_t notify_counter() const { return m_notify_counter.get(); } + size_t callback_counter() const { return m_callback_counter.get(); } + size_t new_connection_counter() const { return m_new_connection_counter.get(); } + size_t close_connection_counter() const { return m_close_connection_counter.get(); } + + int return_code() const { return m_return_code; } + void return_code(int v) { m_return_code = v; } + + const std::string& invoke_out_buf() const { return m_invoke_out_buf; } + void invoke_out_buf(const std::string& v) { m_invoke_out_buf = v; } + + int last_command() const { return m_last_command; } + const std::string& last_in_buf() const { return m_last_in_buf; } + + private: + unit_test::call_counter m_invoke_counter; + unit_test::call_counter m_notify_counter; + unit_test::call_counter m_callback_counter; + unit_test::call_counter m_new_connection_counter; + unit_test::call_counter m_close_connection_counter; + + std::mutex m_mutex; + + int m_return_code; + std::string m_invoke_out_buf; + + int m_last_command; + std::string m_last_in_buf; + }; + + class test_connection : public epee::net_utils::i_service_endpoint + { + public: + test_connection(boost::asio::io_service& io_service, test_levin_protocol_handler_config& protocol_config) + : m_io_service(io_service) + , m_protocol_handler(this, protocol_config, m_context) + , m_send_return(true) + { + } + + void start() + { + ASSERT_TRUE(m_protocol_handler.after_init_connection()); + } + + // Implement epee::net_utils::i_service_endpoint interface + virtual bool do_send(const void* ptr, size_t cb) + { + //std::cout << "test_connection::do_send()" << std::endl; + m_send_counter.inc(); + std::unique_lock<std::mutex> lock(m_mutex); + m_last_send_data.append(reinterpret_cast<const char*>(ptr), cb); + return m_send_return; + } + + virtual bool close() { /*std::cout << "test_connection::close()" << std::endl; */return true; } + virtual bool call_run_once_service_io() { std::cout << "test_connection::call_run_once_service_io()" << std::endl; return true; } + virtual bool request_callback() { std::cout << "test_connection::request_callback()" << std::endl; return true; } + virtual boost::asio::io_service& get_io_service() { std::cout << "test_connection::get_io_service()" << std::endl; return m_io_service; } + virtual bool add_ref() { std::cout << "test_connection::add_ref()" << std::endl; return true; } + virtual bool release() { std::cout << "test_connection::release()" << std::endl; return true; } + + size_t send_counter() const { return m_send_counter.get(); } + + const std::string& last_send_data() const { return m_last_send_data; } + void reset_last_send_data() { std::unique_lock<std::mutex> lock(m_mutex); m_last_send_data.clear(); } + + bool send_return() const { return m_send_return; } + void send_return(bool v) { m_send_return = v; } + + public: + test_levin_protocol_handler m_protocol_handler; + + private: + boost::asio::io_service& m_io_service; + test_levin_connection_context m_context; + + unit_test::call_counter m_send_counter; + std::mutex m_mutex; + + std::string m_last_send_data; + + bool m_send_return; + }; + + class async_protocol_handler_test : public ::testing::Test + { + public: + const static uint64_t invoke_timeout = 5 * 1000; + const static size_t max_packet_size = 10 * 1024 * 1024; + + typedef std::unique_ptr<test_connection> test_connection_ptr; + + async_protocol_handler_test() + { + m_handler_config.m_pcommands_handler = &m_commands_handler; + m_handler_config.m_invoke_timeout = invoke_timeout; + m_handler_config.m_max_packet_size = max_packet_size; + } + + virtual void SetUp() + { + } + + protected: + test_connection_ptr create_connection(bool start = true) + { + test_connection_ptr conn(new test_connection(m_io_service, m_handler_config)); + if (start) + { + conn->start(); + } + return conn; + } + + protected: + boost::asio::io_service m_io_service; + test_levin_protocol_handler_config m_handler_config; + test_levin_commands_handler m_commands_handler; + }; + + class positive_test_connection_to_levin_protocol_handler_calls : public async_protocol_handler_test + { + }; + + class test_levin_protocol_handler__hanle_recv_with_invalid_data : public async_protocol_handler_test + { + public: + static const int expected_command = 5615871; + static const int expected_return_code = 782546; + + test_levin_protocol_handler__hanle_recv_with_invalid_data() + : m_expected_invoke_out_buf(512, 'y') + { + } + + virtual void SetUp() + { + async_protocol_handler_test::SetUp(); + + m_conn = create_connection(); + + m_in_data.assign(256, 't'); + + m_req_head.m_signature = LEVIN_SIGNATURE; + m_req_head.m_cb = m_in_data.size(); + m_req_head.m_have_to_return_data = true; + m_req_head.m_command = expected_command; + m_req_head.m_flags = LEVIN_PACKET_REQUEST; + m_req_head.m_protocol_version = LEVIN_PROTOCOL_VER_1; + + m_commands_handler.return_code(expected_return_code); + m_commands_handler.invoke_out_buf(m_expected_invoke_out_buf); + } + + protected: + void prepare_buf() + { + m_buf.assign(reinterpret_cast<const char*>(&m_req_head), sizeof(m_req_head)); + m_buf += m_in_data; + } + + protected: + test_connection_ptr m_conn; + epee::levin::bucket_head2 m_req_head; + std::string m_in_data; + std::string m_buf; + std::string m_expected_invoke_out_buf; + }; +} + +TEST_F(positive_test_connection_to_levin_protocol_handler_calls, new_handler_is_not_initialized) +{ + test_connection_ptr conn = create_connection(false); + ASSERT_FALSE(conn->m_protocol_handler.m_connection_initialized); + ASSERT_EQ(0, m_handler_config.get_connections_count()); + ASSERT_EQ(0, m_commands_handler.new_connection_counter()); + conn.reset(); + ASSERT_EQ(0, m_handler_config.get_connections_count()); + ASSERT_EQ(0, m_commands_handler.close_connection_counter()); +} + +TEST_F(positive_test_connection_to_levin_protocol_handler_calls, handler_initialization_and_destruction_is_correct) +{ + test_connection_ptr conn = create_connection(); + ASSERT_TRUE(conn->m_protocol_handler.m_connection_initialized); + ASSERT_EQ(1, m_handler_config.get_connections_count()); + ASSERT_EQ(1, m_commands_handler.new_connection_counter()); + conn.reset(); + ASSERT_EQ(0, m_handler_config.get_connections_count()); + ASSERT_EQ(1, m_commands_handler.close_connection_counter()); +} + +TEST_F(positive_test_connection_to_levin_protocol_handler_calls, concurent_handler_initialization_and_destruction_is_correct) +{ + const size_t connection_count = 10000; + auto create_and_destroy_connections = [this, connection_count]() + { + std::vector<test_connection_ptr> connections(connection_count); + for (size_t i = 0; i < connection_count; ++i) + { + connections[i] = create_connection(); + } + + for (size_t i = 0; i < connection_count; ++i) + { + connections[i].reset(); + } + }; + + const size_t thread_count = std::thread::hardware_concurrency(); + std::vector<std::thread> threads(thread_count); + for (std::thread& th : threads) + { + th = std::thread(create_and_destroy_connections); + } + + for (std::thread& th : threads) + { + th.join(); + } + + ASSERT_EQ(0, m_handler_config.get_connections_count()); + ASSERT_EQ(connection_count * thread_count, m_commands_handler.new_connection_counter()); + ASSERT_EQ(connection_count * thread_count, m_commands_handler.close_connection_counter()); +} + +TEST_F(positive_test_connection_to_levin_protocol_handler_calls, handler_processes_handle_read_as_invoke) +{ + // Setup + const int expected_command = 2634981; + const int expected_return_code = 6732; + const std::string expected_out_data(128, 'w'); + + test_connection_ptr conn = create_connection(); + + std::string in_data(256, 'q'); + + epee::levin::bucket_head2 req_head; + req_head.m_signature = LEVIN_SIGNATURE; + req_head.m_cb = in_data.size(); + req_head.m_have_to_return_data = true; + req_head.m_command = expected_command; + req_head.m_flags = LEVIN_PACKET_REQUEST; + req_head.m_protocol_version = LEVIN_PROTOCOL_VER_1; + + std::string buf(reinterpret_cast<const char*>(&req_head), sizeof(req_head)); + buf += in_data; + + m_commands_handler.invoke_out_buf(expected_out_data); + m_commands_handler.return_code(expected_return_code); + + // Test + ASSERT_TRUE(conn->m_protocol_handler.handle_recv(buf.data(), buf.size())); + + // + // Check + // + + // Check connection and levin_commands_handler states + ASSERT_EQ(1, m_commands_handler.invoke_counter()); + ASSERT_EQ(0, m_commands_handler.notify_counter()); + ASSERT_EQ(expected_command, m_commands_handler.last_command()); + ASSERT_EQ(in_data, m_commands_handler.last_in_buf()); + ASSERT_LE(1, conn->send_counter()); + + // Parse send data + std::string send_data = conn->last_send_data(); + epee::levin::bucket_head2 resp_head; + resp_head = *reinterpret_cast<const epee::levin::bucket_head2*>(send_data.data()); + ASSERT_LT(sizeof(resp_head), send_data.size()); + std::string out_data = send_data.substr(sizeof(resp_head)); + + // Check sent response + ASSERT_EQ(expected_out_data, out_data); + ASSERT_EQ(LEVIN_SIGNATURE, resp_head.m_signature); + ASSERT_EQ(expected_command, resp_head.m_command); + ASSERT_EQ(expected_return_code, resp_head.m_return_code); + ASSERT_EQ(expected_out_data.size(), resp_head.m_cb); + ASSERT_FALSE(resp_head.m_have_to_return_data); + ASSERT_EQ(LEVIN_PROTOCOL_VER_1, resp_head.m_protocol_version); + ASSERT_TRUE(0 != (resp_head.m_flags | LEVIN_PACKET_RESPONSE)); +} + +TEST_F(positive_test_connection_to_levin_protocol_handler_calls, handler_processes_handle_read_as_notify) +{ + // Setup + const int expected_command = 4673261; + + test_connection_ptr conn = create_connection(); + + std::string in_data(256, 'e'); + + epee::levin::bucket_head2 req_head; + req_head.m_signature = LEVIN_SIGNATURE; + req_head.m_cb = in_data.size(); + req_head.m_have_to_return_data = false; + req_head.m_command = expected_command; + req_head.m_flags = LEVIN_PACKET_REQUEST; + req_head.m_protocol_version = LEVIN_PROTOCOL_VER_1; + + std::string buf(reinterpret_cast<const char*>(&req_head), sizeof(req_head)); + buf += in_data; + + // Test + ASSERT_TRUE(conn->m_protocol_handler.handle_recv(buf.data(), buf.size())); + + // Check connection and levin_commands_handler states + ASSERT_EQ(1, m_commands_handler.notify_counter()); + ASSERT_EQ(0, m_commands_handler.invoke_counter()); + ASSERT_EQ(expected_command, m_commands_handler.last_command()); + ASSERT_EQ(in_data, m_commands_handler.last_in_buf()); + ASSERT_LE(0, conn->send_counter()); + ASSERT_TRUE(conn->last_send_data().empty()); +} + +TEST_F(positive_test_connection_to_levin_protocol_handler_calls, handler_processes_qued_callback) +{ + test_connection_ptr conn = create_connection(); + + conn->m_protocol_handler.handle_qued_callback(); + conn->m_protocol_handler.handle_qued_callback(); + conn->m_protocol_handler.handle_qued_callback(); + + ASSERT_EQ(3, m_commands_handler.callback_counter()); +} + +TEST_F(test_levin_protocol_handler__hanle_recv_with_invalid_data, handles_big_packet_1) +{ + std::string buf("yyyyyy"); + ASSERT_FALSE(m_conn->m_protocol_handler.handle_recv(buf.data(), max_packet_size + 1)); +} + +TEST_F(test_levin_protocol_handler__hanle_recv_with_invalid_data, handles_big_packet_2) +{ + prepare_buf(); + const size_t first_packet_size = sizeof(m_req_head) - 1; + + m_buf.resize(first_packet_size); + ASSERT_TRUE(m_conn->m_protocol_handler.handle_recv(m_buf.data(), m_buf.size())); + + ASSERT_FALSE(m_conn->m_protocol_handler.handle_recv(m_buf.data(), max_packet_size - m_buf.size() + 1)); +} + +TEST_F(test_levin_protocol_handler__hanle_recv_with_invalid_data, handles_invalid_signature_for_full_header) +{ + m_req_head.m_signature = LEVIN_SIGNATURE ^ 1; + prepare_buf(); + + ASSERT_FALSE(m_conn->m_protocol_handler.handle_recv(m_buf.data(), m_buf.size())); +} + +TEST_F(test_levin_protocol_handler__hanle_recv_with_invalid_data, handles_invalid_signature_for_partial_header) +{ + m_req_head.m_signature = LEVIN_SIGNATURE ^ 1; + prepare_buf(); + m_buf.resize(sizeof(m_req_head.m_signature)); + + ASSERT_FALSE(m_conn->m_protocol_handler.handle_recv(m_buf.data(), m_buf.size())); +} + +TEST_F(test_levin_protocol_handler__hanle_recv_with_invalid_data, handles_big_cb) +{ + m_req_head.m_cb = max_packet_size + 1; + prepare_buf(); + + ASSERT_FALSE(m_conn->m_protocol_handler.handle_recv(m_buf.data(), m_buf.size())); +} + +TEST_F(test_levin_protocol_handler__hanle_recv_with_invalid_data, does_not_handle_data_after_close) +{ + prepare_buf(); + + ASSERT_TRUE(m_conn->m_protocol_handler.close()); + ASSERT_FALSE(m_conn->m_protocol_handler.handle_recv(m_buf.data(), m_buf.size())); +} + +TEST_F(test_levin_protocol_handler__hanle_recv_with_invalid_data, handles_network_error) +{ + prepare_buf(); + + m_conn->send_return(false); + ASSERT_FALSE(m_conn->m_protocol_handler.handle_recv(m_buf.data(), m_buf.size())); +} + +TEST_F(test_levin_protocol_handler__hanle_recv_with_invalid_data, handles_chunked_header) +{ + prepare_buf(); + + size_t buf1_size = sizeof(m_req_head) / 2; + + std::string buf1 = m_buf.substr(0, buf1_size); + std::string buf2 = m_buf.substr(buf1_size); + ASSERT_EQ(m_buf, buf1 + buf2); + + ASSERT_TRUE(m_conn->m_protocol_handler.handle_recv(buf1.data(), buf1.size())); + ASSERT_EQ(0, m_commands_handler.invoke_counter()); + + ASSERT_TRUE(m_conn->m_protocol_handler.handle_recv(buf2.data(), buf2.size())); + ASSERT_EQ(1, m_commands_handler.invoke_counter()); +} + + +TEST_F(test_levin_protocol_handler__hanle_recv_with_invalid_data, handles_chunked_body) +{ + prepare_buf(); + + size_t buf1_size = sizeof(m_req_head) + (m_buf.size() - sizeof(m_req_head)) / 2; + + std::string buf1 = m_buf.substr(0, buf1_size); + std::string buf2 = m_buf.substr(buf1_size); + ASSERT_EQ(m_buf, buf1 + buf2); + + ASSERT_TRUE(m_conn->m_protocol_handler.handle_recv(buf1.data(), buf1.size())); + ASSERT_EQ(0, m_commands_handler.invoke_counter()); + + ASSERT_TRUE(m_conn->m_protocol_handler.handle_recv(buf2.data(), buf2.size())); + ASSERT_EQ(1, m_commands_handler.invoke_counter()); +} + +TEST_F(test_levin_protocol_handler__hanle_recv_with_invalid_data, handles_two_requests_at_once) +{ + prepare_buf(); + m_buf.append(m_buf); + + ASSERT_TRUE(m_conn->m_protocol_handler.handle_recv(m_buf.data(), m_buf.size())); + ASSERT_EQ(2, m_commands_handler.invoke_counter()); +} + +TEST_F(test_levin_protocol_handler__hanle_recv_with_invalid_data, handles_unexpected_response) +{ + m_req_head.m_flags = LEVIN_PACKET_RESPONSE; + prepare_buf(); + + ASSERT_FALSE(m_conn->m_protocol_handler.handle_recv(m_buf.data(), m_buf.size())); +} diff --git a/tests/unit_tests/main.cpp b/tests/unit_tests/main.cpp new file mode 100644 index 000000000..65bf247d8 --- /dev/null +++ b/tests/unit_tests/main.cpp @@ -0,0 +1,15 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include "gtest/gtest.h" + +#include "include_base_utils.h" + +int main(int argc, char** argv) +{ + epee::debug::get_set_enable_assert(true, false); + + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} diff --git a/tests/unit_tests/mul_div.cpp b/tests/unit_tests/mul_div.cpp new file mode 100644 index 000000000..291e4f191 --- /dev/null +++ b/tests/unit_tests/mul_div.cpp @@ -0,0 +1,179 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include "gtest/gtest.h" + +#include "common/int-util.h" + +namespace +{ + TEST(mul128, handles_zero) + { + uint64_t hi, lo; + + lo = mul128(0, 0, &hi); + ASSERT_EQ(lo, 0); + ASSERT_EQ(hi, 0); + + lo = mul128(7, 0, &hi); + ASSERT_EQ(lo, 0); + ASSERT_EQ(hi, 0); + + lo = mul128(0, 7, &hi); + ASSERT_EQ(lo, 0); + ASSERT_EQ(hi, 0); + } + + TEST(mul128, handles_one) + { + uint64_t hi, lo; + + lo = mul128(1, 1, &hi); + ASSERT_EQ(lo, 1); + ASSERT_EQ(hi, 0); + + lo = mul128(7, 1, &hi); + ASSERT_EQ(lo, 7); + ASSERT_EQ(hi, 0); + + lo = mul128(1, 7, &hi); + ASSERT_EQ(lo, 7); + ASSERT_EQ(hi, 0); + } + + TEST(mul128_without_carry, multiplies_correctly) + { + uint64_t hi, lo; + + lo = mul128(0x3333333333333333, 5, &hi); + ASSERT_EQ(lo, 0xffffffffffffffff); + ASSERT_EQ(hi, 0); + + lo = mul128(5, 0x3333333333333333, &hi); + ASSERT_EQ(lo, 0xffffffffffffffff); + ASSERT_EQ(hi, 0); + + lo = mul128(0x1111111111111111, 0x1111111111111111, &hi); + ASSERT_EQ(lo, 0x0fedcba987654321); + ASSERT_EQ(hi, 0x0123456789abcdf0);; + } + + TEST(mul128_with_carry_1_only, multiplies_correctly) + { + uint64_t hi, lo; + + lo = mul128(0xe0000000e0000000, 0xe0000000e0000000, &hi); + ASSERT_EQ(lo, 0xc400000000000000); + ASSERT_EQ(hi, 0xc400000188000000); + } + + TEST(mul128_with_carry_2_only, multiplies_correctly) + { + uint64_t hi, lo; + + lo = mul128(0x10000000ffffffff, 0x10000000ffffffff, &hi); + ASSERT_EQ(lo, 0xdffffffe00000001); + ASSERT_EQ(hi, 0x0100000020000000); + } + + TEST(mul128_with_carry_1_and_2, multiplies_correctly) + { + uint64_t hi, lo; + + lo = mul128(0xf1f2f3f4f5f6f7f8, 0xf9f0fafbfcfdfeff, &hi); + ASSERT_EQ(lo, 0x52118e5f3b211008); + ASSERT_EQ(hi, 0xec39104363716e59); + + lo = mul128(0xffffffffffffffff, 0xffffffffffffffff, &hi); + ASSERT_EQ(lo, 0x0000000000000001); + ASSERT_EQ(hi, 0xfffffffffffffffe); + } + + TEST(div128_32, handles_zero) + { + uint32_t reminder; + uint64_t hi; + uint64_t lo; + + reminder = div128_32(0, 0, 7, &hi, &lo); + ASSERT_EQ(reminder, 0); + ASSERT_EQ(hi, 0); + ASSERT_EQ(lo, 0); + + // Division by zero is UB, so can be tested correctly + } + + TEST(div128_32, handles_one) + { + uint32_t reminder; + uint64_t hi; + uint64_t lo; + + reminder = div128_32(0, 7, 1, &hi, &lo); + ASSERT_EQ(reminder, 0); + ASSERT_EQ(hi, 0); + ASSERT_EQ(lo, 7); + + reminder = div128_32(7, 0, 1, &hi, &lo); + ASSERT_EQ(reminder, 0); + ASSERT_EQ(hi, 7); + ASSERT_EQ(lo, 0); + } + + TEST(div128_32, handles_if_dividend_less_divider) + { + uint32_t reminder; + uint64_t hi; + uint64_t lo; + + reminder = div128_32(0, 1383746, 1645825, &hi, &lo); + ASSERT_EQ(reminder, 1383746); + ASSERT_EQ(hi, 0); + ASSERT_EQ(lo, 0); + } + + TEST(div128_32, handles_if_dividend_dwords_less_divider) + { + uint32_t reminder; + uint64_t hi; + uint64_t lo; + + reminder = div128_32(0x5AD629E441074F28, 0x0DBCAB2B231081F1, 0xFE735CD6, &hi, &lo); + ASSERT_EQ(reminder, 0xB9C924E9); + ASSERT_EQ(hi, 0x000000005B63C274); + ASSERT_EQ(lo, 0x9084FC024383E48C); + } + + TEST(div128_32, works_correctly) + { + uint32_t reminder; + uint64_t hi; + uint64_t lo; + + reminder = div128_32(2, 0, 2, &hi, &lo); + ASSERT_EQ(reminder, 0); + ASSERT_EQ(hi, 1); + ASSERT_EQ(lo, 0); + + reminder = div128_32(0xffffffffffffffff, 0, 0xffffffff, &hi, &lo); + ASSERT_EQ(reminder, 0); + ASSERT_EQ(hi, 0x0000000100000001); + ASSERT_EQ(lo, 0); + + reminder = div128_32(0xffffffffffffffff, 5846, 0xffffffff, &hi, &lo); + ASSERT_EQ(reminder, 5846); + ASSERT_EQ(hi, 0x0000000100000001); + ASSERT_EQ(lo, 0); + + reminder = div128_32(0xffffffffffffffff - 1, 0, 0xffffffff, &hi, &lo); + ASSERT_EQ(reminder, 0xfffffffe); + ASSERT_EQ(hi, 0x0000000100000000); + ASSERT_EQ(lo, 0xfffffffefffffffe); + + reminder = div128_32(0x2649372534875028, 0xaedbfedc5adbc739, 0x27826534, &hi, &lo); + ASSERT_EQ(reminder, 0x1a6dc2e5); + ASSERT_EQ(hi, 0x00000000f812c1f8); + ASSERT_EQ(lo, 0xddf2fdb09bc2e2e9); + } +} diff --git a/tests/unit_tests/serialization.cpp b/tests/unit_tests/serialization.cpp new file mode 100644 index 000000000..616509d82 --- /dev/null +++ b/tests/unit_tests/serialization.cpp @@ -0,0 +1,418 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include <cstring> +#include <cstdint> +#include <cstdio> +#include <iostream> +#include <vector> +#include <boost/foreach.hpp> +#include "cryptonote_core/cryptonote_basic.h" +#include "cryptonote_core/cryptonote_basic_impl.h" +#include "serialization/serialization.h" +#include "serialization/binary_archive.h" +#include "serialization/json_archive.h" +#include "serialization/debug_archive.h" +#include "serialization/variant.h" +#include "serialization/vector.h" +#include "serialization/binary_utils.h" +#include "gtest/gtest.h" +using namespace std; + +struct Struct +{ + int32_t a; + int32_t b; + char blob[8]; +}; + +template <class Archive> +struct serializer<Archive, Struct> +{ + static bool serialize(Archive &ar, Struct &s) { + ar.begin_object(); + ar.tag("a"); + ar.serialize_int(s.a); + ar.tag("b"); + ar.serialize_int(s.b); + ar.tag("blob"); + ar.serialize_blob(s.blob, sizeof(s.blob)); + ar.end_object(); + return true; + } +}; + +struct Struct1 +{ + vector<boost::variant<Struct, int32_t>> si; + vector<int16_t> vi; + + BEGIN_SERIALIZE_OBJECT() + FIELD(si) + FIELD(vi) + END_SERIALIZE() + /*template <bool W, template <bool> class Archive> + bool do_serialize(Archive<W> &ar) + { + ar.begin_object(); + ar.tag("si"); + ::do_serialize(ar, si); + ar.tag("vi"); + ::do_serialize(ar, vi); + ar.end_object(); + }*/ +}; + +struct Blob +{ + uint64_t a; + uint32_t b; + + bool operator==(const Blob& rhs) const + { + return a == rhs.a; + } +}; + +VARIANT_TAG(binary_archive, Struct, 0xe0); +VARIANT_TAG(binary_archive, int, 0xe1); +VARIANT_TAG(json_archive, Struct, "struct"); +VARIANT_TAG(json_archive, int, "int"); +VARIANT_TAG(debug_archive, Struct1, "struct1"); +VARIANT_TAG(debug_archive, Struct, "struct"); +VARIANT_TAG(debug_archive, int, "int"); + +BLOB_SERIALIZER(Blob); + +bool try_parse(const string &blob) +{ + Struct1 s1; + return serialization::parse_binary(blob, s1); +} + +TEST(Serialization, BinaryArchiveInts) { + uint64_t x = 0xff00000000, x1; + + ostringstream oss; + binary_archive<true> oar(oss); + oar.serialize_int(x); + ASSERT_TRUE(oss.good()); + ASSERT_EQ(8, oss.str().size()); + ASSERT_EQ(string("\0\0\0\0\xff\0\0\0", 8), oss.str()); + + istringstream iss(oss.str()); + binary_archive<false> iar(iss); + iar.serialize_int(x1); + ASSERT_EQ(8, iss.tellg()); + ASSERT_TRUE(iss.good()); + + ASSERT_EQ(x, x1); +} + +TEST(Serialization, BinaryArchiveVarInts) { + uint64_t x = 0xff00000000, x1; + + ostringstream oss; + binary_archive<true> oar(oss); + oar.serialize_varint(x); + ASSERT_TRUE(oss.good()); + ASSERT_EQ(6, oss.str().size()); + ASSERT_EQ(string("\x80\x80\x80\x80\xF0\x1F", 6), oss.str()); + + istringstream iss(oss.str()); + binary_archive<false> iar(iss); + iar.serialize_varint(x1); + ASSERT_TRUE(iss.good()); + ASSERT_EQ(x, x1); +} + +TEST(Serialization, Test1) { + ostringstream str; + binary_archive<true> ar(str); + + Struct1 s1; + s1.si.push_back(0); + { + Struct s; + s.a = 5; + s.b = 65539; + std::memcpy(s.blob, "12345678", 8); + s1.si.push_back(s); + } + s1.si.push_back(1); + s1.vi.push_back(10); + s1.vi.push_back(22); + + string blob; + ASSERT_TRUE(serialization::dump_binary(s1, blob)); + ASSERT_TRUE(try_parse(blob)); + + ASSERT_EQ('\xE0', blob[6]); + blob[6] = '\xE1'; + ASSERT_FALSE(try_parse(blob)); + blob[6] = '\xE2'; + ASSERT_FALSE(try_parse(blob)); +} + +TEST(Serialization, Overflow) { + Blob x = { 0xff00000000 }; + Blob x1; + + string blob; + ASSERT_TRUE(serialization::dump_binary(x, blob)); + ASSERT_EQ(sizeof(Blob), blob.size()); + + ASSERT_TRUE(serialization::parse_binary(blob, x1)); + ASSERT_EQ(x, x1); + + vector<Blob> bigvector; + ASSERT_FALSE(serialization::parse_binary(blob, bigvector)); + ASSERT_EQ(0, bigvector.size()); +} + +TEST(Serialization, serializes_vector_uint64_as_varint) +{ + std::vector<uint64_t> v; + string blob; + + ASSERT_TRUE(serialization::dump_binary(v, blob)); + ASSERT_EQ(1, blob.size()); + + // +1 byte + v.push_back(0); + ASSERT_TRUE(serialization::dump_binary(v, blob)); + ASSERT_EQ(2, blob.size()); + + // +1 byte + v.push_back(1); + ASSERT_TRUE(serialization::dump_binary(v, blob)); + ASSERT_EQ(3, blob.size()); + + // +2 bytes + v.push_back(0x80); + ASSERT_TRUE(serialization::dump_binary(v, blob)); + ASSERT_EQ(5, blob.size()); + + // +2 bytes + v.push_back(0xFF); + ASSERT_TRUE(serialization::dump_binary(v, blob)); + ASSERT_EQ(7, blob.size()); + + // +2 bytes + v.push_back(0x3FFF); + ASSERT_TRUE(serialization::dump_binary(v, blob)); + ASSERT_EQ(9, blob.size()); + + // +3 bytes + v.push_back(0x40FF); + ASSERT_TRUE(serialization::dump_binary(v, blob)); + ASSERT_EQ(12, blob.size()); + + // +10 bytes + v.push_back(0xFFFFFFFFFFFFFFFF); + ASSERT_TRUE(serialization::dump_binary(v, blob)); + ASSERT_EQ(22, blob.size()); +} + +TEST(Serialization, serializes_vector_int64_as_fixed_int) +{ + std::vector<int64_t> v; + string blob; + + ASSERT_TRUE(serialization::dump_binary(v, blob)); + ASSERT_EQ(1, blob.size()); + + // +8 bytes + v.push_back(0); + ASSERT_TRUE(serialization::dump_binary(v, blob)); + ASSERT_EQ(9, blob.size()); + + // +8 bytes + v.push_back(1); + ASSERT_TRUE(serialization::dump_binary(v, blob)); + ASSERT_EQ(17, blob.size()); + + // +8 bytes + v.push_back(0x80); + ASSERT_TRUE(serialization::dump_binary(v, blob)); + ASSERT_EQ(25, blob.size()); + + // +8 bytes + v.push_back(0xFF); + ASSERT_TRUE(serialization::dump_binary(v, blob)); + ASSERT_EQ(33, blob.size()); + + // +8 bytes + v.push_back(0x3FFF); + ASSERT_TRUE(serialization::dump_binary(v, blob)); + ASSERT_EQ(41, blob.size()); + + // +8 bytes + v.push_back(0x40FF); + ASSERT_TRUE(serialization::dump_binary(v, blob)); + ASSERT_EQ(49, blob.size()); + + // +8 bytes + v.push_back(0xFFFFFFFFFFFFFFFF); + ASSERT_TRUE(serialization::dump_binary(v, blob)); + ASSERT_EQ(57, blob.size()); +} + +namespace +{ + template<typename T> + std::vector<T> linearize_vector2(const std::vector< std::vector<T> >& vec_vec) + { + std::vector<T> res; + BOOST_FOREACH(const auto& vec, vec_vec) + { + res.insert(res.end(), vec.begin(), vec.end()); + } + return res; + } +} + +TEST(Serialization, serializes_transacion_signatures_correctly) +{ + using namespace cryptonote; + + transaction tx; + transaction tx1; + string blob; + + // Empty tx + tx.set_null(); + ASSERT_TRUE(serialization::dump_binary(tx, blob)); + ASSERT_EQ(5, blob.size()); // 5 bytes + 0 bytes extra + 0 bytes signatures + ASSERT_TRUE(serialization::parse_binary(blob, tx1)); + ASSERT_EQ(tx, tx1); + ASSERT_EQ(linearize_vector2(tx.signatures), linearize_vector2(tx1.signatures)); + + // Miner tx without signatures + txin_gen txin_gen1; + txin_gen1.height = 0; + tx.set_null(); + tx.vin.push_back(txin_gen1); + ASSERT_TRUE(serialization::dump_binary(tx, blob)); + ASSERT_EQ(7, blob.size()); // 5 bytes + 2 bytes vin[0] + 0 bytes extra + 0 bytes signatures + ASSERT_TRUE(serialization::parse_binary(blob, tx1)); + ASSERT_EQ(tx, tx1); + ASSERT_EQ(linearize_vector2(tx.signatures), linearize_vector2(tx1.signatures)); + + // Miner tx with empty signatures 2nd vector + tx.signatures.resize(1); + ASSERT_TRUE(serialization::dump_binary(tx, blob)); + ASSERT_EQ(7, blob.size()); // 5 bytes + 2 bytes vin[0] + 0 bytes extra + 0 bytes signatures + ASSERT_TRUE(serialization::parse_binary(blob, tx1)); + ASSERT_EQ(tx, tx1); + ASSERT_EQ(linearize_vector2(tx.signatures), linearize_vector2(tx1.signatures)); + + // Miner tx with one signature + tx.signatures[0].resize(1); + ASSERT_FALSE(serialization::dump_binary(tx, blob)); + + // Miner tx with 2 empty vectors + tx.signatures.resize(2); + tx.signatures[0].resize(0); + tx.signatures[1].resize(0); + ASSERT_FALSE(serialization::dump_binary(tx, blob)); + + // Miner tx with 2 signatures + tx.signatures[0].resize(1); + tx.signatures[1].resize(1); + ASSERT_FALSE(serialization::dump_binary(tx, blob)); + + // Two txin_gen, no signatures + tx.vin.push_back(txin_gen1); + tx.signatures.resize(0); + ASSERT_TRUE(serialization::dump_binary(tx, blob)); + ASSERT_EQ(9, blob.size()); // 5 bytes + 2 * 2 bytes vins + 0 bytes extra + 0 bytes signatures + ASSERT_TRUE(serialization::parse_binary(blob, tx1)); + ASSERT_EQ(tx, tx1); + ASSERT_EQ(linearize_vector2(tx.signatures), linearize_vector2(tx1.signatures)); + + // Two txin_gen, signatures vector contains only one empty element + tx.signatures.resize(1); + ASSERT_FALSE(serialization::dump_binary(tx, blob)); + + // Two txin_gen, signatures vector contains two empty elements + tx.signatures.resize(2); + ASSERT_TRUE(serialization::dump_binary(tx, blob)); + ASSERT_EQ(9, blob.size()); // 5 bytes + 2 * 2 bytes vins + 0 bytes extra + 0 bytes signatures + ASSERT_TRUE(serialization::parse_binary(blob, tx1)); + ASSERT_EQ(tx, tx1); + ASSERT_EQ(linearize_vector2(tx.signatures), linearize_vector2(tx1.signatures)); + + // Two txin_gen, signatures vector contains three empty elements + tx.signatures.resize(3); + ASSERT_FALSE(serialization::dump_binary(tx, blob)); + + // Two txin_gen, signatures vector contains two non empty elements + tx.signatures.resize(2); + tx.signatures[0].resize(1); + tx.signatures[1].resize(1); + ASSERT_FALSE(serialization::dump_binary(tx, blob)); + + // A few bytes instead of signature + tx.vin.clear(); + tx.vin.push_back(txin_gen1); + tx.signatures.clear(); + ASSERT_TRUE(serialization::dump_binary(tx, blob)); + blob.append(std::string(sizeof(crypto::signature) / 2, 'x')); + ASSERT_FALSE(serialization::parse_binary(blob, tx1)); + + // blob contains one signature + blob.append(std::string(sizeof(crypto::signature) / 2, 'y')); + ASSERT_FALSE(serialization::parse_binary(blob, tx1)); + + // Not enough signature vectors for all inputs + txin_to_key txin_to_key1; + txin_to_key1.key_offsets.resize(2); + tx.vin.clear(); + tx.vin.push_back(txin_to_key1); + tx.vin.push_back(txin_to_key1); + tx.signatures.resize(1); + tx.signatures[0].resize(2); + ASSERT_FALSE(serialization::dump_binary(tx, blob)); + + // Too much signatures for two inputs + tx.signatures.resize(3); + tx.signatures[0].resize(2); + tx.signatures[1].resize(2); + tx.signatures[2].resize(2); + ASSERT_FALSE(serialization::dump_binary(tx, blob)); + + // First signatures vector contains too little elements + tx.signatures.resize(2); + tx.signatures[0].resize(1); + tx.signatures[1].resize(2); + ASSERT_FALSE(serialization::dump_binary(tx, blob)); + + // First signatures vector contains too much elements + tx.signatures.resize(2); + tx.signatures[0].resize(3); + tx.signatures[1].resize(2); + ASSERT_FALSE(serialization::dump_binary(tx, blob)); + + // There are signatures for each input + tx.signatures.resize(2); + tx.signatures[0].resize(2); + tx.signatures[1].resize(2); + ASSERT_TRUE(serialization::dump_binary(tx, blob)); + ASSERT_TRUE(serialization::parse_binary(blob, tx1)); + ASSERT_EQ(tx, tx1); + ASSERT_EQ(linearize_vector2(tx.signatures), linearize_vector2(tx1.signatures)); + + // Blob doesn't contain enough data + blob.resize(blob.size() - sizeof(crypto::signature) / 2); + ASSERT_FALSE(serialization::parse_binary(blob, tx1)); + + // Blob contains too much data + blob.resize(blob.size() + sizeof(crypto::signature)); + ASSERT_FALSE(serialization::parse_binary(blob, tx1)); + + // Blob contains one excess signature + blob.resize(blob.size() + sizeof(crypto::signature) / 2); + ASSERT_FALSE(serialization::parse_binary(blob, tx1)); +} diff --git a/tests/unit_tests/test_format_utils.cpp b/tests/unit_tests/test_format_utils.cpp new file mode 100644 index 000000000..22f56628e --- /dev/null +++ b/tests/unit_tests/test_format_utils.cpp @@ -0,0 +1,97 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include "gtest/gtest.h" + +#include "common/util.h" +#include "cryptonote_core/cryptonote_format_utils.h" + +TEST(parse_and_validate_tx_extra, is_correct_parse_and_validate_tx_extra) +{ + cryptonote::transaction tx = AUTO_VAL_INIT(tx); + cryptonote::account_base acc; + acc.generate(); + std::vector<size_t> bss; + cryptonote::blobdata b = "dsdsdfsdfsf"; + bool r = cryptonote::construct_miner_tx(0, 10000000000000, acc.get_keys().m_account_address, tx, DEFAULT_FEE, bss, 1000, b, 1); + ASSERT_TRUE(r); + crypto::public_key tx_pub_key; + r = cryptonote::parse_and_validate_tx_extra(tx, tx_pub_key); + ASSERT_TRUE(r); +} +TEST(parse_and_validate_tx_extra, is_correct_extranonce_too_big) +{ + cryptonote::transaction tx = AUTO_VAL_INIT(tx); + cryptonote::account_base acc; + acc.generate(); + std::vector<size_t> bss; + cryptonote::blobdata b(260, 0); + bool r = cryptonote::construct_miner_tx(0, 10000000000000, acc.get_keys().m_account_address, tx, DEFAULT_FEE, bss, 1000, b, 1); + ASSERT_FALSE(r); +} +TEST(parse_and_validate_tx_extra, is_correct_wrong_extra_couner_too_big) +{ + cryptonote::transaction tx = AUTO_VAL_INIT(tx); + tx.extra.resize(20, 0); + tx.extra[0] = TX_EXTRA_NONCE; + tx.extra[1] = 255; + crypto::public_key tx_pub_key; + bool r = parse_and_validate_tx_extra(tx, tx_pub_key); + ASSERT_FALSE(r); +} +TEST(parse_and_validate_tx_extra, is_correct_wrong_extra_nonce_double_entry) +{ + cryptonote::transaction tx = AUTO_VAL_INIT(tx); + tx.extra.resize(20, 0); + cryptonote::blobdata v = "asasdasd"; + cryptonote::add_tx_extra_nonce(tx, v); + cryptonote::add_tx_extra_nonce(tx, v); + crypto::public_key tx_pub_key; + bool r = parse_and_validate_tx_extra(tx, tx_pub_key); + ASSERT_FALSE(r); +} + +TEST(validate_parse_amount_case, validate_parse_amount) +{ + uint64_t res = 0; + bool r = cryptonote::parse_amount(res, "0.0001"); + ASSERT_TRUE(r); + ASSERT_EQ(res, 10000); + + r = cryptonote::parse_amount(res, "100.0001"); + ASSERT_TRUE(r); + ASSERT_EQ(res, 10000010000); + + r = cryptonote::parse_amount(res, "000.0000"); + ASSERT_TRUE(r); + ASSERT_EQ(res, 0); + + r = cryptonote::parse_amount(res, "0"); + ASSERT_TRUE(r); + ASSERT_EQ(res, 0); + + + r = cryptonote::parse_amount(res, " 100.0001 "); + ASSERT_TRUE(r); + ASSERT_EQ(res, 10000010000); + + r = cryptonote::parse_amount(res, " 100.0000 "); + ASSERT_TRUE(r); + ASSERT_EQ(res, 10000000000); + + r = cryptonote::parse_amount(res, " 100. 0000 "); + ASSERT_FALSE(r); + + r = cryptonote::parse_amount(res, "100. 0000"); + ASSERT_FALSE(r); + + r = cryptonote::parse_amount(res, "100 . 0000"); + ASSERT_FALSE(r); + + r = cryptonote::parse_amount(res, "100.00 00"); + ASSERT_FALSE(r); + + r = cryptonote::parse_amount(res, "1 00.00 00"); + ASSERT_FALSE(r); +} diff --git a/tests/unit_tests/test_peerlist.cpp b/tests/unit_tests/test_peerlist.cpp new file mode 100644 index 000000000..bd58ca753 --- /dev/null +++ b/tests/unit_tests/test_peerlist.cpp @@ -0,0 +1,58 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include "gtest/gtest.h" + +#include "common/util.h" +#include "p2p/net_peerlist.h" +#include "net/net_utils_base.h" + +TEST(peer_list, peer_list_general) +{ + nodetool::peerlist_manager plm; + plm.init(false); +#define ADD_GRAY_NODE(ip_, port_, id_, last_seen_) { nodetool::peerlist_entry ple; ple.last_seen=last_seen_;ple.adr.ip = ip_; ple.adr.port = port_; ple.id = id_;plm.append_with_peer_gray(ple);} +#define ADD_WHITE_NODE(ip_, port_, id_, last_seen_) { nodetool::peerlist_entry ple;ple.last_seen=last_seen_; ple.adr.ip = ip_; ple.adr.port = port_; ple.id = id_;plm.append_with_peer_white(ple);} + +#define PRINT_HEAD(step) {std::list<nodetool::peerlist_entry> bs_head; bool r = plm.get_peerlist_head(bs_head, 100);std::cout << "step " << step << ": " << bs_head.size() << std::endl;} + + ADD_GRAY_NODE(MAKE_IP(123,43,12,1), 8080, 121241, 34345); + ADD_GRAY_NODE(MAKE_IP(123,43,12,2), 8080, 121241, 34345); + ADD_GRAY_NODE(MAKE_IP(123,43,12,3), 8080, 121241, 34345); + ADD_GRAY_NODE(MAKE_IP(123,43,12,4), 8080, 121241, 34345); + ADD_GRAY_NODE(MAKE_IP(123,43,12,5), 8080, 121241, 34345); + + ADD_WHITE_NODE(MAKE_IP(123,43,12,1), 8080, 121241, 34345); + ADD_WHITE_NODE(MAKE_IP(123,43,12,2), 8080, 121241, 34345); + ADD_WHITE_NODE(MAKE_IP(123,43,12,3), 8080, 121241, 34345); + ADD_WHITE_NODE(MAKE_IP(123,43,12,4), 8080, 121241, 34345); + + size_t gray_list_size = plm.get_gray_peers_count(); + ASSERT_EQ(gray_list_size, 1); + + std::list<nodetool::peerlist_entry> bs_head; + bool r = plm.get_peerlist_head(bs_head, 100); + std::cout << bs_head.size() << std::endl; + ASSERT_TRUE(r); + + ASSERT_EQ(bs_head.size(), 4); + + + ADD_GRAY_NODE(MAKE_IP(123,43,12,5), 8080, 121241, 34345); + ASSERT_EQ(plm.get_gray_peers_count(), 1); + ASSERT_EQ(plm.get_white_peers_count(), 4); +} + + +TEST(peer_list, merge_peer_lists) +{ + //([^ \t]*)\t([^ \t]*):([^ \t]*) \tlast_seen: d(\d+)\.h(\d+)\.m(\d+)\.s(\d+)\n + //ADD_NODE_TO_PL("\2", \3, 0x\1, (1353346618 -(\4*60*60*24+\5*60*60+\6*60+\7 )));\n + nodetool::peerlist_manager plm; + plm.init(false); + std::list<nodetool::peerlist_entry> outer_bs; +#define ADD_NODE_TO_PL(ip_, port_, id_, timestamp_) { nodetool::peerlist_entry ple; epee::string_tools::get_ip_int32_from_string(ple.adr.ip, ip_); ple.last_seen = timestamp_; ple.adr.port = port_; ple.id = id_;outer_bs.push_back(ple);} + + +} diff --git a/tests/unit_tests/test_protocol_pack.cpp b/tests/unit_tests/test_protocol_pack.cpp new file mode 100644 index 000000000..18c7bc78b --- /dev/null +++ b/tests/unit_tests/test_protocol_pack.cpp @@ -0,0 +1,29 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#include "gtest/gtest.h" + +#include "include_base_utils.h" +#include "cryptonote_protocol/cryptonote_protocol_defs.h" +#include "storages/portable_storage_template_helper.h" + +TEST(protocol_pack, protocol_pack_command) +{ + std::string buff; + cryptonote::NOTIFY_RESPONSE_CHAIN_ENTRY::request r; + r.start_height = 1; + r.total_height = 3; + for(int i = 1; i < 10000; i += i*10) + { + r.m_block_ids.resize(i, boost::value_initialized<crypto::hash>()); + bool res = epee::serialization::store_t_to_binary(r, buff); + ASSERT_TRUE(res); + + cryptonote::NOTIFY_RESPONSE_CHAIN_ENTRY::request r2; + res = epee::serialization::load_t_from_binary(r2, buff); + ASSERT_TRUE(r.m_block_ids.size() == i); + ASSERT_TRUE(r.start_height == 1); + ASSERT_TRUE(r.total_height == 3); + } +} diff --git a/tests/unit_tests/unit_tests_utils.h b/tests/unit_tests/unit_tests_utils.h new file mode 100644 index 000000000..9eebb7ed9 --- /dev/null +++ b/tests/unit_tests/unit_tests_utils.h @@ -0,0 +1,38 @@ +// Copyright (c) 2012-2013 The Cryptonote developers +// Distributed under the MIT/X11 software license, see the accompanying +// file COPYING or http://www.opensource.org/licenses/mit-license.php. + +#pragma once + +#include <atomic> + +namespace unit_test +{ + class call_counter + { + public: + call_counter() + : m_counter(0) + { + } + + void inc() volatile + { + // memory_order_relaxed is enough for call counter + m_counter.fetch_add(1, std::memory_order_relaxed); + } + + size_t get() volatile const + { + return m_counter.load(std::memory_order_relaxed); + } + + void reset() volatile + { + m_counter.store(0, std::memory_order_relaxed); + } + + private: + std::atomic<size_t> m_counter; + }; +} |